types

type APIVersion uint32

type ActivateDealsParams = market.ActivateDealsParams

type ActivateDealsResult = market.ActivateDealsResult

type ActiveBeneficiary = miner.ActiveBeneficiary

type ActiveSync struct {
	WorkerID uint64
	Base     *TipSet
	Target   *TipSet

	Stage  SyncStateStage
	Height abi.ChainEpoch

	Start   time.Time
	End     time.Time
	Message string
}

type Actor = types.Actor

type ActorEvent struct {
	// Event entries in log form.
	Entries []EventEntry `json:"entries"`

	// Filecoin address of the actor that emitted this event.
	// NOTE: In a future upgrade, this will change to always be an ID address. Currently this will be
	// either the f4 address, or ID address if an f4 is not available for this actor.
	Emitter address.Address `json:"emitter"`

	// Reverted is set to true if the message that produced this event was reverted because of a network re-org
	// in that case, the event should be considered as reverted as well.
	Reverted bool `json:"reverted"`

	// Height of the tipset that contained the message that produced this event.
	Height abi.ChainEpoch `json:"height"`

	// The tipset that contained the message that produced this event.
	TipSetKey TipSetKey `json:"tipsetKey"`

	// CID of message that produced this event.
	MsgCid cid.Cid `json:"msgCid"`
}

type ActorEventBlock struct {
	// The value codec to match when filtering event values.
	Codec uint64 `json:"codec"`

	// The value to want to match on associated with the corresponding "event key"
	// when filtering events.
	// Should be a byte array encoded with the specified codec.
	// Assumes base64 encoding when converting to/from JSON strings.
	Value []byte `json:"value"`
}

type ActorEventFilter struct {
	// Matches events from one of these actors, or any actor if empty.
	// For now, this MUST be a Filecoin address.
	Addresses []address.Address `json:"addresses,omitempty"`

	// Matches events with the specified key/values, or all events if empty.
	// If the value is an empty slice, the filter will match on the key only, accepting any value.
	Fields map[string][]ActorEventBlock `json:"fields,omitempty"`

	// The height of the earliest tipset to include in the query. If empty, the query starts at the
	// last finalized tipset.
	// NOTE: In a future upgrade, this will be strict when set and will result in an error if a filter
	// cannot be fulfilled by the depth of history available in the node. Currently, the node will
	// nott return an error, but will return starting from the epoch it has data for.
	FromHeight *abi.ChainEpoch `json:"fromHeight,omitempty"`

	// The height of the latest tipset to include in the query. If empty, the query ends at the
	// latest tipset.
	ToHeight *abi.ChainEpoch `json:"toHeight,omitempty"`

	// Restricts events returned to those emitted from messages contained in this tipset.
	// If `TipSetKey` is legt empty in the filter criteria, then neither `FromHeight` nor `ToHeight` are allowed.
	TipSetKey *TipSetKey `json:"tipsetKey,omitempty"`
}

type ActorState struct {
	Balance BigInt
	Code    cid.Cid
	State   interface{}
}

type ActorTrace struct {
	Id    abi.ActorID // nolint
	State Actor
}

type ActorV4 = types.ActorV4

type AddSignerParams = multisig.AddSignerParams

type AddVerifiedClientParams = verifreg.AddVerifiedClientParams

type AddVerifierParams = verifreg.AddVerifierParams

type Allocation = verifreg.Allocation

type AllocationId = verifreg.AllocationId

type AllocationRequest = verifreg.AllocationRequest

type AllocationRequests = verifreg.AllocationRequests

type AllocationsResponse = verifreg.AllocationsResponse

type ApplyRewardParams = miner.ApplyRewardParams

type ApproveReturn = multisig.ApproveReturn

type BatchReturn = verifreg.BatchReturn

type BeaconEntry struct {
	Round uint64
	Data  []byte
}

type BeneficiaryTerm = miner.BeneficiaryTerm

type BigInt = types.BigInt

