diff --git a/api/api_storage.go b/api/api_storage.go
index 8208d049c..9605a6532 100644
--- a/api/api_storage.go
+++ b/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
diff --git a/api/apistruct/struct.go b/api/apistruct/struct.go
index c074d6536..a34838c7b 100644
--- a/api/apistruct/struct.go
+++ b/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"
@@ -181,10 +183,10 @@ type StorageMinerStruct struct {
 
 		PledgeSector func(context.Context) error `perm:"write"`
 
-		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"`
+		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, 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)
 }
 
diff --git a/cmd/lotus-storage-miner/info.go b/cmd/lotus-storage-miner/info.go
index fe8d1a71f..6be83c50d 100644
--- a/cmd/lotus-storage-miner/info.go
+++ b/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 {
diff --git a/cmd/lotus-storage-miner/init.go b/cmd/lotus-storage-miner/init.go
index bb243111d..52df47ff0 100644
--- a/cmd/lotus-storage-miner/init.go
+++ b/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{
 				{
diff --git a/cmd/lotus-storage-miner/sectors.go b/cmd/lotus-storage-miner/sectors.go
index 288397767..fe4a8b9f4 100644
--- a/cmd/lotus-storage-miner/sectors.go
+++ b/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)))
 	},
 }
 
diff --git a/go.mod b/go.mod
index 3eb03175c..49a6c8b4a 100644
--- a/go.mod
+++ b/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
diff --git a/go.sum b/go.sum
index 9054f8ad2..d21cec31b 100644
--- a/go.sum
+++ b/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=
diff --git a/markets/storageadapter/provider.go b/markets/storageadapter/provider.go
index 26e771ee2..15c735c74 100644
--- a/markets/storageadapter/provider.go
+++ b/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
diff --git a/node/impl/storminer.go b/node/impl/storminer.go
index 6ed251832..d60b8e6d5 100644
--- a/node/impl/storminer.go
+++ b/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)
 }
 
diff --git a/storage/adapter_storage_miner.go b/storage/adapter_storage_miner.go
index b12bbb62c..d194f211f 100644
--- a/storage/adapter_storage_miner.go
+++ b/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 {
diff --git a/storage/miner.go b/storage/miner.go
index dcf0c9124..58fb27e41 100644
--- a/storage/miner.go
+++ b/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"
diff --git a/storage/sealing.go b/storage/sealing.go
index f2db4d166..abf2a3213 100644
--- a/storage/sealing.go
+++ b/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)
 }
diff --git a/storage/sealing/cbor_gen.go b/storage/sealing/cbor_gen.go
index d97cebd74..410936f50 100644
--- a/storage/sealing/cbor_gen.go
+++ b/storage/sealing/cbor_gen.go
@@ -3,1137 +3,35 @@
 package sealing
 
 import (
-	"fmt"
 	"io"
 
-	"github.com/filecoin-project/specs-actors/actors/abi"
-	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
 )
 
 var _ = xerrors.Errorf
 
 func (t *Piece) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{163}); err != nil {
-		return err
-	}
-
-	// t.DealID (abi.DealID) (uint64)
-	if len("DealID") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"DealID\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("DealID")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("DealID")); err != nil {
-		return err
-	}
-
-	if t.DealID == nil {
-		if _, err := w.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(*t.DealID))); err != nil {
-			return err
-		}
-	}
-
-	// t.Size (abi.UnpaddedPieceSize) (uint64)
-	if len("Size") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"Size\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Size")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Size")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Size))); err != nil {
-		return err
-	}
-
-	// t.CommP (cid.Cid) (struct)
-	if len("CommP") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"CommP\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("CommP")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("CommP")); err != nil {
-		return err
-	}
-
-	if err := cbg.WriteCid(w, t.CommP); err != nil {
-		return xerrors.Errorf("failed to write cid field t.CommP: %w", err)
-	}
-
 	return nil
