Merge pull request #1116 from filecoin-project/fix/v0.2.5

Correctly update proving set & sector set with amt2

Makefile

@@ -14,7 +14,7 @@ MODULES:=
 
 CLEAN:=
 BINS:=
-GOFLAGS+=-ldflags="-X "github.com/filecoin-project/lotus/build".CurrentCommit=+git$(subst -,.,$(shell git describe --always --match=NeVeRmAtCh --dirty 2>/dev/null || git rev-parse --short HEAD 2>/dev/null))"
+GOFLAGS+=-ldflags='-X="github.com/filecoin-project/lotus/build".CurrentCommit=+git$(subst -,.,$(shell git describe --always --match=NeVeRmAtCh --dirty 2>/dev/null || git rev-parse --short HEAD 2>/dev/null))'
 
 ## FFI
 
@@ -124,7 +124,7 @@ BINS+=townhall
 fountain:
 	rm -f fountain
 	go build -o fountain ./cmd/lotus-fountain
-	go run github.com/GeertJohan/go.rice/rice append --exec fountain -i ./cmd/lotus-fountain
+	go run github.com/GeertJohan/go.rice/rice append --exec fountain -i ./cmd/lotus-fountain -i ./build
 .PHONY: fountain
 BINS+=fountain
 
@@ -149,6 +149,14 @@ stats:
 .PHONY: stats
 BINS+=stats
 
+health:
+	rm -f lotus-health
+	go build -o lotus-health ./cmd/lotus-health
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-health -i ./build
+
+.PHONY: health
+BINS+=health
+
 # MISC
 
 buildall: $(BINS)

api/api_full.go

@@ -37,6 +37,7 @@ type FullNode interface {
 	ChainTipSetWeight(context.Context, *types.TipSet) (types.BigInt, error)
 	ChainGetNode(ctx context.Context, p string) (interface{}, error)
 	ChainGetMessage(context.Context, cid.Cid) (*types.Message, error)
+	ChainGetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*store.HeadChange, error)
 
 	// syncer
 	SyncState(context.Context) (*SyncState, error)
