Struct unc_sdk::Promise

source ·

pub struct Promise { /* private fields */ }

Expand description

A structure representing a result of the scheduled execution on another contract.

Smart contract developers will explicitly use Promise in two situations:

When they need to return Promise.

In the following code if someone calls method ContractA::a they will internally cause an execution of method ContractB::b of bob_unc account, and the return value of ContractA::a will be what ContractB::b returned.

#[ext_contract]
pub trait ContractB {
    fn b(&mut self);
}

#[unc_bindgen]
#[derive(Default, BorshDeserialize, BorshSerialize)]
struct ContractA {}

#[unc_bindgen]
impl ContractA {
    pub fn a(&self) -> Promise {
        contract_b::ext("bob_unc".parse().unwrap()).b()
    }
}

When they need to create a transaction with one or many actions, e.g. the following code schedules a transaction that creates an account, transfers tokens, and assigns a public key:

Promise::new("bob_unc".parse().unwrap())
  .create_account()
  .transfer(UncToken::from_attounc(1000))
  .add_full_access_key(env::signer_account_pk());

Implementations§

source §

impl Promise

source

pub fn new(account_id: AccountId) -> Self

Create a promise that acts on the given account.

source

pub fn create_account(self) -> Self

Create account on which this promise acts.

source

pub fn deploy_contract(self, code: Vec<u8>) -> Self

Deploy a smart contract to the account on which this promise acts.

source

pub fn function_call( self, function_name: String, arguments: Vec<u8>, amount: UncToken, gas: Gas ) -> Self

A low-level interface for making a function call to the account that this promise acts on.

source

pub fn function_call_weight( self, function_name: String, arguments: Vec<u8>, amount: UncToken, gas: Gas, weight: GasWeight ) -> Self

A low-level interface for making a function call to the account that this promise acts on. unlike Promise::function_call, this function accepts a weight to use relative unused gas on this function call at the end of the scheduling method execution.

source

pub fn transfer(self, amount: UncToken) -> Self

Transfer tokens to the account that this promise acts on.

source

pub fn stake(self, amount: UncToken, public_key: PublicKey) -> Self

Stake the account for the given amount of tokens using the given public key.

source

pub fn add_full_access_key(self, public_key: PublicKey) -> Self

Add full access key to the given account.

source

pub fn add_full_access_key_with_nonce( self, public_key: PublicKey, nonce: u64 ) -> Self

Add full access key to the given account with a provided nonce.

source

pub fn add_access_key_allowance( self, public_key: PublicKey, allowance: Allowance, receiver_id: AccountId, function_names: String ) -> Self

Add an access key that is restricted to only calling a smart contract on some account using only a restricted set of methods. Here function_names is a comma separated list of methods, e.g. "method_a,method_b".to_string().

source

pub fn add_access_key( self, public_key: PublicKey, allowance: UncToken, receiver_id: AccountId, function_names: String ) -> Self

👎Deprecated since 2.0.0: Use add_access_key_allowance instead

source

pub fn add_access_key_allowance_with_nonce( self, public_key: PublicKey, allowance: Allowance, receiver_id: AccountId, function_names: String, nonce: u64 ) -> Self

Add an access key with a provided nonce.

source

pub fn add_access_key_with_nonce( self, public_key: PublicKey, allowance: UncToken, receiver_id: AccountId, function_names: String, nonce: u64 ) -> Self

👎Deprecated since 2.0.0: Use add_access_key_allowance_with_nonce instead

source

pub fn delete_key(self, public_key: PublicKey) -> Self

Delete access key from the given account.

source

pub fn delete_account(self, beneficiary_id: AccountId) -> Self

Delete the given account.

source

pub fn and(self, other: Promise) -> Promise

Merge this promise with another promise, so that we can schedule execution of another smart contract right after all merged promises finish.

Note, once the promises are merged it is not possible to add actions to them, e.g. the following code will panic during the execution of the smart contract:

let p1 = Promise::new("bob_unc".parse().unwrap()).create_account();
let p2 = Promise::new("carol_unc".parse().unwrap()).create_account();
let p3 = p1.and(p2);
// p3.create_account();

source

pub fn then(self, other: Promise) -> Promise

Schedules execution of another promise right after the current promise finish executing.

In the following code bob_unc and dave_unc will be created concurrently. carol_unc creation will wait for bob_unc to be created, and eva_unc will wait for both carol_unc and dave_unc to be created first.

let p1 = Promise::new("bob_unc".parse().unwrap()).create_account();
let p2 = Promise::new("carol_unc".parse().unwrap()).create_account();
let p3 = Promise::new("dave_unc".parse().unwrap()).create_account();
let p4 = Promise::new("eva_unc".parse().unwrap()).create_account();
p1.then(p2).and(p3).then(p4);

source

pub fn as_return(self) -> Self

A specialized, relatively low-level API method. Allows to mark the given promise as the one that should be considered as a return value.

In the below code a1 and a2 functions are equivalent.

#[ext_contract]
pub trait ContractB {
    fn b(&mut self);
}

#[unc_bindgen]
#[derive(Default, BorshDeserialize, BorshSerialize)]
struct ContractA {}

#[unc_bindgen]
impl ContractA {
    pub fn a1(&self) {
       contract_b::ext("bob_unc".parse().unwrap()).b().as_return();
    }

    pub fn a2(&self) -> Promise {
       contract_b::ext("bob_unc".parse().unwrap()).b()
    }
}