+
 }
 
 func (t *Piece) 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 > cbg.MaxLength {
-		return fmt.Errorf("Piece: map struct too large (%d)", extra)
-	}
-
-	var name string
-	n := extra
-
-	for i := uint64(0); i < n; i++ {
-
-		{
-			sval, err := cbg.ReadString(br)
-			if err != nil {
-				return err
-			}
-
-			name = string(sval)
-		}
-
-		switch name {
-		// t.DealID (abi.DealID) (uint64)
-		case "DealID":
-
-			{
-
-				pb, err := br.PeekByte()
-				if err != nil {
-					return err
-				}
-				if pb == cbg.CborNull[0] {
-					var nbuf [1]byte
-					if _, err := br.Read(nbuf[:]); err != nil {
-						return err
-					}
-				} else {
-					maj, extra, err = cbg.CborReadHeader(br)
-					if err != nil {
-						return err
-					}
-					if maj != cbg.MajUnsignedInt {
-						return fmt.Errorf("wrong type for uint64 field")
-					}
-					typed := abi.DealID(extra)
-					t.DealID = &typed
-				}
-
-			}
-			// t.Size (abi.UnpaddedPieceSize) (uint64)
-		case "Size":
-
-			{
-
-				maj, extra, err = cbg.CborReadHeader(br)
-				if err != nil {
-					return err
-				}
-				if maj != cbg.MajUnsignedInt {
-					return fmt.Errorf("wrong type for uint64 field")
-				}
-				t.Size = abi.UnpaddedPieceSize(extra)
-
-			}
-			// t.CommP (cid.Cid) (struct)
-		case "CommP":
-
-			{
-
-				c, err := cbg.ReadCid(br)
-				if err != nil {
-					return xerrors.Errorf("failed to read cid field t.CommP: %w", err)
-				}
-
-				t.CommP = c
-
-			}
-
-		default:
-			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
-		}
-	}
-
 	return nil
