Struct elrond_wasm_node::ArwenApiImpl

pub struct ArwenApiImpl {}

The reference to the API implementation based on Arwen hooks. It continas no data, can be embedded at no cost. Cloning it is a no-op.

Trait Implementations

impl CallValueApi<ArwenBigUint> for ArwenApiImpl

fn check_not_payable(&self)

fn egld_value(&self) -> ArwenBigUint

Retrieves the EGLD call value from the VM. Will return 0 in case of an ESDT transfer (cannot have both EGLD and ESDT transfer simultaneously).

fn esdt_value(&self) -> ArwenBigUint

Retrieves the ESDT call value from the VM. Will return 0 in case of an EGLD transfer (cannot have both EGLD and ESDT transfer simultaneously).

fn token(&self) -> TokenIdentifier

Returns the call value token identifier of the current call. The identifier is wrapped in a TokenIdentifier object, to hide underlying logic.

fn esdt_token_nonce(&self) -> u64

Returns the nonce of the received ESDT token. Will return 0 in case of EGLD or fungible ESDT transfer.

fn esdt_token_type(&self) -> EsdtTokenType

Returns the ESDT token type. Will return “Fungible” for EGLD.

pub fn require_egld(&self) -> BigUint

Will return the EGLD call value, but also fail with an error if ESDT is sent. Especially used in the auto-generated call value processing.

pub fn require_esdt(&self, token: &[u8]) -> BigUint

Will return the ESDT call value, but also fail with an error if EGLD or the wrong ESDT token is sent. Especially used in the auto-generated call value processing.

pub fn payment_token_pair(&self) -> (BigUint, TokenIdentifier)