type BlockHeader struct {
	// Miner is the address of the miner actor that mined this newBlock.
	Miner address.Address

	// Ticket is the ticket submitted with this newBlock.
	Ticket *Ticket

	// ElectionProof is the vrf proof giving this newBlock's miner authoring rights
	ElectionProof *ElectionProof

	// BeaconEntries contain the verifiable oracle randomness used to elect
	// this newBlock's author leader
	BeaconEntries []BeaconEntry

	// WinPoStProof are the winning post proofs
	WinPoStProof []proof.PoStProof

	// Parents is the set of parents this newBlock was based on. Typically one,
	// but can be several in the case where there were multiple winning ticket-
	// holders for an epoch.
	Parents []cid.Cid

	// ParentWeight is the aggregate chain weight of the parent set.
	ParentWeight big.Int

	// Height is the chain height of this newBlock.
	Height abi.ChainEpoch

	// ParentStateRoot is the CID of the root of the state tree after application of the messages in the parent tipset
	// to the parent tipset's state root.
	ParentStateRoot cid.Cid

	// ParentMessageReceipts is a list of receipts corresponding to the application of the messages in the parent tipset
	// to the parent tipset's state root (corresponding to this newBlock's ParentStateRoot).
	ParentMessageReceipts cid.Cid

	// Messages is the set of messages included in this newBlock
	Messages cid.Cid

	// The aggregate signature of all BLS signed messages in the newBlock
	BLSAggregate *crypto.Signature

	// The timestamp, in seconds since the Unix epoch, at which this newBlock was created.
	Timestamp uint64

	// The signature of the miner's worker key over the newBlock
	BlockSig *crypto.Signature

	// ForkSignaling is extra data used by miners to communicate
	ForkSignaling uint64

	// identical for all blocks in same tipset: the base fee after executing parent tipset
	ParentBaseFee abi.TokenAmount
	// contains filtered or unexported fields
}

type BlockMessages struct {
	BlsMessages   []*Message
	SecpkMessages []*SignedMessage
	Cids          []cid.Cid
}

type BlockMessagesInfo struct {
	BlsMessages   []ChainMsg
	SecpkMessages []ChainMsg

	Block *BlockHeader
}

type BlockMsg struct {
	Header        *BlockHeader
	BlsMessages   []cid.Cid
	SecpkMessages []cid.Cid
}

type BlockTemplate struct {
	Miner            address.Address
	Parents          TipSetKey
	Ticket           *Ticket
	Eproof           *ElectionProof
	BeaconValues     []BeaconEntry
	Messages         []*SignedMessage
	Epoch            abi.ChainEpoch
	Timestamp        uint64
	WinningPoStProof []builtin.PoStProof
}

type BurnFromParams = datacap.BurnFromParams

type BurnFromReturn = datacap.BurnFromReturn

type BurnParams = datacap.BurnParams

type BurnReturn = datacap.BurnReturn

type ChainInfo struct {
	// The originator of the TipSetKey propagation wave.
	Source peer.ID
	// The peer that sent us the TipSetKey message.
	Sender     peer.ID
	FullTipSet *FullTipSet
}

type ChainMessage struct {
	TS      *TipSet
	Message ChainMsg
	Block   *BlockHeader
	Receipt *MessageReceipt
}

type ChainMsg = types.ChainMsg

type ChangeBeneficiaryParams = miner.ChangeBeneficiaryParams

type ChangeMultiaddrsParams = miner.ChangeMultiaddrsParams

type ChangeNumApprovalsThresholdParams = multisig.ChangeNumApprovalsThresholdParams

type ChangePeerIDParams = miner.ChangePeerIDParams

type ChangeWorkerAddressParams = miner.ChangeWorkerAddressParams

