auth

type Account ¶ added in v0.18.0

type Account interface {
	GetAddress() sdk.AccAddress
	SetAddress(sdk.AccAddress) error // errors if already set.

	GetPubKey() crypto.PubKey // can return nil.
	SetPubKey(crypto.PubKey) error

	GetAccountNumber() int64
	SetAccountNumber(int64) error

	GetSequence() int64
	SetSequence(int64) error

	GetCoins() sdk.Coins
	SetCoins(sdk.Coins) error
}

Account is an interface used to store coins at a given address within state. It presumes a notion of sequence numbers for replay protection, a notion of account numbers for replay protection for previously pruned accounts, and a pubkey for authentication purposes.

Many complex conditions can be used in the concrete struct which implements Account.

func GetSigners(ctx types.Context) []Account

func ProtoBaseAccount() Account

type AccountDecoder ¶ added in v0.18.0

type AccountDecoder func(accountBytes []byte) (Account, error)

AccountDecoder unmarshals account bytes

type AccountKeeper ¶ added in v0.25.0

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

This AccountKeeper encodes/decodes accounts using the go-amino (binary) encoding/decoding library.

func NewAccountKeeper(cdc *codec.Codec, key sdk.StoreKey, proto func() Account) AccountKeeper

func (am AccountKeeper) GetAccount(ctx sdk.Context, addr sdk.AccAddress) Account

func (am AccountKeeper) GetNextAccountNumber(ctx sdk.Context) int64

func (am AccountKeeper) GetPubKey(ctx sdk.Context, addr sdk.AccAddress) (crypto.PubKey, sdk.Error)

func (am AccountKeeper) GetSequence(ctx sdk.Context, addr sdk.AccAddress) (int64, sdk.Error)

func (am AccountKeeper) IterateAccounts(ctx sdk.Context, process func(Account) (stop bool))

func (am AccountKeeper) NewAccount(ctx sdk.Context, acc Account) Account

func (am AccountKeeper) NewAccountWithAddress(ctx sdk.Context, addr sdk.AccAddress) Account

func (am AccountKeeper) RemoveAccount(ctx sdk.Context, acc Account)

func (am AccountKeeper) SetAccount(ctx sdk.Context, acc Account)

type BaseAccount ¶

type BaseAccount struct {
	Address       sdk.AccAddress `json:"address"`
	Coins         sdk.Coins      `json:"coins"`
	PubKey        crypto.PubKey  `json:"public_key"`
	AccountNumber int64          `json:"account_number"`
	Sequence      int64          `json:"sequence"`
}

BaseAccount - a base account structure. This can be extended by embedding within in your AppAccount. There are examples of this in: examples/basecoin/types/account.go. However one doesn't have to use BaseAccount as long as your struct implements Account.

func NewBaseAccountWithAddress(addr sdk.AccAddress) BaseAccount

func (acc *BaseAccount) GetAccountNumber() int64

func (acc BaseAccount) GetAddress() sdk.AccAddress

func (acc *BaseAccount) GetCoins() sdk.Coins

func (acc BaseAccount) GetPubKey() crypto.PubKey

func (acc *BaseAccount) GetSequence() int64

func (acc *BaseAccount) SetAccountNumber(accNumber int64) error

func (acc *BaseAccount) SetAddress(addr sdk.AccAddress) error

func (acc *BaseAccount) SetCoins(coins sdk.Coins) error

func (acc *BaseAccount) SetPubKey(pubKey crypto.PubKey) error

func (acc *BaseAccount) SetSequence(seq int64) error

type FeeCollectionKeeper ¶ added in v0.18.0

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

This FeeCollectionKeeper handles collection of fees in the anteHandler and setting of MinFees for different fee tokens

func NewFeeCollectionKeeper(cdc *codec.Codec, key sdk.StoreKey) FeeCollectionKeeper

func (fck FeeCollectionKeeper) AddCollectedFees(ctx sdk.Context, coins sdk.Coins) sdk.Coins

func (fck FeeCollectionKeeper) ClearCollectedFees(ctx sdk.Context)

func (fck FeeCollectionKeeper) GetCollectedFees(ctx sdk.Context) sdk.Coins

type StdFee ¶ added in v0.18.0

type StdFee struct {
	Amount sdk.Coins `json:"amount"`
	Gas    int64     `json:"gas"`
}

StdFee includes the amount of coins paid in fees and the maximum gas to be used by the transaction. The ratio yields an effective "gasprice", which must be above some miminum to be accepted into the mempool.

func NewStdFee(gas int64, amount ...sdk.Coin) StdFee

func (fee StdFee) Bytes() []byte

type StdSignDoc ¶ added in v0.18.0

type StdSignDoc struct {
	AccountNumber int64             `json:"account_number"`
	ChainID       string            `json:"chain_id"`
	Fee           json.RawMessage   `json:"fee"`
	Memo          string            `json:"memo"`
	Msgs          []json.RawMessage `json:"msgs"`
	Sequence      int64             `json:"sequence"`
}

StdSignDoc is replay-prevention structure. It includes the result of msg.GetSignBytes(), as well as the ChainID (prevent cross chain replay) and the Sequence numbers for each signature (prevent inchain replay and enforce tx ordering per account).

type StdSignature ¶ added in v0.18.0

type StdSignature struct {
	crypto.PubKey `json:"pub_key"` // optional
	Signature     []byte           `json:"signature"`
	AccountNumber int64            `json:"account_number"`
	Sequence      int64            `json:"sequence"`
}

Standard Signature

type StdTx ¶ added in v0.18.0

type StdTx struct {
	Msgs       []sdk.Msg      `json:"msg"`
	Fee        StdFee         `json:"fee"`
	Signatures []StdSignature `json:"signatures"`
	Memo       string         `json:"memo"`
}

StdTx is a standard way to wrap a Msg with Fee and Signatures. NOTE: the first signature is the fee payer (Signatures must not be nil).

func NewStdTx(msgs []sdk.Msg, fee StdFee, sigs []StdSignature, memo string) StdTx

func (tx StdTx) GetMemo() string

func (tx StdTx) GetMsgs() []sdk.Msg

func (tx StdTx) GetSignatures() []StdSignature

func (tx StdTx) GetSigners() []sdk.AccAddress