currency

type Account struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type AccountBSONUnpacker struct {
	H  valuehash.Bytes     `bson:"hash"`
	AD base.AddressDecoder `bson:"address"`
	KS bson.Raw            `bson:"keys"`
}

type AccountJSONUnpacker struct {
	H  valuehash.Bytes     `json:"hash"`
	AD base.AddressDecoder `json:"address"`
	KS json.RawMessage     `json:"keys"`
}

type AccountKey interface {
	hint.Hinter
	isvalid.IsValider
	util.Byter
	Key() key.Publickey
	Weight() uint
	Equal(AccountKey) bool
}

type AccountKeys interface {
	hint.Hinter
	isvalid.IsValider
	util.Byter
	valuehash.Hasher
	Threshold() uint
	Keys() []AccountKey
	Key(key.Publickey) (AccountKey, bool)
	Equal(AccountKeys) bool
}

type AccountPackerJSON struct {
	jsonenc.HintedHead
	H  valuehash.Hash `json:"hash"`
	AD base.Address   `json:"address"`
	KS AccountKeys    `json:"keys"`
}

type Address struct {
	base.StringAddress
}

type Addresses interface {
	Addresses() ([]base.Address, error)
}

type Amount struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type AmountBSONPacker struct {
	CR CurrencyID `bson:"currency"`
	BG Big        `bson:"amount"`
}

type AmountBSONUnpacker struct {
	HT hint.Hint `bson:"_hint"`
	CR string    `bson:"currency"`
	BG Big       `bson:"amount"`
}

type AmountJSONPacker struct {
	jsonenc.HintedHead
	BG Big        `json:"amount"`
	CR CurrencyID `json:"currency"`
}

type AmountJSONUnpacker struct {
	HT hint.Hint `json:"_hint"`
	BG Big       `json:"amount"`
	CR string    `json:"currency"`
}

type AmountState struct {
	state.State
	// contains filtered or unexported fields
}

type AmountsItem interface {
	Amounts() []Amount
}

type BaseAccountKey struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type BaseAccountKeys struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type BaseCreateAccountsItem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type BaseOperation struct {
	operation.BaseOperation
	Memo string
}

type BaseTransfersItem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type BaseTransfersItemBSONUnpacker struct {
	RC base.AddressDecoder `bson:"receiver"`
	AM bson.Raw            `bson:"amounts"`
}

type BaseTransfersItemJSONUnpacker struct {
	RC base.AddressDecoder `json:"receiver"`
	AM json.RawMessage     `json:"amounts"`
}

type Big struct {
	*big.Int
}

type CreateAccounts struct {
	BaseOperation
}

type CreateAccountsFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type CreateAccountsFactBSONUnpacker struct {
	H  valuehash.Bytes     `bson:"hash"`
	TK []byte              `bson:"token"`
	SD base.AddressDecoder `bson:"sender"`
	IT bson.Raw            `bson:"items"`
}

type CreateAccountsFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash       `json:"hash"`
	TK []byte               `json:"token"`
	SD base.Address         `json:"sender"`
	IT []CreateAccountsItem `json:"items"`
}

type CreateAccountsFactJSONUnpacker struct {
	H  valuehash.Bytes     `json:"hash"`
	TK []byte              `json:"token"`
	SD base.AddressDecoder `json:"sender"`
	IT json.RawMessage     `json:"items"`
}

type CreateAccountsItem interface {
	hint.Hinter
	isvalid.IsValider
	AmountsItem
	Bytes() []byte
	Keys() AccountKeys
	Address() (base.Address, error)
	Rebuild() CreateAccountsItem
}

type CreateAccountsItemBSONUnpacker struct {
	KS bson.Raw `bson:"keys"`
	AM bson.Raw `bson:"amounts"`
}

type CreateAccountsItemJSONPacker struct {
	jsonenc.HintedHead
	KS AccountKeys `json:"keys"`
	AS []Amount    `json:"amounts"`
}

type CreateAccountsItemJSONUnpacker struct {
	KS json.RawMessage `json:"keys"`
	AM json.RawMessage `json:"amounts"`
}

type CreateAccountsItemMultiAmounts struct {
	BaseCreateAccountsItem
}

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

type CreateAccountsItemSingleAmount struct {
	BaseCreateAccountsItem
}

type CreateAccountsProcessor struct {
	CreateAccounts
	// contains filtered or unexported fields
}

type CurrencyDesign struct {
	hint.BaseHinter
	Amount
	// contains filtered or unexported fields
}

type CurrencyDesignBSONUnpacker struct {
	AM Amount              `bson:"amount"`
	GA base.AddressDecoder `bson:"genesis_account"`
	PO bson.Raw            `bson:"policy"`
	AG Big                 `bson:"aggregate"`
}