type ChannelAvailableFunds struct {
	// Channel is the address of the channel
	Channel *address.Address
	// From is the from address of the channel (channel creator)
	From address.Address
	// To is the to address of the channel
	To address.Address
	// ConfirmedAmt is the total amount of funds that have been confirmed on-chain for the channel
	ConfirmedAmt BigInt
	// PendingAmt is the amount of funds that are pending confirmation on-chain
	PendingAmt BigInt
	// NonReservedAmt is part of ConfirmedAmt that is available for use (e.g. when the payment channel was pre-funded)
	NonReservedAmt BigInt
	// PendingAvailableAmt is the amount of funds that are pending confirmation on-chain that will become available once confirmed
	PendingAvailableAmt BigInt
	// PendingWaitSentinel can be used with PaychGetWaitReady to wait for
	// confirmation of pending funds
	PendingWaitSentinel *cid.Cid
	// QueuedAmt is the amount that is queued up behind a pending request
	QueuedAmt BigInt
	// VoucherRedeemedAmt is the amount that is redeemed by vouchers on-chain
	// and in the local datastore
	VoucherReedeemedAmt BigInt
}

type ChannelInfo struct {
	Channel      address.Address
	WaitSentinel cid.Cid
}

type CheckSectorProvenParams = miner.CheckSectorProvenParams

type CheckStatus struct {
	Code CheckStatusCode
	OK   bool
	Err  string
	Hint map[string]interface{}
}

type CheckStatusCode int

type CirculatingSupply struct {
	FilVested           abi.TokenAmount
	FilMined            abi.TokenAmount
	FilBurnt            abi.TokenAmount
	FilLocked           abi.TokenAmount
	FilCirculating      abi.TokenAmount
	FilReserveDisbursed abi.TokenAmount
}

type Claim = verifreg.Claim

type ClaimAllocationsParams = verifreg.ClaimAllocationsParams

type ClaimAllocationsReturn = verifreg.ClaimAllocationsReturn

type ClaimExtensionRequest = verifreg.ClaimExtensionRequest

type ClaimId = verifreg.ClaimId

type ClaimTerm = verifreg.ClaimTerm

type ClientDealProposal = market.ClientDealProposal

type CompactPartitionsParams = miner.CompactPartitionsParams

type CompactSectorNumbersParams = miner.CompactSectorNumbersParams

type ComputeDataCommitmentParams = market.ComputeDataCommitmentParams

type ComputeDataCommitmentReturn = market.ComputeDataCommitmentReturn

type ComputeStateOutput struct {
	Root  cid.Cid
	Trace []*InvocResult
}

type ConfirmSectorProofsParams = miner.ConfirmSectorProofsParams

type ConnMgrInfo struct {
	FirstSeen time.Time
	Value     int
	Tags      map[string]int
	Conns     map[string]time.Time
}

type CronEventPayload = miner.CronEventPayload

type CronEventType = miner.CronEventType

type DataCap = verifreg.DataCap

type Deadline struct {
	PostSubmissions      bitfield.BitField
	DisputableProofCount uint64
}

type Deadlines = miner.Deadlines

type DealArray = market.DealArray

type DealCollateralBounds struct {
	Min abi.TokenAmount
	Max abi.TokenAmount
}

type DealLabel = market.DealLabel

type DealProposal = market.DealProposal

type DealSpaces = market.DealSpaces

type DealState = market.DealState

type DeclareFaultsParams = miner.DeclareFaultsParams

type DeclareFaultsRecoveredParams = miner.DeclareFaultsRecoveredParams

type DecreaseAllowanceParams = datacap.DecreaseAllowanceParams

type DeferredCronEventParams = miner.DeferredCronEventParams

type DestroyParams = datacap.DestroyParams

type DisputeWindowedPoStParams = miner.DisputeWindowedPoStParams

type ElectionProof struct {
	WinCount int64

	// A proof output by running a VRF on the VRFProof of the parent ticket
	VRFProof VRFPi
}

type EstimateMessage struct {
	Msg  *Message
	Spec *MessageSendSpec
}

type EstimateResult struct {
	Msg *Message
	Err string
}

type EthAddress = types.EthAddress

type EthAddressList = types.EthAddressList

type EthBigInt = types.EthBigInt

type EthBlock = types.EthBlock

type EthBlockNumberOrHash = types.EthBlockNumberOrHash

type EthBytes = types.EthBytes

type EthCall = types.EthCall

type EthCallTraceAction = types.EthCallTraceAction

type EthCallTraceResult = types.EthCallTraceResult

type EthCreateTraceAction = types.EthCreateTraceAction

type EthCreateTraceResult = types.EthCreateTraceResult

