types

type ChainID ¶

type ChainID int64

ChainID is an EIP-155 chain identifier exposed at the SDK public boundary instead of the bare *big.Int used by go-ethereum. The newtype keeps callers honest about units (raw uint256 chain ids fit easily in int64 for every deployed EVM chain) and avoids silently accepting mutable *big.Int pointers across package boundaries.

The zero value is not a valid chain id; use IsValid to check.

func (c ChainID) BigInt() *big.Int

func (c ChainID) Int64() int64

func (c ChainID) IsValid() bool

type ClientDataSetID ¶

type ClientDataSetID = *big.Int

ClientDataSetID is a caller-assigned identifier that scopes EIP-712 signatures to a specific client/data-set pair. It is a full uint256 in the protocol and reference SDK, so the Go SDK keeps the exact on-chain value.

The pointed-to value must be treated as immutable once shared.

type DataSetID ¶

type DataSetID uint64

DataSetID identifies a warm-storage data set. On-chain it is stored as a uint256, but the Warm Storage contract bounds it to the uint64-safe range; SDK callers work with the typed value directly.

type Epoch ¶

type Epoch uint64

Epoch is a Filecoin chain epoch number. Zero is the valid "indefinite" sentinel in several warm-storage fields.

type ListOptions ¶

type ListOptions struct {
	Offset uint64
	Limit  uint64
}

ListOptions configures a paginated list call.

Limit must be > 0. The zero value is rejected as a programming error: different services/contracts disagree on what "Limit == 0" means (some treat it as "all remaining", others as a default page size), so callers must be explicit.

When you want to iterate every record regardless of page size, use the service's IterateAll* method instead of trying to encode "no cap" via ListOptions.

func (o ListOptions) Validate() error

type PieceID ¶

type PieceID uint64

PieceID identifies a piece within a data set.

type ProviderID ¶

type ProviderID uint64

ProviderID identifies a storage provider registered with the SP registry.

type RailID ¶

type RailID uint64

RailID identifies a payment rail in the payments contract.

type WriteResult ¶

type WriteResult struct {
	Hash    common.Hash
	Receipt *ethtypes.Receipt
}

WriteResult is returned by every state-changing call in the SDK.

Hash is always populated when WriteResult is non-nil — it is set as soon as the transaction is broadcast. Receipt is populated only when the call was made with a wait option (e.g. WithWait(timeout)) and the transaction was mined (successfully or reverted) before the timeout elapsed.

Error semantics (observe WriteResult and err together):

• WriteResult == nil, err != nil: pre-broadcast failure (validation, signing, or broadcast itself failed). The transaction was never submitted to the chain and it is safe to retry with fresh state.
• WriteResult != nil, err == nil: transaction was broadcast successfully. Without a wait option, Receipt is nil. With a wait option, Receipt is non-nil and Status == 1 (successful execution).
• WriteResult != nil, err != nil, Receipt == nil: the wait timed out before a terminal receipt was returned, or receipt lookup failed. This includes both "not mined yet" and "already mined, but the configured confirmation count has not been satisfied yet". Hash is valid; callers can keep polling by Hash.
• WriteResult != nil, err != nil, Receipt != nil: transaction was mined but execution reverted. err wraps ErrTxFailed (use errors.Is). Receipt carries the failed status and any logs emitted before revert.