smartpool

type BranchElement [BranchElementLength]byte

type Claim interface {
	// NumShares returns number of shares that the claim is holding
	NumShares() *big.Int
	GetShare(index int) Share
	// Difficulty returns the min difficulty across all of its shares
	Difficulty() *big.Int
	// Min returns the min counter of the augmented merkle root
	Min() *big.Int
	// Max returns the max counter of the augmented merkle root
	Max() *big.Int
	// AugMerkle returns the hash of the augmented merkle root
	AugMerkle() SPHash
	// SetEvidence sets the share index to be used to prove the claim
	SetEvidence(shareIndex *big.Int)
	// CounterBranch returns array of counters in proof branch of the share
	CounterBranch() []*big.Int
	// HashBranch returns array of hashes in proof branch of the share
	HashBranch() []*big.Int
}

type Contract interface {
	// Version return contract version which is useful for backward and forward
	// compatibility when the contract is redeployed in some occasions.
	Version() string
	// IsRegistered returns true when the miner's address is already recognized
	// as a user of the pool. It returns false otherwise.
	IsRegistered() bool
	// CanRegister returns true when the miner's address can actually register
	// to the pool. It returns false when the contract side decided to refuse
	// the address.
	CanRegister() bool
	// Register takes an address and register it to the pool.
	Register(paymentAddress common.Address) error
	// SubmitClaim takes some necessary parameters that represent a claim and
	// submit to the contract using miner's address. The address should be
	// unlocked first.
	SubmitClaim(claim Claim) error
	// GetShareIndex returns index of the share that is requested to submit
	// proof to the contract to represent correctness of the submitted claim.
	// GetShareIndex must be called after SubmitClaim to get shareIndex which
	// is used to pass to VerifyClaim. If GetShareIndex is called before
	// SubmitClaim, the index will have no meaning to contract.
	GetShareIndex(claim Claim) *big.Int
	// VerifyClaim takes some necessary parameters that provides complete proof
	// of a share with index shareIndex in the cliam and submit to contract side
	// in order to prove that the claim is valid so the miner can take credit
	// of it.
	VerifyClaim(shareIndex *big.Int, claim Claim) error
}

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

type NetworkClient interface {
	// GetWork returns a Work for SmartPool to give to the miner. How the work
	// is formed is upto structs implementing this interface.
	GetWork() Work
	// SubmitSolution submits the solution that miner has submitted to SmartPool
	// so the full block solution can take credits. It also maintain workflow
	// between miner and the network client.
	SubmitSolution(s Solution) bool
	SubmitHashrate(hashrate hexutil.Uint64, id common.Hash) bool
	// ReadyToMine returns true when the network is ready to give and accept
	// pow work and solution. It returns false otherwise.
	ReadyToMine() bool
	// Configure configs etherbase and extradata to the network client
	Configure(etherbase common.Address, extradata string) error
}

type PersistentStorage interface {
	Persist(data interface{}, id string) error
	Load(data interface{}, id string) (interface{}, error)
}

type PoolMonitor interface {
	RequireClientUpdate() bool
	RequireContractUpdate() bool
	ContractAddress() common.Address
}

type Rig interface {
	ID() string
}

type SPHash [HashLength]byte

type Share interface {
	// Counter returns the counter to be used in augmented merkle tree of a claim
	// which contains many shares. This counter must be increasing as shares
	// share coming. In other words, later share must have bigger counter.
	Counter() *big.Int
	// Difficulty returns the difficulty of the share that miner has solved.
	ShareDifficulty() *big.Int
	// Hash return the hash of the share to be used as leaf hash of the augmented
	// merkle tree.
	Hash() SPHash
	// FullSolution returns true if the share is solution for its full block pow
	// hash. It returns false otherwise.
	FullSolution() bool
}

type ShareReceiver interface {
	AcceptSolution(s Solution) Share
}

type Solution interface {
	// WorkID returns the ID to identify the work it is trying to solve
	WorkID() string
}

type StatRecorder interface {
	RecordShare(status string, share Share, rig Rig)
	RecordClaim(status string, claim Claim)
	RecordHashrate(hashrate hexutil.Uint64, id common.Hash, rig Rig)
	// Notify StatRecorder how many share were restored from last session
	// so StatRecorder can track number of abandoned shares
	ShareRestored(noshares uint64)

	OverallFarmStat() interface{}
	FarmStat(start uint64, end uint64) interface{}
	OverallRigStat(rig Rig) interface{}
	RigStat(rig Rig, start uint64, end uint64) interface{}

	Persist(storage PersistentStorage) error
}

type StdOut struct{}

type UserInput interface {
	RPCEndpoint() string
	KeystorePath() string
	ShareThreshold() int
	ShareDifficulty() *big.Int
	SubmitInterval() time.Duration
	ContractAddress() string
	MinerAddress() string
	ExtraData() string
	HotStop() bool
}

type UserOutput interface {
	// TODO: Add necessary methods
	// TODO: This might take information about internal detail such as:
	// number of claim submitted, number of claim verified,
	// number of claim accepted, number of share per claim on average,
	// average hash rate,...
	Printf(format string, a ...interface{}) (n int, err error)
}

type Word [WordLength]byte

type Work interface {
	ID() string
	// AcceptSolution takes solution to construct and return a Share representing
	// the solution that came from miner.
	AcceptSolution(sol Solution) Share
}