type EthEstimateGasParams = types.EthEstimateGasParams

type EthFeeHistory = types.EthFeeHistory

type EthFeeHistoryParams = types.EthFeeHistoryParams

type EthFilterID = types.EthFilterID

type EthFilterResult = types.EthFilterResult

type EthFilterSpec = types.EthFilterSpec

type EthHash = types.EthHash

type EthHashList = types.EthHashList

type EthLog = types.EthLog

type EthNonce = types.EthNonce

type EthSubscribeParams = types.EthSubscribeParams

type EthSubscriptionID = types.EthSubscriptionID

type EthSubscriptionParams = types.EthSubscriptionParams

type EthSubscriptionResponse = types.EthSubscriptionResponse

type EthSyncingResult = types.EthSyncingResult

type EthTopicSpec = types.EthTopicSpec

type EthTrace = types.EthTrace

type EthTraceBlock = types.EthTraceBlock

type EthTraceReplayBlockTransaction = types.EthTraceReplayBlockTransaction

type EthTx = types.EthTx

type EthTxArgs = types.EthTxArgs

type EthTxReceipt = types.EthTxReceipt

type EthUint64 = types.EthUint64

type Event struct {
	// The ID of the actor that emitted this event.
	Emitter abi.ActorID

	// Key values making up this event.
	Entries []EventEntry
}

type EventEntry struct {
	// A bitmap conveying metadata or hints about this entry.
	Flags uint8

	// The key of this event entry
	Key string

	// The event value's codec
	Codec uint64

	// The event value. It is encoded using the codec specified above
	Value []byte
}

type ExecutionTrace struct {
	Msg          MessageTrace
	MsgRct       ReturnTrace
	InvokedActor *ActorTrace      `json:",omitempty"`
	GasCharges   []*GasTrace      `cborgen:"maxlen=1000000000"`
	Subcalls     []ExecutionTrace `cborgen:"maxlen=1000000000"`
}

type ExpTipSet struct {
	Cids   []cid.Cid
	Blocks []*BlockHeader
	Height abi.ChainEpoch
}

type ExpirationExtension = miner.ExpirationExtension

type ExpirationExtension2 = miner.ExpirationExtension2

type ExpirationQueue = miner.ExpirationQueue

type ExpirationSet = miner.ExpirationSet

type ExtendClaimTermsParams = verifreg.ExtendClaimTermsParams

type ExtendClaimTermsReturn = verifreg.ExtendClaimTermsReturn

type ExtendSectorExpiration2Params = miner.ExtendSectorExpiration2Params

type ExtendSectorExpirationParams = miner.ExtendSectorExpirationParams

type ExtendedPeerInfo struct {
	ID          peer.ID
	Agent       string
	Addrs       []string
	Protocols   []string
	ConnMgrMeta *ConnMgrInfo
}

type FIL = types.FIL

type FailCode = verifreg.FailCode

type Fault struct {
	Miner address.Address
	Epoch abi.ChainEpoch
}

type FaultDeclaration = miner.FaultDeclaration

type FilterID [32]byte // compatible with EthHash

type ForkUpgradeParams struct {
	UpgradeSmokeHeight       abi.ChainEpoch
	UpgradeBreezeHeight      abi.ChainEpoch
	UpgradeIgnitionHeight    abi.ChainEpoch
	UpgradeLiftoffHeight     abi.ChainEpoch
	UpgradeAssemblyHeight    abi.ChainEpoch
	UpgradeRefuelHeight      abi.ChainEpoch
	UpgradeTapeHeight        abi.ChainEpoch
	UpgradeKumquatHeight     abi.ChainEpoch
	BreezeGasTampingDuration abi.ChainEpoch
	UpgradeCalicoHeight      abi.ChainEpoch
	UpgradePersianHeight     abi.ChainEpoch
	UpgradeOrangeHeight      abi.ChainEpoch
	UpgradeClausHeight       abi.ChainEpoch
	UpgradeTrustHeight       abi.ChainEpoch
	UpgradeNorwegianHeight   abi.ChainEpoch
	UpgradeTurboHeight       abi.ChainEpoch
	UpgradeHyperdriveHeight  abi.ChainEpoch
	UpgradeChocolateHeight   abi.ChainEpoch
	UpgradeOhSnapHeight      abi.ChainEpoch
	UpgradeSkyrHeight        abi.ChainEpoch
	UpgradeSharkHeight       abi.ChainEpoch
	UpgradeHyggeHeight       abi.ChainEpoch
	UpgradeLightningHeight   abi.ChainEpoch
	UpgradeThunderHeight     abi.ChainEpoch
	UpgradeWatermelonHeight  abi.ChainEpoch
	UpgradeDragonHeight      abi.ChainEpoch
	UpgradePhoenixHeight     abi.ChainEpoch
}