+
 }
 func (t *SectorInfo) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{177}); err != nil {
-		return err
-	}
-
-	// t.State (uint64) (uint64)
-	if len("State") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"State\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("State")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("State")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.State))); err != nil {
-		return err
-	}
-
-	// t.SectorID (abi.SectorNumber) (uint64)
-	if len("SectorID") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"SectorID\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("SectorID")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("SectorID")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorID))); err != nil {
-		return err
-	}
-
-	// t.Nonce (uint64) (uint64)
-	if len("Nonce") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"Nonce\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Nonce")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Nonce")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Nonce))); err != nil {
-		return err
-	}
-
-	// t.SectorType (abi.RegisteredProof) (int64)
-	if len("SectorType") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"SectorType\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("SectorType")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("SectorType")); err != nil {
-		return err
-	}
-
-	if t.SectorType >= 0 {
-		if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorType))); err != nil {
-			return err
-		}
-	} else {
-		if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SectorType)-1)); err != nil {
-			return err
-		}
-	}
-
-	// t.Pieces ([]sealing.Piece) (slice)
-	if len("Pieces") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"Pieces\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Pieces")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Pieces")); err != nil {
-		return err
-	}
-
-	if len(t.Pieces) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Pieces was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Pieces)))); err != nil {
-		return err
-	}
-	for _, v := range t.Pieces {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-
-	// t.CommD (cid.Cid) (struct)
-	if len("CommD") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"CommD\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("CommD")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("CommD")); err != nil {
-		return err
-	}
-
-	if t.CommD == nil {
-		if _, err := w.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if err := cbg.WriteCid(w, *t.CommD); err != nil {
-			return xerrors.Errorf("failed to write cid field t.CommD: %w", err)
-		}
-	}
-
-	// t.CommR (cid.Cid) (struct)
-	if len("CommR") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"CommR\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("CommR")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("CommR")); err != nil {
-		return err
-	}
-
-	if t.CommR == nil {
-		if _, err := w.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if err := cbg.WriteCid(w, *t.CommR); err != nil {
-			return xerrors.Errorf("failed to write cid field t.CommR: %w", err)
-		}
-	}
-
-	// t.Proof ([]uint8) (slice)
-	if len("Proof") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"Proof\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Proof")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Proof")); err != nil {
-		return err
-	}
-
-	if len(t.Proof) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Proof was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Proof)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Proof); err != nil {
-		return err
-	}
-
-	// t.TicketValue (abi.SealRandomness) (slice)
-	if len("TicketValue") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"TicketValue\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("TicketValue")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("TicketValue")); err != nil {
-		return err
-	}
-
-	if len(t.TicketValue) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.TicketValue was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.TicketValue)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.TicketValue); err != nil {
-		return err
-	}
-
-	// t.TicketEpoch (abi.ChainEpoch) (int64)
-	if len("TicketEpoch") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"TicketEpoch\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("TicketEpoch")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("TicketEpoch")); err != nil {
-		return err
-	}
-
-	if t.TicketEpoch >= 0 {
-		if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.TicketEpoch))); err != nil {
-			return err
-		}
-	} else {
-		if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.TicketEpoch)-1)); err != nil {
-			return err
-		}
-	}
-
-	// t.PreCommitMessage (cid.Cid) (struct)
-	if len("PreCommitMessage") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"PreCommitMessage\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("PreCommitMessage")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("PreCommitMessage")); err != nil {
-		return err
-	}
-
-	if t.PreCommitMessage == nil {
-		if _, err := w.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if err := cbg.WriteCid(w, *t.PreCommitMessage); err != nil {
-			return xerrors.Errorf("failed to write cid field t.PreCommitMessage: %w", err)
-		}
-	}
-
-	// t.SeedValue (abi.InteractiveSealRandomness) (slice)
-	if len("SeedValue") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"SeedValue\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("SeedValue")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("SeedValue")); err != nil {
-		return err
-	}
-
-	if len(t.SeedValue) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.SeedValue was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.SeedValue)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.SeedValue); err != nil {
-		return err
-	}
-
-	// t.SeedEpoch (abi.ChainEpoch) (int64)
-	if len("SeedEpoch") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"SeedEpoch\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("SeedEpoch")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("SeedEpoch")); err != nil {
-		return err
-	}
-
-	if t.SeedEpoch >= 0 {
-		if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SeedEpoch))); err != nil {
-			return err
-		}
-	} else {
-		if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SeedEpoch)-1)); err != nil {
-			return err
-		}
-	}
-
-	// t.CommitMessage (cid.Cid) (struct)
-	if len("CommitMessage") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"CommitMessage\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("CommitMessage")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("CommitMessage")); err != nil {
-		return err
-	}
-
-	if t.CommitMessage == nil {
-		if _, err := w.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if err := cbg.WriteCid(w, *t.CommitMessage); err != nil {
-			return xerrors.Errorf("failed to write cid field t.CommitMessage: %w", err)
-		}
-	}
-
-	// t.FaultReportMsg (cid.Cid) (struct)
-	if len("FaultReportMsg") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"FaultReportMsg\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("FaultReportMsg")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("FaultReportMsg")); err != nil {
-		return err
-	}
-
-	if t.FaultReportMsg == nil {
-		if _, err := w.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if err := cbg.WriteCid(w, *t.FaultReportMsg); err != nil {
-			return xerrors.Errorf("failed to write cid field t.FaultReportMsg: %w", err)
-		}
-	}
-
-	// t.LastErr (string) (string)
-	if len("LastErr") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"LastErr\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("LastErr")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("LastErr")); err != nil {
-		return err
-	}
-
-	if len(t.LastErr) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.LastErr was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.LastErr)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.LastErr)); err != nil {
-		return err
-	}
-
-	// t.Log ([]sealing.Log) (slice)
-	if len("Log") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"Log\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Log")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Log")); err != nil {
-		return err
-	}
-
-	if len(t.Log) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Log was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Log)))); err != nil {
-		return err
-	}
-	for _, v := range t.Log {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
 	return nil
+
 }
