Struct concordium_std::ExternStateApi

pub struct ExternStateApi;

Typicall referred to via the alias StateApi.

Implementations

impl ExternStateApi

pub fn open() -> Self

Open the contract state. Only one instance can be opened at the same time.

Trait Implementations

impl Clone for ExternStateApi

fn clone(&self) -> ExternStateApi

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExternStateApi

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

Formats the value using the given formatter.

impl Default for ExternStateApi

fn default() -> ExternStateApi

Returns the “default value” for a type.

impl<const M: usize, K, V> DeserialWithState<ExternStateApi> for StateBTreeMap<K, V, M>

fn deserial_with_state<R: Read>( state: &StateApi, source: &mut R ) -> ParseResult<Self>

Attempt to read a structure from a given source and state, failing if an error occurs during deserialization or reading.

impl<const M: usize, K> DeserialWithState<ExternStateApi> for StateBTreeSet<K, M>

fn deserial_with_state<R: Read>( state: &StateApi, source: &mut R ) -> ParseResult<Self>

Attempt to read a structure from a given source and state, failing if an error occurs during deserialization or reading.

impl HasHost<ExternStateApi> for ExternLowLevelHost

type ReturnValueType = ExternCallResponse

The type of return values this host provides. This is the raw return value. The intention is that it will be deserialized by the consumer, via the Read implementation.

type StateApiType = ExternStateApi

The type of low-level state that is associated with the host. This provides access to low-level state operations.

fn invoke_transfer( &self, receiver: &AccountAddress, amount: Amount ) -> TransferResult

Perform a transfer to the given account if the contract has sufficient balance.

fn invoke_contract_raw( &mut self, to: &ContractAddress, parameter: Parameter<'_>, method: EntrypointName<'_>, amount: Amount ) -> CallContractResult<Self::ReturnValueType>

Invoke a given method of a contract with the amount and parameter provided. If invocation succeeds then the return value is a pair of a boolean which indicates whether the state of the contract has changed or not, and a possible return value. The return value is present if and only if a V1 contract was invoked.

fn account_balance(&self, address: AccountAddress) -> QueryAccountBalanceResult

Get the current public balance of an account. Here public means unencrypted or unshielded. See AccountBalance for more. This query will fail if the provided address does not exist on chain.

fn contract_balance( &self, address: ContractAddress ) -> QueryContractBalanceResult

Get the current balance of a contract instance.

fn exchange_rates(&self) -> ExchangeRates

Get the current exchange rates used by the chain. That is a Euro per Energy rate and micro CCD per Euro rate.

fn upgrade(&mut self, module: ModuleReference) -> UpgradeResult

Upgrade the module for this instance to a given module. The new module must contain a smart contract with a matching name. Invocations of this instance after the point of a successful upgrade, will use the new smart contract module. The remaining code after a successful upgrade in the same invokation is executed as normal.

fn account_public_keys( &self, address: AccountAddress ) -> QueryAccountPublicKeysResult

Get the account’s public keys.

fn check_account_signature( &self, address: AccountAddress, signatures: &AccountSignatures, data: &[u8] ) -> CheckAccountSignatureResult

Verify the signature with account’s public keys.

fn state(&self) -> &ExternStateApi

Get an immutable reference to the contract state.

fn state_mut(&mut self) -> &mut ExternStateApi

Get a mutable reference to the contract state.

fn commit_state(&mut self)

Make sure the contract state is fully written out, so that any changes that were done in-memory up to the point in contract execution are reflected in the actual contract state maintained by the node.

fn self_balance(&self) -> Amount

Get the contract’s own current balance. Upon entry to the entrypoint the balance that is returned is the sum of balance of the contract at the time of the invocation and the amount that is being transferred to the contract.

fn state_builder(&mut self) -> &mut StateBuilder<Self::StateApiType>

Get the state_builder for the contract state.

fn state_and_builder( &mut self ) -> (&mut ExternStateApi, &mut StateBuilder<Self::StateApiType>)

Get a mutable reference to both the state and the builder. This is required due to limitations of the Rust type system, since otherwise it is not possible to get the reference to the state and the state builder at the same time. Once some incarnation of “view types” is stable this will likely be possible to remove, and the types of state_builder and state_mut can be refined.

fn invoke_contract_raw_read_only( &self, to: &ContractAddress, parameter: Parameter<'_>, method: EntrypointName<'_>, amount: Amount ) -> ReadOnlyCallContractResult<Self::ReturnValueType>

Invoke a given method of a contract with the amount and parameter provided. If invocation succeeds and the state of the contract instance is not modified then the return value is the return value of the contract that was invoked. The return value is present (i.e., not None) if and only if a V1 contract was invoked. If the invocation succeeds but the state of the contract is modified then this method will panic.

fn invoke_contract<P: Serial>( &mut self, to: &ContractAddress, parameter: &P, method: EntrypointName<'_>, amount: Amount ) -> CallContractResult<Self::ReturnValueType>

Like invoke_contract_raw, except that the parameter is automatically serialized. If the parameter already implements AsRef<[u8]> or can be equivalently cheaply converted to a byte array, then invoke_contract_raw should be used, since it avoids intermediate allocations.

fn invoke_contract_read_only<P: Serial>( &self, to: &ContractAddress, parameter: &P, method: EntrypointName<'_>, amount: Amount ) -> ReadOnlyCallContractResult<Self::ReturnValueType>

Like invoke_contract_raw_read_only, except that the parameter is automatically serialized. If the parameter already implements AsRef<[u8]> or can be equivalently cheaply converted to a byte array, then invoke_contract_raw should be used, since it avoids intermediate allocations.

impl HasStateApi for ExternStateApi

type EntryType = StateEntry

type IterType = ExternStateIter

fn create_entry(&mut self, key: &[u8]) -> Result<Self::EntryType, StateError>

Create a new entry in the state. If an entry with the given key already exists then it is reset to an empty entry. If the part of the tree where the key points to is locked due to an acquired iterator then no entry is created, and an error will be returned.

fn lookup_entry(&self, key: &[u8]) -> Option<Self::EntryType>

Lookup an entry in the state.

fn delete_entry(&mut self, entry: Self::EntryType) -> Result<(), StateError>

Delete an entry. Returns an error if the entry did not exist, or if it is part of a locked subtree.

fn delete_prefix(&mut self, prefix: &[u8]) -> Result<bool, StateError>

Delete the entire subtree. Returns whether any values were deleted, or an error if the given prefix is part of a locked subtree.

fn iterator(&self, prefix: &[u8]) -> Result<Self::IterType, StateError>

Get an iterator over a map in the state.

fn delete_iterator(&mut self, iter: Self::IterType)

Delete an iterator. See the iterator method for why this is necessary.

fn entry<K: AsRef<[u8]> + Into<Key>>(&mut self, key: K) -> EntryRaw<Self>

Like lookup_entry except that it consumes the key and returns an EntryRaw instead of an optional entry.

fn read_root<A: DeserialWithState<Self>>(&self) -> ParseResult<A>

Read and deserialize the state stored at the root of the state trie. If such a state does not exist, or cannot be deserialized into the provided type, then this returns an error.

fn write_root<A: Serial>(&mut self, new_state: &A)

Serialize and write the state at the root of the state trie. Dual to read_root.