shared

Documentation

Index

• Constants
• func CheckLeadingZeroBits(data []byte, expected uint) bool
• func DecodeSliceOfByteSliceWithLimit(d *scale.Decoder, outerLimit, innerLimit uint32) ([][]byte, int, error)
• func FiatShamir(challenge []byte, spaceSize uint64, securityParam uint8) map[uint64]bool
• func FindSubmitPowNonce(ctx context.Context, powChallenge, poetChallenge, nodeID []byte, ...) (uint64, error)
• func HashMembershipTreeNode(buf, lChild, rChild []byte) []byte
• func MakeLabelFunc() func(hash LabelHash, labelID uint64, leftSiblings [][]byte) []byte
• func NewPowHasher(inputs ...[]byte) *powHasher
• type LabelHash
• type MerkleProof
  • func (t *MerkleProof) DecodeScale(dec *scale.Decoder) (total int, err error)
  • func (t *MerkleProof) EncodeScale(enc *scale.Encoder) (total int, err error)
• type NIP

Constants

const (
	// T is the security param which determines the number of leaves
	// to be included in a non-interactive proof.
	T uint8 = 150
)

Functions

func CheckLeadingZeroBits

func CheckLeadingZeroBits(data []byte, expected uint) bool

CheckLeadingZeroBits checks if the first 'expected' bits of the byte array are all zero.

func DecodeSliceOfByteSliceWithLimit

func DecodeSliceOfByteSliceWithLimit(d *scale.Decoder, outerLimit, innerLimit uint32) ([][]byte, int, error)

func FiatShamir

func FiatShamir(challenge []byte, spaceSize uint64, securityParam uint8) map[uint64]bool

FiatShamir generates a set of indices to include in a non-interactive proof.

func FindSubmitPowNonce

func FindSubmitPowNonce(
	ctx context.Context,
	powChallenge, poetChallenge, nodeID []byte,
	difficulty uint,
) (uint64, error)

FindSubmitPowNonce finds the nonce that solves the PoW challenge.

func HashMembershipTreeNode

func HashMembershipTreeNode(buf, lChild, rChild []byte) []byte

HashMembershipTreeNode calculates internal node of the membership merkle tree.

func MakeLabelFunc

func MakeLabelFunc() func(hash LabelHash, labelID uint64, leftSiblings [][]byte) []byte

MakeLabelFunc returns a function which generates a PoET DAG label by concatenating a representation of the labelID with the list of left siblings and then hashing the result using the provided hash function.

⚠️ The resulting function is NOT thread-safe, however different generated instances are independent. The code is optimized for performance and memory allocations.

func NewPowHasher

func NewPowHasher(inputs ...[]byte) *powHasher

Types

type LabelHash

type LabelHash func(data []byte) []byte

type MerkleProof

type MerkleProof struct {
	Root         []byte   `scale:"max=32"`
	ProvenLeaves [][]byte `scale:"max=150"`  // the max. size of this slice is T (security param), and each element is exactly 32 bytes
	ProofNodes   [][]byte `scale:"max=5400"` // 36 nodes per leaf and each node is exactly 32 bytes
}

MerkleProof is a non-interactive proof of inclusion in a Merkle tree. Scale encoding is implemented by hand to be able to limit [][]byte slices to a maximum size (inner and outer slices).

func (*MerkleProof) DecodeScale

func (t *MerkleProof) DecodeScale(dec *scale.Decoder) (total int, err error)

func (*MerkleProof) EncodeScale

func (t *MerkleProof) EncodeScale(enc *scale.Encoder) (total int, err error)

type NIP

type NIP struct {
	MerkleProof
	Epoch  uint
	Leaves uint64
}

Non-Interactive proof of sequential work.