syncer

type BlockChain interface {

	// GetHeaderByHash retrieves a header from the local chain.
	GetHeaderByHash(common.Hash) *types.Header

	// CurrentHeader retrieves the head header from the local chain.
	CurrentHeader() *types.Header

	// HasBlock verifies a block's presence in the local chain.
	HasBlock(common.Hash, uint64) bool

	// GetBlockByHash retrieves a block from the local chain.
	GetBlockByHash(common.Hash) *types.Block

	GetBlockByNumber(uint64) *types.Block

	// CurrentBlock retrieves the head block from the local chain.
	CurrentBlock() *types.Block

	// CurrentFastBlock retrieves the head fast block from the local chain.
	CurrentFastBlock() *types.Block

	// InsertChain inserts a batch of blocks into the local chain.
	InsertChain(types.Blocks) (int, error)

	// KnownHead returns hash and number of current head block (maybe not in local chain)
	KnownHead() (common.Hash, uint64)

	// SetKnownHead sets the known head block hash and number
	SetKnownHead(common.Hash, uint64)

	// GetReceiptsByHash retrieves the receipts for all transactions in a given block.
	GetReceiptsByHash(hash common.Hash) types.Receipts

	// InsertReceiptChain attempts to complete an already existing header chain with
	// transaction and receipt data.
	InsertReceiptChain(blockChain types.Blocks, receiptChain []types.Receipts) (int, error)

	// InsertHeaderChain attempts to insert the given header chain in to the local
	// chain, possibly creating a reorg. If an error is returned, it will return the
	// index number of the failing header as well an error describing what went wrong.
	InsertHeaderChain(chain []*types.Header, checkFreq int) (int, error)

	// State returns a new mutable state(public) based on the current HEAD block.
	// just for test.
	State() (*state.StateDB, error)

	StateAt(root common.Hash) (*state.StateDB, error)

	Database() database.Database

	// TrieNode retrieves a blob of data associated with a trie node (or code hash)
	// either from ephemeral in-memory cache, or from persistent storage.
	TrieNode(hash common.Hash) ([]byte, error)

	// SetSyncMode set syncMode
	SetSyncMode(mode SyncMode)

	// GetHeaderByNumber retrieves a block header from the database by number,
	// caching it (associated with its hash) if found.
	GetHeaderByNumber(number uint64) *types.Header

	// FastSyncCommitHead sets the current head block to the one defined by the hash
	// irrelevant what the chain contents were prior.
	FastSyncCommitHead(hash common.Hash) error
}

type DoneEvent struct{}

type DropPeer func(id string)

type FailedEvent struct{ Err error }

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

type StartEvent struct{}

type SyncMode int

type SyncPeer interface {
	IDString() string

	// Head returns head block of remote sync peer
	Head() (hash common.Hash, ht *big.Int)

	SendGetBlocks(start uint64) error

	RequestReceipts(hashes []common.Hash) error

	RequestNodeData(hashes []common.Hash) error

	RequestHeadersByNumber(origin uint64, amount int, skip int, reverse bool) error

	RequestBodies([]common.Hash) error
}

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

type Syncer interface {
	// Synchronise syncs blocks from remote peer with given id
	// from current block to latest block with hash as `head`
	// and number as `height`.
	Synchronise(p SyncPeer, head common.Hash, height *big.Int, mode SyncMode) error

	// Cancel cancels sync process from remote peer
	Cancel(id string)

	Progress() cpchain.SyncProgress

	// Synchronising returns if synchronising now
	Synchronising() bool

	// Terminate terminates all sync process and benchmark calculations
	Terminate()

	// DeliverBlocks delivers blocks from remote peer with id to syncer
	DeliverBlocks(id string, blocks types.Blocks) error

	// DeliverReceipts delivers blocks from remote peer with id to syncer
	DeliverReceipts(id string, receipts []types.Receipts) error

	// DeliverNodeData injects a new batch of node state data received from a remote node.
	DeliverNodeData(id string, data [][]byte) error

	// DeliverHeaders injects a new batch of block headers received from a remote
	// node into the download schedule.
	DeliverHeaders(id string, headers []*types.Header) error

	// DeliverBodies injects a new batch of block bodies received from a remote node.
	DeliverBodies(id string, transactions [][]*types.Transaction) error

	// AddPeer add the peer to the pool
	AddPeer(p SyncPeer) error

	// RemovePeer remove the peer
	RemovePeer(peer string) error
}

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

type SyncingResult struct {
	Syncing bool                  `json:"syncing"`
	Status  ethereum.SyncProgress `json:"status"`
}