Avoid the all_balances query in hackathon

Author: webmaster128

contracts/hackatom/schema/hackatom.json

@@ -25,14 +25,22 @@
     "title": "ExecuteMsg",
     "oneOf": [
       {
-        "description": "Releasing all funds in the contract to the beneficiary. This is the only \"proper\" action of this demo contract.",
+        "description": "Releasing all funds of the given denom in the contract to the beneficiary. This is the only \"proper\" action of this demo contract.",
         "type": "object",
         "required": [
           "release"
         ],
         "properties": {
           "release": {
             "type": "object",
+            "required": [
+              "denom"
+            ],
+            "properties": {
+              "denom": {
+                "type": "string"
+              }
+            },
             "additionalProperties": false
           }
         },
@@ -166,28 +174,6 @@
         },
         "additionalProperties": false
       },
-      {
-        "description": "This returns cosmwasm_std::AllBalanceResponse to demo use of the querier",
-        "type": "object",
-        "required": [
-          "other_balance"
-        ],
-        "properties": {
-          "other_balance": {
-            "type": "object",
-            "required": [
-              "address"
-            ],
-            "properties": {
-              "address": {
-                "type": "string"
-              }
-            },
-            "additionalProperties": false
-          }
-        },
-        "additionalProperties": false
-      },
       {
         "description": "Recurse will execute a query into itself up to depth-times and return Each step of the recursion may perform some extra work to test gas metering (`work` rounds of sha256 on contract). Now that we have Env, we can auto-calculate the address to recurse into",
         "type": "object",
@@ -323,46 +309,6 @@
       },
       "additionalProperties": false
     },
-    "other_balance": {
-      "$schema": "http://json-schema.org/draft-07/schema#",
-      "title": "AllBalanceResponse",
-      "type": "object",
-      "required": [
-        "amount"
-      ],
-      "properties": {
-        "amount": {
-          "description": "Returns all non-zero coins held by this account.",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/Coin"
-          }
-        }
-      },
-      "additionalProperties": false,
-      "definitions": {
-        "Coin": {
-          "type": "object",
-          "required": [
-            "amount",
-            "denom"
-          ],
-          "properties": {
-            "amount": {
-              "$ref": "#/definitions/Uint128"
-            },
-            "denom": {
-              "type": "string"
-            }
-          },
-          "additionalProperties": false
-        },
-        "Uint128": {
-          "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
-          "type": "string"
-        }
-      }
-    },
     "recurse": {
       "$schema": "http://json-schema.org/draft-07/schema#",
       "title": "RecurseResponse",

contracts/hackatom/schema/raw/execute.json

@@ -3,14 +3,22 @@
   "title": "ExecuteMsg",
   "oneOf": [
     {
-      "description": "Releasing all funds in the contract to the beneficiary. This is the only \"proper\" action of this demo contract.",
+      "description": "Releasing all funds of the given denom in the contract to the beneficiary. This is the only \"proper\" action of this demo contract.",
       "type": "object",
       "required": [
         "release"
       ],
       "properties": {
         "release": {
           "type": "object",
+          "required": [
+            "denom"
+          ],
+          "properties": {
+            "denom": {
+              "type": "string"
+            }
+          },
           "additionalProperties": false
         }
       },

contracts/hackatom/schema/raw/query.json

@@ -16,28 +16,6 @@
       },
       "additionalProperties": false
     },
-    {
-      "description": "This returns cosmwasm_std::AllBalanceResponse to demo use of the querier",
-      "type": "object",
-      "required": [
-        "other_balance"
-      ],
-      "properties": {
-        "other_balance": {
-          "type": "object",
-          "required": [
-            "address"
-          ],
-          "properties": {
-            "address": {
-              "type": "string"
-            }
-          },
-          "additionalProperties": false
-        }
-      },
-      "additionalProperties": false
-    },
     {
       "description": "Recurse will execute a query into itself up to depth-times and return Each step of the recursion may perform some extra work to test gas metering (`work` rounds of sha256 on contract). Now that we have Env, we can auto-calculate the address to recurse into",
       "type": "object",

contracts/hackatom/src/contract.rs

@@ -1,9 +1,9 @@
 use sha2::{Digest, Sha256};
 
 use cosmwasm_std::{
-    entry_point, from_json, to_json_binary, to_json_vec, Addr, AllBalanceResponse, Api, BankMsg,
-    BankQuery, CanonicalAddr, Deps, DepsMut, Env, Event, MessageInfo, MigrateInfo, QueryRequest,
-    QueryResponse, Response, StdError, StdResult, WasmMsg, WasmQuery,
+    entry_point, from_json, to_json_binary, to_json_vec, Addr, Api, BankMsg, CanonicalAddr, Deps,
+    DepsMut, Env, Event, MessageInfo, MigrateInfo, QueryRequest, QueryResponse, Response, StdError,
+    StdResult, WasmMsg, WasmQuery,
 };
 
 use crate::errors::HackError;
@@ -82,7 +82,7 @@ pub fn execute(
     msg: ExecuteMsg,
 ) -> Result<Response, HackError> {
     match msg {
-        ExecuteMsg::Release {} => do_release(deps, env, info),
+        ExecuteMsg::Release { denom } => do_release(deps, env, info, denom),
         ExecuteMsg::CpuLoop {} => do_cpu_loop(),
         ExecuteMsg::StorageLoop {} => do_storage_loop(deps),
         ExecuteMsg::MemoryLoop {} => do_memory_loop(),
@@ -93,7 +93,12 @@ pub fn execute(
     }
 }
 
-fn do_release(deps: DepsMut, env: Env, info: MessageInfo) -> Result<Response, HackError> {
+fn do_release(
+    deps: DepsMut,
+    env: Env,
+    info: MessageInfo,
+    denom: String,
+) -> Result<Response, HackError> {
     let data = deps
         .storage
         .get(CONFIG_KEY)
@@ -102,16 +107,15 @@ fn do_release(deps: DepsMut, env: Env, info: MessageInfo) -> Result<Response, Ha
 
     if info.sender == state.verifier {
         let to_addr = state.beneficiary;
-        #[allow(deprecated)]
-        let balance = deps.querier.query_all_balances(env.contract.address)?;
+        let balance = deps.querier.query_balance(env.contract.address, denom)?;
 
         let resp = Response::new()
             .add_attribute("action", "release")
             .add_attribute("destination", to_addr.clone())
             .add_event(Event::new("hackatom").add_attribute("action", "release"))
             .add_message(BankMsg::Send {
                 to_address: to_addr.into(),
-                amount: balance,
+                amount: vec![balance],
             })
             .set_data([0xF0, 0x0B, 0xAA]);
         Ok(resp)
@@ -250,7 +254,6 @@ fn do_user_errors_in_api_calls(api: &dyn Api) -> Result<Response, HackError> {
 pub fn query(deps: Deps, env: Env, msg: QueryMsg) -> StdResult<QueryResponse> {
     match msg {
         QueryMsg::Verifier {} => to_json_binary(&query_verifier(deps)?),
-        QueryMsg::OtherBalance { address } => to_json_binary(&query_other_balance(deps, address)?),
         QueryMsg::Recurse { depth, work } => {
             to_json_binary(&query_recurse(deps, depth, work, env.contract.address)?)
         }
@@ -269,12 +272,6 @@ fn query_verifier(deps: Deps) -> StdResult<VerifierResponse> {
     })
 }
 
-#[allow(deprecated)]
-fn query_other_balance(deps: Deps, address: String) -> StdResult<AllBalanceResponse> {
-    deps.querier
-        .query(&BankQuery::AllBalances { address }.into())
-}
-
 fn query_recurse(deps: Deps, depth: u32, work: u32, contract: Addr) -> StdResult<RecurseResponse> {
     // perform all hashes as requested
     let mut hashed: Vec<u8> = contract.as_str().into();
@@ -308,12 +305,9 @@ fn query_int() -> IntResponse {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use cosmwasm_std::testing::{
-        message_info, mock_dependencies, mock_dependencies_with_balances, mock_env,
-        MOCK_CONTRACT_ADDR,
-    };
+    use cosmwasm_std::testing::{message_info, mock_dependencies, mock_env, MOCK_CONTRACT_ADDR};
     // import trait Storage to get access to read
-    use cosmwasm_std::{coins, Binary, Storage, SubMsg};
+    use cosmwasm_std::{coin, coins, Binary, Storage, SubMsg};
 
     #[test]
     fn proper_initialization() {
@@ -440,21 +434,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn querier_callbacks_work() {
-        let rich_addr = String::from("foobar");
-        let rich_balance = coins(10000, "gold");
-        let deps = mock_dependencies_with_balances(&[(&rich_addr, &rich_balance)]);
-
-        // querying with balance gets the balance
-        let bal = query_other_balance(deps.as_ref(), rich_addr).unwrap();
-        assert_eq!(bal.amount, rich_balance);
-
-        // querying other accounts gets none
-        let bal = query_other_balance(deps.as_ref(), String::from("someone else")).unwrap();
-        assert_eq!(bal.amount, vec![]);
-    }
-
     #[test]
     fn execute_release_works() {
         let mut deps = mock_dependencies();
@@ -484,7 +463,9 @@ mod tests {
             deps.as_mut(),
             mock_env(),
             execute_info,
-            ExecuteMsg::Release {},
+            ExecuteMsg::Release {
+                denom: "earth".to_string(),
+            },
         )
         .unwrap();
         assert_eq!(execute_res.messages.len(), 1);
@@ -503,6 +484,71 @@ mod tests {
         assert_eq!(execute_res.data, Some(vec![0xF0, 0x0B, 0xAA].into()));
     }
 
+    #[test]
+    fn execute_release_can_be_called_multiple_times() {
+        let mut deps = mock_dependencies();
+
+        // initialize the store
+        let creator = deps.api.addr_make("creator");
+        let verifier = deps.api.addr_make("verifies");
+        let beneficiary = deps.api.addr_make("benefits");
+
+        let instantiate_msg = InstantiateMsg {
+            verifier: verifier.to_string(),
+            beneficiary: beneficiary.to_string(),
+        };
+        let init_amount = vec![coin(1000, "earth"), coin(70, "sun")];
+        let info = message_info(&creator, &init_amount);
+        instantiate(deps.as_mut(), mock_env(), info, instantiate_msg).unwrap();
+
+        // balance changed in init
+        deps.querier
+            .bank
+            .update_balance(MOCK_CONTRACT_ADDR, init_amount);
+
+        // beneficiary can release it
+        let execute_info = message_info(&verifier, &[]);
+        let execute_res = execute(
+            deps.as_mut(),
+            mock_env(),
+            execute_info,
+            ExecuteMsg::Release {
+                denom: "sun".to_string(),
+            },
+        )
+        .unwrap();
+        assert_eq!(execute_res.messages.len(), 1);
+        let msg = execute_res.messages.first().expect("no message");
+        assert_eq!(
+            msg,
+            &SubMsg::new(BankMsg::Send {
+                to_address: beneficiary.to_string(),
+                amount: coins(70, "sun"),
+            }),
+        );
+
+        // beneficiary can release it again
+        let execute_info = message_info(&verifier, &[]);
+        let execute_res = execute(
+            deps.as_mut(),
+            mock_env(),
+            execute_info,
+            ExecuteMsg::Release {
+                denom: "earth".to_string(),
+            },
+        )
+        .unwrap();
+        assert_eq!(execute_res.messages.len(), 1);
+        let msg = execute_res.messages.first().expect("no message");
+        assert_eq!(
+            msg,
+            &SubMsg::new(BankMsg::Send {
+                to_address: beneficiary.to_string(),
+                amount: coins(1000, "earth"),
+            }),
+        );
+    }
+
     #[test]
     fn execute_release_fails_for_wrong_sender() {
         let mut deps = mock_dependencies();
@@ -532,7 +578,9 @@ mod tests {
             deps.as_mut(),
             mock_env(),
             execute_info,
-            ExecuteMsg::Release {},
+            ExecuteMsg::Release {
+                denom: "earth".to_string(),
+            },
         );
         assert_eq!(execute_res.unwrap_err(), HackError::Unauthorized {});
 

contracts/hackatom/src/msg.rs

@@ -35,8 +35,9 @@ pub enum SudoMsg {
 // https://github.com/cosmwasm/wasmd/issues/8#issuecomment-576146751
 #[cw_serde]
 pub enum ExecuteMsg {
-    /// Releasing all funds in the contract to the beneficiary. This is the only "proper" action of this demo contract.
-    Release {},
+    /// Releasing all funds of the given denom in the contract to the beneficiary.
+    /// This is the only "proper" action of this demo contract.
+    Release { denom: String },
     /// Infinite loop to burn cpu cycles (only run when metering is enabled)
     CpuLoop {},
     /// Infinite loop making storage calls (to test when their limit hits)
@@ -61,9 +62,6 @@ pub enum QueryMsg {
     /// use to ensure query path works in integration tests
     #[returns(VerifierResponse)]
     Verifier {},
-    /// This returns cosmwasm_std::AllBalanceResponse to demo use of the querier
-    #[returns(cosmwasm_std::AllBalanceResponse)]
-    OtherBalance { address: String },
     /// Recurse will execute a query into itself up to depth-times and return
     /// Each step of the recursion may perform some extra work to test gas metering
     /// (`work` rounds of sha256 on contract).