verifreg

type AddVerifiedClientParams struct {
	Address   addr.Address
	Allowance DataCap
}

type AddVerifierParams struct {
	Address   addr.Address
	Allowance DataCap
}

type Allocation struct {
	// The verified client which allocated the DataCap.
	Client abi.ActorID
	// The provider (miner actor) which may claim the allocation.
	Provider abi.ActorID
	// Identifier of the data to be committed.
	Data cid.Cid
	// The (padded) size of data.
	Size abi.PaddedPieceSize
	// The minimum duration which the provider must commit to storing the piece to avoid
	// early-termination penalties (epochs).
	TermMin abi.ChainEpoch
	// The maximum period for which a provider can earn quality-adjusted power
	// for the piece (epochs).
	TermMax abi.ChainEpoch
	// The latest epoch by which a provider must commit data before the allocation expires.
	Expiration abi.ChainEpoch
}

type AllocationId uint64

type AllocationRequest struct {
	// The provider (miner actor) which may claim the allocation.
	Provider abi.ActorID
	// Identifier of the data to be committed.
	Data cid.Cid
	// The (padded) size of data.
	Size abi.PaddedPieceSize
	// The minimum duration which the provider must commit to storing the piece to avoid
	// early-termination penalties (epochs).
	TermMin abi.ChainEpoch
	// The maximum period for which a provider can earn quality-adjusted power
	// for the piece (epochs).
	TermMax abi.ChainEpoch
	// The latest epoch by which a provider must commit data before the allocation expires.
	Expiration abi.ChainEpoch
}

type AllocationRequests struct {
	Allocations []AllocationRequest
	Extensions  []ClaimExtensionRequest
}

type AllocationsResponse struct {
	AllocationResults BatchReturn
	ExtensionResults  BatchReturn
	NewAllocations    []AllocationId
}

type BatchReturn struct {
	SuccessCount uint64
	FailCodes    []FailCode
}

type Claim struct {
	// The provider storing the data (from allocation).
	Provider abi.ActorID
	// The client which allocated the DataCap (from allocation).
	Client abi.ActorID
	// Identifier of the data committed (from allocation).
	Data cid.Cid
	// The (padded) size of data (from allocation).
	Size abi.PaddedPieceSize
	// The min period which the provider must commit to storing data
	TermMin abi.ChainEpoch
	// The max period for which provider can earn QA-power for the data
	TermMax abi.ChainEpoch
	// The epoch at which the (first range of the) piece was committed.
	TermStart abi.ChainEpoch
	// ID of the provider's sector in which the data is committed.
	Sector abi.SectorNumber
}

type ClaimAllocationsParams struct {
	Sectors      []SectorAllocationClaim
	AllOrNothing bool
}

type ClaimAllocationsReturn struct {
	BatchInfo    BatchReturn
	ClaimedSpace big.Int
}

type ClaimExtensionRequest struct {
	// The provider (miner actor) which may claim the allocation.
	Provider abi.ActorID
	// Identifier of the claim to be extended.
	Claim ClaimId
	// The new maximum period for which a provider can earn quality-adjusted power
	// for the piece (epochs).
	TermMax abi.ChainEpoch
}

type ClaimId uint64

type ClaimTerm struct {
	Provider abi.ActorID
	ClaimId  ClaimId
	TermMax  abi.ChainEpoch
}

type DataCap = abi.StoragePower

type ExtendClaimTermsParams struct {
	Terms []ClaimTerm
}

type ExtendClaimTermsReturn BatchReturn

type FailCode struct {
	Idx  uint64
	Code exitcode.ExitCode
}

type GetClaimsParams struct {
	Provider abi.ActorID
	ClaimIds []ClaimId
}

type GetClaimsReturn struct {
	BatchInfo BatchReturn
	Claims    []Claim
}

type ReceiverType uint64

type RemoveDataCapParams struct {
	VerifiedClientToRemove addr.Address
	DataCapAmountToRemove  DataCap
	VerifierRequest1       RemoveDataCapRequest
	VerifierRequest2       RemoveDataCapRequest
}

type RemoveDataCapProposal struct {
	// VerifiedClient is the client address to remove the DataCap from
	// The address must be an ID address
	VerifiedClient addr.Address
	// DataCapAmount is the amount of DataCap to be removed from the VerifiedClient address
	DataCapAmount DataCap
	// RemovalProposalID is the counter of the proposal sent by the Verifier for the VerifiedClient
	RemovalProposalID RmDcProposalID
}

type RemoveDataCapRequest struct {
	// Verifier is the verifier address used for VerifierSignature.
	// The address can be address.SECP256K1 or address.BLS
	Verifier addr.Address
	// VerifierSignature is the Verifier's signature over a RemoveDataCapProposal
	VerifierSignature crypto.Signature
}

type RemoveDataCapReturn struct {
	VerifiedClient addr.Address
	DataCapRemoved DataCap
}

type RemoveExpiredAllocationsParams struct {
	Client        abi.ActorID
	AllocationIds []AllocationId
}

type RemoveExpiredAllocationsReturn struct {
	Considered       []AllocationId
	Results          BatchReturn
	DataCapRecovered DataCap
}

type RemoveExpiredClaimsParams struct {
	Provider abi.ActorID
	ClaimIds []ClaimId
}

type RemoveExpiredClaimsReturn struct {
	Considered []AllocationId
	Results    BatchReturn
}

type RestoreBytesParams struct {
	Address  addr.Address
	DealSize abi.StoragePower
}

type RmDcProposalID struct {
	ProposalID uint64
}

type SectorAllocationClaim struct {
	Client       abi.ActorID
	AllocationId AllocationId
	Data         cid.Cid
	Size         abi.PaddedPieceSize
	Sector       abi.SectorNumber
	SectorExpiry abi.ChainEpoch
}

type State struct {
	// Root key holder multisig.
	// Authorize and remove verifiers.
	RootKey address.Address

	// Verifiers authorize VerifiedClients.
	// Verifiers delegate their DataCap.
	Verifiers cid.Cid // HAMT[addr.Address]DataCap

	// RemoveDataCapProposalIDs keeps the counters of the datacap removal proposal a verifier has submitted for a
	//specific client. Unique proposal ids ensure that removal proposals cannot be replayed.√
	// AddrPairKey is constructed as <verifier address, client address>, both using ID addresses.
	RemoveDataCapProposalIDs cid.Cid // HAMT[AddrPairKey]RmDcProposalID

	// Maps client IDs to allocations made by that client.
	Allocations cid.Cid // HAMT[ActorID]HAMT[AllocationID]Allocation

	// Next allocation identifier to use.
	// The value 0 is reserved to mean "no allocation".
	NextAllocationId AllocationId

	// Maps provider IDs to allocations claimed by that provider.
	Claims cid.Cid // HAMT[ActorID]HAMT[ClaimID]Claim
}

type StateSummary struct {
	Verifiers   map[addr.Address]DataCap
	Claims      map[ClaimId]Claim
	Allocations map[AllocationId]Allocation
}

type UniversalReceiverParams struct {
	Type_   ReceiverType
	Payload []byte
}

type UseBytesParams struct {
	// Address of verified client.
	Address addr.Address
	// Number of bytes to use.
	DealSize abi.StoragePower
}