types

package
v0.0.6 Latest Latest
Warning

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

 Go to latest Published: Sep 30, 2022 License: AGPL-3.0, Apache-2.0 Imports: 4 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	Yes        = "Yes"
	Abstain    = "Abstain"
	No         = "No"
	NoWithVeto = "NoWithVeto"
)

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 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"`
}

type BankQuery 

type BankQuery struct {
	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 seconds since unix epoch - since cosmwasm 0.3
	Time    uint64 `json:"time"`
	ChainID string `json:"chain_id"`
}

type BondedDenomResponse 

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

type CanonicalAddress 

type CanonicalAddress = []byte

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

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 {
	// binary encoding of sdk.AccAddress of the contract, to be used when sending messages
	Address HumanAddress `json:"address"`
}

type ContractKey 

type ContractKey string

type CosmosMsg 

type CosmosMsg struct {
	Bank    *BankMsg        `json:"bank,omitempty"`
	Custom  json.RawMessage `json:"custom,omitempty"`
	Staking *StakingMsg     `json:"staking,omitempty"`
	Wasm    *WasmMsg        `json:"wasm,omitempty"`
	Gov     *GovMsg         `json:"gov,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 DistQuery 

type DistQuery struct {
	Rewards *RewardsQuery `json:"rewards,omitempty"`
}

type Env 

type Env struct {
	Block     BlockInfo    `json:"block"`
	Message   MessageInfo  `json:"message"`
	Contract  ContractInfo `json:"contract"`
	Key       ContractKey  `json:"contract_key"`
	Recursive bool         `json:"recursive"`
}

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 ExceededRecursionLimit 

type ExceededRecursionLimit struct{}

func (ExceededRecursionLimit) Error 

func (e ExceededRecursionLimit) Error() string

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"`
	// Custom addition to support binding a message to specific code to harden against offline & replay attacks
	// This is only needed when creating a callback message
	CallbackCodeHash string `json:"callback_code_hash"`
	// 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
	Send              Coins  `json:"send"`
	CallbackSignature []byte `json:"callback_sig"` // Optional
}

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 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 GenericErr 

type GenericErr struct {
	Msg string `json:"msg,omitempty"`
}

func (GenericErr) Error 

func (e GenericErr) Error() string

type GovMsg 

type GovMsg struct {
	Vote *VoteMsg `json:"vote,omitempty"`
}

type GovQuery 

type GovQuery struct {
	Proposals *ProposalsQuery `json:"proposals,omitempty"`
}

type HandleResponse 

type HandleResponse struct {
	// Messages comes directly from the contract and is it's request for action
	Messages []CosmosMsg `json:"messages"`
	// base64-encoded bytes to return as ABCI.Data field
	Data []byte `json:"data"`
	// log message to return over abci interface
	Log []LogAttribute `json:"log"`
}

HandleResponse defines the return value on a successful handle

type HandleResult 

type HandleResult struct {
	Ok  *HandleResponse `json:"Ok,omitempty"`
	Err *StdError       `json:"Err,omitempty"`
}

HandleResult is the raw response from the handle call

type HumanAddress 

type HumanAddress = string

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

type InitResponse 

type InitResponse struct {
	// Messages comes directly from the contract and is it's request for action
	Messages []CosmosMsg `json:"messages"`
	// log message to return over abci interface
	Log []LogAttribute `json:"log"`
}

InitResponse defines the return value on a successful handle

type InitResult 

type InitResult struct {
	Ok  *InitResponse `json:"Ok,omitempty"`
	Err *StdError     `json:"Err,omitempty"`
}

InitResult is the raw response from the handle call

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"`
	// Custom addition to support binding a message to specific code to harden against offline & replay attacks
	// This is only needed when creating a callback message
	CallbackCodeHash string `json:"callback_code_hash"`
	// 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"`
	/// Label is a mandatory human-readbale label for the contract
	Label string `json:"label"`
	// Send is an optional amount of coins this contract sends to the called contract
	Send              Coins  `json:"send"`
	CallbackSignature []byte `json:"callback_sig"` // Optional
}

type InvalidBase64 

