xco1155

Documentation

Index

• type AllTokens
• type ApproveAll
• type ApprovedForAll
• type Balance
• type Batch
• type BatchBalance
• type BatchBurn
• type BatchMint
• type BatchSendFrom
• type Burn
• type Expiration
• type InstantiateMsg
  • func (m InstantiateMsg) Marshal() ([]byte, error)
• type IsApprovedForAll
• type Mint
  • func (m Mint) Marshal() ([]byte, error)
• type RevokeAll
• type SendFrom
• type TokenId
• type TokenInfo
• type Tokens

Types

type AllTokens

type AllTokens struct {
	Start_after string
	Limit       uint32
}

AllTokens / With Enumerable extension. / Requires pagination. Lists all token_ids controlled by the contract. #[returns(TokensResponse)]

type ApproveAll

type ApproveAll struct {
	Operator string
	Expires  Expiration
}

ApproveAll / Allows operator to transfer / send any token from the owner's account. / If expiration is set then this allowance has a time/height limit

type ApprovedForAll

type ApprovedForAll struct {
	Owner string
	/// unset or false will filter out expired approvals you must set to true to see them
	Include_expired bool
	Start_after     string
	Limit           uint32
}

ApprovedForAll / List all operators that can access all of the owner's tokens. #[returns(ApprovedForAllResponse)]

type Balance

type Balance struct {
	Owner    string
	Token_id TokenId
}

Balance #[returns(BalanceResponse)]

type Batch

type Batch struct {
	Token_id TokenId
	Amt      uint64
}

type BatchBalance

type BatchBalance struct {
	Owner     string
	Token_ids []TokenId
}

BatchBalance BatchBalance / Returns the current balance of the given address for a batch of tokens 0 if unset. #[returns(BatchBalanceResponse)]

type BatchBurn

type BatchBurn struct {
	From  string
	Batch Batch
}

BatchBurn / BatchBurn is a base message to burn multiple types of tokens in batch.

type BatchMint

type BatchMint struct {
	/// If `to` is not contract `msg` should be `None`
	To    string
	Batch Batch
	/// `None` means don't call the receiver interface
	Msg []byte
}

BatchMint / BatchMint is a base message to mint multiple types of tokens in batch.

type BatchSendFrom

type BatchSendFrom struct {
	From string
	/// if `to` is not contract `msg` should be `None`
	To    string
	Batch Batch
	/// `None` means don't call the receiver interface
	Msg []byte
}

BatchSendFrom / BatchSendFrom is a base message to move multiple types of tokens in batch / if `env.sender` is the owner or has sufficient pre-approval.

type Burn

type Burn struct {
	From     string
	Token_id TokenId
	Value    uint64
}

Burn / Burn is a base message to burn tokens.

type Expiration

type Expiration struct {
	AtHeight uint64
	AtTime   time.Time
	Never    interface{}
}

type InstantiateMsg

type InstantiateMsg struct {
	/// The minter is the only one who can create new tokens.
	/// This is designed for a base token platform that is controlled by an external program or
	/// contract.
	Minter string `json:"minter"`
}

func (InstantiateMsg) Marshal

func (m InstantiateMsg) Marshal() ([]byte, error)

type IsApprovedForAll

type IsApprovedForAll struct {
	Owner    string
	Operator string
}

IsApprovedForAll / Query approved status `owner` granted to `operator`. #[returns(IsApprovedForAllResponse)]

type Mint

type Mint struct {
	/// If `to` is not contract `msg` should be `None`
	To      string  `json:"to"`
	TokenId TokenId `json:"token_id"`
	Value   uint64  `json:"value"`
	/// `None` means don't call the receiver interface
	Msg []byte `json:"msg,omitempty"`
}

Mint / Mint is a base message to mint tokens.

func (Mint) Marshal

func (m Mint) Marshal() ([]byte, error)

type RevokeAll

type RevokeAll struct {
	// contains filtered or unexported fields
}

RevokeAll / Remove previously granted ApproveAll permission

type SendFrom

type SendFrom struct {
	From string
	/// If `to` is not contract `msg` should be `None`
	To       string
	Token_id TokenId
	Value    uint64
	/// `None` means don't call the receiver interface
	Msg []byte
}

SendFrom / SendFrom is a base message to move tokens / if `env.sender` is the owner or has sufficient pre-approval.

type TokenId

type TokenId string

type TokenInfo

type TokenInfo struct{ Token_id TokenId }

TokenInfo / With MetaData Extension. / Query metadata of token #[returns(TokenInfoResponse)]

type Tokens

type Tokens struct {
	Owner       string
	Start_after string
	Limit       uint32
}

Tokens / With Enumerable extension. / Returns all tokens owned by the given address [] if unset. #[returns(TokensResponse)]