Enum levana_perpswap_cosmos::token::Token

pub enum Token {
    Cw20 {
        addr: RawAddr,
        decimal_places: u8,
    },
    Native {
        denom: String,
        decimal_places: u8,
    },
}

The overall ideas of the Token API are:

1. use the Number type, not u128 or Uint128
2. abstract over the Cw20/Native variants

At the end of the day, call transfer/query with the same business logic as contract math and don’t worry at all about conversions or addresses/denoms

Variants

Cw20

An asset controlled by a CW20 token.

Fields

addr: RawAddr

Address of the contract

decimal_places: u8

Decimals places used by the contract

Native

Native coin on the blockchain

Fields

denom: String

Native coin denom string

decimal_places: u8

Decimal places used by the asset

Implementations

impl Token

pub fn into_transfer_msg( &self, recipient: &Addr, amount: NonZero<Collateral>, ) -> Result<Option<CosmosMsg>>

This is the usual function to call for transferring money the result can simply be added as a Message to any Response the amount is expressed as Number such that it mirrors self.query_balance()

pub fn query_balance( &self, querier: &QuerierWrapper<'_>, user_addr: &Addr, ) -> Result<Collateral>

Get the balance - this is expressed a Collateral such that it mirrors self.into_transfer_msg()

pub fn query_balance_dec( &self, querier: &QuerierWrapper<'_>, user_addr: &Addr, ) -> Result<Decimal256>

Get the balance - this is expressed as Decimal256 such that it mirrors self.into_transfer_msg()

pub fn from_u128(&self, amount: u128) -> Result<Decimal256>

helper function

given a u128, typically via a native Coin.amount or Cw20 amount get the Decimal256 representation according to the WalletSource’s config

this is essentially the inverse of self.into_u128()

pub fn into_u128(&self, amount: Decimal256) -> Result<Option<u128>>

helper function

given a number, typically via business logic and client API get the u128 representation, e.g. for Coin or Cw20 according to the WalletSource’s config

this will only return None if the amount is zero (or rounds to 0) which then bubbles up into other methods that build on this

this is essentially the inverse of self.from_u128()

pub fn into_native_coin(&self, amount: NumberGtZero) -> Result<Option<Coin>>

helper function

when we know for a fact we have a WalletSource::native we can get a Coin from a Number amount

pub fn round_down_to_precision(&self, amount: Collateral) -> Result<Collateral>

Round down to the supported precision of this token

pub fn into_cw20_execute_send_msg<T: Serialize>( &self, contract: &Addr, amount: Collateral, submsg: &T, ) -> Result<Option<Cw20ExecuteMsg>>

helper function

when we know for a fact we have a WalletSource::Cw20 we can get a Send Execute messge from a Number amount

pub fn into_cw20_execute_transfer_msg( &self, recipient: &Addr, amount: NonZero<Collateral>, ) -> Result<Option<Cw20ExecuteMsg>>

helper function

when we know for a fact we have a WalletSource::Cw20 we can get a Transfer Execute messge from a Number amount

pub fn into_market_execute_msg( &self, market_addr: &Addr, amount: Collateral, execute_msg: MarketExecuteMsg, ) -> Result<WasmMsg>

perps-specific use-case for executing a market message with funds

pub fn into_execute_msg<T: Serialize + Debug>( &self, contract_addr: &Addr, amount: Collateral, execute_msg: &T, ) -> Result<WasmMsg>

helper to create an execute message with funds

pub fn validate_collateral( &self, value: NonZero<Collateral>, ) -> Result<NonZero<Collateral>>

Validates that the given collateral doesn’t require more precision than what the token supports

Trait Implementations

impl Clone for Token

fn clone(&self) -> Token

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Token

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Token

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Token> for TokenInit

fn from(src: Token) -> Self

Converts to this type from the input type.

impl JsonSchema for Token

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for Token

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Token

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 Token

impl StructuralPartialEq for Token