Merge pull request #295 from CosmWasm/extensible-cosmos-msg

Extensible Native variant for CosmosMsg

Author: ethanfrey

CHANGELOG.md

@@ -40,9 +40,6 @@
 - `Env.message.sent_funds` is a `Vec<Coin>` not `Option<Vec<Coin>>`. We will
   normalize the go response in `go-cosmwasm` before sending it to the contract.
 - `Env.block.{height,time}` are now `u64` rather than `i64`.
-- Reorganize `CosmosMsg` enum types. They are now split by modules:
-  `CosmosMsg::Bank(BankMsg)`, `CosmosMsg::Native { msg }`,
-  `CosmosMsg::Wasm(WasmMsg)`
 
 **cosmwasm-schema**
 
@@ -93,6 +90,13 @@
 - Rename `Error` to `StdError`.
 - `ExternalStorage.get` now returns an empty vector if a storage entry exists
   but has an empty value. Before, this was normalized to `None`.
+- Reorganize `CosmosMsg` enum types. They are now split by modules:
+  `CosmosMsg::Bank(BankMsg)`, `CosmosMsg::Custom(T)`,
+  `CosmosMsg::Wasm(WasmMsg)`
+- CosmosMsg is now generic over the content of `Custom` variant. This allows
+  blockchains to support custom native calls in their Cosmos-SDK apps and
+  developers to make use of them in CosmWasm apps without forking the
+  `cosmwasm-vm` and `go-cosmwasm` runtime.
 
 **cosmwasm-vm**
 

MIGRATING.md

@@ -109,6 +109,17 @@ Integration Tests:
     `match err { ContractResult::Err(msg) => assert_eq!(msg, "Unauthorized"), ... }`
   - After: `match err { Err(ApiError::Unauthorized{ ..}) => {}, ... }`
 - Remove all imports / use of `ContractResult`
+- You must specify `CosmosMsg::Native` type when calling
+  `cosmwasm_vm::testing::{handle, init}`. You will want to
+  `use cosmwasm_vm::testing::{HandleResult, InitResult}` or
+  `use cosmwasm_std::{HandleResponse, InitResponse}`. If you don't use custom
+  native types, simply update calls as follows:
+  - `let res = init(...)` => `let res: InitResult = init(...)`
+  - `let res = init(...).unwrap()` =>
+    `let res: InitResponse = init(...).unwrap()`
+  - `let res = handle(...)` => `let res: HandleResult = handle(...)`
+  - `let res = handle(...).unwrap()` =>
+    `let res: HandleResponse = handle(...).unwrap()`
 
 ### Update schema code
 

contracts/hackatom/src/contract.rs

@@ -4,8 +4,8 @@ use snafu::OptionExt;
 
 use cosmwasm_std::{
     contract_err, from_slice, log, to_binary, to_vec, unauthorized, Api, BankMsg, Binary,
-    CanonicalAddr, CosmosMsg, Env, Extern, HandleResponse, HumanAddr, InitResponse, NotFound,
-    Querier, QueryResponse, StdResult, Storage,
+    CanonicalAddr, Env, Extern, HandleResponse, HumanAddr, InitResponse, NotFound, Querier,
+    QueryResponse, StdResult, Storage,
 };
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
@@ -108,11 +108,12 @@ fn do_release<S: Storage, A: Api, Q: Querier>(
                 log("action", "release"),
                 log("destination", to_addr.as_str()),
             ],
-            messages: vec![CosmosMsg::Bank(BankMsg::Send {
+            messages: vec![BankMsg::Send {
                 from_address: from_addr,
                 to_address: to_addr,
                 amount: balance.amount,
-            })],
+            }
+            .into()],
             data: None,
         };
         Ok(res)