-
-func (t *SectorInfo) 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 > cbg.MaxLength {
-		return fmt.Errorf("SectorInfo: map struct too large (%d)", extra)
-	}
-
-	var name string
-	n := extra
-
-	for i := uint64(0); i < n; i++ {
-
-		{
-			sval, err := cbg.ReadString(br)
-			if err != nil {
-				return err
-			}
-
-			name = string(sval)
-		}
-
-		switch name {
-		// t.State (uint64) (uint64)
-		case "State":
-
-			{
-
-				maj, extra, err = cbg.CborReadHeader(br)
-				if err != nil {
-					return err
-				}
-				if maj != cbg.MajUnsignedInt {
-					return fmt.Errorf("wrong type for uint64 field")
-				}
-				t.State = uint64(extra)
-
-			}
-			// t.SectorID (abi.SectorNumber) (uint64)
-		case "SectorID":
-
-			{
-
-				maj, extra, err = cbg.CborReadHeader(br)
-				if err != nil {
-					return err
-				}
-				if maj != cbg.MajUnsignedInt {
-					return fmt.Errorf("wrong type for uint64 field")
-				}
-				t.SectorID = abi.SectorNumber(extra)
-
-			}
-			// t.Nonce (uint64) (uint64)
-		case "Nonce":
-
-			{
-
-				maj, extra, err = cbg.CborReadHeader(br)
-				if err != nil {
-					return err
-				}
-				if maj != cbg.MajUnsignedInt {
-					return fmt.Errorf("wrong type for uint64 field")
-				}
-				t.Nonce = uint64(extra)
-
-			}
-			// t.SectorType (abi.RegisteredProof) (int64)
-		case "SectorType":
-			{
-				maj, extra, err := cbg.CborReadHeader(br)
-				var extraI int64
-				if err != nil {
-					return err
-				}
-				switch maj {
-				case cbg.MajUnsignedInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 positive overflow")
-					}
-				case cbg.MajNegativeInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 negative oveflow")
-					}
-					extraI = -1 - extraI
-				default:
-					return fmt.Errorf("wrong type for int64 field: %d", maj)
-				}
-
-				t.SectorType = abi.RegisteredProof(extraI)
-			}
-			// t.Pieces ([]sealing.Piece) (slice)
-		case "Pieces":
-
-			maj, extra, err = cbg.CborReadHeader(br)
-			if err != nil {
-				return err
-			}
-
-			if extra > cbg.MaxLength {
-				return fmt.Errorf("t.Pieces: array too large (%d)", extra)
-			}
-
-			if maj != cbg.MajArray {
-				return fmt.Errorf("expected cbor array")
-			}
-			if extra > 0 {
-				t.Pieces = make([]Piece, extra)
-			}
-			for i := 0; i < int(extra); i++ {
-
-				var v Piece
-				if err := v.UnmarshalCBOR(br); err != nil {
-					return err
-				}
-
-				t.Pieces[i] = v
-			}
-
-			// t.CommD (cid.Cid) (struct)
-		case "CommD":
-
-			{
-
-				pb, err := br.PeekByte()
-				if err != nil {
-					return err
-				}
-				if pb == cbg.CborNull[0] {
-					var nbuf [1]byte
-					if _, err := br.Read(nbuf[:]); err != nil {
-						return err
-					}
-				} else {
-
-					c, err := cbg.ReadCid(br)
-					if err != nil {
-						return xerrors.Errorf("failed to read cid field t.CommD: %w", err)
-					}
-
-					t.CommD = &c
-				}
-
-			}
-			// t.CommR (cid.Cid) (struct)
-		case "CommR":
-
-			{
-
-				pb, err := br.PeekByte()
-				if err != nil {
-					return err
-				}
-				if pb == cbg.CborNull[0] {
-					var nbuf [1]byte
-					if _, err := br.Read(nbuf[:]); err != nil {
-						return err
-					}
-				} else {
-
-					c, err := cbg.ReadCid(br)
-					if err != nil {
-						return xerrors.Errorf("failed to read cid field t.CommR: %w", err)
-					}
-
-					t.CommR = &c
-				}
-
-			}
-			// t.Proof ([]uint8) (slice)
-		case "Proof":
-
-			maj, extra, err = cbg.CborReadHeader(br)
-			if err != nil {
-				return err
-			}
-
-			if extra > cbg.ByteArrayMaxLen {
-				return fmt.Errorf("t.Proof: byte array too large (%d)", extra)
-			}
-			if maj != cbg.MajByteString {
-				return fmt.Errorf("expected byte array")
-			}
-			t.Proof = make([]byte, extra)
-			if _, err := io.ReadFull(br, t.Proof); err != nil {
-				return err
-			}
-			// t.TicketValue (abi.SealRandomness) (slice)
-		case "TicketValue":
-
-			maj, extra, err = cbg.CborReadHeader(br)
-			if err != nil {
-				return err
-			}
-
-			if extra > cbg.ByteArrayMaxLen {
-				return fmt.Errorf("t.TicketValue: byte array too large (%d)", extra)
-			}
-			if maj != cbg.MajByteString {
-				return fmt.Errorf("expected byte array")
-			}
-			t.TicketValue = make([]byte, extra)
-			if _, err := io.ReadFull(br, t.TicketValue); err != nil {
-				return err
-			}
-			// t.TicketEpoch (abi.ChainEpoch) (int64)
-		case "TicketEpoch":
-			{
-				maj, extra, err := cbg.CborReadHeader(br)
-				var extraI int64
-				if err != nil {
-					return err
-				}
-				switch maj {
-				case cbg.MajUnsignedInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 positive overflow")
-					}
-				case cbg.MajNegativeInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 negative oveflow")
-					}
-					extraI = -1 - extraI
-				default:
-					return fmt.Errorf("wrong type for int64 field: %d", maj)
-				}
-
-				t.TicketEpoch = abi.ChainEpoch(extraI)
-			}
-			// t.PreCommitMessage (cid.Cid) (struct)
-		case "PreCommitMessage":
-
-			{
-
-				pb, err := br.PeekByte()
-				if err != nil {
-					return err
-				}
-				if pb == cbg.CborNull[0] {
-					var nbuf [1]byte
-					if _, err := br.Read(nbuf[:]); err != nil {
-						return err
-					}
-				} else {
-
-					c, err := cbg.ReadCid(br)
-					if err != nil {
-						return xerrors.Errorf("failed to read cid field t.PreCommitMessage: %w", err)
-					}
-
-					t.PreCommitMessage = &c
-				}
-
-			}
-			// t.SeedValue (abi.InteractiveSealRandomness) (slice)
-		case "SeedValue":
-
-			maj, extra, err = cbg.CborReadHeader(br)
-			if err != nil {
-				return err
-			}
-
-			if extra > cbg.ByteArrayMaxLen {
-				return fmt.Errorf("t.SeedValue: byte array too large (%d)", extra)
-			}
-			if maj != cbg.MajByteString {
-				return fmt.Errorf("expected byte array")
-			}
-			t.SeedValue = make([]byte, extra)
-			if _, err := io.ReadFull(br, t.SeedValue); err != nil {
-				return err
-			}
-			// t.SeedEpoch (abi.ChainEpoch) (int64)
-		case "SeedEpoch":
-			{
-				maj, extra, err := cbg.CborReadHeader(br)
-				var extraI int64
-				if err != nil {
-					return err
-				}
-				switch maj {
-				case cbg.MajUnsignedInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 positive overflow")
-					}
-				case cbg.MajNegativeInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 negative oveflow")
-					}
-					extraI = -1 - extraI
-				default:
-					return fmt.Errorf("wrong type for int64 field: %d", maj)
-				}
-
-				t.SeedEpoch = abi.ChainEpoch(extraI)
-			}
-			// t.CommitMessage (cid.Cid) (struct)
-		case "CommitMessage":
-
-			{
-
-				pb, err := br.PeekByte()
-				if err != nil {
-					return err
-				}
-				if pb == cbg.CborNull[0] {
-					var nbuf [1]byte
-					if _, err := br.Read(nbuf[:]); err != nil {
-						return err
-					}
-				} else {
-
-					c, err := cbg.ReadCid(br)
-					if err != nil {
-						return xerrors.Errorf("failed to read cid field t.CommitMessage: %w", err)
-					}
-
-					t.CommitMessage = &c
-				}
-
-			}
-			// t.FaultReportMsg (cid.Cid) (struct)
-		case "FaultReportMsg":
-
-			{
-
-				pb, err := br.PeekByte()
-				if err != nil {
-					return err
-				}
-				if pb == cbg.CborNull[0] {
-					var nbuf [1]byte
-					if _, err := br.Read(nbuf[:]); err != nil {
-						return err
-					}
-				} else {
-
-					c, err := cbg.ReadCid(br)
-					if err != nil {
-						return xerrors.Errorf("failed to read cid field t.FaultReportMsg: %w", err)
-					}
-
-					t.FaultReportMsg = &c
-				}
-
-			}
-			// t.LastErr (string) (string)
-		case "LastErr":
-
-			{
-				sval, err := cbg.ReadString(br)
-				if err != nil {
-					return err
-				}
-
-				t.LastErr = string(sval)
-			}
-			// t.Log ([]sealing.Log) (slice)
-		case "Log":
-
-			maj, extra, err = cbg.CborReadHeader(br)
-			if err != nil {
-				return err
-			}
-
-			if extra > cbg.MaxLength {
-				return fmt.Errorf("t.Log: array too large (%d)", extra)
-			}
-
-			if maj != cbg.MajArray {
-				return fmt.Errorf("expected cbor array")
-			}
-			if extra > 0 {
-				t.Log = make([]Log, extra)
-			}
-			for i := 0; i < int(extra); i++ {
-
-				var v Log
-				if err := v.UnmarshalCBOR(br); err != nil {
-					return err
-				}
-
-				t.Log[i] = v
-			}
-
-		default:
-			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
-		}
-	}
-
+func (t *SectorInfo) UnmarshalCBOR(w io.Reader) error {
 	return nil
+
 }
 func (t *Log) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{164}); err != nil {
-		return err
-	}
-
-	// t.Timestamp (uint64) (uint64)
-	if len("Timestamp") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"Timestamp\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Timestamp")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Timestamp")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Timestamp))); err != nil {
-		return err
-	}
-
-	// t.Trace (string) (string)
-	if len("Trace") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"Trace\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Trace")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Trace")); err != nil {
-		return err
-	}
-
-	if len(t.Trace) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.Trace was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.Trace)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.Trace)); err != nil {
-		return err
-	}
-
-	// t.Message (string) (string)
-	if len("Message") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"Message\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Message")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Message")); err != nil {
-		return err
-	}
-
-	if len(t.Message) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.Message was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.Message)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.Message)); err != nil {
-		return err
-	}
-
-	// t.Kind (string) (string)
-	if len("Kind") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"Kind\" was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Kind")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Kind")); err != nil {
-		return err
-	}
-
-	if len(t.Kind) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.Kind was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.Kind)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.Kind)); err != nil {
-		return err
-	}
 	return nil
 }
 
 func (t *Log) 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 > cbg.MaxLength {
-		return fmt.Errorf("Log: map struct too large (%d)", extra)
-	}
-
-	var name string
-	n := extra
-
-	for i := uint64(0); i < n; i++ {
-
-		{
-			sval, err := cbg.ReadString(br)
-			if err != nil {
-				return err
-			}
-
-			name = string(sval)
-		}
-
-		switch name {
-		// t.Timestamp (uint64) (uint64)
-		case "Timestamp":
-
-			{
-
-				maj, extra, err = cbg.CborReadHeader(br)
-				if err != nil {
-					return err
-				}
-				if maj != cbg.MajUnsignedInt {
-					return fmt.Errorf("wrong type for uint64 field")
-				}
-				t.Timestamp = uint64(extra)
-
-			}
-			// t.Trace (string) (string)
-		case "Trace":
-
-			{
-				sval, err := cbg.ReadString(br)
-				if err != nil {
-					return err
-				}
-
-				t.Trace = string(sval)
-			}
-			// t.Message (string) (string)
-		case "Message":
-
-			{
-				sval, err := cbg.ReadString(br)
-				if err != nil {
-					return err
-				}
-
-				t.Message = string(sval)
-			}
-			// t.Kind (string) (string)
-		case "Kind":
-
-			{
-				sval, err := cbg.ReadString(br)
-				if err != nil {
-					return err
-				}
-
-				t.Kind = string(sval)
-			}
-
-		default:
-			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
-		}
-	}
-
 	return nil