type FullBlock struct {
	Header       *BlockHeader
	BLSMessages  []*Message
	SECPMessages []*SignedMessage
}

type FullTipSet struct {
	Blocks []*FullBlock
	// contains filtered or unexported fields
}

type GasTrace struct {
	Name       string
	TotalGas   int64         `json:"tg"`
	ComputeGas int64         `json:"cg"`
	StorageGas int64         `json:"sg"`
	TimeTaken  time.Duration `json:"tt"`
}

type GetAllowanceParams = datacap.GetAllowanceParams

type GetBeneficiaryReturn = miner.GetBeneficiaryReturn

type GetClaimsParams = verifreg.GetClaimsParams

type GetClaimsReturn = verifreg.GetClaimsReturn

type GetControlAddressesReturn = miner.GetControlAddressesReturn

type HeadChange struct {
	Type HeadChangeType
	Val  *TipSet
}

type HeadChangeType string

type IncreaseAllowanceParams = datacap.IncreaseAllowanceParams

type InvocResult struct {
	MsgCid         cid.Cid
	Msg            *Message
	MsgRct         *MessageReceipt
	GasCost        MsgGasCost
	ExecutionTrace ExecutionTrace
	Error          string
	Duration       time.Duration
}

type KeyInfo struct {
	Type       KeyType
	PrivateKey []byte
}

type KeyType string

type LaneState = paych.LaneState

type LockBalanceParams = multisig.LockBalanceParams

type MarketBalance struct {
	Escrow big.Int
	Locked big.Int
}

type MarketDeal struct {
	Proposal DealProposal
	State    MarketDealState
}

type MarketDealState struct {
	SectorStartEpoch abi.ChainEpoch // -1 if not yet included in proven sector
	LastUpdatedEpoch abi.ChainEpoch // -1 if deal state never updated
	SlashEpoch       abi.ChainEpoch // -1 if deal never slashed
}

type MarketWithdrawBalanceParams = market.WithdrawBalanceParams

type Merge = paych.Merge

type Message = types.Message

type MessageCID struct {
	Cid     cid.Cid
	Message *Message
}

type MessageCheckStatus struct {
	Cid cid.Cid
	CheckStatus
}

type MessageMatch struct {
	To   address.Address
	From address.Address
}

type MessagePrototype struct {
	Message    Message
	ValidNonce bool
}

type MessageReceipt struct {
	ExitCode exitcode.ExitCode
	Return   []byte
	GasUsed  int64

	EventsRoot *cid.Cid // Root of Event AMT with bitwidth = EventAMTBitwidth
	// contains filtered or unexported fields
}

type MessageReceiptVersion byte

type MessageRoot struct {
	BlsRoot   cid.Cid
	SecpkRoot cid.Cid
}

type MessageSendSpec struct {
	MaxFee            abi.TokenAmount
	GasOverEstimation float64
	GasOverPremium    float64
}

type MessageTrace struct {
	From        address.Address
	To          address.Address
	Value       abi.TokenAmount
	Method      abi.MethodNum
	Params      []byte
	ParamsCodec uint64
	GasLimit    uint64
	ReadOnly    bool
}

type MinerConstructorParams = miner.MinerConstructorParams