@@ -343,11 +344,12 @@ mod tests {
         let msg = handle_res.messages.get(0).expect("no message");
         assert_eq!(
             msg,
-            &CosmosMsg::Bank(BankMsg::Send {
+            &BankMsg::Send {
                 from_address: HumanAddr("cosmos2contract".to_string()),
                 to_address: beneficiary,
                 amount: coins(1015, "earth"),
-            }),
+            }
+            .into(),
         );
         assert_eq!(
             handle_res.log,

contracts/hackatom/tests/integration.rs

@@ -30,12 +30,13 @@
 
 use cosmwasm_std::testing::mock_env;
 use cosmwasm_std::{
-    coins, from_binary, log, AllBalanceResponse, Api, ApiError, BankMsg, CosmosMsg, HumanAddr,
-    ReadonlyStorage,
+    coins, from_binary, log, AllBalanceResponse, Api, ApiError, BankMsg, HandleResponse, HumanAddr,
+    InitResponse, NoMsg, ReadonlyStorage,
 };
 use cosmwasm_vm::from_slice;
 use cosmwasm_vm::testing::{
-    handle, init, mock_instance, mock_instance_with_balances, query, test_io,
+    handle, init, mock_instance, mock_instance_with_balances, query, test_io, HandleResult,
+    InitResult,
 };
 
 use hackatom::contract::{HandleMsg, InitMsg, QueryMsg, State, CONFIG_KEY};
@@ -59,7 +60,7 @@ fn proper_initialization() {
         beneficiary,
     };
     let env = mock_env(&deps.api, "creator", &coins(1000, "earth"));
-    let res = init(&mut deps, env, msg).unwrap();
+    let res: InitResponse = init(&mut deps, env, msg).unwrap();
     assert_eq!(0, res.messages.len());
 
     // it worked, let's check the state
@@ -87,7 +88,7 @@ fn init_and_query() {
         beneficiary,
     };
     let env = mock_env(&deps.api, creator.as_str(), &coins(1000, "earth"));
-    let res = init(&mut deps, env, msg).unwrap();
+    let res: InitResponse = init(&mut deps, env, msg).unwrap();
     assert_eq!(0, res.messages.len());
 
     // now let's query
@@ -128,7 +129,7 @@ fn fails_on_bad_init() {
     let mut deps = mock_instance(WASM, &[]);
     let env = mock_env(&deps.api, "creator", &coins(1000, "earth"));
     // bad init returns parse error (pass wrong type - this connection is not enforced)
-    let res = init(&mut deps, env, HandleMsg::Release {});
+    let res: InitResult = init(&mut deps, env, HandleMsg::Release {});
     match res.unwrap_err() {
         ApiError::ParseErr { .. } => {}
         _ => panic!("Expected parse error"),
@@ -148,21 +149,22 @@ fn proper_handle() {
         beneficiary: beneficiary.clone(),
     };
     let init_env = mock_env(&deps.api, "creator", &coins(1000, "earth"));
-    let init_res = init(&mut deps, init_env, init_msg).unwrap();
+    let init_res: InitResponse = init(&mut deps, init_env, init_msg).unwrap();
     assert_eq!(0, init_res.messages.len());
 
     // beneficiary can release it
     let handle_env = mock_env(&deps.api, verifier.as_str(), &coins(15, "earth"));
-    let handle_res = handle(&mut deps, handle_env, HandleMsg::Release {}).unwrap();
+    let handle_res: HandleResponse = handle(&mut deps, handle_env, HandleMsg::Release {}).unwrap();
     assert_eq!(1, handle_res.messages.len());
     let msg = handle_res.messages.get(0).expect("no message");
     assert_eq!(
         msg,
-        &CosmosMsg::Bank(BankMsg::Send {
+        &BankMsg::Send {
             from_address: HumanAddr("cosmos2contract".to_string()),
             to_address: beneficiary,
             amount: coins(1015, "earth"),
-        }),
+        }
+        .into(),
     );
     assert_eq!(
         handle_res.log,
@@ -184,12 +186,12 @@ fn failed_handle() {
         beneficiary: beneficiary.clone(),
     };
     let init_env = mock_env(&deps.api, creator.as_str(), &coins(1000, "earth"));
-    let init_res = init(&mut deps, init_env, init_msg).unwrap();
+    let init_res: InitResponse = init(&mut deps, init_env, init_msg).unwrap();
     assert_eq!(0, init_res.messages.len());
 
     // beneficiary cannot release it
     let handle_env = mock_env(&deps.api, beneficiary.as_str(), &[]);
-    let handle_res = handle(&mut deps, handle_env, HandleMsg::Release {});
+    let handle_res: HandleResult = handle(&mut deps, handle_env, HandleMsg::Release {});
     match handle_res.unwrap_err() {
         ApiError::Unauthorized {} => {}
         _ => panic!("Expect unauthorized error"),
@@ -247,13 +249,13 @@ mod singlepass_tests {
 
         let (init_msg, creator) = make_init_msg();
         let init_env = mock_env(&deps.api, creator.as_str(), &[]);
-        let init_res = init(&mut deps, init_env, init_msg).unwrap();
+        let init_res: InitResponse = init(&mut deps, init_env, init_msg).unwrap();
         assert_eq!(0, init_res.messages.len());
 
         let handle_env = mock_env(&deps.api, creator.as_str(), &[]);
         // panic inside contract should not panic out here
         // Note: we need to use the production-call, not the testing call (which unwraps any vm error)
-        let handle_res = call_handle(
+        let handle_res = call_handle::<_, _, _, NoMsg>(
             &mut deps,
             &handle_env,
             &to_vec(&HandleMsg::Panic {}).unwrap(),
@@ -267,12 +269,12 @@ mod singlepass_tests {
 
         let (init_msg, creator) = make_init_msg();
         let init_env = mock_env(&deps.api, creator.as_str(), &[]);
-        let init_res = init(&mut deps, init_env, init_msg).unwrap();
+        let init_res: InitResponse = init(&mut deps, init_env, init_msg).unwrap();
         assert_eq!(0, init_res.messages.len());
 
         let handle_env = mock_env(&deps.api, creator.as_str(), &[]);
         // Note: we need to use the production-call, not the testing call (which unwraps any vm error)
-        let handle_res = call_handle(
+        let handle_res = call_handle::<_, _, _, NoMsg>(
             &mut deps,
             &handle_env,
             &to_vec(&HandleMsg::CpuLoop {}).unwrap(),
@@ -287,12 +289,12 @@ mod singlepass_tests {
 
         let (init_msg, creator) = make_init_msg();
         let init_env = mock_env(&deps.api, creator.as_str(), &[]);
-        let init_res = init(&mut deps, init_env, init_msg).unwrap();
+        let init_res: InitResponse = init(&mut deps, init_env, init_msg).unwrap();
         assert_eq!(0, init_res.messages.len());
 
         let handle_env = mock_env(&deps.api, creator.as_str(), &[]);
         // Note: we need to use the production-call, not the testing call (which unwraps any vm error)
-        let handle_res = call_handle(
+        let handle_res = call_handle::<_, _, _, NoMsg>(
             &mut deps,
             &handle_env,
             &to_vec(&HandleMsg::StorageLoop {}).unwrap(),
@@ -307,12 +309,12 @@ mod singlepass_tests {
 
         let (init_msg, creator) = make_init_msg();
         let init_env = mock_env(&deps.api, creator.as_str(), &[]);
-        let init_res = init(&mut deps, init_env, init_msg).unwrap();
+        let init_res: InitResponse = init(&mut deps, init_env, init_msg).unwrap();
         assert_eq!(0, init_res.messages.len());
 
         let handle_env = mock_env(&deps.api, creator.as_str(), &[]);
         // Note: we need to use the production-call, not the testing call (which unwraps any vm error)
-        let handle_res = call_handle(
+        let handle_res = call_handle::<_, _, _, NoMsg>(
             &mut deps,
             &handle_env,
             &to_vec(&HandleMsg::MemoryLoop {}).unwrap(),
@@ -330,13 +332,13 @@ mod singlepass_tests {
 
         let (init_msg, creator) = make_init_msg();
         let init_env = mock_env(&deps.api, creator.as_str(), &[]);
-        let init_res = init(&mut deps, init_env, init_msg).unwrap();
+        let init_res: InitResponse = init(&mut deps, init_env, init_msg).unwrap();
         assert_eq!(0, init_res.messages.len());
 
         let handle_env = mock_env(&deps.api, creator.as_str(), &[]);
         let gas_before = deps.get_gas();
         // Note: we need to use the production-call, not the testing call (which unwraps any vm error)
-        let handle_res = call_handle(
+        let handle_res = call_handle::<_, _, _, NoMsg>(
             &mut deps,
             &handle_env,
             &to_vec(&HandleMsg::AllocateLargeMemory {}).unwrap(),
@@ -349,8 +351,8 @@ mod singlepass_tests {
         // Gas consumtion is relatively small
         // Note: the exact gas usage depends on the Rust version used to compile WASM,
         // which we only fix when using cosmwasm-opt, not integration tests.
-        assert!(gas_used > 28000);
-        assert!(gas_used < 32000);
+        assert!(gas_used > 26000, "{}", gas_used);
+        assert!(gas_used < 30000, "{}", gas_used);
 
         // Used between 100 and 102 MiB of memory
         assert!(deps.get_memory_size() > 100 * 1024 * 1024);

contracts/queue/tests/integration.rs

@@ -29,7 +29,7 @@
 //!      }
 
 use cosmwasm_std::testing::{mock_env, MockApi, MockQuerier, MockStorage};
-use cosmwasm_std::{from_binary, from_slice, Env, HumanAddr};
+use cosmwasm_std::{from_binary, from_slice, Env, HandleResponse, HumanAddr, InitResponse};
 use cosmwasm_vm::testing::{handle, init, mock_instance, query};
 use cosmwasm_vm::Instance;
 
@@ -43,7 +43,7 @@ fn create_contract() -> (Instance<MockStorage, MockApi, MockQuerier>, Env) {
     let mut deps = mock_instance(WASM, &[]);
     let creator = HumanAddr(String::from("creator"));
     let env = mock_env(&deps.api, creator.as_str(), &[]);
-    let res = init(&mut deps, env.clone(), InitMsg {}).unwrap();
+    let res: InitResponse = init(&mut deps, env.clone(), InitMsg {}).unwrap();
     assert_eq!(0, res.messages.len());
     (deps, env)
 }
@@ -70,27 +70,33 @@ fn init_and_query() {
 #[test]
 fn push_and_query() {
     let (mut deps, env) = create_contract();
-    handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 25 }).unwrap();
+    let _: HandleResponse =
+        handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 25 }).unwrap();
     assert_eq!(get_count(&mut deps), 1);
     assert_eq!(get_sum(&mut deps), 25);
 }
 
 #[test]
 fn multiple_push() {
     let (mut deps, env) = create_contract();
-    handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 25 }).unwrap();
-    handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 35 }).unwrap();
-    handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 45 }).unwrap();
+    let _: HandleResponse =
+        handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 25 }).unwrap();
+    let _: HandleResponse =
+        handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 35 }).unwrap();
+    let _: HandleResponse =
+        handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 45 }).unwrap();
     assert_eq!(get_count(&mut deps), 3);
     assert_eq!(get_sum(&mut deps), 105);
 }
 
 #[test]
 fn push_and_pop() {
     let (mut deps, env) = create_contract();
-    handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 25 }).unwrap();
-    handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 17 }).unwrap();
-    let res = handle(&mut deps, env.clone(), HandleMsg::Dequeue {}).unwrap();
+    let _: HandleResponse =
+        handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 25 }).unwrap();
+    let _: HandleResponse =
+        handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 17 }).unwrap();
+    let res: HandleResponse = handle(&mut deps, env.clone(), HandleMsg::Dequeue {}).unwrap();
     // ensure we popped properly
     assert!(res.data.is_some());
     let data = res.data.unwrap();
