action

type Address = keys.Address

type Amount struct {
	Currency string         `json:"currency"`
	Value    balance.Amount `json:"value"`
}

type Balance = balance.Balance

type Context struct {
	Router              Router
	State               *storage.State
	Header              *abci.Header
	Accounts            accounts.Wallet
	Balances            *balance.Store
	Domains             *ons.DomainStore
	Delegators          *delegation.DelegationStore
	NetwkDelegators     *netwkDeleg.MasterStore
	EvidenceStore       *evidence.EvidenceStore
	FeePool             *fees.Store
	Currencies          *balance.CurrencySet
	FeeOpt              *fees.FeeOption
	Validators          *identity.ValidatorStore
	Witnesses           *identity.WitnessStore
	BTCTrackers         *bitcoin.TrackerStore
	ETHTrackers         *ethereum.TrackerStore
	Logger              *log.Logger
	JobStore            *jobs.JobStore
	LockScriptStore     *bitcoin.LockScriptStore
	ProposalMasterStore *governance.ProposalMasterStore
	RewardMasterStore   *rewards.RewardMasterStore
	GovernanceStore     *governance.Store
	ExtStores           data.Router
	GovUpdate           *GovernaceUpdateAndValidate
}

type Fee struct {
	Price Amount `json:"price"`
	Gas   int64  `json:"gas"`
}

type FunctionBehaviour int

type Gas = storage.Gas

type GovernaceUpdateAndValidate struct {
	GovernanceUpdateFunction map[string]func(interface{}, *Context, FunctionBehaviour) (bool, error)
}

type Msg interface {
	// return the necessary signers for the message, should have consistent order across the network
	Signers() []Address

	Type() Type

	Tags() kv.Pairs

	Marshal() ([]byte, error)

	Unmarshal([]byte) error
}

type MsgData []byte

type RawTx struct {
	Type Type    `json:"type"`
	Data MsgData `json:"data"`
	Fee  Fee     `json:"fee"`
	Memo string  `json:"memo"`
}

type Response struct {
	Data      []byte
	Events    []types.Event
	Log       string
	Info      string
	GasWanted int64
	GasUsed   int64
}

type Router interface {
	AddHandler(Type, Tx) error
	Handler(Type) Tx
}

type Signature struct {
	Signer keys.PublicKey
	Signed []byte
}

type SignedTx struct {
	RawTx
	Signatures []Signature `json:"signatures"`
}

type Tx interface {
	//it should be able to validate a tx by itself, non-valid tx will be reject by the node directly
	//without going to node process
	Validate(ctx *Context, signedTx SignedTx) (bool, error)

	//check tx on the first node who receives it, if process check failed, the tx will not be broadcast
	//could store a version of checked value in storage, but not implemented now
	ProcessCheck(ctx *Context, tx RawTx) (bool, Response)

	//deliver tx on the chain by changing the storage values, which should only be committed at Application
	//commit stage
	ProcessDeliver(ctx *Context, tx RawTx) (bool, Response)

	//process the charge of fees
	ProcessFee(ctx *Context, signedTx SignedTx, start Gas, size Gas) (bool, Response)
}

type TxTypeDescribe struct {
	TxTypeNum    Type
	TxTypeString string
}

type TxTypeMap map[Type]string

type Type int