type MinerInfo struct {
	Owner                      address.Address   // Must be an ID-address.
	Worker                     address.Address   // Must be an ID-address.
	NewWorker                  address.Address   // Must be an ID-address.
	ControlAddresses           []address.Address // Must be an ID-addresses.
	WorkerChangeEpoch          abi.ChainEpoch
	PeerId                     *peer.ID // nolint
	Multiaddrs                 []abi.Multiaddrs
	WindowPoStProofType        abi.RegisteredPoStProof
	SectorSize                 abi.SectorSize
	WindowPoStPartitionSectors uint64
	ConsensusFaultElapsed      abi.ChainEpoch
	PendingOwnerAddress        *address.Address
	Beneficiary                address.Address
	BeneficiaryTerm            *BeneficiaryTerm
	PendingBeneficiaryTerm     *PendingBeneficiaryChange
}

type MinerPower struct {
	MinerPower  power.Claim
	TotalPower  power.Claim
	HasMinPower bool
}

type MinerSectors struct {
	// Live sectors that should be proven.
	Live uint64
	// Sectors actively contributing to power.
	Active uint64
	// Sectors with failed proofs.
	Faulty uint64
}

type MinerWithdrawBalanceParams = miner.WithdrawBalanceParams

type MiningBaseInfo struct {
	MinerPower        abi.StoragePower
	NetworkPower      abi.StoragePower
	Sectors           []builtin.ExtendedSectorInfo
	WorkerKey         address.Address
	SectorSize        abi.SectorSize
	PrevBeaconEntry   BeaconEntry
	BeaconEntries     []BeaconEntry
	EligibleForMining bool
}

type MintParams = datacap.MintParams

type MintReturn = datacap.MintReturn

type ModVerifyParams = paych.ModVerifyParams

type MpoolChange int

type MpoolConfig struct {
	PriorityAddrs          []address.Address
	SizeLimitHigh          int
	SizeLimitLow           int
	ReplaceByFeeRatio      Percent
	PruneCooldown          time.Duration
	GasLimitOverestimation float64
}

type MpoolUpdate struct {
	Type    MpoolChange
	Message *SignedMessage
}

type MsgGasCost struct {
	Message            cid.Cid // Can be different than requested, in case it was replaced, but only gas values changed
	GasUsed            abi.TokenAmount
	BaseFeeBurn        abi.TokenAmount
	OverEstimationBurn abi.TokenAmount
	MinerPenalty       abi.TokenAmount
	MinerTip           abi.TokenAmount
	Refund             abi.TokenAmount
	TotalCost          abi.TokenAmount
}

type MsgLookup struct {
	Message   cid.Cid // Can be different than requested, in case it was replaced, but only gas values changed
	Receipt   MessageReceipt
	ReturnDec interface{}
	TipSet    TipSetKey
	Height    abi.ChainEpoch
}

type MsgMeta struct {
	Type MsgType

	// Additional data related to what is signed. Should be verifiable with the
	// signed bytes (e.g. CID(Extra).Bytes() == toSign)
	Extra []byte
}

type MsgType string

type MsigInfo struct {
	ApprovalsThreshold uint64
	Signers            []address.Address
	InitialBalance     abi.TokenAmount
	CurrentBalance     abi.TokenAmount
	LockBalance        abi.TokenAmount
	StartEpoch         abi.ChainEpoch
	UnlockDuration     abi.ChainEpoch
}

type MsigTransaction struct {
	ID     int64
	To     address.Address
	Value  abi.TokenAmount
	Method abi.MethodNum
	Params []byte

	Approved []address.Address
}

type MsigVesting struct {
	InitialBalance abi.TokenAmount
	StartEpoch     abi.ChainEpoch
	UnlockDuration abi.ChainEpoch
}

type MultisigConstructorParams = multisig.ConstructorParams

type NatInfo struct {
	Reachability network.Reachability
	PublicAddrs  []string
}

type NetworkName string

type NetworkParams struct {
	NetworkName             NetworkName
	BlockDelaySecs          uint64
	ConsensusMinerMinPower  abi.StoragePower
	SupportedProofTypes     []abi.RegisteredSealProof
	PreCommitChallengeDelay abi.ChainEpoch
	ForkUpgradeParams       ForkUpgradeParams
	Eip155ChainID           int
}

