Network upgrade support

api/api_full.go

@@ -18,6 +18,7 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/dline"
 	"github.com/filecoin-project/specs-actors/actors/builtin/market"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
@@ -312,15 +313,11 @@ type FullNode interface {
 	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) ([]*ChainSectorInfo, error)
 	// StateMinerProvingDeadline calculates the deadline at some epoch for a proving period
 	// and returns the deadline-related calculations.
-	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*miner.DeadlineInfo, error)
+	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
 	// StateMinerPower returns the power of the indicated miner
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
 	// StateMinerInfo returns info about the indicated miner
 	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (MinerInfo, error)
-	// StateMinerDeadlines returns all the proving deadlines for the given miner
-	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]*miner.Deadline, error)
-	// StateMinerPartitions loads miner partitions for the specified miner/deadline
-	StateMinerPartitions(context.Context, address.Address, uint64, types.TipSetKey) ([]*miner.Partition, error)
 	// StateMinerFaults returns a bitfield indicating the faulty sectors of the given miner
 	StateMinerFaults(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)
 	// StateAllMinerFaults returns all non-expired Faults that occur within lookback epochs of the given tipset

api/types.go

@@ -8,9 +8,10 @@ import (
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/ipfs/go-cid"
 
+	v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
 	"github.com/libp2p/go-libp2p-core/peer"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	ma "github.com/multiformats/go-multiaddr"
@@ -49,48 +50,6 @@ type PubsubScore struct {
 	Score *pubsub.PeerScoreSnapshot
 }
 
-type MinerInfo struct {
-	Owner                      address.Address   // Must be an ID-address.
-	Worker                     address.Address   // Must be an ID-address.
-	NewWorker                  address.Address   // Must be an ID-address.
-	ControlAddresses           []address.Address // Must be an ID-addresses.
-	WorkerChangeEpoch          abi.ChainEpoch
-	PeerId                     *peer.ID
-	Multiaddrs                 []abi.Multiaddrs
-	SealProofType              abi.RegisteredSealProof
-	SectorSize                 abi.SectorSize
-	WindowPoStPartitionSectors uint64
-}
-
-func NewApiMinerInfo(info *miner.MinerInfo) MinerInfo {
-	var pid *peer.ID
-	if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
-		pid = &peerID
-	}
-
-	mi := MinerInfo{
-		Owner:            info.Owner,
-		Worker:           info.Worker,
-		ControlAddresses: info.ControlAddresses,
-
-		NewWorker:         address.Undef,
-		WorkerChangeEpoch: -1,
-
-		PeerId:                     pid,
-		Multiaddrs:                 info.Multiaddrs,
-		SealProofType:              info.SealProofType,
-		SectorSize:                 info.SectorSize,
-		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
-	}
-
-	if info.PendingWorkerKey != nil {
-		mi.NewWorker = info.PendingWorkerKey.NewWorker
-		mi.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
-	}
-
-	return mi
-}
-
 type MessageSendSpec struct {
 	MaxFee abi.TokenAmount
 }
@@ -151,3 +110,5 @@ func NewDataTransferChannel(hostID peer.ID, channelState datatransfer.ChannelSta
 	}
 	return channel
 }
+
+type 

chain/actors/adt/adt.go

