types

package
v1.1.2 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 22, 2023 License: Apache-2.0 Imports: 4 Imported by: 0

Documentation

Index

Constants

View Source
const (
	Yes voteOption = iota
	No
	Abstain
	NoWithVeto
)
View Source
const (
	ReplyAlways replyOn = iota
	ReplySuccess
	ReplyError
	ReplyNever
)
View Source
const Ordered = "ORDER_ORDERED"
View Source
const Unordered = "ORDER_UNORDERED"

These are the only two valid values for IbcOrder

Variables

This section is empty.

Functions

This section is empty.

Types

type AllBalancesQuery

type AllBalancesQuery struct {
	Address string `json:"address"`
}

type AllBalancesResponse

type AllBalancesResponse struct {
	Amount Coins `json:"amount"`
}

AllBalancesResponse is the expected response to AllBalancesQuery

type AllDelegationsQuery

type AllDelegationsQuery struct {
	Delegator string `json:"delegator"`
}

type AllDelegationsResponse

type AllDelegationsResponse struct {
	Delegations Delegations `json:"delegations"`
}

AllDelegationsResponse is the expected response to AllDelegationsQuery

type AllValidatorsQuery

type AllValidatorsQuery struct{}

type AllValidatorsResponse

type AllValidatorsResponse struct {
	Validators Validators `json:"validators"`
}

AllValidatorsResponse is the expected response to AllValidatorsQuery

type AnalysisReport

type AnalysisReport struct {
	HasIBCEntryPoints bool
	// Deprecated, use RequiredCapabilities. For now both fields contain the same value.
	RequiredFeatures     string
	RequiredCapabilities string
}

Contains static analysis info of the contract (the Wasm code to be precise). This type is returned by VM.AnalyzeCode().

type BalanceQuery

type BalanceQuery struct {
	Address string `json:"address"`
	Denom   string `json:"denom"`
}

type BalanceResponse

type BalanceResponse struct {
	Amount Coin `json:"amount"`
}

BalanceResponse is the expected response to BalanceQuery

type BankMsg

type BankMsg struct {
	Send *SendMsg `json:"send,omitempty"`
	Burn *BurnMsg `json:"burn,omitempty"`
}

type BankQuery

type BankQuery struct {
	Supply      *SupplyQuery      `json:"supply,omitempty"`
	Balance     *BalanceQuery     `json:"balance,omitempty"`
	AllBalances *AllBalancesQuery `json:"all_balances,omitempty"`
}

type BlockInfo

type BlockInfo struct {
	// block height this transaction is executed
	Height uint64 `json:"height"`
	// time in nanoseconds since unix epoch. Uses string to ensure JavaScript compatibility.
	Time    uint64 `json:"time,string"`
	ChainID string `json:"chain_id"`
	Proof   []byte `json:"proof"`
}

type BondedDenomResponse

type BondedDenomResponse struct {
	Denom string `json:"denom"`
}

type BurnMsg

type BurnMsg struct {
	Amount Coins `json:"amount"`
}

BurnMsg will burn the given coins from the contract's account. There is no Cosmos SDK message that performs this, but it can be done by calling the bank keeper. Important if a contract controls significant token supply that must be retired.

type CanonicalAddress

type CanonicalAddress = []byte

CanonicalAddress uses standard base64 encoding, just use it as a label for developers

type ChannelQuery

type ChannelQuery struct {
	// optional argument
	PortID    string `json:"port_id,omitempty"`
	ChannelID string `json:"channel_id"`
}

type ChannelResponse

type ChannelResponse struct {
	// may be empty if there is no matching channel
	Channel *IBCChannel `json:"channel,omitempty"`
}

type ClearAdminMsg

type ClearAdminMsg struct {
	// ContractAddr is the sdk.AccAddress of the target contract.
	ContractAddr string `json:"contract_addr"`
}

