miscellaneous fixes post-rebase

api/api_storage.go

@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"context"
 
+	"github.com/filecoin-project/lotus/storage/sealing"
+
 	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/go-address"
@@ -11,38 +13,10 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/abi"
 
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/sector-storage"
+	sectorstorage "github.com/filecoin-project/sector-storage"
 	"github.com/filecoin-project/sector-storage/stores"
 )
 
-type SectorState string
-
-const (
-	UndefinedSectorState SectorState = ""
-
-	// happy path
-	Empty          SectorState = "Empty"
-	Packing        SectorState = "Packing"       // sector not in sealStore, and not on chain
-	PreCommit1     SectorState = "PreCommit1"    // do PreCommit1
-	PreCommit2     SectorState = "PreCommit2"    // do PreCommit1
-	PreCommitting  SectorState = "PreCommitting" // on chain pre-commit
-	WaitSeed       SectorState = "WaitSeed"      // waiting for seed
-	Committing     SectorState = "Committing"
-	CommitWait     SectorState = "CommitWait" // waiting for message to land on chain
-	FinalizeSector SectorState = "FinalizeSector"
-	Proving        SectorState = "Proving"
-	// error modes
-	FailedUnrecoverable SectorState = "FailedUnrecoverable"
-	SealFailed          SectorState = "SealFailed"
-	PreCommitFailed     SectorState = "PreCommitFailed"
-	ComputeProofFailed  SectorState = "ComputeProofFailed"
-	CommitFailed        SectorState = "CommitFailed"
-	PackingFailed       SectorState = "PackingFailed"
-	Faulty              SectorState = "Faulty"        // sector is corrupted or gone for some reason
-	FaultReported       SectorState = "FaultReported" // sector has been declared as a fault on chain
-	FaultedFinal        SectorState = "FaultedFinal"  // fault declared on chain
-)
-
 // StorageMiner is a low-level interface to the Filecoin network storage miner node
 type StorageMiner interface {
 	Common
@@ -62,7 +36,7 @@ type StorageMiner interface {
 
 	SectorsRefs(context.Context) (map[string][]SealedRef, error)
 
-	SectorsUpdate(context.Context, abi.SectorNumber, SectorState) error
+	SectorsUpdate(context.Context, abi.SectorNumber, sealing.SectorState) error
 
 	StorageList(ctx context.Context) (map[stores.ID][]stores.Decl, error)
 	StorageLocal(ctx context.Context) (map[stores.ID]string, error)
@@ -103,7 +77,7 @@ type SectorLog struct {
 
 type SectorInfo struct {
 	SectorID abi.SectorNumber
-	State    SectorState
+	State    sealing.SectorState
 	CommD    *cid.Cid
 	CommR    *cid.Cid
 	Proof    []byte

api/apistruct/struct.go

@@ -3,6 +3,8 @@ package apistruct
 import (
 	"context"
 
+	"github.com/filecoin-project/lotus/storage/sealing"
+
 	"github.com/ipfs/go-cid"
 	"github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -184,7 +186,7 @@ type StorageMinerStruct struct {
 		SectorsStatus func(context.Context, abi.SectorNumber) (api.SectorInfo, error)    `perm:"read"`
 		SectorsList   func(context.Context) ([]abi.SectorNumber, error)                  `perm:"read"`
 		SectorsRefs   func(context.Context) (map[string][]api.SealedRef, error)          `perm:"read"`
-		SectorsUpdate func(context.Context, abi.SectorNumber, api.SectorState) error  `perm:"write"`
+		SectorsUpdate func(context.Context, abi.SectorNumber, sealing.SectorState) error `perm:"write"`
 
 		WorkerConnect func(context.Context, string) error                                 `perm:"admin"` // TODO: worker perm
 		WorkerStats   func(context.Context) (map[uint64]sectorstorage.WorkerStats, error) `perm:"admin"`
@@ -675,7 +677,7 @@ func (c *StorageMinerStruct) SectorsRefs(ctx context.Context) (map[string][]api.
 	return c.Internal.SectorsRefs(ctx)
 }
 
-func (c *StorageMinerStruct) SectorsUpdate(ctx context.Context, id abi.SectorNumber, state api.SectorState) error {
+func (c *StorageMinerStruct) SectorsUpdate(ctx context.Context, id abi.SectorNumber, state sealing.SectorState) error {
 	return c.Internal.SectorsUpdate(ctx, id, state)
 }
 

cmd/lotus-storage-miner/info.go

@@ -11,6 +11,7 @@ import (
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/storage/sealing"
 )
 
 var infoCmd = &cli.Command{
@@ -127,13 +128,13 @@ var infoCmd = &cli.Command{
 	},
 }
 
-func sectorsInfo(ctx context.Context, napi api.StorageMiner) (map[api.SectorState]int, error) {
+func sectorsInfo(ctx context.Context, napi api.StorageMiner) (map[sealing.SectorState]int, error) {
 	sectors, err := napi.SectorsList(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	out := map[api.SectorState]int{
+	out := map[sealing.SectorState]int{
 		"Total": len(sectors),
 	}
 	for _, s := range sectors {

cmd/lotus-storage-miner/init.go

@@ -286,7 +286,7 @@ func migratePreSealMeta(ctx context.Context, api lapi.FullNode, metadata string,
 		commR := sector.CommR
 
 		info := &sealing.SectorInfo{
-			State:    lapi.Proving,
+			State:    sealing.Proving,
 			SectorID: sector.SectorID,
 			Pieces: []sealing.Piece{
 				{

cmd/lotus-storage-miner/sectors.go

@@ -9,12 +9,12 @@ import (
 	"time"
 
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/storage/sealing"
 
 	"github.com/filecoin-project/specs-actors/actors/abi"
 	"golang.org/x/xerrors"
 	"gopkg.in/urfave/cli.v2"
 
-	"github.com/filecoin-project/lotus/api"
 	lcli "github.com/filecoin-project/lotus/cli"
 )
 
@@ -236,7 +236,7 @@ var sectorsUpdateCmd = &cli.Command{
 			return xerrors.Errorf("could not parse sector ID: %w", err)
 		}
 
-		return nodeApi.SectorsUpdate(ctx, abi.SectorNumber(id), api.SectorState(cctx.Args().Get(1)))
+		return nodeApi.SectorsUpdate(ctx, abi.SectorNumber(id), sealing.SectorState(cctx.Args().Get(1)))
 	},
 }
 

go.mod

@@ -82,6 +82,7 @@ require (
 	github.com/libp2p/go-libp2p-tls v0.1.0
 	github.com/libp2p/go-libp2p-yamux v0.2.5
 	github.com/libp2p/go-maddr-filter v0.0.5
+	github.com/mgutz/logxi v0.0.0-20161027140823-aebf8a7d67ab
 	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1
 	github.com/minio/sha256-simd v0.1.1
 	github.com/mitchellh/go-homedir v1.1.0
@@ -91,6 +92,7 @@ require (
 	github.com/multiformats/go-multiaddr-net v0.1.3
 	github.com/multiformats/go-multihash v0.0.13
 	github.com/opentracing/opentracing-go v1.1.0
+	github.com/prometheus/common v0.2.0
 	github.com/stretchr/testify v1.4.0
 	github.com/whyrusleeping/bencher v0.0.0-20190829221104-bb6607aa8bba
 	github.com/whyrusleeping/cbor-gen v0.0.0-20200321164527-9340289d0ca7

go.sum

@@ -644,6 +644,8 @@ github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0j
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
+github.com/mgutz/logxi v0.0.0-20161027140823-aebf8a7d67ab h1:n8cgpHzJ5+EDyDri2s/GC7a9+qK3/YEGnBsd0uS/8PY=
+github.com/mgutz/logxi v0.0.0-20161027140823-aebf8a7d67ab/go.mod h1:y1pL58r5z2VvAjeG1VLGc8zOQgSOzbKN7kMHPvFXJ+8=
 github.com/miekg/dns v1.1.12/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
 github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g=
 github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ=

markets/storageadapter/provider.go

@@ -208,13 +208,13 @@ func (n *ProviderNodeAdapter) LocatePieceForDealWithinSector(ctx context.Context
 		if err != nil {
 			return 0, 0, 0, xerrors.Errorf("getting sector info: %w", err)
 		}
-		if si.State == api.Proving {
+		if si.State == sealing.Proving {
 			best = r
 			bestSi = si
 			break
 		}
 	}
-	if bestSi.State == api.UndefinedSectorState {
+	if bestSi.State == sealing.UndefinedSectorState {
 		return 0, 0, 0, xerrors.New("no sealed sector found")
 	}
 	return uint64(best.SectorID), best.Offset, uint64(best.Size), nil

node/impl/storminer.go

@@ -23,6 +23,7 @@ import (
 	"github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node/impl/common"
 	"github.com/filecoin-project/lotus/storage"
+	"github.com/filecoin-project/lotus/storage/sealing"
 	"github.com/filecoin-project/lotus/storage/sectorblocks"
 )
 
@@ -150,7 +151,7 @@ func (sm *StorageMinerAPI) StorageStat(ctx context.Context, id stores.ID) (store
 	return sm.StorageMgr.FsStat(ctx, id)
 }
 
-func (sm *StorageMinerAPI) SectorsUpdate(ctx context.Context, id abi.SectorNumber, state api.SectorState) error {
+func (sm *StorageMinerAPI) SectorsUpdate(ctx context.Context, id abi.SectorNumber, state sealing.SectorState) error {
 	return sm.Miner.ForceSectorState(ctx, id, state)
 }
 

storage/adapter_storage_miner.go

@@ -34,6 +34,15 @@ func NewSealingAPIAdapter(api storageMinerApi) SealingAPIAdapter {
 	return SealingAPIAdapter{delegate: api}
 }
 
+func (s SealingAPIAdapter) StateMinerSectorSize(ctx context.Context, maddr address.Address, tok sealing.TipSetToken) (abi.SectorSize, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return 0, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
+	}
+
+	return s.delegate.StateMinerSectorSize(ctx, maddr, tsk)
+}
+
 func (s SealingAPIAdapter) StateWaitMsg(ctx context.Context, mcid cid.Cid) (sealing.MsgLookup, error) {
 	wmsg, err := s.delegate.StateWaitMsg(ctx, mcid)
 	if err != nil {

storage/miner.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"time"
 
-	"github.com/filecoin-project/go-address"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
 	logging "github.com/ipfs/go-log/v2"

storage/sealing.go

@@ -2,12 +2,12 @@ package storage
 
 import (
 	"context"
-	"github.com/filecoin-project/go-address"
 	"io"
 
+	"github.com/filecoin-project/go-address"
+
 	"github.com/filecoin-project/specs-actors/actors/abi"
 
-	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/storage/sealing"
 )
 
@@ -37,6 +37,6 @@ func (m *Miner) PledgeSector() error {
 	return m.sealing.PledgeSector()
 }
 
-func (m *Miner) ForceSectorState(ctx context.Context, id abi.SectorNumber, state api.SectorState) error {
+func (m *Miner) ForceSectorState(ctx context.Context, id abi.SectorNumber, state sealing.SectorState) error {
 	return m.sealing.ForceSectorState(ctx, id, state)
 }

storage/sealing/checks.go

@@ -6,13 +6,11 @@ import (
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/sector-storage/zerocomm"
 	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-actors/actors/crypto"
-	log "github.com/mgutz/logxi/v1"
 )
 
 // TODO: For now we handle this by halting state execution, when we get jsonrpc reconnecting
@@ -94,34 +92,34 @@ func checkPrecommit(ctx context.Context, maddr address.Address, si SectorInfo, a
 }
 
 func (m *Sealing) checkCommit(ctx context.Context, si SectorInfo, proof []byte) (err error) {
-	tok, height, err := m.api.ChainHead(ctx)
+	tok, _, err := m.api.ChainHead(ctx)
 	if err != nil {
 		return &ErrApi{xerrors.Errorf("getting chain head: %w", err)}
 	}
 
-	if si.Seed.Epoch == 0 {
+	if si.SeedEpoch == 0 {
 		return &ErrBadSeed{xerrors.Errorf("seed epoch was not set")}
 	}
 
-	pci, err := m.api.StateSectorPreCommitInfo(ctx, m.maddr, si.SectorID, types.EmptyTSK)
+	pci, err := m.api.StateGetSectorPreCommitOnChainInfo(ctx, m.maddr, si.SectorID, tok)
 	if err != nil {
 		return xerrors.Errorf("getting precommit info: %w", err)
 	}
 
-	if pci.PreCommitEpoch+miner.PreCommitChallengeDelay != si.Seed.Epoch {
+	if pci.PreCommitEpoch+miner.PreCommitChallengeDelay != si.SeedEpoch {
-		return &ErrBadSeed{xerrors.Errorf("seed epoch doesn't match on chain info: %d != %d", pci.PreCommitEpoch+miner.PreCommitChallengeDelay, si.Seed.Epoch)}
+		return &ErrBadSeed{xerrors.Errorf("seed epoch doesn't match on chain info: %d != %d", pci.PreCommitEpoch+miner.PreCommitChallengeDelay, si.SeedEpoch)}
 	}
 
-	seed, err := m.api.ChainGetRandomness(ctx, head.Key(), crypto.DomainSeparationTag_InteractiveSealChallengeSeed, si.Seed.Epoch, nil)
+	seed, err := m.api.ChainGetRandomness(ctx, tok, crypto.DomainSeparationTag_InteractiveSealChallengeSeed, si.SeedEpoch, nil)
 	if err != nil {
 		return &ErrApi{xerrors.Errorf("failed to get randomness for computing seal proof: %w", err)}
 	}
 
-	if string(seed) != string(si.Seed.Value) {
+	if string(seed) != string(si.SeedValue) {
 		return &ErrBadSeed{xerrors.Errorf("seed has changed")}
 	}
 
-	ss, err := m.api.StateMinerSectorSize(ctx, m.maddr, head.Key())
+	ss, err := m.api.StateMinerSectorSize(ctx, m.maddr, tok)
 	if err != nil {
 		return &ErrApi{err}
 	}
@@ -138,14 +136,14 @@ func (m *Sealing) checkCommit(ctx context.Context, si SectorInfo, proof []byte)
 		SectorID: m.minerSector(si.SectorID),
 		OnChain: abi.OnChainSealVerifyInfo{
 			SealedCID:        pci.Info.SealedCID,
-			InteractiveEpoch: si.Seed.Epoch,
+			InteractiveEpoch: si.SeedEpoch,
 			RegisteredProof:  spt,
 			Proof:            proof,
 			SectorNumber:     si.SectorID,
-			SealRandEpoch:    si.Ticket.Epoch,
+			SealRandEpoch:    si.TicketEpoch,
 		},
-		Randomness:            si.Ticket.Value,
+		Randomness:            si.TicketValue,
-		InteractiveRandomness: si.Seed.Value,
+		InteractiveRandomness: si.SeedValue,
 		UnsealedCID:           *si.CommD,
 	})
 	if err != nil {

storage/sealing/fsm.go

@@ -11,9 +11,7 @@ import (
 	"golang.org/x/xerrors"
 
 	statemachine "github.com/filecoin-project/go-statemachine"
-	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/prometheus/common/log"
 )
 
 func (m *Sealing) Plan(events []statemachine.Event, user interface{}) (interface{}, uint64, error) {
@@ -33,27 +31,27 @@ func (m *Sealing) Plan(events []statemachine.Event, user interface{}) (interface
 	}, uint64(len(events)), nil // TODO: This processed event count is not very correct
 }
 
-var fsmPlanners = map[api.SectorState]func(events []statemachine.Event, state *SectorInfo) error{
+var fsmPlanners = map[SectorState]func(events []statemachine.Event, state *SectorInfo) error{
-	api.UndefinedSectorState: planOne(on(SectorStart{}, api.Packing)),
+	UndefinedSectorState: planOne(on(SectorStart{}, Packing)),
-	api.Packing:              planOne(on(SectorPacked{}, api.PreCommit1)),
+	Packing:              planOne(on(SectorPacked{}, PreCommit1)),
-	api.PreCommit1: planOne(
+	PreCommit1: planOne(
-		on(SectorPreCommit1{}, api.PreCommit2),
+		on(SectorPreCommit1{}, PreCommit2),
-		on(SectorSealPreCommitFailed{}, api.SealFailed),
+		on(SectorSealPreCommitFailed{}, SealFailed),
-		on(SectorPackingFailed{}, api.PackingFailed),
+		on(SectorPackingFailed{}, PackingFailed),
 	),
-	api.PreCommit2: planOne(
+	PreCommit2: planOne(
-		on(SectorPreCommit2{}, api.PreCommitting),
+		on(SectorPreCommit2{}, PreCommitting),
-		on(SectorSealPreCommitFailed{}, api.SealFailed),
+		on(SectorSealPreCommitFailed{}, SealFailed),
-		on(SectorPackingFailed{}, api.PackingFailed),
+		on(SectorPackingFailed{}, PackingFailed),
 	),
-	api.PreCommitting: planOne(
+	PreCommitting: planOne(
-		on(SectorSealPreCommitFailed{}, api.SealFailed),
+		on(SectorSealPreCommitFailed{}, SealFailed),
-		on(SectorPreCommitted{}, api.WaitSeed),
+		on(SectorPreCommitted{}, WaitSeed),
-		on(SectorChainPreCommitFailed{}, api.PreCommitFailed),
+		on(SectorChainPreCommitFailed{}, PreCommitFailed),
 	),
-	api.WaitSeed: planOne(
+	WaitSeed: planOne(
-		on(SectorSeedReady{}, api.Committing),
+		on(SectorSeedReady{}, Committing),
-		on(SectorChainPreCommitFailed{}, api.PreCommitFailed),
+		on(SectorChainPreCommitFailed{}, PreCommitFailed),
 	),
 	Committing: planCommitting,
 	CommitWait: planOne(
@@ -70,22 +68,22 @@ var fsmPlanners = map[api.SectorState]func(events []statemachine.Event, state *S
 		on(SectorFaulty{}, Faulty),
 	),
 
-	api.SealFailed: planOne(
+	SealFailed: planOne(
-		on(SectorRetrySeal{}, api.PreCommit1),
+		on(SectorRetrySeal{}, PreCommit1),
 	),
-	api.PreCommitFailed: planOne(
+	PreCommitFailed: planOne(
-		on(SectorRetryPreCommit{}, api.PreCommitting),
+		on(SectorRetryPreCommit{}, PreCommitting),
-		on(SectorRetryWaitSeed{}, api.WaitSeed),
+		on(SectorRetryWaitSeed{}, WaitSeed),
-		on(SectorSealPreCommitFailed{}, api.SealFailed),
+		on(SectorSealPreCommitFailed{}, SealFailed),
 	),
-	api.ComputeProofFailed: planOne(
+	ComputeProofFailed: planOne(
-		on(SectorRetryComputeProof{}, api.Committing),
+		on(SectorRetryComputeProof{}, Committing),
 	),
-	api.CommitFailed: planOne(
+	CommitFailed: planOne(
-		on(SectorSealPreCommitFailed{}, api.SealFailed),
+		on(SectorSealPreCommitFailed{}, SealFailed),
-		on(SectorRetryWaitSeed{}, api.WaitSeed),
+		on(SectorRetryWaitSeed{}, WaitSeed),
-		on(SectorRetryComputeProof{}, api.Committing),
+		on(SectorRetryComputeProof{}, Committing),
-		on(SectorRetryInvalidProof{}, api.Committing),
+		on(SectorRetryInvalidProof{}, Committing),
 	),
 
 	Faulty: planOne(
@@ -173,11 +171,11 @@ func (m *Sealing) plan(events []statemachine.Event, state *SectorInfo) (func(sta
 	// Happy path
 	case Packing:
 		return m.handlePacking, nil
-	case api.PreCommit1:
+	case PreCommit1:
 		return m.handlePreCommit1, nil
-	case api.PreCommit2:
+	case PreCommit2:
 		return m.handlePreCommit2, nil
-	case api.PreCommitting:
+	case PreCommitting:
 		return m.handlePreCommitting, nil
 	case WaitSeed:
 		return m.handleWaitSeed, nil
@@ -196,9 +194,9 @@ func (m *Sealing) plan(events []statemachine.Event, state *SectorInfo) (func(sta
 		return m.handleSealFailed, nil
 	case PreCommitFailed:
 		return m.handlePreCommitFailed, nil
-	case api.ComputeProofFailed:
+	case ComputeProofFailed:
 		return m.handleComputeProofFailed, nil
-	case api.CommitFailed:
+	case CommitFailed:
 		return m.handleCommitFailed, nil
 
 		// Faults
@@ -239,9 +237,9 @@ func planCommitting(events []statemachine.Event, state *SectorInfo) error {
 			state.State = Committing
 			return nil
 		case SectorComputeProofFailed:
-			state.State = api.ComputeProofFailed
+			state.State = ComputeProofFailed
 		case SectorSealPreCommitFailed:
-			state.State = api.CommitFailed
+			state.State = CommitFailed
 		case SectorCommitFailed:
 			state.State = CommitFailed
 		default:

storage/sealing/fsm_events.go

@@ -4,10 +4,7 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-storage/storage"
 	"github.com/ipfs/go-cid"
-	"github.com/prometheus/common/log"
 	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/specs-actors/actors/abi"
 )
 
 type mutator interface {

storage/sealing/fsm_test.go

@@ -7,7 +7,6 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/filecoin-project/go-statemachine"
-	"github.com/filecoin-project/lotus/api"
 )
 
 func init() {
@@ -35,13 +34,13 @@ func TestHappyPath(t *testing.T) {
 	}
 
 	m.planSingle(SectorPacked{})
-	require.Equal(m.t, m.state.State, api.PreCommit1)
+	require.Equal(m.t, m.state.State, PreCommit1)
 
 	m.planSingle(SectorPreCommit1{})
-	require.Equal(m.t, m.state.State, api.PreCommit2)
+	require.Equal(m.t, m.state.State, PreCommit2)
 
 	m.planSingle(SectorPreCommit2{})
-	require.Equal(m.t, m.state.State, api.PreCommitting)
+	require.Equal(m.t, m.state.State, PreCommitting)
 
 	m.planSingle(SectorPreCommitted{})
 	require.Equal(m.t, m.state.State, WaitSeed)
@@ -67,13 +66,13 @@ func TestSeedRevert(t *testing.T) {
 	}
 
 	m.planSingle(SectorPacked{})
-	require.Equal(m.t, m.state.State, api.PreCommit1)
+	require.Equal(m.t, m.state.State, PreCommit1)
 
 	m.planSingle(SectorPreCommit1{})
-	require.Equal(m.t, m.state.State, api.PreCommit2)
+	require.Equal(m.t, m.state.State, PreCommit2)
 
 	m.planSingle(SectorPreCommit2{})
-	require.Equal(m.t, m.state.State, api.PreCommitting)
+	require.Equal(m.t, m.state.State, PreCommitting)
 
 	m.planSingle(SectorPreCommitted{})
 	require.Equal(m.t, m.state.State, WaitSeed)
@@ -81,12 +80,12 @@ func TestSeedRevert(t *testing.T) {
 	m.planSingle(SectorSeedReady{})
 	require.Equal(m.t, m.state.State, Committing)
 
-	_, err := m.s.plan([]statemachine.Event{{SectorSeedReady{Seed: SealSeed{Epoch: 5}}}, {SectorCommitted{}}}, m.state)
+	_, err := m.s.plan([]statemachine.Event{{SectorSeedReady{SeedValue: nil, SeedEpoch: 5}}, {SectorCommitted{}}}, m.state)
 	require.NoError(t, err)
 	require.Equal(m.t, m.state.State, Committing)
 
 	// not changing the seed this time
-	_, err = m.s.plan([]statemachine.Event{{SectorSeedReady{Seed: SealSeed{Epoch: 5}}}, {SectorCommitted{}}}, m.state)
+	_, err = m.s.plan([]statemachine.Event{{SectorSeedReady{SeedValue: nil, SeedEpoch: 5}}, {SectorCommitted{}}}, m.state)
 	require.Equal(m.t, m.state.State, CommitWait)
 
 	m.planSingle(SectorProving{})
@@ -107,5 +106,5 @@ func TestPlanCommittingHandlesSectorCommitFailed(t *testing.T) {
 
 	require.NoError(t, planCommitting(events, m.state))
 
-	require.Equal(t, api.CommitFailed, m.state.State)
+	require.Equal(t, CommitFailed, m.state.State)
 }

storage/sealing/sealing.go

@@ -1,7 +1,6 @@
 package sealing
 
 import (
-	"bytes"
 	"context"
 	"io"
 
@@ -21,46 +20,17 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin/market"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-actors/actors/crypto"
-	"github.com/filecoin-project/specs-actors/actors/runtime/exitcode"
 )
 
 const SectorStorePrefix = "/sectors"
 
 var log = logging.Logger("sectors")
 
-type TicketFn func(context.Context) (abi.SealRandomness, abi.ChainEpoch, error)
-
-type SectorIDCounter interface {
-	Next() (abi.SectorNumber, error)
-}
-
-type TipSetToken []byte
-
-type MsgLookup struct {
-	Receipt   MessageReceipt
-	TipSetTok TipSetToken
-	Height    abi.ChainEpoch
-}
-
-type MessageReceipt struct {
-	ExitCode exitcode.ExitCode
-	Return   []byte
-	GasUsed  int64
-}
-
-func (mr *MessageReceipt) Equals(o *MessageReceipt) bool {
-	return mr.ExitCode == o.ExitCode && bytes.Equal(mr.Return, o.Return) && mr.GasUsed == o.GasUsed
-}
-
-type MarketDeal struct {
-	Proposal market.DealProposal
-	State    market.DealState
-}
-
 type SealingAPI interface {
 	StateWaitMsg(context.Context, cid.Cid) (MsgLookup, error)
 	StateComputeDataCommitment(ctx context.Context, maddr address.Address, sectorType abi.RegisteredProof, deals []abi.DealID, tok TipSetToken) (cid.Cid, error)
 	StateGetSectorPreCommitOnChainInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok TipSetToken) (*miner.SectorPreCommitOnChainInfo, error)
+	StateMinerSectorSize(context.Context, address.Address, TipSetToken) (abi.SectorSize, error)
 	StateMarketStorageDeal(context.Context, abi.DealID, TipSetToken) (market.DealProposal, market.DealState, error)
 	SendMsg(ctx context.Context, from, to address.Address, method abi.MethodNum, value, gasPrice big.Int, gasLimit int64, params []byte) (cid.Cid, error)
 	ChainHead(ctx context.Context) (TipSetToken, abi.ChainEpoch, error)

storage/sealing/sector_state.go

@@ -1,74 +1,29 @@
 package sealing
 
-// alias because cbor-gen doesn't like non-alias types
+type SectorState string
-type SectorState = uint64
 
 const (
-	UndefinedSectorState SectorState = iota
+	UndefinedSectorState SectorState = ""
 
 	// happy path
-	Empty
+	Empty          SectorState = "Empty"
-	Packing // sector not in sealStore, and not on chain
+	Packing        SectorState = "Packing"       // sector not in sealStore, and not on chain
-
+	PreCommit1     SectorState = "PreCommit1"    // do PreCommit1
-	Unsealed      // sealing / queued
+	PreCommit2     SectorState = "PreCommit2"    // do PreCommit1
-	PreCommitting // on chain pre-commit
+	PreCommitting  SectorState = "PreCommitting" // on chain pre-commit
-	WaitSeed      // waiting for seed
+	WaitSeed       SectorState = "WaitSeed"      // waiting for seed
-	Committing
+	Committing     SectorState = "Committing"
-	CommitWait // waiting for message to land on chain
+	CommitWait     SectorState = "CommitWait" // waiting for message to land on chain
-	FinalizeSector
+	FinalizeSector SectorState = "FinalizeSector"
-	Proving
+	Proving        SectorState = "Proving"
-	_ // reserved
-	_
-	_
-
-	// recovery handling
-	// Reseal
-	_
-	_
-	_
-	_
-	_
-	_
-	_
-
 	// error modes
-	FailedUnrecoverable
+	FailedUnrecoverable SectorState = "FailedUnrecoverable"
-
+	SealFailed          SectorState = "SealFailed"
-	SealFailed
+	PreCommitFailed     SectorState = "PreCommitFailed"
-	PreCommitFailed
+	ComputeProofFailed  SectorState = "ComputeProofFailed"
-	SealCommitFailed
+	CommitFailed        SectorState = "CommitFailed"
-	CommitFailed
+	PackingFailed       SectorState = "PackingFailed"
-	PackingFailed
+	Faulty              SectorState = "Faulty"        // sector is corrupted or gone for some reason
-	_
+	FaultReported       SectorState = "FaultReported" // sector has been declared as a fault on chain
-	_
+	FaultedFinal        SectorState = "FaultedFinal"  // fault declared on chain
-	_
-
-	Faulty        // sector is corrupted or gone for some reason
-	FaultReported // sector has been declared as a fault on chain
-	FaultedFinal  // fault declared on chain
 )
-
-var SectorStates = []string{
-	UndefinedSectorState: "UndefinedSectorState",
-	Empty:                "Empty",
-	Packing:              "Packing",
-	Unsealed:             "Unsealed",
-	PreCommitting:        "PreCommitting",
-	WaitSeed:             "WaitSeed",
-	Committing:           "Committing",
-	CommitWait:           "CommitWait",
-	FinalizeSector:       "FinalizeSector",
-	Proving:              "Proving",
-
-	SealFailed:       "SealFailed",
-	PreCommitFailed:  "PreCommitFailed",
-	SealCommitFailed: "SealCommitFailed",
-	CommitFailed:     "CommitFailed",
-	PackingFailed:    "PackingFailed",
-
-	FailedUnrecoverable: "FailedUnrecoverable",
-
-	Faulty:        "Faulty",
-	FaultReported: "FaultReported",
-	FaultedFinal:  "FaultedFinal",
-}

storage/sealing/states.go

@@ -6,8 +6,7 @@ import (
 
 	"golang.org/x/xerrors"
 
-	statemachine "github.com/filecoin-project/go-statemachine"
+	"github.com/filecoin-project/go-statemachine"
-	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
@@ -146,7 +145,7 @@ func (m *Sealing) handleWaitSeed(ctx statemachine.Context, sector SectorInfo) er
 	}
 	log.Info("precommit message landed on chain: ", sector.SectorID)
 
-	pci, err := m.api.StateSectorPreCommitInfo(ctx.Context(), m.maddr, sector.SectorID, mw.TipSet.Key())
+	pci, err := m.api.StateGetSectorPreCommitOnChainInfo(ctx.Context(), m.maddr, sector.SectorID, mw.TipSetTok)
 	if err != nil {
 		return xerrors.Errorf("getting precommit info: %w", err)
 	}
@@ -158,18 +157,18 @@ func (m *Sealing) handleWaitSeed(ctx statemachine.Context, sector SectorInfo) er
 		if err != nil {
 			err = xerrors.Errorf("failed to get randomness for computing seal proof: %w", err)
 
-			ctx.Send(SectorFatalError{error: err})
+			_ = ctx.Send(SectorFatalError{error: err})
 			return err
 		}
 
-		ctx.Send(SectorSeedReady{SeedValue: abi.InteractiveSealRandomness(rand), SeedEpoch: randHeight})
+		_ = ctx.Send(SectorSeedReady{SeedValue: abi.InteractiveSealRandomness(rand), SeedEpoch: randHeight})
 
 		return nil
 	}, func(ctx context.Context, ts TipSetToken) error {
 		log.Warn("revert in interactive commit sector step")
 		// TODO: need to cancel running process and restart...
 		return nil
-	}, build.InteractivePoRepConfidence, randHeight)
+	}, InteractivePoRepConfidence, randHeight)
 	if err != nil {
 		log.Warn("waitForPreCommitMessage ChainAt errored: ", err)
 	}

storage/sealing/types.go

@@ -1,11 +1,14 @@
 package sealing
 
 import (
-	"github.com/filecoin-project/specs-actors/actors/abi"
+	"bytes"
-	"github.com/filecoin-project/specs-storage/storage"
+	"context"
-	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+	"github.com/filecoin-project/specs-actors/actors/runtime/exitcode"
+	"github.com/filecoin-project/specs-storage/storage"
+	"github.com/ipfs/go-cid"
 )
 
 type Piece struct {
@@ -94,3 +97,32 @@ func (t *SectorInfo) existingPieces() []abi.UnpaddedPieceSize {
 	}
 	return out
 }
+
+type TicketFn func(context.Context) (abi.SealRandomness, abi.ChainEpoch, error)
+
+type SectorIDCounter interface {
+	Next() (abi.SectorNumber, error)
+}
+
+type TipSetToken []byte
+
+type MsgLookup struct {
+	Receipt   MessageReceipt
+	TipSetTok TipSetToken
+	Height    abi.ChainEpoch
+}
+
+type MessageReceipt struct {
+	ExitCode exitcode.ExitCode
+	Return   []byte
+	GasUsed  int64
+}
+
+func (mr *MessageReceipt) Equals(o *MessageReceipt) bool {
+	return mr.ExitCode == o.ExitCode && bytes.Equal(mr.Return, o.Return) && mr.GasUsed == o.GasUsed
+}
+
+type MarketDeal struct {
+	Proposal market.DealProposal
+	State    market.DealState
+}