type CurrencyDesignJSONPacker struct {
	jsonenc.HintedHead
	AM Amount         `json:"amount"`
	GA base.Address   `json:"genesis_account"`
	PO CurrencyPolicy `json:"policy"`
	AG Big            `json:"aggregate"`
}

type CurrencyDesignJSONUnpacker struct {
	AM Amount              `json:"amount"`
	GA base.AddressDecoder `json:"genesis_account"`
	PO json.RawMessage     `json:"policy"`
	AG Big                 `json:"aggregate"`
}

type CurrencyID string

type CurrencyPolicy struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type CurrencyPolicyBSONUnpacker struct {
	MN Big      `bson:"new_account_min_balance"`
	FE bson.Raw `bson:"feeer"`
}

type CurrencyPolicyJSONPacker struct {
	jsonenc.HintedHead
	MN Big   `json:"new_account_min_balance"`
	FE Feeer `json:"feeer"`
}

type CurrencyPolicyJSONUnpacker struct {
	MN Big             `json:"new_account_min_balance"`
	FE json.RawMessage `json:"feeer"`
}

type CurrencyPolicyUpdater struct {
	BaseOperation
}

type CurrencyPolicyUpdaterFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type CurrencyPolicyUpdaterFactBSONUnpacker struct {
	H  valuehash.Bytes `bson:"hash"`
	TK []byte          `bson:"token"`
	CI string          `bson:"currency"`
	PO bson.Raw        `bson:"policy"`
}

type CurrencyPolicyUpdaterFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash `json:"hash"`
	TK []byte         `json:"token"`
	CI CurrencyID     `json:"currency"`
	PO CurrencyPolicy `json:"policy"`
}

type CurrencyPolicyUpdaterFactJSONUnpacker struct {
	H  valuehash.Bytes `json:"hash"`
	TK []byte          `json:"token"`
	CI string          `json:"currency"`
	PO json.RawMessage `json:"policy"`
}

type CurrencyPolicyUpdaterProcessor struct {
	CurrencyPolicyUpdater
	// contains filtered or unexported fields
}

type CurrencyPool struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type CurrencyRegister struct {
	BaseOperation
}

type CurrencyRegisterFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type CurrencyRegisterFactBSONUnpacker struct {
	H  valuehash.Bytes `bson:"hash"`
	TK []byte          `bson:"token"`
	CR bson.Raw        `bson:"currency"`
}

type CurrencyRegisterFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash `json:"hash"`
	TK []byte         `json:"token"`
	CR CurrencyDesign `json:"currency"`
}

type CurrencyRegisterFactJSONUnpacker struct {
	H  valuehash.Bytes `json:"hash"`
	TK []byte          `json:"token"`
	CR json.RawMessage `json:"currency"`
}

type CurrencyRegisterProcessor struct {
	CurrencyRegister
	// contains filtered or unexported fields
}

type DuplicationType string

type FeeOperation struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type FeeOperationBSONUnpacker struct {
	H  valuehash.Bytes `bson:"hash"`
	FC bson.Raw        `bson:"fact"`
}

type FeeOperationFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type FeeOperationFactBSONUnpacker struct {
	H  valuehash.Bytes `bson:"hash"`
	TK []byte          `bson:"token"`
	AM bson.Raw        `bson:"amounts"`
}

type FeeOperationFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash `json:"hash"`
	TK []byte         `json:"token"`
	AM []Amount       `json:"amounts"`
}

type FeeOperationFactJSONUnpacker struct {
	H  valuehash.Bytes `json:"hash"`
	TK []byte          `json:"token"`
	AM json.RawMessage `json:"amounts"`
}

type FeeOperationJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash   `json:"hash"`
	FT FeeOperationFact `json:"fact"`
}

type FeeOperationJSONUnpacker struct {
	H  valuehash.Bytes `json:"hash"`
	FT json.RawMessage `json:"fact"`
}

type FeeOperationProcessor struct {
	FeeOperation
	// contains filtered or unexported fields
}

type Feeer interface {
	isvalid.IsValider
	hint.Hinter
	Type() string
	Bytes() []byte
	Receiver() base.Address
	Min() Big
	Fee(Big) (Big, error)
}

type FixedFeeer struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type FixedFeeerBSONUnpacker struct {
	HT hint.Hint           `bson:"_hint"`
	RC base.AddressDecoder `bson:"receiver"`
	AM Big                 `bson:"amount"`
}

type FixedFeeerJSONPacker struct {
	jsonenc.HintedHead
	RC base.Address `json:"receiver"`
	AM Big          `json:"amount"`
}

type FixedFeeerJSONUnpacker struct {
	HT hint.Hint           `json:"_hint"`
	RC base.AddressDecoder `json:"receiver"`
	AM Big                 `json:"amount"`
}

type GenesisCurrencies struct {
	operation.BaseOperation
}

type GenesisCurrenciesFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type GenesisCurrenciesFactBSONUnpacker struct {
	H  valuehash.Bytes      `bson:"hash"`
	TK []byte               `bson:"token"`
	GK key.PublickeyDecoder `bson:"genesis_node_key"`
	KS bson.Raw             `bson:"keys"`
	CS bson.Raw             `bson:"currencies"`
}

type GenesisCurrenciesFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash   `json:"hash"`
	TK []byte           `json:"token"`
	GK key.Publickey    `json:"genesis_node_key"`
	KS AccountKeys      `json:"keys"`
	CS []CurrencyDesign `json:"currencies"`
}

type GenesisCurrenciesFactJSONUnpacker struct {
	H  valuehash.Bytes      `json:"hash"`
	TK []byte               `json:"token"`
	GK key.PublickeyDecoder `json:"genesis_node_key"`
	KS json.RawMessage      `json:"keys"`
	CS json.RawMessage      `json:"currencies"`
}

type GetNewProcessor func(state.Processor) (state.Processor, error)

type KeyBSONUnpacker struct {
	W uint                 `bson:"weight"`
	K key.PublickeyDecoder `bson:"key"`
}

type KeyJSONPacker struct {
	jsonenc.HintedHead
	W uint          `json:"weight"`
	K key.Publickey `json:"key"`
}

type KeyJSONUnpacker struct {
	W uint                 `json:"weight"`
	K key.PublickeyDecoder `json:"key"`
}

type KeyUpdater struct {
	BaseOperation
}

type KeyUpdaterFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type KeyUpdaterFactBSONUnpacker struct {
	H  valuehash.Bytes     `bson:"hash"`
	TK []byte              `bson:"token"`
	TG base.AddressDecoder `bson:"target"`
	KS bson.Raw            `bson:"keys"`
	CR string              `bson:"currency"`
}

type KeyUpdaterFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash `json:"hash"`
	TK []byte         `json:"token"`
	TG base.Address   `json:"target"`
	KS AccountKeys    `json:"keys"`
	CR CurrencyID     `json:"currency"`
}

type KeyUpdaterFactJSONUnpacker struct {
	H  valuehash.Bytes     `json:"hash"`
	TK []byte              `json:"token"`
	TG base.AddressDecoder `json:"target"`
	KS json.RawMessage     `json:"keys"`
	CR string              `json:"currency"`
}

type KeyUpdaterProcessor struct {
	KeyUpdater
	// contains filtered or unexported fields
}

type KeysBSONUnpacker struct {
	H  valuehash.Bytes `bson:"hash"`
	KS bson.Raw        `bson:"keys"`
	TH uint            `bson:"threshold"`
}

type KeysJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash `json:"hash"`
	KS []AccountKey   `json:"keys"`
	TH uint           `json:"threshold"`
}

type KeysJSONUnpacker struct {
	H  valuehash.Bytes `json:"hash"`
	KS json.RawMessage `json:"keys"`
	TH uint            `json:"threshold"`
}

type MemoBSONUnpacker struct {
	Memo string `bson:"memo"`
}

type MemoJSONUnpacker struct {
	Memo string `json:"memo"`
}

type NilFeeer struct {
	hint.BaseHinter
}

type OperationProcessor struct {
	sync.RWMutex
	*logging.Logging
	// contains filtered or unexported fields
}

type RatioFeeer struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type RatioFeeerBSONUnpacker struct {
	HT hint.Hint           `bson:"_hint"`
	RC base.AddressDecoder `bson:"receiver"`
	RA float64             `bson:"ratio"`
	MI Big                 `bson:"min"`
	MA Big                 `bson:"max"`
}

type RatioFeeerJSONPacker struct {
	jsonenc.HintedHead
	RC base.Address `json:"receiver"`
	RA float64      `json:"ratio"`
	MI Big          `json:"min"`
	MA Big          `json:"max"`
}

type RatioFeeerJSONUnpacker struct {
	HT hint.Hint           `json:"_hint"`
	RC base.AddressDecoder `json:"receiver"`
	RA float64             `json:"ratio"`
	MI Big                 `json:"min"`
	MA Big                 `json:"max"`
}

type SuffrageInflation struct {
	BaseOperation
}

type SuffrageInflationFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type SuffrageInflationFactBSONUnpacker struct {
	H  valuehash.Bytes `bson:"hash"`
	TK []byte          `bson:"token"`
	IS bson.Raw        `bson:"items"`
}

type SuffrageInflationFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash          `json:"hash"`
	TK []byte                  `json:"token"`
	IS []SuffrageInflationItem `json:"items"`
}

type SuffrageInflationFactJSONUnpacker struct {
	H  valuehash.Bytes   `json:"hash"`
	TK []byte            `json:"token"`
	IS []json.RawMessage `json:"items"`
}

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