proof

type CacheProofParams struct {
	SnapshotNodeIndex int64               // which snapshot node contains the challenged leaf
	StartLeaf         int64               // first leaf covered by this snapshot node
	LeavesPerNode     int64               // number of leaves per snapshot node (2^layerIdx)
	SubTreeChallenge  int64               // challenged leaf's position within the snapshot node's subtree
	SectionOffset     int64               // unpadded byte offset into piece data for this section
	SectionLength     int64               // unpadded byte length of the section
	SubrootSize       abi.PaddedPieceSize // padded size for the sub-section memtree
}

type Column[H HasherDomain] struct {
	Index uint32 `json:"index"`
	Rows  []H    `json:"rows"`
	H     any    `json:"_h"`
}

type ColumnProof[H HasherDomain] struct {
	Column         Column[H]      `json:"column"`
	InclusionProof MerkleProof[H] `json:"inclusion_proof"`
}

type Commit1OutRaw struct {
	CommD           Commitment                `json:"comm_d"`
	CommR           Commitment                `json:"comm_r"`
	RegisteredProof StringRegisteredProofType `json:"registered_proof"`
	ReplicaID       Commitment                `json:"replica_id"`
	Seed            Ticket                    `json:"seed"`
	Ticket          Ticket                    `json:"ticket"`

	// ProofType -> [partitions] -> [challenge_index?] -> Proof
	VanillaProofs map[StringRegisteredProofType][][]VanillaStackedProof `json:"vanilla_proofs"`
}

type Commitment [32]byte

type DataCIDSize struct {
	PayloadSize int64
	PieceSize   abi.PaddedPieceSize
	PieceCID    cid.Cid
}

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

type EncodingProof[H HasherDomain] struct {
	Parents    []H    `json:"parents"`
	LayerIndex uint32 `json:"layer_index"`
	Node       uint64 `json:"node"`
}

type FallbackPoStSectorProof struct {
	SectorID     uint64         `json:"sector_id"`
	CommR        PoseidonDomain `json:"comm_r"`
	VanillaProof VanillaProof   `json:"vanilla_proof"`
}

type HasherDomain = any

type InclusionPath[H HasherDomain] struct {
	Path []PathElement[H] `json:"path"`
}

type Label struct {
	ID            string `json:"id"`
	Path          string `json:"path"`
	RowsToDiscard int    `json:"rows_to_discard"`
	Size          int    `json:"size"`
}

type LabelingProof[H HasherDomain] struct {
	Parents    []H    `json:"parents"`
	LayerIndex uint32 `json:"layer_index"`
	Node       uint64 `json:"node"`
}

type Labels struct {
	H      any     `json:"_h"` // todo ?
	Labels []Label `json:"labels"`
}

type MerkleProof[H HasherDomain] struct {
	Data ProofData[H] `json:"data"`
}

type PathElement[H HasherDomain] struct {
	Hashes []H    `json:"hashes"`
	Index  uint64 `json:"index"`
}

type PieceReader interface {
	GetPieceReader(ctx context.Context, pieceCid cid.Cid) (SectionReadCloser, abi.UnpaddedPieceSize, error)
}

type PoStConfig struct {
	PoStType       PoStType
	SectorSize     abi.SectorSize
	SectorCount    int
	ChallengeCount int
	Priority       bool
}

type PoStType int

type PoseidonDomain [32]byte // Fr

type PreCommit1OutRaw struct {
	LotusSealRand []byte `json:"_lotus_SealRandomness"`

	CommD           Commitment                           `json:"comm_d"`
	Config          Label                                `json:"config"`
	Labels          map[StringRegisteredProofType]Labels `json:"labels"`
	RegisteredProof StringRegisteredProofType            `json:"registered_proof"`
}

type ProofCache interface {
	GetLayerIndex(ctx context.Context, pieceCidV2 cid.Cid) (bool, int, error)
	GetNode(ctx context.Context, pieceCidV2 cid.Cid, layerIdx int, index int64) (bool, [32]byte, error)
	GetLayer(ctx context.Context, pieceCidV2 cid.Cid, layerIdx int) ([]byte, error)
}

