Struct unc_workspaces::Worker

pub struct Worker<T: ?Sized> { /* private fields */ }

The Worker type allows us to interact with any UNC related networks, such as mainnet and testnet. This controls where the environment the worker is running on top of it. Refer to this for all network related actions such as deploying a contract, or interacting with transactions.

Implementations

impl<T> Worker<T>

where T: NetworkClient + ?Sized,

pub fn view( &self, contract_id: &AccountId, function: &str ) -> Query<'_, ViewFunction>

Call into a contract’s view function. Returns a Query which allows us to specify further details like the arguments of the view call, or at what point in the chain we want to view.

pub fn view_code(&self, contract_id: &AccountId) -> Query<'_, ViewCode>

View the WASM code bytes of a contract on the network.

pub fn view_state(&self, contract_id: &AccountId) -> Query<'_, ViewState>

View the state of a account/contract on the network. This will return the internal state of the account in the form of a map of key-value pairs; where STATE contains info on a contract’s internal data.

pub fn view_block(&self) -> Query<'_, ViewBlock>

View the block from the network. Supply additional parameters such as block_height or block_hash to get the block.

pub fn view_chunk(&self) -> QueryChunk<'_>

View the chunk from the network once awaited. Supply additional parameters such as block_hash_and_shard, block_height_and_shard or chunk_hash to get the chunk at a specific reference point. If none of those are supplied, the default reference point will be used, which will be the latest block_hash with a shard_id of 0.

pub fn view_access_key( &self, id: &AccountId, pk: &PublicKey ) -> Query<'_, ViewAccessKey>

Views the AccessKey of the account specified by AccountId associated with the PublicKey

pub fn view_access_keys(&self, id: &AccountId) -> Query<'_, ViewAccessKeyList>

Views all the AccessKeys of the account specified by AccountId. This will return a list of AccessKeys along with the associated PublicKey.

pub fn view_account(&self, account_id: &AccountId) -> Query<'_, ViewAccount>

View account details of a specific account on the network.

pub fn gas_price(&self) -> Query<'_, GasPrice>

impl<T> Worker<T>

where T: NetworkClient + Send + Sync + ?Sized,

pub async fn transfer_unc( &self, signer: &InMemorySigner, receiver_id: &AccountId, amount_atto: UncToken ) -> Result<ExecutionFinalResult>

Transfer tokens from one account to another. The signer is the account that will be used to send from.

pub async fn delete_account( &self, account_id: &AccountId, signer: &InMemorySigner, beneficiary_id: &AccountId ) -> Result<ExecutionFinalResult>

Deletes an account from the network. The beneficiary will receive the balance of the account deleted.

impl<T> Worker<T>

where T: Network + 'static,

pub fn call( &self, signer: &InMemorySigner, contract_id: &AccountId, function: &str ) -> CallTransaction

Call into a contract’s change function. Returns a CallTransaction object that we will make use to populate the rest of the call details. The signer will be used to sign the transaction.

impl Worker<Sandbox>

pub fn root_account(&self) -> Result<Account>

pub fn import_contract<'a>( &self, id: &'a AccountId, worker: &Worker<impl Network + 'static> ) -> ImportContractTransaction<'a>

Import a contract from the the given network, and return us a ImportContractTransaction which allows to specify further details, such as being able to import contract data and how far back in time we wanna grab the contract.

pub fn patch(&self, account_id: &AccountId) -> PatchTransaction

Start patching the state of the account specified by the AccountId. This will create a PatchTransaction that will allow us to patch access keys, code, and contract state. This is similar to functions like Account::batch where we can perform multiple actions in one transaction.

pub async fn patch_state( &self, contract_id: &AccountId, key: &[u8], value: &[u8] ) -> Result<()>

Patch state into the sandbox network, given a prefix key and value. This will allow us to set contract state that we have acquired in some manner, where we are able to test random cases that are hard to come up naturally as state evolves.

pub async fn fast_forward(&self, delta_height: u64) -> Result<()>

Fast forward to a point in the future. The delta block height is supplied to tell the network to advanced a certain amount of blocks. This comes with the advantage only having to wait a fraction of the time it takes to produce the same number of blocks.

Estimate as to how long it takes: if our delta_height crosses X epochs, then it would roughly take X * 5 seconds for the fast forward request to be processed.

Note: This is not to be confused with speeding up the current in-flight transactions; the state being forwarded in this case refers to time-related state (the block height, timestamp and epoch).

pub fn rpc_port(&self) -> Option<u16>

The port being used by RPC

pub fn rpc_addr(&self) -> String

Get the address the client is using to connect to the RPC of the network.

impl<T> Worker<T>

where T: DevNetwork + TopLevelAccountCreator + 'static,

pub async fn create_tla( &self, id: AccountId, sk: SecretKey ) -> Result<Execution<Account>>

pub async fn create_account_and_deploy( &self, id: AccountId, sk: SecretKey, wasm: &[u8] ) -> Result<Execution<Contract>>

pub async fn dev_generate(&self) -> (AccountId, SecretKey)

pub async fn dev_create_account(&self) -> Result<Account>

pub async fn dev_deploy(&self, wasm: &[u8]) -> Result<Contract>

Trait Implementations

impl<T: ?Sized> Clone for Worker<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Worker<T>

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

Formats the value using the given formatter.

impl<T> NetworkInfo for Worker<T>

where T: NetworkInfo,

fn info(&self) -> &Info

impl<T> AllowDevAccountCreation for Worker<T>

where T: AllowDevAccountCreation,