Struct cw_asset::AssetBase

pub struct AssetBase<T: AddressLike> {
    pub info: AssetInfoBase<T>,
    pub amount: Uint128,
}

Represents a fungible asset with a known amount

Each asset instance contains two values: info, which specifies the asset’s type (CW20 or native), and its amount, which specifies the asset’s amount.

Fields

info: AssetInfoBase<T>

Specifies the asset’s type (CW20 or native)

amount: Uint128

Specifies the asset’s amount

Implementations

impl<T: AddressLike> AssetBase<T>

pub fn new<A: Into<AssetInfoBase<T>>, B: Into<Uint128>>( info: A, amount: B, ) -> Self

Create a new asset instance based on given asset info and amount

To create an unchecked instance, the info parameter may be either checked or unchecked; to create a checked instance, the info paramter must also be checked.

use cosmwasm_std::Addr;
use cw_asset::{Asset, AssetInfo};

let info1 = AssetInfo::cw20(Addr::unchecked("token_addr"));
let asset1 = Asset::new(info1, 12345u128);

let info2 = AssetInfo::native("uusd");
let asset2 = Asset::new(info2, 67890u128);

pub fn native<A: Into<String>, B: Into<Uint128>>(denom: A, amount: B) -> Self

Create a new asset instance representing a native coin of given denom and amount

use cw_asset::Asset;

let asset = Asset::native("uusd", 12345u128);

pub fn cw20<A: Into<T>, B: Into<Uint128>>(contract_addr: A, amount: B) -> Self

Create a new asset instance representing a CW20 token of given contract address and amount.

use cosmwasm_std::Addr;
use cw_asset::Asset;

let asset = Asset::cw20(Addr::unchecked("token_addr"), 12345u128);

impl AssetBase<String>

pub fn from_sdk_string(s: &str) -> Result<Self, AssetError>

Parse a string of the format {amount}{denom} into an AssetUnchecked object. This is the format that Cosmos SDK uses to stringify native coins. For example:

• 12345uatom
• 69420ibc/27394FB092D2ECCD56123C74F36E4C1F926001CEADA9CA97EA622B25F41E5EB2
• 88888factory/osmo1z926ax906k0ycsuckele6x5hh66e2m4m6ry7dn

Since native coin denoms can only start with a non-numerial character, while its amount can only contain numerical characters, we simply consider the first non-numerical character and all that comes after as the denom, while all that comes before it as the amount. This is the approach used in the Steak Hub contract.

pub fn check( &self, api: &dyn Api, optional_whitelist: Option<&[&str]>, ) -> Result<Asset, AssetError>

Validate data contained in an unchecked asset instnace, return a new checked asset instance:

• For CW20 tokens, assert the contract address is valid;
• For SDK coins, assert that the denom is included in a given whitelist; skip if the whitelist is not provided.

use cosmwasm_std::{Addr, Api};
use cw_asset::{Asset, AssetUnchecked};

fn validate_asset(api: &dyn Api, asset_unchecked: &AssetUnchecked) {
    match asset_unchecked.check(api, Some(&["uatom", "uluna"])) {
        Ok(asset) => println!("asset is valid: {}", asset.to_string()),
        Err(err) => println!("asset is invalid! reason: {}", err),
    }
}

impl AssetBase<Addr>

pub fn send_msg<A: Into<String>>( &self, to: A, msg: Binary, ) -> Result<CosmosMsg, AssetError>

Generate a message that sends a CW20 token to the specified recipient with a binary payload.

NOTE: Only works for CW20 tokens. Returns error if invoked on an Asset instance representing a native coin, as native coins do not have an equivalent method mplemented.

use serde::Serialize;

#[derive(Serialize)]
enum MockReceiveMsg {
    MockCommand {},
}

use cosmwasm_std::{to_json_binary, Addr, Response};
use cw_asset::{Asset, AssetError};

fn send_asset(
    asset: &Asset,
    contract_addr: &Addr,
    msg: &MockReceiveMsg,
) -> Result<Response, AssetError> {
    let msg = asset.send_msg(contract_addr, to_json_binary(msg)?)?;

    Ok(Response::new().add_message(msg).add_attribute("asset_sent", asset.to_string()))
}

pub fn transfer_msg<A: Into<String>>( &self, to: A, ) -> Result<CosmosMsg, AssetError>

Generate a message that transfers the asset from the sender to to a specified account.

use cosmwasm_std::{Addr, Response};
use cw_asset::{Asset, AssetError};

fn transfer_asset(asset: &Asset, recipient_addr: &Addr) -> Result<Response, AssetError> {
    let msg = asset.transfer_msg(recipient_addr)?;

    Ok(Response::new().add_message(msg).add_attribute("asset_sent", asset.to_string()))
}

pub fn transfer_from_msg<A: Into<String>, B: Into<String>>( &self, from: A, to: B, ) -> Result<CosmosMsg, AssetError>

Generate a message that draws the asset from the account specified by from to the one specified by to.

NOTE: Only works for CW20 tokens. Returns error if invoked on an Asset instance representing a native coin, as native coins do not have an equivalent method implemented.

use cosmwasm_std::{Addr, Response};
use cw_asset::{Asset, AssetError};

fn draw_asset(
    asset: &Asset,
    user_addr: &Addr,
    contract_addr: &Addr,
) -> Result<Response, AssetError> {
    let msg = asset.transfer_from_msg(user_addr, contract_addr)?;

    Ok(Response::new().add_message(msg).add_attribute("asset_drawn", asset.to_string()))
}

Trait Implementations

impl<T: Clone + AddressLike> Clone for AssetBase<T>

fn clone(&self) -> AssetBase<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + AddressLike> Debug for AssetBase<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for AssetBase<T>

where T: Deserialize<'de> + AddressLike,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<AssetBase<Addr>> for AssetUnchecked

fn from(asset: Asset) -> Self

Converts to this type from the input type.

impl<T: AddressLike + JsonSchema> JsonSchema for AssetBase<T>

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<AssetBase<Addr>> for Coin

fn eq(&self, other: &Asset) -> 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<T: PartialEq + AddressLike> PartialEq for AssetBase<T>

fn eq(&self, other: &AssetBase<T>) -> 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<T> Serialize for AssetBase<T>

where T: Serialize + AddressLike,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&AssetBase<Addr>> for Coin

type Error = AssetError

The type returned in the event of a conversion error.

fn try_from(asset: &Asset) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<AssetBase<Addr>> for Coin

type Error = AssetError

The type returned in the event of a conversion error.

fn try_from(asset: Asset) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: AddressLike> StructuralPartialEq for AssetBase<T>