@@ -0,0 +1,57 @@
+package adt
+
+import (
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	v0adt "github.com/filecoin-project/specs-actors/actors/util/adt"
+)
+
+type Map interface {
+	Root() (cid.Cid, error)
+
+	Put(k abi.Keyer, v cbor.Marshaler) error
+	Get(k abi.Keyer, v cbor.Unmarshaler) (bool, error)
+	Delete(k abi.Keyer) error
+
+	ForEach(v cbor.Unmarshaler, fn func(key string) error) error
+}
+
+func AsMap(store Store, root cid.Cid, version network.Version) (Map, error) {
+	switch builtin.VersionForNetwork(version) {
+	case builtin.Version0:
+		return v0adt.AsMap(store, root)
+	}
+	return nil, xerrors.Errorf("unknown network version: %d", version)
+}
+
+func NewMap(store Store, version network.Version) (Map, error) {
+	switch builtin.VersionForNetwork(version) {
+	case builtin.Version0:
+		return v0adt.MakeEmptyMap(store)
+	}
+	return nil, xerrors.Errorf("unknown network version: %d", version)
+}
+
+type Array interface {
+	Root() (cid.Cid, error)
+
+	Set(idx uint64, v cbor.Marshaler) error
+	Get(idx uint64, v cbor.Unmarshaler) (bool, error)
+	Delete(idx uint64) error
+	Length() uint64
+
+	ForEach(v cbor.Unmarshaler, fn func(idx int) error) error
+}
+
+func AsArray(store Store, root cid.Cid, version network.Version) (Array, error) {
+	switch builtin.VersionForNetwork(version) {
+	case builtin.Version0:
+		return v0adt.AsArray(store, root)
+	}
+	return nil, xerrors.Errorf("unknown network version: %d", version)
+}

chain/actors/adt/store.go

@@ -0,0 +1,17 @@
+package adt
+
+import (
+	"context"
+
+	adt "github.com/filecoin-project/specs-actors/actors/util/adt"
+	cbor "github.com/ipfs/go-ipld-cbor"
+)
+
+type Store interface {
+	Context() context.Context
+	cbor.IpldStore
+}
+
+func WrapStore(ctx context.Context, store cbor.IpldStore) Store {
+	return adt.WrapStore(ctx, store)
+}

chain/actors/builtin/README.md

@@ -0,0 +1,29 @@
+# Actors
+
+This package contains shims for abstracting over different actor versions.
+
+## Design
+
+Shims in this package follow a few common design principles.
+
+### Structure Agnostic
+
+Shims interfaces defined in this package should (ideally) not change even if the
+structure of the underlying data changes. For example:
+
+* All shims store an internal "store" object. That way, state can be moved into
+  a separate object without needing to add a store to the function signature.
+* All functions must return an error, even if unused for now.
+
+### Minimal
+
+These interfaces should be expanded only as necessary to reduce maintenance burden.
+
+### Queries, not field assessors.
+
+When possible, functions should query the state instead of simply acting as
+field assessors. These queries are more likely to remain stable across
+specs-actor upgrades than specific state fields.
+
+Note: there is a trade-off here. Avoid implementing _complicated_ query logic
+inside these shims, as it will need to be replicated in every shim.

chain/actors/builtin/builtin.go

@@ -0,0 +1,23 @@
+package builtin
+
+import (
+	"fmt"
+
+	"github.com/filecoin-project/go-state-types/network"
+)
+
+type Version int
+
+const (
+	Version0 = iota
+)
+
+// Converts a network version into a specs-actors version.
+func VersionForNetwork(version network.Version) Version {
+	switch version {
+	case network.Version0, network.Version1:
+		return Version
+	default:
+		panic(fmt.Sprintf("unsupported network version %d", version))
+	}
+}

chain/actors/builtin/init/init.go