type NetworkType int

type NodeChainStatus struct {
	BlocksPerTipsetLast100      float64
	BlocksPerTipsetLastFinality float64
}

type NodePeerStatus struct {
	PeersToPublishMsgs   int
	PeersToPublishBlocks int
}

type NodeStatus struct {
	SyncStatus  NodeSyncStatus
	PeerStatus  NodePeerStatus
	ChainStatus NodeChainStatus
}

type NodeSyncStatus struct {
	Epoch  uint64
	Behind uint64
}

type ObjStat struct {
	Size  uint64
	Links uint64
}

type OnMinerSectorsTerminateParams = market.OnMinerSectorsTerminateParams

type PCHDir int

type PaddedByteIndex uint64

type Partition struct {
	AllSectors        bitfield.BitField
	FaultySectors     bitfield.BitField
	RecoveringSectors bitfield.BitField
	LiveSectors       bitfield.BitField
	ActiveSectors     bitfield.BitField
}

type PartitionKey = miner.PartitionKey

type PaychConstructorParams = paych.ConstructorParams

type PaychGetOpts struct {
	OffChain bool
}

type PaymentInfo struct {
	Channel      address.Address
	WaitSentinel cid.Cid
	Vouchers     []*SignedVoucher
}

type PendingBeneficiaryChange = miner.PendingBeneficiaryChange

type Percent int64

type PoStPartition = miner.PoStPartition

type PowerPair = miner.PowerPair

type PreCommitSectorBatchParams = miner.PreCommitSectorBatchParams

type PreCommitSectorBatchParams2 = miner.PreCommitSectorBatchParams2

type PreCommitSectorParams = miner.PreCommitSectorParams

type ProposalHashData = multisig.ProposalHashData

type ProposeParams = multisig.ProposeParams

type ProposeReturn = multisig.ProposeReturn

type ProtocolParams struct {
	Network          string
	BlockTime        time.Duration
	SupportedSectors []SectorInfo
}

type ProveCommitAggregateParams = miner.ProveCommitAggregateParams

type ProveCommitSectorParams = miner.ProveCommitSectorParams

type ProveReplicaUpdatesParams = miner.ProveReplicaUpdatesParams

type ProveReplicaUpdatesParams2 = miner.ProveReplicaUpdatesParams2

type PublishStorageDealsParams = market.PublishStorageDealsParams

type PublishStorageDealsReturn = market.PublishStorageDealsReturn

type PubsubScore struct {
	ID    peer.ID
	Score *pubsub.PeerScoreSnapshot
}

type QuerySignRecordParams struct {
	ID      string
	Type    MsgType
	Signer  address.Address
	IsError bool
	Skip    int
	Limit   int
	After   time.Time
	Before  time.Time
}

type RawHost host.Host

type RawMessage = types.RawMessage

type ReceiverType = verifreg.ReceiverType

type RecoveryDeclaration = miner.RecoveryDeclaration

type RemoveDataCapParams = verifreg.RemoveDataCapParams

type RemoveDataCapProposal = verifreg.RemoveDataCapProposal

type RemoveDataCapRequest = verifreg.RemoveDataCapRequest

type RemoveDataCapReturn = verifreg.RemoveDataCapReturn

type RemoveExpiredAllocationsParams = verifreg.RemoveExpiredAllocationsParams

type RemoveExpiredAllocationsReturn = verifreg.RemoveExpiredAllocationsReturn

type RemoveExpiredClaimsParams = verifreg.RemoveExpiredClaimsParams

type RemoveExpiredClaimsReturn = verifreg.RemoveExpiredClaimsReturn

type RemoveSignerParams = multisig.RemoveSignerParams

type ReplicaUpdate = miner.ReplicaUpdate

type ReplicaUpdate2 = miner.ReplicaUpdate2

type ReportConsensusFaultParams = miner.ReportConsensusFaultParams

type RestoreBytesParams = verifreg.RestoreBytesParams

type ReturnTrace struct {
	ExitCode    exitcode.ExitCode
	Return      []byte
	ReturnCodec uint64
}

