actor

Documentation

Index

• Variables
• type AddBlockReq
• type AddBlockRsp
• type AddHeaderReq
• type AddHeaderRsp
• type AddHeadersReq
• type AddHeadersRsp
• type GetBlockByHashReq
• type GetBlockByHashRsp
• type GetBlockByHeightReq
• type GetBlockByHeightRsp
• type GetBlockHashReq
• type GetBlockHashRsp
• type GetBlockRootWithNewTxRootReq
• type GetBlockRootWithNewTxRootRsp
• type GetBookkeeperStateReq
• type GetBookkeeperStateRsp
• type GetContractStateReq
• type GetContractStateRsp
• type GetCurrentBlockHashReq
• type GetCurrentBlockHashRsp
• type GetCurrentBlockHeightReq
• type GetCurrentBlockHeightRsp
• type GetCurrentHeaderHashReq
• type GetCurrentHeaderHashRsp
• type GetCurrentHeaderHeightReq
• type GetCurrentHeaderHeightRsp
• type GetCurrentStateRootReq
• type GetCurrentStateRootRsp
• type GetEventNotifyByBlockReq
• type GetEventNotifyByBlockRsp
• type GetEventNotifyByTxReq
• type GetEventNotifyByTxRsp
• type GetHeaderByHashReq
• type GetHeaderByHashRsp
• type GetHeaderByHeightReq
• type GetHeaderByHeightRsp
• type GetStorageItemReq
• type GetStorageItemRsp
• type GetTransactionReq
• type GetTransactionRsp
• type GetTransactionWithHeightReq
• type GetTransactionWithHeightRsp
• type IsContainBlockReq
• type IsContainBlockRsp
• type IsContainTransactionReq
• type IsContainTransactionRsp
• type LedgerActor
  • func NewLedgerActor() *LedgerActor
  • func (this *LedgerActor) Receive(ctx actor.Context)
  • func (this *LedgerActor) Start() *actor.PID
• type PreExecuteContractReq
• type PreExecuteContractRsp

Variables

var DefLedgerPid *actor.PID

Types

type AddBlockReq

type AddBlockReq struct {
	Block *types.Block
}

type AddBlockRsp

type AddBlockRsp struct {
	BlockHash common.Uint256
	Error     error
}

type AddHeaderReq

type AddHeaderReq struct {
	Header *types.Header
}

type AddHeaderRsp

type AddHeaderRsp struct {
	BlockHash common.Uint256
	Error     error
}

type AddHeadersReq

type AddHeadersReq struct {
	Headers []*types.Header
}

type AddHeadersRsp

type AddHeadersRsp struct {
	BlockHashes []common.Uint256
	Error       error
}

type GetBlockByHashReq

type GetBlockByHashReq struct {
	BlockHash common.Uint256
}

type GetBlockByHashRsp

type GetBlockByHashRsp struct {
	Block *types.Block
	Error error
}

type GetBlockByHeightReq

type GetBlockByHeightReq struct {
	Height uint32
}

type GetBlockByHeightRsp

type GetBlockByHeightRsp struct {
	Block *types.Block
	Error error
}

type GetBlockHashReq

type GetBlockHashReq struct {
	Height uint32
}

type GetBlockHashRsp

type GetBlockHashRsp struct {
	BlockHash common.Uint256
	Error     error
}

type GetBlockRootWithNewTxRootReq

type GetBlockRootWithNewTxRootReq struct {
	TxRoot common.Uint256
}

type GetBlockRootWithNewTxRootRsp

type GetBlockRootWithNewTxRootRsp struct {
	NewTxRoot common.Uint256
	Error     error
}

type GetBookkeeperStateReq

type GetBookkeeperStateReq struct{}

type GetBookkeeperStateRsp

type GetBookkeeperStateRsp struct {
	BookKeepState *states.BookkeeperState
	Error         error
}

type GetContractStateReq

