diff --git a/chain/actors/policy/policy.go b/chain/actors/policy/policy.go index c06c85d38..0f1ed266c 100644 --- a/chain/actors/policy/policy.go +++ b/chain/actors/policy/policy.go @@ -4,6 +4,7 @@ import ( "sort" "github.com/filecoin-project/go-state-types/big" + "golang.org/x/xerrors" "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/network" @@ -168,31 +169,26 @@ func SetMinVerifiedDealSize(size abi.StoragePower) { } -func GetMaxProveCommitDuration(ver actors.Version, t abi.RegisteredSealProof) abi.ChainEpoch { +func GetMaxProveCommitDuration(ver actors.Version, t abi.RegisteredSealProof) (abi.ChainEpoch, error) { switch ver { case actors.Version0: - - return miner0.MaxSealDuration[t] + return miner0.MaxSealDuration[t], nil case actors.Version2: - - return miner2.MaxProveCommitDuration[t] + return miner2.MaxProveCommitDuration[t], nil case actors.Version3: - - return miner3.MaxProveCommitDuration[t] + return miner3.MaxProveCommitDuration[t], nil case actors.Version4: - - return miner4.MaxProveCommitDuration[t] + return miner4.MaxProveCommitDuration[t], nil case actors.Version5: - - return miner5.MaxProveCommitDuration[t] + return miner5.MaxProveCommitDuration[t], nil default: - panic("unsupported actors version") + return 0, xerrors.Errorf("unsupported actors version") } } @@ -227,31 +223,35 @@ func DealProviderCollateralBounds( size abi.PaddedPieceSize, verified bool, rawBytePower, qaPower, baselinePower abi.StoragePower, circulatingFil abi.TokenAmount, nwVer network.Version, -) (min, max abi.TokenAmount) { - switch actors.VersionForNetwork(nwVer) { +) (min, max abi.TokenAmount, err error) { + v, err := actors.VersionForNetwork(nwVer) + if err != nil { + return big.Zero(), big.Zero(), err + } + switch v { case actors.Version0: - - return market0.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil, nwVer) + min, max := market0.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil, nwVer) + return min, max, nil case actors.Version2: - - return market2.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) + min, max := market2.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) + return min, max, nil case actors.Version3: - - return market3.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) + min, max := market3.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) + return min, max, nil case actors.Version4: - - return market4.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) + min, max := market4.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) + return min, max, nil case actors.Version5: - - return market5.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) + min, max := market5.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) + return min, max, nil default: - panic("unsupported actors version") + return big.Zero(), big.Zero(), xerrors.Errorf("unsupported actors version") } } @@ -310,8 +310,11 @@ func GetMaxPoStPartitions(nv network.Version, p abi.RegisteredPoStProof) (int, e if err != nil { return 0, err } - maxSectors := uint64(GetAddressedSectorsMax(nv)) - return int(maxSectors / sectorsPerPart), nil + maxSectors, err := GetAddressedSectorsMax(nv) + if err != nil { + return 0, err + } + return int(uint64(maxSectors) / sectorsPerPart), nil } func GetDefaultSectorSize() abi.SectorSize { @@ -345,82 +348,94 @@ func GetSectorMaxLifetime(proof abi.RegisteredSealProof, nwVer network.Version) return builtin5.SealProofPoliciesV11[proof].SectorMaxLifetime } -func GetAddressedSectorsMax(nwVer network.Version) int { - switch actors.VersionForNetwork(nwVer) { +func GetAddressedSectorsMax(nwVer network.Version) (int, error) { + v, err := actors.VersionForNetwork(nwVer) + if err != nil { + return 0, err + } + switch v { case actors.Version0: - return miner0.AddressedSectorsMax + return miner0.AddressedSectorsMax, nil case actors.Version2: - return miner2.AddressedSectorsMax + return miner2.AddressedSectorsMax, nil case actors.Version3: - return miner3.AddressedSectorsMax + return miner3.AddressedSectorsMax, nil case actors.Version4: - return miner4.AddressedSectorsMax + return miner4.AddressedSectorsMax, nil case actors.Version5: - return miner5.AddressedSectorsMax + return miner5.AddressedSectorsMax, nil + + default: + return 0, xerrors.Errorf("unsupported network version") + } +} + +func GetDeclarationsMax(nwVer network.Version) (int, error) { + v, err := actors.VersionForNetwork(nwVer) + if err != nil { + return 0, err + } + switch v { + + case actors.Version0: + + // TODO: Should we instead error here since the concept doesn't exist yet? + return miner0.AddressedPartitionsMax, nil + + case actors.Version2: + + return miner2.DeclarationsMax, nil + + case actors.Version3: + + return miner3.DeclarationsMax, nil + + case actors.Version4: + + return miner4.DeclarationsMax, nil + + case actors.Version5: + + return miner5.DeclarationsMax, nil default: panic("unsupported network version") } } -func GetDeclarationsMax(nwVer network.Version) int { - switch actors.VersionForNetwork(nwVer) { +func AggregateNetworkFee(nwVer network.Version, aggregateSize int, baseFee abi.TokenAmount) (abi.TokenAmount, error) { + v, err := actors.VersionForNetwork(nwVer) + if err != nil { + return big.Zero(), err + } + switch v { case actors.Version0: - // TODO: Should we instead panic here since the concept doesn't exist yet? - return miner0.AddressedPartitionsMax + return big.Zero(), nil case actors.Version2: - return miner2.DeclarationsMax + return big.Zero(), nil case actors.Version3: - return miner3.DeclarationsMax + return big.Zero(), nil case actors.Version4: - return miner4.DeclarationsMax + return big.Zero(), nil case actors.Version5: - return miner5.DeclarationsMax + return miner5.AggregateNetworkFee(aggregateSize, baseFee), nil default: - panic("unsupported network version") - } -} - -func AggregateNetworkFee(nwVer network.Version, aggregateSize int, baseFee abi.TokenAmount) abi.TokenAmount { - switch actors.VersionForNetwork(nwVer) { - - case actors.Version0: - - return big.Zero() - - case actors.Version2: - - return big.Zero() - - case actors.Version3: - - return big.Zero() - - case actors.Version4: - - return big.Zero() - - case actors.Version5: - - return miner5.AggregateNetworkFee(aggregateSize, baseFee) - - default: - panic("unsupported network version") + return big.Zero(), xerrors.Errorf("unsupported network version") } } diff --git a/chain/gen/genesis/genesis.go b/chain/gen/genesis/genesis.go index 6dec3fea6..a94442d65 100644 --- a/chain/gen/genesis/genesis.go +++ b/chain/gen/genesis/genesis.go @@ -149,7 +149,10 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge return nil, nil, xerrors.Errorf("making new state tree: %w", err) } - av := actors.VersionForNetwork(template.NetworkVersion) + av, err := actors.VersionForNetwork(template.NetworkVersion) + if err != nil { + return nil, nil, xerrors.Errorf("getting network version: %w", err) + } // Create system actor diff --git a/chain/gen/genesis/miners.go b/chain/gen/genesis/miners.go index e6f17d677..38d3db518 100644 --- a/chain/gen/genesis/miners.go +++ b/chain/gen/genesis/miners.go @@ -81,7 +81,10 @@ func mkFakedSigSyscalls(base vm.SyscallBuilder) vm.SyscallBuilder { func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid, miners []genesis.Miner, nv network.Version) (cid.Cid, error) { cst := cbor.NewCborStore(cs.StateBlockstore()) - av := actors.VersionForNetwork(nv) + av, err := actors.VersionForNetwork(nv) + if err != nil { + return cid.Undef, xerrors.Errorf("failed to get network version: %w", err) + } csc := func(context.Context, abi.ChainEpoch, *state.StateTree) (abi.TokenAmount, error) { return big.Zero(), nil @@ -291,7 +294,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid return cid.Undef, xerrors.Errorf("setting power state: %w", err) } - rewact, err := SetupRewardActor(ctx, cs.StateBlockstore(), big.Zero(), actors.VersionForNetwork(nv)) + rewact, err := SetupRewardActor(ctx, cs.StateBlockstore(), big.Zero(), av) if err != nil { return cid.Undef, xerrors.Errorf("setup reward actor: %w", err) } diff --git a/chain/vm/invoker.go b/chain/vm/invoker.go index e4b154031..be35d93c8 100644 --- a/chain/vm/invoker.go +++ b/chain/vm/invoker.go @@ -39,7 +39,10 @@ type ActorPredicate func(vmr.Runtime, rtt.VMActor) error func ActorsVersionPredicate(ver actors.Version) ActorPredicate { return func(rt vmr.Runtime, v rtt.VMActor) error { - aver := actors.VersionForNetwork(rt.NetworkVersion()) + aver, err := actors.VersionForNetwork(rt.NetworkVersion()) + if err != nil { + return xerrors.Errorf("unsupported network version: %w", err) + } if aver != ver { return xerrors.Errorf("actor %s is a version %d actor; chain only supports actor version %d at height %d and nver %d", v.Code(), ver, aver, rt.CurrEpoch(), rt.NetworkVersion()) } diff --git a/chain/vm/mkactor.go b/chain/vm/mkactor.go index 9f277bf3e..4beee5ce6 100644 --- a/chain/vm/mkactor.go +++ b/chain/vm/mkactor.go @@ -54,7 +54,12 @@ func TryCreateAccountActor(rt *Runtime, addr address.Address) (*types.Actor, add return nil, address.Undef, aerrors.Escalate(err, "registering actor address") } - act, aerr := makeActor(actors.VersionForNetwork(rt.NetworkVersion()), addr) + av, err := actors.VersionForNetwork(rt.NetworkVersion()) + if err != nil { + return nil, address.Undef, aerrors.Escalate(err, "unsupported network version") + } + + act, aerr := makeActor(av, addr) if aerr != nil { return nil, address.Undef, aerr } diff --git a/cmd/lotus-miner/sectors.go b/cmd/lotus-miner/sectors.go index 5c4581bbc..fbf84ecff 100644 --- a/cmd/lotus-miner/sectors.go +++ b/cmd/lotus-miner/sectors.go @@ -561,7 +561,15 @@ var sectorsExtendCmd = &cli.Command{ for l, exts := range extensions { for newExp, numbers := range exts { scount += len(numbers) - if scount > policy.GetAddressedSectorsMax(nv) || len(p.Extensions) == policy.GetDeclarationsMax(nv) { + addressedMax, err := policy.GetAddressedSectorsMax(nv) + if err != nil { + return xerrors.Errorf("failed to get addressed sectors max") + } + declMax, err := policy.GetDeclarationsMax(nv) + if err != nil { + return xerrors.Errorf("failed to get declarations max") + } + if scount > addressedMax || len(p.Extensions) == declMax { params = append(params, p) p = miner3.ExtendSectorExpirationParams{} scount = len(numbers) diff --git a/cmd/lotus-sim/simulation/blockbuilder/blockbuilder.go b/cmd/lotus-sim/simulation/blockbuilder/blockbuilder.go index 2ffc0bf14..bd757614b 100644 --- a/cmd/lotus-sim/simulation/blockbuilder/blockbuilder.go +++ b/cmd/lotus-sim/simulation/blockbuilder/blockbuilder.go @@ -271,7 +271,7 @@ func (bb *BlockBuilder) StateManager() *stmgr.StateManager { } // ActorsVersion returns the actors version for the target block. -func (bb *BlockBuilder) ActorsVersion() actors.Version { +func (bb *BlockBuilder) ActorsVersion() (actors.Version, error) { return actors.VersionForNetwork(bb.NetworkVersion()) } diff --git a/cmd/lotus-sim/simulation/stages/funding_stage.go b/cmd/lotus-sim/simulation/stages/funding_stage.go index f57f85293..faec6a504 100644 --- a/cmd/lotus-sim/simulation/stages/funding_stage.go +++ b/cmd/lotus-sim/simulation/stages/funding_stage.go @@ -145,7 +145,10 @@ func (fs *FundingStage) PackMessages(ctx context.Context, bb *blockbuilder.Block store := bb.ActorStore() epoch := bb.Height() - actorsVersion := bb.ActorsVersion() + actorsVersion, err := bb.ActorsVersion() + if err != nil { + return err + } var accounts, multisigs int defer func() { diff --git a/cmd/lotus-sim/simulation/stages/provecommit_stage.go b/cmd/lotus-sim/simulation/stages/provecommit_stage.go index 6cbca7de9..8b12fc68a 100644 --- a/cmd/lotus-sim/simulation/stages/provecommit_stage.go +++ b/cmd/lotus-sim/simulation/stages/provecommit_stage.go @@ -280,7 +280,11 @@ func (stage *ProveCommitStage) packProveCommitsMiner( // It will drop any pre-commits that have already expired. func (stage *ProveCommitStage) loadMiner(ctx context.Context, bb *blockbuilder.BlockBuilder, addr address.Address) error { epoch := bb.Height() - av := bb.ActorsVersion() + av, err := bb.ActorsVersion() + if err != nil { + return err + } + minerState, err := loadMiner(bb.ActorStore(), bb.ParentStateTree(), addr) if err != nil { return err @@ -291,7 +295,10 @@ func (stage *ProveCommitStage) loadMiner(ctx context.Context, bb *blockbuilder.B var total, dropped int err = minerState.ForEachPrecommittedSector(func(info miner.SectorPreCommitOnChainInfo) error { total++ - msd := policy.GetMaxProveCommitDuration(av, info.Info.SealProof) + msd, err := policy.GetMaxProveCommitDuration(av, info.Info.SealProof) + if err != nil { + return err + } if epoch > info.PreCommitEpoch+msd { dropped++ return nil @@ -327,7 +334,10 @@ func (stage *ProveCommitStage) filterProveCommits( } nextEpoch := bb.Height() - av := bb.ActorsVersion() + av, err := bb.ActorsVersion() + if err != nil { + return nil, err + } good := make([]abi.SectorNumber, 0, len(snos)) for _, sno := range snos { @@ -338,7 +348,10 @@ func (stage *ProveCommitStage) filterProveCommits( if info == nil { continue } - msd := policy.GetMaxProveCommitDuration(av, info.Info.SealProof) + msd, err := policy.GetMaxProveCommitDuration(av, info.Info.SealProof) + if err != nil { + return nil, err + } if nextEpoch > info.PreCommitEpoch+msd { continue } diff --git a/extern/storage-sealing/commit_batch.go b/extern/storage-sealing/commit_batch.go index e9ace820e..c12a9f933 100644 --- a/extern/storage-sealing/commit_batch.go +++ b/extern/storage-sealing/commit_batch.go @@ -338,7 +338,12 @@ func (b *CommitBatcher) processBatch(cfg sealiface.Config) ([]sealiface.CommitBa return []sealiface.CommitBatchRes{res}, xerrors.Errorf("getting network version: %s", err) } - aggFee := big.Div(big.Mul(policy.AggregateNetworkFee(nv, len(infos), bf), aggFeeNum), aggFeeDen) + aggFeeRaw, err := policy.AggregateNetworkFee(nv, len(infos), bf) + if err != nil { + log.Errorf("getting aggregate network fee: %s", err) + return []sealiface.CommitBatchRes{res}, xerrors.Errorf("getting aggregate network fee: %s", err) + } + aggFee := big.Div(big.Mul(aggFeeRaw, aggFeeNum), aggFeeDen) needFunds := big.Add(collateral, aggFee) needFunds, err = collateralSendAmount(b.mctx, b.api, b.maddr, cfg, needFunds) @@ -558,8 +563,18 @@ func (b *CommitBatcher) getCommitCutoff(si SectorInfo) (time.Time, error) { log.Errorf("getting precommit info: %s", err) return time.Now(), err } + av, err := actors.VersionForNetwork(nv) + if err != nil { + log.Errorf("unsupported network vrsion: %s", err) + return time.Now(), err + } + mpcd, err := policy.GetMaxProveCommitDuration(av, si.SectorType) + if err != nil { + log.Errorf("getting max prove commit duration: %s", err) + return time.Now(), err + } - cutoffEpoch := pci.PreCommitEpoch + policy.GetMaxProveCommitDuration(actors.VersionForNetwork(nv), si.SectorType) + cutoffEpoch := pci.PreCommitEpoch + mpcd for _, p := range si.Pieces { if p.DealInfo == nil { diff --git a/extern/storage-sealing/states_sealing.go b/extern/storage-sealing/states_sealing.go index 5334fc72e..7bedc1ed3 100644 --- a/extern/storage-sealing/states_sealing.go +++ b/extern/storage-sealing/states_sealing.go @@ -143,7 +143,14 @@ func (m *Sealing) getTicket(ctx statemachine.Context, sector SectorInfo) (abi.Se return nil, 0, allocated, xerrors.Errorf("getTicket: StateNetworkVersion: api error, not proceeding: %+v", err) } - msd := policy.GetMaxProveCommitDuration(actors.VersionForNetwork(nv), sector.SectorType) + av, err := actors.VersionForNetwork(nv) + if err != nil { + return nil, 0, allocated, xerrors.Errorf("getTicket: actor version for network error, not proceeding: %w", err) + } + msd, err := policy.GetMaxProveCommitDuration(av, sector.SectorType) + if err != nil { + return nil, 0, allocated, xerrors.Errorf("getTicket: max prove commit duration policy error, not proceeding: %w", err) + } if checkProveCommitExpired(pci.PreCommitEpoch, msd, epoch) { return nil, 0, allocated, xerrors.Errorf("ticket expired for precommitted sector") @@ -223,7 +230,16 @@ func (m *Sealing) handlePreCommit1(ctx statemachine.Context, sector SectorInfo) return nil } - msd := policy.GetMaxProveCommitDuration(actors.VersionForNetwork(nv), sector.SectorType) + av, err := actors.VersionForNetwork(nv) + if err != nil { + log.Errorf("handlePreCommit1: VersionForNetwork error, not proceeding: %w", err) + return nil + } + msd, err := policy.GetMaxProveCommitDuration(av, sector.SectorType) + if err != nil { + log.Errorf("handlePreCommit1: GetMaxProveCommitDuration error, not proceeding: %w", err) + return nil + } // if height > PreCommitEpoch + msd, there is no need to recalculate if checkProveCommitExpired(pci.PreCommitEpoch, msd, height) { @@ -311,7 +327,14 @@ func (m *Sealing) preCommitParams(ctx statemachine.Context, sector SectorInfo) ( return nil, big.Zero(), nil, ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("failed to get network version: %w", err)}) } - msd := policy.GetMaxProveCommitDuration(actors.VersionForNetwork(nv), sector.SectorType) + av, err := actors.VersionForNetwork(nv) + if err != nil { + return nil, big.Zero(), nil, ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("failed to get actors version: %w", err)}) + } + msd, err := policy.GetMaxProveCommitDuration(av, sector.SectorType) + if err != nil { + return nil, big.Zero(), nil, ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("failed to get max prove commit duration: %w", err)}) + } if minExpiration := sector.TicketEpoch + policy.MaxPreCommitRandomnessLookback + msd + miner.MinSectorExpiration; expiration < minExpiration { expiration = minExpiration diff --git a/node/impl/full/multisig.go b/node/impl/full/multisig.go index e44509d7c..0d20c3f03 100644 --- a/node/impl/full/multisig.go +++ b/node/impl/full/multisig.go @@ -30,8 +30,12 @@ func (a *MsigAPI) messageBuilder(ctx context.Context, from address.Address) (mul if err != nil { return nil, err } + av, err := actors.VersionForNetwork(nver) + if err != nil { + return nil, err + } - return multisig.Message(actors.VersionForNetwork(nver), from), nil + return multisig.Message(av, from), nil } // TODO: remove gp (gasPrice) from arguments diff --git a/node/impl/full/state.go b/node/impl/full/state.go index d8545ae13..df0888787 100644 --- a/node/impl/full/state.go +++ b/node/impl/full/state.go @@ -1332,13 +1332,16 @@ func (m *StateModule) StateDealProviderCollateralBounds(ctx context.Context, siz return api.DealCollateralBounds{}, xerrors.Errorf("getting reward baseline power: %w", err) } - min, max := policy.DealProviderCollateralBounds(size, + min, max, err := policy.DealProviderCollateralBounds(size, verified, powClaim.RawBytePower, powClaim.QualityAdjPower, rewPow, circ.FilCirculating, m.StateManager.GetNtwkVersion(ctx, ts.Height())) + if err != nil { + return api.DealCollateralBounds{}, xerrors.Errorf("getting deal provider coll bounds: %w", err) + } return api.DealCollateralBounds{ Min: types.BigDiv(types.BigMul(min, dealProviderCollateralNum), dealProviderCollateralDen), Max: max, diff --git a/paychmgr/paych.go b/paychmgr/paych.go index c4ef3deb0..ed72c35e0 100644 --- a/paychmgr/paych.go +++ b/paychmgr/paych.go @@ -88,7 +88,11 @@ func (ca *channelAccessor) messageBuilder(ctx context.Context, from address.Addr return nil, err } - return paych.Message(actors.VersionForNetwork(nwVersion), from), nil + av, err := actors.VersionForNetwork(nwVersion) + if err != nil { + return nil, err + } + return paych.Message(av, from), nil } func (ca *channelAccessor) getChannelInfo(addr address.Address) (*ChannelInfo, error) { diff --git a/storage/wdpost_run.go b/storage/wdpost_run.go index 51a0729af..20d1eeadc 100644 --- a/storage/wdpost_run.go +++ b/storage/wdpost_run.go @@ -739,8 +739,12 @@ func (s *WindowPoStScheduler) batchPartitions(partitions []api.Partition, nv net } // Also respect the AddressedPartitionsMax (which is the same as DeclarationsMax (which is all really just MaxPartitionsPerDeadline)) - if partitionsPerMsg > policy.GetDeclarationsMax(nv) { - partitionsPerMsg = policy.GetDeclarationsMax(nv) + declMax, err := policy.GetDeclarationsMax(nv) + if err != nil { + return nil, xerrors.Errorf("getting max declarations: %w", err) + } + if partitionsPerMsg > declMax { + partitionsPerMsg = declMax } // The number of messages will be: