[−][src]Struct near_sdk::Promise
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 methodContractB::b
ofbob_near
account, and the return value ofContractA::a
will be whatContractB::b
returned.
#[ext_contract] pub trait ContractB { fn b(&mut self); } #[near_bindgen] #[derive(Default, BorshDeserialize, BorshSerialize)] struct ContractA {} #[near_bindgen] impl ContractA { pub fn a(&self) -> Promise { contract_b::b(&"bob_near".to_string(), 0, 1_000) } }
- 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_near".to_string()) .create_account() .transfer(1000) .add_full_access_key(env::signer_account_pk());
Implementations
impl Promise
[src]
pub fn new(account_id: AccountId) -> Self
[src]
Create a promise that acts on the given account.
pub fn create_account(self) -> Self
[src]
Create account on which this promise acts.
pub fn deploy_contract(self, code: Vec<u8>) -> Self
[src]
Deploy a smart contract to the account on which this promise acts.
pub fn function_call(
self,
method_name: Vec<u8>,
arguments: Vec<u8>,
amount: Balance,
gas: Gas
) -> Self
[src]
self,
method_name: Vec<u8>,
arguments: Vec<u8>,
amount: Balance,
gas: Gas
) -> Self
A low-level interface for making a function call to the account that this promise acts on.
pub fn transfer(self, amount: Balance) -> Self
[src]
Transfer tokens to the account that this promise acts on.
pub fn stake(self, amount: Balance, public_key: PublicKey) -> Self
[src]
Stake the account for the given amount of tokens using the given public key.
pub fn add_full_access_key(self, public_key: PublicKey) -> Self
[src]
Add full access key to the given account.
pub fn add_access_key(
self,
public_key: PublicKey,
allowance: Balance,
receiver_id: AccountId,
method_names: Vec<u8>
) -> Self
[src]
self,
public_key: PublicKey,
allowance: Balance,
receiver_id: AccountId,
method_names: Vec<u8>
) -> 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 method_names
is a comma separated list of methods,
e.g. b"method_a,method_b"
.
pub fn delete_key(self, public_key: PublicKey) -> Self
[src]
Delete access key from the given account.
pub fn delete_account(self, beneficiary_id: AccountId) -> Self
[src]
Delete the given account.
pub fn and(self, other: Promise) -> Promise
[src]
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_near".to_string()).create_account(); let p2 = Promise::new("carol_near".to_string()).create_account(); let p3 = p1.and(p2); // p3.create_account();
pub fn then(self, mut other: Promise) -> Promise
[src]
Schedules execution of another promise right after the current promise finish executing.
In the following code bob_near
and dave_near
will be created concurrently. carol_near
creation will wait for bob_near
to be created, and eva_near
will wait for both carol_near
and dave_near
to be created first.
let p1 = Promise::new("bob_near".to_string()).create_account(); let p2 = Promise::new("carol_near".to_string()).create_account(); let p3 = Promise::new("dave_near".to_string()).create_account(); let p4 = Promise::new("eva_near".to_string()).create_account(); p1.then(p2).and(p3).then(p4);
pub fn as_return(self) -> Self
[src]
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); } #[near_bindgen] #[derive(Default, BorshDeserialize, BorshSerialize)] struct ContractA {} #[near_bindgen] impl ContractA { pub fn a1(&self) { contract_b::b(&"bob_near".to_string(), 0, 1_000).as_return(); } pub fn a2(&self) -> Promise { contract_b::b(&"bob_near".to_string(), 0, 1_000) } }
Trait Implementations
impl BorshSchema for Promise
[src]
Until we implement strongly typed promises we serialize them as unit struct.
pub fn add_definitions_recursively(
definitions: &mut HashMap<Declaration, Definition>
)
[src]
definitions: &mut HashMap<Declaration, Definition>
)
pub fn declaration() -> Declaration
[src]
pub fn add_definition(
declaration: String,
definition: Definition,
definitions: &mut HashMap<String, Definition, RandomState>
)
[src]
declaration: String,
definition: Definition,
definitions: &mut HashMap<String, Definition, RandomState>
)
pub fn schema_container() -> BorshSchemaContainer
[src]
impl Clone for Promise
[src]
impl Drop for Promise
[src]
impl<T> From<Promise> for PromiseOrValue<T>
[src]
impl Serialize for Promise
[src]
Auto Trait Implementations
impl !RefUnwindSafe for Promise
[src]
impl !Send for Promise
[src]
impl !Sync for Promise
[src]
impl Unpin for Promise
[src]
impl !UnwindSafe for Promise
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,