Struct ContractInfo 

pub struct ContractInfo<T: Config> {
    pub trie_id: BoundedVec<u8, ConstU32<128>>,
    pub code_hash: H256,
    pub storage_bytes: u32,
    pub storage_items: u32,
    pub storage_byte_deposit: BalanceOf<T>,
    pub storage_item_deposit: BalanceOf<T>,
    pub storage_base_deposit: BalanceOf<T>,
    pub immutable_data_len: u32,
}

Information for managing an account and its sub trie abstraction. This is the required info to cache for an account.

Fields

trie_id: BoundedVec<u8, ConstU32<128>>

Unique ID for the subtree encoded as a bytes vector.

code_hash: H256

The code associated with a given account.

storage_bytes: u32

How many bytes of storage are accumulated in this contract’s child trie.

storage_items: u32

How many items of storage are accumulated in this contract’s child trie.

storage_byte_deposit: BalanceOf<T>

This records to how much deposit the accumulated storage_bytes amount to.

storage_item_deposit: BalanceOf<T>

This records to how much deposit the accumulated storage_items amount to.

storage_base_deposit: BalanceOf<T>

This records how much deposit is put down in order to pay for the contract itself.

We need to store this information separately so it is not used when calculating any refunds since the base deposit can only ever be refunded on contract termination.

immutable_data_len: u32

The size of the immutable data of this contract.

Implementations

impl<T: Config> ContractInfo<T>

pub fn new( address: &H160, nonce: T::Nonce, code_hash: H256, ) -> Result<Self, DispatchError>

Constructs a new contract info without writing it to storage.

This returns an Err if an contract with the supplied account already exists in storage.

pub fn child_trie_info(&self) -> ChildInfo

Associated child trie unique id is built from the hash part of the trie id.

pub fn extra_deposit(&self) -> BalanceOf<T>

The deposit paying for the accumulated storage generated within the contract’s child trie.

pub fn total_deposit(&self) -> BalanceOf<T>

Same as Self::extra_deposit but including the base deposit.

pub fn storage_base_deposit(&self) -> BalanceOf<T>

Returns the storage base deposit of the contract.

pub fn read(&self, key: &Key) -> Option<Vec<u8>>

Reads a storage kv pair of a contract.

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 size(&self, key: &Key) -> Option<u32>

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 write( &self, key: &Key, new_value: Option<Vec<u8>>, frame_meter: Option<&mut FrameMeter<T>>, take: bool, ) -> Result<WriteOutcome, DispatchError>

Update a storage entry into a contract’s kv storage.

If the new_value is None then the kv pair is removed. If take is true a [WriteOutcome::Taken] is returned instead of a [WriteOutcome::Overwritten].

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 update_base_deposit( &mut self, code_deposit: BalanceOf<T>, ) -> BalanceOf<T>

Sets and returns the contract base deposit.

The base deposit is updated when the code_hash of the contract changes, as it depends on the deposit paid to upload the contract’s code. It also depends on the size of immutable storage which is also changed when the code hash of a contract is changed.

pub fn queue_trie_for_deletion(trie_id: BoundedVec<u8, ConstU32<128>>)

Push a contract’s trie to the deletion queue for lazy removal.

You must make sure that the contract is also removed when queuing the trie for deletion.

pub fn deletion_budget(meter: &WeightMeter) -> (Weight, u32)

Calculates the weight that is necessary to remove one key from the trie and how many of those keys can be deleted from the deletion queue given the supplied weight limit.

pub fn process_deletion_queue_batch(meter: &mut WeightMeter)

Delete as many items from the deletion queue possible within the supplied weight limit.

pub fn load_code_hash(account: &<T as Config>::AccountId) -> Option<H256>

Returns the code hash of the contract specified by account ID.

pub fn immutable_data_len(&self) -> u32

Returns the amount of immutable bytes of this contract.

pub fn set_immutable_data_len(&mut self, immutable_data_len: u32)

Set the number of immutable bytes of this contract.

Trait Implementations

impl<T: Config> Clone for ContractInfo<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Config> Debug for ContractInfo<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Config> Decode for ContractInfo<T>

where BalanceOf<T>: Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T: Config> Encode for ContractInfo<T>

where BalanceOf<T>: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T: Config> MaxEncodedLen for ContractInfo<T>

where BalanceOf<T>: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<T: PartialEq + Config> PartialEq for ContractInfo<T>

fn eq(&self, other: &ContractInfo<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> TypeInfo for ContractInfo<T>

where BalanceOf<T>: TypeInfo + 'static, T: Config + 'static,

type Identity = ContractInfo<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> EncodeLike for ContractInfo<T>

where BalanceOf<T>: Encode,

impl<T: Eq + Config> Eq for ContractInfo<T>

impl<T: Config> StructuralPartialEq for ContractInfo<T>