core

type Account struct {
	Type        int32        `json:"type" msgpack:"type"`
	Address     util.String  `json:"address" msgpack:"address"`
	Balance     util.String  `json:"balance" msgpack:"balance"`
	Nonce       uint64       `json:"nonce" msgpack:"nonce"`
	AccountInfo *AccountInfo `json:"accountInfo,omitempty" msgpack:"accountInfo"`
}

type AccountInfo struct {
}

type Addr struct {
	Addresses []*Address `json:"addresses" msgpack:"addresses"`
}

type Address struct {
	Address   util.NodeAddr `json:"address" msgpack:"address"`
	Timestamp int64         `json:"timestamp" msgpack:"timestamp"`
}

type ArgGetMinedBlock struct {
	Limit         int    `mapstructure:"limit"`
	LastHash      string `mapstructure:"lastHash"`
	CreatorPubKey string `mapstructure:"creatorPubKey"`
}

type BestBlockInfo struct {
	BestBlockHash            util.Hash
	BestBlockTotalDifficulty *big.Int
	BestBlockNumber          uint64
}

type Block struct {
	Header       *Header        `json:"header" msgpack:"header"`
	Transactions []*Transaction `json:"transactions" msgpack:"transactions"`
	Hash         util.Hash      `json:"hash" msgpack:"hash"`
	Sig          []byte         `json:"sig" msgpack:"sig"`

	// Broadcaster is the peer responsible
	// for sending this block.
	Broadcaster Engine `json:"-" msgpack:"-"`

	// types.ValidationContext can be used to alter
	// the way the block is validated
	ValidationContexts []types.ValidationContext `json:"-" msgpack:"-"`
}

type BlockBodies struct {
	Blocks []*BlockBody
}

type BlockBody struct {
	Header       *Header        `json:"header" msgpack:"header"`
	Transactions []*Transaction `json:"transactions" msgpack:"transactions"`
	Hash         util.Hash      `json:"hash" msgpack:"hash"`
	Sig          []byte         `json:"sig" msgpack:"sig"`
}

type BlockHashes struct {
	Hashes []util.Hash
}

type BlockInfo struct {
	Hash util.Hash `json:"hash" msgpack:"hash"`
}

type BlockOk struct {
	Ok bool `json:"ok" msgpack:"ok"`
}

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

type ChainInfo struct {
	ID                util.String `json:"id" msgpack:"json"`
	ParentChainID     util.String `json:"parentChainID" msgpack:"parentChainID"`
	ParentBlockNumber uint64      `json:"parentBlockNumber" msgpack:"parentBlockNumber"`
	Timestamp         int64       `json:"timestamp" msgpack:"timestamp"`
}

type Engine interface {

	// SetEventEmitter set the event emitter
	// used to broadcast/receive events
	SetEventEmitter(*emitter.Emitter)

	// DB is the laoded client database
	DB() elldb.DB

	// GetTxPool returns the transaction pool
	GetTxPool() types.TxPool

	// StringID is the peer ID of engine's
	// network host as a string
	StringID() string

	// ShortID is the short version the value
	// return by StringID. It meant to be
	// used for logging.
	ShortID() string

	// ID returns the peer ID of the engine's
	// network knows
	ID() peer.ID

	// GetLastSeen returns the time the engine
	// (or peer) was last seen
	GetLastSeen() time.Time

	// SetLastSeen sets the time the engine
	// (or peer) was last seen
	SetLastSeen(time.Time)

	// CreatedAt returns the time this engine
	// was first created.
	CreatedAt() time.Time

	// SetCreatedAt sets the time this engine
	// was first created
	SetCreatedAt(t time.Time)

	// IsSame checks whether the engine has
	// the same ID as another engine
	IsSame(Engine) bool

	// IsSameID is like IsSame but accepts a string
	IsSameID(id string) bool

	// IsHardcodedSeed indicates that the engine
	// was not discovered through the gossip protocol
	// but injected into the codebase
	IsHardcodedSeed() bool

	// GetAddress returns the listening address
	// of the host network
	GetAddress() util.NodeAddr

	// Connected checks whether the engine is connected
	// to the local node
	Connected() bool

	// Connect connects to rn
	Connect(rn Engine) error

	// IsNetworkDisabled checks whether networking is disabled
	IsNetworkDisabled() bool

	// GetBlockchain returns the blockchain instance
	GetBlockchain() types.Blockchain

	// SetBlockchain stores a reference to the
	// blockchain instance
	SetBlockchain(types.Blockchain)

	// ProdMode checks whether the engine
	// is in production mode
	ProdMode() bool

	// TestMode checks whether the engine
	// is in test mode
	TestMode() bool

	// IsInbound checks whether the engine (or peer) is
	// considered an inbound connection to the local node
	IsInbound() bool

	// IsInbound checks whether the engine (or peer) is
	// considered an outbound connection to the local node
	SetInbound(v bool)

	// HasStopped checks whether the peer has stopped
	HasStopped() bool

	// GetHost returns the engine's network host
	GetHost() host.Host

	// Gossip returns the gossip manager
	Gossip() Gossip

	// NewRemoteNode creates a node that will be used to
	// represent a remote peer.
	NewRemoteNode(address util.NodeAddr) Engine

	// GetCfg returns the engine configuration
	GetCfg() *config.EngineConfig

	// GetEventEmitter gets the event emitter
	GetEventEmitter() *emitter.Emitter

	// GetHistory returns the general items cache
	GetHistory() *cache.Cache

	// AddToPeerStore adds the ID of the engine
	// to the peerstore
	AddToPeerStore(node Engine) Engine

	// SetHardcoded sets the hardcoded seed state
	// of the engine.
	SetHardcoded(v bool)

	// SetGossipManager sets the gossip manager
	SetGossipManager(m Gossip)

	// GetName returns the pet name of the node
	GetName() string

	// SetName sets the name of the node
	SetName(name string)

	// GetSyncMode returns the sync mode
	GetSyncMode() SyncMode
}

