cerc-io/lotus
16
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 27 Wiki Activity

rename imports to match actors code

Browse Source 
`sed -i 's/\bv0\(\w\)\(\w*\)/\L\1\E\20/g' **/*.go`
This commit is contained in:
Steven Allen 2020-09-18 14:59:27 -07:00
parent c130806c37
commit 1bf3b4989d
65 changed files with 534 additions and 534 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
build/params_2k.go
View File

@ -5,9 +5,9 @@ package build
import ( import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
) )
const UpgradeBreezeHeight = -1 const UpgradeBreezeHeight = -1
@ -20,11 +20,11 @@ var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
} }
func init() { func init() {
v0power.ConsensusMinerMinPower = big.NewInt(2048) power0.ConsensusMinerMinPower = big.NewInt(2048)
v0miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{ miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
abi.RegisteredSealProof_StackedDrg2KiBV1: {}, abi.RegisteredSealProof_StackedDrg2KiBV1: {},
} }
v0verifreg.MinVerifiedDealSize = big.NewInt(256) verifreg0.MinVerifiedDealSize = big.NewInt(256)
BuildType |= Build2k BuildType |= Build2k
} }

6
build/params_shared_funcs.go
View File

@ -6,14 +6,14 @@ import (
"github.com/libp2p/go-libp2p-core/protocol" "github.com/libp2p/go-libp2p-core/protocol"
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/filecoin-project/lotus/node/modules/dtypes" "github.com/filecoin-project/lotus/node/modules/dtypes"
) )
func DefaultSectorSize() abi.SectorSize { func DefaultSectorSize() abi.SectorSize {
szs := make([]abi.SectorSize, 0, len(v0miner.SupportedProofTypes)) szs := make([]abi.SectorSize, 0, len(miner0.SupportedProofTypes))
for spt := range v0miner.SupportedProofTypes { for spt := range miner0.SupportedProofTypes {
ss, err := spt.SectorSize() ss, err := spt.SectorSize()
if err != nil { if err != nil {
panic(err) panic(err)

4
build/params_shared_vals.go
View File

@ -9,7 +9,7 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
) )
// ///// // /////
@ -32,7 +32,7 @@ const ForkLengthThreshold = Finality
var BlocksPerEpoch = uint64(builtin.ExpectedLeadersPerEpoch) var BlocksPerEpoch = uint64(builtin.ExpectedLeadersPerEpoch)
// Epochs // Epochs
const Finality = v0miner.ChainFinality const Finality = miner0.ChainFinality
const MessageConfidence = uint64(5) const MessageConfidence = uint64(5)
// constants for Weight calculation // constants for Weight calculation

4
build/params_testground.go
View File

@ -13,7 +13,7 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/network"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
) )
var ( var (
@ -32,7 +32,7 @@ var (
AllowableClockDriftSecs = uint64(1) AllowableClockDriftSecs = uint64(1)
Finality = v0miner.ChainFinality Finality = miner0.ChainFinality
ForkLengthThreshold = Finality ForkLengthThreshold = Finality
SlashablePowerDelay = 20 SlashablePowerDelay = 20

8
build/params_testnet.go
View File

@ -8,8 +8,8 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
) )
var DrandSchedule = map[abi.ChainEpoch]DrandEnum{ var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
@ -23,8 +23,8 @@ const BreezeGasTampingDuration = 120
const UpgradeSmokeHeight = 51000 const UpgradeSmokeHeight = 51000
func init() { func init() {
v0power.ConsensusMinerMinPower = big.NewInt(10 << 40) power0.ConsensusMinerMinPower = big.NewInt(10 << 40)
v0miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{ miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
abi.RegisteredSealProof_StackedDrg32GiBV1: {}, abi.RegisteredSealProof_StackedDrg32GiBV1: {},
abi.RegisteredSealProof_StackedDrg64GiBV1: {}, abi.RegisteredSealProof_StackedDrg64GiBV1: {},
} }

8
chain/actors/adt/adt.go
View File

@ -8,7 +8,7 @@ import (
"github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/cbor"
"github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/network"
"github.com/filecoin-project/lotus/chain/actors/builtin" "github.com/filecoin-project/lotus/chain/actors/builtin"
v0adt "github.com/filecoin-project/specs-actors/actors/util/adt" adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
) )
type Map interface { type Map interface {
@ -24,7 +24,7 @@ type Map interface {
func AsMap(store Store, root cid.Cid, version builtin.Version) (Map, error) { func AsMap(store Store, root cid.Cid, version builtin.Version) (Map, error) {
switch version { switch version {
case builtin.Version0: case builtin.Version0:
return v0adt.AsMap(store, root) return adt0.AsMap(store, root)
} }
return nil, xerrors.Errorf("unknown network version: %d", version) return nil, xerrors.Errorf("unknown network version: %d", version)
} }
@ -32,7 +32,7 @@ func AsMap(store Store, root cid.Cid, version builtin.Version) (Map, error) {
func NewMap(store Store, version builtin.Version) (Map, error) { func NewMap(store Store, version builtin.Version) (Map, error) {
switch version { switch version {
case builtin.Version0: case builtin.Version0:
return v0adt.MakeEmptyMap(store), nil return adt0.MakeEmptyMap(store), nil
} }
return nil, xerrors.Errorf("unknown network version: %d", version) return nil, xerrors.Errorf("unknown network version: %d", version)
} }
@ -51,7 +51,7 @@ type Array interface {
func AsArray(store Store, root cid.Cid, version network.Version) (Array, error) { func AsArray(store Store, root cid.Cid, version network.Version) (Array, error) {
switch builtin.VersionForNetwork(version) { switch builtin.VersionForNetwork(version) {
case builtin.Version0: case builtin.Version0:
return v0adt.AsArray(store, root) return adt0.AsArray(store, root)
} }
return nil, xerrors.Errorf("unknown network version: %d", version) return nil, xerrors.Errorf("unknown network version: %d", version)
} }

10
chain/actors/adt/diff_adt_test.go
View File

@ -13,7 +13,7 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/specs-actors/actors/runtime" "github.com/filecoin-project/specs-actors/actors/runtime"
v0adt "github.com/filecoin-project/specs-actors/actors/util/adt" adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
bstore "github.com/filecoin-project/lotus/lib/blockstore" bstore "github.com/filecoin-project/lotus/lib/blockstore"
) )
@ -22,8 +22,8 @@ func TestDiffAdtArray(t *testing.T) {
ctxstoreA := newContextStore() ctxstoreA := newContextStore()
ctxstoreB := newContextStore() ctxstoreB := newContextStore()
arrA := v0adt.MakeEmptyArray(ctxstoreA) arrA := adt0.MakeEmptyArray(ctxstoreA)
arrB := v0adt.MakeEmptyArray(ctxstoreB) arrB := adt0.MakeEmptyArray(ctxstoreB)
require.NoError(t, arrA.Set(0, runtime.CBORBytes([]byte{0}))) // delete require.NoError(t, arrA.Set(0, runtime.CBORBytes([]byte{0}))) // delete
@ -76,8 +76,8 @@ func TestDiffAdtMap(t *testing.T) {
ctxstoreA := newContextStore() ctxstoreA := newContextStore()
ctxstoreB := newContextStore() ctxstoreB := newContextStore()
mapA := v0adt.MakeEmptyMap(ctxstoreA) mapA := adt0.MakeEmptyMap(ctxstoreA)
mapB := v0adt.MakeEmptyMap(ctxstoreB) mapB := adt0.MakeEmptyMap(ctxstoreB)
require.NoError(t, mapA.Put(abi.UIntKey(0), runtime.CBORBytes([]byte{0}))) // delete require.NoError(t, mapA.Put(abi.UIntKey(0), runtime.CBORBytes([]byte{0}))) // delete

6
chain/actors/builtin/account/account.go
View File

@ -5,7 +5,7 @@ import (
"github.com/filecoin-project/go-address" "github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/cbor"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
@ -13,8 +13,8 @@ import (
func Load(store adt.Store, act *types.Actor) (State, error) { func Load(store adt.Store, act *types.Actor) (State, error) {
switch act.Code { switch act.Code {
case v0builtin.AccountActorCodeID: case builtin0.AccountActorCodeID:
out := v0State{store: store} out := state0{store: store}
err := store.Get(store.Context(), act.Head, &out) err := store.Get(store.Context(), act.Head, &out)
if err != nil { if err != nil {
return nil, err return nil, err

4
chain/actors/builtin/account/v0.go
View File

@ -6,11 +6,11 @@ import (
"github.com/filecoin-project/specs-actors/actors/builtin/account" "github.com/filecoin-project/specs-actors/actors/builtin/account"
) )
type v0State struct { type state0 struct {
account.State account.State
store adt.Store store adt.Store
} }
func (s *v0State) PubkeyAddress() (address.Address, error) { func (s *state0) PubkeyAddress() (address.Address, error) {
return s.Address, nil return s.Address, nil
} }

4
chain/actors/builtin/builtin.go
View File

@ -5,7 +5,7 @@ import (
"github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/network"
v0smoothing "github.com/filecoin-project/specs-actors/actors/util/smoothing" smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
) )
type Version int type Version int
@ -25,4 +25,4 @@ func VersionForNetwork(version network.Version) Version {
} }
// TODO: find some way to abstract over this. // TODO: find some way to abstract over this.
type FilterEstimate = v0smoothing.FilterEstimate type FilterEstimate = smoothing0.FilterEstimate

8
chain/actors/builtin/init/init.go
View File

@ -6,19 +6,19 @@ import (
"github.com/filecoin-project/go-address" "github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/cbor"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/node/modules/dtypes" "github.com/filecoin-project/lotus/node/modules/dtypes"
) )
var Address = v0builtin.InitActorAddr var Address = builtin0.InitActorAddr
func Load(store adt.Store, act *types.Actor) (State, error) { func Load(store adt.Store, act *types.Actor) (State, error) {
switch act.Code { switch act.Code {
case v0builtin.InitActorCodeID: case builtin0.InitActorCodeID:
out := v0State{store: store} out := state0{store: store}
err := store.Get(store.Context(), act.Head, &out) err := store.Get(store.Context(), act.Head, &out)
if err != nil { if err != nil {
return nil, err return nil, err

14
chain/actors/builtin/init/v0.go
View File

@ -10,24 +10,24 @@ import (
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/node/modules/dtypes" "github.com/filecoin-project/lotus/node/modules/dtypes"
v0adt "github.com/filecoin-project/specs-actors/actors/util/adt" adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
) )
type v0State struct { type state0 struct {
init_.State init_.State
store adt.Store store adt.Store
} }
func (s *v0State) ResolveAddress(address address.Address) (address.Address, bool, error) { func (s *state0) ResolveAddress(address address.Address) (address.Address, bool, error) {
return s.State.ResolveAddress(s.store, address) return s.State.ResolveAddress(s.store, address)
} }
func (s *v0State) MapAddressToNewID(address address.Address) (address.Address, error) { func (s *state0) MapAddressToNewID(address address.Address) (address.Address, error) {
return s.State.MapAddressToNewID(s.store, address) return s.State.MapAddressToNewID(s.store, address)
} }
func (s *v0State) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error { func (s *state0) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error {
addrs, err := v0adt.AsMap(s.store, s.State.AddressMap) addrs, err := adt0.AsMap(s.store, s.State.AddressMap)
if err != nil { if err != nil {
return err return err
} }
@ -41,6 +41,6 @@ func (s *v0State) ForEachActor(cb func(id abi.ActorID, address address.Address)
}) })
} }
func (s *v0State) NetworkName() (dtypes.NetworkName, error) { func (s *state0) NetworkName() (dtypes.NetworkName, error) {
return dtypes.NetworkName(s.State.NetworkName), nil return dtypes.NetworkName(s.State.NetworkName), nil
} }

8
chain/actors/builtin/market/market.go
View File

@ -6,7 +6,7 @@ import (
"github.com/filecoin-project/go-address" "github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/cbor"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/ipfs/go-cid" "github.com/ipfs/go-cid"
cbg "github.com/whyrusleeping/cbor-gen" cbg "github.com/whyrusleeping/cbor-gen"
@ -14,12 +14,12 @@ import (
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
) )
var Address = v0builtin.StorageMarketActorAddr var Address = builtin0.StorageMarketActorAddr
func Load(store adt.Store, act *types.Actor) (st State, err error) { func Load(store adt.Store, act *types.Actor) (st State, err error) {
switch act.Code { switch act.Code {
case v0builtin.StorageMarketActorCodeID: case builtin0.StorageMarketActorCodeID:
out := v0State{store: store} out := state0{store: store}
err := store.Get(store.Context(), act.Head, &out) err := store.Get(store.Context(), act.Head, &out)
if err != nil { if err != nil {
return nil, err return nil, err

106
chain/actors/builtin/market/v0.go
View File

@ -8,95 +8,95 @@ import (
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/specs-actors/actors/builtin/market" "github.com/filecoin-project/specs-actors/actors/builtin/market"
v0adt "github.com/filecoin-project/specs-actors/actors/util/adt" adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
cbg "github.com/whyrusleeping/cbor-gen" cbg "github.com/whyrusleeping/cbor-gen"
) )
type v0State struct { type state0 struct {
market.State market.State
store adt.Store store adt.Store
} }
func (s *v0State) TotalLocked() (abi.TokenAmount, error) { func (s *state0) TotalLocked() (abi.TokenAmount, error) {
fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral) fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
fml = types.BigAdd(fml, s.TotalClientStorageFee) fml = types.BigAdd(fml, s.TotalClientStorageFee)
return fml, nil return fml, nil
} }
func (s *v0State) BalancesChanged(otherState State) bool { func (s *state0) BalancesChanged(otherState State) bool {
v0otherState, ok := otherState.(*v0State) otherState0, ok := otherState.(*state0)
if !ok { if !ok {
// there's no way to compare differnt versions of the state, so let's // there's no way to compare differnt versions of the state, so let's
// just say that means the state of balances has changed // just say that means the state of balances has changed
return true return true
} }
return !s.State.EscrowTable.Equals(v0otherState.State.EscrowTable) || !s.State.LockedTable.Equals(v0otherState.State.LockedTable) return !s.State.EscrowTable.Equals(otherState0.State.EscrowTable) || !s.State.LockedTable.Equals(otherState0.State.LockedTable)
} }
func (s *v0State) StatesChanged(otherState State) bool { func (s *state0) StatesChanged(otherState State) bool {
v0otherState, ok := otherState.(*v0State) otherState0, ok := otherState.(*state0)
if !ok { if !ok {
// there's no way to compare differnt versions of the state, so let's // there's no way to compare differnt versions of the state, so let's
// just say that means the state of balances has changed // just say that means the state of balances has changed
return true return true
} }
return !s.State.States.Equals(v0otherState.State.States) return !s.State.States.Equals(otherState0.State.States)
} }
func (s *v0State) States() (DealStates, error) { func (s *state0) States() (DealStates, error) {
stateArray, err := v0adt.AsArray(s.store, s.State.States) stateArray, err := adt0.AsArray(s.store, s.State.States)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &v0DealStates{stateArray}, nil return &dealStates0{stateArray}, nil
} }
func (s *v0State) ProposalsChanged(otherState State) bool { func (s *state0) ProposalsChanged(otherState State) bool {
v0otherState, ok := otherState.(*v0State) otherState0, ok := otherState.(*state0)
if !ok { if !ok {
// there's no way to compare differnt versions of the state, so let's // there's no way to compare differnt versions of the state, so let's
// just say that means the state of balances has changed // just say that means the state of balances has changed
return true return true
} }
return !s.State.Proposals.Equals(v0otherState.State.Proposals) return !s.State.Proposals.Equals(otherState0.State.Proposals)
} }
func (s *v0State) Proposals() (DealProposals, error) { func (s *state0) Proposals() (DealProposals, error) {
proposalArray, err := v0adt.AsArray(s.store, s.State.Proposals) proposalArray, err := adt0.AsArray(s.store, s.State.Proposals)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &v0DealProposals{proposalArray}, nil return &dealProposals0{proposalArray}, nil
} }
func (s *v0State) EscrowTable() (BalanceTable, error) { func (s *state0) EscrowTable() (BalanceTable, error) {
bt, err := v0adt.AsBalanceTable(s.store, s.State.EscrowTable) bt, err := adt0.AsBalanceTable(s.store, s.State.EscrowTable)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &v0BalanceTable{bt}, nil return &balanceTable0{bt}, nil
} }
func (s *v0State) LockedTable() (BalanceTable, error) { func (s *state0) LockedTable() (BalanceTable, error) {
bt, err := v0adt.AsBalanceTable(s.store, s.State.LockedTable) bt, err := adt0.AsBalanceTable(s.store, s.State.LockedTable)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &v0BalanceTable{bt}, nil return &balanceTable0{bt}, nil
} }
func (s *v0State) VerifyDealsForActivation( func (s *state0) VerifyDealsForActivation(
minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch, minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
) (weight, verifiedWeight abi.DealWeight, err error) { ) (weight, verifiedWeight abi.DealWeight, err error) {
return market.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch) return market.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
} }
type v0BalanceTable struct { type balanceTable0 struct {
*v0adt.BalanceTable *adt0.BalanceTable
} }
func (bt *v0BalanceTable) ForEach(cb func(address.Address, abi.TokenAmount) error) error { func (bt *balanceTable0) ForEach(cb func(address.Address, abi.TokenAmount) error) error {
asMap := (*v0adt.Map)(bt.BalanceTable) asMap := (*adt0.Map)(bt.BalanceTable)
var ta abi.TokenAmount var ta abi.TokenAmount
return asMap.ForEach(&ta, func(key string) error { return asMap.ForEach(&ta, func(key string) error {
a, err := address.NewFromBytes([]byte(key)) a, err := address.NewFromBytes([]byte(key))
@ -107,33 +107,33 @@ func (bt *v0BalanceTable) ForEach(cb func(address.Address, abi.TokenAmount) erro
}) })
} }
type v0DealStates struct { type dealStates0 struct {
adt.Array adt.Array
} }
func (s *v0DealStates) Get(dealID abi.DealID) (*DealState, bool, error) { func (s *dealStates0) Get(dealID abi.DealID) (*DealState, bool, error) {
var v0deal market.DealState var deal0 market.DealState
found, err := s.Array.Get(uint64(dealID), &v0deal) found, err := s.Array.Get(uint64(dealID), &deal0)
if err != nil { if err != nil {
return nil, false, err return nil, false, err
} }
if !found { if !found {
return nil, false, nil return nil, false, nil
} }
deal := fromV0DealState(v0deal) deal := fromV0DealState(deal0)
return &deal, true, nil return &deal, true, nil
} }
func (s *v0DealStates) decode(val *cbg.Deferred) (*DealState, error) { func (s *dealStates0) decode(val *cbg.Deferred) (*DealState, error) {
var v0ds market.DealState var ds0 market.DealState
if err := v0ds.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { if err := ds0.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
return nil, err return nil, err
} }
ds := fromV0DealState(v0ds) ds := fromV0DealState(ds0)
return &ds, nil return &ds, nil
} }
func (s *v0DealStates) array() adt.Array { func (s *dealStates0) array() adt.Array {
return s.Array return s.Array
} }
@ -141,40 +141,40 @@ func fromV0DealState(v0 market.DealState) DealState {
return (DealState)(v0) return (DealState)(v0)
} }
type v0DealProposals struct { type dealProposals0 struct {
adt.Array adt.Array
} }
func (s *v0DealProposals) Get(dealID abi.DealID) (*DealProposal, bool, error) { func (s *dealProposals0) Get(dealID abi.DealID) (*DealProposal, bool, error) {
var v0proposal market.DealProposal var proposal0 market.DealProposal
found, err := s.Array.Get(uint64(dealID), &v0proposal) found, err := s.Array.Get(uint64(dealID), &proposal0)
if err != nil { if err != nil {
return nil, false, err return nil, false, err
} }
if !found { if !found {
return nil, false, nil return nil, false, nil
} }
proposal := fromV0DealProposal(v0proposal) proposal := fromV0DealProposal(proposal0)
return &proposal, true, nil return &proposal, true, nil
} }
func (s *v0DealProposals) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error { func (s *dealProposals0) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
var v0dp market.DealProposal var dp0 market.DealProposal
return s.Array.ForEach(&v0dp, func(idx int64) error { return s.Array.ForEach(&dp0, func(idx int64) error {
return cb(abi.DealID(idx), fromV0DealProposal(v0dp)) return cb(abi.DealID(idx), fromV0DealProposal(dp0))
}) })
} }
func (s *v0DealProposals) decode(val *cbg.Deferred) (*DealProposal, error) { func (s *dealProposals0) decode(val *cbg.Deferred) (*DealProposal, error) {
var v0dp market.DealProposal var dp0 market.DealProposal
if err := v0dp.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { if err := dp0.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
return nil, err return nil, err
} }
dp := fromV0DealProposal(v0dp) dp := fromV0DealProposal(dp0)
return &dp, nil return &dp, nil
} }
func (s *v0DealProposals) array() adt.Array { func (s *dealProposals0) array() adt.Array {
return s.Array return s.Array
} }

30
chain/actors/builtin/miner/miner.go
View File

@ -10,19 +10,19 @@ import (
"github.com/filecoin-project/go-bitfield" "github.com/filecoin-project/go-bitfield"
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/cbor"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
) )
var Address = v0builtin.InitActorAddr var Address = builtin0.InitActorAddr
func Load(store adt.Store, act *types.Actor) (st State, err error) { func Load(store adt.Store, act *types.Actor) (st State, err error) {
switch act.Code { switch act.Code {
case v0builtin.StorageMinerActorCodeID: case builtin0.StorageMinerActorCodeID:
out := v0State{store: store} out := state0{store: store}
err := store.Get(store.Context(), act.Head, &out) err := store.Get(store.Context(), act.Head, &out)
if err != nil { if err != nil {
return nil, err return nil, err
@ -83,18 +83,18 @@ type Partition interface {
ActiveSectors() (bitfield.BitField, error) ActiveSectors() (bitfield.BitField, error)
} }
type SectorOnChainInfo = v0miner.SectorOnChainInfo type SectorOnChainInfo = miner0.SectorOnChainInfo
type SectorPreCommitInfo = v0miner.SectorPreCommitInfo type SectorPreCommitInfo = miner0.SectorPreCommitInfo
type SectorPreCommitOnChainInfo = v0miner.SectorPreCommitOnChainInfo type SectorPreCommitOnChainInfo = miner0.SectorPreCommitOnChainInfo
type PoStPartition = v0miner.PoStPartition type PoStPartition = miner0.PoStPartition
type RecoveryDeclaration = v0miner.RecoveryDeclaration type RecoveryDeclaration = miner0.RecoveryDeclaration
type FaultDeclaration = v0miner.FaultDeclaration type FaultDeclaration = miner0.FaultDeclaration
// Params // Params
type DeclareFaultsParams = v0miner.DeclareFaultsParams type DeclareFaultsParams = miner0.DeclareFaultsParams
type DeclareFaultsRecoveredParams = v0miner.DeclareFaultsRecoveredParams type DeclareFaultsRecoveredParams = miner0.DeclareFaultsRecoveredParams
type SubmitWindowedPoStParams = v0miner.SubmitWindowedPoStParams type SubmitWindowedPoStParams = miner0.SubmitWindowedPoStParams
type ProveCommitSectorParams = v0miner.ProveCommitSectorParams type ProveCommitSectorParams = miner0.ProveCommitSectorParams
type MinerInfo struct { type MinerInfo struct {
Owner address.Address // Must be an ID-address. Owner address.Address // Must be an ID-address.

120
chain/actors/builtin/miner/v0.go
View File

@ -9,38 +9,38 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/dline" "github.com/filecoin-project/go-state-types/dline"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
v0adt "github.com/filecoin-project/specs-actors/actors/util/adt" adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
"github.com/libp2p/go-libp2p-core/peer" "github.com/libp2p/go-libp2p-core/peer"
cbg "github.com/whyrusleeping/cbor-gen" cbg "github.com/whyrusleeping/cbor-gen"
"golang.org/x/xerrors" "golang.org/x/xerrors"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
) )
type v0State struct { type state0 struct {
v0miner.State miner0.State
store adt.Store store adt.Store
} }
type v0Deadline struct { type deadline0 struct {
v0miner.Deadline miner0.Deadline
store adt.Store store adt.Store
} }
type v0Partition struct { type partition0 struct {
v0miner.Partition miner0.Partition
store adt.Store store adt.Store
} }
func (s *v0State) AvailableBalance(bal abi.TokenAmount) (abi.TokenAmount, error) { func (s *state0) AvailableBalance(bal abi.TokenAmount) (abi.TokenAmount, error) {
return s.GetAvailableBalance(bal), nil return s.GetAvailableBalance(bal), nil
} }
func (s *v0State) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) { func (s *state0) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) {
return s.CheckVestedFunds(s.store, epoch) return s.CheckVestedFunds(s.store, epoch)
} }
func (s *v0State) LockedFunds() (LockedFunds, error) { func (s *state0) LockedFunds() (LockedFunds, error) {
return LockedFunds{ return LockedFunds{
VestingFunds: s.State.LockedFunds, VestingFunds: s.State.LockedFunds,
InitialPledgeRequirement: s.State.InitialPledgeRequirement, InitialPledgeRequirement: s.State.InitialPledgeRequirement,
@ -48,15 +48,15 @@ func (s *v0State) LockedFunds() (LockedFunds, error) {
}, nil }, nil
} }
func (s *v0State) InitialPledge() (abi.TokenAmount, error) { func (s *state0) InitialPledge() (abi.TokenAmount, error) {
return s.State.InitialPledgeRequirement, nil return s.State.InitialPledgeRequirement, nil
} }
func (s *v0State) PreCommitDeposits() (abi.TokenAmount, error) { func (s *state0) PreCommitDeposits() (abi.TokenAmount, error) {
return s.State.PreCommitDeposits, nil return s.State.PreCommitDeposits, nil
} }
func (s *v0State) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) { func (s *state0) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) {
info, ok, err := s.State.GetSector(s.store, num) info, ok, err := s.State.GetSector(s.store, num)
if !ok || err != nil { if !ok || err != nil {
return nil, err return nil, err
@ -65,7 +65,7 @@ func (s *v0State) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) {
return info, nil return info, nil
} }
func (s *v0State) FindSector(num abi.SectorNumber) (*SectorLocation, error) { func (s *state0) FindSector(num abi.SectorNumber) (*SectorLocation, error) {
dlIdx, partIdx, err := s.State.FindSector(s.store, num) dlIdx, partIdx, err := s.State.FindSector(s.store, num)
if err != nil { if err != nil {
return nil, err return nil, err
@ -81,7 +81,7 @@ func (s *v0State) FindSector(num abi.SectorNumber) (*SectorLocation, error) {
// If the sector isn't found or has already been terminated, this method returns // If the sector isn't found or has already been terminated, this method returns
// nil and no error. If the sector does not expire early, the Early expiration // nil and no error. If the sector does not expire early, the Early expiration
// field is 0. // field is 0.
func (s *v0State) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, error) { func (s *state0) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, error) {
dls, err := s.State.LoadDeadlines(s.store) dls, err := s.State.LoadDeadlines(s.store)
if err != nil { if err != nil {
return nil, err return nil, err
@ -94,13 +94,13 @@ func (s *v0State) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration,
// of the expiration queue. // of the expiration queue.
stopErr := errors.New("stop") stopErr := errors.New("stop")
out := SectorExpiration{} out := SectorExpiration{}
err = dls.ForEach(s.store, func(dlIdx uint64, dl *v0miner.Deadline) error { err = dls.ForEach(s.store, func(dlIdx uint64, dl *miner0.Deadline) error {
partitions, err := dl.PartitionsArray(s.store) partitions, err := dl.PartitionsArray(s.store)
if err != nil { if err != nil {
return err return err
} }
quant := s.State.QuantSpecForDeadline(dlIdx) quant := s.State.QuantSpecForDeadline(dlIdx)
var part v0miner.Partition var part miner0.Partition
return partitions.ForEach(&part, func(partIdx int64) error { return partitions.ForEach(&part, func(partIdx int64) error {
if found, err := part.Sectors.IsSet(uint64(num)); err != nil { if found, err := part.Sectors.IsSet(uint64(num)); err != nil {
return err return err
@ -114,11 +114,11 @@ func (s *v0State) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration,
return stopErr return stopErr
} }
q, err := v0miner.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant) q, err := miner0.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant)
if err != nil { if err != nil {
return err return err
} }
var exp v0miner.ExpirationSet var exp miner0.ExpirationSet
return q.ForEach(&exp, func(epoch int64) error { return q.ForEach(&exp, func(epoch int64) error {
if early, err := exp.EarlySectors.IsSet(uint64(num)); err != nil { if early, err := exp.EarlySectors.IsSet(uint64(num)); err != nil {
return err return err
@ -148,7 +148,7 @@ func (s *v0State) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration,
return &out, nil return &out, nil
} }
func (s *v0State) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) { func (s *state0) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) {
info, ok, err := s.State.GetPrecommittedSector(s.store, num) info, ok, err := s.State.GetPrecommittedSector(s.store, num)
if !ok || err != nil { if !ok || err != nil {
return nil, err return nil, err
@ -157,8 +157,8 @@ func (s *v0State) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitO
return info, nil return info, nil
} }
func (s *v0State) LoadSectorsFromSet(filter *bitfield.BitField, filterOut bool) (adt.Array, error) { func (s *state0) LoadSectorsFromSet(filter *bitfield.BitField, filterOut bool) (adt.Array, error) {
a, err := v0adt.AsArray(s.store, s.State.Sectors) a, err := adt0.AsArray(s.store, s.State.Sectors)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -185,11 +185,11 @@ func (s *v0State) LoadSectorsFromSet(filter *bitfield.BitField, filterOut bool)
return a, nil return a, nil
} }
func (s *v0State) LoadPreCommittedSectors() (adt.Map, error) { func (s *state0) LoadPreCommittedSectors() (adt.Map, error) {
return v0adt.AsMap(s.store, s.State.PreCommittedSectors) return adt0.AsMap(s.store, s.State.PreCommittedSectors)
} }
func (s *v0State) IsAllocated(num abi.SectorNumber) (bool, error) { func (s *state0) IsAllocated(num abi.SectorNumber) (bool, error) {
var allocatedSectors bitfield.BitField var allocatedSectors bitfield.BitField
if err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors); err != nil { if err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors); err != nil {
return false, err return false, err
@ -198,7 +198,7 @@ func (s *v0State) IsAllocated(num abi.SectorNumber) (bool, error) {
return allocatedSectors.IsSet(uint64(num)) return allocatedSectors.IsSet(uint64(num))
} }
func (s *v0State) LoadDeadline(idx uint64) (Deadline, error) { func (s *state0) LoadDeadline(idx uint64) (Deadline, error) {
dls, err := s.State.LoadDeadlines(s.store) dls, err := s.State.LoadDeadlines(s.store)
if err != nil { if err != nil {
return nil, err return nil, err
@ -207,39 +207,39 @@ func (s *v0State) LoadDeadline(idx uint64) (Deadline, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &v0Deadline{*dl, s.store}, nil return &deadline0{*dl, s.store}, nil
} }
func (s *v0State) ForEachDeadline(cb func(uint64, Deadline) error) error { func (s *state0) ForEachDeadline(cb func(uint64, Deadline) error) error {
dls, err := s.State.LoadDeadlines(s.store) dls, err := s.State.LoadDeadlines(s.store)
if err != nil { if err != nil {
return err return err
} }
return dls.ForEach(s.store, func(i uint64, dl *v0miner.Deadline) error { return dls.ForEach(s.store, func(i uint64, dl *miner0.Deadline) error {
return cb(i, &v0Deadline{*dl, s.store}) return cb(i, &deadline0{*dl, s.store})
}) })
} }
func (s *v0State) NumDeadlines() (uint64, error) { func (s *state0) NumDeadlines() (uint64, error) {
return v0miner.WPoStPeriodDeadlines, nil return miner0.WPoStPeriodDeadlines, nil
} }
// Max sectors per PoSt // Max sectors per PoSt
func (s *v0State) MaxAddressedSectors() (uint64, error) { func (s *state0) MaxAddressedSectors() (uint64, error) {
return v0miner.AddressedSectorsMax, nil return miner0.AddressedSectorsMax, nil
} }
func (s *v0State) DeadlinesChanged(other State) bool { func (s *state0) DeadlinesChanged(other State) bool {
v0other, ok := other.(*v0State) other0, ok := other.(*state0)
if !ok { if !ok {
// treat an upgrade as a change, always // treat an upgrade as a change, always
return true return true
} }
return s.State.Deadlines.Equals(v0other.Deadlines) return s.State.Deadlines.Equals(other0.Deadlines)
} }
func (s *v0State) Info() (MinerInfo, error) { func (s *state0) Info() (MinerInfo, error) {
info, err := s.State.GetInfo(s.store) info, err := s.State.GetInfo(s.store)
if err != nil { if err != nil {
return MinerInfo{}, err return MinerInfo{}, err
@ -273,71 +273,71 @@ func (s *v0State) Info() (MinerInfo, error) {
return mi, nil return mi, nil
} }
func (s *v0State) DeadlineInfo(epoch abi.ChainEpoch) *dline.Info { func (s *state0) DeadlineInfo(epoch abi.ChainEpoch) *dline.Info {
return s.State.DeadlineInfo(epoch) return s.State.DeadlineInfo(epoch)
} }
func (s *v0State) sectors() (adt.Array, error) { func (s *state0) sectors() (adt.Array, error) {
return v0adt.AsArray(s.store, s.Sectors) return adt0.AsArray(s.store, s.Sectors)
} }
func (s *v0State) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) { func (s *state0) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) {
var si v0miner.SectorOnChainInfo var si miner0.SectorOnChainInfo
err := si.UnmarshalCBOR(bytes.NewReader(val.Raw)) err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
return si, err return si, err
} }
func (s *v0State) precommits() (adt.Map, error) { func (s *state0) precommits() (adt.Map, error) {
return v0adt.AsMap(s.store, s.PreCommittedSectors) return adt0.AsMap(s.store, s.PreCommittedSectors)
} }
func (s *v0State) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) { func (s *state0) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) {
var sp v0miner.SectorPreCommitOnChainInfo var sp miner0.SectorPreCommitOnChainInfo
err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw)) err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
return sp, err return sp, err
} }
func (d *v0Deadline) LoadPartition(idx uint64) (Partition, error) { func (d *deadline0) LoadPartition(idx uint64) (Partition, error) {
p, err := d.Deadline.LoadPartition(d.store, idx) p, err := d.Deadline.LoadPartition(d.store, idx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &v0Partition{*p, d.store}, nil return &partition0{*p, d.store}, nil
} }
func (d *v0Deadline) ForEachPartition(cb func(uint64, Partition) error) error { func (d *deadline0) ForEachPartition(cb func(uint64, Partition) error) error {
ps, err := d.Deadline.PartitionsArray(d.store) ps, err := d.Deadline.PartitionsArray(d.store)
if err != nil { if err != nil {
return err return err
} }
var part v0miner.Partition var part miner0.Partition
return ps.ForEach(&part, func(i int64) error { return ps.ForEach(&part, func(i int64) error {
return cb(uint64(i), &v0Partition{part, d.store}) return cb(uint64(i), &partition0{part, d.store})
}) })
} }
func (d *v0Deadline) PartitionsChanged(other Deadline) bool { func (d *deadline0) PartitionsChanged(other Deadline) bool {
v0other, ok := other.(*v0Deadline) other0, ok := other.(*deadline0)
if !ok { if !ok {
// treat an upgrade as a change, always // treat an upgrade as a change, always
return true return true
} }
return d.Deadline.Partitions.Equals(v0other.Deadline.Partitions) return d.Deadline.Partitions.Equals(other0.Deadline.Partitions)
} }
func (d *v0Deadline) PostSubmissions() (bitfield.BitField, error) { func (d *deadline0) PostSubmissions() (bitfield.BitField, error) {
return d.Deadline.PostSubmissions, nil return d.Deadline.PostSubmissions, nil
} }
func (p *v0Partition) AllSectors() (bitfield.BitField, error) { func (p *partition0) AllSectors() (bitfield.BitField, error) {
return p.Partition.Sectors, nil return p.Partition.Sectors, nil
} }
func (p *v0Partition) FaultySectors() (bitfield.BitField, error) { func (p *partition0) FaultySectors() (bitfield.BitField, error) {
return p.Partition.Faults, nil return p.Partition.Faults, nil
} }
func (p *v0Partition) RecoveringSectors() (bitfield.BitField, error) { func (p *partition0) RecoveringSectors() (bitfield.BitField, error) {
return p.Partition.Recoveries, nil return p.Partition.Recoveries, nil
} }

6
chain/actors/builtin/multisig/multisig.go
View File

@ -5,7 +5,7 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/cbor"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
@ -13,8 +13,8 @@ import (
func Load(store adt.Store, act *types.Actor) (State, error) { func Load(store adt.Store, act *types.Actor) (State, error) {
switch act.Code { switch act.Code {
case v0builtin.MultisigActorCodeID: case builtin0.MultisigActorCodeID:
out := v0State{store: store} out := state0{store: store}
err := store.Get(store.Context(), act.Head, &out) err := store.Get(store.Context(), act.Head, &out)
if err != nil { if err != nil {
return nil, err return nil, err

10
chain/actors/builtin/multisig/v0.go
View File

@ -6,23 +6,23 @@ import (
"github.com/filecoin-project/specs-actors/actors/builtin/multisig" "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
) )
type v0State struct { type state0 struct {
multisig.State multisig.State
store adt.Store store adt.Store
} }
func (s *v0State) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) { func (s *state0) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) {
return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil
} }
func (s *v0State) StartEpoch() abi.ChainEpoch { func (s *state0) StartEpoch() abi.ChainEpoch {
return s.State.StartEpoch return s.State.StartEpoch
} }
func (s *v0State) UnlockDuration() abi.ChainEpoch { func (s *state0) UnlockDuration() abi.ChainEpoch {
return s.State.UnlockDuration return s.State.UnlockDuration
} }
func (s *v0State) InitialBalance() abi.TokenAmount { func (s *state0) InitialBalance() abi.TokenAmount {
return s.State.InitialBalance return s.State.InitialBalance
} }

6
chain/actors/builtin/paych/paych.go
View File

@ -7,7 +7,7 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
big "github.com/filecoin-project/go-state-types/big" big "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/cbor"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
@ -16,8 +16,8 @@ import (
// Load returns an abstract copy of payment channel state, irregardless of actor version // Load returns an abstract copy of payment channel state, irregardless of actor version
func Load(store adt.Store, act *types.Actor) (State, error) { func Load(store adt.Store, act *types.Actor) (State, error) {
switch act.Code { switch act.Code {
case v0builtin.PaymentChannelActorCodeID: case builtin0.PaymentChannelActorCodeID:
out := v0State{store: store} out := state0{store: store}
err := store.Get(store.Context(), act.Head, &out) err := store.Get(store.Context(), act.Head, &out)
if err != nil { if err != nil {
return nil, err return nil, err

30
chain/actors/builtin/paych/v0.go
View File

@ -6,42 +6,42 @@ import (
big "github.com/filecoin-project/go-state-types/big" big "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/specs-actors/actors/builtin/paych" "github.com/filecoin-project/specs-actors/actors/builtin/paych"
v0adt "github.com/filecoin-project/specs-actors/actors/util/adt" adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
) )
type v0State struct { type state0 struct {
paych.State paych.State
store adt.Store store adt.Store
lsAmt *v0adt.Array lsAmt *adt0.Array
} }
// Channel owner, who has funded the actor // Channel owner, who has funded the actor
func (s *v0State) From() address.Address { func (s *state0) From() address.Address {
return s.State.From return s.State.From
} }
// Recipient of payouts from channel // Recipient of payouts from channel
func (s *v0State) To() address.Address { func (s *state0) To() address.Address {
return s.State.To return s.State.To
} }
// Height at which the channel can be `Collected` // Height at which the channel can be `Collected`
func (s *v0State) SettlingAt() abi.ChainEpoch { func (s *state0) SettlingAt() abi.ChainEpoch {
return s.State.SettlingAt return s.State.SettlingAt
} }
// Amount successfully redeemed through the payment channel, paid out on `Collect()` // Amount successfully redeemed through the payment channel, paid out on `Collect()`
func (s *v0State) ToSend() abi.TokenAmount { func (s *state0) ToSend() abi.TokenAmount {
return s.State.ToSend return s.State.ToSend
} }
func (s *v0State) getOrLoadLsAmt() (*v0adt.Array, error) { func (s *state0) getOrLoadLsAmt() (*adt0.Array, error) {
if s.lsAmt != nil { if s.lsAmt != nil {
return s.lsAmt, nil return s.lsAmt, nil
} }
// Get the lane state from the chain // Get the lane state from the chain
lsamt, err := v0adt.AsArray(s.store, s.State.LaneStates) lsamt, err := adt0.AsArray(s.store, s.State.LaneStates)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -51,7 +51,7 @@ func (s *v0State) getOrLoadLsAmt() (*v0adt.Array, error) {
} }
// Get total number of lanes // Get total number of lanes
func (s *v0State) LaneCount() (uint64, error) { func (s *state0) LaneCount() (uint64, error) {
lsamt, err := s.getOrLoadLsAmt() lsamt, err := s.getOrLoadLsAmt()
if err != nil { if err != nil {
return 0, err return 0, err
@ -60,7 +60,7 @@ func (s *v0State) LaneCount() (uint64, error) {
} }
// Iterate lane states // Iterate lane states
func (s *v0State) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error { func (s *state0) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error {
// Get the lane state from the chain // Get the lane state from the chain
lsamt, err := s.getOrLoadLsAmt() lsamt, err := s.getOrLoadLsAmt()
if err != nil { if err != nil {
@ -72,18 +72,18 @@ func (s *v0State) ForEachLaneState(cb func(idx uint64, dl LaneState) error) erro
// very large index. // very large index.
var ls paych.LaneState var ls paych.LaneState
return lsamt.ForEach(&ls, func(i int64) error { return lsamt.ForEach(&ls, func(i int64) error {
return cb(uint64(i), &v0LaneState{ls}) return cb(uint64(i), &laneState0{ls})
}) })
} }
type v0LaneState struct { type laneState0 struct {
paych.LaneState paych.LaneState
} }
func (ls *v0LaneState) Redeemed() big.Int { func (ls *laneState0) Redeemed() big.Int {
return ls.LaneState.Redeemed return ls.LaneState.Redeemed
} }
func (ls *v0LaneState) Nonce() uint64 { func (ls *laneState0) Nonce() uint64 {
return ls.LaneState.Nonce return ls.LaneState.Nonce
} }

8
chain/actors/builtin/power/power.go
View File

@ -6,19 +6,19 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/cbor"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/actors/builtin" "github.com/filecoin-project/lotus/chain/actors/builtin"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
) )
var Address = v0builtin.StoragePowerActorAddr var Address = builtin0.StoragePowerActorAddr
func Load(store adt.Store, act *types.Actor) (st State, err error) { func Load(store adt.Store, act *types.Actor) (st State, err error) {
switch act.Code { switch act.Code {
case v0builtin.StoragePowerActorCodeID: case builtin0.StoragePowerActorCodeID:
out := v0State{store: store} out := state0{store: store}
err := store.Get(store.Context(), act.Head, &out) err := store.Get(store.Context(), act.Head, &out)
if err != nil { if err != nil {
return nil, err return nil, err

24
chain/actors/builtin/power/v0.go
View File

@ -4,20 +4,20 @@ import (
"github.com/filecoin-project/go-address" "github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/lotus/chain/actors/builtin" "github.com/filecoin-project/lotus/chain/actors/builtin"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
"github.com/filecoin-project/specs-actors/actors/util/adt" "github.com/filecoin-project/specs-actors/actors/util/adt"
) )
type v0State struct { type state0 struct {
v0power.State power0.State
store adt.Store store adt.Store
} }
func (s *v0State) TotalLocked() (abi.TokenAmount, error) { func (s *state0) TotalLocked() (abi.TokenAmount, error) {
return s.TotalPledgeCollateral, nil return s.TotalPledgeCollateral, nil
} }
func (s *v0State) TotalPower() (Claim, error) { func (s *state0) TotalPower() (Claim, error) {
return Claim{ return Claim{
RawBytePower: s.TotalRawBytePower, RawBytePower: s.TotalRawBytePower,
QualityAdjPower: s.TotalQualityAdjPower, QualityAdjPower: s.TotalQualityAdjPower,
@ -25,19 +25,19 @@ func (s *v0State) TotalPower() (Claim, error) {
} }
// Committed power to the network. Includes miners below the minimum threshold. // Committed power to the network. Includes miners below the minimum threshold.
func (s *v0State) TotalCommitted() (Claim, error) { func (s *state0) TotalCommitted() (Claim, error) {
return Claim{ return Claim{
RawBytePower: s.TotalBytesCommitted, RawBytePower: s.TotalBytesCommitted,
QualityAdjPower: s.TotalQABytesCommitted, QualityAdjPower: s.TotalQABytesCommitted,
}, nil }, nil
} }
func (s *v0State) MinerPower(addr address.Address) (Claim, bool, error) { func (s *state0) MinerPower(addr address.Address) (Claim, bool, error) {
claims, err := adt.AsMap(s.store, s.Claims) claims, err := adt.AsMap(s.store, s.Claims)
if err != nil { if err != nil {
return Claim{}, false, err return Claim{}, false, err
} }
var claim v0power.Claim var claim power0.Claim
ok, err := claims.Get(abi.AddrKey(addr), &claim) ok, err := claims.Get(abi.AddrKey(addr), &claim)
if err != nil { if err != nil {
return Claim{}, false, err return Claim{}, false, err
@ -48,19 +48,19 @@ func (s *v0State) MinerPower(addr address.Address) (Claim, bool, error) {
}, ok, nil }, ok, nil
} }
func (s *v0State) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) { func (s *state0) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) {
return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a) return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a)
} }
func (s *v0State) TotalPowerSmoothed() (builtin.FilterEstimate, error) { func (s *state0) TotalPowerSmoothed() (builtin.FilterEstimate, error) {
return *s.State.ThisEpochQAPowerSmoothed, nil return *s.State.ThisEpochQAPowerSmoothed, nil
} }
func (s *v0State) MinerCounts() (uint64, uint64, error) { func (s *state0) MinerCounts() (uint64, uint64, error) {
return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil
} }
func (s *v0State) ListAllMiners() ([]address.Address, error) { func (s *state0) ListAllMiners() ([]address.Address, error) {
claims, err := adt.AsMap(s.store, s.Claims) claims, err := adt.AsMap(s.store, s.Claims)
if err != nil { if err != nil {
return nil, err return nil, err

8
chain/actors/builtin/reward/reward.go
View File

@ -5,19 +5,19 @@ import (
"golang.org/x/xerrors" "golang.org/x/xerrors"
"github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/cbor"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/actors/builtin" "github.com/filecoin-project/lotus/chain/actors/builtin"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
) )
var Address = v0builtin.RewardActorAddr var Address = builtin0.RewardActorAddr
func Load(store adt.Store, act *types.Actor) (st State, err error) { func Load(store adt.Store, act *types.Actor) (st State, err error) {
switch act.Code { switch act.Code {
case v0builtin.RewardActorCodeID: case builtin0.RewardActorCodeID:
out := v0State{store: store} out := state0{store: store}
err := store.Get(store.Context(), act.Head, &out) err := store.Get(store.Context(), act.Head, &out)
if err != nil { if err != nil {
return nil, err return nil, err

18
chain/actors/builtin/reward/v0.go
View File

@ -7,39 +7,39 @@ import (
"github.com/filecoin-project/specs-actors/actors/util/adt" "github.com/filecoin-project/specs-actors/actors/util/adt"
) )
type v0State struct { type state0 struct {
reward.State reward.State
store adt.Store store adt.Store
} }
func (s *v0State) ThisEpochReward() (abi.StoragePower, error) { func (s *state0) ThisEpochReward() (abi.StoragePower, error) {
return s.State.ThisEpochReward, nil return s.State.ThisEpochReward, nil
} }
func (s *v0State) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) { func (s *state0) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) {
return *s.State.ThisEpochRewardSmoothed, nil return *s.State.ThisEpochRewardSmoothed, nil
} }
func (s *v0State) ThisEpochBaselinePower() (abi.StoragePower, error) { func (s *state0) ThisEpochBaselinePower() (abi.StoragePower, error) {
return s.State.ThisEpochBaselinePower, nil return s.State.ThisEpochBaselinePower, nil
} }
func (s *v0State) TotalStoragePowerReward() (abi.TokenAmount, error) { func (s *state0) TotalStoragePowerReward() (abi.TokenAmount, error) {
return s.State.TotalMined, nil return s.State.TotalMined, nil
} }
func (s *v0State) EffectiveBaselinePower() (abi.StoragePower, error) { func (s *state0) EffectiveBaselinePower() (abi.StoragePower, error) {
return s.State.EffectiveBaselinePower, nil return s.State.EffectiveBaselinePower, nil
} }
func (s *v0State) EffectiveNetworkTime() (abi.ChainEpoch, error) { func (s *state0) EffectiveNetworkTime() (abi.ChainEpoch, error) {
return s.State.EffectiveNetworkTime, nil return s.State.EffectiveNetworkTime, nil
} }
func (s *v0State) CumsumBaseline() (abi.StoragePower, error) { func (s *state0) CumsumBaseline() (abi.StoragePower, error) {
return s.State.CumsumBaseline, nil return s.State.CumsumBaseline, nil
} }
func (s *v0State) CumsumRealized() (abi.StoragePower, error) { func (s *state0) CumsumRealized() (abi.StoragePower, error) {
return s.State.CumsumBaseline, nil return s.State.CumsumBaseline, nil
} }

12
chain/actors/builtin/verifreg/v0.go
View File

@ -4,24 +4,24 @@ import (
"github.com/filecoin-project/go-address" "github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
v0adt "github.com/filecoin-project/specs-actors/actors/util/adt" adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
"golang.org/x/xerrors" "golang.org/x/xerrors"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
) )
type v0State struct { type state0 struct {
v0verifreg.State verifreg0.State
store adt.Store store adt.Store
} }
func (s *v0State) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) { func (s *state0) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) {
if addr.Protocol() != address.ID { if addr.Protocol() != address.ID {
return false, big.Zero(), xerrors.Errorf("can only look up ID addresses") return false, big.Zero(), xerrors.Errorf("can only look up ID addresses")
} }
vh, err := v0adt.AsMap(s.store, s.VerifiedClients) vh, err := adt0.AsMap(s.store, s.VerifiedClients)
if err != nil { if err != nil {
return false, big.Zero(), xerrors.Errorf("loading verified clients: %w", err) return false, big.Zero(), xerrors.Errorf("loading verified clients: %w", err)
} }

8
chain/actors/builtin/verifreg/verifreg.go
View File

@ -6,18 +6,18 @@ import (
"golang.org/x/xerrors" "golang.org/x/xerrors"
"github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/cbor"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
) )
var Address = v0builtin.VerifiedRegistryActorAddr var Address = builtin0.VerifiedRegistryActorAddr
func Load(store adt.Store, act *types.Actor) (State, error) { func Load(store adt.Store, act *types.Actor) (State, error) {
switch act.Code { switch act.Code {
case v0builtin.VerifiedRegistryActorCodeID: case builtin0.VerifiedRegistryActorCodeID:
out := v0State{store: store} out := state0{store: store}
err := store.Get(store.Context(), act.Head, &out) err := store.Get(store.Context(), act.Head, &out)
if err != nil { if err != nil {
return nil, err return nil, err

4
chain/events/state/predicates.go
View File

@ -509,12 +509,12 @@ func (sp *StatePredicates) OnAddressMapChange() DiffInitActorStateFunc {
return false, nil, nil return false, nil, nil
} }
oldAddrs, err := v0adt.AsMap(ctxStore, oldState.AddressMap) oldAddrs, err := adt0.AsMap(ctxStore, oldState.AddressMap)
if err != nil { if err != nil {
return false, nil, err return false, nil, err
} }
newAddrs, err := v0adt.AsMap(ctxStore, newState.AddressMap) newAddrs, err := adt0.AsMap(ctxStore, newState.AddressMap)
if err != nil { if err != nil {
return false, nil, err return false, nil, err
} }

78
chain/events/state/predicates_test.go
View File

@ -19,10 +19,10 @@ import (
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/go-state-types/crypto" "github.com/filecoin-project/go-state-types/crypto"
"github.com/filecoin-project/lotus/chain/actors/builtin/market" "github.com/filecoin-project/lotus/chain/actors/builtin/market"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
v0market "github.com/filecoin-project/specs-actors/actors/builtin/market" market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/filecoin-project/specs-actors/actors/util/adt" "github.com/filecoin-project/specs-actors/actors/util/adt"
tutils "github.com/filecoin-project/specs-actors/support/testing" tutils "github.com/filecoin-project/specs-actors/support/testing"
@ -74,22 +74,22 @@ func TestMarketPredicates(t *testing.T) {
bs := bstore.NewTemporarySync() bs := bstore.NewTemporarySync()
store := adt.WrapStore(ctx, cbornode.NewCborStore(bs)) store := adt.WrapStore(ctx, cbornode.NewCborStore(bs))
oldDeal1 := &v0market.DealState{ oldDeal1 := &market0.DealState{
SectorStartEpoch: 1, SectorStartEpoch: 1,
LastUpdatedEpoch: 2, LastUpdatedEpoch: 2,
SlashEpoch: 0, SlashEpoch: 0,
} }
oldDeal2 := &v0market.DealState{ oldDeal2 := &market0.DealState{
SectorStartEpoch: 4, SectorStartEpoch: 4,
LastUpdatedEpoch: 5, LastUpdatedEpoch: 5,
SlashEpoch: 0, SlashEpoch: 0,
} }
oldDeals := map[abi.DealID]*v0market.DealState{ oldDeals := map[abi.DealID]*market0.DealState{
abi.DealID(1): oldDeal1, abi.DealID(1): oldDeal1,
abi.DealID(2): oldDeal2, abi.DealID(2): oldDeal2,
} }
oldProp1 := &v0market.DealProposal{ oldProp1 := &market0.DealProposal{
PieceCID: dummyCid, PieceCID: dummyCid,
PieceSize: 0, PieceSize: 0,
VerifiedDeal: false, VerifiedDeal: false,
@ -101,7 +101,7 @@ func TestMarketPredicates(t *testing.T) {
ProviderCollateral: big.Zero(), ProviderCollateral: big.Zero(),
ClientCollateral: big.Zero(), ClientCollateral: big.Zero(),
} }
oldProp2 := &v0market.DealProposal{ oldProp2 := &market0.DealProposal{
PieceCID: dummyCid, PieceCID: dummyCid,
PieceSize: 0, PieceSize: 0,
VerifiedDeal: false, VerifiedDeal: false,
@ -113,7 +113,7 @@ func TestMarketPredicates(t *testing.T) {
ProviderCollateral: big.Zero(), ProviderCollateral: big.Zero(),
ClientCollateral: big.Zero(), ClientCollateral: big.Zero(),
} }
oldProps := map[abi.DealID]*v0market.DealProposal{ oldProps := map[abi.DealID]*market0.DealProposal{
abi.DealID(1): oldProp1, abi.DealID(1): oldProp1,
abi.DealID(2): oldProp2, abi.DealID(2): oldProp2,
} }
@ -127,7 +127,7 @@ func TestMarketPredicates(t *testing.T) {
oldStateC := createMarketState(ctx, t, store, oldDeals, oldProps, oldBalances) oldStateC := createMarketState(ctx, t, store, oldDeals, oldProps, oldBalances)
newDeal1 := &v0market.DealState{ newDeal1 := &market0.DealState{
SectorStartEpoch: 1, SectorStartEpoch: 1,
LastUpdatedEpoch: 3, LastUpdatedEpoch: 3,
SlashEpoch: 0, SlashEpoch: 0,
@ -136,19 +136,19 @@ func TestMarketPredicates(t *testing.T) {
// deal 2 removed // deal 2 removed
// added // added
newDeal3 := &v0market.DealState{ newDeal3 := &market0.DealState{
SectorStartEpoch: 1, SectorStartEpoch: 1,
LastUpdatedEpoch: 2, LastUpdatedEpoch: 2,
SlashEpoch: 3, SlashEpoch: 3,
} }
newDeals := map[abi.DealID]*v0market.DealState{ newDeals := map[abi.DealID]*market0.DealState{
abi.DealID(1): newDeal1, abi.DealID(1): newDeal1,
// deal 2 was removed // deal 2 was removed
abi.DealID(3): newDeal3, abi.DealID(3): newDeal3,
} }
// added // added
newProp3 := &v0market.DealProposal{ newProp3 := &market0.DealProposal{
PieceCID: dummyCid, PieceCID: dummyCid,
PieceSize: 0, PieceSize: 0,
VerifiedDeal: false, VerifiedDeal: false,
@ -160,7 +160,7 @@ func TestMarketPredicates(t *testing.T) {
ProviderCollateral: big.Zero(), ProviderCollateral: big.Zero(),
ClientCollateral: big.Zero(), ClientCollateral: big.Zero(),
} }
newProps := map[abi.DealID]*v0market.DealProposal{ newProps := map[abi.DealID]*market0.DealProposal{
abi.DealID(1): oldProp1, // 1 was persisted abi.DealID(1): oldProp1, // 1 was persisted
// prop 2 was removed // prop 2 was removed
abi.DealID(3): newProp3, // new abi.DealID(3): newProp3, // new
@ -183,8 +183,8 @@ func TestMarketPredicates(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
api := newMockAPI(bs) api := newMockAPI(bs)
api.setActor(oldState.Key(), &types.Actor{Code: v0builtin.StorageMarketActorCodeID, Head: oldStateC}) api.setActor(oldState.Key(), &types.Actor{Code: builtin0.StorageMarketActorCodeID, Head: oldStateC})
api.setActor(newState.Key(), &types.Actor{Code: v0builtin.StorageMarketActorCodeID, Head: newStateC}) api.setActor(newState.Key(), &types.Actor{Code: builtin0.StorageMarketActorCodeID, Head: newStateC})
t.Run("deal ID predicate", func(t *testing.T) { t.Run("deal ID predicate", func(t *testing.T) {
preds := NewStatePredicates(api) preds := NewStatePredicates(api)
@ -239,11 +239,11 @@ func TestMarketPredicates(t *testing.T) {
t.Fatal("No state change so this should not be called") t.Fatal("No state change so this should not be called")
return false, nil, nil return false, nil, nil
}) })
v0marketState := createEmptyMarketState(t, store) marketState0 := createEmptyMarketState(t, store)
marketCid, err := store.Put(ctx, v0marketState) marketCid, err := store.Put(ctx, marketState0)
require.NoError(t, err) require.NoError(t, err)
marketState, err := market.Load(store, &types.Actor{ marketState, err := market.Load(store, &types.Actor{
Code: v0builtin.StorageMarketActorCodeID, Code: builtin0.StorageMarketActorCodeID,
Head: marketCid, Head: marketCid,
}) })
require.NoError(t, err) require.NoError(t, err)
@ -352,11 +352,11 @@ func TestMarketPredicates(t *testing.T) {
t.Fatal("No state change so this should not be called") t.Fatal("No state change so this should not be called")
return false, nil, nil return false, nil, nil
}) })
v0marketState := createEmptyMarketState(t, store) marketState0 := createEmptyMarketState(t, store)
marketCid, err := store.Put(ctx, v0marketState) marketCid, err := store.Put(ctx, marketState0)
require.NoError(t, err) require.NoError(t, err)
marketState, err := market.Load(store, &types.Actor{ marketState, err := market.Load(store, &types.Actor{
Code: v0builtin.StorageMarketActorCodeID, Code: builtin0.StorageMarketActorCodeID,
Head: marketCid, Head: marketCid,
}) })
require.NoError(t, err) require.NoError(t, err)
@ -379,12 +379,12 @@ func TestMinerSectorChange(t *testing.T) {
} }
owner, worker := nextIDAddrF(), nextIDAddrF() owner, worker := nextIDAddrF(), nextIDAddrF()
si0 := newSectorOnChainInfo(0, tutils.MakeCID("0", &v0miner.SealedCIDPrefix), big.NewInt(0), abi.ChainEpoch(0), abi.ChainEpoch(10)) si0 := newSectorOnChainInfo(0, tutils.MakeCID("0", &miner0.SealedCIDPrefix), big.NewInt(0), abi.ChainEpoch(0), abi.ChainEpoch(10))
si1 := newSectorOnChainInfo(1, tutils.MakeCID("1", &v0miner.SealedCIDPrefix), big.NewInt(1), abi.ChainEpoch(1), abi.ChainEpoch(11)) si1 := newSectorOnChainInfo(1, tutils.MakeCID("1", &miner0.SealedCIDPrefix), big.NewInt(1), abi.ChainEpoch(1), abi.ChainEpoch(11))
si2 := newSectorOnChainInfo(2, tutils.MakeCID("2", &v0miner.SealedCIDPrefix), big.NewInt(2), abi.ChainEpoch(2), abi.ChainEpoch(11)) si2 := newSectorOnChainInfo(2, tutils.MakeCID("2", &miner0.SealedCIDPrefix), big.NewInt(2), abi.ChainEpoch(2), abi.ChainEpoch(11))
oldMinerC := createMinerState(ctx, t, store, owner, worker, []miner.SectorOnChainInfo{si0, si1, si2}) oldMinerC := createMinerState(ctx, t, store, owner, worker, []miner.SectorOnChainInfo{si0, si1, si2})
si3 := newSectorOnChainInfo(3, tutils.MakeCID("3", &v0miner.SealedCIDPrefix), big.NewInt(3), abi.ChainEpoch(3), abi.ChainEpoch(12)) si3 := newSectorOnChainInfo(3, tutils.MakeCID("3", &miner0.SealedCIDPrefix), big.NewInt(3), abi.ChainEpoch(3), abi.ChainEpoch(12))
// 0 delete // 0 delete
// 1 extend // 1 extend
// 2 same // 2 same
@ -400,8 +400,8 @@ func TestMinerSectorChange(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
api := newMockAPI(bs) api := newMockAPI(bs)
api.setActor(oldState.Key(), &types.Actor{Head: oldMinerC, Code: v0builtin.StorageMinerActorCodeID}) api.setActor(oldState.Key(), &types.Actor{Head: oldMinerC, Code: builtin0.StorageMinerActorCodeID})
api.setActor(newState.Key(), &types.Actor{Head: newMinerC, Code: v0builtin.StorageMinerActorCodeID}) api.setActor(newState.Key(), &types.Actor{Head: newMinerC, Code: builtin0.StorageMinerActorCodeID})
preds := NewStatePredicates(api) preds := NewStatePredicates(api)
@ -467,7 +467,7 @@ type balance struct {
locked abi.TokenAmount locked abi.TokenAmount
} }
func createMarketState(ctx context.Context, t *testing.T, store adt.Store, deals map[abi.DealID]*v0market.DealState, props map[abi.DealID]*v0market.DealProposal, balances map[address.Address]balance) cid.Cid { func createMarketState(ctx context.Context, t *testing.T, store adt.Store, deals map[abi.DealID]*market0.DealState, props map[abi.DealID]*market0.DealProposal, balances map[address.Address]balance) cid.Cid {
dealRootCid := createDealAMT(ctx, t, store, deals) dealRootCid := createDealAMT(ctx, t, store, deals)
propRootCid := createProposalAMT(ctx, t, store, props) propRootCid := createProposalAMT(ctx, t, store, props)
balancesCids := createBalanceTable(ctx, t, store, balances) balancesCids := createBalanceTable(ctx, t, store, balances)
@ -482,15 +482,15 @@ func createMarketState(ctx context.Context, t *testing.T, store adt.Store, deals
return stateC return stateC
} }
func createEmptyMarketState(t *testing.T, store adt.Store) *v0market.State { func createEmptyMarketState(t *testing.T, store adt.Store) *market0.State {
emptyArrayCid, err := adt.MakeEmptyArray(store).Root() emptyArrayCid, err := adt.MakeEmptyArray(store).Root()
require.NoError(t, err) require.NoError(t, err)
emptyMap, err := adt.MakeEmptyMap(store).Root() emptyMap, err := adt.MakeEmptyMap(store).Root()
require.NoError(t, err) require.NoError(t, err)
return v0market.ConstructState(emptyArrayCid, emptyMap, emptyMap) return market0.ConstructState(emptyArrayCid, emptyMap, emptyMap)
} }
func createDealAMT(ctx context.Context, t *testing.T, store adt.Store, deals map[abi.DealID]*v0market.DealState) cid.Cid { func createDealAMT(ctx context.Context, t *testing.T, store adt.Store, deals map[abi.DealID]*market0.DealState) cid.Cid {
root := adt.MakeEmptyArray(store) root := adt.MakeEmptyArray(store)
for dealID, dealState := range deals { for dealID, dealState := range deals {
err := root.Set(uint64(dealID), dealState) err := root.Set(uint64(dealID), dealState)
@ -501,7 +501,7 @@ func createDealAMT(ctx context.Context, t *testing.T, store adt.Store, deals map
return rootCid return rootCid
} }
func createProposalAMT(ctx context.Context, t *testing.T, store adt.Store, props map[abi.DealID]*v0market.DealProposal) cid.Cid { func createProposalAMT(ctx context.Context, t *testing.T, store adt.Store, props map[abi.DealID]*market0.DealProposal) cid.Cid {
root := adt.MakeEmptyArray(store) root := adt.MakeEmptyArray(store)
for dealID, prop := range props { for dealID, prop := range props {
err := root.Set(uint64(dealID), prop) err := root.Set(uint64(dealID), prop)
@ -549,20 +549,20 @@ func createMinerState(ctx context.Context, t *testing.T, store adt.Store, owner,
return stateC return stateC
} }
func createEmptyMinerState(ctx context.Context, t *testing.T, store adt.Store, owner, worker address.Address) *v0miner.State { func createEmptyMinerState(ctx context.Context, t *testing.T, store adt.Store, owner, worker address.Address) *miner0.State {
emptyArrayCid, err := adt.MakeEmptyArray(store).Root() emptyArrayCid, err := adt.MakeEmptyArray(store).Root()
require.NoError(t, err) require.NoError(t, err)
emptyMap, err := adt.MakeEmptyMap(store).Root() emptyMap, err := adt.MakeEmptyMap(store).Root()
require.NoError(t, err) require.NoError(t, err)
emptyDeadline, err := store.Put(store.Context(), v0miner.ConstructDeadline(emptyArrayCid)) emptyDeadline, err := store.Put(store.Context(), miner0.ConstructDeadline(emptyArrayCid))
require.NoError(t, err) require.NoError(t, err)
emptyVestingFunds := v0miner.ConstructVestingFunds() emptyVestingFunds := miner0.ConstructVestingFunds()
emptyVestingFundsCid, err := store.Put(store.Context(), emptyVestingFunds) emptyVestingFundsCid, err := store.Put(store.Context(), emptyVestingFunds)
require.NoError(t, err) require.NoError(t, err)
emptyDeadlines := v0miner.ConstructDeadlines(emptyDeadline) emptyDeadlines := miner0.ConstructDeadlines(emptyDeadline)
emptyDeadlinesCid, err := store.Put(store.Context(), emptyDeadlines) emptyDeadlinesCid, err := store.Put(store.Context(), emptyDeadlines)
require.NoError(t, err) require.NoError(t, err)
@ -572,7 +572,7 @@ func createEmptyMinerState(ctx context.Context, t *testing.T, store adt.Store, o
emptyBitfieldCid, err := store.Put(store.Context(), emptyBitfield) emptyBitfieldCid, err := store.Put(store.Context(), emptyBitfield)
require.NoError(t, err) require.NoError(t, err)
state, err := v0miner.ConstructState(minerInfo, 123, emptyBitfieldCid, emptyArrayCid, emptyMap, emptyDeadlinesCid, emptyVestingFundsCid) state, err := miner0.ConstructState(minerInfo, 123, emptyBitfieldCid, emptyArrayCid, emptyMap, emptyDeadlinesCid, emptyVestingFundsCid)
require.NoError(t, err) require.NoError(t, err)
return state return state
@ -625,7 +625,7 @@ func newSectorPreCommitInfo(sectorNo abi.SectorNumber, sealed cid.Cid, expiratio
} }
} }
func dealEquality(expected v0market.DealState, actual market.DealState) bool { func dealEquality(expected market0.DealState, actual market.DealState) bool {
return expected.LastUpdatedEpoch == actual.LastUpdatedEpoch && return expected.LastUpdatedEpoch == actual.LastUpdatedEpoch &&
expected.SectorStartEpoch == actual.SectorStartEpoch && expected.SectorStartEpoch == actual.SectorStartEpoch &&
expected.SlashEpoch == actual.SlashEpoch expected.SlashEpoch == actual.SlashEpoch

4
chain/gen/gen.go
View File

@ -14,7 +14,7 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/go-state-types/crypto" "github.com/filecoin-project/go-state-types/crypto"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
block "github.com/ipfs/go-block-format" block "github.com/ipfs/go-block-format"
"github.com/ipfs/go-blockservice" "github.com/ipfs/go-blockservice"
"github.com/ipfs/go-cid" "github.com/ipfs/go-cid"
@ -121,7 +121,7 @@ var DefaultRemainderAccountActor = genesis.Actor{
} }
func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) { func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
v0miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{ miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
abi.RegisteredSealProof_StackedDrg2KiBV1: {}, abi.RegisteredSealProof_StackedDrg2KiBV1: {},
} }

12
chain/gen/gen_test.go
View File

@ -5,20 +5,20 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
_ "github.com/filecoin-project/lotus/lib/sigs/bls" _ "github.com/filecoin-project/lotus/lib/sigs/bls"
_ "github.com/filecoin-project/lotus/lib/sigs/secp" _ "github.com/filecoin-project/lotus/lib/sigs/secp"
) )
func init() { func init() {
v0miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{ miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
abi.RegisteredSealProof_StackedDrg2KiBV1: {}, abi.RegisteredSealProof_StackedDrg2KiBV1: {},
} }
v0power.ConsensusMinerMinPower = big.NewInt(2048) power0.ConsensusMinerMinPower = big.NewInt(2048)
v0verifreg.MinVerifiedDealSize = big.NewInt(256) verifreg0.MinVerifiedDealSize = big.NewInt(256)
} }
func testGeneration(t testing.TB, n int, msgs int, sectors int) { func testGeneration(t testing.TB, n int, msgs int, sectors int) {

60
chain/gen/genesis/genesis.go
View File

@ -17,11 +17,11 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/go-state-types/crypto" "github.com/filecoin-project/go-state-types/crypto"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
v0account "github.com/filecoin-project/specs-actors/actors/builtin/account" account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
v0multisig "github.com/filecoin-project/specs-actors/actors/builtin/multisig" multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
v0adt "github.com/filecoin-project/specs-actors/actors/util/adt" adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/actors/builtin" "github.com/filecoin-project/lotus/chain/actors/builtin"
@ -126,7 +126,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
if err != nil { if err != nil {
return nil, nil, xerrors.Errorf("setup init actor: %w", err) return nil, nil, xerrors.Errorf("setup init actor: %w", err)
} }
if err := state.SetActor(v0builtin.SystemActorAddr, sysact); err != nil { if err := state.SetActor(builtin0.SystemActorAddr, sysact); err != nil {
return nil, nil, xerrors.Errorf("set init actor: %w", err) return nil, nil, xerrors.Errorf("set init actor: %w", err)
} }
@ -136,7 +136,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
if err != nil { if err != nil {
return nil, nil, xerrors.Errorf("setup init actor: %w", err) return nil, nil, xerrors.Errorf("setup init actor: %w", err)
} }
if err := state.SetActor(v0builtin.InitActorAddr, initact); err != nil { if err := state.SetActor(builtin0.InitActorAddr, initact); err != nil {
return nil, nil, xerrors.Errorf("set init actor: %w", err) return nil, nil, xerrors.Errorf("set init actor: %w", err)
} }
@ -147,7 +147,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
return nil, nil, xerrors.Errorf("setup init actor: %w", err) return nil, nil, xerrors.Errorf("setup init actor: %w", err)
} }
err = state.SetActor(v0builtin.RewardActorAddr, rewact) err = state.SetActor(builtin0.RewardActorAddr, rewact)
if err != nil { if err != nil {
return nil, nil, xerrors.Errorf("set network account actor: %w", err) return nil, nil, xerrors.Errorf("set network account actor: %w", err)
} }
@ -157,7 +157,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
if err != nil { if err != nil {
return nil, nil, xerrors.Errorf("setup cron actor: %w", err) return nil, nil, xerrors.Errorf("setup cron actor: %w", err)
} }
if err := state.SetActor(v0builtin.CronActorAddr, cronact); err != nil { if err := state.SetActor(builtin0.CronActorAddr, cronact); err != nil {
return nil, nil, xerrors.Errorf("set cron actor: %w", err) return nil, nil, xerrors.Errorf("set cron actor: %w", err)
} }
@ -166,7 +166,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
if err != nil { if err != nil {
return nil, nil, xerrors.Errorf("setup storage market actor: %w", err) return nil, nil, xerrors.Errorf("setup storage market actor: %w", err)
} }
if err := state.SetActor(v0builtin.StoragePowerActorAddr, spact); err != nil { if err := state.SetActor(builtin0.StoragePowerActorAddr, spact); err != nil {
return nil, nil, xerrors.Errorf("set storage market actor: %w", err) return nil, nil, xerrors.Errorf("set storage market actor: %w", err)
} }
@ -175,7 +175,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
if err != nil { if err != nil {
return nil, nil, xerrors.Errorf("setup storage market actor: %w", err) return nil, nil, xerrors.Errorf("setup storage market actor: %w", err)
} }
if err := state.SetActor(v0builtin.StorageMarketActorAddr, marketact); err != nil { if err := state.SetActor(builtin0.StorageMarketActorAddr, marketact); err != nil {
return nil, nil, xerrors.Errorf("set market actor: %w", err) return nil, nil, xerrors.Errorf("set market actor: %w", err)
} }
@ -184,20 +184,20 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
if err != nil { if err != nil {
return nil, nil, xerrors.Errorf("setup storage market actor: %w", err) return nil, nil, xerrors.Errorf("setup storage market actor: %w", err)
} }
if err := state.SetActor(v0builtin.VerifiedRegistryActorAddr, verifact); err != nil { if err := state.SetActor(builtin0.VerifiedRegistryActorAddr, verifact); err != nil {
return nil, nil, xerrors.Errorf("set market actor: %w", err) return nil, nil, xerrors.Errorf("set market actor: %w", err)
} }
burntRoot, err := cst.Put(ctx, &v0account.State{ burntRoot, err := cst.Put(ctx, &account0.State{
Address: v0builtin.BurntFundsActorAddr, Address: builtin0.BurntFundsActorAddr,
}) })
if err != nil { if err != nil {
return nil, nil, xerrors.Errorf("failed to setup burnt funds actor state: %w", err) return nil, nil, xerrors.Errorf("failed to setup burnt funds actor state: %w", err)
} }
// Setup burnt-funds // Setup burnt-funds
err = state.SetActor(v0builtin.BurntFundsActorAddr, &types.Actor{ err = state.SetActor(builtin0.BurntFundsActorAddr, &types.Actor{
Code: v0builtin.AccountActorCodeID, Code: builtin0.AccountActorCodeID,
Balance: types.NewInt(0), Balance: types.NewInt(0),
Head: burntRoot, Head: burntRoot,
}) })
@ -262,13 +262,13 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
return nil, nil, err return nil, nil, err
} }
verifierState, err := cst.Put(ctx, &v0account.State{Address: verifierAd}) verifierState, err := cst.Put(ctx, &account0.State{Address: verifierAd})
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
err = state.SetActor(verifierId, &types.Actor{ err = state.SetActor(verifierId, &types.Actor{
Code: v0builtin.AccountActorCodeID, Code: builtin0.AccountActorCodeID,
Balance: types.NewInt(0), Balance: types.NewInt(0),
Head: verifierState, Head: verifierState,
}) })
@ -315,7 +315,7 @@ func createAccountActor(ctx context.Context, cst cbor.IpldStore, state *state.St
if err := json.Unmarshal(info.Meta, &ainfo); err != nil { if err := json.Unmarshal(info.Meta, &ainfo); err != nil {
return xerrors.Errorf("unmarshaling account meta: %w", err) return xerrors.Errorf("unmarshaling account meta: %w", err)
} }
st, err := cst.Put(ctx, &v0account.State{Address: ainfo.Owner}) st, err := cst.Put(ctx, &account0.State{Address: ainfo.Owner})
if err != nil { if err != nil {
return err return err
} }
@ -326,7 +326,7 @@ func createAccountActor(ctx context.Context, cst cbor.IpldStore, state *state.St
} }
err = state.SetActor(ida, &types.Actor{ err = state.SetActor(ida, &types.Actor{
Code: v0builtin.AccountActorCodeID, Code: builtin0.AccountActorCodeID,
Balance: info.Balance, Balance: info.Balance,
Head: st, Head: st,
}) })
@ -344,7 +344,7 @@ func createMultisigAccount(ctx context.Context, bs bstore.Blockstore, cst cbor.I
if err := json.Unmarshal(info.Meta, &ainfo); err != nil { if err := json.Unmarshal(info.Meta, &ainfo); err != nil {
return xerrors.Errorf("unmarshaling account meta: %w", err) return xerrors.Errorf("unmarshaling account meta: %w", err)
} }
pending, err := v0adt.MakeEmptyMap(v0adt.WrapStore(ctx, cst)).Root() pending, err := adt0.MakeEmptyMap(adt0.WrapStore(ctx, cst)).Root()
if err != nil { if err != nil {
return xerrors.Errorf("failed to create empty map: %v", err) return xerrors.Errorf("failed to create empty map: %v", err)
} }
@ -364,12 +364,12 @@ func createMultisigAccount(ctx context.Context, bs bstore.Blockstore, cst cbor.I
continue continue
} }
st, err := cst.Put(ctx, &v0account.State{Address: e}) st, err := cst.Put(ctx, &account0.State{Address: e})
if err != nil { if err != nil {
return err return err
} }
err = state.SetActor(idAddress, &types.Actor{ err = state.SetActor(idAddress, &types.Actor{
Code: v0builtin.AccountActorCodeID, Code: builtin0.AccountActorCodeID,
Balance: types.NewInt(0), Balance: types.NewInt(0),
Head: st, Head: st,
}) })
@ -379,7 +379,7 @@ func createMultisigAccount(ctx context.Context, bs bstore.Blockstore, cst cbor.I
signers = append(signers, idAddress) signers = append(signers, idAddress)
} }
st, err := cst.Put(ctx, &v0multisig.State{ st, err := cst.Put(ctx, &multisig0.State{
Signers: signers, Signers: signers,
NumApprovalsThreshold: uint64(ainfo.Threshold), NumApprovalsThreshold: uint64(ainfo.Threshold),
StartEpoch: abi.ChainEpoch(ainfo.VestingStart), StartEpoch: abi.ChainEpoch(ainfo.VestingStart),
@ -391,7 +391,7 @@ func createMultisigAccount(ctx context.Context, bs bstore.Blockstore, cst cbor.I
return err return err
} }
err = state.SetActor(ida, &types.Actor{ err = state.SetActor(ida, &types.Actor{
Code: v0builtin.MultisigActorCodeID, Code: builtin0.MultisigActorCodeID,
Balance: info.Balance, Balance: info.Balance,
Head: st, Head: st,
}) })
@ -442,7 +442,7 @@ func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot ci
return cid.Undef, err return cid.Undef, err
} }
_, err = doExecValue(ctx, vm, v0builtin.VerifiedRegistryActorAddr, verifregRoot, types.NewInt(0), v0builtin.MethodsVerifiedRegistry.AddVerifier, mustEnc(&v0verifreg.AddVerifierParams{ _, err = doExecValue(ctx, vm, builtin0.VerifiedRegistryActorAddr, verifregRoot, types.NewInt(0), builtin0.MethodsVerifiedRegistry.AddVerifier, mustEnc(&verifreg0.AddVerifierParams{
Address: verifier, Address: verifier,
Allowance: abi.NewStoragePower(int64(sum)), // eh, close enough Allowance: abi.NewStoragePower(int64(sum)), // eh, close enough
@ -453,7 +453,7 @@ func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot ci
} }
for c, amt := range verifNeeds { for c, amt := range verifNeeds {
_, err := doExecValue(ctx, vm, v0builtin.VerifiedRegistryActorAddr, verifier, types.NewInt(0), v0builtin.MethodsVerifiedRegistry.AddVerifiedClient, mustEnc(&v0verifreg.AddVerifiedClientParams{ _, err := doExecValue(ctx, vm, builtin0.VerifiedRegistryActorAddr, verifier, types.NewInt(0), builtin0.MethodsVerifiedRegistry.AddVerifiedClient, mustEnc(&verifreg0.AddVerifiedClientParams{
Address: c, Address: c,
Allowance: abi.NewStoragePower(int64(amt)), Allowance: abi.NewStoragePower(int64(amt)),
})) }))
@ -495,8 +495,8 @@ func MakeGenesisBlock(ctx context.Context, bs bstore.Blockstore, sys vm.SyscallB
return nil, xerrors.Errorf("setup miners failed: %w", err) return nil, xerrors.Errorf("setup miners failed: %w", err)
} }
store := v0adt.WrapStore(ctx, cbor.NewCborStore(bs)) store := adt0.WrapStore(ctx, cbor.NewCborStore(bs))
emptyroot, err := v0adt.MakeEmptyArray(store).Root() emptyroot, err := adt0.MakeEmptyArray(store).Root()
if err != nil { if err != nil {
return nil, xerrors.Errorf("amt build failed: %w", err) return nil, xerrors.Errorf("amt build failed: %w", err)
} }
@ -544,7 +544,7 @@ func MakeGenesisBlock(ctx context.Context, bs bstore.Blockstore, sys vm.SyscallB
} }
b := &types.BlockHeader{ b := &types.BlockHeader{
Miner: v0builtin.SystemActorAddr, Miner: builtin0.SystemActorAddr,
Ticket: genesisticket, Ticket: genesisticket,
Parents: []cid.Cid{filecoinGenesisCid}, Parents: []cid.Cid{filecoinGenesisCid},
Height: 0, Height: 0,

42
chain/gen/genesis/miners.go
View File

@ -20,9 +20,9 @@ import (
"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper" "github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/specs-actors/actors/builtin/market" "github.com/filecoin-project/specs-actors/actors/builtin/market"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
v0reward "github.com/filecoin-project/specs-actors/actors/builtin/reward" reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
"github.com/filecoin-project/specs-actors/actors/runtime" "github.com/filecoin-project/specs-actors/actors/runtime"
"github.com/filecoin-project/lotus/chain/state" "github.com/filecoin-project/lotus/chain/state"
@ -101,7 +101,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
} }
{ {
constructorParams := &v0power.CreateMinerParams{ constructorParams := &power0.CreateMinerParams{
Owner: m.Worker, Owner: m.Worker,
Worker: m.Worker, Worker: m.Worker,
Peer: []byte(m.PeerId), Peer: []byte(m.PeerId),
@ -114,7 +114,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err) return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err)
} }
var ma v0power.CreateMinerReturn var ma power0.CreateMinerReturn
if err := ma.UnmarshalCBOR(bytes.NewReader(rval)); err != nil { if err := ma.UnmarshalCBOR(bytes.NewReader(rval)); err != nil {
return cid.Undef, xerrors.Errorf("unmarshaling CreateMinerReturn: %w", err) return cid.Undef, xerrors.Errorf("unmarshaling CreateMinerReturn: %w", err)
} }
@ -126,9 +126,9 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
minerInfos[i].maddr = ma.IDAddress minerInfos[i].maddr = ma.IDAddress
// TODO: ActorUpgrade // TODO: ActorUpgrade
err = vm.MutateState(ctx, minerInfos[i].maddr, func(cst cbor.IpldStore, st *v0miner.State) error { err = vm.MutateState(ctx, minerInfos[i].maddr, func(cst cbor.IpldStore, st *miner0.State) error {
maxPeriods := v0miner.MaxSectorExpirationExtension / v0miner.WPoStProvingPeriod maxPeriods := miner0.MaxSectorExpirationExtension / miner0.WPoStProvingPeriod
minerInfos[i].presealExp = (maxPeriods-1)*v0miner.WPoStProvingPeriod + st.ProvingPeriodStart - 1 minerInfos[i].presealExp = (maxPeriods-1)*miner0.WPoStProvingPeriod + st.ProvingPeriodStart - 1
return nil return nil
}) })
@ -204,13 +204,13 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
return cid.Undef, xerrors.Errorf("getting deal weight: %w", err) return cid.Undef, xerrors.Errorf("getting deal weight: %w", err)
} }
sectorWeight := v0miner.QAPowerForWeight(m.SectorSize, minerInfos[i].presealExp, dweight.DealWeight, dweight.VerifiedDealWeight) sectorWeight := miner0.QAPowerForWeight(m.SectorSize, minerInfos[i].presealExp, dweight.DealWeight, dweight.VerifiedDealWeight)
qaPow = types.BigAdd(qaPow, sectorWeight) qaPow = types.BigAdd(qaPow, sectorWeight)
} }
} }
err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *v0power.State) error { err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power0.State) error {
st.TotalQualityAdjPower = qaPow st.TotalQualityAdjPower = qaPow
st.TotalRawBytePower = rawPow st.TotalRawBytePower = rawPow
@ -222,8 +222,8 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
return cid.Undef, xerrors.Errorf("mutating state: %w", err) return cid.Undef, xerrors.Errorf("mutating state: %w", err)
} }
err = vm.MutateState(ctx, builtin.RewardActorAddr, func(sct cbor.IpldStore, st *v0reward.State) error { err = vm.MutateState(ctx, builtin.RewardActorAddr, func(sct cbor.IpldStore, st *reward0.State) error {
*st = *v0reward.ConstructState(qaPow) *st = *reward0.ConstructState(qaPow)
return nil return nil
}) })
if err != nil { if err != nil {
@ -249,10 +249,10 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
return cid.Undef, xerrors.Errorf("getting deal weight: %w", err) return cid.Undef, xerrors.Errorf("getting deal weight: %w", err)
} }
sectorWeight := v0miner.QAPowerForWeight(m.SectorSize, minerInfos[i].presealExp, dweight.DealWeight, dweight.VerifiedDealWeight) sectorWeight := miner0.QAPowerForWeight(m.SectorSize, minerInfos[i].presealExp, dweight.DealWeight, dweight.VerifiedDealWeight)
// we've added fake power for this sector above, remove it now // we've added fake power for this sector above, remove it now
err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *v0power.State) error { err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power0.State) error {
st.TotalQualityAdjPower = types.BigSub(st.TotalQualityAdjPower, sectorWeight) //nolint:scopelint st.TotalQualityAdjPower = types.BigSub(st.TotalQualityAdjPower, sectorWeight) //nolint:scopelint
st.TotalRawBytePower = types.BigSub(st.TotalRawBytePower, types.NewInt(uint64(m.SectorSize))) st.TotalRawBytePower = types.BigSub(st.TotalRawBytePower, types.NewInt(uint64(m.SectorSize)))
return nil return nil
@ -271,9 +271,9 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
return cid.Undef, xerrors.Errorf("getting current total power: %w", err) return cid.Undef, xerrors.Errorf("getting current total power: %w", err)
} }
pcd := v0miner.PreCommitDepositForPower(epochReward.ThisEpochRewardSmoothed, tpow.QualityAdjPowerSmoothed, sectorWeight) pcd := miner0.PreCommitDepositForPower(epochReward.ThisEpochRewardSmoothed, tpow.QualityAdjPowerSmoothed, sectorWeight)
pledge := v0miner.InitialPledgeForPower( pledge := miner0.InitialPledgeForPower(
sectorWeight, sectorWeight,
epochReward.ThisEpochBaselinePower, epochReward.ThisEpochBaselinePower,
tpow.PledgeCollateral, tpow.PledgeCollateral,
@ -304,7 +304,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
} }
// Sanity-check total network power // Sanity-check total network power
err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *v0power.State) error { err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power0.State) error {
if !st.TotalRawBytePower.Equals(rawPow) { if !st.TotalRawBytePower.Equals(rawPow) {
return xerrors.Errorf("st.TotalRawBytePower doesn't match previously calculated rawPow") return xerrors.Errorf("st.TotalRawBytePower doesn't match previously calculated rawPow")
} }
@ -343,12 +343,12 @@ func (fr *fakeRand) GetBeaconRandomness(ctx context.Context, personalization cry
return out, nil return out, nil
} }
func currentTotalPower(ctx context.Context, vm *vm.VM, maddr address.Address) (*v0power.CurrentTotalPowerReturn, error) { func currentTotalPower(ctx context.Context, vm *vm.VM, maddr address.Address) (*power0.CurrentTotalPowerReturn, error) {
pwret, err := doExecValue(ctx, vm, builtin.StoragePowerActorAddr, maddr, big.Zero(), builtin.MethodsPower.CurrentTotalPower, nil) pwret, err := doExecValue(ctx, vm, builtin.StoragePowerActorAddr, maddr, big.Zero(), builtin.MethodsPower.CurrentTotalPower, nil)
if err != nil { if err != nil {
return nil, err return nil, err
} }
var pwr v0power.CurrentTotalPowerReturn var pwr power0.CurrentTotalPowerReturn
if err := pwr.UnmarshalCBOR(bytes.NewReader(pwret)); err != nil { if err := pwr.UnmarshalCBOR(bytes.NewReader(pwret)); err != nil {
return nil, err return nil, err
} }
@ -381,13 +381,13 @@ func dealWeight(ctx context.Context, vm *vm.VM, maddr address.Address, dealIDs [
return dealWeights, nil return dealWeights, nil
} }
func currentEpochBlockReward(ctx context.Context, vm *vm.VM, maddr address.Address) (*v0reward.ThisEpochRewardReturn, error) { func currentEpochBlockReward(ctx context.Context, vm *vm.VM, maddr address.Address) (*reward0.ThisEpochRewardReturn, error) {
rwret, err := doExecValue(ctx, vm, builtin.RewardActorAddr, maddr, big.Zero(), builtin.MethodsReward.ThisEpochReward, nil) rwret, err := doExecValue(ctx, vm, builtin.RewardActorAddr, maddr, big.Zero(), builtin.MethodsReward.ThisEpochReward, nil)
if err != nil { if err != nil {
return nil, err return nil, err
} }
var epochReward v0reward.ThisEpochRewardReturn var epochReward reward0.ThisEpochRewardReturn
if err := epochReward.UnmarshalCBOR(bytes.NewReader(rwret)); err != nil { if err := epochReward.UnmarshalCBOR(bytes.NewReader(rwret)); err != nil {
return nil, err return nil, err
} }

4
chain/gen/genesis/t02_reward.go
View File

@ -6,7 +6,7 @@ import (
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0reward "github.com/filecoin-project/specs-actors/actors/builtin/reward" reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
cbor "github.com/ipfs/go-ipld-cbor" cbor "github.com/ipfs/go-ipld-cbor"
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
@ -17,7 +17,7 @@ import (
func SetupRewardActor(bs bstore.Blockstore, qaPower big.Int) (*types.Actor, error) { func SetupRewardActor(bs bstore.Blockstore, qaPower big.Int) (*types.Actor, error) {
cst := cbor.NewCborStore(bs) cst := cbor.NewCborStore(bs)
st := v0reward.ConstructState(qaPower) st := reward0.ConstructState(qaPower)
hcid, err := cst.Put(context.TODO(), st) hcid, err := cst.Put(context.TODO(), st)
if err != nil { if err != nil {

4
chain/gen/genesis/t04_power.go
View File

@ -6,7 +6,7 @@ import (
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/specs-actors/actors/util/adt" "github.com/filecoin-project/specs-actors/actors/util/adt"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
cbor "github.com/ipfs/go-ipld-cbor" cbor "github.com/ipfs/go-ipld-cbor"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
@ -30,7 +30,7 @@ func SetupStoragePowerActor(bs bstore.Blockstore) (*types.Actor, error) {
return nil, err return nil, err
} }
sms := v0power.ConstructState(emptyMap, emptyMultiMap) sms := power0.ConstructState(emptyMap, emptyMultiMap)
stcid, err := store.Put(store.Context(), sms) stcid, err := store.Put(store.Context(), sms)
if err != nil { if err != nil {

4
chain/gen/genesis/t06_vreg.go
View File

@ -7,7 +7,7 @@ import (
cbor "github.com/ipfs/go-ipld-cbor" cbor "github.com/ipfs/go-ipld-cbor"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
"github.com/filecoin-project/specs-actors/actors/util/adt" "github.com/filecoin-project/specs-actors/actors/util/adt"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
@ -34,7 +34,7 @@ func SetupVerifiedRegistryActor(bs bstore.Blockstore) (*types.Actor, error) {
return nil, err return nil, err
} }
sms := v0verifreg.ConstructState(h, RootVerifierID) sms := verifreg0.ConstructState(h, RootVerifierID)
stcid, err := store.Put(store.Context(), sms) stcid, err := store.Put(store.Context(), sms)
if err != nil { if err != nil {

14
chain/stmgr/forks.go
View File

@ -9,8 +9,8 @@ import (
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
"github.com/filecoin-project/specs-actors/actors/util/adt" "github.com/filecoin-project/specs-actors/actors/util/adt"
cbor "github.com/ipfs/go-ipld-cbor" cbor "github.com/ipfs/go-ipld-cbor"
"golang.org/x/xerrors" "golang.org/x/xerrors"
@ -135,7 +135,7 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
}) })
} }
case builtin.StorageMinerActorCodeID: case builtin.StorageMinerActorCodeID:
var st v0miner.State var st miner0.State
if err := sm.ChainStore().Store(ctx).Get(ctx, act.Head, &st); err != nil { if err := sm.ChainStore().Store(ctx).Get(ctx, act.Head, &st); err != nil {
return xerrors.Errorf("failed to load miner state: %w", err) return xerrors.Errorf("failed to load miner state: %w", err)
} }
@ -172,7 +172,7 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
} }
// pull up power table to give miners back some funds proportional to their power // pull up power table to give miners back some funds proportional to their power
var ps v0power.State var ps power0.State
powAct, err := tree.GetActor(builtin.StoragePowerActorAddr) powAct, err := tree.GetActor(builtin.StoragePowerActorAddr)
if err != nil { if err != nil {
return xerrors.Errorf("failed to load power actor: %w", err) return xerrors.Errorf("failed to load power actor: %w", err)
@ -211,12 +211,12 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
}) })
} }
case builtin.StorageMinerActorCodeID: case builtin.StorageMinerActorCodeID:
var st v0miner.State var st miner0.State
if err := sm.ChainStore().Store(ctx).Get(ctx, act.Head, &st); err != nil { if err := sm.ChainStore().Store(ctx).Get(ctx, act.Head, &st); err != nil {
return xerrors.Errorf("failed to load miner state: %w", err) return xerrors.Errorf("failed to load miner state: %w", err)
} }
var minfo v0miner.MinerInfo var minfo miner0.MinerInfo
if err := cst.Get(ctx, st.Info, &minfo); err != nil { if err := cst.Get(ctx, st.Info, &minfo); err != nil {
return xerrors.Errorf("failed to get miner info: %w", err) return xerrors.Errorf("failed to get miner info: %w", err)
} }
@ -240,7 +240,7 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
// Now make sure to give each miner who had power at the lookback some FIL // Now make sure to give each miner who had power at the lookback some FIL
lbact, err := lbtree.GetActor(addr) lbact, err := lbtree.GetActor(addr)
if err == nil { if err == nil {
var lbst v0miner.State var lbst miner0.State
if err := sm.ChainStore().Store(ctx).Get(ctx, lbact.Head, &lbst); err != nil { if err := sm.ChainStore().Store(ctx).Get(ctx, lbact.Head, &lbst); err != nil {
return xerrors.Errorf("failed to load miner state: %w", err) return xerrors.Errorf("failed to load miner state: %w", err)
} }

12
chain/stmgr/forks_test.go
View File

@ -11,9 +11,9 @@ import (
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
init_ "github.com/filecoin-project/specs-actors/actors/builtin/init" init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
"github.com/filecoin-project/specs-actors/actors/runtime" "github.com/filecoin-project/specs-actors/actors/runtime"
"golang.org/x/xerrors" "golang.org/x/xerrors"
@ -33,11 +33,11 @@ import (
) )
func init() { func init() {
v0miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{ miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
abi.RegisteredSealProof_StackedDrg2KiBV1: {}, abi.RegisteredSealProof_StackedDrg2KiBV1: {},
} }
v0power.ConsensusMinerMinPower = big.NewInt(2048) power0.ConsensusMinerMinPower = big.NewInt(2048)
v0verifreg.MinVerifiedDealSize = big.NewInt(256) verifreg0.MinVerifiedDealSize = big.NewInt(256)
} }
const testForkHeight = 40 const testForkHeight = 40

16
chain/stmgr/stmgr.go
View File

@ -5,7 +5,7 @@ import (
"fmt" "fmt"
"sync" "sync"
v0msig "github.com/filecoin-project/specs-actors/actors/builtin/multisig" msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
"github.com/filecoin-project/lotus/chain/actors/builtin/multisig" "github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
@ -23,7 +23,7 @@ import (
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/network"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0reward "github.com/filecoin-project/specs-actors/actors/builtin/reward" reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
"github.com/filecoin-project/specs-actors/actors/util/adt" "github.com/filecoin-project/specs-actors/actors/util/adt"
"github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/api"
@ -251,7 +251,7 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
nv := sm.GetNtwkVersion(ctx, epoch) nv := sm.GetNtwkVersion(ctx, epoch)
if nv < build.ActorUpgradeNetworkVersion { if nv < build.ActorUpgradeNetworkVersion {
params, err = actors.SerializeParams(&v0reward.AwardBlockRewardParams{ params, err = actors.SerializeParams(&reward0.AwardBlockRewardParams{
Miner: b.Miner, Miner: b.Miner,
Penalty: penalty, Penalty: penalty,
GasReward: gasReward, GasReward: gasReward,
@ -797,7 +797,7 @@ func (sm *StateManager) SetVMConstructor(nvm func(context.Context, *vm.VMOpts) (
} }
type genesisInfo struct { type genesisInfo struct {
genesisMsigs []v0msig.State genesisMsigs []msig0.State
// info about the Accounts in the genesis state // info about the Accounts in the genesis state
genesisActors []genesisActor genesisActors []genesisActor
genesisPledge abi.TokenAmount genesisPledge abi.TokenAmount
@ -898,9 +898,9 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
return xerrors.Errorf("error setting up genesis infos: %w", err) return xerrors.Errorf("error setting up genesis infos: %w", err)
} }
gi.genesisMsigs = make([]v0msig.State, 0, len(totalsByEpoch)) gi.genesisMsigs = make([]msig0.State, 0, len(totalsByEpoch))
for k, v := range totalsByEpoch { for k, v := range totalsByEpoch {
ns := v0msig.State{ ns := msig0.State{
InitialBalance: v, InitialBalance: v,
UnlockDuration: k, UnlockDuration: k,
PendingTxns: cid.Undef, PendingTxns: cid.Undef,
@ -975,9 +975,9 @@ func (sm *StateManager) setupGenesisActorsTestnet(ctx context.Context) error {
totalsByEpoch[sixYears] = big.NewInt(100_000_000) totalsByEpoch[sixYears] = big.NewInt(100_000_000)
totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000)) totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))
gi.genesisMsigs = make([]v0msig.State, 0, len(totalsByEpoch)) gi.genesisMsigs = make([]msig0.State, 0, len(totalsByEpoch))
for k, v := range totalsByEpoch { for k, v := range totalsByEpoch {
ns := v0msig.State{ ns := msig0.State{
InitialBalance: v, InitialBalance: v,
UnlockDuration: k, UnlockDuration: k,
PendingTxns: cid.Undef, PendingTxns: cid.Undef,

30
chain/stmgr/utils.go
View File

@ -9,11 +9,11 @@ import (
"runtime" "runtime"
"strings" "strings"
v0init "github.com/filecoin-project/specs-actors/actors/builtin/init" init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
v0market "github.com/filecoin-project/specs-actors/actors/builtin/market" market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
saruntime "github.com/filecoin-project/specs-actors/actors/runtime" saruntime "github.com/filecoin-project/specs-actors/actors/runtime"
"github.com/filecoin-project/specs-actors/actors/runtime/proof" "github.com/filecoin-project/specs-actors/actors/runtime/proof"
@ -31,10 +31,10 @@ import (
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/specs-actors/actors/builtin/account" "github.com/filecoin-project/specs-actors/actors/builtin/account"
"github.com/filecoin-project/specs-actors/actors/builtin/cron" "github.com/filecoin-project/specs-actors/actors/builtin/cron"
v0msig "github.com/filecoin-project/specs-actors/actors/builtin/multisig" msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
"github.com/filecoin-project/specs-actors/actors/builtin/paych" "github.com/filecoin-project/specs-actors/actors/builtin/paych"
v0reward "github.com/filecoin-project/specs-actors/actors/builtin/reward" reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
"github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
@ -169,7 +169,7 @@ func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet,
var sset []*miner.ChainSectorInfo var sset []*miner.ChainSectorInfo
var v cbg.Deferred var v cbg.Deferred
if err := sectors.ForEach(&v, func(i int64) error { if err := sectors.ForEach(&v, func(i int64) error {
var oci v0miner.SectorOnChainInfo var oci miner0.SectorOnChainInfo
if err := oci.UnmarshalCBOR(bytes.NewReader(v.Raw)); err != nil { if err := oci.UnmarshalCBOR(bytes.NewReader(v.Raw)); err != nil {
return err return err
} }
@ -555,16 +555,16 @@ var MethodsMap = map[cid.Cid]map[abi.MethodNum]MethodMeta{}
func init() { func init() {
cidToMethods := map[cid.Cid][2]interface{}{ cidToMethods := map[cid.Cid][2]interface{}{
// builtin.SystemActorCodeID: {builtin.MethodsSystem, system.Actor{} }- apparently it doesn't have methods // builtin.SystemActorCodeID: {builtin.MethodsSystem, system.Actor{} }- apparently it doesn't have methods
builtin.InitActorCodeID: {builtin.MethodsInit, v0init.Actor{}}, builtin.InitActorCodeID: {builtin.MethodsInit, init0.Actor{}},
builtin.CronActorCodeID: {builtin.MethodsCron, cron.Actor{}}, builtin.CronActorCodeID: {builtin.MethodsCron, cron.Actor{}},
builtin.AccountActorCodeID: {builtin.MethodsAccount, account.Actor{}}, builtin.AccountActorCodeID: {builtin.MethodsAccount, account.Actor{}},
builtin.StoragePowerActorCodeID: {builtin.MethodsPower, v0power.Actor{}}, builtin.StoragePowerActorCodeID: {builtin.MethodsPower, power0.Actor{}},
builtin.StorageMinerActorCodeID: {builtin.MethodsMiner, v0miner.Actor{}}, builtin.StorageMinerActorCodeID: {builtin.MethodsMiner, miner0.Actor{}},
builtin.StorageMarketActorCodeID: {builtin.MethodsMarket, v0market.Actor{}}, builtin.StorageMarketActorCodeID: {builtin.MethodsMarket, market0.Actor{}},
builtin.PaymentChannelActorCodeID: {builtin.MethodsPaych, paych.Actor{}}, builtin.PaymentChannelActorCodeID: {builtin.MethodsPaych, paych.Actor{}},
builtin.MultisigActorCodeID: {builtin.MethodsMultisig, v0msig.Actor{}}, builtin.MultisigActorCodeID: {builtin.MethodsMultisig, msig0.Actor{}},
builtin.RewardActorCodeID: {builtin.MethodsReward, v0reward.Actor{}}, builtin.RewardActorCodeID: {builtin.MethodsReward, reward0.Actor{}},
builtin.VerifiedRegistryActorCodeID: {builtin.MethodsVerifiedRegistry, v0verifreg.Actor{}}, builtin.VerifiedRegistryActorCodeID: {builtin.MethodsVerifiedRegistry, verifreg0.Actor{}},
} }
for c, m := range cidToMethods { for c, m := range cidToMethods {

12
chain/store/store_test.go
View File

@ -10,9 +10,9 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/go-state-types/crypto" "github.com/filecoin-project/go-state-types/crypto"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
"github.com/filecoin-project/lotus/chain/gen" "github.com/filecoin-project/lotus/chain/gen"
"github.com/filecoin-project/lotus/chain/store" "github.com/filecoin-project/lotus/chain/store"
@ -22,11 +22,11 @@ import (
) )
func init() { func init() {
v0miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{ miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
abi.RegisteredSealProof_StackedDrg2KiBV1: {}, abi.RegisteredSealProof_StackedDrg2KiBV1: {},
} }
v0power.ConsensusMinerMinPower = big.NewInt(2048) power0.ConsensusMinerMinPower = big.NewInt(2048)
v0verifreg.MinVerifiedDealSize = big.NewInt(256) verifreg0.MinVerifiedDealSize = big.NewInt(256)
} }
func BenchmarkGetRandomness(b *testing.B) { func BenchmarkGetRandomness(b *testing.B) {

12
chain/sync_test.go
View File

@ -20,9 +20,9 @@ import (
"github.com/filecoin-project/go-address" "github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
"github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
@ -43,11 +43,11 @@ func init() {
if err != nil { if err != nil {
panic(err) panic(err)
} }
v0miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{ miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
abi.RegisteredSealProof_StackedDrg2KiBV1: {}, abi.RegisteredSealProof_StackedDrg2KiBV1: {},
} }
v0power.ConsensusMinerMinPower = big.NewInt(2048) power0.ConsensusMinerMinPower = big.NewInt(2048)
v0verifreg.MinVerifiedDealSize = big.NewInt(256) verifreg0.MinVerifiedDealSize = big.NewInt(256)
} }
const source = 0 const source = 0

8
chain/vectors/gen/main.go
View File

@ -6,7 +6,7 @@ import (
"math/rand" "math/rand"
"os" "os"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
"github.com/filecoin-project/go-address" "github.com/filecoin-project/go-address"
"golang.org/x/xerrors" "golang.org/x/xerrors"
@ -19,15 +19,15 @@ import (
"github.com/filecoin-project/lotus/chain/types/mock" "github.com/filecoin-project/lotus/chain/types/mock"
"github.com/filecoin-project/lotus/chain/vectors" "github.com/filecoin-project/lotus/chain/vectors"
"github.com/filecoin-project/lotus/chain/wallet" "github.com/filecoin-project/lotus/chain/wallet"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
_ "github.com/filecoin-project/lotus/lib/sigs/bls" _ "github.com/filecoin-project/lotus/lib/sigs/bls"
_ "github.com/filecoin-project/lotus/lib/sigs/secp" _ "github.com/filecoin-project/lotus/lib/sigs/secp"
) )
func init() { func init() {
v0verifreg.MinVerifiedDealSize = big.NewInt(2048) verifreg0.MinVerifiedDealSize = big.NewInt(2048)
v0power.ConsensusMinerMinPower = big.NewInt(2048) power0.ConsensusMinerMinPower = big.NewInt(2048)
} }
func MakeHeaderVectors() []vectors.HeaderVector { func MakeHeaderVectors() []vectors.HeaderVector {

48
chain/vm/invoker.go
View File

@ -10,18 +10,18 @@ import (
cbg "github.com/whyrusleeping/cbor-gen" cbg "github.com/whyrusleeping/cbor-gen"
"golang.org/x/xerrors" "golang.org/x/xerrors"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
v0account "github.com/filecoin-project/specs-actors/actors/builtin/account" account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
v0cron "github.com/filecoin-project/specs-actors/actors/builtin/cron" cron0 "github.com/filecoin-project/specs-actors/actors/builtin/cron"
v0init "github.com/filecoin-project/specs-actors/actors/builtin/init" init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
v0market "github.com/filecoin-project/specs-actors/actors/builtin/market" market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0msig "github.com/filecoin-project/specs-actors/actors/builtin/multisig" msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
v0paych "github.com/filecoin-project/specs-actors/actors/builtin/paych" paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
v0reward "github.com/filecoin-project/specs-actors/actors/builtin/reward" reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
v0system "github.com/filecoin-project/specs-actors/actors/builtin/system" system0 "github.com/filecoin-project/specs-actors/actors/builtin/system"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
vmr "github.com/filecoin-project/specs-actors/actors/runtime" vmr "github.com/filecoin-project/specs-actors/actors/runtime"
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
@ -46,17 +46,17 @@ func NewInvoker() *Invoker {
// add builtInCode using: register(cid, singleton) // add builtInCode using: register(cid, singleton)
// NETUPGRADE: register code IDs for v2, etc. // NETUPGRADE: register code IDs for v2, etc.
inv.Register(v0builtin.SystemActorCodeID, v0system.Actor{}, abi.EmptyValue{}) inv.Register(builtin0.SystemActorCodeID, system0.Actor{}, abi.EmptyValue{})
inv.Register(v0builtin.InitActorCodeID, v0init.Actor{}, v0init.State{}) inv.Register(builtin0.InitActorCodeID, init0.Actor{}, init0.State{})
inv.Register(v0builtin.RewardActorCodeID, v0reward.Actor{}, v0reward.State{}) inv.Register(builtin0.RewardActorCodeID, reward0.Actor{}, reward0.State{})
inv.Register(v0builtin.CronActorCodeID, v0cron.Actor{}, v0cron.State{}) inv.Register(builtin0.CronActorCodeID, cron0.Actor{}, cron0.State{})
inv.Register(v0builtin.StoragePowerActorCodeID, v0power.Actor{}, v0power.State{}) inv.Register(builtin0.StoragePowerActorCodeID, power0.Actor{}, power0.State{})
inv.Register(v0builtin.StorageMarketActorCodeID, v0market.Actor{}, v0market.State{}) inv.Register(builtin0.StorageMarketActorCodeID, market0.Actor{}, market0.State{})
inv.Register(v0builtin.StorageMinerActorCodeID, v0miner.Actor{}, v0miner.State{}) inv.Register(builtin0.StorageMinerActorCodeID, miner0.Actor{}, miner0.State{})
inv.Register(v0builtin.MultisigActorCodeID, v0msig.Actor{}, v0msig.State{}) inv.Register(builtin0.MultisigActorCodeID, msig0.Actor{}, msig0.State{})
inv.Register(v0builtin.PaymentChannelActorCodeID, v0paych.Actor{}, v0paych.State{}) inv.Register(builtin0.PaymentChannelActorCodeID, paych0.Actor{}, paych0.State{})
inv.Register(v0builtin.VerifiedRegistryActorCodeID, v0verifreg.Actor{}, v0verifreg.State{}) inv.Register(builtin0.VerifiedRegistryActorCodeID, verifreg0.Actor{}, verifreg0.State{})
inv.Register(v0builtin.AccountActorCodeID, v0account.Actor{}, v0account.State{}) inv.Register(builtin0.AccountActorCodeID, account0.Actor{}, account0.State{})
return inv return inv
} }
@ -177,7 +177,7 @@ func DecodeParams(b []byte, out interface{}) error {
} }
func DumpActorState(code cid.Cid, b []byte) (interface{}, error) { func DumpActorState(code cid.Cid, b []byte) (interface{}, error) {
if code == v0builtin.AccountActorCodeID { // Account code special case if code == builtin0.AccountActorCodeID { // Account code special case
return nil, nil return nil, nil
} }

14
cli/multisig.go
View File

@ -17,7 +17,7 @@ import (
"github.com/filecoin-project/go-address" "github.com/filecoin-project/go-address"
init_ "github.com/filecoin-project/specs-actors/actors/builtin/init" init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
v0msig "github.com/filecoin-project/specs-actors/actors/builtin/multisig" msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
cid "github.com/ipfs/go-cid" cid "github.com/ipfs/go-cid"
cbor "github.com/ipfs/go-ipld-cbor" cbor "github.com/ipfs/go-ipld-cbor"
"github.com/urfave/cli/v2" "github.com/urfave/cli/v2"
@ -199,7 +199,7 @@ var msigInspectCmd = &cli.Command{
return err return err
} }
var mstate v0msig.State var mstate msig0.State
if err := mstate.UnmarshalCBOR(bytes.NewReader(obj)); err != nil { if err := mstate.UnmarshalCBOR(bytes.NewReader(obj)); err != nil {
return err return err
} }
@ -251,7 +251,7 @@ var msigInspectCmd = &cli.Command{
}, },
} }
func GetMultisigPending(ctx context.Context, lapi api.FullNode, hroot cid.Cid) (map[int64]*v0msig.Transaction, error) { func GetMultisigPending(ctx context.Context, lapi api.FullNode, hroot cid.Cid) (map[int64]*msig0.Transaction, error) {
bs := apibstore.NewAPIBlockstore(lapi) bs := apibstore.NewAPIBlockstore(lapi)
store := adt.WrapStore(ctx, cbor.NewCborStore(bs)) store := adt.WrapStore(ctx, cbor.NewCborStore(bs))
@ -260,8 +260,8 @@ func GetMultisigPending(ctx context.Context, lapi api.FullNode, hroot cid.Cid) (
return nil, err return nil, err
} }
txs := make(map[int64]*v0msig.Transaction) txs := make(map[int64]*msig0.Transaction)
var tx v0msig.Transaction var tx msig0.Transaction
err = nd.ForEach(&tx, func(k string) error { err = nd.ForEach(&tx, func(k string) error {
txid, _ := binary.Varint([]byte(k)) txid, _ := binary.Varint([]byte(k))
@ -276,7 +276,7 @@ func GetMultisigPending(ctx context.Context, lapi api.FullNode, hroot cid.Cid) (
return txs, nil return txs, nil
} }
func state(tx *v0msig.Transaction) string { func state(tx *msig0.Transaction) string {
/* // TODO(why): I strongly disagree with not having these... but i need to move forward /* // TODO(why): I strongly disagree with not having these... but i need to move forward
if tx.Complete { if tx.Complete {
return "done" return "done"
@ -385,7 +385,7 @@ var msigProposeCmd = &cli.Command{
return fmt.Errorf("proposal returned exit %d", wait.Receipt.ExitCode) return fmt.Errorf("proposal returned exit %d", wait.Receipt.ExitCode)
} }
var retval v0msig.ProposeReturn var retval msig0.ProposeReturn
if err := retval.UnmarshalCBOR(bytes.NewReader(wait.Receipt.Return)); err != nil { if err := retval.UnmarshalCBOR(bytes.NewReader(wait.Receipt.Return)); err != nil {
return fmt.Errorf("failed to unmarshal propose return value: %w", err) return fmt.Errorf("failed to unmarshal propose return value: %w", err)
} }

12
cli/paych_test.go
View File

@ -15,9 +15,9 @@ import (
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
"github.com/multiformats/go-multiaddr" "github.com/multiformats/go-multiaddr"
@ -40,11 +40,11 @@ import (
) )
func init() { func init() {
v0power.ConsensusMinerMinPower = big.NewInt(2048) power0.ConsensusMinerMinPower = big.NewInt(2048)
v0miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{ miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
abi.RegisteredSealProof_StackedDrg2KiBV1: {}, abi.RegisteredSealProof_StackedDrg2KiBV1: {},
} }
v0verifreg.MinVerifiedDealSize = big.NewInt(256) verifreg0.MinVerifiedDealSize = big.NewInt(256)
} }
// TestPaymentChannels does a basic test to exercise the payment channel CLI // TestPaymentChannels does a basic test to exercise the payment channel CLI

4
cmd/lotus-pcr/main.go
View File

@ -12,7 +12,7 @@ import (
"strconv" "strconv"
"time" "time"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/network"
"github.com/filecoin-project/lotus/chain/actors/builtin/miner" "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
@ -403,7 +403,7 @@ func (r *refunder) ProcessTipset(ctx context.Context, tipset *types.TipSet, refu
} }
if nv < build.ActorUpgradeNetworkVersion { if nv < build.ActorUpgradeNetworkVersion {
var proveCommitSector v0miner.ProveCommitSectorParams var proveCommitSector miner0.ProveCommitSectorParams
if err := proveCommitSector.UnmarshalCBOR(bytes.NewBuffer(m.Params)); err != nil { if err := proveCommitSector.UnmarshalCBOR(bytes.NewBuffer(m.Params)); err != nil {
log.Warnw("failed to decode provecommit params", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To) log.Warnw("failed to decode provecommit params", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To)
continue continue

10
cmd/lotus-storage-miner/actor.go
View File

@ -16,7 +16,7 @@ import (
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/filecoin-project/lotus/chain/actors" "github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
@ -88,7 +88,7 @@ var actorSetAddrsCmd = &cli.Command{
return err return err
} }
params, err := actors.SerializeParams(&v0miner.ChangeMultiaddrsParams{NewMultiaddrs: addrs}) params, err := actors.SerializeParams(&miner0.ChangeMultiaddrsParams{NewMultiaddrs: addrs})
if err != nil { if err != nil {
return err return err
} }
@ -153,7 +153,7 @@ var actorSetPeeridCmd = &cli.Command{
return err return err
} }
params, err := actors.SerializeParams(&v0miner.ChangePeerIDParams{NewID: abi.PeerID(pid)}) params, err := actors.SerializeParams(&miner0.ChangePeerIDParams{NewID: abi.PeerID(pid)})
if err != nil { if err != nil {
return err return err
} }
@ -226,7 +226,7 @@ var actorWithdrawCmd = &cli.Command{
} }
} }
params, err := actors.SerializeParams(&v0miner.WithdrawBalanceParams{ params, err := actors.SerializeParams(&miner0.WithdrawBalanceParams{
AmountRequested: amount, // Default to attempting to withdraw all the extra funds in the miner actor AmountRequested: amount, // Default to attempting to withdraw all the extra funds in the miner actor
}) })
if err != nil { if err != nil {
@ -451,7 +451,7 @@ var actorControlSet = &cli.Command{
return nil return nil
} }
cwp := &v0miner.ChangeWorkerAddressParams{ cwp := &miner0.ChangeWorkerAddressParams{
NewWorker: mi.Worker, NewWorker: mi.Worker,
NewControlAddrs: toSet, NewControlAddrs: toSet,
} }

22
cmd/lotus-storage-miner/init.go
View File

@ -32,10 +32,10 @@ import (
"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper" "github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
"github.com/filecoin-project/lotus/extern/sector-storage/stores" "github.com/filecoin-project/lotus/extern/sector-storage/stores"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
v0market "github.com/filecoin-project/specs-actors/actors/builtin/market" market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
lapi "github.com/filecoin-project/lotus/api" lapi "github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
@ -373,7 +373,7 @@ func migratePreSealMeta(ctx context.Context, api lapi.FullNode, metadata string,
return mds.Put(datastore.NewKey(modules.StorageCounterDSPrefix), buf[:size]) return mds.Put(datastore.NewKey(modules.StorageCounterDSPrefix), buf[:size])
} }
func findMarketDealID(ctx context.Context, api lapi.FullNode, deal v0market.DealProposal) (abi.DealID, error) { func findMarketDealID(ctx context.Context, api lapi.FullNode, deal market0.DealProposal) (abi.DealID, error) {
// TODO: find a better way // TODO: find a better way
// (this is only used by genesis miners) // (this is only used by genesis miners)
@ -567,7 +567,7 @@ func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.
return xerrors.Errorf("getWorkerAddr returned bad address: %w", err) return xerrors.Errorf("getWorkerAddr returned bad address: %w", err)
} }
enc, err := actors.SerializeParams(&v0miner.ChangePeerIDParams{NewID: abi.PeerID(peerid)}) enc, err := actors.SerializeParams(&miner0.ChangePeerIDParams{NewID: abi.PeerID(peerid)})
if err != nil { if err != nil {
return err return err
} }
@ -575,7 +575,7 @@ func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.
msg := &types.Message{ msg := &types.Message{
To: addr, To: addr,
From: mi.Worker, From: mi.Worker,
Method: v0builtin.MethodsMiner.ChangePeerID, Method: builtin0.MethodsMiner.ChangePeerID,
Params: enc, Params: enc,
Value: types.NewInt(0), Value: types.NewInt(0),
GasPremium: gasPrice, GasPremium: gasPrice,
@ -634,7 +634,7 @@ func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID,
return address.Undef, err return address.Undef, err
} }
params, err := actors.SerializeParams(&v0power.CreateMinerParams{ params, err := actors.SerializeParams(&power0.CreateMinerParams{
Owner: owner, Owner: owner,
Worker: worker, Worker: worker,
SealProofType: spt, SealProofType: spt,
@ -654,11 +654,11 @@ func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID,
} }
createStorageMinerMsg := &types.Message{ createStorageMinerMsg := &types.Message{
To: v0builtin.StoragePowerActorAddr, To: builtin0.StoragePowerActorAddr,
From: sender, From: sender,
Value: big.Zero(), Value: big.Zero(),
Method: v0builtin.MethodsPower.CreateMiner, Method: builtin0.MethodsPower.CreateMiner,
Params: params, Params: params,
GasLimit: 0, GasLimit: 0,
@ -682,7 +682,7 @@ func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID,
return address.Undef, xerrors.Errorf("create miner failed: exit code %d", mw.Receipt.ExitCode) return address.Undef, xerrors.Errorf("create miner failed: exit code %d", mw.Receipt.ExitCode)
} }
var retval v0power.CreateMinerReturn var retval power0.CreateMinerReturn
if err := retval.UnmarshalCBOR(bytes.NewReader(mw.Receipt.Return)); err != nil { if err := retval.UnmarshalCBOR(bytes.NewReader(mw.Receipt.Return)); err != nil {
return address.Undef, err return address.Undef, err
} }

4
cmd/lotus-storage-miner/sectors.go
View File

@ -13,7 +13,7 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/chain/actors/builtin/miner" "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
@ -380,7 +380,7 @@ var sectorsCapacityCollateralCmd = &cli.Command{
Expiration: abi.ChainEpoch(cctx.Uint64("expiration")), Expiration: abi.ChainEpoch(cctx.Uint64("expiration")),
} }
if pci.Expiration == 0 { if pci.Expiration == 0 {
pci.Expiration = v0miner.MaxSectorExpirationExtension pci.Expiration = miner0.MaxSectorExpirationExtension
} }
pc, err := nApi.StateMinerInitialPledgeCollateral(ctx, maddr, pci, types.EmptyTSK) pc, err := nApi.StateMinerInitialPledgeCollateral(ctx, maddr, pci, types.EmptyTSK)
if err != nil { if err != nil {

8
extern/storage-sealing/checks.go vendored
View File

@ -5,9 +5,9 @@ import (
"context" "context"
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0proof "github.com/filecoin-project/specs-actors/actors/runtime/proof" proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
"golang.org/x/xerrors" "golang.org/x/xerrors"
@ -102,7 +102,7 @@ func checkPrecommit(ctx context.Context, maddr address.Address, si SectorInfo, t
var msd abi.ChainEpoch var msd abi.ChainEpoch
if nv < build.ActorUpgradeNetworkVersion { if nv < build.ActorUpgradeNetworkVersion {
msd = v0miner.MaxSealDuration[si.SectorType] msd = miner0.MaxSealDuration[si.SectorType]
} else { } else {
// TODO: ActorUpgrade // TODO: ActorUpgrade
msd = 0 msd = 0
@ -190,7 +190,7 @@ func (m *Sealing) checkCommit(ctx context.Context, si SectorInfo, proof []byte,
log.Warn("on-chain sealed CID doesn't match!") log.Warn("on-chain sealed CID doesn't match!")
} }
ok, err := m.verif.VerifySeal(v0proof.SealVerifyInfo{ ok, err := m.verif.VerifySeal(proof0.SealVerifyInfo{
SectorID: m.minerSector(si.SectorNumber), SectorID: m.minerSector(si.SectorNumber),
SealedCID: pci.Info.SealedCID, SealedCID: pci.Info.SealedCID,
SealProof: spt, SealProof: spt,

4
extern/storage-sealing/constants.go vendored
View File

@ -1,11 +1,11 @@
package sealing package sealing
import ( import (
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
) )
// Epochs // Epochs
const SealRandomnessLookback = v0miner.ChainFinality const SealRandomnessLookback = miner0.ChainFinality
// Epochs // Epochs
const InteractivePoRepConfidence = 6 const InteractivePoRepConfidence = 6

4
extern/storage-sealing/precommit_policy.go vendored
View File

@ -7,7 +7,7 @@ import (
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
) )
type PreCommitPolicy interface { type PreCommitPolicy interface {
@ -87,7 +87,7 @@ func (p *BasicPreCommitPolicy) Expiration(ctx context.Context, ps ...Piece) (abi
var wpp abi.ChainEpoch var wpp abi.ChainEpoch
if nv < build.ActorUpgradeNetworkVersion { if nv < build.ActorUpgradeNetworkVersion {
wpp = v0miner.WPoStProvingPeriod wpp = miner0.WPoStProvingPeriod
} else { } else {
// TODO: ActorUpgrade // TODO: ActorUpgrade
wpp = 0 wpp = 0

4
extern/storage-sealing/sealing.go vendored
View File

@ -9,7 +9,7 @@ import (
"time" "time"
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/network"
"github.com/ipfs/go-cid" "github.com/ipfs/go-cid"
@ -430,7 +430,7 @@ func (m *Sealing) getPreCommitChallengeDelay(ctx context.Context, tok TipSetToke
} }
if nv < build.ActorUpgradeNetworkVersion { if nv < build.ActorUpgradeNetworkVersion {
return v0miner.PreCommitChallengeDelay, nil return miner0.PreCommitChallengeDelay, nil
} }
// TODO: ActorUpgrade // TODO: ActorUpgrade

8
extern/storage-sealing/states_sealing.go vendored
View File

@ -6,7 +6,7 @@ import (
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/actors/builtin/miner" "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"golang.org/x/xerrors" "golang.org/x/xerrors"
@ -191,8 +191,8 @@ func (m *Sealing) handlePreCommitting(ctx statemachine.Context, sector SectorInf
var msd abi.ChainEpoch var msd abi.ChainEpoch
var mse abi.ChainEpoch var mse abi.ChainEpoch
if nv < build.ActorUpgradeNetworkVersion { if nv < build.ActorUpgradeNetworkVersion {
msd = v0miner.MaxSealDuration[sector.SectorType] msd = miner0.MaxSealDuration[sector.SectorType]
mse = v0miner.MinSectorExpiration mse = miner0.MinSectorExpiration
} else { } else {
// TODO: ActorUpgrade // TODO: ActorUpgrade
msd = 0 msd = 0
@ -387,7 +387,7 @@ func (m *Sealing) handleSubmitCommit(ctx statemachine.Context, sector SectorInfo
enc := new(bytes.Buffer) enc := new(bytes.Buffer)
if nv < build.ActorUpgradeNetworkVersion { if nv < build.ActorUpgradeNetworkVersion {
params := &v0miner.ProveCommitSectorParams{ params := &miner0.ProveCommitSectorParams{
SectorNumber: sector.SectorNumber, SectorNumber: sector.SectorNumber,
Proof: sector.Proof, Proof: sector.Proof,
} }

4
node/impl/client/client.go
View File

@ -41,7 +41,7 @@ import (
"github.com/filecoin-project/go-multistore" "github.com/filecoin-project/go-multistore"
"github.com/filecoin-project/go-padreader" "github.com/filecoin-project/go-padreader"
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper" "github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
marketevents "github.com/filecoin-project/lotus/markets/loggers" marketevents "github.com/filecoin-project/lotus/markets/loggers"
@ -87,7 +87,7 @@ func calcDealExpiration(minDuration uint64, md *dline.Info, startEpoch abi.Chain
minExp := startEpoch + abi.ChainEpoch(minDuration) minExp := startEpoch + abi.ChainEpoch(minDuration)
// Align on miners ProvingPeriodBoundary // Align on miners ProvingPeriodBoundary
return minExp + v0miner.WPoStProvingPeriod - (minExp % v0miner.WPoStProvingPeriod) + (md.PeriodStart % v0miner.WPoStProvingPeriod) - 1 return minExp + miner0.WPoStProvingPeriod - (minExp % miner0.WPoStProvingPeriod) + (md.PeriodStart % miner0.WPoStProvingPeriod) - 1
} }
func (a *API) imgr() *importmgr.Mgr { func (a *API) imgr() *importmgr.Mgr {

14
node/impl/full/state.go
View File

@ -5,7 +5,7 @@ import (
"context" "context"
"strconv" "strconv"
v0market "github.com/filecoin-project/specs-actors/actors/builtin/market" market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
"github.com/filecoin-project/lotus/chain/actors/builtin/verifreg" "github.com/filecoin-project/lotus/chain/actors/builtin/verifreg"
@ -24,7 +24,7 @@ import (
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper" "github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/filecoin-project/specs-actors/actors/util/adt" "github.com/filecoin-project/specs-actors/actors/util/adt"
"github.com/filecoin-project/specs-actors/actors/util/smoothing" "github.com/filecoin-project/specs-actors/actors/util/smoothing"
@ -921,7 +921,7 @@ func (a *StateAPI) StateMinerPreCommitDepositForPower(ctx context.Context, maddr
duration := pci.Expiration - ts.Height() duration := pci.Expiration - ts.Height()
// TODO: ActorUpgrade // TODO: ActorUpgrade
sectorWeight = v0miner.QAPowerForWeight(ssize, duration, w, vw) sectorWeight = miner0.QAPowerForWeight(ssize, duration, w, vw)
} }
var powerSmoothed smoothing.FilterEstimate var powerSmoothed smoothing.FilterEstimate
@ -947,7 +947,7 @@ func (a *StateAPI) StateMinerPreCommitDepositForPower(ctx context.Context, maddr
} }
// TODO: ActorUpgrade // TODO: ActorUpgrade
deposit := v0miner.PreCommitDepositForPower(&rewardSmoothed, &powerSmoothed, sectorWeight) deposit := miner0.PreCommitDepositForPower(&rewardSmoothed, &powerSmoothed, sectorWeight)
return types.BigDiv(types.BigMul(deposit, initialPledgeNum), initialPledgeDen), nil return types.BigDiv(types.BigMul(deposit, initialPledgeNum), initialPledgeDen), nil
} }
@ -983,7 +983,7 @@ func (a *StateAPI) StateMinerInitialPledgeCollateral(ctx context.Context, maddr
duration := pci.Expiration - ts.Height() duration := pci.Expiration - ts.Height()
// TODO: handle changes to this function across actor upgrades. // TODO: handle changes to this function across actor upgrades.
sectorWeight = v0miner.QAPowerForWeight(ssize, duration, w, vw) sectorWeight = miner0.QAPowerForWeight(ssize, duration, w, vw)
} }
var ( var (
@ -1027,7 +1027,7 @@ func (a *StateAPI) StateMinerInitialPledgeCollateral(ctx context.Context, maddr
// TODO: ActorUpgrade // TODO: ActorUpgrade
initialPledge := v0miner.InitialPledgeForPower( initialPledge := miner0.InitialPledgeForPower(
sectorWeight, sectorWeight,
baselinePower, baselinePower,
pledgeCollateral, pledgeCollateral,
@ -1145,7 +1145,7 @@ func (a *StateAPI) StateDealProviderCollateralBounds(ctx context.Context, size a
return api.DealCollateralBounds{}, xerrors.Errorf("getting reward baseline power: %w", err) return api.DealCollateralBounds{}, xerrors.Errorf("getting reward baseline power: %w", err)
} }
min, max := v0market.DealProviderCollateralBounds(size, min, max := market0.DealProviderCollateralBounds(size,
verified, verified,
powClaim.RawBytePower, powClaim.RawBytePower,
powClaim.QualityAdjPower, powClaim.QualityAdjPower,

14
node/node_test.go
View File

@ -10,9 +10,9 @@ import (
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/lotus/lib/lotuslog" "github.com/filecoin-project/lotus/lib/lotuslog"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
v0power "github.com/filecoin-project/specs-actors/actors/builtin/power" power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
v0verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
logging "github.com/ipfs/go-log/v2" logging "github.com/ipfs/go-log/v2"
"github.com/filecoin-project/lotus/api/test" "github.com/filecoin-project/lotus/api/test"
@ -21,11 +21,11 @@ import (
func init() { func init() {
_ = logging.SetLogLevel("*", "INFO") _ = logging.SetLogLevel("*", "INFO")
v0power.ConsensusMinerMinPower = big.NewInt(2048) power0.ConsensusMinerMinPower = big.NewInt(2048)
v0miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{ miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
abi.RegisteredSealProof_StackedDrg2KiBV1: {}, abi.RegisteredSealProof_StackedDrg2KiBV1: {},
} }
v0verifreg.MinVerifiedDealSize = big.NewInt(256) verifreg0.MinVerifiedDealSize = big.NewInt(256)
} }
func TestAPI(t *testing.T) { func TestAPI(t *testing.T) {
@ -68,7 +68,7 @@ func TestAPIDealFlowReal(t *testing.T) {
logging.SetLogLevel("sub", "ERROR") logging.SetLogLevel("sub", "ERROR")
logging.SetLogLevel("storageminer", "ERROR") logging.SetLogLevel("storageminer", "ERROR")
v0miner.PreCommitChallengeDelay = 5 miner0.PreCommitChallengeDelay = 5
t.Run("basic", func(t *testing.T) { t.Run("basic", func(t *testing.T) {
test.TestDealFlow(t, builder.Builder, time.Second, false, false) test.TestDealFlow(t, builder.Builder, time.Second, false, false)

4
node/test/builder.go
View File

@ -37,7 +37,7 @@ import (
"github.com/filecoin-project/lotus/node/repo" "github.com/filecoin-project/lotus/node/repo"
"github.com/filecoin-project/lotus/storage/mockstorage" "github.com/filecoin-project/lotus/storage/mockstorage"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/ipfs/go-datastore" "github.com/ipfs/go-datastore"
"github.com/libp2p/go-libp2p-core/crypto" "github.com/libp2p/go-libp2p-core/crypto"
"github.com/libp2p/go-libp2p-core/peer" "github.com/libp2p/go-libp2p-core/peer"
@ -83,7 +83,7 @@ func CreateTestStorageNode(ctx context.Context, t *testing.T, waddr address.Addr
peerid, err := peer.IDFromPrivateKey(pk) peerid, err := peer.IDFromPrivateKey(pk)
require.NoError(t, err) require.NoError(t, err)
enc, err := actors.SerializeParams(&v0miner.ChangePeerIDParams{NewID: abi.PeerID(peerid)}) enc, err := actors.SerializeParams(&miner0.ChangePeerIDParams{NewID: abi.PeerID(peerid)})
require.NoError(t, err) require.NoError(t, err)
msg := &types.Message{ msg := &types.Message{

14
paychmgr/manager.go
View File

@ -12,7 +12,7 @@ import (
"github.com/filecoin-project/go-address" "github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-state-types/crypto" "github.com/filecoin-project/go-state-types/crypto"
v0paych "github.com/filecoin-project/specs-actors/actors/builtin/paych" paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
"github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
@ -221,7 +221,7 @@ func (pm *Manager) GetChannelInfo(addr address.Address) (*ChannelInfo, error) {
return ca.getChannelInfo(addr) return ca.getChannelInfo(addr)
} }
func (pm *Manager) CreateVoucher(ctx context.Context, ch address.Address, voucher v0paych.SignedVoucher) (*api.VoucherCreateResult, error) { func (pm *Manager) CreateVoucher(ctx context.Context, ch address.Address, voucher paych0.SignedVoucher) (*api.VoucherCreateResult, error) {
ca, err := pm.accessorByAddress(ch) ca, err := pm.accessorByAddress(ch)
if err != nil { if err != nil {
return nil, err return nil, err
@ -233,7 +233,7 @@ func (pm *Manager) CreateVoucher(ctx context.Context, ch address.Address, vouche
// CheckVoucherValid checks if the given voucher is valid (is or could become spendable at some point). // CheckVoucherValid checks if the given voucher is valid (is or could become spendable at some point).
// If the channel is not in the store, fetches the channel from state (and checks that // If the channel is not in the store, fetches the channel from state (and checks that
// the channel To address is owned by the wallet). // the channel To address is owned by the wallet).
func (pm *Manager) CheckVoucherValid(ctx context.Context, ch address.Address, sv *v0paych.SignedVoucher) error { func (pm *Manager) CheckVoucherValid(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher) error {
// Get an accessor for the channel, creating it from state if necessary // Get an accessor for the channel, creating it from state if necessary
ca, err := pm.inboundChannelAccessor(ctx, ch) ca, err := pm.inboundChannelAccessor(ctx, ch)
if err != nil { if err != nil {
@ -245,7 +245,7 @@ func (pm *Manager) CheckVoucherValid(ctx context.Context, ch address.Address, sv
} }
// CheckVoucherSpendable checks if the given voucher is currently spendable // CheckVoucherSpendable checks if the given voucher is currently spendable
func (pm *Manager) CheckVoucherSpendable(ctx context.Context, ch address.Address, sv *v0paych.SignedVoucher, secret []byte, proof []byte) (bool, error) { func (pm *Manager) CheckVoucherSpendable(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, secret []byte, proof []byte) (bool, error) {
ca, err := pm.accessorByAddress(ch) ca, err := pm.accessorByAddress(ch)
if err != nil { if err != nil {
return false, err return false, err
@ -256,7 +256,7 @@ func (pm *Manager) CheckVoucherSpendable(ctx context.Context, ch address.Address
// AddVoucherOutbound adds a voucher for an outbound channel. // AddVoucherOutbound adds a voucher for an outbound channel.
// Returns an error if the channel is not already in the store. // Returns an error if the channel is not already in the store.
func (pm *Manager) AddVoucherOutbound(ctx context.Context, ch address.Address, sv *v0paych.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) { func (pm *Manager) AddVoucherOutbound(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
ca, err := pm.accessorByAddress(ch) ca, err := pm.accessorByAddress(ch)
if err != nil { if err != nil {
return types.NewInt(0), err return types.NewInt(0), err
@ -267,7 +267,7 @@ func (pm *Manager) AddVoucherOutbound(ctx context.Context, ch address.Address, s
// AddVoucherInbound adds a voucher for an inbound channel. // AddVoucherInbound adds a voucher for an inbound channel.
// If the channel is not in the store, fetches the channel from state (and checks that // If the channel is not in the store, fetches the channel from state (and checks that
// the channel To address is owned by the wallet). // the channel To address is owned by the wallet).
func (pm *Manager) AddVoucherInbound(ctx context.Context, ch address.Address, sv *v0paych.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) { func (pm *Manager) AddVoucherInbound(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
// Get an accessor for the channel, creating it from state if necessary // Get an accessor for the channel, creating it from state if necessary
ca, err := pm.inboundChannelAccessor(ctx, ch) ca, err := pm.inboundChannelAccessor(ctx, ch)
if err != nil { if err != nil {
@ -336,7 +336,7 @@ func (pm *Manager) trackInboundChannel(ctx context.Context, ch address.Address)
return pm.store.TrackChannel(stateCi) return pm.store.TrackChannel(stateCi)
} }
func (pm *Manager) SubmitVoucher(ctx context.Context, ch address.Address, sv *v0paych.SignedVoucher, secret []byte, proof []byte) (cid.Cid, error) { func (pm *Manager) SubmitVoucher(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, secret []byte, proof []byte) (cid.Cid, error) {
ca, err := pm.accessorByAddress(ch) ca, err := pm.accessorByAddress(ch)
if err != nil { if err != nil {
return cid.Undef, err return cid.Undef, err

22
paychmgr/paych.go
View File

@ -12,7 +12,7 @@ import (
cborutil "github.com/filecoin-project/go-cbor-util" cborutil "github.com/filecoin-project/go-cbor-util"
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0paych "github.com/filecoin-project/specs-actors/actors/builtin/paych" paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
"github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/chain/actors" "github.com/filecoin-project/lotus/chain/actors"
@ -103,7 +103,7 @@ func (ca *channelAccessor) outboundActiveByFromTo(from, to address.Address) (*Ch
// nonce, signing the voucher and storing it in the local datastore. // nonce, signing the voucher and storing it in the local datastore.
// If there are not enough funds in the channel to create the voucher, returns // If there are not enough funds in the channel to create the voucher, returns
// the shortfall in funds. // the shortfall in funds.
func (ca *channelAccessor) createVoucher(ctx context.Context, ch address.Address, voucher v0paych.SignedVoucher) (*api.VoucherCreateResult, error) { func (ca *channelAccessor) createVoucher(ctx context.Context, ch address.Address, voucher paych0.SignedVoucher) (*api.VoucherCreateResult, error) {
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
@ -162,14 +162,14 @@ func (ca *channelAccessor) nextNonceForLane(ci *ChannelInfo, lane uint64) uint64
return maxnonce + 1 return maxnonce + 1
} }
func (ca *channelAccessor) checkVoucherValid(ctx context.Context, ch address.Address, sv *v0paych.SignedVoucher) (map[uint64]paych.LaneState, error) { func (ca *channelAccessor) checkVoucherValid(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher) (map[uint64]paych.LaneState, error) {
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
return ca.checkVoucherValidUnlocked(ctx, ch, sv) return ca.checkVoucherValidUnlocked(ctx, ch, sv)
} }
func (ca *channelAccessor) checkVoucherValidUnlocked(ctx context.Context, ch address.Address, sv *v0paych.SignedVoucher) (map[uint64]paych.LaneState, error) { func (ca *channelAccessor) checkVoucherValidUnlocked(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher) (map[uint64]paych.LaneState, error) {
if sv.ChannelAddr != ch { if sv.ChannelAddr != ch {
return nil, xerrors.Errorf("voucher ChannelAddr doesn't match channel address, got %s, expected %s", sv.ChannelAddr, ch) return nil, xerrors.Errorf("voucher ChannelAddr doesn't match channel address, got %s, expected %s", sv.ChannelAddr, ch)
} }
@ -251,7 +251,7 @@ func (ca *channelAccessor) checkVoucherValidUnlocked(ctx context.Context, ch add
return laneStates, nil return laneStates, nil
} }
func (ca *channelAccessor) checkVoucherSpendable(ctx context.Context, ch address.Address, sv *v0paych.SignedVoucher, secret []byte, proof []byte) (bool, error) { func (ca *channelAccessor) checkVoucherSpendable(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, secret []byte, proof []byte) (bool, error) {
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
@ -290,7 +290,7 @@ func (ca *channelAccessor) checkVoucherSpendable(ctx context.Context, ch address
} }
} }
enc, err := actors.SerializeParams(&v0paych.UpdateChannelStateParams{ enc, err := actors.SerializeParams(&paych0.UpdateChannelStateParams{
Sv: *sv, Sv: *sv,
Secret: secret, Secret: secret,
Proof: proof, Proof: proof,
@ -325,14 +325,14 @@ func (ca *channelAccessor) getPaychRecipient(ctx context.Context, ch address.Add
return state.To(), nil return state.To(), nil
} }
func (ca *channelAccessor) addVoucher(ctx context.Context, ch address.Address, sv *v0paych.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) { func (ca *channelAccessor) addVoucher(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
return ca.addVoucherUnlocked(ctx, ch, sv, proof, minDelta) return ca.addVoucherUnlocked(ctx, ch, sv, proof, minDelta)
} }
func (ca *channelAccessor) addVoucherUnlocked(ctx context.Context, ch address.Address, sv *v0paych.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) { func (ca *channelAccessor) addVoucherUnlocked(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
ci, err := ca.store.ByAddress(ch) ci, err := ca.store.ByAddress(ch)
if err != nil { if err != nil {
return types.BigInt{}, err return types.BigInt{}, err
@ -396,7 +396,7 @@ func (ca *channelAccessor) addVoucherUnlocked(ctx context.Context, ch address.Ad
return delta, ca.store.putChannelInfo(ci) return delta, ca.store.putChannelInfo(ci)
} }
func (ca *channelAccessor) submitVoucher(ctx context.Context, ch address.Address, sv *v0paych.SignedVoucher, secret []byte, proof []byte) (cid.Cid, error) { func (ca *channelAccessor) submitVoucher(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, secret []byte, proof []byte) (cid.Cid, error) {
ca.lk.Lock() ca.lk.Lock()
defer ca.lk.Unlock() defer ca.lk.Unlock()
@ -437,7 +437,7 @@ func (ca *channelAccessor) submitVoucher(ctx context.Context, ch address.Address
} }
} }
enc, err := actors.SerializeParams(&v0paych.UpdateChannelStateParams{ enc, err := actors.SerializeParams(&paych0.UpdateChannelStateParams{
Sv: *sv, Sv: *sv,
Secret: secret, Secret: secret,
Proof: proof, Proof: proof,
@ -543,7 +543,7 @@ func (ca *channelAccessor) laneState(ctx context.Context, state paych.State, ch
} }
// Get the total redeemed amount across all lanes, after applying the voucher // Get the total redeemed amount across all lanes, after applying the voucher
func (ca *channelAccessor) totalRedeemedWithVoucher(laneStates map[uint64]paych.LaneState, sv *v0paych.SignedVoucher) (big.Int, error) { func (ca *channelAccessor) totalRedeemedWithVoucher(laneStates map[uint64]paych.LaneState, sv *paych0.SignedVoucher) (big.Int, error) {
// TODO: merges // TODO: merges
if len(sv.Merges) != 0 { if len(sv.Merges) != 0 {
return big.Int{}, xerrors.Errorf("dont currently support paych lane merges") return big.Int{}, xerrors.Errorf("dont currently support paych lane merges")

36
paychmgr/paych_test.go
View File

@ -15,7 +15,7 @@ import (
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/go-state-types/crypto" "github.com/filecoin-project/go-state-types/crypto"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0paych "github.com/filecoin-project/specs-actors/actors/builtin/paych" paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
tutils "github.com/filecoin-project/specs-actors/support/testing" tutils "github.com/filecoin-project/specs-actors/support/testing"
"github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/api"
@ -339,7 +339,7 @@ func TestCreateVoucher(t *testing.T) {
// Create a voucher in lane 1 // Create a voucher in lane 1
voucherLane1Amt := big.NewInt(5) voucherLane1Amt := big.NewInt(5)
voucher := v0paych.SignedVoucher{ voucher := paych0.SignedVoucher{
Lane: 1, Lane: 1,
Amount: voucherLane1Amt, Amount: voucherLane1Amt,
} }
@ -354,7 +354,7 @@ func TestCreateVoucher(t *testing.T) {
// Create a voucher in lane 1 again, with a higher amount // Create a voucher in lane 1 again, with a higher amount
voucherLane1Amt = big.NewInt(8) voucherLane1Amt = big.NewInt(8)
voucher = v0paych.SignedVoucher{ voucher = paych0.SignedVoucher{
Lane: 1, Lane: 1,
Amount: voucherLane1Amt, Amount: voucherLane1Amt,
} }
@ -369,7 +369,7 @@ func TestCreateVoucher(t *testing.T) {
// Create a voucher in lane 2 that covers all the remaining funds // Create a voucher in lane 2 that covers all the remaining funds
// in the channel // in the channel
voucherLane2Amt := big.Sub(s.amt, voucherLane1Amt) voucherLane2Amt := big.Sub(s.amt, voucherLane1Amt)
voucher = v0paych.SignedVoucher{ voucher = paych0.SignedVoucher{
Lane: 2, Lane: 2,
Amount: voucherLane2Amt, Amount: voucherLane2Amt,
} }
@ -383,7 +383,7 @@ func TestCreateVoucher(t *testing.T) {
// Create a voucher in lane 2 that exceeds the remaining funds in the // Create a voucher in lane 2 that exceeds the remaining funds in the
// channel // channel
voucherLane2Amt = big.Add(voucherLane2Amt, big.NewInt(1)) voucherLane2Amt = big.Add(voucherLane2Amt, big.NewInt(1))
voucher = v0paych.SignedVoucher{ voucher = paych0.SignedVoucher{
Lane: 2, Lane: 2,
Amount: voucherLane2Amt, Amount: voucherLane2Amt,
} }
@ -772,7 +772,7 @@ func TestCheckSpendable(t *testing.T) {
// Check that the secret and proof were passed through correctly // Check that the secret and proof were passed through correctly
lastCall := s.mock.getLastCall() lastCall := s.mock.getLastCall()
var p v0paych.UpdateChannelStateParams var p paych0.UpdateChannelStateParams
err = p.UnmarshalCBOR(bytes.NewReader(lastCall.Params)) err = p.UnmarshalCBOR(bytes.NewReader(lastCall.Params))
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, otherProof, p.Proof) require.Equal(t, otherProof, p.Proof)
@ -786,7 +786,7 @@ func TestCheckSpendable(t *testing.T) {
require.True(t, spendable) require.True(t, spendable)
lastCall = s.mock.getLastCall() lastCall = s.mock.getLastCall()
var p2 v0paych.UpdateChannelStateParams var p2 paych0.UpdateChannelStateParams
err = p2.UnmarshalCBOR(bytes.NewReader(lastCall.Params)) err = p2.UnmarshalCBOR(bytes.NewReader(lastCall.Params))
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, proof, p2.Proof) require.Equal(t, proof, p2.Proof)
@ -843,7 +843,7 @@ func TestSubmitVoucher(t *testing.T) {
// Check that the secret and proof were passed through correctly // Check that the secret and proof were passed through correctly
msg := s.mock.pushedMessages(submitCid) msg := s.mock.pushedMessages(submitCid)
var p v0paych.UpdateChannelStateParams var p paych0.UpdateChannelStateParams
err = p.UnmarshalCBOR(bytes.NewReader(msg.Message.Params)) err = p.UnmarshalCBOR(bytes.NewReader(msg.Message.Params))
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, submitProof, p.Proof) require.Equal(t, submitProof, p.Proof)
@ -863,7 +863,7 @@ func TestSubmitVoucher(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
msg = s.mock.pushedMessages(submitCid) msg = s.mock.pushedMessages(submitCid)
var p2 v0paych.UpdateChannelStateParams var p2 paych0.UpdateChannelStateParams
err = p2.UnmarshalCBOR(bytes.NewReader(msg.Message.Params)) err = p2.UnmarshalCBOR(bytes.NewReader(msg.Message.Params))
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, addVoucherProof2, p2.Proof) require.Equal(t, addVoucherProof2, p2.Proof)
@ -879,7 +879,7 @@ func TestSubmitVoucher(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
msg = s.mock.pushedMessages(submitCid) msg = s.mock.pushedMessages(submitCid)
var p3 v0paych.UpdateChannelStateParams var p3 paych0.UpdateChannelStateParams
err = p3.UnmarshalCBOR(bytes.NewReader(msg.Message.Params)) err = p3.UnmarshalCBOR(bytes.NewReader(msg.Message.Params))
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, proof3, p3.Proof) require.Equal(t, proof3, p3.Proof)
@ -966,8 +966,8 @@ func testGenerateKeyPair(t *testing.T) ([]byte, []byte) {
return priv, pub return priv, pub
} }
func createTestVoucher(t *testing.T, ch address.Address, voucherLane uint64, nonce uint64, voucherAmount big.Int, key []byte) *v0paych.SignedVoucher { func createTestVoucher(t *testing.T, ch address.Address, voucherLane uint64, nonce uint64, voucherAmount big.Int, key []byte) *paych0.SignedVoucher {
sv := &v0paych.SignedVoucher{ sv := &paych0.SignedVoucher{
ChannelAddr: ch, ChannelAddr: ch,
Lane: voucherLane, Lane: voucherLane,
Nonce: nonce, Nonce: nonce,
@ -982,13 +982,13 @@ func createTestVoucher(t *testing.T, ch address.Address, voucherLane uint64, non
return sv return sv
} }
func createTestVoucherWithExtra(t *testing.T, ch address.Address, voucherLane uint64, nonce uint64, voucherAmount big.Int, key []byte) *v0paych.SignedVoucher { func createTestVoucherWithExtra(t *testing.T, ch address.Address, voucherLane uint64, nonce uint64, voucherAmount big.Int, key []byte) *paych0.SignedVoucher {
sv := &v0paych.SignedVoucher{ sv := &paych0.SignedVoucher{
ChannelAddr: ch, ChannelAddr: ch,
Lane: voucherLane, Lane: voucherLane,
Nonce: nonce, Nonce: nonce,
Amount: voucherAmount, Amount: voucherAmount,
Extra: &v0paych.ModVerifyParams{ Extra: &paych0.ModVerifyParams{
Actor: tutils.NewActorAddr(t, "act"), Actor: tutils.NewActorAddr(t, "act"),
}, },
} }
@ -1006,13 +1006,13 @@ type mockBestSpendableAPI struct {
mgr *Manager mgr *Manager
} }
func (m *mockBestSpendableAPI) PaychVoucherList(ctx context.Context, ch address.Address) ([]*v0paych.SignedVoucher, error) { func (m *mockBestSpendableAPI) PaychVoucherList(ctx context.Context, ch address.Address) ([]*paych0.SignedVoucher, error) {
vi, err := m.mgr.ListVouchers(ctx, ch) vi, err := m.mgr.ListVouchers(ctx, ch)
if err != nil { if err != nil {
return nil, err return nil, err
} }
out := make([]*v0paych.SignedVoucher, len(vi)) out := make([]*paych0.SignedVoucher, len(vi))
for k, v := range vi { for k, v := range vi {
out[k] = v.Voucher out[k] = v.Voucher
} }
@ -1020,7 +1020,7 @@ func (m *mockBestSpendableAPI) PaychVoucherList(ctx context.Context, ch address.
return out, nil return out, nil
} }
func (m *mockBestSpendableAPI) PaychVoucherCheckSpendable(ctx context.Context, ch address.Address, voucher *v0paych.SignedVoucher, secret []byte, proof []byte) (bool, error) { func (m *mockBestSpendableAPI) PaychVoucherCheckSpendable(ctx context.Context, ch address.Address, voucher *paych0.SignedVoucher, secret []byte, proof []byte) (bool, error) {
return m.mgr.CheckVoucherSpendable(ctx, ch, voucher, secret, proof) return m.mgr.CheckVoucherSpendable(ctx, ch, voucher, secret, proof)
} }

4
paychmgr/simple.go
View File

@ -14,7 +14,7 @@ import (
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
init_ "github.com/filecoin-project/specs-actors/actors/builtin/init" init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
v0paych "github.com/filecoin-project/specs-actors/actors/builtin/paych" paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
"github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
@ -382,7 +382,7 @@ func (ca *channelAccessor) processTask(ctx context.Context, amt types.BigInt) *p
// createPaych sends a message to create the channel and returns the message cid // createPaych sends a message to create the channel and returns the message cid
func (ca *channelAccessor) createPaych(ctx context.Context, amt types.BigInt) (cid.Cid, error) { func (ca *channelAccessor) createPaych(ctx context.Context, amt types.BigInt) (cid.Cid, error) {
params, aerr := actors.SerializeParams(&v0paych.ConstructorParams{From: ca.from, To: ca.to}) params, aerr := actors.SerializeParams(&paych0.ConstructorParams{From: ca.from, To: ca.to})
if aerr != nil { if aerr != nil {
return cid.Undef, aerr return cid.Undef, aerr
} }

4
storage/adapter_storage_miner.go
View File

@ -15,7 +15,7 @@ import (
"github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/go-state-types/crypto" "github.com/filecoin-project/go-state-types/crypto"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0market "github.com/filecoin-project/specs-actors/actors/builtin/market" market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
"github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/api/apibstore" "github.com/filecoin-project/lotus/api/apibstore"
@ -137,7 +137,7 @@ func (s SealingAPIAdapter) StateComputeDataCommitment(ctx context.Context, maddr
return cid.Undef, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err) return cid.Undef, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
} }
ccparams, err := actors.SerializeParams(&v0market.ComputeDataCommitmentParams{ ccparams, err := actors.SerializeParams(&market0.ComputeDataCommitmentParams{
DealIDs: deals, DealIDs: deals,
SectorType: sectorType, SectorType: sectorType,
}) })

4
storage/miner.go
View File

@ -5,7 +5,7 @@ import (
"errors" "errors"
"time" "time"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/network"
@ -146,7 +146,7 @@ func (m *Miner) Run(ctx context.Context) error {
evts := events.NewEvents(ctx, m.api) evts := events.NewEvents(ctx, m.api)
adaptedAPI := NewSealingAPIAdapter(m.api) adaptedAPI := NewSealingAPIAdapter(m.api)
// TODO: Maybe we update this policy after actor upgrades? // TODO: Maybe we update this policy after actor upgrades?
pcp := sealing.NewBasicPreCommitPolicy(adaptedAPI, v0miner.MaxSectorExpirationExtension-(v0miner.WPoStProvingPeriod*2), md.PeriodStart%v0miner.WPoStProvingPeriod) pcp := sealing.NewBasicPreCommitPolicy(adaptedAPI, miner0.MaxSectorExpirationExtension-(miner0.WPoStProvingPeriod*2), md.PeriodStart%miner0.WPoStProvingPeriod)
m.sealing = sealing.New(adaptedAPI, fc, NewEventsAdapter(evts), m.maddr, m.ds, m.sealer, m.sc, m.verif, &pcp, sealing.GetSealingConfigFunc(m.getSealConfig), m.handleSealingNotifications) m.sealing = sealing.New(adaptedAPI, fc, NewEventsAdapter(evts), m.maddr, m.ds, m.sealer, m.sc, m.verif, &pcp, sealing.GetSealingConfigFunc(m.getSealConfig), m.handleSealingNotifications)
go m.sealing.Run(ctx) //nolint:errcheck // logged intside the function go m.sealing.Run(ctx) //nolint:errcheck // logged intside the function

8
storage/wdpost_run_test.go
View File

@ -19,8 +19,8 @@ import (
"github.com/filecoin-project/go-state-types/crypto" "github.com/filecoin-project/go-state-types/crypto"
"github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/network"
"github.com/filecoin-project/specs-actors/actors/builtin" "github.com/filecoin-project/specs-actors/actors/builtin"
v0builtin "github.com/filecoin-project/specs-actors/actors/builtin" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/filecoin-project/specs-actors/actors/runtime/proof" "github.com/filecoin-project/specs-actors/actors/runtime/proof"
tutils "github.com/filecoin-project/specs-actors/support/testing" tutils "github.com/filecoin-project/specs-actors/support/testing"
@ -134,7 +134,7 @@ func TestWDPostDoPost(t *testing.T) {
// without exceeding the message sector limit // without exceeding the message sector limit
require.NoError(t, err) require.NoError(t, err)
partitionsPerMsg := int(v0miner.AddressedSectorsMax / sectorsPerPartition) partitionsPerMsg := int(miner0.AddressedSectorsMax / sectorsPerPartition)
// Enough partitions to fill expectedMsgCount-1 messages // Enough partitions to fill expectedMsgCount-1 messages
partitionCount := (expectedMsgCount - 1) * partitionsPerMsg partitionCount := (expectedMsgCount - 1) * partitionsPerMsg
@ -249,7 +249,7 @@ func (m *mockStorageMinerAPI) StateSearchMsg(ctx context.Context, cid cid.Cid) (
func (m *mockStorageMinerAPI) StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error) { func (m *mockStorageMinerAPI) StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error) {
return &types.Actor{ return &types.Actor{
Code: v0builtin.StorageMinerActorCodeID, Code: builtin0.StorageMinerActorCodeID,
}, nil }, nil
} }