auth

package
v0.9.1 Latest Latest
Warning

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

 Go to latest Published: Jan 4, 2019 License: Apache-2.0 Imports: 13 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AddressStoreKey 

func AddressStoreKey(addr sdk.AccAddress) []byte

Turn an address to key used to get it from the account store

func DefaultTxDecoder 

func DefaultTxDecoder(cdc *codec.Codec) sdk.TxDecoder

logic for standard transaction decoding

func InitGenesis 

func InitGenesis(ctx sdk.Context, keeper FeeCollectionKeeper, data GenesisState, ps FeeManager, params FeeGenesisStateConfig)

Init store state from genesis data

func NewAnteHandler 

func NewAnteHandler(am AccountKeeper, fck FeeCollectionKeeper) sdk.AnteHandler

NewAnteHandler returns an AnteHandler that checks and increments sequence numbers, checks signatures & account numbers, and deducts fees from the first signer.

func NewFeePreprocessHandler added in v0.9.0 

func NewFeePreprocessHandler(fm FeeManager) types.FeePreprocessHandler

NewFeePreprocessHandler creates a fee token preprocesser

func NewFeeRefundHandler added in v0.9.0 

func NewFeeRefundHandler(am AccountKeeper, fck FeeCollectionKeeper, fm FeeManager) types.FeeRefundHandler

NewFeePreprocessHandler creates a fee token refund handler

func ParamTypeTable added in v0.9.0 

func ParamTypeTable() params.TypeTable

Type declaration for parameters

func RegisterBaseAccount 

func RegisterBaseAccount(cdc *codec.Codec)

Most users shouldn't use this, but this comes in handy for tests.

func RegisterCodec 

func RegisterCodec(cdc *codec.Codec)

Register concrete types on codec codec for default AppAccount

func StdSignBytes 

func StdSignBytes(chainID string, accnum uint64, sequence uint64, fee StdFee, msgs []sdk.Msg, memo string) []byte

StdSignBytes returns the bytes to sign for a transaction.

func WithSigners 

func WithSigners(ctx types.Context, accounts []Account) types.Context

add the signers to the context

Types

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

	GetAccountNumber() uint64
	SetAccountNumber(uint64) error

	GetSequence() uint64
	SetSequence(uint64) 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 

func GetSigners(ctx types.Context) []Account

get the signers from the context

func ProtoBaseAccount 

func ProtoBaseAccount() Account

Prototype function for BaseAccount

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 

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

NewAccountKeeper returns a new sdk.AccountKeeper that uses go-amino to (binary) encode and decode concrete sdk.Accounts. nolint

func (AccountKeeper) GetAccount 

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

Implements sdk.AccountKeeper.

func (AccountKeeper) GetNextAccountNumber 

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

Returns and increments the global account number counter

func (AccountKeeper) GetPubKey 

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

Returns the PubKey of the account at address

func (AccountKeeper) GetSequence 

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

Returns the Sequence of the account at address

func (AccountKeeper) IterateAccounts 

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

Implements sdk.AccountKeeper.

func (AccountKeeper) NewAccount 

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

New Account

func (AccountKeeper) NewAccountWithAddress 

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

Implaements sdk.AccountKeeper.

func (AccountKeeper) RemoveAccount 

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

RemoveAccount removes an account for the account mapper store.

func (AccountKeeper) SetAccount 

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

Implements sdk.AccountKeeper.

type BaseAccount 

type BaseAccount struct {
	Address       sdk.AccAddress `json:"address"`
	Coins         sdk.Coins      `json:"coins"`
	PubKey        crypto.PubKey  `json:"public_key"`
	AccountNumber uint64         `json:"account_number"`
	Sequence      uint64         `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 

func NewBaseAccountWithAddress(addr sdk.AccAddress) BaseAccount

func (*BaseAccount) GetAccountNumber 

func (acc *BaseAccount) GetAccountNumber() uint64

Implements Account

func (BaseAccount) GetAddress 

func (acc BaseAccount) GetAddress() sdk.AccAddress

Implements sdk.Account.

func (*BaseAccount) GetCoins 

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

Implements sdk.Account.

func (BaseAccount) GetPubKey 

func (acc BaseAccount) GetPubKey() crypto.PubKey

Implements sdk.Account.

func (*BaseAccount) GetSequence 

func (acc *BaseAccount) GetSequence() uint64

Implements sdk.Account.

func (*BaseAccount) SetAccountNumber 

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

Implements Account

func (*BaseAccount) SetAddress 

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

Implements sdk.Account.

func (*BaseAccount) SetCoins 

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

Implements sdk.Account.

func (*BaseAccount) SetPubKey 

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

Implements sdk.Account.

func (*BaseAccount) SetSequence 

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

Implements sdk.Account.

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 

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

func (FeeCollectionKeeper) AddCollectedFees 

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

add to the fee pool

func (FeeCollectionKeeper) ClearCollectedFees 

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

clear the fee pool

func (FeeCollectionKeeper) GetCollectedFees 

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

retrieves the collected fee pool

func (FeeCollectionKeeper) RefundCollectedFees 

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

////////////////// iris/cosmos-sdk begin/////////////////////////// RefundCollectedFees deducts fees from fee collector

type FeeGenesisStateConfig added in v0.9.0 

type FeeGenesisStateConfig struct {
	FeeTokenNative    string `json:"fee_token_native"`
	GasPriceThreshold int64  `json:"gas_price_threshold"`
}

type FeeManager added in v0.9.0 

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

FeeManager do fee tokens preprocess according to fee token configuration

func NewFeeManager added in v0.9.0 

func NewFeeManager(paramSpace params.Subspace) FeeManager

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 

func DefaultGenesisState() GenesisState

Return a default genesis state

func ExportGenesis 

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

ExportGenesis returns a GenesisState for a given context and keeper

func NewGenesisState 

func NewGenesisState(collectedFees sdk.Coins) GenesisState

Create a new genesis state

type StdFee 

type StdFee struct {
	Amount sdk.Coins `json:"amount"`
	Gas    uint64    `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 

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

func (StdFee) Bytes 

func (fee StdFee) Bytes() []byte

fee bytes for signing later

type StdSignDoc 

type StdSignDoc struct {
	AccountNumber uint64            `json:"account_number"`
	ChainID       string            `json:"chain_id"`
	Fee           json.RawMessage   `json:"fee"`
	Memo          string            `json:"memo"`
	Msgs          []json.RawMessage `json:"msgs"`
	Sequence      uint64            `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"`
	AccountNumber uint64           `json:"account_number"`
	Sequence      uint64           `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 

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

func (StdTx) GetMemo 

func (tx StdTx) GetMemo() string

nolint

func (StdTx) GetMsgs 

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

nolint GetMsgs returns the all the transaction's messages.

func (StdTx) GetSignatures 

func (tx StdTx) GetSignatures() []StdSignature

Signatures returns the signature of signers who signed the Msg. GetSignatures returns the signature of signers who signed the Msg. CONTRACT: Length returned is same as length of pubkeys returned from MsgKeySigners, and the order matches. CONTRACT: If the signature is missing (ie the Msg is invalid), then the corresponding signature is .Empty().

func (StdTx) GetSigners 

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

GetSigners returns the addresses that must sign the transaction. Addresses are returned in a deterministic order. They are accumulated from the GetSigners method for each Msg in the order they appear in tx.GetMsgs(). Duplicate addresses will be omitted.

func (StdTx) ValidateBasic added in v0.9.0 

func (tx StdTx) ValidateBasic() sdk.Error

ValidateBasic does a simple and lightweight validation check that doesn't require access to any other information.

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.