Butterfly genesis

New butterfly network info
2020-10-07 01:45:21 +00:00 · 2020-10-07 01:21:47 +00:00
137 changed files with 1154 additions and 4027 deletions
@@ -12,7 +12,6 @@
 /lotus-bench
 /lotus-gateway
 /lotus-pcr
-/lotus-wallet
 /bench.json
 /lotuspond/front/node_modules
 /lotuspond/front/build
@@ -1,118 +1,5 @@
 # Lotus changelog

-# 0.9.1 / 2020-10-10
-
-This release fixes an issue which may cause the actors v2 migration to compute the state incorrectly when more than one migration is running in parallel.
-
-## Changes
-
- Make concurrent actor migrations safe (https://github.com/filecoin-project/lotus/pull/4293)
- Remote wallet backends (https://github.com/filecoin-project/lotus/pull/3583)
- Track funds in FundMgr correctly in case of AddFunds failing (https://github.com/filecoin-project/lotus/pull/4273)
- Partial lite-node mode (https://github.com/filecoin-project/lotus/pull/4095)
- Fix potential infinite loop in GetBestMiningCandidate (https://github.com/filecoin-project/lotus/pull/3444)
- sync wait: Handle processed message offset (https://github.com/filecoin-project/lotus/pull/4253)
- Add some new endpoints for querying Msig info (https://github.com/filecoin-project/lotus/pull/4250)
- Update markets v0.7.1 (https://github.com/filecoin-project/lotus/pull/4254)
- Optimize SearchForMessage and GetReceipt (https://github.com/filecoin-project/lotus/pull/4246)
- Use FIL instead of attoFIL in CLI more consistently (https://github.com/filecoin-project/lotus/pull/4249)
- fix: clash between daemon --api flag and cli tests (https://github.com/filecoin-project/lotus/pull/4241)
- add more info to chain sync lookback failure (https://github.com/filecoin-project/lotus/pull/4245)
- Add message counts to inspect chain output (https://github.com/filecoin-project/lotus/pull/4230)
-
-# 0.9.0 / 2020-10-07
-
-This consensus-breaking release of Lotus upgrades the actors version to v2.0.0. This requires migrating actor state from v0 to v2. The changes that break consensus are:
-
- Introducing v2 actors and its migration (https://github.com/filecoin-project/lotus/pull/3936)
- Runtime's Receiver() should only return ID addresses  (https://github.com/filecoin-project/lotus/pull/3589)
- Update miner eligibility checks for v2 actors (https://github.com/filecoin-project/lotus/pull/4188)
- Add funds that have left FilReserve to circ supply (https://github.com/filecoin-project/lotus/pull/4160)
- Set WinningPoStSectorSetLookback to finality post-v2 actors (https://github.com/filecoin-project/lotus/pull/4190)
- fix: error when actor panics directly (https://github.com/filecoin-project/lotus/pull/3697)
-
-## Changes
-
-#### Dependencies
-
- Update go-bitfield (https://github.com/filecoin-project/lotus/pull/4171)
- update the AMT implementation (https://github.com/filecoin-project/lotus/pull/4194)
- Update to actors v0.2.1 (https://github.com/filecoin-project/lotus/pull/4199)
-
-#### Core Lotus
-
- Paych: fix voucher amount verification (https://github.com/filecoin-project/lotus/pull/3821)
- Cap market provider messages (https://github.com/filecoin-project/lotus/pull/4141)
- Run fork function after cron for null block safety (https://github.com/filecoin-project/lotus/pull/4114)
- use bitswap sessions when fetching messages, and cancel them (https://github.com/filecoin-project/lotus/pull/4142)
- relax pubsub IPColocationFactorThreshold to 5 (https://github.com/filecoin-project/lotus/pull/4183)
- Support addresses with mainnet prefixes (https://github.com/filecoin-project/lotus/pull/4186)
- fix: make message signer nonce generation transactional (https://github.com/filecoin-project/lotus/pull/4165)
- build: Env var to keep test address output (https://github.com/filecoin-project/lotus/pull/4213)
- make vm.EnableGasTracing public (https://github.com/filecoin-project/lotus/pull/4214)
- introduce separate state-tree versions (https://github.com/filecoin-project/lotus/pull/4197)
- reject explicit "calls" at the upgrade height (https://github.com/filecoin-project/lotus/pull/4231)
- return an illegal actor error when we see an unsupported actor version (https://github.com/filecoin-project/lotus/pull/4232)
- Set head should unmark blocks as valid (https://gist.github.com/travisperson/3c7cddd77a33979a519ccef4e6515f20)
-
-#### Mining
-
- Increased ExpectedSealDuration and and WaitDealsDelay (https://github.com/filecoin-project/lotus/pull/3743)
- Miner backup/restore commands (https://github.com/filecoin-project/lotus/pull/4133)
- lotus-miner: add more help text to storage / attach (https://github.com/filecoin-project/lotus/pull/3961)
- Reject deals that are > 7 days in the future in the BasicDealFilter (https://github.com/filecoin-project/lotus/pull/4173)
- feat(miner): add miner deadline diffing logic (https://github.com/filecoin-project/lotus/pull/4178)
-
-#### UX
-
- Improve the UX for replacing messages (https://github.com/filecoin-project/lotus/pull/4134)
- Add verified flag to interactive deal creation (https://github.com/filecoin-project/lotus/pull/4145)
- Add command to (slowly) prune lotus chain datastore (https://github.com/filecoin-project/lotus/pull/3876)
- Some helpers for verifreg work (https://github.com/filecoin-project/lotus/pull/4124)
- Always use default 720h for setask duration and hide the duration param option (https://github.com/filecoin-project/lotus/pull/4077)
- Convert ID addresses to key addresses before checking wallet (https://github.com/filecoin-project/lotus/pull/4122)
- add a command to view block space utilization (https://github.com/filecoin-project/lotus/pull/4176)
- allow usage inspection on a chain segment (https://github.com/filecoin-project/lotus/pull/4177)
- Add mpool stats for base fee (https://github.com/filecoin-project/lotus/pull/4170)
- Add verified status to api.DealInfo (https://github.com/filecoin-project/lotus/pull/4153)
- Add a CLI command to set a miner's owner address (https://github.com/filecoin-project/lotus/pull/4189)
-
-#### Tooling and validation
-
- Lotus-pcr: add recover-miners command (https://github.com/filecoin-project/lotus/pull/3714)
- MpoolPushUntrusted API for gateway (https://github.com/filecoin-project/lotus/pull/3915)
- Test lotus-miner info all (https://github.com/filecoin-project/lotus/pull/4166)
- chain export: Error with unfinished exports (https://github.com/filecoin-project/lotus/pull/4179)
- add printf in TestWindowPost (https://github.com/filecoin-project/lotus/pull/4043)
- add trace wdpost (https://github.com/filecoin-project/lotus/pull/4020)
- Fix noncefix (https://github.com/filecoin-project/lotus/pull/4202)
- Lotus-pcr: Limit the fee cap of messages we will process, refund gas fees for windowed post and storage deals (https://github.com/filecoin-project/lotus/pull/4198)
- Fix pond (https://github.com/filecoin-project/lotus/pull/4203)
- allow manual setting of noncefix fee cap (https://github.com/filecoin-project/lotus/pull/4205)
- implement command to get execution traces of any message (https://github.com/filecoin-project/lotus/pull/4200)
- conformance: minor driver refactors (https://github.com/filecoin-project/lotus/pull/4211) 
- lotus-pcr: ignore all other messages (https://github.com/filecoin-project/lotus/pull/4218)
- lotus-pcr: zero refund (https://github.com/filecoin-project/lotus/pull/4229)
-
-## Contributors
-
-The following contributors had 5 or more commits go into this release.
-We are grateful for every contribution!
-
-| Contributor        | Commits | Lines ±       |
-|--------------------|---------|---------------|
-| Stebalien          | 84       | +3425/-2287  |
-| magik6k            | 41       | +2121/-506   |
-| arajasek           | 39       | +2467/-424   |
-| Kubuxu             | 25       | +2344/-775   |
-| raulk              | 21       | +287/-196    |
-| whyrusleeping      | 13       | +727/-71     |
-| hsanjuan           | 13       | +5886/-7956  |
-| dirkmc             | 11       | +2634/-576   | 
-| travisperson       | 8        | +923/-202    |
-| ribasushi          | 6        | +188/-128    |
-| zgfzgf             | 5        | +21/-17      |
-
 # 0.8.1 / 2020-09-30

 This optional release of Lotus introduces a new version of markets which switches to CBOR-map encodings, and allows datastore migrations. The release also introduces several improvements to the mining process, a few performance optimizations, and a battery of UX additions and enhancements.
@@ -230,7 +117,7 @@ We are grateful for every contribution!
 | vyzo               | 22       | +287/-196    |
 | alanshaw           | 15       | +761/-146    |
 | whyrusleeping      | 15       | +736/-52     |
-| hannahhoward       | 14       | +1237/-837   | 
+| hannahhoward       | 14       | +1237/837-   | 
 | anton              | 6        | +32/-8       |
 | travisperson       | 5        | +502/-6      |
 | Frank              | 5        | +78/-39      |
@@ -186,12 +186,6 @@ lotus-health:
 .PHONY: lotus-health
 BINS+=lotus-health

-lotus-wallet:
-	rm -f lotus-wallet
-	go build -o lotus-wallet ./cmd/lotus-wallet
-.PHONY: lotus-wallet
-BINS+=lotus-wallet
-
 testground:
 	go build -tags testground -o /dev/null ./cmd/lotus
 .PHONY: testground
@@ -367,10 +367,6 @@ type FullNode interface {
 	// StateWaitMsg looks back in the chain for a message. If not found, it blocks until the
 	// message arrives on chain, and gets to the indicated confidence depth.
 	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64) (*MsgLookup, error)
-	// StateWaitMsgLimited looks back up to limit epochs in the chain for a message.
-	// If not found, it blocks until the message arrives on chain, and gets to the
-	// indicated confidence depth.
-	StateWaitMsgLimited(ctx context.Context, cid cid.Cid, confidence uint64, limit abi.ChainEpoch) (*MsgLookup, error)
 	// StateListMiners returns the addresses of every miner that has claimed power in the Power Actor
 	StateListMiners(context.Context, types.TipSetKey) ([]address.Address, error)
 	// StateListActors returns the addresses of every actor in the state
@@ -422,8 +418,6 @@ type FullNode interface {

 	// MsigGetAvailableBalance returns the portion of a multisig's balance that can be withdrawn or spent
 	MsigGetAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)
-	// MsigGetVestingSchedule returns the vesting details of a given multisig.
-	MsigGetVestingSchedule(context.Context, address.Address, types.TipSetKey) (MsigVesting, error)
 	// MsigGetVested returns the amount of FIL that vested in a multisig in a certain period.
 	// It takes the following params: <multisig address>, <start epoch>, <end epoch>
 	MsigGetVested(context.Context, address.Address, types.TipSetKey, types.TipSetKey) (types.BigInt, error)
@@ -877,15 +871,3 @@ type Fault struct {
 	Miner address.Address
 	Epoch abi.ChainEpoch
 }
-
-var EmptyVesting = MsigVesting{
-	InitialBalance: types.EmptyInt,
-	StartEpoch:     -1,
-	UnlockDuration: -1,
-}
-
-type MsigVesting struct {
-	InitialBalance abi.TokenAmount
-	StartEpoch     abi.ChainEpoch
-	UnlockDuration abi.ChainEpoch
-}
@@ -1,24 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/ipfs/go-cid"
-)
-
-type GatewayAPI interface {
-	ChainHead(ctx context.Context) (*types.TipSet, error)
-	ChainGetTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error)
-	ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error)
-	GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *MessageSendSpec, tsk types.TipSetKey) (*types.Message, error)
-	MpoolPush(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error)
-	MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error)
-	MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error)
-	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
-	StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-	StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*MsgLookup, error)
-}
@@ -1,47 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/crypto"
-
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type MsgType string
-
-const (
-	MTUnknown = "unknown"
-
-	// Signing message CID. MsgMeta.Extra contains raw cbor message bytes
-	MTChainMsg = "message"
-
-	// Signing a blockheader. signing raw cbor block bytes (MsgMeta.Extra is empty)
-	MTBlock = "block"
-
-	// Signing a deal proposal. signing raw cbor proposal bytes (MsgMeta.Extra is empty)
-	MTDealProposal = "dealproposal"
-
-	// TODO: Deals, Vouchers, VRF
-)
-
-type MsgMeta struct {
-	Type MsgType
-
-	// Additional data related to what is signed. Should be verifiable with the
-	// signed bytes (e.g. CID(Extra).Bytes() == toSign)
-	Extra []byte
-}
-
-type WalletAPI interface {
-	WalletNew(context.Context, crypto.SigType) (address.Address, error)
-	WalletHas(context.Context, address.Address) (bool, error)
-	WalletList(context.Context) ([]address.Address, error)
-
-	WalletSign(ctx context.Context, signer address.Address, toSign []byte, meta MsgMeta) (*crypto.Signature, error)
-
-	WalletExport(context.Context, address.Address) (*types.KeyInfo, error)
-	WalletImport(context.Context, *types.KeyInfo) (address.Address, error)
-	WalletDelete(context.Context, address.Address) error
-}
@@ -36,9 +36,3 @@ func PermissionedWorkerAPI(a api.WorkerAPI) api.WorkerAPI {
 	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
 	return &out
 }
-
-func PermissionedWalletAPI(a api.WalletAPI) api.WalletAPI {
-	var out WalletStruct
-	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
-	return &out
-}
@@ -190,7 +190,6 @@ type FullNodeStruct struct {
 		StateReadState                     func(context.Context, address.Address, types.TipSetKey) (*api.ActorState, error)                                    `perm:"read"`
 		StateMsgGasCost                    func(context.Context, cid.Cid, types.TipSetKey) (*api.MsgGasCost, error)                                            `perm:"read"`
 		StateWaitMsg                       func(ctx context.Context, cid cid.Cid, confidence uint64) (*api.MsgLookup, error)                                   `perm:"read"`
-		StateWaitMsgLimited                func(context.Context, cid.Cid, uint64, abi.ChainEpoch) (*api.MsgLookup, error)                                      `perm:"read"`
 		StateSearchMsg                     func(context.Context, cid.Cid) (*api.MsgLookup, error)                                                              `perm:"read"`
 		StateListMiners                    func(context.Context, types.TipSetKey) ([]address.Address, error)                                                   `perm:"read"`
 		StateListActors                    func(context.Context, types.TipSetKey) ([]address.Address, error)                                                   `perm:"read"`
@@ -213,7 +212,6 @@ type FullNodeStruct struct {
 		StateNetworkVersion                func(context.Context, types.TipSetKey) (stnetwork.Version, error)                                                   `perm:"read"`

 		MsigGetAvailableBalance func(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)                                                                    `perm:"read"`
-		MsigGetVestingSchedule  func(context.Context, address.Address, types.TipSetKey) (api.MsigVesting, error)                                                                 `perm:"read"`
 		MsigGetVested           func(context.Context, address.Address, types.TipSetKey, types.TipSetKey) (types.BigInt, error)                                                   `perm:"read"`
 		MsigCreate              func(context.Context, uint64, []address.Address, abi.ChainEpoch, types.BigInt, address.Address, types.BigInt) (cid.Cid, error)                   `perm:"sign"`
 		MsigPropose             func(context.Context, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)                          `perm:"sign"`
@@ -362,35 +360,6 @@ type WorkerStruct struct {
 	}
 }

-type GatewayStruct struct {
-	Internal struct {
-		// TODO: does the gateway need perms?
-		ChainGetTipSet          func(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error)
-		ChainGetTipSetByHeight  func(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error)
-		ChainHead               func(ctx context.Context) (*types.TipSet, error)
-		GasEstimateMessageGas   func(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, tsk types.TipSetKey) (*types.Message, error)
-		MpoolPush               func(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error)
-		MsigGetAvailableBalance func(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error)
-		MsigGetVested           func(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error)
-		StateAccountKey         func(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-		StateGetActor           func(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
-		StateLookupID           func(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-		StateWaitMsg            func(ctx context.Context, msg cid.Cid, confidence uint64) (*api.MsgLookup, error)
-	}
-}
-
-type WalletStruct struct {
-	Internal struct {
-		WalletNew    func(context.Context, crypto.SigType) (address.Address, error)                         `perm:"write"`
-		WalletHas    func(context.Context, address.Address) (bool, error)                                   `perm:"write"`
-		WalletList   func(context.Context) ([]address.Address, error)                                       `perm:"write"`
-		WalletSign   func(context.Context, address.Address, []byte, api.MsgMeta) (*crypto.Signature, error) `perm:"sign"`
-		WalletExport func(context.Context, address.Address) (*types.KeyInfo, error)                         `perm:"admin"`
-		WalletImport func(context.Context, *types.KeyInfo) (address.Address, error)                         `perm:"admin"`
-		WalletDelete func(context.Context, address.Address) error                                           `perm:"write"`
-	}
-}
-
 // CommonStruct

 func (c *CommonStruct) AuthVerify(ctx context.Context, token string) ([]auth.Permission, error) {
@@ -884,10 +853,6 @@ func (c *FullNodeStruct) StateWaitMsg(ctx context.Context, msgc cid.Cid, confide
 	return c.Internal.StateWaitMsg(ctx, msgc, confidence)
 }

-func (c *FullNodeStruct) StateWaitMsgLimited(ctx context.Context, msgc cid.Cid, confidence uint64, limit abi.ChainEpoch) (*api.MsgLookup, error) {
-	return c.Internal.StateWaitMsgLimited(ctx, msgc, confidence, limit)
-}
-
 func (c *FullNodeStruct) StateSearchMsg(ctx context.Context, msgc cid.Cid) (*api.MsgLookup, error) {
 	return c.Internal.StateSearchMsg(ctx, msgc)
 }
@@ -968,10 +933,6 @@ func (c *FullNodeStruct) MsigGetAvailableBalance(ctx context.Context, a address.
 	return c.Internal.MsigGetAvailableBalance(ctx, a, tsk)
 }

-func (c *FullNodeStruct) MsigGetVestingSchedule(ctx context.Context, a address.Address, tsk types.TipSetKey) (api.MsigVesting, error) {
-	return c.Internal.MsigGetVestingSchedule(ctx, a, tsk)
-}
-
 func (c *FullNodeStruct) MsigGetVested(ctx context.Context, a address.Address, sTsk types.TipSetKey, eTsk types.TipSetKey) (types.BigInt, error) {
 	return c.Internal.MsigGetVested(ctx, a, sTsk, eTsk)
 }
@@ -1406,81 +1367,7 @@ func (w *WorkerStruct) Closing(ctx context.Context) (<-chan struct{}, error) {
 	return w.Internal.Closing(ctx)
 }

-func (g GatewayStruct) ChainHead(ctx context.Context) (*types.TipSet, error) {
-	return g.Internal.ChainHead(ctx)
-}
-
-func (g GatewayStruct) ChainGetTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error) {
-	return g.Internal.ChainGetTipSet(ctx, tsk)
-}
-
-func (g GatewayStruct) ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error) {
-	return g.Internal.ChainGetTipSetByHeight(ctx, h, tsk)
-}
-
-func (g GatewayStruct) GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, tsk types.TipSetKey) (*types.Message, error) {
-	return g.Internal.GasEstimateMessageGas(ctx, msg, spec, tsk)
-}
-
-func (g GatewayStruct) MpoolPush(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error) {
-	return g.Internal.MpoolPush(ctx, sm)
-}
-
-func (g GatewayStruct) MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error) {
-	return g.Internal.MsigGetAvailableBalance(ctx, addr, tsk)
-}
-
-func (g GatewayStruct) MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error) {
-	return g.Internal.MsigGetVested(ctx, addr, start, end)
-}
-
-func (g GatewayStruct) StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
-	return g.Internal.StateAccountKey(ctx, addr, tsk)
-}
-
-func (g GatewayStruct) StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error) {
-	return g.Internal.StateGetActor(ctx, actor, ts)
-}
-
-func (g GatewayStruct) StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
-	return g.Internal.StateLookupID(ctx, addr, tsk)
-}
-
-func (g GatewayStruct) StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*api.MsgLookup, error) {
-	return g.Internal.StateWaitMsg(ctx, msg, confidence)
-}
-
-func (c *WalletStruct) WalletNew(ctx context.Context, typ crypto.SigType) (address.Address, error) {
-	return c.Internal.WalletNew(ctx, typ)
-}
-
-func (c *WalletStruct) WalletHas(ctx context.Context, addr address.Address) (bool, error) {
-	return c.Internal.WalletHas(ctx, addr)
-}
-
-func (c *WalletStruct) WalletList(ctx context.Context) ([]address.Address, error) {
-	return c.Internal.WalletList(ctx)
-}
-
-func (c *WalletStruct) WalletSign(ctx context.Context, k address.Address, msg []byte, meta api.MsgMeta) (*crypto.Signature, error) {
-	return c.Internal.WalletSign(ctx, k, msg, meta)
-}
-
-func (c *WalletStruct) WalletExport(ctx context.Context, a address.Address) (*types.KeyInfo, error) {
-	return c.Internal.WalletExport(ctx, a)
-}
-
-func (c *WalletStruct) WalletImport(ctx context.Context, ki *types.KeyInfo) (address.Address, error) {
-	return c.Internal.WalletImport(ctx, ki)
-}
-
-func (c *WalletStruct) WalletDelete(ctx context.Context, addr address.Address) error {
-	return c.Internal.WalletDelete(ctx, addr)
-}
-
 var _ api.Common = &CommonStruct{}
 var _ api.FullNode = &FullNodeStruct{}
 var _ api.StorageMiner = &StorageMinerStruct{}
 var _ api.WorkerAPI = &WorkerStruct{}
-var _ api.GatewayAPI = &GatewayStruct{}
-var _ api.WalletAPI = &WalletStruct{}
@@ -82,29 +82,3 @@ func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (

 	return &res, closer, err
 }
-
-// NewGatewayRPC creates a new http jsonrpc client for a gateway node.
-func NewGatewayRPC(ctx context.Context, addr string, requestHeader http.Header, opts ...jsonrpc.Option) (api.GatewayAPI, jsonrpc.ClientCloser, error) {
-	var res apistruct.GatewayStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		[]interface{}{
-			&res.Internal,
-		},
-		requestHeader,
-		opts...,
-	)
-
-	return &res, closer, err
-}
-
-func NewWalletRPC(ctx context.Context, addr string, requestHeader http.Header) (api.WalletAPI, jsonrpc.ClientCloser, error) {
-	var res apistruct.WalletStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		[]interface{}{
-			&res.Internal,
-		},
-		requestHeader,
-	)
-
-	return &res, closer, err
-}
@@ -12,7 +12,10 @@ import (

 	"github.com/filecoin-project/go-state-types/abi"

+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node"
 	"github.com/filecoin-project/lotus/node/impl"
 )

@@ -34,7 +37,11 @@ func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {

 func testCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, upgradeHeight abi.ChainEpoch) {
 	ctx := context.Background()
-	n, sn := b(t, []FullNodeOpts{FullNodeWithUpgradeAt(upgradeHeight)}, OneMiner)
+	n, sn := b(t, 1, OneMiner, node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
+		Network:   build.ActorUpgradeNetworkVersion,
+		Height:    upgradeHeight,
+		Migration: stmgr.UpgradeActorsV2,
+	}}))
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

@@ -48,7 +48,7 @@ func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")

 	ctx := context.Background()
-	n, sn := b(t, OneFull, OneMiner)
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

@@ -85,7 +85,7 @@ func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")

 	ctx := context.Background()
-	n, sn := b(t, OneFull, OneMiner)
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

@@ -149,7 +149,7 @@ func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Durati
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")

 	ctx := context.Background()
-	n, sn := b(t, OneFull, OneMiner)
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

@@ -204,7 +204,7 @@ func TestSenondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")

 	ctx := context.Background()
-	n, sn := b(t, OneFull, OneMiner)
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

@@ -25,7 +25,7 @@ var log = logging.Logger("apitest")

 func (ts *testSuite) testMining(t *testing.T) {
 	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, OneFull, OneMiner)
+	apis, sn := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]

 	newHeads, err := api.ChainNotify(ctx)
@@ -54,7 +54,7 @@ func (ts *testSuite) testMiningReal(t *testing.T) {
 	}()

 	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, OneFull, OneMiner)
+	apis, sn := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]

 	newHeads, err := api.ChainNotify(ctx)
@@ -93,7 +93,7 @@ func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExpo
 	// test making a deal with a fresh miner, and see if it starts to mine

 	ctx := context.Background()
-	n, sn := b(t, OneFull, []StorageMiner{
+	n, sn := b(t, 1, []StorageMiner{
 		{Full: 0, Preseal: PresealGenesis},
 		{Full: 0, Preseal: 0}, // TODO: Add support for miners on non-first full node
 	})
@@ -33,7 +33,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")

 	ctx := context.Background()
-	n, sn := b(t, TwoFull, OneMiner)
+	n, sn := b(t, 2, OneMiner)

 	paymentCreator := n[0]
 	paymentReceiver := n[1]
@@ -4,14 +4,11 @@ import (
 	"context"
 	"testing"

-	"github.com/filecoin-project/lotus/chain/stmgr"
-
 	"github.com/multiformats/go-multiaddr"

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"

-	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/miner"
@@ -38,27 +35,17 @@ var PresealGenesis = -1

 const GenesisPreseals = 2

-// Options for setting up a mock storage miner
 type StorageMiner struct {
 	Full    int
 	Preseal int
 }

-type OptionGenerator func([]TestNode) node.Option
-
-// Options for setting up a mock full node
-type FullNodeOpts struct {
-	Lite bool            // run node in "lite" mode
-	Opts OptionGenerator // generate dependency injection options
-}
-
 // APIBuilder is a function which is invoked in test suite to provide
 // test nodes and networks
 //
-// fullOpts array defines options for each full node
 // storage array defines storage nodes, numbers in the array specify full node
 // index the storage node 'belongs' to
-type APIBuilder func(t *testing.T, full []FullNodeOpts, storage []StorageMiner) ([]TestNode, []TestStorageNode)
+type APIBuilder func(t *testing.T, nFull int, storage []StorageMiner, opts ...node.Option) ([]TestNode, []TestStorageNode)
 type testSuite struct {
 	makeNodes APIBuilder
 }
@@ -76,39 +63,13 @@ func TestApis(t *testing.T, b APIBuilder) {
 	t.Run("testMiningReal", ts.testMiningReal)
 }

-func DefaultFullOpts(nFull int) []FullNodeOpts {
-	full := make([]FullNodeOpts, nFull)
-	for i := range full {
-		full[i] = FullNodeOpts{
-			Opts: func(nodes []TestNode) node.Option {
-				return node.Options()
-			},
-		}
-	}
-	return full
-}
-
 var OneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}
-var OneFull = DefaultFullOpts(1)
-var TwoFull = DefaultFullOpts(2)
-
-var FullNodeWithUpgradeAt = func(upgradeHeight abi.ChainEpoch) FullNodeOpts {
-	return FullNodeOpts{
-		Opts: func(nodes []TestNode) node.Option {
-			return node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
-				Network:   build.ActorUpgradeNetworkVersion,
-				Height:    upgradeHeight,
-				Migration: stmgr.UpgradeActorsV2,
-			}})
-		},
-	}
-}

 func (ts *testSuite) testVersion(t *testing.T) {
 	build.RunningNodeType = build.NodeFull

 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, OneFull, OneMiner)
+	apis, _ := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]

 	v, err := api.Version(ctx)
@@ -120,7 +81,7 @@ func (ts *testSuite) testVersion(t *testing.T) {

 func (ts *testSuite) testID(t *testing.T) {
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, OneFull, OneMiner)
+	apis, _ := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]

 	id, err := api.ID(ctx)
@@ -132,7 +93,7 @@ func (ts *testSuite) testID(t *testing.T) {

 func (ts *testSuite) testConnectTwo(t *testing.T) {
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, TwoFull, OneMiner)
+	apis, _ := ts.makeNodes(t, 2, OneMiner)

 	p, err := apis[0].NetPeers(ctx)
 	if err != nil {
@@ -15,9 +15,11 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/extern/sector-storage/mock"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+	"github.com/filecoin-project/lotus/node"

 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 	bminer "github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node/impl"
@@ -32,7 +34,7 @@ func init() {

 func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
 	ctx := context.Background()
-	n, sn := b(t, OneFull, OneMiner)
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

@@ -131,7 +133,11 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()

-	n, sn := b(t, []FullNodeOpts{FullNodeWithUpgradeAt(upgradeHeight)}, OneMiner)
+	n, sn := b(t, 1, OneMiner, node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
+		Network:   build.ActorUpgradeNetworkVersion,
+		Height:    upgradeHeight,
+		Migration: stmgr.UpgradeActorsV2,
+	}}))

 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
@@ -1,12 +1,2 @@
-/dns4/bootstrap-0.testnet.fildev.network/tcp/1347/p2p/12D3KooWJTUBUjtzWJGWU1XSiY21CwmHaCNLNYn2E7jqHEHyZaP7
-/dns4/bootstrap-1.testnet.fildev.network/tcp/1347/p2p/12D3KooW9yeKXha4hdrJKq74zEo99T8DhriQdWNoojWnnQbsgB3v
-/dns4/bootstrap-2.testnet.fildev.network/tcp/1347/p2p/12D3KooWCrx8yVG9U9Kf7w8KLN3Edkj5ZKDhgCaeMqQbcQUoB6CT
-/dns4/bootstrap-4.testnet.fildev.network/tcp/1347/p2p/12D3KooWPkL9LrKRQgHtq7kn9ecNhGU9QaziG8R5tX8v9v7t3h34
-/dns4/bootstrap-3.testnet.fildev.network/tcp/1347/p2p/12D3KooWKYSsbpgZ3HAjax5M1BXCwXLa6gVkUARciz7uN3FNtr7T
-/dns4/bootstrap-5.testnet.fildev.network/tcp/1347/p2p/12D3KooWQYzqnLASJAabyMpPb1GcWZvNSe7JDcRuhdRqonFoiK9W
-/dns4/lotus-bootstrap.forceup.cn/tcp/41778/p2p/12D3KooWFQsv3nRMUevZNWWsY1Wu6NUzUbawnWU5NcRhgKuJA37C
-/dns4/bootstrap-0.starpool.in/tcp/12757/p2p/12D3KooWGHpBMeZbestVEWkfdnC9u7p6uFHXL1n7m1ZBqsEmiUzz
-/dns4/bootstrap-1.starpool.in/tcp/12757/p2p/12D3KooWQZrGH1PxSNZPum99M1zNvjNFM33d1AAu5DcvdHptuU7u
-/dns4/node.glif.io/tcp/1235/p2p/12D3KooWBF8cpp65hp2u9LK5mh19x67ftAam84z9LsfaquTDSBpt
-/dns4/bootstrap-0.ipfsmain.cn/tcp/34721/p2p/12D3KooWQnwEGNqcM2nAcPtRR9rAX8Hrg4k9kJLCHoTR5chJfz6d
-/dns4/bootstrap-1.ipfsmain.cn/tcp/34723/p2p/12D3KooWMKxMkD5DMpSWsW7dBddKxKT7L2GgbNuckz9otxvkvByP
+/dns4/bootstrap-0.butterfly.fildev.network/tcp/1347/p2p/12D3KooWCYDmiVU7yXfg8MsuCAwuMmueCrjeaqduFA8gMFTWCUJk
+/dns4/bootstrap-1.butterfly.fildev.network/tcp/1347/p2p/12D3KooWKap2ouokyEu2kF56CCBsgxx3e54TGzdzcbYhxk4DtSRr
@@ -3,9 +3,6 @@
 package build

 import (
-	"math"
-	"os"
-
 	"github.com/filecoin-project/go-state-types/abi"

 	"github.com/filecoin-project/lotus/chain/actors/policy"
@@ -16,10 +13,8 @@ const BreezeGasTampingDuration = 0

 const UpgradeSmokeHeight = -1
 const UpgradeIgnitionHeight = -2
-const UpgradeRefuelHeight = -3
-
-var UpgradeActorsV2Height = abi.ChainEpoch(10)
-var UpgradeLiftoffHeight = abi.ChainEpoch(-4)
+const UpgradeLiftoffHeight = -3
+const UpgradeActorsV2Height = 10

 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0: DrandMainnet,
@@ -30,11 +25,6 @@ func init() {
 	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
 	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))

-	if os.Getenv("LOTUS_DISABLE_V2_ACTOR_MIGRATION") == "1" {
-		UpgradeActorsV2Height = math.MaxInt64
-		UpgradeLiftoffHeight = 11
-	}
-
 	BuildType |= Build2k
 }

@@ -82,9 +82,8 @@ var (

 	UpgradeSmokeHeight    abi.ChainEpoch = -1
 	UpgradeIgnitionHeight abi.ChainEpoch = -2
-	UpgradeRefuelHeight   abi.ChainEpoch = -3
+	UpgradeLiftoffHeight  abi.ChainEpoch = -3
 	UpgradeActorsV2Height abi.ChainEpoch = 10
-	UpgradeLiftoffHeight  abi.ChainEpoch = -4

 	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 		0: DrandMainnet,
@@ -5,9 +5,6 @@
 package build

 import (
-	"math"
-	"os"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
@@ -16,19 +13,17 @@ import (
 )

 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0:                  DrandIncentinet,
-	UpgradeSmokeHeight: DrandMainnet,
+	0: DrandMainnet,
 }

-const UpgradeBreezeHeight = 41280
+const UpgradeBreezeHeight = -1
 const BreezeGasTampingDuration = 120

-const UpgradeSmokeHeight = 51000
+const UpgradeSmokeHeight = -2

-const UpgradeIgnitionHeight = 94000
-const UpgradeRefuelHeight = 130800
+const UpgradeIgnitionHeight = -3

-var UpgradeActorsV2Height = abi.ChainEpoch(138720)
+const UpgradeActorsV2Height = 500

 // This signals our tentative epoch for mainnet launch. Can make it later, but not earlier.
 // Miners, clients, developers, custodians all need time to prepare.
@@ -36,19 +31,14 @@ var UpgradeActorsV2Height = abi.ChainEpoch(138720)
 const UpgradeLiftoffHeight = 148888

 func init() {
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 40))
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(1 << 30))
 	policy.SetSupportedProofTypes(
+		abi.RegisteredSealProof_StackedDrg512MiBV1,
 		abi.RegisteredSealProof_StackedDrg32GiBV1,
 		abi.RegisteredSealProof_StackedDrg64GiBV1,
 	)

-	if os.Getenv("LOTUS_USE_TEST_ADDRESSES") != "1" {
-		SetAddressNetwork(address.Mainnet)
-	}
-
-	if os.Getenv("LOTUS_DISABLE_V2_ACTOR_MIGRATION") == "1" {
-		UpgradeActorsV2Height = math.MaxInt64
-	}
+	SetAddressNetwork(address.Testnet)

 	Devnet = false
 }
@@ -29,7 +29,7 @@ func buildType() string {
 }

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

 func UserVersion() string {
 	return BuildVersion + buildType() + CurrentCommit
@@ -22,7 +22,6 @@ import (
 var SystemActorAddr = builtin0.SystemActorAddr
 var BurntFundsActorAddr = builtin0.BurntFundsActorAddr
 var ReserveAddress = makeAddress("t090")
-var RootVerifierAddress = makeAddress("t080")

 // TODO: Why does actors have 2 different versions of this?
 type SectorInfo = proof0.SectorInfo
@@ -1,180 +0,0 @@
-package miner
-
-import (
-	"errors"
-
-	"github.com/filecoin-project/go-bitfield"
-	"github.com/filecoin-project/go-state-types/exitcode"
-)
-
-type DeadlinesDiff map[uint64]*DeadlineDiff
-
-func DiffDeadlines(pre, cur State) (*DeadlinesDiff, error) {
-	changed, err := pre.DeadlinesChanged(cur)
-	if err != nil {
-		return nil, err
-	}
-	if !changed {
-		return nil, nil
-	}
-
-	numDl, err := pre.NumDeadlines()
-	if err != nil {
-		return nil, err
-	}
-	dlDiff := make(DeadlinesDiff, numDl)
-	if err := pre.ForEachDeadline(func(idx uint64, preDl Deadline) error {
-		curDl, err := cur.LoadDeadline(idx)
-		if err != nil {
-			return err
-		}
-
-		diff, err := DiffDeadline(preDl, curDl)
-		if err != nil {
-			return err
-		}
-
-		dlDiff[idx] = diff
-		return nil
-	}); err != nil {
-		return nil, err
-	}
-	return &dlDiff, nil
-}
-
-type DeadlineDiff map[uint64]*PartitionDiff
-
-func DiffDeadline(pre, cur Deadline) (*DeadlineDiff, error) {
-	changed, err := pre.PartitionsChanged(cur)
-	if err != nil {
-		return nil, err
-	}
-	if !changed {
-		return nil, nil
-	}
-
-	partDiff := make(DeadlineDiff)
-	if err := pre.ForEachPartition(func(idx uint64, prePart Partition) error {
-		// try loading current partition at this index
-		curPart, err := cur.LoadPartition(idx)
-		if err != nil {
-			if errors.Is(err, exitcode.ErrNotFound) {
-				// TODO correctness?
-				return nil // the partition was removed.
-			}
-			return err
-		}
-
-		// compare it with the previous partition
-		diff, err := DiffPartition(prePart, curPart)
-		if err != nil {
-			return err
-		}
-
-		partDiff[idx] = diff
-		return nil
-	}); err != nil {
-		return nil, err
-	}
-
-	// all previous partitions have been walked.
-	// all partitions in cur and not in prev are new... can they be faulty already?
-	// TODO is this correct?
-	if err := cur.ForEachPartition(func(idx uint64, curPart Partition) error {
-		if _, found := partDiff[idx]; found {
-			return nil
-		}
-		faults, err := curPart.FaultySectors()
-		if err != nil {
-			return err
-		}
-		recovering, err := curPart.RecoveringSectors()
-		if err != nil {
-			return err
-		}
-		partDiff[idx] = &PartitionDiff{
-			Removed:    bitfield.New(),
-			Recovered:  bitfield.New(),
-			Faulted:    faults,
-			Recovering: recovering,
-		}
-
-		return nil
-	}); err != nil {
-		return nil, err
-	}
-
-	return &partDiff, nil
-}
-
-type PartitionDiff struct {
-	Removed    bitfield.BitField
-	Recovered  bitfield.BitField
-	Faulted    bitfield.BitField
-	Recovering bitfield.BitField
-}
-
-func DiffPartition(pre, cur Partition) (*PartitionDiff, error) {
-	prevLiveSectors, err := pre.LiveSectors()
-	if err != nil {
-		return nil, err
-	}
-	curLiveSectors, err := cur.LiveSectors()
-	if err != nil {
-		return nil, err
-	}
-
-	removed, err := bitfield.SubtractBitField(prevLiveSectors, curLiveSectors)
-	if err != nil {
-		return nil, err
-	}
-
-	prevRecoveries, err := pre.RecoveringSectors()
-	if err != nil {
-		return nil, err
-	}
-
-	curRecoveries, err := cur.RecoveringSectors()
-	if err != nil {
-		return nil, err
-	}
-
-	recovering, err := bitfield.SubtractBitField(curRecoveries, prevRecoveries)
-	if err != nil {
-		return nil, err
-	}
-
-	prevFaults, err := pre.FaultySectors()
-	if err != nil {
-		return nil, err
-	}
-
-	curFaults, err := cur.FaultySectors()
-	if err != nil {
-		return nil, err
-	}
-
-	faulted, err := bitfield.SubtractBitField(curFaults, prevFaults)
-	if err != nil {
-		return nil, err
-	}
-
-	// all current good sectors
-	curActiveSectors, err := cur.ActiveSectors()
-	if err != nil {
-		return nil, err
-	}
-
-	// sectors that were previously fault and are now currently active are considered recovered.
-	recovered, err := bitfield.IntersectBitField(prevFaults, curActiveSectors)
-	if err != nil {
-		return nil, err
-	}
-
-	return &PartitionDiff{
-		Removed:    removed,
-		Recovered:  recovered,
-		Faulted:    faulted,
-		Recovering: recovering,
-	}, nil
-}
@@ -57,7 +57,7 @@ func (s *state0) CumsumBaseline() (abi.StoragePower, error) {
 }

 func (s *state0) CumsumRealized() (abi.StoragePower, error) {
-	return s.State.CumsumRealized, nil
+	return s.State.CumsumBaseline, nil
 }

 func (s *state0) InitialPledgeForPower(sectorWeight abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) {
@@ -60,7 +60,7 @@ func (s *state2) CumsumBaseline() (abi.StoragePower, error) {
 }

 func (s *state2) CumsumRealized() (abi.StoragePower, error) {
-	return s.State.CumsumRealized, nil
+	return s.State.CumsumBaseline, nil
 }

 func (s *state2) InitialPledgeForPower(qaPower abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) {
@@ -9,8 +9,8 @@ import (
 type Version int

 const (
-	Version0 Version = 0
-	Version2 Version = 2
+	Version0 = 0
+	Version2 = 2
 )

 // Converts a network version into an actors adt version.
@@ -39,7 +39,6 @@ import (
 	"github.com/filecoin-project/lotus/cmd/lotus-seed/seed"
 	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/lotus/genesis"
-	"github.com/filecoin-project/lotus/journal"
 	"github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/filecoin-project/lotus/lib/sigs"
 	"github.com/filecoin-project/lotus/node/repo"
@@ -72,7 +71,7 @@ type ChainGen struct {

 	GetMessages func(*ChainGen) ([]*types.SignedMessage, error)

-	w *wallet.LocalWallet
+	w *wallet.Wallet

 	eppProvs    map[address.Address]WinningPoStProver
 	Miners      []address.Address
@@ -123,7 +122,6 @@ var DefaultRemainderAccountActor = genesis.Actor{
 }

 func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
-	j := journal.NilJournal()
 	// TODO: we really shouldn't modify a global variable here.
 	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)

@@ -155,14 +153,14 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 		return nil, xerrors.Errorf("creating memrepo wallet failed: %w", err)
 	}

-	banker, err := w.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	banker, err := w.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to generate banker key: %w", err)
 	}

 	receievers := make([]address.Address, msgsPerBlock)
 	for r := range receievers {
-		receievers[r], err = w.WalletNew(context.Background(), crypto.SigTypeBLS)
+		receievers[r], err = w.GenerateKey(crypto.SigTypeBLS)
 		if err != nil {
 			return nil, xerrors.Errorf("failed to generate receiver key: %w", err)
 		}
@@ -192,11 +190,11 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 		return nil, err
 	}

-	mk1, err := w.WalletImport(context.Background(), k1)
+	mk1, err := w.Import(k1)
 	if err != nil {
 		return nil, err
 	}
-	mk2, err := w.WalletImport(context.Background(), k2)
+	mk2, err := w.Import(k2)
 	if err != nil {
 		return nil, err
 	}
@@ -231,12 +229,12 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 		Timestamp:        uint64(build.Clock.Now().Add(-500 * time.Duration(build.BlockDelaySecs) * time.Second).Unix()),
 	}

-	genb, err := genesis2.MakeGenesisBlock(context.TODO(), j, bs, sys, tpl)
+	genb, err := genesis2.MakeGenesisBlock(context.TODO(), bs, sys, tpl)
 	if err != nil {
 		return nil, xerrors.Errorf("make genesis block failed: %w", err)
 	}

-	cs := store.NewChainStore(bs, ds, sys, j)
+	cs := store.NewChainStore(bs, ds, sys)

 	genfb := &types.FullBlock{Header: genb.Genesis}
 	gents := store.NewFullTipSet([]*types.FullBlock{genfb})
@@ -376,13 +374,7 @@ func (cg *ChainGen) nextBlockProof(ctx context.Context, pts *types.TipSet, m add
 		return nil, nil, nil, xerrors.Errorf("get miner worker: %w", err)
 	}

-	sf := func(ctx context.Context, a address.Address, i []byte) (*crypto.Signature, error) {
-		return cg.w.WalletSign(ctx, a, i, api.MsgMeta{
-			Type: api.MTUnknown,
-		})
-	}
-
-	vrfout, err := ComputeVRF(ctx, sf, worker, ticketRand)
+	vrfout, err := ComputeVRF(ctx, cg.w.Sign, worker, ticketRand)
 	if err != nil {
 		return nil, nil, nil, xerrors.Errorf("compute VRF: %w", err)
 	}
@@ -514,7 +506,7 @@ func (cg *ChainGen) Banker() address.Address {
 	return cg.banker
 }

-func (cg *ChainGen) Wallet() *wallet.LocalWallet {
+func (cg *ChainGen) Wallet() *wallet.Wallet {
 	return cg.w
 }

@@ -536,9 +528,7 @@ func getRandomMessages(cg *ChainGen) ([]*types.SignedMessage, error) {
 			GasPremium: types.NewInt(0),
 		}

-		sig, err := cg.w.WalletSign(context.TODO(), cg.banker, msg.Cid().Bytes(), api.MsgMeta{
-			Type: api.MTUnknown, // testing
-		})
+		sig, err := cg.w.Sign(context.TODO(), cg.banker, msg.Cid().Bytes())
 		if err != nil {
 			return nil, err
 		}
@@ -569,7 +559,7 @@ type MiningCheckAPI interface {
 }

 type mca struct {
-	w   *wallet.LocalWallet
+	w   *wallet.Wallet
 	sm  *stmgr.StateManager
 	pv  ffiwrapper.Verifier
 	bcn beacon.Schedule
@@ -598,9 +588,7 @@ func (mca mca) MinerGetBaseInfo(ctx context.Context, maddr address.Address, epoc
 }

 func (mca mca) WalletSign(ctx context.Context, a address.Address, v []byte) (*crypto.Signature, error) {
-	return mca.w.WalletSign(ctx, a, v, api.MsgMeta{
-		Type: api.MTUnknown,
-	})
+	return mca.w.Sign(ctx, a, v)
 }

 type WinningPoStProver interface {
@@ -7,7 +7,6 @@ import (
 	"fmt"

 	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/journal"

 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
@@ -27,6 +26,7 @@ import (
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"

 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -117,7 +117,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
 		return nil, nil, xerrors.Errorf("putting empty object: %w", err)
 	}

-	state, err := state.NewStateTree(cst, types.StateTreeVersion0)
+	state, err := state.NewStateTree(cst, actors.Version0)
 	if err != nil {
 		return nil, nil, xerrors.Errorf("making new state tree: %w", err)
 	}
@@ -467,10 +467,7 @@ func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot ci
 	return st, nil
 }

-func MakeGenesisBlock(ctx context.Context, j journal.Journal, bs bstore.Blockstore, sys vm.SyscallBuilder, template genesis.Template) (*GenesisBootstrap, error) {
-	if j == nil {
-		j = journal.NilJournal()
-	}
+func MakeGenesisBlock(ctx context.Context, bs bstore.Blockstore, sys vm.SyscallBuilder, template genesis.Template) (*GenesisBootstrap, error) {
 	st, keyIDs, err := MakeInitialStateTree(ctx, bs, template)
 	if err != nil {
 		return nil, xerrors.Errorf("make initial state tree failed: %w", err)
@@ -482,7 +479,7 @@ func MakeGenesisBlock(ctx context.Context, j journal.Journal, bs bstore.Blocksto
 	}

 	// temp chainstore
-	cs := store.NewChainStore(bs, datastore.NewMapDatastore(), sys, j)
+	cs := store.NewChainStore(bs, datastore.NewMapDatastore(), sys)

 	// Verify PreSealed Data
 	stateroot, err = VerifyPreSealedData(ctx, cs, stateroot, template, keyIDs)
@@ -15,10 +15,11 @@ import (
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/chain/wallet"
 	"github.com/filecoin-project/lotus/lib/sigs/bls"
 )

-func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w api.WalletAPI, bt *api.BlockTemplate) (*types.FullBlock, error) {
+func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w *wallet.Wallet, bt *api.BlockTemplate) (*types.FullBlock, error) {

 	pts, err := sm.ChainStore().LoadTipSet(bt.Parents)
 	if err != nil {
@@ -130,9 +131,7 @@ func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w api.WalletA
 		return nil, xerrors.Errorf("failed to get signing bytes for block: %w", err)
 	}

-	sig, err := w.WalletSign(ctx, waddr, nosigbytes, api.MsgMeta{
-		Type: api.MTBlock,
-	})
+	sig, err := w.Sign(ctx, waddr, nosigbytes)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to sign new block: %w", err)
 	}
@@ -120,10 +120,9 @@ func (fm *FundMgr) EnsureAvailable(ctx context.Context, addr, wallet address.Add
 		return cid.Undef, err
 	}
 	fm.lk.Lock()
-	defer fm.lk.Unlock()
-
 	bal, err := fm.api.StateMarketBalance(ctx, addr, types.EmptyTSK)
 	if err != nil {
+		fm.lk.Unlock()
 		return cid.Undef, err
 	}

@@ -139,6 +138,7 @@ func (fm *FundMgr) EnsureAvailable(ctx context.Context, addr, wallet address.Add
 		toAdd = types.NewInt(0)
 	}
 	fm.available[idAddr] = big.Add(avail, toAdd)
+	fm.lk.Unlock()

 	log.Infof("Funds operation w/ Expected Balance: %s, In State: %s, Requested: %s, Adding: %s", avail.String(), stateAvail.String(), amt.String(), toAdd.String())

@@ -148,7 +148,6 @@ func (fm *FundMgr) EnsureAvailable(ctx context.Context, addr, wallet address.Add

 	params, err := actors.SerializeParams(&addr)
 	if err != nil {
-		fm.available[idAddr] = avail
 		return cid.Undef, err
 	}

@@ -160,7 +159,6 @@ func (fm *FundMgr) EnsureAvailable(ctx context.Context, addr, wallet address.Add
 		Params: params,
 	}, nil)
 	if err != nil {
-		fm.available[idAddr] = avail
 		return cid.Undef, err
 	}

@@ -57,10 +57,9 @@ func addFundsMsg(toAdd abi.TokenAmount, addr address.Address, wallet address.Add
 }

 type expectedResult struct {
-	addAmt          abi.TokenAmount
-	shouldAdd       bool
-	err             error
-	cachedAvailable abi.TokenAmount
+	addAmt    abi.TokenAmount
+	shouldAdd bool
+	err       error
 }

 func TestAddFunds(t *testing.T) {
@@ -89,9 +88,8 @@ func TestAddFunds(t *testing.T) {
 			addAmounts:      []abi.TokenAmount{abi.NewTokenAmount(100)},
 			expectedResults: []expectedResult{
 				{
-					shouldAdd:       false,
-					err:             nil,
-					cachedAvailable: abi.NewTokenAmount(100),
+					shouldAdd: false,
+					err:       nil,
 				},
 			},
 		},
@@ -104,21 +102,18 @@ func TestAddFunds(t *testing.T) {
 					err:       nil,
 				},
 				{
-					addAmt:          abi.NewTokenAmount(100),
-					shouldAdd:       true,
-					err:             nil,
-					cachedAvailable: abi.NewTokenAmount(200),
+					addAmt:    abi.NewTokenAmount(100),
+					shouldAdd: true,
+					err:       nil,
 				},
 				{
-					addAmt:          abi.NewTokenAmount(50),
-					shouldAdd:       true,
-					err:             nil,
-					cachedAvailable: abi.NewTokenAmount(250),
+					addAmt:    abi.NewTokenAmount(50),
+					shouldAdd: true,
+					err:       nil,
 				},
 				{
-					shouldAdd:       false,
-					err:             nil,
-					cachedAvailable: abi.NewTokenAmount(250),
+					shouldAdd: false,
+					err:       nil,
 				},
 			},
 		},
@@ -137,8 +132,7 @@ func TestAddFunds(t *testing.T) {
 			addAmounts:      []abi.TokenAmount{abi.NewTokenAmount(100)},
 			expectedResults: []expectedResult{
 				{
-					err:             errors.New("something went wrong"),
-					cachedAvailable: abi.NewTokenAmount(0),
+					err: errors.New("something went wrong"),
 				},
 			},
 		},
@@ -189,10 +183,6 @@ func TestAddFunds(t *testing.T) {
 				} else {
 					require.EqualError(t, err, expected.err.Error())
 				}
-
-				if !expected.cachedAvailable.Nil() {
-					require.Equal(t, expected.cachedAvailable, fundMgr.available[addr])
-				}
 			}
 		})
 	}
@@ -159,7 +159,6 @@ type MessagePool struct {
 	sigValCache *lru.TwoQueueCache

 	evtTypes [3]journal.EventType
-	journal  journal.Journal
 }

 type msgSet struct {
@@ -317,7 +316,7 @@ func (ms *msgSet) getRequiredFunds(nonce uint64) types.BigInt {
 	return types.BigInt{Int: requiredFunds}
 }

-func New(api Provider, ds dtypes.MetadataDS, netName dtypes.NetworkName, j journal.Journal) (*MessagePool, error) {
+func New(api Provider, ds dtypes.MetadataDS, netName dtypes.NetworkName) (*MessagePool, error) {
 	cache, _ := lru.New2Q(build.BlsSignatureCacheSize)
 	verifcache, _ := lru.New2Q(build.VerifSigCacheSize)

@@ -326,10 +325,6 @@ func New(api Provider, ds dtypes.MetadataDS, netName dtypes.NetworkName, j journ
 		return nil, xerrors.Errorf("error loading mpool config: %w", err)
 	}

-	if j == nil {
-		j = journal.NilJournal()
-	}
-
 	mp := &MessagePool{
 		ds:            ds,
 		addSema:       make(chan struct{}, 1),
@@ -349,11 +344,10 @@ func New(api Provider, ds dtypes.MetadataDS, netName dtypes.NetworkName, j journ
 		netName:       netName,
 		cfg:           cfg,
 		evtTypes: [...]journal.EventType{
-			evtTypeMpoolAdd:    j.RegisterEventType("mpool", "add"),
-			evtTypeMpoolRemove: j.RegisterEventType("mpool", "remove"),
-			evtTypeMpoolRepub:  j.RegisterEventType("mpool", "repub"),
+			evtTypeMpoolAdd:    journal.J.RegisterEventType("mpool", "add"),
+			evtTypeMpoolRemove: journal.J.RegisterEventType("mpool", "remove"),
+			evtTypeMpoolRepub:  journal.J.RegisterEventType("mpool", "repub"),
 		},
-		journal: j,
 	}

 	// enable initial prunes
@@ -750,7 +744,7 @@ func (mp *MessagePool) addLocked(m *types.SignedMessage, strict, untrusted bool)
 		Message: m,
 	}, localUpdates)

-	mp.journal.RecordEvent(mp.evtTypes[evtTypeMpoolAdd], func() interface{} {
+	journal.J.RecordEvent(mp.evtTypes[evtTypeMpoolAdd], func() interface{} {
 		return MessagePoolEvt{
 			Action:   "add",
 			Messages: []MessagePoolEvtMessage{{Message: m.Message, CID: m.Cid()}},
@@ -871,7 +865,7 @@ func (mp *MessagePool) remove(from address.Address, nonce uint64, applied bool)
 			Message: m,
 		}, localUpdates)

-		mp.journal.RecordEvent(mp.evtTypes[evtTypeMpoolRemove], func() interface{} {
+		journal.J.RecordEvent(mp.evtTypes[evtTypeMpoolRemove], func() interface{} {
 			return MessagePoolEvt{
 				Action:   "remove",
 				Messages: []MessagePoolEvtMessage{{Message: m.Message, CID: m.Cid()}}}
@@ -225,14 +225,14 @@ func TestMessagePool(t *testing.T) {

 	ds := datastore.NewMapDatastore()

-	mp, err := New(tma, ds, "mptest", nil)
+	mp, err := New(tma, ds, "mptest")
 	if err != nil {
 		t.Fatal(err)
 	}

 	a := tma.nextBlock()

-	sender, err := w.WalletNew(context.Background(), crypto.SigTypeBLS)
+	sender, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -266,14 +266,14 @@ func TestMessagePoolMessagesInEachBlock(t *testing.T) {

 	ds := datastore.NewMapDatastore()

-	mp, err := New(tma, ds, "mptest", nil)
+	mp, err := New(tma, ds, "mptest")
 	if err != nil {
 		t.Fatal(err)
 	}

 	a := tma.nextBlock()

-	sender, err := w.WalletNew(context.Background(), crypto.SigTypeBLS)
+	sender, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -315,7 +315,7 @@ func TestRevertMessages(t *testing.T) {

 	ds := datastore.NewMapDatastore()

-	mp, err := New(tma, ds, "mptest", nil)
+	mp, err := New(tma, ds, "mptest")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -323,7 +323,7 @@ func TestRevertMessages(t *testing.T) {
 	a := tma.nextBlock()
 	b := tma.nextBlock()

-	sender, err := w.WalletNew(context.Background(), crypto.SigTypeBLS)
+	sender, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -378,7 +378,7 @@ func TestPruningSimple(t *testing.T) {

 	ds := datastore.NewMapDatastore()

-	mp, err := New(tma, ds, "mptest", nil)
+	mp, err := New(tma, ds, "mptest")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -386,7 +386,7 @@ func TestPruningSimple(t *testing.T) {
 	a := tma.nextBlock()
 	tma.applyBlock(t, a)

-	sender, err := w.WalletNew(context.Background(), crypto.SigTypeBLS)
+	sender, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -422,7 +422,7 @@ func TestLoadLocal(t *testing.T) {
 	tma := newTestMpoolAPI()
 	ds := datastore.NewMapDatastore()

-	mp, err := New(tma, ds, "mptest", nil)
+	mp, err := New(tma, ds, "mptest")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -433,7 +433,7 @@ func TestLoadLocal(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -443,7 +443,7 @@ func TestLoadLocal(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -465,7 +465,7 @@ func TestLoadLocal(t *testing.T) {
 		t.Fatal(err)
 	}

-	mp, err = New(tma, ds, "mptest", nil)
+	mp, err = New(tma, ds, "mptest")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -494,7 +494,7 @@ func TestClearAll(t *testing.T) {
 	tma := newTestMpoolAPI()
 	ds := datastore.NewMapDatastore()

-	mp, err := New(tma, ds, "mptest", nil)
+	mp, err := New(tma, ds, "mptest")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -505,7 +505,7 @@ func TestClearAll(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -515,7 +515,7 @@ func TestClearAll(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -548,7 +548,7 @@ func TestClearNonLocal(t *testing.T) {
 	tma := newTestMpoolAPI()
 	ds := datastore.NewMapDatastore()

-	mp, err := New(tma, ds, "mptest", nil)
+	mp, err := New(tma, ds, "mptest")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -559,7 +559,7 @@ func TestClearNonLocal(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -569,7 +569,7 @@ func TestClearNonLocal(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -609,7 +609,7 @@ func TestUpdates(t *testing.T) {
 	tma := newTestMpoolAPI()
 	ds := datastore.NewMapDatastore()

-	mp, err := New(tma, ds, "mptest", nil)
+	mp, err := New(tma, ds, "mptest")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -620,7 +620,7 @@ func TestUpdates(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -630,7 +630,7 @@ func TestUpdates(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -11,6 +11,7 @@ import (
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/journal"
 	"github.com/ipfs/go-cid"
 )

@@ -147,14 +148,14 @@ loop:
 	}

 	if len(msgs) > 0 {
-		mp.journal.RecordEvent(mp.evtTypes[evtTypeMpoolRepub], func() interface{} {
-			msgsEv := make([]MessagePoolEvtMessage, 0, len(msgs))
+		journal.J.RecordEvent(mp.evtTypes[evtTypeMpoolRepub], func() interface{} {
+			msgs := make([]MessagePoolEvtMessage, 0, len(msgs))
 			for _, m := range msgs {
-				msgsEv = append(msgsEv, MessagePoolEvtMessage{Message: m.Message, CID: m.Cid()})
+				msgs = append(msgs, MessagePoolEvtMessage{Message: m.Message, CID: m.Cid()})
 			}
 			return MessagePoolEvt{
 				Action:   "repub",
-				Messages: msgsEv,
+				Messages: msgs,
 			}
 		})
 	}
@@ -1,7 +1,6 @@
 package messagepool

 import (
-	"context"
 	"testing"
 	"time"

@@ -22,7 +21,7 @@ func TestRepubMessages(t *testing.T) {
 	tma := newTestMpoolAPI()
 	ds := datastore.NewMapDatastore()

-	mp, err := New(tma, ds, "mptest", nil)
+	mp, err := New(tma, ds, "mptest")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -33,7 +32,7 @@ func TestRepubMessages(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -43,7 +42,7 @@ func TestRepubMessages(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -13,10 +13,6 @@ import (
 	"sort"
 	"testing"

-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-datastore"
-	logging "github.com/ipfs/go-log"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/lotus/build"
@@ -25,10 +21,12 @@ import (
 	"github.com/filecoin-project/lotus/chain/types/mock"
 	"github.com/filecoin-project/lotus/chain/wallet"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-datastore"

-	"github.com/filecoin-project/lotus/api"
 	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
 	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
+	logging "github.com/ipfs/go-log"
 )

 func init() {
@@ -36,7 +34,7 @@ func init() {
 	MaxActorPendingMessages = 1000000
 }

-func makeTestMessage(w *wallet.LocalWallet, from, to address.Address, nonce uint64, gasLimit int64, gasPrice uint64) *types.SignedMessage {
+func makeTestMessage(w *wallet.Wallet, from, to address.Address, nonce uint64, gasLimit int64, gasPrice uint64) *types.SignedMessage {
 	msg := &types.Message{
 		From:       from,
 		To:         to,
@@ -47,7 +45,7 @@ func makeTestMessage(w *wallet.LocalWallet, from, to address.Address, nonce uint
 		GasFeeCap:  types.NewInt(100 + gasPrice),
 		GasPremium: types.NewInt(gasPrice),
 	}
-	sig, err := w.WalletSign(context.TODO(), from, msg.Cid().Bytes(), api.MsgMeta{})
+	sig, err := w.Sign(context.TODO(), from, msg.Cid().Bytes())
 	if err != nil {
 		panic(err)
 	}
@@ -60,7 +58,7 @@ func makeTestMessage(w *wallet.LocalWallet, from, to address.Address, nonce uint
 func makeTestMpool() (*MessagePool, *testMpoolAPI) {
 	tma := newTestMpoolAPI()
 	ds := datastore.NewMapDatastore()
-	mp, err := New(tma, ds, "test", nil)
+	mp, err := New(tma, ds, "test")
 	if err != nil {
 		panic(err)
 	}
@@ -77,7 +75,7 @@ func TestMessageChains(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -87,7 +85,7 @@ func TestMessageChains(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -315,7 +313,7 @@ func TestMessageChainSkipping(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -325,7 +323,7 @@ func TestMessageChainSkipping(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -391,7 +389,7 @@ func TestBasicMessageSelection(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -401,7 +399,7 @@ func TestBasicMessageSelection(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -535,7 +533,7 @@ func TestMessageSelectionTrimming(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -545,7 +543,7 @@ func TestMessageSelectionTrimming(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -598,7 +596,7 @@ func TestPriorityMessageSelection(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -608,7 +606,7 @@ func TestPriorityMessageSelection(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -677,7 +675,7 @@ func TestPriorityMessageSelection2(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -687,7 +685,7 @@ func TestPriorityMessageSelection2(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -746,7 +744,7 @@ func TestPriorityMessageSelection3(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -756,7 +754,7 @@ func TestPriorityMessageSelection3(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -843,7 +841,7 @@ func TestOptimalMessageSelection1(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -853,7 +851,7 @@ func TestOptimalMessageSelection1(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -910,7 +908,7 @@ func TestOptimalMessageSelection2(t *testing.T) {
 		t.Fatal(err)
 	}

-	a1, err := w1.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -920,7 +918,7 @@ func TestOptimalMessageSelection2(t *testing.T) {
 		t.Fatal(err)
 	}

-	a2, err := w2.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -986,7 +984,7 @@ func TestOptimalMessageSelection3(t *testing.T) {
 	nActors := 10
 	// the actors
 	var actors []address.Address
-	var wallets []*wallet.LocalWallet
+	var wallets []*wallet.Wallet

 	for i := 0; i < nActors; i++ {
 		w, err := wallet.NewWallet(wallet.NewMemKeyStore())
@@ -994,7 +992,7 @@ func TestOptimalMessageSelection3(t *testing.T) {
 			t.Fatal(err)
 		}

-		a, err := w.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+		a, err := w.GenerateKey(crypto.SigTypeSecp256k1)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -1066,7 +1064,7 @@ func testCompetitiveMessageSelection(t *testing.T, rng *rand.Rand, getPremium fu
 	nActors := 300
 	// the actors
 	var actors []address.Address
-	var wallets []*wallet.LocalWallet
+	var wallets []*wallet.Wallet

 	for i := 0; i < nActors; i++ {
 		w, err := wallet.NewWallet(wallet.NewMemKeyStore())
@@ -1074,7 +1072,7 @@ func testCompetitiveMessageSelection(t *testing.T, rng *rand.Rand, getPremium fu
 			t.Fatal(err)
 		}

-		a, err := w.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+		a, err := w.GenerateKey(crypto.SigTypeSecp256k1)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -1332,7 +1330,7 @@ readLoop:
 	}

 	actorMap := make(map[address.Address]address.Address)
-	actorWallets := make(map[address.Address]api.WalletAPI)
+	actorWallets := make(map[address.Address]*wallet.Wallet)

 	for _, m := range msgs {
 		baseNonce := baseNonces[m.Message.From]
@@ -1344,7 +1342,7 @@ readLoop:
 				t.Fatal(err)
 			}

-			a, err := w.WalletNew(context.Background(), crypto.SigTypeSecp256k1)
+			a, err := w.GenerateKey(crypto.SigTypeSecp256k1)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -1362,7 +1360,7 @@ readLoop:
 		m.Message.From = localActor
 		m.Message.Nonce -= baseNonce

-		sig, err := w.WalletSign(context.TODO(), localActor, m.Message.Cid().Bytes(), api.MsgMeta{})
+		sig, err := w.Sign(context.TODO(), localActor, m.Message.Cid().Bytes())
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -5,37 +5,40 @@ import (
 	"context"
 	"sync"

+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/chain/messagepool"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/wallet"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/namespace"
 	logging "github.com/ipfs/go-log/v2"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )

 const dsKeyActorNonce = "ActorNextNonce"

 var log = logging.Logger("messagesigner")

-type MpoolNonceAPI interface {
+type mpoolAPI interface {
 	GetNonce(address.Address) (uint64, error)
 }

 // MessageSigner keeps track of nonces per address, and increments the nonce
 // when signing a message
 type MessageSigner struct {
-	wallet api.WalletAPI
+	wallet *wallet.Wallet
 	lk     sync.Mutex
-	mpool  MpoolNonceAPI
+	mpool  mpoolAPI
 	ds     datastore.Batching
 }

-func NewMessageSigner(wallet api.WalletAPI, mpool MpoolNonceAPI, ds dtypes.MetadataDS) *MessageSigner {
+func NewMessageSigner(wallet *wallet.Wallet, mpool *messagepool.MessagePool, ds dtypes.MetadataDS) *MessageSigner {
+	return newMessageSigner(wallet, mpool, ds)
+}
+
+func newMessageSigner(wallet *wallet.Wallet, mpool mpoolAPI, ds dtypes.MetadataDS) *MessageSigner {
 	ds = namespace.Wrap(ds, datastore.NewKey("/message-signer/"))
 	return &MessageSigner{
 		wallet: wallet,
@@ -58,16 +61,7 @@ func (ms *MessageSigner) SignMessage(ctx context.Context, msg *types.Message, cb

 	// Sign the message with the nonce
 	msg.Nonce = nonce
-
-	mb, err := msg.ToStorageBlock()
-	if err != nil {
-		return nil, xerrors.Errorf("serializing message: %w", err)
-	}
-
-	sig, err := ms.wallet.WalletSign(ctx, msg.From, mb.Cid().Bytes(), api.MsgMeta{
-		Type:  api.MTChainMsg,
-		Extra: mb.RawData(),
-	})
+	sig, err := ms.wallet.Sign(ctx, msg.From, msg.Cid().Bytes())
 	if err != nil {
 		return nil, xerrors.Errorf("failed to sign message: %w", err)
 	}
@@ -47,13 +47,13 @@ func TestMessageSignerSignMessage(t *testing.T) {
 	ctx := context.Background()

 	w, _ := wallet.NewWallet(wallet.NewMemKeyStore())
-	from1, err := w.WalletNew(ctx, crypto.SigTypeSecp256k1)
+	from1, err := w.GenerateKey(crypto.SigTypeSecp256k1)
 	require.NoError(t, err)
-	from2, err := w.WalletNew(ctx, crypto.SigTypeSecp256k1)
+	from2, err := w.GenerateKey(crypto.SigTypeSecp256k1)
 	require.NoError(t, err)
-	to1, err := w.WalletNew(ctx, crypto.SigTypeSecp256k1)
+	to1, err := w.GenerateKey(crypto.SigTypeSecp256k1)
 	require.NoError(t, err)
-	to2, err := w.WalletNew(ctx, crypto.SigTypeSecp256k1)
+	to2, err := w.GenerateKey(crypto.SigTypeSecp256k1)
 	require.NoError(t, err)

 	type msgSpec struct {
@@ -177,7 +177,7 @@ func TestMessageSignerSignMessage(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			mpool := newMockMpool()
 			ds := ds_sync.MutexWrap(datastore.NewMapDatastore())
-			ms := NewMessageSigner(w, mpool, ds)
+			ms := newMessageSigner(w, mpool, ds)

 			for _, m := range tt.msgs {
 				if len(m.mpoolNonce) == 1 {
@@ -13,7 +13,6 @@ import (

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/lotus/chain/actors"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	cbg "github.com/whyrusleeping/cbor-gen"
@@ -27,7 +26,7 @@ var log = logging.Logger("statetree")
 // StateTree stores actors state by their ID.
 type StateTree struct {
 	root    adt.Map
-	version types.StateTreeVersion
+	version actors.Version // TODO
 	info    cid.Cid
 	Store   cbor.IpldStore

@@ -121,41 +120,21 @@ func (ss *stateSnaps) deleteActor(addr address.Address) {
 	ss.layers[len(ss.layers)-1].actors[addr] = streeOp{Delete: true}
 }

-// VersionForNetwork returns the state tree version for the given network
-// version.
-func VersionForNetwork(ver network.Version) types.StateTreeVersion {
-	if actors.VersionForNetwork(ver) == actors.Version0 {
-		return types.StateTreeVersion0
-	}
-	return types.StateTreeVersion1
-}
-
-func adtForSTVersion(ver types.StateTreeVersion) actors.Version {
-	switch ver {
-	case types.StateTreeVersion0:
-		return actors.Version0
-	case types.StateTreeVersion1:
-		return actors.Version2
-	default:
-		panic("unhandled state tree version")
-	}
-}
-
-func NewStateTree(cst cbor.IpldStore, ver types.StateTreeVersion) (*StateTree, error) {
+func NewStateTree(cst cbor.IpldStore, version actors.Version) (*StateTree, error) {
 	var info cid.Cid
-	switch ver {
-	case types.StateTreeVersion0:
+	switch version {
+	case actors.Version0:
 		// info is undefined
-	case types.StateTreeVersion1:
+	case actors.Version2:
 		var err error
-		info, err = cst.Put(context.TODO(), new(types.StateInfo0))
+		info, err = cst.Put(context.TODO(), new(types.StateInfo))
 		if err != nil {
 			return nil, err
 		}
 	default:
-		return nil, xerrors.Errorf("unsupported state tree version: %d", ver)
+		return nil, xerrors.Errorf("unsupported state tree version: %d", version)
 	}
-	root, err := adt.NewMap(adt.WrapStore(context.TODO(), cst), adtForSTVersion(ver))
+	root, err := adt.NewMap(adt.WrapStore(context.TODO(), cst), version)
 	if err != nil {
 		return nil, err
 	}
@@ -163,7 +142,7 @@ func NewStateTree(cst cbor.IpldStore, ver types.StateTreeVersion) (*StateTree, e
 	return &StateTree{
 		root:    root,
 		info:    info,
-		version: ver,
+		version: version,
 		Store:   cst,
 		snaps:   newStateSnaps(),
 	}, nil
@@ -175,16 +154,13 @@ func LoadStateTree(cst cbor.IpldStore, c cid.Cid) (*StateTree, error) {
 	if err := cst.Get(context.TODO(), c, &root); err != nil {
 		// We failed to decode as the new version, must be an old version.
 		root.Actors = c
-		root.Version = types.StateTreeVersion0
+		root.Version = actors.Version0
 	}

 	switch root.Version {
-	case types.StateTreeVersion0, types.StateTreeVersion1:
+	case actors.Version0, actors.Version2:
 		// Load the actual state-tree HAMT.
-		nd, err := adt.AsMap(
-			adt.WrapStore(context.TODO(), cst), root.Actors,
-			adtForSTVersion(root.Version),
-		)
+		nd, err := adt.AsMap(adt.WrapStore(context.TODO(), cst), root.Actors, actors.Version(root.Version))
 		if err != nil {
 			log.Errorf("loading hamt node %s failed: %s", c, err)
 			return nil, err
@@ -193,7 +169,7 @@ func LoadStateTree(cst cbor.IpldStore, c cid.Cid) (*StateTree, error) {
 		return &StateTree{
 			root:    nd,
 			info:    root.Info,
-			version: root.Version,
+			version: actors.Version(root.Version),
 			Store:   cst,
 			snaps:   newStateSnaps(),
 		}, nil
@@ -333,11 +309,11 @@ func (st *StateTree) Flush(ctx context.Context) (cid.Cid, error) {
 		return cid.Undef, xerrors.Errorf("failed to flush state-tree hamt: %w", err)
 	}
 	// If we're version 0, return a raw tree.
-	if st.version == types.StateTreeVersion0 {
+	if st.version == actors.Version0 {
 		return root, nil
 	}
 	// Otherwise, return a versioned tree.
-	return st.Store.Put(ctx, &types.StateRoot{Version: st.version, Actors: root, Info: st.info})
+	return st.Store.Put(ctx, &types.StateRoot{Version: uint64(st.version), Actors: root, Info: st.info})
 }

 func (st *StateTree) Snapshot(ctx context.Context) error {
@@ -424,7 +400,7 @@ func (st *StateTree) ForEach(f func(address.Address, *types.Actor) error) error
 }

 // Version returns the version of the StateTree data structure in use.
-func (st *StateTree) Version() types.StateTreeVersion {
+func (st *StateTree) Version() actors.Version {
 	return st.version
 }

@@ -13,12 +13,13 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin"

 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/types"
 )

 func BenchmarkStateTreeSet(b *testing.B) {
 	cst := cbor.NewMemCborStore()
-	st, err := NewStateTree(cst, VersionForNetwork(build.NewestNetworkVersion))
+	st, err := NewStateTree(cst, actors.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -45,7 +46,7 @@ func BenchmarkStateTreeSet(b *testing.B) {

 func BenchmarkStateTreeSetFlush(b *testing.B) {
 	cst := cbor.NewMemCborStore()
-	st, err := NewStateTree(cst, VersionForNetwork(build.NewestNetworkVersion))
+	st, err := NewStateTree(cst, actors.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -75,7 +76,7 @@ func BenchmarkStateTreeSetFlush(b *testing.B) {

 func BenchmarkStateTree10kGetActor(b *testing.B) {
 	cst := cbor.NewMemCborStore()
-	st, err := NewStateTree(cst, VersionForNetwork(build.NewestNetworkVersion))
+	st, err := NewStateTree(cst, actors.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -117,7 +118,7 @@ func BenchmarkStateTree10kGetActor(b *testing.B) {

 func TestSetCache(t *testing.T) {
 	cst := cbor.NewMemCborStore()
-	st, err := NewStateTree(cst, VersionForNetwork(build.NewestNetworkVersion))
+	st, err := NewStateTree(cst, actors.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -154,7 +155,7 @@ func TestSetCache(t *testing.T) {
 func TestSnapshots(t *testing.T) {
 	ctx := context.Background()
 	cst := cbor.NewMemCborStore()
-	st, err := NewStateTree(cst, VersionForNetwork(build.NewestNetworkVersion))
+	st, err := NewStateTree(cst, actors.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -238,7 +239,7 @@ func assertNotHas(t *testing.T, st *StateTree, addr address.Address) {
 func TestStateTreeConsistency(t *testing.T) {
 	cst := cbor.NewMemCborStore()
 	// TODO: ActorUpgrade: this test tests pre actors v2
-	st, err := NewStateTree(cst, VersionForNetwork(network.Version3))
+	st, err := NewStateTree(cst, actors.VersionForNetwork(network.Version3))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2,7 +2,6 @@ package stmgr

 import (
 	"context"
-	"errors"
 	"fmt"

 	"github.com/filecoin-project/go-address"
@@ -18,38 +17,17 @@ import (
 	"github.com/filecoin-project/lotus/chain/vm"
 )

-var ErrExpensiveFork = errors.New("refusing explicit call due to state fork at epoch")
-
 func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.TipSet) (*api.InvocResult, error) {
 	ctx, span := trace.StartSpan(ctx, "statemanager.Call")
 	defer span.End()

-	// If no tipset is provided, try to find one without a fork.
 	if ts == nil {
 		ts = sm.cs.GetHeaviestTipSet()
-
-		// Search back till we find a height with no fork, or we reach the beginning.
-		for ts.Height() > 0 && sm.hasExpensiveFork(ctx, ts.Height()-1) {
-			var err error
-			ts, err = sm.cs.GetTipSetFromKey(ts.Parents())
-			if err != nil {
-				return nil, xerrors.Errorf("failed to find a non-forking epoch: %w", err)
-			}
-		}
 	}

 	bstate := ts.ParentState()
 	bheight := ts.Height()

-	// If we have to run an expensive migration, and we're not at genesis,
-	// return an error because the migration will take too long.
-	//
-	// We allow this at height 0 for at-genesis migrations (for testing).
-	if bheight-1 > 0 && sm.hasExpensiveFork(ctx, bheight-1) {
-		return nil, ErrExpensiveFork
-	}
-
-	// Run the (not expensive) migration.
 	bstate, err := sm.handleStateForks(ctx, bstate, bheight-1, nil, ts)
 	if err != nil {
 		return nil, fmt.Errorf("failed to handle fork: %w", err)
@@ -66,7 +44,7 @@ func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.
 		BaseFee:        types.NewInt(0),
 	}

-	vmi, err := sm.newVM(ctx, vmopt)
+	vmi, err := vm.NewVM(ctx, vmopt)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to set up vm: %w", err)
 	}
@@ -128,24 +106,6 @@ func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, pri

 	if ts == nil {
 		ts = sm.cs.GetHeaviestTipSet()
-
-		// Search back till we find a height with no fork, or we reach the beginning.
-		// We need the _previous_ height to have no fork, because we'll
-		// run the fork logic in `sm.TipSetState`. We need the _current_
-		// height to have no fork, because we'll run it inside this
-		// function before executing the given message.
-		for ts.Height() > 0 && (sm.hasExpensiveFork(ctx, ts.Height()) || sm.hasExpensiveFork(ctx, ts.Height()-1)) {
-			var err error
-			ts, err = sm.cs.GetTipSetFromKey(ts.Parents())
-			if err != nil {
-				return nil, xerrors.Errorf("failed to find a non-forking epoch: %w", err)
-			}
-		}
-	}
-
-	// When we're not at the genesis block, make sure we don't have an expensive migration.
-	if ts.Height() > 0 && (sm.hasExpensiveFork(ctx, ts.Height()) || sm.hasExpensiveFork(ctx, ts.Height()-1)) {
-		return nil, ErrExpensiveFork
 	}

 	state, _, err := sm.TipSetState(ctx, ts)
@@ -178,7 +138,7 @@ func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, pri
 		NtwkVersion:    sm.GetNtwkVersion,
 		BaseFee:        ts.Blocks()[0].ParentBaseFee,
 	}
-	vmi, err := sm.newVM(ctx, vmopt)
+	vmi, err := vm.NewVM(ctx, vmopt)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to set up vm: %w", err)
 	}
@@ -6,8 +6,6 @@ import (
 	"encoding/binary"
 	"math"

-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
@@ -24,32 +22,23 @@ import (

 	"github.com/filecoin-project/specs-actors/actors/migration/nv3"
 	m2 "github.com/filecoin-project/specs-actors/v2/actors/migration"
+	states2 "github.com/filecoin-project/specs-actors/v2/actors/states"

 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
 	"github.com/filecoin-project/lotus/chain/state"
-	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
-	bstore "github.com/filecoin-project/lotus/lib/blockstore"
-	"github.com/filecoin-project/lotus/lib/bufbstore"
 )

-// UpgradeFunc is a migration function run at every upgrade.
-//
-// - The oldState is the state produced by the upgrade epoch.
-// - The returned newState is the new state that will be used by the next epoch.
-// - The height is the upgrade epoch height (already executed).
-// - The tipset is the tipset for the last non-null block before the upgrade. Do
-//   not assume that ts.Height() is the upgrade height.
-type UpgradeFunc func(ctx context.Context, sm *StateManager, cb ExecCallback, oldState cid.Cid, height abi.ChainEpoch, ts *types.TipSet) (newState cid.Cid, err error)
+type UpgradeFunc func(context.Context, *StateManager, ExecCallback, cid.Cid, *types.TipSet) (cid.Cid, error)

 type Upgrade struct {
 	Height    abi.ChainEpoch
 	Network   network.Version
-	Expensive bool
 	Migration UpgradeFunc
 }

@@ -58,7 +47,7 @@ type UpgradeSchedule []Upgrade
 func DefaultUpgradeSchedule() UpgradeSchedule {
 	var us UpgradeSchedule

-	updates := []Upgrade{{
+	for _, u := range []Upgrade{{
 		Height:    build.UpgradeBreezeHeight,
 		Network:   network.Version1,
 		Migration: UpgradeFaucetBurnRecovery,
@@ -70,46 +59,15 @@ func DefaultUpgradeSchedule() UpgradeSchedule {
 		Height:    build.UpgradeIgnitionHeight,
 		Network:   network.Version3,
 		Migration: UpgradeIgnition,
-	}, {
-		Height:    build.UpgradeRefuelHeight,
-		Network:   network.Version3,
-		Migration: UpgradeRefuel,
 	}, {
 		Height:    build.UpgradeActorsV2Height,
 		Network:   network.Version4,
-		Expensive: true,
 		Migration: UpgradeActorsV2,
 	}, {
 		Height:    build.UpgradeLiftoffHeight,
 		Network:   network.Version4,
 		Migration: UpgradeLiftoff,
-	}}
-
-	if build.UpgradeActorsV2Height == math.MaxInt64 { // disable actors upgrade
-		updates = []Upgrade{{
-			Height:    build.UpgradeBreezeHeight,
-			Network:   network.Version1,
-			Migration: UpgradeFaucetBurnRecovery,
-		}, {
-			Height:    build.UpgradeSmokeHeight,
-			Network:   network.Version2,
-			Migration: nil,
-		}, {
-			Height:    build.UpgradeIgnitionHeight,
-			Network:   network.Version3,
-			Migration: UpgradeIgnition,
-		}, {
-			Height:    build.UpgradeRefuelHeight,
-			Network:   network.Version3,
-			Migration: UpgradeRefuel,
-		}, {
-			Height:    build.UpgradeLiftoffHeight,
-			Network:   network.Version3,
-			Migration: UpgradeLiftoff,
-		}}
-	}
-
-	for _, u := range updates {
+	}} {
 		if u.Height < 0 {
 			// upgrade disabled
 			continue
@@ -151,7 +109,7 @@ func (sm *StateManager) handleStateForks(ctx context.Context, root cid.Cid, heig
 	var err error
 	f, ok := sm.stateMigrations[height]
 	if ok {
-		retCid, err = f(ctx, sm, cb, root, height, ts)
+		retCid, err = f(ctx, sm, cb, root, ts)
 		if err != nil {
 			return cid.Undef, err
 		}
@@ -160,11 +118,6 @@ func (sm *StateManager) handleStateForks(ctx context.Context, root cid.Cid, heig
 	return retCid, nil
 }

-func (sm *StateManager) hasExpensiveFork(ctx context.Context, height abi.ChainEpoch) bool {
-	_, ok := sm.expensiveUpgrades[height]
-	return ok
-}
-
 func doTransfer(cb ExecCallback, tree types.StateTree, from, to address.Address, amt abi.TokenAmount) error {
 	fromAct, err := tree.GetActor(from)
 	if err != nil {
@@ -227,7 +180,7 @@ func doTransfer(cb ExecCallback, tree types.StateTree, from, to address.Address,
 	return nil
 }

-func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
+func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
 	// Some initial parameters
 	FundsForMiners := types.FromFil(1_000_000)
 	LookbackEpoch := abi.ChainEpoch(32000)
@@ -479,9 +432,11 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, cb ExecCal
 	return tree.Flush(ctx)
 }

-func UpgradeIgnition(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
+func UpgradeIgnition(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
 	store := sm.cs.Store(ctx)

+	epoch := ts.Height() - 1
+
 	if build.UpgradeLiftoffHeight <= epoch {
 		return cid.Undef, xerrors.Errorf("liftoff height must be beyond ignition height")
 	}
@@ -534,42 +489,12 @@ func UpgradeIgnition(ctx context.Context, sm *StateManager, cb ExecCallback, roo
 	return tree.Flush(ctx)
 }

-func UpgradeRefuel(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
-
+func UpgradeActorsV2(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
 	store := sm.cs.Store(ctx)
-	tree, err := sm.StateTree(root)
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("getting state tree: %w", err)
-	}

-	addr, err := address.NewFromString("t0122")
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("getting address: %w", err)
-	}
+	epoch := ts.Height() - 1

-	err = resetMultisigVesting(ctx, store, tree, addr, 0, 0, big.Zero())
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("tweaking msig vesting: %w", err)
-	}
-
-	err = resetMultisigVesting(ctx, store, tree, builtin.ReserveAddress, 0, 0, big.Zero())
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("tweaking msig vesting: %w", err)
-	}
-
-	err = resetMultisigVesting(ctx, store, tree, builtin.RootVerifierAddress, 0, 0, big.Zero())
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("tweaking msig vesting: %w", err)
-	}
-
-	return tree.Flush(ctx)
-}
-
-func UpgradeActorsV2(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
-	buf := bufbstore.NewTieredBstore(sm.cs.Blockstore(), bstore.NewTemporarySync())
-	store := store.ActorStore(ctx, buf)
-
-	info, err := store.Put(ctx, new(types.StateInfo0))
+	info, err := store.Put(ctx, new(types.StateInfo))
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("failed to create new state info for actors v2: %w", err)
 	}
@@ -579,8 +504,22 @@ func UpgradeActorsV2(ctx context.Context, sm *StateManager, cb ExecCallback, roo
 		return cid.Undef, xerrors.Errorf("upgrading to actors v2: %w", err)
 	}

+	newStateTree, err := states2.LoadTree(store, newHamtRoot)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to load new state tree: %w", err)
+	}
+
+	// Check all state-tree invariants.
+	if msgs, err := states2.CheckStateInvariants(newStateTree, types.TotalFilecoinInt); err != nil {
+		return cid.Undef, xerrors.Errorf("failed to check new state tree: %w", err)
+	} else if !msgs.IsEmpty() {
+		// This error is going to be really nasty.
+		return cid.Undef, xerrors.Errorf("network upgrade failed: %v", msgs.Messages())
+	}
+
 	newRoot, err := store.Put(ctx, &types.StateRoot{
-		Version: types.StateTreeVersion1,
+		// TODO: ActorUpgrade: should be state-tree specific, not just the actors version.
+		Version: actors.Version2,
 		Actors:  newHamtRoot,
 		Info:    info,
 	})
@@ -599,19 +538,10 @@ func UpgradeActorsV2(ctx context.Context, sm *StateManager, cb ExecCallback, roo
 		return cid.Undef, xerrors.Errorf("failed to load init actor after upgrade: %w", err)
 	}

-	{
-		from := buf
-		to := buf.Read()
-
-		if err := vm.Copy(ctx, from, to, newRoot); err != nil {
-			return cid.Undef, xerrors.Errorf("copying migrated tree: %w", err)
-		}
-	}
-
 	return newRoot, nil
 }

-func UpgradeLiftoff(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
+func UpgradeLiftoff(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
 	tree, err := sm.StateTree(root)
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("getting state tree: %w", err)
@@ -769,7 +699,6 @@ func makeKeyAddr(splitAddr address.Address, count uint64) (address.Address, erro
 	return addr, nil
 }

-// TODO: After the Liftoff epoch, refactor this to use resetMultisigVesting
 func resetGenesisMsigs(ctx context.Context, sm *StateManager, store adt0.Store, tree *state.StateTree, startEpoch abi.ChainEpoch) error {
 	gb, err := sm.cs.GetGenesis()
 	if err != nil {
@@ -819,34 +748,3 @@ func resetGenesisMsigs(ctx context.Context, sm *StateManager, store adt0.Store,

 	return nil
 }
-
-func resetMultisigVesting(ctx context.Context, store adt0.Store, tree *state.StateTree, addr address.Address, startEpoch abi.ChainEpoch, duration abi.ChainEpoch, balance abi.TokenAmount) error {
-	act, err := tree.GetActor(addr)
-	if err != nil {
-		return xerrors.Errorf("getting actor: %w", err)
-	}
-
-	if !builtin.IsMultisigActor(act.Code) {
-		return xerrors.Errorf("actor wasn't msig: %w", err)
-	}
-
-	var msigState multisig0.State
-	if err := store.Get(ctx, act.Head, &msigState); err != nil {
-		return xerrors.Errorf("reading multisig state: %w", err)
-	}
-
-	msigState.StartEpoch = startEpoch
-	msigState.UnlockDuration = duration
-	msigState.InitialBalance = balance
-
-	act.Head, err = store.Put(ctx, &msigState)
-	if err != nil {
-		return xerrors.Errorf("writing new multisig state: %w", err)
-	}
-
-	if err := tree.SetActor(addr, act); err != nil {
-		return xerrors.Errorf("setting multisig actor: %w", err)
-	}
-
-	return nil
-}
@@ -6,21 +6,14 @@ import (
 	"io"
 	"testing"

-	"github.com/ipfs/go-cid"
-	ipldcbor "github.com/ipfs/go-ipld-cbor"
-	logging "github.com/ipfs/go-log"
-	"github.com/stretchr/testify/require"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
-	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
+	"golang.org/x/xerrors"

-	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 	lotusinit "github.com/filecoin-project/lotus/chain/actors/builtin/init"
@@ -31,6 +24,11 @@ import (
 	"github.com/filecoin-project/lotus/chain/vm"
 	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
 	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
+
+	"github.com/ipfs/go-cid"
+	ipldcbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log"
+	cbg "github.com/whyrusleeping/cbor-gen"
 )

 func init() {
@@ -78,7 +76,7 @@ func (ta testActor) Exports() []interface{} {
 func (ta *testActor) Constructor(rt runtime.Runtime, params *abi.EmptyValue) *abi.EmptyValue {
 	rt.ValidateImmediateCallerAcceptAny()
 	rt.StateCreate(&testActorState{11})
-	//fmt.Println("NEW ACTOR ADDRESS IS: ", rt.Receiver())
+	fmt.Println("NEW ACTOR ADDRESS IS: ", rt.Receiver())

 	return abi.Empty
 }
@@ -122,7 +120,7 @@ func TestForkHeightTriggers(t *testing.T) {
 			Network: 1,
 			Height:  testForkHeight,
 			Migration: func(ctx context.Context, sm *StateManager, cb ExecCallback,
-				root cid.Cid, height abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
+				root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
 				cst := ipldcbor.NewCborStore(sm.ChainStore().Blockstore())

 				st, err := sm.StateTree(root)
@@ -175,7 +173,7 @@ func TestForkHeightTriggers(t *testing.T) {

 	var msgs []*types.SignedMessage

-	enc, err := actors.SerializeParams(&init0.ExecParams{CodeCID: (testActor{}).Code()})
+	enc, err := actors.SerializeParams(&init_.ExecParams{CodeCID: (testActor{}).Code()})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -187,7 +185,7 @@ func TestForkHeightTriggers(t *testing.T) {
 		Params:   enc,
 		GasLimit: types.TestGasLimit,
 	}
-	sig, err := cg.Wallet().WalletSign(ctx, cg.Banker(), m.Cid().Bytes(), api.MsgMeta{})
+	sig, err := cg.Wallet().Sign(ctx, cg.Banker(), m.Cid().Bytes())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -215,7 +213,7 @@ func TestForkHeightTriggers(t *testing.T) {
 		}
 		nonce++

-		sig, err := cg.Wallet().WalletSign(ctx, cg.Banker(), m.Cid().Bytes(), api.MsgMeta{})
+		sig, err := cg.Wallet().Sign(ctx, cg.Banker(), m.Cid().Bytes())
 		if err != nil {
 			return nil, err
 		}
@@ -235,84 +233,3 @@ func TestForkHeightTriggers(t *testing.T) {
 		}
 	}
 }
-
-func TestForkRefuseCall(t *testing.T) {
-	logging.SetAllLoggers(logging.LevelInfo)
-
-	ctx := context.TODO()
-
-	cg, err := gen.NewGenerator()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	sm, err := NewStateManagerWithUpgradeSchedule(
-		cg.ChainStore(), UpgradeSchedule{{
-			Network:   1,
-			Expensive: true,
-			Height:    testForkHeight,
-			Migration: func(ctx context.Context, sm *StateManager, cb ExecCallback,
-				root cid.Cid, height abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
-				return root, nil
-			}}})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	inv := vm.NewActorRegistry()
-	inv.Register(nil, testActor{})
-
-	sm.SetVMConstructor(func(ctx context.Context, vmopt *vm.VMOpts) (*vm.VM, error) {
-		nvm, err := vm.NewVM(ctx, vmopt)
-		if err != nil {
-			return nil, err
-		}
-		nvm.SetInvoker(inv)
-		return nvm, nil
-	})
-
-	cg.SetStateManager(sm)
-
-	enc, err := actors.SerializeParams(&init0.ExecParams{CodeCID: (testActor{}).Code()})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	m := &types.Message{
-		From:       cg.Banker(),
-		To:         lotusinit.Address,
-		Method:     builtin.MethodsInit.Exec,
-		Params:     enc,
-		GasLimit:   types.TestGasLimit,
-		Value:      types.NewInt(0),
-		GasPremium: types.NewInt(0),
-		GasFeeCap:  types.NewInt(0),
-	}
-
-	for i := 0; i < 50; i++ {
-		ts, err := cg.NextTipSet()
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		ret, err := sm.CallWithGas(ctx, m, nil, ts.TipSet.TipSet())
-		switch ts.TipSet.TipSet().Height() {
-		case testForkHeight, testForkHeight + 1:
-			// If I had a fork, or I _will_ have a fork, it should fail.
-			require.Equal(t, ErrExpensiveFork, err)
-		default:
-			require.NoError(t, err)
-			require.True(t, ret.MsgRct.ExitCode.IsSuccess())
-		}
-		// Call just runs on the parent state for a tipset, so we only
-		// expect an error at the fork height.
-		ret, err = sm.Call(ctx, m, ts.TipSet.TipSet())
-		switch ts.TipSet.TipSet().Height() {
-		case testForkHeight + 1:
-			require.Equal(t, ErrExpensiveFork, err)
-		default:
-			require.NoError(t, err)
-			require.True(t, ret.MsgRct.ExitCode.IsSuccess())
-		}
-	}
-}
@@ -2,7 +2,6 @@ package stmgr

 import (
 	"context"
-	"errors"
 	"fmt"
 	"sync"

@@ -38,16 +37,8 @@ import (
 	"github.com/filecoin-project/lotus/chain/vm"
 )

-const LookbackNoLimit = abi.ChainEpoch(-1)
-
 var log = logging.Logger("statemgr")

-type StateManagerAPI interface {
-	LoadActorTsk(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*types.Actor, error)
-	LookupID(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error)
-	ResolveToKeyAddress(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error)
-}
-
 type versionSpec struct {
 	networkVersion network.Version
 	atOrBelow      abi.ChainEpoch
@@ -62,10 +53,6 @@ type StateManager struct {

 	// Maps chain epochs to upgrade functions.
 	stateMigrations map[abi.ChainEpoch]UpgradeFunc
-	// A set of potentially expensive/time consuming upgrades. Explicit
-	// calls for, e.g., gas estimation fail against this epoch with
-	// ErrExpensiveFork.
-	expensiveUpgrades map[abi.ChainEpoch]struct{}

 	stCache              map[string][]cid.Cid
 	compWait             map[string]chan struct{}
@@ -91,7 +78,6 @@ func NewStateManagerWithUpgradeSchedule(cs *store.ChainStore, us UpgradeSchedule
 	}

 	stateMigrations := make(map[abi.ChainEpoch]UpgradeFunc, len(us))
-	expensiveUpgrades := make(map[abi.ChainEpoch]struct{}, len(us))
 	var networkVersions []versionSpec
 	lastVersion := network.Version0
 	if len(us) > 0 {
@@ -101,9 +87,6 @@ func NewStateManagerWithUpgradeSchedule(cs *store.ChainStore, us UpgradeSchedule
 			if upgrade.Migration != nil {
 				stateMigrations[upgrade.Height] = upgrade.Migration
 			}
-			if upgrade.Expensive {
-				expensiveUpgrades[upgrade.Height] = struct{}{}
-			}
 			networkVersions = append(networkVersions, versionSpec{
 				networkVersion: lastVersion,
 				atOrBelow:      upgrade.Height,
@@ -116,14 +99,13 @@ func NewStateManagerWithUpgradeSchedule(cs *store.ChainStore, us UpgradeSchedule
 	}

 	return &StateManager{
-		networkVersions:   networkVersions,
-		latestVersion:     lastVersion,
-		stateMigrations:   stateMigrations,
-		expensiveUpgrades: expensiveUpgrades,
-		newVM:             vm.NewVM,
-		cs:                cs,
-		stCache:           make(map[string][]cid.Cid),
-		compWait:          make(map[string]chan struct{}),
+		networkVersions: networkVersions,
+		latestVersion:   lastVersion,
+		stateMigrations: stateMigrations,
+		newVM:           vm.NewVM,
+		cs:              cs,
+		stCache:         make(map[string][]cid.Cid),
+		compWait:        make(map[string]chan struct{}),
 	}, nil
 }

@@ -516,7 +498,16 @@ func (sm *StateManager) GetReceipt(ctx context.Context, msg cid.Cid, ts *types.T
 		return nil, fmt.Errorf("failed to load message: %w", err)
 	}

-	_, r, _, err := sm.searchBackForMsg(ctx, ts, m, LookbackNoLimit)
+	r, _, err := sm.tipsetExecutedMessage(ts, msg, m.VMMessage())
+	if err != nil {
+		return nil, err
+	}
+
+	if r != nil {
+		return r, nil
+	}
+
+	_, r, _, err = sm.searchBackForMsg(ctx, ts, m)
 	if err != nil {
 		return nil, fmt.Errorf("failed to look back through chain for message: %w", err)
 	}
@@ -525,9 +516,9 @@ func (sm *StateManager) GetReceipt(ctx context.Context, msg cid.Cid, ts *types.T
 }

 // WaitForMessage blocks until a message appears on chain. It looks backwards in the chain to see if this has already
-// happened, with an optional limit to how many epochs it will search. It guarantees that the message has been on
-// chain for at least confidence epochs without being reverted before returning.
-func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confidence uint64, lookbackLimit abi.ChainEpoch) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
+// happened. It guarantees that the message has been on chain for at least confidence epochs without being reverted
+// before returning.
+func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confidence uint64) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()

@@ -565,7 +556,7 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
 	var backFm cid.Cid
 	backSearchWait := make(chan struct{})
 	go func() {
-		fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head[0].Val, msg, lookbackLimit)
+		fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head[0].Val, msg)
 		if err != nil {
 			log.Warnf("failed to look back through chain for message: %w", err)
 			return
@@ -657,7 +648,7 @@ func (sm *StateManager) SearchForMessage(ctx context.Context, mcid cid.Cid) (*ty
 		return head, r, foundMsg, nil
 	}

-	fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head, msg, LookbackNoLimit)
+	fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head, msg)

 	if err != nil {
 		log.Warnf("failed to look back through chain for message %s", mcid)
@@ -671,33 +662,11 @@ func (sm *StateManager) SearchForMessage(ctx context.Context, mcid cid.Cid) (*ty
 	return fts, r, foundMsg, nil
 }

-// searchBackForMsg searches up to limit tipsets backwards from the given
-// tipset for a message receipt.
-// If limit is
-// - 0 then no tipsets are searched
-// - 5 then five tipset are searched
-// - LookbackNoLimit then there is no limit
-func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet, m types.ChainMsg, limit abi.ChainEpoch) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
-	limitHeight := from.Height() - limit
-	noLimit := limit == LookbackNoLimit
+func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet, m types.ChainMsg) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {

 	cur := from
-	curActor, err := sm.LoadActor(ctx, m.VMMessage().From, cur)
-	if err != nil {
-		return nil, nil, cid.Undef, xerrors.Errorf("failed to load initital tipset")
-	}
-
-	mFromId, err := sm.LookupID(ctx, m.VMMessage().From, from)
-	if err != nil {
-		return nil, nil, cid.Undef, xerrors.Errorf("looking up From id address: %w", err)
-	}
-
-	mNonce := m.VMMessage().Nonce
-
 	for {
-		// If we've reached the genesis block, or we've reached the limit of
-		// how far back to look
-		if cur.Height() == 0 || !noLimit && cur.Height() <= limitHeight {
+		if cur.Height() == 0 {
 			// it ain't here!
 			return nil, nil, cid.Undef, nil
 		}
@@ -708,37 +677,32 @@ func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet
 		default:
 		}

+		act, err := sm.LoadActor(ctx, m.VMMessage().From, cur)
+		if err != nil {
+			return nil, nil, cid.Cid{}, err
+		}
+
 		// we either have no messages from the sender, or the latest message we found has a lower nonce than the one being searched for,
 		// either way, no reason to lookback, it ain't there
-		if curActor == nil || curActor.Nonce == 0 || curActor.Nonce < mNonce {
+		if act.Nonce == 0 || act.Nonce < m.VMMessage().Nonce {
 			return nil, nil, cid.Undef, nil
 		}

-		pts, err := sm.cs.LoadTipSet(cur.Parents())
+		ts, err := sm.cs.LoadTipSet(cur.Parents())
 		if err != nil {
-			return nil, nil, cid.Undef, xerrors.Errorf("failed to load tipset during msg wait searchback: %w", err)
+			return nil, nil, cid.Undef, fmt.Errorf("failed to load tipset during msg wait searchback: %w", err)
 		}

-		act, err := sm.LoadActor(ctx, mFromId, pts)
-		actorNoExist := errors.Is(err, types.ErrActorNotFound)
-		if err != nil && !actorNoExist {
-			return nil, nil, cid.Cid{}, xerrors.Errorf("failed to load the actor: %w", err)
+		r, foundMsg, err := sm.tipsetExecutedMessage(ts, m.Cid(), m.VMMessage())
+		if err != nil {
+			return nil, nil, cid.Undef, fmt.Errorf("checking for message execution during lookback: %w", err)
 		}

-		// check that between cur and parent tipset the nonce fell into range of our message
-		if actorNoExist || (curActor.Nonce > mNonce && act.Nonce <= mNonce) {
-			r, foundMsg, err := sm.tipsetExecutedMessage(cur, m.Cid(), m.VMMessage())
-			if err != nil {
-				return nil, nil, cid.Undef, xerrors.Errorf("checking for message execution during lookback: %w", err)
-			}
-
-			if r != nil {
-				return pts, r, foundMsg, nil
-			}
+		if r != nil {
+			return ts, r, foundMsg, nil
 		}

-		cur = pts
-		curActor = act
+		cur = ts
 	}
 }

@@ -1411,5 +1375,3 @@ func (sm *StateManager) GetMarketState(ctx context.Context, ts *types.TipSet) (m
 	}
 	return actState, nil
 }
-
-var _ StateManagerAPI = (*StateManager)(nil)
@@ -387,7 +387,7 @@ func ComputeState(ctx context.Context, sm *StateManager, height abi.ChainEpoch,
 		NtwkVersion:    sm.GetNtwkVersion,
 		BaseFee:        ts.Blocks()[0].ParentBaseFee,
 	}
-	vmi, err := sm.newVM(ctx, vmopt)
+	vmi, err := vm.NewVM(ctx, vmopt)
 	if err != nil {
 		return cid.Undef, nil, err
 	}
@@ -31,7 +31,7 @@ func TestIndexSeeks(t *testing.T) {
 	ctx := context.TODO()

 	nbs := blockstore.NewTemporarySync()
-	cs := store.NewChainStore(nbs, syncds.MutexWrap(datastore.NewMapDatastore()), nil, nil)
+	cs := store.NewChainStore(nbs, syncds.MutexWrap(datastore.NewMapDatastore()), nil)

 	_, err = cs.Import(bytes.NewReader(gencar))
 	if err != nil {
@@ -124,15 +124,11 @@ type ChainStore struct {
 	vmcalls vm.SyscallBuilder

 	evtTypes [1]journal.EventType
-	journal  journal.Journal
 }

-func NewChainStore(bs bstore.Blockstore, ds dstore.Batching, vmcalls vm.SyscallBuilder, j journal.Journal) *ChainStore {
+func NewChainStore(bs bstore.Blockstore, ds dstore.Batching, vmcalls vm.SyscallBuilder) *ChainStore {
 	c, _ := lru.NewARC(DefaultMsgMetaCacheSize)
 	tsc, _ := lru.NewARC(DefaultTipSetCacheSize)
-	if j == nil {
-		j = journal.NilJournal()
-	}
 	cs := &ChainStore{
 		bs:       bs,
 		ds:       ds,
@@ -141,11 +137,10 @@ func NewChainStore(bs bstore.Blockstore, ds dstore.Batching, vmcalls vm.SyscallB
 		mmCache:  c,
 		tsCache:  tsc,
 		vmcalls:  vmcalls,
-		journal:  j,
 	}

 	cs.evtTypes = [1]journal.EventType{
-		evtTypeHeadChange: j.RegisterEventType("sync", "head_change"),
+		evtTypeHeadChange: journal.J.RegisterEventType("sync", "head_change"),
 	}

 	ci := NewChainIndex(cs.LoadTipSet)
@@ -384,7 +379,7 @@ func (cs *ChainStore) reorgWorker(ctx context.Context, initialNotifees []ReorgNo
 					continue
 				}

-				cs.journal.RecordEvent(cs.evtTypes[evtTypeHeadChange], func() interface{} {
+				journal.J.RecordEvent(cs.evtTypes[evtTypeHeadChange], func() interface{} {
 					return HeadChangeEvt{
 						From:        r.old.Key(),
 						FromHeight:  r.old.Height(),
@@ -62,7 +62,7 @@ func BenchmarkGetRandomness(b *testing.B) {

 	bs := blockstore.NewBlockstore(bds)

-	cs := store.NewChainStore(bs, mds, nil, nil)
+	cs := store.NewChainStore(bs, mds, nil)

 	b.ResetTimer()

@@ -96,7 +96,7 @@ func TestChainExportImport(t *testing.T) {
 	}

 	nbs := blockstore.NewTemporary()
-	cs := store.NewChainStore(nbs, datastore.NewMapDatastore(), nil, nil)
+	cs := store.NewChainStore(nbs, datastore.NewMapDatastore(), nil)

 	root, err := cs.Import(buf)
 	if err != nil {
@@ -120,6 +120,12 @@ func FetchMessagesByCids(
 			return err
 		}

+		// FIXME: We already sort in `fetchCids`, we are duplicating too much work,
+		//  we don't need to pass the index.
+		if out[i] != nil {
+			return fmt.Errorf("received duplicate message")
+		}
+
 		out[i] = msg
 		return nil
 	})
@@ -143,6 +149,10 @@ func FetchSignedMessagesByCids(
 			return err
 		}

+		if out[i] != nil {
+			return fmt.Errorf("received duplicate message")
+		}
+
 		out[i] = smsg
 		return nil
 	})
@@ -162,41 +172,37 @@ func fetchCids(
 	cids []cid.Cid,
 	cb func(int, blocks.Block) error,
 ) error {
-
-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
+	fetchedBlocks := bserv.GetBlocks(ctx, cids)

 	cidIndex := make(map[cid.Cid]int)
 	for i, c := range cids {
 		cidIndex[c] = i
 	}
-	if len(cids) != len(cidIndex) {
-		return fmt.Errorf("duplicate CIDs in fetchCids input")
-	}

-	for block := range bserv.GetBlocks(ctx, cids) {
-		ix, ok := cidIndex[block.Cid()]
-		if !ok {
-			// Ignore duplicate/unexpected blocks. This shouldn't
-			// happen, but we can be safe.
-			log.Errorw("received duplicate/unexpected block when syncing", "cid", block.Cid())
-			continue
+	for i := 0; i < len(cids); i++ {
+		select {
+		case block, ok := <-fetchedBlocks:
+			if !ok {
+				// Closed channel, no more blocks fetched, check if we have all
+				// of the CIDs requested.
+				// FIXME: Review this check. We don't call the callback on the
+				//  last index?
+				if i == len(cids)-1 {
+					break
+				}
+
+				return fmt.Errorf("failed to fetch all messages")
+			}
+
+			ix, ok := cidIndex[block.Cid()]
+			if !ok {
+				return fmt.Errorf("received message we didnt ask for")
+			}
+
+			if err := cb(ix, block); err != nil {
+				return err
+			}
 		}
-
-		// Record that we've received the block.
-		delete(cidIndex, block.Cid())
-
-		if err := cb(ix, block); err != nil {
-			return err
-		}
-	}
-
-	if len(cidIndex) > 0 {
-		err := ctx.Err()
-		if err == nil {
-			err = fmt.Errorf("failed to fetch %d messages for unknown reasons", len(cidIndex))
-		}
-		return err
 	}

 	return nil
@@ -1,63 +0,0 @@
-package sub
-
-import (
-	"context"
-	"testing"
-
-	address "github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/types"
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-)
-
-type getter struct {
-	msgs []*types.Message
-}
-
-func (g *getter) GetBlock(ctx context.Context, c cid.Cid) (blocks.Block, error) { panic("NYI") }
-
-func (g *getter) GetBlocks(ctx context.Context, ks []cid.Cid) <-chan blocks.Block {
-	ch := make(chan blocks.Block, len(g.msgs))
-	for _, m := range g.msgs {
-		by, err := m.Serialize()
-		if err != nil {
-			panic(err)
-		}
-		b, err := blocks.NewBlockWithCid(by, m.Cid())
-		if err != nil {
-			panic(err)
-		}
-		ch <- b
-	}
-	close(ch)
-	return ch
-}
-
-func TestFetchCidsWithDedup(t *testing.T) {
-	msgs := []*types.Message{}
-	for i := 0; i < 10; i++ {
-		msgs = append(msgs, &types.Message{
-			From: address.TestAddress,
-			To:   address.TestAddress,
-
-			Nonce: uint64(i),
-		})
-	}
-	cids := []cid.Cid{}
-	for _, m := range msgs {
-		cids = append(cids, m.Cid())
-	}
-	g := &getter{msgs}
-
-	// the cids have a duplicate
-	res, err := FetchMessagesByCids(context.TODO(), g, append(cids, cids[0]))
-
-	t.Logf("err: %+v", err)
-	t.Logf("res: %+v", res)
-	if err == nil {
-		t.Errorf("there should be an error")
-	}
-	if err == nil && (res[0] == nil || res[len(res)-1] == nil) {
-		t.Fatalf("there is a nil message: first %p, last %p", res[0], res[len(res)-1])
-	}
-}
@@ -217,12 +217,6 @@ func (syncer *Syncer) Stop() {
 // This should be called when connecting to new peers, and additionally
 // when receiving new blocks from the network
 func (syncer *Syncer) InformNewHead(from peer.ID, fts *store.FullTipSet) bool {
-	defer func() {
-		if err := recover(); err != nil {
-			log.Errorf("panic in InformNewHead: ", err)
-		}
-	}()
-
 	ctx := context.Background()
 	if fts == nil {
 		log.Errorf("got nil tipset in InformNewHead")
@@ -737,7 +731,7 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock, use

 	lbst, _, err := syncer.sm.TipSetState(ctx, lbts)
 	if err != nil {
-		return xerrors.Errorf("failed to compute lookback tipset state (epoch %d): %w", lbts.Height(), err)
+		return xerrors.Errorf("failed to compute lookback tipset state: %w", err)
 	}

 	prevBeacon, err := syncer.store.GetLatestBeaconEntry(baseTs)
@@ -1287,11 +1281,9 @@ func (syncer *Syncer) collectHeaders(ctx context.Context, incoming *types.TipSet

 	blockSet := []*types.TipSet{incoming}

-	// Parent of the new (possibly better) tipset that we need to fetch next.
 	at := incoming.Parents()

-	// we want to sync all the blocks until the height above our
-	// best tipset so far
+	// we want to sync all the blocks until the height above the block we have
 	untilHeight := known.Height() + 1

 	ss.SetHeight(blockSet[len(blockSet)-1].Height())
@@ -1385,17 +1377,13 @@ loop:
 	}

 	base := blockSet[len(blockSet)-1]
-	if base.IsChildOf(known) {
-		// common case: receiving blocks that are building on top of our best tipset
+	if base.Parents() == known.Parents() {
+		// common case: receiving a block thats potentially part of the same tipset as our best block
 		return blockSet, nil
 	}

-	knownParent, err := syncer.store.LoadTipSet(known.Parents())
-	if err != nil {
-		return nil, xerrors.Errorf("failed to load next local tipset: %w", err)
-	}
-	if base.IsChildOf(knownParent) {
-		// common case: receiving a block thats potentially part of the same tipset as our best block
+	if types.CidArrsEqual(base.Parents().Cids(), known.Cids()) {
+		// common case: receiving blocks that are building on top of our best tipset
 		return blockSet, nil
 	}

@@ -1526,7 +1514,7 @@ func (syncer *Syncer) iterFullTipsets(ctx context.Context, headers []*types.TipS
 		ss.SetStage(api.StageMessages)

 		if batchErr != nil {
-			return xerrors.Errorf("failed to fetch messages: %w", batchErr)
+			return xerrors.Errorf("failed to fetch messages: %w", err)
 		}

 		for bsi := 0; bsi < len(bstout); bsi++ {
@@ -221,7 +221,8 @@ func (tu *syncTestUtil) addSourceNode(gen int) {
 	sourceRepo, genesis, blocks := tu.repoWithChain(tu.t, gen)
 	var out api.FullNode

-	stop, err := node.New(tu.ctx,
+	// TODO: Don't ignore stop
+	_, err := node.New(tu.ctx,
 		node.FullAPI(&out),
 		node.Online(),
 		node.Repo(sourceRepo),
@@ -231,7 +232,6 @@ func (tu *syncTestUtil) addSourceNode(gen int) {
 		node.Override(new(modules.Genesis), modules.LoadGenesis(genesis)),
 	)
 	require.NoError(tu.t, err)
-	tu.t.Cleanup(func() { _ = stop(context.Background()) })

 	lastTs := blocks[len(blocks)-1].Blocks
 	for _, lastB := range lastTs {
@@ -253,7 +253,8 @@ func (tu *syncTestUtil) addClientNode() int {

 	var out api.FullNode

-	stop, err := node.New(tu.ctx,
+	// TODO: Don't ignore stop
+	_, err := node.New(tu.ctx,
 		node.FullAPI(&out),
 		node.Online(),
 		node.Repo(repo.NewMemory(nil)),
@@ -263,7 +264,6 @@ func (tu *syncTestUtil) addClientNode() int {
 		node.Override(new(modules.Genesis), modules.LoadGenesis(tu.genesis)),
 	)
 	require.NoError(tu.t, err)
-	tu.t.Cleanup(func() { _ = stop(context.Background()) })

 	tu.nds = append(tu.nds, out)
 	return len(tu.nds) - 1
@@ -593,7 +593,7 @@ func TestDuplicateNonce(t *testing.T) {
 			GasPremium: types.NewInt(0),
 		}

-		sig, err := tu.g.Wallet().WalletSign(context.TODO(), tu.g.Banker(), msg.Cid().Bytes(), api.MsgMeta{})
+		sig, err := tu.g.Wallet().Sign(context.TODO(), tu.g.Banker(), msg.Cid().Bytes())
 		require.NoError(t, err)

 		return &types.SignedMessage{
@@ -685,7 +685,7 @@ func TestBadNonce(t *testing.T) {
 			GasPremium: types.NewInt(0),
 		}

-		sig, err := tu.g.Wallet().WalletSign(context.TODO(), tu.g.Banker(), msg.Cid().Bytes(), api.MsgMeta{})
+		sig, err := tu.g.Wallet().Sign(context.TODO(), tu.g.Banker(), msg.Cid().Bytes())
 		require.NoError(t, err)

 		return &types.SignedMessage{
@@ -1648,7 +1648,7 @@ func (t *StateRoot) MarshalCBOR(w io.Writer) error {

 	scratch := make([]byte, 9)

-	// t.Version (types.StateTreeVersion) (uint64)
+	// t.Version (uint64) (uint64)

 	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Version)); err != nil {
 		return err
@@ -1687,7 +1687,7 @@ func (t *StateRoot) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input had wrong number of fields")
 	}

-	// t.Version (types.StateTreeVersion) (uint64)
+	// t.Version (uint64) (uint64)

 	{

@@ -1698,7 +1698,7 @@ func (t *StateRoot) UnmarshalCBOR(r io.Reader) error {
 		if maj != cbg.MajUnsignedInt {
 			return fmt.Errorf("wrong type for uint64 field")
 		}
-		t.Version = StateTreeVersion(extra)
+		t.Version = uint64(extra)

 	}
 	// t.Actors (cid.Cid) (struct)
@@ -1728,22 +1728,22 @@ func (t *StateRoot) UnmarshalCBOR(r io.Reader) error {
 	return nil
 }

-var lengthBufStateInfo0 = []byte{128}
+var lengthBufStateInfo = []byte{128}

-func (t *StateInfo0) MarshalCBOR(w io.Writer) error {
+func (t *StateInfo) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write(lengthBufStateInfo0); err != nil {
+	if _, err := w.Write(lengthBufStateInfo); err != nil {
 		return err
 	}

 	return nil
 }

-func (t *StateInfo0) UnmarshalCBOR(r io.Reader) error {
-	*t = StateInfo0{}
+func (t *StateInfo) UnmarshalCBOR(r io.Reader) error {
+	*t = StateInfo{}

 	br := cbg.GetPeeker(r)
 	scratch := make([]byte, 8)
@@ -12,15 +12,11 @@ import (
 type FIL BigInt

 func (f FIL) String() string {
-	return f.Unitless() + " FIL"
-}
-
-func (f FIL) Unitless() string {
 	r := new(big.Rat).SetFrac(f.Int, big.NewInt(int64(build.FilecoinPrecision)))
 	if r.Sign() == 0 {
-		return "0"
+		return "0 FIL"
 	}
-	return strings.TrimRight(strings.TrimRight(r.FloatString(18), "0"), ".")
+	return strings.TrimRight(strings.TrimRight(r.FloatString(18), "0"), ".") + " FIL"
 }

 func (f FIL) Format(s fmt.State, ch rune) {
@@ -9,7 +9,6 @@ import (
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/ipfs/go-cid"

-	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/wallet"
@@ -23,7 +22,7 @@ func Address(i uint64) address.Address {
 	return a
 }

-func MkMessage(from, to address.Address, nonce uint64, w *wallet.LocalWallet) *types.SignedMessage {
+func MkMessage(from, to address.Address, nonce uint64, w *wallet.Wallet) *types.SignedMessage {
 	msg := &types.Message{
 		To:         to,
 		From:       from,
@@ -34,7 +33,7 @@ func MkMessage(from, to address.Address, nonce uint64, w *wallet.LocalWallet) *t
 		GasPremium: types.NewInt(1),
 	}

-	sig, err := w.WalletSign(context.TODO(), from, msg.Cid().Bytes(), api.MsgMeta{})
+	sig, err := w.Sign(context.TODO(), from, msg.Cid().Bytes())
 	if err != nil {
 		panic(err)
 	}
@@ -60,11 +59,9 @@ func MkBlock(parents *types.TipSet, weightInc uint64, ticketNonce uint64) *types
 	var pcids []cid.Cid
 	var height abi.ChainEpoch
 	weight := types.NewInt(weightInc)
-	var timestamp uint64
 	if parents != nil {
 		pcids = parents.Cids()
 		height = parents.Height() + 1
-		timestamp = parents.MinTimestamp() + build.BlockDelaySecs
 		weight = types.BigAdd(parents.Blocks()[0].ParentWeight, weight)
 	}

@@ -82,7 +79,6 @@ func MkBlock(parents *types.TipSet, weightInc uint64, ticketNonce uint64) *types
 		ParentWeight:          weight,
 		Messages:              c,
 		Height:                height,
-		Timestamp:             timestamp,
 		ParentStateRoot:       pstateRoot,
 		BlockSig:              &crypto.Signature{Type: crypto.SigTypeBLS, Data: []byte("boo! im a signature")},
 		ParentBaseFee:         types.NewInt(uint64(build.MinimumBaseFee)),
@@ -2,20 +2,9 @@ package types

 import "github.com/ipfs/go-cid"

-// StateTreeVersion is the version of the state tree itself, independent of the
-// network version or the actors version.
-type StateTreeVersion uint64
-
-const (
-	// StateTreeVersion0 corresponds to actors < v2.
-	StateTreeVersion0 StateTreeVersion = iota
-	// StateTreeVersion1 corresponds to actors >= v2.
-	StateTreeVersion1
-)
-
 type StateRoot struct {
-	// State tree version.
-	Version StateTreeVersion
+	// State root version. Versioned along with actors (for now).
+	Version uint64
 	// Actors tree. The structure depends on the state root version.
 	Actors cid.Cid
 	// Info. The structure depends on the state root version.
@@ -23,4 +12,4 @@ type StateRoot struct {
 }

 // TODO: version this.
-type StateInfo0 struct{}
+type StateInfo struct{}
@@ -1,7 +1,6 @@
 package main

 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"math/rand"
@@ -62,11 +61,11 @@ func MakeMessageSigningVectors() []vectors.MessageSigningVector {
 		panic(err)
 	}

-	blsk, err := w.WalletNew(context.Background(), crypto.SigTypeBLS)
+	blsk, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
 		panic(err)
 	}
-	bki, err := w.WalletExport(context.Background(), blsk)
+	bki, err := w.Export(blsk)
 	if err != nil {
 		panic(err)
 	}
@@ -86,11 +85,11 @@ func MakeMessageSigningVectors() []vectors.MessageSigningVector {
 		Signature:   &bmsg.Signature,
 	}

-	secpk, err := w.WalletNew(context.Background(), crypto.SigTypeBLS)
+	secpk, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
 		panic(err)
 	}
-	ski, err := w.WalletExport(context.Background(), secpk)
+	ski, err := w.Export(secpk)
 	if err != nil {
 		panic(err)
 	}
@@ -70,12 +70,12 @@ func (ar *ActorRegistry) Invoke(codeCid cid.Cid, rt vmr.Runtime, method abi.Meth
 		log.Errorf("no code for actor %s (Addr: %s)", codeCid, rt.Receiver())
 		return nil, aerrors.Newf(exitcode.SysErrorIllegalActor, "no code for actor %s(%d)(%s)", codeCid, method, hex.EncodeToString(params))
 	}
-	if err := act.predicate(rt, act.vmActor); err != nil {
-		return nil, aerrors.Newf(exitcode.SysErrorIllegalActor, "unsupported actor: %s", err)
-	}
 	if method >= abi.MethodNum(len(act.methods)) || act.methods[method] == nil {
 		return nil, aerrors.Newf(exitcode.SysErrInvalidMethod, "no method %d on actor", method)
 	}
+	if err := act.predicate(rt, act.vmActor); err != nil {
+		return nil, aerrors.Newf(exitcode.SysErrInvalidMethod, "unsupported actor: %s", err)
+	}
 	return act.methods[method](rt, params)

 }
@@ -49,9 +49,6 @@ func (m *Message) ValueReceived() abi.TokenAmount {
 	return m.msg.Value
 }

-// EnableGasTracing, if true, outputs gas tracing in execution traces.
-var EnableGasTracing = false
-
 type Runtime struct {
 	rt0.Message
 	rt0.Syscalls
@@ -480,7 +477,7 @@ func (rt *Runtime) stateCommit(oldh, newh cid.Cid) aerrors.ActorError {
 }

 func (rt *Runtime) finilizeGasTracing() {
-	if EnableGasTracing {
+	if enableTracing {
 		if rt.lastGasCharge != nil {
 			rt.lastGasCharge.TimeTaken = time.Since(rt.lastGasChargeTime)
 		}
@@ -512,9 +509,11 @@ func (rt *Runtime) chargeGasFunc(skip int) func(GasCharge) {

 }

+var enableTracing = false
+
 func (rt *Runtime) chargeGasInternal(gas GasCharge, skip int) aerrors.ActorError {
 	toUse := gas.Total()
-	if EnableGasTracing {
+	if enableTracing {
 		var callers [10]uintptr

 		cout := 0 //gruntime.Callers(2+skip, callers[:])
@@ -45,23 +45,3 @@ func TestRuntimePutErrors(t *testing.T) {
 	rt.StorePut(&NotAVeryGoodMarshaler{})
 	t.Error("expected panic")
 }
-
-func BenchmarkRuntime_CreateRuntimeChargeGas_TracingDisabled(b *testing.B) {
-	var (
-		cst = cbor.NewCborStore(nil)
-		gch = newGasCharge("foo", 1000, 1000)
-	)
-
-	b.ResetTimer()
-
-	EnableGasTracing = false
-	noop := func() bool { return EnableGasTracing }
-	for n := 0; n < b.N; n++ {
-		// flip the value and access it to make sure
-		// the compiler doesn't optimize away
-		EnableGasTracing = true
-		_ = noop()
-		EnableGasTracing = false
-		_ = (&Runtime{cst: cst}).chargeGasInternal(gch, 0)
-	}
-}
@@ -236,7 +236,7 @@ func (vm *VM) send(ctx context.Context, msg *types.Message, parent *Runtime,
 	}

 	rt := vm.makeRuntime(ctx, msg, origin, on, gasUsed, nac)
-	if EnableGasTracing {
+	if enableTracing {
 		rt.lastGasChargeTime = start
 		if parent != nil {
 			rt.lastGasChargeTime = parent.lastGasChargeTime
@@ -1,81 +0,0 @@
-package wallet
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/crypto"
-
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/lib/sigs"
-)
-
-func GenerateKey(typ crypto.SigType) (*Key, error) {
-	pk, err := sigs.Generate(typ)
-	if err != nil {
-		return nil, err
-	}
-	ki := types.KeyInfo{
-		Type:       kstoreSigType(typ),
-		PrivateKey: pk,
-	}
-	return NewKey(ki)
-}
-
-type Key struct {
-	types.KeyInfo
-
-	PublicKey []byte
-	Address   address.Address
-}
-
-func NewKey(keyinfo types.KeyInfo) (*Key, error) {
-	k := &Key{
-		KeyInfo: keyinfo,
-	}
-
-	var err error
-	k.PublicKey, err = sigs.ToPublic(ActSigType(k.Type), k.PrivateKey)
-	if err != nil {
-		return nil, err
-	}
-
-	switch k.Type {
-	case KTSecp256k1:
-		k.Address, err = address.NewSecp256k1Address(k.PublicKey)
-		if err != nil {
-			return nil, xerrors.Errorf("converting Secp256k1 to address: %w", err)
-		}
-	case KTBLS:
-		k.Address, err = address.NewBLSAddress(k.PublicKey)
-		if err != nil {
-			return nil, xerrors.Errorf("converting BLS to address: %w", err)
-		}
-	default:
-		return nil, xerrors.Errorf("unknown key type")
-	}
-	return k, nil
-
-}
-
-func kstoreSigType(typ crypto.SigType) string {
-	switch typ {
-	case crypto.SigTypeBLS:
-		return KTBLS
-	case crypto.SigTypeSecp256k1:
-		return KTSecp256k1
-	default:
-		return ""
-	}
-}
-
-func ActSigType(typ string) crypto.SigType {
-	switch typ {
-	case KTBLS:
-		return crypto.SigTypeBLS
-	case KTSecp256k1:
-		return crypto.SigTypeSecp256k1
-	default:
-		return 0
-	}
-}
@@ -1,42 +0,0 @@
-package remotewallet
-
-import (
-	"context"
-
-	"go.uber.org/fx"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/client"
-	cliutil "github.com/filecoin-project/lotus/cli/util"
-	"github.com/filecoin-project/lotus/node/modules/helpers"
-)
-
-type RemoteWallet struct {
-	api.WalletAPI
-}
-
-func SetupRemoteWallet(info string) func(mctx helpers.MetricsCtx, lc fx.Lifecycle) (*RemoteWallet, error) {
-	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle) (*RemoteWallet, error) {
-		ai := cliutil.ParseApiInfo(info)
-
-		url, err := ai.DialArgs()
-		if err != nil {
-			return nil, err
-		}
-
-		wapi, closer, err := client.NewWalletRPC(mctx, url, ai.AuthHeader())
-		if err != nil {
-			return nil, xerrors.Errorf("creating jsonrpc client: %w", err)
-		}
-
-		lc.Append(fx.Hook{
-			OnStop: func(ctx context.Context) error {
-				closer()
-				return nil
-			},
-		})
-
-		return &RemoteWallet{wapi}, nil
-	}
-}
@@ -12,7 +12,6 @@ import (

 	"github.com/filecoin-project/go-address"

-	"github.com/filecoin-project/lotus/api"
 	_ "github.com/filecoin-project/lotus/lib/sigs/bls"  // enable bls signatures
 	_ "github.com/filecoin-project/lotus/lib/sigs/secp" // enable secp signatures

@@ -30,20 +29,15 @@ const (
 	KTSecp256k1  = "secp256k1"
 )

-type LocalWallet struct {
+type Wallet struct {
 	keys     map[address.Address]*Key
 	keystore types.KeyStore

 	lk sync.Mutex
 }

-type Default interface {
-	GetDefault() (address.Address, error)
-	SetDefault(a address.Address) error
-}
-
-func NewWallet(keystore types.KeyStore) (*LocalWallet, error) {
-	w := &LocalWallet{
+func NewWallet(keystore types.KeyStore) (*Wallet, error) {
+	w := &Wallet{
 		keys:     make(map[address.Address]*Key),
 		keystore: keystore,
 	}
@@ -51,18 +45,18 @@ func NewWallet(keystore types.KeyStore) (*LocalWallet, error) {
 	return w, nil
 }

-func KeyWallet(keys ...*Key) *LocalWallet {
+func KeyWallet(keys ...*Key) *Wallet {
 	m := make(map[address.Address]*Key)
 	for _, key := range keys {
 		m[key.Address] = key
 	}

-	return &LocalWallet{
+	return &Wallet{
 		keys: m,
 	}
 }

-func (w *LocalWallet) WalletSign(ctx context.Context, addr address.Address, msg []byte, meta api.MsgMeta) (*crypto.Signature, error) {
+func (w *Wallet) Sign(ctx context.Context, addr address.Address, msg []byte) (*crypto.Signature, error) {
 	ki, err := w.findKey(addr)
 	if err != nil {
 		return nil, err
@@ -74,7 +68,7 @@ func (w *LocalWallet) WalletSign(ctx context.Context, addr address.Address, msg
 	return sigs.Sign(ActSigType(ki.Type), ki.PrivateKey, msg)
 }

-func (w *LocalWallet) findKey(addr address.Address) (*Key, error) {
+func (w *Wallet) findKey(addr address.Address) (*Key, error) {
 	w.lk.Lock()
 	defer w.lk.Unlock()

@@ -102,7 +96,7 @@ func (w *LocalWallet) findKey(addr address.Address) (*Key, error) {
 	return k, nil
 }

-func (w *LocalWallet) tryFind(addr address.Address) (types.KeyInfo, error) {
+func (w *Wallet) tryFind(addr address.Address) (types.KeyInfo, error) {

 	ki, err := w.keystore.Get(KNamePrefix + addr.String())
 	if err == nil {
@@ -116,12 +110,14 @@ func (w *LocalWallet) tryFind(addr address.Address) (types.KeyInfo, error) {
 	// We got an ErrKeyInfoNotFound error
 	// Try again, this time with the testnet prefix

-	tAddress, err := swapMainnetForTestnetPrefix(addr.String())
-	if err != nil {
-		return types.KeyInfo{}, err
+	aChars := []rune(addr.String())
+	prefixRunes := []rune(address.TestnetPrefix)
+	if len(prefixRunes) != 1 {
+		return types.KeyInfo{}, xerrors.Errorf("unexpected prefix length: %d", len(prefixRunes))
 	}

-	ki, err = w.keystore.Get(KNamePrefix + tAddress)
+	aChars[0] = prefixRunes[0]
+	ki, err = w.keystore.Get(KNamePrefix + string(aChars))
 	if err != nil {
 		return types.KeyInfo{}, err
 	}
@@ -136,7 +132,7 @@ func (w *LocalWallet) tryFind(addr address.Address) (types.KeyInfo, error) {
 	return ki, nil
 }

-func (w *LocalWallet) WalletExport(ctx context.Context, addr address.Address) (*types.KeyInfo, error) {
+func (w *Wallet) Export(addr address.Address) (*types.KeyInfo, error) {
 	k, err := w.findKey(addr)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to find key to export: %w", err)
@@ -145,7 +141,7 @@ func (w *LocalWallet) WalletExport(ctx context.Context, addr address.Address) (*
 	return &k.KeyInfo, nil
 }

-func (w *LocalWallet) WalletImport(ctx context.Context, ki *types.KeyInfo) (address.Address, error) {
+func (w *Wallet) Import(ki *types.KeyInfo) (address.Address, error) {
 	w.lk.Lock()
 	defer w.lk.Unlock()

@@ -161,7 +157,7 @@ func (w *LocalWallet) WalletImport(ctx context.Context, ki *types.KeyInfo) (addr
 	return k.Address, nil
 }

-func (w *LocalWallet) WalletList(ctx context.Context) ([]address.Address, error) {
+func (w *Wallet) ListAddrs() ([]address.Address, error) {
 	all, err := w.keystore.List()
 	if err != nil {
 		return nil, xerrors.Errorf("listing keystore: %w", err)
@@ -194,7 +190,7 @@ func (w *LocalWallet) WalletList(ctx context.Context) ([]address.Address, error)
 	return out, nil
 }

-func (w *LocalWallet) GetDefault() (address.Address, error) {
+func (w *Wallet) GetDefault() (address.Address, error) {
 	w.lk.Lock()
 	defer w.lk.Unlock()

@@ -211,7 +207,7 @@ func (w *LocalWallet) GetDefault() (address.Address, error) {
 	return k.Address, nil
 }

-func (w *LocalWallet) SetDefault(a address.Address) error {
+func (w *Wallet) SetDefault(a address.Address) error {
 	w.lk.Lock()
 	defer w.lk.Unlock()

@@ -233,7 +229,19 @@ func (w *LocalWallet) SetDefault(a address.Address) error {
 	return nil
 }

-func (w *LocalWallet) WalletNew(ctx context.Context, typ crypto.SigType) (address.Address, error) {
+func GenerateKey(typ crypto.SigType) (*Key, error) {
+	pk, err := sigs.Generate(typ)
+	if err != nil {
+		return nil, err
+	}
+	ki := types.KeyInfo{
+		Type:       kstoreSigType(typ),
+		PrivateKey: pk,
+	}
+	return NewKey(ki)
+}
+
+func (w *Wallet) GenerateKey(typ crypto.SigType) (address.Address, error) {
 	w.lk.Lock()
 	defer w.lk.Unlock()

@@ -261,7 +269,7 @@ func (w *LocalWallet) WalletNew(ctx context.Context, typ crypto.SigType) (addres
 	return k.Address, nil
 }

-func (w *LocalWallet) WalletHas(ctx context.Context, addr address.Address) (bool, error) {
+func (w *Wallet) HasKey(addr address.Address) (bool, error) {
 	k, err := w.findKey(addr)
 	if err != nil {
 		return false, err
@@ -269,7 +277,7 @@ func (w *LocalWallet) WalletHas(ctx context.Context, addr address.Address) (bool
 	return k != nil, nil
 }

-func (w *LocalWallet) WalletDelete(ctx context.Context, addr address.Address) error {
+func (w *Wallet) DeleteKey(addr address.Address) error {
 	k, err := w.findKey(addr)
 	if err != nil {
 		return xerrors.Errorf("failed to delete key %s : %w", addr, err)
@@ -283,26 +291,63 @@ func (w *LocalWallet) WalletDelete(ctx context.Context, addr address.Address) er
 		return xerrors.Errorf("failed to delete key %s: %w", addr, err)
 	}

-	tAddr, err := swapMainnetForTestnetPrefix(addr.String())
-	if err != nil {
-		return xerrors.Errorf("failed to swap prefixes: %w", err)
-	}
-
-	// TODO: Does this always error in the not-found case? Just ignoring an error return for now.
-	_ = w.keystore.Delete(KNamePrefix + tAddr)
-
 	return nil
 }

-var _ api.WalletAPI = &LocalWallet{}
+type Key struct {
+	types.KeyInfo

-func swapMainnetForTestnetPrefix(addr string) (string, error) {
-	aChars := []rune(addr)
-	prefixRunes := []rune(address.TestnetPrefix)
-	if len(prefixRunes) != 1 {
-		return "", xerrors.Errorf("unexpected prefix length: %d", len(prefixRunes))
+	PublicKey []byte
+	Address   address.Address
+}
+
+func NewKey(keyinfo types.KeyInfo) (*Key, error) {
+	k := &Key{
+		KeyInfo: keyinfo,
 	}

-	aChars[0] = prefixRunes[0]
-	return string(aChars), nil
+	var err error
+	k.PublicKey, err = sigs.ToPublic(ActSigType(k.Type), k.PrivateKey)
+	if err != nil {
+		return nil, err
+	}
+
+	switch k.Type {
+	case KTSecp256k1:
+		k.Address, err = address.NewSecp256k1Address(k.PublicKey)
+		if err != nil {
+			return nil, xerrors.Errorf("converting Secp256k1 to address: %w", err)
+		}
+	case KTBLS:
+		k.Address, err = address.NewBLSAddress(k.PublicKey)
+		if err != nil {
+			return nil, xerrors.Errorf("converting BLS to address: %w", err)
+		}
+	default:
+		return nil, xerrors.Errorf("unknown key type")
+	}
+	return k, nil
+
+}
+
+func kstoreSigType(typ crypto.SigType) string {
+	switch typ {
+	case crypto.SigTypeBLS:
+		return KTBLS
+	case crypto.SigTypeSecp256k1:
+		return KTSecp256k1
+	default:
+		return ""
+	}
+}
+
+func ActSigType(typ string) crypto.SigType {
+	switch typ {
+	case KTBLS:
+		return crypto.SigTypeBLS
+	case KTSecp256k1:
+		return crypto.SigTypeSecp256k1
+	default:
+		return 0
+	}
 }
@@ -449,16 +449,11 @@ var chainInspectUsage = &cli.Command{
 		bySender := make(map[string]int64)
 		byDest := make(map[string]int64)
 		byMethod := make(map[string]int64)
-		bySenderC := make(map[string]int64)
-		byDestC := make(map[string]int64)
-		byMethodC := make(map[string]int64)

 		var sum int64
 		for _, m := range msgs {
 			bySender[m.Message.From.String()] += m.Message.GasLimit
-			bySenderC[m.Message.From.String()]++
 			byDest[m.Message.To.String()] += m.Message.GasLimit
-			byDestC[m.Message.To.String()]++
 			sum += m.Message.GasLimit

 			code, err := lookupActorCode(m.Message.To)
@@ -469,7 +464,7 @@ var chainInspectUsage = &cli.Command{
 			mm := stmgr.MethodsMap[code][m.Message.Method]

 			byMethod[mm.Name] += m.Message.GasLimit
-			byMethodC[mm.Name]++
+
 		}

 		type keyGasPair struct {
@@ -501,19 +496,19 @@ var chainInspectUsage = &cli.Command{
 		fmt.Printf("By Sender:\n")
 		for i := 0; i < numRes && i < len(senderVals); i++ {
 			sv := senderVals[i]
-			fmt.Printf("%s\t%0.2f%%\t(total: %d, count: %d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas, bySenderC[sv.Key])
+			fmt.Printf("%s\t%0.2f%%\t(%d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas)
 		}
 		fmt.Println()
 		fmt.Printf("By Receiver:\n")
 		for i := 0; i < numRes && i < len(destVals); i++ {
 			sv := destVals[i]
-			fmt.Printf("%s\t%0.2f%%\t(total: %d, count: %d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas, byDestC[sv.Key])
+			fmt.Printf("%s\t%0.2f%%\t(%d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas)
 		}
 		fmt.Println()
 		fmt.Printf("By Method:\n")
 		for i := 0; i < numRes && i < len(methodVals); i++ {
 			sv := methodVals[i]
-			fmt.Printf("%s\t%0.2f%%\t(total: %d, count: %d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas, byMethodC[sv.Key])
+			fmt.Printf("%s\t%0.2f%%\t(%d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas)
 		}

 		return nil
@@ -536,7 +536,7 @@ func interactiveDeal(cctx *cli.Context) error {

 			state = "miner"
 		case "miner":
-			fmt.Print("Miner Address (f0..): ")
+			fmt.Print("Miner Address (t0..): ")
 			var maddrStr string

 			_, err := fmt.Scan(&maddrStr)
@@ -1039,10 +1039,6 @@ var clientListDeals = &cli.Command{
 			Usage: "use color in display output",
 			Value: true,
 		},
-		&cli.BoolFlag{
-			Name:  "show-failed",
-			Usage: "show failed/failing deals",
-		},
 		&cli.BoolFlag{
 			Name:  "watch",
 			Usage: "watch deal updates in real-time, rather than a one time list",
@@ -1059,7 +1055,6 @@ var clientListDeals = &cli.Command{
 		verbose := cctx.Bool("verbose")
 		color := cctx.Bool("color")
 		watch := cctx.Bool("watch")
-		showFailed := cctx.Bool("show-failed")

 		localDeals, err := api.ClientListDeals(ctx)
 		if err != nil {
@@ -1076,7 +1071,7 @@ var clientListDeals = &cli.Command{
 				tm.Clear()
 				tm.MoveCursor(1, 1)

-				err = outputStorageDeals(ctx, tm.Screen, api, localDeals, verbose, color, showFailed)
+				err = outputStorageDeals(ctx, tm.Screen, api, localDeals, verbose, color)
 				if err != nil {
 					return err
 				}
@@ -1102,7 +1097,7 @@ var clientListDeals = &cli.Command{
 			}
 		}

-		return outputStorageDeals(ctx, os.Stdout, api, localDeals, cctx.Bool("verbose"), cctx.Bool("color"), showFailed)
+		return outputStorageDeals(ctx, os.Stdout, api, localDeals, cctx.Bool("verbose"), cctx.Bool("color"))
 	},
 }

@@ -1125,7 +1120,7 @@ func dealFromDealInfo(ctx context.Context, full api.FullNode, head *types.TipSet
 	}
 }

-func outputStorageDeals(ctx context.Context, out io.Writer, full lapi.FullNode, localDeals []lapi.DealInfo, verbose bool, color bool, showFailed bool) error {
+func outputStorageDeals(ctx context.Context, out io.Writer, full api.FullNode, localDeals []api.DealInfo, verbose bool, color bool) error {
 	sort.Slice(localDeals, func(i, j int) bool {
 		return localDeals[i].CreationTime.Before(localDeals[j].CreationTime)
 	})
@@ -1137,14 +1132,12 @@ func outputStorageDeals(ctx context.Context, out io.Writer, full lapi.FullNode,

 	var deals []deal
 	for _, localDeal := range localDeals {
-		if showFailed || localDeal.State != storagemarket.StorageDealError {
-			deals = append(deals, dealFromDealInfo(ctx, full, head, localDeal))
-		}
+		deals = append(deals, dealFromDealInfo(ctx, full, head, localDeal))
 	}

 	if verbose {
 		w := tabwriter.NewWriter(out, 2, 4, 2, ' ', 0)
-		fmt.Fprintf(w, "Created\tDealCid\tDealId\tProvider\tState\tOn Chain?\tSlashed?\tPieceCID\tSize\tPrice\tDuration\tVerified\tMessage\n")
+		fmt.Fprintf(w, "Created\tDealCid\tDealId\tProvider\tState\tOn Chain?\tSlashed?\tPieceCID\tSize\tPrice\tDuration\tMessage\n")
 		for _, d := range deals {
 			onChain := "N"
 			if d.OnChainDealState.SectorStartEpoch != -1 {
@@ -1157,7 +1150,7 @@ func outputStorageDeals(ctx context.Context, out io.Writer, full lapi.FullNode,
 			}

 			price := types.FIL(types.BigMul(d.LocalDeal.PricePerEpoch, types.NewInt(d.LocalDeal.Duration)))
-			fmt.Fprintf(w, "%s\t%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%d\t%v\t%s\n", d.LocalDeal.CreationTime.Format(time.Stamp), d.LocalDeal.ProposalCid, d.LocalDeal.DealID, d.LocalDeal.Provider, dealStateString(color, d.LocalDeal.State), onChain, slashed, d.LocalDeal.PieceCID, types.SizeStr(types.NewInt(d.LocalDeal.Size)), price, d.LocalDeal.Duration, d.LocalDeal.Verified, d.LocalDeal.Message)
+			fmt.Fprintf(w, "%s\t%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%d\t%s\n", d.LocalDeal.CreationTime.Format(time.Stamp), d.LocalDeal.ProposalCid, d.LocalDeal.DealID, d.LocalDeal.Provider, dealStateString(color, d.LocalDeal.State), onChain, slashed, d.LocalDeal.PieceCID, types.SizeStr(types.NewInt(d.LocalDeal.Size)), price, d.LocalDeal.Duration, d.LocalDeal.Message)
 		}
 		return w.Flush()
 	}
@@ -1172,7 +1165,6 @@ func outputStorageDeals(ctx context.Context, out io.Writer, full lapi.FullNode,
 		tablewriter.Col("Size"),
 		tablewriter.Col("Price"),
 		tablewriter.Col("Duration"),
-		tablewriter.Col("Verified"),
 		tablewriter.NewLineCol("Message"))

 	for _, d := range deals {
@@ -1202,7 +1194,6 @@ func outputStorageDeals(ctx context.Context, out io.Writer, full lapi.FullNode,
 			"PieceCID":  piece,
 			"Size":      types.SizeStr(types.NewInt(d.LocalDeal.Size)),
 			"Price":     price,
-			"Verified":  d.LocalDeal.Verified,
 			"Duration":  d.LocalDeal.Duration,
 			"Message":   d.LocalDeal.Message,
 		})
@@ -11,6 +11,8 @@ import (

 	logging "github.com/ipfs/go-log/v2"
 	"github.com/mitchellh/go-homedir"
+	"github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr/net"
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"

@@ -18,7 +20,6 @@ import (

 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/client"
-	cliutil "github.com/filecoin-project/lotus/cli/util"
 	"github.com/filecoin-project/lotus/node/repo"
 )

@@ -45,16 +46,37 @@ func NewCliError(s string) error {
 // ApiConnector returns API instance
 type ApiConnector func() api.FullNode

+type APIInfo struct {
+	Addr  multiaddr.Multiaddr
+	Token []byte
+}
+
+func (a APIInfo) DialArgs() (string, error) {
+	_, addr, err := manet.DialArgs(a.Addr)
+
+	return "ws://" + addr + "/rpc/v0", err
+}
+
+func (a APIInfo) AuthHeader() http.Header {
+	if len(a.Token) != 0 {
+		headers := http.Header{}
+		headers.Add("Authorization", "Bearer "+string(a.Token))
+		return headers
+	}
+	log.Warn("API Token not set and requested, capabilities might be limited.")
+	return nil
+}
+
 // The flag passed on the command line with the listen address of the API
 // server (only used by the tests)
 func flagForAPI(t repo.RepoType) string {
 	switch t {
 	case repo.FullNode:
-		return "api-url"
+		return "api"
 	case repo.StorageMiner:
-		return "miner-api-url"
+		return "miner-api"
 	case repo.Worker:
-		return "worker-api-url"
+		return "worker-api"
 	default:
 		panic(fmt.Sprintf("Unknown repo type: %v", t))
 	}
@@ -100,7 +122,7 @@ func envForRepoDeprecation(t repo.RepoType) string {
 	}
 }

-func GetAPIInfo(ctx *cli.Context, t repo.RepoType) (cliutil.APIInfo, error) {
+func GetAPIInfo(ctx *cli.Context, t repo.RepoType) (APIInfo, error) {
 	// Check if there was a flag passed with the listen address of the API
 	// server (only used by the tests)
 	apiFlag := flagForAPI(t)
@@ -108,7 +130,11 @@ func GetAPIInfo(ctx *cli.Context, t repo.RepoType) (cliutil.APIInfo, error) {
 		strma := ctx.String(apiFlag)
 		strma = strings.TrimSpace(strma)

-		return cliutil.APIInfo{Addr: strma}, nil
+		apima, err := multiaddr.NewMultiaddr(strma)
+		if err != nil {
+			return APIInfo{}, err
+		}
+		return APIInfo{Addr: apima}, nil
 	}

 	envKey := envForRepo(t)
@@ -122,24 +148,36 @@ func GetAPIInfo(ctx *cli.Context, t repo.RepoType) (cliutil.APIInfo, error) {
 		}
 	}
 	if ok {
-		return cliutil.ParseApiInfo(env), nil
+		sp := strings.SplitN(env, ":", 2)
+		if len(sp) != 2 {
+			log.Warnf("invalid env(%s) value, missing token or address", envKey)
+		} else {
+			ma, err := multiaddr.NewMultiaddr(sp[1])
+			if err != nil {
+				return APIInfo{}, xerrors.Errorf("could not parse multiaddr from env(%s): %w", envKey, err)
+			}
+			return APIInfo{
+				Addr:  ma,
+				Token: []byte(sp[0]),
+			}, nil
+		}
 	}

 	repoFlag := flagForRepo(t)

 	p, err := homedir.Expand(ctx.String(repoFlag))
 	if err != nil {
-		return cliutil.APIInfo{}, xerrors.Errorf("could not expand home dir (%s): %w", repoFlag, err)
+		return APIInfo{}, xerrors.Errorf("could not expand home dir (%s): %w", repoFlag, err)
 	}

 	r, err := repo.NewFS(p)
 	if err != nil {
-		return cliutil.APIInfo{}, xerrors.Errorf("could not open repo at path: %s; %w", p, err)
+		return APIInfo{}, xerrors.Errorf("could not open repo at path: %s; %w", p, err)
 	}

 	ma, err := r.APIEndpoint()
 	if err != nil {
-		return cliutil.APIInfo{}, xerrors.Errorf("could not get api endpoint: %w", err)
+		return APIInfo{}, xerrors.Errorf("could not get api endpoint: %w", err)
 	}

 	token, err := r.APIToken()
@@ -147,8 +185,8 @@ func GetAPIInfo(ctx *cli.Context, t repo.RepoType) (cliutil.APIInfo, error) {
 		log.Warnf("Couldn't load CLI token, capabilities may be limited: %v", err)
 	}

-	return cliutil.APIInfo{
-		Addr:  ma.String(),
+	return APIInfo{
+		Addr:  ma,
 		Token: token,
 	}, nil
 }
@@ -228,15 +266,6 @@ func GetWorkerAPI(ctx *cli.Context) (api.WorkerAPI, jsonrpc.ClientCloser, error)
 	return client.NewWorkerRPC(ctx.Context, addr, headers)
 }

-func GetGatewayAPI(ctx *cli.Context) (api.GatewayAPI, jsonrpc.ClientCloser, error) {
-	addr, headers, err := GetRawAPI(ctx, repo.FullNode)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return client.NewGatewayRPC(ctx.Context, addr, headers)
-}
-
 func DaemonContext(cctx *cli.Context) context.Context {
 	if mtCtx, ok := cctx.App.Metadata[metadataTraceContext]; ok {
 		return mtCtx.(context.Context)
@@ -121,13 +121,13 @@ func TestPaymentChannelStatus(t *testing.T) {
 	create := make(chan string)
 	go func() {
 		// creator: paych add-funds <creator> <receiver> <amount>
-		cmd := []string{creatorAddr.String(), receiverAddr.String(), fmt.Sprintf("%d", channelAmt)}
+		cmd = []string{creatorAddr.String(), receiverAddr.String(), fmt.Sprintf("%d", channelAmt)}
 		create <- creatorCLI.runCmd(paychAddFundsCmd, cmd)
 	}()

 	// Wait for the output to stop being "Channel does not exist"
 	for regexp.MustCompile(noChannelState).MatchString(out) {
-		cmd := []string{creatorAddr.String(), receiverAddr.String()}
+		cmd = []string{creatorAddr.String(), receiverAddr.String()}
 		out = creatorCLI.runCmd(paychStatusByFromToCmd, cmd)
 	}
 	fmt.Println(out)
@@ -390,7 +390,7 @@ func checkVoucherOutput(t *testing.T, list string, vouchers []voucherSpec) {
 }

 func startTwoNodesOneMiner(ctx context.Context, t *testing.T, blocktime time.Duration) ([]test.TestNode, []address.Address) {
-	n, sn := builder.RPCMockSbBuilder(t, test.TwoFull, test.OneMiner)
+	n, sn := builder.RPCMockSbBuilder(t, 2, test.OneMiner)

 	paymentCreator := n[0]
 	paymentReceiver := n[1]
@@ -439,12 +439,12 @@ type mockCLI struct {
 }

 func newMockCLI(t *testing.T) *mockCLI {
-	// Create a CLI App with an --api-url flag so that we can specify which node
+	// Create a CLI App with an --api flag so that we can specify which node
 	// the command should be executed against
 	app := cli.NewApp()
 	app.Flags = []cli.Flag{
 		&cli.StringFlag{
-			Name:   "api-url",
+			Name:   "api",
 			Hidden: true,
 		},
 	}
@@ -476,8 +476,8 @@ func (c *mockCLIClient) runCmd(cmd *cli.Command, input []string) string {
 }

 func (c *mockCLIClient) runCmdRaw(cmd *cli.Command, input []string) (string, error) {
-	// prepend --api-url=<node api listener address>
-	apiFlag := "--api-url=" + c.addr.String()
+	// prepend --api=<node api listener address>
+	apiFlag := "--api=" + c.addr.String()
 	input = append([]string{apiFlag}, input...)

 	fs := c.flagSet(cmd)
@@ -493,7 +493,7 @@ func (c *mockCLIClient) runCmdRaw(cmd *cli.Command, input []string) (string, err
 }

 func (c *mockCLIClient) flagSet(cmd *cli.Command) *flag.FlagSet {
-	// Apply app level flags (so we can process --api-url flag)
+	// Apply app level flags (so we can process --api flag)
 	fs := &flag.FlagSet{}
 	for _, f := range c.cctx.App.Flags {
 		err := f.Apply(fs)
@@ -9,6 +9,7 @@ import (
 	"golang.org/x/xerrors"

 	"github.com/filecoin-project/lotus/node/repo"
+	manet "github.com/multiformats/go-multiaddr/net"
 )

 var pprofCmd = &cli.Command{
@@ -36,7 +37,7 @@ var PprofGoroutines = &cli.Command{
 		if err != nil {
 			return xerrors.Errorf("could not get API info: %w", err)
 		}
-		addr, err := ainfo.Host()
+		_, addr, err := manet.DialArgs(ainfo.Addr)
 		if err != nil {
 			return err
 		}
@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"html/template"
 	"io"
-	"io/ioutil"
 	"os"
 	"reflect"
 	"sort"
@@ -33,7 +32,6 @@ import (
 	"github.com/filecoin-project/go-state-types/exitcode"

 	"github.com/filecoin-project/lotus/api"
-	lapi "github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/apibstore"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/state"
@@ -72,7 +70,6 @@ var stateCmd = &cli.Command{
 		stateMsgCostCmd,
 		stateMinerInfo,
 		stateMarketCmd,
-		stateExecTraceCmd,
 	},
 }

@@ -316,74 +313,6 @@ var stateActiveSectorsCmd = &cli.Command{
 	},
 }

-var stateExecTraceCmd = &cli.Command{
-	Name:      "exec-trace",
-	Usage:     "Get the execution trace of a given message",
-	ArgsUsage: "<messageCid>",
-	Action: func(cctx *cli.Context) error {
-		if !cctx.Args().Present() {
-			return ShowHelp(cctx, fmt.Errorf("must pass message cid"))
-		}
-
-		mcid, err := cid.Decode(cctx.Args().First())
-		if err != nil {
-			return fmt.Errorf("message cid was invalid: %s", err)
-		}
-
-		capi, closer, err := GetFullNodeAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-
-		ctx := ReqContext(cctx)
-
-		msg, err := capi.ChainGetMessage(ctx, mcid)
-		if err != nil {
-			return err
-		}
-
-		lookup, err := capi.StateSearchMsg(ctx, mcid)
-		if err != nil {
-			return err
-		}
-
-		ts, err := capi.ChainGetTipSet(ctx, lookup.TipSet)
-		if err != nil {
-			return err
-		}
-
-		pts, err := capi.ChainGetTipSet(ctx, ts.Parents())
-		if err != nil {
-			return err
-		}
-
-		cso, err := capi.StateCompute(ctx, pts.Height(), nil, pts.Key())
-		if err != nil {
-			return err
-		}
-
-		var trace *api.InvocResult
-		for _, t := range cso.Trace {
-			if t.Msg.From == msg.From && t.Msg.Nonce == msg.Nonce {
-				trace = t
-				break
-			}
-		}
-		if trace == nil {
-			return fmt.Errorf("failed to find message in tipset trace output")
-		}
-
-		out, err := json.MarshalIndent(trace, "", "  ")
-		if err != nil {
-			return err
-		}
-
-		fmt.Println(string(out))
-		return nil
-	},
-}
-
 var stateReplaySetCmd = &cli.Command{
 	Name:      "replay",
 	Usage:     "Replay a particular message within a tipset",
@@ -894,10 +823,6 @@ var stateComputeStateCmd = &cli.Command{
 			Name:  "json",
 			Usage: "generate json output",
 		},
-		&cli.StringFlag{
-			Name:  "compute-state-output",
-			Usage: "a json file containing pre-existing compute-state output, to generate html reports without rerunning state changes",
-		},
 	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
@@ -937,26 +862,9 @@ var stateComputeStateCmd = &cli.Command{
 			}
 		}

-		var stout *lapi.ComputeStateOutput
-		if csofile := cctx.String("compute-state-output"); csofile != "" {
-			data, err := ioutil.ReadFile(csofile)
-			if err != nil {
-				return err
-			}
-
-			var o lapi.ComputeStateOutput
-			if err := json.Unmarshal(data, &o); err != nil {
-				return err
-			}
-
-			stout = &o
-		} else {
-			o, err := api.StateCompute(ctx, h, msgs, ts.Key())
-			if err != nil {
-				return err
-			}
-
-			stout = o
+		stout, err := api.StateCompute(ctx, h, msgs, ts.Key())
+		if err != nil {
+			return err
 		}

 		if cctx.Bool("json") {
@@ -233,13 +233,7 @@ func SyncWait(ctx context.Context, napi api.FullNode) error {

 	samples := 8
 	i := 0
-	var firstApp, app, lastApp uint64
-
-	state, err := napi.SyncState(ctx)
-	if err != nil {
-		return err
-	}
-	firstApp = state.VMApplied
+	var app, lastApp uint64

 	for {
 		state, err := napi.SyncState(ctx)
@@ -292,10 +286,10 @@ func SyncWait(ctx context.Context, napi api.FullNode) error {

 		if i%samples == 0 {
 			lastApp = app
-			app = state.VMApplied - firstApp
+			app = state.VMApplied
 		}
 		if i > 0 {
-			fmt.Printf("Validated %d messages (%d per second)\n", state.VMApplied-firstApp, (app-lastApp)*uint64(time.Second/tick)/uint64(samples))
+			fmt.Printf("Validated %d messages (%d per second)\n", state.VMApplied, (app-lastApp)*uint64(time.Second/tick)/uint64(samples))
 			lastLines++
 		}

@@ -1,83 +0,0 @@
-package cliutil
-
-import (
-	"net/http"
-	"net/url"
-	"regexp"
-	"strings"
-
-	logging "github.com/ipfs/go-log/v2"
-	"github.com/multiformats/go-multiaddr"
-	manet "github.com/multiformats/go-multiaddr/net"
-)
-
-var log = logging.Logger("cliutil")
-
-var (
-	infoWithToken = regexp.MustCompile("^[a-zA-Z0-9\\-_]+?\\.[a-zA-Z0-9\\-_]+?\\.([a-zA-Z0-9\\-_]+)?:.+$")
-)
-
-type APIInfo struct {
-	Addr  string
-	Token []byte
-}
-
-func ParseApiInfo(s string) APIInfo {
-	var tok []byte
-	if infoWithToken.Match([]byte(s)) {
-		sp := strings.SplitN(s, ":", 2)
-		tok = []byte(sp[0])
-		s = sp[1]
-	}
-
-	return APIInfo{
-		Addr:  s,
-		Token: tok,
-	}
-}
-
-func (a APIInfo) DialArgs() (string, error) {
-	ma, err := multiaddr.NewMultiaddr(a.Addr)
-	if err == nil {
-		_, addr, err := manet.DialArgs(ma)
-		if err != nil {
-			return "", err
-		}
-
-		return "ws://" + addr + "/rpc/v0", nil
-	}
-
-	_, err = url.Parse(a.Addr)
-	if err != nil {
-		return "", err
-	}
-	return a.Addr + "/rpc/v0", nil
-}
-
-func (a APIInfo) Host() (string, error) {
-	ma, err := multiaddr.NewMultiaddr(a.Addr)
-	if err == nil {
-		_, addr, err := manet.DialArgs(ma)
-		if err != nil {
-			return "", err
-		}
-
-		return addr, nil
-	}
-
-	spec, err := url.Parse(a.Addr)
-	if err != nil {
-		return "", err
-	}
-	return spec.Host, nil
-}
-
-func (a APIInfo) AuthHeader() http.Header {
-	if len(a.Token) != 0 {
-		headers := http.Header{}
-		headers.Add("Authorization", "Bearer "+string(a.Token))
-		return headers
-	}
-	log.Warn("API Token not set and requested, capabilities might be limited.")
-	return nil
-}
@@ -183,7 +183,7 @@ var importBenchCmd = &cli.Command{
 			return nil
 		}

-		cs := store.NewChainStore(bs, ds, vm.Syscalls(verifier), nil)
+		cs := store.NewChainStore(bs, ds, vm.Syscalls(verifier))
 		stm := stmgr.NewStateManager(cs)

 		if cctx.Bool("global-profile") {
@@ -6,174 +6,85 @@ import (
 	"time"

 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/node/impl/full"
 	"github.com/ipfs/go-cid"
+
+	"go.opencensus.io/trace"
 )

-const (
-	LookbackCap            = time.Hour
-	stateWaitLookbackLimit = abi.ChainEpoch(20)
-)
+const LookbackCap = time.Hour

 var (
 	ErrLookbackTooLong = fmt.Errorf("lookbacks of more than %s are disallowed", LookbackCap)
 )

-// gatewayDepsAPI defines the API methods that the GatewayAPI depends on
-// (to make it easy to mock for tests)
-type gatewayDepsAPI interface {
-	ChainHead(ctx context.Context) (*types.TipSet, error)
-	ChainGetTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error)
-	ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error)
-	GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, tsk types.TipSetKey) (*types.Message, error)
-	MpoolPushUntrusted(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error)
-	MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error)
-	MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error)
-	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
-	StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-	StateWaitMsgLimited(ctx context.Context, msg cid.Cid, confidence uint64, h abi.ChainEpoch) (*api.MsgLookup, error)
-}
-
 type GatewayAPI struct {
-	api gatewayDepsAPI
+	api api.FullNode
 }

-func (a *GatewayAPI) checkTipsetKey(ctx context.Context, tsk types.TipSetKey) error {
+func (a *GatewayAPI) getTipsetTimestamp(ctx context.Context, tsk types.TipSetKey) (time.Time, error) {
 	if tsk.IsEmpty() {
-		return nil
+		return time.Now(), nil
 	}

 	ts, err := a.api.ChainGetTipSet(ctx, tsk)
+	if err != nil {
+		return time.Time{}, err
+	}
+
+	return time.Unix(int64(ts.Blocks()[0].Timestamp), 0), nil
+}
+
+func (a *GatewayAPI) checkTipset(ctx context.Context, ts types.TipSetKey) error {
+	when, err := a.getTipsetTimestamp(ctx, ts)
 	if err != nil {
 		return err
 	}

-	return a.checkTipset(ts)
-}
-
-func (a *GatewayAPI) checkTipset(ts *types.TipSet) error {
-	at := time.Unix(int64(ts.Blocks()[0].Timestamp), 0)
-	if err := a.checkTimestamp(at); err != nil {
-		return fmt.Errorf("bad tipset: %w", err)
-	}
-	return nil
-}
-
-func (a *GatewayAPI) checkTipsetHeight(ts *types.TipSet, h abi.ChainEpoch) error {
-	tsBlock := ts.Blocks()[0]
-	heightDelta := time.Duration(uint64(tsBlock.Height-h)*build.BlockDelaySecs) * time.Second
-	timeAtHeight := time.Unix(int64(tsBlock.Timestamp), 0).Add(-heightDelta)
-
-	if err := a.checkTimestamp(timeAtHeight); err != nil {
-		return fmt.Errorf("bad tipset height: %w", err)
-	}
-	return nil
-}
-
-func (a *GatewayAPI) checkTimestamp(at time.Time) error {
-	if time.Since(at) > LookbackCap {
+	if time.Since(when) > time.Hour {
 		return ErrLookbackTooLong
 	}

 	return nil
 }

+func (a *GatewayAPI) StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error) {
+	ctx, span := trace.StartSpan(ctx, "StateGetActor")
+	defer span.End()
+
+	if err := a.checkTipset(ctx, ts); err != nil {
+		return nil, fmt.Errorf("bad tipset: %w", err)
+	}
+
+	return a.api.StateGetActor(ctx, actor, ts)
+}
+
 func (a *GatewayAPI) ChainHead(ctx context.Context) (*types.TipSet, error) {
+	ctx, span := trace.StartSpan(ctx, "ChainHead")
+	defer span.End()
 	// TODO: cache and invalidate cache when timestamp is up (or have internal ChainNotify)

 	return a.api.ChainHead(ctx)
 }

 func (a *GatewayAPI) ChainGetTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error) {
+	ctx, span := trace.StartSpan(ctx, "ChainGetTipSet")
+	defer span.End()
+
+	if err := a.checkTipset(ctx, tsk); err != nil {
+		return nil, fmt.Errorf("bad tipset: %w", err)
+	}
+
+	// TODO: since we're limiting lookbacks, should just cache this (could really even cache the json response bytes)
 	return a.api.ChainGetTipSet(ctx, tsk)
 }

-func (a *GatewayAPI) ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error) {
-	ts, err := a.api.ChainGetTipSet(ctx, tsk)
-	if err != nil {
-		return nil, err
-	}
-
-	// Check if the tipset key refers to a tipset that's too far in the past
-	if err := a.checkTipset(ts); err != nil {
-		return nil, err
-	}
-
-	// Check if the height is too far in the past
-	if err := a.checkTipsetHeight(ts, h); err != nil {
-		return nil, err
-	}
-
-	return a.api.ChainGetTipSetByHeight(ctx, h, tsk)
-}
-
-func (a *GatewayAPI) GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, tsk types.TipSetKey) (*types.Message, error) {
-	if err := a.checkTipsetKey(ctx, tsk); err != nil {
-		return nil, err
-	}
-
-	return a.api.GasEstimateMessageGas(ctx, msg, spec, tsk)
-}
-
 func (a *GatewayAPI) MpoolPush(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error) {
+	ctx, span := trace.StartSpan(ctx, "MpoolPush")
+	defer span.End()
+
 	// TODO: additional anti-spam checks
+
 	return a.api.MpoolPushUntrusted(ctx, sm)
 }
-
-func (a *GatewayAPI) MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error) {
-	if err := a.checkTipsetKey(ctx, tsk); err != nil {
-		return types.NewInt(0), err
-	}
-
-	return a.api.MsigGetAvailableBalance(ctx, addr, tsk)
-}
-
-func (a *GatewayAPI) MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error) {
-	if err := a.checkTipsetKey(ctx, start); err != nil {
-		return types.NewInt(0), err
-	}
-	if err := a.checkTipsetKey(ctx, end); err != nil {
-		return types.NewInt(0), err
-	}
-
-	return a.api.MsigGetVested(ctx, addr, start, end)
-}
-
-func (a *GatewayAPI) StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
-	if err := a.checkTipsetKey(ctx, tsk); err != nil {
-		return address.Undef, err
-	}
-
-	return a.api.StateAccountKey(ctx, addr, tsk)
-}
-
-func (a *GatewayAPI) StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) {
-	if err := a.checkTipsetKey(ctx, tsk); err != nil {
-		return nil, err
-	}
-
-	return a.api.StateGetActor(ctx, actor, tsk)
-}
-
-func (a *GatewayAPI) StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
-	if err := a.checkTipsetKey(ctx, tsk); err != nil {
-		return address.Undef, err
-	}
-
-	return a.api.StateLookupID(ctx, addr, tsk)
-}
-
-func (a *GatewayAPI) StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*api.MsgLookup, error) {
-	return a.api.StateWaitMsgLimited(ctx, msg, confidence, stateWaitLookbackLimit)
-}
-
-var _ api.GatewayAPI = (*GatewayAPI)(nil)
-var _ full.ChainModuleAPI = (*GatewayAPI)(nil)
-var _ full.GasModuleAPI = (*GatewayAPI)(nil)
-var _ full.MpoolModuleAPI = (*GatewayAPI)(nil)
-var _ full.StateModuleAPI = (*GatewayAPI)(nil)
@@ -1,191 +0,0 @@
-package main
-
-import (
-	"context"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/filecoin-project/lotus/build"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/filecoin-project/lotus/chain/types/mock"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/ipfs/go-cid"
-)
-
-func TestGatewayAPIChainGetTipSetByHeight(t *testing.T) {
-	ctx := context.Background()
-
-	lookbackTimestamp := uint64(time.Now().Unix()) - uint64(LookbackCap.Seconds())
-	type args struct {
-		h         abi.ChainEpoch
-		tskh      abi.ChainEpoch
-		genesisTS uint64
-	}
-	tests := []struct {
-		name   string
-		args   args
-		expErr bool
-	}{{
-		name: "basic",
-		args: args{
-			h:    abi.ChainEpoch(1),
-			tskh: abi.ChainEpoch(5),
-		},
-	}, {
-		name: "genesis",
-		args: args{
-			h:    abi.ChainEpoch(0),
-			tskh: abi.ChainEpoch(5),
-		},
-	}, {
-		name: "same epoch as tipset",
-		args: args{
-			h:    abi.ChainEpoch(5),
-			tskh: abi.ChainEpoch(5),
-		},
-	}, {
-		name: "tipset too old",
-		args: args{
-			// Tipset height is 5, genesis is at LookbackCap - 10 epochs.
-			// So resulting tipset height will be 5 epochs earlier than LookbackCap.
-			h:         abi.ChainEpoch(1),
-			tskh:      abi.ChainEpoch(5),
-			genesisTS: lookbackTimestamp - build.BlockDelaySecs*10,
-		},
-		expErr: true,
-	}, {
-		name: "lookup height too old",
-		args: args{
-			// Tipset height is 5, lookup height is 1, genesis is at LookbackCap - 3 epochs.
-			// So
-			// - lookup height will be 2 epochs earlier than LookbackCap.
-			// - tipset height will be 2 epochs later than LookbackCap.
-			h:         abi.ChainEpoch(1),
-			tskh:      abi.ChainEpoch(5),
-			genesisTS: lookbackTimestamp - build.BlockDelaySecs*3,
-		},
-		expErr: true,
-	}, {
-		name: "tipset and lookup height within acceptable range",
-		args: args{
-			// Tipset height is 5, lookup height is 1, genesis is at LookbackCap.
-			// So
-			// - lookup height will be 1 epoch later than LookbackCap.
-			// - tipset height will be 5 epochs later than LookbackCap.
-			h:         abi.ChainEpoch(1),
-			tskh:      abi.ChainEpoch(5),
-			genesisTS: lookbackTimestamp,
-		},
-	}}
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			mock := &mockGatewayDepsAPI{}
-			a := &GatewayAPI{api: mock}
-
-			// Create tipsets from genesis up to tskh and return the highest
-			ts := mock.createTipSets(tt.args.tskh, tt.args.genesisTS)
-
-			got, err := a.ChainGetTipSetByHeight(ctx, tt.args.h, ts.Key())
-			if tt.expErr {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-				require.Equal(t, tt.args.h, got.Height())
-			}
-		})
-	}
-}
-
-type mockGatewayDepsAPI struct {
-	lk      sync.RWMutex
-	tipsets []*types.TipSet
-}
-
-func (m *mockGatewayDepsAPI) ChainHead(ctx context.Context) (*types.TipSet, error) {
-	m.lk.RLock()
-	defer m.lk.RUnlock()
-
-	return m.tipsets[len(m.tipsets)-1], nil
-}
-
-func (m *mockGatewayDepsAPI) ChainGetTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error) {
-	m.lk.RLock()
-	defer m.lk.RUnlock()
-
-	for _, ts := range m.tipsets {
-		if ts.Key() == tsk {
-			return ts, nil
-		}
-	}
-
-	return nil, nil
-}
-
-// createTipSets creates tipsets from genesis up to tskh and returns the highest
-func (m *mockGatewayDepsAPI) createTipSets(h abi.ChainEpoch, genesisTimestamp uint64) *types.TipSet {
-	m.lk.Lock()
-	defer m.lk.Unlock()
-
-	targeth := h + 1 // add one for genesis block
-	if genesisTimestamp == 0 {
-		genesisTimestamp = uint64(time.Now().Unix()) - build.BlockDelaySecs*uint64(targeth)
-	}
-	var currts *types.TipSet
-	for currh := abi.ChainEpoch(0); currh < targeth; currh++ {
-		blks := mock.MkBlock(currts, 1, 1)
-		if currh == 0 {
-			blks.Timestamp = genesisTimestamp
-		}
-		currts = mock.TipSet(blks)
-		m.tipsets = append(m.tipsets, currts)
-	}
-
-	return m.tipsets[len(m.tipsets)-1]
-}
-
-func (m *mockGatewayDepsAPI) ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error) {
-	m.lk.Lock()
-	defer m.lk.Unlock()
-
-	return m.tipsets[h], nil
-}
-
-func (m *mockGatewayDepsAPI) GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, tsk types.TipSetKey) (*types.Message, error) {
-	panic("implement me")
-}
-
-func (m *mockGatewayDepsAPI) MpoolPushUntrusted(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error) {
-	panic("implement me")
-}
-
-func (m *mockGatewayDepsAPI) MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error) {
-	panic("implement me")
-}
-
-func (m *mockGatewayDepsAPI) MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error) {
-	panic("implement me")
-}
-
-func (m *mockGatewayDepsAPI) StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
-	panic("implement me")
-}
-
-func (m *mockGatewayDepsAPI) StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error) {
-	panic("implement me")
-}
-
-func (m *mockGatewayDepsAPI) StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
-	panic("implement me")
-}
-
-func (m *mockGatewayDepsAPI) StateWaitMsgLimited(ctx context.Context, msg cid.Cid, confidence uint64, h abi.ChainEpoch) (*api.MsgLookup, error) {
-	panic("implement me")
-}
@@ -1,211 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"os"
-	"testing"
-	"time"
-
-	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	"github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-
-	"github.com/stretchr/testify/require"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-jsonrpc"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/client"
-	"github.com/filecoin-project/lotus/api/test"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/wallet"
-	"github.com/filecoin-project/lotus/node"
-	builder "github.com/filecoin-project/lotus/node/test"
-)
-
-func init() {
-	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
-	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
-}
-
-// TestEndToEnd tests that API calls can be made on a lite node that is
-// connected through a gateway to a full API node
-func TestEndToEnd(t *testing.T) {
-	_ = os.Setenv("BELLMAN_NO_GPU", "1")
-
-	blocktime := 5 * time.Millisecond
-	ctx := context.Background()
-	full, lite, closer := startNodes(ctx, t, blocktime)
-	defer closer()
-
-	// The full node starts with a wallet
-	fullWalletAddr, err := full.WalletDefaultAddress(ctx)
-	require.NoError(t, err)
-
-	// Check the full node's wallet balance from the lite node
-	balance, err := lite.WalletBalance(ctx, fullWalletAddr)
-	require.NoError(t, err)
-	fmt.Println(balance)
-
-	// Create a wallet on the lite node
-	liteWalletAddr, err := lite.WalletNew(ctx, wallet.ActSigType("secp256k1"))
-	require.NoError(t, err)
-
-	// Send some funds from the full node to the lite node
-	err = sendFunds(ctx, t, full, fullWalletAddr, liteWalletAddr, types.NewInt(1e18))
-	require.NoError(t, err)
-
-	// Send some funds from the lite node back to the full node
-	err = sendFunds(ctx, t, lite, liteWalletAddr, fullWalletAddr, types.NewInt(100))
-	require.NoError(t, err)
-
-	// Sign some data with the lite node wallet address
-	data := []byte("hello")
-	sig, err := lite.WalletSign(ctx, liteWalletAddr, data)
-	require.NoError(t, err)
-
-	// Verify the signature
-	ok, err := lite.WalletVerify(ctx, liteWalletAddr, data, sig)
-	require.NoError(t, err)
-	require.True(t, ok)
-
-	// Create some wallets on the lite node to use for testing multisig
-	var walletAddrs []address.Address
-	for i := 0; i < 4; i++ {
-		addr, err := lite.WalletNew(ctx, wallet.ActSigType("secp256k1"))
-		require.NoError(t, err)
-
-		walletAddrs = append(walletAddrs, addr)
-
-		err = sendFunds(ctx, t, lite, liteWalletAddr, addr, types.NewInt(1e15))
-		require.NoError(t, err)
-	}
-
-	// Create an msig with three of the addresses and threshold of two sigs
-	msigAddrs := walletAddrs[:3]
-	amt := types.NewInt(1000)
-	addProposal, err := lite.MsigCreate(ctx, 2, msigAddrs, abi.ChainEpoch(50), amt, liteWalletAddr, types.NewInt(0))
-	require.NoError(t, err)
-
-	res, err := lite.StateWaitMsg(ctx, addProposal, 1)
-	require.NoError(t, err)
-	require.EqualValues(t, 0, res.Receipt.ExitCode)
-
-	var execReturn init0.ExecReturn
-	err = execReturn.UnmarshalCBOR(bytes.NewReader(res.Receipt.Return))
-	require.NoError(t, err)
-
-	// Get available balance of msig: should be greater than zero and less
-	// than initial amount
-	msig := execReturn.IDAddress
-	msigBalance, err := lite.MsigGetAvailableBalance(ctx, msig, types.EmptyTSK)
-	require.NoError(t, err)
-	require.Greater(t, msigBalance.Int64(), int64(0))
-	require.Less(t, msigBalance.Int64(), amt.Int64())
-
-	// Propose to add a new address to the msig
-	addProposal, err = lite.MsigAddPropose(ctx, msig, walletAddrs[0], walletAddrs[3], false)
-	require.NoError(t, err)
-
-	res, err = lite.StateWaitMsg(ctx, addProposal, 1)
-	require.NoError(t, err)
-	require.EqualValues(t, 0, res.Receipt.ExitCode)
-
-	var proposeReturn multisig.ProposeReturn
-	err = proposeReturn.UnmarshalCBOR(bytes.NewReader(res.Receipt.Return))
-	require.NoError(t, err)
-
-	// Approve proposal (proposer is first (implicit) signer, approver is
-	// second signer
-	txnID := uint64(proposeReturn.TxnID)
-	approval1, err := lite.MsigAddApprove(ctx, msig, walletAddrs[1], txnID, walletAddrs[0], walletAddrs[3], false)
-	require.NoError(t, err)
-
-	res, err = lite.StateWaitMsg(ctx, approval1, 1)
-	require.NoError(t, err)
-	require.EqualValues(t, 0, res.Receipt.ExitCode)
-
-	var approveReturn multisig.ApproveReturn
-	err = approveReturn.UnmarshalCBOR(bytes.NewReader(res.Receipt.Return))
-	require.NoError(t, err)
-	require.True(t, approveReturn.Applied)
-}
-
-func sendFunds(ctx context.Context, t *testing.T, fromNode test.TestNode, fromAddr address.Address, toAddr address.Address, amt types.BigInt) error {
-	msg := &types.Message{
-		From:  fromAddr,
-		To:    toAddr,
-		Value: amt,
-	}
-
-	sm, err := fromNode.MpoolPushMessage(ctx, msg, nil)
-	if err != nil {
-		return err
-	}
-
-	res, err := fromNode.StateWaitMsg(ctx, sm.Cid(), 1)
-	if err != nil {
-		return err
-	}
-	if res.Receipt.ExitCode != 0 {
-		return xerrors.Errorf("send funds failed with exit code %d", res.Receipt.ExitCode)
-	}
-
-	return nil
-}
-
-func startNodes(ctx context.Context, t *testing.T, blocktime time.Duration) (test.TestNode, test.TestNode, jsonrpc.ClientCloser) {
-	var closer jsonrpc.ClientCloser
-
-	// Create one miner and two full nodes.
-	// - Put a gateway server in front of full node 1
-	// - Start full node 2 in lite mode
-	// - Connect lite node -> gateway server -> full node
-	opts := append(
-		// Full node
-		test.OneFull,
-		// Lite node
-		test.FullNodeOpts{
-			Lite: true,
-			Opts: func(nodes []test.TestNode) node.Option {
-				fullNode := nodes[0]
-
-				// Create a gateway server in front of the full node
-				_, addr, err := builder.CreateRPCServer(&GatewayAPI{api: fullNode})
-				require.NoError(t, err)
-
-				// Create a gateway client API that connects to the gateway server
-				var gapi api.GatewayAPI
-				gapi, closer, err = client.NewGatewayRPC(ctx, addr, nil)
-				require.NoError(t, err)
-
-				// Provide the gateway API to dependency injection
-				return node.Override(new(api.GatewayAPI), gapi)
-			},
-		},
-	)
-	n, sn := builder.RPCMockSbBuilder(t, opts, test.OneMiner)
-
-	full := n[0]
-	lite := n[1]
-	miner := sn[0]
-
-	// Get the listener address for the full node
-	fullAddr, err := full.NetAddrsListen(ctx)
-	require.NoError(t, err)
-
-	// Connect the miner and the full node
-	err = miner.NetConnect(ctx, fullAddr)
-	require.NoError(t, err)
-
-	// Start mining blocks
-	bm := test.NewBlockMiner(ctx, t, miner, blocktime)
-	bm.MineBlocks()
-
-	return full, lite, closer
-}
@@ -40,12 +40,12 @@ func main() {
 			return fmt.Errorf("unrecognized key type: %q", cctx.String("type"))
 		}

-		kaddr, err := w.WalletNew(cctx.Context, kt)
+		kaddr, err := w.GenerateKey(kt)
 		if err != nil {
 			return err
 		}

-		ki, err := w.WalletExport(cctx.Context, kaddr)
+		ki, err := w.Export(kaddr)
 		if err != nil {
 			return err
 		}
@@ -15,7 +15,6 @@ import (
 	"time"

 	"github.com/filecoin-project/lotus/chain/actors/builtin"
-
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"

 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
@@ -38,7 +37,6 @@ import (

 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/tools/stats"
@@ -344,18 +342,6 @@ var runCmd = &cli.Command{
 			Usage:   "process ProveCommitSector messages",
 			Value:   true,
 		},
-		&cli.BoolFlag{
-			Name:    "windowed-post",
-			EnvVars: []string{"LOTUS_PCR_WINDOWED_POST"},
-			Usage:   "process SubmitWindowedPoSt messages and refund gas fees",
-			Value:   false,
-		},
-		&cli.BoolFlag{
-			Name:    "storage-deals",
-			EnvVars: []string{"LOTUS_PCR_STORAGE_DEALS"},
-			Usage:   "process PublishStorageDeals messages and refund gas fees",
-			Value:   false,
-		},
 		&cli.IntFlag{
 			Name:    "head-delay",
 			EnvVars: []string{"LOTUS_PCR_HEAD_DELAY"},
@@ -392,18 +378,6 @@ var runCmd = &cli.Command{
 			Usage:   "percent of refund to issue",
 			Value:   110,
 		},
-		&cli.StringFlag{
-			Name:    "pre-fee-cap-max",
-			EnvVars: []string{"LOTUS_PCR_PRE_FEE_CAP_MAX"},
-			Usage:   "messages with a fee cap larger than this will be skipped when processing pre commit messages",
-			Value:   "0.000000001",
-		},
-		&cli.StringFlag{
-			Name:    "prove-fee-cap-max",
-			EnvVars: []string{"LOTUS_PCR_PROVE_FEE_CAP_MAX"},
-			Usage:   "messages with a prove cap larger than this will be skipped when processing pre commit messages",
-			Value:   "0.000000001",
-		},
 	},
 	Action: func(cctx *cli.Context) error {
 		go func() {
@@ -447,8 +421,6 @@ var runCmd = &cli.Command{
 		dryRun := cctx.Bool("dry-run")
 		preCommitEnabled := cctx.Bool("pre-commit")
 		proveCommitEnabled := cctx.Bool("prove-commit")
-		windowedPoStEnabled := cctx.Bool("windowed-post")
-		publishStorageDealsEnabled := cctx.Bool("storage-deals")
 		aggregateTipsets := cctx.Int("aggregate-tipsets")
 		minerRecoveryEnabled := cctx.Bool("miner-recovery")
 		minerRecoveryPeriod := abi.ChainEpoch(int64(cctx.Int("miner-recovery-period")))
@@ -456,16 +428,6 @@ var runCmd = &cli.Command{
 		minerRecoveryCutoff := uint64(cctx.Int("miner-recovery-cutoff"))
 		minerRecoveryBonus := uint64(cctx.Int("miner-recovery-bonus"))

-		preFeeCapMax, err := types.ParseFIL(cctx.String("pre-fee-cap-max"))
-		if err != nil {
-			return err
-		}
-
-		proveFeeCapMax, err := types.ParseFIL(cctx.String("prove-fee-cap-max"))
-		if err != nil {
-			return err
-		}
-
 		rf := &refunder{
 			api:                        api,
 			wallet:                     from,
@@ -476,10 +438,6 @@ var runCmd = &cli.Command{
 			dryRun:                     dryRun,
 			preCommitEnabled:           preCommitEnabled,
 			proveCommitEnabled:         proveCommitEnabled,
-			windowedPoStEnabled:        windowedPoStEnabled,
-			publishStorageDealsEnabled: publishStorageDealsEnabled,
-			preFeeCapMax:               types.BigInt(preFeeCapMax),
-			proveFeeCapMax:             types.BigInt(proveFeeCapMax),
 		}

 		var refunds *MinersRefund = NewMinersRefund()
@@ -631,12 +589,7 @@ type refunder struct {
 	dryRun                     bool
 	preCommitEnabled           bool
 	proveCommitEnabled         bool
-	windowedPoStEnabled        bool
-	publishStorageDealsEnabled bool
 	threshold                  big.Int
-
-	preFeeCapMax   big.Int
-	proveFeeCapMax big.Int
 }

 func (r *refunder) FindMiners(ctx context.Context, tipset *types.TipSet, refunds *MinersRefund, owner, worker, control bool) (*MinersRefund, error) {
@@ -864,147 +817,6 @@ func (r *refunder) EnsureMinerMinimums(ctx context.Context, tipset *types.TipSet
 	return refunds, nil
 }

-func (r *refunder) processTipsetStorageMarketActor(ctx context.Context, tipset *types.TipSet, msg api.Message, recp *types.MessageReceipt) (bool, string, types.BigInt, error) {
-
-	m := msg.Message
-	refundValue := types.NewInt(0)
-	var messageMethod string
-
-	switch m.Method {
-	case builtin0.MethodsMarket.PublishStorageDeals:
-		if !r.publishStorageDealsEnabled {
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		messageMethod = "PublishStorageDeals"
-
-		if recp.ExitCode != exitcode.Ok {
-			log.Debugw("skipping non-ok exitcode message", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "exitcode", recp.ExitCode)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		refundValue = types.BigMul(types.NewInt(uint64(recp.GasUsed)), tipset.Blocks()[0].ParentBaseFee)
-	}
-
-	return true, messageMethod, refundValue, nil
-}
-
-func (r *refunder) processTipsetStorageMinerActor(ctx context.Context, tipset *types.TipSet, msg api.Message, recp *types.MessageReceipt) (bool, string, types.BigInt, error) {
-
-	m := msg.Message
-	refundValue := types.NewInt(0)
-	var messageMethod string
-
-	switch m.Method {
-	case builtin0.MethodsMiner.SubmitWindowedPoSt:
-		if !r.windowedPoStEnabled {
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		messageMethod = "SubmitWindowedPoSt"
-
-		if recp.ExitCode != exitcode.Ok {
-			log.Debugw("skipping non-ok exitcode message", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "exitcode", recp.ExitCode)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		refundValue = types.BigMul(types.NewInt(uint64(recp.GasUsed)), tipset.Blocks()[0].ParentBaseFee)
-	case builtin0.MethodsMiner.ProveCommitSector:
-		if !r.proveCommitEnabled {
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		messageMethod = "ProveCommitSector"
-
-		if recp.ExitCode != exitcode.Ok {
-			log.Debugw("skipping non-ok exitcode message", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "exitcode", recp.ExitCode)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		if m.GasFeeCap.GreaterThan(r.proveFeeCapMax) {
-			log.Debugw("skipping high fee cap message", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "gas_fee_cap", m.GasFeeCap, "fee_cap_max", r.proveFeeCapMax)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		var sn abi.SectorNumber
-
-		var proveCommitSector miner0.ProveCommitSectorParams
-		if err := proveCommitSector.UnmarshalCBOR(bytes.NewBuffer(m.Params)); err != nil {
-			log.Warnw("failed to decode provecommit params", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		sn = proveCommitSector.SectorNumber
-
-		// We use the parent tipset key because precommit information is removed when ProveCommitSector is executed
-		precommitChainInfo, err := r.api.StateSectorPreCommitInfo(ctx, m.To, sn, tipset.Parents())
-		if err != nil {
-			log.Warnw("failed to get precommit info for sector", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", sn)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		precommitTipset, err := r.api.ChainGetTipSetByHeight(ctx, precommitChainInfo.PreCommitEpoch, tipset.Key())
-		if err != nil {
-			log.Warnf("failed to lookup precommit epoch", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", sn)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		collateral, err := r.api.StateMinerInitialPledgeCollateral(ctx, m.To, precommitChainInfo.Info, precommitTipset.Key())
-		if err != nil {
-			log.Warnw("failed to get initial pledge collateral", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", sn)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		collateral = big.Sub(collateral, precommitChainInfo.PreCommitDeposit)
-		if collateral.LessThan(big.Zero()) {
-			log.Debugw("skipping zero pledge collateral difference", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", sn)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		refundValue = collateral
-		if r.refundPercent > 0 {
-			refundValue = types.BigMul(types.BigDiv(refundValue, types.NewInt(100)), types.NewInt(uint64(r.refundPercent)))
-		}
-	case builtin0.MethodsMiner.PreCommitSector:
-		if !r.preCommitEnabled {
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		messageMethod = "PreCommitSector"
-
-		if recp.ExitCode != exitcode.Ok {
-			log.Debugw("skipping non-ok exitcode message", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "exitcode", recp.ExitCode)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		if m.GasFeeCap.GreaterThan(r.preFeeCapMax) {
-			log.Debugw("skipping high fee cap message", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "gas_fee_cap", m.GasFeeCap, "fee_cap_max", r.preFeeCapMax)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		var precommitInfo miner.SectorPreCommitInfo
-		if err := precommitInfo.UnmarshalCBOR(bytes.NewBuffer(m.Params)); err != nil {
-			log.Warnw("failed to decode precommit params", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		collateral, err := r.api.StateMinerInitialPledgeCollateral(ctx, m.To, precommitInfo, tipset.Key())
-		if err != nil {
-			log.Warnw("failed to calculate initial pledge collateral", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", precommitInfo.SectorNumber)
-			return false, messageMethod, types.NewInt(0), nil
-		}
-
-		refundValue = collateral
-		if r.refundPercent > 0 {
-			refundValue = types.BigMul(types.BigDiv(refundValue, types.NewInt(100)), types.NewInt(uint64(r.refundPercent)))
-		}
-	default:
-		return false, messageMethod, types.NewInt(0), nil
-	}
-
-	return true, messageMethod, refundValue, nil
-}
-
 func (r *refunder) ProcessTipset(ctx context.Context, tipset *types.TipSet, refunds *MinersRefund) (*MinersRefund, error) {
 	cids := tipset.Cids()
 	if len(cids) == 0 {
@@ -1029,9 +841,9 @@ func (r *refunder) ProcessTipset(ctx context.Context, tipset *types.TipSet, refu
 		return nil, nil
 	}

+	refundValue := types.NewInt(0)
 	tipsetRefunds := NewMinersRefund()
 	for i, msg := range msgs {
-		refundValue := types.NewInt(0)
 		m := msg.Message

 		a, err := r.api.StateGetActor(ctx, m.To, tipset.Key())
@@ -1040,23 +852,91 @@ func (r *refunder) ProcessTipset(ctx context.Context, tipset *types.TipSet, refu
 			continue
 		}

+		if !builtin.IsStorageMinerActor(a.Code) {
+			continue
+		}
+
 		var messageMethod string
-		var processed bool

-		if m.To == market.Address {
-			processed, messageMethod, refundValue, err = r.processTipsetStorageMarketActor(ctx, tipset, msg, recps[i])
-		}
+		switch m.Method {
+		case builtin0.MethodsMiner.ProveCommitSector:
+			if !r.proveCommitEnabled {
+				continue
+			}

-		if builtin.IsStorageMinerActor(a.Code) {
-			processed, messageMethod, refundValue, err = r.processTipsetStorageMinerActor(ctx, tipset, msg, recps[i])
-		}
+			messageMethod = "ProveCommitSector"

-		if err != nil {
-			log.Errorw("error while processing message", "cid", msg.Cid)
+			if recps[i].ExitCode != exitcode.Ok {
+				log.Debugw("skipping non-ok exitcode message", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "exitcode", recps[i].ExitCode)
+				continue
+			}
+
+			var sn abi.SectorNumber
+
+			var proveCommitSector miner0.ProveCommitSectorParams
+			if err := proveCommitSector.UnmarshalCBOR(bytes.NewBuffer(m.Params)); err != nil {
+				log.Warnw("failed to decode provecommit params", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To)
+				continue
+			}
+
+			sn = proveCommitSector.SectorNumber
+
+			// We use the parent tipset key because precommit information is removed when ProveCommitSector is executed
+			precommitChainInfo, err := r.api.StateSectorPreCommitInfo(ctx, m.To, sn, tipset.Parents())
+			if err != nil {
+				log.Warnw("failed to get precommit info for sector", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", sn)
+				continue
+			}
+
+			precommitTipset, err := r.api.ChainGetTipSetByHeight(ctx, precommitChainInfo.PreCommitEpoch, tipset.Key())
+			if err != nil {
+				log.Warnf("failed to lookup precommit epoch", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", sn)
+				continue
+			}
+
+			collateral, err := r.api.StateMinerInitialPledgeCollateral(ctx, m.To, precommitChainInfo.Info, precommitTipset.Key())
+			if err != nil {
+				log.Warnw("failed to get initial pledge collateral", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", sn)
+			}
+
+			collateral = big.Sub(collateral, precommitChainInfo.PreCommitDeposit)
+			if collateral.LessThan(big.Zero()) {
+				log.Debugw("skipping zero pledge collateral difference", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", sn)
+				continue
+			}
+
+			refundValue = collateral
+		case builtin0.MethodsMiner.PreCommitSector:
+			if !r.preCommitEnabled {
+				continue
+			}
+
+			messageMethod = "PreCommitSector"
+
+			if recps[i].ExitCode != exitcode.Ok {
+				log.Debugw("skipping non-ok exitcode message", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "exitcode", recps[i].ExitCode)
+				continue
+			}
+
+			var precommitInfo miner.SectorPreCommitInfo
+			if err := precommitInfo.UnmarshalCBOR(bytes.NewBuffer(m.Params)); err != nil {
+				log.Warnw("failed to decode precommit params", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To)
+				continue
+			}
+
+			collateral, err := r.api.StateMinerInitialPledgeCollateral(ctx, m.To, precommitInfo, tipset.Key())
+			if err != nil {
+				log.Warnw("failed to calculate initial pledge collateral", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", precommitInfo.SectorNumber)
+				continue
+			}
+
+			refundValue = collateral
+		default:
 			continue
 		}
-		if !processed {
-			continue
+
+		if r.refundPercent > 0 {
+			refundValue = types.BigMul(types.BigDiv(refundValue, types.NewInt(100)), types.NewInt(uint64(r.refundPercent)))
 		}

 		log.Debugw(
@@ -7,7 +7,6 @@ import (

 	"github.com/docker/go-units"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"

@@ -34,19 +33,16 @@ import (
 )

 type accountInfo struct {
-	Address         address.Address
-	Balance         types.FIL
-	Type            string
-	Power           abi.StoragePower
-	Worker          address.Address
-	Owner           address.Address
-	InitialPledge   types.FIL
-	PreCommits      types.FIL
-	LockedFunds     types.FIL
-	Sectors         uint64
-	VestingStart    abi.ChainEpoch
-	VestingDuration abi.ChainEpoch
-	VestingAmount   types.FIL
+	Address       address.Address
+	Balance       types.FIL
+	Type          string
+	Power         abi.StoragePower
+	Worker        address.Address
+	Owner         address.Address
+	InitialPledge types.FIL
+	PreCommits    types.FIL
+	LockedFunds   types.FIL
+	Sectors       uint64
 }

 var auditsCmd = &cli.Command{
@@ -119,8 +115,10 @@ var chainBalanceCmd = &cli.Command{
 			infos = append(infos, ai)
 		}

-		printAccountInfos(infos, false)
-
+		fmt.Printf("Address,Balance,Type,Power,Worker,Owner\n")
+		for _, acc := range infos {
+			fmt.Printf("%s,%s,%s,%s,%s,%s\n", acc.Address, acc.Balance, acc.Type, acc.Power, acc.Worker, acc.Owner)
+		}
 		return nil
 	},
 }
@@ -173,7 +171,7 @@ var chainBalanceStateCmd = &cli.Command{

 		bs := blockstore.NewBlockstore(ds)

-		cs := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier), nil)
+		cs := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier))

 		cst := cbor.NewCborStore(bs)
 		store := adt.WrapStore(ctx, cst)
@@ -198,7 +196,6 @@ var chainBalanceStateCmd = &cli.Command{
 				LockedFunds:   types.FIL(big.NewInt(0)),
 				InitialPledge: types.FIL(big.NewInt(0)),
 				PreCommits:    types.FIL(big.NewInt(0)),
-				VestingAmount: types.FIL(big.NewInt(0)),
 			}

 			if minerInfo && builtin.IsStorageMinerActor(act.Code) {
@@ -237,32 +234,6 @@ var chainBalanceStateCmd = &cli.Command{
 				ai.Worker = minfo.Worker
 				ai.Owner = minfo.Owner
 			}
-
-			if builtin.IsMultisigActor(act.Code) {
-				mst, err := multisig.Load(store, act)
-				if err != nil {
-					return err
-				}
-
-				ai.VestingStart, err = mst.StartEpoch()
-				if err != nil {
-					return err
-				}
-
-				ib, err := mst.InitialBalance()
-				if err != nil {
-					return err
-				}
-
-				ai.VestingAmount = types.FIL(ib)
-
-				ai.VestingDuration, err = mst.UnlockDuration()
-				if err != nil {
-					return err
-				}
-
-			}
-
 			infos = append(infos, ai)
 			return nil
 		})
@@ -270,27 +241,22 @@ var chainBalanceStateCmd = &cli.Command{
 			return xerrors.Errorf("failed to loop over actors: %w", err)
 		}

-		printAccountInfos(infos, minerInfo)
+		if minerInfo {
+			fmt.Printf("Address,Balance,Type,Sectors,Worker,Owner,InitialPledge,Locked,PreCommits\n")
+			for _, acc := range infos {
+				fmt.Printf("%s,%s,%s,%d,%s,%s,%s,%s,%s\n", acc.Address, acc.Balance, acc.Type, acc.Sectors, acc.Worker, acc.Owner, acc.InitialPledge, acc.LockedFunds, acc.PreCommits)
+			}
+		} else {
+			fmt.Printf("Address,Balance,Type\n")
+			for _, acc := range infos {
+				fmt.Printf("%s,%s,%s\n", acc.Address, acc.Balance, acc.Type)
+			}
+		}

 		return nil
 	},
 }

-func printAccountInfos(infos []accountInfo, minerInfo bool) {
-	if minerInfo {
-		fmt.Printf("Address,Balance,Type,Sectors,Worker,Owner,InitialPledge,Locked,PreCommits,VestingStart,VestingDuration,VestingAmount\n")
-		for _, acc := range infos {
-			fmt.Printf("%s,%s,%s,%d,%s,%s,%s,%s,%s,%d,%d,%s\n", acc.Address, acc.Balance.Unitless(), acc.Type, acc.Sectors, acc.Worker, acc.Owner, acc.InitialPledge.Unitless(), acc.LockedFunds.Unitless(), acc.PreCommits.Unitless(), acc.VestingStart, acc.VestingDuration, acc.VestingAmount.Unitless())
-		}
-	} else {
-		fmt.Printf("Address,Balance,Type\n")
-		for _, acc := range infos {
-			fmt.Printf("%s,%s,%s\n", acc.Address, acc.Balance.Unitless(), acc.Type)
-		}
-	}
-
-}
-
 var chainPledgeCmd = &cli.Command{
 	Name:        "stateroot-pledge",
 	Description: "Calculate sector pledge numbers",
@@ -343,7 +309,7 @@ var chainPledgeCmd = &cli.Command{

 		bs := blockstore.NewBlockstore(ds)

-		cs := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier), nil)
+		cs := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier))

 		cst := cbor.NewCborStore(bs)
 		store := adt.WrapStore(ctx, cst)
@@ -15,7 +15,6 @@ import (
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
-	cliutil "github.com/filecoin-project/lotus/cli/util"
 	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/multiformats/go-multiaddr"
 	"github.com/urfave/cli/v2"
@@ -112,7 +111,7 @@ var consensusCheckCmd = &cli.Command{
 			if err != nil {
 				return err
 			}
-			ainfo := cliutil.APIInfo{Addr: apima.String()}
+			ainfo := lcli.APIInfo{Addr: apima}
 			addr, err := ainfo.DialArgs()
 			if err != nil {
 				return err
@@ -83,7 +83,7 @@ var exportChainCmd = &cli.Command{

 		bs := blockstore.NewBlockstore(ds)

-		cs := store.NewChainStore(bs, mds, nil, nil)
+		cs := store.NewChainStore(bs, mds, nil)
 		if err := cs.Load(); err != nil {
 			return err
 		}
@@ -52,7 +52,7 @@ var genesisVerifyCmd = &cli.Command{
 		}
 		bs := blockstore.NewBlockstore(datastore.NewMapDatastore())

-		cs := store.NewChainStore(bs, datastore.NewMapDatastore(), nil, nil)
+		cs := store.NewChainStore(bs, datastore.NewMapDatastore(), nil)

 		cf := cctx.Args().Get(0)
 		f, err := os.Open(cf)
@@ -105,7 +105,7 @@ var keyinfoVerifyCmd = &cli.Command{
 				return err
 			}

-			if _, err := w.WalletImport(cctx.Context, &keyInfo); err != nil {
+			if _, err := w.Import(&keyInfo); err != nil {
 				return err
 			}

@@ -220,7 +220,7 @@ var keyinfoImportCmd = &cli.Command{
 				return err
 			}

-			addr, err := w.WalletImport(cctx.Context, &keyInfo)
+			addr, err := w.Import(&keyInfo)
 			if err != nil {
 				return err
 			}
@@ -5,8 +5,6 @@ import (
 	"math"

 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
 	"github.com/urfave/cli/v2"

 	"github.com/filecoin-project/lotus/chain/types"
@@ -34,10 +32,6 @@ var noncefix = &cli.Command{
 		&cli.BoolFlag{
 			Name: "auto",
 		},
-		&cli.Int64Flag{
-			Name:  "gas-fee-cap",
-			Usage: "specify gas fee cap for nonce filling messages",
-		},
 	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := lcli.GetFullNodeAPI(cctx)
@@ -90,32 +84,15 @@ var noncefix = &cli.Command{
 		}
 		fmt.Printf("Creating %d filler messages (%d ~ %d)\n", end-start, start, end)

-		ts, err := api.ChainHead(ctx)
-		if err != nil {
-			return err
-		}
-
-		feeCap := big.Mul(ts.Blocks()[0].ParentBaseFee, big.NewInt(2)) // default fee cap to 2 * parent base fee
-		if fcf := cctx.Int64("gas-fee-cap"); fcf != 0 {
-			feeCap = abi.NewTokenAmount(fcf)
-		}
-
 		for i := start; i < end; i++ {
 			msg := &types.Message{
-				From:       addr,
-				To:         addr,
-				Value:      types.NewInt(0),
-				Nonce:      i,
-				GasLimit:   1000000,
-				GasFeeCap:  feeCap,
-				GasPremium: abi.NewTokenAmount(5),
-			}
-			smsg, err := api.WalletSignMessage(ctx, addr, msg)
-			if err != nil {
-				return err
+				From:  addr,
+				To:    addr,
+				Value: types.NewInt(1),
+				Nonce: i,
 			}

-			_, err = api.MpoolPush(ctx, smsg)
+			_, err = api.MpoolPushMessage(ctx, msg, nil)
 			if err != nil {
 				return err
 			}
@@ -162,7 +162,7 @@ var stateTreePruneCmd = &cli.Command{

 		bs := blockstore.NewBlockstore(ds)

-		cs := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier), nil)
+		cs := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier))
 		if err := cs.Load(); err != nil {
 			return fmt.Errorf("loading chainstore: %w", err)
 		}
@@ -5,6 +5,8 @@ import (
 	"testing"
 	"time"

+	"github.com/filecoin-project/lotus/node"
+
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/stretchr/testify/require"
 	"github.com/urfave/cli/v2"
@@ -62,8 +64,8 @@ func TestMinerAllInfo(t *testing.T) {
 		require.NoError(t, infoAllCmd.Action(cctx))
 	}

-	bp := func(t *testing.T, fullOpts []test.FullNodeOpts, storage []test.StorageMiner) ([]test.TestNode, []test.TestStorageNode) {
-		n, sn = builder.Builder(t, fullOpts, storage)
+	bp := func(t *testing.T, nFull int, storage []test.StorageMiner, opts ...node.Option) ([]test.TestNode, []test.TestStorageNode) {
+		n, sn = builder.Builder(t, nFull, storage, opts...)

 		t.Run("pre-info-all", run)

@@ -464,12 +464,13 @@ func storageMinerInit(ctx context.Context, cctx *cli.Context, api lapi.FullNode,
 				return err
 			}

-			j, err := journal.OpenFSJournal(lr, journal.EnvDisabledEvents())
-			if err != nil {
+			if jrnl, err := journal.OpenFSJournal(lr, journal.DefaultDisabledEvents); err == nil {
+				journal.J = jrnl
+			} else {
 				return fmt.Errorf("failed to open filesystem journal: %w", err)
 			}

-			m := miner.NewMiner(api, epp, a, slashfilter.New(mds), j)
+			m := miner.NewMiner(api, epp, a, slashfilter.New(mds))
 			{
 				if err := m.Start(ctx); err != nil {
 					return xerrors.Errorf("failed to start up genesis miner: %w", err)
@@ -154,14 +154,14 @@ var setAskCmd = &cli.Command{
 	Name:  "set-ask",
 	Usage: "Configure the miner's ask",
 	Flags: []cli.Flag{
-		&cli.StringFlag{
+		&cli.Uint64Flag{
 			Name:     "price",
-			Usage:    "Set the price of the ask for unverified deals (specified as FIL / GiB / Epoch) to `PRICE`.",
+			Usage:    "Set the price of the ask for unverified deals (specified as attoFIL / GiB / Epoch) to `PRICE`",
 			Required: true,
 		},
-		&cli.StringFlag{
+		&cli.Uint64Flag{
 			Name:     "verified-price",
-			Usage:    "Set the price of the ask for verified deals (specified as FIL / GiB / Epoch) to `PRICE`",
+			Usage:    "Set the price of the ask for verified deals (specified as attoFIL / GiB / Epoch) to `PRICE`",
 			Required: true,
 		},
 		&cli.StringFlag{
@@ -185,15 +185,8 @@ var setAskCmd = &cli.Command{
 		}
 		defer closer()

-		pri, err := types.ParseFIL(cctx.String("price"))
-		if err != nil {
-			return err
-		}
-
-		vpri, err := types.ParseFIL(cctx.String("verified-price"))
-		if err != nil {
-			return err
-		}
+		pri := types.NewInt(cctx.Uint64("price"))
+		vpri := types.NewInt(cctx.Uint64("verified-price"))

 		dur, err := time.ParseDuration("720h0m0s")
 		if err != nil {
@@ -236,7 +229,7 @@ var setAskCmd = &cli.Command{
 			return xerrors.Errorf("max piece size (w/bit-padding) %s cannot exceed miner sector size %s", types.SizeStr(types.NewInt(uint64(max))), types.SizeStr(types.NewInt(uint64(smax))))
 		}

-		return api.MarketSetAsk(ctx, types.BigInt(pri), types.BigInt(vpri), abi.ChainEpoch(qty), abi.PaddedPieceSize(min), abi.PaddedPieceSize(max))
+		return api.MarketSetAsk(ctx, pri, vpri, abi.ChainEpoch(qty), abi.PaddedPieceSize(min), abi.PaddedPieceSize(max))
 	},
 }

@@ -288,7 +281,7 @@ var getAskCmd = &cli.Command{
 			rem = (time.Second * time.Duration(int64(dlt)*int64(build.BlockDelaySecs))).String()
 		}

-		fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%d\t%s\t%d\n", types.FIL(ask.Price), types.FIL(ask.VerifiedPrice), types.SizeStr(types.NewInt(uint64(ask.MinPieceSize))), types.SizeStr(types.NewInt(uint64(ask.MaxPieceSize))), ask.Expiry, rem, ask.SeqNo)
+		fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%d\t%s\t%d\n", ask.Price, ask.VerifiedPrice, types.SizeStr(types.NewInt(uint64(ask.MinPieceSize))), types.SizeStr(types.NewInt(uint64(ask.MaxPieceSize))), ask.Expiry, rem, ask.SeqNo)

 		return w.Flush()
 	},
@@ -33,7 +33,7 @@ var runCmd = &cli.Command{
 	Usage: "Start a lotus miner process",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
-			Name:  "miner-api",
+			Name:  "api",
 			Usage: "2345",
 		},
 		&cli.BoolFlag{
@@ -61,7 +61,7 @@ var runCmd = &cli.Command{

 		nodeApi, ncloser, err := lcli.GetFullNodeAPI(cctx)
 		if err != nil {
-			return xerrors.Errorf("getting full node api: %w", err)
+			return err
 		}
 		defer ncloser()
 		ctx := lcli.DaemonContext(cctx)
@@ -112,29 +112,29 @@ var runCmd = &cli.Command{
 			node.Online(),
 			node.Repo(r),

-			node.ApplyIf(func(s *node.Settings) bool { return cctx.IsSet("miner-api") },
+			node.ApplyIf(func(s *node.Settings) bool { return cctx.IsSet("api") },
 				node.Override(new(dtypes.APIEndpoint), func() (dtypes.APIEndpoint, error) {
-					return multiaddr.NewMultiaddr("/ip4/127.0.0.1/tcp/" + cctx.String("miner-api"))
+					return multiaddr.NewMultiaddr("/ip4/127.0.0.1/tcp/" + cctx.String("api"))
 				})),
 			node.Override(new(api.FullNode), nodeApi),
 		)
 		if err != nil {
-			return xerrors.Errorf("creating node: %w", err)
+			return err
 		}

 		endpoint, err := r.APIEndpoint()
 		if err != nil {
-			return xerrors.Errorf("getting API endpoint: %w", err)
+			return err
 		}

 		// Bootstrap with full node
 		remoteAddrs, err := nodeApi.NetAddrsListen(ctx)
 		if err != nil {
-			return xerrors.Errorf("getting full node libp2p address: %w", err)
+			return err
 		}

 		if err := minerapi.NetConnect(ctx, remoteAddrs); err != nil {
-			return xerrors.Errorf("connecting to full node (libp2p): %w", err)
+			return err
 		}

 		log.Infof("Remote version %s", v)
@@ -31,10 +31,6 @@ const metaFile = "sectorstore.json"
 var storageCmd = &cli.Command{
 	Name:  "storage",
 	Usage: "manage sector storage",
-	Description: `Sectors can be stored across many filesystem paths. These
-commands provide ways to manage the storage the miner will used to store sectors
-long term for proving (references as 'store') as well as how sectors will be
-stored while moving through the sealing pipeline (references as 'seal').`,
 	Subcommands: []*cli.Command{
 		storageAttachCmd,
 		storageListCmd,
@@ -45,25 +41,6 @@ stored while moving through the sealing pipeline (references as 'seal').`,
 var storageAttachCmd = &cli.Command{
 	Name:  "attach",
 	Usage: "attach local storage path",
-	Description: `Storage can be attached to the miner using this command. The storage volume
-list is stored local to the miner in $LOTUS_MINER_PATH/storage.json. We do not
-recommend manually modifying this value without further understanding of the
-storage system.
-
-Each storage volume contains a configuration file which describes the
-capabilities of the volume. When the '--init' flag is provided, this file will
-be created using the additional flags.
-
-Weight
-A high weight value means data will be more likely to be stored in this path
-
-Seal
-Data for the sealing process will be stored here
-
-Store
-Finalized sectors that will be moved here for long term storage and be proven
-over time
-   `,
 	Flags: []cli.Flag{
 		&cli.BoolFlag{
 			Name:  "init",
@@ -1,94 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"context"
-	"encoding/hex"
-
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/crypto"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type LoggedWallet struct {
-	under api.WalletAPI
-}
-
-func (c *LoggedWallet) WalletNew(ctx context.Context, typ crypto.SigType) (address.Address, error) {
-	n, err := typ.Name()
-	if err != nil {
-		return address.Address{}, err
-	}
-
-	log.Infow("WalletNew", "type", n)
-
-	return c.under.WalletNew(ctx, typ)
-}
-
-func (c *LoggedWallet) WalletHas(ctx context.Context, addr address.Address) (bool, error) {
-	log.Infow("WalletHas", "address", addr)
-
-	return c.under.WalletHas(ctx, addr)
-}
-
-func (c *LoggedWallet) WalletList(ctx context.Context) ([]address.Address, error) {
-	log.Infow("WalletList")
-
-	return c.under.WalletList(ctx)
-}
-
-func (c *LoggedWallet) WalletSign(ctx context.Context, k address.Address, msg []byte, meta api.MsgMeta) (*crypto.Signature, error) {
-	switch meta.Type {
-	case api.MTChainMsg:
-		var cmsg types.Message
-		if err := cmsg.UnmarshalCBOR(bytes.NewReader(meta.Extra)); err != nil {
-			return nil, xerrors.Errorf("unmarshalling message: %w", err)
-		}
-
-		_, bc, err := cid.CidFromBytes(msg)
-		if err != nil {
-			return nil, xerrors.Errorf("getting cid from signing bytes: %w", err)
-		}
-
-		if !cmsg.Cid().Equals(bc) {
-			return nil, xerrors.Errorf("cid(meta.Extra).bytes() != msg")
-		}
-
-		log.Infow("WalletSign",
-			"address", k,
-			"type", meta.Type,
-			"from", cmsg.From,
-			"to", cmsg.To,
-			"value", types.FIL(cmsg.Value),
-			"feecap", types.FIL(cmsg.RequiredFunds()),
-			"method", cmsg.Method,
-			"params", hex.EncodeToString(cmsg.Params))
-	default:
-		log.Infow("WalletSign", "address", k, "type", meta.Type)
-	}
-
-	return c.under.WalletSign(ctx, k, msg, meta)
-}
-
-func (c *LoggedWallet) WalletExport(ctx context.Context, a address.Address) (*types.KeyInfo, error) {
-	log.Infow("WalletExport", "address", a)
-
-	return c.under.WalletExport(ctx, a)
-}
-
-func (c *LoggedWallet) WalletImport(ctx context.Context, ki *types.KeyInfo) (address.Address, error) {
-	log.Infow("WalletImport", "type", ki.Type)
-
-	return c.under.WalletImport(ctx, ki)
-}
-
-func (c *LoggedWallet) WalletDelete(ctx context.Context, addr address.Address) error {
-	log.Infow("WalletDelete", "address", addr)
-
-	return c.under.WalletDelete(ctx, addr)
-}
@@ -1,141 +0,0 @@
-package main
-
-import (
-	"context"
-	"net"
-	"net/http"
-	"os"
-
-	"github.com/gorilla/mux"
-	logging "github.com/ipfs/go-log/v2"
-	"github.com/urfave/cli/v2"
-
-	"github.com/filecoin-project/go-jsonrpc"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/wallet"
-	lcli "github.com/filecoin-project/lotus/cli"
-	"github.com/filecoin-project/lotus/lib/lotuslog"
-	"github.com/filecoin-project/lotus/node/repo"
-)
-
-var log = logging.Logger("main")
-
-const FlagWalletRepo = "wallet-repo"
-
-func main() {
-	lotuslog.SetupLogLevels()
-
-	local := []*cli.Command{
-		runCmd,
-	}
-
-	app := &cli.App{
-		Name:    "lotus-wallet",
-		Usage:   "Basic external wallet",
-		Version: build.UserVersion(),
-		Flags: []cli.Flag{
-			&cli.StringFlag{
-				Name:    FlagWalletRepo,
-				EnvVars: []string{"WALLET_PATH"},
-				Value:   "~/.lotuswallet", // TODO: Consider XDG_DATA_HOME
-			},
-		},
-
-		Commands: local,
-	}
-	app.Setup()
-
-	if err := app.Run(os.Args); err != nil {
-		log.Warnf("%+v", err)
-		return
-	}
-}
-
-var runCmd = &cli.Command{
-	Name:  "run",
-	Usage: "Start lotus wallet",
-	Flags: []cli.Flag{
-		&cli.StringFlag{
-			Name:  "listen",
-			Usage: "host address and port the wallet api will listen on",
-			Value: "0.0.0.0:1777",
-		},
-	},
-	Action: func(cctx *cli.Context) error {
-		log.Info("Starting lotus wallet")
-
-		ctx := lcli.ReqContext(cctx)
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
-
-		repoPath := cctx.String(FlagWalletRepo)
-		r, err := repo.NewFS(repoPath)
-		if err != nil {
-			return err
-		}
-
-		ok, err := r.Exists()
-		if err != nil {
-			return err
-		}
-		if !ok {
-			if err := r.Init(repo.Worker); err != nil {
-				return err
-			}
-		}
-
-		lr, err := r.Lock(repo.Wallet)
-		if err != nil {
-			return err
-		}
-
-		ks, err := lr.KeyStore()
-		if err != nil {
-			return err
-		}
-
-		w, err := wallet.NewWallet(ks)
-		if err != nil {
-			return err
-		}
-
-		address := cctx.String("listen")
-		mux := mux.NewRouter()
-
-		log.Info("Setting up API endpoint at " + address)
-
-		rpcServer := jsonrpc.NewServer()
-		rpcServer.Register("Filecoin", &LoggedWallet{under: w})
-
-		mux.Handle("/rpc/v0", rpcServer)
-		mux.PathPrefix("/").Handler(http.DefaultServeMux) // pprof
-
-		/*ah := &auth.Handler{
-			Verify: nodeApi.AuthVerify,
-			Next:   mux.ServeHTTP,
-		}*/
-
-		srv := &http.Server{
-			Handler: mux,
-			BaseContext: func(listener net.Listener) context.Context {
-				return ctx
-			},
-		}
-
-		go func() {
-			<-ctx.Done()
-			log.Warn("Shutting down...")
-			if err := srv.Shutdown(context.TODO()); err != nil {
-				log.Errorf("shutting down RPC server failed: %s", err)
-			}
-			log.Warn("Graceful shutdown successful")
-		}()
-
-		nl, err := net.Listen("tcp", address)
-		if err != nil {
-			return err
-		}
-
-		return srv.Serve(nl)
-	},
-}
@@ -15,6 +15,8 @@ import (
 	"runtime/pprof"
 	"strings"

+	"github.com/filecoin-project/lotus/chain/types"
+
 	paramfetch "github.com/filecoin-project/go-paramfetch"
 	"github.com/mitchellh/go-homedir"
 	"github.com/multiformats/go-multiaddr"
@@ -30,11 +32,9 @@ import (
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
 	lcli "github.com/filecoin-project/lotus/cli"
 	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
-	"github.com/filecoin-project/lotus/journal"
 	"github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/filecoin-project/lotus/lib/peermgr"
 	"github.com/filecoin-project/lotus/lib/ulimit"
@@ -114,11 +114,6 @@ var DaemonCmd = &cli.Command{
 			Name:  "halt-after-import",
 			Usage: "halt the process after importing chain from file",
 		},
-		&cli.BoolFlag{
-			Name:   "lite",
-			Usage:  "start lotus in lite mode",
-			Hidden: true,
-		},
 		&cli.StringFlag{
 			Name:  "pprof",
 			Usage: "specify name of file for writing cpu profile to",
@@ -138,8 +133,6 @@ var DaemonCmd = &cli.Command{
 		},
 	},
 	Action: func(cctx *cli.Context) error {
-		isLite := cctx.Bool("lite")
-
 		err := runmetrics.Enable(runmetrics.RunMetricOptions{
 			EnableCPU:    true,
 			EnableMemory: true,
@@ -199,10 +192,8 @@ var DaemonCmd = &cli.Command{
 			return xerrors.Errorf("repo init error: %w", err)
 		}

-		if !isLite {
-			if err := paramfetch.GetParams(lcli.ReqContext(cctx), build.ParametersJSON(), 0); err != nil {
-				return xerrors.Errorf("fetching proof parameters: %w", err)
-			}
+		if err := paramfetch.GetParams(lcli.ReqContext(cctx), build.ParametersJSON(), 0); err != nil {
+			return xerrors.Errorf("fetching proof parameters: %w", err)
 		}

 		var genBytes []byte
@@ -249,23 +240,10 @@ var DaemonCmd = &cli.Command{

 		shutdownChan := make(chan struct{})

-		// If the daemon is started in "lite mode", provide a  GatewayAPI
-		// for RPC calls
-		liteModeDeps := node.Options()
-		if isLite {
-			gapi, closer, err := lcli.GetGatewayAPI(cctx)
-			if err != nil {
-				return err
-			}
-
-			defer closer()
-			liteModeDeps = node.Override(new(api.GatewayAPI), gapi)
-		}
-
 		var api api.FullNode

 		stop, err := node.New(ctx,
-			node.FullAPI(&api, node.Lite(isLite)),
+			node.FullAPI(&api),

 			node.Override(new(dtypes.Bootstrapper), isBootstrapper),
 			node.Override(new(dtypes.ShutdownChan), shutdownChan),
@@ -273,7 +251,6 @@ var DaemonCmd = &cli.Command{
 			node.Repo(r),

 			genesis,
-			liteModeDeps,

 			node.ApplyIf(func(s *node.Settings) bool { return cctx.IsSet("api") },
 				node.Override(node.SetApiEndpointKey, func(lr repo.LockedRepo) error {
@@ -411,11 +388,7 @@ func ImportChain(r repo.Repo, fname string, snapshot bool) (err error) {

 	bs := blockstore.NewBlockstore(ds)

-	j, err := journal.OpenFSJournal(lr, journal.EnvDisabledEvents())
-	if err != nil {
-		return xerrors.Errorf("failed to open journal: %w", err)
-	}
-	cst := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier), j)
+	cst := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier))

 	log.Infof("importing chain from %s...", fname)

@@ -198,10 +198,8 @@ func doExtract(ctx context.Context, fapi api.FullNode, opts extractOpts) error {
 			Preroot:    root,
 			Epoch:      execTs.Height(),
 			Message:    m,
-			CircSupply: circSupplyDetail.FilCirculating,
-			BaseFee:    basefee,
-			// recorded randomness will be discarded.
-			Rand: conformance.NewRecordingRand(new(conformance.LogReporter), fapi),
+			CircSupply: &circSupplyDetail.FilCirculating,
+			BaseFee:    &basefee,
 		})
 		if err != nil {
 			return fmt.Errorf("failed to execute precursor message: %w", err)
@@ -214,9 +212,6 @@ func doExtract(ctx context.Context, fapi api.FullNode, opts extractOpts) error {
 		applyret  *vm.ApplyRet
 		carWriter func(w io.Writer) error
 		retention = opts.retain
-
-		// recordingRand will record randomness so we can embed it in the test vector.
-		recordingRand = conformance.NewRecordingRand(new(conformance.LogReporter), fapi)
 	)

 	log.Printf("using state retention strategy: %s", retention)
@@ -234,9 +229,8 @@ func doExtract(ctx context.Context, fapi api.FullNode, opts extractOpts) error {
 			Preroot:    preroot,
 			Epoch:      execTs.Height(),
 			Message:    msg,
-			CircSupply: circSupplyDetail.FilCirculating,
-			BaseFee:    basefee,
-			Rand:       recordingRand,
+			CircSupply: &circSupplyDetail.FilCirculating,
+			BaseFee:    &basefee,
 		})
 		if err != nil {
 			return fmt.Errorf("failed to execute message: %w", err)
@@ -266,9 +260,8 @@ func doExtract(ctx context.Context, fapi api.FullNode, opts extractOpts) error {
 			Preroot:    preroot,
 			Epoch:      execTs.Height(),
 			Message:    msg,
-			CircSupply: circSupplyDetail.FilCirculating,
-			BaseFee:    basefee,
-			Rand:       recordingRand,
+			CircSupply: &circSupplyDetail.FilCirculating,
+			BaseFee:    &basefee,
 		})
 		if err != nil {
 			return fmt.Errorf("failed to execute message: %w", err)
@@ -363,8 +356,7 @@ func doExtract(ctx context.Context, fapi api.FullNode, opts extractOpts) error {
 				{Source: fmt.Sprintf("execution_tipset:%s", execTs.Key().String())},
 				{Source: "github.com/filecoin-project/lotus", Version: version.String()}},
 		},
-		Randomness: recordingRand.Recorded(),
-		CAR:        out.Bytes(),
+		CAR: out.Bytes(),
 		Pre: &schema.Preconditions{
 			Epoch:      int64(execTs.Height()),
 			CircSupply: circSupply.Int,
@@ -2,7 +2,6 @@ package conformance

 import (
 	"context"
-	gobig "math/big"
 	"os"

 	"github.com/filecoin-project/lotus/chain/state"
@@ -14,11 +13,7 @@ import (
 	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/lotus/lib/blockstore"

-	_ "github.com/filecoin-project/lotus/lib/sigs/bls"  // enable bls signatures
-	_ "github.com/filecoin-project/lotus/lib/sigs/secp" // enable secp signatures
-
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"

 	"github.com/filecoin-project/test-vectors/schema"
@@ -84,10 +79,10 @@ type ExecuteTipsetResult struct {
 // and reward withdrawal per miner.
 func (d *Driver) ExecuteTipset(bs blockstore.Blockstore, ds ds.Batching, preroot cid.Cid, parentEpoch abi.ChainEpoch, tipset *schema.Tipset) (*ExecuteTipsetResult, error) {
 	var (
-		syscalls = vm.Syscalls(ffiwrapper.ProofVerifier)
-		vmRand   = NewFixedRand()
+		syscalls = mkFakedSigSyscalls(vm.Syscalls(ffiwrapper.ProofVerifier))
+		vmRand   = new(testRand)

-		cs = store.NewChainStore(bs, ds, syscalls, nil)
+		cs = store.NewChainStore(bs, ds, syscalls)
 		sm = stmgr.NewStateManager(cs)
 	)

@@ -148,12 +143,8 @@ type ExecuteMessageParams struct {
 	Preroot    cid.Cid
 	Epoch      abi.ChainEpoch
 	Message    *types.Message
-	CircSupply abi.TokenAmount
-	BaseFee    abi.TokenAmount
-
-	// Rand is an optional vm.Rand implementation to use. If nil, the driver
-	// will use a vm.Rand that returns a fixed value for all calls.
-	Rand vm.Rand
+	CircSupply *abi.TokenAmount
+	BaseFee    *abi.TokenAmount
 }

 // ExecuteMessage executes a conformance test vector message in a temporary VM.
@@ -164,8 +155,14 @@ func (d *Driver) ExecuteMessage(bs blockstore.Blockstore, params ExecuteMessageP
 		_ = os.Setenv("LOTUS_DISABLE_VM_BUF", "iknowitsabadidea")
 	}

-	if params.Rand == nil {
-		params.Rand = NewFixedRand()
+	basefee := DefaultBaseFee
+	if params.BaseFee != nil {
+		basefee = *params.BaseFee
+	}
+
+	circSupply := DefaultCirculatingSupply
+	if params.CircSupply != nil {
+		circSupply = *params.CircSupply
 	}

 	// dummy state manager; only to reference the GetNetworkVersion method,
@@ -175,13 +172,13 @@ func (d *Driver) ExecuteMessage(bs blockstore.Blockstore, params ExecuteMessageP
 	vmOpts := &vm.VMOpts{
 		StateBase: params.Preroot,
 		Epoch:     params.Epoch,
+		Rand:      &testRand{}, // TODO always succeeds; need more flexibility.
 		Bstore:    bs,
-		Syscalls:  vm.Syscalls(ffiwrapper.ProofVerifier),
+		Syscalls:  mkFakedSigSyscalls(vm.Syscalls(ffiwrapper.ProofVerifier)), // TODO always succeeds; need more flexibility.
 		CircSupplyCalc: func(_ context.Context, _ abi.ChainEpoch, _ *state.StateTree) (abi.TokenAmount, error) {
-			return params.CircSupply, nil
+			return circSupply, nil
 		},
-		Rand:        params.Rand,
-		BaseFee:     params.BaseFee,
+		BaseFee:     basefee,
 		NtwkVersion: sm.GetNtwkVersion,
 	}

@@ -234,22 +231,3 @@ func toChainMsg(msg *types.Message) (ret types.ChainMsg) {
 	}
 	return ret
 }
-
-// BaseFeeOrDefault converts a basefee as passed in a test vector (go *big.Int
-// type) to an abi.TokenAmount, or if nil it returns the DefaultBaseFee.
-func BaseFeeOrDefault(basefee *gobig.Int) abi.TokenAmount {
-	if basefee == nil {
-		return DefaultBaseFee
-	}
-	return big.NewFromGo(basefee)
-}
-
-// CircSupplyOrDefault converts a circulating supply as passed in a test vector
-// (go *big.Int type) to an abi.TokenAmount, or if nil it returns the
-// DefaultCirculatingSupply.
-func CircSupplyOrDefault(circSupply *gobig.Int) abi.TokenAmount {
-	if circSupply == nil {
-		return DefaultBaseFee
-	}
-	return big.NewFromGo(circSupply)
-}
@@ -1,28 +0,0 @@
-package conformance
-
-import (
-	"context"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/crypto"
-
-	"github.com/filecoin-project/lotus/chain/vm"
-)
-
-type fixedRand struct{}
-
-var _ vm.Rand = (*fixedRand)(nil)
-
-// NewFixedRand creates a test vm.Rand that always returns fixed bytes value
-// of utf-8 string 'i_am_random_____i_am_random_____'.
-func NewFixedRand() vm.Rand {
-	return &fixedRand{}
-}
-
-func (r *fixedRand) GetChainRandomness(_ context.Context, _ crypto.DomainSeparationTag, _ abi.ChainEpoch, _ []byte) ([]byte, error) {
-	return []byte("i_am_random_____i_am_random_____"), nil // 32 bytes.
-}
-
-func (r *fixedRand) GetBeaconRandomness(_ context.Context, _ crypto.DomainSeparationTag, _ abi.ChainEpoch, _ []byte) ([]byte, error) {
-	return []byte("i_am_random_____i_am_random_____"), nil // 32 bytes.
-}
@@ -1,103 +0,0 @@
-package conformance
-
-import (
-	"context"
-	"fmt"
-	"sync"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/crypto"
-
-	"github.com/filecoin-project/test-vectors/schema"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/vm"
-)
-
-type RecordingRand struct {
-	reporter Reporter
-	api      api.FullNode
-
-	// once guards the loading of the head tipset.
-	// can be removed when https://github.com/filecoin-project/lotus/issues/4223
-	// is fixed.
-	once     sync.Once
-	head     types.TipSetKey
-	lk       sync.Mutex
-	recorded schema.Randomness
-}
-
-var _ vm.Rand = (*RecordingRand)(nil)
-
-// NewRecordingRand returns a vm.Rand implementation that proxies calls to a
-// full Lotus node via JSON-RPC, and records matching rules and responses so
-// they can later be embedded in test vectors.
-func NewRecordingRand(reporter Reporter, api api.FullNode) *RecordingRand {
-	return &RecordingRand{reporter: reporter, api: api}
-}
-
-func (r *RecordingRand) loadHead() {
-	head, err := r.api.ChainHead(context.Background())
-	if err != nil {
-		panic(fmt.Sprintf("could not fetch chain head while fetching randomness: %s", err))
-	}
-	r.head = head.Key()
-}
-
-func (r *RecordingRand) GetChainRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
-	r.once.Do(r.loadHead)
-	ret, err := r.api.ChainGetRandomnessFromTickets(ctx, r.head, pers, round, entropy)
-	if err != nil {
-		return ret, err
-	}
-
-	r.reporter.Logf("fetched and recorded chain randomness for: dst=%d, epoch=%d, entropy=%x, result=%x", pers, round, entropy, ret)
-
-	match := schema.RandomnessMatch{
-		On: schema.RandomnessRule{
-			Kind:                schema.RandomnessChain,
-			DomainSeparationTag: int64(pers),
-			Epoch:               int64(round),
-			Entropy:             entropy,
-		},
-		Return: []byte(ret),
-	}
-	r.lk.Lock()
-	r.recorded = append(r.recorded, match)
-	r.lk.Unlock()
-
-	return ret, err
-}
-
-func (r *RecordingRand) GetBeaconRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
-	r.once.Do(r.loadHead)
-	ret, err := r.api.ChainGetRandomnessFromBeacon(ctx, r.head, pers, round, entropy)
-	if err != nil {
-		return ret, err
-	}
-
-	r.reporter.Logf("fetched and recorded beacon randomness for: dst=%d, epoch=%d, entropy=%x, result=%x", pers, round, entropy, ret)
-
-	match := schema.RandomnessMatch{
-		On: schema.RandomnessRule{
-			Kind:                schema.RandomnessBeacon,
-			DomainSeparationTag: int64(pers),
-			Epoch:               int64(round),
-			Entropy:             entropy,
-		},
-		Return: []byte(ret),
-	}
-	r.lk.Lock()
-	r.recorded = append(r.recorded, match)
-	r.lk.Unlock()
-
-	return ret, err
-}
-
-func (r *RecordingRand) Recorded() schema.Randomness {
-	r.lk.Lock()
-	defer r.lk.Unlock()
-
-	return r.recorded
-}
@@ -1,79 +0,0 @@
-package conformance
-
-import (
-	"bytes"
-	"context"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/crypto"
-
-	"github.com/filecoin-project/test-vectors/schema"
-
-	"github.com/filecoin-project/lotus/chain/vm"
-)
-
-type ReplayingRand struct {
-	reporter Reporter
-	recorded schema.Randomness
-	fallback vm.Rand
-}
-
-var _ vm.Rand = (*ReplayingRand)(nil)
-
-// NewReplayingRand replays recorded randomness when requested, falling back to
-// fixed randomness if the value cannot be found; hence this is a safe
-// backwards-compatible replacement for fixedRand.
-func NewReplayingRand(reporter Reporter, recorded schema.Randomness) *ReplayingRand {
-	return &ReplayingRand{
-		reporter: reporter,
-		recorded: recorded,
-		fallback: NewFixedRand(),
-	}
-}
-
-func (r *ReplayingRand) match(requested schema.RandomnessRule) ([]byte, bool) {
-	for _, other := range r.recorded {
-		if other.On.Kind == requested.Kind &&
-			other.On.Epoch == requested.Epoch &&
-			other.On.DomainSeparationTag == requested.DomainSeparationTag &&
-			bytes.Equal(other.On.Entropy, requested.Entropy) {
-			return other.Return, true
-		}
-	}
-	return nil, false
-}
-
-func (r *ReplayingRand) GetChainRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
-	rule := schema.RandomnessRule{
-		Kind:                schema.RandomnessChain,
-		DomainSeparationTag: int64(pers),
-		Epoch:               int64(round),
-		Entropy:             entropy,
-	}
-
-	if ret, ok := r.match(rule); ok {
-		r.reporter.Logf("returning saved chain randomness: dst=%d, epoch=%d, entropy=%x, result=%x", pers, round, entropy, ret)
-		return ret, nil
-	}
-
-	r.reporter.Logf("returning fallback chain randomness: dst=%d, epoch=%d, entropy=%x", pers, round, entropy)
-	return r.fallback.GetChainRandomness(ctx, pers, round, entropy)
-}
-
-func (r *ReplayingRand) GetBeaconRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
-	rule := schema.RandomnessRule{
-		Kind:                schema.RandomnessBeacon,
-		DomainSeparationTag: int64(pers),
-		Epoch:               int64(round),
-		Entropy:             entropy,
-	}
-
-	if ret, ok := r.match(rule); ok {
-		r.reporter.Logf("returning saved beacon randomness: dst=%d, epoch=%d, entropy=%x, result=%x", pers, round, entropy, ret)
-		return ret, nil
-	}
-
-	r.reporter.Logf("returning fallback beacon randomness: dst=%d, epoch=%d, entropy=%x", pers, round, entropy)
-	return r.fallback.GetBeaconRandomness(ctx, pers, round, entropy)
-
-}
@@ -13,7 +13,9 @@ import (

 	"github.com/fatih/color"
 	"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/test-vectors/schema"
 	"github.com/ipfs/go-blockservice"
 	"github.com/ipfs/go-cid"
 	ds "github.com/ipfs/go-datastore"
@@ -22,8 +24,6 @@ import (
 	"github.com/ipfs/go-merkledag"
 	"github.com/ipld/go-car"

-	"github.com/filecoin-project/test-vectors/schema"
-
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
 	"github.com/filecoin-project/lotus/lib/blockstore"
@@ -46,6 +46,18 @@ func ExecuteMessageVector(r Reporter, vector *schema.TestVector) {
 	// Create a new Driver.
 	driver := NewDriver(ctx, vector.Selector, DriverOpts{DisableVMFlush: true})

+	var circSupply *abi.TokenAmount
+	if cs := vector.Pre.CircSupply; cs != nil {
+		ta := big.NewFromGo(cs)
+		circSupply = &ta
+	}
+
+	var basefee *abi.TokenAmount
+	if bf := vector.Pre.BaseFee; bf != nil {
+		ta := big.NewFromGo(bf)
+		basefee = &ta
+	}
+
 	// Apply every message.
 	for i, m := range vector.ApplyMessages {
 		msg, err := types.DecodeMessage(m.Bytes)
@@ -64,9 +76,8 @@ func ExecuteMessageVector(r Reporter, vector *schema.TestVector) {
 			Preroot:    root,
 			Epoch:      abi.ChainEpoch(epoch),
 			Message:    msg,
-			BaseFee:    BaseFeeOrDefault(vector.Pre.BaseFee),
-			CircSupply: CircSupplyOrDefault(vector.Pre.CircSupply),
-			Rand:       NewReplayingRand(r, vector.Randomness),
+			CircSupply: circSupply,
+			BaseFee:    basefee,
 		})
 		if err != nil {
 			r.Fatalf("fatal failure when executing message: %s", err)
@@ -0,0 +1,56 @@
+package conformance
+
+import (
+	"context"
+
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/vm"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/runtime"
+
+	cbor "github.com/ipfs/go-ipld-cbor"
+)
+
+type testRand struct{}
+
+var _ vm.Rand = (*testRand)(nil)
+
+func (r *testRand) GetChainRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
+	return []byte("i_am_random_____i_am_random_____"), nil // 32 bytes.
+}
+
+func (r *testRand) GetBeaconRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
+	return []byte("i_am_random_____i_am_random_____"), nil // 32 bytes.
+}
+
+type testSyscalls struct {
+	runtime.Syscalls
+}
+
+// TODO VerifySignature this will always succeed; but we want to be able to test failures too.
+func (fss *testSyscalls) VerifySignature(_ crypto.Signature, _ address.Address, _ []byte) error {
+	return nil
+}
+
+// TODO VerifySeal this will always succeed; but we want to be able to test failures too.
+func (fss *testSyscalls) VerifySeal(_ proof.SealVerifyInfo) error {
+	return nil
+}
+
+// TODO VerifyPoSt this will always succeed; but we want to be able to test failures too.
+func (fss *testSyscalls) VerifyPoSt(_ proof.WindowPoStVerifyInfo) error {
+	return nil
+}
+
+func mkFakedSigSyscalls(base vm.SyscallBuilder) vm.SyscallBuilder {
+	return func(ctx context.Context, cstate *state.StateTree, cst cbor.IpldStore) runtime.Syscalls {
+		return &testSyscalls{
+			base(ctx, cstate, cst),
+		}
+	}
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Travis Person	321c59ee40	Butterfly genesis	2020-10-07 01:45:21 +00:00
Travis Person	a986baebf5	New butterfly network info	2020-10-07 01:21:47 +00:00