auth

type Account ¶

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

	GetPubKey() crypto.PubKey // can return nil.
	SetPubKey(crypto.PubKey) 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 ¶

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

AccountDecoder unmarshals account bytes

type AccountKeeper ¶

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) 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) 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"`
	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) GetAddress() sdk.AccAddress

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

func (acc BaseAccount) GetPubKey() crypto.PubKey

func (acc *BaseAccount) GetSequence() int64

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 ¶

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 GenesisState ¶

type GenesisState struct {
	CollectedFees sdk.Coins `json:"collected_fees"` // collected fees
}

GenesisState - all auth state that must be provided at genesis

func DefaultGenesisState() GenesisState

func ExportGenesis(ctx sdk.Context, keeper FeeCollectionKeeper) GenesisState

func NewGenesisState(collectedFees sdk.Coins) GenesisState

type StdFee ¶

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 ¶

type StdSignDoc struct {
	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 ¶

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

Standard Signature

type StdTx ¶

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