Merge remote-tracking branch 'origin/master' into feat/async-restartable-workers

2020-09-14 19:11:50 +02:00 · 2020-09-14 19:11:50 +02:00 · 381a6cdfac
commit 381a6cdfac
parent 1ebca8f732 86607452d7
74 changed files with 1122 additions and 450 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@ -400,7 +400,8 @@ workflows:
  version: 2.1
  ci:
    jobs:
-      - lint-all
+      - lint-all:
+          concurrency: "16"   # expend all docker 2xlarge CPUs.
      - mod-tidy-check
      - gofmt
      - cbor-gen-check
--- a/.gitmodules
+++ b/.gitmodules
@ -8,3 +8,6 @@
 [submodule "extern/test-vectors"]
 	path = extern/test-vectors
 	url = https://github.com/filecoin-project/test-vectors.git
+[submodule "extern/fil-blst"]
+	path = extern/fil-blst
+	url = https://github.com/filecoin-project/fil-blst.git
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,5 +1,60 @@
 # Lotus changelog

+# 0.7.0 / 2020-09-10
+
+This consensus-breaking release of Lotus is designed to test a network upgrade on the space race testnet. The changes that break consensus are:
+
+- Upgrading the Drand network used from the test Drand network to the League of Entropy main drand network. This is the same Drand network that will be used in the Filecoin mainnet.
+- Upgrading to specs-actors v0.9.8, which adds a new method to the Multisig actor.
+
+## Changes
+
+#### Core Lotus
+
+- Fix IsAncestorOf (https://github.com/filecoin-project/lotus/pull/3717)
+- Update to specs-actors v0.9.8 (https://github.com/filecoin-project/lotus/pull/3725)
+- Increase chain throughput by 20% (https://github.com/filecoin-project/lotus/pull/3732)
+- Updare to go-libp2p-pubsub `master` (https://github.com/filecoin-project/lotus/pull/3735)
+- Drand upgrade (https://github.com/filecoin-project/lotus/pull/3670)
+- Multisig API additions (https://github.com/filecoin-project/lotus/pull/3590)
+
+#### Storage Miner 
+
+- Increase the number of times precommit2 is attempted before moving back to precommit1 (https://github.com/filecoin-project/lotus/pull/3720)
+
+#### Message pool
+
+- Relax mpool add strictness checks for local pushes (https://github.com/filecoin-project/lotus/pull/3724)
+
+
+#### Maintenance
+
+- Fix devnets (https://github.com/filecoin-project/lotus/pull/3712)
+- Fix(chainwatch): compare prev miner with cur miner (https://github.com/filecoin-project/lotus/pull/3715)
+- CI: fix statediff build; make optional (https://github.com/filecoin-project/lotus/pull/3729)
+- Feat: Chaos abort (https://github.com/filecoin-project/lotus/pull/3733)
+
+## Contributors
+
+The following contributors had commits go into this release.
+We are grateful for every contribution!
+
+| Contributor        | Commits | Lines ±       |
+|--------------------|---------|---------------|
+| arajasek           | 28      | +1144/-239    |
+| Kubuxu             | 19      | +452/-261     |
+| whyrusleeping      | 13      | +456/-87      |
+| vyzo               | 11      | +318/-20      |
+| raulk              | 10      | +1289/-350    |
+| magik6k            | 6       | +188/-55      |
+| dirkmc             | 3       | +31/-8        |
+| alanshaw           | 3       | +176/-37      |
+| Stebalien          | 2       | +9/-12        |
+| lanzafame          | 1       | +1/-1         |
+| frrist             | 1       | +1/-1         |
+| mishmosh           | 1       | +1/-1         |
+| nonsense           | 1       | +1/-0         |
+
 # 0.6.2 / 2020-09-09

 This release introduces some critical fixes to message selection and gas estimation logic. It also adds the ability for nodes to mark a certain tipset as checkpointed, as well as various minor improvements and bugfixes.
@ -38,7 +93,6 @@ This release introduces some critical fixes to message selection and gas estimat
 - Paych: add docs on how to use paych status (https://github.com/filecoin-project/lotus/pull/3690)
 - Initial CODEOWNERS (https://github.com/filecoin-project/lotus/pull/3691)

-
 # 0.6.1 / 2020-09-08

 This optional release introduces a minor improvement to the sync process, ensuring nodes don't fall behind and then resync.
--- a/api/api_full.go
+++ b/api/api_full.go
@ -5,6 +5,8 @@ import (
 	"fmt"
 	"time"

+	"github.com/filecoin-project/go-state-types/dline"
+
 	"github.com/filecoin-project/specs-actors/actors/runtime/proof"

 	"github.com/ipfs/go-cid"
@ -116,7 +118,8 @@ type FullNode interface {
 	// The exported chain data includes the header chain from the given tipset
 	// back to genesis, the entire genesis state, and the most recent 'nroots'
 	// state trees.
-	ChainExport(ctx context.Context, nroots abi.ChainEpoch, tsk types.TipSetKey) (<-chan []byte, error)
+	// If oldmsgskip is set, messages from before the requested roots are also not included.
+	ChainExport(ctx context.Context, nroots abi.ChainEpoch, oldmsgskip bool, tsk types.TipSetKey) (<-chan []byte, error)

 	// MethodGroup: Beacon
 	// The Beacon method group contains methods for interacting with the random beacon (DRAND)
@ -318,7 +321,7 @@ type FullNode interface {
 	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) ([]*ChainSectorInfo, error)
 	// StateMinerProvingDeadline calculates the deadline at some epoch for a proving period
 	// and returns the deadline-related calculations.
-	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*miner.DeadlineInfo, error)
+	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
 	// StateMinerPower returns the power of the indicated miner
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
 	// StateMinerInfo returns info about the indicated miner
--- a/api/apistruct/struct.go
+++ b/api/apistruct/struct.go
@ -5,6 +5,8 @@ import (
 	"io"
 	"time"

+	"github.com/filecoin-project/go-state-types/dline"
+
 	"github.com/ipfs/go-cid"
 	metrics "github.com/libp2p/go-libp2p-core/metrics"
 	"github.com/libp2p/go-libp2p-core/network"
@ -93,7 +95,7 @@ type FullNodeStruct struct {
 		ChainGetNode                  func(ctx context.Context, p string) (*api.IpldObject, error)                                                       `perm:"read"`
 		ChainGetMessage               func(context.Context, cid.Cid) (*types.Message, error)                                                             `perm:"read"`
 		ChainGetPath                  func(context.Context, types.TipSetKey, types.TipSetKey) ([]*api.HeadChange, error)                                 `perm:"read"`
-		ChainExport                   func(context.Context, abi.ChainEpoch, types.TipSetKey) (<-chan []byte, error)                                      `perm:"read"`
+		ChainExport                   func(context.Context, abi.ChainEpoch, bool, types.TipSetKey) (<-chan []byte, error)                                `perm:"read"`

 		BeaconGetEntry func(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) `perm:"read"`

@ -162,7 +164,7 @@ type FullNodeStruct struct {
 		StateNetworkName                   func(context.Context) (dtypes.NetworkName, error)                                                                   `perm:"read"`
 		StateMinerSectors                  func(context.Context, address.Address, *bitfield.BitField, bool, types.TipSetKey) ([]*api.ChainSectorInfo, error)   `perm:"read"`
 		StateMinerActiveSectors            func(context.Context, address.Address, types.TipSetKey) ([]*api.ChainSectorInfo, error)                             `perm:"read"`
-		StateMinerProvingDeadline          func(context.Context, address.Address, types.TipSetKey) (*miner.DeadlineInfo, error)                                `perm:"read"`
+		StateMinerProvingDeadline          func(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)                                        `perm:"read"`
 		StateMinerPower                    func(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error)                                    `perm:"read"`
 		StateMinerInfo                     func(context.Context, address.Address, types.TipSetKey) (api.MinerInfo, error)                                      `perm:"read"`
 		StateMinerDeadlines                func(context.Context, address.Address, types.TipSetKey) ([]*miner.Deadline, error)                                  `perm:"read"`
@ -701,8 +703,8 @@ func (c *FullNodeStruct) ChainGetPath(ctx context.Context, from types.TipSetKey,
 	return c.Internal.ChainGetPath(ctx, from, to)
 }

-func (c *FullNodeStruct) ChainExport(ctx context.Context, nroots abi.ChainEpoch, tsk types.TipSetKey) (<-chan []byte, error) {
-	return c.Internal.ChainExport(ctx, nroots, tsk)
+func (c *FullNodeStruct) ChainExport(ctx context.Context, nroots abi.ChainEpoch, iom bool, tsk types.TipSetKey) (<-chan []byte, error) {
+	return c.Internal.ChainExport(ctx, nroots, iom, tsk)
 }

 func (c *FullNodeStruct) BeaconGetEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) {
@ -749,7 +751,7 @@ func (c *FullNodeStruct) StateMinerActiveSectors(ctx context.Context, addr addre
 	return c.Internal.StateMinerActiveSectors(ctx, addr, tsk)
 }

-func (c *FullNodeStruct) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*miner.DeadlineInfo, error) {
+func (c *FullNodeStruct) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error) {
 	return c.Internal.StateMinerProvingDeadline(ctx, addr, tsk)
 }

--- a/api/test/window_post.go
+++ b/api/test/window_post.go
@ -192,7 +192,7 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector

 		// Drop the partition
 		err = parts[0].Sectors.ForEach(func(sid uint64) error {
-			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkFailed(abi.SectorID{
+			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(abi.SectorID{
 				Miner:  abi.ActorID(mid),
 				Number: abi.SectorNumber(sid),
 			}, true)
--- a/build/drand.go
+++ b/build/drand.go
@ -1,15 +1,26 @@
 package build

-import "github.com/filecoin-project/lotus/node/modules/dtypes"
+import (
+	"sort"

-var DrandNetwork = DrandIncentinet
-
-func DrandConfig() dtypes.DrandConfig {
-	return DrandConfigs[DrandNetwork]
-}
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+)

 type DrandEnum int

+func DrandConfigSchedule() dtypes.DrandSchedule {
+	out := dtypes.DrandSchedule{}
+	for start, config := range DrandSchedule {
+		out = append(out, dtypes.DrandPoint{Start: start, Config: DrandConfigs[config]})
+	}
+
+	sort.Slice(out, func(i, j int) bool {
+		return out[i].Start < out[j].Start
+	})
+
+	return out
+}
+
 const (
 	DrandMainnet DrandEnum = iota + 1
 	DrandTestnet
--- a/build/params_2k.go
+++ b/build/params_2k.go
@ -13,6 +13,12 @@ import (
 const UpgradeBreezeHeight = -1
 const BreezeGasTampingDuration = 0

+const UpgradeSmokeHeight = -1
+
+var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+	0: DrandMainnet,
+}
+
 func init() {
 	power.ConsensusMinerMinPower = big.NewInt(2048)
 	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
@ -23,7 +29,7 @@ func init() {
 	BuildType |= Build2k
 }

-const BlockDelaySecs = uint64(4)
+const BlockDelaySecs = uint64(30)

 const PropagationDelaySecs = uint64(1)

--- a/build/params_shared_funcs.go
+++ b/build/params_shared_funcs.go
@ -36,3 +36,11 @@ func MessagesTopic(netName dtypes.NetworkName) string { return "/fil/msgs/" + st
 func DhtProtocolName(netName dtypes.NetworkName) protocol.ID {
 	return protocol.ID("/fil/kad/" + string(netName))
 }
+
+func UseNewestNetwork() bool {
+	// TODO: Put these in a container we can iterate over
+	if UpgradeBreezeHeight <= 0 && UpgradeSmokeHeight <= 0 {
+		return true
+	}
+	return false
+}
--- a/build/params_shared_vals.go
+++ b/build/params_shared_vals.go
@ -5,6 +5,8 @@ package build
 import (
 	"math/big"

+	"github.com/filecoin-project/go-state-types/network"
+
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
@ -20,6 +22,7 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network

 const AllowableClockDriftSecs = uint64(1)
+const NewestNetworkVersion = network.Version2

 // Epochs
 const ForkLengthThreshold = Finality
--- a/build/params_testground.go
+++ b/build/params_testground.go
@ -11,6 +11,7 @@ import (
 	"math/big"

 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 )
@ -70,6 +71,14 @@ var (
 	PackingEfficiencyNum   int64 = 4
 	PackingEfficiencyDenom int64 = 5

-	UpgradeBreezeHeight      abi.ChainEpoch = 0
+	UpgradeBreezeHeight      abi.ChainEpoch = -1
 	BreezeGasTampingDuration abi.ChainEpoch = 0
+
+	UpgradeSmokeHeight abi.ChainEpoch = -1
+
+	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+		0: DrandMainnet,
+	}
+
+	NewestNetworkVersion = network.Version2
 )
--- a/build/params_testnet.go
+++ b/build/params_testnet.go
@ -12,9 +12,16 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
 )

+var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+	0:                  DrandIncentinet,
+	UpgradeSmokeHeight: DrandMainnet,
+}
+
 const UpgradeBreezeHeight = 41280
 const BreezeGasTampingDuration = 120

+const UpgradeSmokeHeight = 51000
+
 func init() {
 	power.ConsensusMinerMinPower = big.NewInt(10 << 40)
 	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
--- a/build/version.go
+++ b/build/version.go
@ -29,7 +29,7 @@ func buildType() string {
 }

 // BuildVersion is the local build version, set by build system
-const BuildVersion = "0.6.2"
+const BuildVersion = "0.7.0"

 func UserVersion() string {
 	return BuildVersion + buildType() + CurrentCommit
--- a/chain/beacon/beacon.go
+++ b/chain/beacon/beacon.go
@ -18,6 +18,23 @@ type Response struct {
 	Err   error
 }

+type Schedule []BeaconPoint
+
+func (bs Schedule) BeaconForEpoch(e abi.ChainEpoch) RandomBeacon {
+	for i := len(bs) - 1; i >= 0; i-- {
+		bp := bs[i]
+		if e >= bp.Start {
+			return bp.Beacon
+		}
+	}
+	return bs[0].Beacon
+}
+
+type BeaconPoint struct {
+	Start  abi.ChainEpoch
+	Beacon RandomBeacon
+}
+
 // RandomBeacon represents a system that provides randomness to Lotus.
 // Other components interrogate the RandomBeacon to acquire randomness that's
 // valid for a specific chain epoch. Also to verify beacon entries that have
@ -25,11 +42,30 @@ type Response struct {
 type RandomBeacon interface {
 	Entry(context.Context, uint64) <-chan Response
 	VerifyEntry(types.BeaconEntry, types.BeaconEntry) error
-	MaxBeaconRoundForEpoch(abi.ChainEpoch, types.BeaconEntry) uint64
+	MaxBeaconRoundForEpoch(abi.ChainEpoch) uint64
 }

-func ValidateBlockValues(b RandomBeacon, h *types.BlockHeader, prevEntry types.BeaconEntry) error {
-	maxRound := b.MaxBeaconRoundForEpoch(h.Height, prevEntry)
+func ValidateBlockValues(bSchedule Schedule, h *types.BlockHeader, parentEpoch abi.ChainEpoch,
+	prevEntry types.BeaconEntry) error {
+	{
+		parentBeacon := bSchedule.BeaconForEpoch(parentEpoch)
+		currBeacon := bSchedule.BeaconForEpoch(h.Height)
+		if parentBeacon != currBeacon {
+			if len(h.BeaconEntries) != 2 {
+				return xerrors.Errorf("expected two beacon entries at beacon fork, got %d", len(h.BeaconEntries))
+			}
+			err := currBeacon.VerifyEntry(h.BeaconEntries[1], h.BeaconEntries[0])
+			if err != nil {
+				return xerrors.Errorf("beacon at fork point invalid: (%v, %v): %w",
+					h.BeaconEntries[1], h.BeaconEntries[0], err)
+			}
+			return nil
+		}
+	}
+
+	// TODO: fork logic
+	b := bSchedule.BeaconForEpoch(h.Height)
+	maxRound := b.MaxBeaconRoundForEpoch(h.Height)
 	if maxRound == prevEntry.Round {
 		if len(h.BeaconEntries) != 0 {
 			return xerrors.Errorf("expected not to have any beacon entries in this block, got %d", len(h.BeaconEntries))
@ -56,10 +92,35 @@ func ValidateBlockValues(b RandomBeacon, h *types.BlockHeader, prevEntry types.B
 	return nil
 }

-func BeaconEntriesForBlock(ctx context.Context, beacon RandomBeacon, round abi.ChainEpoch, prev types.BeaconEntry) ([]types.BeaconEntry, error) {
+func BeaconEntriesForBlock(ctx context.Context, bSchedule Schedule, epoch abi.ChainEpoch, parentEpoch abi.ChainEpoch, prev types.BeaconEntry) ([]types.BeaconEntry, error) {
+	{
+		parentBeacon := bSchedule.BeaconForEpoch(parentEpoch)
+		currBeacon := bSchedule.BeaconForEpoch(epoch)
+		if parentBeacon != currBeacon {
+			// Fork logic
+			round := currBeacon.MaxBeaconRoundForEpoch(epoch)
+			out := make([]types.BeaconEntry, 2)
+			rch := currBeacon.Entry(ctx, round-1)
+			res := <-rch
+			if res.Err != nil {
+				return nil, xerrors.Errorf("getting entry %d returned error: %w", round-1, res.Err)
+			}
+			out[0] = res.Entry
+			rch = currBeacon.Entry(ctx, round)
+			res = <-rch
+			if res.Err != nil {
+				return nil, xerrors.Errorf("getting entry %d returned error: %w", round, res.Err)
+			}
+			out[1] = res.Entry
+			return out, nil
+		}
+	}
+
+	beacon := bSchedule.BeaconForEpoch(epoch)
+
 	start := build.Clock.Now()

-	maxRound := beacon.MaxBeaconRoundForEpoch(round, prev)
+	maxRound := beacon.MaxBeaconRoundForEpoch(epoch)
 	if maxRound == prev.Round {
 		return nil, nil
 	}
@ -82,7 +143,7 @@ func BeaconEntriesForBlock(ctx context.Context, beacon RandomBeacon, round abi.C
 			out = append(out, resp.Entry)
 			cur = resp.Entry.Round - 1
 		case <-ctx.Done():
-			return nil, xerrors.Errorf("context timed out waiting on beacon entry to come back for round %d: %w", round, ctx.Err())
+			return nil, xerrors.Errorf("context timed out waiting on beacon entry to come back for epoch %d: %w", epoch, ctx.Err())
 		}
 	}

--- a/chain/beacon/drand/drand.go
+++ b/chain/beacon/drand/drand.go
@ -187,7 +187,7 @@ func (db *DrandBeacon) VerifyEntry(curr types.BeaconEntry, prev types.BeaconEntr
 	return err
 }

-func (db *DrandBeacon) MaxBeaconRoundForEpoch(filEpoch abi.ChainEpoch, prevEntry types.BeaconEntry) uint64 {
+func (db *DrandBeacon) MaxBeaconRoundForEpoch(filEpoch abi.ChainEpoch) uint64 {
 	// TODO: sometimes the genesis time for filecoin is zero and this goes negative
 	latestTs := ((uint64(filEpoch) * db.filRoundTime) + db.filGenTime) - db.filRoundTime
 	dround := (latestTs - db.drandGenTime) / uint64(db.interval.Seconds())
--- a/chain/beacon/drand/drand_test.go
+++ b/chain/beacon/drand/drand_test.go
@ -12,7 +12,7 @@ import (
 )

 func TestPrintGroupInfo(t *testing.T) {
-	server := build.DrandConfig().Servers[0]
+	server := build.DrandConfigs[build.DrandIncentinet].Servers[0]
 	c, err := hclient.New(server, nil, nil)
 	assert.NoError(t, err)
 	cg := c.(interface {
--- a/chain/beacon/mock.go
+++ b/chain/beacon/mock.go
@ -53,11 +53,7 @@ func (mb *mockBeacon) VerifyEntry(from types.BeaconEntry, to types.BeaconEntry)
 	return nil
 }

-func (mb *mockBeacon) IsEntryForEpoch(e types.BeaconEntry, epoch abi.ChainEpoch, nulls int) (bool, error) {
-	return int64(e.Round) <= int64(epoch) && int64(epoch)-int64(nulls) >= int64(e.Round), nil
-}
-
-func (mb *mockBeacon) MaxBeaconRoundForEpoch(epoch abi.ChainEpoch, prevEntry types.BeaconEntry) uint64 {
+func (mb *mockBeacon) MaxBeaconRoundForEpoch(epoch abi.ChainEpoch) uint64 {
 	return uint64(epoch)
 }

--- a/chain/gen/gen.go
+++ b/chain/gen/gen.go
@ -59,7 +59,7 @@ type ChainGen struct {

 	cs *store.ChainStore

-	beacon beacon.RandomBeacon
+	beacon beacon.Schedule

 	sm *stmgr.StateManager

@ -252,7 +252,7 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {

 	miners := []address.Address{maddr1, maddr2}

-	beac := beacon.NewMockBeacon(time.Second)
+	beac := beacon.Schedule{{Start: 0, Beacon: beacon.NewMockBeacon(time.Second)}}
 	//beac, err := drand.NewDrandBeacon(tpl.Timestamp, build.BlockDelaySecs)
 	//if err != nil {
 	//return nil, xerrors.Errorf("creating drand beacon: %w", err)
@ -338,7 +338,7 @@ func (cg *ChainGen) nextBlockProof(ctx context.Context, pts *types.TipSet, m add

 	prev := mbi.PrevBeaconEntry

-	entries, err := beacon.BeaconEntriesForBlock(ctx, cg.beacon, round, prev)
+	entries, err := beacon.BeaconEntriesForBlock(ctx, cg.beacon, round, pts.Height(), prev)
 	if err != nil {
 		return nil, nil, nil, xerrors.Errorf("get beacon entries for block: %w", err)
 	}
@ -358,7 +358,7 @@ func (cg *ChainGen) nextBlockProof(ctx context.Context, pts *types.TipSet, m add
 		return nil, nil, nil, xerrors.Errorf("failed to cbor marshal address: %w", err)
 	}

-	if len(entries) == 0 {
+	if round > build.UpgradeSmokeHeight {
 		buf.Write(pts.MinTicket().VRFProof)
 	}

@ -559,7 +559,7 @@ type mca struct {
 	w   *wallet.Wallet
 	sm  *stmgr.StateManager
 	pv  ffiwrapper.Verifier
-	bcn beacon.RandomBeacon
+	bcn beacon.Schedule
 }

 func (mca mca) ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
--- a/chain/gen/genesis/genesis.go
+++ b/chain/gen/genesis/genesis.go
@ -6,7 +6,7 @@ import (
 	"encoding/json"
 	"fmt"

-	"github.com/filecoin-project/specs-actors/actors/runtime"
+	"github.com/filecoin-project/go-state-types/network"

 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
@ -406,8 +406,8 @@ func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot ci
 	verifNeeds := make(map[address.Address]abi.PaddedPieceSize)
 	var sum abi.PaddedPieceSize

-	nwv := func(context.Context, abi.ChainEpoch) runtime.NetworkVersion {
-		return runtime.NetworkVersion1
+	nwv := func(context.Context, abi.ChainEpoch) network.Version {
+		return build.NewestNetworkVersion
 	}

 	vmopt := vm.VMOpts{
--- a/chain/gen/genesis/miners.go
+++ b/chain/gen/genesis/miners.go
@ -6,6 +6,10 @@ import (
 	"fmt"
 	"math/rand"

+	"github.com/filecoin-project/lotus/build"
+
+	"github.com/filecoin-project/go-state-types/network"
+
 	"github.com/filecoin-project/lotus/chain/state"

 	"github.com/ipfs/go-cid"
@ -61,8 +65,8 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 		return big.Zero(), nil
 	}

-	nwv := func(context.Context, abi.ChainEpoch) runtime.NetworkVersion {
-		return runtime.NetworkVersion1
+	nwv := func(context.Context, abi.ChainEpoch) network.Version {
+		return build.NewestNetworkVersion
 	}

 	vmopt := &vm.VMOpts{
--- a/chain/messagepool/messagepool.go
+++ b/chain/messagepool/messagepool.go
@ -12,6 +12,7 @@ import (
 	"time"

 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/hashicorp/go-multierror"
 	lru "github.com/hashicorp/golang-lru"
@ -160,6 +161,22 @@ func ComputeMinRBF(curPrem abi.TokenAmount) abi.TokenAmount {
 	return types.BigAdd(minPrice, types.NewInt(1))
 }

+func CapGasFee(msg *types.Message, maxFee abi.TokenAmount) {
+	if maxFee.Equals(big.Zero()) {
+		maxFee = types.NewInt(build.FilecoinPrecision / 10)
+	}
+
+	gl := types.NewInt(uint64(msg.GasLimit))
+	totalFee := types.BigMul(msg.GasFeeCap, gl)
+
+	if totalFee.LessThanEqual(maxFee) {
+		return
+	}
+
+	msg.GasFeeCap = big.Div(maxFee, gl)
+	msg.GasPremium = big.Min(msg.GasFeeCap, msg.GasPremium) // cap premium at FeeCap
+}
+
 func (ms *msgSet) add(m *types.SignedMessage, mp *MessagePool, strict bool) (bool, error) {
 	nextNonce := ms.nextNonce
 	nonceGap := false
@ -399,7 +416,7 @@ func (mp *MessagePool) verifyMsgBeforeAdd(m *types.SignedMessage, curTs *types.T
 	publish := local
 	if strictBaseFeeValidation && len(curTs.Blocks()) > 0 {
 		baseFee := curTs.Blocks()[0].ParentBaseFee
-		baseFeeLowerBound := types.BigDiv(baseFee, baseFeeLowerBoundFactor)
+		baseFeeLowerBound := getBaseFeeLowerBound(baseFee)
 		if m.Message.GasFeeCap.LessThan(baseFeeLowerBound) {
 			if local {
 				log.Warnf("local message will not be immediately published because GasFeeCap doesn't meet the lower bound for inclusion in the next 20 blocks (GasFeeCap: %s, baseFeeLowerBound: %s)",
@ -1282,3 +1299,12 @@ func (mp *MessagePool) Clear(local bool) {
 		delete(mp.pending, a)
 	}
 }
+
+func getBaseFeeLowerBound(baseFee types.BigInt) types.BigInt {
+	baseFeeLowerBound := types.BigDiv(baseFee, baseFeeLowerBoundFactor)
+	if baseFeeLowerBound.LessThan(minimumBaseFee) {
+		baseFeeLowerBound = minimumBaseFee
+	}
+
+	return baseFeeLowerBound
+}
--- a/chain/messagepool/pruning.go
+++ b/chain/messagepool/pruning.go
@ -46,13 +46,21 @@ func (mp *MessagePool) pruneMessages(ctx context.Context, ts *types.TipSet) erro
 	if err != nil {
 		return xerrors.Errorf("computing basefee: %w", err)
 	}
+	baseFeeLowerBound := getBaseFeeLowerBound(baseFee)

 	pending, _ := mp.getPendingMessages(ts, ts)

-	// priority actors -- not pruned
-	priority := make(map[address.Address]struct{})
+	// protected actors -- not pruned
+	protected := make(map[address.Address]struct{})
+
+	// we never prune priority addresses
 	for _, actor := range mp.cfg.PriorityAddrs {
-		priority[actor] = struct{}{}
+		protected[actor] = struct{}{}
+	}
+
+	// we also never prune locally published messages
+	for actor := range mp.localAddrs {
+		protected[actor] = struct{}{}
 	}

 	// Collect all messages to track which ones to remove and create chains for block inclusion
@ -61,18 +69,18 @@ func (mp *MessagePool) pruneMessages(ctx context.Context, ts *types.TipSet) erro

 	var chains []*msgChain
 	for actor, mset := range pending {
-		// we never prune priority actors
-		_, keep := priority[actor]
+		// we never prune protected actors
+		_, keep := protected[actor]
 		if keep {
 			keepCount += len(mset)
 			continue
 		}

-		// not a priority actor, track the messages and create chains
+		// not a protected actor, track the messages and create chains
 		for _, m := range mset {
 			pruneMsgs[m.Message.Cid()] = m
 		}
-		actorChains := mp.createMessageChains(actor, mset, baseFee, ts)
+		actorChains := mp.createMessageChains(actor, mset, baseFeeLowerBound, ts)
 		chains = append(chains, actorChains...)
 	}

--- a/chain/messagepool/repub.go
+++ b/chain/messagepool/repub.go
@ -27,11 +27,7 @@ func (mp *MessagePool) republishPendingMessages() error {
 		mp.curTsLk.Unlock()
 		return xerrors.Errorf("computing basefee: %w", err)
 	}
-
-	baseFeeLowerBound := types.BigDiv(baseFee, baseFeeLowerBoundFactor)
-	if baseFeeLowerBoundFactor.LessThan(minimumBaseFee) {
-		baseFeeLowerBound = minimumBaseFee
-	}
+	baseFeeLowerBound := getBaseFeeLowerBound(baseFee)

 	pending := make(map[address.Address]map[uint64]*types.SignedMessage)
 	mp.lk.Lock()
--- a/chain/stmgr/forks_test.go
+++ b/chain/stmgr/forks_test.go
@ -15,7 +15,6 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
 	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	"golang.org/x/xerrors"

 	"github.com/filecoin-project/lotus/chain/actors"
@ -73,15 +72,15 @@ func (ta *testActor) Exports() []interface{} {
 	}
 }

-func (ta *testActor) Constructor(rt runtime.Runtime, params *adt.EmptyValue) *adt.EmptyValue {
+func (ta *testActor) Constructor(rt runtime.Runtime, params *abi.EmptyValue) *abi.EmptyValue {
 	rt.ValidateImmediateCallerAcceptAny()
 	rt.State().Create(&testActorState{11})
 	fmt.Println("NEW ACTOR ADDRESS IS: ", rt.Message().Receiver())

-	return adt.Empty
+	return abi.Empty
 }

-func (ta *testActor) TestMethod(rt runtime.Runtime, params *adt.EmptyValue) *adt.EmptyValue {
+func (ta *testActor) TestMethod(rt runtime.Runtime, params *abi.EmptyValue) *abi.EmptyValue {
 	rt.ValidateImmediateCallerAcceptAny()
 	var st testActorState
 	rt.State().Readonly(&st)
@ -96,7 +95,7 @@ func (ta *testActor) TestMethod(rt runtime.Runtime, params *adt.EmptyValue) *adt
 		}
 	}

-	return adt.Empty
+	return abi.Empty
 }

 func TestForkHeightTriggers(t *testing.T) {
--- a/chain/stmgr/stmgr.go
+++ b/chain/stmgr/stmgr.go
@ -5,7 +5,7 @@ import (
 	"fmt"
 	"sync"

-	"github.com/filecoin-project/specs-actors/actors/runtime"
+	"github.com/filecoin-project/go-state-types/network"

 	"github.com/filecoin-project/specs-actors/actors/builtin/power"

@ -1124,14 +1124,18 @@ func (sm *StateManager) GetCirculatingSupply(ctx context.Context, height abi.Cha
 	return csi.FilCirculating, nil
 }

-func (sm *StateManager) GetNtwkVersion(ctx context.Context, height abi.ChainEpoch) runtime.NetworkVersion {
-	if build.UpgradeBreezeHeight == 0 {
-		return runtime.NetworkVersion1
+func (sm *StateManager) GetNtwkVersion(ctx context.Context, height abi.ChainEpoch) network.Version {
+	if build.UseNewestNetwork() {
+		return build.NewestNetworkVersion
 	}

 	if height <= build.UpgradeBreezeHeight {
-		return runtime.NetworkVersion0
+		return network.Version0
 	}

-	return runtime.NetworkVersion1
+	if height <= build.UpgradeSmokeHeight {
+		return network.Version1
+	}
+
+	return build.NewestNetworkVersion
 }
--- a/chain/stmgr/utils.go
+++ b/chain/stmgr/utils.go
@ -502,7 +502,7 @@ func GetLookbackTipSetForRound(ctx context.Context, sm *StateManager, ts *types.
 	return lbts, nil
 }

-func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcn beacon.RandomBeacon, tsk types.TipSetKey, round abi.ChainEpoch, maddr address.Address, pv ffiwrapper.Verifier) (*api.MiningBaseInfo, error) {
+func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcs beacon.Schedule, tsk types.TipSetKey, round abi.ChainEpoch, maddr address.Address, pv ffiwrapper.Verifier) (*api.MiningBaseInfo, error) {
 	ts, err := sm.ChainStore().LoadTipSet(tsk)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load tipset for mining base: %w", err)
@ -517,7 +517,7 @@ func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcn beacon.RandomBe
 		prev = &types.BeaconEntry{}
 	}

-	entries, err := beacon.BeaconEntriesForBlock(ctx, bcn, round, *prev)
+	entries, err := beacon.BeaconEntriesForBlock(ctx, bcs, round, ts.Height(), *prev)
 	if err != nil {
 		return nil, err
 	}
@ -624,8 +624,8 @@ func init() {
 		// Explicitly add send, it's special.
 		methods[builtin.MethodSend] = MethodMeta{
 			Name:   "Send",
-			Params: reflect.TypeOf(new(adt.EmptyValue)),
-			Ret:    reflect.TypeOf(new(adt.EmptyValue)),
+			Params: reflect.TypeOf(new(abi.EmptyValue)),
+			Ret:    reflect.TypeOf(new(abi.EmptyValue)),
 		}

 		// Learn method names from the builtin.Methods* structs.
--- a/chain/store/basefee.go
+++ b/chain/store/basefee.go
@ -11,14 +11,20 @@ import (
 	"golang.org/x/xerrors"
 )

-func computeNextBaseFee(baseFee types.BigInt, gasLimitUsed int64, noOfBlocks int) types.BigInt {
-	// deta := 1/PackingEfficiency * gasLimitUsed/noOfBlocks - build.BlockGasTarget
-	// change := baseFee * deta / BlockGasTarget / BaseFeeMaxChangeDenom
+func ComputeNextBaseFee(baseFee types.BigInt, gasLimitUsed int64, noOfBlocks int, epoch abi.ChainEpoch) types.BigInt {
+	// deta := gasLimitUsed/noOfBlocks - build.BlockGasTarget
+	// change := baseFee * deta / BlockGasTarget
 	// nextBaseFee = baseFee + change
 	// nextBaseFee = max(nextBaseFee, build.MinimumBaseFee)

-	delta := build.PackingEfficiencyDenom * gasLimitUsed / (int64(noOfBlocks) * build.PackingEfficiencyNum)
+	var delta int64
+	if epoch > build.UpgradeSmokeHeight {
+		delta = gasLimitUsed / int64(noOfBlocks)
 		delta -= build.BlockGasTarget
+	} else {
+		delta = build.PackingEfficiencyDenom * gasLimitUsed / (int64(noOfBlocks) * build.PackingEfficiencyNum)
+		delta -= build.BlockGasTarget
+	}

 	// cap change at 12.5% (BaseFeeMaxChangeDenom) by capping delta
 	if delta > build.BlockGasTarget {
@ -73,5 +79,5 @@ func (cs *ChainStore) ComputeBaseFee(ctx context.Context, ts *types.TipSet) (abi
 	}
 	parentBaseFee := ts.Blocks()[0].ParentBaseFee

-	return computeNextBaseFee(parentBaseFee, totalLimit, len(ts.Blocks())), nil
+	return ComputeNextBaseFee(parentBaseFee, totalLimit, len(ts.Blocks()), ts.Height()), nil
 }
--- a/chain/store/basefee_test.go
+++ b/chain/store/basefee_test.go
@ -27,7 +27,7 @@ func TestBaseFee(t *testing.T) {
 	for _, test := range tests {
 		test := test
 		t.Run(fmt.Sprintf("%v", test), func(t *testing.T) {
-			output := computeNextBaseFee(types.NewInt(test.basefee), test.limitUsed, test.noOfBlocks)
+			output := ComputeNextBaseFee(types.NewInt(test.basefee), test.limitUsed, test.noOfBlocks, 0)
 			assert.Equal(t, fmt.Sprintf("%d", test.output), output.String())
 		})
 	}
--- a/chain/store/store.go
+++ b/chain/store/store.go
@ -1159,7 +1159,7 @@ func recurseLinks(bs bstore.Blockstore, walked *cid.Set, root cid.Cid, in []cid.
 	return in, rerr
 }

-func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRoots abi.ChainEpoch, w io.Writer) error {
+func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRoots abi.ChainEpoch, skipOldMsgs bool, w io.Writer) error {
 	if ts == nil {
 		ts = cs.GetHeaviestTipSet()
 	}
@ -1197,10 +1197,14 @@ func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRo
 			return xerrors.Errorf("unmarshaling block header (cid=%s): %w", blk, err)
 		}

-		cids, err := recurseLinks(cs.bs, walked, b.Messages, []cid.Cid{b.Messages})
+		var cids []cid.Cid
+		if !skipOldMsgs || b.Height > ts.Height()-inclRecentRoots {
+			mcids, err := recurseLinks(cs.bs, walked, b.Messages, []cid.Cid{b.Messages})
 			if err != nil {
 				return xerrors.Errorf("recursing messages failed: %w", err)
 			}
+			cids = mcids
+		}

 		if b.Height > 0 {
 			for _, p := range b.Parents {
--- a/chain/store/store_test.go
+++ b/chain/store/store_test.go
@ -96,7 +96,7 @@ func TestChainExportImport(t *testing.T) {
 	}

 	buf := new(bytes.Buffer)
-	if err := cg.ChainStore().Export(context.TODO(), last, 0, buf); err != nil {
+	if err := cg.ChainStore().Export(context.TODO(), last, 0, false, buf); err != nil {
 		t.Fatal(err)
 	}

--- a/chain/sync.go
+++ b/chain/sync.go
@ -103,7 +103,7 @@ type Syncer struct {
 	store *store.ChainStore

 	// handle to the random beacon for verification
-	beacon beacon.RandomBeacon
+	beacon beacon.Schedule

 	// the state manager handles making state queries
 	sm *stmgr.StateManager
@ -141,7 +141,7 @@ type Syncer struct {
 }

 // NewSyncer creates a new Syncer object.
-func NewSyncer(ds dtypes.MetadataDS, sm *stmgr.StateManager, exchange exchange.Client, connmgr connmgr.ConnManager, self peer.ID, beacon beacon.RandomBeacon, verifier ffiwrapper.Verifier) (*Syncer, error) {
+func NewSyncer(ds dtypes.MetadataDS, sm *stmgr.StateManager, exchange exchange.Client, connmgr connmgr.ConnManager, self peer.ID, beacon beacon.Schedule, verifier ffiwrapper.Verifier) (*Syncer, error) {
 	gen, err := sm.ChainStore().GetGenesis()
 	if err != nil {
 		return nil, xerrors.Errorf("getting genesis block: %w", err)
@ -879,7 +879,7 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) (er
 			return nil
 		}

-		if err := beacon.ValidateBlockValues(syncer.beacon, h, *prevBeacon); err != nil {
+		if err := beacon.ValidateBlockValues(syncer.beacon, h, baseTs.Height(), *prevBeacon); err != nil {
 			return xerrors.Errorf("failed to validate blocks random beacon values: %w", err)
 		}
 		return nil
@ -891,10 +891,12 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) (er
 			return xerrors.Errorf("failed to marshal miner address to cbor: %w", err)
 		}

-		beaconBase := *prevBeacon
-		if len(h.BeaconEntries) == 0 {
+		if h.Height > build.UpgradeSmokeHeight {
 			buf.Write(baseTs.MinTicket().VRFProof)
-		} else {
+		}
+
+		beaconBase := *prevBeacon
+		if len(h.BeaconEntries) != 0 {
 			beaconBase = h.BeaconEntries[len(h.BeaconEntries)-1]
 		}

--- a/chain/vm/invoker.go
+++ b/chain/vm/invoker.go
@ -15,6 +15,7 @@ import (
 	"golang.org/x/xerrors"

 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/cron"
 	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
@ -27,9 +28,6 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin/system"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
 	vmr "github.com/filecoin-project/specs-actors/actors/runtime"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
-
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 )

 type Invoker struct {
@ -47,7 +45,7 @@ func NewInvoker() *Invoker {
 	}

 	// add builtInCode using: register(cid, singleton)
-	inv.Register(builtin.SystemActorCodeID, system.Actor{}, adt.EmptyValue{})
+	inv.Register(builtin.SystemActorCodeID, system.Actor{}, abi.EmptyValue{})
 	inv.Register(builtin.InitActorCodeID, init_.Actor{}, init_.State{})
 	inv.Register(builtin.RewardActorCodeID, reward.Actor{}, reward.State{})
 	inv.Register(builtin.CronActorCodeID, cron.Actor{}, cron.State{})
--- a/chain/vm/invoker_test.go
+++ b/chain/vm/invoker_test.go
@ -5,6 +5,8 @@ import (
 	"io"
 	"testing"

+	"github.com/filecoin-project/go-state-types/abi"
+
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"github.com/stretchr/testify/assert"
 	cbg "github.com/whyrusleeping/cbor-gen"
@ -13,7 +15,6 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 )

 type basicContract struct{}
@ -60,17 +61,17 @@ func (b basicContract) Exports() []interface{} {
 	}
 }

-func (basicContract) InvokeSomething0(rt runtime.Runtime, params *basicParams) *adt.EmptyValue {
+func (basicContract) InvokeSomething0(rt runtime.Runtime, params *basicParams) *abi.EmptyValue {
 	rt.Abortf(exitcode.ExitCode(params.B), "params.B")
 	return nil
 }

-func (basicContract) BadParam(rt runtime.Runtime, params *basicParams) *adt.EmptyValue {
+func (basicContract) BadParam(rt runtime.Runtime, params *basicParams) *abi.EmptyValue {
 	rt.Abortf(255, "bad params")
 	return nil
 }

-func (basicContract) InvokeSomething10(rt runtime.Runtime, params *basicParams) *adt.EmptyValue {
+func (basicContract) InvokeSomething10(rt runtime.Runtime, params *basicParams) *abi.EmptyValue {
 	rt.Abortf(exitcode.ExitCode(params.B+10), "params.B")
 	return nil
 }
--- a/chain/vm/runtime.go
+++ b/chain/vm/runtime.go
@ -8,6 +8,8 @@ import (
 	gruntime "runtime"
 	"time"

+	"github.com/filecoin-project/go-state-types/network"
+
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
@ -16,7 +18,6 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
 	vmr "github.com/filecoin-project/specs-actors/actors/runtime"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	"github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	cbg "github.com/whyrusleeping/cbor-gen"
@ -56,7 +57,7 @@ type Runtime struct {
 	lastGasCharge     *types.GasTrace
 }

-func (rt *Runtime) NetworkVersion() vmr.NetworkVersion {
+func (rt *Runtime) NetworkVersion() network.Version {
 	return rt.vm.GetNtwkVersion(rt.ctx, rt.CurrEpoch())
 }

@ -136,7 +137,7 @@ func (rt *Runtime) shimCall(f func() interface{}) (rval []byte, aerr aerrors.Act
 	switch ret := ret.(type) {
 	case []byte:
 		return ret, nil
-	case *adt.EmptyValue:
+	case *abi.EmptyValue:
 		return nil, nil
 	case cbg.CBORMarshaler:
 		buf := new(bytes.Buffer)
--- a/chain/vm/vm.go
+++ b/chain/vm/vm.go
@ -7,7 +7,7 @@ import (
 	"reflect"
 	"time"

-	"github.com/filecoin-project/specs-actors/actors/runtime"
+	"github.com/filecoin-project/go-state-types/network"

 	bstore "github.com/filecoin-project/lotus/lib/blockstore"

@ -142,7 +142,7 @@ func (vm *UnsafeVM) MakeRuntime(ctx context.Context, msg *types.Message, origin
 }

 type CircSupplyCalculator func(context.Context, abi.ChainEpoch, *state.StateTree) (abi.TokenAmount, error)
-type NtwkVersionGetter func(context.Context, abi.ChainEpoch) runtime.NetworkVersion
+type NtwkVersionGetter func(context.Context, abi.ChainEpoch) network.Version

 type VM struct {
 	cstate         *state.StateTree
@ -722,7 +722,7 @@ func (vm *VM) SetInvoker(i *Invoker) {
 	vm.inv = i
 }

-func (vm *VM) GetNtwkVersion(ctx context.Context, ce abi.ChainEpoch) runtime.NetworkVersion {
+func (vm *VM) GetNtwkVersion(ctx context.Context, ce abi.ChainEpoch) network.Version {
 	return vm.ntwkVersion(ctx, ce)
 }

--- a/cli/chain.go
+++ b/cli/chain.go
@ -844,6 +844,9 @@ var chainExportCmd = &cli.Command{
 			Name:  "recent-stateroots",
 			Usage: "specify the number of recent state roots to include in the export",
 		},
+		&cli.BoolFlag{
+			Name: "skip-old-msgs",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
@ -878,7 +881,13 @@ var chainExportCmd = &cli.Command{
 			return err
 		}

-		stream, err := api.ChainExport(ctx, rsrs, ts.Key())
+		skipold := cctx.Bool("skip-old-msgs")
+
+		if rsrs == 0 && skipold {
+			return fmt.Errorf("must pass recent stateroots along with skip-old-msgs")
+		}
+
+		stream, err := api.ChainExport(ctx, rsrs, skipold, ts.Key())
 		if err != nil {
 			return err
 		}
--- a/cli/mpool.go
+++ b/cli/mpool.go
@ -303,6 +303,10 @@ var mpoolReplaceCmd = &cli.Command{
 			Name:  "auto",
 			Usage: "automatically reprice the specified message",
 		},
+		&cli.StringFlag{
+			Name:  "max-fee",
+			Usage: "Spend up to X FIL for this message (applicable for auto mode)",
+		},
 	},
 	ArgsUsage: "[from] [nonce]",
 	Action: func(cctx *cli.Context) error {
@ -353,17 +357,30 @@ var mpoolReplaceCmd = &cli.Command{
 		msg := found.Message

 		if cctx.Bool("auto") {
+			minRBF := messagepool.ComputeMinRBF(msg.GasPremium)
+
+			var mss *lapi.MessageSendSpec
+			if cctx.IsSet("max-fee") {
+				maxFee, err := types.BigFromString(cctx.String("max-fee"))
+				if err != nil {
+					return fmt.Errorf("parsing max-spend: %w", err)
+				}
+				mss = &lapi.MessageSendSpec{
+					MaxFee: maxFee,
+				}
+			}
+
 			// msg.GasLimit = 0 // TODO: need to fix the way we estimate gas limits to account for the messages already being in the mempool
 			msg.GasFeeCap = abi.NewTokenAmount(0)
 			msg.GasPremium = abi.NewTokenAmount(0)
-			retm, err := api.GasEstimateMessageGas(ctx, &msg, &lapi.MessageSendSpec{}, types.EmptyTSK)
+			retm, err := api.GasEstimateMessageGas(ctx, &msg, mss, types.EmptyTSK)
 			if err != nil {
 				return fmt.Errorf("failed to estimate gas values: %w", err)
 			}
-			msg.GasFeeCap = retm.GasFeeCap

-			minRBF := messagepool.ComputeMinRBF(msg.GasPremium)
 			msg.GasPremium = big.Max(retm.GasPremium, minRBF)
+			msg.GasFeeCap = big.Max(retm.GasFeeCap, msg.GasPremium)
+			messagepool.CapGasFee(&msg, mss.Get().MaxFee)
 		} else {
 			msg.GasLimit = cctx.Int64("gas-limit")
 			msg.GasPremium, err = types.BigFromString(cctx.String("gas-premium"))
--- a/cli/paych.go
+++ b/cli/paych.go
@ -28,6 +28,7 @@ var paychCmd = &cli.Command{
 		paychListCmd,
 		paychVoucherCmd,
 		paychSettleCmd,
+		paychStatusCmd,
 		paychCloseCmd,
 	},
 }
--- a/cli/state.go
+++ b/cli/state.go
@ -27,6 +27,7 @@ import (

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/exitcode"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/exported"
@ -122,7 +123,7 @@ var stateMinerInfo = &cli.Command{
 	},
 }

-func parseTipSetString(ts string) ([]cid.Cid, error) {
+func ParseTipSetString(ts string) ([]cid.Cid, error) {
 	strs := strings.Split(ts, ",")

 	var cids []cid.Cid
@ -160,7 +161,7 @@ func ParseTipSetRef(ctx context.Context, api api.FullNode, tss string) (*types.T
 		return api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(h), types.EmptyTSK)
 	}

-	cids, err := parseTipSetString(tss)
+	cids, err := ParseTipSetString(tss)
 	if err != nil {
 		return nil, err
 	}
@ -1384,7 +1385,7 @@ var stateCallCmd = &cli.Command{
 		}

 		if ret.MsgRct.ExitCode != 0 {
-			return fmt.Errorf("invocation failed (exit: %d): %s", ret.MsgRct.ExitCode, ret.Error)
+			return fmt.Errorf("invocation failed (exit: %d, gasUsed: %d): %s", ret.MsgRct.ExitCode, ret.MsgRct.GasUsed, ret.Error)
 		}

 		s, err := formatOutput(cctx.String("ret"), ret.MsgRct.Return)
@ -1392,6 +1393,7 @@ var stateCallCmd = &cli.Command{
 			return fmt.Errorf("failed to format output: %s", err)
 		}

+		fmt.Printf("gas used: %d\n", ret.MsgRct.GasUsed)
 		fmt.Printf("return: %s\n", s)

 		return nil
@ -1465,11 +1467,11 @@ func parseParamsForMethod(act cid.Cid, method uint64, args []string) ([]byte, er
 	f := methods[method]

 	rf := reflect.TypeOf(f)
-	if rf.NumIn() != 3 {
+	if rf.NumIn() != 2 {
 		return nil, fmt.Errorf("expected referenced method to have three arguments")
 	}

-	paramObj := rf.In(2).Elem()
+	paramObj := rf.In(1).Elem()
 	if paramObj.NumField() != len(args) {
 		return nil, fmt.Errorf("not enough arguments given to call that method (expecting %d)", paramObj.NumField())
 	}
@ -1489,6 +1491,18 @@ func parseParamsForMethod(act cid.Cid, method uint64, args []string) ([]byte, er
 				return nil, err
 			}
 			p.Elem().Field(i).Set(reflect.ValueOf(val))
+		case reflect.TypeOf(abi.ChainEpoch(0)):
+			val, err := strconv.ParseInt(args[i], 10, 64)
+			if err != nil {
+				return nil, err
+			}
+			p.Elem().Field(i).Set(reflect.ValueOf(abi.ChainEpoch(val)))
+		case reflect.TypeOf(big.Int{}):
+			val, err := big.FromString(args[i])
+			if err != nil {
+				return nil, err
+			}
+			p.Elem().Field(i).Set(reflect.ValueOf(val))
 		case reflect.TypeOf(peer.ID("")):
 			pid, err := peer.Decode(args[i])
 			if err != nil {
--- a/cmd/lotus-shed/export.go
+++ b/cmd/lotus-shed/export.go
@ -0,0 +1,123 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/node/repo"
+)
+
+var exportChainCmd = &cli.Command{
+	Name:        "export",
+	Description: "Export chain from repo (requires node to be offline)",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "repo",
+			Value: "~/.lotus",
+		},
+		&cli.StringFlag{
+			Name:  "tipset",
+			Usage: "tipset to export from",
+		},
+		&cli.Int64Flag{
+			Name: "recent-stateroots",
+		},
+		&cli.BoolFlag{
+			Name: "full-state",
+		},
+		&cli.BoolFlag{
+			Name: "skip-old-msgs",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return lcli.ShowHelp(cctx, fmt.Errorf("must specify file name to write export to"))
+		}
+
+		ctx := context.TODO()
+
+		r, err := repo.NewFS(cctx.String("repo"))
+		if err != nil {
+			return xerrors.Errorf("opening fs repo: %w", err)
+		}
+
+		exists, err := r.Exists()
+		if err != nil {
+			return err
+		}
+		if !exists {
+			return xerrors.Errorf("lotus repo doesn't exist")
+		}
+
+		lr, err := r.Lock(repo.FullNode)
+		if err != nil {
+			return err
+		}
+		defer lr.Close() //nolint:errcheck
+
+		fi, err := os.Create(cctx.Args().First())
+		if err != nil {
+			return xerrors.Errorf("opening the output file: %w", err)
+		}
+
+		defer fi.Close() //nolint:errcheck
+
+		ds, err := lr.Datastore("/chain")
+		if err != nil {
+			return err
+		}
+
+		mds, err := lr.Datastore("/metadata")
+		if err != nil {
+			return err
+		}
+
+		bs := blockstore.NewBlockstore(ds)
+
+		cs := store.NewChainStore(bs, mds, nil)
+		if err := cs.Load(); err != nil {
+			return err
+		}
+
+		nroots := abi.ChainEpoch(cctx.Int64("recent-stateroots"))
+		fullstate := cctx.Bool("full-state")
+		skipoldmsgs := cctx.Bool("skip-old-msgs")
+
+		var ts *types.TipSet
+		if tss := cctx.String("tipset"); tss != "" {
+			cids, err := lcli.ParseTipSetString(tss)
+			if err != nil {
+				return xerrors.Errorf("failed to parse tipset (%q): %w", tss, err)
+			}
+
+			tsk := types.NewTipSetKey(cids...)
+
+			selts, err := cs.LoadTipSet(tsk)
+			if err != nil {
+				return xerrors.Errorf("loading tipset: %w", err)
+			}
+			ts = selts
+		} else {
+			ts = cs.GetHeaviestTipSet()
+		}
+
+		if fullstate {
+			nroots = ts.Height() + 1
+		}
+
+		if err := cs.Export(ctx, ts, nroots, skipoldmsgs, fi); err != nil {
+			return xerrors.Errorf("export failed: %w", err)
+		}
+
+		return nil
+	},
+}
--- a/cmd/lotus-shed/main.go
+++ b/cmd/lotus-shed/main.go
@ -34,6 +34,7 @@ func main() {
 		genesisVerifyCmd,
 		mathCmd,
 		mpoolStatsCmd,
+		exportChainCmd,
 	}

 	app := &cli.App{
--- a/cmd/lotus/debug_advance.go
+++ b/cmd/lotus/debug_advance.go
@ -46,6 +46,7 @@ func init() {
 					return xerrors.Errorf("StateMinerWorker: %w", err)
 				}

+				// XXX: This can't be right
 				rand, err := api.ChainGetRandomnessFromTickets(ctx, head.Key(), crypto.DomainSeparationTag_TicketProduction, head.Height(), addr.Bytes())
 				if err != nil {
 					return xerrors.Errorf("failed to get randomness: %w", err)
--- a/conformance/chaos/actor.go
+++ b/conformance/chaos/actor.go
@ -6,7 +6,6 @@ import (
 	"github.com/filecoin-project/go-state-types/exitcode"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	"github.com/ipfs/go-cid"

 	typegen "github.com/whyrusleeping/cbor-gen"
@ -120,7 +119,7 @@ func (a Actor) Send(rt runtime.Runtime, args *SendArgs) *SendReturn {
 }

 // Constructor will panic because the Chaos actor is a singleton.
-func (a Actor) Constructor(_ runtime.Runtime, _ *adt.EmptyValue) *adt.EmptyValue {
+func (a Actor) Constructor(_ runtime.Runtime, _ *abi.EmptyValue) *abi.EmptyValue {
 	panic("constructor should not be called; the Chaos actor is a singleton actor")
 }

@ -131,7 +130,7 @@ func (a Actor) Constructor(_ runtime.Runtime, _ *adt.EmptyValue) *adt.EmptyValue
 //  CallerValidationBranchAddrNilSet validates against an empty caller
 //  address set.
 //  CallerValidationBranchTypeNilSet validates against an empty caller type set.
-func (a Actor) CallerValidation(rt runtime.Runtime, branch *typegen.CborInt) *adt.EmptyValue {
+func (a Actor) CallerValidation(rt runtime.Runtime, branch *typegen.CborInt) *abi.EmptyValue {
 	switch CallerValidationBranch(*branch) {
 	case CallerValidationBranchNone:
 	case CallerValidationBranchTwice:
@ -161,7 +160,7 @@ type CreateActorArgs struct {
 }

 // CreateActor creates an actor with the supplied CID and Address.
-func (a Actor) CreateActor(rt runtime.Runtime, args *CreateActorArgs) *adt.EmptyValue {
+func (a Actor) CreateActor(rt runtime.Runtime, args *CreateActorArgs) *abi.EmptyValue {
 	rt.ValidateImmediateCallerAcceptAny()

 	var (
@ -199,7 +198,7 @@ func (a Actor) ResolveAddress(rt runtime.Runtime, args *address.Address) *Resolv

 // DeleteActor deletes the executing actor from the state tree, transferring any
 // balance to beneficiary.
-func (a Actor) DeleteActor(rt runtime.Runtime, beneficiary *address.Address) *adt.EmptyValue {
+func (a Actor) DeleteActor(rt runtime.Runtime, beneficiary *address.Address) *abi.EmptyValue {
 	rt.ValidateImmediateCallerAcceptAny()
 	rt.DeleteActor(*beneficiary)
 	return nil
@ -213,7 +212,7 @@ type MutateStateArgs struct {
 }

 // MutateState attempts to mutate a state value in the actor.
-func (a Actor) MutateState(rt runtime.Runtime, args *MutateStateArgs) *adt.EmptyValue {
+func (a Actor) MutateState(rt runtime.Runtime, args *MutateStateArgs) *abi.EmptyValue {
 	rt.ValidateImmediateCallerAcceptAny()
 	var st State
 	switch args.Branch {
@ -244,7 +243,7 @@ type AbortWithArgs struct {
 }

 // AbortWith simply causes a panic with the passed exit code.
-func (a Actor) AbortWith(rt runtime.Runtime, args *AbortWithArgs) *adt.EmptyValue {
+func (a Actor) AbortWith(rt runtime.Runtime, args *AbortWithArgs) *abi.EmptyValue {
 	if args.Uncontrolled { // uncontrolled abort: directly panic
 		panic(args.Message)
 	} else {
--- a/conformance/chaos/actor_test.go
+++ b/conformance/chaos/actor_test.go
@ -0,0 +1,153 @@
+package chaos
+
+import (
+	"context"
+	"testing"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/specs-actors/support/mock"
+	atesting "github.com/filecoin-project/specs-actors/support/testing"
+)
+
+func TestSingleton(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	msg := "constructor should not be called; the Chaos actor is a singleton actor"
+	rt.ExpectAssertionFailure(msg, func() {
+		rt.Call(a.Constructor, abi.Empty)
+	})
+	rt.Verify()
+}
+
+func TestDeleteActor(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	beneficiary := atesting.NewIDAddr(t, 101)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.ExpectDeleteActor(beneficiary)
+	rt.Call(a.DeleteActor, &beneficiary)
+	rt.Verify()
+}
+
+func TestMutateStateInTransaction(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.Create(&State{})
+
+	val := "__mutstat test"
+	rt.Call(a.MutateState, &MutateStateArgs{
+		Value:  val,
+		Branch: MutateInTransaction,
+	})
+
+	var st State
+	rt.GetState(&st)
+
+	if st.Value != val {
+		t.Fatal("state was not updated")
+	}
+
+	rt.Verify()
+}
+
+func TestMutateStateAfterTransaction(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.Create(&State{})
+
+	val := "__mutstat test"
+	rt.Call(a.MutateState, &MutateStateArgs{
+		Value:  val,
+		Branch: MutateAfterTransaction,
+	})
+
+	var st State
+	rt.GetState(&st)
+
+	// state should be updated successfully _in_ the transaction but not outside
+	if st.Value != val+"-in" {
+		t.Fatal("state was not updated")
+	}
+
+	rt.Verify()
+}
+
+func TestMutateStateReadonly(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.Create(&State{})
+
+	val := "__mutstat test"
+	rt.Call(a.MutateState, &MutateStateArgs{
+		Value:  val,
+		Branch: MutateReadonly,
+	})
+
+	var st State
+	rt.GetState(&st)
+
+	if st.Value != "" {
+		t.Fatal("state was not expected to be updated")
+	}
+
+	rt.Verify()
+}
+
+func TestAbortWith(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	msg := "__test forbidden"
+	rt.ExpectAbortContainsMessage(exitcode.ErrForbidden, msg, func() {
+		rt.Call(a.AbortWith, &AbortWithArgs{
+			Code:         exitcode.ErrForbidden,
+			Message:      msg,
+			Uncontrolled: false,
+		})
+	})
+	rt.Verify()
+}
+
+func TestAbortWithUncontrolled(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	msg := "__test uncontrolled panic"
+	rt.ExpectAssertionFailure(msg, func() {
+		rt.Call(a.AbortWith, &AbortWithArgs{
+			Message:      msg,
+			Uncontrolled: true,
+		})
+	})
+	rt.Verify()
+}
--- a/documentation/en/api-methods.md
+++ b/documentation/en/api-methods.md
@ -284,6 +284,7 @@ ChainExport returns a stream of bytes with CAR dump of chain data.
 The exported chain data includes the header chain from the given tipset
 back to genesis, the entire genesis state, and the most recent 'nroots'
 state trees.
+If oldmsgskip is set, messages from before the requested roots are also not included.


 Perms: read
@ -292,6 +293,7 @@ Inputs:
 ```json
 [
  10101,
+  true,
  [
    {
      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
@ -3633,7 +3635,12 @@ Response:
  "Open": 10101,
  "Close": 10101,
  "Challenge": 10101,
-  "FaultCutoff": 10101
+  "FaultCutoff": 10101,
+  "WPoStPeriodDeadlines": 42,
+  "WPoStProvingPeriod": 10101,
+  "WPoStChallengeWindow": 10101,
+  "WPoStChallengeLookback": 10101,
+  "FaultDeclarationCutoff": 10101
 }
 ```

--- a/extern/fil-blst
+++ b/extern/fil-blst
@ -0,0 +1 @@
+Subproject commit 5f93488fc0dbfb450f2355269f18fc67010d59bb
--- a/extern/filecoin-ffi
+++ b/extern/filecoin-ffi
@ -1 +1 @@
-Subproject commit 40569104603407c999d6c9e4c3f1228cbd4d0e5c
+Subproject commit f640612a1a1f7a2dd8b3a49e1531db0aa0f63447
--- a/extern/sector-storage/ffiwrapper/sealer_test.go
+++ b/extern/sector-storage/ffiwrapper/sealer_test.go
@ -168,50 +168,34 @@ func (s *seal) unseal(t *testing.T, sb *Sealer, sp *basicfs.Provider, si abi.Sec
 	}
 }

-func post(t *testing.T, sealer *Sealer, seals ...seal) time.Time {
-	/*randomness := abi.PoStRandomness{0, 9, 2, 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 7, 6, 45, 3, 2, 1, 0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 9, 7}
+func post(t *testing.T, sealer *Sealer, skipped []abi.SectorID, seals ...seal) {
+	randomness := abi.PoStRandomness{0, 9, 2, 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 7, 6, 45, 3, 2, 1, 0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 9, 7}

-	sis := make([]abi.SectorInfo, len(seals))
+	sis := make([]saproof.SectorInfo, len(seals))
 	for i, s := range seals {
-		sis[i] = abi.SectorInfo{
-			RegisteredProof: sealProofType,
+		sis[i] = saproof.SectorInfo{
+			SealProof:    sealProofType,
 			SectorNumber: s.id.Number,
 			SealedCID:    s.cids.Sealed,
 		}
 	}

-	candidates, err := sealer.GenerateEPostCandidates(context.TODO(), seals[0].id.Miner, sis, randomness, []abi.SectorNumber{})
-	if err != nil {
-		t.Fatalf("%+v", err)
-	}*/
-
-	fmt.Println("skipping post")
-
-	genCandidates := time.Now()
-
-	/*if len(candidates) != 1 {
-		t.Fatal("expected 1 candidate")
+	proofs, skp, err := sealer.GenerateWindowPoSt(context.TODO(), seals[0].id.Miner, sis, randomness)
+	if len(skipped) > 0 {
+		require.Error(t, err)
+		require.EqualValues(t, skipped, skp)
+		return
 	}

-	candidatesPrime := make([]abi.PoStCandidate, len(candidates))
-	for idx := range candidatesPrime {
-		candidatesPrime[idx] = candidates[idx].Candidate
-	}
-
-	proofs, err := sealer.ComputeElectionPoSt(context.TODO(), seals[0].id.Miner, sis, randomness, candidatesPrime)
 	if err != nil {
 		t.Fatalf("%+v", err)
 	}

-	ePoStChallengeCount := ElectionPostChallengeCount(uint64(len(sis)), 0)
-
-	ok, err := ProofVerifier.VerifyElectionPost(context.TODO(), abi.PoStVerifyInfo{
+	ok, err := ProofVerifier.VerifyWindowPoSt(context.TODO(), saproof.WindowPoStVerifyInfo{
 		Randomness:        randomness,
-		Candidates:      candidatesPrime,
 		Proofs:            proofs,
-		EligibleSectors: sis,
+		ChallengedSectors: sis,
 		Prover:            seals[0].id.Miner,
-		ChallengeCount:  ePoStChallengeCount,
 	})
 	if err != nil {
 		t.Fatalf("%+v", err)
@ -219,8 +203,21 @@ func post(t *testing.T, sealer *Sealer, seals ...seal) time.Time {
 	if !ok {
 		t.Fatal("bad post")
 	}
-	*/
-	return genCandidates
+}
+
+func corrupt(t *testing.T, sealer *Sealer, id abi.SectorID) {
+	paths, done, err := sealer.sectors.AcquireSector(context.Background(), id, stores.FTSealed, 0, stores.PathStorage)
+	require.NoError(t, err)
+	defer done()
+
+	log.Infof("corrupt %s", paths.Sealed)
+	f, err := os.OpenFile(paths.Sealed, os.O_RDWR, 0664)
+	require.NoError(t, err)
+
+	_, err = f.WriteAt(bytes.Repeat([]byte{'d'}, 2048), 0)
+	require.NoError(t, err)
+
+	require.NoError(t, f.Close())
 }

 func getGrothParamFileAndVerifyingKeys(s abi.SectorSize) {
@ -299,11 +296,11 @@ func TestSealAndVerify(t *testing.T) {

 	commit := time.Now()

-	genCandidiates := post(t, sb, s)
+	post(t, sb, nil, s)

 	epost := time.Now()

-	post(t, sb, s)
+	post(t, sb, nil, s)

 	if err := sb.FinalizeSector(context.TODO(), si, nil); err != nil {
 		t.Fatalf("%+v", err)
@ -313,8 +310,7 @@ func TestSealAndVerify(t *testing.T) {

 	fmt.Printf("PreCommit: %s\n", precommit.Sub(start).String())
 	fmt.Printf("Commit: %s\n", commit.Sub(precommit).String())
-	fmt.Printf("GenCandidates: %s\n", genCandidiates.Sub(commit).String())
-	fmt.Printf("EPoSt: %s\n", epost.Sub(genCandidiates).String())
+	fmt.Printf("EPoSt: %s\n", epost.Sub(commit).String())
 }

 func TestSealPoStNoCommit(t *testing.T) {
@ -370,16 +366,15 @@ func TestSealPoStNoCommit(t *testing.T) {
 		t.Fatal(err)
 	}

-	genCandidiates := post(t, sb, s)
+	post(t, sb, nil, s)

 	epost := time.Now()

 	fmt.Printf("PreCommit: %s\n", precommit.Sub(start).String())
-	fmt.Printf("GenCandidates: %s\n", genCandidiates.Sub(precommit).String())
-	fmt.Printf("EPoSt: %s\n", epost.Sub(genCandidiates).String())
+	fmt.Printf("EPoSt: %s\n", epost.Sub(precommit).String())
 }

-func TestSealAndVerify2(t *testing.T) {
+func TestSealAndVerify3(t *testing.T) {
 	defer requireFDsClosed(t, openFDs(t))

 	if runtime.NumCPU() < 10 && os.Getenv("CI") == "" { // don't bother on slow hardware
@ -419,22 +414,32 @@ func TestSealAndVerify2(t *testing.T) {

 	si1 := abi.SectorID{Miner: miner, Number: 1}
 	si2 := abi.SectorID{Miner: miner, Number: 2}
+	si3 := abi.SectorID{Miner: miner, Number: 3}

 	s1 := seal{id: si1}
 	s2 := seal{id: si2}
+	s3 := seal{id: si3}

-	wg.Add(2)
+	wg.Add(3)
 	go s1.precommit(t, sb, si1, wg.Done) //nolint: staticcheck
 	time.Sleep(100 * time.Millisecond)
 	go s2.precommit(t, sb, si2, wg.Done) //nolint: staticcheck
+	time.Sleep(100 * time.Millisecond)
+	go s3.precommit(t, sb, si3, wg.Done) //nolint: staticcheck
 	wg.Wait()

-	wg.Add(2)
+	wg.Add(3)
 	go s1.commit(t, sb, wg.Done) //nolint: staticcheck
 	go s2.commit(t, sb, wg.Done) //nolint: staticcheck
+	go s3.commit(t, sb, wg.Done) //nolint: staticcheck
 	wg.Wait()

-	post(t, sb, s1, s2)
+	post(t, sb, nil, s1, s2, s3)
+
+	corrupt(t, sb, si1)
+	corrupt(t, sb, si2)
+
+	post(t, sb, []abi.SectorID{si1, si2}, s1, s2, s3)
 }

 func BenchmarkWriteWithAlignment(b *testing.B) {
--- a/extern/sector-storage/ffiwrapper/verifier_cgo.go
+++ b/extern/sector-storage/ffiwrapper/verifier_cgo.go
@ -39,8 +39,21 @@ func (sb *Sealer) GenerateWindowPoSt(ctx context.Context, minerID abi.ActorID, s
 	}
 	defer done()

-	proof, err := ffi.GenerateWindowPoSt(minerID, privsectors, randomness)
-	return proof, skipped, err
+	if len(skipped) > 0 {
+		return nil, skipped, xerrors.Errorf("pubSectorToPriv skipped some sectors")
+	}
+
+	proof, faulty, err := ffi.GenerateWindowPoSt(minerID, privsectors, randomness)
+
+	var faultyIDs []abi.SectorID
+	for _, f := range faulty {
+		faultyIDs = append(faultyIDs, abi.SectorID{
+			Miner:  minerID,
+			Number: f,
+		})
+	}
+
+	return proof, faultyIDs, err
 }

 func (sb *Sealer) pubSectorToPriv(ctx context.Context, mid abi.ActorID, sectorInfo []proof.SectorInfo, faults []abi.SectorNumber, rpt func(abi.RegisteredSealProof) (abi.RegisteredPoStProof, error)) (ffi.SortedPrivateSectorInfo, []abi.SectorID, func(), error) {
--- a/extern/sector-storage/mock/mock.go
+++ b/extern/sector-storage/mock/mock.go
@ -68,6 +68,7 @@ const (
 type sectorState struct {
 	pieces    []cid.Cid
 	failed    bool
+	corrupted bool

 	state int

@ -251,6 +252,18 @@ func (mgr *SectorMgr) MarkFailed(sid abi.SectorID, failed bool) error {
 	return nil
 }

+func (mgr *SectorMgr) MarkCorrupted(sid abi.SectorID, corrupted bool) error {
+	mgr.lk.Lock()
+	defer mgr.lk.Unlock()
+	ss, ok := mgr.sectors[sid]
+	if !ok {
+		return fmt.Errorf("no such sector in storage")
+	}
+
+	ss.corrupted = corrupted
+	return nil
+}
+
 func opFinishWait(ctx context.Context) {
 	val, ok := ctx.Value("opfinish").(chan struct{})
 	if !ok {
@ -275,6 +288,8 @@ func (mgr *SectorMgr) GenerateWindowPoSt(ctx context.Context, minerID abi.ActorI
 	si := make([]proof.SectorInfo, 0, len(sectorInfo))
 	var skipped []abi.SectorID

+	var err error
+
 	for _, info := range sectorInfo {
 		sid := abi.SectorID{
 			Miner:  minerID,
@ -283,13 +298,18 @@ func (mgr *SectorMgr) GenerateWindowPoSt(ctx context.Context, minerID abi.ActorI

 		_, found := mgr.sectors[sid]

-		if found && !mgr.sectors[sid].failed {
+		if found && !mgr.sectors[sid].failed && !mgr.sectors[sid].corrupted {
 			si = append(si, info)
 		} else {
 			skipped = append(skipped, sid)
+			err = xerrors.Errorf("skipped some sectors")
 		}
 	}

+	if err != nil {
+		return nil, skipped, err
+	}
+
 	return generateFakePoSt(si, abi.RegisteredSealProof.RegisteredWindowPoStProof, randomness), skipped, nil
 }

--- a/extern/storage-sealing/sealing.go
+++ b/extern/storage-sealing/sealing.go
@ -28,6 +28,8 @@ import (

 const SectorStorePrefix = "/sectors"

+var ErrTooManySectorsSealing = xerrors.New("too many sectors sealing")
+
 var log = logging.Logger("sectors")

 type SectorLocation struct {
@ -280,7 +282,7 @@ func (m *Sealing) newDealSector() (abi.SectorNumber, error) {

 	if cfg.MaxSealingSectorsForDeals > 0 {
 		if m.stats.curSealing() > cfg.MaxSealingSectorsForDeals {
-			return 0, xerrors.Errorf("too many sectors sealing")
+			return 0, ErrTooManySectorsSealing
 		}
 	}

--- a/go.mod
+++ b/go.mod
@ -2,8 +2,6 @@ module github.com/filecoin-project/lotus

 go 1.14

-replace github.com/supranational/blst => github.com/supranational/blst v0.1.2-alpha.1
-
 require (
 	contrib.go.opencensus.io/exporter/jaeger v0.1.0
 	contrib.go.opencensus.io/exporter/prometheus v0.1.0
@ -15,10 +13,10 @@ require (
 	github.com/buger/goterm v0.0.0-20200322175922-2f3e71b85129
 	github.com/coreos/go-systemd/v22 v22.0.0
 	github.com/detailyang/go-fallocate v0.0.0-20180908115635-432fa640bd2e
-	github.com/dgraph-io/badger/v2 v2.0.3
+	github.com/dgraph-io/badger/v2 v2.2007.2
 	github.com/docker/go-units v0.4.0
-	github.com/drand/drand v1.0.3-0.20200714175734-29705eaf09d4
-	github.com/drand/kyber v1.1.1
+	github.com/drand/drand v1.1.2-0.20200905144319-79c957281b32
+	github.com/drand/kyber v1.1.2
 	github.com/dustin/go-humanize v1.0.0
 	github.com/elastic/go-sysinfo v1.3.0
 	github.com/fatih/color v1.8.0
@ -29,16 +27,16 @@ require (
 	github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03
 	github.com/filecoin-project/go-data-transfer v0.6.3
 	github.com/filecoin-project/go-fil-commcid v0.0.0-20200716160307-8f644712406f
-	github.com/filecoin-project/go-fil-markets v0.6.0
+	github.com/filecoin-project/go-fil-markets v0.6.1-0.20200911011457-2959ccca6a3c
 	github.com/filecoin-project/go-jsonrpc v0.1.2-0.20200822201400-474f4fdccc52
 	github.com/filecoin-project/go-multistore v0.0.3
 	github.com/filecoin-project/go-padreader v0.0.0-20200903213702-ed5fae088b20
 	github.com/filecoin-project/go-paramfetch v0.0.2-0.20200701152213-3e0f0afdc261
-	github.com/filecoin-project/go-state-types v0.0.0-20200905071437-95828685f9df
+	github.com/filecoin-project/go-state-types v0.0.0-20200909080127-001afaca718c
 	github.com/filecoin-project/go-statemachine v0.0.0-20200813232949-df9b130df370
 	github.com/filecoin-project/go-statestore v0.1.0
 	github.com/filecoin-project/go-storedcounter v0.0.0-20200421200003-1c99c62e8a5b
-	github.com/filecoin-project/specs-actors v0.9.7
+	github.com/filecoin-project/specs-actors v0.9.8
 	github.com/filecoin-project/specs-storage v0.1.1-0.20200907031224-ed2e5cd13796
 	github.com/filecoin-project/test-vectors/schema v0.0.1
 	github.com/gbrlsnchs/jwt/v3 v3.0.0-beta.1
@ -135,6 +133,8 @@ replace github.com/golangci/golangci-lint => github.com/golangci/golangci-lint v

 replace github.com/filecoin-project/filecoin-ffi => ./extern/filecoin-ffi

-replace github.com/dgraph-io/badger/v2 => github.com/dgraph-io/badger/v2 v2.0.1-rc1.0.20200716180832-3ab515320794
-
 replace github.com/filecoin-project/test-vectors => ./extern/test-vectors
+
+replace github.com/supranational/blst => ./extern/fil-blst/blst
+
+replace github.com/filecoin-project/fil-blst => ./extern/fil-blst
--- a/go.sum
+++ b/go.sum
@ -91,6 +91,7 @@ github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
 github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
+github.com/briandowns/spinner v1.11.1 h1:OixPqDEcX3juo5AjQZAnFPbeUA0jvkp2qzB5gOZJ/L0=
 github.com/briandowns/spinner v1.11.1/go.mod h1:QOuQk7x+EaDASo80FEXwlwiA+j/PPIcX3FScO+3/ZPQ=
 github.com/btcsuite/btcd v0.0.0-20190213025234-306aecffea32/go.mod h1:DrZx5ec/dmnfpw9KyYoQyYo7d0KEvTkk/5M/vbZjAr8=
 github.com/btcsuite/btcd v0.0.0-20190523000118-16327141da8c/go.mod h1:3J08xEfcugPacsc34/LKRU2yO7YmuT8yt28J8k2+rrI=
@ -166,8 +167,10 @@ github.com/dgraph-io/badger v1.6.0-rc1/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhY
 github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4=
 github.com/dgraph-io/badger v1.6.1 h1:w9pSFNSdq/JPM1N12Fz/F/bzo993Is1W+Q7HjPzi7yg=
 github.com/dgraph-io/badger v1.6.1/go.mod h1:FRmFw3uxvcpa8zG3Rxs0th+hCLIuaQg8HlNV5bjgnuU=
-github.com/dgraph-io/badger/v2 v2.0.1-rc1.0.20200716180832-3ab515320794 h1:PIPH4SLjYXMMlX/cQqV7nIRatv7556yqUfWY+KBjrtQ=
-github.com/dgraph-io/badger/v2 v2.0.1-rc1.0.20200716180832-3ab515320794/go.mod h1:26P/7fbL4kUZVEVKLAKXkBXKOydDmM2p1e+NhhnBCAE=
+github.com/dgraph-io/badger/v2 v2.0.3/go.mod h1:3KY8+bsP8wI0OEnQJAKpd4wIJW/Mm32yw2j/9FUVnIM=
+github.com/dgraph-io/badger/v2 v2.2007.2 h1:EjjK0KqwaFMlPin1ajhP943VPENHJdEz1KLIegjaI3k=
+github.com/dgraph-io/badger/v2 v2.2007.2/go.mod h1:26P/7fbL4kUZVEVKLAKXkBXKOydDmM2p1e+NhhnBCAE=
+github.com/dgraph-io/ristretto v0.0.2-0.20200115201040-8f368f2f2ab3/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E=
 github.com/dgraph-io/ristretto v0.0.2/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E=
 github.com/dgraph-io/ristretto v0.0.3-0.20200630154024-f66de99634de h1:t0UHb5vdojIDUqktM6+xJAfScFBsVpXZmqC9dsgJmeA=
 github.com/dgraph-io/ristretto v0.0.3-0.20200630154024-f66de99634de/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E=
@ -179,12 +182,12 @@ github.com/docker/go-units v0.4.0 h1:3uh0PgVws3nIA0Q+MwDC8yjEPf9zjRfZZWXZYDct3Tw
 github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
 github.com/drand/bls12-381 v0.3.2 h1:RImU8Wckmx8XQx1tp1q04OV73J9Tj6mmpQLYDP7V1XE=
 github.com/drand/bls12-381 v0.3.2/go.mod h1:dtcLgPtYT38L3NO6mPDYH0nbpc5tjPassDqiniuAt4Y=
-github.com/drand/drand v1.0.3-0.20200714175734-29705eaf09d4 h1:+Rov3bfUriGWFR/lUVXnpimx+HMr9BXRC4by0BxuQ8k=
-github.com/drand/drand v1.0.3-0.20200714175734-29705eaf09d4/go.mod h1:SnqWL9jksIMK63UKkfmWI6f9PDN8ROoCgg+Z4zWk7hg=
+github.com/drand/drand v1.1.2-0.20200905144319-79c957281b32 h1:sU+51aQRaDxg0KnjQg19KuYRIxDBEUHffBAICSnBys8=
+github.com/drand/drand v1.1.2-0.20200905144319-79c957281b32/go.mod h1:0sQEVg+ngs1jaDPVIiEgY0lbENWJPaUlWxGHEaSmKVM=
 github.com/drand/kyber v1.0.1-0.20200110225416-8de27ed8c0e2/go.mod h1:UpXoA0Upd1N9l4TvRPHr1qAUBBERj6JQ/mnKI3BPEmw=
 github.com/drand/kyber v1.0.2/go.mod h1:x6KOpK7avKj0GJ4emhXFP5n7M7W7ChAPmnQh/OL6vRw=
-github.com/drand/kyber v1.1.1 h1:mwCY2XGRB+Qc1MPfrnRuVuXELkPhcq/r9yMoJIcDhHI=
-github.com/drand/kyber v1.1.1/go.mod h1:x6KOpK7avKj0GJ4emhXFP5n7M7W7ChAPmnQh/OL6vRw=
+github.com/drand/kyber v1.1.2 h1:faemqlaFyLrbBSjZGRzzu5SG/do+uTYpHlnrJIHbAhQ=
+github.com/drand/kyber v1.1.2/go.mod h1:x6KOpK7avKj0GJ4emhXFP5n7M7W7ChAPmnQh/OL6vRw=
 github.com/drand/kyber-bls12381 v0.1.0 h1:/P4C65VnyEwxzR5ZYYVMNzY1If+aYBrdUU5ukwh7LQw=
 github.com/drand/kyber-bls12381 v0.1.0/go.mod h1:N1emiHpm+jj7kMlxEbu3MUyOiooTgNySln564cgD9mk=
 github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
@ -224,8 +227,10 @@ github.com/filecoin-project/go-data-transfer v0.6.3 h1:7TLwm8nuodHYD/uiwJjKc/PGR
 github.com/filecoin-project/go-data-transfer v0.6.3/go.mod h1:PmBKVXkhh67/tnEdJXQwDHl5mT+7Tbcwe1NPninqhnM=
 github.com/filecoin-project/go-fil-commcid v0.0.0-20200716160307-8f644712406f h1:GxJzR3oRIMTPtpZ0b7QF8FKPK6/iPAc7trhlL5k/g+s=
 github.com/filecoin-project/go-fil-commcid v0.0.0-20200716160307-8f644712406f/go.mod h1:Eaox7Hvus1JgPrL5+M3+h7aSPHc0cVqpSxA+TxIEpZQ=
-github.com/filecoin-project/go-fil-markets v0.6.0 h1:gfxMweUHo4u+2BZh2Q7/7+cV0/ttikuJfhkkxLRsE2Q=
-github.com/filecoin-project/go-fil-markets v0.6.0/go.mod h1:LhSFYLkjaoe0vFRKABGYyw1Jz+9jCpF1sPA7yOftLTw=
+github.com/filecoin-project/go-fil-markets v0.6.1-0.20200911011457-2959ccca6a3c h1:YGoyYmELQ0LHwDj/WcOvY3oYt+3iM0wdrAhqJQUAIy4=
+github.com/filecoin-project/go-fil-markets v0.6.1-0.20200911011457-2959ccca6a3c/go.mod h1:PLr9svZxsnHkae1Ky7+66g7fP9AlneVxIVu+oSMq56A=
+github.com/filecoin-project/go-hamt-ipld v0.1.5 h1:uoXrKbCQZ49OHpsTCkrThPNelC4W3LPEk0OrS/ytIBM=
+github.com/filecoin-project/go-hamt-ipld v0.1.5/go.mod h1:6Is+ONR5Cd5R6XZoCse1CWaXZc0Hdb/JeX+EQCQzX24=
 github.com/filecoin-project/go-jsonrpc v0.1.2-0.20200822201400-474f4fdccc52 h1:FXtCp0ybqdQL9knb3OGDpkNTaBbPxgkqPeWKotUwkH0=
 github.com/filecoin-project/go-jsonrpc v0.1.2-0.20200822201400-474f4fdccc52/go.mod h1:XBBpuKIMaXIIzeqzO1iucq4GvbF8CxmXRFoezRh+Cx4=
 github.com/filecoin-project/go-multistore v0.0.3 h1:vaRBY4YiA2UZFPK57RNuewypB8u0DzzQwqsL0XarpnI=
@ -238,6 +243,8 @@ github.com/filecoin-project/go-state-types v0.0.0-20200903145444-247639ffa6ad/go
 github.com/filecoin-project/go-state-types v0.0.0-20200904021452-1883f36ca2f4/go.mod h1:IQ0MBPnonv35CJHtWSN3YY1Hz2gkPru1Q9qoaYLxx9I=
 github.com/filecoin-project/go-state-types v0.0.0-20200905071437-95828685f9df h1:m2esXSuGBkuXlRyCsl1a/7/FkFam63o1OzIgzaHtOfI=
 github.com/filecoin-project/go-state-types v0.0.0-20200905071437-95828685f9df/go.mod h1:IQ0MBPnonv35CJHtWSN3YY1Hz2gkPru1Q9qoaYLxx9I=
+github.com/filecoin-project/go-state-types v0.0.0-20200909080127-001afaca718c h1:HHRMFpU8OrODDUja5NmGWNBAVGoSy4MRjxgZa+a0qIw=
+github.com/filecoin-project/go-state-types v0.0.0-20200909080127-001afaca718c/go.mod h1:IQ0MBPnonv35CJHtWSN3YY1Hz2gkPru1Q9qoaYLxx9I=
 github.com/filecoin-project/go-statemachine v0.0.0-20200714194326-a77c3ae20989/go.mod h1:FGwQgZAt2Gh5mjlwJUlVB62JeYdo+if0xWxSEfBD9ig=
 github.com/filecoin-project/go-statemachine v0.0.0-20200813232949-df9b130df370 h1:Jbburj7Ih2iaJ/o5Q9A+EAeTabME6YII7FLi9SKUf5c=
 github.com/filecoin-project/go-statemachine v0.0.0-20200813232949-df9b130df370/go.mod h1:FGwQgZAt2Gh5mjlwJUlVB62JeYdo+if0xWxSEfBD9ig=
@ -248,6 +255,8 @@ github.com/filecoin-project/go-storedcounter v0.0.0-20200421200003-1c99c62e8a5b/
 github.com/filecoin-project/specs-actors v0.9.4/go.mod h1:BStZQzx5x7TmCkLv0Bpa07U6cPKol6fd3w9KjMPZ6Z4=
 github.com/filecoin-project/specs-actors v0.9.7 h1:7PAZ8kdqwBdmgf/23FCkQZLCXcVu02XJrkpkhBikiA8=
 github.com/filecoin-project/specs-actors v0.9.7/go.mod h1:wM2z+kwqYgXn5Z7scV1YHLyd1Q1cy0R8HfTIWQ0BFGU=
+github.com/filecoin-project/specs-actors v0.9.8 h1:45fnx/BsseFL3CtvSoR6CszFY26TFtsh9AHwCW2vkg8=
+github.com/filecoin-project/specs-actors v0.9.8/go.mod h1:xFObDoWPySBNTNBrGXVVrutmgSZH/mMo46Q1bec/0hw=
 github.com/filecoin-project/specs-storage v0.1.1-0.20200907031224-ed2e5cd13796 h1:dJsTPWpG2pcTeojO2pyn0c6l+x/3MZYCBgo/9d11JEk=
 github.com/filecoin-project/specs-storage v0.1.1-0.20200907031224-ed2e5cd13796/go.mod h1:nJRRM7Aa9XVvygr3W9k6xGF46RWzr2zxF/iGoAIfA/g=
 github.com/filecoin-project/test-vectors/schema v0.0.1 h1:5fNF76nl4qolEvcIsjc0kUADlTMVHO73tW4kXXPnsus=
@ -1316,8 +1325,6 @@ github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5
 github.com/stretchr/testify v1.6.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/supranational/blst v0.1.2-alpha.1 h1:v0UqVlvbRNZIaSeMPr+T01kvTUq1h0EZuZ6gnDR1Mlg=
-github.com/supranational/blst v0.1.2-alpha.1/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
 github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE=
 github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ=
 github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
@ -1747,7 +1754,6 @@ google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8
 google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/grpc v1.29.1 h1:EC2SB8S04d2r73uptxphDSUG+kTKVgjRPF+N3xpxRB4=
 google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
-google.golang.org/grpc/cmd/protoc-gen-go-grpc v0.0.0-20200617041141-9a465503579e/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
--- a/markets/storageadapter/client.go
+++ b/markets/storageadapter/client.go
@ -501,12 +501,12 @@ func (c *ClientNodeAdapter) GetChainHead(ctx context.Context) (shared.TipSetToke
 	return head.Key().Bytes(), head.Height(), nil
 }

-func (c *ClientNodeAdapter) WaitForMessage(ctx context.Context, mcid cid.Cid, cb func(code exitcode.ExitCode, bytes []byte, err error) error) error {
+func (c *ClientNodeAdapter) WaitForMessage(ctx context.Context, mcid cid.Cid, cb func(code exitcode.ExitCode, bytes []byte, finalCid cid.Cid, err error) error) error {
 	receipt, err := c.StateWaitMsg(ctx, mcid, build.MessageConfidence)
 	if err != nil {
-		return cb(0, nil, err)
+		return cb(0, nil, cid.Undef, err)
 	}
-	return cb(receipt.Receipt.ExitCode, receipt.Receipt.Return, nil)
+	return cb(receipt.Receipt.ExitCode, receipt.Receipt.Return, receipt.Message, nil)
 }

 func (c *ClientNodeAdapter) GetMinerInfo(ctx context.Context, addr address.Address, encodedTs shared.TipSetToken) (*storagemarket.StorageProviderInfo, error) {
--- a/markets/storageadapter/provider.go
+++ b/markets/storageadapter/provider.go
@ -6,6 +6,7 @@ import (
 	"bytes"
 	"context"
 	"io"
+	"time"

 	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log/v2"
@ -35,6 +36,8 @@ import (
 	"github.com/filecoin-project/lotus/storage/sectorblocks"
 )

+var addPieceRetryWait = 5 * time.Minute
+var addPieceRetryTimeout = 6 * time.Hour
 var log = logging.Logger("storageadapter")

 type ProviderNodeAdapter struct {
@ -91,7 +94,7 @@ func (n *ProviderNodeAdapter) OnDealComplete(ctx context.Context, deal storagema
 		return nil, xerrors.Errorf("deal.PublishCid can't be nil")
 	}

-	p, offset, err := n.secb.AddPiece(ctx, pieceSize, pieceData, sealing.DealInfo{
+	sdInfo := sealing.DealInfo{
 		DealID:     deal.DealID,
 		PublishCid: deal.PublishCid,
 		DealSchedule: sealing.DealSchedule{
@ -99,7 +102,23 @@ func (n *ProviderNodeAdapter) OnDealComplete(ctx context.Context, deal storagema
 			EndEpoch:   deal.ClientDealProposal.Proposal.EndEpoch,
 		},
 		KeepUnsealed: deal.FastRetrieval,
-	})
+	}
+
+	p, offset, err := n.secb.AddPiece(ctx, pieceSize, pieceData, sdInfo)
+	curTime := time.Now()
+	for time.Since(curTime) < addPieceRetryTimeout {
+		if !xerrors.Is(err, sealing.ErrTooManySectorsSealing) {
+			log.Errorf("failed to addPiece for deal %d, err: %w", deal.DealID, err)
+			break
+		}
+		select {
+		case <-time.After(addPieceRetryWait):
+			p, offset, err = n.secb.AddPiece(ctx, pieceSize, pieceData, sdInfo)
+		case <-ctx.Done():
+			return nil, xerrors.New("context expired while waiting to retry AddPiece")
+		}
+	}
+
 	if err != nil {
 		return nil, xerrors.Errorf("AddPiece failed: %s", err)
 	}
@ -355,12 +374,12 @@ func (n *ProviderNodeAdapter) GetChainHead(ctx context.Context) (shared.TipSetTo
 	return head.Key().Bytes(), head.Height(), nil
 }

-func (n *ProviderNodeAdapter) WaitForMessage(ctx context.Context, mcid cid.Cid, cb func(code exitcode.ExitCode, bytes []byte, err error) error) error {
+func (n *ProviderNodeAdapter) WaitForMessage(ctx context.Context, mcid cid.Cid, cb func(code exitcode.ExitCode, bytes []byte, finalCid cid.Cid, err error) error) error {
 	receipt, err := n.StateWaitMsg(ctx, mcid, 2*build.MessageConfidence)
 	if err != nil {
-		return cb(0, nil, err)
+		return cb(0, nil, cid.Undef, err)
 	}
-	return cb(receipt.Receipt.ExitCode, receipt.Receipt.Return, nil)
+	return cb(receipt.Receipt.ExitCode, receipt.Receipt.Return, receipt.Message, nil)
 }

 func (n *ProviderNodeAdapter) GetDataCap(ctx context.Context, addr address.Address, encodedTs shared.TipSetToken) (*verifreg.DataCap, error) {
--- a/miner/miner.go
+++ b/miner/miner.go
@ -362,7 +362,7 @@ func (m *Miner) mineOne(ctx context.Context, base *MiningBase) (*types.BlockMsg,
 		rbase = bvals[len(bvals)-1]
 	}

-	ticket, err := m.computeTicket(ctx, &rbase, base, len(bvals) > 0)
+	ticket, err := m.computeTicket(ctx, &rbase, base)
 	if err != nil {
 		return nil, xerrors.Errorf("scratching ticket failed: %w", err)
 	}
@ -432,7 +432,7 @@ func (m *Miner) mineOne(ctx context.Context, base *MiningBase) (*types.BlockMsg,
 	return b, nil
 }

-func (m *Miner) computeTicket(ctx context.Context, brand *types.BeaconEntry, base *MiningBase, haveNewEntries bool) (*types.Ticket, error) {
+func (m *Miner) computeTicket(ctx context.Context, brand *types.BeaconEntry, base *MiningBase) (*types.Ticket, error) {
 	mi, err := m.api.StateMinerInfo(ctx, m.address, types.EmptyTSK)
 	if err != nil {
 		return nil, err
@ -447,11 +447,12 @@ func (m *Miner) computeTicket(ctx context.Context, brand *types.BeaconEntry, bas
 		return nil, xerrors.Errorf("failed to marshal address to cbor: %w", err)
 	}

-	if !haveNewEntries {
+	round := base.TipSet.Height() + base.NullRounds + 1
+	if round > build.UpgradeSmokeHeight {
 		buf.Write(base.TipSet.MinTicket().VRFProof)
 	}

-	input, err := store.DrawRandomness(brand.Data, crypto.DomainSeparationTag_TicketProduction, base.TipSet.Height()+base.NullRounds+1-build.TicketRandomnessLookback, buf.Bytes())
+	input, err := store.DrawRandomness(brand.Data, crypto.DomainSeparationTag_TicketProduction, round-build.TicketRandomnessLookback, buf.Bytes())
 	if err != nil {
 		return nil, err
 	}
--- a/node/builder.go
+++ b/node/builder.go
@ -227,7 +227,7 @@ func Online() Option {

 			Override(new(dtypes.BootstrapPeers), modules.BuiltinBootstrap),
 			Override(new(dtypes.DrandBootstrap), modules.DrandBootstrap),
-			Override(new(dtypes.DrandConfig), modules.BuiltinDrandConfig),
+			Override(new(dtypes.DrandSchedule), modules.BuiltinDrandConfig),

 			Override(HandleIncomingMessagesKey, modules.HandleIncomingMessages),

@ -273,7 +273,7 @@ func Online() Option {
 			Override(new(modules.ClientDealFunds), modules.NewClientDealFunds),
 			Override(new(storagemarket.StorageClient), modules.StorageClient),
 			Override(new(storagemarket.StorageClientNode), storageadapter.NewClientNodeAdapter),
-			Override(new(beacon.RandomBeacon), modules.RandomBeacon),
+			Override(new(beacon.Schedule), modules.RandomSchedule),

 			Override(new(*paychmgr.Store), paychmgr.NewStore),
 			Override(new(*paychmgr.Manager), paychmgr.NewManager),
@ -537,6 +537,6 @@ func Test() Option {
 	return Options(
 		Unset(RunPeerMgrKey),
 		Unset(new(*peermgr.PeerMgr)),
-		Override(new(beacon.RandomBeacon), testing.RandomBeacon),
+		Override(new(beacon.Schedule), testing.RandomBeacon),
 	)
 }
--- a/node/impl/client/client.go
+++ b/node/impl/client/client.go
@ -6,6 +6,8 @@ import (
 	"io"
 	"os"

+	"github.com/filecoin-project/go-state-types/dline"
+
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-state-types/big"
 	"golang.org/x/xerrors"
@ -80,7 +82,7 @@ type API struct {
 	Host              host.Host
 }

-func calcDealExpiration(minDuration uint64, md *miner.DeadlineInfo, startEpoch abi.ChainEpoch) abi.ChainEpoch {
+func calcDealExpiration(minDuration uint64, md *dline.Info, startEpoch abi.ChainEpoch) abi.ChainEpoch {
 	// Make sure we give some time for the miner to seal
 	minExp := startEpoch + abi.ChainEpoch(minDuration)

--- a/node/impl/full/beacon.go
+++ b/node/impl/full/beacon.go
@ -13,12 +13,13 @@ import (
 type BeaconAPI struct {
 	fx.In

-	Beacon beacon.RandomBeacon
+	Beacon beacon.Schedule
 }

 func (a *BeaconAPI) BeaconGetEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) {
-	rr := a.Beacon.MaxBeaconRoundForEpoch(epoch, types.BeaconEntry{})
-	e := a.Beacon.Entry(ctx, rr)
+	b := a.Beacon.BeaconForEpoch(epoch)
+	rr := b.MaxBeaconRoundForEpoch(epoch)
+	e := b.Entry(ctx, rr)

 	select {
 	case be, ok := <-e:
--- a/node/impl/full/chain.go
+++ b/node/impl/full/chain.go
@ -495,7 +495,7 @@ func (a *ChainAPI) ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Mess
 	return cm.VMMessage(), nil
 }

-func (a *ChainAPI) ChainExport(ctx context.Context, nroots abi.ChainEpoch, tsk types.TipSetKey) (<-chan []byte, error) {
+func (a *ChainAPI) ChainExport(ctx context.Context, nroots abi.ChainEpoch, skipoldmsgs bool, tsk types.TipSetKey) (<-chan []byte, error) {
 	ts, err := a.Chain.GetTipSetFromKey(tsk)
 	if err != nil {
 		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
@ -508,7 +508,7 @@ func (a *ChainAPI) ChainExport(ctx context.Context, nroots abi.ChainEpoch, tsk t
 		bw := bufio.NewWriterSize(w, 1<<20)
 		defer bw.Flush() //nolint:errcheck // it is a write to a pipe

-		if err := a.Chain.Export(ctx, ts, nroots, bw); err != nil {
+		if err := a.Chain.Export(ctx, ts, nroots, skipoldmsgs, bw); err != nil {
 			log.Errorf("chain export call failed: %s", err)
 			return
 		}
--- a/node/impl/full/gas.go
+++ b/node/impl/full/gas.go
@ -204,30 +204,14 @@ func (a *GasAPI) GasEstimateMessageGas(ctx context.Context, msg *types.Message,
 	}

 	if msg.GasFeeCap == types.EmptyInt || types.BigCmp(msg.GasFeeCap, types.NewInt(0)) == 0 {
-		feeCap, err := a.GasEstimateFeeCap(ctx, msg, 10, types.EmptyTSK)
+		feeCap, err := a.GasEstimateFeeCap(ctx, msg, 20, types.EmptyTSK)
 		if err != nil {
 			return nil, xerrors.Errorf("estimating fee cap: %w", err)
 		}
 		msg.GasFeeCap = feeCap
 	}

-	capGasFee(msg, spec.Get().MaxFee)
+	messagepool.CapGasFee(msg, spec.Get().MaxFee)

 	return msg, nil
 }
-
-func capGasFee(msg *types.Message, maxFee abi.TokenAmount) {
-	if maxFee.Equals(big.Zero()) {
-		maxFee = types.NewInt(build.FilecoinPrecision / 10)
-	}
-
-	gl := types.NewInt(uint64(msg.GasLimit))
-	totalFee := types.BigMul(msg.GasFeeCap, gl)
-
-	if totalFee.LessThanEqual(maxFee) {
-		return
-	}
-
-	msg.GasFeeCap = big.Div(maxFee, gl)
-	msg.GasPremium = big.Min(msg.GasFeeCap, msg.GasPremium) // cap premium at FeeCap
-}
--- a/node/impl/full/state.go
+++ b/node/impl/full/state.go
@ -7,6 +7,8 @@ import (
 	"fmt"
 	"strconv"

+	"github.com/filecoin-project/go-state-types/dline"
+
 	cid "github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	cbg "github.com/whyrusleeping/cbor-gen"
@ -53,7 +55,7 @@ type StateAPI struct {
 	ProofVerifier ffiwrapper.Verifier
 	StateManager  *stmgr.StateManager
 	Chain         *store.ChainStore
-	Beacon        beacon.RandomBeacon
+	Beacon        beacon.Schedule
 }

 func (a *StateAPI) StateNetworkName(ctx context.Context) (dtypes.NetworkName, error) {
@ -145,7 +147,7 @@ func (a *StateAPI) StateMinerPartitions(ctx context.Context, m address.Address,
 						}))))))
 }

-func (a *StateAPI) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*miner.DeadlineInfo, error) {
+func (a *StateAPI) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error) {
 	ts, err := a.Chain.GetTipSetFromKey(tsk)
 	if err != nil {
 		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
--- a/node/modules/chain.go
+++ b/node/modules/chain.go
@ -163,7 +163,7 @@ func NetworkName(mctx helpers.MetricsCtx, lc fx.Lifecycle, cs *store.ChainStore,
 	return netName, err
 }

-func NewSyncer(lc fx.Lifecycle, ds dtypes.MetadataDS, sm *stmgr.StateManager, exchange exchange.Client, h host.Host, beacon beacon.RandomBeacon, verifier ffiwrapper.Verifier) (*chain.Syncer, error) {
+func NewSyncer(lc fx.Lifecycle, ds dtypes.MetadataDS, sm *stmgr.StateManager, exchange exchange.Client, h host.Host, beacon beacon.Schedule, verifier ffiwrapper.Verifier) (*chain.Syncer, error) {
 	syncer, err := chain.NewSyncer(ds, sm, exchange, h.ConnManager(), h.ID(), beacon, verifier)
 	if err != nil {
 		return nil, err
--- a/node/modules/core.go
+++ b/node/modules/core.go
@ -10,6 +10,7 @@ import (

 	"github.com/gbrlsnchs/jwt/v3"
 	logging "github.com/ipfs/go-log/v2"
+	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/libp2p/go-libp2p-core/peerstore"
 	record "github.com/libp2p/go-libp2p-record"
 	"golang.org/x/xerrors"
@ -93,14 +94,18 @@ func BuiltinBootstrap() (dtypes.BootstrapPeers, error) {
 	return build.BuiltinBootstrap()
 }

-func DrandBootstrap(d dtypes.DrandConfig) (dtypes.DrandBootstrap, error) {
+func DrandBootstrap(ds dtypes.DrandSchedule) (dtypes.DrandBootstrap, error) {
 	// TODO: retry resolving, don't fail if at least one resolve succeeds
-	addrs, err := addrutil.ParseAddresses(context.TODO(), d.Relays)
+	res := []peer.AddrInfo{}
+	for _, d := range ds {
+		addrs, err := addrutil.ParseAddresses(context.TODO(), d.Config.Relays)
 		if err != nil {
 			log.Errorf("reoslving drand relays addresses: %+v", err)
-		return nil, nil
+			return res, nil
 		}
-	return addrs, nil
+		res = append(res, addrs...)
+	}
+	return res, nil
 }

 func SetupJournal(lr repo.LockedRepo) error {
--- a/node/modules/dtypes/beacon.go
+++ b/node/modules/dtypes/beacon.go
@ -1,5 +1,14 @@
 package dtypes

+import "github.com/filecoin-project/go-state-types/abi"
+
+type DrandSchedule []DrandPoint
+
+type DrandPoint struct {
+	Start  abi.ChainEpoch
+	Config DrandConfig
+}
+
 type DrandConfig struct {
 	Servers       []string
 	Relays        []string
--- a/node/modules/lp2p/pubsub.go
+++ b/node/modules/lp2p/pubsub.go
@ -49,7 +49,7 @@ type GossipIn struct {
 	Db   dtypes.DrandBootstrap
 	Cfg  *config.Pubsub
 	Sk   *dtypes.ScoreKeeper
-	Dr   dtypes.DrandConfig
+	Dr   dtypes.DrandSchedule
 }

 func getDrandTopic(chainInfoJSON string) (string, error) {
@ -74,58 +74,8 @@ func GossipSub(in GossipIn) (service *pubsub.PubSub, err error) {
 	}

 	isBootstrapNode := in.Cfg.Bootstrapper
-	drandTopic, err := getDrandTopic(in.Dr.ChainInfoJSON)
-	if err != nil {
-		return nil, err
-	}

-	options := []pubsub.Option{
-		// Gossipsubv1.1 configuration
-		pubsub.WithFloodPublish(true),
-		pubsub.WithMessageIdFn(HashMsgId),
-		pubsub.WithPeerScore(
-			&pubsub.PeerScoreParams{
-				AppSpecificScore: func(p peer.ID) float64 {
-					// return a heavy positive score for bootstrappers so that we don't unilaterally prune
-					// them and accept PX from them.
-					// we don't do that in the bootstrappers themselves to avoid creating a closed mesh
-					// between them (however we might want to consider doing just that)
-					_, ok := bootstrappers[p]
-					if ok && !isBootstrapNode {
-						return 2500
-					}
-
-					_, ok = drandBootstrappers[p]
-					if ok && !isBootstrapNode {
-						return 1500
-					}
-
-					// TODO: we want to  plug the application specific score to the node itself in order
-					//       to provide feedback to the pubsub system based on observed behaviour
-					return 0
-				},
-				AppSpecificWeight: 1,
-
-				// This sets the IP colocation threshold to 1 peer per
-				IPColocationFactorThreshold: 1,
-				IPColocationFactorWeight:    -100,
-				// TODO we want to whitelist IPv6 /64s that belong to datacenters etc
-				// IPColocationFactorWhitelist: map[string]struct{}{},
-
-				// P7: behavioural penalties, decay after 1hr
-				BehaviourPenaltyThreshold: 6,
-				BehaviourPenaltyWeight:    -10,
-				BehaviourPenaltyDecay:     pubsub.ScoreParameterDecay(time.Hour),
-
-				DecayInterval: pubsub.DefaultDecayInterval,
-				DecayToZero:   pubsub.DefaultDecayToZero,
-
-				// this retains non-positive scores for 6 hours
-				RetainScore: 6 * time.Hour,
-
-				// topic parameters
-				Topics: map[string]*pubsub.TopicScoreParams{
-					drandTopic: {
+	drandTopicParams := &pubsub.TopicScoreParams{
 		// expected 2 beaconsn/min
 		TopicWeight: 0.5, // 5x block topic; max cap is 62.5

@ -152,7 +102,9 @@ func GossipSub(in GossipIn) (service *pubsub.PubSub, err error) {
 		// invalid messages decay after 1 hour
 		InvalidMessageDeliveriesWeight: -1000,
 		InvalidMessageDeliveriesDecay:  pubsub.ScoreParameterDecay(time.Hour),
-					},
+	}
+
+	topicParams := map[string]*pubsub.TopicScoreParams{
 		build.BlocksTopic(in.Nn): {
 			// expected 10 blocks/min
 			TopicWeight: 0.1, // max cap is 50, max mesh penalty is -10, single invalid message is -100
@ -228,7 +180,68 @@ func GossipSub(in GossipIn) (service *pubsub.PubSub, err error) {
 			InvalidMessageDeliveriesWeight: -1000,
 			InvalidMessageDeliveriesDecay:  pubsub.ScoreParameterDecay(time.Hour),
 		},
+	}
+
+	pgTopicWeights := map[string]float64{
+		build.BlocksTopic(in.Nn):   10,
+		build.MessagesTopic(in.Nn): 1,
+	}
+
+	for _, d := range in.Dr {
+		topic, err := getDrandTopic(d.Config.ChainInfoJSON)
+		if err != nil {
+			return nil, err
+		}
+		topicParams[topic] = drandTopicParams
+		pgTopicWeights[topic] = 5
+	}
+
+	options := []pubsub.Option{
+		// Gossipsubv1.1 configuration
+		pubsub.WithFloodPublish(true),
+		pubsub.WithMessageIdFn(HashMsgId),
+		pubsub.WithPeerScore(
+			&pubsub.PeerScoreParams{
+				AppSpecificScore: func(p peer.ID) float64 {
+					// return a heavy positive score for bootstrappers so that we don't unilaterally prune
+					// them and accept PX from them.
+					// we don't do that in the bootstrappers themselves to avoid creating a closed mesh
+					// between them (however we might want to consider doing just that)
+					_, ok := bootstrappers[p]
+					if ok && !isBootstrapNode {
+						return 2500
+					}
+
+					_, ok = drandBootstrappers[p]
+					if ok && !isBootstrapNode {
+						return 1500
+					}
+
+					// TODO: we want to  plug the application specific score to the node itself in order
+					//       to provide feedback to the pubsub system based on observed behaviour
+					return 0
 				},
+				AppSpecificWeight: 1,
+
+				// This sets the IP colocation threshold to 1 peer per
+				IPColocationFactorThreshold: 1,
+				IPColocationFactorWeight:    -100,
+				// TODO we want to whitelist IPv6 /64s that belong to datacenters etc
+				// IPColocationFactorWhitelist: map[string]struct{}{},
+
+				// P7: behavioural penalties, decay after 1hr
+				BehaviourPenaltyThreshold: 6,
+				BehaviourPenaltyWeight:    -10,
+				BehaviourPenaltyDecay:     pubsub.ScoreParameterDecay(time.Hour),
+
+				DecayInterval: pubsub.DefaultDecayInterval,
+				DecayToZero:   pubsub.DefaultDecayToZero,
+
+				// this retains non-positive scores for 6 hours
+				RetainScore: 6 * time.Hour,
+
+				// topic parameters
+				Topics: topicParams,
 			},
 			&pubsub.PeerScoreThresholds{
 				GossipThreshold:             -500,
@ -278,11 +291,6 @@ func GossipSub(in GossipIn) (service *pubsub.PubSub, err error) {
 	}

 	// validation queue RED
-	pgTopicWeights := map[string]float64{
-		drandTopic:                 5,
-		build.BlocksTopic(in.Nn):   10,
-		build.MessagesTopic(in.Nn): 1,
-	}
 	var pgParams *pubsub.PeerGaterParams

 	if isBootstrapNode {
--- a/node/modules/services.go
+++ b/node/modules/services.go
@ -126,19 +126,27 @@ type RandomBeaconParams struct {

 	PubSub      *pubsub.PubSub `optional:"true"`
 	Cs          *store.ChainStore
-	DrandConfig dtypes.DrandConfig
+	DrandConfig dtypes.DrandSchedule
 }

-func BuiltinDrandConfig() dtypes.DrandConfig {
-	return build.DrandConfig()
+func BuiltinDrandConfig() dtypes.DrandSchedule {
+	return build.DrandConfigSchedule()
 }

-func RandomBeacon(p RandomBeaconParams, _ dtypes.AfterGenesisSet) (beacon.RandomBeacon, error) {
+func RandomSchedule(p RandomBeaconParams, _ dtypes.AfterGenesisSet) (beacon.Schedule, error) {
 	gen, err := p.Cs.GetGenesis()
 	if err != nil {
 		return nil, err
 	}

-	//return beacon.NewMockBeacon(build.BlockDelaySecs * time.Second)
-	return drand.NewDrandBeacon(gen.Timestamp, build.BlockDelaySecs, p.PubSub, p.DrandConfig)
+	shd := beacon.Schedule{}
+	for _, dc := range p.DrandConfig {
+		bc, err := drand.NewDrandBeacon(gen.Timestamp, build.BlockDelaySecs, p.PubSub, dc.Config)
+		if err != nil {
+			return nil, xerrors.Errorf("creating drand beacon: %w", err)
+		}
+		shd = append(shd, beacon.BeaconPoint{Start: dc.Start, Beacon: bc})
+	}
+
+	return shd, nil
 }
--- a/node/modules/testing/beacon.go
+++ b/node/modules/testing/beacon.go
@ -7,6 +7,9 @@ import (
 	"github.com/filecoin-project/lotus/chain/beacon"
 )

-func RandomBeacon() (beacon.RandomBeacon, error) {
-	return beacon.NewMockBeacon(time.Duration(build.BlockDelaySecs) * time.Second), nil
+func RandomBeacon() (beacon.Schedule, error) {
+	return beacon.Schedule{
+		{Start: 0,
+			Beacon: beacon.NewMockBeacon(time.Duration(build.BlockDelaySecs) * time.Second),
+		}}, nil
 }
--- a/node/repo/fsrepo.go
+++ b/node/repo/fsrepo.go
@ -101,7 +101,7 @@ func (fsr *FsRepo) Init(t RepoType) error {
 	}

 	log.Infof("Initializing repo at '%s'", fsr.path)
-	err = os.Mkdir(fsr.path, 0755) //nolint: gosec
+	err = os.MkdirAll(fsr.path, 0755) //nolint: gosec
 	if err != nil && !os.IsExist(err) {
 		return err
 	}
--- a/scripts/dev/sminer-init
+++ b/scripts/dev/sminer-init
@ -7,4 +7,4 @@ export TRUST_PARAMS=1
 tag=${TAG:-debug}

 go run -tags=$tag ./cmd/lotus wallet import ~/.genesis-sectors/pre-seal-t01000.key
-go run -tags=$tag ./cmd/lotus-miner init --actor=t01000 --genesis-miner --pre-sealed-sectors=~/.genesis-sectors --pre-sealed-metadata=~/.genesis-sectors/pre-seal-t01000.json
+go run -tags=$tag ./cmd/lotus-storage-miner init --actor=t01000 --genesis-miner --pre-sealed-sectors=~/.genesis-sectors --pre-sealed-metadata=~/.genesis-sectors/pre-seal-t01000.json
--- a/storage/miner.go
+++ b/storage/miner.go
@ -5,6 +5,8 @@ import (
 	"errors"
 	"time"

+	"github.com/filecoin-project/go-state-types/dline"
+
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/specs-actors/actors/runtime/proof"

@ -60,7 +62,7 @@ type storageMinerApi interface {
 	StateSectorGetInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorOnChainInfo, error)
 	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*api.SectorLocation, error)
 	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (api.MinerInfo, error)
-	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*miner.DeadlineInfo, error)
+	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
 	StateMinerPreCommitDepositForPower(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)
 	StateMinerInitialPledgeCollateral(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)
 	StateSearchMsg(context.Context, cid.Cid) (*api.MsgLookup, error)
--- a/storage/wdpost_run.go
+++ b/storage/wdpost_run.go
@ -6,6 +6,8 @@ import (
 	"errors"
 	"time"

+	"github.com/filecoin-project/go-state-types/dline"
+
 	"github.com/filecoin-project/specs-actors/actors/runtime/proof"

 	"github.com/filecoin-project/go-bitfield"
@ -27,7 +29,7 @@ import (

 var errNoPartitions = errors.New("no partitions")

-func (s *WindowPoStScheduler) failPost(deadline *miner.DeadlineInfo) {
+func (s *WindowPoStScheduler) failPost(deadline *dline.Info) {
 	log.Errorf("TODO")
 	/*s.failLk.Lock()
 	if eps > s.failed {
@ -36,7 +38,7 @@ func (s *WindowPoStScheduler) failPost(deadline *miner.DeadlineInfo) {
 	s.failLk.Unlock()*/
 }

-func (s *WindowPoStScheduler) doPost(ctx context.Context, deadline *miner.DeadlineInfo, ts *types.TipSet) {
+func (s *WindowPoStScheduler) doPost(ctx context.Context, deadline *dline.Info, ts *types.TipSet) {
 	ctx, abort := context.WithCancel(ctx)

 	s.abort = abort
@ -286,7 +288,7 @@ func (s *WindowPoStScheduler) checkNextFaults(ctx context.Context, dlIdx uint64,
 	return nil
 }

-func (s *WindowPoStScheduler) runPost(ctx context.Context, di miner.DeadlineInfo, ts *types.TipSet) (*miner.SubmitWindowedPoStParams, error) {
+func (s *WindowPoStScheduler) runPost(ctx context.Context, di dline.Info, ts *types.TipSet) (*miner.SubmitWindowedPoStParams, error) {
 	ctx, span := trace.StartSpan(ctx, "storage.runPost")
 	defer span.End()

@ -335,9 +337,13 @@ func (s *WindowPoStScheduler) runPost(ctx context.Context, di miner.DeadlineInfo
 		Proofs:     nil,
 	}

-	var sinfos []proof.SectorInfo
-	sidToPart := map[abi.SectorNumber]uint64{}
 	skipCount := uint64(0)
+	postSkipped := bitfield.New()
+	var postOut []proof.PoStProof
+
+	for retries := 0; retries < 5; retries++ {
+		var sinfos []proof.SectorInfo
+		sidToPart := map[abi.SectorNumber]int{}

 		for partIdx, partition := range partitions {
 			// TODO: Can do this in parallel
@ -351,6 +357,11 @@ func (s *WindowPoStScheduler) runPost(ctx context.Context, di miner.DeadlineInfo
 				return nil, xerrors.Errorf("adding recoveries to set of sectors to prove: %w", err)
 			}

+			toProve, err = bitfield.SubtractBitField(toProve, postSkipped)
+			if err != nil {
+				return nil, xerrors.Errorf("toProve - postSkipped: %w", err)
+			}
+
 			good, err := s.checkSectors(ctx, toProve)
 			if err != nil {
 				return nil, xerrors.Errorf("checking sectors to skip: %w", err)
@ -379,7 +390,7 @@ func (s *WindowPoStScheduler) runPost(ctx context.Context, di miner.DeadlineInfo

 			sinfos = append(sinfos, ssi...)
 			for _, si := range ssi {
-			sidToPart[si.SectorNumber] = uint64(partIdx)
+				sidToPart[si.SectorNumber] = partIdx
 			}

 			params.Partitions = append(params.Partitions, miner.PoStPartition{
@ -406,23 +417,34 @@ func (s *WindowPoStScheduler) runPost(ctx context.Context, di miner.DeadlineInfo
 			return nil, err
 		}

-	postOut, postSkipped, err := s.prover.GenerateWindowPoSt(ctx, abi.ActorID(mid), sinfos, abi.PoStRandomness(rand))
-	if err != nil {
+		var ps []abi.SectorID
+		postOut, ps, err = s.prover.GenerateWindowPoSt(ctx, abi.ActorID(mid), sinfos, abi.PoStRandomness(rand))
+		elapsed := time.Since(tsStart)
+
+		log.Infow("computing window PoSt", "elapsed", elapsed)
+
+		if err == nil {
+			break
+		}
+
+		if len(ps) == 0 {
 			return nil, xerrors.Errorf("running post failed: %w", err)
 		}

+		log.Warnw("generate window PoSt skipped sectors", "sectors", ps, "error", err, "try", retries)
+
+		skipCount += uint64(len(ps))
+		for _, sector := range ps {
+			postSkipped.Set(uint64(sector.Number))
+		}
+	}
+
 	if len(postOut) == 0 {
-		return nil, xerrors.Errorf("received proofs back from generate window post")
+		return nil, xerrors.Errorf("received no proofs back from generate window post")
 	}

 	params.Proofs = postOut

-	for _, sector := range postSkipped {
-		params.Partitions[sidToPart[sector.Number]].Skipped.Set(uint64(sector.Number))
-	}
-
-	elapsed := time.Since(tsStart)
-
 	commEpoch := di.Open
 	commRand, err := s.api.ChainGetRandomnessFromTickets(ctx, ts.Key(), crypto.DomainSeparationTag_PoStChainCommit, commEpoch, nil)
 	if err != nil {
@ -431,7 +453,7 @@ func (s *WindowPoStScheduler) runPost(ctx context.Context, di miner.DeadlineInfo
 	params.ChainCommitEpoch = commEpoch
 	params.ChainCommitRand = commRand

-	log.Infow("submitting window PoSt", "elapsed", elapsed)
+	log.Infow("submitting window PoSt")

 	return params, nil
 }
--- a/storage/wdpost_sched.go
+++ b/storage/wdpost_sched.go
@ -4,11 +4,12 @@ import (
 	"context"
 	"time"

+	"github.com/filecoin-project/go-state-types/dline"
+
 	"golang.org/x/xerrors"

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-storage/storage"

 	"github.com/filecoin-project/lotus/api"
@ -37,7 +38,7 @@ type WindowPoStScheduler struct {
 	cur *types.TipSet

 	// if a post is in progress, this indicates for which ElectionPeriodStart
-	activeDeadline *miner.DeadlineInfo
+	activeDeadline *dline.Info
 	abort          context.CancelFunc

 	//failed abi.ChainEpoch // eps
@ -68,7 +69,7 @@ func NewWindowedPoStScheduler(api storageMinerApi, fc config.MinerFeeConfig, sb
 	}, nil
 }

-func deadlineEquals(a, b *miner.DeadlineInfo) bool {
+func deadlineEquals(a, b *dline.Info) bool {
 	if a == nil || b == nil {
 		return b == a
 	}
--- a/tools/stats/metrics.go
+++ b/tools/stats/metrics.go
@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"math"
 	"math/big"
 	"strings"
 	"time"
@ -12,6 +13,7 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
@ -131,12 +133,6 @@ func RecordTipsetPoints(ctx context.Context, api api.FullNode, pl *PointList, ti
 	p = NewPoint("chain.blocktime", tsTime.Unix())
 	pl.AddPoint(p)

-	baseFeeBig := tipset.Blocks()[0].ParentBaseFee.Copy()
-	baseFeeRat := new(big.Rat).SetFrac(baseFeeBig.Int, new(big.Int).SetUint64(build.FilecoinPrecision))
-	baseFeeFloat, _ := baseFeeRat.Float64()
-	p = NewPoint("chain.basefee", baseFeeFloat)
-	pl.AddPoint(p)
-
 	totalGasLimit := int64(0)
 	totalUniqGasLimit := int64(0)
 	seen := make(map[cid.Cid]struct{})
@ -178,6 +174,30 @@ func RecordTipsetPoints(ctx context.Context, api api.FullNode, pl *PointList, ti
 	p = NewPoint("chain.gas_limit_uniq_total", totalUniqGasLimit)
 	pl.AddPoint(p)

+	{
+		baseFeeIn := tipset.Blocks()[0].ParentBaseFee
+		newBaseFee := store.ComputeNextBaseFee(baseFeeIn, totalUniqGasLimit, len(tipset.Blocks()), tipset.Height())
+
+		baseFeeRat := new(big.Rat).SetFrac(newBaseFee.Int, new(big.Int).SetUint64(build.FilecoinPrecision))
+		baseFeeFloat, _ := baseFeeRat.Float64()
+		p = NewPoint("chain.basefee", baseFeeFloat)
+		pl.AddPoint(p)
+
+		baseFeeChange := new(big.Rat).SetFrac(newBaseFee.Int, baseFeeIn.Int)
+		baseFeeChangeF, _ := baseFeeChange.Float64()
+		p = NewPoint("chain.basefee_change_log", math.Log(baseFeeChangeF)/math.Log(1.125))
+		pl.AddPoint(p)
+	}
+	{
+		blks := len(cids)
+		p = NewPoint("chain.gas_fill_ratio", float64(totalGasLimit)/float64(blks*build.BlockGasTarget))
+		pl.AddPoint(p)
+		p = NewPoint("chain.gas_capacity_ratio", float64(totalUniqGasLimit)/float64(blks*build.BlockGasTarget))
+		pl.AddPoint(p)
+		p = NewPoint("chain.gas_waste_ratio", float64(totalGasLimit-totalUniqGasLimit)/float64(blks*build.BlockGasTarget))
+		pl.AddPoint(p)
+	}
+
 	return nil
 }
				`@ -0,0 +1 @@`
				`Subproject commit 5f93488fc0dbfb450f2355269f18fc67010d59bb`