Returns both the call value (either EGLD or ESDT) and the token identifier. Especially used in the `#[payable(“*”)] auto-generated snippets. The method might seem redundant, but there is such a hook in Arwen that might be used in this scenario in the future.

impl Clone for ArwenApiImpl

Should be no-op. The API implementation is zero-sized.

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ContractHookApi<ArwenBigInt, ArwenBigUint> for ArwenApiImpl

type Storage = Self

Abstracts the lower-level storage functionality.

type CallValue = Self

Abstracts the call value handling at the beginning of a function call.

type SendApi = Self

Abstracts the sending of EGLD & ESDT transactions, as well as async calls.

fn get_storage_raw(&self) -> Self::Storage

Gateway into the lower-level storage functionality. Storage related annotations make use of this. Using it directly is not recommended.

fn call_value(&self) -> Self::CallValue

Gateway into the call value retrieval functionality. The payment annotations should normally be the ones to handle this, but the developer is also given direct access to the API.

fn send(&self) -> Self::SendApi

Gateway to the functionality related to sending transactions from the current contract.

fn get_sc_address(&self) -> Address

fn get_owner_address(&self) -> Address

fn get_shard_of_address(&self, address: &Address) -> u32

fn is_smart_contract(&self, address: &Address) -> bool

fn get_caller(&self) -> Address

fn get_balance(&self, address: &Address) -> ArwenBigUint

fn get_tx_hash(&self) -> H256

fn get_gas_left(&self) -> u64

fn get_block_timestamp(&self) -> u64

fn get_block_nonce(&self) -> u64

fn get_block_round(&self) -> u64

fn get_block_epoch(&self) -> u64

fn get_block_random_seed(&self) -> Box<[u8; 48]>

fn get_prev_block_timestamp(&self) -> u64

fn get_prev_block_nonce(&self) -> u64

fn get_prev_block_round(&self) -> u64

fn get_prev_block_epoch(&self) -> u64

fn get_prev_block_random_seed(&self) -> Box<[u8; 48]>

fn get_current_esdt_nft_nonce(&self, address: &Address, token: &[u8]) -> u64

fn get_esdt_balance(
    &self,
    address: &Address,
    token: &[u8],
    nonce: u64
) -> ArwenBigUint

fn get_esdt_token_data(
    &self,
    address: &Address,
    token: &[u8],
    nonce: u64
) -> EsdtTokenData<ArwenBigUint>

pub fn get_sc_balance(&self) -> BigUint

pub fn storage_load_cumulated_validator_reward(&self) -> BigUint

impl CryptoApi for ArwenApiImpl

fn sha256(&self, data: &[u8]) -> H256

fn keccak256(&self, data: &[u8]) -> H256

fn verify_bls(&self, key: &[u8], message: &[u8], signature: &[u8]) -> bool

fn verify_ed25519(&self, key: &[u8], message: &[u8], signature: &[u8]) -> bool

fn verify_secp256k1(&self, key: &[u8], message: &[u8], signature: &[u8]) -> bool

Note: the signature is minimum 2 bytes in length, the second byte encodes the length of the remaining signature bytes.

impl EndpointArgumentApi for ArwenApiImpl

Interface to only be used by code generated by the macros. The smart contract code doesn’t have access to these methods directly.

fn get_num_arguments(&self) -> i32

fn get_argument_len(&self, arg_index: i32) -> usize

fn copy_argument_to_slice(&self, arg_index: i32, slice: &mut [u8])

fn get_argument_vec_u8(&self, arg_index: i32) -> Vec<u8>

fn get_argument_boxed_bytes(&self, arg_index: i32) -> BoxedBytes

fn get_argument_big_uint_raw(&self, arg_id: i32) -> i32

fn get_argument_big_int_raw(&self, arg_id: i32) -> i32

fn get_argument_u64(&self, arg_id: i32) -> u64

fn get_argument_i64(&self, arg_id: i32) -> i64

pub fn check_num_arguments(&self, expected: i32)

impl EndpointFinishApi for ArwenApiImpl

Interface to only be used by code generated by the macros. The smart contract code doesn’t have access to these methods directly.

fn finish_slice_u8(&self, slice: &[u8])

fn finish_big_int_raw(&self, handle: i32)

fn finish_big_uint_raw(&self, handle: i32)

fn finish_u64(&self, value: u64)

fn finish_i64(&self, value: i64)

impl ErrorApi for ArwenApiImpl

fn signal_error(&self, message: &[u8]) -> !

impl LogApi for ArwenApiImpl

Interface to only be used by code generated by the macros. The smart contract code doesn’t have access to these methods directly.

fn write_event_log(&self, topics_buffer: &ArgBuffer, data: &[u8])

Saves an event log.

fn write_legacy_log(&self, topics: &[[u8; 32]], data: &[u8])

The legacy Arwen hook for saving event logs. It does the same, but only accepts 32-byte topics. Only kept for backwards compatibility.

impl SendApi<ArwenBigUint> for ArwenApiImpl

fn direct_egld(&self, to: &Address, amount: &ArwenBigUint, data: &[u8])

Sends EGLD to a given address, directly. Used especially for sending EGLD to regular accounts.

fn direct_egld_execute(
    &self,
    to: &Address,
    amount: &ArwenBigUint,
    gas_limit: u64,
    function: &[u8],
    arg_buffer: &ArgBuffer
)

Sends EGLD to an address (optionally) and executes like an async call, but without callback.

fn direct_esdt_execute(
    &self,
    to: &Address,
    token: &[u8],
    amount: &ArwenBigUint,
    gas_limit: u64,
    function: &[u8],
    arg_buffer: &ArgBuffer
)

Sends ESDT to an address and executes like an async call, but without callback.

fn direct_esdt_nft_execute(
    &self,
    to: &Address,
    token: &[u8],
    nonce: u64,
    amount: &ArwenBigUint,
    gas_limit: u64,
    function: &[u8],
    arg_buffer: &ArgBuffer
)

Sends ESDT NFT to an address and executes like an async call, but without callback.

fn async_call_raw(&self, to: &Address, amount: &ArwenBigUint, data: &[u8]) -> !

Sends an asynchronous call to another contract. Calling this method immediately terminates tx execution. Using it directly is generally discouraged.

fn deploy_contract(
    &self,
    gas: u64,
    amount: &ArwenBigUint,
    code: &BoxedBytes,
    code_metadata: CodeMetadata,
    arg_buffer: &ArgBuffer
) -> Address

Deploys a new contract in the same shard. Unlike async_call_raw, the deployment is synchronous and tx execution continues afterwards. Also unlike async_call_raw, it uses an argument buffer to pass arguments

fn execute_on_dest_context_raw(
    &self,
    gas: u64,
    address: &Address,
    amount: &ArwenBigUint,
    function: &[u8],
    arg_buffer: &ArgBuffer
) -> Vec<BoxedBytes>

fn execute_on_dest_context_by_caller_raw(
    &self,
    gas: u64,
    address: &Address,
    amount: &ArwenBigUint,
    function: &[u8],
    arg_buffer: &ArgBuffer
) -> Vec<BoxedBytes>

fn execute_on_same_context_raw(
    &self,
    gas: u64,
    address: &Address,
    amount: &ArwenBigUint,
    function: &[u8],
    arg_buffer: &ArgBuffer
)

fn storage_store_tx_hash_key(&self, data: &[u8])

Used to store data between async call and callback.

fn storage_load_tx_hash_key(&self) -> BoxedBytes

Used to store data between async call and callback.

fn call_local_esdt_built_in_function(
    &self,
    gas: u64,
    function: &[u8],
    arg_buffer: &ArgBuffer
)

Allows synchronously calling a local function by name. Execution is resumed afterwards. You should never have to call this function directly. Use the other specific methods instead.

pub fn direct_esdt_via_transf_exec(
    &self,
    to: &Address,
    token: &[u8],
    amount: &BigUint,
    data: &[u8]
)

Sends an ESDT token to a given address, directly. Used especially for sending ESDT to regular accounts.

pub fn direct(
    &self,
    to: &Address,
    token: &TokenIdentifier,
    amount: &BigUint,
    data: &[u8]
)

Sends either EGLD or an ESDT token to the target address, depending on what token identifier was specified.

pub fn direct_esdt_via_async_call(
    &self,
    to: &Address,
    esdt_token_name: &[u8],
    amount: &BigUint,
    data: &[u8]
) -> !

Performs a simple ESDT transfer, but via async call. This is the preferred way to send ESDT.

pub fn direct_via_async_call(
    &self,
    to: &Address,
    token: &TokenIdentifier,
    amount: &BigUint,
    data: &[u8]
)

Sends either EGLD or an ESDT token to the target address, depending on what token identifier was specified. In case of ESDT it performs an async call.

pub fn async_call(&self, async_call: AsyncCall<BigUint>) -> !

Sends an asynchronous call to another contract, with either EGLD or ESDT value. The token argument decides which one it will be. Calling this method immediately terminates tx execution.

pub fn esdt_local_mint(&self, gas: u64, token: &[u8], amount: &BigUint)

Allows synchronous minting of ESDT tokens. Execution is resumed afterwards.

pub fn esdt_local_burn(&self, gas: u64, token: &[u8], amount: &BigUint)

Allows synchronous burning of ESDT tokens. Execution is resumed afterwards.

pub fn esdt_nft_create<T>(
    &self,
    gas: u64,
    token: &[u8],
    amount: &BigUint,
    name: &BoxedBytes,
    royalties: &BigUint,
    hash: &H256,
    attributes: &T,
    uris: &[BoxedBytes]
) where
    T: TopEncode, 

Creates a new NFT token of a certain type (determined by token_identifier).
attributes can be any serializable custom struct.
This is a built-in function, so the smart contract execution is resumed after.

pub fn esdt_nft_add_quantity(
    &self,
    gas: u64,
    token: &[u8],
    nonce: u64,
    amount: &BigUint
)

Adds quantity for an Non-Fungible Token. (which makes it a Semi-Fungible Token by definition)
This is a built-in function, so the smart contract execution is resumed after.

pub fn esdt_nft_burn(
    &self,
    gas: u64,
    token: &[u8],
    nonce: u64,
    amount: &BigUint
)

The reverse operation of esdt_nft_add_quantity, this locally decreases This is a built-in function, so the smart contract execution is resumed after.

pub fn direct_esdt_nft_via_async_call(
    &self,
    from: &Address,
    to: &Address,
    token: &[u8],
    nonce: u64,
    amount: &BigUint,
    data: &[u8]
)

Performs a simple ESDT NFT transfer, but via async call. This is the preferred way to send ESDT. Note: call is done to the SC itself, so from should be the SCs own address

pub fn direct_esdt_nft_via_transfer_exec(
    &self,
    to: &Address,
    token: &[u8],
    nonce: u64,
    amount: &BigUint,
    data: &[u8]
)

Sends an ESDT NFT to a given address, directly. Used especially for sending ESDT to regular accounts.

impl StorageReadApi for ArwenApiImpl

fn storage_load_len(&self, key: &[u8]) -> usize

fn storage_load_vec_u8(&self, key: &[u8]) -> Vec<u8>

fn storage_load_boxed_bytes(&self, key: &[u8]) -> BoxedBytes

fn storage_load_big_uint_raw(&self, key: &[u8]) -> i32

fn storage_load_u64(&self, key: &[u8]) -> u64

fn storage_load_i64(&self, key: &[u8]) -> i64

impl StorageWriteApi for ArwenApiImpl

fn storage_store_slice_u8(&self, key: &[u8], value: &[u8])

fn storage_store_big_uint_raw(&self, key: &[u8], handle: i32)

fn storage_store_u64(&self, key: &[u8], value: u64)

fn storage_store_i64(&self, key: &[u8], value: i64)