@@ -118,6 +119,7 @@ type FullNode interface {
 	StateChangedActors(context.Context, cid.Cid, cid.Cid) (map[string]types.Actor, error)
 	StateGetReceipt(context.Context, cid.Cid, *types.TipSet) (*types.MessageReceipt, error)
 	StateMinerSectorCount(context.Context, address.Address, *types.TipSet) (MinerSectors, error)
+	StateCompute(context.Context, uint64, []*types.Message, *types.TipSet) (cid.Cid, error)
 
 	MarketEnsureAvailable(context.Context, address.Address, types.BigInt) error
 	// MarketFreeBalance

api/apistruct/struct.go

@@ -40,21 +40,22 @@ type FullNodeStruct struct {
 	CommonStruct
 
 	Internal struct {
-		ChainNotify            func(context.Context) (<-chan []*store.HeadChange, error)           `perm:"read"`
-		ChainHead              func(context.Context) (*types.TipSet, error)                        `perm:"read"`
-		ChainGetRandomness     func(context.Context, types.TipSetKey, int64) ([]byte, error)       `perm:"read"`
-		ChainGetBlock          func(context.Context, cid.Cid) (*types.BlockHeader, error)          `perm:"read"`
-		ChainGetTipSet         func(context.Context, types.TipSetKey) (*types.TipSet, error)       `perm:"read"`
-		ChainGetBlockMessages  func(context.Context, cid.Cid) (*api.BlockMessages, error)          `perm:"read"`
-		ChainGetParentReceipts func(context.Context, cid.Cid) ([]*types.MessageReceipt, error)     `perm:"read"`
-		ChainGetParentMessages func(context.Context, cid.Cid) ([]api.Message, error)               `perm:"read"`
-		ChainGetTipSetByHeight func(context.Context, uint64, *types.TipSet) (*types.TipSet, error) `perm:"read"`
-		ChainReadObj           func(context.Context, cid.Cid) ([]byte, error)                      `perm:"read"`
-		ChainSetHead           func(context.Context, *types.TipSet) error                          `perm:"admin"`
-		ChainGetGenesis        func(context.Context) (*types.TipSet, error)                        `perm:"read"`
-		ChainTipSetWeight      func(context.Context, *types.TipSet) (types.BigInt, error)          `perm:"read"`
-		ChainGetNode           func(ctx context.Context, p string) (interface{}, error)            `perm:"read"`
-		ChainGetMessage        func(context.Context, cid.Cid) (*types.Message, error)              `perm:"read"`
+		ChainNotify            func(context.Context) (<-chan []*store.HeadChange, error)                            `perm:"read"`
+		ChainHead              func(context.Context) (*types.TipSet, error)                                         `perm:"read"`
+		ChainGetRandomness     func(context.Context, types.TipSetKey, int64) ([]byte, error)                        `perm:"read"`
+		ChainGetBlock          func(context.Context, cid.Cid) (*types.BlockHeader, error)                           `perm:"read"`
+		ChainGetTipSet         func(context.Context, types.TipSetKey) (*types.TipSet, error)                        `perm:"read"`
+		ChainGetBlockMessages  func(context.Context, cid.Cid) (*api.BlockMessages, error)                           `perm:"read"`
+		ChainGetParentReceipts func(context.Context, cid.Cid) ([]*types.MessageReceipt, error)                      `perm:"read"`
+		ChainGetParentMessages func(context.Context, cid.Cid) ([]api.Message, error)                                `perm:"read"`
+		ChainGetTipSetByHeight func(context.Context, uint64, *types.TipSet) (*types.TipSet, error)                  `perm:"read"`
+		ChainReadObj           func(context.Context, cid.Cid) ([]byte, error)                                       `perm:"read"`
+		ChainSetHead           func(context.Context, *types.TipSet) error                                           `perm:"admin"`
+		ChainGetGenesis        func(context.Context) (*types.TipSet, error)                                         `perm:"read"`
+		ChainTipSetWeight      func(context.Context, *types.TipSet) (types.BigInt, error)                           `perm:"read"`
+		ChainGetNode           func(ctx context.Context, p string) (interface{}, error)                             `perm:"read"`
+		ChainGetMessage        func(context.Context, cid.Cid) (*types.Message, error)                               `perm:"read"`
+		ChainGetPath           func(context.Context, types.TipSetKey, types.TipSetKey) ([]*store.HeadChange, error) `perm:"read"`
 
 		SyncState          func(context.Context) (*api.SyncState, error)                `perm:"read"`
 		SyncSubmitBlock    func(ctx context.Context, blk *types.BlockMsg) error         `perm:"write"`
@@ -114,6 +115,7 @@ type FullNodeStruct struct {
 		StateGetReceipt               func(context.Context, cid.Cid, *types.TipSet) (*types.MessageReceipt, error)                      `perm:"read"`
 		StateMinerSectorCount         func(context.Context, address.Address, *types.TipSet) (api.MinerSectors, error)                   `perm:"read"`
 		StateListMessages             func(ctx context.Context, match *types.Message, ts *types.TipSet, toht uint64) ([]cid.Cid, error) `perm:"read"`
+		StateCompute                  func(context.Context, uint64, []*types.Message, *types.TipSet) (cid.Cid, error)                   `perm:"read"`
 
 		MarketEnsureAvailable func(context.Context, address.Address, types.BigInt) error `perm:"sign"`
 
@@ -355,6 +357,10 @@ func (c *FullNodeStruct) ChainGetMessage(ctx context.Context, mc cid.Cid) (*type
 	return c.Internal.ChainGetMessage(ctx, mc)
 }
 
+func (c *FullNodeStruct) ChainGetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*store.HeadChange, error) {
+	return c.Internal.ChainGetPath(ctx, from, to)
+}
+
 func (c *FullNodeStruct) SyncState(ctx context.Context) (*api.SyncState, error) {
 	return c.Internal.SyncState(ctx)
 }
@@ -462,6 +468,10 @@ func (c *FullNodeStruct) StateListMessages(ctx context.Context, match *types.Mes
 	return c.Internal.StateListMessages(ctx, match, ts, toht)
 }
 
+func (c *FullNodeStruct) StateCompute(ctx context.Context, height uint64, msgs []*types.Message, ts *types.TipSet) (cid.Cid, error) {
+	return c.Internal.StateCompute(ctx, height, msgs, ts)
+}
+
 func (c *FullNodeStruct) MarketEnsureAvailable(ctx context.Context, addr address.Address, amt types.BigInt) error {
 	return c.Internal.MarketEnsureAvailable(ctx, addr, amt)
 }

build/forks.go

@@ -1,3 +1,7 @@
 package build
 
-// No forks yet \o/
+const ForkBlizzardHeight = 6288
+
+const ForkFrigidHeight = 7950
+
+const ForkBootyBayHeight = 11000

build/params_debug.go

@@ -2,8 +2,6 @@
 
 package build
 
-import "os"
-
 var SectorSizes = []uint64{1024}
 
 // Seconds
@@ -31,7 +29,3 @@ const InteractivePoRepConfidence = 6
 
 // Bytes
 var MinimumMinerPower uint64 = 2 << 10 // 2KiB
-
-func init() {
-	os.Setenv("TRUST_PARAMS", "1")
-}

build/params_shared.go

@@ -105,3 +105,4 @@ const BlsSignatureCacheSize = 40000
 // Limits
 
 const BlockMessageLimit = 512
+const MinerMaxSectors = 1 << 48

build/version.go

@@ -5,7 +5,7 @@ import "fmt"
 var CurrentCommit string
 
 // BuildVersion is the local build version, set by build system
-const BuildVersion = "0.2.1"
+const BuildVersion = "0.2.5"
 
 var UserVersion = BuildVersion + CurrentCommit
 

chain/actors/actor_init.go

@@ -161,7 +161,7 @@ func (ia InitActor) Exec(act *types.Actor, vmctx types.VMContext, p *ExecParams)
 
 func IsBuiltinActor(code cid.Cid) bool {
 	switch code {
-	case StorageMarketCodeCid, StoragePowerCodeCid, StorageMinerCodeCid, AccountCodeCid, InitCodeCid, MultisigCodeCid, PaymentChannelCodeCid:
+	case StorageMarketCodeCid, StoragePowerCodeCid, StorageMinerCodeCid, StorageMiner2CodeCid, AccountCodeCid, InitCodeCid, MultisigCodeCid, PaymentChannelCodeCid:
 		return true
 	default:
 		return false

chain/actors/actor_miner.go

@@ -22,8 +22,6 @@ import (
 	"golang.org/x/xerrors"
 )
 
-const MaxSectors = 1 << 48
-
 type StorageMinerActor struct{}
 
 type StorageMinerActorState struct {
@@ -571,7 +569,7 @@ func SectorIsUnique(ctx context.Context, s types.Storage, sroot cid.Cid, sid uin
 }
 
 func AddToSectorSet(ctx context.Context, blks amt.Blocks, ss cid.Cid, sectorID uint64, commR, commD []byte) (cid.Cid, ActorError) {
-	if sectorID >= MaxSectors {
+	if sectorID >= build.MinerMaxSectors {
 		return cid.Undef, aerrors.Newf(25, "sector ID out of range: %d", sectorID)
 	}
 	ssr, err := amt.LoadAMT(blks, ss)
@@ -594,7 +592,7 @@ func AddToSectorSet(ctx context.Context, blks amt.Blocks, ss cid.Cid, sectorID u
 }
 
 func GetFromSectorSet(ctx context.Context, s types.Storage, ss cid.Cid, sectorID uint64) (bool, []byte, []byte, ActorError) {
-	if sectorID >= MaxSectors {
+	if sectorID >= build.MinerMaxSectors {
 		return false, nil, nil, aerrors.Newf(25, "sector ID out of range: %d", sectorID)
 	}
 

chain/actors/actor_miner2.go

@@ -0,0 +1,865 @@
+package actors
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+	amt2 "github.com/filecoin-project/go-amt-ipld/v2"
+
+	"github.com/filecoin-project/go-sectorbuilder"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/aerrors"
+	"github.com/filecoin-project/lotus/chain/types"
+
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
+)
+
+type StorageMinerActor2 struct{}
+
+func (sma StorageMinerActor2) Exports() []interface{} {
+	return []interface{}{
+		1: sma.StorageMinerConstructor,
+		2: sma.PreCommitSector,
+		3: sma.ProveCommitSector,
+		4: sma.SubmitFallbackPoSt,
+		//5: sma.SlashStorageFault,
+		//6: sma.GetCurrentProvingSet,
+		//7:  sma.ArbitrateDeal,
+		//8:  sma.DePledge,
+		9:  sma.GetOwner,
+		10: sma.GetWorkerAddr,
+		11: sma.GetPower, // TODO: Remove
+		12: sma.GetPeerID,
+		13: sma.GetSectorSize,
+		14: sma.UpdatePeerID,
+		//15: sma.ChangeWorker,
+		16: sma.IsSlashed,
+		17: sma.CheckMiner,
+		18: sma.DeclareFaults,
+		19: sma.SlashConsensusFault,
+		20: sma.SubmitElectionPoSt,
+	}
+}
+
+func (sma StorageMinerActor2) StorageMinerConstructor(act *types.Actor, vmctx types.VMContext, params *StorageMinerConstructorParams) ([]byte, ActorError) {
+	minerInfo := &MinerInfo{
+		Owner:      params.Owner,
+		Worker:     params.Worker,
+		PeerID:     params.PeerID,
+		SectorSize: params.SectorSize,
+	}
+
+	minfocid, err := vmctx.Storage().Put(minerInfo)
+	if err != nil {
+		return nil, err
+	}
+
+	var self StorageMinerActorState
+	sectors := amt2.NewAMT(types.WrapStorage(vmctx.Storage()))
+	scid, serr := sectors.Flush()
+	if serr != nil {
+		return nil, aerrors.HandleExternalError(serr, "initializing AMT")
+	}
+
+	self.Sectors = scid
+	self.ProvingSet = scid
+	self.Info = minfocid
+
+	storage := vmctx.Storage()
+	c, err := storage.Put(&self)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := storage.Commit(EmptyCBOR, c); err != nil {
+		return nil, err
+	}
+
+	return nil, nil
+}
+
+func (sma StorageMinerActor2) PreCommitSector(act *types.Actor, vmctx types.VMContext, params *SectorPreCommitInfo) ([]byte, ActorError) {
+
+	ctx := vmctx.Context()
+	oldstate, self, err := loadState(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if params.SealEpoch >= vmctx.BlockHeight()+build.SealRandomnessLookback {
+		return nil, aerrors.Newf(1, "sector commitment must be based off past randomness (%d >= %d)", params.SealEpoch, vmctx.BlockHeight()+build.SealRandomnessLookback)
+	}
+
+	if vmctx.BlockHeight()-params.SealEpoch+build.SealRandomnessLookback > build.SealRandomnessLookbackLimit {
+		return nil, aerrors.Newf(2, "sector commitment must be recent enough (was %d)", vmctx.BlockHeight()-params.SealEpoch+build.SealRandomnessLookback)
+	}
+
+	mi, err := loadMinerInfo(vmctx, self)
+	if err != nil {
+		return nil, err
+	}
+
+	if vmctx.Message().From != mi.Worker {
+		return nil, aerrors.New(1, "not authorized to precommit sector for miner")
+	}
+
+	// make sure the miner isnt trying to submit a pre-existing sector
+	unique, err := SectorIsUnique(ctx, vmctx.Storage(), self.Sectors, params.SectorNumber)
+	if err != nil {
+		return nil, err
+	}
+	if !unique {
+		return nil, aerrors.New(3, "sector already committed!")
+	}
+
+	// Power of the miner after adding this sector
+	futurePower := types.BigAdd(self.Power, types.NewInt(mi.SectorSize))
+	collateralRequired := CollateralForPower(futurePower)
+
+	// TODO: grab from market?
+	if act.Balance.LessThan(collateralRequired) {
+		return nil, aerrors.New(4, "not enough collateral")
+	}
+
+	self.PreCommittedSectors[uintToStringKey(params.SectorNumber)] = &PreCommittedSector{
+		Info:          *params,
+		ReceivedEpoch: vmctx.BlockHeight(),
+	}
+
+	if len(self.PreCommittedSectors) > 4096 {
+		return nil, aerrors.New(5, "too many precommitted sectors")
+	}
+
+	nstate, err := vmctx.Storage().Put(self)
+	if err != nil {
+		return nil, err
+	}
+	if err := vmctx.Storage().Commit(oldstate, nstate); err != nil {
+		return nil, err
+	}
+
+	return nil, nil
+}
+
+func (sma StorageMinerActor2) ProveCommitSector(act *types.Actor, vmctx types.VMContext, params *SectorProveCommitInfo) ([]byte, ActorError) {
+	ctx := vmctx.Context()
+	oldstate, self, err := loadState(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	mi, err := loadMinerInfo(vmctx, self)
+	if err != nil {
+		return nil, err
+	}
+
+	if vmctx.Message().From != mi.Worker {
+		return nil, aerrors.New(1, "not authorized to submit sector proof for miner")
+	}
+
+	us, ok := self.PreCommittedSectors[uintToStringKey(params.SectorID)]
+	if !ok {
+		return nil, aerrors.New(1, "no pre-commitment found for sector")
+	}
+
+	if us.ReceivedEpoch+build.InteractivePoRepDelay >= vmctx.BlockHeight() {
+		return nil, aerrors.New(2, "too early for proof submission")
+	}
+
+	delete(self.PreCommittedSectors, uintToStringKey(params.SectorID))
+
+	// TODO: ensure normalization to ID address
+	maddr := vmctx.Message().To
+
+	if vmctx.BlockHeight()-us.Info.SealEpoch > build.MaxSealLookback {
+		return nil, aerrors.Newf(5, "source randomness for sector SealEpoch too far in past (epoch %d)", us.Info.SealEpoch)
+	}
+
+	if vmctx.BlockHeight()-us.ReceivedEpoch > build.MaxSealLookback {
+		return nil, aerrors.Newf(6, "source randomness for sector ReceivedEpoch too far in past (epoch %d)", us.ReceivedEpoch)
+	}
+
+	ticket, err := vmctx.GetRandomness(us.Info.SealEpoch - build.SealRandomnessLookback)
+	if err != nil {
+		return nil, aerrors.Wrap(err, "failed to get ticket randomness")
+	}
+
+	seed, err := vmctx.GetRandomness(us.ReceivedEpoch + build.InteractivePoRepDelay)
+	if err != nil {
+		return nil, aerrors.Wrap(err, "failed to get randomness for prove sector commitment")
+	}
+
+	enc, err := SerializeParams(&ComputeDataCommitmentParams{
+		DealIDs:    params.DealIDs,
+		SectorSize: mi.SectorSize,
+	})
+	if err != nil {
+		return nil, aerrors.Wrap(err, "failed to serialize ComputeDataCommitmentParams")
+	}
+
+	commD, err := vmctx.Send(StorageMarketAddress, SMAMethods.ComputeDataCommitment, types.NewInt(0), enc)
+	if err != nil {
+		return nil, aerrors.Wrapf(err, "failed to compute data commitment (sector %d, deals: %v)", params.SectorID, params.DealIDs)
+	}
+
+	if ok, err := vmctx.Sys().ValidatePoRep(ctx, maddr, mi.SectorSize, commD, us.Info.CommR, ticket, params.Proof, seed, params.SectorID); err != nil {
+		return nil, err
+	} else if !ok {
+		return nil, aerrors.Newf(2, "porep proof was invalid (t:%x; s:%x(%d); p:%s)", ticket, seed, us.ReceivedEpoch+build.InteractivePoRepDelay, truncateHexPrint(params.Proof))
+	}
+
+	// Note: There must exist a unique index in the miner's sector set for each
+	// sector ID. The `faults`, `recovered`, and `done` parameters of the
+	// SubmitPoSt method express indices into this sector set.
+	nssroot, err := AddToSectorSet2(ctx, types.WrapStorage(vmctx.Storage()), self.Sectors, params.SectorID, us.Info.CommR, commD)
+	if err != nil {
+		return nil, err
+	}
+	self.Sectors = nssroot
+
+	// if miner is not mining, start their proving period now
+	// Note: As written here, every miners first PoSt will only be over one sector.
+	// We could set up a 'grace period' for starting mining that would allow miners
+	// to submit several sectors for their first proving period. Alternatively, we
+	// could simply make the 'PreCommitSector' call take multiple sectors at a time.
+	//
+	// Note: Proving period is a function of sector size; small sectors take less
+	// time to prove than large sectors do. Sector size is selected when pledging.
+	pss, lerr := amt2.LoadAMT(types.WrapStorage(vmctx.Storage()), self.ProvingSet)
+	if lerr != nil {
+		return nil, aerrors.HandleExternalError(lerr, "could not load proving set node")
+	}
+
+	if pss.Count == 0 && !self.Active {
+		self.ProvingSet = self.Sectors
+		// TODO: probably want to wait until the miner is above a certain
+		//  threshold before starting this
+		self.ElectionPeriodStart = vmctx.BlockHeight()
+	}
+
+	nstate, err := vmctx.Storage().Put(self)
+	if err != nil {
+		return nil, err
+	}
+	if err := vmctx.Storage().Commit(oldstate, nstate); err != nil {
+		return nil, err
+	}
+
+	activateParams, err := SerializeParams(&ActivateStorageDealsParams{
+		Deals: params.DealIDs,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = vmctx.Send(StorageMarketAddress, SMAMethods.ActivateStorageDeals, types.NewInt(0), activateParams)
+	return nil, aerrors.Wrapf(err, "calling ActivateStorageDeals failed")
+}
+
+func (sma StorageMinerActor2) SubmitFallbackPoSt(act *types.Actor, vmctx types.VMContext, params *SubmitFallbackPoStParams) ([]byte, ActorError) {
+	oldstate, self, err := loadState(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	mi, err := loadMinerInfo(vmctx, self)
+	if err != nil {
+		return nil, err
+	}
+
+	if vmctx.Message().From != mi.Worker {
+		return nil, aerrors.New(1, "not authorized to submit post for miner")
+	}
+
+	/*
+		// TODO: handle fees
+		msgVal := vmctx.Message().Value
+		if msgVal.LessThan(feesRequired) {
+			return nil, aerrors.New(2, "not enough funds to pay post submission fees")
+		}
+
+		if msgVal.GreaterThan(feesRequired) {
+			_, err := vmctx.Send(vmctx.Message().From, 0,
+				types.BigSub(msgVal, feesRequired), nil)
+			if err != nil {
+				return nil, aerrors.Wrap(err, "could not refund excess fees")
+			}
+		}
+	*/
+
+	var seed [sectorbuilder.CommLen]byte
+	{
+		randHeight := self.ElectionPeriodStart + build.FallbackPoStDelay
+		if vmctx.BlockHeight() <= randHeight {
+			// TODO: spec, retcode
+			return nil, aerrors.Newf(1, "submit fallback PoSt called too early (%d < %d)", vmctx.BlockHeight(), randHeight)
+		}
+
+		rand, err := vmctx.GetRandomness(randHeight)
+
+		if err != nil {
+			return nil, aerrors.Wrap(err, "could not get randomness for PoST")
+		}
+		if len(rand) < len(seed) {
+			return nil, aerrors.Escalate(fmt.Errorf("randomness too small (%d < %d)",
+				len(rand), len(seed)), "improper randomness")
+		}
+		copy(seed[:], rand)
+	}
+
+	pss, lerr := amt2.LoadAMT(types.WrapStorage(vmctx.Storage()), self.ProvingSet)
+	if lerr != nil {
+		return nil, aerrors.HandleExternalError(lerr, "could not load proving set node")
+	}
+
+	ss, lerr := amt2.LoadAMT(types.WrapStorage(vmctx.Storage()), self.Sectors)
+	if lerr != nil {
+		return nil, aerrors.HandleExternalError(lerr, "could not load proving set node")
+	}
+
+	faults, nerr := self.FaultSet.AllMap(2 * ss.Count)
+	if nerr != nil {
+		return nil, aerrors.Absorb(err, 5, "RLE+ invalid")
+	}
+
+	activeFaults := uint64(0)
+	var sectorInfos []ffi.PublicSectorInfo
+	if err := pss.ForEach(func(id uint64, v *cbg.Deferred) error {
+		if faults[id] {
+			activeFaults++
+			return nil
+		}
+
+		var comms [][]byte
+		if err := cbor.DecodeInto(v.Raw, &comms); err != nil {
+			return xerrors.New("could not decode comms")
+		}
+		si := ffi.PublicSectorInfo{
+			SectorID: id,
+		}
+		commR := comms[0]
+		if len(commR) != len(si.CommR) {
+			return xerrors.Errorf("commR length is wrong: %d", len(commR))
+		}
+		copy(si.CommR[:], commR)
+
+		sectorInfos = append(sectorInfos, si)
+
+		return nil
+	}); err != nil {
+		return nil, aerrors.Absorb(err, 3, "could not decode sectorset")
+	}
+
+	proverID := vmctx.Message().To // TODO: normalize to ID address
+
+	var candidates []sectorbuilder.EPostCandidate
+	for _, t := range params.Candidates {
+		var partial [32]byte
+		copy(partial[:], t.Partial)
+		candidates = append(candidates, sectorbuilder.EPostCandidate{
+			PartialTicket:        partial,
+			SectorID:             t.SectorID,
+			SectorChallengeIndex: t.ChallengeIndex,
+		})
+	}
+
+	if ok, lerr := vmctx.Sys().VerifyFallbackPost(vmctx.Context(), mi.SectorSize,
+		sectorbuilder.NewSortedPublicSectorInfo(sectorInfos), seed[:], params.Proof, candidates, proverID, activeFaults); !ok || lerr != nil {
+		if lerr != nil {
+			// TODO: study PoST errors
+			return nil, aerrors.Absorb(lerr, 4, "PoST error")
+		}
+		if !ok {
+			return nil, aerrors.New(4, "PoST invalid")
+		}
+	}
+
+	// Post submission is successful!
+	if err := onSuccessfulPoSt2(self, vmctx, activeFaults); err != nil {
+		return nil, err
+	}
+
+	c, err := vmctx.Storage().Put(self)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := vmctx.Storage().Commit(oldstate, c); err != nil {
+		return nil, err
+	}
+
+	return nil, nil
+}
+
+func (sma StorageMinerActor2) GetPower(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
+	_, self, err := loadState(vmctx)
+	if err != nil {
+		return nil, err
+	}
+	return self.Power.Bytes(), nil
+}
+
+func SectorIsUnique2(ctx context.Context, s types.Storage, sroot cid.Cid, sid uint64) (bool, ActorError) {
+	found, _, _, err := GetFromSectorSet2(ctx, s, sroot, sid)
+	if err != nil {
+		return false, err
+	}
+
+	return !found, nil
+}
+
+func AddToSectorSet2(ctx context.Context, blks amt2.Blocks, ss cid.Cid, sectorID uint64, commR, commD []byte) (cid.Cid, ActorError) {
+	if sectorID >= build.MinerMaxSectors {
+		return cid.Undef, aerrors.Newf(25, "sector ID out of range: %d", sectorID)
+	}
+	ssr, err := amt2.LoadAMT(blks, ss)
+	if err != nil {
+		return cid.Undef, aerrors.HandleExternalError(err, "could not load sector set node")
+	}
+
+	// TODO: Spec says to use SealCommitment, and construct commD from deals each time,
+	//  but that would make SubmitPoSt way, way more expensive
+	if err := ssr.Set(sectorID, [][]byte{commR, commD}); err != nil {
+		return cid.Undef, aerrors.HandleExternalError(err, "failed to set commitment in sector set")
+	}
+
+	ncid, err := ssr.Flush()
+	if err != nil {
+		return cid.Undef, aerrors.HandleExternalError(err, "failed to flush sector set")
+	}
+
+	return ncid, nil
+}
+
+func GetFromSectorSet2(ctx context.Context, s types.Storage, ss cid.Cid, sectorID uint64) (bool, []byte, []byte, ActorError) {
+	if sectorID >= build.MinerMaxSectors {
+		return false, nil, nil, aerrors.Newf(25, "sector ID out of range: %d", sectorID)
+	}
+
+	ssr, err := amt2.LoadAMT(types.WrapStorage(s), ss)
+	if err != nil {
+		return false, nil, nil, aerrors.HandleExternalError(err, "could not load sector set node")
+	}
+
+	var comms [][]byte
+	err = ssr.Get(sectorID, &comms)
+	if err != nil {
+		if _, ok := err.(*amt2.ErrNotFound); ok {
+			return false, nil, nil, nil
+		}
+		return false, nil, nil, aerrors.HandleExternalError(err, "failed to find sector in sector set")
+	}
+
+	if len(comms) != 2 {
+		return false, nil, nil, aerrors.Newf(20, "sector set entry should only have 2 elements")
+	}
+
+	return true, comms[0], comms[1], nil
+}
+
+func RemoveFromSectorSet2(ctx context.Context, s types.Storage, ss cid.Cid, ids []uint64) (cid.Cid, aerrors.ActorError) {
+
+	ssr, err := amt2.LoadAMT(types.WrapStorage(s), ss)
+	if err != nil {
+		return cid.Undef, aerrors.HandleExternalError(err, "could not load sector set node")
+	}
+
+	for _, id := range ids {
+		if err := ssr.Delete(id); err != nil {
+			log.Warnf("failed to delete sector %d from set: %s", id, err)
+		}
+	}
+
+	ncid, err := ssr.Flush()
+	if err != nil {
+		return cid.Undef, aerrors.HandleExternalError(err, "failed to flush sector set")
+	}
+
+	return ncid, nil
+}
+
+func (sma StorageMinerActor2) GetWorkerAddr(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
+	_, self, err := loadState(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	mi, err := loadMinerInfo(vmctx, self)
+	if err != nil {
+		return nil, err
+	}
+
+	return mi.Worker.Bytes(), nil
+}
+
+func (sma StorageMinerActor2) GetOwner(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
+	_, self, err := loadState(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	mi, err := loadMinerInfo(vmctx, self)
+	if err != nil {
+		return nil, err
+	}
+
+	return mi.Owner.Bytes(), nil
+}
+
+func (sma StorageMinerActor2) GetPeerID(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
+	_, self, err := loadState(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	mi, err := loadMinerInfo(vmctx, self)
+	if err != nil {
+		return nil, err
+	}
+
+	return []byte(mi.PeerID), nil
+}
+
+func (sma StorageMinerActor2) UpdatePeerID(act *types.Actor, vmctx types.VMContext, params *UpdatePeerIDParams) ([]byte, ActorError) {
+	oldstate, self, err := loadState(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	mi, err := loadMinerInfo(vmctx, self)
+	if err != nil {
+		return nil, err
+	}
+
+	if vmctx.Message().From != mi.Worker {
+		return nil, aerrors.New(2, "only the mine worker may update the peer ID")
+	}
+
+	mi.PeerID = params.PeerID
+
+	mic, err := vmctx.Storage().Put(mi)
+	if err != nil {
+		return nil, err
+	}
+
+	self.Info = mic
+
+	c, err := vmctx.Storage().Put(self)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := vmctx.Storage().Commit(oldstate, c); err != nil {
+		return nil, err
+	}
+
+	return nil, nil
+}
+
+func (sma StorageMinerActor2) GetSectorSize(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
+	_, self, err := loadState(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	mi, err := loadMinerInfo(vmctx, self)
+	if err != nil {
+		return nil, err
+	}
+
+	return types.NewInt(mi.SectorSize).Bytes(), nil
+}
+
+func (sma StorageMinerActor2) IsSlashed(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
+	_, self, err := loadState(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return cbg.EncodeBool(self.SlashedAt != 0), nil
+}
+
+// TODO: better name
+func (sma StorageMinerActor2) CheckMiner(act *types.Actor, vmctx types.VMContext, params *CheckMinerParams) ([]byte, ActorError) {
+	if vmctx.Message().From != StoragePowerAddress {
+		return nil, aerrors.New(2, "only the storage power actor can check miner")
+	}
+
+	oldstate, self, err := loadState(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if !isLate(vmctx.BlockHeight(), self) {
+		// Everything's fine
+		return nil, nil
+	}
+
+	if self.SlashedAt != 0 {
+		// Don't slash more than necessary
+		return nil, nil
+	}
+
+	if params.NetworkPower.Equals(self.Power) {
+		// Don't break the network when there's only one miner left
+
+		log.Warnf("can't slash miner %s for missed PoSt, no power would be left in the network", vmctx.Message().To)
+		return nil, nil
+	}
+
+	// Slash for being late
+
+	self.SlashedAt = vmctx.BlockHeight()
+
+	nstate, err := vmctx.Storage().Put(self)
+	if err != nil {
+		return nil, err
+	}
+	if err := vmctx.Storage().Commit(oldstate, nstate); err != nil {
+		return nil, err
+	}
+
+	var out bytes.Buffer
+	if err := self.Power.MarshalCBOR(&out); err != nil {
+		return nil, aerrors.HandleExternalError(err, "marshaling return value")
+	}
+	return out.Bytes(), nil
+}
+
+func (sma StorageMinerActor2) DeclareFaults(act *types.Actor, vmctx types.VMContext, params *DeclareFaultsParams) ([]byte, ActorError) {
+	oldstate, self, aerr := loadState(vmctx)
+	if aerr != nil {
+		return nil, aerr
+	}
+
+	mi, aerr := loadMinerInfo(vmctx, self)
+	if aerr != nil {
+		return nil, aerr
+	}
+
+	if vmctx.Message().From != mi.Worker {
+		return nil, aerrors.New(1, "not authorized to declare faults for miner")
+	}
+
+	nfaults, err := types.MergeBitFields(params.Faults, self.FaultSet)
+	if err != nil {
+		return nil, aerrors.Absorb(err, 1, "failed to merge bitfields")
+	}
+
+	ss, nerr := amt2.LoadAMT(types.WrapStorage(vmctx.Storage()), self.Sectors)
+	if nerr != nil {
+		return nil, aerrors.HandleExternalError(nerr, "failed to load sector set")
+	}
+
+	cf, nerr := nfaults.Count()
+	if nerr != nil {
+		return nil, aerrors.Absorb(nerr, 2, "could not decode RLE+")
+	}
+
+	if cf > 2*ss.Count {
+		return nil, aerrors.Newf(3, "too many declared faults: %d > %d", cf, 2*ss.Count)
+	}
+
+	self.FaultSet = nfaults
+
+	self.LastFaultSubmission = vmctx.BlockHeight()
+
+	nstate, aerr := vmctx.Storage().Put(self)
+	if aerr != nil {
+		return nil, aerr
+	}
+	if err := vmctx.Storage().Commit(oldstate, nstate); err != nil {
+		return nil, err
+	}
+
+	return nil, nil
+}
+
+func (sma StorageMinerActor2) SlashConsensusFault(act *types.Actor, vmctx types.VMContext, params *MinerSlashConsensusFault) ([]byte, ActorError) {
+	if vmctx.Message().From != StoragePowerAddress {
+		return nil, aerrors.New(1, "SlashConsensusFault may only be called by the storage market actor")
+	}
+
+	slashedCollateral := params.SlashedCollateral
+	if slashedCollateral.LessThan(act.Balance) {
+		slashedCollateral = act.Balance
+	}
+
+	// Some of the slashed collateral should be paid to the slasher
+	// GROWTH_RATE determines how fast the slasher share of slashed collateral will increase as block elapses
+	// current GROWTH_RATE results in SLASHER_SHARE reaches 1 after 30 blocks
+	// TODO: define arithmetic precision and rounding for this operation
+	blockElapsed := vmctx.BlockHeight() - params.AtHeight
+
+	slasherShare := slasherShare(params.SlashedCollateral, blockElapsed)
+
+	burnPortion := types.BigSub(slashedCollateral, slasherShare)
+
+	_, err := vmctx.Send(vmctx.Message().From, 0, slasherShare, nil)
+	if err != nil {
+		return nil, aerrors.Wrap(err, "failed to pay slasher")
+	}
+
+	_, err = vmctx.Send(BurntFundsAddress, 0, burnPortion, nil)
+	if err != nil {
+		return nil, aerrors.Wrap(err, "failed to burn funds")
+	}
+
+	// TODO: this still allows the miner to commit sectors and submit posts,
+	// their users could potentially be unaffected, but the miner will never be
+	// able to mine a block again
+	// One potential issue: the miner will have to pay back the slashed
+	// collateral to continue submitting PoSts, which includes pledge
+	// collateral that they no longer really 'need'
+
+	return nil, nil
+}
+
+func (sma StorageMinerActor2) SubmitElectionPoSt(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, aerrors.ActorError) {
+	if vmctx.Message().From != NetworkAddress {
+		return nil, aerrors.Newf(1, "submit election post can only be called by the storage power actor")
+	}
+
+	oldstate, self, aerr := loadState(vmctx)
+	if aerr != nil {
+		return nil, aerr
+	}
+
+	if self.SlashedAt != 0 {
+		return nil, aerrors.New(1, "slashed miners can't perform election PoSt")
+	}
+
+	pss, nerr := amt2.LoadAMT(types.WrapStorage(vmctx.Storage()), self.ProvingSet)
+	if nerr != nil {
+		return nil, aerrors.HandleExternalError(nerr, "failed to load proving set")
+	}
+
+	ss, nerr := amt2.LoadAMT(types.WrapStorage(vmctx.Storage()), self.Sectors)
+	if nerr != nil {
+		return nil, aerrors.HandleExternalError(nerr, "failed to load proving set")
+	}
+
+	faults, nerr := self.FaultSet.AllMap(2 * ss.Count)
+	if nerr != nil {
+		return nil, aerrors.Absorb(nerr, 1, "invalid bitfield (fatal?)")
+	}
+
+	activeFaults := uint64(0)
+	for f := range faults {
+		if f > amt2.MaxIndex {
+			continue
+		}
+
+		var comms [][]byte
+		err := pss.Get(f, &comms)
+		if err != nil {
+			var notfound *amt2.ErrNotFound
+			if !xerrors.As(err, &notfound) {
+				return nil, aerrors.HandleExternalError(err, "failed to find sector in sector set")
+			}
+			continue
+		}
+
+		activeFaults++
+	}
+
+	if err := onSuccessfulPoSt2(self, vmctx, activeFaults); err != nil { // TODO
+		return nil, err
+	}
+
+	ncid, err := vmctx.Storage().Put(self)
+	if err != nil {
+		return nil, err
+	}
+	if err := vmctx.Storage().Commit(oldstate, ncid); err != nil {
+		return nil, err
+	}
+
+	return nil, nil
+}
+
+func onSuccessfulPoSt2(self *StorageMinerActorState, vmctx types.VMContext, activeFaults uint64) aerrors.ActorError {
+	// FORK
+	if vmctx.BlockHeight() < build.ForkBootyBayHeight {
+		return onSuccessfulPoSt(self, vmctx, activeFaults)
+	}
+
+	var mi MinerInfo
+	if err := vmctx.Storage().Get(self.Info, &mi); err != nil {
+		return err
+	}
+
+	pss, nerr := amt2.LoadAMT(types.WrapStorage(vmctx.Storage()), self.ProvingSet)
+	if nerr != nil {
+		return aerrors.HandleExternalError(nerr, "failed to load proving set")
+	}
+
+	ss, nerr := amt2.LoadAMT(types.WrapStorage(vmctx.Storage()), self.Sectors)
+	if nerr != nil {
+		return aerrors.HandleExternalError(nerr, "failed to load sector set")
+	}
+
+	faults, nerr := self.FaultSet.All(2 * ss.Count)
+	if nerr != nil {
+		return aerrors.Absorb(nerr, 1, "invalid bitfield (fatal?)")
+	}
+
+	self.FaultSet = types.NewBitField()
+
+	oldPower := self.Power
+	newPower := types.BigMul(types.NewInt(pss.Count-activeFaults), types.NewInt(mi.SectorSize))
+
+	// If below the minimum size requirement, miners have zero power
+	if newPower.LessThan(types.NewInt(build.MinimumMinerPower)) {
+		newPower = types.NewInt(0)
+	}
+
+	self.Power = newPower
+
+	delta := types.BigSub(self.Power, oldPower)
+	if self.SlashedAt != 0 {
+		self.SlashedAt = 0
+		delta = self.Power
+	}
+
+	prevSlashingDeadline := self.ElectionPeriodStart + build.SlashablePowerDelay
+	if !self.Active && newPower.GreaterThan(types.NewInt(0)) {
+		self.Active = true
+		prevSlashingDeadline = 0
+	}
+
+	if !(oldPower.IsZero() && newPower.IsZero()) {
+		enc, err := SerializeParams(&UpdateStorageParams{
+			Delta:                 delta,
+			NextSlashDeadline:     vmctx.BlockHeight() + build.SlashablePowerDelay,
+			PreviousSlashDeadline: prevSlashingDeadline,
+		})
+		if err != nil {
+			return err
+		}
+
+		_, err = vmctx.Send(StoragePowerAddress, SPAMethods.UpdateStorage, types.NewInt(0), enc)
+		if err != nil {
+			return aerrors.Wrap(err, "updating storage failed")
+		}
+
+		self.ElectionPeriodStart = vmctx.BlockHeight()
+	}
+
+	var ncid cid.Cid
+	var err aerrors.ActorError
+
+	ncid, err = RemoveFromSectorSet2(vmctx.Context(), vmctx.Storage(), self.Sectors, faults)
+	if err != nil {
+		return err
+	}
+
+	self.Sectors = ncid
+	self.ProvingSet = ncid
+	return nil
+}

chain/actors/actor_storagepower.go

@@ -85,7 +85,13 @@ func (spa StoragePowerActor) CreateStorageMiner(act *types.Actor, vmctx types.VM
 		return nil, aerrors.Newf(1, "not enough funds passed to cover required miner collateral (needed %s, got %s)", reqColl, vmctx.Message().Value)
 	}
 
-	encoded, err := CreateExecParams(StorageMinerCodeCid, &StorageMinerConstructorParams{
+	// FORK
+	minerCid := StorageMinerCodeCid
+	if vmctx.BlockHeight() > build.ForkFrigidHeight {
+		minerCid = StorageMiner2CodeCid
+	}
+
+	encoded, err := CreateExecParams(minerCid, &StorageMinerConstructorParams{
 		Owner:      params.Owner,
 		Worker:     params.Worker,
 		SectorSize: params.SectorSize,
@@ -138,6 +144,21 @@ func (spa StoragePowerActor) ArbitrateConsensusFault(act *types.Actor, vmctx typ
 		return nil, aerrors.New(2, "blocks must be from the same miner")
 	}
 
+	// FORK
+	if vmctx.BlockHeight() > build.ForkBlizzardHeight {
+		if params.Block1.Height <= build.ForkBlizzardHeight {
+			return nil, aerrors.New(10, "cannot slash miners with blocks from before blizzard")
+		}
+
+		if params.Block2.Height <= build.ForkBlizzardHeight {
+			return nil, aerrors.New(11, "cannot slash miners with blocks from before blizzard")
+		}
+
+		if params.Block1.Cid() == params.Block2.Cid() {
+			return nil, aerrors.New(3, "blocks must be different")
+		}
+	}
+
 	rval, err := vmctx.Send(params.Block1.Miner, MAMethods.GetWorkerAddr, types.NewInt(0), nil)
 	if err != nil {
 		return nil, aerrors.Wrap(err, "failed to get miner worker")

chain/actors/actor_storagepower_test.go

@@ -93,7 +93,15 @@ func TestStorageMarketCreateAndSlashMiner(t *testing.T) {
 		signBlock(t, h.w, workerAddr, b1)
 		signBlock(t, h.w, workerAddr, b2)
 
+		h.BlockHeight = build.ForkBlizzardHeight + 1
 		ret, _ := h.Invoke(t, ownerAddr, StoragePowerAddress, SPAMethods.ArbitrateConsensusFault,
+			&ArbitrateConsensusFaultParams{
+				Block1: b1,
+				Block2: b1,
+			})
+		assert.Equal(t, uint8(3), ret.ExitCode, "should have failed with exit 3")
+
+		ret, _ = h.Invoke(t, ownerAddr, StoragePowerAddress, SPAMethods.ArbitrateConsensusFault,
 			&ArbitrateConsensusFaultParams{
 				Block1: b1,
 				Block2: b2,
@@ -145,7 +153,7 @@ func cheatStorageMarketTotal(t *testing.T, vm *vm.VM, bs bstore.Blockstore) {
 
 func fakeBlock(t *testing.T, minerAddr address.Address, ts uint64) *types.BlockHeader {
 	c := fakeCid(t, 1)
-	return &types.BlockHeader{Height: 5, Miner: minerAddr, Timestamp: ts, ParentStateRoot: c, Messages: c, ParentMessageReceipts: c, BLSAggregate: types.Signature{Type: types.KTBLS}}
+	return &types.BlockHeader{Height: 8000, Miner: minerAddr, Timestamp: ts, ParentStateRoot: c, Messages: c, ParentMessageReceipts: c, BLSAggregate: types.Signature{Type: types.KTBLS}}
 }
 
 func fakeCid(t *testing.T, s int) cid.Cid {

chain/actors/actors.go

@@ -12,6 +12,7 @@ var CronCodeCid cid.Cid
 var StoragePowerCodeCid cid.Cid
 var StorageMarketCodeCid cid.Cid
 var StorageMinerCodeCid cid.Cid
+var StorageMiner2CodeCid cid.Cid
 var MultisigCodeCid cid.Cid
 var InitCodeCid cid.Cid
 var PaymentChannelCodeCid cid.Cid
@@ -46,6 +47,7 @@ func init() {
 	StoragePowerCodeCid = mustSum("fil/1/power")
 	StorageMarketCodeCid = mustSum("fil/1/market")
 	StorageMinerCodeCid = mustSum("fil/1/miner")
+	StorageMiner2CodeCid = mustSum("fil/1/miner/2")
 	MultisigCodeCid = mustSum("fil/1/multisig")
 	InitCodeCid = mustSum("fil/1/init")
 	PaymentChannelCodeCid = mustSum("fil/1/paych")

chain/blocksync/blocksync_client.go

@@ -455,7 +455,7 @@ func (bpt *bsPeerTracker) prefSortedPeers() []peer.ID {
 		getPeerInitLat := func(p peer.ID) float64 {
 			var res float64
 			if bpt.pmgr != nil {
-				if lat, ok := bpt.pmgr.GetPeerLatency(out[i]); ok {
+				if lat, ok := bpt.pmgr.GetPeerLatency(p); ok {
 					res = float64(lat)
 				}
 			}
@@ -476,7 +476,7 @@ func (bpt *bsPeerTracker) prefSortedPeers() []peer.ID {
 			failRateJ := float64(pj.failures) / float64(pj.failures+pj.successes)
 			costJ = float64(pj.averageTime) + failRateJ*float64(bpt.avgGlobalTime)
 		} else {
-			costI = getPeerInitLat(out[i])
+			costJ = getPeerInitLat(out[j])
 		}
 
 		return costI < costJ

chain/blocksync/cbor_gen.go

@@ -5,7 +5,7 @@ import (
 	"io"
 
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/ipfs/go-cid"
+	cid "github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
 )

chain/messagepool/messagepool.go

@@ -94,7 +94,7 @@ func (ms *msgSet) add(m *types.SignedMessage) error {
 	if _, has := ms.msgs[m.Message.Nonce]; has {
 		if m.Cid() != ms.msgs[m.Message.Nonce].Cid() {
 			log.Error("Add with duplicate nonce")
-			return xerrors.Errorf("message to %s with nonce %d already in mpool")
+			return xerrors.Errorf("message to %s with nonce %d already in mpool", m.Message.To, m.Message.Nonce)
 		}
 	}
 	ms.msgs[m.Message.Nonce] = m

chain/stmgr/forks.go

@@ -3,14 +3,149 @@ package stmgr
 import (
 	"context"
 
+	amt "github.com/filecoin-project/go-amt-ipld/v2"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/ipfs/go-cid"
+	hamt "github.com/ipfs/go-hamt-ipld"
+	blockstore "github.com/ipfs/go-ipfs-blockstore"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
 )
 
 func (sm *StateManager) handleStateForks(ctx context.Context, pstate cid.Cid, height, parentH uint64) (_ cid.Cid, err error) {
 	for i := parentH; i < height; i++ {
 		switch i {
+		case build.ForkBlizzardHeight:
+			log.Warnw("Executing blizzard fork logic", "height", i)
+			pstate, err = fixBlizzardAMTBug(ctx, sm, pstate)
+			if err != nil {
+				return cid.Undef, xerrors.Errorf("blizzard bug fix failed: %w", err)
+			}
+		case build.ForkFrigidHeight:
+			log.Warnw("Executing frigid fork logic", "height", i)
+			pstate, err = fixBlizzardAMTBug(ctx, sm, pstate)
+			if err != nil {
+				return cid.Undef, xerrors.Errorf("frigid bug fix failed: %w", err)
+			}
+		case build.ForkBootyBayHeight:
+			log.Warnw("Executing booty bay fork logic", "height", i)
+			pstate, err = fixBlizzardAMTBug(ctx, sm, pstate)
+			if err != nil {
+				return cid.Undef, xerrors.Errorf("booty bay bug fix failed: %w", err)
+			}
 		}
 	}
 
 	return pstate, nil
 }
+
+/*
+1) Iterate through each miner in the chain:
+	1.1) Fixup their sector set and proving set
+	1.2) Change their code cid to point to the new miner actor code
+*/
+func fixBlizzardAMTBug(ctx context.Context, sm *StateManager, pstate cid.Cid) (cid.Cid, error) {
+	cst := hamt.CSTFromBstore(sm.cs.Blockstore())
+	st, err := state.LoadStateTree(cst, pstate)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	spa, err := st.GetActor(actors.StoragePowerAddress)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to get storage power actor: %w", err)
+	}
+
+	var spast actors.StoragePowerState
+	if err := cst.Get(ctx, spa.Head, &spast); err != nil {
+		return cid.Undef, err
+	}
+
+	miners, err := actors.MinerSetList(ctx, cst, spast.Miners)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	for _, m := range miners {
+		mact, err := st.GetActor(m)
+		if err != nil {
+			return cid.Undef, xerrors.Errorf("getting miner actor to fix: %w", err)
+		}
+
+		nhead, err := fixMiner(ctx, cst, sm.cs.Blockstore(), mact.Head)
+		if err != nil {
+			return cid.Undef, xerrors.Errorf("fixing miner: %w", err)
+		}
+
+		if nhead != mact.Head {
+			log.Warnf("Miner %s had changes", m)
+		}
+
+		mact.Head = nhead
+		mact.Code = actors.StorageMiner2CodeCid
+
+		if err := st.SetActor(m, mact); err != nil {
+			return cid.Undef, err
+		}
+	}
+
+	return st.Flush()
+}
+
+func fixMiner(ctx context.Context, cst *hamt.CborIpldStore, bs blockstore.Blockstore, mscid cid.Cid) (cid.Cid, error) {
+	var mstate actors.StorageMinerActorState
+	if err := cst.Get(ctx, mscid, &mstate); err != nil {
+		return cid.Undef, xerrors.Errorf("failed to load miner actor state: %w", err)
+	}
+
+	amts := amt.WrapBlockstore(bs)
+
+	nsectors, err := amtFsck(amts, mstate.Sectors)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("error fsck'ing sector set: %w", err)
+	}
+	mstate.Sectors = nsectors
+
+	nproving, err := amtFsck(amts, mstate.ProvingSet)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("error fsck'ing proving set: %w", err)
+	}
+	mstate.ProvingSet = nproving
+
+	nmcid, err := cst.Put(ctx, &mstate)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to put modified miner state: %w", err)
+	}
+
+	return nmcid, nil
+}
+
+func amtFsck(s amt.Blocks, ss cid.Cid) (cid.Cid, error) {
+	a, err := amt.LoadAMT(s, ss)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("could not load AMT: %w", a)
+	}
+
+	b := amt.NewAMT(s)
+
+	err = a.ForEach(func(id uint64, data *cbg.Deferred) error {
+		err := b.Set(id, data)
+		if err != nil {
+			return xerrors.Errorf("could not copy at idx (%d): %w", id, err)
+		}
+		return nil
+	})
+
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("could not copy: %w", err)
+	}
+
+	nss, err := b.Flush()
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("could not flush: %w", err)
+	}
+
+	return nss, nil
+}

chain/stmgr/utils.go

@@ -10,7 +10,9 @@ import (
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
 
 	amt "github.com/filecoin-project/go-amt-ipld"
 	cid "github.com/ipfs/go-cid"
@@ -311,3 +313,37 @@ func LoadSectorsFromSet(ctx context.Context, bs blockstore.Blockstore, ssc cid.C
 
 	return sset, nil
 }
+
+func ComputeState(ctx context.Context, sm *StateManager, height uint64, msgs []*types.Message, ts *types.TipSet) (cid.Cid, error) {
+	if ts == nil {
+		ts = sm.cs.GetHeaviestTipSet()
+	}
+
+	base, _, err := sm.TipSetState(ctx, ts)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	fstate, err := sm.handleStateForks(ctx, base, height, ts.Height())
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	r := store.NewChainRand(sm.cs, ts.Cids(), height)
+	vmi, err := vm.NewVM(fstate, height, r, actors.NetworkAddress, sm.cs.Blockstore(), sm.cs.VMSys())
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	for i, msg := range msgs {
+		ret, err := vmi.ApplyMessage(ctx, msg)
+		if err != nil {
+			return cid.Undef, xerrors.Errorf("applying message %s: %w", msg.Cid(), err)
+		}
+		if ret.ExitCode != 0 {
+			log.Infof("compute state apply message %d failed (exit: %d): %s", i, ret.ExitCode, ret.ActorErr)
+		}
+	}
+
+	return vmi.Flush(ctx)
+}

chain/store/store.go

@@ -730,6 +730,30 @@ func (cs *ChainStore) readMsgMetaCids(mmc cid.Cid) ([]cid.Cid, []cid.Cid, error)
 	return blscids, secpkcids, nil
 }
 
+func (cs *ChainStore) GetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*HeadChange, error) {
+	fts, err := cs.LoadTipSet(from)
+	if err != nil {
+		return nil, xerrors.Errorf("loading from tipset %s: %w", from, err)
+	}
+	tts, err := cs.LoadTipSet(to)
+	if err != nil {
+		return nil, xerrors.Errorf("loading to tipset %s: %w", to, err)
+	}
+	revert, apply, err := cs.ReorgOps(fts, tts)
+	if err != nil {
+		return nil, xerrors.Errorf("error getting tipset branches: %w", err)
+	}
+
+	path := make([]*HeadChange, len(revert)+len(apply))
+	for i, r := range revert {
+		path[i] = &HeadChange{Type: HCRevert, Val: r}
+	}
+	for j, i := 0, len(apply)-1; i >= 0; j, i = j+1, i-1 {
+		path[j+len(revert)] = &HeadChange{Type: HCApply, Val: apply[i]}
+	}
+	return path, nil
+}
+
 func (cs *ChainStore) MessagesForBlock(b *types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error) {
 	blscids, secpkcids, err := cs.readMsgMetaCids(b.Messages)
 	if err != nil {

chain/types/blockheader.go

@@ -120,6 +120,10 @@ func (blk *BlockHeader) CheckBlockSignature(ctx context.Context, worker address.
 	_, span := trace.StartSpan(ctx, "checkBlockSignature")
 	defer span.End()
 
+	if blk.BlockSig == nil {
+		return xerrors.New("block signature not present")
+	}
+
 	sigb, err := blk.SigningBytes()
 	if err != nil {
 		return xerrors.Errorf("failed to get block signing bytes: %w", err)

chain/types/cbor_gen.go

@@ -5,7 +5,7 @@ import (
 	"io"
 	"math"
 
-	"github.com/ipfs/go-cid"
+	cid "github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
 )

chain/types/signature.go

@@ -116,5 +116,8 @@ func (s *Signature) UnmarshalCBOR(br io.Reader) error {
 }
 
 func (s *Signature) Equals(o *Signature) bool {
+	if s == nil || o == nil {
+		return s == o
+	}
 	return s.Type == o.Type && bytes.Equal(s.Data, o.Data)
 }

chain/types/signature_cgo.go

@@ -9,9 +9,14 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-crypto"
 	"github.com/minio/blake2b-simd"
+	"golang.org/x/xerrors"
 )
 
 func (s *Signature) Verify(addr address.Address, msg []byte) error {
+	if s == nil {
+		return xerrors.Errorf("signature is nil")
+	}
+
 	if addr.Protocol() == address.ID {
 		return fmt.Errorf("must resolve ID addresses before using them to verify a signature")
 	}

chain/vm/invoker.go

@@ -35,6 +35,7 @@ func newInvoker() *invoker {
 	inv.register(actors.StoragePowerCodeCid, actors.StoragePowerActor{}, actors.StoragePowerState{})
 	inv.register(actors.StorageMarketCodeCid, actors.StorageMarketActor{}, actors.StorageMarketState{})
 	inv.register(actors.StorageMinerCodeCid, actors.StorageMinerActor{}, actors.StorageMinerActorState{})
+	inv.register(actors.StorageMiner2CodeCid, actors.StorageMinerActor2{}, actors.StorageMinerActorState{})
 	inv.register(actors.MultisigCodeCid, actors.MultiSigActor{}, actors.MultiSigActorState{})
 	inv.register(actors.PaymentChannelCodeCid, actors.PaymentChannelActor{}, actors.PaymentChannelActorState{})
 

chain/vm/vm.go

@@ -467,7 +467,7 @@ func (vm *VM) ApplyMessage(ctx context.Context, msg *types.Message) (*ApplyRet,
 		return nil, xerrors.Errorf("[from=%s,to=%s,n=%d,m=%d,h=%d] fatal error: %w", msg.From, msg.To, msg.Nonce, msg.Method, vm.blockHeight, actorErr)
 	}
 	if actorErr != nil {
-		log.Warnf("[from=%s,to=%s,n=%d,m=%d,h=%d] Send actor error: %+v", msg.From, msg.To, msg.Nonce, msg.Method, vm.blockHeight, actorErr)
+		log.Warnw("Send actor error", "from", msg.From, "to", msg.To, "nonce", msg.Nonce, "method", msg.Method, "height", vm.blockHeight, "error", fmt.Sprintf("%+v", actorErr))
 	}
 
 	var errcode uint8

cli/state.go

@@ -9,6 +9,7 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/miner"
 	"golang.org/x/xerrors"
 
 	"github.com/ipfs/go-cid"
@@ -37,6 +38,7 @@ var stateCmd = &cli.Command{
 		stateSectorSizeCmd,
 		stateReadStateCmd,
 		stateListMessagesCmd,
+		stateComputeStateCmd,
 	},
 }
 
@@ -580,3 +582,69 @@ var stateListMessagesCmd = &cli.Command{
 		return nil
 	},
 }
+
+var stateComputeStateCmd = &cli.Command{
+	Name:  "compute-state",
+	Usage: "Perform state computations",
+	Flags: []cli.Flag{
+		&cli.Uint64Flag{
+			Name:  "height",
+			Usage: "set the height to compute state at",
+		},
+		&cli.BoolFlag{
+			Name:  "apply-mpool-messages",
+			Usage: "apply messages from the mempool to the computed state",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		ts, err := loadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		h := cctx.Uint64("height")
+		if h == 0 {
+			if ts == nil {
+				head, err := api.ChainHead(ctx)
+				if err != nil {
+					return err
+				}
+				ts = head
+			}
+			h = ts.Height()
+		}
+
+		var msgs []*types.Message
+		if cctx.Bool("apply-mpool-messages") {
+			pmsgs, err := api.MpoolPending(ctx, ts)
+			if err != nil {
+				return err
+			}
+
+			pmsgs, err = miner.SelectMessages(ctx, api.StateGetActor, ts, pmsgs)
+			if err != nil {
+				return err
+			}
+
+			for _, sm := range pmsgs {
+				msgs = append(msgs, &sm.Message)
+			}
+		}
+
+		nstate, err := api.StateCompute(ctx, h, msgs, ts)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("computed state cid: ", nstate)
+		return nil
+	},
+}

cmd/lotus-bench/main.go

@@ -303,8 +303,8 @@ func main() {
 
 			epost2 := time.Now()
 
-			if !bytes.Equal(proof1, proof2) {
-				log.Warn("separate epost calls returned different proof values (this might be bad)")
+			if bytes.Equal(proof1, proof2) {
+				log.Warn("separate epost calls returned the same proof values (this might be bad)")
 			}
 
 			ok, err := sectorbuilder.ProofVerifier.VerifyElectionPost(context.TODO(), sectorSize, sinfos, challenge[:], proof1, candidates[:1], maddr)
@@ -351,7 +351,9 @@ func main() {
 					fmt.Printf("seal: preCommit: %s (%s)\n", bo.SealingResults[0].PreCommit, bps(bo.SectorSize, bo.SealingResults[0].PreCommit))
 					fmt.Printf("seal: commit: %s (%s)\n", bo.SealingResults[0].Commit, bps(bo.SectorSize, bo.SealingResults[0].Commit))
 					fmt.Printf("seal: verify: %s\n", bo.SealingResults[0].Verify)
-					fmt.Printf("unseal: %s  (%s)\n", bo.SealingResults[0].Unseal, bps(bo.SectorSize, bo.SealingResults[0].Unseal))
+					if !c.Bool("skip-unseal") {
+						fmt.Printf("unseal: %s  (%s)\n", bo.SealingResults[0].Unseal, bps(bo.SectorSize, bo.SealingResults[0].Unseal))
+					}
 				}
 				fmt.Printf("generate candidates: %s (%s)\n", bo.PostGenerateCandidates, bps(bo.SectorSize*uint64(len(bo.SealingResults)), bo.PostGenerateCandidates))
 				fmt.Printf("compute epost proof (cold): %s\n", bo.PostEProofCold)

cmd/lotus-chainwatch/sync.go

@@ -221,7 +221,7 @@ func syncHead(ctx context.Context, api api.FullNode, st *storage, ts *types.TipS
 
 		for addr, m := range actors {
 			for actor, c := range m {
-				if actor.Code != actors2.StorageMinerCodeCid {
+				if !(actor.Code == actors2.StorageMinerCodeCid || actor.Code == actors2.StorageMiner2CodeCid) {
 					continue
 				}
 

cmd/lotus-fountain/main.go

@@ -275,7 +275,7 @@ func (h *handler) mkminer(w http.ResponseWriter, r *http.Request) {
 	createStorageMinerMsg := &types.Message{
 		To:    actors.StoragePowerAddress,
 		From:  h.from,
-		Value: collateral,
+		Value: types.BigAdd(collateral, types.BigDiv(collateral, types.NewInt(100))),
 
 		Method: actors.SPAMethods.CreateStorageMiner,
 		Params: params,

cmd/lotus-health/main.go

@@ -0,0 +1,211 @@
+package main
+
+import (
+	"context"
+	"os"
+	"time"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	lcli "github.com/filecoin-project/lotus/cli"
+	cid "github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log"
+	"gopkg.in/urfave/cli.v2"
+)
+
+type CidWindow [][]cid.Cid
+
+var log = logging.Logger("lotus-health")
+
+func main() {
+	logging.SetLogLevel("*", "INFO")
+
+	log.Info("Starting health agent")
+
+	local := []*cli.Command{
+		watchHeadCmd,
+	}
+
+	app := &cli.App{
+		Name:     "lotus-health",
+		Usage:    "Tools for monitoring lotus daemon health",
+		Version:  build.UserVersion,
+		Commands: local,
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "repo",
+				EnvVars: []string{"LOTUS_PATH"},
+				Value:   "~/.lotus", // TODO: Consider XDG_DATA_HOME
+			},
+		},
+	}
+
+	if err := app.Run(os.Args); err != nil {
+		log.Warn(err)
+		return
+	}
+}
+
+var watchHeadCmd = &cli.Command{
+	Name: "watch-head",
+	Flags: []cli.Flag{
+		&cli.IntFlag{
+			Name:  "threshold",
+			Value: 3,
+			Usage: "number of times head remains unchanged before failing health check",
+		},
+		&cli.IntFlag{
+			Name:  "interval",
+			Value: build.BlockDelay,
+			Usage: "interval in seconds between chain head checks",
+		},
+		&cli.StringFlag{
+			Name:  "systemd-unit",
+			Value: "lotus-daemon.service",
+			Usage: "systemd unit name to restart on health check failure",
+		},
+	},
+	Action: func(c *cli.Context) error {
+		threshold := c.Int("threshold")
+		interval := time.Duration(c.Int("interval")) * time.Second
+		name := c.String("systemd-unit")
+
+		var headCheckWindow CidWindow
+
+		api, closer, err := lcli.GetFullNodeAPI(c)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(c)
+
+		if err := WaitForSyncComplete(ctx, api); err != nil {
+			log.Fatal(err)
+		}
+
+		ch := make(chan CidWindow, 1)
+		aCh := make(chan interface{}, 1)
+
+		go func() {
+			for {
+				headCheckWindow, err = updateWindow(ctx, api, headCheckWindow, threshold, ch)
+				if err != nil {
+					log.Fatal(err)
+				}
+				time.Sleep(interval)
+			}
+		}()
+
+		go func() {
+			result, err := alertHandler(name, aCh)
+			if err != nil {
+				log.Fatal(err)
+			}
+			if result != "done" {
+				log.Fatal("systemd unit failed to restart:", result)
+			}
+			log.Info("restarting health agent")
+			// Exit health agent and let supervisor restart health agent
+			// Restarting lotus systemd unit kills api connection
+			os.Exit(130)
+		}()
+
+		for {
+			ok := checkWindow(ch, int(interval))
+			if !ok {
+				log.Warn("chain head has not updated. Restarting systemd service")
+				aCh <- nil
+				break
+			}
+			log.Info("chain head is healthy")
+		}
+		return nil
+	},
+}
+
+/*
+ * reads channel of slices of Cids
+ * compares slices of Cids when len is greater or equal to `t` - threshold
+ * if all slices are equal, head has not updated and returns false
+ */
+func checkWindow(ch chan CidWindow, t int) bool {
+	select {
+	case window := <-ch:
+		var dup int
+		windowLen := len(window)
+		if windowLen >= t {
+		cidWindow:
+			for i, cids := range window {
+				next := windowLen - 1 - i
+				// if array length is different, head is changing
+				if next >= 1 && len(window[next]) != len(window[next-1]) {
+					break cidWindow
+				}
+				// if cids are different, head is changing
+				for j := range cids {
+					if next >= 1 && window[next][j] != window[next-1][j] {
+						break cidWindow
+					}
+				}
+				if i < (t - 1) {
+					dup++
+				}
+			}
+
+			if dup == (t - 1) {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+/*
+ * reads channel of slices of slices of Cids
+ * compares Cids when len of window is greater or equal to `t` - threshold
+ * if all slices are the equal, head has not updated and returns false
+ */
+func updateWindow(ctx context.Context, a api.FullNode, w CidWindow, t int, ch chan CidWindow) (CidWindow, error) {
+	head, err := a.ChainHead(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	window := appendCIDsToWindow(w, head.Cids(), t)
+	ch <- window
+	return window, nil
+}
+
+/*
+ * appends slice of Cids to window slice
+ * keeps a fixed window slice size, dropping older slices
+ * returns new window
+ */
+func appendCIDsToWindow(w CidWindow, c []cid.Cid, t int) CidWindow {
+	offset := len(w) - t + 1
+	if offset >= 0 {
+		return append(w[offset:], c)
+	}
+	return append(w, c)
+}
+
+/*
+ * wait for node to sync
+ */
+func WaitForSyncComplete(ctx context.Context, napi api.FullNode) error {
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-time.After(3 * time.Second):
+			head, err := napi.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+
+			if time.Now().Unix()-int64(head.MinTimestamp()) < build.BlockDelay {
+				return nil
+			}
+		}
+	}
+}

cmd/lotus-health/main_test.go

@@ -0,0 +1,84 @@
+package main
+
+import (
+	"testing"
+
+	cid "github.com/ipfs/go-cid"
+	mh "github.com/multiformats/go-multihash"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAppendCIDsToWindow(t *testing.T) {
+	assert := assert.New(t)
+	var window CidWindow
+	threshold := 3
+	cid0 := makeCID("0")
+	cid1 := makeCID("1")
+	cid2 := makeCID("2")
+	cid3 := makeCID("3")
+	window = appendCIDsToWindow(window, []cid.Cid{cid0}, threshold)
+	window = appendCIDsToWindow(window, []cid.Cid{cid1}, threshold)
+	window = appendCIDsToWindow(window, []cid.Cid{cid2}, threshold)
+	window = appendCIDsToWindow(window, []cid.Cid{cid3}, threshold)
+	assert.Len(window, 3)
+	assert.Equal(window[0][0], cid1)
+	assert.Equal(window[1][0], cid2)
+	assert.Equal(window[2][0], cid3)
+}
+
+func TestCheckWindow(t *testing.T) {
+	assert := assert.New(t)
+	ch := make(chan CidWindow, 1)
+	och := make(chan bool, 1)
+	threshold := 3
+	go func() {
+		och <- checkWindow(ch, threshold)
+	}()
+	var healthyHeadCheckWindow CidWindow
+	healthyHeadCheckWindow = appendCIDsToWindow(healthyHeadCheckWindow, []cid.Cid{
+		makeCID("abcd"),
+	}, threshold)
+	healthyHeadCheckWindow = appendCIDsToWindow(healthyHeadCheckWindow, []cid.Cid{
+		makeCID("bbcd"),
+		makeCID("bbfe"),
+	}, threshold)
+	healthyHeadCheckWindow = appendCIDsToWindow(healthyHeadCheckWindow, []cid.Cid{
+		makeCID("bbcd"),
+		makeCID("bbfe"),
+	}, threshold)
+	ch <- healthyHeadCheckWindow
+	select {
+	case ok := <-och:
+		assert.True(ok)
+	}
+	go func() {
+		och <- checkWindow(ch, threshold)
+	}()
+	var unhealthyHeadCheckWindow CidWindow
+	unhealthyHeadCheckWindow = appendCIDsToWindow(unhealthyHeadCheckWindow, []cid.Cid{
+		makeCID("abcd"),
+		makeCID("fbcd"),
+	}, threshold)
+	unhealthyHeadCheckWindow = appendCIDsToWindow(unhealthyHeadCheckWindow, []cid.Cid{
+		makeCID("abcd"),
+		makeCID("fbcd"),
+	}, threshold)
+	unhealthyHeadCheckWindow = appendCIDsToWindow(unhealthyHeadCheckWindow, []cid.Cid{
+		makeCID("abcd"),
+		makeCID("fbcd"),
+	}, threshold)
+	ch <- unhealthyHeadCheckWindow
+	select {
+	case ok := <-och:
+		assert.False(ok)
+	}
+
+}
+
+func makeCID(s string) cid.Cid {
+	h1, err := mh.Sum([]byte(s), mh.SHA2_256, -1)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return cid.NewCidV1(0x55, h1)
+}

cmd/lotus-health/systemd.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"github.com/coreos/go-systemd/dbus"
+)
+
+func alertHandler(n string, ch chan interface{}) (string, error) {
+	select {
+	case <-ch:
+		statusCh := make(chan string, 1)
+		c, err := dbus.New()
+		if err != nil {
+			return "", err
+		}
+		_, err = c.TryRestartUnit(n, "fail", statusCh)
+		if err != nil {
+			return "", err
+		}
+		select {
+		case result := <-statusCh:
+			return result, nil
+		}
+	}
+}

cmd/lotus-seal-worker/sub.go

@@ -116,6 +116,10 @@ func (w *worker) processTask(ctx context.Context, task sectorbuilder.WorkerTask)
 		if err := w.push("cache", task.SectorID); err != nil {
 			return errRes(xerrors.Errorf("pushing precommited data: %w", err))
 		}
+
+		if err := w.remove("staging", task.SectorID); err != nil {
+			return errRes(xerrors.Errorf("cleaning up staged sector: %w", err))
+		}
 	case sectorbuilder.WorkerCommit:
 		proof, err := w.sb.SealCommit(ctx, task.SectorID, task.SealTicket, task.SealSeed, task.Pieces, task.Rspco)
 		if err != nil {
@@ -127,6 +131,10 @@ func (w *worker) processTask(ctx context.Context, task sectorbuilder.WorkerTask)
 		if err := w.push("cache", task.SectorID); err != nil {
 			return errRes(xerrors.Errorf("pushing precommited data: %w", err))
 		}
+
+		if err := w.remove("sealed", task.SectorID); err != nil {
+			return errRes(xerrors.Errorf("cleaning up sealed sector: %w", err))
+		}
 	}
 
 	return res

cmd/lotus-seal-worker/transfer.go

@@ -125,6 +125,11 @@ func (w *worker) push(typ string, sectorID uint64) error {
 	}
 
 	// TODO: keep files around for later stages of sealing
+	return w.remove(typ, sectorID)
+}
+
+func (w *worker) remove(typ string, sectorID uint64) error {
+	filename := filepath.Join(w.repo, typ, w.sb.SectorName(sectorID))
 	return os.RemoveAll(filename)
 }
 

cmd/lotus-storage-miner/init.go

@@ -11,7 +11,12 @@ import (
 	"path/filepath"
 	"strconv"
 
+	"github.com/filecoin-project/go-address"
+	cborutil "github.com/filecoin-project/go-cbor-util"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	deals "github.com/filecoin-project/go-fil-markets/storagemarket/impl"
 	paramfetch "github.com/filecoin-project/go-paramfetch"
+	"github.com/filecoin-project/go-sectorbuilder"
 	"github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/namespace"
 	badger "github.com/ipfs/go-ds-badger2"
@@ -21,11 +26,6 @@ import (
 	"golang.org/x/xerrors"
 	"gopkg.in/urfave/cli.v2"
 
-	"github.com/filecoin-project/go-address"
-	cborutil "github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/go-fil-markets/storagemarket"
-	deals "github.com/filecoin-project/go-fil-markets/storagemarket/impl"
-	"github.com/filecoin-project/go-sectorbuilder"
 	lapi "github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors"
@@ -38,6 +38,7 @@ import (
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/repo"
 	"github.com/filecoin-project/lotus/storage"
+	"github.com/filecoin-project/lotus/storage/sealing"
 )
 
 var initCmd = &cli.Command{
@@ -242,17 +243,17 @@ func migratePreSealMeta(ctx context.Context, api lapi.FullNode, presealDir strin
 	}
 
 	for _, sector := range meta.Sectors {
-		sectorKey := datastore.NewKey(storage.SectorStorePrefix).ChildString(fmt.Sprint(sector.SectorID))
+		sectorKey := datastore.NewKey(sealing.SectorStorePrefix).ChildString(fmt.Sprint(sector.SectorID))
 
 		dealID, err := findMarketDealID(ctx, api, sector.Deal)
 		if err != nil {
 			return xerrors.Errorf("finding storage deal for pre-sealed sector %d: %w", sector.SectorID, err)
 		}
 
-		info := &storage.SectorInfo{
+		info := &sealing.SectorInfo{
 			State:    lapi.Proving,
 			SectorID: sector.SectorID,
-			Pieces: []storage.Piece{
+			Pieces: []sealing.Piece{
 				{
 					DealID: dealID,
 					Size:   meta.SectorSize,
@@ -262,9 +263,9 @@ func migratePreSealMeta(ctx context.Context, api lapi.FullNode, presealDir strin
 			CommD:            sector.CommD[:],
 			CommR:            sector.CommR[:],
 			Proof:            nil,
-			Ticket:           storage.SealTicket{},
+			Ticket:           sealing.SealTicket{},
 			PreCommitMessage: nil,
-			Seed:             storage.SealSeed{},
+			Seed:             sealing.SealSeed{},
 			CommitMessage:    nil,
 		}
 
@@ -556,7 +557,7 @@ func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID,
 	createStorageMinerMsg := &types.Message{
 		To:    actors.StoragePowerAddress,
 		From:  owner,
-		Value: collateral,
+		Value: types.BigAdd(collateral, types.BigDiv(collateral, types.NewInt(100))),
 
 		Method: actors.SPAMethods.CreateStorageMiner,
 		Params: params,

gen/main.go

@@ -10,8 +10,9 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/blocksync"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/statemachine"
 	"github.com/filecoin-project/lotus/paych"
-	"github.com/filecoin-project/lotus/storage"
+	"github.com/filecoin-project/lotus/storage/sealing"
 )
 
 func main() {
@@ -121,14 +122,23 @@ func main() {
 		os.Exit(1)
 	}
 
-	err = gen.WriteMapEncodersToFile("./storage/cbor_gen.go", "storage",
-		storage.SealTicket{},
-		storage.SealSeed{},
-		storage.Piece{},
-		storage.SectorInfo{},
+	err = gen.WriteMapEncodersToFile("./storage/sectors/cbor_gen.go", "sectors",
+		sealing.SealTicket{},
+		sealing.SealSeed{},
+		sealing.Piece{},
+		sealing.SectorInfo{},
 	)
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
+
+	err = gen.WriteMapEncodersToFile("./lib/statemachine/cbor_gen.go", "statemachine",
+		statemachine.TestState{},
+		statemachine.TestEvent{},
+	)
+	if err != nil {
+		fmt.Printf("%+v\n", err)
+		os.Exit(1)
+	}
 }

go.mod

@@ -8,11 +8,13 @@ require (
 	github.com/GeertJohan/go.rice v1.0.0
 	github.com/Gurpartap/async v0.0.0-20180927173644-4f7f499dd9ee
 	github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d // indirect
+	github.com/coreos/go-systemd v0.0.0-00010101000000-000000000000
 	github.com/docker/go-units v0.4.0
 	github.com/filecoin-project/chain-validation v0.0.3
 	github.com/filecoin-project/filecoin-ffi v0.0.0-20191219131535-bb699517a590
 	github.com/filecoin-project/go-address v0.0.0-20191219011437-af739c490b4f
 	github.com/filecoin-project/go-amt-ipld v0.0.0-20191205011053-79efc22d6cdc
+	github.com/filecoin-project/go-amt-ipld/v2 v2.0.0
 	github.com/filecoin-project/go-cbor-util v0.0.0-20191219014500-08c40a1e63a2
 	github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03
 	github.com/filecoin-project/go-data-transfer v0.0.0-20191219005021-4accf56bd2ce
@@ -109,3 +111,5 @@ require (
 replace github.com/golangci/golangci-lint => github.com/golangci/golangci-lint v1.18.0
 
 replace github.com/filecoin-project/filecoin-ffi => ./extern/filecoin-ffi
+
+replace github.com/coreos/go-systemd => github.com/coreos/go-systemd/v22 v22.0.0

go.sum

@@ -3,14 +3,12 @@ cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT
 contrib.go.opencensus.io/exporter/jaeger v0.1.0 h1:WNc9HbA38xEQmsI40Tjd/MNU/g8byN2Of7lwIjv0Jdc=
 contrib.go.opencensus.io/exporter/jaeger v0.1.0/go.mod h1:VYianECmuFPwU37O699Vc1GOcy+y8kOsfaxHRImmjbA=
 github.com/AndreasBriese/bbloom v0.0.0-20180913140656-343706a395b7/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8=
-github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9 h1:HD8gA2tkByhMAwYaFAX9w2l7vxvBQ5NMoxDrkhqhtn4=
 github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8=
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/DataDog/zstd v1.4.1 h1:3oxKN3wbHibqx897utPC2LTQU4J+IHWWJO+glkAkpFM=
 github.com/DataDog/zstd v1.4.1/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo=
 github.com/GeertJohan/go.incremental v1.0.0 h1:7AH+pY1XUgQE4Y1HcXYaMqAI0m9yrFqo/jt0CW30vsg=
-github.com/GeertJohan/go.incremental v1.0.0 h1:7AH+pY1XUgQE4Y1HcXYaMqAI0m9yrFqo/jt0CW30vsg=
 github.com/GeertJohan/go.incremental v1.0.0/go.mod h1:6fAjUhbVuX1KcMD3c8TEgVUqmo4seqhv0i0kdATSkM0=
 github.com/GeertJohan/go.rice v1.0.0 h1:KkI6O9uMaQU3VEKaj01ulavtF7o1fWT7+pk/4voiMLQ=
 github.com/GeertJohan/go.rice v1.0.0/go.mod h1:eH6gbSOAUv07dQuZVnBmoDP8mgsM1rtixis4Tib9if0=
@@ -61,6 +59,8 @@ github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3Ee
 github.com/coreos/go-semver v0.2.1-0.20180108230905-e214231b295a/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/coreos/go-semver v0.3.0 h1:wkHLiw0WNATZnSG7epLsujiMCgPAc9xhjJ4tgnAxmfM=
 github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/coreos/go-systemd/v22 v22.0.0 h1:XJIw/+VlJ+87J+doOxznsAWIdmWuViOVhkQamW5YV28=
+github.com/coreos/go-systemd/v22 v22.0.0/go.mod h1:xO0FLkIi5MaZafQlIrOotqXZ90ih+1atmu1JpKERPPk=
 github.com/cpuguy83/go-md2man v1.0.10 h1:BSKMNlYxDvnunlTymqtgONjNnaRV1sTpcovwwjF22jk=
 github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d h1:U+s90UTSYgptZMwQh2aRr3LuazLJIa+Pg3Kc1ylSYVY=
@@ -91,7 +91,6 @@ github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25Kn
 github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
 github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
 github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
-github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.8.0 h1:5bzFgL+oy7JITMTxUPJ00n7VxmYd/PdMp5mHFX40/RY=
 github.com/fatih/color v1.8.0/go.mod h1:3l45GVGkyrnYNl9HoIjnp2NnNWvh6hLAqD8yTfGjnw8=
@@ -102,10 +101,17 @@ github.com/filecoin-project/go-address v0.0.0-20191219011437-af739c490b4f h1:L2j
 github.com/filecoin-project/go-address v0.0.0-20191219011437-af739c490b4f/go.mod h1:rCbpXPva2NKF9/J4X6sr7hbKBgQCxyFtRj7KOZqoIms=
 github.com/filecoin-project/go-amt-ipld v0.0.0-20191205011053-79efc22d6cdc h1:cODZD2YzpTUtrOSxbEnWFcQHidNRZiRdvLxySjGvG/M=
 github.com/filecoin-project/go-amt-ipld v0.0.0-20191205011053-79efc22d6cdc/go.mod h1:KsFPWjF+UUYl6n9A+qbg4bjFgAOneicFZtDH/LQEX2U=
+github.com/filecoin-project/go-amt-ipld/v2 v2.0.0 h1:rQ7GTJbWE5XqUCPiBgs4gbTKD2wC7MynZhSaf7ZzlUM=
+github.com/filecoin-project/go-amt-ipld/v2 v2.0.0/go.mod h1:PAZ5tvSfMfWE327osqFXKm7cBpCpBk2Nh0qKsJUmjjk=
 github.com/filecoin-project/go-cbor-util v0.0.0-20191219014500-08c40a1e63a2 h1:av5fw6wmm58FYMgJeoB/lK9XXrgdugYiTqkdxjTy9k8=
 github.com/filecoin-project/go-cbor-util v0.0.0-20191219014500-08c40a1e63a2/go.mod h1:pqTiPHobNkOVM5thSRsHYjyQfq7O5QSCMhvuu9JoDlg=
 github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03 h1:2pMXdBnCiXjfCYx/hLqFxccPoqsSveQFxVLvNxy9bus=
 github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03 h1:2pMXdBnCiXjfCYx/hLqFxccPoqsSveQFxVLvNxy9bus=
+github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03 h1:2pMXdBnCiXjfCYx/hLqFxccPoqsSveQFxVLvNxy9bus=
+github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03 h1:2pMXdBnCiXjfCYx/hLqFxccPoqsSveQFxVLvNxy9bus=
+github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
+github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
+github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
 github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
 github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
 github.com/filecoin-project/go-data-transfer v0.0.0-20191219005021-4accf56bd2ce h1:Jdejrx6XVSTRy2PiX08HCU5y68p3wx2hNMJJc/J7kZY=
@@ -114,22 +120,22 @@ github.com/filecoin-project/go-fil-markets v0.0.0-20200114015428-74d100f305f8 h1
 github.com/filecoin-project/go-fil-markets v0.0.0-20200114015428-74d100f305f8/go.mod h1:c8NTjvFVy1Ud02mmGDjOiMeawY2t6ALfrrdvAB01FQc=
 github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878 h1:YicJT9xhPzZ1SBGiJFNUCkfwqK/G9vFyY1ytKBSjNJA=
 github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878 h1:YicJT9xhPzZ1SBGiJFNUCkfwqK/G9vFyY1ytKBSjNJA=
-github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878/go.mod h1:40kI2Gv16mwcRsHptI3OAV4nlOEU7wVDc4RgMylNFjU=
-github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878/go.mod h1:40kI2Gv16mwcRsHptI3OAV4nlOEU7wVDc4RgMylNFjU=
-github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03 h1:2pMXdBnCiXjfCYx/hLqFxccPoqsSveQFxVLvNxy9bus=
-github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
-github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
 github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878 h1:YicJT9xhPzZ1SBGiJFNUCkfwqK/G9vFyY1ytKBSjNJA=
 github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878 h1:YicJT9xhPzZ1SBGiJFNUCkfwqK/G9vFyY1ytKBSjNJA=
+github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878 h1:YicJT9xhPzZ1SBGiJFNUCkfwqK/G9vFyY1ytKBSjNJA=
+github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878/go.mod h1:40kI2Gv16mwcRsHptI3OAV4nlOEU7wVDc4RgMylNFjU=
+github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878/go.mod h1:40kI2Gv16mwcRsHptI3OAV4nlOEU7wVDc4RgMylNFjU=
+github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878/go.mod h1:40kI2Gv16mwcRsHptI3OAV4nlOEU7wVDc4RgMylNFjU=
 github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878/go.mod h1:40kI2Gv16mwcRsHptI3OAV4nlOEU7wVDc4RgMylNFjU=
 github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878/go.mod h1:40kI2Gv16mwcRsHptI3OAV4nlOEU7wVDc4RgMylNFjU=
 github.com/filecoin-project/go-paramfetch v0.0.1 h1:gV7bs5YaqlgpGFMiLxInGK2L1FyCXUE0rimz4L7ghoE=
 github.com/filecoin-project/go-paramfetch v0.0.1/go.mod h1:fZzmf4tftbwf9S37XRifoJlz7nCjRdIrMGLR07dKLCc=
-github.com/filecoin-project/go-sectorbuilder v0.0.1 h1:yiLSEprWA1E43DFTSCXLSuCstYuDKiI6RCXiYz4GaRs=
 github.com/filecoin-project/go-sectorbuilder v0.0.1/go.mod h1:3OZ4E3B2OuwhJjtxR4r7hPU9bCfB+A+hm4alLEsaeDc=
 github.com/filecoin-project/go-sectorbuilder v0.0.2-0.20200114015900-4103afa82689 h1:2cT5bhm/5I0RY+HBIPdRRrtjCwLj33Qx6DHRs9TCslY=
 github.com/filecoin-project/go-sectorbuilder v0.0.2-0.20200114015900-4103afa82689/go.mod h1:3OZ4E3B2OuwhJjtxR4r7hPU9bCfB+A+hm4alLEsaeDc=
 github.com/filecoin-project/go-statestore v0.1.0 h1:t56reH59843TwXHkMcwyuayStBIiWBRilQjQ+5IiwdQ=
+github.com/filecoin-project/go-statestore v0.1.0 h1:t56reH59843TwXHkMcwyuayStBIiWBRilQjQ+5IiwdQ=
+github.com/filecoin-project/go-statestore v0.1.0/go.mod h1:LFc9hD+fRxPqiHiaqUEZOinUJB4WARkRfNl10O7kTnI=
 github.com/filecoin-project/go-statestore v0.1.0/go.mod h1:LFc9hD+fRxPqiHiaqUEZOinUJB4WARkRfNl10O7kTnI=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
@@ -142,6 +148,8 @@ github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9
 github.com/go-ole/go-ole v1.2.4 h1:nNBDSCOigTSiarFpYE9J/KtEA1IOW4CNeqT9TQDqCxI=
 github.com/go-ole/go-ole v1.2.4/go.mod h1:XCwSNxSkXRo4vlyPy93sltvi/qJq0jqQhjqQNIwKuxM=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/godbus/dbus/v5 v5.0.3 h1:ZqHaoEF7TBzh4jzPmqVhE/5A1z9of6orkAe5uHoAeME=
+github.com/godbus/dbus/v5 v5.0.3/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
@@ -230,7 +238,6 @@ github.com/ipfs/go-cid v0.0.4/go.mod h1:4LLaPOQwmk5z9LBgQnpkivrx8BJjUyGwTXCd5Xfj
 github.com/ipfs/go-datastore v0.0.1/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE=
 github.com/ipfs/go-datastore v0.0.5/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE=
 github.com/ipfs/go-datastore v0.1.0/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE=
-github.com/ipfs/go-datastore v0.1.1 h1:F4k0TkTAZGLFzBOrVKDAvch6JZtuN4NHkfdcEZL50aI=
 github.com/ipfs/go-datastore v0.1.1/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw=
 github.com/ipfs/go-datastore v0.3.1 h1:SS1t869a6cctoSYmZXUk8eL6AzVXgASmKIWFNQkQ1jU=
 github.com/ipfs/go-datastore v0.3.1/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw=
@@ -238,7 +245,6 @@ github.com/ipfs/go-detect-race v0.0.1 h1:qX/xay2W3E4Q1U7d9lNs1sU9nvguX0a7319XbyQ
 github.com/ipfs/go-detect-race v0.0.1/go.mod h1:8BNT7shDZPo99Q74BpGMK+4D8Mn4j46UU0LZ723meps=
 github.com/ipfs/go-ds-badger v0.0.2/go.mod h1:Y3QpeSFWQf6MopLTiZD+VT6IC1yZqaGmjvRcKeSGij8=
 github.com/ipfs/go-ds-badger v0.0.5/go.mod h1:g5AuuCGmr7efyzQhLL8MzwqcauPojGPUaHzfGTzuE3s=
-github.com/ipfs/go-ds-badger v0.0.7 h1:NMyh88Q50HG6/S2YD58DLkq0c0/ZQPMbSojONH+PRf4=
 github.com/ipfs/go-ds-badger v0.0.7/go.mod h1:qt0/fWzZDoPW6jpQeqUjR5kBfhDNB65jd9YlmAvpQBk=
 github.com/ipfs/go-ds-badger2 v0.0.0-20200108185345-7f650e6b2521 h1:GSygNXXIRXFVntMR3Yr30imf40H9cYDAw72Qb0za2nE=
 github.com/ipfs/go-ds-badger2 v0.0.0-20200108185345-7f650e6b2521/go.mod h1:oDKWqmQbLyyml3mgMtHgB7qAf6cQOEsJPRLFzfwKQ5Q=
@@ -289,15 +295,9 @@ github.com/ipfs/go-ipld-format v0.0.1/go.mod h1:kyJtbkDALmFHv3QR6et67i35QzO3S0dC
 github.com/ipfs/go-ipld-format v0.0.2 h1:OVAGlyYT6JPZ0pEfGntFPS40lfrDmaDbQwNHEY2G9Zs=
 github.com/ipfs/go-ipld-format v0.0.2/go.mod h1:4B6+FM2u9OJ9zCV+kSbgFAZlOrv1Hqbf0INGQgiKf9k=
 github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM=
-github.com/ipfs/go-log v1.0.0 h1:BW3LQIiZzpNyolt84yvKNCd3FU+AK4VDw1hnHR+1aiI=
 github.com/ipfs/go-log v1.0.0/go.mod h1:JO7RzlMK6rA+CIxFMLOuB6Wf5b81GDiKElL7UPSIKjA=
 github.com/ipfs/go-log v1.0.1 h1:5lIEEOQTk/vd1WuPFBRqz2mcp+5G1fMVcW+Ib/H5Hfo=
-github.com/ipfs/go-log v1.0.1 h1:5lIEEOQTk/vd1WuPFBRqz2mcp+5G1fMVcW+Ib/H5Hfo=
 github.com/ipfs/go-log v1.0.1/go.mod h1:HuWlQttfN6FWNHRhlY5yMk/lW7evQC0HHGOxEwMRR8I=
-github.com/ipfs/go-log v1.0.1/go.mod h1:HuWlQttfN6FWNHRhlY5yMk/lW7evQC0HHGOxEwMRR8I=
-github.com/ipfs/go-log/v2 v2.0.1 h1:mnR9XFltezAtO8A6tj5U7nKkRzhEQNEw/wT11U2HhPM=
-github.com/ipfs/go-log/v2 v2.0.1 h1:mnR9XFltezAtO8A6tj5U7nKkRzhEQNEw/wT11U2HhPM=
-github.com/ipfs/go-log/v2 v2.0.1/go.mod h1:O7P1lJt27vWHhOwQmcFEvlmo49ry2VY2+JfBWFaa9+0=
 github.com/ipfs/go-log/v2 v2.0.1/go.mod h1:O7P1lJt27vWHhOwQmcFEvlmo49ry2VY2+JfBWFaa9+0=
 github.com/ipfs/go-log/v2 v2.0.2 h1:xguurydRdfKMJjKyxNXNU8lYP0VZH1NUwJRwUorjuEw=
 github.com/ipfs/go-log/v2 v2.0.2/go.mod h1:O7P1lJt27vWHhOwQmcFEvlmo49ry2VY2+JfBWFaa9+0=
@@ -457,7 +457,6 @@ github.com/libp2p/go-libp2p-peerstore v0.0.1/go.mod h1:RabLyPVJLuNQ+GFyoEkfi8H4T
 github.com/libp2p/go-libp2p-peerstore v0.0.6/go.mod h1:RabLyPVJLuNQ+GFyoEkfi8H4Ti6k/HtZJ7YKgtSq+20=
 github.com/libp2p/go-libp2p-peerstore v0.1.0/go.mod h1:2CeHkQsr8svp4fZ+Oi9ykN1HBb6u0MOvdJ7YIsmcwtY=
 github.com/libp2p/go-libp2p-peerstore v0.1.2/go.mod h1:BJ9sHlm59/80oSkpWgr1MyY1ciXAXV397W6h1GH/uKI=
-github.com/libp2p/go-libp2p-peerstore v0.1.3 h1:wMgajt1uM2tMiqf4M+4qWKVyyFc8SfA+84VV9glZq1M=
 github.com/libp2p/go-libp2p-peerstore v0.1.3/go.mod h1:BJ9sHlm59/80oSkpWgr1MyY1ciXAXV397W6h1GH/uKI=
 github.com/libp2p/go-libp2p-peerstore v0.1.4 h1:d23fvq5oYMJ/lkkbO4oTwBp/JP+I/1m5gZJobNXCE/k=
 github.com/libp2p/go-libp2p-peerstore v0.1.4/go.mod h1:+4BDbDiiKf4PzpANZDAT+knVdLxvqh7hXOujessqdzs=
@@ -479,7 +478,6 @@ github.com/libp2p/go-libp2p-routing-helpers v0.1.0/go.mod h1:oUs0h39vNwYtYXnQWOT
 github.com/libp2p/go-libp2p-secio v0.0.3/go.mod h1:hS7HQ00MgLhRO/Wyu1bTX6ctJKhVpm+j2/S2A5UqYb0=
 github.com/libp2p/go-libp2p-secio v0.1.0/go.mod h1:tMJo2w7h3+wN4pgU2LSYeiKPrfqBgkOsdiKK77hE7c8=
 github.com/libp2p/go-libp2p-secio v0.1.1/go.mod h1:tMJo2w7h3+wN4pgU2LSYeiKPrfqBgkOsdiKK77hE7c8=
-github.com/libp2p/go-libp2p-secio v0.2.0 h1:ywzZBsWEEz2KNTn5RtzauEDq5RFEefPsttXYwAWqHng=
 github.com/libp2p/go-libp2p-secio v0.2.0/go.mod h1:2JdZepB8J5V9mBp79BmwsaPQhRPNN2NrnB2lKQcdy6g=
 github.com/libp2p/go-libp2p-secio v0.2.1 h1:eNWbJTdyPA7NxhP7J3c5lT97DC5d+u+IldkgCYFTPVA=
 github.com/libp2p/go-libp2p-secio v0.2.1/go.mod h1:cWtZpILJqkqrSkiYcDBh5lA3wbT2Q+hz3rJQq3iftD8=
@@ -530,7 +528,6 @@ github.com/libp2p/go-reuseport v0.0.1 h1:7PhkfH73VXfPJYKQ6JwS5I/eVcoyYi9IMNGc6FW
 github.com/libp2p/go-reuseport v0.0.1/go.mod h1:jn6RmB1ufnQwl0Q1f+YxAj8isJgDCQzaaxIFYDhcYEA=
 github.com/libp2p/go-reuseport-transport v0.0.2 h1:WglMwyXyBu61CMkjCCtnmqNqnjib0GIEjMiHTwR/KN4=
 github.com/libp2p/go-reuseport-transport v0.0.2/go.mod h1:YkbSDrvjUVDL6b8XqriyA20obEtsW9BLkuOUyQAOCbs=
-github.com/libp2p/go-stream-muxer v0.0.1 h1:Ce6e2Pyu+b5MC1k3eeFtAax0pW4gc6MosYSLV05UeLw=
 github.com/libp2p/go-stream-muxer v0.0.1/go.mod h1:bAo8x7YkSpadMTbtTaxGVHWUQsR/l5MEaHbKaliuT14=
 github.com/libp2p/go-stream-muxer v0.1.0/go.mod h1:8JAVsjeRBCWwPoZeH0W1imLOcriqXJyFvB0mR4A04sQ=
 github.com/libp2p/go-stream-muxer-multistream v0.1.1/go.mod h1:zmGdfkQ1AzOECIAcccoL8L//laqawOsO03zX8Sa+eGw=
@@ -558,7 +555,6 @@ github.com/marten-seemann/qtls v0.2.3 h1:0yWJ43C62LsZt08vuQJDK1uC1czUc3FJeCLPoNA
 github.com/marten-seemann/qtls v0.2.3/go.mod h1:xzjG7avBwGGbdZ8dTGxlBnLArsVKLvwmjgmPuiQEcYk=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
-github.com/mattn/go-colorable v0.1.2 h1:/bC9yWikZXAL9uJdulbSfyVNIR3n3trXl+v8+1sx8mU=
 github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
 github.com/mattn/go-colorable v0.1.4 h1:snbPLB8fVfU9iwbbo30TPtbLRzwWu6aJS6Xh4eaaviA=
 github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
@@ -716,7 +712,6 @@ github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijb
 github.com/urfave/cli/v2 v2.0.0 h1:+HU9SCbu8GnEUFtIBfuUNXN39ofWViIEJIp6SURMpCg=
 github.com/urfave/cli/v2 v2.0.0/go.mod h1:SE9GqnLQmjVa0iPEY0f1w3ygNIYcIJ0OKPMoW2caLfQ=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
-github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasttemplate v1.0.1 h1:tY9CJiPnMXf1ERmG2EyK7gNUd+c6RKGD0IfU8WdUSz8=
 github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
@@ -731,7 +726,6 @@ github.com/whyrusleeping/cbor-gen v0.0.0-20190910031516-c1cbffdb01bb/go.mod h1:x
 github.com/whyrusleeping/cbor-gen v0.0.0-20190917003517-d78d67427694/go.mod h1:xdlJQaiqipF0HW+Mzpg7XRM3fWbGvfgFlcppuvlkIvY=
 github.com/whyrusleeping/cbor-gen v0.0.0-20191116002219-891f55cd449d/go.mod h1:xdlJQaiqipF0HW+Mzpg7XRM3fWbGvfgFlcppuvlkIvY=
 github.com/whyrusleeping/cbor-gen v0.0.0-20191212224538-d370462a7e8a/go.mod h1:xdlJQaiqipF0HW+Mzpg7XRM3fWbGvfgFlcppuvlkIvY=
-github.com/whyrusleeping/cbor-gen v0.0.0-20191216205031-b047b6acb3c0 h1:efb/4CnrubzNGqQOeHErxyQ6rIsJb7GcgeSDF7fqWeI=
 github.com/whyrusleeping/cbor-gen v0.0.0-20191216205031-b047b6acb3c0/go.mod h1:xdlJQaiqipF0HW+Mzpg7XRM3fWbGvfgFlcppuvlkIvY=
 github.com/whyrusleeping/cbor-gen v0.0.0-20200106232624-282db0d37dbe h1:n7En1uyDtknjLRDXebWlPGJoHvwL8AkNcSQzuOoYYYQ=
 github.com/whyrusleeping/cbor-gen v0.0.0-20200106232624-282db0d37dbe/go.mod h1:xdlJQaiqipF0HW+Mzpg7XRM3fWbGvfgFlcppuvlkIvY=
@@ -760,12 +754,10 @@ github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:
 go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
-go.opencensus.io v0.22.1 h1:8dP3SGL7MPB94crU3bEPplMPe83FI4EouesJUeFHv50=
 go.opencensus.io v0.22.1/go.mod h1:Ap50jQcDJrx6rB6VgeeFPtuPIf3wMRvRfrfYDO6+BmA=
 go.opencensus.io v0.22.2 h1:75k/FF0Q2YM8QYo07VPddOLBslDt1MZOdEslOHvmzAs=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/atomic v1.5.0 h1:OI5t8sDa1Or+q8AeE+yKeB/SDYioSHAgcVljj9JIETY=
 go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
 go.uber.org/atomic v1.5.1 h1:rsqfU5vBkVknbhUGbAUwQKR2H4ItV8tjJ+6kJX4cxHM=
 go.uber.org/atomic v1.5.1/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
@@ -781,7 +773,6 @@ go.uber.org/multierr v1.4.0 h1:f3WCSC2KzAcBXGATIxAB1E2XuCpNU255wNKZ505qi3E=
 go.uber.org/multierr v1.4.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
 go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee h1:0mgffUl7nfd+FpvXMVz4IDEaUSmT1ysygQC7qYo7sG4=
 go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
-go.uber.org/zap v1.10.0 h1:ORx85nbTijNz8ljznvCMR1ZBIPKFn3jQrag10X2AsuM=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 go.uber.org/zap v1.13.0 h1:nR6NoDBgAf67s68NhaXbsojM+2gxp3S1hWkHDl27pVU=
 go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
@@ -802,7 +793,6 @@ golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190618222545-ea8f1a30c443/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550 h1:ObdrDkeb4kJdCP557AjRjq69pTHfNouLtWZG7j9rPN8=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413 h1:ULYEB3JvPRE/IfO+9uO7vKV/xzVTO7XPAwm8xbf4w2g=
 golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
@@ -811,7 +801,6 @@ golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTk
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
 golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f h1:J5lckAjkw6qYlOZNj90mLYNTEKDvWeuc1yieZ8qUzUE=
 golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
@@ -832,12 +821,10 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190611141213-3f473d35a33a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859 h1:R/3boaszxrf1GEUWTVDzSKVwLmSJpwZ1yqXm8j0v2QI=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190724013045-ca1201d0de80 h1:Ao/3l156eZf2AW5wK8a7/smtodRU+gha3+BeqJ69lRk=
 golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421 h1:Wo7BWFiOk0QRFMLYMqJGFMd9CgUAcGx7V+qEg/h5IBI=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -868,7 +855,6 @@ golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191210023423-ac6580df4449 h1:gSbV7h1NRL2G1xTg/owz62CST1oJBmxy4QpMMregXVQ=
 golang.org/x/sys v0.0.0-20191210023423-ac6580df4449/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200107162124-548cf772de50 h1:YvQ10rzcqWXLlJZ3XCUoO25savxmscf4+SC+ZqiCHhA=
 golang.org/x/sys v0.0.0-20200107162124-548cf772de50/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -891,7 +877,6 @@ golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgw
 golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191216173652-a0e659d51361 h1:RIIXAeV6GvDBuADKumTODatUqANFZ+5BPMnzsy4hulY=
 golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/tools v0.0.0-20200108195415-316d2f248479 h1:csuS+MHeEA2eWhyjQCMaPMq4z1+/PohkBSjJZHSIbOE=
 golang.org/x/tools v0.0.0-20200108195415-316d2f248479/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
@@ -911,7 +896,6 @@ google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRn
 google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.20.1 h1:Hz2g2wirWK7H0qIIhGIqRGTuMwTE8HEKFnDZZ7lm9NU=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6 h1:jMFz6MfLP0/4fUyZle81rXUoxOBFi19VUFKVDOQfozc=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=

lib/statemachine/cbor_gen.go

@@ -0,0 +1,238 @@
+package statemachine
+
+import (
+	"fmt"
+	"io"
+
+	cbg "github.com/whyrusleeping/cbor-gen"
+	xerrors "golang.org/x/xerrors"
+)
+
+// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
+
+var _ = xerrors.Errorf
+
+func (t *TestState) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write([]byte{162}); err != nil {
+		return err
+	}
+
+	// t.A (uint64) (uint64)
+	if len("A") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"A\" was too long")
+	}
+
+	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("A")))); err != nil {
+		return err
+	}
+	if _, err := w.Write([]byte("A")); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.A))); err != nil {
+		return err
+	}
+
+	// t.B (uint64) (uint64)
+	if len("B") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"B\" was too long")
+	}
+
+	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("B")))); err != nil {
+		return err
+	}
+	if _, err := w.Write([]byte("B")); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.B))); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *TestState) UnmarshalCBOR(r io.Reader) error {
+	br := cbg.GetPeeker(r)
+
+	maj, extra, err := cbg.CborReadHeader(br)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	var name string
+
+	// t.A (uint64) (uint64)
+
+	{
+		sval, err := cbg.ReadString(br)
+		if err != nil {
+			return err
+		}
+
+		name = string(sval)
+	}
+
+	if name != "A" {
+		return fmt.Errorf("expected struct map entry %s to be A", name)
+	}
+
+	maj, extra, err = cbg.CborReadHeader(br)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajUnsignedInt {
+		return fmt.Errorf("wrong type for uint64 field")
+	}
+	t.A = uint64(extra)
+	// t.B (uint64) (uint64)
+
+	{
+		sval, err := cbg.ReadString(br)
+		if err != nil {
+			return err
+		}
+
+		name = string(sval)
+	}
+
+	if name != "B" {
+		return fmt.Errorf("expected struct map entry %s to be B", name)
+	}
+
+	maj, extra, err = cbg.CborReadHeader(br)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajUnsignedInt {
+		return fmt.Errorf("wrong type for uint64 field")
+	}
+	t.B = uint64(extra)
+	return nil
+}
+
+func (t *TestEvent) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write([]byte{162}); err != nil {
+		return err
+	}
+
+	// t.A (string) (string)
+	if len("A") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"A\" was too long")
+	}
+
+	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("A")))); err != nil {
+		return err
+	}
+	if _, err := w.Write([]byte("A")); err != nil {
+		return err
+	}
+
+	if len(t.A) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.A was too long")
+	}
+
+	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.A)))); err != nil {
+		return err
+	}
+	if _, err := w.Write([]byte(t.A)); err != nil {
+		return err
+	}
+
+	// t.Val (uint64) (uint64)
+	if len("Val") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Val\" was too long")
+	}
+
+	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Val")))); err != nil {
+		return err
+	}
+	if _, err := w.Write([]byte("Val")); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Val))); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *TestEvent) UnmarshalCBOR(r io.Reader) error {
+	br := cbg.GetPeeker(r)
+
+	maj, extra, err := cbg.CborReadHeader(br)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	var name string
+
+	// t.A (string) (string)
+
+	{
+		sval, err := cbg.ReadString(br)
+		if err != nil {
+			return err
+		}
+
+		name = string(sval)
+	}
+
+	if name != "A" {
+		return fmt.Errorf("expected struct map entry %s to be A", name)
+	}
+
+	{
+		sval, err := cbg.ReadString(br)
+		if err != nil {
+			return err
+		}
+
+		t.A = string(sval)
+	}
+	// t.Val (uint64) (uint64)
+
+	{
+		sval, err := cbg.ReadString(br)
+		if err != nil {
+			return err
+		}
+
+		name = string(sval)
+	}
+
+	if name != "Val" {
+		return fmt.Errorf("expected struct map entry %s to be Val", name)
+	}
+
+	maj, extra, err = cbg.CborReadHeader(br)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajUnsignedInt {
+		return fmt.Errorf("wrong type for uint64 field")
+	}
+	t.Val = uint64(extra)
+	return nil
+}

lib/statemachine/context.go

@@ -0,0 +1,16 @@
+package statemachine
+
+import "context"
+
+type Context struct {
+	ctx  context.Context
+	send func(evt interface{}) error
+}
+
+func (ctx *Context) Context() context.Context {
+	return ctx.ctx
+}
+
+func (ctx *Context) Send(evt interface{}) error {
+	return ctx.send(evt)
+}

lib/statemachine/group.go

@@ -0,0 +1,116 @@
+package statemachine
+
+import (
+	"context"
+	"reflect"
+	"sync"
+
+	"github.com/filecoin-project/go-statestore"
+	"github.com/ipfs/go-datastore"
+	"golang.org/x/xerrors"
+)
+
+type StateHandler interface {
+	// returns
+	Plan(events []Event, user interface{}) (interface{}, error)
+}
+
+// StateGroup manages a group of state machines sharing the same logic
+type StateGroup struct {
+	sts       *statestore.StateStore
+	hnd       StateHandler
+	stateType reflect.Type
+
+	lk  sync.Mutex
+	sms map[datastore.Key]*StateMachine
+}
+
+// stateType: T - (MyStateStruct{})
+func New(ds datastore.Datastore, hnd StateHandler, stateType interface{}) *StateGroup {
+	return &StateGroup{
+		sts:       statestore.New(ds),
+		hnd:       hnd,
+		stateType: reflect.TypeOf(stateType),
+
+		sms: map[datastore.Key]*StateMachine{},
+	}
+}
+
+// Send sends an event to machine identified by `id`.
+// `evt` is going to be passed into StateHandler.Planner, in the events[].User param
+//
+// If a state machine with the specified id doesn't exits, it's created, and it's
+// state is set to zero-value of stateType provided in group constructor
+func (s *StateGroup) Send(id interface{}, evt interface{}) (err error) {
+	s.lk.Lock()
+	defer s.lk.Unlock()
+
+	sm, exist := s.sms[statestore.ToKey(id)]
+	if !exist {
+		sm, err = s.loadOrCreate(id)
+		if err != nil {
+			return xerrors.Errorf("loadOrCreate state: %w", err)
+		}
+		s.sms[statestore.ToKey(id)] = sm
+	}
+
+	return sm.send(Event{User: evt})
+}
+
+func (s *StateGroup) loadOrCreate(name interface{}) (*StateMachine, error) {
+	exists, err := s.sts.Has(name)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to check if state for %v exists: %w", name, err)
+	}
+
+	if !exists {
+		userState := reflect.New(s.stateType).Interface()
+
+		err = s.sts.Begin(name, userState)
+		if err != nil {
+			return nil, xerrors.Errorf("saving initial state: %w", err)
+		}
+	}
+
+	res := &StateMachine{
+		planner:  s.hnd.Plan,
+		eventsIn: make(chan Event),
+
+		name:      name,
+		st:        s.sts.Get(name),
+		stateType: s.stateType,
+
+		stageDone: make(chan struct{}),
+		closing:   make(chan struct{}),
+		closed:    make(chan struct{}),
+	}
+
+	go res.run()
+
+	return res, nil
+}
+
+// Stop stops all state machines in this group
+func (s *StateGroup) Stop(ctx context.Context) error {
+	s.lk.Lock()
+	defer s.lk.Unlock()
+
+	for _, sm := range s.sms {
+		if err := sm.stop(ctx); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// List outputs states of all state machines in this group
+// out: *[]StateT
+func (s *StateGroup) List(out interface{}) error {
+	return s.sts.List(out)
+}
+
+// Get gets state for a single state machine
+func (s *StateGroup) Get(id interface{}) *statestore.StoredState {
+	return s.sts.Get(id)
+}

lib/statemachine/machine.go

@@ -0,0 +1,127 @@
+package statemachine
+
+import (
+	"context"
+	"reflect"
+	"sync/atomic"
+
+	"github.com/filecoin-project/go-statestore"
+
+	logging "github.com/ipfs/go-log"
+)
+
+var log = logging.Logger("evtsm")
+
+type Event struct {
+	User interface{}
+}
+
+// TODO: This probably should be returning an int indicating partial event processing
+//  (or something like errPartial(nEvents))
+// returns func(ctx Context, st <T>) (func(*<T>), error), where <T> is the typeOf(User) param
+type Planner func(events []Event, user interface{}) (interface{}, error)
+
+type StateMachine struct {
+	planner  Planner
+	eventsIn chan Event
+
+	name      interface{}
+	st        *statestore.StoredState
+	stateType reflect.Type
+
+	stageDone chan struct{}
+	closing   chan struct{}
+	closed    chan struct{}
+
+	busy int32
+}
+
+func (fsm *StateMachine) run() {
+	defer close(fsm.closed)
+
+	var pendingEvents []Event
+
+	for {
+		// NOTE: This requires at least one event to be sent to trigger a stage
+		//  This means that after restarting the state machine users of this
+		//  code must send a 'restart' event
+		select {
+		case evt := <-fsm.eventsIn:
+			pendingEvents = append(pendingEvents, evt)
+		case <-fsm.stageDone:
+			if len(pendingEvents) == 0 {
+				continue
+			}
+		case <-fsm.closing:
+			return
+		}
+
+		if atomic.CompareAndSwapInt32(&fsm.busy, 0, 1) {
+			var nextStep interface{}
+			var ustate interface{}
+
+			err := fsm.mutateUser(func(user interface{}) (err error) {
+				nextStep, err = fsm.planner(pendingEvents, user)
+				ustate = user
+				return err
+			})
+			if err != nil {
+				log.Errorf("Executing event planner failed: %+v", err)
+				return
+			}
+
+			pendingEvents = nil
+
+			if nextStep == nil {
+				continue
+			}
+
+			ctx := Context{
+				ctx: context.TODO(),
+				send: func(evt interface{}) error {
+					return fsm.send(Event{User: evt})
+				},
+			}
+
+			go func() {
+				res := reflect.ValueOf(nextStep).Call([]reflect.Value{reflect.ValueOf(ctx), reflect.ValueOf(ustate).Elem()})
+
+				if res[0].Interface() != nil {
+					log.Errorf("executing step: %+v", res[0].Interface().(error)) // TODO: propagate top level
+					return
+				}
+
+				atomic.StoreInt32(&fsm.busy, 0)
+				fsm.stageDone <- struct{}{}
+			}()
+
+		}
+	}
+}
+
+func (fsm *StateMachine) mutateUser(cb func(user interface{}) error) error {
+	mutt := reflect.FuncOf([]reflect.Type{reflect.PtrTo(fsm.stateType)}, []reflect.Type{reflect.TypeOf(new(error)).Elem()}, false)
+
+	mutf := reflect.MakeFunc(mutt, func(args []reflect.Value) (results []reflect.Value) {
+		err := cb(args[0].Interface())
+		return []reflect.Value{reflect.ValueOf(&err).Elem()}
+	})
+
+	return fsm.st.Mutate(mutf.Interface())
+}
+
+func (fsm *StateMachine) send(evt Event) error {
+	fsm.eventsIn <- evt // TODO: ctx, at least
+	return nil
+}
+
+func (fsm *StateMachine) stop(ctx context.Context) error {
+	close(fsm.closing)
+
+	select {
+	case <-fsm.closed:
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}

lib/statemachine/machine_test.go

@@ -0,0 +1,105 @@
+package statemachine
+
+import (
+	"context"
+	"testing"
+
+	"github.com/ipfs/go-datastore"
+	logging "github.com/ipfs/go-log"
+	"gotest.tools/assert"
+)
+
+func init() {
+	logging.SetLogLevel("*", "INFO")
+}
+
+type testHandler struct {
+	t       *testing.T
+	proceed chan struct{}
+	done    chan struct{}
+}
+
+func (t *testHandler) Plan(events []Event, state interface{}) (interface{}, error) {
+	return t.plan(events, state.(*TestState))
+}
+
+func (t *testHandler) plan(events []Event, state *TestState) (func(Context, TestState) error, error) {
+	for _, event := range events {
+		e := event.User.(*TestEvent)
+		switch e.A {
+		case "restart":
+		case "start":
+			state.A = 1
+		case "b":
+			state.A = 2
+			state.B = e.Val
+		}
+	}
+
+	switch state.A {
+	case 1:
+		return t.step0, nil
+	case 2:
+		return t.step1, nil
+	default:
+		t.t.Fatal(state.A)
+	}
+	panic("how?")
+}
+
+func (t *testHandler) step0(ctx Context, st TestState) error {
+	ctx.Send(&TestEvent{A: "b", Val: 55})
+	<-t.proceed
+	return nil
+}
+
+func (t *testHandler) step1(ctx Context, st TestState) error {
+	assert.Equal(t.t, uint64(2), st.A)
+
+	close(t.done)
+	return nil
+}
+
+func TestBasic(t *testing.T) {
+	for i := 0; i < 1000; i++ { // run a few times to expose any races
+		ds := datastore.NewMapDatastore()
+
+		th := &testHandler{t: t, done: make(chan struct{}), proceed: make(chan struct{})}
+		close(th.proceed)
+		smm := New(ds, th, TestState{})
+
+		if err := smm.Send(uint64(2), &TestEvent{A: "start"}); err != nil {
+			t.Fatalf("%+v", err)
+		}
+
+		<-th.done
+	}
+}
+
+func TestPersist(t *testing.T) {
+	for i := 0; i < 1000; i++ { // run a few times to expose any races
+		ds := datastore.NewMapDatastore()
+
+		th := &testHandler{t: t, done: make(chan struct{}), proceed: make(chan struct{})}
+		smm := New(ds, th, TestState{})
+
+		if err := smm.Send(uint64(2), &TestEvent{A: "start"}); err != nil {
+			t.Fatalf("%+v", err)
+		}
+
+		if err := smm.Stop(context.Background()); err != nil {
+			t.Fatal(err)
+			return
+		}
+
+		smm = New(ds, th, TestState{})
+		if err := smm.Send(uint64(2), &TestEvent{A: "restart"}); err != nil {
+			t.Fatalf("%+v", err)
+		}
+		close(th.proceed)
+
+		<-th.done
+	}
+}
+
+var _ StateHandler = &testHandler{}

lib/statemachine/testing.go

@@ -0,0 +1,11 @@
+package statemachine
+
+type TestState struct {
+	A uint64
+	B uint64
+}
+
+type TestEvent struct {
+	A   string
+	Val uint64
+}

miner/miner.go

@@ -2,6 +2,7 @@ package miner
 
 import (
 	"context"
+	"fmt"
 	"sync"
 	"time"
 
@@ -11,6 +12,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/types"
+	lru "github.com/hashicorp/golang-lru"
 
 	logging "github.com/ipfs/go-log/v2"
 	"go.opencensus.io/trace"
@@ -22,6 +24,11 @@ var log = logging.Logger("miner")
 type waitFunc func(ctx context.Context, baseTime uint64) error
 
 func NewMiner(api api.FullNode, epp gen.ElectionPoStProver) *Miner {
+	arc, err := lru.NewARC(10000)
+	if err != nil {
+		panic(err)
+	}
+
 	return &Miner{
 		api: api,
 		epp: epp,
@@ -32,6 +39,7 @@ func NewMiner(api api.FullNode, epp gen.ElectionPoStProver) *Miner {
 
 			return nil
 		},
+		minedBlockHeights: arc,
 	}
 }
 
@@ -48,6 +56,8 @@ type Miner struct {
 	waitFunc waitFunc
 
 	lastWork *MiningBase
+
+	minedBlockHeights *lru.ARCCache
 }
 
 func (m *Miner) Addresses() ([]address.Address, error) {
@@ -200,6 +210,17 @@ eventLoop:
 				mWon[b.Header.Miner] = struct{}{}
 			}
 			for _, b := range blks {
+				// TODO: this code was written to handle creating blocks for multiple miners.
+				// However, we don't use that, and we probably never will. So even though this code will
+				// never see different miners, i'm going to handle the caching as if it was going to.
+				// We can clean it up later when we remove all the multiple miner logic.
+				blkKey := fmt.Sprintf("%s-%d", b.Header.Miner, b.Header.Height)
+				if _, ok := m.minedBlockHeights.Get(blkKey); ok {
+					log.Warnw("Created a block at the same height as another block we've created", "height", b.Header.Height, "miner", b.Header.Miner, "parents", b.Header.Parents)
+					continue
+				}
+
+				m.minedBlockHeights.Add(blkKey, true)
 				if err := m.api.SyncSubmitBlock(ctx, b); err != nil {
 					log.Errorf("failed to submit newly mined block: %s", err)
 				}
@@ -356,13 +377,13 @@ func (m *Miner) computeTicket(ctx context.Context, addr address.Address, base *M
 }
 
 func (m *Miner) createBlock(base *MiningBase, addr address.Address, ticket *types.Ticket, proof *types.EPostProof, pending []*types.SignedMessage) (*types.BlockMsg, error) {
-	msgs, err := selectMessages(context.TODO(), m.api.StateGetActor, base, pending)
+	msgs, err := SelectMessages(context.TODO(), m.api.StateGetActor, base.ts, pending)
 	if err != nil {
 		return nil, xerrors.Errorf("message filtering failed: %w", err)
 	}
 
 	if len(msgs) > build.BlockMessageLimit {
-		log.Error("selectMessages returned too many messages: ", len(msgs))
+		log.Error("SelectMessages returned too many messages: ", len(msgs))
 		msgs = msgs[:build.BlockMessageLimit]
 	}
 
@@ -374,7 +395,7 @@ func (m *Miner) createBlock(base *MiningBase, addr address.Address, ticket *type
 	return m.api.MinerCreateBlock(context.TODO(), addr, base.ts, ticket, proof, msgs, nheight, uint64(uts))
 }
 
-type actorLookup func(context.Context, address.Address, *types.TipSet) (*types.Actor, error)
+type ActorLookup func(context.Context, address.Address, *types.TipSet) (*types.Actor, error)
 
 func countFrom(msgs []*types.SignedMessage, from address.Address) (out int) {
 	for _, msg := range msgs {
@@ -385,7 +406,7 @@ func countFrom(msgs []*types.SignedMessage, from address.Address) (out int) {
 	return out
 }
 
-func selectMessages(ctx context.Context, al actorLookup, base *MiningBase, msgs []*types.SignedMessage) ([]*types.SignedMessage, error) {
+func SelectMessages(ctx context.Context, al ActorLookup, ts *types.TipSet, msgs []*types.SignedMessage) ([]*types.SignedMessage, error) {
 	out := make([]*types.SignedMessage, 0, build.BlockMessageLimit)
 	inclNonces := make(map[address.Address]uint64)
 	inclBalances := make(map[address.Address]types.BigInt)
@@ -401,7 +422,7 @@ func selectMessages(ctx context.Context, al actorLookup, base *MiningBase, msgs
 		from := msg.Message.From
 
 		if _, ok := inclNonces[from]; !ok {
-			act, err := al(ctx, from, base.ts)
+			act, err := al(ctx, from, ts)
 			if err != nil {
 				log.Warnf("failed to check message sender balance, skipping message: %+v", err)
 				continue

miner/miner_test.go

@@ -80,7 +80,7 @@ func TestMessageFiltering(t *testing.T) {
 		},
 	}
 
-	outmsgs, err := selectMessages(ctx, af, &MiningBase{}, wrapMsgs(msgs))
+	outmsgs, err := SelectMessages(ctx, af, nil, wrapMsgs(msgs))
 	if err != nil {
 		t.Fatal(err)
 	}

miner/testminer.go

@@ -6,14 +6,21 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/gen"
+	lru "github.com/hashicorp/golang-lru"
 )
 
 func NewTestMiner(nextCh <-chan struct{}, addr address.Address) func(api.FullNode, gen.ElectionPoStProver) *Miner {
 	return func(api api.FullNode, epp gen.ElectionPoStProver) *Miner {
+		arc, err := lru.NewARC(10000)
+		if err != nil {
+			panic(err)
+		}
+
 		m := &Miner{
-			api:      api,
-			waitFunc: chanWaiter(nextCh),
-			epp:      epp,
+			api:               api,
+			waitFunc:          chanWaiter(nextCh),
+			epp:               epp,
+			minedBlockHeights: arc,
 		}
 
 		if err := m.Register(addr); err != nil {

node/builder.go

@@ -50,6 +50,7 @@ import (
 	"github.com/filecoin-project/lotus/paych"
 	"github.com/filecoin-project/lotus/peermgr"
 	"github.com/filecoin-project/lotus/storage"
+	"github.com/filecoin-project/lotus/storage/sealing"
 	"github.com/filecoin-project/lotus/storage/sectorblocks"
 )
 
@@ -245,7 +246,7 @@ func Online() Option {
 		ApplyIf(func(s *Settings) bool { return s.nodeType == repo.StorageMiner },
 			Override(new(sectorbuilder.Interface), modules.SectorBuilder),
 			Override(new(*sectorblocks.SectorBlocks), sectorblocks.NewSectorBlocks),
-			Override(new(storage.TicketFn), modules.SealTicketGen),
+			Override(new(sealing.TicketFn), modules.SealTicketGen),
 			Override(new(*storage.Miner), modules.StorageMiner),
 
 			Override(new(dtypes.StagingBlockstore), modules.StagingBlockstore),

node/impl/full/chain.go

@@ -83,6 +83,10 @@ func (a *ChainAPI) ChainGetBlockMessages(ctx context.Context, msg cid.Cid) (*api
 	}, nil
 }
 
+func (a *ChainAPI) ChainGetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*store.HeadChange, error) {
+	return a.Chain.GetPath(ctx, from, to)
+}
+
 func (a *ChainAPI) ChainGetParentMessages(ctx context.Context, bcid cid.Cid) ([]api.Message, error) {
 	b, err := a.Chain.GetBlock(bcid)
 	if err != nil {

node/impl/full/state.go

@@ -400,3 +400,7 @@ func (a *StateAPI) StateListMessages(ctx context.Context, match *types.Message,
 
 	return out, nil
 }
+
+func (a *StateAPI) StateCompute(ctx context.Context, height uint64, msgs []*types.Message, ts *types.TipSet) (cid.Cid, error) {
+	return stmgr.ComputeState(ctx, a.StateManager, height, msgs, ts)
+}

node/impl/storminer.go

@@ -206,7 +206,7 @@ func (sm *StorageMinerAPI) SectorsRefs(context.Context) (map[string][]api.Sealed
 }
 
 func (sm *StorageMinerAPI) SectorsUpdate(ctx context.Context, id uint64, state api.SectorState) error {
-	return sm.Miner.UpdateSectorState(ctx, id, storage.NonceIncrement, state)
+	return sm.Miner.ForceSectorState(ctx, id, state)
 }
 
 func (sm *StorageMinerAPI) WorkerQueue(ctx context.Context, cfg sectorbuilder.WorkerCfg) (<-chan sectorbuilder.WorkerTask, error) {

node/modules/storageminer.go

@@ -5,7 +5,16 @@ import (
 	"math"
 	"reflect"
 
+	"github.com/filecoin-project/go-address"
+	dtgraphsync "github.com/filecoin-project/go-data-transfer/impl/graphsync"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	retrievalimpl "github.com/filecoin-project/go-fil-markets/retrievalmarket/impl"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	deals "github.com/filecoin-project/go-fil-markets/storagemarket/impl"
+	storageimpl "github.com/filecoin-project/go-fil-markets/storagemarket/impl"
 	paramfetch "github.com/filecoin-project/go-paramfetch"
+	"github.com/filecoin-project/go-sectorbuilder"
+	"github.com/filecoin-project/go-statestore"
 	"github.com/ipfs/go-bitswap"
 	"github.com/ipfs/go-bitswap/network"
 	"github.com/ipfs/go-blockservice"
@@ -23,25 +32,16 @@ import (
 	"go.uber.org/fx"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-address"
-	dtgraphsync "github.com/filecoin-project/go-data-transfer/impl/graphsync"
-	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
-	retrievalimpl "github.com/filecoin-project/go-fil-markets/retrievalmarket/impl"
-	"github.com/filecoin-project/go-fil-markets/storagemarket"
-	deals "github.com/filecoin-project/go-fil-markets/storagemarket/impl"
-	storageimpl "github.com/filecoin-project/go-fil-markets/storagemarket/impl"
-	"github.com/filecoin-project/go-sectorbuilder"
-	"github.com/filecoin-project/go-statestore"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/gen"
+	"github.com/filecoin-project/lotus/markets/retrievaladapter"
 	"github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/modules/helpers"
 	"github.com/filecoin-project/lotus/node/repo"
-
-	"github.com/filecoin-project/lotus/markets/retrievaladapter"
 	"github.com/filecoin-project/lotus/storage"
+	"github.com/filecoin-project/lotus/storage/sealing"
 	"github.com/filecoin-project/lotus/storage/sectorblocks"
 )
 
@@ -98,7 +98,7 @@ func SectorBuilderConfig(storagePath string, threads uint, noprecommit, nocommit
 	}
 }
 
-func StorageMiner(mctx helpers.MetricsCtx, lc fx.Lifecycle, api api.FullNode, h host.Host, ds dtypes.MetadataDS, sb sectorbuilder.Interface, tktFn storage.TicketFn) (*storage.Miner, error) {
+func StorageMiner(mctx helpers.MetricsCtx, lc fx.Lifecycle, api api.FullNode, h host.Host, ds dtypes.MetadataDS, sb sectorbuilder.Interface, tktFn sealing.TicketFn) (*storage.Miner, error) {
 	maddr, err := minerAddrFromDS(ds)
 	if err != nil {
 		return nil, err
@@ -241,7 +241,7 @@ func SectorBuilder(cfg *sectorbuilder.Config, ds dtypes.MetadataDS) (*sectorbuil
 	return sb, nil
 }
 
-func SealTicketGen(api api.FullNode) storage.TicketFn {
+func SealTicketGen(api api.FullNode) sealing.TicketFn {
 	return func(ctx context.Context) (*sectorbuilder.SealTicket, error) {
 		ts, err := api.ChainHead(ctx)
 		if err != nil {

storage/miner.go

@@ -5,45 +5,39 @@ import (
 	"errors"
 	"time"
 
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-sectorbuilder"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/namespace"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/libp2p/go-libp2p-core/host"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-sectorbuilder"
-	"github.com/filecoin-project/go-statestore"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/events"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/storage/sealing"
 )
 
 var log = logging.Logger("storageminer")
 
-const SectorStorePrefix = "/sectors"
-
 type Miner struct {
-	api    storageMinerApi
-	events *events.Events
-	h      host.Host
+	api   storageMinerApi
+	h     host.Host
+	sb    sectorbuilder.Interface
+	ds    datastore.Batching
+	tktFn sealing.TicketFn
 
 	maddr  address.Address
 	worker address.Address
 
-	// Sealing
-	sb      sectorbuilder.Interface
-	sectors *statestore.StateStore
-	tktFn   TicketFn
+	sealing *sealing.Sealing
 
-	sectorIncoming chan *SectorInfo
-	sectorUpdated  chan sectorUpdate
-	stop           chan struct{}
-	stopped        chan struct{}
+	stop    chan struct{}
+	stopped chan struct{}
 }
 
 type storageMinerApi interface {
@@ -71,22 +65,21 @@ type storageMinerApi interface {
 	WalletHas(context.Context, address.Address) (bool, error)
 }
 
-func NewMiner(api storageMinerApi, addr address.Address, h host.Host, ds datastore.Batching, sb sectorbuilder.Interface, tktFn TicketFn) (*Miner, error) {
-	return &Miner{
-		api: api,
-
-		maddr: addr,
+func NewMiner(api storageMinerApi, addr address.Address, h host.Host, ds datastore.Batching, sb sectorbuilder.Interface, tktFn sealing.TicketFn) (*Miner, error) {
+	m := &Miner{
+		api:   api,
 		h:     h,
 		sb:    sb,
+		ds:    ds,
 		tktFn: tktFn,
 
-		sectors: statestore.New(namespace.Wrap(ds, datastore.NewKey(SectorStorePrefix))),
+		maddr: addr,
 
-		sectorIncoming: make(chan *SectorInfo),
-		sectorUpdated:  make(chan sectorUpdate),
-		stop:           make(chan struct{}),
-		stopped:        make(chan struct{}),
-	}, nil
+		stop:    make(chan struct{}),
+		stopped: make(chan struct{}),
+	}
+
+	return m, nil
 }
 
 func (m *Miner) Run(ctx context.Context) error {
@@ -94,25 +87,25 @@ func (m *Miner) Run(ctx context.Context) error {
 		return xerrors.Errorf("miner preflight checks failed: %w", err)
 	}
 
-	m.events = events.NewEvents(ctx, m.api)
-
 	fps := &fpostScheduler{
-		api:    m.api,
-		sb:     m.sb,
+		api: m.api,
+		sb:  m.sb,
+
 		actor:  m.maddr,
 		worker: m.worker,
 	}
 
 	go fps.run(ctx)
-	if err := m.sectorStateLoop(ctx); err != nil {
-		log.Errorf("%+v", err)
-		return xerrors.Errorf("failed to startup sector state loop: %w", err)
-	}
+
+	evts := events.NewEvents(ctx, m.api)
+	m.sealing = sealing.New(m.api, evts, m.maddr, m.worker, m.ds, m.sb, m.tktFn)
 
 	return nil
 }
 
 func (m *Miner) Stop(ctx context.Context) error {
+	defer m.sealing.Stop(ctx)
+
 	close(m.stop)
 	select {
 	case <-m.stopped:

storage/sealing.go

@@ -0,0 +1,35 @@
+package storage
+
+import (
+	"context"
+	"io"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/storage/sealing"
+)
+
+// TODO: refactor this to be direct somehow
+
+func (m *Miner) AllocatePiece(size uint64) (sectorID uint64, offset uint64, err error) {
+	return m.sealing.AllocatePiece(size)
+}
+
+func (m *Miner) SealPiece(ctx context.Context, size uint64, r io.Reader, sectorID uint64, dealID uint64) error {
+	return m.sealing.SealPiece(ctx, size, r, sectorID, dealID)
+}
+
+func (m *Miner) ListSectors() ([]sealing.SectorInfo, error) {
+	return m.sealing.ListSectors()
+}
+
+func (m *Miner) GetSectorInfo(sid uint64) (sealing.SectorInfo, error) {
+	return m.sealing.GetSectorInfo(sid)
+}
+
+func (m *Miner) PledgeSector() error {
+	return m.sealing.PledgeSector()
+}
+
+func (m *Miner) ForceSectorState(ctx context.Context, id uint64, state api.SectorState) error {
+	return m.sealing.ForceSectorState(ctx, id, state)
+}

storage/sealing/cbor_gen.go

@@ -1,4 +1,4 @@
-package storage
+package sealing
 
 import (
 	"fmt"

storage/sealing/fsm.go

@@ -0,0 +1,243 @@
+package sealing
+
+import (
+	"context"
+	"reflect"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/lib/statemachine"
+)
+
+func (m *Sealing) Plan(events []statemachine.Event, user interface{}) (interface{}, error) {
+	next, err := m.plan(events, user.(*SectorInfo))
+	if err != nil || next == nil {
+		return nil, err
+	}
+
+	return func(ctx statemachine.Context, si SectorInfo) error {
+		err := next(ctx, si)
+		if err != nil {
+			if err := ctx.Send(SectorFatalError{error: err}); err != nil {
+				return xerrors.Errorf("error while sending error: reporting %+v: %w", err, err)
+			}
+		}
+
+		return nil
+	}, nil
+}
+
+var fsmPlanners = []func(events []statemachine.Event, state *SectorInfo) error{
+	api.UndefinedSectorState: planOne(on(SectorStart{}, api.Packing)),
+	api.Packing:              planOne(on(SectorPacked{}, api.Unsealed)),
+	api.Unsealed: planOne(
+		on(SectorSealed{}, api.PreCommitting),
+		on(SectorSealFailed{}, api.SealFailed),
+	),
+	api.PreCommitting: planOne(
+		on(SectorPreCommitted{}, api.PreCommitted),
+		on(SectorPreCommitFailed{}, api.PreCommitFailed),
+	),
+	api.PreCommitted: planOne(
+		on(SectorSeedReady{}, api.Committing),
+		on(SectorPreCommitFailed{}, api.PreCommitFailed),
+	),
+	api.Committing: planCommitting,
+	api.CommitWait: planOne(on(SectorProving{}, api.Proving)),
+
+	api.Proving: planOne(
+		on(SectorFaultReported{}, api.FaultReported),
+		on(SectorFaulty{}, api.Faulty),
+	),
+
+	api.Faulty: planOne(
+		on(SectorFaultReported{}, api.FaultReported),
+	),
+	api.FaultedFinal: final,
+}
+
+func (m *Sealing) plan(events []statemachine.Event, state *SectorInfo) (func(statemachine.Context, SectorInfo) error, error) {
+	/////
+	// First process all events
+
+	p := fsmPlanners[state.State]
+	if p == nil {
+		return nil, xerrors.Errorf("planner for state %d not found", state.State)
+	}
+
+	if err := p(events, state); err != nil {
+		return nil, xerrors.Errorf("running planner for state %s failed: %w", api.SectorStates[state.State], err)
+	}
+
+	/////
+	// Now decide what to do next
+
+	/*
+
+		*   Empty
+		|   |
+		|   v
+		*<- Packing <- incoming
+		|   |
+		|   v
+		*<- Unsealed <--> SealFailed
+		|   |
+		|   v
+		*   PreCommitting <--> PreCommitFailed
+		|   |                  ^
+		|   v                  |
+		*<- PreCommitted ------/
+		|   |||
+		|   vvv      v--> SealCommitFailed
+		*<- Committing
+		|   |        ^--> CommitFailed
+		|   v             ^
+		*<- CommitWait ---/
+		|   |
+		|   v
+		*<- Proving
+		|
+		v
+		FailedUnrecoverable
+
+		UndefinedSectorState <- ¯\_(ツ)_/¯
+		    |                     ^
+		    *---------------------/
+
+	*/
+
+	switch state.State {
+	// Happy path
+	case api.Packing:
+		return m.handlePacking, nil
+	case api.Unsealed:
+		return m.handleUnsealed, nil
+	case api.PreCommitting:
+		return m.handlePreCommitting, nil
+	case api.PreCommitted:
+		return m.handlePreCommitted, nil
+	case api.Committing:
+		return m.handleCommitting, nil
+	case api.CommitWait:
+		return m.handleCommitWait, nil
+	case api.Proving:
+		// TODO: track sector health / expiration
+		log.Infof("Proving sector %d", state.SectorID)
+
+	// Handled failure modes
+	case api.SealFailed:
+		log.Warnf("sector %d entered unimplemented state 'SealFailed'", state.SectorID)
+	case api.PreCommitFailed:
+		log.Warnf("sector %d entered unimplemented state 'PreCommitFailed'", state.SectorID)
+	case api.SealCommitFailed:
+		log.Warnf("sector %d entered unimplemented state 'SealCommitFailed'", state.SectorID)
+	case api.CommitFailed:
+		log.Warnf("sector %d entered unimplemented state 'CommitFailed'", state.SectorID)
+
+		// Faults
+	case api.Faulty:
+		return m.handleFaulty, nil
+	case api.FaultReported:
+		return m.handleFaultReported, nil
+
+	// Fatal errors
+	case api.UndefinedSectorState:
+		log.Error("sector update with undefined state!")
+	case api.FailedUnrecoverable:
+		log.Errorf("sector %d failed unrecoverably", state.SectorID)
+	default:
+		log.Errorf("unexpected sector update state: %d", state.State)
+	}
+
+	return nil, nil
+}
+
+func planCommitting(events []statemachine.Event, state *SectorInfo) error {
+	for _, event := range events {
+		switch e := event.User.(type) {
+		case globalMutator:
+			if e.applyGlobal(state) {
+				return nil
+			}
+		case SectorCommitted: // the normal case
+			e.apply(state)
+			state.State = api.CommitWait
+		case SectorSeedReady: // seed changed :/
+			if e.seed.Equals(&state.Seed) {
+				log.Warnf("planCommitting: got SectorSeedReady, but the seed didn't change")
+				continue // or it didn't!
+			}
+			log.Warnf("planCommitting: commit Seed changed")
+			e.apply(state)
+			state.State = api.Committing
+			return nil
+		case SectorSealCommitFailed:
+			state.State = api.SealCommitFailed
+		case SectorSealFailed:
+			state.State = api.CommitFailed
+		default:
+			return xerrors.Errorf("planCommitting got event of unknown type %T, events: %+v", event.User, events)
+		}
+	}
+	return nil
+}
+
+func (m *Sealing) restartSectors(ctx context.Context) error {
+	trackedSectors, err := m.ListSectors()
+	if err != nil {
+		log.Errorf("loading sector list: %+v", err)
+	}
+
+	for _, sector := range trackedSectors {
+		if err := m.sectors.Send(sector.SectorID, SectorRestart{}); err != nil {
+			log.Errorf("restarting sector %d: %+v", sector.SectorID, err)
+		}
+	}
+
+	// TODO: Grab on-chain sector set and diff with trackedSectors
+
+	return nil
+}
+
+func (m *Sealing) ForceSectorState(ctx context.Context, id uint64, state api.SectorState) error {
+	return m.sectors.Send(id, SectorForceState{state})
+}
+
+func final(events []statemachine.Event, state *SectorInfo) error {
+	return xerrors.Errorf("didn't expect any events in state %s, got %+v", api.SectorStates[state.State], events)
+}
+
+func on(mut mutator, next api.SectorState) func() (mutator, api.SectorState) {
+	return func() (mutator, api.SectorState) {
+		return mut, next
+	}
+}
+
+func planOne(ts ...func() (mut mutator, next api.SectorState)) func(events []statemachine.Event, state *SectorInfo) error {
+	return func(events []statemachine.Event, state *SectorInfo) error {
+		if len(events) != 1 {
+			for _, event := range events {
+				if gm, ok := event.User.(globalMutator); !ok {
+					gm.applyGlobal(state)
+					return nil
+				}
+			}
+			return xerrors.Errorf("planner for state %s only has a plan for a single event only, got %+v", api.SectorStates[state.State], events)
+		}
+
+		for _, t := range ts {
+			mut, next := t()
+
+			if reflect.TypeOf(events[0].User) != reflect.TypeOf(mut) {
+				continue
+			}
+
+			events[0].User.(mutator).apply(state)
+			state.State = next
+			return nil
+		}
+
+		return xerrors.Errorf("planner for state %s received unexpected event %+v", events[0])
+	}
+}

storage/sealing/fsm_events.go

@@ -0,0 +1,125 @@
+package sealing
+
+import (
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/api"
+)
+
+type mutator interface {
+	apply(state *SectorInfo)
+}
+
+// globalMutator is an event which can apply in every state
+type globalMutator interface {
+	// applyGlobal applies the event to the state. If if returns true,
+	//  event processing should be interrupted
+	applyGlobal(state *SectorInfo) bool
+}
+
+// Global events
+
+type SectorRestart struct{}
+
+func (evt SectorRestart) applyGlobal(*SectorInfo) bool { return false }
+
+type SectorFatalError struct{ error }
+
+func (evt SectorFatalError) applyGlobal(state *SectorInfo) bool {
+	log.Errorf("Fatal error on sector %d: %+v", state.SectorID, evt.error)
+	// TODO: Do we want to mark the state as unrecoverable?
+	//  I feel like this should be a softer error, where the user would
+	//  be able to send a retry event of some kind
+	return true
+}
+
+type SectorForceState struct {
+	state api.SectorState
+}
+
+func (evt SectorForceState) applyGlobal(state *SectorInfo) bool {
+	state.State = evt.state
+	return true
+}
+
+// Normal path
+
+type SectorStart struct {
+	id     uint64
+	pieces []Piece
+}
+
+func (evt SectorStart) apply(state *SectorInfo) {
+	state.SectorID = evt.id
+	state.Pieces = evt.pieces
+}
+
+type SectorPacked struct{ pieces []Piece }
+
+func (evt SectorPacked) apply(state *SectorInfo) {
+	state.Pieces = append(state.Pieces, evt.pieces...)
+}
+
+type SectorSealed struct {
+	commR  []byte
+	commD  []byte
+	ticket SealTicket
+}
+
+func (evt SectorSealed) apply(state *SectorInfo) {
+	state.CommD = evt.commD
+	state.CommR = evt.commR
+	state.Ticket = evt.ticket
+}
+
+type SectorSealFailed struct{ error }
+
+func (evt SectorSealFailed) apply(*SectorInfo) {}
+
+type SectorPreCommitFailed struct{ error }
+
+func (evt SectorPreCommitFailed) apply(*SectorInfo) {}
+
+type SectorPreCommitted struct {
+	message cid.Cid
+}
+
+func (evt SectorPreCommitted) apply(state *SectorInfo) {
+	state.PreCommitMessage = &evt.message
+}
+
+type SectorSeedReady struct {
+	seed SealSeed
+}
+
+func (evt SectorSeedReady) apply(state *SectorInfo) {
+	state.Seed = evt.seed
+}
+
+type SectorSealCommitFailed struct{ error }
+type SectorCommitFailed struct{ error }
+type SectorCommitted struct {
+	message cid.Cid
+	proof   []byte
+}
+
+func (evt SectorCommitted) apply(state *SectorInfo) {
+	state.Proof = evt.proof
+	state.CommitMessage = &evt.message
+}
+
+type SectorProving struct{}
+
+func (evt SectorProving) apply(*SectorInfo) {}
+
+type SectorFaulty struct{}
+
+func (evt SectorFaulty) apply(state *SectorInfo) {}
+
+type SectorFaultReported struct{ reportMsg cid.Cid }
+
+func (evt SectorFaultReported) apply(state *SectorInfo) {
+	state.FaultReportMsg = &evt.reportMsg
+}
+
+type SectorFaultedFinal struct{}

storage/sealing/fsm_test.go

@@ -0,0 +1,85 @@
+package sealing
+
+import (
+	"testing"
+
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/lib/statemachine"
+)
+
+func init() {
+	_ = logging.SetLogLevel("*", "INFO")
+}
+
+func (t *test) planSingle(evt interface{}) {
+	_, err := t.s.plan([]statemachine.Event{{evt}}, t.state)
+	require.NoError(t.t, err)
+}
+
+type test struct {
+	s     *Sealing
+	t     *testing.T
+	state *SectorInfo
+
+	next func(statemachine.Context, SectorInfo) error
+}
+
+func TestHappyPath(t *testing.T) {
+	m := test{
+		s:     &Sealing{},
+		t:     t,
+		state: &SectorInfo{State: api.Packing},
+	}
+
+	m.planSingle(SectorPacked{})
+	require.Equal(m.t, m.state.State, api.Unsealed)
+
+	m.planSingle(SectorSealed{})
+	require.Equal(m.t, m.state.State, api.PreCommitting)
+
+	m.planSingle(SectorPreCommitted{})
+	require.Equal(m.t, m.state.State, api.PreCommitted)
+
+	m.planSingle(SectorSeedReady{})
+	require.Equal(m.t, m.state.State, api.Committing)
+
+	m.planSingle(SectorCommitted{})
+	require.Equal(m.t, m.state.State, api.CommitWait)
+
+	m.planSingle(SectorProving{})
+	require.Equal(m.t, m.state.State, api.Proving)
+}
+
+func TestSeedRevert(t *testing.T) {
+	m := test{
+		s:     &Sealing{},
+		t:     t,
+		state: &SectorInfo{State: api.Packing},
+	}
+
+	m.planSingle(SectorPacked{})
+	require.Equal(m.t, m.state.State, api.Unsealed)
+
+	m.planSingle(SectorSealed{})
+	require.Equal(m.t, m.state.State, api.PreCommitting)
+
+	m.planSingle(SectorPreCommitted{})
+	require.Equal(m.t, m.state.State, api.PreCommitted)
+
+	m.planSingle(SectorSeedReady{})
+	require.Equal(m.t, m.state.State, api.Committing)
+
+	_, err := m.s.plan([]statemachine.Event{{SectorSeedReady{seed: SealSeed{BlockHeight: 5}}}, {SectorCommitted{}}}, m.state)
+	require.NoError(t, err)
+	require.Equal(m.t, m.state.State, api.Committing)
+
+	// not changing the seed this time
+	_, err = m.s.plan([]statemachine.Event{{SectorSeedReady{seed: SealSeed{BlockHeight: 5}}}, {SectorCommitted{}}}, m.state)
+	require.Equal(m.t, m.state.State, api.CommitWait)
+
+	m.planSingle(SectorProving{})
+	require.Equal(m.t, m.state.State, api.Proving)
+}

storage/sealing/garbage.go

@@ -1,4 +1,4 @@
-package storage
+package sealing
 
 import (
 	"bytes"
@@ -14,7 +14,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
-func (m *Miner) pledgeSector(ctx context.Context, sectorID uint64, existingPieceSizes []uint64, sizes ...uint64) ([]Piece, error) {
+func (m *Sealing) pledgeSector(ctx context.Context, sectorID uint64, existingPieceSizes []uint64, sizes ...uint64) ([]Piece, error) {
 	if len(sizes) == 0 {
 		return nil, nil
 	}
@@ -98,7 +98,7 @@ func (m *Miner) pledgeSector(ctx context.Context, sectorID uint64, existingPiece
 	return out, nil
 }
 
-func (m *Miner) PledgeSector() error {
+func (m *Sealing) PledgeSector() error {
 	go func() {
 		ctx := context.TODO() // we can't use the context from command which invokes
 		// this, as we run everything here async, and it's cancelled when the

storage/sealing/sealing.go

@@ -0,0 +1,134 @@
+package sealing
+
+import (
+	"context"
+	"io"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-sectorbuilder"
+	"github.com/filecoin-project/lotus/lib/padreader"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-datastore"
+	"github.com/ipfs/go-datastore/namespace"
+	logging "github.com/ipfs/go-log/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/events"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/statemachine"
+)
+
+const SectorStorePrefix = "/sectors"
+
+var log = logging.Logger("sectors")
+
+type TicketFn func(context.Context) (*sectorbuilder.SealTicket, error)
+
+type sealingApi interface { // TODO: trim down
+	// Call a read only method on actors (no interaction with the chain required)
+	StateCall(ctx context.Context, msg *types.Message, ts *types.TipSet) (*types.MessageReceipt, error)
+	StateMinerWorker(context.Context, address.Address, *types.TipSet) (address.Address, error)
+	StateMinerElectionPeriodStart(ctx context.Context, actor address.Address, ts *types.TipSet) (uint64, error)
+	StateMinerSectors(context.Context, address.Address, *types.TipSet) ([]*api.ChainSectorInfo, error)
+	StateMinerProvingSet(context.Context, address.Address, *types.TipSet) ([]*api.ChainSectorInfo, error)
+	StateMinerSectorSize(context.Context, address.Address, *types.TipSet) (uint64, error)
+	StateWaitMsg(context.Context, cid.Cid) (*api.MsgWait, error) // TODO: removeme eventually
+	StateGetActor(ctx context.Context, actor address.Address, ts *types.TipSet) (*types.Actor, error)
+	StateGetReceipt(context.Context, cid.Cid, *types.TipSet) (*types.MessageReceipt, error)
+
+	MpoolPushMessage(context.Context, *types.Message) (*types.SignedMessage, error)
+
+	ChainHead(context.Context) (*types.TipSet, error)
+	ChainNotify(context.Context) (<-chan []*store.HeadChange, error)
+	ChainGetRandomness(context.Context, types.TipSetKey, int64) ([]byte, error)
+	ChainGetTipSetByHeight(context.Context, uint64, *types.TipSet) (*types.TipSet, error)
+	ChainGetBlockMessages(context.Context, cid.Cid) (*api.BlockMessages, error)
+
+	WalletSign(context.Context, address.Address, []byte) (*types.Signature, error)
+	WalletBalance(context.Context, address.Address) (types.BigInt, error)
+	WalletHas(context.Context, address.Address) (bool, error)
+}
+
+type Sealing struct {
+	api    sealingApi
+	events *events.Events
+
+	maddr  address.Address
+	worker address.Address
+
+	sb      sectorbuilder.Interface
+	sectors *statemachine.StateGroup
+	tktFn   TicketFn
+}
+
+func New(api sealingApi, events *events.Events, maddr address.Address, worker address.Address, ds datastore.Batching, sb sectorbuilder.Interface, tktFn TicketFn) *Sealing {
+	s := &Sealing{
+		api:    api,
+		events: events,
+
+		maddr:  maddr,
+		worker: worker,
+		sb:     sb,
+		tktFn:  tktFn,
+	}
+
+	s.sectors = statemachine.New(namespace.Wrap(ds, datastore.NewKey(SectorStorePrefix)), s, SectorInfo{})
+
+	return s
+}
+
+func (m *Sealing) Run(ctx context.Context) error {
+	m.events = events.NewEvents(ctx, m.api)
+
+	if err := m.restartSectors(ctx); err != nil {
+		log.Errorf("%+v", err)
+		return xerrors.Errorf("failed load sector states: %w", err)
+	}
+
+	return nil
+}
+
+func (m *Sealing) Stop(ctx context.Context) error {
+	return m.sectors.Stop(ctx)
+}
+
+func (m *Sealing) AllocatePiece(size uint64) (sectorID uint64, offset uint64, err error) {
+	if padreader.PaddedSize(size) != size {
+		return 0, 0, xerrors.Errorf("cannot allocate unpadded piece")
+	}
+
+	sid, err := m.sb.AcquireSectorId() // TODO: Put more than one thing in a sector
+	if err != nil {
+		return 0, 0, xerrors.Errorf("acquiring sector ID: %w", err)
+	}
+
+	// offset hard-coded to 0 since we only put one thing in a sector for now
+	return sid, 0, nil
+}
+
+func (m *Sealing) SealPiece(ctx context.Context, size uint64, r io.Reader, sectorID uint64, dealID uint64) error {
+	log.Infof("Seal piece for deal %d", dealID)
+
+	ppi, err := m.sb.AddPiece(size, sectorID, r, []uint64{})
+	if err != nil {
+		return xerrors.Errorf("adding piece to sector: %w", err)
+	}
+
+	return m.newSector(ctx, sectorID, dealID, ppi)
+}
+
+func (m *Sealing) newSector(ctx context.Context, sid uint64, dealID uint64, ppi sectorbuilder.PublicPieceInfo) error {
+	return m.sectors.Send(sid, SectorStart{
+		id: sid,
+		pieces: []Piece{
+			{
+				DealID: dealID,
+
+				Size:  ppi.Size,
+				CommP: ppi.CommP[:],
+			},
+		},
+	})
+}

storage/sealing/states.go

@@ -0,0 +1,254 @@
+package sealing
+
+import (
+	"context"
+
+	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/statemachine"
+)
+
+func (m *Sealing) handlePacking(ctx statemachine.Context, sector SectorInfo) error {
+	log.Infow("performing filling up rest of the sector...", "sector", sector.SectorID)
+
+	var allocated uint64
+	for _, piece := range sector.Pieces {
+		allocated += piece.Size
+	}
+
+	ubytes := sectorbuilder.UserBytesForSectorSize(m.sb.SectorSize())
+
+	if allocated > ubytes {
+		return xerrors.Errorf("too much data in sector: %d > %d", allocated, ubytes)
+	}
+
+	fillerSizes, err := fillersFromRem(ubytes - allocated)
+	if err != nil {
+		return err
+	}
+
+	if len(fillerSizes) > 0 {
+		log.Warnf("Creating %d filler pieces for sector %d", len(fillerSizes), sector.SectorID)
+	}
+
+	pieces, err := m.pledgeSector(ctx.Context(), sector.SectorID, sector.existingPieces(), fillerSizes...)
+	if err != nil {
+		return xerrors.Errorf("filling up the sector (%v): %w", fillerSizes, err)
+	}
+
+	return ctx.Send(SectorPacked{pieces: pieces})
+}
+
+func (m *Sealing) handleUnsealed(ctx statemachine.Context, sector SectorInfo) error {
+	log.Infow("performing sector replication...", "sector", sector.SectorID)
+	ticket, err := m.tktFn(ctx.Context())
+	if err != nil {
+		return err
+	}
+
+	rspco, err := m.sb.SealPreCommit(ctx.Context(), sector.SectorID, *ticket, sector.pieceInfos())
+	if err != nil {
+		return ctx.Send(SectorSealFailed{xerrors.Errorf("seal pre commit failed: %w", err)})
+	}
+
+	return ctx.Send(SectorSealed{
+		commD: rspco.CommD[:],
+		commR: rspco.CommR[:],
+		ticket: SealTicket{
+			BlockHeight: ticket.BlockHeight,
+			TicketBytes: ticket.TicketBytes[:],
+		},
+	})
+}
+
+func (m *Sealing) handlePreCommitting(ctx statemachine.Context, sector SectorInfo) error {
+	params := &actors.SectorPreCommitInfo{
+		SectorNumber: sector.SectorID,
+
+		CommR:     sector.CommR,
+		SealEpoch: sector.Ticket.BlockHeight,
+		DealIDs:   sector.deals(),
+	}
+	enc, aerr := actors.SerializeParams(params)
+	if aerr != nil {
+		return ctx.Send(SectorPreCommitFailed{xerrors.Errorf("could not serialize commit sector parameters: %w", aerr)})
+	}
+
+	msg := &types.Message{
+		To:       m.maddr,
+		From:     m.worker,
+		Method:   actors.MAMethods.PreCommitSector,
+		Params:   enc,
+		Value:    types.NewInt(0), // TODO: need to ensure sufficient collateral
+		GasLimit: types.NewInt(1000000 /* i dont know help */),
+		GasPrice: types.NewInt(1),
+	}
+
+	log.Info("submitting precommit for sector: ", sector.SectorID)
+	smsg, err := m.api.MpoolPushMessage(ctx.Context(), msg)
+	if err != nil {
+		return ctx.Send(SectorPreCommitFailed{xerrors.Errorf("pushing message to mpool: %w", err)})
+	}
+
+	return ctx.Send(SectorPreCommitted{message: smsg.Cid()})
+}
+
+func (m *Sealing) handlePreCommitted(ctx statemachine.Context, sector SectorInfo) error {
+	// would be ideal to just use the events.Called handler, but it wouldnt be able to handle individual message timeouts
+	log.Info("Sector precommitted: ", sector.SectorID)
+	mw, err := m.api.StateWaitMsg(ctx.Context(), *sector.PreCommitMessage)
+	if err != nil {
+		return ctx.Send(SectorPreCommitFailed{err})
+	}
+
+	if mw.Receipt.ExitCode != 0 {
+		log.Error("sector precommit failed: ", mw.Receipt.ExitCode)
+		err := xerrors.Errorf("sector precommit failed: %d", mw.Receipt.ExitCode)
+		return ctx.Send(SectorPreCommitFailed{err})
+	}
+	log.Info("precommit message landed on chain: ", sector.SectorID)
+
+	randHeight := mw.TipSet.Height() + build.InteractivePoRepDelay - 1 // -1 because of how the messages are applied
+	log.Infof("precommit for sector %d made it on chain, will start proof computation at height %d", sector.SectorID, randHeight)
+
+	err = m.events.ChainAt(func(ectx context.Context, ts *types.TipSet, curH uint64) error {
+		rand, err := m.api.ChainGetRandomness(ectx, ts.Key(), int64(randHeight))
+		if err != nil {
+			err = xerrors.Errorf("failed to get randomness for computing seal proof: %w", err)
+
+			ctx.Send(SectorFatalError{error: err})
+			return err
+		}
+
+		ctx.Send(SectorSeedReady{seed: SealSeed{
+			BlockHeight: randHeight,
+			TicketBytes: rand,
+		}})
+
+		return nil
+	}, func(ctx context.Context, ts *types.TipSet) error {
+		log.Warn("revert in interactive commit sector step")
+		// TODO: need to cancel running process and restart...
+		return nil
+	}, build.InteractivePoRepConfidence, mw.TipSet.Height()+build.InteractivePoRepDelay)
+	if err != nil {
+		log.Warn("waitForPreCommitMessage ChainAt errored: ", err)
+	}
+
+	return nil
+}
+
+func (m *Sealing) handleCommitting(ctx statemachine.Context, sector SectorInfo) error {
+	log.Info("scheduling seal proof computation...")
+
+	proof, err := m.sb.SealCommit(ctx.Context(), sector.SectorID, sector.Ticket.SB(), sector.Seed.SB(), sector.pieceInfos(), sector.rspco())
+	if err != nil {
+		return ctx.Send(SectorSealCommitFailed{xerrors.Errorf("computing seal proof failed: %w", err)})
+	}
+
+	// TODO: Consider splitting states and persist proof for faster recovery
+
+	params := &actors.SectorProveCommitInfo{
+		Proof:    proof,
+		SectorID: sector.SectorID,
+		DealIDs:  sector.deals(),
+	}
+
+	enc, aerr := actors.SerializeParams(params)
+	if aerr != nil {
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("could not serialize commit sector parameters: %w", aerr)})
+	}
+
+	msg := &types.Message{
+		To:       m.maddr,
+		From:     m.worker,
+		Method:   actors.MAMethods.ProveCommitSector,
+		Params:   enc,
+		Value:    types.NewInt(0), // TODO: need to ensure sufficient collateral
+		GasLimit: types.NewInt(1000000 /* i dont know help */),
+		GasPrice: types.NewInt(1),
+	}
+
+	// TODO: check seed / ticket are up to date
+
+	smsg, err := m.api.MpoolPushMessage(ctx.Context(), msg)
+	if err != nil {
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("pushing message to mpool: %w", err)})
+	}
+
+	return ctx.Send(SectorCommitted{
+		proof:   proof,
+		message: smsg.Cid(),
+	})
+}
+
+func (m *Sealing) handleCommitWait(ctx statemachine.Context, sector SectorInfo) error {
+	if sector.CommitMessage == nil {
+		log.Errorf("sector %d entered commit wait state without a message cid", sector.SectorID)
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("entered commit wait with no commit cid")})
+	}
+
+	mw, err := m.api.StateWaitMsg(ctx.Context(), *sector.CommitMessage)
+	if err != nil {
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("failed to wait for porep inclusion: %w", err)})
+	}
+
+	if mw.Receipt.ExitCode != 0 {
+		log.Errorf("UNHANDLED: submitting sector proof failed (exit=%d, msg=%s) (t:%x; s:%x(%d); p:%x)", mw.Receipt.ExitCode, sector.CommitMessage, sector.Ticket.TicketBytes, sector.Seed.TicketBytes, sector.Seed.BlockHeight, sector.Proof)
+		return xerrors.Errorf("UNHANDLED: submitting sector proof failed (exit: %d)", mw.Receipt.ExitCode)
+	}
+
+	return ctx.Send(SectorProving{})
+}
+
+func (m *Sealing) handleFaulty(ctx statemachine.Context, sector SectorInfo) error {
+	// TODO: check if the fault has already been reported, and that this sector is even valid
+
+	// TODO: coalesce faulty sector reporting
+	bf := types.NewBitField()
+	bf.Set(sector.SectorID)
+
+	enc, aerr := actors.SerializeParams(&actors.DeclareFaultsParams{bf})
+	if aerr != nil {
+		return xerrors.Errorf("failed to serialize declare fault params: %w", aerr)
+	}
+
+	msg := &types.Message{
+		To:       m.maddr,
+		From:     m.worker,
+		Method:   actors.MAMethods.DeclareFaults,
+		Params:   enc,
+		Value:    types.NewInt(0), // TODO: need to ensure sufficient collateral
+		GasLimit: types.NewInt(1000000 /* i dont know help */),
+		GasPrice: types.NewInt(1),
+	}
+
+	smsg, err := m.api.MpoolPushMessage(ctx.Context(), msg)
+	if err != nil {
+		return xerrors.Errorf("failed to push declare faults message to network: %w", err)
+	}
+
+	return ctx.Send(SectorFaultReported{reportMsg: smsg.Cid()})
+}
+
+func (m *Sealing) handleFaultReported(ctx statemachine.Context, sector SectorInfo) error {
+	if sector.FaultReportMsg == nil {
+		return xerrors.Errorf("entered fault reported state without a FaultReportMsg cid")
+	}
+
+	mw, err := m.api.StateWaitMsg(ctx.Context(), *sector.FaultReportMsg)
+	if err != nil {
+		return xerrors.Errorf("failed to wait for fault declaration: %w", err)
+	}
+
+	if mw.Receipt.ExitCode != 0 {
+		log.Errorf("UNHANDLED: declaring sector fault failed (exit=%d, msg=%s) (id: %d)", mw.Receipt.ExitCode, *sector.FaultReportMsg, sector.SectorID)
+		return xerrors.Errorf("UNHANDLED: submitting fault declaration failed (exit %d)", mw.Receipt.ExitCode)
+	}
+
+	return ctx.Send(SectorFaultedFinal{})
+}

storage/sealing/types.go

@@ -1,16 +1,12 @@
-package storage
+package sealing
 
 import (
-	"context"
-
 	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
 	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/lotus/api"
 )
 
-type TicketFn func(context.Context) (*sectorbuilder.SealTicket, error)
-
 type SealTicket struct {
 	BlockHeight uint64
 	TicketBytes []byte
@@ -33,6 +29,10 @@ func (t *SealSeed) SB() sectorbuilder.SealSeed {
 	return out
 }
 
+func (t *SealSeed) Equals(o *SealSeed) bool {
+	return string(t.TicketBytes) == string(o.TicketBytes) && t.BlockHeight == o.BlockHeight
+}
+
 type Piece struct {
 	DealID uint64
 
@@ -74,10 +74,8 @@ type SectorInfo struct {
 
 	// Debug
 	LastErr string
-}
 
-func (t *SectorInfo) upd() *sectorUpdate {
-	return &sectorUpdate{id: t.SectorID, nonce: t.Nonce}
+	// TODO: Log []struct{ts, msg, trace string}
 }
 
 func (t *SectorInfo) pieceInfos() []sectorbuilder.PublicPieceInfo {

storage/sealing/types_test.go

@@ -1,4 +1,4 @@
-package storage
+package sealing
 
 import (
 	"bytes"

storage/sealing/utils.go

@@ -1,4 +1,4 @@
-package storage
+package sealing
 
 import (
 	"math/bits"
@@ -42,7 +42,7 @@ func fillersFromRem(toFill uint64) ([]uint64, error) {
 	return out, nil
 }
 
-func (m *Miner) ListSectors() ([]SectorInfo, error) {
+func (m *Sealing) ListSectors() ([]SectorInfo, error) {
 	var sectors []SectorInfo
 	if err := m.sectors.List(&sectors); err != nil {
 		return nil, err
@@ -50,7 +50,7 @@ func (m *Miner) ListSectors() ([]SectorInfo, error) {
 	return sectors, nil
 }
 
-func (m *Miner) GetSectorInfo(sid uint64) (SectorInfo, error) {
+func (m *Sealing) GetSectorInfo(sid uint64) (SectorInfo, error) {
 	var out SectorInfo
 	err := m.sectors.Get(sid).Get(&out)
 	return out, err

storage/sealing/utils_test.go

@@ -1,4 +1,4 @@
-package storage
+package sealing
 
 import (
 	"testing"

storage/sector_states.go

@@ -1,289 +0,0 @@
-package storage
-
-import (
-	"context"
-
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type providerHandlerFunc func(ctx context.Context, deal SectorInfo) *sectorUpdate
-
-func (m *Miner) handleSectorUpdate(ctx context.Context, sector SectorInfo, cb providerHandlerFunc) {
-	go func() {
-		update := cb(ctx, sector)
-
-		if update == nil {
-			return // async
-		}
-
-		select {
-		case m.sectorUpdated <- *update:
-		case <-m.stop:
-		}
-	}()
-}
-
-func (m *Miner) handlePacking(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	log.Infow("performing filling up rest of the sector...", "sector", sector.SectorID)
-
-	var allocated uint64
-	for _, piece := range sector.Pieces {
-		allocated += piece.Size
-	}
-
-	ubytes := sectorbuilder.UserBytesForSectorSize(m.sb.SectorSize())
-
-	if allocated > ubytes {
-		return sector.upd().fatal(xerrors.Errorf("too much data in sector: %d > %d", allocated, ubytes))
-	}
-
-	fillerSizes, err := fillersFromRem(ubytes - allocated)
-	if err != nil {
-		return sector.upd().fatal(err)
-	}
-
-	if len(fillerSizes) > 0 {
-		log.Warnf("Creating %d filler pieces for sector %d", len(fillerSizes), sector.SectorID)
-	}
-
-	pieces, err := m.pledgeSector(ctx, sector.SectorID, sector.existingPieces(), fillerSizes...)
-	if err != nil {
-		return sector.upd().fatal(xerrors.Errorf("filling up the sector (%v): %w", fillerSizes, err))
-	}
-
-	return sector.upd().to(api.Unsealed).state(func(info *SectorInfo) {
-		info.Pieces = append(info.Pieces, pieces...)
-	})
-}
-
-func (m *Miner) handleUnsealed(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	log.Infow("performing sector replication...", "sector", sector.SectorID)
-	ticket, err := m.tktFn(ctx)
-	if err != nil {
-		return sector.upd().fatal(err)
-	}
-
-	rspco, err := m.sb.SealPreCommit(ctx, sector.SectorID, *ticket, sector.pieceInfos())
-	if err != nil {
-		return sector.upd().to(api.SealFailed).error(xerrors.Errorf("seal pre commit failed: %w", err))
-	}
-
-	return sector.upd().to(api.PreCommitting).state(func(info *SectorInfo) {
-		info.CommD = rspco.CommD[:]
-		info.CommR = rspco.CommR[:]
-		info.Ticket = SealTicket{
-			BlockHeight: ticket.BlockHeight,
-			TicketBytes: ticket.TicketBytes[:],
-		}
-	})
-}
-
-func (m *Miner) handlePreCommitting(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	params := &actors.SectorPreCommitInfo{
-		SectorNumber: sector.SectorID,
-
-		CommR:     sector.CommR,
-		SealEpoch: sector.Ticket.BlockHeight,
-		DealIDs:   sector.deals(),
-	}
-	enc, aerr := actors.SerializeParams(params)
-	if aerr != nil {
-		return sector.upd().to(api.PreCommitFailed).error(xerrors.Errorf("could not serialize commit sector parameters: %w", aerr))
-	}
-
-	msg := &types.Message{
-		To:       m.maddr,
-		From:     m.worker,
-		Method:   actors.MAMethods.PreCommitSector,
-		Params:   enc,
-		Value:    types.NewInt(0), // TODO: need to ensure sufficient collateral
-		GasLimit: types.NewInt(1000000 /* i dont know help */),
-		GasPrice: types.NewInt(1),
-	}
-
-	log.Info("submitting precommit for sector: ", sector.SectorID)
-	smsg, err := m.api.MpoolPushMessage(ctx, msg)
-	if err != nil {
-		return sector.upd().to(api.PreCommitFailed).error(xerrors.Errorf("pushing message to mpool: %w", err))
-	}
-
-	return sector.upd().to(api.PreCommitted).state(func(info *SectorInfo) {
-		mcid := smsg.Cid()
-		info.PreCommitMessage = &mcid
-	})
-}
-
-func (m *Miner) handlePreCommitted(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	// would be ideal to just use the events.Called handler, but it wouldnt be able to handle individual message timeouts
-	log.Info("Sector precommitted: ", sector.SectorID)
-	mw, err := m.api.StateWaitMsg(ctx, *sector.PreCommitMessage)
-	if err != nil {
-		return sector.upd().to(api.PreCommitFailed).error(err)
-	}
-
-	if mw.Receipt.ExitCode != 0 {
-		log.Error("sector precommit failed: ", mw.Receipt.ExitCode)
-		err := xerrors.Errorf("sector precommit failed: %d", mw.Receipt.ExitCode)
-		return sector.upd().to(api.PreCommitFailed).error(err)
-	}
-	log.Info("precommit message landed on chain: ", sector.SectorID)
-
-	randHeight := mw.TipSet.Height() + build.InteractivePoRepDelay - 1 // -1 because of how the messages are applied
-	log.Infof("precommit for sector %d made it on chain, will start proof computation at height %d", sector.SectorID, randHeight)
-
-	updateNonce := sector.Nonce
-
-	err = m.events.ChainAt(func(ctx context.Context, ts *types.TipSet, curH uint64) error {
-		rand, err := m.api.ChainGetRandomness(ctx, ts.Key(), int64(randHeight))
-		if err != nil {
-			err = xerrors.Errorf("failed to get randomness for computing seal proof: %w", err)
-
-			m.sectorUpdated <- *sector.upd().fatal(err)
-			return err
-		}
-
-		m.sectorUpdated <- *sector.upd().to(api.Committing).setNonce(updateNonce).state(func(info *SectorInfo) {
-			info.Seed = SealSeed{
-				BlockHeight: randHeight,
-				TicketBytes: rand,
-			}
-		})
-
-		updateNonce++
-
-		return nil
-	}, func(ctx context.Context, ts *types.TipSet) error {
-		log.Warn("revert in interactive commit sector step")
-		// TODO: need to cancel running process and restart...
-		return nil
-	}, build.InteractivePoRepConfidence, mw.TipSet.Height()+build.InteractivePoRepDelay)
-	if err != nil {
-		log.Warn("waitForPreCommitMessage ChainAt errored: ", err)
-	}
-
-	return nil
-}
-
-func (m *Miner) handleCommitting(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	log.Info("scheduling seal proof computation...")
-
-	proof, err := m.sb.SealCommit(ctx, sector.SectorID, sector.Ticket.SB(), sector.Seed.SB(), sector.pieceInfos(), sector.rspco())
-	if err != nil {
-		return sector.upd().to(api.SealCommitFailed).error(xerrors.Errorf("computing seal proof failed: %w", err))
-	}
-
-	// TODO: Consider splitting states and persist proof for faster recovery
-
-	params := &actors.SectorProveCommitInfo{
-		Proof:    proof,
-		SectorID: sector.SectorID,
-		DealIDs:  sector.deals(),
-	}
-
-	enc, aerr := actors.SerializeParams(params)
-	if aerr != nil {
-		return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("could not serialize commit sector parameters: %w", aerr))
-	}
-
-	msg := &types.Message{
-		To:       m.maddr,
-		From:     m.worker,
-		Method:   actors.MAMethods.ProveCommitSector,
-		Params:   enc,
-		Value:    types.NewInt(0), // TODO: need to ensure sufficient collateral
-		GasLimit: types.NewInt(1000000 /* i dont know help */),
-		GasPrice: types.NewInt(1),
-	}
-
-	smsg, err := m.api.MpoolPushMessage(ctx, msg)
-	if err != nil {
-		return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("pushing message to mpool: %w", err))
-	}
-
-	// TODO: Separate state before this wait, so we persist message cid?
-	return sector.upd().to(api.CommitWait).state(func(info *SectorInfo) {
-		mcid := smsg.Cid()
-		info.CommitMessage = &mcid
-		info.Proof = proof
-	})
-}
-
-func (m *Miner) handleCommitWait(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	if sector.CommitMessage == nil {
-		log.Errorf("sector %d entered commit wait state without a message cid", sector.SectorID)
-		return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("entered commit wait with no commit cid"))
-	}
-
-	mw, err := m.api.StateWaitMsg(ctx, *sector.CommitMessage)
-	if err != nil {
-		return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("failed to wait for porep inclusion: %w", err))
-	}
-
-	if mw.Receipt.ExitCode != 0 {
-		log.Errorf("UNHANDLED: submitting sector proof failed (exit=%d, msg=%s) (t:%x; s:%x(%d); p:%x)", mw.Receipt.ExitCode, sector.CommitMessage, sector.Ticket.TicketBytes, sector.Seed.TicketBytes, sector.Seed.BlockHeight, sector.Proof)
-		return sector.upd().fatal(xerrors.Errorf("UNHANDLED: submitting sector proof failed (exit: %d)", mw.Receipt.ExitCode))
-	}
-
-	return sector.upd().to(api.Proving).state(func(info *SectorInfo) {
-	})
-}
-
-func (m *Miner) handleFaulty(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	// TODO: check if the fault has already been reported, and that this sector is even valid
-
-	// TODO: coalesce faulty sector reporting
-	bf := types.NewBitField()
-	bf.Set(sector.SectorID)
-
-	fp := &actors.DeclareFaultsParams{bf}
-	_ = fp
-	enc, aerr := actors.SerializeParams(nil)
-	if aerr != nil {
-		return sector.upd().fatal(xerrors.Errorf("failed to serialize declare fault params: %w", aerr))
-	}
-
-	msg := &types.Message{
-		To:       m.maddr,
-		From:     m.worker,
-		Method:   actors.MAMethods.DeclareFaults,
-		Params:   enc,
-		Value:    types.NewInt(0), // TODO: need to ensure sufficient collateral
-		GasLimit: types.NewInt(1000000 /* i dont know help */),
-		GasPrice: types.NewInt(1),
-	}
-
-	smsg, err := m.api.MpoolPushMessage(ctx, msg)
-	if err != nil {
-		return sector.upd().to(api.FailedUnrecoverable).error(xerrors.Errorf("failed to push declare faults message to network: %w", err))
-	}
-
-	return sector.upd().to(api.FaultReported).state(func(info *SectorInfo) {
-		c := smsg.Cid()
-		info.FaultReportMsg = &c
-	})
-}
-
-func (m *Miner) handleFaultReported(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	if sector.FaultReportMsg == nil {
-		return sector.upd().to(api.FailedUnrecoverable).error(xerrors.Errorf("entered fault reported state without a FaultReportMsg cid"))
-	}
-
-	mw, err := m.api.StateWaitMsg(ctx, *sector.FaultReportMsg)
-	if err != nil {
-		return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("failed to wait for fault declaration: %w", err))
-	}
-
-	if mw.Receipt.ExitCode != 0 {
-		log.Errorf("UNHANDLED: declaring sector fault failed (exit=%d, msg=%s) (id: %d)", mw.Receipt.ExitCode, *sector.FaultReportMsg, sector.SectorID)
-		return sector.upd().fatal(xerrors.Errorf("UNHANDLED: submitting fault declaration failed (exit %d)", mw.Receipt.ExitCode))
-	}
-
-	return sector.upd().to(api.FaultedFinal).state(func(info *SectorInfo) {})
-
-}

storage/sectorblocks/blockstore.go

@@ -2,8 +2,6 @@ package sectorblocks
 
 import (
 	"context"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/storage"
 	"io/ioutil"
 
 	blocks "github.com/ipfs/go-block-format"
@@ -11,6 +9,9 @@ import (
 	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	logging "github.com/ipfs/go-log/v2"
 	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/storage/sealing"
 )
 
 var log = logging.Logger("sectorblocks")
@@ -76,7 +77,7 @@ func (s *SectorBlockStore) Get(c cid.Cid) (blocks.Block, error) {
 
 	// TODO: better strategy (e.g. look for already unsealed)
 	var best api.SealedRef
-	var bestSi storage.SectorInfo
+	var bestSi sealing.SectorInfo
 	for _, r := range refs {
 		si, err := s.sectorBlocks.Miner.GetSectorInfo(r.SectorID)
 		if err != nil {

storage/sectors.go

@@ -1,318 +0,0 @@
-package storage
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"math"
-
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	xerrors "golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/lib/padreader"
-)
-
-const NonceIncrement = math.MaxUint64
-
-type sectorUpdate struct {
-	newState api.SectorState
-	id       uint64
-	err      error
-	nonce    uint64
-	mut      func(*SectorInfo)
-}
-
-func (u *sectorUpdate) fatal(err error) *sectorUpdate {
-	u.newState = api.FailedUnrecoverable
-	u.err = err
-	return u
-}
-
-func (u *sectorUpdate) error(err error) *sectorUpdate {
-	u.err = err
-	return u
-}
-
-func (u *sectorUpdate) state(m func(*SectorInfo)) *sectorUpdate {
-	u.mut = m
-	return u
-}
-
-func (u *sectorUpdate) to(newState api.SectorState) *sectorUpdate {
-	u.newState = newState
-	return u
-}
-
-func (u *sectorUpdate) setNonce(nc uint64) *sectorUpdate {
-	u.nonce = nc
-	return u
-}
-
-func (m *Miner) UpdateSectorState(ctx context.Context, sector uint64, snonce uint64, state api.SectorState) error {
-	select {
-	case m.sectorUpdated <- sectorUpdate{
-		newState: state,
-		nonce:    snonce,
-		id:       sector,
-	}:
-		return nil
-	case <-ctx.Done():
-		return ctx.Err()
-	}
-}
-
-func (m *Miner) sectorStateLoop(ctx context.Context) error {
-	trackedSectors, err := m.ListSectors()
-	if err != nil {
-		log.Errorf("loading sector list: %+v", err)
-	}
-
-	go func() {
-		for _, si := range trackedSectors {
-			select {
-			case m.sectorUpdated <- sectorUpdate{
-				newState: si.State,
-				nonce:    si.Nonce,
-				id:       si.SectorID,
-				err:      nil,
-				mut:      nil,
-			}:
-			case <-ctx.Done():
-				log.Warn("didn't restart processing for all sectors: ", ctx.Err())
-				return
-			}
-		}
-	}()
-
-	{
-		// verify on-chain state
-		trackedByID := map[uint64]*SectorInfo{}
-		for _, si := range trackedSectors {
-			i := si
-			trackedByID[si.SectorID] = &i
-		}
-
-		curTs, err := m.api.ChainHead(ctx)
-		if err != nil {
-			return xerrors.Errorf("getting chain head: %w", err)
-		}
-
-		ps, err := m.api.StateMinerProvingSet(ctx, m.maddr, curTs)
-		if err != nil {
-			return xerrors.Errorf("getting miner proving set: %w", err)
-		}
-		for _, ocs := range ps {
-			if _, ok := trackedByID[ocs.SectorID]; ok {
-				continue // TODO: check state
-			}
-
-			// TODO: attempt recovery
-			log.Warnf("untracked sector %d found on chain", ocs.SectorID)
-		}
-	}
-
-	go func() {
-		defer log.Warn("quitting deal provider loop")
-		defer close(m.stopped)
-
-		for {
-			select {
-			case sector := <-m.sectorIncoming:
-				m.onSectorIncoming(sector)
-			case update := <-m.sectorUpdated:
-				m.onSectorUpdated(ctx, update)
-			case <-m.stop:
-				return
-			}
-		}
-	}()
-
-	return nil
-}
-
-func (m *Miner) onSectorIncoming(sector *SectorInfo) {
-	has, err := m.sectors.Has(sector.SectorID)
-	if err != nil {
-		return
-	}
-	if has {
-		log.Warnf("SealPiece called more than once for sector %d", sector.SectorID)
-		return
-	}
-
-	if err := m.sectors.Begin(sector.SectorID, sector); err != nil {
-		log.Errorf("sector tracking failed: %s", err)
-		return
-	}
-
-	go func() {
-		select {
-		case m.sectorUpdated <- sectorUpdate{
-			newState: api.Packing,
-			id:       sector.SectorID,
-		}:
-		case <-m.stop:
-			log.Warn("failed to send incoming sector update, miner shutting down")
-		}
-	}()
-}
-
-func (m *Miner) onSectorUpdated(ctx context.Context, update sectorUpdate) {
-	log.Infof("Sector %d updated state to %s", update.id, api.SectorStates[update.newState])
-	var sector SectorInfo
-	err := m.sectors.Get(update.id).Mutate(func(s *SectorInfo) error {
-		if update.nonce < s.Nonce {
-			return xerrors.Errorf("update nonce too low, ignoring (%d < %d)", update.nonce, s.Nonce)
-		}
-
-		if update.nonce != NonceIncrement {
-			s.Nonce = update.nonce
-		} else {
-			s.Nonce++ // forced update
-		}
-		s.State = update.newState
-		if update.err != nil {
-			if s.LastErr != "" {
-				s.LastErr += "---------\n\n"
-			}
-			s.LastErr += fmt.Sprintf("entering state %s: %+v", api.SectorStates[update.newState], update.err)
-		}
-
-		if update.mut != nil {
-			update.mut(s)
-		}
-		sector = *s
-		return nil
-	})
-	if update.err != nil {
-		log.Errorf("sector %d failed: %+v", update.id, update.err)
-	}
-	if err != nil {
-		log.Errorf("sector %d update error: %+v", update.id, err)
-		return
-	}
-
-	/*
-
-		*   Empty
-		|   |
-		|   v
-		*<- Packing <- incoming
-		|   |
-		|   v
-		*<- Unsealed <--> SealFailed
-		|   |
-		|   v
-		*   PreCommitting <--> PreCommitFailed
-		|   |                  ^
-		|   v                  |
-		*<- PreCommitted ------/
-		|   |||
-		|   vvv      v--> SealCommitFailed
-		*<- Committing
-		|   |        ^--> CommitFailed
-		|   v             ^
-		*<- CommitWait ---/
-		|   |
-		|   v
-		*<- Proving
-		|
-		v
-		FailedUnrecoverable
-
-		UndefinedSectorState <- ¯\_(ツ)_/¯
-		    |                     ^
-		    *---------------------/
-
-	*/
-
-	switch update.newState {
-	// Happy path
-	case api.Packing:
-		m.handleSectorUpdate(ctx, sector, m.handlePacking)
-	case api.Unsealed:
-		m.handleSectorUpdate(ctx, sector, m.handleUnsealed)
-	case api.PreCommitting:
-		m.handleSectorUpdate(ctx, sector, m.handlePreCommitting)
-	case api.PreCommitted:
-		m.handleSectorUpdate(ctx, sector, m.handlePreCommitted)
-	case api.Committing:
-		m.handleSectorUpdate(ctx, sector, m.handleCommitting)
-	case api.CommitWait:
-		m.handleSectorUpdate(ctx, sector, m.handleCommitWait)
-	case api.Proving:
-		// TODO: track sector health / expiration
-		log.Infof("Proving sector %d", update.id)
-
-	// Handled failure modes
-	case api.SealFailed:
-		log.Warnf("sector %d entered unimplemented state 'SealFailed'", update.id)
-	case api.PreCommitFailed:
-		log.Warnf("sector %d entered unimplemented state 'PreCommitFailed'", update.id)
-	case api.SealCommitFailed:
-		log.Warnf("sector %d entered unimplemented state 'SealCommitFailed'", update.id)
-	case api.CommitFailed:
-		log.Warnf("sector %d entered unimplemented state 'CommitFailed'", update.id)
-
-		// Faults
-	case api.Faulty:
-		m.handleSectorUpdate(ctx, sector, m.handleFaulty)
-	case api.FaultReported:
-		m.handleSectorUpdate(ctx, sector, m.handleFaultReported)
-
-	// Fatal errors
-	case api.UndefinedSectorState:
-		log.Error("sector update with undefined state!")
-	case api.FailedUnrecoverable:
-		log.Errorf("sector %d failed unrecoverably", update.id)
-	default:
-		log.Errorf("unexpected sector update state: %d", update.newState)
-	}
-}
-
-func (m *Miner) AllocatePiece(size uint64) (sectorID uint64, offset uint64, err error) {
-	if padreader.PaddedSize(size) != size {
-		return 0, 0, xerrors.Errorf("cannot allocate unpadded piece")
-	}
-
-	sid, err := m.sb.AcquireSectorId() // TODO: Put more than one thing in a sector
-	if err != nil {
-		return 0, 0, xerrors.Errorf("acquiring sector ID: %w", err)
-	}
-
-	// offset hard-coded to 0 since we only put one thing in a sector for now
-	return sid, 0, nil
-}
-
-func (m *Miner) SealPiece(ctx context.Context, size uint64, r io.Reader, sectorID uint64, dealID uint64) error {
-	log.Infof("Seal piece for deal %d", dealID)
-
-	ppi, err := m.sb.AddPiece(size, sectorID, r, []uint64{})
-	if err != nil {
-		return xerrors.Errorf("adding piece to sector: %w", err)
-	}
-
-	return m.newSector(ctx, sectorID, dealID, ppi)
-}
-
-func (m *Miner) newSector(ctx context.Context, sid uint64, dealID uint64, ppi sectorbuilder.PublicPieceInfo) error {
-	si := &SectorInfo{
-		SectorID: sid,
-
-		Pieces: []Piece{
-			{
-				DealID: dealID,
-
-				Size:  ppi.Size,
-				CommP: ppi.CommP[:],
-			},
-		},
-	}
-	select {
-	case m.sectorIncoming <- si:
-		return nil
-	case <-ctx.Done():
-		return xerrors.Errorf("failed to submit sector for sealing, queue full: %w", ctx.Err())
-	}
-}