pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-05-06 23:08:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

[contracts] Implement transparent hashing for contract storage (#11501)

Browse Source 
* save

* builds and old tests pass

save:  temporary value dropped while borrowed

save: finally builds

test updated but still fails

* type names enhanced

* VarSizedKey bounded to new Config param

* improved wasm runtime updated funcs

* unstable-interface tests fixed

* benchmarks fixed

* Apply suggestions from code review

Co-authored-by: Alexander Theißen <alex.theissen@me.com>

* fixes on feedback

* fixes on feedback applied + make it build

* benchmarks build but fail (old)

* "Original code too large"

* seal_clear_storage bench fixed (code size workaround hack removal tbd)

* bench_seal_clear_storage pass

* bench_seal_take_storage ... ok

* added new seal_set_storage + updated benchmarks

* added new seal_get_storage + updated benchmarks

* added new seal_contains_storage + updated benchmarks

* added tests for _transparent exec functions

* wasm test for clear_storage

* wasm test for take_storage

* wasm test for new set_storage

* wasm test for new get_storage

* wasm test for new contains_storage

* CI fix

* ci fix

* ci fix

* ci fix

* cargo run --quiet --profile=production  --features=runtime-benchmarks --manifest-path=bin/node/cli/Cargo.toml -- benchmark pallet --chain=dev --steps=50 --repeat=20 --pallet=pallet_contracts --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./frame/contracts/src/weights.rs --template=./.maintain/frame-weight-template.hbs

* fixes according to the review feedback

* tests & benchmarks fixed

* cargo run --quiet --profile=production  --features=runtime-benchmarks --manifest-path=bin/node/cli/Cargo.toml -- benchmark pallet --chain=dev --steps=50 --repeat=20 --pallet=pallet_contracts --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./frame/contracts/src/weights.rs --template=./.maintain/frame-weight-template.hbs

* refactoring

* fix to runtime api

* ci fix

* ctx.get_storage() factored out

* ctx.contains_storage() factored out

* number of batches reduced for transparent hashing storage benchmarks

* contracts RPC & pallet::get_storage to use transparent hashing

* node and rpc updated to use get_storage with VarSizedKey

* refactored (more concize)

* refactored contains_storage (DRYed)

* refactored contains_storage (DRYed)

* fix rpc

* fmt fix

* more fixes in rpc

* rollback `Pallet:get_storage` to Vec<u8> and rpc and node parts related to it

* added `KeyDecodingFailed` error

* Revert weird "fmt fix"

This reverts commit c582cfff4b5cb2c9929fd5e3b45519bb24aeb657.

* node-executor basic test update

* fix node-executor basic test

* benchmarks fix

* more benchmarks fix

* FixedSizedKey is hidden from pub, VarSizedKey is exported as StorageKey

* ci fix

* set_storage benchmark fix

* ci fix

* ci fix

* comments improved

* new error code to rpc: KEY_DECODING_FAILED

* Put `rusty-cachier` before PR merge into `master` for `cargo-check-benches` job

* cargo run --quiet --profile=production  --features=runtime-benchmarks --manifest-path=bin/node/cli/Cargo.toml -- benchmark pallet --chain=dev --steps=50 --repeat=20 --pallet=pallet_contracts --extrinsic=* --execution=wasm --wasm-execution=compiled --heap-pages=4096 --output=./frame/contracts/src/weights.rs --template=./.maintain/frame-weight-template.hbs

* minor optimization

Co-authored-by: Alexander Theißen <alex.theissen@me.com>
Co-authored-by: Parity Bot <admin@parity.io>
Co-authored-by: Vladimir Istyufeev <vladimir@parity.io>
Co-authored-by: command-bot <>
This commit is contained in:
Alexander Gryaznov
2022-06-23 15:10:35 +03:00
committed by GitHub
parent 7d2ecc8995
commit 68ea2ab039
13 changed files with 2200 additions and 1158 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/bin/node/executor/tests/basic.rs
+5 -1
View File
@@ -764,7 +764,11 @@ fn deploying_wasm_contract_should_work() {
t.execute_with(|| {
// Verify that the contract does exist by querying some of its storage items
// It does not matter that the storage item itself does not exist.
assert!(&pallet_contracts::Pallet::<Runtime>::get_storage(addr, Default::default()).is_ok());
assert!(&pallet_contracts::Pallet::<Runtime>::get_storage(
addr,
pallet_contracts::StorageKey::<Runtime>::default().to_vec()
)
.is_ok());
});
}
substrate/bin/node/runtime/src/lib.rs
+2 -1
View File
@@ -1151,6 +1151,7 @@ impl pallet_contracts::Config for Runtime {
type ContractAccessWeight = pallet_contracts::DefaultContractAccessWeight<RuntimeBlockWeights>;
type MaxCodeLen = ConstU32<{ 128 * 1024 }>;
type RelaxedMaxCodeLen = ConstU32<{ 256 * 1024 }>;
type MaxStorageKeyLen = ConstU32<128>;
}
impl pallet_sudo::Config for Runtime {
@@ -1936,7 +1937,7 @@ impl_runtime_apis! {
fn get_storage(
address: AccountId,
key: [u8; 32],
key: Vec<u8>,
) -> pallet_contracts_primitives::GetStorageResult {
Contracts::get_storage(address, key)
}
substrate/frame/contracts/common/src/lib.rs
+2
View File
@@ -106,6 +106,8 @@ pub type GetStorageResult = Result<Option<Vec<u8>>, ContractAccessError>;
pub enum ContractAccessError {
/// The given address doesn't point to a contract.
DoesntExist,
/// Storage key cannot be decoded from the provided input data.
KeyDecodingFailed,
}
bitflags! {
substrate/frame/contracts/rpc/runtime-api/src/lib.rs
+1 -1
View File
@@ -79,7 +79,7 @@ sp_api::decl_runtime_apis! {
/// doesn't exist, or doesn't have a contract then `Err` is returned.
fn get_storage(
address: AccountId,
key: [u8; 32],
key: Vec<u8>,
) -> GetStorageResult;
}
}
substrate/frame/contracts/rpc/src/lib.rs
+11 -4
View File
@@ -33,7 +33,7 @@ use pallet_contracts_primitives::{
use serde::{Deserialize, Serialize};
use sp_api::ProvideRuntimeApi;
use sp_blockchain::HeaderBackend;
use sp_core::{Bytes, H256};
use sp_core::Bytes;
use sp_rpc::number::NumberOrHex;
use sp_runtime::{
generic::BlockId,
@@ -44,6 +44,7 @@ pub use pallet_contracts_rpc_runtime_api::ContractsApi as ContractsRuntimeApi;
const RUNTIME_ERROR: i32 = 1;
const CONTRACT_DOESNT_EXIST: i32 = 2;
const KEY_DECODING_FAILED: i32 = 3;
pub type Weight = u64;
@@ -74,6 +75,12 @@ impl From<ContractAccessError> for JsonRpseeError {
None::<()>,
))
.into(),
KeyDecodingFailed => CallError::Custom(ErrorObject::owned(
KEY_DECODING_FAILED,
"Failed to decode the specified storage key.",
None::<()>,
))
.into(),
}
}
}
@@ -167,7 +174,7 @@ where
fn get_storage(
&self,
address: AccountId,
key: H256,
key: Bytes,
at: Option<BlockHash>,
) -> RpcResult<Option<Bytes>>;
}
@@ -292,13 +299,13 @@ where
fn get_storage(
&self,
address: AccountId,
key: H256,
key: Bytes,
at: Option<<Block as BlockT>::Hash>,
) -> RpcResult<Option<Bytes>> {
let api = self.client.runtime_api();
let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash));
let result = api
.get_storage(&at, address, key.into())
.get_storage(&at, address, key.to_vec())
.map_err(runtime_error_into_rpc_err)?
.map_err(ContractAccessError)?
.map(Bytes);
substrate/frame/contracts/src/benchmarking/mod.rs
+138 -107
View File
@@ -30,7 +30,7 @@ use self::{
sandbox::Sandbox,
};
use crate::{
exec::{AccountIdOf, StorageKey},
exec::{AccountIdOf, FixSizedKey, VarSizedKey},
schedule::{API_BENCHMARK_BATCH_SIZE, INSTR_BENCHMARK_BATCH_SIZE},
storage::Storage,
wasm::CallFlags,
@@ -132,11 +132,17 @@ where
}
/// Store the supplied storage items into this contracts storage.
fn store(&self, items: &Vec<(StorageKey, Vec<u8>)>) -> Result<(), &'static str> {
fn store(&self, items: &Vec<(FixSizedKey, Vec<u8>)>) -> Result<(), &'static str> {
let info = self.info()?;
for item in items {
Storage::<T>::write(&info.trie_id, &item.0, Some(item.1.clone()), None, false)
.map_err(|_| "Failed to write storage to restoration dest")?;
Storage::<T>::write(
&info.trie_id,
&item.0 as &FixSizedKey,
Some(item.1.clone()),
None,
false,
)
.map_err(|_| "Failed to write storage to restoration dest")?;
}
<ContractInfoOf<T>>::insert(&self.account_id, info);
Ok(())
@@ -896,33 +902,37 @@ benchmarks! {
}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
// Only the overhead of calling the function itself with minimal arguments.
// The contract is a bit more complex because I needs to use different keys in order
// The contract is a bit more complex because it needs to use different keys in order
// to generate unique storage accesses. However, it is still dominated by the storage
// accesses.
// accesses. We store all the keys that we are about to write at beforehand
// because re-writing at an existing key is always more expensive than writing
// it at a virgin key.
#[skip_meta]
seal_set_storage {
let r in 0 .. API_BENCHMARK_BATCHES;
let r in 0 .. API_BENCHMARK_BATCHES/2;
let max_key_len = T::MaxStorageKeyLen::get();
let keys = (0 .. r * API_BENCHMARK_BATCH_SIZE)
.map(|n| T::Hashing::hash_of(&n).as_ref().to_vec())
.collect::<Vec<_>>();
let key_len = keys.get(0).map(|i| i.len() as u32).unwrap_or(0);
let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
.map(|n| { let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); h })
.collect::<Vec<_>>();
let keys_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
let code = WasmModule::<T>::from(ModuleDefinition {
memory: Some(ImportedMemory::max::<T>()),
imported_functions: vec![ImportedFunction {
module: "seal1",
module: "__unstable__",
name: "seal_set_storage",
params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
return_type: Some(ValueType::I32),
}],
data_segments: vec![
DataSegment {
offset: 0,
value: key_bytes,
value: keys_bytes,
},
],
call_body: Some(body::repeated_dyn(r * API_BENCHMARK_BATCH_SIZE, vec![
Counter(0, key_len as u32), // key_ptr
Counter(0, max_key_len as u32), // key_ptr
Regular(Instruction::I32Const(max_key_len as i32)), // key_len
Regular(Instruction::I32Const(0)), // value_ptr
Regular(Instruction::I32Const(0)), // value_len
Regular(Instruction::Call(0)),
@@ -935,7 +945,7 @@ benchmarks! {
for key in keys {
Storage::<T>::write(
&info.trie_id,
key.as_slice().try_into().map_err(|e| "Key has wrong length")?,
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![]),
None,
false,
@@ -947,18 +957,19 @@ benchmarks! {
#[skip_meta]
seal_set_storage_per_new_kb {
let n in 0 .. T::Schedule::get().limits.payload_len / 1024;
let keys = (0 .. API_BENCHMARK_BATCH_SIZE)
.map(|n| T::Hashing::hash_of(&n).as_ref().to_vec())
.collect::<Vec<_>>();
let key_len = keys.get(0).map(|i| i.len() as u32).unwrap_or(0);
let n in 0 .. T::Schedule::get().limits.payload_len / 2048; // half of the max payload_len in kb
let max_key_len = T::MaxStorageKeyLen::get();
let keys = (0 .. n * API_BENCHMARK_BATCH_SIZE)
.map(|n| { let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); h })
.collect::<Vec<_>>();
let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
let code = WasmModule::<T>::from(ModuleDefinition {
memory: Some(ImportedMemory::max::<T>()),
imported_functions: vec![ImportedFunction {
module: "seal1",
module: "__unstable__",
name: "seal_set_storage",
params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
return_type: Some(ValueType::I32),
}],
data_segments: vec![
@@ -968,9 +979,10 @@ benchmarks! {
},
],
call_body: Some(body::repeated_dyn(API_BENCHMARK_BATCH_SIZE, vec![
Counter(0, key_len as u32), // key_ptr
Counter(0, max_key_len as u32), // key_ptr
Regular(Instruction::I32Const(max_key_len as i32)), // key_len
Regular(Instruction::I32Const(0)), // value_ptr
Regular(Instruction::I32Const((n * 1024) as i32)), // value_len
Regular(Instruction::I32Const((n * 2048) as i32)), // value_len increments by 2kb up to max payload_len
Regular(Instruction::Call(0)),
Regular(Instruction::Drop),
])),
@@ -981,7 +993,7 @@ benchmarks! {
for key in keys {
Storage::<T>::write(
&info.trie_id,
key.as_slice().try_into().map_err(|e| "Key has wrong length")?,
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![]),
None,
false,
@@ -993,18 +1005,19 @@ benchmarks! {
#[skip_meta]
seal_set_storage_per_old_kb {
let n in 0 .. T::Schedule::get().limits.payload_len / 1024;
let keys = (0 .. API_BENCHMARK_BATCH_SIZE)
.map(|n| T::Hashing::hash_of(&n).as_ref().to_vec())
.collect::<Vec<_>>();
let key_len = keys.get(0).map(|i| i.len() as u32).unwrap_or(0);
let n in 0 .. T::Schedule::get().limits.payload_len / 2048; // half of the max payload_len in kb
let max_key_len = T::MaxStorageKeyLen::get();
let keys = (0 .. n * API_BENCHMARK_BATCH_SIZE)
.map(|n| { let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); h })
.collect::<Vec<_>>();
let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
let code = WasmModule::<T>::from(ModuleDefinition {
memory: Some(ImportedMemory::max::<T>()),
imported_functions: vec![ImportedFunction {
module: "seal1",
module: "__unstable__",
name: "seal_set_storage",
params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
return_type: Some(ValueType::I32),
}],
data_segments: vec![
@@ -1014,9 +1027,10 @@ benchmarks! {
},
],
call_body: Some(body::repeated_dyn(API_BENCHMARK_BATCH_SIZE, vec![
Counter(0, key_len as u32), // key_ptr
Counter(0, max_key_len as u32), // key_ptr
Regular(Instruction::I32Const(max_key_len as i32)), // key_len
Regular(Instruction::I32Const(0)), // value_ptr
Regular(Instruction::I32Const(0)), // value_len
Regular(Instruction::I32Const(0)), // value_len is 0 as testing vs pre-existing value len
Regular(Instruction::Call(0)),
Regular(Instruction::Drop),
])),
@@ -1027,8 +1041,8 @@ benchmarks! {
for key in keys {
Storage::<T>::write(
&info.trie_id,
key.as_slice().try_into().map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 1024) as usize]),
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len
None,
false,
)
@@ -1037,23 +1051,25 @@ benchmarks! {
let origin = RawOrigin::Signed(instance.caller.clone());
}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
// Similar to seal_set_storage. However, we store all the keys that we are about to
// Similar to seal_set_storage. We store all the keys that we are about to
// delete beforehand in order to prevent any optimizations that could occur when
// deleting a non existing key.
// deleting a non existing key. We generate keys of a maximum length, and have to
// reduce batch size in order to make resulting contract code size less than MaxCodeLen.
#[skip_meta]
seal_clear_storage {
let r in 0 .. API_BENCHMARK_BATCHES;
let r in 0 .. API_BENCHMARK_BATCHES/2;
let max_key_len = T::MaxStorageKeyLen::get();
let keys = (0 .. r * API_BENCHMARK_BATCH_SIZE)
.map(|n| T::Hashing::hash_of(&n).as_ref().to_vec())
.collect::<Vec<_>>();
.map(|n| { let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); h })
.collect::<Vec<_>>();
let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
let key_len = keys.get(0).map(|i| i.len() as u32).unwrap_or(0);
let code = WasmModule::<T>::from(ModuleDefinition {
memory: Some(ImportedMemory::max::<T>()),
imported_functions: vec![ImportedFunction {
module: "__unstable__",
name: "seal_clear_storage",
params: vec![ValueType::I32],
params: vec![ValueType::I32, ValueType::I32],
return_type: Some(ValueType::I32),
}],
data_segments: vec![
@@ -1063,7 +1079,8 @@ benchmarks! {
},
],
call_body: Some(body::repeated_dyn(r * API_BENCHMARK_BATCH_SIZE, vec![
Counter(0, key_len as u32),
Counter(0, max_key_len as u32), // key_ptr
Regular(Instruction::I32Const(max_key_len as i32)), // key_len
Regular(Instruction::Call(0)),
Regular(Instruction::Drop),
])),
@@ -1074,7 +1091,7 @@ benchmarks! {
for key in keys {
Storage::<T>::write(
&info.trie_id,
key.as_slice().try_into().map_err(|e| "Key has wrong length")?,
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![]),
None,
false,
@@ -1087,18 +1104,19 @@ benchmarks! {
#[skip_meta]
seal_clear_storage_per_kb {
let n in 0 .. T::Schedule::get().limits.payload_len / 1024;
let keys = (0 .. API_BENCHMARK_BATCH_SIZE)
.map(|n| T::Hashing::hash_of(&n).as_ref().to_vec())
.collect::<Vec<_>>();
let key_len = keys.get(0).map(|i| i.len() as u32).unwrap_or(0);
let n in 0 .. T::Schedule::get().limits.payload_len / 2048; // half of the max payload_len in kb
let max_key_len = T::MaxStorageKeyLen::get();
let keys = (0 .. n * API_BENCHMARK_BATCH_SIZE)
.map(|n| { let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); h })
.collect::<Vec<_>>();
let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
let code = WasmModule::<T>::from(ModuleDefinition {
memory: Some(ImportedMemory::max::<T>()),
imported_functions: vec![ImportedFunction {
module: "__unstable__",
name: "seal_clear_storage",
params: vec![ValueType::I32],
params: vec![ValueType::I32, ValueType::I32],
return_type: Some(ValueType::I32),
}],
data_segments: vec![
@@ -1108,7 +1126,8 @@ benchmarks! {
},
],
call_body: Some(body::repeated_dyn(API_BENCHMARK_BATCH_SIZE, vec![
Counter(0, key_len as u32), // key_ptr
Counter(0, max_key_len as u32), // key_ptr
Regular(Instruction::I32Const(max_key_len as i32)), // key_len
Regular(Instruction::Call(0)),
Regular(Instruction::Drop),
])),
@@ -1119,8 +1138,8 @@ benchmarks! {
for key in keys {
Storage::<T>::write(
&info.trie_id,
key.as_slice().try_into().map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 1024) as usize]),
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len
None,
false,
)
@@ -1132,19 +1151,20 @@ benchmarks! {
// We make sure that all storage accesses are to unique keys.
#[skip_meta]
seal_get_storage {
let r in 0 .. API_BENCHMARK_BATCHES;
let r in 0 .. API_BENCHMARK_BATCHES/2;
let max_key_len = T::MaxStorageKeyLen::get();
let keys = (0 .. r * API_BENCHMARK_BATCH_SIZE)
.map(|n| T::Hashing::hash_of(&n).as_ref().to_vec())
.collect::<Vec<_>>();
let key_len = keys.get(0).map(|i| i.len() as u32).unwrap_or(0);
.map(|n| { let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); h })
.collect::<Vec<_>>();
let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
let key_bytes_len = key_bytes.len();
let code = WasmModule::<T>::from(ModuleDefinition {
memory: Some(ImportedMemory::max::<T>()),
imported_functions: vec![ImportedFunction {
module: "seal0",
module: "__unstable__",
name: "seal_get_storage",
params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
return_type: Some(ValueType::I32),
}],
data_segments: vec![
@@ -1158,7 +1178,8 @@ benchmarks! {
},
],
call_body: Some(body::repeated_dyn(r * API_BENCHMARK_BATCH_SIZE, vec![
Counter(0, key_len as u32), // key_ptr
Counter(0, max_key_len as u32), // key_ptr
Regular(Instruction::I32Const(max_key_len as i32)), // key_len
Regular(Instruction::I32Const((key_bytes_len + 4) as i32)), // out_ptr
Regular(Instruction::I32Const(key_bytes_len as i32)), // out_len_ptr
Regular(Instruction::Call(0)),
@@ -1171,7 +1192,7 @@ benchmarks! {
for key in keys {
Storage::<T>::write(
&info.trie_id,
key.as_slice().try_into().map_err(|e| "Key has wrong length")?,
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![]),
None,
false,
@@ -1184,19 +1205,20 @@ benchmarks! {
#[skip_meta]
seal_get_storage_per_kb {
let n in 0 .. T::Schedule::get().limits.payload_len / 1024;
let keys = (0 .. API_BENCHMARK_BATCH_SIZE)
.map(|n| T::Hashing::hash_of(&n).as_ref().to_vec())
.collect::<Vec<_>>();
let key_len = keys.get(0).map(|i| i.len() as u32).unwrap_or(0);
let n in 0 .. T::Schedule::get().limits.payload_len / 2048; // half of the max payload_len in kb
let max_key_len = T::MaxStorageKeyLen::get();
let keys = (0 .. n * API_BENCHMARK_BATCH_SIZE)
.map(|n| { let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); h })
.collect::<Vec<_>>();
let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
let key_bytes_len = key_bytes.len();
let code = WasmModule::<T>::from(ModuleDefinition {
memory: Some(ImportedMemory::max::<T>()),
imported_functions: vec![ImportedFunction {
module: "seal0",
module: "__unstable__",
name: "seal_get_storage",
params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
return_type: Some(ValueType::I32),
}],
data_segments: vec![
@@ -1210,7 +1232,8 @@ benchmarks! {
},
],
call_body: Some(body::repeated_dyn(API_BENCHMARK_BATCH_SIZE, vec![
Counter(0, key_len as u32), // key_ptr
Counter(0, max_key_len as u32), // key_ptr
Regular(Instruction::I32Const(max_key_len as i32)), // key_len
Regular(Instruction::I32Const((key_bytes_len + 4) as i32)), // out_ptr
Regular(Instruction::I32Const(key_bytes_len as i32)), // out_len_ptr
Regular(Instruction::Call(0)),
@@ -1223,8 +1246,8 @@ benchmarks! {
for key in keys {
Storage::<T>::write(
&info.trie_id,
key.as_slice().try_into().map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 1024) as usize]),
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len
None,
false,
)
@@ -1237,19 +1260,20 @@ benchmarks! {
// We make sure that all storage accesses are to unique keys.
#[skip_meta]
seal_contains_storage {
let r in 0 .. API_BENCHMARK_BATCHES;
let r in 0 .. API_BENCHMARK_BATCHES/2;
let max_key_len = T::MaxStorageKeyLen::get();
let keys = (0 .. r * API_BENCHMARK_BATCH_SIZE)
.map(|n| T::Hashing::hash_of(&n).as_ref().to_vec())
.collect::<Vec<_>>();
let key_len = keys.get(0).map(|i| i.len() as u32).unwrap_or(0);
.map(|n| { let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); h })
.collect::<Vec<_>>();
let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
let key_bytes_len = key_bytes.len();
let code = WasmModule::<T>::from(ModuleDefinition {
memory: Some(ImportedMemory::max::<T>()),
imported_functions: vec![ImportedFunction {
module: "seal0",
module: "__unstable__",
name: "seal_contains_storage",
params: vec![ValueType::I32],
params: vec![ValueType::I32, ValueType::I32],
return_type: Some(ValueType::I32),
}],
data_segments: vec![
@@ -1259,7 +1283,8 @@ benchmarks! {
},
],
call_body: Some(body::repeated_dyn(r * API_BENCHMARK_BATCH_SIZE, vec![
Counter(0, key_len as u32), // key_ptr
Counter(0, max_key_len as u32), // key_ptr
Regular(Instruction::I32Const(max_key_len as i32)), // key_len
Regular(Instruction::Call(0)),
Regular(Instruction::Drop),
])),
@@ -1270,7 +1295,7 @@ benchmarks! {
for key in keys {
Storage::<T>::write(
&info.trie_id,
key.as_slice().try_into().map_err(|e| "Key has wrong length")?,
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![]),
None,
false,
@@ -1283,18 +1308,19 @@ benchmarks! {
#[skip_meta]
seal_contains_storage_per_kb {
let n in 0 .. T::Schedule::get().limits.payload_len / 1024;
let keys = (0 .. API_BENCHMARK_BATCH_SIZE)
.map(|n| T::Hashing::hash_of(&n).as_ref().to_vec())
.collect::<Vec<_>>();
let key_len = keys.get(0).map(|i| i.len() as u32).unwrap_or(0);
let n in 0 .. T::Schedule::get().limits.payload_len / 2048; // half of the max payload_len in kb
let max_key_len = T::MaxStorageKeyLen::get();
let keys = (0 .. n * API_BENCHMARK_BATCH_SIZE)
.map(|n| { let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); h })
.collect::<Vec<_>>();
let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
let code = WasmModule::<T>::from(ModuleDefinition {
memory: Some(ImportedMemory::max::<T>()),
imported_functions: vec![ImportedFunction {
module: "seal0",
module: "__unstable__",
name: "seal_contains_storage",
params: vec![ValueType::I32],
params: vec![ValueType::I32, ValueType::I32],
return_type: Some(ValueType::I32),
}],
data_segments: vec![
@@ -1304,7 +1330,8 @@ benchmarks! {
},
],
call_body: Some(body::repeated_dyn(API_BENCHMARK_BATCH_SIZE, vec![
Counter(0, key_len as u32), // key_ptr
Counter(0, max_key_len as u32), // key_ptr
Regular(Instruction::I32Const(max_key_len as i32)), // key_len
Regular(Instruction::Call(0)),
Regular(Instruction::Drop),
])),
@@ -1315,8 +1342,8 @@ benchmarks! {
for key in keys {
Storage::<T>::write(
&info.trie_id,
key.as_slice().try_into().map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 1024) as usize]),
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len
None,
false,
)
@@ -1328,11 +1355,12 @@ benchmarks! {
#[skip_meta]
seal_take_storage {
let r in 0 .. API_BENCHMARK_BATCHES;
let r in 0 .. API_BENCHMARK_BATCHES/2;
let max_key_len = T::MaxStorageKeyLen::get();
let keys = (0 .. r * API_BENCHMARK_BATCH_SIZE)
.map(|n| T::Hashing::hash_of(&n).as_ref().to_vec())
.collect::<Vec<_>>();
let key_len = keys.get(0).map(|i| i.len() as u32).unwrap_or(0);
.map(|n| { let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); h })
.collect::<Vec<_>>();
let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
let key_bytes_len = key_bytes.len();
let code = WasmModule::<T>::from(ModuleDefinition {
@@ -1340,7 +1368,7 @@ benchmarks! {
imported_functions: vec![ImportedFunction {
module: "__unstable__",
name: "seal_take_storage",
params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
return_type: Some(ValueType::I32),
}],
data_segments: vec![
@@ -1354,7 +1382,8 @@ benchmarks! {
},
],
call_body: Some(body::repeated_dyn(r * API_BENCHMARK_BATCH_SIZE, vec![
Counter(0, key_len as u32), // key_ptr
Counter(0, max_key_len as u32), // key_ptr
Regular(Instruction::I32Const(max_key_len as i32)), // key_len
Regular(Instruction::I32Const((key_bytes_len + 4) as i32)), // out_ptr
Regular(Instruction::I32Const(key_bytes_len as i32)), // out_len_ptr
Regular(Instruction::Call(0)),
@@ -1367,7 +1396,7 @@ benchmarks! {
for key in keys {
Storage::<T>::write(
&info.trie_id,
key.as_slice().try_into().map_err(|e| "Key has wrong length")?,
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![]),
None,
false,
@@ -1380,11 +1409,12 @@ benchmarks! {
#[skip_meta]
seal_take_storage_per_kb {
let n in 0 .. T::Schedule::get().limits.payload_len / 1024;
let keys = (0 .. API_BENCHMARK_BATCH_SIZE)
.map(|n| T::Hashing::hash_of(&n).as_ref().to_vec())
.collect::<Vec<_>>();
let key_len = keys.get(0).map(|i| i.len() as u32).unwrap_or(0);
let n in 0 .. T::Schedule::get().limits.payload_len / 2048; // half of the max payload_len in kb
let max_key_len = T::MaxStorageKeyLen::get();
let keys = (0 .. n * API_BENCHMARK_BATCH_SIZE)
.map(|n| { let mut h = T::Hashing::hash_of(&n).as_ref().to_vec();
h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); h })
.collect::<Vec<_>>();
let key_bytes = keys.iter().flatten().cloned().collect::<Vec<_>>();
let key_bytes_len = key_bytes.len();
let code = WasmModule::<T>::from(ModuleDefinition {
@@ -1392,7 +1422,7 @@ benchmarks! {
imported_functions: vec![ImportedFunction {
module: "__unstable__",
name: "seal_take_storage",
params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32],
return_type: Some(ValueType::I32),
}],
data_segments: vec![
@@ -1406,7 +1436,8 @@ benchmarks! {
},
],
call_body: Some(body::repeated_dyn(API_BENCHMARK_BATCH_SIZE, vec![
Counter(0, key_len as u32), // key_ptr
Counter(0, max_key_len as u32), // key_ptr
Regular(Instruction::I32Const(max_key_len as i32)), // key_len
Regular(Instruction::I32Const((key_bytes_len + 4) as i32)), // out_ptr
Regular(Instruction::I32Const(key_bytes_len as i32)), // out_len_ptr
Regular(Instruction::Call(0)),
@@ -1419,8 +1450,8 @@ benchmarks! {
for key in keys {
Storage::<T>::write(
&info.trie_id,
key.as_slice().try_into().map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 1024) as usize]),
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len
None,
false,
)
substrate/frame/contracts/src/exec.rs
+385 -23
View File
@@ -27,12 +27,13 @@ use frame_support::{
storage::{with_transaction, TransactionOutcome},
traits::{Contains, Currency, ExistenceRequirement, OriginTrait, Randomness, Time},
weights::Weight,
Blake2_128Concat, BoundedVec, StorageHasher,
};
use frame_system::RawOrigin;
use pallet_contracts_primitives::ExecReturnValue;
use smallvec::{Array, SmallVec};
use sp_core::{crypto::UncheckedFrom, ecdsa::Public as ECDSAPublic};
use sp_io::crypto::secp256k1_ecdsa_recover_compressed;
use sp_io::{crypto::secp256k1_ecdsa_recover_compressed, hashing::blake2_256};
use sp_runtime::traits::Convert;
use sp_std::{marker::PhantomData, mem, prelude::*};
@@ -40,12 +41,40 @@ pub type AccountIdOf<T> = <T as frame_system::Config>::AccountId;
pub type MomentOf<T> = <<T as Config>::Time as Time>::Moment;
pub type SeedOf<T> = <T as frame_system::Config>::Hash;
pub type BlockNumberOf<T> = <T as frame_system::Config>::BlockNumber;
pub type StorageKey = [u8; 32];
pub type ExecResult = Result<ExecReturnValue, ExecError>;
/// A type that represents a topic of an event. At the moment a hash is used.
pub type TopicOf<T> = <T as frame_system::Config>::Hash;
/// Type for fix sized storage key.
pub type FixSizedKey = [u8; 32];
/// Type for variable sized storage key. Used for transparent hashing.
pub type VarSizedKey<T> = BoundedVec<u8, <T as Config>::MaxStorageKeyLen>;
/// Trait for hashing storage keys.
pub trait StorageKey<T>
where
T: Config,
{
fn hash(&self) -> Vec<u8>;
}
impl<T: Config> StorageKey<T> for FixSizedKey {
fn hash(&self) -> Vec<u8> {
blake2_256(self.as_slice()).to_vec()
}
}
impl<T> StorageKey<T> for VarSizedKey<T>
where
T: Config,
{
fn hash(&self) -> Vec<u8> {
Blake2_128Concat::hash(self.as_slice())
}
}
/// Origin of the error.
///
/// Call or instantiate both called into other contracts and pass through errors happening
@@ -140,19 +169,44 @@ pub trait Ext: sealing::Sealed {
///
/// Returns `None` if the `key` wasn't previously set by `set_storage` or
/// was deleted.
fn get_storage(&mut self, key: &StorageKey) -> Option<Vec<u8>>;
fn get_storage(&mut self, key: &FixSizedKey) -> Option<Vec<u8>>;
/// This is a variation of `get_storage()` to be used with transparent hashing.
/// These two will be merged into a single function after some refactoring is done.
/// Returns the storage entry of the executing account by the given `key`.
///
/// Returns `None` if the `key` wasn't previously set by `set_storage` or
/// was deleted.
fn get_storage_transparent(&mut self, key: &VarSizedKey<Self::T>) -> Option<Vec<u8>>;
/// Returns `Some(len)` (in bytes) if a storage item exists at `key`.
///
/// Returns `None` if the `key` wasn't previously set by `set_storage` or
/// was deleted.
fn get_storage_size(&mut self, key: &StorageKey) -> Option<u32>;
fn get_storage_size(&mut self, key: &FixSizedKey) -> Option<u32>;
/// This is the variation of `get_storage_size()` to be used with transparent hashing.
/// These two will be merged into a single function after some refactoring is done.
/// Returns `Some(len)` (in bytes) if a storage item exists at `key`.
///
/// Returns `None` if the `key` wasn't previously set by `set_storage` or
/// was deleted.
fn get_storage_size_transparent(&mut self, key: &VarSizedKey<Self::T>) -> Option<u32>;
/// Sets the storage entry by the given key to the specified value. If `value` is `None` then
/// the storage entry is deleted.
fn set_storage(
&mut self,
key: StorageKey,
key: &FixSizedKey,
value: Option<Vec<u8>>,
take_old: bool,
) -> Result<WriteOutcome, DispatchError>;
/// This is the variation of `set_storage()` to be used with transparent hashing.
/// These two will be merged into a single function after some refactoring is done.
fn set_storage_transparent(
&mut self,
key: &VarSizedKey<Self::T>,
value: Option<Vec<u8>>,
take_old: bool,
) -> Result<WriteOutcome, DispatchError>;
@@ -1085,24 +1139,48 @@ where
Self::transfer(ExistenceRequirement::KeepAlive, &self.top_frame().account_id, to, value)
}
fn get_storage(&mut self, key: &StorageKey) -> Option<Vec<u8>> {
fn get_storage(&mut self, key: &FixSizedKey) -> Option<Vec<u8>> {
Storage::<T>::read(&self.top_frame_mut().contract_info().trie_id, key)
}
fn get_storage_size(&mut self, key: &StorageKey) -> Option<u32> {
fn get_storage_transparent(&mut self, key: &VarSizedKey<T>) -> Option<Vec<u8>> {
Storage::<T>::read(&self.top_frame_mut().contract_info().trie_id, key)
}
fn get_storage_size(&mut self, key: &FixSizedKey) -> Option<u32> {
Storage::<T>::size(&self.top_frame_mut().contract_info().trie_id, key)
}
fn get_storage_size_transparent(&mut self, key: &VarSizedKey<T>) -> Option<u32> {
Storage::<T>::size(&self.top_frame_mut().contract_info().trie_id, key)
}
fn set_storage(
&mut self,
key: StorageKey,
key: &FixSizedKey,
value: Option<Vec<u8>>,
take_old: bool,
) -> Result<WriteOutcome, DispatchError> {
let frame = self.top_frame_mut();
Storage::<T>::write(
&frame.contract_info.get(&frame.account_id).trie_id,
&key,
key,
value,
Some(&mut frame.nested_storage),
take_old,
)
}
fn set_storage_transparent(
&mut self,
key: &VarSizedKey<T>,
value: Option<Vec<u8>>,
take_old: bool,
) -> Result<WriteOutcome, DispatchError> {
let frame = self.top_frame_mut();
Storage::<T>::write(
&frame.contract_info.get(&frame.account_id).trie_id,
key,
value,
Some(&mut frame.nested_storage),
take_old,
@@ -2635,35 +2713,35 @@ mod tests {
let code_hash = MockLoader::insert(Call, |ctx, _| {
// Write
assert_eq!(
ctx.ext.set_storage([1; 32], Some(vec![1, 2, 3]), false),
ctx.ext.set_storage(&[1; 32], Some(vec![1, 2, 3]), false),
Ok(WriteOutcome::New)
);
assert_eq!(
ctx.ext.set_storage([2; 32], Some(vec![4, 5, 6]), true),
ctx.ext.set_storage(&[2; 32], Some(vec![4, 5, 6]), true),
Ok(WriteOutcome::New)
);
assert_eq!(ctx.ext.set_storage([3; 32], None, false), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.set_storage([4; 32], None, true), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.set_storage([5; 32], Some(vec![]), false), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.set_storage([6; 32], Some(vec![]), true), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.set_storage(&[3; 32], None, false), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.set_storage(&[4; 32], None, true), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.set_storage(&[5; 32], Some(vec![]), false), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.set_storage(&[6; 32], Some(vec![]), true), Ok(WriteOutcome::New));
// Overwrite
assert_eq!(
ctx.ext.set_storage([1; 32], Some(vec![42]), false),
ctx.ext.set_storage(&[1; 32], Some(vec![42]), false),
Ok(WriteOutcome::Overwritten(3))
);
assert_eq!(
ctx.ext.set_storage([2; 32], Some(vec![48]), true),
ctx.ext.set_storage(&[2; 32], Some(vec![48]), true),
Ok(WriteOutcome::Taken(vec![4, 5, 6]))
);
assert_eq!(ctx.ext.set_storage([3; 32], None, false), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.set_storage([4; 32], None, true), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.set_storage(&[3; 32], None, false), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.set_storage(&[4; 32], None, true), Ok(WriteOutcome::New));
assert_eq!(
ctx.ext.set_storage([5; 32], Some(vec![]), false),
ctx.ext.set_storage(&[5; 32], Some(vec![]), false),
Ok(WriteOutcome::Overwritten(0))
);
assert_eq!(
ctx.ext.set_storage([6; 32], Some(vec![]), true),
ctx.ext.set_storage(&[6; 32], Some(vec![]), true),
Ok(WriteOutcome::Taken(vec![]))
);
@@ -2690,14 +2768,175 @@ mod tests {
});
}
#[test]
fn set_storage_transparent_works() {
let code_hash = MockLoader::insert(Call, |ctx, _| {
// Write
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([1; 64].to_vec()).unwrap(),
Some(vec![1, 2, 3]),
false
),
Ok(WriteOutcome::New)
);
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([2; 19].to_vec()).unwrap(),
Some(vec![4, 5, 6]),
true
),
Ok(WriteOutcome::New)
);
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([3; 19].to_vec()).unwrap(),
None,
false
),
Ok(WriteOutcome::New)
);
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([4; 64].to_vec()).unwrap(),
None,
true
),
Ok(WriteOutcome::New)
);
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([5; 30].to_vec()).unwrap(),
Some(vec![]),
false
),
Ok(WriteOutcome::New)
);
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([6; 128].to_vec()).unwrap(),
Some(vec![]),
true
),
Ok(WriteOutcome::New)
);
// Overwrite
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([1; 64].to_vec()).unwrap(),
Some(vec![42, 43, 44]),
false
),
Ok(WriteOutcome::Overwritten(3))
);
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([2; 19].to_vec()).unwrap(),
Some(vec![48]),
true
),
Ok(WriteOutcome::Taken(vec![4, 5, 6]))
);
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([3; 19].to_vec()).unwrap(),
None,
false
),
Ok(WriteOutcome::New)
);
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([4; 64].to_vec()).unwrap(),
None,
true
),
Ok(WriteOutcome::New)
);
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([5; 30].to_vec()).unwrap(),
Some(vec![]),
false
),
Ok(WriteOutcome::Overwritten(0))
);
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([6; 128].to_vec()).unwrap(),
Some(vec![]),
true
),
Ok(WriteOutcome::Taken(vec![]))
);
exec_success()
});
ExtBuilder::default().build().execute_with(|| {
let min_balance = <Test as Config>::Currency::minimum_balance();
let schedule = <Test as Config>::Schedule::get();
let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
set_balance(&ALICE, min_balance * 1000);
place_contract(&BOB, code_hash);
let mut storage_meter = storage::meter::Meter::new(&ALICE, None, 0).unwrap();
assert_ok!(MockStack::run_call(
ALICE,
BOB,
&mut gas_meter,
&mut storage_meter,
&schedule,
0,
vec![],
None,
));
});
}
#[test]
fn get_storage_works() {
let code_hash = MockLoader::insert(Call, |ctx, _| {
assert_eq!(
ctx.ext.set_storage(&[1; 32], Some(vec![1, 2, 3]), false),
Ok(WriteOutcome::New)
);
assert_eq!(ctx.ext.set_storage(&[2; 32], Some(vec![]), false), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.get_storage(&[1; 32]), Some(vec![1, 2, 3]));
assert_eq!(ctx.ext.get_storage(&[2; 32]), Some(vec![]));
assert_eq!(ctx.ext.get_storage(&[3; 32]), None);
exec_success()
});
ExtBuilder::default().build().execute_with(|| {
let min_balance = <Test as Config>::Currency::minimum_balance();
let schedule = <Test as Config>::Schedule::get();
let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
set_balance(&ALICE, min_balance * 1000);
place_contract(&BOB, code_hash);
let mut storage_meter = storage::meter::Meter::new(&ALICE, None, 0).unwrap();
assert_ok!(MockStack::run_call(
ALICE,
BOB,
&mut gas_meter,
&mut storage_meter,
&schedule,
0,
vec![],
None,
));
});
}
#[test]
fn get_storage_size_works() {
let code_hash = MockLoader::insert(Call, |ctx, _| {
assert_eq!(
ctx.ext.set_storage([1; 32], Some(vec![1, 2, 3]), false),
ctx.ext.set_storage(&[1; 32], Some(vec![1, 2, 3]), false),
Ok(WriteOutcome::New)
);
assert_eq!(ctx.ext.set_storage([2; 32], Some(vec![]), false), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.set_storage(&[2; 32], Some(vec![]), false), Ok(WriteOutcome::New));
assert_eq!(ctx.ext.get_storage_size(&[1; 32]), Some(3));
assert_eq!(ctx.ext.get_storage_size(&[2; 32]), Some(0));
assert_eq!(ctx.ext.get_storage_size(&[3; 32]), None);
@@ -2724,6 +2963,129 @@ mod tests {
));
});
}
#[test]
fn get_storage_transparent_works() {
let code_hash = MockLoader::insert(Call, |ctx, _| {
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([1; 19].to_vec()).unwrap(),
Some(vec![1, 2, 3]),
false
),
Ok(WriteOutcome::New)
);
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([2; 16].to_vec()).unwrap(),
Some(vec![]),
false
),
Ok(WriteOutcome::New)
);
assert_eq!(
ctx.ext.get_storage_transparent(
&VarSizedKey::<Test>::try_from([1; 19].to_vec()).unwrap()
),
Some(vec![1, 2, 3])
);
assert_eq!(
ctx.ext.get_storage_transparent(
&VarSizedKey::<Test>::try_from([2; 16].to_vec()).unwrap()
),
Some(vec![])
);
assert_eq!(
ctx.ext.get_storage_transparent(
&VarSizedKey::<Test>::try_from([3; 8].to_vec()).unwrap()
),
None
);
exec_success()
});
ExtBuilder::default().build().execute_with(|| {
let min_balance = <Test as Config>::Currency::minimum_balance();
let schedule = <Test as Config>::Schedule::get();
let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
set_balance(&ALICE, min_balance * 1000);
place_contract(&BOB, code_hash);
let mut storage_meter = storage::meter::Meter::new(&ALICE, None, 0).unwrap();
assert_ok!(MockStack::run_call(
ALICE,
BOB,
&mut gas_meter,
&mut storage_meter,
&schedule,
0,
vec![],
None,
));
});
}
#[test]
fn get_storage_size_transparent_works() {
let code_hash = MockLoader::insert(Call, |ctx, _| {
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([1; 19].to_vec()).unwrap(),
Some(vec![1, 2, 3]),
false
),
Ok(WriteOutcome::New)
);
assert_eq!(
ctx.ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([2; 16].to_vec()).unwrap(),
Some(vec![]),
false
),
Ok(WriteOutcome::New)
);
assert_eq!(
ctx.ext.get_storage_size_transparent(
&VarSizedKey::<Test>::try_from([1; 19].to_vec()).unwrap()
),
Some(3)
);
assert_eq!(
ctx.ext.get_storage_size_transparent(
&VarSizedKey::<Test>::try_from([2; 16].to_vec()).unwrap()
),
Some(0)
);
assert_eq!(
ctx.ext.get_storage_size_transparent(
&VarSizedKey::<Test>::try_from([3; 8].to_vec()).unwrap()
),
None
);
exec_success()
});
ExtBuilder::default().build().execute_with(|| {
let min_balance = <Test as Config>::Currency::minimum_balance();
let schedule = <Test as Config>::Schedule::get();
let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
set_balance(&ALICE, min_balance * 1000);
place_contract(&BOB, code_hash);
let mut storage_meter = storage::meter::Meter::new(&ALICE, None, 0).unwrap();
assert_ok!(MockStack::run_call(
ALICE,
BOB,
&mut gas_meter,
&mut storage_meter,
&schedule,
0,
vec![],
None,
));
});
}
#[test]
fn ecdsa_to_eth_address_returns_proper_value() {
let bob_ch = MockLoader::insert(Call, |ctx, _| {
substrate/frame/contracts/src/lib.rs
+14 -7
View File
@@ -98,11 +98,6 @@ pub mod weights;
#[cfg(test)]
mod tests;
pub use crate::{
exec::Frame,
pallet::*,
schedule::{HostFnWeights, InstructionWeights, Limits, Schedule},
};
use crate::{
exec::{AccountIdOf, ExecError, Executable, Stack as ExecStack},
gas::GasMeter,
@@ -129,6 +124,12 @@ use sp_core::{crypto::UncheckedFrom, Bytes};
use sp_runtime::traits::{Convert, Hash, Saturating, StaticLookup};
use sp_std::{fmt::Debug, marker::PhantomData, prelude::*};
pub use crate::{
exec::{Frame, VarSizedKey as StorageKey},
pallet::*,
schedule::{HostFnWeights, InstructionWeights, Limits, Schedule},
};
type CodeHash<T> = <T as frame_system::Config>::Hash;
type TrieId = BoundedVec<u8, ConstU32<128>>;
type BalanceOf<T> =
@@ -372,6 +373,9 @@ pub mod pallet {
/// new instrumentation increases the size beyond the limit it would make that contract
/// inaccessible until rectified by another runtime upgrade.
type RelaxedMaxCodeLen: Get<u32>;
/// The maximum allowable length in bytes for storage keys.
type MaxStorageKeyLen: Get<u32>;
}
#[pallet::hooks]
@@ -942,11 +946,14 @@ where
}
/// Query storage of a specified contract under a specified key.
pub fn get_storage(address: T::AccountId, key: [u8; 32]) -> GetStorageResult {
pub fn get_storage(address: T::AccountId, key: Vec<u8>) -> GetStorageResult {
let contract_info =
ContractInfoOf::<T>::get(&address).ok_or(ContractAccessError::DoesntExist)?;
let maybe_value = Storage::<T>::read(&contract_info.trie_id, &key);
let maybe_value = Storage::<T>::read(
&contract_info.trie_id,
&StorageKey::<T>::try_from(key).map_err(|_| ContractAccessError::KeyDecodingFailed)?,
);
Ok(maybe_value)
}
substrate/frame/contracts/src/storage.rs
+8 -8
View File
@@ -32,7 +32,7 @@ use frame_support::{
};
use scale_info::TypeInfo;
use sp_core::crypto::UncheckedFrom;
use sp_io::{hashing::blake2_256, KillStorageResult};
use sp_io::KillStorageResult;
use sp_runtime::{
traits::{Hash, Zero},
RuntimeDebug,
@@ -124,16 +124,16 @@ where
///
/// The read is performed from the `trie_id` only. The `address` is not necessary. If the
/// contract doesn't store under the given `key` `None` is returned.
pub fn read(trie_id: &TrieId, key: &StorageKey) -> Option<Vec<u8>> {
child::get_raw(&child_trie_info(trie_id), &blake2_256(key))
pub fn read<K: StorageKey<T>>(trie_id: &TrieId, key: &K) -> Option<Vec<u8>> {
child::get_raw(&child_trie_info(trie_id), key.hash().as_slice())
}
/// Returns `Some(len)` (in bytes) if a storage item exists at `key`.
///
/// Returns `None` if the `key` wasn't previously set by `set_storage` or
/// was deleted.
pub fn size(trie_id: &TrieId, key: &StorageKey) -> Option<u32> {
child::len(&child_trie_info(trie_id), &blake2_256(key))
pub fn size<K: StorageKey<T>>(trie_id: &TrieId, key: &K) -> Option<u32> {
child::len(&child_trie_info(trie_id), key.hash().as_slice())
}
/// Update a storage entry into a contract's kv storage.
@@ -143,15 +143,15 @@ where
///
/// This function also records how much storage was created or removed if a `storage_meter`
/// is supplied. It should only be absent for testing or benchmarking code.
pub fn write(
pub fn write<K: StorageKey<T>>(
trie_id: &TrieId,
key: &StorageKey,
key: &K,
new_value: Option<Vec<u8>>,
storage_meter: Option<&mut meter::NestedMeter<T>>,
take: bool,
) -> Result<WriteOutcome, DispatchError> {
let hashed_key = blake2_256(key);
let child_trie_info = &child_trie_info(trie_id);
let hashed_key = key.hash();
let (old_len, old_value) = if take {
let val = child::get_raw(child_trie_info, &hashed_key);
(val.as_ref().map(|v| v.len() as u32), val)
substrate/frame/contracts/src/tests.rs
+18 -5
View File
@@ -20,7 +20,7 @@ use crate::{
ChainExtension, Environment, Ext, InitState, Result as ExtensionResult, RetVal,
ReturnFlags, SysConfig, UncheckedFrom,
},
exec::Frame,
exec::{FixSizedKey, Frame},
storage::Storage,
wasm::{PrefabWasmModule, ReturnCode as RuntimeReturnCode},
weights::WeightInfo,
@@ -291,6 +291,7 @@ impl Config for Test {
type ContractAccessWeight = DefaultContractAccessWeight<BlockWeights>;
type MaxCodeLen = ConstU32<{ 128 * 1024 }>;
type RelaxedMaxCodeLen = ConstU32<{ 256 * 1024 }>;
type MaxStorageKeyLen = ConstU32<128>;
}
pub const ALICE: AccountId32 = AccountId32::new([1u8; 32]);
@@ -1723,8 +1724,14 @@ fn lazy_removal_partial_remove_works() {
// Put value into the contracts child trie
for val in &vals {
Storage::<Test>::write(&info.trie_id, &val.0, Some(val.2.clone()), None, false)
.unwrap();
Storage::<Test>::write(
&info.trie_id,
&val.0 as &FixSizedKey,
Some(val.2.clone()),
None,
false,
)
.unwrap();
}
<ContractInfoOf<Test>>::insert(&addr, info.clone());
@@ -1903,8 +1910,14 @@ fn lazy_removal_does_not_use_all_weight() {
// Put value into the contracts child trie
for val in &vals {
Storage::<Test>::write(&info.trie_id, &val.0, Some(val.2.clone()), None, false)
.unwrap();
Storage::<Test>::write(
&info.trie_id,
&val.0 as &FixSizedKey,
Some(val.2.clone()),
None,
false,
)
.unwrap();
}
<ContractInfoOf<Test>>::insert(&addr, info.clone());
substrate/frame/contracts/src/wasm/mod.rs
+373 -60
View File
@@ -275,7 +275,8 @@ mod tests {
use super::*;
use crate::{
exec::{
AccountIdOf, BlockNumberOf, ErrorOrigin, ExecError, Executable, Ext, SeedOf, StorageKey,
AccountIdOf, BlockNumberOf, ErrorOrigin, ExecError, Executable, Ext, FixSizedKey,
SeedOf, VarSizedKey,
},
gas::GasMeter,
storage::WriteOutcome,
@@ -330,7 +331,7 @@ mod tests {
}
pub struct MockExt {
storage: HashMap<StorageKey, Vec<u8>>,
storage: HashMap<Vec<u8>, Vec<u8>>,
instantiates: Vec<InstantiateEntry>,
terminations: Vec<TerminationEntry>,
calls: Vec<CallEntry>,
@@ -425,19 +426,45 @@ mod tests {
self.terminations.push(TerminationEntry { beneficiary: beneficiary.clone() });
Ok(())
}
fn get_storage(&mut self, key: &StorageKey) -> Option<Vec<u8>> {
self.storage.get(key).cloned()
fn get_storage(&mut self, key: &FixSizedKey) -> Option<Vec<u8>> {
self.storage.get(&key.to_vec()).cloned()
}
fn get_storage_size(&mut self, key: &StorageKey) -> Option<u32> {
self.storage.get(key).map(|val| val.len() as u32)
fn get_storage_transparent(&mut self, key: &VarSizedKey<Self::T>) -> Option<Vec<u8>> {
self.storage.get(&key.to_vec()).cloned()
}
fn get_storage_size(&mut self, key: &FixSizedKey) -> Option<u32> {
self.storage.get(&key.to_vec()).map(|val| val.len() as u32)
}
fn get_storage_size_transparent(&mut self, key: &VarSizedKey<Self::T>) -> Option<u32> {
self.storage.get(&key.to_vec()).map(|val| val.len() as u32)
}
fn set_storage(
&mut self,
key: StorageKey,
key: &FixSizedKey,
value: Option<Vec<u8>>,
take_old: bool,
) -> Result<WriteOutcome, DispatchError> {
let entry = self.storage.entry(key);
let key = key.to_vec();
let entry = self.storage.entry(key.clone());
let result = match (entry, take_old) {
(Entry::Vacant(_), _) => WriteOutcome::New,
(Entry::Occupied(entry), false) =>
WriteOutcome::Overwritten(entry.remove().len() as u32),
(Entry::Occupied(entry), true) => WriteOutcome::Taken(entry.remove()),
};
if let Some(value) = value {
self.storage.insert(key, value);
}
Ok(result)
}
fn set_storage_transparent(
&mut self,
key: &VarSizedKey<Self::T>,
value: Option<Vec<u8>>,
take_old: bool,
) -> Result<WriteOutcome, DispatchError> {
let key = key.to_vec();
let entry = self.storage.entry(key.clone());
let result = match (entry, take_old) {
(Entry::Vacant(_), _) => WriteOutcome::New,
(Entry::Occupied(entry), false) =>
@@ -836,6 +863,7 @@ mod tests {
}
#[test]
#[cfg(not(feature = "unstable-interface"))]
fn contains_storage_works() {
const CODE: &str = r#"
(module
@@ -844,11 +872,10 @@ mod tests {
(import "seal0" "seal_contains_storage" (func $seal_contains_storage (param i32) (result i32)))
(import "env" "memory" (memory 1 1))
;; [0, 4) size of input buffer (32 byte as we copy the key here)
;; [0, 4) size of input buffer (32 bytes as we copy the key here)
(data (i32.const 0) "\20")
;; [4, 36) input buffer
;; [36, inf) output buffer
(func (export "call")
@@ -879,8 +906,8 @@ mod tests {
let mut ext = MockExt::default();
ext.storage.insert([1u8; 32], vec![42u8]);
ext.storage.insert([2u8; 32], vec![]);
ext.storage.insert(vec![1u8; 32], vec![42u8]);
ext.storage.insert(vec![2u8; 32], vec![]);
// value does not exist -> sentinel value returned
let result = execute(CODE, [3u8; 32].encode(), &mut ext).unwrap();
@@ -895,6 +922,84 @@ mod tests {
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 0,);
}
#[test]
#[cfg(feature = "unstable-interface")]
fn contains_storage_works() {
const CODE: &str = r#"
(module
(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
(import "__unstable__" "seal_contains_storage" (func $seal_contains_storage (param i32 i32) (result i32)))
(import "env" "memory" (memory 1 1))
;; size of input buffer
;; [0, 4) size of input buffer (128+32 = 160 bytes = 0xA0)
(data (i32.const 0) "\A0")
;; [4, 164) input buffer
(func (export "call")
;; Receive key
(call $seal_input
(i32.const 4) ;; Where we take input and store it
(i32.const 0) ;; Where we take and store the length of the data
)
;; Call seal_clear_storage and save what it returns at 0
(i32.store (i32.const 0)
(call $seal_contains_storage
(i32.const 8) ;; key_ptr
(i32.load (i32.const 4)) ;; key_len
)
)
(call $seal_return
(i32.const 0) ;; flags
(i32.const 0) ;; returned value
(i32.const 4) ;; length of returned value
)
)
(func (export "deploy"))
)
"#;
let mut ext = MockExt::default();
ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([1u8; 64].to_vec()).unwrap(),
Some(vec![42u8]),
false,
)
.unwrap();
ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([2u8; 19].to_vec()).unwrap(),
Some(vec![]),
false,
)
.unwrap();
//value does not exist (wrong key length)
let input = (63, [1u8; 64]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
// sentinel returned
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), crate::SENTINEL);
// value exists
let input = (64, [1u8; 64]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
// true as u32 returned
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 1);
// getter does not remove the value from storage
assert_eq!(ext.storage.get(&[1u8; 64].to_vec()).unwrap(), &[42u8]);
// value exists (test for 0 sized)
let input = (19, [2u8; 19]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
// true as u32 returned
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 0);
// getter does not remove the value from storage
assert_eq!(ext.storage.get(&[2u8; 19].to_vec()).unwrap(), &([] as [u8; 0]));
}
const CODE_INSTANTIATE: &str = r#"
(module
;; seal_instantiate(
@@ -1204,7 +1309,7 @@ mod tests {
#[test]
fn get_storage_puts_data_into_buf() {
let mut mock_ext = MockExt::default();
mock_ext.storage.insert([0x11; 32], [0x22; 32].to_vec());
mock_ext.storage.insert([0x11; 32].to_vec(), [0x22; 32].to_vec());
let output = execute(CODE_GET_STORAGE, vec![], mock_ext).unwrap();
@@ -2176,6 +2281,7 @@ mod tests {
}
#[test]
#[cfg(not(feature = "unstable-interface"))]
fn set_storage_works() {
const CODE: &str = r#"
(module
@@ -2199,7 +2305,7 @@ mod tests {
(call $seal_set_storage
(i32.const 4) ;; key_ptr
(i32.const 36) ;; value_ptr
(i32.sub ;; value_len (input_size - key_size)
(i32.sub ;; value_len (input_size - key_size)
(i32.load (i32.const 0))
(i32.const 32)
)
@@ -2207,7 +2313,7 @@ mod tests {
)
(call $seal_return
(i32.const 0) ;; flags
(i32.const 0) ;; returned value
(i32.const 0) ;; pointer to returned value
(i32.const 4) ;; length of returned value
)
)
@@ -2222,19 +2328,184 @@ mod tests {
let input = ([1u8; 32], [42u8, 48]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), crate::SENTINEL);
assert_eq!(ext.storage.get(&[1u8; 32]).unwrap(), &[42u8, 48]);
assert_eq!(ext.storage.get(&[1u8; 32].to_vec()).unwrap(), &[42u8, 48]);
// value do exist -> length of old value returned
let input = ([1u8; 32], [0u8; 0]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 2);
assert_eq!(ext.storage.get(&[1u8; 32]).unwrap(), &[0u8; 0]);
assert_eq!(ext.storage.get(&[1u8; 32].to_vec()).unwrap(), &[0u8; 0]);
// value do exist -> length of old value returned (test for zero sized val)
let input = ([1u8; 32], [99u8]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 0);
assert_eq!(ext.storage.get(&[1u8; 32]).unwrap(), &[99u8]);
assert_eq!(ext.storage.get(&[1u8; 32].to_vec()).unwrap(), &[99u8]);
}
#[test]
#[cfg(feature = "unstable-interface")]
fn set_storage_works() {
const CODE: &str = r#"
(module
(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
(import "__unstable__" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32 i32) (result i32)))
(import "env" "memory" (memory 1 1))
;; [0, 4) size of input buffer
;; 4k in little endian
(data (i32.const 0) "\00\10")
;; [4, 4100) input buffer
(func (export "call")
;; Receive (key ++ value_to_write)
(call $seal_input
(i32.const 4) ;; Pointer to the input buffer
(i32.const 0) ;; Size of the input buffer
)
;; Store the passed value to the passed key and store result to memory
(i32.store (i32.const 168)
(call $seal_set_storage
(i32.const 8) ;; key_ptr
(i32.load (i32.const 4)) ;; key_len
(i32.add ;; value_ptr = 8 + key_len
(i32.const 8)
(i32.load (i32.const 4)))
(i32.sub ;; value_len (input_size - (key_len + key_len_len))
(i32.load (i32.const 0))
(i32.add
(i32.load (i32.const 4))
(i32.const 4)
)
)
)
)
(call $seal_return
(i32.const 0) ;; flags
(i32.const 168) ;; ptr to returned value
(i32.const 4) ;; length of returned value
)
)
(func (export "deploy"))
)
"#;
let mut ext = MockExt::default();
// value did not exist before -> sentinel returned
let input = (32, [1u8; 32], [42u8, 48]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), crate::SENTINEL);
assert_eq!(ext.storage.get(&[1u8; 32].to_vec()).unwrap(), &[42u8, 48]);
// value do exist -> length of old value returned
let input = (32, [1u8; 32], [0u8; 0]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 2);
assert_eq!(ext.storage.get(&[1u8; 32].to_vec()).unwrap(), &[0u8; 0]);
// value do exist -> length of old value returned (test for zero sized val)
let input = (32, [1u8; 32], [99u8]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 0);
assert_eq!(ext.storage.get(&[1u8; 32].to_vec()).unwrap(), &[99u8]);
}
#[test]
#[cfg(feature = "unstable-interface")]
fn get_storage_works() {
const CODE: &str = r#"
(module
(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
(import "__unstable__" "seal_get_storage" (func $seal_get_storage (param i32 i32 i32 i32) (result i32)))
(import "env" "memory" (memory 1 1))
;; [0, 4) size of input buffer (160 bytes as we copy the key+len here)
(data (i32.const 0) "\A0")
;; [4, 8) size of output buffer
;; 4k in little endian
(data (i32.const 4) "\00\10")
;; [8, 168) input buffer
;; [168, 4264) output buffer
(func (export "call")
;; Receive (key ++ value_to_write)
(call $seal_input
(i32.const 8) ;; Pointer to the input buffer
(i32.const 0) ;; Size of the input buffer
)
;; Load a storage value and result of this call into the output buffer
(i32.store (i32.const 168)
(call $seal_get_storage
(i32.const 12) ;; key_ptr
(i32.load (i32.const 8)) ;; key_len
(i32.const 172) ;; Pointer to the output buffer
(i32.const 4) ;; Pointer to the size of the buffer
)
)
(call $seal_return
(i32.const 0) ;; flags
(i32.const 168) ;; output buffer ptr
(i32.add ;; length: output size + 4 (retval)
(i32.load (i32.const 4))
(i32.const 4)
)
)
)
(func (export "deploy"))
)
"#;
let mut ext = MockExt::default();
ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([1u8; 64].to_vec()).unwrap(),
Some(vec![42u8]),
false,
)
.unwrap();
ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([2u8; 19].to_vec()).unwrap(),
Some(vec![]),
false,
)
.unwrap();
// value does not exist
let input = (63, [1u8; 64]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
assert_eq!(
u32::from_le_bytes(result.data.0[0..4].try_into().unwrap()),
ReturnCode::KeyNotFound as u32
);
// value exists
let input = (64, [1u8; 64]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
assert_eq!(
u32::from_le_bytes(result.data.0[0..4].try_into().unwrap()),
ReturnCode::Success as u32
);
assert_eq!(ext.storage.get(&[1u8; 64].to_vec()).unwrap(), &[42u8]);
assert_eq!(&result.data.0[4..], &[42u8]);
// value exists (test for 0 sized)
let input = (19, [2u8; 19]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
assert_eq!(
u32::from_le_bytes(result.data.0[0..4].try_into().unwrap()),
ReturnCode::Success as u32
);
assert_eq!(ext.storage.get(&[2u8; 19].to_vec()), Some(&vec![]));
assert_eq!(&result.data.0[4..], &([] as [u8; 0]));
}
#[test]
@@ -2244,23 +2515,26 @@ mod tests {
(module
(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
(import "__unstable__" "seal_clear_storage" (func $seal_clear_storage (param i32) (result i32)))
(import "__unstable__" "seal_clear_storage" (func $seal_clear_storage (param i32 i32) (result i32)))
(import "env" "memory" (memory 1 1))
;; 0x1000 = 4k in little endian
;; size of input buffer
(data (i32.const 0) "\00\10")
;; [0, 4) size of input buffer (128+32 = 160 bytes = 0xA0)
(data (i32.const 0) "\A0")
;; [4, 164) input buffer
(func (export "call")
;; Receive key
(call $seal_input
(i32.const 4) ;; Pointer to the input buffer
(i32.const 0) ;; Size of the length buffer
(i32.const 4) ;; Where we take input and store it
(i32.const 0) ;; Where we take and store the length of thedata
)
;; Store the passed value to the passed key and store result to memory
;; Call seal_clear_storage and save what it returns at 0
(i32.store (i32.const 0)
(call $seal_clear_storage
(i32.const 4) ;; key_ptr
(i32.const 8) ;; key_ptr
(i32.load (i32.const 4)) ;; key_len
)
)
(call $seal_return
@@ -2276,23 +2550,48 @@ mod tests {
let mut ext = MockExt::default();
ext.storage.insert([1u8; 32], vec![42u8]);
ext.storage.insert([2u8; 32], vec![]);
ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([1u8; 64].to_vec()).unwrap(),
Some(vec![42u8]),
false,
)
.unwrap();
ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([2u8; 19].to_vec()).unwrap(),
Some(vec![]),
false,
)
.unwrap();
// value does not exist -> sentinel returned
let result = execute(CODE, [3u8; 32].encode(), &mut ext).unwrap();
// value did not exist
let input = (32, [3u8; 32]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
// sentinel returned
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), crate::SENTINEL);
assert_eq!(ext.storage.get(&[3u8; 32]), None);
assert_eq!(ext.storage.get(&[3u8; 32].to_vec()), None);
// value did exist -> length returned
let result = execute(CODE, [1u8; 32].encode(), &mut ext).unwrap();
// value did exist
let input = (64, [1u8; 64]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
// length returned
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 1);
assert_eq!(ext.storage.get(&[1u8; 32]), None);
// value cleared
assert_eq!(ext.storage.get(&[1u8; 64].to_vec()), None);
// value did exist -> length returned (test for 0 sized)
let result = execute(CODE, [2u8; 32].encode(), &mut ext).unwrap();
//value did not exist (wrong key length)
let input = (63, [1u8; 64]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
// sentinel returned
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), crate::SENTINEL);
assert_eq!(ext.storage.get(&[1u8; 64].to_vec()), None);
// value exists
let input = (19, [2u8; 19]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
// length returned (test for 0 sized)
assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 0);
assert_eq!(ext.storage.get(&[2u8; 32]), None);
// value cleared
assert_eq!(ext.storage.get(&[2u8; 19].to_vec()), None);
}
#[test]
@@ -2302,42 +2601,42 @@ mod tests {
(module
(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
(import "__unstable__" "seal_take_storage" (func $seal_take_storage (param i32 i32 i32) (result i32)))
(import "__unstable__" "seal_take_storage" (func $seal_take_storage (param i32 i32 i32 i32) (result i32)))
(import "env" "memory" (memory 1 1))
;; [0, 32) size of input buffer (32 byte as we copy the key here)
(data (i32.const 0) "\20")
;; [0, 4) size of input buffer (160 bytes as we copy the key+len here)
(data (i32.const 0) "\A0")
;; [32, 64) size of output buffer
;; [4, 8) size of output buffer
;; 4k in little endian
(data (i32.const 32) "\00\10")
(data (i32.const 4) "\00\10")
;; [64, 96) input buffer
;; [96, inf) output buffer
;; [8, 168) input buffer
;; [168, 4264) output buffer
(func (export "call")
;; Receive key
(call $seal_input
(i32.const 64) ;; Pointer to the input buffer
(i32.const 8) ;; Pointer to the input buffer
(i32.const 0) ;; Size of the length buffer
)
;; Load a storage value and result of this call into the output buffer
(i32.store (i32.const 96)
(i32.store (i32.const 168)
(call $seal_take_storage
(i32.const 64) ;; The pointer to the storage key to fetch
(i32.const 100) ;; Pointer to the output buffer
(i32.const 32) ;; Pointer to the size of the buffer
(i32.const 12) ;; key_ptr
(i32.load (i32.const 8)) ;; key_len
(i32.const 172) ;; Pointer to the output buffer
(i32.const 4) ;; Pointer to the size of the buffer
)
)
;; Return the contents of the buffer
(call $seal_return
(i32.const 0) ;; flags
(i32.const 96) ;; output buffer ptr
(i32.add ;; length: storage size + 4 (retval)
(i32.load (i32.const 32))
(i32.const 0) ;; flags
(i32.const 168) ;; output buffer ptr
(i32.add ;; length: storage size + 4 (retval)
(i32.load (i32.const 4))
(i32.const 4)
)
)
@@ -2349,32 +2648,46 @@ mod tests {
let mut ext = MockExt::default();
ext.storage.insert([1u8; 32], vec![42u8]);
ext.storage.insert([2u8; 32], vec![]);
ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([1u8; 64].to_vec()).unwrap(),
Some(vec![42u8]),
false,
)
.unwrap();
ext.set_storage_transparent(
&VarSizedKey::<Test>::try_from([2u8; 19].to_vec()).unwrap(),
Some(vec![]),
false,
)
.unwrap();
// value does not exist -> error returned
let result = execute(CODE, [3u8; 32].encode(), &mut ext).unwrap();
let input = (63, [1u8; 64]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
assert_eq!(
u32::from_le_bytes(result.data.0[0..4].try_into().unwrap()),
ReturnCode::KeyNotFound as u32
);
// value did exist -> value returned
let result = execute(CODE, [1u8; 32].encode(), &mut ext).unwrap();
let input = (64, [1u8; 64]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
assert_eq!(
u32::from_le_bytes(result.data.0[0..4].try_into().unwrap()),
ReturnCode::Success as u32
);
assert_eq!(ext.storage.get(&[1u8; 32]), None);
assert_eq!(ext.storage.get(&[1u8; 64].to_vec()), None);
assert_eq!(&result.data.0[4..], &[42u8]);
// value did exist -> length returned (test for 0 sized)
let result = execute(CODE, [2u8; 32].encode(), &mut ext).unwrap();
let input = (19, [2u8; 19]).encode();
let result = execute(CODE, input, &mut ext).unwrap();
assert_eq!(
u32::from_le_bytes(result.data.0[0..4].try_into().unwrap()),
ReturnCode::Success as u32
);
assert_eq!(ext.storage.get(&[2u8; 32]), None);
assert_eq!(ext.storage.get(&[2u8; 19].to_vec()), None);
assert_eq!(&result.data.0[4..], &[0u8; 0]);
}
substrate/frame/contracts/src/wasm/runtime.rs
+180 -40
View File
@@ -18,15 +18,16 @@
//! Environment definition of the wasm smart-contract runtime.
use crate::{
exec::{ExecError, ExecResult, Ext, StorageKey, TopicOf},
exec::{ExecError, ExecResult, Ext, FixSizedKey, TopicOf, VarSizedKey},
gas::{ChargedAmount, Token},
schedule::HostFnWeights,
wasm::env_def::ConvertibleToWasm,
BalanceOf, CodeHash, Config, Error, SENTINEL,
};
use bitflags::bitflags;
use codec::{Decode, DecodeAll, Encode, MaxEncodedLen};
use frame_support::{dispatch::DispatchError, ensure, weights::Weight};
use frame_support::{dispatch::DispatchError, ensure, traits::Get, weights::Weight};
use pallet_contracts_primitives::{ExecReturnValue, ReturnFlags};
use sp_core::{crypto::UncheckedFrom, Bytes};
use sp_io::hashing::{blake2_128, blake2_256, keccak_256, sha2_256};
@@ -35,6 +36,28 @@ use sp_sandbox::SandboxMemory;
use sp_std::prelude::*;
use wasm_instrument::parity_wasm::elements::ValueType;
/// Type of a storage key.
#[allow(dead_code)]
enum KeyType {
/// Deprecated fix sized key [0;32].
Fix,
/// Variable sized key used in transparent hashing,
/// cannot be larger than MaxStorageKeyLen.
Variable(u32),
}
impl KeyType {
fn len<T: Config>(&self) -> Result<u32, TrapReason> {
match self {
KeyType::Fix => Ok(32u32),
KeyType::Variable(len) => {
ensure!(len <= &<T>::MaxStorageKeyLen::get(), Error::<T>::DecodingFailed);
Ok(*len)
},
}
}
}
/// Every error that can be returned to a contract when it calls any of the host functions.
///
/// # Note
@@ -695,6 +718,7 @@ where
fn set_storage(
&mut self,
key_type: KeyType,
key_ptr: u32,
value_ptr: u32,
value_len: u32,
@@ -705,10 +729,21 @@ where
if value_len > max_size {
return Err(Error::<E::T>::ValueTooLarge.into())
}
let mut key: StorageKey = [0; 32];
self.read_sandbox_memory_into_buf(key_ptr, &mut key)?;
let key = self.read_sandbox_memory(key_ptr, key_type.len::<E::T>()?)?;
let value = Some(self.read_sandbox_memory(value_ptr, value_len)?);
let write_outcome = self.ext.set_storage(key, value, false)?;
let write_outcome = match key_type {
KeyType::Fix => self.ext.set_storage(
&FixSizedKey::try_from(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
value,
false,
)?,
KeyType::Variable(_) => self.ext.set_storage_transparent(
&VarSizedKey::<E::T>::try_from(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
value,
false,
)?,
};
self.adjust_gas(
charged,
RuntimeCosts::SetStorage { new_bytes: value_len, old_bytes: write_outcome.old_len() },
@@ -716,15 +751,70 @@ where
Ok(write_outcome.old_len_with_sentinel())
}
fn clear_storage(&mut self, key_ptr: u32) -> Result<u32, TrapReason> {
fn clear_storage(&mut self, key_type: KeyType, key_ptr: u32) -> Result<u32, TrapReason> {
let charged = self.charge_gas(RuntimeCosts::ClearStorage(self.ext.max_value_size()))?;
let mut key: StorageKey = [0; 32];
self.read_sandbox_memory_into_buf(key_ptr, &mut key)?;
let outcome = self.ext.set_storage(key, None, false)?;
let key = self.read_sandbox_memory(key_ptr, key_type.len::<E::T>()?)?;
let outcome = match key_type {
KeyType::Fix => self.ext.set_storage(
&FixSizedKey::try_from(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
None,
false,
)?,
KeyType::Variable(_) => self.ext.set_storage_transparent(
&VarSizedKey::<E::T>::try_from(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
None,
false,
)?,
};
self.adjust_gas(charged, RuntimeCosts::ClearStorage(outcome.old_len()));
Ok(outcome.old_len_with_sentinel())
}
fn get_storage(
&mut self,
key_type: KeyType,
key_ptr: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnCode, TrapReason> {
let charged = self.charge_gas(RuntimeCosts::GetStorage(self.ext.max_value_size()))?;
let key = self.read_sandbox_memory(key_ptr, key_type.len::<E::T>()?)?;
let outcome = match key_type {
KeyType::Fix => self.ext.get_storage(
&FixSizedKey::try_from(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
),
KeyType::Variable(_) => self.ext.get_storage_transparent(
&VarSizedKey::<E::T>::try_from(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
),
};
if let Some(value) = outcome {
self.adjust_gas(charged, RuntimeCosts::GetStorage(value.len() as u32));
self.write_sandbox_output(out_ptr, out_len_ptr, &value, false, already_charged)?;
Ok(ReturnCode::Success)
} else {
self.adjust_gas(charged, RuntimeCosts::GetStorage(0));
Ok(ReturnCode::KeyNotFound)
}
}
fn contains_storage(&mut self, key_type: KeyType, key_ptr: u32) -> Result<u32, TrapReason> {
let charged = self.charge_gas(RuntimeCosts::ContainsStorage(self.ext.max_value_size()))?;
let key = self.read_sandbox_memory(key_ptr, key_type.len::<E::T>()?)?;
let outcome = match key_type {
KeyType::Fix => self.ext.get_storage_size(
&FixSizedKey::try_from(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
),
KeyType::Variable(_) => self.ext.get_storage_size_transparent(
&VarSizedKey::<E::T>::try_from(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
),
};
self.adjust_gas(charged, RuntimeCosts::ClearStorage(outcome.unwrap_or(0)));
Ok(outcome.unwrap_or(SENTINEL))
}
fn call(
&mut self,
flags: CallFlags,
@@ -863,11 +953,14 @@ define_env!(Env, <E: Ext>,
// Equivalent to the newer version of `seal_set_storage` with the exception of the return
// type. Still a valid thing to call when not interested in the return value.
[seal0] seal_set_storage(ctx, key_ptr: u32, value_ptr: u32, value_len: u32) => {
ctx.set_storage(key_ptr, value_ptr, value_len).map(|_| ())
ctx.set_storage(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
},
// Set the value at the given key in the contract storage.
//
// This version is to be used with a fixed sized storage key. For runtimes supporting transparent
// hashing, please use the newer version of this function.
//
// The value length must not exceed the maximum defined by the contracts module parameters.
// Specifying a `value_len` of zero will store an empty value.
//
@@ -882,7 +975,27 @@ define_env!(Env, <E: Ext>,
// Returns the size of the pre-existing value at the specified key if any. Otherwise
// `SENTINEL` is returned as a sentinel value.
[seal1] seal_set_storage(ctx, key_ptr: u32, value_ptr: u32, value_len: u32) -> u32 => {
ctx.set_storage(key_ptr, value_ptr, value_len)
ctx.set_storage(KeyType::Fix, key_ptr, value_ptr, value_len)
},
// Set the value at the given key in the contract storage.
//
// The key and value lengths must not exceed the maximums defined by the contracts module parameters.
// Specifying a `value_len` of zero will store an empty value.
//
// # Parameters
//
// - `key_ptr`: pointer into the linear memory where the location to store the value is placed.
// - `key_len`: the length of the key in bytes.
// - `value_ptr`: pointer into the linear memory where the value to set is placed.
// - `value_len`: the length of the value in bytes.
//
// # Return Value
//
// Returns the size of the pre-existing value at the specified key if any. Otherwise
// `SENTINEL` is returned as a sentinel value.
[__unstable__] seal_set_storage(ctx, key_ptr: u32, key_len: u32, value_ptr: u32, value_len: u32) -> u32 => {
ctx.set_storage(KeyType::Variable(key_len), key_ptr, value_ptr, value_len)
},
// Clear the value at the given key in the contract storage.
@@ -890,25 +1003,29 @@ define_env!(Env, <E: Ext>,
// Equivalent to the newer version of `seal_clear_storage` with the exception of the return
// type. Still a valid thing to call when not interested in the return value.
[seal0] seal_clear_storage(ctx, key_ptr: u32) => {
ctx.clear_storage(key_ptr).map(|_| ()).map_err(Into::into)
ctx.clear_storage(KeyType::Fix, key_ptr).map(|_| ())
},
// Clear the value at the given key in the contract storage.
//
// # Parameters
//
// - `key_ptr`: pointer into the linear memory where the location to clear the value is placed.
// - `key_ptr`: pointer into the linear memory where the key is placed.
// - `key_len`: the length of the key in bytes.
//
// # Return Value
//
// Returns the size of the pre-existing value at the specified key if any. Otherwise
// `SENTINEL` is returned as a sentinel value.
[__unstable__] seal_clear_storage(ctx, key_ptr: u32) -> u32 => {
ctx.clear_storage(key_ptr).map_err(Into::into)
[__unstable__] seal_clear_storage(ctx, key_ptr: u32, key_len: u32) -> u32 => {
ctx.clear_storage(KeyType::Variable(key_len), key_ptr)
},
// Retrieve the value under the given key from storage.
//
// This version is to be used with a fixed sized storage key. For runtimes supporting transparent
// hashing, please use the newer version of this function.
//
// # Parameters
//
// - `key_ptr`: pointer into the linear memory where the key of the requested value is placed.
@@ -920,21 +1037,36 @@ define_env!(Env, <E: Ext>,
//
// `ReturnCode::KeyNotFound`
[seal0] seal_get_storage(ctx, key_ptr: u32, out_ptr: u32, out_len_ptr: u32) -> ReturnCode => {
let charged = ctx.charge_gas(RuntimeCosts::GetStorage(ctx.ext.max_value_size()))?;
let mut key: StorageKey = [0; 32];
ctx.read_sandbox_memory_into_buf(key_ptr, &mut key)?;
if let Some(value) = ctx.ext.get_storage(&key) {
ctx.adjust_gas(charged, RuntimeCosts::GetStorage(value.len() as u32));
ctx.write_sandbox_output(out_ptr, out_len_ptr, &value, false, already_charged)?;
Ok(ReturnCode::Success)
} else {
ctx.adjust_gas(charged, RuntimeCosts::GetStorage(0));
Ok(ReturnCode::KeyNotFound)
}
ctx.get_storage(KeyType::Fix, key_ptr, out_ptr, out_len_ptr)
},
// Retrieve the value under the given key from storage.
//
// This version is to be used with a fixed sized storage key. For runtimes supporting transparent
// hashing, please use the newer version of this function.
//
// The key length must not exceed the maximum defined by the contracts module parameter.
//
// # Parameters
//
// - `key_ptr`: pointer into the linear memory where the key of the requested value is placed.
// - `key_len`: the length of the key in bytes.
// - `out_ptr`: pointer to the linear memory where the value is written to.
// - `out_len_ptr`: in-out pointer into linear memory where the buffer length
// is read from and the value length is written to.
//
// # Errors
//
// `ReturnCode::KeyNotFound`
[__unstable__] seal_get_storage(ctx, key_ptr: u32, key_len: u32, out_ptr: u32, out_len_ptr: u32) -> ReturnCode => {
ctx.get_storage(KeyType::Variable(key_len), key_ptr, out_ptr, out_len_ptr)
},
// Checks whether there is a value stored under the given key.
//
// This version is to be used with a fixed sized storage key. For runtimes supporting transparent
// hashing, please use the newer version of this function.
//
// # Parameters
//
// - `key_ptr`: pointer into the linear memory where the key of the requested value is placed.
@@ -944,16 +1076,24 @@ define_env!(Env, <E: Ext>,
// Returns the size of the pre-existing value at the specified key if any. Otherwise
// `SENTINEL` is returned as a sentinel value.
[seal0] seal_contains_storage(ctx, key_ptr: u32) -> u32 => {
let charged = ctx.charge_gas(RuntimeCosts::ContainsStorage(ctx.ext.max_value_size()))?;
let mut key: StorageKey = [0; 32];
ctx.read_sandbox_memory_into_buf(key_ptr, &mut key)?;
if let Some(len) = ctx.ext.get_storage_size(&key) {
ctx.adjust_gas(charged, RuntimeCosts::ContainsStorage(len));
Ok(len)
} else {
ctx.adjust_gas(charged, RuntimeCosts::ContainsStorage(0));
Ok(SENTINEL)
}
ctx.contains_storage(KeyType::Fix, key_ptr)
},
// Checks whether there is a value stored under the given key.
//
// The key length must not exceed the maximum defined by the contracts module parameter.
//
// # Parameters
//
// - `key_ptr`: pointer into the linear memory where the key of the requested value is placed.
// - `key_len`: the length of the key in bytes.
//
// # Return Value
//
// Returns the size of the pre-existing value at the specified key if any. Otherwise
// `SENTINEL` is returned as a sentinel value.
[__unstable__] seal_contains_storage(ctx, key_ptr: u32, key_len: u32) -> u32 => {
ctx.contains_storage(KeyType::Variable(key_len), key_ptr)
},
// Retrieve and remove the value under the given key from storage.
@@ -961,6 +1101,7 @@ define_env!(Env, <E: Ext>,
// # Parameters
//
// - `key_ptr`: pointer into the linear memory where the key of the requested value is placed.
// - `key_len`: the length of the key in bytes.
// - `out_ptr`: pointer to the linear memory where the value is written to.
// - `out_len_ptr`: in-out pointer into linear memory where the buffer length
// is read from and the value length is written to.
@@ -968,11 +1109,10 @@ define_env!(Env, <E: Ext>,
// # Errors
//
// `ReturnCode::KeyNotFound`
[__unstable__] seal_take_storage(ctx, key_ptr: u32, out_ptr: u32, out_len_ptr: u32) -> ReturnCode => {
[__unstable__] seal_take_storage(ctx, key_ptr: u32, key_len: u32, out_ptr: u32, out_len_ptr: u32) -> ReturnCode => {
let charged = ctx.charge_gas(RuntimeCosts::TakeStorage(ctx.ext.max_value_size()))?;
let mut key: StorageKey = [0; 32];
ctx.read_sandbox_memory_into_buf(key_ptr, &mut key)?;
if let crate::storage::WriteOutcome::Taken(value) = ctx.ext.set_storage(key, None, true)? {
let key = ctx.read_sandbox_memory(key_ptr, key_len)?;
if let crate::storage::WriteOutcome::Taken(value) = ctx.ext.set_storage_transparent(&VarSizedKey::<E::T>::try_from(key).map_err(|_| Error::<E::T>::DecodingFailed)?, None, true)? {
ctx.adjust_gas(charged, RuntimeCosts::TakeStorage(value.len() as u32));
ctx.write_sandbox_output(out_ptr, out_len_ptr, &value, false, already_charged)?;
Ok(ReturnCode::Success)
substrate/frame/contracts/src/weights.rs
+1063 -901
View File
File diff suppressed because it is too large Load Diff