type InvalidBase64 struct {
	Msg string `json:"msg,omitempty"`
}

func (InvalidBase64) Error 

func (e InvalidBase64) Error() string

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 InvalidUtf8 

type InvalidUtf8 struct {
	Msg string `json:"msg,omitempty"`
}

func (InvalidUtf8) Error 

func (e InvalidUtf8) Error() string

type LogAttribute 

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

LogAttribute

type MessageInfo 

type MessageInfo struct {
	// binary encoding of sdk.AccAddress executing the contract
	Sender HumanAddress `json:"sender"`
	// amount of funds send to the contract along with this message
	SentFunds Coins `json:"sent_funds"`
}

type MigrateResponse 

type MigrateResponse struct {
	// Messages comes directly from the contract and is it's request for action
	Messages []CosmosMsg `json:"messages"`
	// base64-encoded bytes to return as ABCI.Data field
	Data []byte `json:"data"`
	// log message to return over abci interface
	Log []LogAttribute `json:"log"`
}

MigrateResponse defines the return value on a successful handle

type MigrateResult 

type MigrateResult struct {
	Ok  *MigrateResponse `json:"Ok,omitempty"`
	Err *StdError        `json:"Err,omitempty"`
}

MigrateResult is the raw response from the handle call

type MintQuery 

type MintQuery struct {
	Inflation   *MintingInflationQuery   `json:"inflation,omitempty"`
	BondedRatio *MintingBondedRatioQuery `json:"bonded_ratio,omitempty"`
}

type MintingBondedRatioQuery 

type MintingBondedRatioQuery struct{}

type MintingBondedRatioResponse 

type MintingBondedRatioResponse struct {
	BondedRatio string `json:"bonded_ratio"`
}

type MintingInflationQuery 

type MintingInflationQuery struct{}

type MintingInflationResponse 

type MintingInflationResponse struct {
	InflationRate string `json:"inflation_rate"`
}

type NoSuchContract 

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

func (NoSuchContract) Error 

func (e NoSuchContract) Error() string

type NotFound 

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

func (NotFound) Error 

func (e NotFound) Error() string

type OutOfGasError 

type OutOfGasError struct{}

func (OutOfGasError) Error 

func (o OutOfGasError) Error() string

type ParseErr 

type ParseErr struct {
	Target string `json:"target,omitempty"`
	Msg    string `json:"msg,omitempty"`
}

func (ParseErr) Error 

func (e ParseErr) Error() string

type Proposal 

type Proposal struct {
	ProposalID      uint64 `json:"id" yaml:"id"`                               //  ID of the proposal
	VotingStartTime uint64 `json:"voting_start_time" yaml:"voting_start_time"` // Time of the block where MinDeposit was reached. -1 if MinDeposit is not reached
	VotingEndTime   uint64 `json:"voting_end_time" yaml:"voting_end_time"`     // Time that the VotingPeriod for this proposal will end and votes will be tallied
}

type ProposalsQuery 

type ProposalsQuery struct{}

type ProposalsResponse 

type ProposalsResponse struct {
	Proposals []Proposal `json:"proposals,omitempty"`
}

DelegationResponse is the expected response to DelegationsQuery

func (ProposalsResponse) MarshalJSON 

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

MarshalJSON ensures that we get [] for empty arrays

func (*ProposalsResponse) UnmarshalJSON 

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

UnmarshalJSON ensures that we get [] for empty arrays

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:"Err,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"`
	Staking *StakingQuery   `json:"staking,omitempty"`
	Wasm    *WasmQuery      `json:"wasm,omitempty"`
	Dist    *DistQuery      `json:"dist,omitempty"`
	Mint    *MintQuery      `json:"mint,omitempty"`
	Gov     *GovQuery       `json:"gov,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 struct {
	Ok  []byte    `json:"Ok,omitempty"`
	Err *StdError `json:"Err,omitempty"`
}

type RawQuery 

