actors

package
v0.2.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 14, 2020 License: Apache-2.0, MIT Imports: 25 Imported by: 100

Documentation

Index

Constants

View Source 
const (
	GasCreateActor = 100
)
View Source 
const MaxSectors = 1 << 48
View Source 
const (
	SerializationUnixFSv0 = iota
)

Variables

View Source 
var AccountCodeCid cid.Cid
View Source 
var BurntFundsAddress = mustIDAddress(99)
View Source 
var CAMethods = cAMethods{2}
View Source 
var CborNull = &cbgNull{}
View Source 
var CronActors = []callTuple{
	{StoragePowerAddress, SPAMethods.CheckProofSubmissions},
}
View Source 
var CronAddress = mustIDAddress(4)
View Source 
var CronCodeCid cid.Cid
View Source 
var EmptyCBOR cid.Cid
View Source 
var (
	EmptyStructCBOR = []byte{0xa0}
)
View Source 
var IAMethods = iAMethods{2}
View Source 
var InitAddress = mustIDAddress(0)
View Source 
var InitCodeCid cid.Cid
View Source 
var MAMethods = maMethods{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
View Source 
var MultiSigMethods = musigMethods{1, 2, 3, 4, 5, 6, 7, 8, 9}
View Source 
var MultisigCodeCid cid.Cid
View Source 
var NetworkAddress = mustIDAddress(1)
View Source 
var PCAMethods = pcaMethods{1, 2, 3, 4, 5, 6}
View Source 
var PaymentChannelCodeCid cid.Cid
View Source 
var SMAMethods = smaMethods{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
View Source 
var SPAMethods = spaMethods{1, 2, 3, 4, 5, 6, 7, 8, 9}
View Source 
var StorageMarketAddress = mustIDAddress(3) // TODO: missing from spec
View Source 
var StorageMarketCodeCid cid.Cid
View Source 
var StorageMinerCodeCid cid.Cid
View Source 
var StoragePowerAddress = mustIDAddress(2)
View Source 
var StoragePowerCodeCid cid.Cid

Functions

func CollateralForPower 

func CollateralForPower(power types.BigInt) types.BigInt

func CreateExecParams 

func CreateExecParams(act cid.Cid, obj cbg.CBORMarshaler) ([]byte, aerrors.ActorError)

func GetMarketBalances 

func GetMarketBalances(ctx context.Context, store *hamt.CborIpldStore, rcid cid.Cid, addrs ...address.Address) ([]StorageParticipantBalance, *hamt.Node, ActorError)

func IsBuiltinActor 

func IsBuiltinActor(code cid.Cid) bool

func IsSingletonActor 

func IsSingletonActor(code cid.Cid) bool

func MinerSetAdd 

func MinerSetAdd(ctx context.Context, vmctx types.VMContext, rcid cid.Cid, maddr address.Address) (cid.Cid, aerrors.ActorError)

func MinerSetHas 

func MinerSetHas(vmctx types.VMContext, rcid cid.Cid, maddr address.Address) (bool, aerrors.ActorError)

func MinerSetList 

func MinerSetList(ctx context.Context, cst *hamt.CborIpldStore, rcid cid.Cid) ([]address.Address, error)

func MinerSetRemove 

func MinerSetRemove(ctx context.Context, vmctx types.VMContext, rcid cid.Cid, maddr address.Address) (cid.Cid, aerrors.ActorError)

func RemoveFromSectorSet 

func RemoveFromSectorSet(ctx context.Context, s types.Storage, ss cid.Cid, ids []uint64) (cid.Cid, aerrors.ActorError)

func SerializeParams 

func SerializeParams(i cbg.CBORMarshaler) ([]byte, aerrors.ActorError)

Types

type AccountActorState 

type AccountActorState struct {
	Address address.Address
}

func (*AccountActorState) MarshalCBOR 

func (t *AccountActorState) MarshalCBOR(w io.Writer) error

func (*AccountActorState) UnmarshalCBOR 

func (t *AccountActorState) UnmarshalCBOR(r io.Reader) error

type ActivateStorageDealsParams 

type ActivateStorageDealsParams struct {
	Deals []uint64
}

func (*ActivateStorageDealsParams) MarshalCBOR 

func (t *ActivateStorageDealsParams) MarshalCBOR(w io.Writer) error

func (*ActivateStorageDealsParams) UnmarshalCBOR 

func (t *ActivateStorageDealsParams) UnmarshalCBOR(r io.Reader) error

type ActorError 

type ActorError = aerrors.ActorError

func AddToSectorSet 

func AddToSectorSet(ctx context.Context, blks amt.Blocks, ss cid.Cid, sectorID uint64, commR, commD []byte) (cid.Cid, ActorError)

func ComputeActorAddress 

func ComputeActorAddress(creator address.Address, nonce uint64) (address.Address, ActorError)

func GetFromSectorSet 

func GetFromSectorSet(ctx context.Context, s types.Storage, ss cid.Cid, sectorID uint64) (bool, []byte, []byte, ActorError)

func NewIDAddress 

func NewIDAddress(id uint64) (address.Address, ActorError)

func SectorIsUnique 

func SectorIsUnique(ctx context.Context, s types.Storage, sroot cid.Cid, sid uint64) (bool, ActorError)

type ArbitrateConsensusFaultParams 

type ArbitrateConsensusFaultParams struct {
	Block1 *types.BlockHeader
	Block2 *types.BlockHeader
}

func (*ArbitrateConsensusFaultParams) MarshalCBOR 

func (t *ArbitrateConsensusFaultParams) MarshalCBOR(w io.Writer) error

func (*ArbitrateConsensusFaultParams) UnmarshalCBOR 

func (t *ArbitrateConsensusFaultParams) UnmarshalCBOR(r io.Reader) error

type CheckMinerParams 

type CheckMinerParams struct {
	NetworkPower types.BigInt
}

func (*CheckMinerParams) MarshalCBOR 

func (t *CheckMinerParams) MarshalCBOR(w io.Writer) error

func (*CheckMinerParams) UnmarshalCBOR 

func (t *CheckMinerParams) UnmarshalCBOR(r io.Reader) error

type ComputeDataCommitmentParams 

type ComputeDataCommitmentParams struct {
	DealIDs    []uint64
	SectorSize uint64
}

func (*ComputeDataCommitmentParams) MarshalCBOR 

func (t *ComputeDataCommitmentParams) MarshalCBOR(w io.Writer) error

func (*ComputeDataCommitmentParams) UnmarshalCBOR 

func (t *ComputeDataCommitmentParams) UnmarshalCBOR(r io.Reader) error

type CreateStorageMinerParams 

type CreateStorageMinerParams struct {
	Owner      address.Address
	Worker     address.Address
	SectorSize uint64
	PeerID     peer.ID
}

func (*CreateStorageMinerParams) MarshalCBOR 

func (t *CreateStorageMinerParams) MarshalCBOR(w io.Writer) error

func (*CreateStorageMinerParams) UnmarshalCBOR 

func (t *CreateStorageMinerParams) UnmarshalCBOR(r io.Reader) error

type CronActor 

type CronActor struct{}

func (CronActor) EpochTick 

func (ca CronActor) EpochTick(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError)

func (CronActor) Exports 

func (ca CronActor) Exports() []interface{}

type CronActorState 

type CronActorState struct{}

func (*CronActorState) MarshalCBOR 

func (t *CronActorState) MarshalCBOR(w io.Writer) error

func (*CronActorState) UnmarshalCBOR 

func (t *CronActorState) UnmarshalCBOR(r io.Reader) error

type DeclareFaultsParams 

type DeclareFaultsParams struct {
	Faults types.BitField
}

func (*DeclareFaultsParams) MarshalCBOR 

func (t *DeclareFaultsParams) MarshalCBOR(w io.Writer) error

func (*DeclareFaultsParams) UnmarshalCBOR 

func (t *DeclareFaultsParams) UnmarshalCBOR(r io.Reader) error

type ExecParams 

type ExecParams struct {
	Code   cid.Cid
	Params []byte
}

func (*ExecParams) MarshalCBOR 

func (t *ExecParams) MarshalCBOR(w io.Writer) error

func (*ExecParams) UnmarshalCBOR 

func (t *ExecParams) UnmarshalCBOR(r io.Reader) error

type InitActor 

type InitActor struct{}

func (InitActor) Exec 

func (ia InitActor) Exec(act *types.Actor, vmctx types.VMContext, p *ExecParams) ([]byte, aerrors.ActorError)

func (InitActor) Exports 

func (ia InitActor) Exports() []interface{}

type InitActorState 

type InitActorState struct {
	AddressMap cid.Cid

	NextID uint64
}

func (*InitActorState) AddActor 

func (ias *InitActorState) AddActor(cst *hamt.CborIpldStore, addr address.Address) (address.Address, error)

func (*InitActorState) Lookup 

func (ias *InitActorState) Lookup(cst *hamt.CborIpldStore, addr address.Address) (address.Address, error)

func (*InitActorState) MarshalCBOR 

func (t *InitActorState) MarshalCBOR(w io.Writer) error

func (*InitActorState) UnmarshalCBOR 

func (t *InitActorState) UnmarshalCBOR(r io.Reader) error

type IsValidMinerParam 

type IsValidMinerParam struct {
	Addr address.Address
}

func (*IsValidMinerParam) MarshalCBOR 

func (t *IsValidMinerParam) MarshalCBOR(w io.Writer) error

func (*IsValidMinerParam) UnmarshalCBOR 

func (t *IsValidMinerParam) UnmarshalCBOR(r io.Reader) error

type LaneState 

type LaneState struct {
	Closed   bool
	Redeemed types.BigInt
	Nonce    uint64
}

func (*LaneState) MarshalCBOR 

func (t *LaneState) MarshalCBOR(w io.Writer) error

func (*LaneState) UnmarshalCBOR 

func (t *LaneState) UnmarshalCBOR(r io.Reader) error

type MTransaction 

type MTransaction struct {
	Created uint64 // NOT USED ??
	TxID    uint64

	To     address.Address
	Value  types.BigInt
	Method uint64
	Params []byte

	Approved []address.Address
	Complete bool
	Canceled bool
	RetCode  uint64
}

func (MTransaction) Active 

func (tx MTransaction) Active() ActorError

func (*MTransaction) MarshalCBOR 

func (t *MTransaction) MarshalCBOR(w io.Writer) error

func (*MTransaction) UnmarshalCBOR 

func (t *MTransaction) UnmarshalCBOR(r io.Reader) error

type MinerInfo 

type MinerInfo struct {
	// Account that owns this miner.
	// - Income and returned collateral are paid to this address.
	// - This address is also allowed to change the worker address for the miner.
	Owner address.Address

	// Worker account for this miner.
	// This will be the key that is used to sign blocks created by this miner, and
	// sign messages sent on behalf of this miner to commit sectors, submit PoSts, and
	// other day to day miner activities.
	Worker address.Address

	// Libp2p identity that should be used when connecting to this miner.
	PeerID peer.ID

	// Amount of space in each sector committed to the network by this miner.
	SectorSize uint64
}

func (*MinerInfo) MarshalCBOR 

func (t *MinerInfo) MarshalCBOR(w io.Writer) error

func (*MinerInfo) UnmarshalCBOR 

func (t *MinerInfo) UnmarshalCBOR(r io.Reader) error

type MinerSlashConsensusFault 

type MinerSlashConsensusFault struct {
	Slasher           address.Address
	AtHeight          uint64
	SlashedCollateral types.BigInt
}

func (*MinerSlashConsensusFault) MarshalCBOR 

func (t *MinerSlashConsensusFault) MarshalCBOR(w io.Writer) error

func (*MinerSlashConsensusFault) UnmarshalCBOR 

func (t *MinerSlashConsensusFault) UnmarshalCBOR(r io.Reader) error

type MultiSigActor 

type MultiSigActor struct{}

func (MultiSigActor) AddSigner 

func (msa MultiSigActor) AddSigner(act *types.Actor, vmctx types.VMContext,
	params *MultiSigAddSignerParam) ([]byte, ActorError)

func (MultiSigActor) Approve 

func (msa MultiSigActor) Approve(act *types.Actor, vmctx types.VMContext,
	params *MultiSigTxID) ([]byte, ActorError)

func (MultiSigActor) Cancel 

func (msa MultiSigActor) Cancel(act *types.Actor, vmctx types.VMContext,
	params *MultiSigTxID) ([]byte, ActorError)

func (MultiSigActor) ChangeRequirement 

func (msa MultiSigActor) ChangeRequirement(act *types.Actor, vmctx types.VMContext,
	params *MultiSigChangeReqParams) ([]byte, ActorError)

func (MultiSigActor) Exports 

func (msa MultiSigActor) Exports() []interface{}

func (MultiSigActor) MultiSigConstructor 

func (MultiSigActor) MultiSigConstructor(act *types.Actor, vmctx types.VMContext,
	params *MultiSigConstructorParams) ([]byte, ActorError)

func (MultiSigActor) Propose 

func (msa MultiSigActor) Propose(act *types.Actor, vmctx types.VMContext,
	params *MultiSigProposeParams) ([]byte, ActorError)

func (MultiSigActor) RemoveSigner 

func (msa MultiSigActor) RemoveSigner(act *types.Actor, vmctx types.VMContext,
	params *MultiSigRemoveSignerParam) ([]byte, ActorError)

func (MultiSigActor) SwapSigner 

func (msa MultiSigActor) SwapSigner(act *types.Actor, vmctx types.VMContext,
	params *MultiSigSwapSignerParams) ([]byte, ActorError)

type MultiSigActorState 

type MultiSigActorState struct {
	Signers  []address.Address
	Required uint64
	NextTxID uint64

	InitialBalance types.BigInt
	StartingBlock  uint64
	UnlockDuration uint64

	//TODO: make this map/sharray/whatever
	Transactions []MTransaction
}

func (*MultiSigActorState) MarshalCBOR 

func (t *MultiSigActorState) MarshalCBOR(w io.Writer) error

func (*MultiSigActorState) UnmarshalCBOR 

func (t *MultiSigActorState) UnmarshalCBOR(r io.Reader) error

type MultiSigAddSignerParam 

type MultiSigAddSignerParam struct {
	Signer   address.Address
	Increase bool
}

func (*MultiSigAddSignerParam) MarshalCBOR 

func (t *MultiSigAddSignerParam) MarshalCBOR(w io.Writer) error

func (*MultiSigAddSignerParam) UnmarshalCBOR 

func (t *MultiSigAddSignerParam) UnmarshalCBOR(r io.Reader) error

type MultiSigChangeReqParams 

type MultiSigChangeReqParams struct {
	Req uint64
}

func (*MultiSigChangeReqParams) MarshalCBOR 

func (t *MultiSigChangeReqParams) MarshalCBOR(w io.Writer) error

func (*MultiSigChangeReqParams) UnmarshalCBOR 

func (t *MultiSigChangeReqParams) UnmarshalCBOR(r io.Reader) error

type MultiSigConstructorParams 

type MultiSigConstructorParams struct {
	Signers        []address.Address
	Required       uint64
	UnlockDuration uint64
}

func (*MultiSigConstructorParams) MarshalCBOR 

func (t *MultiSigConstructorParams) MarshalCBOR(w io.Writer) error

func (*MultiSigConstructorParams) UnmarshalCBOR 

func (t *MultiSigConstructorParams) UnmarshalCBOR(r io.Reader) error

type MultiSigProposeParams 

type MultiSigProposeParams struct {
	To     address.Address
	Value  types.BigInt
	Method uint64
	Params []byte
}

func (*MultiSigProposeParams) MarshalCBOR 

func (t *MultiSigProposeParams) MarshalCBOR(w io.Writer) error

func (*MultiSigProposeParams) UnmarshalCBOR 

func (t *MultiSigProposeParams) UnmarshalCBOR(r io.Reader) error

type MultiSigRemoveSignerParam 

type MultiSigRemoveSignerParam struct {
	Signer   address.Address
	Decrease bool
}

func (*MultiSigRemoveSignerParam) MarshalCBOR 

func (t *MultiSigRemoveSignerParam) MarshalCBOR(w io.Writer) error

func (*MultiSigRemoveSignerParam) UnmarshalCBOR 

func (t *MultiSigRemoveSignerParam) UnmarshalCBOR(r io.Reader) error

type MultiSigSwapSignerParams 

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

func (*MultiSigSwapSignerParams) MarshalCBOR 

func (t *MultiSigSwapSignerParams) MarshalCBOR(w io.Writer) error

func (*MultiSigSwapSignerParams) UnmarshalCBOR 

func (t *MultiSigSwapSignerParams) UnmarshalCBOR(r io.Reader) error

type MultiSigTxID 

type MultiSigTxID struct {
	TxID uint64
}

func (*MultiSigTxID) MarshalCBOR 

func (t *MultiSigTxID) MarshalCBOR(w io.Writer) error

func (*MultiSigTxID) UnmarshalCBOR 

func (t *MultiSigTxID) UnmarshalCBOR(r io.Reader) error

type OnChainDeal 

type OnChainDeal struct {
	PieceRef  []byte // cid bytes // TODO: spec says to use cid.Cid, probably not a good idea
	PieceSize uint64

	Client   address.Address
	Provider address.Address

	ProposalExpiration uint64
	Duration           uint64 // TODO: spec

	StoragePricePerEpoch types.BigInt
	StorageCollateral    types.BigInt
	ActivationEpoch      uint64 // 0 = inactive
}

func (*OnChainDeal) MarshalCBOR 

func (t *OnChainDeal) MarshalCBOR(w io.Writer) error

func (*OnChainDeal) UnmarshalCBOR 

func (t *OnChainDeal) UnmarshalCBOR(r io.Reader) error

type PCAConstructorParams 

type PCAConstructorParams struct {
	To address.Address
}

func (*PCAConstructorParams) MarshalCBOR 

func (t *PCAConstructorParams) MarshalCBOR(w io.Writer) error

func (*PCAConstructorParams) UnmarshalCBOR 

func (t *PCAConstructorParams) UnmarshalCBOR(r io.Reader) error

type PCAUpdateChannelStateParams 

type PCAUpdateChannelStateParams struct {
	Sv     types.SignedVoucher
	Secret []byte
	Proof  []byte
}

func (*PCAUpdateChannelStateParams) MarshalCBOR 

func (t *PCAUpdateChannelStateParams) MarshalCBOR(w io.Writer) error

func (*PCAUpdateChannelStateParams) UnmarshalCBOR 

func (t *PCAUpdateChannelStateParams) UnmarshalCBOR(r io.Reader) error

type PaymentChannelActor 

type PaymentChannelActor struct{}

func (PaymentChannelActor) Close 

func (pca PaymentChannelActor) Close(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, aerrors.ActorError)

func (PaymentChannelActor) Collect 

func (pca PaymentChannelActor) Collect(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, aerrors.ActorError)

func (PaymentChannelActor) Constructor 

func (pca PaymentChannelActor) Constructor(act *types.Actor, vmctx types.VMContext, params *PCAConstructorParams) ([]byte, ActorError)

func (PaymentChannelActor) Exports 

func (pca PaymentChannelActor) Exports() []interface{}

func (PaymentChannelActor) GetOwner 

func (pca PaymentChannelActor) GetOwner(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, aerrors.ActorError)

func (PaymentChannelActor) GetToSend 

func (pca PaymentChannelActor) GetToSend(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, aerrors.ActorError)

func (PaymentChannelActor) UpdateChannelState 

func (pca PaymentChannelActor) UpdateChannelState(act *types.Actor, vmctx types.VMContext, params *PCAUpdateChannelStateParams) ([]byte, ActorError)

type PaymentChannelActorState 

type PaymentChannelActorState struct {
	From address.Address
	To   address.Address

	ToSend types.BigInt

	ClosingAt      uint64
	MinCloseHeight uint64

	// TODO: needs to be map[uint64]*laneState
	// waiting on refmt#35 to be fixed
	LaneStates map[string]*LaneState
}

func (*PaymentChannelActorState) MarshalCBOR 

func (t *PaymentChannelActorState) MarshalCBOR(w io.Writer) error

func (*PaymentChannelActorState) UnmarshalCBOR 

func (t *PaymentChannelActorState) UnmarshalCBOR(r io.Reader) error

type PaymentInfo 

type PaymentInfo struct {
	PayChActor     address.Address
	Payer          address.Address
	ChannelMessage *cid.Cid

	Vouchers []*types.SignedVoucher
}

func (*PaymentInfo) MarshalCBOR 

func (t *PaymentInfo) MarshalCBOR(w io.Writer) error

func (*PaymentInfo) UnmarshalCBOR 

func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error

type PaymentVerifyParams 

type PaymentVerifyParams struct {
	Extra []byte
	Proof []byte
}

func (*PaymentVerifyParams) MarshalCBOR 

func (t *PaymentVerifyParams) MarshalCBOR(w io.Writer) error

func (*PaymentVerifyParams) UnmarshalCBOR 

func (t *PaymentVerifyParams) UnmarshalCBOR(r io.Reader) error

type PledgeCollateralParams 

type PledgeCollateralParams struct {
	Size types.BigInt
}

func (*PledgeCollateralParams) MarshalCBOR 

func (t *PledgeCollateralParams) MarshalCBOR(w io.Writer) error

func (*PledgeCollateralParams) UnmarshalCBOR 

func (t *PledgeCollateralParams) UnmarshalCBOR(r io.Reader) error

type PowerLookupParams 

type PowerLookupParams struct {
	Miner address.Address
}

func (*PowerLookupParams) MarshalCBOR 

func (t *PowerLookupParams) MarshalCBOR(w io.Writer) error

func (*PowerLookupParams) UnmarshalCBOR 

func (t *PowerLookupParams) UnmarshalCBOR(r io.Reader) error

type PreCommittedSector 

type PreCommittedSector struct {
	Info          SectorPreCommitInfo
	ReceivedEpoch uint64
}

func (*PreCommittedSector) MarshalCBOR 

func (t *PreCommittedSector) MarshalCBOR(w io.Writer) error

func (*PreCommittedSector) UnmarshalCBOR 

func (t *PreCommittedSector) UnmarshalCBOR(r io.Reader) error

type ProcessStorageDealsPaymentParams 

type ProcessStorageDealsPaymentParams struct {
	DealIDs []uint64
}

func (*ProcessStorageDealsPaymentParams) MarshalCBOR 

func (t *ProcessStorageDealsPaymentParams) MarshalCBOR(w io.Writer) error

func (*ProcessStorageDealsPaymentParams) UnmarshalCBOR 

func (t *ProcessStorageDealsPaymentParams) UnmarshalCBOR(r io.Reader) error

type PublishStorageDealResponse 

type PublishStorageDealResponse struct {
	DealIDs []uint64
}

func (*PublishStorageDealResponse) MarshalCBOR 

func (t *PublishStorageDealResponse) MarshalCBOR(w io.Writer) error

func (*PublishStorageDealResponse) UnmarshalCBOR 

func (t *PublishStorageDealResponse) UnmarshalCBOR(r io.Reader) error

type PublishStorageDealsParams 

type PublishStorageDealsParams struct {
	Deals []StorageDealProposal
}

func (*PublishStorageDealsParams) MarshalCBOR 

func (t *PublishStorageDealsParams) MarshalCBOR(w io.Writer) error

func (*PublishStorageDealsParams) UnmarshalCBOR 

func (t *PublishStorageDealsParams) UnmarshalCBOR(r io.Reader) error

type SectorPreCommitInfo 

type SectorPreCommitInfo struct {
	SectorNumber uint64

	CommR     []byte // TODO: Spec says CID
	SealEpoch uint64
	DealIDs   []uint64
}

func (*SectorPreCommitInfo) MarshalCBOR 

func (t *SectorPreCommitInfo) MarshalCBOR(w io.Writer) error

func (*SectorPreCommitInfo) UnmarshalCBOR 

func (t *SectorPreCommitInfo) UnmarshalCBOR(r io.Reader) error

type SectorProveCommitInfo 

type SectorProveCommitInfo struct {
	Proof    []byte
	SectorID uint64
	DealIDs  []uint64
}

func (*SectorProveCommitInfo) MarshalCBOR 

func (t *SectorProveCommitInfo) MarshalCBOR(w io.Writer) error

func (*SectorProveCommitInfo) UnmarshalCBOR 

func (t *SectorProveCommitInfo) UnmarshalCBOR(r io.Reader) error

type SerializationMode 

type SerializationMode = uint64

TODO: Drop in favour of car storage

type SignFunc 

type SignFunc = func(context.Context, []byte) (*types.Signature, error)

type StorageDealProposal 

type StorageDealProposal struct {
	PieceRef  []byte // cid bytes // TODO: spec says to use cid.Cid, probably not a good idea
	PieceSize uint64

	Client   address.Address
	Provider address.Address

	ProposalExpiration uint64
	Duration           uint64 // TODO: spec

	StoragePricePerEpoch types.BigInt
	StorageCollateral    types.BigInt

	ProposerSignature *types.Signature
}

func (*StorageDealProposal) Cid 

func (sdp *StorageDealProposal) Cid() (cid.Cid, error)

func (*StorageDealProposal) MarshalCBOR 

func (t *StorageDealProposal) MarshalCBOR(w io.Writer) error

func (*StorageDealProposal) Sign 

func (sdp *StorageDealProposal) Sign(ctx context.Context, sign SignFunc) error

func (*StorageDealProposal) TotalStoragePrice 

func (sdp *StorageDealProposal) TotalStoragePrice() types.BigInt

func (*StorageDealProposal) UnmarshalCBOR 

func (t *StorageDealProposal) UnmarshalCBOR(r io.Reader) error

func (*StorageDealProposal) Verify 

func (sdp *StorageDealProposal) Verify(worker address.Address) error

type StorageMarketActor 

type StorageMarketActor struct{}

func (StorageMarketActor) ActivateStorageDeals 

func (sma StorageMarketActor) ActivateStorageDeals(act *types.Actor, vmctx types.VMContext, params *ActivateStorageDealsParams) ([]byte, ActorError)

func (StorageMarketActor) AddBalance 

func (sma StorageMarketActor) AddBalance(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError)

func (StorageMarketActor) ComputeDataCommitment 

func (sma StorageMarketActor) ComputeDataCommitment(act *types.Actor, vmctx types.VMContext, params *ComputeDataCommitmentParams) ([]byte, ActorError)

func (StorageMarketActor) Exports 

func (sma StorageMarketActor) Exports() []interface{}

func (StorageMarketActor) ProcessStorageDealsPayment 

func (sma StorageMarketActor) ProcessStorageDealsPayment(act *types.Actor, vmctx types.VMContext, params *ProcessStorageDealsPaymentParams) ([]byte, ActorError)

func (StorageMarketActor) PublishStorageDeals 

func (sma StorageMarketActor) PublishStorageDeals(act *types.Actor, vmctx types.VMContext, params *PublishStorageDealsParams) ([]byte, ActorError)

func (StorageMarketActor) WithdrawBalance 

func (sma StorageMarketActor) WithdrawBalance(act *types.Actor, vmctx types.VMContext, params *WithdrawBalanceParams) ([]byte, ActorError)

type StorageMarketState 

type StorageMarketState struct {
	Balances cid.Cid // hamt<addr, StorageParticipantBalance>
	Deals    cid.Cid // amt<StorageDeal>

	NextDealID uint64 // TODO: spec
}

func (*StorageMarketState) MarshalCBOR 

func (t *StorageMarketState) MarshalCBOR(w io.Writer) error

func (*StorageMarketState) UnmarshalCBOR 

func (t *StorageMarketState) UnmarshalCBOR(r io.Reader) error

type StorageMinerActor 

type StorageMinerActor struct{}

func (StorageMinerActor) CheckMiner 

func (sma StorageMinerActor) CheckMiner(act *types.Actor, vmctx types.VMContext, params *CheckMinerParams) ([]byte, ActorError)

TODO: better name

func (StorageMinerActor) DeclareFaults 

func (sma StorageMinerActor) DeclareFaults(act *types.Actor, vmctx types.VMContext, params *DeclareFaultsParams) ([]byte, ActorError)

func (StorageMinerActor) Exports 

func (sma StorageMinerActor) Exports() []interface{}

func (StorageMinerActor) GetOwner 

func (sma StorageMinerActor) GetOwner(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError)

func (StorageMinerActor) GetPeerID 

func (sma StorageMinerActor) GetPeerID(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError)

func (StorageMinerActor) GetPower 

func (sma StorageMinerActor) GetPower(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError)

func (StorageMinerActor) GetSectorSize 

func (sma StorageMinerActor) GetSectorSize(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError)

func (StorageMinerActor) GetWorkerAddr 

func (sma StorageMinerActor) GetWorkerAddr(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError)

func (StorageMinerActor) IsSlashed 

func (sma StorageMinerActor) IsSlashed(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError)

func (StorageMinerActor) PreCommitSector 

func (sma StorageMinerActor) PreCommitSector(act *types.Actor, vmctx types.VMContext, params *SectorPreCommitInfo) ([]byte, ActorError)

func (StorageMinerActor) ProveCommitSector 

func (sma StorageMinerActor) ProveCommitSector(act *types.Actor, vmctx types.VMContext, params *SectorProveCommitInfo) ([]byte, ActorError)

func (StorageMinerActor) SlashConsensusFault 

func (sma StorageMinerActor) SlashConsensusFault(act *types.Actor, vmctx types.VMContext, params *MinerSlashConsensusFault) ([]byte, ActorError)

func (StorageMinerActor) StorageMinerConstructor 

func (sma StorageMinerActor) StorageMinerConstructor(act *types.Actor, vmctx types.VMContext, params *StorageMinerConstructorParams) ([]byte, ActorError)

func (StorageMinerActor) SubmitElectionPoSt 

func (sma StorageMinerActor) SubmitElectionPoSt(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, aerrors.ActorError)

func (StorageMinerActor) SubmitFallbackPoSt 

func (sma StorageMinerActor) SubmitFallbackPoSt(act *types.Actor, vmctx types.VMContext, params *SubmitFallbackPoStParams) ([]byte, ActorError)

func (StorageMinerActor) UpdatePeerID 

func (sma StorageMinerActor) UpdatePeerID(act *types.Actor, vmctx types.VMContext, params *UpdatePeerIDParams) ([]byte, ActorError)

type StorageMinerActorState 

type StorageMinerActorState struct {
	// PreCommittedSectors is the set of sectors that have been committed to but not
	// yet had their proofs submitted
	PreCommittedSectors map[string]*PreCommittedSector

	// All sectors this miner has committed.
	//
	// AMT[sectorID]ffi.PublicSectorInfo
	Sectors cid.Cid

	// Sectors this miner is currently mining. It is only updated
	// when a PoSt is submitted (not as each new sector commitment is added).
	//
	// AMT[sectorID]ffi.PublicSectorInfo
	ProvingSet cid.Cid

	// Contains mostly static info about this miner
	Info cid.Cid

	// Faulty sectors reported since last SubmitPost
	FaultSet types.BitField

	LastFaultSubmission uint64

	// Amount of power this miner has.
	Power types.BigInt

	// Active is set to true after the miner has submitted their first PoSt
	Active bool

	// The height at which this miner was slashed at.
	SlashedAt uint64

	ElectionPeriodStart uint64
}

func (*StorageMinerActorState) MarshalCBOR 

func (t *StorageMinerActorState) MarshalCBOR(w io.Writer) error

func (*StorageMinerActorState) UnmarshalCBOR 

func (t *StorageMinerActorState) UnmarshalCBOR(r io.Reader) error

type StorageMinerConstructorParams 

type StorageMinerConstructorParams struct {
	Owner      address.Address
	Worker     address.Address
	SectorSize uint64
	PeerID     peer.ID
}

func (*StorageMinerConstructorParams) MarshalCBOR 

func (t *StorageMinerConstructorParams) MarshalCBOR(w io.Writer) error

func (*StorageMinerConstructorParams) UnmarshalCBOR 

func (t *StorageMinerConstructorParams) UnmarshalCBOR(r io.Reader) error

type StorageParticipantBalance 

type StorageParticipantBalance struct {
	Locked    types.BigInt
	Available types.BigInt
}

func (*StorageParticipantBalance) MarshalCBOR 

func (t *StorageParticipantBalance) MarshalCBOR(w io.Writer) error

func (*StorageParticipantBalance) UnmarshalCBOR 

func (t *StorageParticipantBalance) UnmarshalCBOR(r io.Reader) error

type StoragePowerActor 

type StoragePowerActor struct{}

func (StoragePowerActor) ArbitrateConsensusFault 

func (spa StoragePowerActor) ArbitrateConsensusFault(act *types.Actor, vmctx types.VMContext, params *ArbitrateConsensusFaultParams) ([]byte, ActorError)

func (StoragePowerActor) CheckProofSubmissions 

func (spa StoragePowerActor) CheckProofSubmissions(act *types.Actor, vmctx types.VMContext, param *struct{}) ([]byte, ActorError)

func (StoragePowerActor) CreateStorageMiner 

func (spa StoragePowerActor) CreateStorageMiner(act *types.Actor, vmctx types.VMContext, params *CreateStorageMinerParams) ([]byte, ActorError)

func (StoragePowerActor) Exports 

func (spa StoragePowerActor) Exports() []interface{}

func (StoragePowerActor) GetTotalStorage 

func (spa StoragePowerActor) GetTotalStorage(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError)

func (StoragePowerActor) IsValidMiner 

func (spa StoragePowerActor) IsValidMiner(act *types.Actor, vmctx types.VMContext, param *IsValidMinerParam) ([]byte, ActorError)

func (StoragePowerActor) PledgeCollateralForSize 

func (spa StoragePowerActor) PledgeCollateralForSize(act *types.Actor, vmctx types.VMContext, param *PledgeCollateralParams) ([]byte, ActorError)

func (StoragePowerActor) PowerLookup 

func (spa StoragePowerActor) PowerLookup(act *types.Actor, vmctx types.VMContext, params *PowerLookupParams) ([]byte, ActorError)

func (StoragePowerActor) UpdateStorage 

func (spa StoragePowerActor) UpdateStorage(act *types.Actor, vmctx types.VMContext, params *UpdateStorageParams) ([]byte, ActorError)

type StoragePowerState 

type StoragePowerState struct {
	Miners         cid.Cid
	ProvingBuckets cid.Cid // amt[ProvingPeriodBucket]hamt[minerAddress]struct{}
	MinerCount     uint64
	LastMinerCheck uint64

	TotalStorage types.BigInt
}

func (*StoragePowerState) MarshalCBOR 

func (t *StoragePowerState) MarshalCBOR(w io.Writer) error

func (*StoragePowerState) UnmarshalCBOR 

func (t *StoragePowerState) UnmarshalCBOR(r io.Reader) error

type SubmitFallbackPoStParams 

type SubmitFallbackPoStParams struct {
	Proof      []byte
	Candidates []types.EPostTicket
}

func (*SubmitFallbackPoStParams) MarshalCBOR 

func (t *SubmitFallbackPoStParams) MarshalCBOR(w io.Writer) error

func (*SubmitFallbackPoStParams) UnmarshalCBOR 

func (t *SubmitFallbackPoStParams) UnmarshalCBOR(r io.Reader) error

type UpdatePeerIDParams 

type UpdatePeerIDParams struct {
	PeerID peer.ID
}

func (*UpdatePeerIDParams) MarshalCBOR 

func (t *UpdatePeerIDParams) MarshalCBOR(w io.Writer) error

func (*UpdatePeerIDParams) UnmarshalCBOR 

func (t *UpdatePeerIDParams) UnmarshalCBOR(r io.Reader) error

type UpdateStorageParams 

type UpdateStorageParams struct {
	Delta                 types.BigInt
	NextSlashDeadline     uint64
	PreviousSlashDeadline uint64
}

func (*UpdateStorageParams) MarshalCBOR 

func (t *UpdateStorageParams) MarshalCBOR(w io.Writer) error

func (*UpdateStorageParams) UnmarshalCBOR 

func (t *UpdateStorageParams) UnmarshalCBOR(r io.Reader) error

type WithdrawBalanceParams 

type WithdrawBalanceParams struct {
	Balance types.BigInt
}

func (*WithdrawBalanceParams) MarshalCBOR 

func (t *WithdrawBalanceParams) MarshalCBOR(w io.Writer) error

func (*WithdrawBalanceParams) UnmarshalCBOR 

func (t *WithdrawBalanceParams) UnmarshalCBOR(r io.Reader) error

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.