type RevokeAllowanceParams = datacap.RevokeAllowanceParams

type RmDcProposalID = verifreg.RmDcProposalID

type SectorAllocationClaim = verifreg.SectorAllocationClaim

type SectorClaim = miner.SectorClaim

type SectorDataSpec = market.SectorDataSpec

type SectorDealData = market.SectorDealData

type SectorDeals = market.SectorDeals

type SectorInfo struct {
	Size         abi.SectorSize
	MaxPieceSize abi.UnpaddedPieceSize
}

type SectorOnChainInfo = miner.SectorOnChainInfo

type SectorPreCommitInfo = miner.SectorPreCommitInfo

type SectorPreCommitOnChainInfo = miner.SectorPreCommitOnChainInfo

type Sectors = miner.Sectors

type SetMultimap = market.SetMultimap

type SigType = crypto.SigType

type SignRecord struct {
	ID        string
	Type      MsgType
	Signer    address.Address
	Err       error
	RawMsg    []byte
	Signature *crypto.Signature
	CreateAt  time.Time
}

type SignedMessage = types.SignedMessage

type SignedVoucher = paych.SignedVoucher

type Signer interface {
	SignBytes(ctx context.Context, data []byte, addr address.Address) (*crypto.Signature, error)
	HasAddress(ctx context.Context, addr address.Address) (bool, error)
}

type Status struct {
	ControlAddr address.Address
	Direction   PCHDir
}

type SubmitWindowedPoStParams = miner.SubmitWindowedPoStParams

type SwapSignerParams = multisig.SwapSignerParams

type SyncState struct {
	ActiveSyncs []ActiveSync

	VMApplied uint64
}

type SyncStateStage int

type Target struct {
	State   SyncStateStage
	Base    *TipSet
	Current *TipSet
	Start   time.Time
	End     time.Time
	Err     error
	Head    *TipSet
	Sender  peer.ID
}

type TargetTracker struct {
	History []*Target
	Buckets []*Target
}

type TerminateSectorsParams = miner.TerminateSectorsParams

type TerminateSectorsReturn = miner.TerminateSectorsReturn

type TerminationDeclaration = miner.TerminationDeclaration

type Ticket struct {
	// A proof output by running a VRF on the VRFProof of the parent ticket
	VRFProof VRFPi
}

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

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

type TokenState = datacap.TokenState

type Transaction = multisig.Transaction

type TransferFromParams = datacap.TransferFromParams

type TransferFromReturn = datacap.TransferFromReturn

type TransferParams = datacap.TransferParams

type TransferReturn = datacap.TransferReturn

type TxnID = multisig.TxnID

type TxnIDParams = multisig.TxnIDParams

type UUID uuid.UUID

type UniversalReceiverParams = verifreg.UniversalReceiverParams

type UnpaddedByteIndex uint64

type UpdateChannelStateParams = paych.UpdateChannelStateParams

type UseBytesParams = verifreg.UseBytesParams

type VRFPi []byte

type VerifiedDealInfo = market.VerifiedDealInfo

type VerifyDealsForActivationParams = market.VerifyDealsForActivationParams

type VerifyDealsForActivationReturn = market.VerifyDealsForActivationReturn

type Version struct {
	Version string

	// APIVersion is a binary encoded semver version of the remote implementing
	// this api
	//
	APIVersion APIVersion
}

type VestSpec = miner.VestSpec

type VestingFund = miner.VestingFund

type VestingFunds = miner.VestingFunds

type VoucherCreateResult struct {
	// Voucher that was created, or nil if there was an error or if there
	// were insufficient funds in the channel
	Voucher *SignedVoucher
	// Shortfall is the additional amount that would be needed in the channel
	// in order to be able to create the voucher
	Shortfall BigInt
}

type VoucherSpec struct {
	Amount      BigInt
	TimeLockMin abi.ChainEpoch
	TimeLockMax abi.ChainEpoch
	MinSettle   abi.ChainEpoch

	Extra *ModVerifyParams
}

type WindowedPoSt = miner.WindowedPoSt

type WorkerKeyChange = miner.WorkerKeyChange