chain

type ABCI struct {
	*Blockchain
}

type Address [20]byte

type Block struct {
	Header
	// Transactions is the list of transactions ordered in the merkle
	// tree structure with the necessary empty nodes in the list as
	// required. The MerkleRoot is computed from this list which must be
	// structured correctly for this.
	Transactions []interface{}
	// MasternodeSignature - After a block is proposed, masternodes run a
	// vote/compare/sign cycle which generates a Schnorr signature with each
	// masternode's signature overlaid on it, the masternode list being
	// visible as the issued tokens and their currently controlling account.
	//
	// This signature indicates to nodes that no previous block can now be
	// mined on, making the block immediately final, a requirement for
	// Cosmos IBC protocol.
	//
	// This signature is the product of the peer validation process for
	// signatures on the block, the first signature chain to acquire the 2/3
	// quorum of masternodes triggers the acceptance and finality of the
	// new block.
	//
	// The signature is applied to the Hash of the Header, which a verifier
	// must generate from the serialized block header.
	// Without this signature a block may not be mined on,
	// and the masternodes only accept one and finalize it immediately
	// before a new block is allowed to happen (15 second minimum)
	MasternodeSignature []byte
}

type BlockNode struct {

	// Block is the block itself
	*Block
	// contains filtered or unexported fields
}

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

type Difficulty []byte

type Hash [32]byte

type Header struct {
	// Parent is the hash of the previous block
	Parent Hash
	// Time is the Unix timestamp of the block
	Time int64
	// Provenance is a value computed by the app state hash of the block
	// nearest the staking cooldown period, as displaced from the block's
	// timestamp, combined with the coinbase of the parent block, two values
	// that don't exist until a block has been mined.
	//
	// Before the cooldown period the genesis block is always the app
	// state hash used to generate this
	Provenance Hash
	// Difficulty is a value that is subtracted from the lowest difficulty
	// (all but the largest bit 1 in a 256 bit hash) to create a difficulty
	// target which defines the largest proof that can be accepted.
	//
	// If the following is true:
	//
	//   stake * proof < target
	//
	// then the block has valid proof and could be accepted.
	Difficulty Difficulty
	// Coinbase is the account to which the reward for this block is paid
	Coinbase Address
	// Stake is the necessary amount of stake to normalize the difficulty
	// target, minimum of 1. This functions as a multiplier on the proof
	// to produce the value that is compared to the difficulty target
	Stake uint64
	// MerkleRoot is the root hash of the transaction merkle tree
	MerkleRoot Hash
}

type SaphoConsensus struct {
	// MinBlockInterval is the minimum difference between a new block and
	// the parent block
	MinBlockInterval int
	// BlockIntervalTarget is the set point for the difficulty adjustment,
	// important for regulating the token emission rate
	BlockIntervalTarget int
	// AdjustmentInverseBase is the reciprocal of the scaling value
	// compounded with the difference between the block timestamp and the
	// time target computed by the difficulty for a given parent block and
	// the timestamp of the proposed block.
	//
	// The closer the timestamp is to the computed target timestamp the less
	// that difficulty is adjusted.
	AdjustmentInverseBase int
	// EMAWindow is the number of previous blocks used to compute the
	// average used to derive the difficulty
	EMAWindow int
	// EMANumer is the numerator of the EMA smoothing factor (multiplies)
	EMANumer int
	// EMADenom is the denominator of the EMA smoothing factor (divides)
	EMADenom int
	// StakeCoolDown is the number of seconds that stake is subtracted
	// from available balance when querying to perform another
	// transaction. During this period the stake cannot be spent or staked.
	StakeCoolDown int
}

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