type GetContractStateReq struct {
	ContractHash common.Address
}

type GetContractStateRsp

type GetContractStateRsp struct {
	ContractState *payload.DeployCode
	Error         error
}

type GetCurrentBlockHashReq

type GetCurrentBlockHashReq struct{}

type GetCurrentBlockHashRsp

type GetCurrentBlockHashRsp struct {
	BlockHash common.Uint256
	Error     error
}

type GetCurrentBlockHeightReq

type GetCurrentBlockHeightReq struct{}

type GetCurrentBlockHeightRsp

type GetCurrentBlockHeightRsp struct {
	Height uint32
	Error  error
}

type GetCurrentHeaderHashReq

type GetCurrentHeaderHashReq struct{}

type GetCurrentHeaderHashRsp

type GetCurrentHeaderHashRsp struct {
	BlockHash common.Uint256
	Error     error
}

type GetCurrentHeaderHeightReq

type GetCurrentHeaderHeightReq struct{}

type GetCurrentHeaderHeightRsp

type GetCurrentHeaderHeightRsp struct {
	Height uint32
	Error  error
}

type GetCurrentStateRootReq

type GetCurrentStateRootReq struct{}

type GetCurrentStateRootRsp

type GetCurrentStateRootRsp struct {
	StateRoot common.Uint256
	Error     error
}

type GetEventNotifyByBlockReq

type GetEventNotifyByBlockReq struct {
	Height uint32
}

type GetEventNotifyByBlockRsp

type GetEventNotifyByBlockRsp struct {
	TxHashes []common.Uint256
	Error    error
}

type GetEventNotifyByTxReq

type GetEventNotifyByTxReq struct {
	Tx common.Uint256
}

type GetEventNotifyByTxRsp

type GetEventNotifyByTxRsp struct {
	Notifies []*event.NotifyEventInfo
	Error    error
}

type GetHeaderByHashReq

type GetHeaderByHashReq struct {
	BlockHash common.Uint256
}

type GetHeaderByHashRsp

type GetHeaderByHashRsp struct {
	Header *types.Header
	Error  error
}

type GetHeaderByHeightReq

type GetHeaderByHeightReq struct {
	Height uint32
}

type GetHeaderByHeightRsp

type GetHeaderByHeightRsp struct {
	Header *types.Header
	Error  error
}

type GetStorageItemReq

type GetStorageItemReq struct {
	CodeHash common.Address
	Key      []byte
}

type GetStorageItemRsp

type GetStorageItemRsp struct {
	Value []byte
	Error error
}

type GetTransactionReq

type GetTransactionReq struct {
	TxHash common.Uint256
}

type GetTransactionRsp

type GetTransactionRsp struct {
	Tx    *types.Transaction
	Error error
}

type GetTransactionWithHeightReq

type GetTransactionWithHeightReq struct {
	TxHash common.Uint256
}

type GetTransactionWithHeightRsp

type GetTransactionWithHeightRsp struct {
	Tx     *types.Transaction
	Height uint32
	Error  error
}

type IsContainBlockReq

type IsContainBlockReq struct {
	BlockHash common.Uint256
}

type IsContainBlockRsp

type IsContainBlockRsp struct {
	IsContain bool
	Error     error
}

type IsContainTransactionReq

type IsContainTransactionReq struct {
	TxHash common.Uint256
}

type IsContainTransactionRsp

type IsContainTransactionRsp struct {
	IsContain bool
	Error     error
}

type LedgerActor

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

func NewLedgerActor

func NewLedgerActor() *LedgerActor

func (*LedgerActor) Receive

func (this *LedgerActor) Receive(ctx actor.Context)

func (*LedgerActor) Start

func (this *LedgerActor) Start() *actor.PID

type PreExecuteContractReq

type PreExecuteContractReq struct {
	Tx *types.Transaction
}

type PreExecuteContractRsp

type PreExecuteContractRsp struct {
	Result []interface{}
	Error  error
}