Add ibc stargate to vm

.circleci/config.yml

@@ -173,17 +173,17 @@ jobs:
           working_directory: ~/project/packages/vm
           command: cargo build --locked
       - run:
-          name: Build with iterator
+          name: Build with all features
           working_directory: ~/project/packages/vm
-          command: cargo build --locked --features iterator
+          command: cargo build --locked --features iterator,staking,stargate
       - run:
           name: Test
           working_directory: ~/project/packages/vm
           command: cargo test --locked
       - run:
-          name: Test with iterator
+          name: Test with all features
           working_directory: ~/project/packages/vm
-          command: cargo test --locked --features iterator
+          command: cargo test --locked --features iterator,staking,stargate
       - save_cache:
           paths:
             - /usr/local/cargo/registry
@@ -208,17 +208,17 @@ jobs:
           working_directory: ~/project/packages/vm
           command: cargo build --locked --features cranelift
       - run:
-          name: Build with iterator
+          name: Build with all features
           working_directory: ~/project/packages/vm
-          command: cargo build --locked --features cranelift,iterator
+          command: cargo build --locked --features cranelift,iterator,staking,stargate
       - run:
           name: Test
           working_directory: ~/project/packages/vm
           command: cargo test --locked --features cranelift
       - run:
-          name: Test with iterator
+          name: Test with all features
           working_directory: ~/project/packages/vm
-          command: cargo test --locked --features cranelift,iterator
+          command: cargo test --locked --features cranelift,iterator,staking,stargate
       - save_cache:
           paths:
             - /usr/local/cargo/registry

packages/vm/Cargo.toml

@@ -24,6 +24,8 @@ backtraces = []
 # we keep this optional, to allow possible future integration (or different Cosmos Backends)
 iterator = ["cosmwasm-std/iterator"]
 staking = ["cosmwasm-std/staking"]
+# this enables all stargate-related functionality, including the ibc entry points
+stargate = ["cosmwasm-std/stargate"]
 # Use cranelift backend instead of singlepass. This is required for development on Windows.
 cranelift = ["wasmer/cranelift"]
 

packages/vm/src/calls.rs

@@ -168,7 +168,7 @@ where
 
 /// Calls a function with the given arguments.
 /// The exported function must return exactly one result (an offset to the result Region).
