currency

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

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

type AmountValueBSONPacker struct {
	AM currency.Amount `bson:"amount"`
	CI ContractID      `bson:"contractid"`
}

type AmountValueBSONUnpacker struct {
	HT hint.Hint `bson:"_hint"`
	AM bson.Raw  `bson:"amount"`
	CI string    `bson:"contractid"`
}

type AmountValueJSONPacker struct {
	jsonenc.HintedHead
	AM currency.Amount `json:"amount"`
	CI ContractID      `json:"contractid"`
}

type AmountValueJSONUnpacker struct {
	HT hint.Hint       `json:"_hint"`
	AM json.RawMessage `json:"amount"`
	CI string          `json:"contractid"`
}

type AmountsItem interface {
	Amounts() []currency.Amount
}

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

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

type BaseWithdrawsItemBSONUnpacker struct {
	TG base.AddressDecoder `bson:"target"`
	AM bson.Raw            `bson:"amounts"`
}

type BaseWithdrawsItemJSONUnpacker struct {
	TG base.AddressDecoder `json:"target"`
	AM json.RawMessage     `json:"amounts"`
}

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

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

type ContractAccountStatusBSONUnpacker struct {
	IA bool                `bson:"isactive"`
	OW base.AddressDecoder `bson:"owner"`
}

type ContractAccountStatusJSONPacker struct {
	jsonenc.HintedHead
	IA bool         `json:"isactive"`
	OW base.Address `json:"owner"`
}

type ContractAccountStatusJSONUnpacker struct {
	IA bool                `json:"isactive"`
	OW base.AddressDecoder `json:"owner"`
}

type ContractID string

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

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

type CreateContractAccounts struct {
	currency.BaseOperation
}

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

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

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

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

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

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

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

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

type CreateContractAccountsItemMultiAmounts struct {
	BaseCreateContractAccountsItem
}

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

type CreateContractAccountsItemSingleAmount struct {
	BaseCreateContractAccountsItem
}

type CreateContractAccountsProcessor struct {
	CreateContractAccounts
	// contains filtered or unexported fields
}

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

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

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

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

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

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

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

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

type CurrencyPolicyUpdater struct {
	currency.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 currency.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 {
	currency.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 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 []currency.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() currency.Big
	ExchangeMin() currency.Big
	Fee(currency.Big) (currency.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 currency.Big        `bson:"amount"`
	EM currency.Big        `bson:"exchange-min-amount"`
}

type FixedFeeerJSONPacker struct {
	jsonenc.HintedHead
	RC base.Address `json:"receiver"`
	AM currency.Big `json:"amount"`
	EM currency.Big `json:"exchange-min-amount"`
}

type FixedFeeerJSONUnpacker struct {
	HT hint.Hint           `json:"_hint"`
	RC base.AddressDecoder `json:"receiver"`
	AM currency.Big        `json:"amount"`
	EM currency.Big        `json:"exchange-min-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 currency.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 KeyUpdaterProcessor struct {
	currency.KeyUpdater
	// contains filtered or unexported fields
}

type NilFeeer struct {
	hint.BaseHinter
}

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 currency.Big        `bson:"min"`
	MA currency.Big        `bson:"max"`
	EM currency.Big        `bson:"exchange-min-amount"`
}

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

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

type StateKeyBalanceSuffix string

type SuffrageInflation struct {
	currency.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
}

type SuffrageInflationItemPacker struct {
	RC base.Address    `bson:"receiver" json:"receiver"`
	AM currency.Amount `bson:"amount" json:"amount"`
}

type SuffrageInflationItemUnpacker struct {
	RC base.AddressDecoder `bson:"receiver" json:"receiver"`
	AM currency.Amount     `bson:"amount" json:"amount"`
}

type SuffrageInflationProcessor struct {
	SuffrageInflation
	// contains filtered or unexported fields
}

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

type TransfersProcessor struct {
	currency.Transfers
	// contains filtered or unexported fields
}

type Withdraws struct {
	currency.BaseOperation
}

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

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

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

type WithdrawsItem interface {
	hint.Hinter
	isvalid.IsValider
	AmountsItem
	Bytes() []byte
	Target() base.Address
	Rebuild() WithdrawsItem
}

type WithdrawsItemJSONPacker struct {
	jsonenc.HintedHead
	TG base.Address      `json:"target"`
	AM []currency.Amount `json:"amounts"`
}

type WithdrawsItemMultiAmounts struct {
	BaseWithdrawsItem
}

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

type WithdrawsItemSingleAmount struct {
	BaseWithdrawsItem
}

type WithdrawsProcessor struct {
	Withdraws
	// contains filtered or unexported fields
}