diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 24c397009..b5d2fe43b 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -56,7 +56,7 @@ jobs: make clean-enclave Build-Contracts: - runs-on: ubuntu-20.04 + runs-on: ubuntu-22.04 steps: - uses: actions/checkout@v3 - name: Download sccache diff --git a/.gitignore b/.gitignore index 35fada994..1d454081e 100644 --- a/.gitignore +++ b/.gitignore @@ -39,12 +39,6 @@ node_modules /secretjs /secret.js tmp-swagger-gen -x/compute/internal/keeper/testdata/contract_with_floats.wasm -x/compute/internal/keeper/testdata/contract.wasm -x/compute/internal/keeper/testdata/ibc.wasm -x/compute/internal/keeper/testdata/static-too-high-initial-memory.wasm -x/compute/internal/keeper/testdata/too-high-initial-memory.wasm -x/compute/internal/keeper/testdata/v1-contract.wasm /github.com third_party/build x/compute/internal/keeper/testdata/test-contract/target diff --git a/.vscode/settings.json b/.vscode/settings.json index 6b3e9d7dc..a38db357c 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -16,6 +16,7 @@ "cosmwasm/contracts/v1/compute-tests/migration/contract-v2/Cargo.toml", "integration-tests/contract-v1/Cargo.toml", "integration-tests/contract-v0.10/Cargo.toml", + "cosmwasm/contracts/v1/compute-tests/random-test/Cargo.toml", "go-cosmwasm/Cargo.toml", "cosmwasm/enclaves/shared/cosmos-proto/Cargo.toml", "cosmwasm/enclaves/shared/contract-engine/Cargo.toml", diff --git a/Makefile b/Makefile index 34f1c5ef8..0191b9fd2 100644 --- a/Makefile +++ b/Makefile @@ -242,6 +242,10 @@ clean: $(MAKE) -C go-cosmwasm clean-all $(MAKE) -C cosmwasm/enclaves/test clean $(MAKE) -C check-hw clean + $(MAKE) -C $(TEST_CONTRACT_V010_PATH)/test-compute-contract clean + $(MAKE) -C $(TEST_CONTRACT_V010_PATH)/test-compute-contract-v2 clean + $(MAKE) -C $(TEST_CONTRACT_V1_PATH)/test-compute-contract clean + $(MAKE) -C $(TEST_CONTRACT_V1_PATH)/test-compute-contract-v2 clean localsecret: DOCKER_BUILDKIT=1 docker build \ @@ -460,6 +464,10 @@ build-test-contracts: rm -f $(TEST_COMPUTE_MODULE_PATH)/migrate_contract_v2.wasm cp $(TEST_CONTRACT_V1_PATH)/migration/contract-v2/migrate_contract_v2.wasm $(TEST_COMPUTE_MODULE_PATH)/migrate_contract_v2.wasm + $(MAKE) -C $(TEST_CONTRACT_V1_PATH)/random-test + rm -f $(TEST_COMPUTE_MODULE_PATH)/v1_random_test.wasm + cp $(TEST_CONTRACT_V1_PATH)/random-test/v1_random_test.wasm $(TEST_COMPUTE_MODULE_PATH)/v1_random_test.wasm + prep-go-tests: build-test-contracts bin-data-sw # empty BUILD_PROFILE means debug mode which compiles faster diff --git a/cosmwasm/Cargo.lock b/cosmwasm/Cargo.lock index 421e0b681..b1a9bbeb9 100644 --- a/cosmwasm/Cargo.lock +++ b/cosmwasm/Cargo.lock @@ -396,9 +396,9 @@ dependencies = [ [[package]] name = "parity-wasm" -version = "0.41.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ddfc878dac00da22f8f61e7af3157988424567ab01d9920b962ef7dcbd7cd865" +checksum = "e1ad0aff30c1da14b1254fcb2af73e1fa9a28670e584a626f53a369d0e157304" [[package]] name = "parking_lot" diff --git a/cosmwasm/contracts/v010/compute-tests/test-compute-contract-v2/src/contract.rs b/cosmwasm/contracts/v010/compute-tests/test-compute-contract-v2/src/contract.rs index 5de810363..1953c7b43 100644 --- a/cosmwasm/contracts/v010/compute-tests/test-compute-contract-v2/src/contract.rs +++ b/cosmwasm/contracts/v010/compute-tests/test-compute-contract-v2/src/contract.rs @@ -1,20 +1,19 @@ use cosmwasm_storage::{PrefixedStorage, ReadonlySingleton, Singleton}; use cosmwasm_std::{ - log, plaintext_log, to_binary, Api, BankMsg, Binary, Coin, CosmosMsg, Empty, Env, Extern, - HandleResponse, HandleResult, HumanAddr, InitResponse, InitResult, MigrateResponse, - MigrateResult, Querier, QueryRequest, QueryResult, ReadonlyStorage, StdError, StdResult, - Storage, Uint128, WasmMsg, WasmQuery, + log, plaintext_log, to_binary, Api, BankMsg, Binary, CanonicalAddr, Coin, CosmosMsg, Empty, + Env, Extern, HandleResponse, HandleResult, HumanAddr, InitResponse, InitResult, + MigrateResponse, MigrateResult, Querier, QueryRequest, QueryResult, ReadonlyStorage, StdError, + StdResult, Storage, Uint128, WasmMsg, WasmQuery, }; use secp256k1::Secp256k1; /////////////////////////////// Messages /////////////////////////////// use core::time; -use mem::MaybeUninit; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use std::{mem, thread, vec}; +use std::{thread, vec}; //// consts @@ -1647,12 +1646,13 @@ fn exec_with_callback_contract_error( } fn allocate_on_heap(bytes: usize) -> HandleResponse { - let mut values: Vec = vec![0; bytes]; + let mut values: Box> = Box::new(vec![0; bytes]); + values[bytes - 1] = 1; HandleResponse { data: Some(Binary("😅".as_bytes().to_vec())), - log: vec![], + log: vec![log("zero", format!("{}", values[bytes / 2]))], messages: vec![], } } @@ -1698,7 +1698,13 @@ fn pass_null_pointer_to_imports_should_throw( deps: &mut Extern, pass_type: String, ) -> HandleResponse { - let null_ptr_slice: &[u8] = unsafe { MaybeUninit::zeroed().assume_init() }; + let null_ptr_slice: &[u8] = unsafe { std::slice::from_raw_parts(std::ptr::null(), 0) }; + + let null_ptr: *const HumanAddr = std::ptr::null(); + let null_human_addr: &HumanAddr = unsafe { &*null_ptr }; + + let null_ptr: *const CanonicalAddr = std::ptr::null(); + let null_canon_addr: &CanonicalAddr = unsafe { &*null_ptr }; match &pass_type[..] { "read_db_key" => { @@ -1714,13 +1720,11 @@ fn pass_null_pointer_to_imports_should_throw( deps.storage.remove(null_ptr_slice); } "canonicalize_address_input" => { - deps.api - .canonical_address(unsafe { MaybeUninit::zeroed().assume_init() }); + deps.api.canonical_address(null_human_addr); } "canonicalize_address_output" => { /* TODO */ } "humanize_address_input" => { - deps.api - .human_address(unsafe { MaybeUninit::zeroed().assume_init() }); + deps.api.human_address(null_canon_addr); } "humanize_address_output" => { /* TODO */ } _ => {} diff --git a/cosmwasm/contracts/v010/compute-tests/test-compute-contract/Makefile b/cosmwasm/contracts/v010/compute-tests/test-compute-contract/Makefile index 0c3dd2ae4..43026623a 100644 --- a/cosmwasm/contracts/v010/compute-tests/test-compute-contract/Makefile +++ b/cosmwasm/contracts/v010/compute-tests/test-compute-contract/Makefile @@ -16,17 +16,22 @@ contract_with_floats.wasm: $(Rust_Crate_Source) rm -f ./contract_with_floats.wasm mv -f ./target/wasm32-unknown-unknown/release/test_contract.wasm ./contract_with_floats.wasm +# Older versions of wabt had the --enable-sign-extension flag, while on newer +# versions it's turned on by default and the flag is replaced with --disable-sign-extension +WASM2WAT_OPTS := $(shell wasm2wat --help | grep -Po '\-\-enable-sign-extension') +WAT2WAT_OPTS := $(shell wat2wasm --help | grep -Po '\-\-enable-sign-extension') + # Create a wasm with more than 192 memory pages (fails in init, handle & query, this is our limit) # https://github.com/scrtlabs/SecretNetwork/blob/9eef8591b2c04c586ceee12f424b92062598123e/cosmwasm/packages/wasmi-runtime/src/wasm/memory.rs#L39 too-high-initial-memory.wasm: contract.wasm - wasm2wat ./contract.wasm | perl -pe 's/\(memory \(;0;\) \d+\)/(memory (;0;) 193)/' > /tmp/too-high-initial-memory.wat - wat2wasm /tmp/too-high-initial-memory.wat -o ./too-high-initial-memory.wasm + wasm2wat $(WASM2WAT_OPTS) ./contract.wasm | perl -pe 's/\(memory \(;0;\) \d+\)/(memory (;0;) 193)/' > /tmp/too-high-initial-memory.wat + wat2wasm $(WAT2WAT_OPTS) /tmp/too-high-initial-memory.wat -o ./too-high-initial-memory.wasm # Create a wasm with more than 512 memory pages (fails in store, this is cosmwasm's limit) # https://github.com/scrtlabs/SecretNetwork/blob/9eef8591b2c04c586ceee12f424b92062598123e/cosmwasm/packages/sgx-vm/src/compatability.rs#L36 static-too-high-initial-memory.wasm: contract.wasm - wasm2wat ./contract.wasm | perl -pe 's/\(memory \(;0;\) \d+\)/(memory (;0;) 513)/' > /tmp/static-too-high-initial-memory.wat - wat2wasm /tmp/static-too-high-initial-memory.wat -o ./static-too-high-initial-memory.wasm + wasm2wat $(WASM2WAT_OPTS) ./contract.wasm | perl -pe 's/\(memory \(;0;\) \d+\)/(memory (;0;) 513)/' > /tmp/static-too-high-initial-memory.wat + wat2wasm $(WAT2WAT_OPTS) /tmp/static-too-high-initial-memory.wat -o ./static-too-high-initial-memory.wasm setup: apt-get install wabt diff --git a/cosmwasm/contracts/v010/compute-tests/test-compute-contract/contract.rs b/cosmwasm/contracts/v010/compute-tests/test-compute-contract/contract.rs new file mode 100644 index 000000000..d7f5b7805 --- /dev/null +++ b/cosmwasm/contracts/v010/compute-tests/test-compute-contract/contract.rs @@ -0,0 +1,1920 @@ +use cosmwasm_storage::{PrefixedStorage, ReadonlySingleton, Singleton}; + +use cosmwasm_std::{ + log, plaintext_log, to_binary, Api, BankMsg, Binary, Coin, CosmosMsg, Empty, Env, Extern, + HandleResponse, HandleResult, HumanAddr, InitResponse, InitResult, Querier, QueryRequest, + QueryResult, ReadonlyStorage, StdError, StdResult, Storage, Uint128, WasmMsg, WasmQuery, +}; +use secp256k1::Secp256k1; + +/////////////////////////////// Messages /////////////////////////////// + +use core::time; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use std::thread; + +//// consts + +const REALLY_LONG: &[u8] = b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum InitMsg { + WasmMsg { + ty: String, + }, + Nop {}, + Callback { + contract_addr: HumanAddr, + code_hash: String, + }, + CallbackContractError { + contract_addr: HumanAddr, + code_hash: String, + }, + ContractError { + error_type: String, + }, + NoLogs {}, + CallbackToInit { + code_id: u64, + code_hash: String, + }, + CallbackBadParams { + contract_addr: HumanAddr, + code_hash: String, + }, + Panic {}, + SendExternalQueryDepthCounter { + to: HumanAddr, + depth: u8, + code_hash: String, + }, + SendExternalQueryRecursionLimit { + to: HumanAddr, + depth: u8, + code_hash: String, + }, + CallToInit { + code_id: u64, + code_hash: String, + label: String, + msg: String, + }, + CallToExec { + addr: HumanAddr, + code_hash: String, + msg: String, + }, + CallToQuery { + addr: HumanAddr, + code_hash: String, + msg: String, + }, + InitFromV1 { + counter: u64, + }, + Counter { + counter: u64, + }, + AddAttributes {}, + AddAttributesWithSubmessage {}, + AddPlaintextAttributes {}, + AddPlaintextAttributesWithSubmessage {}, + AddMixedEventsAndAttributesFromV1 { + addr: HumanAddr, + code_hash: String, + }, + BankMsgSend { + amount: Vec, + to: HumanAddr, + from: Option, + }, + CosmosMsgCustom {}, + SendMultipleFundsToInitCallback { + coins: Vec, + code_id: u64, + code_hash: String, + }, + SendMultipleFundsToExecCallback { + coins: Vec, + to: HumanAddr, + code_hash: String, + }, + GetEnv {}, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum HandleMsg { + WasmMsg { + ty: String, + }, + A { + contract_addr: HumanAddr, + code_hash: String, + x: u8, + y: u8, + }, + B { + contract_addr: HumanAddr, + code_hash: String, + x: u8, + y: u8, + }, + C { + x: u8, + y: u8, + }, + UnicodeData {}, + EmptyLogKeyValue {}, + EmptyData {}, + NoData {}, + ContractError { + error_type: String, + }, + NoLogs {}, + CallbackToInit { + code_id: u64, + code_hash: String, + }, + CallbackContractError { + contract_addr: HumanAddr, + code_hash: String, + }, + CallbackBadParams { + contract_addr: HumanAddr, + code_hash: String, + }, + SetState { + key: String, + value: String, + }, + GetState { + key: String, + }, + RemoveState { + key: String, + }, + TestCanonicalizeAddressErrors {}, + Panic {}, + AllocateOnHeap { + bytes: u32, + }, + PassNullPointerToImportsShouldThrow { + pass_type: String, + }, + SendExternalQuery { + to: HumanAddr, + code_hash: String, + }, + SendExternalQueryPanic { + to: HumanAddr, + code_hash: String, + }, + SendExternalQueryError { + to: HumanAddr, + code_hash: String, + }, + SendExternalQueryBadAbi { + to: HumanAddr, + code_hash: String, + }, + SendExternalQueryBadAbiReceiver { + to: HumanAddr, + code_hash: String, + }, + LogMsgSender {}, + CallbackToLogMsgSender { + to: HumanAddr, + code_hash: String, + }, + DepositToContract {}, + SendFunds { + amount: u32, + denom: String, + to: HumanAddr, + from: HumanAddr, + }, + BankMsgSend { + amount: Vec, + to: HumanAddr, + from: Option, + }, + SendFundsToInitCallback { + amount: u32, + denom: String, + code_id: u64, + code_hash: String, + }, + SendMultipleFundsToInitCallback { + coins: Vec, + code_id: u64, + code_hash: String, + }, + SendFundsToExecCallback { + amount: u32, + denom: String, + to: HumanAddr, + code_hash: String, + }, + SendMultipleFundsToExecCallback { + coins: Vec, + to: HumanAddr, + code_hash: String, + }, + Sleep { + ms: u64, + }, + SendExternalQueryDepthCounter { + to: HumanAddr, + code_hash: String, + depth: u8, + }, + SendExternalQueryRecursionLimit { + to: HumanAddr, + code_hash: String, + depth: u8, + }, + WithFloats { + x: u8, + y: u8, + }, + CallToInit { + code_id: u64, + code_hash: String, + label: String, + msg: String, + }, + CallToExec { + addr: HumanAddr, + code_hash: String, + msg: String, + }, + CallToQuery { + addr: HumanAddr, + code_hash: String, + msg: String, + }, + StoreReallyLongKey {}, + StoreReallyShortKey {}, + StoreReallyLongValue {}, + Secp256k1Verify { + pubkey: Binary, + sig: Binary, + msg_hash: Binary, + iterations: u32, + }, + Secp256k1VerifyFromCrate { + pubkey: Binary, + sig: Binary, + msg_hash: Binary, + iterations: u32, + }, + Ed25519Verify { + pubkey: Binary, + sig: Binary, + msg: Binary, + iterations: u32, + }, + Ed25519BatchVerify { + pubkeys: Vec, + sigs: Vec, + msgs: Vec, + iterations: u32, + }, + Secp256k1RecoverPubkey { + msg_hash: Binary, + sig: Binary, + recovery_param: u8, + iterations: u32, + }, + Secp256k1Sign { + msg: Binary, + privkey: Binary, + iterations: u32, + }, + Ed25519Sign { + msg: Binary, + privkey: Binary, + iterations: u32, + }, + ExecuteFromV1 { + counter: u64, + }, + IncrementFromV1 { + addition: u64, + }, + AddAttributes {}, + AddAttributesWithSubmessage {}, + AddMoreAttributes {}, + AddPlaintextAttributes {}, + AddPlaintextAttributesWithSubmessage {}, + AddMorePlaintextAttributes {}, + AddMixedEventsAndAttributesFromV1 { + addr: HumanAddr, + code_hash: String, + }, + CosmosMsgCustom {}, + InitNewContract {}, + GetEnv {}, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum QueryMsg { + ContractError { + error_type: String, + }, + Panic {}, + ReceiveExternalQuery { + num: u8, + }, + SendExternalQueryInfiniteLoop { + to: HumanAddr, + code_hash: String, + }, + WriteToStorage {}, + RemoveFromStorage {}, + SendExternalQueryDepthCounter { + to: HumanAddr, + depth: u8, + code_hash: String, + }, + SendExternalQueryRecursionLimit { + to: HumanAddr, + depth: u8, + code_hash: String, + }, + CallToQuery { + addr: HumanAddr, + code_hash: String, + msg: String, + }, + GetCountFromV1 {}, + Get {}, + GetContractVersion {}, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum QueryRes { + Get { count: u64 }, +} + +/////////////////////////////// Init /////////////////////////////// + +pub fn init( + deps: &mut Extern, + env: Env, + msg: InitMsg, +) -> InitResult { + match msg { + InitMsg::WasmMsg { ty } => { + if ty == "success" { + return Ok(InitResponse::default()); + } else if ty == "err" { + return Err(StdError::generic_err("custom error")); + } else if ty == "panic" { + panic!() + } + + return Err(StdError::generic_err("custom error")); + } + InitMsg::Nop {} => Ok(InitResponse { + messages: vec![], + log: vec![log("init", "🌈")], + }), + InitMsg::Callback { + contract_addr, + code_hash, + } => Ok(init_with_callback(deps, env, contract_addr, code_hash)), + InitMsg::ContractError { error_type } => Err(map_string_to_error(error_type)), + InitMsg::NoLogs {} => Ok(InitResponse::default()), + InitMsg::CallbackToInit { code_id, code_hash } => { + Ok(init_callback_to_init(deps, env, code_id, code_hash)) + } + InitMsg::CallbackContractError { + contract_addr, + code_hash, + } => Ok(init_with_callback_contract_error(contract_addr, code_hash)), + InitMsg::CallbackBadParams { + contract_addr, + code_hash, + } => Ok(init_callback_bad_params(contract_addr, code_hash)), + InitMsg::Panic {} => panic!("panic in init"), + InitMsg::SendExternalQueryDepthCounter { + to, + depth, + code_hash, + } => Ok(InitResponse { + messages: vec![], + log: vec![log( + format!( + "{}", + send_external_query_depth_counter(deps, to, depth, code_hash) + ), + "", + )], + }), + InitMsg::SendExternalQueryRecursionLimit { + to, + depth, + code_hash, + } => Ok(InitResponse { + messages: vec![], + log: vec![log( + "message", + send_external_query_recursion_limit(deps, to, depth, code_hash)?, + )], + }), + InitMsg::CallToInit { + code_id, + code_hash, + label, + msg, + } => Ok(InitResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Instantiate { + code_id, + callback_code_hash: code_hash, + msg: Binary(msg.as_bytes().into()), + send: vec![], + label: label, + })], + log: vec![log("a", "a")], + }), + InitMsg::CallToExec { + addr, + code_hash, + msg, + } => Ok(InitResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: addr, + callback_code_hash: code_hash, + msg: Binary(msg.as_bytes().into()), + send: vec![], + })], + log: vec![log("b", "b")], + }), + InitMsg::CallToQuery { + addr, + code_hash, + msg, + } => { + let answer: u32 = deps + .querier + .query(&QueryRequest::Wasm(WasmQuery::Smart { + contract_addr: addr, + callback_code_hash: code_hash, + msg: Binary::from(msg.as_bytes().to_vec()), + })) + .map_err(|err| { + StdError::generic_err(format!("Got an error from query: {:?}", err)) + })?; + + Ok(InitResponse { + messages: vec![], + log: vec![log("c", format!("{}", answer))], + }) + } + InitMsg::InitFromV1 { counter } => { + count(&mut deps.storage).save(&counter)?; + + Ok(InitResponse { + messages: vec![], + log: vec![], + }) + } + InitMsg::Counter { counter } => { + count(&mut deps.storage).save(&counter)?; + + Ok(InitResponse { + messages: vec![], + log: vec![], + }) + } + InitMsg::AddAttributes {} => Ok(InitResponse { + messages: vec![], + log: vec![log("attr1", "🦄"), log("attr2", "🌈")], + }), + InitMsg::AddAttributesWithSubmessage {} => Ok(InitResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: env.contract.address, + callback_code_hash: env.contract_code_hash, + msg: Binary::from(r#"{"add_more_attributes":{}}"#.as_bytes().to_vec()), + send: vec![], + })], + log: vec![log("attr1", "🦄"), log("attr2", "🌈")], + }), + InitMsg::AddPlaintextAttributes {} => Ok(InitResponse { + messages: vec![], + log: vec![plaintext_log("attr1", "🦄"), plaintext_log("attr2", "🌈")], + }), + InitMsg::AddPlaintextAttributesWithSubmessage {} => Ok(InitResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: env.contract.address, + callback_code_hash: env.contract_code_hash, + msg: Binary::from(r#"{"add_more_plaintext_attributes":{}}"#.as_bytes().to_vec()), + send: vec![], + })], + log: vec![plaintext_log("attr1", "🦄"), plaintext_log("attr2", "🌈")], + }), + InitMsg::AddMixedEventsAndAttributesFromV1 { addr, code_hash } => Ok(InitResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: addr, + callback_code_hash: code_hash, + msg: Binary::from( + r#"{"add_more_mixed_attributes_and_events":{}}"#.as_bytes().to_vec(), + ), + send: vec![], + })], + log: vec![plaintext_log("attr1", "🦄"), plaintext_log("attr2", "🌈")], + }), + InitMsg::BankMsgSend { + to, + amount: coins, + from, + } => Ok(InitResponse { + messages: vec![CosmosMsg::Bank(BankMsg::Send { + from_address: from.unwrap_or(env.contract.address), + to_address: to, + amount: coins, + })], + log: vec![], + }), + InitMsg::CosmosMsgCustom {} => Ok(InitResponse { + messages: vec![CosmosMsg::Custom(Empty {})], + log: vec![], + }), + InitMsg::SendMultipleFundsToExecCallback { + coins, + to, + code_hash, + } => Ok(InitResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: to, + msg: Binary::from("{\"no_data\":{}}".as_bytes().to_vec()), + callback_code_hash: code_hash, + send: coins, + })], + log: vec![], + }), + InitMsg::SendMultipleFundsToInitCallback { + coins, + code_id, + code_hash, + } => Ok(InitResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Instantiate { + code_id, + msg: Binary::from("{\"nop\":{}}".as_bytes().to_vec()), + callback_code_hash: code_hash, + send: coins, + label: "test".to_string(), + })], + log: vec![], + }), + InitMsg::GetEnv {} => Ok(InitResponse { + log: vec![log("env", serde_json_wasm::to_string(&env).unwrap())], + messages: vec![], + }), + } +} + +pub const COUNT_KEY: &[u8] = b"count"; + +pub fn count(storage: &mut S) -> Singleton { + Singleton::new(storage, COUNT_KEY) +} + +pub fn count_read(storage: &S) -> ReadonlySingleton { + ReadonlySingleton::new(storage, COUNT_KEY) +} + +fn map_string_to_error(error_type: String) -> StdError { + let as_str: &str = &error_type[..]; + match as_str { + "generic_err" => StdError::generic_err("la la 🤯"), + "invalid_base64" => StdError::invalid_base64("ra ra 🤯"), + "invalid_utf8" => StdError::invalid_utf8("ka ka 🤯"), + "not_found" => StdError::not_found("za za 🤯"), + "parse_err" => StdError::parse_err("na na 🤯", "pa pa 🤯"), + "serialize_err" => StdError::serialize_err("ba ba 🤯", "ga ga 🤯"), + "unauthorized" => StdError::unauthorized(), + "underflow" => StdError::underflow("minuend 🤯", "subtrahend 🤯"), + _ => StdError::generic_err("catch-all 🤯"), + } +} + +fn init_with_callback_contract_error(contract_addr: HumanAddr, code_hash: String) -> InitResponse { + InitResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: contract_addr.clone(), + callback_code_hash: code_hash, + msg: Binary::from(r#"{"contract_error":{"error_type":"generic_err"}}"#.as_bytes()), + send: vec![], + })], + log: vec![log("init with a callback with contract error", "🤷‍♀️")], + } +} + +fn init_callback_bad_params(contract_addr: HumanAddr, code_hash: String) -> InitResponse { + InitResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: contract_addr.clone(), + callback_code_hash: code_hash, + msg: Binary::from(r#"{"c":{"x":"banana","y":3}}"#.as_bytes().to_vec()), + send: vec![], + })], + log: vec![], + } +} + +fn init_with_callback( + _deps: &mut Extern, + _env: Env, + contract_addr: HumanAddr, + code_hash: String, +) -> InitResponse { + InitResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + callback_code_hash: code_hash, + contract_addr: contract_addr.clone(), + msg: Binary::from("{\"c\":{\"x\":0,\"y\":13}}".as_bytes().to_vec()), + send: vec![], + })], + log: vec![log("init with a callback", "🦄")], + } +} + +pub fn init_callback_to_init( + _deps: &mut Extern, + _env: Env, + code_id: u64, + code_hash: String, +) -> InitResponse { + InitResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Instantiate { + code_id, + msg: Binary::from("{\"nop\":{}}".as_bytes().to_vec()), + callback_code_hash: code_hash, + send: vec![], + label: String::from("fi"), + })], + log: vec![log("instantiating a new contract from init!", "🐙")], + } +} + +/////////////////////////////// Handle /////////////////////////////// + +pub fn handle( + deps: &mut Extern, + env: Env, + msg: HandleMsg, +) -> HandleResult { + match msg { + HandleMsg::WasmMsg { ty } => { + if ty == "success" { + return Ok(HandleResponse::default()); + } else if ty == "err" { + return Err(StdError::generic_err("custom error")); + } else if ty == "panic" { + panic!() + } + + return Err(StdError::generic_err("custom error")); + } + HandleMsg::A { + contract_addr, + code_hash, + x, + y, + } => Ok(a(deps, env, contract_addr, code_hash, x, y)), + HandleMsg::B { + contract_addr, + code_hash, + x, + y, + } => Ok(b(deps, env, contract_addr, code_hash, x, y)), + HandleMsg::C { x, y } => Ok(c(deps, env, x, y)), + HandleMsg::UnicodeData {} => Ok(unicode_data(deps, env)), + HandleMsg::EmptyLogKeyValue {} => Ok(empty_log_key_value(deps, env)), + HandleMsg::EmptyData {} => Ok(empty_data(deps, env)), + HandleMsg::NoData {} => Ok(no_data(deps, env)), + HandleMsg::ContractError { error_type } => Err(map_string_to_error(error_type)), + HandleMsg::NoLogs {} => Ok(HandleResponse::default()), + HandleMsg::CallbackToInit { code_id, code_hash } => { + Ok(exec_callback_to_init(deps, env, code_id, code_hash)) + } + HandleMsg::CallbackBadParams { + contract_addr, + code_hash, + } => Ok(exec_callback_bad_params(contract_addr, code_hash)), + HandleMsg::CallbackContractError { + contract_addr, + code_hash, + } => Ok(exec_with_callback_contract_error(contract_addr, code_hash)), + HandleMsg::SetState { key, value } => Ok(set_state(deps, key, value)), + HandleMsg::GetState { key } => Ok(get_state(deps, key)), + HandleMsg::RemoveState { key } => Ok(remove_state(deps, key)), + HandleMsg::TestCanonicalizeAddressErrors {} => test_canonicalize_address_errors(deps), + HandleMsg::Panic {} => panic!("panic in exec"), + HandleMsg::AllocateOnHeap { bytes } => Ok(allocate_on_heap(bytes as usize)), + HandleMsg::PassNullPointerToImportsShouldThrow { pass_type } => { + Ok(pass_null_pointer_to_imports_should_throw(deps, pass_type)) + } + HandleMsg::SendExternalQuery { to, code_hash } => Ok(HandleResponse { + messages: vec![], + log: vec![], + data: Some(vec![send_external_query(deps, to, code_hash)].into()), + }), + HandleMsg::SendExternalQueryDepthCounter { + to, + code_hash, + depth, + } => Ok(HandleResponse { + messages: vec![], + log: vec![], + data: Some( + vec![send_external_query_depth_counter( + deps, to, depth, code_hash, + )] + .into(), + ), + }), + HandleMsg::SendExternalQueryRecursionLimit { + to, + code_hash, + depth, + } => Ok(HandleResponse { + messages: vec![], + log: vec![], + data: Some(to_binary(&send_external_query_recursion_limit( + deps, to, depth, code_hash, + )?)?), + }), + HandleMsg::SendExternalQueryPanic { to, code_hash } => { + send_external_query_panic(deps, to, code_hash) + } + HandleMsg::SendExternalQueryError { to, code_hash } => { + send_external_query_stderror(deps, to, code_hash) + } + HandleMsg::SendExternalQueryBadAbi { to, code_hash } => { + send_external_query_bad_abi(deps, to, code_hash) + } + HandleMsg::SendExternalQueryBadAbiReceiver { to, code_hash } => { + send_external_query_bad_abi_receiver(deps, to, code_hash) + } + HandleMsg::LogMsgSender {} => Ok(HandleResponse { + messages: vec![], + log: vec![log("msg.sender", env.message.sender.to_string())], + data: None, + }), + HandleMsg::CallbackToLogMsgSender { to, code_hash } => Ok(HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: to.clone(), + callback_code_hash: code_hash, + msg: Binary::from(r#"{"log_msg_sender":{}}"#.as_bytes().to_vec()), + send: vec![], + })], + log: vec![log("hi", "hey")], + data: None, + }), + HandleMsg::DepositToContract {} => Ok(HandleResponse { + messages: vec![], + log: vec![], + data: Some(to_binary(&env.message.sent_funds).unwrap()), + }), + HandleMsg::SendFunds { + amount, + from, + to, + denom, + } => Ok(HandleResponse { + messages: vec![CosmosMsg::Bank(BankMsg::Send { + from_address: from, + to_address: to, + amount: vec![Coin { + amount: Uint128(amount as u128), + denom: denom, + }], + })], + log: vec![], + data: None, + }), + HandleMsg::BankMsgSend { to, amount, from } => Ok(HandleResponse { + messages: vec![CosmosMsg::Bank(BankMsg::Send { + from_address: from.unwrap_or(env.contract.address), + to_address: to, + amount, + })], + log: vec![], + data: None, + }), + HandleMsg::CosmosMsgCustom {} => Ok(HandleResponse { + messages: vec![CosmosMsg::Custom(Empty {})], + log: vec![], + data: None, + }), + HandleMsg::SendFundsToInitCallback { + amount, + denom, + code_id, + code_hash, + } => Ok(HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Instantiate { + msg: Binary("{\"nop\":{}}".as_bytes().to_vec()), + code_id: code_id, + callback_code_hash: code_hash, + label: String::from("yo"), + send: vec![Coin { + amount: Uint128(amount as u128), + denom: denom, + }], + })], + log: vec![], + data: None, + }), + HandleMsg::SendFundsToExecCallback { + amount, + denom, + to, + code_hash, + } => Ok(HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + msg: Binary("{\"no_data\":{}}".as_bytes().to_vec()), + contract_addr: to, + callback_code_hash: code_hash, + send: vec![Coin { + amount: Uint128(amount as u128), + denom: denom, + }], + })], + log: vec![], + data: None, + }), + HandleMsg::Sleep { ms } => { + thread::sleep(time::Duration::from_millis(ms)); + + Ok(HandleResponse { + messages: vec![], + log: vec![], + data: None, + }) + } + HandleMsg::WithFloats { x, y } => Ok(HandleResponse { + messages: vec![], + log: vec![], + data: Some(use_floats(x, y)), + }), + HandleMsg::CallToInit { + code_id, + code_hash, + label, + msg, + } => Ok(HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Instantiate { + code_id, + callback_code_hash: code_hash, + msg: Binary(msg.as_bytes().into()), + send: vec![], + label: label, + })], + log: vec![log("a", "a")], + data: None, + }), + HandleMsg::CallToExec { + addr, + code_hash, + msg, + } => Ok(HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: addr, + callback_code_hash: code_hash, + msg: Binary(msg.as_bytes().into()), + send: vec![], + })], + log: vec![log("b", "b")], + data: None, + }), + HandleMsg::CallToQuery { + addr, + code_hash, + msg, + } => { + let answer: u32 = deps + .querier + .query(&QueryRequest::Wasm(WasmQuery::Smart { + contract_addr: addr, + callback_code_hash: code_hash, + msg: Binary::from(msg.as_bytes().to_vec()), + })) + .map_err(|err| { + StdError::generic_err(format!("Got an error from query: {:?}", err)) + })?; + + Ok(HandleResponse { + messages: vec![], + log: vec![log("c", format!("{}", answer))], + data: None, + }) + } + HandleMsg::StoreReallyLongKey {} => { + let mut store = PrefixedStorage::new(b"my_prefix", &mut deps.storage); + store.set(REALLY_LONG, b"hello"); + Ok(HandleResponse::default()) + } + HandleMsg::StoreReallyShortKey {} => { + let mut store = PrefixedStorage::new(b"my_prefix", &mut deps.storage); + store.set(b"a", b"hello"); + Ok(HandleResponse::default()) + } + HandleMsg::StoreReallyLongValue {} => { + let mut store = PrefixedStorage::new(b"my_prefix", &mut deps.storage); + store.set(b"hello", REALLY_LONG); + Ok(HandleResponse::default()) + } + HandleMsg::Secp256k1Verify { + pubkey, + sig, + msg_hash, + iterations, + } => { + let mut res: HandleResult = Ok(HandleResponse { + messages: vec![], + log: vec![], + data: None, + }); + + // loop for benchmarking + for _ in 0..iterations { + res = match deps.api.secp256k1_verify( + msg_hash.as_slice(), + sig.as_slice(), + pubkey.as_slice(), + ) { + Ok(result) => Ok(HandleResponse { + messages: vec![], + log: vec![log("result", format!("{}", result))], + data: None, + }), + Err(err) => Err(StdError::generic_err(format!("{:?}", err))), + }; + } + + return res; + } + HandleMsg::Secp256k1VerifyFromCrate { + pubkey, + sig, + msg_hash, + iterations, + } => { + let mut res: HandleResult = Ok(HandleResponse { + messages: vec![], + log: vec![], + data: None, + }); + + // loop for benchmarking + for _ in 0..iterations { + let secp256k1_verifier = Secp256k1::verification_only(); + + let secp256k1_signature = + secp256k1::Signature::from_compact(&sig.0).map_err(|err| { + StdError::generic_err(format!("Malformed signature: {:?}", err)) + })?; + let secp256k1_pubkey = secp256k1::PublicKey::from_slice(pubkey.0.as_slice()) + .map_err(|err| StdError::generic_err(format!("Malformed pubkey: {:?}", err)))?; + let secp256k1_msg = + secp256k1::Message::from_slice(&msg_hash.as_slice()).map_err(|err| { + StdError::generic_err(format!( + "Failed to create a secp256k1 message from signed_bytes: {:?}", + err + )) + })?; + + res = match secp256k1_verifier.verify( + &secp256k1_msg, + &secp256k1_signature, + &secp256k1_pubkey, + ) { + Ok(()) => Ok(HandleResponse { + messages: vec![], + log: vec![log("result", "true")], + data: None, + }), + Err(_err) => Ok(HandleResponse { + messages: vec![], + log: vec![log("result", "false")], + data: None, + }), + }; + } + + return res; + } + HandleMsg::Ed25519Verify { + pubkey, + sig, + msg, + iterations, + } => { + let mut res: HandleResult = Ok(HandleResponse { + messages: vec![], + log: vec![], + data: None, + }); + + // loop for benchmarking + for _ in 0..iterations { + res = + match deps + .api + .ed25519_verify(msg.as_slice(), sig.as_slice(), pubkey.as_slice()) + { + Ok(result) => Ok(HandleResponse { + messages: vec![], + log: vec![log("result", format!("{}", result))], + data: None, + }), + Err(err) => Err(StdError::generic_err(format!("{:?}", err))), + }; + } + + return res; + } + HandleMsg::Ed25519BatchVerify { + pubkeys, + sigs, + msgs, + iterations, + } => { + let mut res: HandleResult = Ok(HandleResponse { + messages: vec![], + log: vec![], + data: None, + }); + + // loop for benchmarking + for _ in 0..iterations { + res = match deps.api.ed25519_batch_verify( + msgs.iter() + .map(|m| m.as_slice()) + .collect::>() + .as_slice(), + sigs.iter() + .map(|s| s.as_slice()) + .collect::>() + .as_slice(), + pubkeys + .iter() + .map(|p| p.as_slice()) + .collect::>() + .as_slice(), + ) { + Ok(result) => Ok(HandleResponse { + messages: vec![], + log: vec![log("result", format!("{}", result))], + data: None, + }), + Err(err) => Err(StdError::generic_err(format!("{:?}", err))), + }; + } + + return res; + } + HandleMsg::Secp256k1RecoverPubkey { + msg_hash, + sig, + recovery_param, + iterations, + } => { + let mut res: HandleResult = Ok(HandleResponse { + messages: vec![], + log: vec![], + data: None, + }); + + // loop for benchmarking + for _ in 0..iterations { + res = match deps.api.secp256k1_recover_pubkey( + msg_hash.as_slice(), + sig.as_slice(), + recovery_param, + ) { + Ok(result) => Ok(HandleResponse { + messages: vec![], + log: vec![log("result", format!("{}", Binary(result).to_base64()))], + data: None, + }), + Err(err) => Err(StdError::generic_err(format!("{:?}", err))), + }; + } + + return res; + } + HandleMsg::Secp256k1Sign { + msg, + privkey, + iterations, + } => { + let mut res: HandleResult = Ok(HandleResponse { + messages: vec![], + log: vec![], + data: None, + }); + + // loop for benchmarking + for _ in 0..iterations { + res = match deps.api.secp256k1_sign(msg.as_slice(), privkey.as_slice()) { + Ok(result) => Ok(HandleResponse { + messages: vec![], + log: vec![log("result", format!("{}", Binary(result).to_base64()))], + data: None, + }), + Err(err) => Err(StdError::generic_err(format!("{:?}", err))), + }; + } + + return res; + } + HandleMsg::Ed25519Sign { + msg, + privkey, + iterations, + } => { + let mut res: HandleResult = Ok(HandleResponse { + messages: vec![], + log: vec![], + data: None, + }); + + // loop for benchmarking + for _ in 0..iterations { + res = match deps.api.ed25519_sign(msg.as_slice(), privkey.as_slice()) { + Ok(result) => Ok(HandleResponse { + messages: vec![], + log: vec![log("result", format!("{}", Binary(result).to_base64()))], + data: None, + }), + Err(err) => Err(StdError::generic_err(format!("{:?}", err))), + }; + } + + return res; + } + HandleMsg::ExecuteFromV1 { counter } => { + count(&mut deps.storage).save(&counter)?; + + let mut resp = HandleResponse::default(); + resp.data = Some( + (count_read(&deps.storage).load()? as u32) + .to_be_bytes() + .into(), + ); + + Ok(resp) + } + HandleMsg::IncrementFromV1 { addition } => { + if addition == 0 { + return Err(StdError::generic_err("got wrong counter")); + } + + let new_count = count(&mut deps.storage).load()? + addition; + count(&mut deps.storage).save(&new_count)?; + + let mut resp = HandleResponse::default(); + resp.data = Some((new_count as u32).to_be_bytes().into()); + + Ok(resp) + } + HandleMsg::AddAttributes {} => Ok(HandleResponse { + messages: vec![], + log: vec![log("attr1", "🦄"), log("attr2", "🌈")], + data: None, + }), + HandleMsg::AddMoreAttributes {} => Ok(HandleResponse { + messages: vec![], + log: vec![log("attr3", "🍉"), log("attr4", "🥝")], + data: None, + }), + HandleMsg::AddAttributesWithSubmessage {} => Ok(HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: env.contract.address, + callback_code_hash: env.contract_code_hash, + msg: Binary::from(r#"{"add_more_attributes":{}}"#.as_bytes().to_vec()), + send: vec![], + })], + log: vec![log("attr1", "🦄"), log("attr2", "🌈")], + data: None, + }), + HandleMsg::AddPlaintextAttributes {} => Ok(HandleResponse { + messages: vec![], + log: vec![plaintext_log("attr1", "🦄"), plaintext_log("attr2", "🌈")], + data: None, + }), + HandleMsg::AddMorePlaintextAttributes {} => Ok(HandleResponse { + messages: vec![], + log: vec![plaintext_log("attr3", "🍉"), plaintext_log("attr4", "🥝")], + data: None, + }), + HandleMsg::AddPlaintextAttributesWithSubmessage {} => Ok(HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: env.contract.address, + callback_code_hash: env.contract_code_hash, + msg: Binary::from(r#"{"add_more_plaintext_attributes":{}}"#.as_bytes().to_vec()), + send: vec![], + })], + log: vec![plaintext_log("attr1", "🦄"), plaintext_log("attr2", "🌈")], + data: None, + }), + HandleMsg::AddMixedEventsAndAttributesFromV1 { addr, code_hash } => Ok(HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: addr, + callback_code_hash: code_hash, + msg: Binary::from( + r#"{"add_more_mixed_attributes_and_events":{}}"#.as_bytes().to_vec(), + ), + send: vec![], + })], + log: vec![plaintext_log("attr1", "🦄"), plaintext_log("attr2", "🌈")], + data: None, + }), + HandleMsg::InitNewContract {} => Ok(HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Instantiate { + code_id: 1, + msg: Binary::from( + "{\"counter\":{\"counter\":150, \"expires\":100}}" + .as_bytes() + .to_vec(), + ), + callback_code_hash: env.contract_code_hash, + send: vec![], + label: String::from("fi"), + })], + log: vec![], + data: None, + }), + HandleMsg::SendMultipleFundsToExecCallback { + coins, + to, + code_hash, + } => Ok(HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: to, + msg: Binary::from("{\"no_data\":{}}".as_bytes().to_vec()), + callback_code_hash: code_hash, + send: coins, + })], + log: vec![], + data: None, + }), + HandleMsg::SendMultipleFundsToInitCallback { + coins, + code_id, + code_hash, + } => Ok(HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Instantiate { + code_id, + msg: Binary::from("{\"nop\":{}}".as_bytes().to_vec()), + callback_code_hash: code_hash, + send: coins, + label: "test".to_string(), + })], + log: vec![], + data: None, + }), + HandleMsg::GetEnv {} => Ok(HandleResponse { + log: vec![log("env", serde_json_wasm::to_string(&env).unwrap())], + data: None, + messages: vec![], + }), + } +} + +#[cfg(feature = "with_floats")] +fn use_floats(x: u8, y: u8) -> Binary { + let res: f64 = (x as f64) / (y as f64); + to_binary(&format!("{}", res)).unwrap() +} + +#[cfg(not(feature = "with_floats"))] +fn use_floats(x: u8, y: u8) -> Binary { + Binary(vec![x, y]) +} + +fn send_external_query( + deps: &Extern, + contract_addr: HumanAddr, + code_hash: String, +) -> u8 { + let answer: u8 = deps + .querier + .query(&QueryRequest::Wasm(WasmQuery::Smart { + contract_addr, + callback_code_hash: code_hash, + msg: Binary::from(r#"{"receive_external_query":{"num":2}}"#.as_bytes().to_vec()), + })) + .unwrap(); + answer +} + +fn send_external_query_depth_counter( + deps: &Extern, + contract_addr: HumanAddr, + depth: u8, + code_hash: String, +) -> u8 { + if depth == 0 { + return 0; + } + + let answer: u8 = deps + .querier + .query(&QueryRequest::Wasm(WasmQuery::Smart { + contract_addr: contract_addr.clone(), + callback_code_hash: code_hash.clone(), + msg: Binary( + format!( + r#"{{"send_external_query_depth_counter":{{"to":"{}","code_hash":"{}","depth":{}}}}}"#, + contract_addr.clone().to_string(), + code_hash.clone().to_string(), + depth - 1 + ) + .into(), + ), + })) + .unwrap(); + + answer + 1 +} + +fn send_external_query_recursion_limit( + deps: &Extern, + contract_addr: HumanAddr, + depth: u8, + code_hash: String, +) -> StdResult { + let result = deps + .querier + .query(&QueryRequest::Wasm(WasmQuery::Smart { + contract_addr: contract_addr.clone(), + callback_code_hash: code_hash.clone(), + msg: Binary( + format!( + r#"{{"send_external_query_recursion_limit":{{"to":"{}","code_hash":"{}","depth":{}}}}}"#, + contract_addr.clone().to_string(), + code_hash.clone().to_string(), + depth + 1 + ) + .into_bytes(), + ), + })); + + // 10 is the current recursion limit. + if depth != 10 { + result + } else { + match result { + Err(StdError::GenericErr { msg, .. }) + if msg == "Querier system error: Query recursion limit exceeded" => + { + Ok(String::from("Recursion limit was correctly enforced")) + } + _ => Err(StdError::generic_err( + "Recursion limit was bypassed! this is a bug!", + )), + } + } +} + +fn send_external_query_panic( + deps: &mut Extern, + contract_addr: HumanAddr, + code_hash: String, +) -> HandleResult { + let err = deps + .querier + .query::(&QueryRequest::Wasm(WasmQuery::Smart { + contract_addr, + msg: Binary::from(r#"{"panic":{}}"#.as_bytes().to_vec()), + callback_code_hash: code_hash, + })) + .unwrap_err(); + + Err(err) +} + +fn send_external_query_stderror( + deps: &mut Extern, + contract_addr: HumanAddr, + code_hash: String, +) -> HandleResult { + let answer = deps + .querier + .query::(&QueryRequest::Wasm(WasmQuery::Smart { + contract_addr, + msg: Binary::from( + r#"{"contract_error":{"error_type":"generic_err"}}"# + .as_bytes() + .to_vec(), + ), + callback_code_hash: code_hash, + })); + + match answer { + Ok(wtf) => Ok(HandleResponse { + messages: vec![], + log: vec![], + data: Some(wtf), + }), + Err(e) => Err(e), + } +} + +fn send_external_query_bad_abi( + deps: &mut Extern, + contract_addr: HumanAddr, + code_hash: String, +) -> HandleResult { + let answer = deps + .querier + .query::(&QueryRequest::Wasm(WasmQuery::Smart { + contract_addr, + callback_code_hash: code_hash, + msg: Binary::from( + r#""contract_error":{"error_type":"generic_err"}}"#.as_bytes().to_vec(), + ), + })); + + match answer { + Ok(wtf) => Ok(HandleResponse { + messages: vec![], + log: vec![], + data: Some(wtf), + }), + Err(e) => Err(e), + } +} + +fn send_external_query_bad_abi_receiver( + deps: &mut Extern, + contract_addr: HumanAddr, + code_hash: String, +) -> HandleResult { + let answer = deps + .querier + .query::(&QueryRequest::Wasm(WasmQuery::Smart { + contract_addr, + msg: Binary::from(r#"{"receive_external_query":{"num":25}}"#.as_bytes().to_vec()), + callback_code_hash: code_hash, + })); + + match answer { + Ok(wtf) => Ok(HandleResponse { + messages: vec![], + log: vec![log("wtf", wtf)], + data: None, + }), + Err(e) => Err(e), + } +} + +fn exec_callback_bad_params(contract_addr: HumanAddr, code_hash: String) -> HandleResponse { + HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: contract_addr.clone(), + callback_code_hash: code_hash, + msg: Binary::from(r#"{"c":{"x":"banana","y":3}}"#.as_bytes().to_vec()), + send: vec![], + })], + log: vec![], + data: None, + } +} + +pub fn a( + _deps: &mut Extern, + _env: Env, + contract_addr: HumanAddr, + code_hash: String, + x: u8, + y: u8, +) -> HandleResponse { + HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: contract_addr.clone(), + callback_code_hash: code_hash.clone(), + msg: Binary::from(format!( + "{{\"b\":{{\"x\":{} ,\"y\": {},\"contract_addr\": \"{}\",\"code_hash\": \"{}\" }}}}", + x, + y, + contract_addr.as_str(), + &code_hash + ) + .as_bytes() + .to_vec()), + send: vec![], + })], + log: vec![log("banana", "🍌")], + data: Some(Binary(vec![x, y])), + } +} + +pub fn b( + _deps: &mut Extern, + _env: Env, + contract_addr: HumanAddr, + code_hash: String, + x: u8, + y: u8, +) -> HandleResponse { + HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: contract_addr.clone(), + callback_code_hash: code_hash, + msg: Binary::from( + format!("{{\"c\":{{\"x\":{} ,\"y\": {} }}}}", x + 1, y + 1) + .as_bytes() + .to_vec(), + ), + send: vec![], + })], + log: vec![log("kiwi", "🥝")], + data: Some(Binary(vec![x + y])), + } +} + +pub fn c( + _deps: &mut Extern, + _env: Env, + x: u8, + y: u8, +) -> HandleResponse { + HandleResponse { + messages: vec![], + log: vec![log("watermelon", "🍉")], + data: Some(Binary(vec![x + y])), + } +} + +pub fn empty_log_key_value( + _deps: &mut Extern, + _env: Env, +) -> HandleResponse { + HandleResponse { + messages: vec![], + log: vec![log("my value is empty", ""), log("", "my key is empty")], + data: None, + } +} + +pub fn empty_data( + _deps: &mut Extern, + _env: Env, +) -> HandleResponse { + HandleResponse { + messages: vec![], + log: vec![], + data: Some(Binary(vec![])), + } +} + +pub fn unicode_data( + _deps: &mut Extern, + _env: Env, +) -> HandleResponse { + HandleResponse { + messages: vec![], + log: vec![], + data: Some(Binary("🍆🥑🍄".as_bytes().to_vec())), + } +} + +pub fn no_data( + _deps: &mut Extern, + _env: Env, +) -> HandleResponse { + HandleResponse { + messages: vec![], + log: vec![], + data: None, + } +} + +pub fn exec_callback_to_init( + _deps: &mut Extern, + _env: Env, + code_id: u64, + code_hash: String, +) -> HandleResponse { + HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Instantiate { + code_id, + msg: Binary::from("{\"nop\":{}}".as_bytes().to_vec()), + callback_code_hash: code_hash, + send: vec![], + label: String::from("hi"), + })], + log: vec![log("instantiating a new contract", "🪂")], + data: None, + } +} + +fn exec_with_callback_contract_error( + contract_addr: HumanAddr, + code_hash: String, +) -> HandleResponse { + HandleResponse { + messages: vec![CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: contract_addr.clone(), + callback_code_hash: code_hash, + msg: Binary::from( + r#"{"contract_error":{"error_type":"generic_err"}}"# + .as_bytes() + .to_vec(), + ), + send: vec![], + })], + log: vec![log("exec with a callback with contract error", "🤷‍♂️")], + data: None, + } +} + +fn allocate_on_heap(bytes: usize) -> HandleResponse { + let mut values: Box> = Box::new(vec![0; bytes]); + + values[bytes - 1] = 1; + + HandleResponse { + data: Some(Binary("😅".as_bytes().to_vec())), + log: vec![log("zero", format!("{}", values[bytes / 2]))], + messages: vec![], + } +} + +fn get_state( + deps: &mut Extern, + key: String, +) -> HandleResponse { + let store = PrefixedStorage::new(b"my_prefix", &mut deps.storage); + + match store.get(key.as_bytes()) { + Some(value) => HandleResponse { + data: Some(Binary(value)), + log: vec![], + messages: vec![], + }, + None => HandleResponse::default(), + } +} + +fn set_state( + deps: &mut Extern, + key: String, + value: String, +) -> HandleResponse { + let mut store = PrefixedStorage::new(b"my_prefix", &mut deps.storage); + store.set(key.as_bytes(), value.as_bytes()); + HandleResponse::default() +} + +fn remove_state( + deps: &mut Extern, + key: String, +) -> HandleResponse { + let mut store = PrefixedStorage::new(b"my_prefix", &mut deps.storage); + store.remove(key.as_bytes()); + HandleResponse::default() +} + +#[allow(invalid_value)] +#[allow(unused_must_use)] +fn pass_null_pointer_to_imports_should_throw( + deps: &mut Extern, + pass_type: String, +) -> HandleResponse { + let null_ptr_slice: &[u8] = unsafe { std::slice::from_raw_parts(std::ptr::null(), 0) }; + + let null_ptr: *const HumanAddr = std::ptr::null(); + let null_human_addr: &HumanAddr = unsafe { &*null_ptr }; + + let null_ptr: *const CanonicalAddr = std::ptr::null(); + let null_canon_addr: &CanonicalAddr = unsafe { &*null_ptr }; + + match &pass_type[..] { + "read_db_key" => { + deps.storage.get(null_ptr_slice); + } + "write_db_key" => { + deps.storage.set(null_ptr_slice, b"write value"); + } + "write_db_value" => { + deps.storage.set(b"write key", null_ptr_slice); + } + "remove_db_key" => { + deps.storage.remove(null_ptr_slice); + } + "canonicalize_address_input" => { + deps.api.canonical_address(null_human_addr); + } + "canonicalize_address_output" => { /* TODO */ } + "humanize_address_input" => { + deps.api.human_address(null_canon_addr); + } + "humanize_address_output" => { /* TODO */ } + _ => {} + }; + + HandleResponse::default() +} + +fn test_canonicalize_address_errors( + deps: &mut Extern, +) -> HandleResult { + match deps.api.canonical_address(&HumanAddr(String::from(""))) { + Err(StdError::GenericErr { msg, backtrace: _ }) => { + if msg != String::from("canonicalize_address errored: input is empty") { + return Err(StdError::generic_err( + "empty address should have failed with 'canonicalize_address errored: input is empty'", + )); + } + // all is good, continue + } + _ => return Err(StdError::generic_err( + "empty address should have failed with 'canonicalize_address errored: input is empty'", + )), + } + + match deps.api.canonical_address(&HumanAddr(String::from(" "))) { + Err(StdError::GenericErr { msg, backtrace: _ }) => { + if msg != String::from("canonicalize_address errored: input is empty") { + return Err(StdError::generic_err( + "empty trimmed address should have failed with 'canonicalize_address errored: input is empty'", + )); + } + // all is good, continue + } + _ => { + return Err(StdError::generic_err( + "empty trimmed address should have failed with 'canonicalize_address errored: input is empty'", + )) + } + } + + match deps + .api + .canonical_address(&HumanAddr(String::from("cosmos1h99hrcc54ms9lxxxx"))) + { + Err(StdError::GenericErr { msg, backtrace: _ }) => { + if msg != String::from("canonicalize_address errored: invalid checksum") { + return Err(StdError::generic_err( + "bad bech32 should have failed with 'canonicalize_address errored: invalid checksum'", + )); + } + // all is good, continue + } + _ => return Err(StdError::generic_err( + "bad bech32 should have failed with 'canonicalize_address errored: invalid checksum'", + )), + } + + match deps.api.canonical_address(&HumanAddr(String::from( + "cosmos1h99hrcc54ms9luwpex9kw0rwdt7etvfdyxh6gu", + ))) { + Err(StdError::GenericErr { msg, backtrace: _ }) => { + if msg != String::from("canonicalize_address errored: wrong address prefix: \"cosmos\"") + { + return Err(StdError::generic_err( + "bad prefix should have failed with 'canonicalize_address errored: wrong address prefix: \"cosmos\"'", + )); + } + // all is good, continue + } + _ => { + return Err(StdError::generic_err( + "bad prefix should have failed with 'canonicalize_address errored: wrong address prefix: \"cosmos\"'", + )) + } + } + + Ok(HandleResponse { + data: Some(Binary("🤟".as_bytes().to_vec())), + log: vec![], + messages: vec![], + }) +} + +/////////////////////////////// Query /////////////////////////////// + +pub fn query( + deps: &Extern, + _msg: QueryMsg, +) -> QueryResult { + match _msg { + QueryMsg::ContractError { error_type } => Err(map_string_to_error(error_type)), + QueryMsg::Panic {} => panic!("panic in query"), + QueryMsg::ReceiveExternalQuery { num } => { + Ok(Binary(serde_json_wasm::to_vec(&(num + 1)).unwrap())) + } + QueryMsg::SendExternalQueryInfiniteLoop { to, code_hash } => { + send_external_query_infinite_loop(deps, to, code_hash) + } + QueryMsg::WriteToStorage {} => write_to_storage_in_query(deps), + QueryMsg::RemoveFromStorage {} => remove_from_storage_in_query(deps), + QueryMsg::SendExternalQueryDepthCounter { + to, + depth, + code_hash, + } => Ok(to_binary(&send_external_query_depth_counter( + deps, to, depth, code_hash, + )) + .unwrap()), + QueryMsg::SendExternalQueryRecursionLimit { + to, + depth, + code_hash, + } => to_binary(&send_external_query_recursion_limit( + deps, to, depth, code_hash, + )?), + QueryMsg::CallToQuery { + addr, + code_hash, + msg, + } => { + let answer: u32 = deps + .querier + .query(&QueryRequest::Wasm(WasmQuery::Smart { + contract_addr: addr, + callback_code_hash: code_hash, + msg: Binary::from(msg.as_bytes().to_vec()), + })) + .map_err(|err| { + StdError::generic_err(format!("Got an error from query: {:?}", err)) + })?; + return Ok(to_binary(&answer)?); + } + QueryMsg::GetCountFromV1 {} => { + let count = count_read(&deps.storage).load()?; + + Ok(to_binary(&QueryRes::Get { count })?) + } + QueryMsg::Get {} => { + let count = count_read(&deps.storage).load()?; + + Ok(to_binary(&QueryRes::Get { count })?) + } + QueryMsg::GetContractVersion {} => { + let answer: u8 = 10; + return Ok(to_binary(&answer)?); + } + } +} + +fn send_external_query_infinite_loop( + deps: &Extern, + contract_addr: HumanAddr, + code_hash: String, +) -> QueryResult { + let answer = deps + .querier + .query::(&QueryRequest::Wasm(WasmQuery::Smart { + contract_addr: contract_addr.clone(), + callback_code_hash: code_hash.clone(), + msg: Binary::from( + format!( + r#"{{"send_external_query_infinite_loop":{{"to":"{}", "code_hash":"{}"}}}}"#, + contract_addr.clone().to_string(), + &code_hash + ) + .as_bytes() + .to_vec(), + ), + })); + + match answer { + Ok(wtf) => Ok(Binary(wtf.into())), + Err(e) => Err(e), + } +} + +fn write_to_storage_in_query( + deps: &Extern, +) -> StdResult { + #[allow(clippy::cast_ref_to_mut)] + let deps = unsafe { &mut *(deps as *const _ as *mut Extern) }; + deps.storage.set(b"abcd", b"dcba"); + + Ok(Binary(vec![])) +} + +fn remove_from_storage_in_query( + deps: &Extern, +) -> StdResult { + #[allow(clippy::cast_ref_to_mut)] + let deps = unsafe { &mut *(deps as *const _ as *mut Extern) }; + deps.storage.remove(b"abcd"); + + Ok(Binary(vec![])) +} diff --git a/cosmwasm/contracts/v010/compute-tests/test-compute-contract/rust-toolchain b/cosmwasm/contracts/v010/compute-tests/test-compute-contract/rust-toolchain new file mode 100644 index 000000000..650b514e6 --- /dev/null +++ b/cosmwasm/contracts/v010/compute-tests/test-compute-contract/rust-toolchain @@ -0,0 +1 @@ +1.71 \ No newline at end of file diff --git a/cosmwasm/contracts/v010/compute-tests/test-compute-contract/src/contract.rs b/cosmwasm/contracts/v010/compute-tests/test-compute-contract/src/contract.rs index 74a1ce0e6..f86a25543 100644 --- a/cosmwasm/contracts/v010/compute-tests/test-compute-contract/src/contract.rs +++ b/cosmwasm/contracts/v010/compute-tests/test-compute-contract/src/contract.rs @@ -1,19 +1,19 @@ use cosmwasm_storage::{PrefixedStorage, ReadonlySingleton, Singleton}; use cosmwasm_std::{ - log, plaintext_log, to_binary, Api, BankMsg, Binary, Coin, CosmosMsg, Empty, Env, Extern, - HandleResponse, HandleResult, HumanAddr, InitResponse, InitResult, Querier, QueryRequest, - QueryResult, ReadonlyStorage, StdError, StdResult, Storage, Uint128, WasmMsg, WasmQuery, + log, plaintext_log, to_binary, Api, BankMsg, Binary, CanonicalAddr, Coin, CosmosMsg, Empty, + Env, Extern, HandleResponse, HandleResult, HumanAddr, InitResponse, InitResult, Querier, + QueryRequest, QueryResult, ReadonlyStorage, StdError, StdResult, Storage, Uint128, WasmMsg, + WasmQuery, }; use secp256k1::Secp256k1; /////////////////////////////// Messages /////////////////////////////// use core::time; -use mem::MaybeUninit; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; -use std::{mem, thread}; +use std::thread; //// consts @@ -1644,12 +1644,13 @@ fn exec_with_callback_contract_error( } fn allocate_on_heap(bytes: usize) -> HandleResponse { - let mut values: Vec = vec![0; bytes]; + let mut values: Box> = Box::new(vec![0; bytes]); + values[bytes - 1] = 1; HandleResponse { data: Some(Binary("😅".as_bytes().to_vec())), - log: vec![], + log: vec![log("zero", format!("{}", values[bytes / 2]))], messages: vec![], } } @@ -1695,7 +1696,13 @@ fn pass_null_pointer_to_imports_should_throw( deps: &mut Extern, pass_type: String, ) -> HandleResponse { - let null_ptr_slice: &[u8] = unsafe { MaybeUninit::zeroed().assume_init() }; + let null_ptr_slice: &[u8] = unsafe { std::slice::from_raw_parts(std::ptr::null(), 0) }; + + let null_ptr: *const HumanAddr = std::ptr::null(); + let null_human_addr: &HumanAddr = unsafe { &*null_ptr }; + + let null_ptr: *const CanonicalAddr = std::ptr::null(); + let null_canon_addr: &CanonicalAddr = unsafe { &*null_ptr }; match &pass_type[..] { "read_db_key" => { @@ -1711,13 +1718,11 @@ fn pass_null_pointer_to_imports_should_throw( deps.storage.remove(null_ptr_slice); } "canonicalize_address_input" => { - deps.api - .canonical_address(unsafe { MaybeUninit::zeroed().assume_init() }); + deps.api.canonical_address(null_human_addr); } "canonicalize_address_output" => { /* TODO */ } "humanize_address_input" => { - deps.api - .human_address(unsafe { MaybeUninit::zeroed().assume_init() }); + deps.api.human_address(null_canon_addr); } "humanize_address_output" => { /* TODO */ } _ => {} diff --git a/cosmwasm/contracts/v1/compute-tests/random-test/Cargo.lock b/cosmwasm/contracts/v1/compute-tests/random-test/Cargo.lock index 543f0beff..72c9eb427 100644 --- a/cosmwasm/contracts/v1/compute-tests/random-test/Cargo.lock +++ b/cosmwasm/contracts/v1/compute-tests/random-test/Cargo.lock @@ -2,6 +2,17 @@ # It is not intended for manual editing. version = 3 +[[package]] +name = "ahash" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47" +dependencies = [ + "getrandom", + "once_cell", + "version_check", +] + [[package]] name = "base16ct" version = "0.1.1" @@ -10,15 +21,15 @@ checksum = "349a06037c7bf932dd7e7d1f653678b2038b9ad46a74102f1fc7bd7872678cce" [[package]] name = "base64" -version = "0.13.0" +version = "0.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd" +checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" [[package]] name = "base64ct" -version = "1.5.1" +version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3bdca834647821e0b13d9539a8634eb62d3501b6b6c2cec1722786ee6671b851" +checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b" [[package]] name = "block-buffer" @@ -29,6 +40,15 @@ dependencies = [ "generic-array", ] +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + [[package]] name = "byteorder" version = "1.4.3" @@ -43,23 +63,23 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" [[package]] name = "const-oid" -version = "0.7.1" +version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e4c78c047431fee22c1a7bb92e00ad095a02a983affe4d8a72e2a2c62c1b94f3" +checksum = "795bc6e66a8e340f075fcf6227e417a2dc976b92b91f3cdc778bb858778b6747" [[package]] name = "cosmwasm-derive" -version = "1.0.0" -source = "git+https://github.com/scrtlabs/cosmwasm?rev=8ee395ba033c392d7170c971df97f085edaed2d9#8ee395ba033c392d7170c971df97f085edaed2d9" +version = "1.1.10" +source = "git+https://github.com/scrtlabs/cosmwasm?rev=b46529a2#b46529a2a7e4b595b39722e09ef5cd8b5a60443f" dependencies = [ - "syn", + "syn 1.0.109", ] [[package]] name = "cpufeatures" -version = "0.2.2" +version = "0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59a6001667ab124aebae2a495118e11d30984c3a653e99d86d58971708cf5e4b" +checksum = "a17b76ff3a4162b0b27f354a0c87015ddad39d35f9c0c36607a3bdd175dde1f1" dependencies = [ "libc", ] @@ -72,24 +92,24 @@ checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" [[package]] name = "crypto-bigint" -version = "0.3.2" +version = "0.4.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "03c6a1d5fa1de37e071642dfa44ec552ca5b299adb128fab16138e24b548fd21" +checksum = "ef2b4b23cddf68b89b8f8069890e8c270d54e2d5fe1b143820234805e4cb17ef" dependencies = [ "generic-array", - "rand_core 0.6.3", + "rand_core 0.6.4", "subtle", "zeroize", ] [[package]] -name = "crypto-mac" -version = "0.11.1" +name = "crypto-common" +version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714" +checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" dependencies = [ "generic-array", - "subtle", + "typenum", ] [[package]] @@ -99,7 +119,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61" dependencies = [ "byteorder", - "digest", + "digest 0.9.0", "rand_core 0.5.1", "subtle", "zeroize", @@ -107,11 +127,23 @@ dependencies = [ [[package]] name = "der" -version = "0.5.1" +version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6919815d73839e7ad218de758883aae3a257ba6759ce7a9992501efbb53d705c" +checksum = "f1a467a65c5e759bce6e65eaf91cc29f466cdc57cb65777bd646872a8a1fd4de" dependencies = [ "const-oid", + "zeroize", +] + +[[package]] +name = "derivative" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", ] [[package]] @@ -123,17 +155,28 @@ dependencies = [ "generic-array", ] +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer 0.10.4", + "crypto-common", + "subtle", +] + [[package]] name = "dyn-clone" -version = "1.0.8" +version = "1.0.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d07a982d1fb29db01e5a59b1918e03da4df7297eaeee7686ac45542fd4e59c8" +checksum = "304e6508efa593091e97a9abbc10f90aa7ca635b6d2784feff3c89d41dd12272" [[package]] name = "ecdsa" -version = "0.13.4" +version = "0.14.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d0d69ae62e0ce582d56380743515fefaf1a8c70cec685d9677636d7e30ae9dc9" +checksum = "413301934810f597c1d19ca71c8710e99a3f1ba28a0d2ebc01551a2daeea3c5c" dependencies = [ "der", "elliptic-curve", @@ -143,32 +186,34 @@ dependencies = [ [[package]] name = "ed25519-zebra" -version = "3.0.0" +version = "3.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "403ef3e961ab98f0ba902771d29f842058578bb1ce7e3c59dad5a6a93e784c69" +checksum = "7c24f403d068ad0b359e577a77f92392118be3f3c927538f2bb544a5ecd828c6" dependencies = [ "curve25519-dalek", + "hashbrown", "hex", - "rand_core 0.6.3", + "rand_core 0.6.4", "serde", - "sha2", - "thiserror", + "sha2 0.9.9", "zeroize", ] [[package]] name = "elliptic-curve" -version = "0.11.12" +version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25b477563c2bfed38a3b7a60964c49e058b2510ad3f12ba3483fd8f62c2306d6" +checksum = "e7bb888ab5300a19b8e5bceef25ac745ad065f3c9f7efc6de1b91958110891d3" dependencies = [ "base16ct", "crypto-bigint", "der", + "digest 0.10.7", "ff", "generic-array", "group", - "rand_core 0.6.3", + "pkcs8", + "rand_core 0.6.4", "sec1", "subtle", "zeroize", @@ -176,11 +221,11 @@ dependencies = [ [[package]] name = "ff" -version = "0.11.1" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "131655483be284720a17d74ff97592b8e76576dc25563148601df2d7c9080924" +checksum = "d013fc25338cc558c5c2cfbad646908fb23591e2404481826742b651c9af7160" dependencies = [ - "rand_core 0.6.3", + "rand_core 0.6.4", "subtle", ] @@ -192,9 +237,9 @@ checksum = "c8cbd1169bd7b4a0a20d92b9af7a7e0422888bd38a6f5ec29c1fd8c1558a272e" [[package]] name = "generic-array" -version = "0.14.5" +version = "0.14.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fd48d33ec7f05fbfa152300fdad764757cbded343c1aa1cff2fbaf4134851803" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" dependencies = [ "typenum", "version_check", @@ -202,35 +247,33 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.1.16" +version = "0.2.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce" +checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427" dependencies = [ "cfg-if", "libc", - "wasi 0.9.0+wasi-snapshot-preview1", + "wasi", ] [[package]] -name = "getrandom" -version = "0.2.7" +name = "group" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4eb1a864a501629691edf6c15a593b7a51eebaa1e8468e9ddc623de7c9b58ec6" +checksum = "5dfbfb3a6cfbd390d5c9564ab283a0349b9b9fcd46a706c1eb10e0db70bfbac7" dependencies = [ - "cfg-if", - "libc", - "wasi 0.11.0+wasi-snapshot-preview1", + "ff", + "rand_core 0.6.4", + "subtle", ] [[package]] -name = "group" -version = "0.11.0" +name = "hashbrown" +version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc5ac374b108929de78460075f3dc439fa66df9d8fc77e8f12caa5165fcf0c89" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" dependencies = [ - "ff", - "rand_core 0.6.3", - "subtle", + "ahash", ] [[package]] @@ -241,38 +284,42 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" [[package]] name = "hmac" -version = "0.11.0" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" dependencies = [ - "crypto-mac", - "digest", + "digest 0.10.7", ] [[package]] name = "itoa" -version = "1.0.2" +version = "1.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "112c678d4050afce233f4f2852bb2eb519230b3cf12f33585275537d7e41578d" +checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38" [[package]] name = "k256" -version = "0.10.4" +version = "0.11.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19c3a5e0a0b8450278feda242592512e09f61c72e018b8cd5c859482802daf2d" +checksum = "72c1e0b51e7ec0a97369623508396067a486bd0cbed95a2659a4b863d28cfc8b" dependencies = [ "cfg-if", "ecdsa", "elliptic-curve", - "sec1", - "sha2", + "sha2 0.10.7", ] [[package]] name = "libc" -version = "0.2.126" +version = "0.2.147" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836" +checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3" + +[[package]] +name = "once_cell" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d" [[package]] name = "opaque-debug" @@ -282,29 +329,28 @@ checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" [[package]] name = "pkcs8" -version = "0.8.0" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7cabda3fb821068a9a4fab19a683eac3af12edf0f34b94a8be53c4972b8149d0" +checksum = "9eca2c590a5f85da82668fa685c09ce2888b9430e83299debf1f34b65fd4a4ba" dependencies = [ "der", "spki", - "zeroize", ] [[package]] name = "proc-macro2" -version = "1.0.42" +version = "1.0.66" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c278e965f1d8cf32d6e0e96de3d3e79712178ae67986d9cf9151f51e95aac89b" +checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.20" +version = "1.0.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3bcdf212e9776fbcb2d23ab029360416bb1706b1aea2d1a5ba002727cbcab804" +checksum = "50f3b39ccfb720540debaa0164757101c08ecb8d326b15358ce76a62c7e85965" dependencies = [ "proc-macro2", ] @@ -314,24 +360,21 @@ name = "rand_core" version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" -dependencies = [ - "getrandom 0.1.16", -] [[package]] name = "rand_core" -version = "0.6.3" +version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" dependencies = [ - "getrandom 0.2.7", + "getrandom", ] [[package]] name = "rfc6979" -version = "0.1.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96ef608575f6392792f9ecf7890c00086591d29a83910939d430753f7c050525" +checksum = "7743f17af12fa0b03b803ba12cd6a8d9483a587e89c69445e3909655c0b9fabb" dependencies = [ "crypto-bigint", "hmac", @@ -340,15 +383,15 @@ dependencies = [ [[package]] name = "ryu" -version = "1.0.10" +version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3f6f92acf49d1b98f7a81226834412ada05458b7364277387724a237f062695" +checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741" [[package]] name = "schemars" -version = "0.8.10" +version = "0.8.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1847b767a3d62d95cbf3d8a9f0e421cf57a0d8aa4f411d4b16525afb0284d4ed" +checksum = "02c613288622e5f0c3fdc5dbd4db1c5fbe752746b1d1a56a0630b78fd00de44f" dependencies = [ "dyn-clone", "schemars_derive", @@ -358,22 +401,23 @@ dependencies = [ [[package]] name = "schemars_derive" -version = "0.8.10" +version = "0.8.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af4d7e1b012cb3d9129567661a63755ea4b8a7386d339dc945ae187e403c6743" +checksum = "109da1e6b197438deb6db99952990c7f959572794b80ff93707d55a232545e7c" dependencies = [ "proc-macro2", "quote", "serde_derive_internals", - "syn", + "syn 1.0.109", ] [[package]] name = "sec1" -version = "0.2.1" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08da66b8b0965a5555b6bd6639e68ccba85e1e2506f5fbb089e93f8a04e1a2d1" +checksum = "3be24c1842290c45df0a7bf069e0c268a747ad05a192f2fd7dcfdbc1cba40928" dependencies = [ + "base16ct", "der", "generic-array", "pkcs8", @@ -383,24 +427,26 @@ dependencies = [ [[package]] name = "secret-cosmwasm-crypto" -version = "1.0.0" -source = "git+https://github.com/scrtlabs/cosmwasm?rev=8ee395ba033c392d7170c971df97f085edaed2d9#8ee395ba033c392d7170c971df97f085edaed2d9" +version = "1.1.10" +source = "git+https://github.com/scrtlabs/cosmwasm?rev=b46529a2#b46529a2a7e4b595b39722e09ef5cd8b5a60443f" dependencies = [ - "digest", + "digest 0.10.7", "ed25519-zebra", "k256", - "rand_core 0.6.3", + "rand_core 0.6.4", "thiserror", ] [[package]] name = "secret-cosmwasm-std" -version = "1.0.0" -source = "git+https://github.com/scrtlabs/cosmwasm?rev=8ee395ba033c392d7170c971df97f085edaed2d9#8ee395ba033c392d7170c971df97f085edaed2d9" +version = "1.1.10" +source = "git+https://github.com/scrtlabs/cosmwasm?rev=b46529a2#b46529a2a7e4b595b39722e09ef5cd8b5a60443f" dependencies = [ "base64", "cosmwasm-derive", + "derivative", "forward_ref", + "hex", "schemars", "secret-cosmwasm-crypto", "serde", @@ -411,8 +457,8 @@ dependencies = [ [[package]] name = "secret-cosmwasm-storage" -version = "1.0.0" -source = "git+https://github.com/scrtlabs/cosmwasm?rev=8ee395ba033c392d7170c971df97f085edaed2d9#8ee395ba033c392d7170c971df97f085edaed2d9" +version = "1.1.10" +source = "git+https://github.com/scrtlabs/cosmwasm?rev=b46529a2#b46529a2a7e4b595b39722e09ef5cd8b5a60443f" dependencies = [ "secret-cosmwasm-std", "serde", @@ -420,9 +466,9 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.140" +version = "1.0.180" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc855a42c7967b7c369eb5860f7164ef1f6f81c20c7cc1141f2a604e18723b03" +checksum = "0ea67f183f058fe88a4e3ec6e2788e003840893b91bac4559cabedd00863b3ed" dependencies = [ "serde_derive", ] @@ -447,13 +493,13 @@ dependencies = [ [[package]] name = "serde_derive" -version = "1.0.140" +version = "1.0.180" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f2122636b9fe3b81f1cb25099fcf2d3f542cdb1d45940d56c713158884a05da" +checksum = "24e744d7782b686ab3b73267ef05697159cc0e5abbed3f47f9933165e5219036" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.28", ] [[package]] @@ -464,14 +510,14 @@ checksum = "85bf8229e7920a9f636479437026331ce11aa132b4dde37d121944a44d6e5f3c" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 1.0.109", ] [[package]] name = "serde_json" -version = "1.0.82" +version = "1.0.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "82c2c1fdcd807d1098552c5b9a36e425e42e9fbd7c6a37a8425f390f781f7fa7" +checksum = "076066c5f1078eac5b722a31827a8832fe108bed65dfa75e233c89f8206e976c" dependencies = [ "itoa", "ryu", @@ -484,28 +530,39 @@ version = "0.9.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800" dependencies = [ - "block-buffer", + "block-buffer 0.9.0", "cfg-if", "cpufeatures", - "digest", + "digest 0.9.0", "opaque-debug", ] +[[package]] +name = "sha2" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479fb9d862239e610720565ca91403019f2f00410f1864c5aa7479b950a76ed8" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest 0.10.7", +] + [[package]] name = "signature" -version = "1.4.0" +version = "1.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02658e48d89f2bec991f9a78e69cfa4c316f8d6a6c4ec12fae1aeb263d486788" +checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c" dependencies = [ - "digest", - "rand_core 0.6.3", + "digest 0.10.7", + "rand_core 0.6.4", ] [[package]] name = "spki" -version = "0.5.4" +version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44d01ac02a6ccf3e07db148d2be087da624fea0221a16152ed01f0496a6b0a27" +checksum = "67cf02bbac7a337dc36e4f5a693db6c21e7863f45070f7064577eb4367a3212b" dependencies = [ "base64ct", "der", @@ -519,15 +576,26 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" [[package]] name = "subtle" -version = "2.4.1" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc" + +[[package]] +name = "syn" +version = "1.0.109" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] [[package]] name = "syn" -version = "1.0.98" +version = "2.0.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c50aef8a904de4c23c788f104b7dddc7d6f79c647c7c8ce4cc8f73eb0ca773dd" +checksum = "04361975b3f5e348b2189d8dc55bc942f278b2d482a6a0365de5bdd62d351567" dependencies = [ "proc-macro2", "quote", @@ -536,35 +604,35 @@ dependencies = [ [[package]] name = "thiserror" -version = "1.0.31" +version = "1.0.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd829fe32373d27f76265620b5309d0340cb8550f523c1dda251d6298069069a" +checksum = "611040a08a0439f8248d1990b111c95baa9c704c805fa1f62104b39655fd7f90" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.31" +version = "1.0.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0396bc89e626244658bef819e22d0cc459e795a5ebe878e6ec336d1674a8d79a" +checksum = "090198534930841fab3a5d1bb637cde49e339654e606195f8d9c76eeb081dc96" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.28", ] [[package]] name = "typenum" -version = "1.15.0" +version = "1.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987" +checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba" [[package]] name = "uint" -version = "0.9.3" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "12f03af7ccf01dd611cc450a0d10dbc9b745770d096473e2faf0ca6e2d66d1e0" +checksum = "76f64bba2c53b04fcab63c01a7d7427eadc821e3bc48c34dc9ba29c501164b52" dependencies = [ "byteorder", "crunchy", @@ -574,9 +642,9 @@ dependencies = [ [[package]] name = "unicode-ident" -version = "1.0.2" +version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15c61ba63f9235225a22310255a29b806b907c9b8c964bcbd0a2c70f3f2deea7" +checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c" [[package]] name = "v1-random-test" @@ -595,12 +663,6 @@ version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" -[[package]] -name = "wasi" -version = "0.9.0+wasi-snapshot-preview1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" - [[package]] name = "wasi" version = "0.11.0+wasi-snapshot-preview1" @@ -609,6 +671,6 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" [[package]] name = "zeroize" -version = "1.5.7" +version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c394b5bd0c6f669e7275d9c20aa90ae064cb22e75a1cad54e1b34088034b149f" +checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9" diff --git a/cosmwasm/contracts/v1/compute-tests/random-test/Cargo.toml b/cosmwasm/contracts/v1/compute-tests/random-test/Cargo.toml index 093f28e4a..dc4e91a74 100644 --- a/cosmwasm/contracts/v1/compute-tests/random-test/Cargo.toml +++ b/cosmwasm/contracts/v1/compute-tests/random-test/Cargo.toml @@ -30,10 +30,10 @@ default = [] backtraces = ["cosmwasm-std/backtraces"] [dependencies] -cosmwasm-std = { git = "https://github.com/scrtlabs/cosmwasm", rev = "8ee395ba033c392d7170c971df97f085edaed2d9", package = "secret-cosmwasm-std", features = [ +cosmwasm-std = { git = "https://github.com/scrtlabs/cosmwasm", rev = "b46529a2", package = "secret-cosmwasm-std", features = [ "random" ] } -cosmwasm-storage = { git = "https://github.com/scrtlabs/cosmwasm", rev = "8ee395ba033c392d7170c971df97f085edaed2d9", package = "secret-cosmwasm-storage" } +cosmwasm-storage = { git = "https://github.com/scrtlabs/cosmwasm", rev = "b46529a2", package = "secret-cosmwasm-storage" } schemars = "0.8.1" serde = { version = "1.0.114", default-features = false, features = [ "derive", diff --git a/cosmwasm/contracts/v1/compute-tests/random-test/Makefile b/cosmwasm/contracts/v1/compute-tests/random-test/Makefile index 5bbfc2dcb..8b5290532 100644 --- a/cosmwasm/contracts/v1/compute-tests/random-test/Makefile +++ b/cosmwasm/contracts/v1/compute-tests/random-test/Makefile @@ -1,7 +1,8 @@ -all: src/contract.rs src src src Cargo.toml Cargo.lock +all: src/contract.rs src Cargo.toml Cargo.lock rustup target add wasm32-unknown-unknown RUSTFLAGS='-C link-arg=-s' cargo build --release --target wasm32-unknown-unknown - cp ./target/wasm32-unknown-unknown/release/v1_random_test.wasm ./v1_random_test.wasm + rm -f ./v1_random_test.wasm + mv -f ./target/wasm32-unknown-unknown/release/v1_random_test.wasm ./v1_random_test.wasm clean: cargo clean diff --git a/cosmwasm/contracts/v1/compute-tests/random-test/rust-toolchain b/cosmwasm/contracts/v1/compute-tests/random-test/rust-toolchain index a7efc46ca..650b514e6 100644 --- a/cosmwasm/contracts/v1/compute-tests/random-test/rust-toolchain +++ b/cosmwasm/contracts/v1/compute-tests/random-test/rust-toolchain @@ -1 +1 @@ -1.61 \ No newline at end of file +1.71 \ No newline at end of file diff --git a/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/Cargo.lock b/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/Cargo.lock index 9179d4fc1..1d81f0040 100644 --- a/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/Cargo.lock +++ b/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/Cargo.lock @@ -86,7 +86,7 @@ checksum = "520fbf3c07483f94e3e3ca9d0cfd913d7718ef2483d2cfd91c0d9e91474ab913" [[package]] name = "cosmwasm-derive" version = "1.1.10" -source = "git+https://github.com/scrtlabs/cosmwasm?rev=c6c5ee77#c6c5ee775f7656d12196bd1acfb7cb9e26aa75d6" +source = "git+https://github.com/scrtlabs/cosmwasm?rev=b46529a2#b46529a2a7e4b595b39722e09ef5cd8b5a60443f" dependencies = [ "syn 1.0.109", ] @@ -462,7 +462,7 @@ dependencies = [ [[package]] name = "secret-cosmwasm-crypto" version = "1.1.10" -source = "git+https://github.com/scrtlabs/cosmwasm?rev=c6c5ee77#c6c5ee775f7656d12196bd1acfb7cb9e26aa75d6" +source = "git+https://github.com/scrtlabs/cosmwasm?rev=b46529a2#b46529a2a7e4b595b39722e09ef5cd8b5a60443f" dependencies = [ "digest 0.10.7", "ed25519-zebra", @@ -474,7 +474,7 @@ dependencies = [ [[package]] name = "secret-cosmwasm-std" version = "1.1.10" -source = "git+https://github.com/scrtlabs/cosmwasm?rev=c6c5ee77#c6c5ee775f7656d12196bd1acfb7cb9e26aa75d6" +source = "git+https://github.com/scrtlabs/cosmwasm?rev=b46529a2#b46529a2a7e4b595b39722e09ef5cd8b5a60443f" dependencies = [ "base64", "cosmwasm-derive", @@ -492,7 +492,7 @@ dependencies = [ [[package]] name = "secret-cosmwasm-storage" version = "1.1.10" -source = "git+https://github.com/scrtlabs/cosmwasm?rev=c6c5ee77#c6c5ee775f7656d12196bd1acfb7cb9e26aa75d6" +source = "git+https://github.com/scrtlabs/cosmwasm?rev=b46529a2#b46529a2a7e4b595b39722e09ef5cd8b5a60443f" dependencies = [ "secret-cosmwasm-std", "serde", diff --git a/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/Cargo.toml b/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/Cargo.toml index 32f80532c..52741faf9 100644 --- a/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/Cargo.toml +++ b/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/Cargo.toml @@ -27,14 +27,13 @@ overflow-checks = true [features] default = [] -backtraces = ["cosmwasm-std/backtraces"] with_floats = [] [dependencies] -cosmwasm-std = { git = "https://github.com/scrtlabs/cosmwasm", rev = "c6c5ee77", package = "secret-cosmwasm-std", features = [ +cosmwasm-std = { git = "https://github.com/scrtlabs/cosmwasm", rev = "b46529a2", package = "secret-cosmwasm-std", features = [ "random" ] } -cosmwasm-storage = { git = "https://github.com/scrtlabs/cosmwasm", rev = "c6c5ee77", package = "secret-cosmwasm-storage" } +cosmwasm-storage = { git = "https://github.com/scrtlabs/cosmwasm", rev = "b46529a2", package = "secret-cosmwasm-storage" } schemars = "0.8.1" serde = { version = "1.0.114", default-features = false, features = [ "derive", diff --git a/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/rust-toolchain b/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/rust-toolchain index a7efc46ca..650b514e6 100644 --- a/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/rust-toolchain +++ b/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/rust-toolchain @@ -1 +1 @@ -1.61 \ No newline at end of file +1.71 \ No newline at end of file diff --git a/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/src/contract.rs b/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/src/contract.rs index 3f5128661..902a04a2a 100644 --- a/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/src/contract.rs +++ b/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/src/contract.rs @@ -1,11 +1,10 @@ use core::time; -use mem::MaybeUninit; -use std::{mem, thread, vec}; +use std::{thread, vec}; use cosmwasm_std::{ attr, coins, entry_point, to_binary, BankMsg, Binary, CosmosMsg, Deps, DepsMut, Empty, Env, Event, MessageInfo, QueryRequest, Reply, ReplyOn, Response, StdError, StdResult, Storage, - SubMsg, SubMsgResult, WasmMsg, WasmQuery, from_binary, SubMsgResponse, + SubMsg, SubMsgResult, WasmMsg, WasmQuery, from_binary, SubMsgResponse, CanonicalAddr, }; use cosmwasm_storage::PrefixedStorage; use secp256k1::Secp256k1; @@ -343,6 +342,9 @@ pub fn instantiate( Ok(Response::new()) } + InstantiateMsg::TxHash { } => Ok(Response::new().add_attributes(vec![ + ("txhash", env.transaction.unwrap().hash), + ])), } } @@ -1393,6 +1395,9 @@ pub fn execute(deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg) -> S ), } ExecuteMsg::Echo { data } => Ok(Response::new().set_data(data)), + ExecuteMsg::TxHash { } => Ok(Response::new().add_attributes(vec![ + ("txhash", env.transaction.unwrap().hash), + ])), } } @@ -2660,10 +2665,11 @@ fn exec_with_callback_contract_error(contract_addr: String, code_hash: String) - } fn allocate_on_heap(bytes: usize) -> Response { - let mut values: Vec = vec![0; bytes]; + let mut values: Box> = Box::new(vec![0; bytes]); + values[bytes - 1] = 1; - Response::new().set_data("😅".as_bytes().to_vec()) + Response::new().set_data("😅".as_bytes().to_vec()).add_attribute("zero", format!("{}", values[bytes / 2])) } fn get_state(deps: DepsMut, key: String) -> Response { @@ -2690,7 +2696,12 @@ fn remove_state(deps: DepsMut, key: String) -> Response { #[allow(invalid_value)] #[allow(unused_must_use)] fn pass_null_pointer_to_imports_should_throw(deps: DepsMut, pass_type: String) -> Response { - let null_ptr_slice: &[u8] = unsafe { MaybeUninit::zeroed().assume_init() }; + let null_ptr_slice: &[u8] = unsafe { std::slice::from_raw_parts(std::ptr::null(), 0) }; + + let null_human_addr: &str = unsafe{ std::str::from_utf8_unchecked(null_ptr_slice) }; + + let null_ptr: *const CanonicalAddr = std::ptr::null(); + let null_canon_addr: &CanonicalAddr = unsafe { &*null_ptr }; match &pass_type[..] { "read_db_key" => { @@ -2707,17 +2718,17 @@ fn pass_null_pointer_to_imports_should_throw(deps: DepsMut, pass_type: String) - } "canonicalize_address_input" => { deps.api - .addr_canonicalize(unsafe { MaybeUninit::zeroed().assume_init() }); + .addr_canonicalize(null_human_addr); } "canonicalize_address_output" => { /* TODO */ } "humanize_address_input" => { deps.api - .addr_humanize(unsafe { MaybeUninit::zeroed().assume_init() }); + .addr_humanize(null_canon_addr); } "humanize_address_output" => { /* TODO */ } "validate_address_input" => { deps.api - .addr_validate(unsafe { MaybeUninit::zeroed().assume_init() }); + .addr_validate(null_human_addr); } "validate_address_output" => { /* TODO */ } _ => {} @@ -3868,6 +3879,9 @@ pub fn migrate(deps: DepsMut, env: Env, msg: ExecuteMsg) -> StdResult ), } ExecuteMsg::Echo { data } => Ok(Response::new().set_data(data)), + ExecuteMsg::TxHash { } => Ok(Response::new().add_attributes(vec![ + ("txhash", env.transaction.unwrap().hash), + ])), } } diff --git a/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/src/msg.rs b/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/src/msg.rs index 7a0463fe2..1ee4b6ba4 100644 --- a/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/src/msg.rs +++ b/cosmwasm/contracts/v1/compute-tests/test-compute-contract-v2/src/msg.rs @@ -110,6 +110,7 @@ pub enum InstantiateMsg { }, GetEnv {}, TestRemoveDb {}, + TxHash {}, } #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] @@ -446,6 +447,7 @@ pub enum ExecuteMsg { Echo { data: Binary, }, + TxHash {}, } #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)] diff --git a/cosmwasm/contracts/v1/compute-tests/test-compute-contract/Cargo.lock b/cosmwasm/contracts/v1/compute-tests/test-compute-contract/Cargo.lock index fc0ba771f..4e191ac78 100644 --- a/cosmwasm/contracts/v1/compute-tests/test-compute-contract/Cargo.lock +++ b/cosmwasm/contracts/v1/compute-tests/test-compute-contract/Cargo.lock @@ -86,7 +86,7 @@ checksum = "520fbf3c07483f94e3e3ca9d0cfd913d7718ef2483d2cfd91c0d9e91474ab913" [[package]] name = "cosmwasm-derive" version = "1.1.10" -source = "git+https://github.com/scrtlabs/cosmwasm?rev=c6c5ee77#c6c5ee775f7656d12196bd1acfb7cb9e26aa75d6" +source = "git+https://github.com/scrtlabs/cosmwasm?rev=b46529a2#b46529a2a7e4b595b39722e09ef5cd8b5a60443f" dependencies = [ "syn 1.0.109", ] @@ -462,7 +462,7 @@ dependencies = [ [[package]] name = "secret-cosmwasm-crypto" version = "1.1.10" -source = "git+https://github.com/scrtlabs/cosmwasm?rev=c6c5ee77#c6c5ee775f7656d12196bd1acfb7cb9e26aa75d6" +source = "git+https://github.com/scrtlabs/cosmwasm?rev=b46529a2#b46529a2a7e4b595b39722e09ef5cd8b5a60443f" dependencies = [ "digest 0.10.6", "ed25519-zebra", @@ -474,7 +474,7 @@ dependencies = [ [[package]] name = "secret-cosmwasm-std" version = "1.1.10" -source = "git+https://github.com/scrtlabs/cosmwasm?rev=c6c5ee77#c6c5ee775f7656d12196bd1acfb7cb9e26aa75d6" +source = "git+https://github.com/scrtlabs/cosmwasm?rev=b46529a2#b46529a2a7e4b595b39722e09ef5cd8b5a60443f" dependencies = [ "base64", "cosmwasm-derive", @@ -492,7 +492,7 @@ dependencies = [ [[package]] name = "secret-cosmwasm-storage" version = "1.1.10" -source = "git+https://github.com/scrtlabs/cosmwasm?rev=c6c5ee77#c6c5ee775f7656d12196bd1acfb7cb9e26aa75d6" +source = "git+https://github.com/scrtlabs/cosmwasm?rev=b46529a2#b46529a2a7e4b595b39722e09ef5cd8b5a60443f" dependencies = [ "secret-cosmwasm-std", "serde", diff --git a/cosmwasm/contracts/v1/compute-tests/test-compute-contract/Cargo.toml b/cosmwasm/contracts/v1/compute-tests/test-compute-contract/Cargo.toml index f551c94a1..82d63b7f5 100644 --- a/cosmwasm/contracts/v1/compute-tests/test-compute-contract/Cargo.toml +++ b/cosmwasm/contracts/v1/compute-tests/test-compute-contract/Cargo.toml @@ -27,12 +27,11 @@ overflow-checks = true [features] default = [] -backtraces = ["cosmwasm-std/backtraces"] with_floats = [] [dependencies] -cosmwasm-std = { git = "https://github.com/scrtlabs/cosmwasm", rev = "c6c5ee77", package = "secret-cosmwasm-std" } -cosmwasm-storage = { git = "https://github.com/scrtlabs/cosmwasm", rev = "c6c5ee77", package = "secret-cosmwasm-storage" } +cosmwasm-std = { git = "https://github.com/scrtlabs/cosmwasm", rev = "b46529a2", package = "secret-cosmwasm-std" } +cosmwasm-storage = { git = "https://github.com/scrtlabs/cosmwasm", rev = "b46529a2", package = "secret-cosmwasm-storage" } schemars = "0.8.1" serde = { version = "1.0.114", default-features = false, features = [ "derive", diff --git a/cosmwasm/contracts/v1/compute-tests/test-compute-contract/rust-toolchain b/cosmwasm/contracts/v1/compute-tests/test-compute-contract/rust-toolchain index a7efc46ca..650b514e6 100644 --- a/cosmwasm/contracts/v1/compute-tests/test-compute-contract/rust-toolchain +++ b/cosmwasm/contracts/v1/compute-tests/test-compute-contract/rust-toolchain @@ -1 +1 @@ -1.61 \ No newline at end of file +1.71 \ No newline at end of file diff --git a/cosmwasm/contracts/v1/compute-tests/test-compute-contract/src/contract.rs b/cosmwasm/contracts/v1/compute-tests/test-compute-contract/src/contract.rs index 87e3c761a..cdf2dc04e 100644 --- a/cosmwasm/contracts/v1/compute-tests/test-compute-contract/src/contract.rs +++ b/cosmwasm/contracts/v1/compute-tests/test-compute-contract/src/contract.rs @@ -1,11 +1,10 @@ use core::time; -use mem::MaybeUninit; -use std::{mem, thread, vec}; +use std::{thread, vec}; use cosmwasm_std::{ attr, coins, entry_point, to_binary, BankMsg, Binary, CosmosMsg, Deps, DepsMut, Empty, Env, Event, MessageInfo, QueryRequest, Reply, ReplyOn, Response, StdError, StdResult, Storage, - SubMsg, SubMsgResponse, SubMsgResult, WasmMsg, WasmQuery, from_binary, + SubMsg, SubMsgResponse, SubMsgResult, WasmMsg, WasmQuery, from_binary, CanonicalAddr, }; use cosmwasm_storage::PrefixedStorage; use secp256k1::Secp256k1; @@ -2659,10 +2658,11 @@ fn exec_with_callback_contract_error(contract_addr: String, code_hash: String) - } fn allocate_on_heap(bytes: usize) -> Response { - let mut values: Vec = vec![0; bytes]; + let mut values: Box> = Box::new(vec![0; bytes]); + values[bytes - 1] = 1; - Response::new().set_data("😅".as_bytes().to_vec()) + Response::new().set_data("😅".as_bytes().to_vec()).add_attribute("zero", format!("{}", values[bytes / 2])) } fn get_state(deps: DepsMut, key: String) -> Response { @@ -2689,7 +2689,12 @@ fn remove_state(deps: DepsMut, key: String) -> Response { #[allow(invalid_value)] #[allow(unused_must_use)] fn pass_null_pointer_to_imports_should_throw(deps: DepsMut, pass_type: String) -> Response { - let null_ptr_slice: &[u8] = unsafe { MaybeUninit::zeroed().assume_init() }; + let null_ptr_slice: &[u8] = unsafe { std::slice::from_raw_parts(std::ptr::null(), 0) }; + + let null_human_addr: &str = unsafe{ std::str::from_utf8_unchecked(null_ptr_slice) }; + + let null_ptr: *const CanonicalAddr = std::ptr::null(); + let null_canon_addr: &CanonicalAddr = unsafe { &*null_ptr }; match &pass_type[..] { "read_db_key" => { @@ -2706,17 +2711,17 @@ fn pass_null_pointer_to_imports_should_throw(deps: DepsMut, pass_type: String) - } "canonicalize_address_input" => { deps.api - .addr_canonicalize(unsafe { MaybeUninit::zeroed().assume_init() }); + .addr_canonicalize(null_human_addr); } "canonicalize_address_output" => { /* TODO */ } "humanize_address_input" => { deps.api - .addr_humanize(unsafe { MaybeUninit::zeroed().assume_init() }); + .addr_humanize(null_canon_addr); } "humanize_address_output" => { /* TODO */ } "validate_address_input" => { deps.api - .addr_validate(unsafe { MaybeUninit::zeroed().assume_init() }); + .addr_validate(null_human_addr); } "validate_address_output" => { /* TODO */ } _ => {} diff --git a/cosmwasm/enclaves/Cargo.lock b/cosmwasm/enclaves/Cargo.lock index 2862ff0e3..5aad4ef6c 100644 --- a/cosmwasm/enclaves/Cargo.lock +++ b/cosmwasm/enclaves/Cargo.lock @@ -640,7 +640,7 @@ dependencies = [ "lazy_static", "log", "lru", - "parity-wasm", + "parity-wasm 0.45.0", "protobuf", "pwasm-utils", "rand_chacha", @@ -1154,6 +1154,12 @@ version = "0.41.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ddfc878dac00da22f8f61e7af3157988424567ab01d9920b962ef7dcbd7cd865" +[[package]] +name = "parity-wasm" +version = "0.45.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1ad0aff30c1da14b1254fcb2af73e1fa9a28670e584a626f53a369d0e157304" + [[package]] name = "paste" version = "1.0.11" @@ -1292,7 +1298,7 @@ checksum = "4f7a12f176deee919f4ba55326ee17491c8b707d0987aed822682c821b660192" dependencies = [ "byteorder", "log", - "parity-wasm", + "parity-wasm 0.41.0", ] [[package]] @@ -1491,7 +1497,7 @@ dependencies = [ "lazy_static", "log", "num-bigint", - "parity-wasm", + "parity-wasm 0.45.0", "pwasm-utils", "rustls", "serde 1.0.118", @@ -2091,7 +2097,7 @@ dependencies = [ "memory_units", "num-rational", "num-traits 0.2.15", - "parity-wasm", + "parity-wasm 0.41.0", "wasmi-validation", ] @@ -2100,7 +2106,7 @@ name = "wasmi-validation" version = "0.3.0" source = "git+https://github.com/paritytech/wasmi?rev=84d2764594d80425373bf4949a58fa3df3d624c3#84d2764594d80425373bf4949a58fa3df3d624c3" dependencies = [ - "parity-wasm", + "parity-wasm 0.41.0", ] [[package]] diff --git a/cosmwasm/enclaves/execute/Cargo.toml b/cosmwasm/enclaves/execute/Cargo.toml index d12896565..5bbca306e 100644 --- a/cosmwasm/enclaves/execute/Cargo.toml +++ b/cosmwasm/enclaves/execute/Cargo.toml @@ -69,7 +69,9 @@ serde_json = { git = "https://github.com/mesalock-linux/serde-json-sgx" } ctor = "0.1.13" derive_more = "0.99" pwasm-utils = { version = "0.12.0", default-features = false } -parity-wasm = { version = "0.41.0", default-features = false } +parity-wasm = { version = "0.45.0", default-features = false, features = [ + "sign_ext" +] } base64 = { rev = "dc7389e10817b078f289386b3b6a852ab6c4c021", git = "https://github.com/mesalock-linux/rust-base64-sgx" } # for attestation chrono = { git = "https://github.com/mesalock-linux/chrono-sgx" } diff --git a/cosmwasm/enclaves/shared/contract-engine/Cargo.toml b/cosmwasm/enclaves/shared/contract-engine/Cargo.toml index 075bf2c72..4019667f6 100644 --- a/cosmwasm/enclaves/shared/contract-engine/Cargo.toml +++ b/cosmwasm/enclaves/shared/contract-engine/Cargo.toml @@ -49,7 +49,9 @@ derive_more = "0.99" sha2 = "0.8.1" bech32 = "0.7.2" pwasm-utils = { version = "0.12.0", default-features = false, optional = true } -parity-wasm = { version = "0.41.0", default-features = false, optional = true } +parity-wasm = { version = "0.45.0", default-features = false, optional = true, features = [ + "sign_ext" +] } wasm3 = { git = "https://github.com/scrtlabs/wasm3-rs", rev = "ad1c868" } walrus = { version = "0.19.0", git = "https://github.com/scrtlabs/walrus", rev = "c5777d4" } lru = { version = "0.7", default-features = false } diff --git a/cosmwasm/enclaves/shared/contract-engine/src/contract_operations.rs b/cosmwasm/enclaves/shared/contract-engine/src/contract_operations.rs index c770e3605..95f0c147c 100644 --- a/cosmwasm/enclaves/shared/contract-engine/src/contract_operations.rs +++ b/cosmwasm/enclaves/shared/contract-engine/src/contract_operations.rs @@ -932,7 +932,7 @@ fn extract_query_depth(env: &[u8]) -> Result { EnclaveError::FailedToDeserialize }) .map(|env| { - trace!("base env: {:?}", env); + trace!("env.query_depth: {:?}", env); env.query_depth }) } diff --git a/cosmwasm/enclaves/shared/contract-engine/src/contract_validation.rs b/cosmwasm/enclaves/shared/contract-engine/src/contract_validation.rs index b2e2d4b53..aa56c3a82 100644 --- a/cosmwasm/enclaves/shared/contract-engine/src/contract_validation.rs +++ b/cosmwasm/enclaves/shared/contract-engine/src/contract_validation.rs @@ -627,6 +627,7 @@ fn verify_input( verify_tx_bytes(sig_info, &sdk_messages)?; let is_verified = verify_input_params( + #[cfg(feature = "light-client-validation")] sig_info, &sdk_messages, sender, @@ -859,7 +860,7 @@ fn verify_callback_sig_impl( #[allow(clippy::too_many_arguments)] fn verify_input_params( - sig_info: &SigInfo, + #[cfg(feature = "light-client-validation")] sig_info: &SigInfo, sdk_messages: &[DirectSdkMsg], sender: &CanonicalAddr, sent_funds: &[Coin], diff --git a/cosmwasm/enclaves/shared/cosmwasm-types/v0.10/src/types.rs b/cosmwasm/enclaves/shared/cosmwasm-types/v0.10/src/types.rs index fb17b8d60..1af8c88fa 100644 --- a/cosmwasm/enclaves/shared/cosmwasm-types/v0.10/src/types.rs +++ b/cosmwasm/enclaves/shared/cosmwasm-types/v0.10/src/types.rs @@ -134,6 +134,11 @@ pub struct TransactionInfo { /// using the pair (`env.block.height`, `env.transaction.index`). /// pub index: u32, + /// The hash of the current transaction bytes. + /// aka txhash or transaction_id + /// hash = sha256(tx_bytes) + #[serde(default)] + pub hash: String, } #[derive(Serialize, Deserialize, Clone, Default, Debug, PartialEq)] diff --git a/cosmwasm/enclaves/test/Cargo.lock b/cosmwasm/enclaves/test/Cargo.lock index 43e47a625..568a7c4af 100644 --- a/cosmwasm/enclaves/test/Cargo.lock +++ b/cosmwasm/enclaves/test/Cargo.lock @@ -283,9 +283,9 @@ dependencies = [ [[package]] name = "parity-wasm" -version = "0.41.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ddfc878dac00da22f8f61e7af3157988424567ab01d9920b962ef7dcbd7cd865" +checksum = "e1ad0aff30c1da14b1254fcb2af73e1fa9a28670e584a626f53a369d0e157304" [[package]] name = "parking_lot" @@ -451,9 +451,9 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.180" +version = "1.0.182" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ea67f183f058fe88a4e3ec6e2788e003840893b91bac4559cabedd00863b3ed" +checksum = "bdb30a74471f5b7a1fa299f40b4bf1be93af61116df95465b2b5fc419331e430" dependencies = [ "serde_derive", ] @@ -469,9 +469,9 @@ dependencies = [ [[package]] name = "serde_derive" -version = "1.0.180" +version = "1.0.182" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24e744d7782b686ab3b73267ef05697159cc0e5abbed3f47f9933165e5219036" +checksum = "6f4c2c6ea4bc09b5c419012eafcdb0fcef1d9119d626c8f3a0708a5b92d38a70" dependencies = [ "proc-macro2", "quote", diff --git a/cosmwasm/packages/sgx-vm/Cargo.toml b/cosmwasm/packages/sgx-vm/Cargo.toml index 23a4a1304..0a074b786 100644 --- a/cosmwasm/packages/sgx-vm/Cargo.toml +++ b/cosmwasm/packages/sgx-vm/Cargo.toml @@ -53,7 +53,7 @@ snafu = { version = "0.6.3" } sha2 = "0.10.7" hex = "0.4" memmap = "0.7" -parity-wasm = "0.41" +parity-wasm = { version = "0.45", features = ["sign_ext"] } # requirements specific to Secret Network lazy_static = "1.4" enclave-ffi-types = { path = "../../enclaves/ffi-types", features = [ diff --git a/deployment/dockerfiles/base-images/secret-contract-optimizer.Dockerfile b/deployment/dockerfiles/base-images/secret-contract-optimizer.Dockerfile index 343db9ea3..96af523df 100644 --- a/deployment/dockerfiles/base-images/secret-contract-optimizer.Dockerfile +++ b/deployment/dockerfiles/base-images/secret-contract-optimizer.Dockerfile @@ -1,4 +1,4 @@ -FROM rust:1.69.0-slim-bullseye +FROM rust:1.71.0-slim-bullseye RUN rustup target add wasm32-unknown-unknown RUN apt update && apt install -y binaryen clang && rm -rf /var/lib/apt/lists/* diff --git a/go-cosmwasm/Cargo.lock b/go-cosmwasm/Cargo.lock index 70d9fcd7d..99baca506 100644 --- a/go-cosmwasm/Cargo.lock +++ b/go-cosmwasm/Cargo.lock @@ -408,9 +408,9 @@ checksum = "1ab52be62400ca80aa00285d25253d7f7c437b7375c4de678f5405d3afe82ca5" [[package]] name = "parity-wasm" -version = "0.41.0" +version = "0.45.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ddfc878dac00da22f8f61e7af3157988424567ab01d9920b962ef7dcbd7cd865" +checksum = "e1ad0aff30c1da14b1254fcb2af73e1fa9a28670e584a626f53a369d0e157304" [[package]] name = "parking_lot" @@ -582,9 +582,9 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.180" +version = "1.0.182" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ea67f183f058fe88a4e3ec6e2788e003840893b91bac4559cabedd00863b3ed" +checksum = "bdb30a74471f5b7a1fa299f40b4bf1be93af61116df95465b2b5fc419331e430" dependencies = [ "serde_derive", ] @@ -600,9 +600,9 @@ dependencies = [ [[package]] name = "serde_derive" -version = "1.0.180" +version = "1.0.182" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24e744d7782b686ab3b73267ef05697159cc0e5abbed3f47f9933165e5219036" +checksum = "6f4c2c6ea4bc09b5c419012eafcdb0fcef1d9119d626c8f3a0708a5b92d38a70" dependencies = [ "proc-macro2", "quote", diff --git a/go-cosmwasm/types/env.go b/go-cosmwasm/types/env.go index e3e107adb..987229dd8 100644 --- a/go-cosmwasm/types/env.go +++ b/go-cosmwasm/types/env.go @@ -29,6 +29,10 @@ type TransactionInfo struct { // Along with BlockInfo.Height, this allows you to get a unique // transaction identifier for the chain for future queries Index uint32 `json:"index"` + /// The hash of the current transaction bytes. + /// aka txhash or transaction_id + /// hash = sha256(tx_bytes) + Hash string `json:"hash"` } type BaseEnv[T Env] struct { diff --git a/scripts/install-wasm-tools.sh b/scripts/install-wasm-tools.sh index 75d9dcf6d..b439e9c3d 100755 --- a/scripts/install-wasm-tools.sh +++ b/scripts/install-wasm-tools.sh @@ -81,34 +81,12 @@ cargo install pwasm-utils-cli --bin wasm-prune --force if [[ "$OSTYPE" == "linux-gnu" ]]; then set -e - BUILD_NUM=`curl -s https://storage.googleapis.com/wasm-llvm/builds/linux/lkgr.json | jq -r '.build'` - if [ -z ${BUILD_NUM+x} ]; then - echo "Could not fetch the latest build number."; - exit 1; - fi - - tmp=`mktemp -d` - pushd $tmp > /dev/null - echo "Downloading wasm-binaries.tbz2"; - curl -L -o wasm-binaries.tbz2 https://storage.googleapis.com/wasm-llvm/builds/linux/$BUILD_NUM/wasm-binaries.tbz2 - - declare -a binaries=("wasm2wat" "wat2wasm") # Default binaries - if [ "$#" -ne 0 ]; then - echo "Installing selected binaries."; - binaries=("$@"); - else - echo "Installing default binaries."; - fi - - for bin in "${binaries[@]}" - do - echo "Installing $bin into ~/.cargo/bin" - tar -xvjf wasm-binaries.tbz2 wasm-install/bin/$bin > /dev/null - cp -f wasm-install/bin/$bin ~/.cargo/bin/ - done - popd > /dev/null + sudo apt-get install -y wabt fi echo "" echo "Run source ~/.cargo/env now to update environment." echo "" + +source ~/.cargo/env +wasm2wat --version diff --git a/x/compute/internal/keeper/keeper_test.go b/x/compute/internal/keeper/keeper_test.go index 92ed11b3d..a1e56642b 100644 --- a/x/compute/internal/keeper/keeper_test.go +++ b/x/compute/internal/keeper/keeper_test.go @@ -291,6 +291,7 @@ func TestInstantiate(t *testing.T) { require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = types.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) // create with no balance is also legal @@ -409,6 +410,7 @@ func TestInstantiateWithNonExistingCodeID(t *testing.T) { require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = types.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) addr, _, err := keeper.Instantiate(ctx, nonExistingCodeID, creator, nil, initMsgBz, "demo contract 2", nil, nil) @@ -641,6 +643,7 @@ func TestExecuteWithNonExistingAddress(t *testing.T) { require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = types.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) _, err = keeper.Execute(ctx, nonExistingAddress, creator, msgBz, nil, nil, wasmtypes.HandleTypeExecute) @@ -696,6 +699,7 @@ func TestExecuteWithPanic(t *testing.T) { require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = types.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) // let's make sure we get a reasonable error, no panic/crash @@ -761,6 +765,7 @@ func TestExecuteWithCpuLoop(t *testing.T) { require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = types.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) addr, _, err := keeper.Instantiate(ctx, contractID, creator, nil, msgBz, "demo contract 5", deposit, nil) @@ -807,6 +812,7 @@ func TestExecuteWithCpuLoop(t *testing.T) { require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = types.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) // this must fail @@ -880,6 +886,7 @@ func TestExecuteWithStorageLoop(t *testing.T) { require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = types.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) start := time.Now() diff --git a/x/compute/internal/keeper/param_verification_test.go b/x/compute/internal/keeper/param_verification_test.go index a8a96fbdf..5e129741e 100644 --- a/x/compute/internal/keeper/param_verification_test.go +++ b/x/compute/internal/keeper/param_verification_test.go @@ -110,9 +110,10 @@ func multisigTxCreatorForExisting( require.NoError(t, err) tx := builder.(protoTxProvider) - txbytes, err := tx.GetProtoTx().Marshal() + txBytes, err := tx.GetProtoTx().Marshal() require.NoError(t, err) - *ctx = ctx.WithTxBytes(txbytes) + *ctx = ctx.WithTxBytes(txBytes) + *ctx = types.WithTXCounter(*ctx, 1) // updateLightClientHelper(t, *ctx) return signmodeHandler @@ -204,6 +205,7 @@ func prepareInitSignedTxMultipleMsgs( require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = types.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) return ctx } @@ -624,6 +626,7 @@ func TestMultiSigInMultiSig(t *testing.T) { require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = types.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) contractAddressA, _, err := keeper.Instantiate( @@ -729,6 +732,7 @@ func TestMultiSigInMultiSigDifferentOrder(t *testing.T) { require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = types.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) contractAddressA, _, err := keeper.Instantiate( @@ -877,6 +881,7 @@ func TestInvalidKeyTypeInMultisig(t *testing.T) { txBytes, err := tx.GetProtoTx().Marshal() require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = types.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) _, _, err = keeper.Instantiate( diff --git a/x/compute/internal/keeper/querier_test.go b/x/compute/internal/keeper/querier_test.go index e3700340b..d0f469f9c 100644 --- a/x/compute/internal/keeper/querier_test.go +++ b/x/compute/internal/keeper/querier_test.go @@ -343,6 +343,7 @@ func TestListContractByCodeOrdering(t *testing.T) { require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = types.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) _, _, err = keeper.Instantiate(ctx, codeID, creator, nil, initMsgBz, fmt.Sprintf("contract %d", i), topUp, nil) diff --git a/x/compute/internal/keeper/secret_contracts_exec_test.go b/x/compute/internal/keeper/secret_contracts_exec_test.go index 22cdb908c..ff05d9f22 100644 --- a/x/compute/internal/keeper/secret_contracts_exec_test.go +++ b/x/compute/internal/keeper/secret_contracts_exec_test.go @@ -171,7 +171,7 @@ func TestAddrValidateFunction(t *testing.T) { func TestRandomEnv(t *testing.T) { ctx, keeper, codeID, _, walletA, privKeyA, _, _ := setupTest(t, TestContractPaths[randomContract], sdk.NewCoins()) - _, _, contractAddress, initEvents, initErr := initHelperImpl(t, keeper, ctx, codeID, walletA, nil, privKeyA, `{"get_env":{}}`, true, true, defaultGasForTests, -1, sdk.NewCoins(sdk.NewInt64Coin("denom", 1))) + _, ctx, contractAddress, initEvents, initErr := initHelperImpl(t, keeper, ctx, codeID, walletA, nil, privKeyA, `{"get_env":{}}`, true, true, defaultGasForTests, -1, sdk.NewCoins(sdk.NewInt64Coin("denom", 1))) require.Empty(t, initErr) require.Len(t, initEvents, 1) @@ -186,16 +186,16 @@ func TestRandomEnv(t *testing.T) { require.Len(t, actualMessageInfo.Block.Random, 32) expectedV1Env := fmt.Sprintf( - `{"block":{"height":%d,"time":"%d","chain_id":"%s","random":"%s"},"transaction":null,"contract":{"address":"%s","code_hash":"%s"}}`, + `{"block":{"height":%d,"time":"%d","chain_id":"%s","random":"%s"},"transaction":{"index":1,"hash":"%s"},"contract":{"address":"%s","code_hash":"%s"}}`, ctx.BlockHeight(), // env.block.time is nanoseconds since unix epoch ctx.BlockTime().UnixNano(), ctx.ChainID(), base64.StdEncoding.EncodeToString(actualMessageInfo.Block.Random), + txhash(t, ctx), contractAddress.String(), calcCodeHash(TestContractPaths[randomContract]), ) - // requireEventsInclude(t, initEvents, []ContractEvent{ @@ -209,8 +209,7 @@ func TestRandomEnv(t *testing.T) { }, ) - // - _, _, _, execEvents, _, execErr := execHelper(t, keeper, ctx, contractAddress, walletA, privKeyA, `{"get_env":{}}`, true, true, defaultGasForTests, 1) + _, ctx, _, execEvents, _, execErr := execHelper(t, keeper, ctx, contractAddress, walletA, privKeyA, `{"get_env":{}}`, true, true, defaultGasForTests, 1) require.Empty(t, execErr) execEvent := execEvents[0] @@ -221,12 +220,13 @@ func TestRandomEnv(t *testing.T) { json.Unmarshal([]byte(envAttribute.Value), &actualExecEnv) expectedV1EnvExec := fmt.Sprintf( - `{"block":{"height":%d,"time":"%d","chain_id":"%s","random":"%s"},"transaction":null,"contract":{"address":"%s","code_hash":"%s"}}`, + `{"block":{"height":%d,"time":"%d","chain_id":"%s","random":"%s"},"transaction":{"index":1,"hash":"%s"},"contract":{"address":"%s","code_hash":"%s"}}`, ctx.BlockHeight(), // env.block.time is nanoseconds since unix epoch ctx.BlockTime().UnixNano(), ctx.ChainID(), base64.StdEncoding.EncodeToString(actualExecEnv.Block.Random), + txhash(t, ctx), contractAddress.String(), calcCodeHash(TestContractPaths[randomContract]), ) @@ -256,18 +256,19 @@ func TestEnv(t *testing.T) { t.Run(testContract.CosmWasmVersion, func(t *testing.T) { ctx, keeper, codeID, _, walletA, privKeyA, _, _ := setupTest(t, testContract.WasmFilePath, sdk.NewCoins()) - _, _, contractAddress, initEvents, initErr := initHelperImpl(t, keeper, ctx, codeID, walletA, nil, privKeyA, `{"get_env":{}}`, true, testContract.IsCosmWasmV1, defaultGasForTests, -1, sdk.NewCoins(sdk.NewInt64Coin("denom", 1))) + _, ctx, contractAddress, initEvents, initErr := initHelperImpl(t, keeper, ctx, codeID, walletA, nil, privKeyA, `{"get_env":{}}`, true, testContract.IsCosmWasmV1, defaultGasForTests, -1, sdk.NewCoins(sdk.NewInt64Coin("denom", 1))) require.Empty(t, initErr) require.Len(t, initEvents, 1) // var firstRandom string expectedV1Env := fmt.Sprintf( - `{"block":{"height":%d,"time":"%d","chain_id":"%s"},"transaction":null,"contract":{"address":"%s","code_hash":"%s"}}`, + `{"block":{"height":%d,"time":"%d","chain_id":"%s"},"transaction":{"index":1,"hash":"%s"},"contract":{"address":"%s","code_hash":"%s"}}`, ctx.BlockHeight(), // env.block.time is nanoseconds since unix epoch ctx.BlockTime().UnixNano(), ctx.ChainID(), + txhash(t, ctx), contractAddress.String(), calcCodeHash(testContract.WasmFilePath), ) @@ -322,9 +323,20 @@ func TestEnv(t *testing.T) { initEvents, ) } - _, _, _, execEvents, _, execErr := execHelper(t, keeper, ctx, contractAddress, walletA, privKeyA, `{"get_env":{}}`, true, testContract.IsCosmWasmV1, defaultGasForTests, 1) + _, ctx, _, execEvents, _, execErr := execHelper(t, keeper, ctx, contractAddress, walletA, privKeyA, `{"get_env":{}}`, true, testContract.IsCosmWasmV1, defaultGasForTests, 1) require.Empty(t, execErr) + expectedV1Env = fmt.Sprintf( + `{"block":{"height":%d,"time":"%d","chain_id":"%s"},"transaction":{"index":1,"hash":"%s"},"contract":{"address":"%s","code_hash":"%s"}}`, + ctx.BlockHeight(), + // env.block.time is nanoseconds since unix epoch + ctx.BlockTime().UnixNano(), + ctx.ChainID(), + txhash(t, ctx), + contractAddress.String(), + calcCodeHash(testContract.WasmFilePath), + ) + if testContract.IsCosmWasmV1 { requireEventsInclude(t, execEvents, @@ -381,6 +393,16 @@ func TestEnv(t *testing.T) { queryRes, qErr := queryHelper(t, keeper, ctx, contractAddress, `{"get_env":{}}`, true, false, math.MaxUint64) require.Empty(t, qErr) + expectedV1Env := fmt.Sprintf( + `{"block":{"height":%d,"time":"%d","chain_id":"%s"},"transaction":null,"contract":{"address":"%s","code_hash":"%s"}}`, + ctx.BlockHeight(), + // env.block.time is nanoseconds since unix epoch + ctx.BlockTime().UnixNano(), + ctx.ChainID(), + contractAddress.String(), + calcCodeHash(testContract.WasmFilePath), + ) + require.Equal(t, expectedV1Env, queryRes) } else { // no env or msg info in v0.10 query @@ -2250,7 +2272,7 @@ func TestEvaporateGas(t *testing.T) { msg: `{"evaporate":{"amount": 1200}}`, outOfGas: false, // 1200 - (base = 8) + 1 (see above) = 1193 - gasExpected: 1192, + gasExpected: 1193, gasForTest: defaultGasForTests, }, { @@ -2338,7 +2360,7 @@ func TestConsumeExact(t *testing.T) { // to be offset by 1 - do we really care? msg: `{"use_exact":{"amount": 399999}}`, outOfGas: false, - gasExpected: 400000, + gasExpected: 399999, gasForTest: defaultGasForTests, }, } { @@ -2800,3 +2822,47 @@ func TestIBCHooksOutgoingTransferTimeout(t *testing.T) { }) } } + +func TestExecEnvTxHash(t *testing.T) { + ctx, keeper, codeID, _, walletA, privKeyA, _, _ := setupTest(t, TestContractPaths[v1MigratedContract], sdk.NewCoins()) + + _, _, contractAddress, _, _ := initHelper(t, keeper, ctx, codeID, walletA, nil, privKeyA, `{"nop":{}}`, true, true, defaultGasForTests) + + _, ctx, _, events, _, err := execHelper(t, keeper, ctx, contractAddress, walletA, privKeyA, `{"tx_hash":{}}`, true, true, math.MaxUint64, 0) + + require.Empty(t, err) + + requireEvents(t, + []ContractEvent{ + { + {Key: "contract_address", Value: contractAddress.String()}, + {Key: "txhash", Value: txhash(t, ctx)}, + }, + }, + events, + ) +} + +func TestCallbackEnvTxHash(t *testing.T) { + ctx, keeper, codeID, codeHash, walletA, privKeyA, _, _ := setupTest(t, TestContractPaths[v1MigratedContract], sdk.NewCoins()) + + _, _, contractAddress, _, _ := initHelper(t, keeper, ctx, codeID, walletA, nil, privKeyA, `{"nop":{}}`, true, true, defaultGasForTests) + + _, ctx, _, events, _, err := execHelper(t, keeper, ctx, contractAddress, walletA, privKeyA, fmt.Sprintf(`{"call_to_exec":{"addr":"%s","code_hash":"%s","msg":"%s"}}`, contractAddress, codeHash, `{\"tx_hash\":{}}`), true, true, math.MaxUint64, 0) + + require.Empty(t, err) + require.Len(t, events, 2) + requireEvents(t, + []ContractEvent{ + { + {Key: "contract_address", Value: contractAddress.String()}, + {Key: "b", Value: "b"}, + }, + { + {Key: "contract_address", Value: contractAddress.String()}, + {Key: "txhash", Value: txhash(t, ctx)}, + }, + }, + events, + ) +} diff --git a/x/compute/internal/keeper/secret_contracts_init_test.go b/x/compute/internal/keeper/secret_contracts_init_test.go index 4cc414704..ea0439a15 100644 --- a/x/compute/internal/keeper/secret_contracts_init_test.go +++ b/x/compute/internal/keeper/secret_contracts_init_test.go @@ -1113,3 +1113,21 @@ func TestInputAdminMismatch(t *testing.T) { } } } + +func TestInitEnvTxHash(t *testing.T) { + ctx, keeper, codeID, _, walletA, privKeyA, _, _ := setupTest(t, TestContractPaths[v1MigratedContract], sdk.NewCoins()) + + _, ctx, contractAddress, events, err := initHelper(t, keeper, ctx, codeID, walletA, nil, privKeyA, `{"tx_hash":{}}`, true, true, defaultGasForTests) + + require.Empty(t, err) + + requireEvents(t, + []ContractEvent{ + { + {Key: "contract_address", Value: contractAddress.String()}, + {Key: "txhash", Value: txhash(t, ctx)}, + }, + }, + events, + ) +} diff --git a/x/compute/internal/keeper/secret_contracts_migrate_test.go b/x/compute/internal/keeper/secret_contracts_migrate_test.go index f7447643a..5638d923d 100644 --- a/x/compute/internal/keeper/secret_contracts_migrate_test.go +++ b/x/compute/internal/keeper/secret_contracts_migrate_test.go @@ -251,7 +251,7 @@ func TestEnvAfterMigrate(t *testing.T) { _, migrateErr := migrateHelper(t, keeper, ctx, newCodeId, contractAddress, walletA, privKeyA, `{"nop":{}}`, true, testContract.IsCosmWasmV1After, math.MaxUint64) require.Empty(t, migrateErr) - _, _, _, execEvents, _, execErr := execHelper(t, keeper, ctx, contractAddress, walletA, privKeyA, `{"get_env":{}}`, true, testContract.IsCosmWasmV1After, defaultGasForTests, 1) + _, ctx, _, execEvents, _, execErr := execHelper(t, keeper, ctx, contractAddress, walletA, privKeyA, `{"get_env":{}}`, true, testContract.IsCosmWasmV1After, defaultGasForTests, 1) require.Empty(t, execErr) execEvent := execEvents[0] @@ -262,12 +262,13 @@ func TestEnvAfterMigrate(t *testing.T) { json.Unmarshal([]byte(envAttribute.Value), &actualExecEnv) expectedV1EnvExec := fmt.Sprintf( - `{"block":{"height":%d,"time":"%d","chain_id":"%s","random":"%s"},"transaction":null,"contract":{"address":"%s","code_hash":"%s"}}`, + `{"block":{"height":%d,"time":"%d","chain_id":"%s","random":"%s"},"transaction":{"index":1,"hash":"%s"},"contract":{"address":"%s","code_hash":"%s"}}`, ctx.BlockHeight(), // env.block.time is nanoseconds since unix epoch ctx.BlockTime().UnixNano(), ctx.ChainID(), base64.StdEncoding.EncodeToString(actualExecEnv.Block.Random), + txhash(t, ctx), contractAddress.String(), calcCodeHash(TestContractPaths[v1MigratedContract]), ) @@ -2877,12 +2878,13 @@ func TestEnvDuringMigrate(t *testing.T) { json.Unmarshal([]byte(envAttribute.Value), &actualMigrateEnv) expectedV1EnvMigrate := fmt.Sprintf( - `{"block":{"height":%d,"time":"%d","chain_id":"%s","random":"%s"},"transaction":null,"contract":{"address":"%s","code_hash":"%s"}}`, + `{"block":{"height":%d,"time":"%d","chain_id":"%s","random":"%s"},"transaction":{"index":1,"hash":"%s"},"contract":{"address":"%s","code_hash":"%s"}}`, ctx.BlockHeight(), // env.block.time is nanoseconds since unix epoch ctx.BlockTime().UnixNano(), ctx.ChainID(), base64.StdEncoding.EncodeToString(actualMigrateEnv.Block.Random), + txhash(t, migrateResult.Ctx), contractAddress.String(), calcCodeHash(testContract.WasmFilePathAfter), ) @@ -8209,3 +8211,24 @@ func TestContractNoLongerIbcEnabledAfterMigrate(t *testing.T) { info = keeper.GetContractInfo(ctx, contractA) require.Equal(t, info.IBCPortID, "wasm."+contractA.String()) } + +func TestMigrateEnvTxHash(t *testing.T) { + ctx, keeper, codeID, _, walletA, privKeyA, _, _ := setupTest(t, TestContractPaths[v1MigratedContract], sdk.NewCoins()) + + _, _, contractAddress, _, initErr := initHelper(t, keeper, ctx, codeID, walletA, walletA, privKeyA, `{"nop":{}}`, true, true, defaultGasForTests) + require.Empty(t, initErr) + + newCodeId, _ := uploadCode(ctx, t, keeper, TestContractPaths[v1MigratedContract], walletA) + res, migErr := migrateHelper(t, keeper, ctx, newCodeId, contractAddress, walletA, privKeyA, `{"tx_hash":{}}`, true, true, math.MaxUint64) + require.Empty(t, migErr) + + requireEvents(t, + []ContractEvent{ + { + {Key: "contract_address", Value: contractAddress.String()}, + {Key: "txhash", Value: txhash(t, res.Ctx)}, + }, + }, + res.WasmEvents, + ) +} diff --git a/x/compute/internal/keeper/test_common.go b/x/compute/internal/keeper/test_common.go index 3791e231e..316afd932 100644 --- a/x/compute/internal/keeper/test_common.go +++ b/x/compute/internal/keeper/test_common.go @@ -4,6 +4,7 @@ import ( "crypto/rand" "crypto/sha256" "encoding/binary" + "encoding/hex" "fmt" "os" "path/filepath" @@ -681,6 +682,7 @@ func PrepareExecSignedTxWithMultipleMsgs( require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = wasmtypes.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) return ctx } @@ -701,6 +703,7 @@ func PrepareExecSignedTx(t *testing.T, keeper Keeper, ctx sdk.Context, sender sd require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = wasmtypes.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) return ctx } @@ -723,6 +726,7 @@ func PrepareInitSignedTx(t *testing.T, keeper Keeper, ctx sdk.Context, creator, require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = wasmtypes.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) return ctx } @@ -742,6 +746,7 @@ func prepareMigrateSignedTx(t *testing.T, keeper Keeper, ctx sdk.Context, contra require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = wasmtypes.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) return ctx } @@ -760,6 +765,7 @@ func prepareUpdateAdminSignedTx(t *testing.T, keeper Keeper, ctx sdk.Context, co require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = wasmtypes.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) return ctx } @@ -777,6 +783,7 @@ func prepareClearAdminSignedTx(t *testing.T, keeper Keeper, ctx sdk.Context, con require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = wasmtypes.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) return ctx } @@ -797,6 +804,7 @@ func PrepareSignedTx(t *testing.T, require.NoError(t, err) ctx = ctx.WithTxBytes(txBytes) + ctx = wasmtypes.WithTXCounter(ctx, 1) // updateLightClientHelper(t, ctx) return ctx } @@ -827,6 +835,7 @@ func NewTestTx(msg sdk.Msg, creatorAcc authtypes.AccountI, privKey crypto.PrivKe // txBytes, err := tx.Marshal() // require.NoError(t, err) // +// ctx = wasmtypes.WithTXCounter(ctx, 1) // return ctx.WithTxBytes(txBytes) //} @@ -1039,3 +1048,10 @@ func makeBlockIDRandom() tmtypes.BlockID { }, } } + +func txhash(t *testing.T, ctx sdk.Context) string { + require.NotEmpty(t, ctx.TxBytes()) + txhashBz := sha256.Sum256(ctx.TxBytes()) + txhash := hex.EncodeToString(txhashBz[:]) + return txhash +} diff --git a/x/compute/internal/keeper/testdata/contract-v2.wasm b/x/compute/internal/keeper/testdata/contract-v2.wasm index 77a7c770c..77241b600 100755 Binary files a/x/compute/internal/keeper/testdata/contract-v2.wasm and b/x/compute/internal/keeper/testdata/contract-v2.wasm differ diff --git a/x/compute/internal/keeper/testdata/contract.wasm b/x/compute/internal/keeper/testdata/contract.wasm new file mode 100755 index 000000000..a32511b68 Binary files /dev/null and b/x/compute/internal/keeper/testdata/contract.wasm differ diff --git a/x/compute/internal/keeper/testdata/contract_with_floats.wasm b/x/compute/internal/keeper/testdata/contract_with_floats.wasm new file mode 100755 index 000000000..de9dad847 Binary files /dev/null and b/x/compute/internal/keeper/testdata/contract_with_floats.wasm differ diff --git a/x/compute/internal/keeper/testdata/ibc.wasm b/x/compute/internal/keeper/testdata/ibc.wasm new file mode 100755 index 000000000..b71ce613d Binary files /dev/null and b/x/compute/internal/keeper/testdata/ibc.wasm differ diff --git a/x/compute/internal/keeper/testdata/static-too-high-initial-memory.wasm b/x/compute/internal/keeper/testdata/static-too-high-initial-memory.wasm new file mode 100644 index 000000000..16a1b0c57 Binary files /dev/null and b/x/compute/internal/keeper/testdata/static-too-high-initial-memory.wasm differ diff --git a/x/compute/internal/keeper/testdata/too-high-initial-memory.wasm b/x/compute/internal/keeper/testdata/too-high-initial-memory.wasm new file mode 100644 index 000000000..3329559dd Binary files /dev/null and b/x/compute/internal/keeper/testdata/too-high-initial-memory.wasm differ diff --git a/x/compute/internal/keeper/testdata/v1-contract-v2.wasm b/x/compute/internal/keeper/testdata/v1-contract-v2.wasm index eb3ea6dce..e75fac50e 100755 Binary files a/x/compute/internal/keeper/testdata/v1-contract-v2.wasm and b/x/compute/internal/keeper/testdata/v1-contract-v2.wasm differ diff --git a/x/compute/internal/keeper/testdata/v1-contract.wasm b/x/compute/internal/keeper/testdata/v1-contract.wasm new file mode 100755 index 000000000..39eac401b Binary files /dev/null and b/x/compute/internal/keeper/testdata/v1-contract.wasm differ diff --git a/x/compute/internal/keeper/testdata/v1_random_test.wasm b/x/compute/internal/keeper/testdata/v1_random_test.wasm index 9be09425f..382a9b48d 100755 Binary files a/x/compute/internal/keeper/testdata/v1_random_test.wasm and b/x/compute/internal/keeper/testdata/v1_random_test.wasm differ diff --git a/x/compute/internal/types/types.go b/x/compute/internal/types/types.go index 6281a7b2e..784959b68 100644 --- a/x/compute/internal/types/types.go +++ b/x/compute/internal/types/types.go @@ -1,6 +1,8 @@ package types import ( + "crypto/sha256" + "encoding/hex" fmt "fmt" "strings" @@ -153,8 +155,15 @@ func NewEnv(ctx sdk.Context, creator sdk.AccAddress, deposit sdk.Coins, contract } if txCounter, ok := TXCounter(ctx); ok { - env.Transaction = &wasmTypes.TransactionInfo{Index: txCounter} + txhashBz := sha256.Sum256(ctx.TxBytes()) + txhash := hex.EncodeToString(txhashBz[:]) + + env.Transaction = &wasmTypes.TransactionInfo{ + Index: txCounter, + Hash: txhash, + } } + return env }