+
 }
diff --git a/storage/sealing/checks.go b/storage/sealing/checks.go
index 2721c8333..ff1572cf2 100644
--- a/storage/sealing/checks.go
+++ b/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 {
-		return &ErrBadSeed{xerrors.Errorf("seed epoch doesn't match on chain info: %d != %d", 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.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,
-		InteractiveRandomness: si.Seed.Value,
+		Randomness:            si.TicketValue,
+		InteractiveRandomness: si.SeedValue,
 		UnsealedCID:           *si.CommD,
 	})
 	if err != nil {
diff --git a/storage/sealing/fsm.go b/storage/sealing/fsm.go
index 88be53eff..e03ab7bd8 100644
--- a/storage/sealing/fsm.go
+++ b/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{
-	api.UndefinedSectorState: planOne(on(SectorStart{}, api.Packing)),
-	api.Packing:              planOne(on(SectorPacked{}, api.PreCommit1)),
-	api.PreCommit1: planOne(
-		on(SectorPreCommit1{}, api.PreCommit2),
-		on(SectorSealPreCommitFailed{}, api.SealFailed),
-		on(SectorPackingFailed{}, api.PackingFailed),
+var fsmPlanners = map[SectorState]func(events []statemachine.Event, state *SectorInfo) error{
+	UndefinedSectorState: planOne(on(SectorStart{}, Packing)),
+	Packing:              planOne(on(SectorPacked{}, PreCommit1)),
+	PreCommit1: planOne(
+		on(SectorPreCommit1{}, PreCommit2),
+		on(SectorSealPreCommitFailed{}, SealFailed),
+		on(SectorPackingFailed{}, PackingFailed),
 	),
-	api.PreCommit2: planOne(
-		on(SectorPreCommit2{}, api.PreCommitting),
-		on(SectorSealPreCommitFailed{}, api.SealFailed),
-		on(SectorPackingFailed{}, api.PackingFailed),
+	PreCommit2: planOne(
+		on(SectorPreCommit2{}, PreCommitting),
+		on(SectorSealPreCommitFailed{}, SealFailed),
+		on(SectorPackingFailed{}, PackingFailed),
 	),
-	api.PreCommitting: planOne(
-		on(SectorSealPreCommitFailed{}, api.SealFailed),
-		on(SectorPreCommitted{}, api.WaitSeed),
-		on(SectorChainPreCommitFailed{}, api.PreCommitFailed),
+	PreCommitting: planOne(
+		on(SectorSealPreCommitFailed{}, SealFailed),
+		on(SectorPreCommitted{}, WaitSeed),
+		on(SectorChainPreCommitFailed{}, PreCommitFailed),
 	),
-	api.WaitSeed: planOne(
-		on(SectorSeedReady{}, api.Committing),
-		on(SectorChainPreCommitFailed{}, api.PreCommitFailed),
+	WaitSeed: planOne(
+		on(SectorSeedReady{}, Committing),
+		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(
-		on(SectorRetrySeal{}, api.PreCommit1),
+	SealFailed: planOne(
+		on(SectorRetrySeal{}, PreCommit1),
 	),
-	api.PreCommitFailed: planOne(
-		on(SectorRetryPreCommit{}, api.PreCommitting),
-		on(SectorRetryWaitSeed{}, api.WaitSeed),
-		on(SectorSealPreCommitFailed{}, api.SealFailed),
+	PreCommitFailed: planOne(
+		on(SectorRetryPreCommit{}, PreCommitting),
+		on(SectorRetryWaitSeed{}, WaitSeed),
+		on(SectorSealPreCommitFailed{}, SealFailed),
 	),
-	api.ComputeProofFailed: planOne(
-		on(SectorRetryComputeProof{}, api.Committing),
+	ComputeProofFailed: planOne(
+		on(SectorRetryComputeProof{}, Committing),
 	),
-	api.CommitFailed: planOne(
-		on(SectorSealPreCommitFailed{}, api.SealFailed),
-		on(SectorRetryWaitSeed{}, api.WaitSeed),
-		on(SectorRetryComputeProof{}, api.Committing),
-		on(SectorRetryInvalidProof{}, api.Committing),
+	CommitFailed: planOne(
+		on(SectorSealPreCommitFailed{}, SealFailed),
+		on(SectorRetryWaitSeed{}, WaitSeed),
+		on(SectorRetryComputeProof{}, 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:
diff --git a/storage/sealing/fsm_events.go b/storage/sealing/fsm_events.go
index 40388ad70..2dee984d5 100644
--- a/storage/sealing/fsm_events.go
+++ b/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 {
diff --git a/storage/sealing/fsm_test.go b/storage/sealing/fsm_test.go
index 69c2a99fb..8738d1c59 100644
--- a/storage/sealing/fsm_test.go
+++ b/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)
 }
diff --git a/storage/sealing/sealing.go b/storage/sealing/sealing.go
index a843650b4..d79ebfc84 100644
--- a/storage/sealing/sealing.go
+++ b/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)
diff --git a/storage/sealing/sector_state.go b/storage/sealing/sector_state.go
index 5477edff8..f2a95ed5a 100644
--- a/storage/sealing/sector_state.go
+++ b/storage/sealing/sector_state.go
@@ -1,74 +1,29 @@
 package sealing
 
-// alias because cbor-gen doesn't like non-alias types
-type SectorState = uint64
+type SectorState string
 
 const (
-	UndefinedSectorState SectorState = iota
+	UndefinedSectorState SectorState = ""
 
 	// happy path
-	Empty
-	Packing // sector not in sealStore, and not on chain
-
-	Unsealed      // sealing / queued
-	PreCommitting // on chain pre-commit
-	WaitSeed      // waiting for seed
-	Committing
-	CommitWait // waiting for message to land on chain
-	FinalizeSector
-	Proving
-	_ // reserved
-	_
-	_
-
-	// recovery handling
-	// Reseal
-	_
-	_
-	_
-	_
-	_
-	_
-	_
-
+	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
-
-	SealFailed
-	PreCommitFailed
-	SealCommitFailed
-	CommitFailed
-	PackingFailed
-	_
-	_
-	_
-
-	Faulty        // sector is corrupted or gone for some reason
-	FaultReported // sector has been declared as a fault on chain
-	FaultedFinal  // fault declared on chain
+	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
 )
-
-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",
-}
diff --git a/storage/sealing/states.go b/storage/sealing/states.go
index 0bd4f767d..907ead6b3 100644
--- a/storage/sealing/states.go
+++ b/storage/sealing/states.go
@@ -6,8 +6,7 @@ import (
 
 	"golang.org/x/xerrors"
 
-	statemachine "github.com/filecoin-project/go-statemachine"
-	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/go-statemachine"
 	"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)
 	}
diff --git a/storage/sealing/types.go b/storage/sealing/types.go
index 4b2a6396a..7edbe7145 100644
--- a/storage/sealing/types.go
+++ b/storage/sealing/types.go
@@ -1,11 +1,14 @@
 package sealing
 
 import (
-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-storage/storage"
-	"github.com/ipfs/go-cid"
+	"bytes"
+	"context"
 
 	"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
+}