Struct Worker

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

The Worker type allows us to interact with any NEAR 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_near( &self, signer: &InMemorySigner, receiver_id: &AccountId, amount_yocto: NearToken, ) -> 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.

pub async fn status(&self) -> Result<StatusResponse>

Returns the status of the network.

impl<T> Worker<T>

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

pub async fn changes_in_block( &self, block_reference: BlockReference, ) -> Result<RpcStateChangesInBlockByTypeResponse>

Provides a list of changes in block associated with the given block reference.

pub async fn changes( &self, block_reference: BlockReference, state_changes_request: StateChangesRequestView, ) -> Result<RpcStateChangesInBlockResponse>

Provides a list of changes in block associated with the given block reference and state changes request.

pub async fn genesis_config(&self) -> Result<GenesisConfig>

Provides a genesis config associated with the network being used.

pub async fn protocol_config( &self, block_reference: BlockReference, ) -> Result<ProtocolConfigView>

Provides a protocol config associated with the given block reference.

pub async fn receipt( &self, receipt_reference: ReceiptReference, ) -> Result<ReceiptView>

Provides a receipt associated with the given receipt reference.

pub async fn tx_status( &self, transaction_info: TransactionInfo, wait_until: TxExecutionStatus, ) -> Result<RpcTransactionResponse>

Returns the transaction status for a given transaction hash or signed transaction.

pub async fn validators_ordered( &self, block_id: MaybeBlockId, ) -> Result<Vec<ValidatorStakeView>>

Provides a list of validators ordered with respect to their stake.

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<Testnet>

pub fn root_account_id(&self) -> AccountId

it’s just "testnet"

impl Worker<Sandbox>

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

Returns root account of this Sandbox instance

Examples

use near_workspaces::{result::Result, Account, network::Sandbox, Worker};
fn get_account_with_lots_of_near(worker: &Worker<Sandbox>) -> Result<Account> {
    worker.root_account()
}

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

Import a contract from 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>

pub fn generate_dev_account_credentials(&self) -> (AccountId, SecretKey)

impl<T> Worker<T>

where T: Network + TopLevelAccountCreator + 'static,

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

Creates account id as top level account

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

Creates account id as top level account and deploys wasm code to it

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

Creates a top level developement account. On sandbox network it has a balance of 100 Near. If you need more Near for your tests in sandbox consider using Worker::<Sandbox>::root_account method.

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

Creates a top level developement account and deploys wasm code to it.

impl<T> Worker<T>

where T: DevNetwork + 'static,

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

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

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

Creates a subaccount of the network’s root account with random account ID and secret key. By default, balance is around 10 Near for testnet and 100 NEAR for sandbox.

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

Creates a subaccount of the network’s root account with random account ID and secret key and deploys provided wasm code into it.

Trait Implementations

impl<T: ?Sized> Clone for Worker<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: 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