type ProofData[H HasherDomain] struct {
	Single *SingleProof[H] `json:"Single,omitempty"`
	Sub    *SubProof[H]    `json:"Sub,omitempty"`
	Top    *TopProof[H]    `json:"Top,omitempty"`
}

type PublicReplicaInfo struct {
	CommR PoseidonDomain
}

type RawMerkleProof struct {
	Leaf  [32]byte
	Proof [][32]byte
	Root  [32]byte
}

type ReplicaColumnProof[H HasherDomain] struct {
	C_X        ColumnProof[H]   `json:"c_x"`
	DrgParents []ColumnProof[H] `json:"drg_parents"`
	ExpParents []ColumnProof[H] `json:"exp_parents"`
}

type SectionReadCloser interface {
	io.Reader
	io.ReaderAt
	io.Closer
}

type SectorNodes uint64

type SectorProof struct {
	// One or more “MerkleProof” objects describing the inclusion paths
	InclusionProofs []MerkleProof[PoseidonDomain] `json:"inclusion_proofs"`

	CommC     PoseidonDomain `json:"comm_c"`
	CommRLast PoseidonDomain `json:"comm_r_last"`
}

type Sha256Domain [32]byte

type SingleProof[H HasherDomain] struct {
	Root H                `json:"root"`
	Leaf H                `json:"leaf"`
	Path InclusionPath[H] `json:"path"`
}

type Snap struct {
	ProofType abi.RegisteredUpdateProof

	OldR Commitment `json:"old_r"`
	NewR Commitment `json:"new_r"`
	NewD Commitment `json:"new_d"`

	// rust-fil-proofs bincoded repr; Todo is implementing types in Go
	Proofs [][]byte
}

type StoreConfig struct {
	// A directory in which data (a merkle tree) can be persisted.
	Path string

	// A unique identifier used to help specify the on-disk store location for this particular data.
	ID string

	// The number of elements in the DiskStore. This field is optional, and unused internally.
	Size *uint64

	// The number of merkle tree rows_to_discard then cache on disk.
	RowsToDiscard uint64
}

type StringRegisteredProofType string // e.g. "StackedDrg2KiBV1", StackedDrg32GiBV1_1

type SubProof[H HasherDomain] struct {
	BaseProof InclusionPath[H] `json:"base_proof"`
	SubProof  InclusionPath[H] `json:"sub_proof"`
	Root      H                `json:"root"`
	Leaf      H                `json:"leaf"`
}

type TAuxLabels struct {
	Labels []StoreConfig
}

type TemporaryAux struct {
	Labels      TAuxLabels
	TreeDConfig StoreConfig
	TreeRConfig StoreConfig
	TreeCConfig StoreConfig
}

type Ticket [32]byte

type TopProof[H HasherDomain] struct {
	BaseProof InclusionPath[H] `json:"base_proof"`
	SubProof  InclusionPath[H] `json:"sub_proof"`
	TopProof  InclusionPath[H] `json:"top_proof"`

	Root H `json:"root"`
	Leaf H `json:"leaf"`
}

type VanillaProof struct {
	// Each “SectorProof” holds merkle inclusion proofs, comm_c, comm_r_last, etc.
	Sectors []SectorProof `json:"sectors"`
}

type VanillaStackedProof struct {
	CommDProofs    MerkleProof[Sha256Domain]   `json:"comm_d_proofs"`
	CommRLastProof MerkleProof[PoseidonDomain] `json:"comm_r_last_proof"`

	ReplicaColumnProofs ReplicaColumnProof[PoseidonDomain] `json:"replica_column_proofs"`
	LabelingProofs      []LabelingProof[PoseidonDomain]    `json:"labeling_proofs"`
	EncodingProof       EncodingProof[PoseidonDomain]      `json:"encoding_proof"`
}