agent

type Agent interface {
	Tick(v SimState) ([]message, error)
}

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

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

type DealClientAgent struct {
	DealCount int
	// contains filtered or unexported fields
}

type DealClientConfig struct {
	DealRate         float64         // deals made per epoch
	MinPieceSize     uint64          // minimum piece size (actual piece size be rounded up to power of 2)
	MaxPieceSize     uint64          // maximum piece size
	MinStoragePrice  abi.TokenAmount // minimum price per epoch a client will pay for storage (may be zero)
	MaxStoragePrice  abi.TokenAmount // maximum price per epoch a client will pay for storage
	MinMarketBalance abi.TokenAmount // balance below which client will top up funds in market actor
	MaxMarketBalance abi.TokenAmount // balance to which client will top up funds in market actor
}

type DealProvider interface {
	Address() address.Address
	DealRange(currentEpoch abi.ChainEpoch) (start abi.ChainEpoch, end abi.ChainEpoch)
	CreateDeal(proposal market.ClientDealProposal)
	AvailableCollateral() abi.TokenAmount
}

type MinerAgent struct {
	Config        MinerAgentConfig // parameters used to define miner prior to creation
	Owner         address.Address
	Worker        address.Address
	IDAddress     address.Address
	RobustAddress address.Address

	// Stats
	UpgradedSectors uint64
	// contains filtered or unexported fields
}

type MinerAgentConfig struct {
	PrecommitRate    float64                 // average number of PreCommits per epoch
	ProofType        abi.RegisteredSealProof // seal proof type for this miner
	StartingBalance  abi.TokenAmount         // initial actor balance for miner actor
	FaultRate        float64                 // rate at which committed sectors go faulty (faults per committed sector per epoch)
	RecoveryRate     float64                 // rate at which faults are recovered (recoveries per fault per epoch)
	MinMarketBalance abi.TokenAmount         // balance below which miner will top up funds in market actor
	MaxMarketBalance abi.TokenAmount         // balance to which miner will top up funds in market actor
	UpgradeSectors   bool                    // if true, miner will replace sectors without deals with sectors that do
}

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

type MinerStateV4 struct {
	Root cid.Cid
	Ctx  context.Context
	// contains filtered or unexported fields
}

type MinerStateV5 struct {
	Root cid.Cid

	Ctx context.Context
	// contains filtered or unexported fields
}

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

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

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

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

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

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

type Sim struct {
	Config        SimConfig
	Agents        []Agent
	DealProviders []DealProvider
	WinCount      uint64
	MessageCount  uint64
	// contains filtered or unexported fields
}

type SimConfig struct {
	AccountCount           int
	AccountInitialBalance  abi.TokenAmount
	Seed                   int64
	CreateMinerProbability float32
	CheckpointEpochs       uint64
}

type SimDeadlineState interface {
	LoadPartition(adt.Store, uint64) (SimPartitionState, error)
}

type SimMinerState interface {
	HasSectorNo(adt.Store, abi.SectorNumber) (bool, error)
	FindSector(adt.Store, abi.SectorNumber) (uint64, uint64, error)
	ProvingPeriodStart(adt.Store) (abi.ChainEpoch, error)
	LoadSectorInfo(adt.Store, uint64) (SimSectorInfo, error)
	DeadlineInfo(adt.Store, abi.ChainEpoch) (*dline.Info, error)
	FeeDebt(adt.Store) (abi.TokenAmount, error)
	LoadDeadlineState(adt.Store, uint64) (SimDeadlineState, error)
}

type SimPartitionState interface {
	Terminated() bitfield.BitField
}

type SimSectorInfo interface {
	Expiration() abi.ChainEpoch
}

type SimState interface {
	GetEpoch() abi.ChainEpoch
	GetState(addr address.Address, out cbor.Unmarshaler) error
	Store() adt.Store
	AddAgent(a Agent)
	AddDealProvider(d DealProvider)
	NetworkCirculatingSupply() abi.TokenAmount
	MinerState(addr address.Address) (SimMinerState, error)
	CreateMinerParams(worker, owner address.Address, sealProof abi.RegisteredSealProof) (*power.CreateMinerParams, error)

	// randomly select an agent capable of making deals.
	// Returns nil if no providers exist.
	ChooseDealProvider() DealProvider
}

type SimVM interface {
	ApplyMessage(from, to address.Address, value abi.TokenAmount, method abi.MethodNum, params interface{}, info string) (vm.MessageResult, error)
	GetCirculatingSupply() abi.TokenAmount
	GetLogs() []string
	GetState(addr address.Address, out cbor.Unmarshaler) error
	SetStatsSource(stats vm2.StatsSource)
	GetCallStats() map[vm2.MethodKey]*vm2.CallStats
	GetEpoch() abi.ChainEpoch
	Store() adt2.Store
	GetActor(addr address.Address) (*states.Actor, bool, error)
	SetCirculatingSupply(supply big.Int)
	GetActorImpls() map[cid.Cid]rt.VMActor
	StateRoot() cid.Cid
	GetStatsSource() vm2.StatsSource
	GetTotalActorBalance() (abi.TokenAmount, error)
}

type VMFactoryFunc func(context.Context, vm2.ActorImplLookup, adt.Store, cid.Cid, abi.ChainEpoch) (SimVM, error)