-fn call_raw<A, S, Q>(
+pub(crate) fn call_raw<A, S, Q>(
     instance: &mut Instance<A, S, Q>,
     name: &str,
     args: &[&[u8]],

packages/vm/src/ibc_calls.rs

@@ -0,0 +1,233 @@
+#![cfg(feature = "stargate")]
+
+use cosmwasm_std::{
+    ContractResult, Env, IbcAcknowledgement, IbcBasicResponse, IbcChannel, IbcPacket,
+    IbcReceiveResponse,
+};
+use schemars::JsonSchema;
+use serde::de::DeserializeOwned;
+use std::fmt;
+
+use crate::backend::{Api, Querier, Storage};
+use crate::calls::call_raw;
+use crate::errors::VmResult;
+use crate::instance::Instance;
+use crate::serde::{from_slice, to_vec};
+
+const MAX_LENGTH_IBC: usize = 100_000;
+
+pub fn call_ibc_channel_open<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
+    env: &Env,
+    channel: &IbcChannel,
+) -> VmResult<ContractResult<()>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
+    let env = to_vec(env)?;
+    let channel = to_vec(channel)?;
+    let data = call_ibc_channel_open_raw(instance, &env, &channel)?;
+    let result: ContractResult<()> = from_slice(&data)?;
+    Ok(result)
+}
+
+pub fn call_ibc_channel_connect<A, S, Q, U>(
+    instance: &mut Instance<A, S, Q>,
+    env: &Env,
+    channel: &IbcChannel,
+) -> VmResult<ContractResult<IbcBasicResponse<U>>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+    U: DeserializeOwned + Clone + fmt::Debug + JsonSchema + PartialEq,
+{
+    let env = to_vec(env)?;
+    let channel = to_vec(channel)?;
+    let data = call_ibc_channel_connect_raw(instance, &env, &channel)?;
+    let result = from_slice(&data)?;
+    Ok(result)
+}
+
+pub fn call_ibc_channel_close<A, S, Q, U>(
+    instance: &mut Instance<A, S, Q>,
+    env: &Env,
+    channel: &IbcChannel,
+) -> VmResult<ContractResult<IbcBasicResponse<U>>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+    U: DeserializeOwned + Clone + fmt::Debug + JsonSchema + PartialEq,
+{
+    let env = to_vec(env)?;
+    let channel = to_vec(channel)?;
+    let data = call_ibc_channel_close_raw(instance, &env, &channel)?;
+    let result = from_slice(&data)?;
+    Ok(result)
+}
+
+pub fn call_ibc_packet_receive<A, S, Q, U>(
+    instance: &mut Instance<A, S, Q>,
+    env: &Env,
+    packet: &IbcPacket,
+) -> VmResult<ContractResult<IbcReceiveResponse<U>>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+    U: DeserializeOwned + Clone + fmt::Debug + JsonSchema + PartialEq,
+{
+    let env = to_vec(env)?;
+    let packet = to_vec(packet)?;
+    let data = call_ibc_packet_receive_raw(instance, &env, &packet)?;
+    let result = from_slice(&data)?;
+    Ok(result)
+}
+
+pub fn call_ibc_packet_ack<A, S, Q, U>(
+    instance: &mut Instance<A, S, Q>,
+    env: &Env,
+    ack: &IbcAcknowledgement,
+) -> VmResult<ContractResult<IbcBasicResponse<U>>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+    U: DeserializeOwned + Clone + fmt::Debug + JsonSchema + PartialEq,
+{
+    let env = to_vec(env)?;
+    let ack = to_vec(ack)?;
+    let data = call_ibc_packet_ack_raw(instance, &env, &ack)?;
+    let result = from_slice(&data)?;
+    Ok(result)
+}
+
+pub fn call_ibc_packet_timeout<A, S, Q, U>(
+    instance: &mut Instance<A, S, Q>,
+    env: &Env,
+    packet: &IbcPacket,
+) -> VmResult<ContractResult<IbcBasicResponse<U>>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+    U: DeserializeOwned + Clone + fmt::Debug + JsonSchema + PartialEq,
+{
+    let env = to_vec(env)?;
+    let packet = to_vec(packet)?;
+    let data = call_ibc_packet_timeout_raw(instance, &env, &packet)?;
+    let result = from_slice(&data)?;
+    Ok(result)
+}
+
+pub fn call_ibc_channel_open_raw<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
+    env: &[u8],
+    channel: &[u8],
+) -> VmResult<Vec<u8>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
+    instance.set_storage_readonly(false);
+    call_raw(
+        instance,
+        "ibc_channel_open",
+        &[env, channel],
+        MAX_LENGTH_IBC,
+    )
+}
+
+pub fn call_ibc_channel_connect_raw<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
+    env: &[u8],
+    channel: &[u8],
+) -> VmResult<Vec<u8>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
+    instance.set_storage_readonly(false);
+    call_raw(
+        instance,
+        "ibc_channel_connect",
+        &[env, channel],
+        MAX_LENGTH_IBC,
+    )
+}
+
+pub fn call_ibc_channel_close_raw<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
+    env: &[u8],
+    channel: &[u8],
+) -> VmResult<Vec<u8>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
+    instance.set_storage_readonly(false);
+    call_raw(
+        instance,
+        "ibc_channel_close",
+        &[env, channel],
+        MAX_LENGTH_IBC,
+    )
+}
+
+pub fn call_ibc_packet_receive_raw<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
+    env: &[u8],
+    packet: &[u8],
+) -> VmResult<Vec<u8>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
+    instance.set_storage_readonly(false);
+    call_raw(
+        instance,
+        "ibc_packet_receive",
+        &[env, packet],
+        MAX_LENGTH_IBC,
+    )
+}
+
+pub fn call_ibc_packet_ack_raw<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
+    env: &[u8],
+    ack: &[u8],
+) -> VmResult<Vec<u8>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
+    instance.set_storage_readonly(false);
+    call_raw(instance, "ibc_packet_ack", &[env, ack], MAX_LENGTH_IBC)
+}
+
+pub fn call_ibc_packet_timeout_raw<A, S, Q>(
+    instance: &mut Instance<A, S, Q>,
+    env: &[u8],
+    packet: &[u8],
+) -> VmResult<Vec<u8>>
+where
+    A: Api + 'static,
+    S: Storage + 'static,
+    Q: Querier + 'static,
+{
+    instance.set_storage_readonly(false);
+    call_raw(
+        instance,
+        "ibc_packet_timeout",
+        &[env, packet],
+        MAX_LENGTH_IBC,
+    )
+}

packages/vm/src/lib.rs

@@ -9,6 +9,8 @@ mod conversion;
 mod environment;
 mod errors;
 mod features;
+#[cfg(feature = "stargate")]
+mod ibc_calls;
 mod imports;
 mod instance;
 mod limited;
@@ -32,6 +34,13 @@ pub use crate::errors::{
     VmError, VmResult,
 };
 pub use crate::features::features_from_csv;
+#[cfg(feature = "stargate")]
+pub use crate::ibc_calls::{
+    call_ibc_channel_close, call_ibc_channel_close_raw, call_ibc_channel_connect,
+    call_ibc_channel_connect_raw, call_ibc_channel_open, call_ibc_channel_open_raw,
+    call_ibc_packet_ack, call_ibc_packet_ack_raw, call_ibc_packet_receive,
+    call_ibc_packet_receive_raw, call_ibc_packet_timeout, call_ibc_packet_timeout_raw,
+};
 pub use crate::instance::{GasReport, Instance, InstanceOptions};
 pub use crate::serde::{from_slice, to_vec};
 pub use crate::size::Size;