type GetAddr struct {
}

type GetBlockBodies struct {
	Hashes []util.Hash
}

type GetBlockHashes struct {
	Locators  []util.Hash `json:"hash" msgpack:"hash"`
	Seek      util.Hash   `json:"seek" msgpack:"seek"`
	MaxBlocks int64       `json:"maxBlocks" msgpack:"maxBlocks"`
}

type Gossip interface {

	// Address messages
	OnAddr(s net.Stream, rp Engine) error
	RelayAddresses(addrs []*Address) []error

	// Block messages
	BroadcastBlock(block types.Block, remotePeers []Engine) []error
	OnBlockInfo(s net.Stream, rp Engine) error
	OnBlockBody(s net.Stream, rp Engine) error
	RequestBlock(rp Engine, blockHash util.Hash) error
	OnRequestBlock(s net.Stream, rp Engine) error
	SendGetBlockHashes(rp Engine, locators []util.Hash, seek util.Hash) (*BlockHashes, error)
	OnGetBlockHashes(s net.Stream, rp Engine) error
	SendGetBlockBodies(rp Engine, hashes []util.Hash) (*BlockBodies, error)
	OnGetBlockBodies(s net.Stream, rp Engine) error

	// Handshake messages
	SendHandshake(rp Engine) error
	OnHandshake(s net.Stream, rp Engine) error

	// GetAddr messages
	SendGetAddrToPeer(remotePeer Engine) ([]*Address, error)
	SendGetAddr(remotePeers []Engine) error
	OnGetAddr(s net.Stream, rp Engine) error

	// Ping messages
	SendPing(remotePeers []Engine)
	SendPingToPeer(remotePeer Engine) error
	OnPing(s net.Stream, rp Engine) error

	// Node advertisement
	SelfAdvertise(connectedPeers []Engine) int

	// Transaction messages
	BroadcastTx(tx types.Transaction, remotePeers []Engine) error
	OnTx(s net.Stream, rp Engine) error

	// PickBroadcasters selects N random addresses from
	// the given slice of addresses and caches them to
	// be used as broadcasters.
	// They are returned on subsequent calls and only
	// renewed when there are less than N addresses or the
	// cache is over 24 hours since it was last updated.
	PickBroadcasters(cache *BroadcastPeers, addresses []*Address, n int) *BroadcastPeers

	// GetBroadcasters returns the broadcasters
	GetBroadcasters() *BroadcastPeers
	GetRandBroadcasters() *BroadcastPeers

	// NewStream creates a stream for a given protocol
	// ID and between the local peer and the given remote peer.
	NewStream(remotePeer Engine, msgVersion string) (net.Stream,
		context.CancelFunc, error)

	// CheckRemotePeer performs validation against the remote peer.
	CheckRemotePeer(ws *WrappedStream, rp Engine) error

	// Handle wrappers a protocol handler providing an
	// interface to perform pre and post handling operations.
	Handle(handler func(s net.Stream, remotePeer Engine) error) func(net.Stream)
}

type Handshake struct {
	Version                  string    `json:"version" msgpack:"version"`
	BestBlockHash            util.Hash `json:"bestBlockHash" msgpack:"bestBlockHash"`
	BestBlockTotalDifficulty *big.Int  `json:"bestBlockTD" msgpack:"bestBlockTD"`
	BestBlockNumber          uint64    `json:"bestBlockNumber" msgpack:"bestBlockNumber"`
	Name                     string    `json:"name" msgpack:"name"`
}

