Struct TokenDiff

pub struct TokenDiff {
    pub diff: TokenDeltas,
    pub memo: Option<String>,
    pub referral: Option<AccountId>,
}

The user declares the will to have a set of changes done to set of tokens. For example, a simple trade of 100 of token A for 200 of token B, can be represented by TokenDiff of {“A”: -100, “B”: 200} (this format is just for demonstration purposes). In general, the user can submit multiple changes with many tokens, not just token A for token B.

Fields

diff: TokenDeltas

memo: Option<String>

referral: Option<AccountId>

Implementations

impl TokenDiff

pub fn closure(self, fee: Pips) -> Option<TokenDeltas>

Returns TokenDiff closure to successfully execute self assuming given fee

pub fn closure_many( diffs: impl IntoIterator<Item = Self>, fee: Pips, ) -> Option<TokenDeltas>

Returns TokenDiff closure to successfully execute given set of distinct TokenDiff assuming given fee

pub fn closure_deltas( deltas: impl IntoIterator<Item = (TokenId, i128)>, fee: Pips, ) -> Option<TokenDeltas>

Returns closure for deltas that should be given in a single TokenDiff to successfully execute given set of distinct deltas assuming given fee

pub fn closure_delta(token_id: &TokenId, delta: i128, fee: Pips) -> Option<i128>

Returns closure for delta that should be given in a single TokenDiff to successfully execute TokenDiff with given delta on the same token assuming given fee.

pub fn closure_supply_delta( token_id: &TokenId, delta: i128, fee: Pips, ) -> Option<i128>

Returns closure for total supply delta that should be given in a single TokenDiff to successfully execute TokenDiff with given delta on the same token assuming given fee.

pub fn token_fee( token_id: impl Into<TokenIdType>, amount: u128, fee: Pips, ) -> Pips

Methods from Deref<Target = TokenDeltas>

pub fn amount_for(&self, k: &T::K) -> T::V

pub fn add(&mut self, k: T::K, amount: u128) -> Option<T::V>

where T::V: CheckedAdd<u128>,

pub fn sub(&mut self, k: T::K, amount: u128) -> Option<T::V>

where T::V: CheckedSub<u128>,

pub fn apply_delta(&mut self, k: T::K, delta: i128) -> Option<T::V>

where T::V: CheckedAdd<i128>,

pub fn iter(&self) -> T::Iter<'_>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

Trait Implementations

impl BorshDeserialize for TokenDiff

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for TokenDiff

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl Clone for TokenDiff

fn clone(&self) -> TokenDiff

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TokenDiff

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

Formats the value using the given formatter.

impl Default for TokenDiff

fn default() -> TokenDiff

Returns the “default value” for a type.

impl Deref for TokenDiff

type Target = Amounts<BTreeMap<TokenId, i128>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for TokenDiff

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for TokenDiff

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl ExecutableIntent for TokenDiff

fn execute_intent<S, I>( self, signer_id: &AccountIdRef, engine: &mut Engine<S, I>, intent_hash: CryptoHash, ) -> Result<()>

where S: State, I: Inspector,

impl From<TokenDiff> for Intent

fn from(value: TokenDiff) -> Self

Converts to this type from the input type.

impl PartialEq for TokenDiff

fn eq(&self, other: &TokenDiff) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TokenDiff

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TokenDiff

impl StructuralPartialEq for TokenDiff