type RawQuery struct {
	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 RewardCoins 

type RewardCoins []Coin

func (RewardCoins) MarshalJSON 

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

MarshalJSON ensures that we get [] for empty arrays

func (*RewardCoins) UnmarshalJSON 

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

UnmarshalJSON ensures that we get [] for empty arrays

type Rewards 

type Rewards struct {
	Validator string      `json:"validator_address"`
	Reward    RewardCoins `json:"reward"`
}

type RewardsQuery 

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

type RewardsResponse 

type RewardsResponse struct {
	Rewards []Rewards   `json:"rewards,omitempty"`
	Total   RewardCoins `json:"total,omitempty"`
}

DelegationResponse is the expected response to DelegationsQuery

type SendMsg 

type SendMsg struct {
	FromAddress string `json:"from_address"`
	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 SerializeErr 

type SerializeErr struct {
	Source string `json:"source,omitempty"`
	Msg    string `json:"msg,omitempty"`
}

func (SerializeErr) Error 

func (e SerializeErr) Error() string

type SmartQuery 

type SmartQuery struct {
	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"`
	Withdraw   *WithdrawMsg   `json:"withdraw,omitempty"`
}

type StakingQuery 

type StakingQuery struct {
	Validators           *ValidatorsQuery         `json:"validators,omitempty"`
	AllDelegations       *AllDelegationsQuery     `json:"all_delegations,omitempty"`
	Delegation           *DelegationQuery         `json:"delegation,omitempty"`
	UnBondingDelegations *UnbondingDeletionsQuery `json:"unbonding_delegations, omitempty"`
	BondedDenom          *struct{}                `json:"bonded_denom,omitempty"`
}

type StdError 

type StdError struct {
	GenericErr    *GenericErr    `json:"generic_err,omitempty"`
	InvalidBase64 *InvalidBase64 `json:"invalid_base64,omitempty"`
	InvalidUtf8   *InvalidUtf8   `json:"invalid_utf8,omitempty"`
	NotFound      *NotFound      `json:"not_found,omitempty"`
	ParseErr      *ParseErr      `json:"parse_err,omitempty"`
	SerializeErr  *SerializeErr  `json:"serialize_err,omitempty"`
	Unauthorized  *Unauthorized  `json:"unauthorized,omitempty"`
	Underflow     *Underflow     `json:"underflow,omitempty"`
}

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

func ToStdError 

func ToStdError(err error) *StdError

ToStdError will convert the given error to an StdError. 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, convert it to a GenericErr.

func (StdError) Error 

func (a StdError) Error() string

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"`
	ExceededRecursionLimit *ExceededRecursionLimit `json:"exceeded_recursion_limit,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 Unauthorized 

type Unauthorized struct{}

func (Unauthorized) Error 

func (e Unauthorized) Error() string

type UnbondingDelegationsResponse 

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

type UnbondingDeletionsQuery 

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

type UndelegateMsg 

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

type Underflow 

type Underflow struct {
	Minuend    string `json:"minuend,omitempty"`
	Subtrahend string `json:"subtrahend,omitempty"`
}

func (Underflow) Error 

func (e Underflow) Error() string

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 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 Validators 

type Validators []Validator

TODO: 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 ValidatorsQuery 

type ValidatorsQuery struct{}

type ValidatorsResponse 

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

ValidatorsResponse is the expected response to ValidatorsQuery

type VerificationInfo 

type VerificationInfo struct {
	Bytes             []byte `json:"sign_bytes"`
	SignMode          string `json:"sign_mode"`
	ModeInfo          []byte `json:"mode_info"`
	PublicKey         []byte `json:"public_key"`
	Signature         []byte `json:"signature"`
	CallbackSignature []byte `json:"callback_sig"` // Optional
}

type VoteMsg 

type VoteMsg struct {
	Proposal   uint64 `json:"proposal"`
	VoteOption string `json:"vote_option"`
}

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

type WasmMsg 

type WasmMsg struct {
	Execute     *ExecuteMsg     `json:"execute,omitempty"`
	Instantiate *InstantiateMsg `json:"instantiate,omitempty"`
}

type WasmQuery 

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

type WithdrawMsg 

type WithdrawMsg struct {
	Validator string `json:"validator"`
	// this is optional
	Recipient string `json:"recipient,omitempty"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.