type Header struct {
	Number           uint64          `json:"number" msgpack:"number"`
	Nonce            util.BlockNonce `json:"nonce" msgpack:"nonce"`
	Timestamp        int64           `json:"timestamp" msgpack:"timestamp"`
	CreatorPubKey    util.String     `json:"creatorPubKey" msgpack:"creatorPubKey"`
	ParentHash       util.Hash       `json:"parentHash" msgpack:"parentHash"`
	StateRoot        util.Hash       `json:"stateRoot" msgpack:"stateRoot"`
	TransactionsRoot util.Hash       `json:"transactionsRoot" msgpack:"transactionsRoot"`
	Difficulty       *big.Int        `json:"difficulty" msgpack:"difficulty"`
	TotalDifficulty  *big.Int        `json:"totalDifficulty" msgpack:"totalDifficulty"`
	Extra            []byte          `json:"extra" msgpack:"extra"`
}

type Intro struct {
	PeerID string `json:"id" msgpack:"id"`
}

type InvokeArgs struct {
	Func   string            `json:"func" msgpack:"func"`
	Params map[string][]byte `json:"params" msgpack:"params"`
}

type MinedBlock struct {
	Number        uint64      `json:"number" msgpack:"number"`
	Timestamp     int64       `json:"timestamp" msgpack:"timestamp"`
	CreatorPubKey util.String `json:"creatorPubKey" msgpack:"creatorPubKey"`
	TxCount       uint        `json:"txCount" msgpack:"txCount"`
	TotalFees     string      `json:"totalFees" msgpack:"totalFees"`
	Hash          util.Hash   `json:"hash" msgpack:"hash"`
}

type Ping struct {
	BestBlockHash            util.Hash `json:"bestBlockHash" msgpack:"bestBlockHash"`
	BestBlockTotalDifficulty *big.Int  `json:"bestBlockTD" msgpack:"bestBlockTD"`
	BestBlockNumber          uint64    `json:"bestBlockNumber" msgpack:"bestBlockNumber"`
}

type Pong struct {
	BestBlockHash            util.Hash `json:"bestBlockHash" msgpack:"bestBlockHash"`
	BestBlockTotalDifficulty *big.Int  `json:"bestBlockTD" msgpack:"bestBlockTD"`
	BestBlockNumber          uint64    `json:"bestBlockNumber" msgpack:"bestBlockNumber"`
}

type Reject struct {
	Message   string `json:"message" msgpack:"message"`
	Code      int32  `json:"code" msgpack:"code"`
	Reason    string `json:"reason" msgpack:"reason"`
	ExtraData []byte `json:"extraData" msgpack:"extraData"`
}

type RequestBlock struct {
	Hash string `json:"hash" msgpack:"hash"`
}

type SyncMode interface {
	// IsDisabled checks whether synchronization has been disabled
	IsDisabled() bool

	// Enable enables the sync mode
	Enable()

	// Disable disables the sync mode
	Disable()
}

type SyncStateInfo struct {
	TargetTD           *big.Int `json:"targetTotalDifficulty"`
	TargetChainHeight  uint64   `json:"targetChainHeight" msgpack:"targetChainHeight"`
	CurrentTD          *big.Int `json:"currentTotalDifficulty" msgpack:"currentTotalDifficulty"`
	CurrentChainHeight uint64   `json:"currentChainHeight" msgpack:"currentChainHeight"`
	ProgressPercent    float64  `json:"progressPercent" msgpack:"progressPercent"`
}

type Transaction struct {
	Type         int64       `json:"type" msgpack:"type"`
	Nonce        uint64      `json:"nonce" msgpack:"nonce"`
	To           util.String `json:"to" msgpack:"to"`
	From         util.String `json:"from" msgpack:"from"`
	SenderPubKey util.String `json:"senderPubKey" msgpack:"senderPubKey"`
	Value        util.String `json:"value" msgpack:"value"`
	Timestamp    int64       `json:"timestamp" msgpack:"timestamp"`
	Fee          util.String `json:"fee" msgpack:"fee"`
	InvokeArgs   *InvokeArgs `json:"invokeArgs,omitempty" msgpack:"invokeArgs"`
	Sig          []byte      `json:"sig" msgpack:"sig"`
	Hash         util.Hash   `json:"hash" msgpack:"hash"`
}

type TxInfo struct {
	Hash util.Hash `json:"hash" msgpack:"hash"`
}

type TxOk struct {
	Ok bool `json:"ok" msgpack:"ok"`
}

type WrappedStream struct {
	Stream net.Stream
	Extra  map[string]interface{}
}