spec

type Account interface {
	Address() string
	Marshal() proto.Message
}

type AddBlocksResponse struct {
	AddedBlock         Block
	AddedToRoot        int
	MaxBlockNumber     uint64
	DisqualifiedBlocks []Block
	Error              error
}

type Block interface {
	Marshalled

	// returns the identifier of the block's parent
	ParentHash() string

	// returns the sequential number of the block in the blockchain
	BlockNumber() uint64

	// validates the block
	Valid() bool

	// gets the block's transactions
	Transactions() []Transaction

	// gets the Unix time in milliseconds the block was generated
	Timestamp() int64
}

type BlockComparator func([]Block) Block

type BlockConfirmationHandler func(Block)

type BlockGenerator interface {
	Type() string
	ReceiveTransaction(*NetworkMessage) (Transaction, error)
	TryCommitBlock(newBlock Block, branch []Block) bool
	CommitBlock(Block)
	GenerateGenesisBlock() Block
	GenerateBlock(parentBranch []Block) (newBlock Block)
	BlockPrototype() Block
}

type Blockchain interface {
	Name() string
	Consensus() Consensus
	Start(ctx context.Context)
	Stop()
	IsRunning() bool
	GenerateBlock(branch []Block, rootID int) Block
	GenerateGenesis() Block
	AddBlocks(blocks []Block, local bool) *AddBlocksResponse
	ReceiveTransaction(*NetworkMessage) error
}

type CompetingBranch interface {
	// Blocks returns the blocks contained in the branch, ordered from
	// head to confirming root.
	Blocks() []Block

	// RootID is the identifier of the branch.
	RootID() int

	// ConsecutiveLocalHits returns the number of times the branch has
	// received blocks for evaluation from only the local node. This
	// is an indicator that the current node is operating in an echo
	// chamber.
	ConsecutiveLocalHits() int

	// HitRate is a measure of popularity of the branch. If returns the
	// number of blocks per second that are being evaluated from the
	// network and locally for addition to the branch.
	HitRate() float64
}

type Competition interface {
	// Branches returns the current competing branches being tracked
	// in the consensus system indexed by RootID.
	Branches() map[int]CompetingBranch
}

type Consensus interface {
	OnBlockConfirmed(BlockConfirmationHandler)
	OnLocalBlockConfirmed(BlockConfirmationHandler)
	Evaluate() Competition
	AddBlocks(block []Block, local bool) *AddBlocksResponse
	ConfirmBlocks()
	WasSeen(block Block) bool
	SetCompeted(head Block)
	SetConfirmingRoot(rootID int)
}

type Controller interface {
	Start(context.Context)
	StartBlockchain(ctx context.Context, blockchainType string)
	StopBlockchain(blockchainType string)
	Stop()
}

type Links map[string]string // [name]hash

type Marshalled interface {
	Namespace() string
	ResourceType() string
	Name() string
	Version() string
	Hash() string
	Marshal() ([]byte, Links, error)
	Unmarshal([]byte, Links) error
}

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

type MessageReceiver func(*NetworkMessage)

type NetworkMessage struct {
	Data     []byte
	Links    Links
	Hash     string
	Protocol *MessageProtocol
	From     string
}

type NetworkNode interface {
	Bootstrap(context.Context) error
	PeerID() string
	Listen(context.Context)
	Sign(data []byte) ([]byte, error)
	Verify(peerID string, data []byte, sig []byte, pubKey []byte) (bool, error)

	// Broadcast is a NetworkBroadcaster function that can be passed
	// around to any component that needs to broadcast to the P2P network.
	Broadcast([]*NetworkMessage)
	OnMessageReceived(MessageReceiver)
	Close()
}

type Store interface {
	OpenBlock(blockNumber uint64) (StoreBlock, error)
	StoreBlock() StoreBlock
	Close()
	GetRoot() string
	Put(context.Context, Marshalled) error
	Get(ctx context.Context, hash string, obj Marshalled) error
	TreeGet(ctx context.Context, key string, obj Marshalled) error
	Hash(data []byte, links Links) (string, error)
}

type StoreBlock interface {
	IsOpen() (bool, uint64)
	Submit(context.Context, Block) (root string, err error)
	GetRoot() string
	Commit(context.Context) error
	Revert() error
	TreePut(ctx context.Context, key string, obj Marshalled) error
	TreeGet(ctx context.Context, key string, obj Marshalled) error
}

type Transaction interface {
	Marshalled
	Parties() map[string]Account // e.g. ["sender"]Account{x}
}

type TransactionHandler interface {
	Type() string
	ReceiveTransaction(*NetworkMessage) (Transaction, error)
	Execute(Transaction) (ok bool)
}

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