@@ -104,10 +110,14 @@ fn push_and_pop() {
 #[test]
 fn push_and_reduce() {
     let (mut deps, env) = create_contract();
-    handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 40 }).unwrap();
-    handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 15 }).unwrap();
-    handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 85 }).unwrap();
-    handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: -10 }).unwrap();
+    let _: HandleResponse =
+        handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 40 }).unwrap();
+    let _: HandleResponse =
+        handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 15 }).unwrap();
+    let _: HandleResponse =
+        handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: 85 }).unwrap();
+    let _: HandleResponse =
+        handle(&mut deps, env.clone(), HandleMsg::Enqueue { value: -10 }).unwrap();
     assert_eq!(get_count(&mut deps), 4);
     assert_eq!(get_sum(&mut deps), 130);
     let data = query(&mut deps, QueryMsg::Reducer {}).unwrap();

contracts/reflect/examples/schema.rs

@@ -2,8 +2,9 @@ use std::env::current_dir;
 use std::fs::create_dir_all;
 
 use cosmwasm_schema::{export_schema, remove_schemas, schema_for};
+use cosmwasm_std::HandleResponse;
 
-use reflect::msg::{HandleMsg, InitMsg, OwnerResponse, QueryMsg};
+use reflect::msg::{CustomMsg, HandleMsg, InitMsg, OwnerResponse, QueryMsg};
 use reflect::state::State;
 
 fn main() {
@@ -12,8 +13,10 @@ fn main() {
     create_dir_all(&out_dir).unwrap();
     remove_schemas(&out_dir).unwrap();
 
+    export_schema(&schema_for!(CustomMsg), &out_dir);
     export_schema(&schema_for!(InitMsg), &out_dir);
     export_schema(&schema_for!(HandleMsg), &out_dir);
+    export_schema(&schema_for!(HandleResponse<CustomMsg>), &out_dir);
     export_schema(&schema_for!(QueryMsg), &out_dir);
     export_schema(&schema_for!(State), &out_dir);
     export_schema(&schema_for!(OwnerResponse), &out_dir);

contracts/reflect/schema/custom_msg.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "CustomMsg",
+  "description": "CustomMsg is an override of CosmosMsg::Custom to show this works and can be extended in the contract",
+  "anyOf": [
+    {
+      "type": "object",
+      "required": [
+        "debug"
+      ],
+      "properties": {
+        "debug": {
+          "type": "string"
+        }
+      }
+    },
+    {
+      "type": "object",
+      "required": [
+        "raw"
+      ],
+      "properties": {
+        "raw": {
+          "$ref": "#/definitions/Binary"
+        }
+      }
+    }
+  ],
+  "definitions": {
+    "Binary": {
+      "description": "Binary is a wrapper around Vec<u8> to add base64 de/serialization with serde. It also adds some helper methods to help encode inline.\n\nThis is only needed as serde-json-{core,wasm} has a horrible encoding for Vec<u8>",
+      "type": "string"
+    }
+  }
+}