@@ -0,0 +1,32 @@
+package init
+
+import (
+	"github.com/filecoin-project/go-bitfield"
+	"github.com/filecoin-project/go-state-types/cbor"
+	"golang.org/x/xerrors"
+
+	v0builtin "github.com/filecoin-project/specs-actors/actors/builtin"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func Load(store adt.Store, act *types.Actor) (State, error) {
+	switch act.Code {
+	case v0builtin.InitActorCodeID:
+		out := v0State{store: store}
+		err := store.Get(store.Context(), act.Head, &out)
+		if err != nil {
+			return nil, err
+		}
+		return &out, nil
+	}
+	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
+}
+
+type State interface {
+	cbor.Marshaler
+
+	ResolveAddress(address addr.Address) (address.Address, bool, error)
+	MapAddressToNewID(address addr.Address) (address.Address, error)
+}

chain/actors/builtin/init/v0.go

@@ -0,0 +1,22 @@
+package init
+
+import (
+	"github.com/filecoin-project/go-address"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin/init"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+)
+
+type v0State struct {
+	init.State
+	store adt.Store
+}
+
+func (s *v0State) ResolveAddress(address address.Address) (address.Address, bool, error) {
+	return s.State.ResolveAddress(s.store, address)
+}
+
+func (s *v0State) MapAddressToNewID(address address.Address) (address.Address, error) {
+	return s.State.MapAddressToNewID(s.store, address)
+}

chain/actors/builtin/market/market.go

@@ -0,0 +1,32 @@
+package market
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/ipfs/go-cid"
+)
+
+func Load(store adt.Store, act *types.Actor) (st State, err error) {
+	switch act.Code {
+	case v0builtin.MarketActorCodeID:
+		out := v0State{store: store}
+		err := store.Get(store.Context(), act.Head, &out)
+		if err != nil {
+			return nil, err
+		}
+		return &out, nil
+	}
+	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
+}
+
+type State interface {
+	cbor.Marshaler
+	EscrowTable() (BalanceTable, error)
+	LockedTable() (BalanceTable, error)
+	TotalLocked() (abi.TokenAmount, error)
+}
+
+type BalanceTable interface {
+	Get(key address.Address) (abi.TokenAmount, error)
+}

chain/actors/builtin/market/v0.go

@@ -0,0 +1,25 @@
+package market
+
+import (
+	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+)
+
+type v0State struct {
+	market.State
+	store adt.Store
+}
+
+func (s *v0State) TotalLocked() (abi.TokenAmount, error) {
+	fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
+	fml = types.BigAdd(fml, s.TotalClientStorageFee)
+	return fml, nil
+}
+
+func (s *v0State) EscrowTable() (BalanceTable, error) {
+	return adt.AsBalanceTable(s.store, s.State.EscrowTable)
+}
+
+func (s *v0State) Lockedtable() (BalanceTable, error) {
+	return adt.AsBalanceTable(s.store, s.State.LockedTable)
+}

chain/actors/builtin/miner/miner.go

@@ -0,0 +1,59 @@
+package miner
+
+import (
+	"github.com/filecoin-project/go-bitfield"
+	"github.com/filecoin-project/go-state-types/abi"
+	"golang.org/x/xerrors"
+
+	v0builtin "github.com/filecoin-project/specs-actors/actors/builtin"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func Load(store adt.Store, act *types.Actor) (st State, err error) {
+	switch act.Code {
+	case v0builtin.StorageMinerActorCodeID:
+		out := v0State{store: store}
+		err := store.Get(store.Context(), act.Head, &out)
+		if err != nil {
+			return nil, err
+		}
+		return &out, nil
+	}
+	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
+}
+
+type State interface {
+	cbor.Marshaler
+
+	LoadDeadline(idx uint64) (Deadline, error)
+	ForEachDeadline(cb func(idx uint64, dl Deadline) error) error
+	NumDeadlines() (uint64, error)
+}
+
+type Deadline interface {
+	LoadPartition(idx uint64) (Partition, error)
+	ForEachPartition(cb func(idx uint64, part Partition) error) error
+}
+
+type Partition interface {
+	AllSectors() (bitfield.BitField, error)
+	FaultySectors() (bitfield.BitField, error)
+	RecoveringSectors() (bitfield.BitField, error)
+	LiveSectors() (bitfield.BitField, error)
+	ActiveSectors() (bitfield.BitField, error)
+}
+
+type MinerInfo struct {
+	Owner                      address.Address   // Must be an ID-address.
+	Worker                     address.Address   // Must be an ID-address.
+	NewWorker                  address.Address   // Must be an ID-address.
+	ControlAddresses           []address.Address // Must be an ID-addresses.
+	WorkerChangeEpoch          abi.ChainEpoch
+	PeerId                     *peer.ID
+	Multiaddrs                 []abi.Multiaddrs
+	SealProofType              abi.RegisteredSealProof
+	SectorSize                 abi.SectorSize
+	WindowPoStPartitionSectors uint64
+}