Merge pull request #46 from osmosis-labs/wasm-sudo

Enable calling sudo on contract directly

Author: iboss-ptk

Cargo.toml

@@ -1,5 +1,6 @@
 [workspace]
 members = [
   "packages/*",
+  "test_contracts/*",
 ]
 resolver = "2"

packages/osmosis-test-tube/Cargo.toml

@@ -20,9 +20,14 @@ serde_json = "1.0.85"
 test-tube = {version = "0.4.0", path = "../test-tube", features = ["module-wrappers"]}
 thiserror = "1.0.34"
 
+[features]
+default = []
+wasm-sudo = ["test-tube/wasm-sudo"]
+
 [build-dependencies]
 bindgen = "0.69.1"
 
 [dev-dependencies]
 cw1-whitelist = "1.1.1"
 rayon = "1.5.3"
+simple-sudo = {path = "../../test_contracts/simple-sudo"}

packages/osmosis-test-tube/libosmosistesttube/go.mod

@@ -1,6 +1,8 @@
 module github.com/osmosis-labs/test-tube/osmosis-test-tube
 
-go 1.19
+go 1.21
+
+toolchain go1.21.6
 
 require (
 	cosmossdk.io/errors v1.0.0

packages/osmosis-test-tube/libosmosistesttube/go.sum

@@ -160,6 +160,30 @@ func EndBlock(envId uint64) {
 	envRegister.Store(envId, env)
 }
 
+//export WasmSudo
+func WasmSudo(envId uint64, bech32Address, msgJson string) *C.char {
+	env := loadEnv(envId)
+	// Temp fix for concurrency issue
+	mu.Lock()
+	defer mu.Unlock()
+
+	accAddr, err := sdk.AccAddressFromBech32(bech32Address)
+	if err != nil {
+		panic(err)
+	}
+
+	msgBytes := []byte(msgJson)
+
+	res, err := env.App.WasmKeeper.Sudo(env.Ctx, accAddr, msgBytes)
+	if err != nil {
+		return encodeErrToResultBytes(result.ExecuteError, err)
+	}
+
+	envRegister.Store(envId, env)
+
+	return encodeBytesResultBytes(res)
+}
+
 //export Execute
 func Execute(envId uint64, base64ReqDeliverTx string) *C.char {
 	env := loadEnv(envId)

packages/osmosis-test-tube/libosmosistesttube/main.go

@@ -109,6 +109,23 @@ impl OsmosisTestApp {
     ) -> RunnerResult<P> {
         self.inner.get_param_set(subspace, type_url)
     }
+
+    /// Directly trigger sudo entrypoint on a given contract.
+    ///
+    /// # Caution
+    ///
+    /// This function bypasses standard state changes and processes within the chain logic that might occur in normal situation,
+    /// It is primarily intended for internal system logic where necessary state adjustments are handled.
+    /// Use only with full understanding of the function's impact on system state and testing validity.
+    /// Improper use may result in misleading test outcomes, including false positives or negatives.
+    #[cfg(feature = "wasm-sudo")]
+    pub fn wasm_sudo<M: serde::Serialize>(
+        &self,
+        contract_address: &str,
+        sudo_msg: M,
+    ) -> RunnerResult<Vec<u8>> {
+        self.inner.wasm_sudo(contract_address, sudo_msg)
+    }
 }
 
 impl<'a> Runner<'a> for OsmosisTestApp {
@@ -570,4 +587,57 @@ mod tests {
         // should succeed
         assert!(res.data.success);
     }
+
+    #[cfg(feature = "wasm-sudo")]
+    #[test]
+    fn test_wasm_sudo() {
+        let app = OsmosisTestApp::default();
+        let wasm = Wasm::new(&app);
+
+        let wasm_byte_code = std::fs::read("./test_artifacts/simple_sudo.wasm").unwrap();
+        let alice = app
+            .init_account(&coins(1_000_000_000_000, "uosmo"))
+            .unwrap();
+
+        let code_id = wasm
+            .store_code(&wasm_byte_code, None, &alice)
+            .unwrap()
+            .data
+            .code_id;
+
+        let contract_addr = wasm
+            .instantiate(
+                code_id,
+                &simple_sudo::msg::InstantiateMsg {},
+                None,
+                Some("simple_sudo"),
+                &[],
+                &alice,
+            )
+            .unwrap()
+            .data
+            .address;
+
+        let res = app
+            .wasm_sudo(
+                &contract_addr,
+                simple_sudo::msg::SudoMsg::SetRandomData {
+                    key: "x".to_string(),
+                    value: "1".to_string(),
+                },
+            )
+            .unwrap();
+
+        assert_eq!(String::from_utf8(res).unwrap(), "x=1");
+
+        let res: simple_sudo::msg::RandomDataResponse = wasm
+            .query(
+                &contract_addr,
+                &simple_sudo::msg::QueryMsg::GetRandomData {
+                    key: "x".to_string(),
+                },
+            )
+            .unwrap();
+        assert_eq!(res.value, "1");
+    }
 }

packages/osmosis-test-tube/src/runner/app.rs

@@ -8,7 +8,7 @@ mod tests {
 
     use super::app::OsmosisTestApp;
     use base64::Engine;
-    use cosmwasm_std::{to_binary, BankMsg, Coin, CosmosMsg, Empty, Event, WasmMsg};
+    use cosmwasm_std::{to_json_binary, BankMsg, Coin, CosmosMsg, Empty, Event, WasmMsg};
     use cw1_whitelist::msg::{ExecuteMsg, InstantiateMsg};
     use osmosis_std::types::cosmos::bank::v1beta1::{MsgSendResponse, QueryBalanceRequest};
     use osmosis_std::types::cosmwasm::wasm::v1::{
@@ -162,7 +162,7 @@ mod tests {
         // Wasm::Instantiate
         let instantiate_msg: CosmosMsg = CosmosMsg::Wasm(WasmMsg::Instantiate {
             code_id,
-            msg: to_binary(&InstantiateMsg {
+            msg: to_json_binary(&InstantiateMsg {
                 admins: vec![signer.address()],
                 mutable: true,
             })
@@ -180,7 +180,7 @@ mod tests {
         // Wasm::Execute
         let execute_msg: CosmosMsg = CosmosMsg::Wasm(WasmMsg::Execute {
             contract_addr: contract_address.clone(),
-            msg: to_binary(&ExecuteMsg::<Empty>::Freeze {}).unwrap(),
+            msg: to_json_binary(&ExecuteMsg::<Empty>::Freeze {}).unwrap(),
             funds: vec![],
         });
         let execute_res = app

packages/osmosis-test-tube/src/runner/mod.rs

@@ -24,8 +24,8 @@ rayon = "1.5.3"
 
 [features]
 default = []
-
 module-wrappers = ["bank", "wasm"]
+wasm-sudo = []
 
 bank = ["osmosis-std"]
 wasm = ["osmosis-std"]

packages/osmosis-test-tube/test_artifacts/simple_sudo.wasm

@@ -220,6 +220,13 @@ extern "C" {
 extern "C" {
     pub fn EndBlock(envId: GoUint64);
 }
+extern "C" {
+    pub fn WasmSudo(
+        envId: GoUint64,
+        bech32Address: GoString,
+        msgJson: GoString,
+    ) -> *mut ::std::os::raw::c_char;
+}
 extern "C" {
     pub fn IncreaseTime(envId: GoUint64, seconds: GoInt64);
 }