ClearAdminMsg is the Go counterpart of WasmMsg::ClearAdmin (https://github.com/PikeEcosystem/cosmwasm/blob/v0.14.0-beta5/packages/std/src/results/cosmos_msg.rs#L158-L160).

type CloseChannelMsg

type CloseChannelMsg struct {
	ChannelID string `json:"channel_id"`
}

type Coin

type Coin struct {
	Denom  string `json:"denom"`  // type, eg. "ATOM"
	Amount string `json:"amount"` // string encoing of decimal value, eg. "12.3456"
}

Coin is a string representation of the sdk.Coin type (more portable than sdk.Int)

func NewCoin

func NewCoin(amount uint64, denom string) Coin

type Coins

type Coins []Coin

Coins handles properly serializing empty amounts

func (Coins) MarshalJSON

func (c Coins) MarshalJSON() ([]byte, error)

MarshalJSON ensures that we get [] for empty arrays

func (*Coins) UnmarshalJSON

func (c *Coins) UnmarshalJSON(data []byte) error

UnmarshalJSON ensures that we get [] for empty arrays

type ContractInfo

type ContractInfo struct {
	// Bech32 encoded sdk.AccAddress of the contract, to be used when sending messages
	Address HumanAddress `json:"address"`
}

type ContractInfoQuery

type ContractInfoQuery struct {
	// Bech32 encoded sdk.AccAddress of the contract
	ContractAddr string `json:"contract_addr"`
}

type ContractInfoResponse

type ContractInfoResponse struct {
	CodeID  uint64 `json:"code_id"`
	Creator string `json:"creator"`
	// Set to the admin who can migrate contract, if any
	Admin  string `json:"admin,omitempty"`
	Pinned bool   `json:"pinned"`
	// Set if the contract is IBC enabled
	IBCPort string `json:"ibc_port,omitempty"`
}

type ContractResult

type ContractResult struct {
	Ok  *Response `json:"ok,omitempty"`
	Err string    `json:"error,omitempty"`
}

ContractResult is the raw response from the instantiate/execute/migrate calls. This is mirrors Rust's ContractResult<Response>.

type CosmosMsg

type CosmosMsg struct {
	Bank         *BankMsg         `json:"bank,omitempty"`
	Custom       json.RawMessage  `json:"custom,omitempty"`
	Distribution *DistributionMsg `json:"distribution,omitempty"`
	Gov          *GovMsg          `json:"gov,omitempty"`
	IBC          *IBCMsg          `json:"ibc,omitempty"`
	Staking      *StakingMsg      `json:"staking,omitempty"`
	Stargate     *StargateMsg     `json:"stargate,omitempty"`
	Wasm         *WasmMsg         `json:"wasm,omitempty"`
}

CosmosMsg is an rust enum and only (exactly) one of the fields should be set Should we do a cleaner approach in Go? (type/data?)

type DelegateMsg

type DelegateMsg struct {
	Validator string `json:"validator"`
	Amount    Coin   `json:"amount"`
}

type Delegation

type Delegation struct {
	Delegator string `json:"delegator"`
	Validator string `json:"validator"`
	Amount    Coin   `json:"amount"`
}

type DelegationQuery

type DelegationQuery struct {
	Delegator string `json:"delegator"`
	Validator string `json:"validator"`
}

type DelegationResponse

type DelegationResponse struct {
	Delegation *FullDelegation `json:"delegation,omitempty"`
}

DelegationResponse is the expected response to DelegationsQuery

type Delegations

type Delegations []Delegation

func (Delegations) MarshalJSON

func (d Delegations) MarshalJSON() ([]byte, error)

MarshalJSON ensures that we get [] for empty arrays

func (*Delegations) UnmarshalJSON

func (d *Delegations) UnmarshalJSON(data []byte) error

UnmarshalJSON ensures that we get [] for empty arrays

type DistributionMsg

type DistributionMsg struct {
	SetWithdrawAddress      *SetWithdrawAddressMsg      `json:"set_withdraw_address,omitempty"`
	WithdrawDelegatorReward *WithdrawDelegatorRewardMsg `json:"withdraw_delegator_reward,omitempty"`
}

type Env

type Env struct {
	Block       BlockInfo        `json:"block"`
	Transaction *TransactionInfo `json:"transaction"`
	Contract    ContractInfo     `json:"contract"`
}

Env defines the state of the blockchain environment this contract is running in. This must contain only trusted data - nothing from the Tx itself that has not been verfied (like Signer).

Env are json encoded to a byte slice before passing to the wasm contract.

type Event

type Event struct {
	Type       string          `json:"type"`
	Attributes EventAttributes `json:"attributes"`
}

type EventAttribute

type EventAttribute struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

EventAttribute

type EventAttributes

type EventAttributes []EventAttribute

EventAttributes must encode empty array as []

func (EventAttributes) MarshalJSON

func (a EventAttributes) MarshalJSON() ([]byte, error)

MarshalJSON ensures that we get [] for empty arrays

func (*EventAttributes) UnmarshalJSON

func (a *EventAttributes) UnmarshalJSON(data []byte) error

UnmarshalJSON ensures that we get [] for empty arrays

type Events

type Events []Event

Events must encode empty array as []

func (Events) MarshalJSON

func (e Events) MarshalJSON() ([]byte, error)

MarshalJSON ensures that we get [] for empty arrays

func (*Events) UnmarshalJSON

func (e *Events) UnmarshalJSON(data []byte) error

UnmarshalJSON ensures that we get [] for empty arrays

type ExecuteMsg

type ExecuteMsg struct {
	// ContractAddr is the sdk.AccAddress of the contract, which uniquely defines
	// the contract ID and instance ID. The sdk module should maintain a reverse lookup table.
	ContractAddr string `json:"contract_addr"`
	// Msg is assumed to be a json-encoded message, which will be passed directly
	// as `userMsg` when calling `Handle` on the above-defined contract
	Msg []byte `json:"msg"`
	// Send is an optional amount of coins this contract sends to the called contract
	Funds Coins `json:"funds"`
}

ExecuteMsg is used to call another defined contract on this chain. The calling contract requires the callee to be defined beforehand, and the address should have been defined in initialization. And we assume the developer tested the ABIs and coded them together.

Since a contract is immutable once it is deployed, we don't need to transform this. If it was properly coded and worked once, it will continue to work throughout upgrades.

type Fraction

type Fraction struct {
	Numerator   int64
	Denominator int64
}

func (Fraction) Floor

func (f Fraction) Floor() int64

func (*Fraction) Mul

func (f *Fraction) Mul(m int64) Fraction

type FullDelegation

type FullDelegation struct {
	Delegator          string `json:"delegator"`
	Validator          string `json:"validator"`
	Amount             Coin   `json:"amount"`
	AccumulatedRewards Coins  `json:"accumulated_rewards"`
	CanRedelegate      Coin   `json:"can_redelegate"`
}

type GovMsg

type GovMsg struct {
	// This maps directly to [MsgVote](https://github.com/cosmos/cosmos-sdk/blob/v0.42.5/proto/cosmos/gov/v1beta1/tx.proto#L46-L56) in the Cosmos SDK with voter set to the contract address.
	Vote *VoteMsg `json:"vote,omitempty"`
}

type HumanAddress

type HumanAddress = string

HumanAddress is a printable (typically bech32 encoded) address string. Just use it as a label for developers.

type IBC3ChannelOpenResponse

type IBC3ChannelOpenResponse struct {
	Version string `json:"version"`
}

IBC3ChannelOpenResponse is version negotiation data for the handshake

type IBCAcknowledgement

type IBCAcknowledgement struct {
	Data []byte `json:"data"`
}

type IBCBasicResponse

type IBCBasicResponse struct {
	// Messages comes directly from the contract and is its request for action.
	// If the ReplyOn value matches the result, the runtime will invoke this
	// contract's `reply` entry point after execution. Otherwise, this is all
	// "fire and forget".
	Messages []SubMsg `json:"messages"`
	// attributes for a log event to return over abci interface
	Attributes []EventAttribute `json:"attributes"`
	// custom events (separate from the main one that contains the attributes
	// above)
	Events []Event `json:"events"`
}

IBCBasicResponse defines the return value on a successful processing. This is the counterpart of [IbcBasicResponse](https://github.com/PikeEcosystem/cosmwasm/blob/v0.14.0-beta1/packages/std/src/ibc.rs#L194-L216).

type IBCBasicResult

type IBCBasicResult struct {
	Ok  *IBCBasicResponse `json:"ok,omitempty"`
	Err string            `json:"error,omitempty"`
}

This is the return value for the majority of the ibc handlers. That are able to dispatch messages / events on their own, but have no meaningful return value to the calling code.

Callbacks that have return values (like ibc_receive_packet) or that cannot redispatch messages (like ibc_channel_open) will use other Response types

type IBCChannel

type IBCChannel struct {
	Endpoint             IBCEndpoint `json:"endpoint"`
	CounterpartyEndpoint IBCEndpoint `json:"counterparty_endpoint"`
	Order                IBCOrder    `json:"order"`
	Version              string      `json:"version"`
	ConnectionID         string      `json:"connection_id"`
}

type IBCChannelCloseMsg

type IBCChannelCloseMsg struct {
	CloseInit    *IBCCloseInit    `json:"close_init,omitempty"`
	CloseConfirm *IBCCloseConfirm `json:"close_confirm,omitempty"`
}

func (IBCChannelCloseMsg) GetChannel

func (msg IBCChannelCloseMsg) GetChannel() IBCChannel

GetChannel returns the IBCChannel in this message.

type IBCChannelConnectMsg

type IBCChannelConnectMsg struct {
	OpenAck     *IBCOpenAck     `json:"open_ack,omitempty"`
	OpenConfirm *IBCOpenConfirm `json:"open_confirm,omitempty"`
}

func (IBCChannelConnectMsg) GetChannel

func (msg IBCChannelConnectMsg) GetChannel() IBCChannel

GetChannel returns the IBCChannel in this message.

func (IBCChannelConnectMsg) GetCounterVersion

func (msg IBCChannelConnectMsg) GetCounterVersion() (ver string, ok bool)

GetCounterVersion checks if the message has a counterparty version and returns it if so.

type IBCChannelOpenMsg

type IBCChannelOpenMsg struct {
	OpenInit *IBCOpenInit `json:"open_init,omitempty"`
	OpenTry  *IBCOpenTry  `json:"open_try,omitempty"`
}

func (IBCChannelOpenMsg) GetChannel

func (msg IBCChannelOpenMsg) GetChannel() IBCChannel

GetChannel returns the IBCChannel in this message.

func (IBCChannelOpenMsg) GetCounterVersion

func (msg IBCChannelOpenMsg) GetCounterVersion() (ver string, ok bool)

GetCounterVersion checks if the message has a counterparty version and returns it if so.

type IBCChannelOpenResult

type IBCChannelOpenResult struct {
	Ok  *IBC3ChannelOpenResponse `json:"ok,omitempty"`
	Err string                   `json:"error,omitempty"`
}

IBCChannelOpenResult is the raw response from the ibc_channel_open call. This is mirrors Rust's ContractResult<()>. Check if Err == "" to see if this is success On Success, IBCV3ChannelOpenResponse *may* be set if the contract is ibcv3 compatible and wishes to define a custom version in the handshake.

type IBCChannels

type IBCChannels []IBCChannel

IBCChannels must JSON encode empty array as [] (not null) for consistency with Rust parser

func (IBCChannels) MarshalJSON

func (e IBCChannels) MarshalJSON() ([]byte, error)

MarshalJSON ensures that we get [] for empty arrays

func (*IBCChannels) UnmarshalJSON

func (e *IBCChannels) UnmarshalJSON(data []byte) error

UnmarshalJSON ensures that we get [] for empty arrays

type IBCCloseConfirm

type IBCCloseConfirm struct {
	Channel IBCChannel `json:"channel"`
}

func (*IBCCloseConfirm) ToMsg

type IBCCloseInit

type IBCCloseInit struct {
	Channel IBCChannel `json:"channel"`
}

func (*IBCCloseInit) ToMsg

func (m *IBCCloseInit) ToMsg() IBCChannelCloseMsg

type IBCEndpoint

type IBCEndpoint struct {
	PortID    string `json:"port_id"`
	ChannelID string `json:"channel_id"`
}

type IBCEndpoints

type IBCEndpoints []IBCEndpoint

IBCEndpoints must JSON encode empty array as [] (not null) for consistency with Rust parser

func (IBCEndpoints) MarshalJSON

func (e IBCEndpoints) MarshalJSON() ([]byte, error)

MarshalJSON ensures that we get [] for empty arrays

func (*IBCEndpoints) UnmarshalJSON

func (e *IBCEndpoints) UnmarshalJSON(data []byte) error

UnmarshalJSON ensures that we get [] for empty arrays

type IBCMsg

type IBCMsg struct {
	Transfer     *TransferMsg     `json:"transfer,omitempty"`
	SendPacket   *SendPacketMsg   `json:"send_packet,omitempty"`
	CloseChannel *CloseChannelMsg `json:"close_channel,omitempty"`
}

type IBCOpenAck

type IBCOpenAck struct {
	Channel             IBCChannel `json:"channel"`
	CounterpartyVersion string     `json:"counterparty_version"`
}

func (*IBCOpenAck) ToMsg

func (m *IBCOpenAck) ToMsg() IBCChannelConnectMsg

type IBCOpenConfirm

type IBCOpenConfirm struct {
	Channel IBCChannel `json:"channel"`
}

func (*IBCOpenConfirm) ToMsg

type IBCOpenInit

type IBCOpenInit struct {
	Channel IBCChannel `json:"channel"`
}

func (*IBCOpenInit) ToMsg

func (m *IBCOpenInit) ToMsg() IBCChannelOpenMsg

type IBCOpenTry

type IBCOpenTry struct {
	Channel             IBCChannel `json:"channel"`
	CounterpartyVersion string     `json:"counterparty_version"`
}

func (*IBCOpenTry) ToMsg

func (m *IBCOpenTry) ToMsg() IBCChannelOpenMsg

type IBCPacket

type IBCPacket struct {
	Data     []byte      `json:"data"`
	Src      IBCEndpoint `json:"src"`
	Dest     IBCEndpoint `json:"dest"`
	Sequence uint64      `json:"sequence"`
	Timeout  IBCTimeout  `json:"timeout"`
}

type IBCPacketAckMsg

type IBCPacketAckMsg struct {
	Acknowledgement IBCAcknowledgement `json:"acknowledgement"`
	OriginalPacket  IBCPacket          `json:"original_packet"`
	Relayer         string             `json:"relayer"`
}

type IBCPacketReceiveMsg

type IBCPacketReceiveMsg struct {
	Packet  IBCPacket `json:"packet"`
	Relayer string    `json:"relayer"`
}

type IBCPacketTimeoutMsg

type IBCPacketTimeoutMsg struct {
	Packet  IBCPacket `json:"packet"`
	Relayer string    `json:"relayer"`
}

type IBCQuery

type IBCQuery struct {
	PortID       *PortIDQuery       `json:"port_id,omitempty"`
	ListChannels *ListChannelsQuery `json:"list_channels,omitempty"`
	Channel      *ChannelQuery      `json:"channel,omitempty"`
}

IBCQuery defines a query request from the contract into the chain. This is the counterpart of [IbcQuery](https://github.com/PikeEcosystem/cosmwasm/blob/v0.14.0-beta1/packages/std/src/ibc.rs#L61-L83).

type IBCReceiveResponse

type IBCReceiveResponse struct {
	// binary encoded data to be returned to calling chain as the acknowledgement
	Acknowledgement []byte `json:"acknowledgement"`
	// Messages comes directly from the contract and is it's request for action.
	// If the ReplyOn value matches the result, the runtime will invoke this
	// contract's `reply` entry point after execution. Otherwise, this is all
	// "fire and forget".
	Messages   []SubMsg         `json:"messages"`
	Attributes []EventAttribute `json:"attributes"`
	// custom events (separate from the main one that contains the attributes
	// above)
	Events []Event `json:"events"`
}

IBCReceiveResponse defines the return value on packet response processing. This "success" case should be returned even in application-level errors, Where the Acknowledgement bytes contain an encoded error message to be returned to the calling chain. (Returning IBCReceiveResult::Err will abort processing of this packet and not inform the calling chain). This is the counterpart of (IbcReceiveResponse)(https://github.com/PikeEcosystem/cosmwasm/blob/v0.15.0/packages/std/src/ibc.rs#L247-L267).

type IBCReceiveResult

type IBCReceiveResult struct {
	Ok  *IBCReceiveResponse `json:"ok,omitempty"`
	Err string              `json:"error,omitempty"`
}

This is the return value for the majority of the ibc handlers. That are able to dispatch messages / events on their own, but have no meaningful return value to the calling code.

Callbacks that have return values (like receive_packet) or that cannot redispatch messages (like the handshake callbacks) will use other Response types

type IBCTimeout

type IBCTimeout struct {
	Block *IBCTimeoutBlock `json:"block"`
	// Nanoseconds since UNIX epoch
	Timestamp uint64 `json:"timestamp,string,omitempty"`
}

IBCTimeout is the timeout for an IBC packet. At least one of block and timestamp is required.

type IBCTimeoutBlock

type IBCTimeoutBlock struct {
	// the version that the client is currently on
	// (eg. after reseting the chain this could increment 1 as height drops to 0)
	Revision uint64 `json:"revision"`
	// block height after which the packet times out.
	// the height within the given revision
	Height uint64 `json:"height"`
}

IBCTimeoutBlock Height is a monotonically increasing data type that can be compared against another Height for the purposes of updating and freezing clients. Ordering is (revision_number, timeout_height)

func (IBCTimeoutBlock) IsZero

func (t IBCTimeoutBlock) IsZero() bool

type InstantiateMsg

type InstantiateMsg struct {
	// CodeID is the reference to the wasm byte code as used by the Cosmos-SDK
	CodeID uint64 `json:"code_id"`
	// Msg is assumed to be a json-encoded message, which will be passed directly
	// as `userMsg` when calling `Init` on a new contract with the above-defined CodeID
	Msg []byte `json:"msg"`
	// Send is an optional amount of coins this contract sends to the called contract
	Funds Coins `json:"funds"`
	// Label is optional metadata to be stored with a contract instance.
	Label string `json:"label"`
	// Admin (optional) may be set here to allow future migrations from this address
	Admin string `json:"admin,omitempty"`
}

InstantiateMsg will create a new contract instance from a previously uploaded CodeID. This allows one contract to spawn "sub-contracts".

type InvalidRequest

type InvalidRequest struct {
	Err     string `json:"error"`
	Request []byte `json:"request"`
}

func (InvalidRequest) Error

func (e InvalidRequest) Error() string

type InvalidResponse

type InvalidResponse struct {
	Err      string `json:"error"`
	Response []byte `json:"response"`
}

func (InvalidResponse) Error

func (e InvalidResponse) Error() string

type ListChannelsQuery

type ListChannelsQuery struct {
	// optional argument
	PortID string `json:"port_id,omitempty"`
}

ListChannelsQuery is an IBCQuery that lists all channels that are bound to a given port. If `PortID` is unset, this list all channels bound to the contract's port. Returns a `ListChannelsResponse`. This is the counterpart of [IbcQuery::ListChannels](https://github.com/PikeEcosystem/cosmwasm/blob/v0.14.0-beta1/packages/std/src/ibc.rs#L70-L73).

type ListChannelsResponse

type ListChannelsResponse struct {
	Channels IBCChannels `json:"channels"`
}

type MessageInfo

type MessageInfo struct {
	// Bech32 encoded sdk.AccAddress executing the contract
	Sender HumanAddress `json:"sender"`
	// Amount of funds send to the contract along with this message
	Funds Coins `json:"funds"`
}

type Metrics

type Metrics struct {
	HitsPinnedMemoryCache     uint32
	HitsMemoryCache           uint32
	HitsFsCache               uint32
	Misses                    uint32
	ElementsPinnedMemoryCache uint64
	ElementsMemoryCache       uint64
	// Cumulative size of all elements in pinned memory cache (in bytes)
	SizePinnedMemoryCache uint64
	// Cumulative size of all elements in memory cache (in bytes)
	SizeMemoryCache uint64
}

type MigrateMsg

type MigrateMsg struct {
	// ContractAddr is the sdk.AccAddress of the target contract, to migrate.
	ContractAddr string `json:"contract_addr"`
	// NewCodeID is the reference to the wasm byte code for the new logic to migrate to
	NewCodeID uint64 `json:"new_code_id"`
	// Msg is assumed to be a json-encoded message, which will be passed directly
	// as `userMsg` when calling `Migrate` on the above-defined contract
	Msg []byte `json:"msg"`
}

MigrateMsg will migrate an existing contract from it's current wasm code (logic) to another previously uploaded wasm code. It requires the calling contract to be listed as "admin" of the contract to be migrated.

type NoSuchContract

type NoSuchContract struct {
	Addr string `json:"addr,omitempty"`
}

func (NoSuchContract) Error

func (e NoSuchContract) Error() string

type OutOfGasError

type OutOfGasError struct{}

func (OutOfGasError) Error

func (o OutOfGasError) Error() string

type PortIDQuery

type PortIDQuery struct{}

type PortIDResponse

type PortIDResponse struct {
	PortID string `json:"port_id"`
}

type Querier

type Querier interface {
	Query(request QueryRequest, gasLimit uint64) ([]byte, error)
	GasConsumed() uint64
}

type QuerierResult

type QuerierResult struct {
	Ok  *QueryResponse `json:"ok,omitempty"`
	Err *SystemError   `json:"error,omitempty"`
}

This is a 2-level result

func RustQuery

func RustQuery(querier Querier, binRequest []byte, gasLimit uint64) QuerierResult

this is a thin wrapper around the desired Go API to give us types closer to Rust FFI

func ToQuerierResult

func ToQuerierResult(response []byte, err error) QuerierResult

type QueryRequest

type QueryRequest struct {
	Bank     *BankQuery      `json:"bank,omitempty"`
	Custom   json.RawMessage `json:"custom,omitempty"`
	IBC      *IBCQuery       `json:"ibc,omitempty"`
	Staking  *StakingQuery   `json:"staking,omitempty"`
	Stargate *StargateQuery  `json:"stargate,omitempty"`
	Wasm     *WasmQuery      `json:"wasm,omitempty"`
}

QueryRequest is an rust enum and only (exactly) one of the fields should be set Should we do a cleaner approach in Go? (type/data?)

type QueryResponse

type QueryResponse queryResponseImpl

QueryResponse is the Go counterpart of `ContractResult<Binary>`. The JSON annotations are used for deserializing directly. There is a custom serializer below.

func (QueryResponse) MarshalJSON

func (q QueryResponse) MarshalJSON() ([]byte, error)

A custom serializer that allows us to map QueryResponse instances to the Rust enum `ContractResult<Binary>`

type RawQuery

type RawQuery struct {
	// Bech32 encoded sdk.AccAddress of the contract
	ContractAddr string `json:"contract_addr"`
	Key          []byte `json:"key"`
}

RawQuery response is raw bytes ([]byte)

type RedelegateMsg

type RedelegateMsg struct {
	SrcValidator string `json:"src_validator"`
	DstValidator string `json:"dst_validator"`
	Amount       Coin   `json:"amount"`
}

type Reply

type Reply struct {
	ID     uint64       `json:"id"`
	Result SubMsgResult `json:"result"`
}

type Response

type Response struct {
	// Messages comes directly from the contract and is its request for action.
	// If the ReplyOn value matches the result, the runtime will invoke this
	// contract's `reply` entry point after execution. Otherwise, this is all
	// "fire and forget".
	Messages []SubMsg `json:"messages"`
	// base64-encoded bytes to return as ABCI.Data field
	Data []byte `json:"data"`
	// attributes for a log event to return over abci interface
	Attributes []EventAttribute `json:"attributes"`
	// custom events (separate from the main one that contains the attributes
	// above)
	Events []Event `json:"events"`
}

Response defines the return value on a successful instantiate/execute/migrate. This is the counterpart of Response(https://github.com/PikeEcosystem/cosmwasm/blob/v0.14.0-beta1/packages/std/src/results/response.rs#L73-L88)

type SendMsg

type SendMsg struct {
	ToAddress string `json:"to_address"`
	Amount    Coins  `json:"amount"`
}

SendMsg contains instructions for a Cosmos-SDK/SendMsg It has a fixed interface here and should be converted into the proper SDK format before dispatching

type SendPacketMsg

type SendPacketMsg struct {
	ChannelID string     `json:"channel_id"`
	Data      []byte     `json:"data"`
	Timeout   IBCTimeout `json:"timeout"`
}

type SetWithdrawAddressMsg

type SetWithdrawAddressMsg struct {
	// Address contains the `delegator_address` of a MsgSetWithdrawAddress
	Address string `json:"address"`
}

SetWithdrawAddressMsg is translated to a [MsgSetWithdrawAddress](https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto#L29-L37). `delegator_address` is automatically filled with the current contract's address.

type SmartQuery

type SmartQuery struct {
	// Bech32 encoded sdk.AccAddress of the contract
	ContractAddr string `json:"contract_addr"`
	Msg          []byte `json:"msg"`
}

SmartQuery respone is raw bytes ([]byte)

type StakingMsg

type StakingMsg struct {
	Delegate   *DelegateMsg   `json:"delegate,omitempty"`
	Undelegate *UndelegateMsg `json:"undelegate,omitempty"`
	Redelegate *RedelegateMsg `json:"redelegate,omitempty"`
}

type StakingQuery

type StakingQuery struct {
	AllValidators  *AllValidatorsQuery  `json:"all_validators,omitempty"`
	Validator      *ValidatorQuery      `json:"validator,omitempty"`
	AllDelegations *AllDelegationsQuery `json:"all_delegations,omitempty"`
	Delegation     *DelegationQuery     `json:"delegation,omitempty"`
	BondedDenom    *struct{}            `json:"bonded_denom,omitempty"`
}

type StargateMsg

type StargateMsg struct {
	TypeURL string `json:"type_url"`
	Value   []byte `json:"value"`
}

StargateMsg is encoded the same way as a protobof [Any](https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto). This is the same structure as messages in `TxBody` from [ADR-020](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-020-protobuf-transaction-encoding.md)

type StargateQuery

type StargateQuery struct {
	// this is the fully qualified service path used for routing,
	// eg. custom/cosmos_sdk.x.bank.v1.Query/QueryBalance
	Path string `json:"path"`
	// this is the expected protobuf message type (not any), binary encoded
	Data []byte `json:"data"`
}

StargateQuery is encoded the same way as abci_query, with path and protobuf encoded request data. The format is defined in [ADR-21](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-021-protobuf-query-encoding.md). The response is protobuf encoded data directly without a JSON response wrapper. The caller is responsible for compiling the proper protobuf definitions for both requests and responses.

type SubMsg

type SubMsg struct {
	ID       uint64    `json:"id"`
	Msg      CosmosMsg `json:"msg"`
	GasLimit *uint64   `json:"gas_limit,omitempty"`
	ReplyOn  replyOn   `json:"reply_on"`
}

SubMsg wraps a CosmosMsg with some metadata for handling replies (ID) and optionally limiting the gas usage (GasLimit)

type SubMsgResponse

type SubMsgResponse struct {
	Events Events `json:"events"`
	Data   []byte `json:"data,omitempty"`
}

SubMsgResponse contains information we get back from a successful sub message execution, with full Cosmos SDK events. This mirrors Rust's SubMsgResponse.

type SubMsgResult

type SubMsgResult struct {
	Ok  *SubMsgResponse `json:"ok,omitempty"`
	Err string          `json:"error,omitempty"`
}

SubMsgResult is the raw response we return from wasmd after executing a SubMsg. This mirrors Rust's SubMsgResult.

type SubcallResponse deprecated

type SubcallResponse = SubMsgResponse

Deprecated: Renamed to SubMsgResponse

type SubcallResult deprecated

type SubcallResult = SubMsgResult

Deprecated: Renamed to SubMsgResult

type SupplyQuery

type SupplyQuery struct {
	Denom string `json:"denom"`
}

type SupplyResponse

type SupplyResponse struct {
	Amount Coin `json:"amount"`
}

SupplyResponse is the expected response to SupplyQuery

type SystemError

type SystemError struct {
	InvalidRequest     *InvalidRequest     `json:"invalid_request,omitempty"`
	InvalidResponse    *InvalidResponse    `json:"invalid_response,omitempty"`
	NoSuchContract     *NoSuchContract     `json:"no_such_contract,omitempty"`
	Unknown            *Unknown            `json:"unknown,omitempty"`
	UnsupportedRequest *UnsupportedRequest `json:"unsupported_request,omitempty"`
}

SystemError captures all errors returned from the Rust code as SystemError. Exactly one of the fields should be set.

func ToSystemError

func ToSystemError(err error) *SystemError

ToSystemError will try to convert the given error to an SystemError. This is important to returning any Go error back to Rust.

If it is already StdError, return self. If it is an error, which could be a sub-field of StdError, embed it. If it is anything else, **return nil**

This may return nil on an unknown error, whereas ToStdError will always create a valid error type.

func (SystemError) Error

func (a SystemError) Error() string

type TransactionInfo

type TransactionInfo struct {
	// Position of this transaction in the block.
	// The first transaction has index 0
	//
	// Along with BlockInfo.Height, this allows you to get a unique
	// transaction identifier for the chain for future queries
	Index uint32 `json:"index"`
}

type TransferMsg

type TransferMsg struct {
	ChannelID string     `json:"channel_id"`
	ToAddress string     `json:"to_address"`
	Amount    Coin       `json:"amount"`
	Timeout   IBCTimeout `json:"timeout"`
}

type UFraction

type UFraction struct {
	Numerator   uint64
	Denominator uint64
}

func (UFraction) Floor

func (f UFraction) Floor() uint64

func (*UFraction) Mul

func (f *UFraction) Mul(m uint64) UFraction

type UndelegateMsg

type UndelegateMsg struct {
	Validator string `json:"validator"`
	Amount    Coin   `json:"amount"`
}

type Unknown

type Unknown struct{}

func (Unknown) Error

func (e Unknown) Error() string

type UnsupportedRequest

type UnsupportedRequest struct {
	Kind string `json:"kind,omitempty"`
}

func (UnsupportedRequest) Error

func (e UnsupportedRequest) Error() string

type UpdateAdminMsg

type UpdateAdminMsg struct {
	// ContractAddr is the sdk.AccAddress of the target contract.
	ContractAddr string `json:"contract_addr"`
	// Admin is the sdk.AccAddress of the new admin.
	Admin string `json:"admin"`
}

UpdateAdminMsg is the Go counterpart of WasmMsg::UpdateAdmin (https://github.com/PikeEcosystem/cosmwasm/blob/v0.14.0-beta5/packages/std/src/results/cosmos_msg.rs#L158-L160).

type Validator

type Validator struct {
	Address string `json:"address"`
	// decimal string, eg "0.02"
	Commission string `json:"commission"`
	// decimal string, eg "0.02"
	MaxCommission string `json:"max_commission"`
	// decimal string, eg "0.02"
	MaxChangeRate string `json:"max_change_rate"`
}

type ValidatorQuery

type ValidatorQuery struct {
	/// Address is the validator's address (e.g. cosmosvaloper1...)
	Address string `json:"address"`
}

type ValidatorResponse

type ValidatorResponse struct {
	Validator *Validator `json:"validator"` // serializes to `null` when unset which matches Rust's Option::None serialization
}

ValidatorResponse is the expected response to ValidatorQuery

type Validators

type Validators []Validator

Validators must JSON encode empty array as []

func (Validators) MarshalJSON

func (v Validators) MarshalJSON() ([]byte, error)

MarshalJSON ensures that we get [] for empty arrays

func (*Validators) UnmarshalJSON

func (v *Validators) UnmarshalJSON(data []byte) error

UnmarshalJSON ensures that we get [] for empty arrays

type VoteMsg

type VoteMsg struct {
	ProposalId uint64     `json:"proposal_id"`
	Vote       voteOption `json:"vote"`
}

type WasmMsg

type WasmMsg struct {
	Execute     *ExecuteMsg     `json:"execute,omitempty"`
	Instantiate *InstantiateMsg `json:"instantiate,omitempty"`
	Migrate     *MigrateMsg     `json:"migrate,omitempty"`
	UpdateAdmin *UpdateAdminMsg `json:"update_admin,omitempty"`
	ClearAdmin  *ClearAdminMsg  `json:"clear_admin,omitempty"`
}

type WasmQuery

type WasmQuery struct {
	Smart        *SmartQuery        `json:"smart,omitempty"`
	Raw          *RawQuery          `json:"raw,omitempty"`
	ContractInfo *ContractInfoQuery `json:"contract_info,omitempty"`
}

type WithdrawDelegatorRewardMsg

type WithdrawDelegatorRewardMsg struct {
	// Validator contains `validator_address` of a MsgWithdrawDelegatorReward
	Validator string `json:"validator"`
}

WithdrawDelegatorRewardMsg is translated to a [MsgWithdrawDelegatorReward](https://github.com/cosmos/cosmos-sdk/blob/v0.42.4/proto/cosmos/distribution/v1beta1/tx.proto#L42-L50). `delegator_address` is automatically filled with the current contract's address.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL