Merge pull request #2593 from mgoelzer/paych_get_parse_as_fil

Parse amount as FIL in paych get

.github/ISSUE_TEMPLATE/bug_report.md

@@ -21,7 +21,7 @@ A clear and concise description of what you expected to happen.
 **Screenshots**
 If applicable, add screenshots to help explain your problem.
 
-**Version (run `lotus --version`):**
+**Version (run `lotus version`):**
 
 **Additional context**
 Add any other context about the problem here.

Makefile

@@ -158,7 +158,6 @@ BINS+=fountain
 chainwatch:
 	rm -f chainwatch
 	go build -o chainwatch ./cmd/lotus-chainwatch
-	go run github.com/GeertJohan/go.rice/rice append --exec chainwatch -i ./cmd/lotus-chainwatch -i ./build
 .PHONY: chainwatch
 BINS+=chainwatch
 

README.md

@@ -19,7 +19,7 @@ All work is tracked via issues. An attempt at keeping an up-to-date view on rema
 The main branches under development at the moment are:
 * [`master`](https://github.com/filecoin-project/lotus): current testnet.
 * [`next`](https://github.com/filecoin-project/lotus/tree/next): working branch with chain-breaking changes.
-* [`interopnet`](https://github.com/filecoin-project/lotus/tree/interopnet): devnet running one of `next` commits.
+* [`ntwk-calibration`](https://github.com/filecoin-project/lotus/tree/ntwk-calibration): devnet running one of `next` commits.
 
 ## License
 

api/api_full.go

@@ -26,62 +26,61 @@ import (
 type FullNode interface {
 	Common
 
-	// TODO: TipSetKeys
-
 	// MethodGroup: Chain
 	// The Chain method group contains methods for interacting with the
-	// blockchain, but that do not require any form of state computation
+	// blockchain, but that do not require any form of state computation.
 
-	// ChainNotify returns channel with chain head updates
-	// First message is guaranteed to be of len == 1, and type == 'current'
+	// ChainNotify returns channel with chain head updates.
+	// First message is guaranteed to be of len == 1, and type == 'current'.
 	ChainNotify(context.Context) (<-chan []*HeadChange, error)
 
-	// ChainHead returns the current head of the chain
+	// ChainHead returns the current head of the chain.
 	ChainHead(context.Context) (*types.TipSet, error)
 
-	// ChainGetRandomness is used to sample the chain for randomness
+	// ChainGetRandomness is used to sample the chain for randomness.
 	ChainGetRandomness(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
 
-	// ChainGetBlock returns the block specified by the given CID
+	// ChainGetBlock returns the block specified by the given CID.
 	ChainGetBlock(context.Context, cid.Cid) (*types.BlockHeader, error)
+	// ChainGetTipSet returns the tipset specified by the given TipSetKey.
 	ChainGetTipSet(context.Context, types.TipSetKey) (*types.TipSet, error)
 
-	// ChainGetBlockMessages returns messages stored in the specified block
+	// ChainGetBlockMessages returns messages stored in the specified block.
 	ChainGetBlockMessages(ctx context.Context, blockCid cid.Cid) (*BlockMessages, error)
 
 	// ChainGetParentReceipts returns receipts for messages in parent tipset of
-	// the specified block
+	// the specified block.
 	ChainGetParentReceipts(ctx context.Context, blockCid cid.Cid) ([]*types.MessageReceipt, error)
 
-	// ChainGetParentReceipts returns messages stored in parent tipset of the
-	// specified block
+	// ChainGetParentMessages returns messages stored in parent tipset of the
+	// specified block.
 	ChainGetParentMessages(ctx context.Context, blockCid cid.Cid) ([]Message, error)
 
 	// ChainGetTipSetByHeight looks back for a tipset at the specified epoch.
-	// If there are no blocks at the specified epoch, a tipset at higher epoch
-	// will be returned
+	// If there are no blocks at the specified epoch, a tipset at an earlier epoch
+	// will be returned.
 	ChainGetTipSetByHeight(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)
 
 	// ChainReadObj reads ipld nodes referenced by the specified CID from chain
-	// blockstore and returns raw bytes
+	// blockstore and returns raw bytes.
 	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
 
-	// ChainHasObj checks if a given CID exists in the chain blockstore
+	// ChainHasObj checks if a given CID exists in the chain blockstore.
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
 	ChainStatObj(context.Context, cid.Cid, cid.Cid) (ObjStat, error)
 
-	// ChainSetHead forcefully sets current chain head. Use with caution
+	// ChainSetHead forcefully sets current chain head. Use with caution.
 	ChainSetHead(context.Context, types.TipSetKey) error
 
-	// ChainGetGenesis returns the genesis tipset
+	// ChainGetGenesis returns the genesis tipset.
 	ChainGetGenesis(context.Context) (*types.TipSet, error)
 
-	// ChainTipSetWeight computes weight for the specified tipset
+	// ChainTipSetWeight computes weight for the specified tipset.
 	ChainTipSetWeight(context.Context, types.TipSetKey) (types.BigInt, error)
 	ChainGetNode(ctx context.Context, p string) (*IpldObject, error)
 
 	// ChainGetMessage reads a message referenced by the specified CID from the
-	// chain blockstore
+	// chain blockstore.
 	ChainGetMessage(context.Context, cid.Cid) (*types.Message, error)
 
 	// ChainGetPath returns a set of revert/apply operations needed to get from
@@ -99,17 +98,17 @@ type FullNode interface {
 	// Would return `[revert(tBA), apply(tAB), apply(tAA)]`
 	ChainGetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*HeadChange, error)
 
-	// ChainExport returns a stream of bytes with CAR dump of chain data
+	// ChainExport returns a stream of bytes with CAR dump of chain data.
 	ChainExport(context.Context, types.TipSetKey) (<-chan []byte, error)
 
 	// MethodGroup: Sync
 	// The Sync method group contains methods for interacting with and
-	// observing the lotus sync service
+	// observing the lotus sync service.
 
-	// SyncState returns the current status of the lotus sync system
+	// SyncState returns the current status of the lotus sync system.
 	SyncState(context.Context) (*SyncState, error)
 
-	// SyncSubmitBlock can be used to submit a newly created block to the
+	// SyncSubmitBlock can be used to submit a newly created block to the.
 	// network through this node
 	SyncSubmitBlock(ctx context.Context, blk *types.BlockMsg) error
 
@@ -118,34 +117,34 @@ type FullNode interface {
 	SyncIncomingBlocks(ctx context.Context) (<-chan *types.BlockHeader, error)
 
 	// SyncMarkBad marks a blocks as bad, meaning that it won't ever by synced.
-	// Use with extreme caution
+	// Use with extreme caution.
 	SyncMarkBad(ctx context.Context, bcid cid.Cid) error
 
 	// SyncCheckBad checks if a block was marked as bad, and if it was, returns
-	// the reason
+	// the reason.
 	SyncCheckBad(ctx context.Context, bcid cid.Cid) (string, error)
 
 	// MethodGroup: Mpool
 	// The Mpool methods are for interacting with the message pool. The message pool
 	// manages all incoming and outgoing 'messages' going over the network.
 
-	// MpoolPending returns pending mempool messages
+	// MpoolPending returns pending mempool messages.
 	MpoolPending(context.Context, types.TipSetKey) ([]*types.SignedMessage, error)
 
-	// MpoolPush pushes a signed message to mempool
+	// MpoolPush pushes a signed message to mempool.
 	MpoolPush(context.Context, *types.SignedMessage) (cid.Cid, error)
 
 	// MpoolPushMessage atomically assigns a nonce, signs, and pushes a message
-	// to mempool
+	// to mempool.
 	MpoolPushMessage(context.Context, *types.Message) (*types.SignedMessage, error)
 
 	// MpoolGetNonce gets next nonce for the specified sender.
-	// Note that this method may not be atomic. Use MpoolPushMessage instead
+	// Note that this method may not be atomic. Use MpoolPushMessage instead.
 	MpoolGetNonce(context.Context, address.Address) (uint64, error)
 	MpoolSub(context.Context) (<-chan MpoolUpdate, error)
 
 	// MpoolEstimateGasPrice estimates what gas price should be used for a
-	// message to have high likelihood of inclusion in `nblocksincl` epochs
+	// message to have high likelihood of inclusion in `nblocksincl` epochs.
 	MpoolEstimateGasPrice(ctx context.Context, nblocksincl uint64, sender address.Address, gaslimit int64, tsk types.TipSetKey) (types.BigInt, error)
 
 	// MethodGroup: Miner
@@ -157,17 +156,30 @@ type FullNode interface {
 
 	// MethodGroup: Wallet
 
+	// WalletNew creates a new address in the wallet with the given sigType.
 	WalletNew(context.Context, crypto.SigType) (address.Address, error)
+	// WalletHas indicates whether the given address is in the wallet.
 	WalletHas(context.Context, address.Address) (bool, error)
+	// WalletList lists all the addresses in the wallet.
 	WalletList(context.Context) ([]address.Address, error)
+	// WalletBalance returns the balance of the given address at the current head of the chain.
 	WalletBalance(context.Context, address.Address) (types.BigInt, error)
+	// WalletSign signs the given bytes using the given address.
 	WalletSign(context.Context, address.Address, []byte) (*crypto.Signature, error)
+	// WalletSignMessage signs the given message using the given address.
 	WalletSignMessage(context.Context, address.Address, *types.Message) (*types.SignedMessage, error)
+	// WalletVerify takes an address, a signature, and some bytes, and indicates whether the signature is valid.
+	// The address does not have to be in the wallet.
 	WalletVerify(context.Context, address.Address, []byte, *crypto.Signature) bool
+	// WalletDefaultAddress returns the address marked as default in the wallet.
 	WalletDefaultAddress(context.Context) (address.Address, error)
+	// WalletSetDefault marks the given address as as the default one.
 	WalletSetDefault(context.Context, address.Address) error
+	// WalletExport returns the private key of an address in the wallet.
 	WalletExport(context.Context, address.Address) (*types.KeyInfo, error)
+	// WalletImport receives a KeyInfo, which includes a private key, and imports it into the wallet.
 	WalletImport(context.Context, *types.KeyInfo) (address.Address, error)
+	// WalletDelete deletes an address from the wallet.
 	WalletDelete(context.Context, address.Address) error
 
 	// Other
@@ -176,19 +188,27 @@ type FullNode interface {
 	// The Client methods all have to do with interacting with the storage and
 	// retrieval markets as a client
 
-	// ClientImport imports file under the specified path into filestore
+	// ClientImport imports file under the specified path into filestore.
 	ClientImport(ctx context.Context, ref FileRef) (cid.Cid, error)
-	// ClientStartDeal proposes a deal with a miner
+	// ClientStartDeal proposes a deal with a miner.
 	ClientStartDeal(ctx context.Context, params *StartDealParams) (*cid.Cid, error)
-	// ClientGetDeal info returns the latest information about a given deal
+	// ClientGetDealInfo returns the latest information about a given deal.
 	ClientGetDealInfo(context.Context, cid.Cid) (*DealInfo, error)
+	// ClientListDeals returns information about the deals made by the local client.
 	ClientListDeals(ctx context.Context) ([]DealInfo, error)
+	// ClientHasLocal indicates whether a certain CID is locally stored.
 	ClientHasLocal(ctx context.Context, root cid.Cid) (bool, error)
+	// ClientFindData identifies peers that have a certain file, and returns QueryOffers (one per peer).
 	ClientFindData(ctx context.Context, root cid.Cid) ([]QueryOffer, error)
+	// ClientMinerQueryOffer returns a QueryOffer for the specific miner and file.
 	ClientMinerQueryOffer(ctx context.Context, root cid.Cid, miner address.Address) (QueryOffer, error)
+	// ClientRetrieve initiates the retrieval of a file, as specified in the order.
 	ClientRetrieve(ctx context.Context, order RetrievalOrder, ref *FileRef) error
+	// ClientQueryAsk returns a signed StorageAsk from the specified miner.
 	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error)
+	// ClientCalcCommP calculates the CommP for a specified file, based on the sector size of the provided miner.
 	ClientCalcCommP(ctx context.Context, inpath string, miner address.Address) (*CommPRet, error)
+	// ClientGenCar generates a CAR file for the specified file.
 	ClientGenCar(ctx context.Context, ref FileRef, outpath string) error
 
 	// ClientUnimport removes references to the specified file from filestore
@@ -200,55 +220,119 @@ type FullNode interface {
 	//ClientListAsks() []Ask
 
 	// MethodGroup: State
-	// The State methods are used to query, inspect, and interact with chain state
+	// The State methods are used to query, inspect, and interact with chain state.
+	// All methods take a TipSetKey as a parameter. The state looked up is the state at that tipset.
+	// A nil TipSetKey can be provided as a param, this will cause the heaviest tipset in the chain to be used.
 
-	// if tipset is nil, we'll use heaviest
+	// StateCall runs the given message and returns its result without any persisted changes.
 	StateCall(context.Context, *types.Message, types.TipSetKey) (*InvocResult, error)
+	// StateReplay returns the result of executing the indicated message, assuming it was executed in the indicated tipset.
 	StateReplay(context.Context, types.TipSetKey, cid.Cid) (*InvocResult, error)
+	// StateGetActor returns the indicated actor's nonce and balance.
 	StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error)
+	// StateReadState returns the indicated actor's state.
 	StateReadState(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*ActorState, error)
+	// StateListMessages looks back and returns all messages with a matching to or from address, stopping at the given height.
 	StateListMessages(ctx context.Context, match *types.Message, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error)
 
+	// StateNetworkName returns the name of the network the node is synced to
 	StateNetworkName(context.Context) (dtypes.NetworkName, error)
+	// StateMinerSectors returns info about the given miner's sectors. If the filter bitfield is nil, all sectors are included.
+	// If the filterOut boolean is set to true, any sectors in the filter are excluded.
+	// If false, only those sectors in the filter are included.
 	StateMinerSectors(context.Context, address.Address, *abi.BitField, bool, types.TipSetKey) ([]*ChainSectorInfo, error)
+	// StateMinerProvingSet returns info about those sectors that a given miner is actively proving.
 	StateMinerProvingSet(context.Context, address.Address, types.TipSetKey) ([]*ChainSectorInfo, error)
+	// StateMinerProvingDeadline calculates the deadline at some epoch for a proving period
+	// and returns the deadline-related calculations.
 	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*miner.DeadlineInfo, error)
+	// StateMinerPower returns the power of the indicated miner
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
+	// StateMinerInfo returns info about the indicated miner
 	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (MinerInfo, error)
+	// StateMinerDeadlines returns all the proving deadlines for the given miner
 	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) (*miner.Deadlines, error)
+	// StateMinerFaults returns a bitfield indicating the faulty sectors of the given miner
 	StateMinerFaults(context.Context, address.Address, types.TipSetKey) (*abi.BitField, error)
-	// Returns all non-expired Faults that occur within lookback epochs of the given tipset
+	// StateAllMinerFaults returns all non-expired Faults that occur within lookback epochs of the given tipset
 	StateAllMinerFaults(ctx context.Context, lookback abi.ChainEpoch, ts types.TipSetKey) ([]*Fault, error)
+	// StateMinerRecoveries returns a bitfield indicating the recovering sectors of the given miner
 	StateMinerRecoveries(context.Context, address.Address, types.TipSetKey) (*abi.BitField, error)
+	// StateMinerInitialPledgeCollateral returns the initial pledge collateral for the specified miner's sector
 	StateMinerInitialPledgeCollateral(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (types.BigInt, error)
+	// StateMinerAvailableBalance returns the portion of a miner's balance that can be withdrawn or spent
 	StateMinerAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)
+	// StateSectorPreCommitInfo returns the PreCommit info for the specified miner's sector
 	StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error)
+	// StateSectorGetInfo returns the on-chain info for the specified miner's sector
 	StateSectorGetInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorOnChainInfo, error)
 	StatePledgeCollateral(context.Context, types.TipSetKey) (types.BigInt, error)
-	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64) (*MsgLookup, error)
+	// StateSearchMsg searches for a message in the chain, and returns its receipt and the tipset where it was executed
 	StateSearchMsg(context.Context, cid.Cid) (*MsgLookup, error)
+	// 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)
+	// 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
 	StateListActors(context.Context, types.TipSetKey) ([]address.Address, error)
+	// StateMarketBalance looks up the Escrow and Locked balances of the given address in the Storage Market
 	StateMarketBalance(context.Context, address.Address, types.TipSetKey) (MarketBalance, error)
+	// StateMarketParticipants returns the Escrow and Locked balances of every participant in the Storage Market
 	StateMarketParticipants(context.Context, types.TipSetKey) (map[string]MarketBalance, error)
+	// StateMarketDeals returns information about every deal in the Storage Market
 	StateMarketDeals(context.Context, types.TipSetKey) (map[string]MarketDeal, error)
+	// StateMarketStorageDeal returns information about the indicated deal
 	StateMarketStorageDeal(context.Context, abi.DealID, types.TipSetKey) (*MarketDeal, error)
+	// StateLookupID retrieves the ID address of the given address
 	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+	// StateAccountKey returns the public key address of the given ID address
 	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+	// StateChangedActors returns all the actors whose states change between the two given state CIDs
+	// TODO: Should this take tipset keys instead?
 	StateChangedActors(context.Context, cid.Cid, cid.Cid) (map[string]types.Actor, error)
+	// StateGetReceipt returns the message receipt for the given message
 	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
+	// StateMinerSectorCount returns the number of sectors in a miner's sector set and proving set
 	StateMinerSectorCount(context.Context, address.Address, types.TipSetKey) (MinerSectors, error)
+	// StateCompute is a flexible command that applies the given messages on the given tipset.
+	// The messages are run as though the VM were at the provided height.
 	StateCompute(context.Context, abi.ChainEpoch, []*types.Message, types.TipSetKey) (*ComputeStateOutput, error)
 
 	// MethodGroup: Msig
 	// The Msig methods are used to interact with multisig wallets on the
 	// filecoin network
 
+	// 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)
-	MsigCreate(context.Context, int64, []address.Address, types.BigInt, address.Address, types.BigInt) (cid.Cid, error)
+	// MsigCreate creates a multisig wallet
+	// It takes the following params: <required number of senders>, <approving addresses>, <unlock duration>
+	//<initial balance>, <sender address of the create msg>, <gas price>
+	MsigCreate(context.Context, int64, []address.Address, abi.ChainEpoch, types.BigInt, address.Address, types.BigInt) (cid.Cid, error)
+	// MsigPropose proposes a multisig message
+	// It takes the following params: <multisig address>, <recipient address>, <value to transfer>,
+	// <sender address of the propose msg>, <method to call in the proposed message>, <params to include in the proposed message>
 	MsigPropose(context.Context, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
+	// MsigApprove approves a previously-proposed multisig message
+	// It takes the following params: <multisig address>, <proposed message ID>, <proposer address>, <recipient address>, <value to transfer>,
+	// <sender address of the approve msg>, <method to call in the proposed message>, <params to include in the proposed message>
 	MsigApprove(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
-	MsigCancel(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
+	// MsigCancel cancels a previously-proposed multisig message
+	// It takes the following params: <multisig address>, <proposed message ID>, <recipient address>, <value to transfer>,
+	// <sender address of the cancel msg>, <method to call in the proposed message>, <params to include in the proposed message>
+	MsigCancel(context.Context, address.Address, uint64, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
+	// MsigSwapPropose proposes swapping 2 signers in the multisig
+	// It takes the following params: <multisig address>, <sender address of the propose msg>,
+	// <old signer> <new signer>
+	MsigSwapPropose(context.Context, address.Address, address.Address, address.Address, address.Address) (cid.Cid, error)
+	// MsigSwapApprove approves a previously proposed SwapSigner
+	// It takes the following params: <multisig address>, <sender address of the approve msg>, <proposed message ID>,
+	// <proposer address>, <old signer> <new signer>
+	MsigSwapApprove(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, address.Address) (cid.Cid, error)
+	// MsigSwapCancel cancels a previously proposed SwapSigner message
+	// It takes the following params: <multisig address>, <sender address of the cancel msg>, <proposed message ID>,
+	// <old signer> <new signer>
+	MsigSwapCancel(context.Context, address.Address, address.Address, uint64, address.Address, address.Address) (cid.Cid, error)
 
 	MarketEnsureAvailable(context.Context, address.Address, address.Address, types.BigInt) (cid.Cid, error)
 	// MarketFreeBalance
@@ -303,8 +387,10 @@ type DealInfo struct {
 }
 
 type MsgLookup struct {
-	Receipt types.MessageReceipt
-	TipSet  *types.TipSet
+	Receipt   types.MessageReceipt
+	ReturnDec interface{}
+	TipSet    types.TipSetKey
+	Height    abi.ChainEpoch
 }
 
 type BlockMessages struct {

api/apistruct/struct.go

@@ -158,10 +158,13 @@ type FullNodeStruct struct {
 		StateCompute                      func(context.Context, abi.ChainEpoch, []*types.Message, types.TipSetKey) (*api.ComputeStateOutput, error)           `perm:"read"`
 
 		MsigGetAvailableBalance func(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)                                                                    `perm:"read"`
-		MsigCreate              func(context.Context, int64, []address.Address, types.BigInt, address.Address, types.BigInt) (cid.Cid, error)                                    `perm:"sign"`
+		MsigCreate              func(context.Context, int64, []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"`
 		MsigApprove             func(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error) `perm:"sign"`
-		MsigCancel              func(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error) `perm:"sign"`
+		MsigCancel              func(context.Context, address.Address, uint64, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)                  `perm:"sign"`
+		MsigSwapPropose         func(context.Context, address.Address, address.Address, address.Address, address.Address) (cid.Cid, error)                                       `perm:"sign"`
+		MsigSwapApprove         func(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, address.Address) (cid.Cid, error)              `perm:"sign"`
+		MsigSwapCancel          func(context.Context, address.Address, address.Address, uint64, address.Address, address.Address) (cid.Cid, error)                               `perm:"sign"`
 
 		MarketEnsureAvailable func(context.Context, address.Address, address.Address, types.BigInt) (cid.Cid, error) `perm:"sign"`
 
@@ -692,8 +695,8 @@ func (c *FullNodeStruct) MsigGetAvailableBalance(ctx context.Context, a address.
 	return c.Internal.MsigGetAvailableBalance(ctx, a, tsk)
 }
 
-func (c *FullNodeStruct) MsigCreate(ctx context.Context, req int64, addrs []address.Address, val types.BigInt, src address.Address, gp types.BigInt) (cid.Cid, error) {
-	return c.Internal.MsigCreate(ctx, req, addrs, val, src, gp)
+func (c *FullNodeStruct) MsigCreate(ctx context.Context, req int64, addrs []address.Address, duration abi.ChainEpoch, val types.BigInt, src address.Address, gp types.BigInt) (cid.Cid, error) {
+	return c.Internal.MsigCreate(ctx, req, addrs, duration, val, src, gp)
 }
 
 func (c *FullNodeStruct) MsigPropose(ctx context.Context, msig address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
@@ -704,8 +707,20 @@ func (c *FullNodeStruct) MsigApprove(ctx context.Context, msig address.Address,
 	return c.Internal.MsigApprove(ctx, msig, txID, proposer, to, amt, src, method, params)
 }
 
-func (c *FullNodeStruct) MsigCancel(ctx context.Context, msig address.Address, txID uint64, proposer address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
-	return c.Internal.MsigCancel(ctx, msig, txID, proposer, to, amt, src, method, params)
+func (c *FullNodeStruct) MsigCancel(ctx context.Context, msig address.Address, txID uint64, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+	return c.Internal.MsigCancel(ctx, msig, txID, to, amt, src, method, params)
+}
+
+func (c *FullNodeStruct) MsigSwapPropose(ctx context.Context, msig address.Address, src address.Address, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+	return c.Internal.MsigSwapPropose(ctx, msig, src, oldAdd, newAdd)
+}
+
+func (c *FullNodeStruct) MsigSwapApprove(ctx context.Context, msig address.Address, src address.Address, txID uint64, proposer address.Address, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+	return c.Internal.MsigSwapApprove(ctx, msig, src, txID, proposer, oldAdd, newAdd)
+}
+
+func (c *FullNodeStruct) MsigSwapCancel(ctx context.Context, msig address.Address, src address.Address, txID uint64, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+	return c.Internal.MsigSwapCancel(ctx, msig, src, txID, oldAdd, newAdd)
 }
 
 func (c *FullNodeStruct) MarketEnsureAvailable(ctx context.Context, addr, wallet address.Address, amt types.BigInt) (cid.Cid, error) {

api/test/deals.go

@@ -59,7 +59,7 @@ func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport
 		defer close(done)
 		for atomic.LoadInt64(&mine) == 1 {
 			time.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, func(bool) {}); err != nil {
+			if err := sn[0].MineOne(ctx, func(bool, error) {}); err != nil {
 				t.Error(err)
 			}
 		}
@@ -97,7 +97,7 @@ func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		defer close(done)
 		for atomic.LoadInt64(&mine) == 1 {
 			time.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, func(bool) {}); err != nil {
+			if err := sn[0].MineOne(ctx, func(bool, error) {}); err != nil {
 				t.Error(err)
 			}
 		}

api/test/mining.go

@@ -34,7 +34,7 @@ func (ts *testSuite) testMining(t *testing.T) {
 	require.NoError(t, err)
 	<-newHeads
 
-	err = sn[0].MineOne(ctx, func(bool) {})
+	err = sn[0].MineOne(ctx, func(bool, error) {})
 	require.NoError(t, err)
 
 	<-newHeads
@@ -62,7 +62,7 @@ func (ts *testSuite) testMiningReal(t *testing.T) {
 	require.NoError(t, err)
 	<-newHeads
 
-	err = sn[0].MineOne(ctx, func(bool) {})
+	err = sn[0].MineOne(ctx, func(bool, error) {})
 	require.NoError(t, err)
 
 	<-newHeads
@@ -71,7 +71,7 @@ func (ts *testSuite) testMiningReal(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, abi.ChainEpoch(1), h2.Height())
 
-	err = sn[0].MineOne(ctx, func(bool) {})
+	err = sn[0].MineOne(ctx, func(bool, error) {})
 	require.NoError(t, err)
 
 	<-newHeads
@@ -132,7 +132,7 @@ func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExpo
 		prevExpect := 0
 		for atomic.LoadInt32(&mine) != 0 {
 			wait := make(chan int, 2)
-			mdone := func(mined bool) {
+			mdone := func(mined bool, err error) {
 				go func() {
 					n := 0
 					if mined {

api/test/test.go

@@ -18,7 +18,7 @@ type TestNode struct {
 type TestStorageNode struct {
 	api.StorageMiner
 
-	MineOne func(context.Context, func(bool)) error
+	MineOne func(context.Context, func(bool, error)) error
 }
 
 var PresealGenesis = -1

api/test/window_post.go

@@ -43,7 +43,7 @@ func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSect
 		defer close(done)
 		for mine {
 			time.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, func(bool) {}); err != nil {
+			if err := sn[0].MineOne(ctx, func(bool, error) {}); err != nil {
 				t.Error(err)
 			}
 		}
@@ -123,7 +123,7 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 		defer close(done)
 		for mine {
 			time.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, func(bool) {}); err != nil {
+			if err := sn[0].MineOne(ctx, func(bool, error) {}); err != nil {
 				t.Error(err)
 			}
 		}

build/version.go

@@ -53,7 +53,7 @@ func (ve Version) EqMajorMinor(v2 Version) bool {
 }
 
 // APIVersion is a semver version of the rpc api exposed
-var APIVersion Version = newVer(0, 5, 0)
+var APIVersion Version = newVer(0, 6, 0)
 
 //nolint:varcheck,deadcode
 const (

chain/badtscache.go

@@ -1,6 +1,8 @@
 package chain
 
 import (
+	"fmt"
+
 	"github.com/filecoin-project/lotus/build"
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/ipfs/go-cid"
@@ -10,6 +12,35 @@ type BadBlockCache struct {
 	badBlocks *lru.ARCCache
 }
 
+type BadBlockReason struct {
+	Reason         string
+	TipSet         []cid.Cid
+	OriginalReason *BadBlockReason
+}
+
+func NewBadBlockReason(cid []cid.Cid, format string, i ...interface{}) BadBlockReason {
+	return BadBlockReason{
+		TipSet: cid,
+		Reason: fmt.Sprintf(format, i...),
+	}
+}
+
+func (bbr BadBlockReason) Linked(reason string, i ...interface{}) BadBlockReason {
+	or := &bbr
+	if bbr.OriginalReason != nil {
+		or = bbr.OriginalReason
+	}
+	return BadBlockReason{Reason: fmt.Sprintf(reason, i...), OriginalReason: or}
+}
+
+func (bbr BadBlockReason) String() string {
+	res := bbr.Reason
+	if bbr.OriginalReason != nil {
+		res += " caused by: " + fmt.Sprintf("%s %s", bbr.OriginalReason.TipSet, bbr.OriginalReason.String())
+	}
+	return res
+}
+
 func NewBadBlockCache() *BadBlockCache {
 	cache, err := lru.NewARC(build.BadBlockCacheSize)
 	if err != nil {
@@ -21,15 +52,15 @@ func NewBadBlockCache() *BadBlockCache {
 	}
 }
 
-func (bts *BadBlockCache) Add(c cid.Cid, reason string) {
-	bts.badBlocks.Add(c, reason)
+func (bts *BadBlockCache) Add(c cid.Cid, bbr BadBlockReason) {
+	bts.badBlocks.Add(c, bbr)
 }
 
-func (bts *BadBlockCache) Has(c cid.Cid) (string, bool) {
+func (bts *BadBlockCache) Has(c cid.Cid) (BadBlockReason, bool) {
 	rval, ok := bts.badBlocks.Get(c)
 	if !ok {
-		return "", false
+		return BadBlockReason{}, false
 	}
 
-	return rval.(string), true
+	return rval.(BadBlockReason), true
 }

chain/events/events_height.go

@@ -93,7 +93,6 @@ func (e *heightEvents) headChangeAt(rev, app []*types.TipSet) error {
 				if hnd.called {
 					return nil
 				}
-				hnd.called = true
 
 				triggerH := h - abi.ChainEpoch(hnd.confidence)
 
@@ -108,6 +107,7 @@ func (e *heightEvents) headChangeAt(rev, app []*types.TipSet) error {
 				e.lk.Unlock()
 				err = handle(ctx, incTs, h)
 				e.lk.Lock()
+				hnd.called = true
 				span.End()
 
 				if err != nil {

chain/events/state/ctxstore.go

@@ -0,0 +1,25 @@
+package state
+
+import (
+	"context"
+
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+)
+
+type contextStore struct {
+	ctx context.Context
+	cst *cbor.BasicIpldStore
+}
+
+func (cs *contextStore) Context() context.Context {
+	return cs.ctx
+}
+
+func (cs *contextStore) Get(ctx context.Context, c cid.Cid, out interface{}) error {
+	return cs.cst.Get(ctx, c, out)
+}
+
+func (cs *contextStore) Put(ctx context.Context, v interface{}) (cid.Cid, error) {
+	return cs.cst.Put(ctx, v)
+}

chain/events/state/diff_adt.go

@@ -0,0 +1,106 @@
+package state
+
+import (
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	typegen "github.com/whyrusleeping/cbor-gen"
+)
+
+// AdtArrayDiff generalizes adt.Array diffing by accepting a Deferred type that can unmarshalled to its corresponding struct
+// in an interface implantation.
+// Add should be called when a new k,v is added to the array
+// Modify should be called when a value is modified in the array
+// Remove should be called when a value is removed from the array
+type AdtArrayDiff interface {
+	Add(key uint64, val *typegen.Deferred) error
+	Modify(key uint64, from, to *typegen.Deferred) error
+	Remove(key uint64, val *typegen.Deferred) error
+}
+
+// TODO Performance can be improved by diffing the underlying IPLD graph, e.g. https://github.com/ipfs/go-merkledag/blob/749fd8717d46b4f34c9ce08253070079c89bc56d/dagutils/diff.go#L104
+// CBOR Marshaling will likely be the largest performance bottleneck here.
+
+// DiffAdtArray accepts two *adt.Array's and an AdtArrayDiff implementation. It does the following:
+// - All values that exist in preArr and not in curArr are passed to AdtArrayDiff.Remove()
+// - All values that exist in curArr nnd not in prevArr are passed to adtArrayDiff.Add()
+// - All values that exist in preArr and in curArr are passed to AdtArrayDiff.Modify()
+//  - It is the responsibility of AdtArrayDiff.Modify() to determine if the values it was passed have been modified.
+func DiffAdtArray(preArr, curArr *adt.Array, out AdtArrayDiff) error {
+	prevVal := new(typegen.Deferred)
+	if err := preArr.ForEach(prevVal, func(i int64) error {
+		curVal := new(typegen.Deferred)
+		found, err := curArr.Get(uint64(i), curVal)
+		if err != nil {
+			return err
+		}
+		if !found {
+			if err := out.Remove(uint64(i), prevVal); err != nil {
+				return err
+			}
+			return nil
+		}
+
+		if err := out.Modify(uint64(i), prevVal, curVal); err != nil {
+			return err
+		}
+
+		return curArr.Delete(uint64(i))
+	}); err != nil {
+		return err
+	}
+
+	curVal := new(typegen.Deferred)
+	return curArr.ForEach(curVal, func(i int64) error {
+		return out.Add(uint64(i), curVal)
+	})
+}
+
+// TODO Performance can be improved by diffing the underlying IPLD graph, e.g. https://github.com/ipfs/go-merkledag/blob/749fd8717d46b4f34c9ce08253070079c89bc56d/dagutils/diff.go#L104
+// CBOR Marshaling will likely be the largest performance bottleneck here.
+
+// AdtMapDiff generalizes adt.Map diffing by accepting a Deferred type that can unmarshalled to its corresponding struct
+// in an interface implantation.
+// AsKey should return the Keyer implementation specific to the map
+// Add should be called when a new k,v is added to the map
+// Modify should be called when a value is modified in the map
+// Remove should be called when a value is removed from the map
+type AdtMapDiff interface {
+	AsKey(key string) (adt.Keyer, error)
+	Add(key string, val *typegen.Deferred) error
+	Modify(key string, from, to *typegen.Deferred) error
+	Remove(key string, val *typegen.Deferred) error
+}
+
+func DiffAdtMap(preMap, curMap *adt.Map, out AdtMapDiff) error {
+	prevVal := new(typegen.Deferred)
+	if err := preMap.ForEach(prevVal, func(key string) error {
+		curVal := new(typegen.Deferred)
+		k, err := out.AsKey(key)
+		if err != nil {
+			return err
+		}
+
+		found, err := curMap.Get(k, curVal)
+		if err != nil {
+			return err
+		}
+		if !found {
+			if err := out.Remove(key, prevVal); err != nil {
+				return err
+			}
+			return nil
+		}
+
+		if err := out.Modify(key, prevVal, curVal); err != nil {
+			return err
+		}
+
+		return curMap.Delete(k)
+	}); err != nil {
+		return err
+	}
+
+	curVal := new(typegen.Deferred)
+	return curMap.ForEach(curVal, func(key string) error {
+		return out.Add(key, curVal)
+	})
+}

chain/events/state/diff_adt_test.go

@@ -0,0 +1,155 @@
+package state
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	ds "github.com/ipfs/go-datastore"
+	ds_sync "github.com/ipfs/go-datastore/sync"
+	bstore "github.com/ipfs/go-ipfs-blockstore"
+	cbornode "github.com/ipfs/go-ipld-cbor"
+	typegen "github.com/whyrusleeping/cbor-gen"
+
+	"github.com/filecoin-project/specs-actors/actors/runtime"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+)
+
+func TestDiffAdtArray(t *testing.T) {
+	ctxstoreA := newContextStore()
+	ctxstoreB := newContextStore()
+
+	arrA := adt.MakeEmptyArray(ctxstoreA)
+	arrB := adt.MakeEmptyArray(ctxstoreB)
+
+	require.NoError(t, arrA.Set(0, runtime.CBORBytes([]byte{0}))) // delete
+
+	require.NoError(t, arrA.Set(1, runtime.CBORBytes([]byte{0}))) // modify
+	require.NoError(t, arrB.Set(1, runtime.CBORBytes([]byte{1})))
+
+	require.NoError(t, arrA.Set(2, runtime.CBORBytes([]byte{1}))) // delete
+
+	require.NoError(t, arrA.Set(3, runtime.CBORBytes([]byte{0}))) // noop
+	require.NoError(t, arrB.Set(3, runtime.CBORBytes([]byte{0})))
+
+	require.NoError(t, arrA.Set(4, runtime.CBORBytes([]byte{0}))) // modify
+	require.NoError(t, arrB.Set(4, runtime.CBORBytes([]byte{6})))
+
+	require.NoError(t, arrB.Set(5, runtime.CBORBytes{8})) // add
+	require.NoError(t, arrB.Set(6, runtime.CBORBytes{9})) // add
+
+	changes := new(TestAdtDiff)
+
+	assert.NoError(t, DiffAdtArray(arrA, arrB, changes))
+	assert.NotNil(t, changes)
+
+	assert.Equal(t, 2, len(changes.Added))
+	// keys 5 and 6 were added
+	assert.EqualValues(t, uint64(5), changes.Added[0].key)
+	assert.EqualValues(t, []byte{8}, changes.Added[0].val)
+	assert.EqualValues(t, uint64(6), changes.Added[1].key)
+	assert.EqualValues(t, []byte{9}, changes.Added[1].val)
+
+	assert.Equal(t, 2, len(changes.Modified))
+	// keys 1 and 4 were modified
+	assert.EqualValues(t, uint64(1), changes.Modified[0].From.key)
+	assert.EqualValues(t, []byte{0}, changes.Modified[0].From.val)
+	assert.EqualValues(t, uint64(1), changes.Modified[0].To.key)
+	assert.EqualValues(t, []byte{1}, changes.Modified[0].To.val)
+	assert.EqualValues(t, uint64(4), changes.Modified[1].From.key)
+	assert.EqualValues(t, []byte{0}, changes.Modified[1].From.val)
+	assert.EqualValues(t, uint64(4), changes.Modified[1].To.key)
+	assert.EqualValues(t, []byte{6}, changes.Modified[1].To.val)
+
+	assert.Equal(t, 2, len(changes.Removed))
+	// keys 0 and 2 were deleted
+	assert.EqualValues(t, uint64(0), changes.Removed[0].key)
+	assert.EqualValues(t, []byte{0}, changes.Removed[0].val)
+	assert.EqualValues(t, uint64(2), changes.Removed[1].key)
+	assert.EqualValues(t, []byte{1}, changes.Removed[1].val)
+}
+
+type adtDiffResult struct {
+	key uint64
+	val runtime.CBORBytes
+}
+
+type TestAdtDiff struct {
+	Added    []adtDiffResult
+	Modified []TestAdtDiffModified
+	Removed  []adtDiffResult
+}
+
+var _ AdtArrayDiff = &TestAdtDiff{}
+
+type TestAdtDiffModified struct {
+	From adtDiffResult
+	To   adtDiffResult
+}
+
+func (t *TestAdtDiff) Add(key uint64, val *typegen.Deferred) error {
+	v := new(runtime.CBORBytes)
+	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	t.Added = append(t.Added, adtDiffResult{
+		key: key,
+		val: *v,
+	})
+	return nil
+}
+
+func (t *TestAdtDiff) Modify(key uint64, from, to *typegen.Deferred) error {
+	vFrom := new(runtime.CBORBytes)
+	err := vFrom.UnmarshalCBOR(bytes.NewReader(from.Raw))
+	if err != nil {
+		return err
+	}
+
+	vTo := new(runtime.CBORBytes)
+	err = vTo.UnmarshalCBOR(bytes.NewReader(to.Raw))
+	if err != nil {
+		return err
+	}
+
+	if !bytes.Equal(*vFrom, *vTo) {
+		t.Modified = append(t.Modified, TestAdtDiffModified{
+			From: adtDiffResult{
+				key: key,
+				val: *vFrom,
+			},
+			To: adtDiffResult{
+				key: key,
+				val: *vTo,
+			},
+		})
+	}
+	return nil
+}
+
+func (t *TestAdtDiff) Remove(key uint64, val *typegen.Deferred) error {
+	v := new(runtime.CBORBytes)
+	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	t.Removed = append(t.Removed, adtDiffResult{
+		key: key,
+		val: *v,
+	})
+	return nil
+}
+
+func newContextStore() *contextStore {
+	ctx := context.Background()
+	bs := bstore.NewBlockstore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+	store := cbornode.NewCborStore(bs)
+	return &contextStore{
+		ctx: ctx,
+		cst: store,
+	}
+}

chain/events/state/predicates.go

@@ -1,20 +1,24 @@
 package state
 
 import (
+	"bytes"
 	"context"
-
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-amt-ipld/v2"
-	"github.com/filecoin-project/lotus/api/apibstore"
-	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	typegen "github.com/whyrusleeping/cbor-gen"
+
 	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/market"
-	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/api/apibstore"
+	"github.com/filecoin-project/lotus/chain/types"
 )
 
-// UserData is the data returned from the DiffFunc
+// UserData is the data returned from the DiffTipSetKeyFunc
 type UserData interface{}
 
 // ChainAPI abstracts out calls made by this class to external APIs
@@ -36,22 +40,22 @@ func NewStatePredicates(api ChainAPI) *StatePredicates {
 	}
 }
 
-// DiffFunc check if there's a change form oldState to newState, and returns
+// DiffTipSetKeyFunc check if there's a change form oldState to newState, and returns
 // - changed: was there a change
 // - user: user-defined data representing the state change
 // - err
-type DiffFunc func(ctx context.Context, oldState, newState *types.TipSet) (changed bool, user UserData, err error)
+type DiffTipSetKeyFunc func(ctx context.Context, oldState, newState types.TipSetKey) (changed bool, user UserData, err error)
 
-type DiffStateFunc func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error)
+type DiffActorStateFunc func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error)
 
 // OnActorStateChanged calls diffStateFunc when the state changes for the given actor
-func (sp *StatePredicates) OnActorStateChanged(addr address.Address, diffStateFunc DiffStateFunc) DiffFunc {
-	return func(ctx context.Context, oldState, newState *types.TipSet) (changed bool, user UserData, err error) {
-		oldActor, err := sp.api.StateGetActor(ctx, addr, oldState.Key())
+func (sp *StatePredicates) OnActorStateChanged(addr address.Address, diffStateFunc DiffActorStateFunc) DiffTipSetKeyFunc {
+	return func(ctx context.Context, oldState, newState types.TipSetKey) (changed bool, user UserData, err error) {
+		oldActor, err := sp.api.StateGetActor(ctx, addr, oldState)
 		if err != nil {
 			return false, nil, err
 		}
-		newActor, err := sp.api.StateGetActor(ctx, addr, newState.Key())
+		newActor, err := sp.api.StateGetActor(ctx, addr, newState)
 		if err != nil {
 			return false, nil, err
 		}
@@ -66,7 +70,7 @@ func (sp *StatePredicates) OnActorStateChanged(addr address.Address, diffStateFu
 type DiffStorageMarketStateFunc func(ctx context.Context, oldState *market.State, newState *market.State) (changed bool, user UserData, err error)
 
 // OnStorageMarketActorChanged calls diffStorageMarketState when the state changes for the market actor
-func (sp *StatePredicates) OnStorageMarketActorChanged(diffStorageMarketState DiffStorageMarketStateFunc) DiffFunc {
+func (sp *StatePredicates) OnStorageMarketActorChanged(diffStorageMarketState DiffStorageMarketStateFunc) DiffTipSetKeyFunc {
 	return sp.OnActorStateChanged(builtin.StorageMarketActorAddr, func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error) {
 		var oldState market.State
 		if err := sp.cst.Get(ctx, oldActorStateHead, &oldState); err != nil {
@@ -80,20 +84,25 @@ func (sp *StatePredicates) OnStorageMarketActorChanged(diffStorageMarketState Di
 	})
 }
 
-type DiffDealStatesFunc func(ctx context.Context, oldDealStateRoot *amt.Root, newDealStateRoot *amt.Root) (changed bool, user UserData, err error)
+type DiffAdtArraysFunc func(ctx context.Context, oldDealStateRoot, newDealStateRoot *adt.Array) (changed bool, user UserData, err error)
 
-// OnDealStateChanged calls diffDealStates when the market state changes
-func (sp *StatePredicates) OnDealStateChanged(diffDealStates DiffDealStatesFunc) DiffStorageMarketStateFunc {
+// OnDealStateChanged calls diffDealStates when the market deal state changes
+func (sp *StatePredicates) OnDealStateChanged(diffDealStates DiffAdtArraysFunc) DiffStorageMarketStateFunc {
 	return func(ctx context.Context, oldState *market.State, newState *market.State) (changed bool, user UserData, err error) {
 		if oldState.States.Equals(newState.States) {
 			return false, nil, nil
 		}
 
-		oldRoot, err := amt.LoadAMT(ctx, sp.cst, oldState.States)
+		ctxStore := &contextStore{
+			ctx: ctx,
+			cst: sp.cst,
+		}
+
+		oldRoot, err := adt.AsArray(ctxStore, oldState.States)
 		if err != nil {
 			return false, nil, err
 		}
-		newRoot, err := amt.LoadAMT(ctx, sp.cst, newState.States)
+		newRoot, err := adt.AsArray(ctxStore, newState.States)
 		if err != nil {
 			return false, nil, err
 		}
@@ -102,31 +111,188 @@ func (sp *StatePredicates) OnDealStateChanged(diffDealStates DiffDealStatesFunc)
 	}
 }
 
+// OnDealProposalChanged calls diffDealProps when the market proposal state changes
+func (sp *StatePredicates) OnDealProposalChanged(diffDealProps DiffAdtArraysFunc) DiffStorageMarketStateFunc {
+	return func(ctx context.Context, oldState *market.State, newState *market.State) (changed bool, user UserData, err error) {
+		if oldState.Proposals.Equals(newState.Proposals) {
+			return false, nil, nil
+		}
+
+		ctxStore := &contextStore{
+			ctx: ctx,
+			cst: sp.cst,
+		}
+
+		oldRoot, err := adt.AsArray(ctxStore, oldState.Proposals)
+		if err != nil {
+			return false, nil, err
+		}
+		newRoot, err := adt.AsArray(ctxStore, newState.Proposals)
+		if err != nil {
+			return false, nil, err
+		}
+
+		return diffDealProps(ctx, oldRoot, newRoot)
+	}
+}
+
+var _ AdtArrayDiff = &MarketDealProposalChanges{}
+
+type MarketDealProposalChanges struct {
+	Added   []ProposalIDState
+	Removed []ProposalIDState
+}
+
+type ProposalIDState struct {
+	ID       abi.DealID
+	Proposal market.DealProposal
+}
+
+func (m *MarketDealProposalChanges) Add(key uint64, val *typegen.Deferred) error {
+	dp := new(market.DealProposal)
+	err := dp.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Added = append(m.Added, ProposalIDState{abi.DealID(key), *dp})
+	return nil
+}
+
+func (m *MarketDealProposalChanges) Modify(key uint64, from, to *typegen.Deferred) error {
+	// short circuit, DealProposals are static
+	return nil
+}
+
+func (m *MarketDealProposalChanges) Remove(key uint64, val *typegen.Deferred) error {
+	dp := new(market.DealProposal)
+	err := dp.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Removed = append(m.Removed, ProposalIDState{abi.DealID(key), *dp})
+	return nil
+}
+
+// OnDealProposalAmtChanged detects changes in the deal proposal AMT for all deal proposals and returns a MarketProposalsChanges structure containing:
+// - Added Proposals
+// - Modified Proposals
+// - Removed Proposals
+func (sp *StatePredicates) OnDealProposalAmtChanged() DiffAdtArraysFunc {
+	return func(ctx context.Context, oldDealProps, newDealProps *adt.Array) (changed bool, user UserData, err error) {
+		proposalChanges := new(MarketDealProposalChanges)
+		if err := DiffAdtArray(oldDealProps, newDealProps, proposalChanges); err != nil {
+			return false, nil, err
+		}
+
+		if len(proposalChanges.Added)+len(proposalChanges.Removed) == 0 {
+			return false, nil, nil
+		}
+
+		return true, proposalChanges, nil
+	}
+}
+
+var _ AdtArrayDiff = &MarketDealStateChanges{}
+
+type MarketDealStateChanges struct {
+	Added    []DealIDState
+	Modified []DealStateChange
+	Removed  []DealIDState
+}
+
+type DealIDState struct {
+	ID   abi.DealID
+	Deal market.DealState
+}
+
+func (m *MarketDealStateChanges) Add(key uint64, val *typegen.Deferred) error {
+	ds := new(market.DealState)
+	err := ds.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Added = append(m.Added, DealIDState{abi.DealID(key), *ds})
+	return nil
+}
+
+func (m *MarketDealStateChanges) Modify(key uint64, from, to *typegen.Deferred) error {
+	dsFrom := new(market.DealState)
+	if err := dsFrom.UnmarshalCBOR(bytes.NewReader(from.Raw)); err != nil {
+		return err
+	}
+
+	dsTo := new(market.DealState)
+	if err := dsTo.UnmarshalCBOR(bytes.NewReader(to.Raw)); err != nil {
+		return err
+	}
+
+	if *dsFrom != *dsTo {
+		m.Modified = append(m.Modified, DealStateChange{abi.DealID(key), dsFrom, dsTo})
+	}
+	return nil
+}
+
+func (m *MarketDealStateChanges) Remove(key uint64, val *typegen.Deferred) error {
+	ds := new(market.DealState)
+	err := ds.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Removed = append(m.Removed, DealIDState{abi.DealID(key), *ds})
+	return nil
+}
+
+// OnDealStateAmtChanged detects changes in the deal state AMT for all deal states and returns a MarketDealStateChanges structure containing:
+// - Added Deals
+// - Modified Deals
+// - Removed Deals
+func (sp *StatePredicates) OnDealStateAmtChanged() DiffAdtArraysFunc {
+	return func(ctx context.Context, oldDealStates, newDealStates *adt.Array) (changed bool, user UserData, err error) {
+		dealStateChanges := new(MarketDealStateChanges)
+		if err := DiffAdtArray(oldDealStates, newDealStates, dealStateChanges); err != nil {
+			return false, nil, err
+		}
+
+		if len(dealStateChanges.Added)+len(dealStateChanges.Modified)+len(dealStateChanges.Removed) == 0 {
+			return false, nil, nil
+		}
+
+		return true, dealStateChanges, nil
+	}
+}
+
 // ChangedDeals is a set of changes to deal state
 type ChangedDeals map[abi.DealID]DealStateChange
 
 // DealStateChange is a change in deal state from -> to
 type DealStateChange struct {
-	From market.DealState
-	To   market.DealState
+	ID   abi.DealID
+	From *market.DealState
+	To   *market.DealState
 }
 
 // DealStateChangedForIDs detects changes in the deal state AMT for the given deal IDs
-func (sp *StatePredicates) DealStateChangedForIDs(dealIds []abi.DealID) DiffDealStatesFunc {
-	return func(ctx context.Context, oldDealStateRoot *amt.Root, newDealStateRoot *amt.Root) (changed bool, user UserData, err error) {
+func (sp *StatePredicates) DealStateChangedForIDs(dealIds []abi.DealID) DiffAdtArraysFunc {
+	return func(ctx context.Context, oldDealStateArray, newDealStateArray *adt.Array) (changed bool, user UserData, err error) {
 		changedDeals := make(ChangedDeals)
 		for _, dealID := range dealIds {
+			var oldDealPtr, newDealPtr *market.DealState
 			var oldDeal, newDeal market.DealState
-			err := oldDealStateRoot.Get(ctx, uint64(dealID), &oldDeal)
+
+			_, err := oldDealStateArray.Get(uint64(dealID), &oldDeal)
 			if err != nil {
 				return false, nil, err
 			}
-			err = newDealStateRoot.Get(ctx, uint64(dealID), &newDeal)
+			oldDealPtr = &oldDeal
+
+			_, err = newDealStateArray.Get(uint64(dealID), &newDeal)
 			if err != nil {
 				return false, nil, err
 			}
+			newDealPtr = &newDeal
+
 			if oldDeal != newDeal {
-				changedDeals[dealID] = DealStateChange{oldDeal, newDeal}
+				changedDeals[dealID] = DealStateChange{dealID, oldDealPtr, newDealPtr}
 			}
 		}
 		if len(changedDeals) > 0 {
@@ -135,3 +301,190 @@ func (sp *StatePredicates) DealStateChangedForIDs(dealIds []abi.DealID) DiffDeal
 		return false, nil, nil
 	}
 }
+
+type DiffMinerActorStateFunc func(ctx context.Context, oldState *miner.State, newState *miner.State) (changed bool, user UserData, err error)
+
+func (sp *StatePredicates) OnMinerActorChange(minerAddr address.Address, diffMinerActorState DiffMinerActorStateFunc) DiffTipSetKeyFunc {
+	return sp.OnActorStateChanged(minerAddr, func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error) {
+		var oldState miner.State
+		if err := sp.cst.Get(ctx, oldActorStateHead, &oldState); err != nil {
+			return false, nil, err
+		}
+		var newState miner.State
+		if err := sp.cst.Get(ctx, newActorStateHead, &newState); err != nil {
+			return false, nil, err
+		}
+		return diffMinerActorState(ctx, &oldState, &newState)
+	})
+}
+
+type MinerSectorChanges struct {
+	Added    []miner.SectorOnChainInfo
+	Extended []SectorExtensions
+	Removed  []miner.SectorOnChainInfo
+}
+
+var _ AdtArrayDiff = &MinerSectorChanges{}
+
+type SectorExtensions struct {
+	From miner.SectorOnChainInfo
+	To   miner.SectorOnChainInfo
+}
+
+func (m *MinerSectorChanges) Add(key uint64, val *typegen.Deferred) error {
+	si := new(miner.SectorOnChainInfo)
+	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Added = append(m.Added, *si)
+	return nil
+}
+
+func (m *MinerSectorChanges) Modify(key uint64, from, to *typegen.Deferred) error {
+	siFrom := new(miner.SectorOnChainInfo)
+	err := siFrom.UnmarshalCBOR(bytes.NewReader(from.Raw))
+	if err != nil {
+		return err
+	}
+
+	siTo := new(miner.SectorOnChainInfo)
+	err = siTo.UnmarshalCBOR(bytes.NewReader(to.Raw))
+	if err != nil {
+		return err
+	}
+
+	if siFrom.Info.Expiration != siTo.Info.Expiration {
+		m.Extended = append(m.Extended, SectorExtensions{
+			From: *siFrom,
+			To:   *siTo,
+		})
+	}
+	return nil
+}
+
+func (m *MinerSectorChanges) Remove(key uint64, val *typegen.Deferred) error {
+	si := new(miner.SectorOnChainInfo)
+	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Removed = append(m.Removed, *si)
+	return nil
+}
+
+func (sp *StatePredicates) OnMinerSectorChange() DiffMinerActorStateFunc {
+	return func(ctx context.Context, oldState, newState *miner.State) (changed bool, user UserData, err error) {
+		ctxStore := &contextStore{
+			ctx: ctx,
+			cst: sp.cst,
+		}
+
+		sectorChanges := &MinerSectorChanges{
+			Added:    []miner.SectorOnChainInfo{},
+			Extended: []SectorExtensions{},
+			Removed:  []miner.SectorOnChainInfo{},
+		}
+
+		// no sector changes
+		if oldState.Sectors.Equals(newState.Sectors) {
+			return false, nil, nil
+		}
+
+		oldSectors, err := adt.AsArray(ctxStore, oldState.Sectors)
+		if err != nil {
+			return false, nil, err
+		}
+
+		newSectors, err := adt.AsArray(ctxStore, newState.Sectors)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if err := DiffAdtArray(oldSectors, newSectors, sectorChanges); err != nil {
+			return false, nil, err
+		}
+
+		// nothing changed
+		if len(sectorChanges.Added)+len(sectorChanges.Extended)+len(sectorChanges.Removed) == 0 {
+			return false, nil, nil
+		}
+
+		return true, sectorChanges, nil
+	}
+}
+
+type MinerPreCommitChanges struct {
+	Added   []miner.SectorPreCommitOnChainInfo
+	Removed []miner.SectorPreCommitOnChainInfo
+}
+
+func (m *MinerPreCommitChanges) AsKey(key string) (adt.Keyer, error) {
+	sector, err := adt.ParseUIntKey(key)
+	if err != nil {
+		return nil, err
+	}
+	return miner.SectorKey(abi.SectorNumber(sector)), nil
+}
+
+func (m *MinerPreCommitChanges) Add(key string, val *typegen.Deferred) error {
+	sp := new(miner.SectorPreCommitOnChainInfo)
+	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Added = append(m.Added, *sp)
+	return nil
+}
+
+func (m *MinerPreCommitChanges) Modify(key string, from, to *typegen.Deferred) error {
+	return nil
+}
+
+func (m *MinerPreCommitChanges) Remove(key string, val *typegen.Deferred) error {
+	sp := new(miner.SectorPreCommitOnChainInfo)
+	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Removed = append(m.Removed, *sp)
+	return nil
+}
+
+func (sp *StatePredicates) OnMinerPreCommitChange() DiffMinerActorStateFunc {
+	return func(ctx context.Context, oldState, newState *miner.State) (changed bool, user UserData, err error) {
+		ctxStore := &contextStore{
+			ctx: ctx,
+			cst: sp.cst,
+		}
+
+		precommitChanges := &MinerPreCommitChanges{
+			Added:   []miner.SectorPreCommitOnChainInfo{},
+			Removed: []miner.SectorPreCommitOnChainInfo{},
+		}
+
+		if oldState.PreCommittedSectors.Equals(newState.PreCommittedSectors) {
+			return false, nil, nil
+		}
+
+		oldPrecommits, err := adt.AsMap(ctxStore, oldState.PreCommittedSectors)
+		if err != nil {
+			return false, nil, err
+		}
+
+		newPrecommits, err := adt.AsMap(ctxStore, newState.PreCommittedSectors)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if err := DiffAdtMap(oldPrecommits, newPrecommits, precommitChanges); err != nil {
+			return false, nil, err
+		}
+
+		if len(precommitChanges.Added)+len(precommitChanges.Removed) == 0 {
+			return false, nil, nil
+		}
+
+		return true, precommitChanges, nil
+	}
+}

chain/events/state/predicates_test.go

@@ -4,23 +4,27 @@ import (
 	"context"
 	"testing"
 
-	"github.com/filecoin-project/specs-actors/actors/crypto"
-	"github.com/ipfs/go-hamt-ipld"
-
-	"github.com/filecoin-project/go-amt-ipld/v2"
-	"github.com/filecoin-project/specs-actors/actors/builtin/market"
-	ds "github.com/ipfs/go-datastore"
-	ds_sync "github.com/ipfs/go-datastore/sync"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
-	cbornode "github.com/ipfs/go-ipld-cbor"
+	"github.com/stretchr/testify/require"
 	"golang.org/x/xerrors"
 
 	"github.com/ipfs/go-cid"
-	"github.com/stretchr/testify/require"
+	ds "github.com/ipfs/go-datastore"
+	ds_sync "github.com/ipfs/go-datastore/sync"
+	"github.com/ipfs/go-hamt-ipld"
+	bstore "github.com/ipfs/go-ipfs-blockstore"
+	cbornode "github.com/ipfs/go-ipld-cbor"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/go-amt-ipld/v2"
 	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	tutils "github.com/filecoin-project/specs-actors/support/testing"
+
+	"github.com/filecoin-project/lotus/chain/types"
 )
 
 var dummyCid cid.Cid
@@ -62,104 +66,303 @@ func (m mockAPI) setActor(tsk types.TipSetKey, act *types.Actor) {
 	m.ts[tsk] = act
 }
 
-func TestPredicates(t *testing.T) {
+func TestMarketPredicates(t *testing.T) {
 	ctx := context.Background()
 	bs := bstore.NewBlockstore(ds_sync.MutexWrap(ds.NewMapDatastore()))
 	store := cbornode.NewCborStore(bs)
 
+	oldDeal1 := &market.DealState{
+		SectorStartEpoch: 1,
+		LastUpdatedEpoch: 2,
+		SlashEpoch:       0,
+	}
+	oldDeal2 := &market.DealState{
+		SectorStartEpoch: 4,
+		LastUpdatedEpoch: 5,
+		SlashEpoch:       0,
+	}
 	oldDeals := map[abi.DealID]*market.DealState{
-		abi.DealID(1): {
-			SectorStartEpoch: 1,
-			LastUpdatedEpoch: 2,
-			SlashEpoch:       0,
-		},
-		abi.DealID(2): {
-			SectorStartEpoch: 4,
-			LastUpdatedEpoch: 5,
-			SlashEpoch:       0,
-		},
+		abi.DealID(1): oldDeal1,
+		abi.DealID(2): oldDeal2,
 	}
-	oldStateC := createMarketState(ctx, t, store, oldDeals)
 
+	oldProp1 := &market.DealProposal{
+		PieceCID:             dummyCid,
+		PieceSize:            0,
+		VerifiedDeal:         false,
+		Client:               tutils.NewIDAddr(t, 1),
+		Provider:             tutils.NewIDAddr(t, 1),
+		StartEpoch:           1,
+		EndEpoch:             2,
+		StoragePricePerEpoch: big.Zero(),
+		ProviderCollateral:   big.Zero(),
+		ClientCollateral:     big.Zero(),
+	}
+	oldProp2 := &market.DealProposal{
+		PieceCID:             dummyCid,
+		PieceSize:            0,
+		VerifiedDeal:         false,
+		Client:               tutils.NewIDAddr(t, 1),
+		Provider:             tutils.NewIDAddr(t, 1),
+		StartEpoch:           2,
+		EndEpoch:             3,
+		StoragePricePerEpoch: big.Zero(),
+		ProviderCollateral:   big.Zero(),
+		ClientCollateral:     big.Zero(),
+	}
+	oldProps := map[abi.DealID]*market.DealProposal{
+		abi.DealID(1): oldProp1,
+		abi.DealID(2): oldProp2,
+	}
+
+	oldStateC := createMarketState(ctx, t, store, oldDeals, oldProps)
+
+	newDeal1 := &market.DealState{
+		SectorStartEpoch: 1,
+		LastUpdatedEpoch: 3,
+		SlashEpoch:       0,
+	}
+	newDeal2 := &market.DealState{
+		SectorStartEpoch: 4,
+		LastUpdatedEpoch: 6,
+		SlashEpoch:       6,
+	}
+	// added
+	newDeal3 := &market.DealState{
+		SectorStartEpoch: 1,
+		LastUpdatedEpoch: 2,
+		SlashEpoch:       3,
+	}
 	newDeals := map[abi.DealID]*market.DealState{
-		abi.DealID(1): {
-			SectorStartEpoch: 1,
-			LastUpdatedEpoch: 3,
-			SlashEpoch:       0,
-		},
-		abi.DealID(2): {
-			SectorStartEpoch: 4,
-			LastUpdatedEpoch: 6,
-			SlashEpoch:       6,
-		},
+		abi.DealID(1): newDeal1,
+		abi.DealID(2): newDeal2,
+		abi.DealID(3): newDeal3,
 	}
-	newStateC := createMarketState(ctx, t, store, newDeals)
 
-	miner, err := address.NewFromString("t00")
+	// added
+	newProp3 := &market.DealProposal{
+		PieceCID:             dummyCid,
+		PieceSize:            0,
+		VerifiedDeal:         false,
+		Client:               tutils.NewIDAddr(t, 1),
+		Provider:             tutils.NewIDAddr(t, 1),
+		StartEpoch:           4,
+		EndEpoch:             4,
+		StoragePricePerEpoch: big.Zero(),
+		ProviderCollateral:   big.Zero(),
+		ClientCollateral:     big.Zero(),
+	}
+	newProps := map[abi.DealID]*market.DealProposal{
+		abi.DealID(1): oldProp1, // 1 was persisted
+		// prop 2 was removed
+		abi.DealID(3): newProp3, // new
+		// NB: DealProposals cannot be modified, so don't test that case.
+	}
+	newStateC := createMarketState(ctx, t, store, newDeals, newProps)
+
+	minerAddr, err := address.NewFromString("t00")
 	require.NoError(t, err)
-	oldState, err := mockTipset(miner, 1)
+	oldState, err := mockTipset(minerAddr, 1)
 	require.NoError(t, err)
-	newState, err := mockTipset(miner, 2)
+	newState, err := mockTipset(minerAddr, 2)
 	require.NoError(t, err)
 
 	api := newMockAPI(bs)
 	api.setActor(oldState.Key(), &types.Actor{Head: oldStateC})
 	api.setActor(newState.Key(), &types.Actor{Head: newStateC})
 
-	preds := NewStatePredicates(api)
+	t.Run("deal ID predicate", func(t *testing.T) {
+		preds := NewStatePredicates(api)
 
-	dealIds := []abi.DealID{abi.DealID(1), abi.DealID(2)}
-	diffFn := preds.OnStorageMarketActorChanged(preds.OnDealStateChanged(preds.DealStateChangedForIDs(dealIds)))
+		dealIds := []abi.DealID{abi.DealID(1), abi.DealID(2)}
+		diffIDFn := preds.OnStorageMarketActorChanged(preds.OnDealStateChanged(preds.DealStateChangedForIDs(dealIds)))
 
-	// Diff a state against itself: expect no change
-	changed, _, err := diffFn(ctx, oldState, oldState)
-	require.NoError(t, err)
-	require.False(t, changed)
+		// Diff a state against itself: expect no change
+		changed, _, err := diffIDFn(ctx, oldState.Key(), oldState.Key())
+		require.NoError(t, err)
+		require.False(t, changed)
 
-	// Diff old state against new state
-	changed, val, err := diffFn(ctx, oldState, newState)
-	require.NoError(t, err)
-	require.True(t, changed)
+		// Diff old state against new state
+		changed, valIDs, err := diffIDFn(ctx, oldState.Key(), newState.Key())
+		require.NoError(t, err)
+		require.True(t, changed)
 
-	changedDeals, ok := val.(ChangedDeals)
-	require.True(t, ok)
-	require.Len(t, changedDeals, 2)
-	require.Contains(t, changedDeals, abi.DealID(1))
-	require.Contains(t, changedDeals, abi.DealID(2))
-	deal1 := changedDeals[abi.DealID(1)]
-	if deal1.From.LastUpdatedEpoch != 2 || deal1.To.LastUpdatedEpoch != 3 {
-		t.Fatal("Unexpected change to LastUpdatedEpoch")
-	}
-	deal2 := changedDeals[abi.DealID(2)]
-	if deal2.From.SlashEpoch != 0 || deal2.To.SlashEpoch != 6 {
-		t.Fatal("Unexpected change to SlashEpoch")
-	}
+		changedDealIDs, ok := valIDs.(ChangedDeals)
+		require.True(t, ok)
+		require.Len(t, changedDealIDs, 2)
+		require.Contains(t, changedDealIDs, abi.DealID(1))
+		require.Contains(t, changedDealIDs, abi.DealID(2))
+		deal1 := changedDealIDs[abi.DealID(1)]
+		if deal1.From.LastUpdatedEpoch != 2 || deal1.To.LastUpdatedEpoch != 3 {
+			t.Fatal("Unexpected change to LastUpdatedEpoch")
+		}
+		deal2 := changedDealIDs[abi.DealID(2)]
+		if deal2.From.SlashEpoch != 0 || deal2.To.SlashEpoch != 6 {
+			t.Fatal("Unexpected change to SlashEpoch")
+		}
 
-	// Test that OnActorStateChanged does not call the callback if the state has not changed
-	mockAddr, err := address.NewFromString("t01")
-	require.NoError(t, err)
-	actorDiffFn := preds.OnActorStateChanged(mockAddr, func(context.Context, cid.Cid, cid.Cid) (bool, UserData, error) {
-		t.Fatal("No state change so this should not be called")
-		return false, nil, nil
+		// Test that OnActorStateChanged does not call the callback if the state has not changed
+		mockAddr, err := address.NewFromString("t01")
+		require.NoError(t, err)
+		actorDiffFn := preds.OnActorStateChanged(mockAddr, func(context.Context, cid.Cid, cid.Cid) (bool, UserData, error) {
+			t.Fatal("No state change so this should not be called")
+			return false, nil, nil
+		})
+		changed, _, err = actorDiffFn(ctx, oldState.Key(), oldState.Key())
+		require.NoError(t, err)
+		require.False(t, changed)
+
+		// Test that OnDealStateChanged does not call the callback if the state has not changed
+		diffDealStateFn := preds.OnDealStateChanged(func(context.Context, *adt.Array, *adt.Array) (bool, UserData, error) {
+			t.Fatal("No state change so this should not be called")
+			return false, nil, nil
+		})
+		marketState := createEmptyMarketState(t, store)
+		changed, _, err = diffDealStateFn(ctx, marketState, marketState)
+		require.NoError(t, err)
+		require.False(t, changed)
 	})
-	changed, _, err = actorDiffFn(ctx, oldState, oldState)
-	require.NoError(t, err)
-	require.False(t, changed)
 
-	// Test that OnDealStateChanged does not call the callback if the state has not changed
-	diffDealStateFn := preds.OnDealStateChanged(func(context.Context, *amt.Root, *amt.Root) (bool, UserData, error) {
-		t.Fatal("No state change so this should not be called")
-		return false, nil, nil
+	t.Run("deal state array predicate", func(t *testing.T) {
+		preds := NewStatePredicates(api)
+		diffArrFn := preds.OnStorageMarketActorChanged(preds.OnDealStateChanged(preds.OnDealStateAmtChanged()))
+
+		changed, _, err := diffArrFn(ctx, oldState.Key(), oldState.Key())
+		require.NoError(t, err)
+		require.False(t, changed)
+
+		changed, valArr, err := diffArrFn(ctx, oldState.Key(), newState.Key())
+		require.NoError(t, err)
+		require.True(t, changed)
+
+		changedDeals, ok := valArr.(*MarketDealStateChanges)
+		require.True(t, ok)
+		require.Len(t, changedDeals.Added, 1)
+		require.Equal(t, abi.DealID(3), changedDeals.Added[0].ID)
+		require.Equal(t, *newDeal3, changedDeals.Added[0].Deal)
+
+		require.Len(t, changedDeals.Removed, 0)
+
+		require.Len(t, changedDeals.Modified, 2)
+		require.Equal(t, abi.DealID(1), changedDeals.Modified[0].ID)
+		require.Equal(t, newDeal1, changedDeals.Modified[0].To)
+		require.Equal(t, oldDeal1, changedDeals.Modified[0].From)
+
+		require.Equal(t, abi.DealID(2), changedDeals.Modified[1].ID)
+		require.Equal(t, oldDeal2, changedDeals.Modified[1].From)
+		require.Equal(t, newDeal2, changedDeals.Modified[1].To)
+	})
+
+	t.Run("deal proposal array predicate", func(t *testing.T) {
+		preds := NewStatePredicates(api)
+		diffArrFn := preds.OnStorageMarketActorChanged(preds.OnDealProposalChanged(preds.OnDealProposalAmtChanged()))
+		changed, _, err := diffArrFn(ctx, oldState.Key(), oldState.Key())
+		require.NoError(t, err)
+		require.False(t, changed)
+
+		changed, valArr, err := diffArrFn(ctx, oldState.Key(), newState.Key())
+		require.NoError(t, err)
+		require.True(t, changed)
+
+		changedProps, ok := valArr.(*MarketDealProposalChanges)
+		require.True(t, ok)
+		require.Len(t, changedProps.Added, 1)
+		require.Equal(t, abi.DealID(3), changedProps.Added[0].ID)
+		require.Equal(t, *newProp3, changedProps.Added[0].Proposal)
+
+		// proposals cannot be modified -- no modified testing
+
+		require.Len(t, changedProps.Removed, 1)
+		require.Equal(t, abi.DealID(2), changedProps.Removed[0].ID)
+		require.Equal(t, *oldProp2, changedProps.Removed[0].Proposal)
 	})
-	marketState := createEmptyMarketState(t, store)
-	changed, _, err = diffDealStateFn(ctx, marketState, marketState)
-	require.NoError(t, err)
-	require.False(t, changed)
 }
 
-func mockTipset(miner address.Address, timestamp uint64) (*types.TipSet, error) {
+func TestMinerSectorChange(t *testing.T) {
+	ctx := context.Background()
+	bs := bstore.NewBlockstore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+	store := cbornode.NewCborStore(bs)
+
+	nextID := uint64(0)
+	nextIDAddrF := func() address.Address {
+		defer func() { nextID++ }()
+		return tutils.NewIDAddr(t, nextID)
+	}
+
+	owner, worker := nextIDAddrF(), nextIDAddrF()
+	si0 := newSectorOnChainInfo(0, tutils.MakeCID("0"), big.NewInt(0), abi.ChainEpoch(0), abi.ChainEpoch(10))
+	si1 := newSectorOnChainInfo(1, tutils.MakeCID("1"), big.NewInt(1), abi.ChainEpoch(1), abi.ChainEpoch(11))
+	si2 := newSectorOnChainInfo(2, tutils.MakeCID("2"), big.NewInt(2), abi.ChainEpoch(2), abi.ChainEpoch(11))
+	oldMinerC := createMinerState(ctx, t, store, owner, worker, []miner.SectorOnChainInfo{si0, si1, si2})
+
+	si3 := newSectorOnChainInfo(3, tutils.MakeCID("3"), big.NewInt(3), abi.ChainEpoch(3), abi.ChainEpoch(12))
+	// 0 delete
+	// 1 extend
+	// 2 same
+	// 3 added
+	si1Ext := si1
+	si1Ext.Info.Expiration++
+	newMinerC := createMinerState(ctx, t, store, owner, worker, []miner.SectorOnChainInfo{si1Ext, si2, si3})
+
+	minerAddr := nextIDAddrF()
+	oldState, err := mockTipset(minerAddr, 1)
+	require.NoError(t, err)
+	newState, err := mockTipset(minerAddr, 2)
+	require.NoError(t, err)
+
+	api := newMockAPI(bs)
+	api.setActor(oldState.Key(), &types.Actor{Head: oldMinerC})
+	api.setActor(newState.Key(), &types.Actor{Head: newMinerC})
+
+	preds := NewStatePredicates(api)
+
+	minerDiffFn := preds.OnMinerActorChange(minerAddr, preds.OnMinerSectorChange())
+	change, val, err := minerDiffFn(ctx, oldState.Key(), newState.Key())
+	require.NoError(t, err)
+	require.True(t, change)
+	require.NotNil(t, val)
+
+	sectorChanges, ok := val.(*MinerSectorChanges)
+	require.True(t, ok)
+
+	require.Equal(t, len(sectorChanges.Added), 1)
+	require.Equal(t, 1, len(sectorChanges.Added))
+	require.Equal(t, si3, sectorChanges.Added[0])
+
+	require.Equal(t, 1, len(sectorChanges.Removed))
+	require.Equal(t, si0, sectorChanges.Removed[0])
+
+	require.Equal(t, 1, len(sectorChanges.Extended))
+	require.Equal(t, si1, sectorChanges.Extended[0].From)
+	require.Equal(t, si1Ext, sectorChanges.Extended[0].To)
+
+	change, val, err = minerDiffFn(ctx, oldState.Key(), oldState.Key())
+	require.NoError(t, err)
+	require.False(t, change)
+	require.Nil(t, val)
+
+	change, val, err = minerDiffFn(ctx, newState.Key(), oldState.Key())
+	require.NoError(t, err)
+	require.True(t, change)
+	require.NotNil(t, val)
+
+	sectorChanges, ok = val.(*MinerSectorChanges)
+	require.True(t, ok)
+
+	require.Equal(t, 1, len(sectorChanges.Added))
+	require.Equal(t, si0, sectorChanges.Added[0])
+
+	require.Equal(t, 1, len(sectorChanges.Removed))
+	require.Equal(t, si3, sectorChanges.Removed[0])
+
+	require.Equal(t, 1, len(sectorChanges.Extended))
+	require.Equal(t, si1, sectorChanges.Extended[0].To)
+	require.Equal(t, si1Ext, sectorChanges.Extended[0].From)
+}
+
+func mockTipset(minerAddr address.Address, timestamp uint64) (*types.TipSet, error) {
 	return types.NewTipSet([]*types.BlockHeader{{
-		Miner:                 miner,
+		Miner:                 minerAddr,
 		Height:                5,
 		ParentStateRoot:       dummyCid,
 		Messages:              dummyCid,
@@ -170,11 +373,13 @@ func mockTipset(miner address.Address, timestamp uint64) (*types.TipSet, error)
 	}})
 }
 
-func createMarketState(ctx context.Context, t *testing.T, store *cbornode.BasicIpldStore, deals map[abi.DealID]*market.DealState) cid.Cid {
-	rootCid := createAMT(ctx, t, store, deals)
+func createMarketState(ctx context.Context, t *testing.T, store *cbornode.BasicIpldStore, deals map[abi.DealID]*market.DealState, props map[abi.DealID]*market.DealProposal) cid.Cid {
+	dealRootCid := createDealAMT(ctx, t, store, deals)
+	propRootCid := createProposalAMT(ctx, t, store, props)
 
 	state := createEmptyMarketState(t, store)
-	state.States = rootCid
+	state.States = dealRootCid
+	state.Proposals = propRootCid
 
 	stateC, err := store.Put(ctx, state)
 	require.NoError(t, err)
@@ -189,7 +394,7 @@ func createEmptyMarketState(t *testing.T, store *cbornode.BasicIpldStore) *marke
 	return market.ConstructState(emptyArrayCid, emptyMap, emptyMap)
 }
 
-func createAMT(ctx context.Context, t *testing.T, store *cbornode.BasicIpldStore, deals map[abi.DealID]*market.DealState) cid.Cid {
+func createDealAMT(ctx context.Context, t *testing.T, store *cbornode.BasicIpldStore, deals map[abi.DealID]*market.DealState) cid.Cid {
 	root := amt.NewAMT(store)
 	for dealID, dealState := range deals {
 		err := root.Set(ctx, uint64(dealID), dealState)
@@ -199,3 +404,80 @@ func createAMT(ctx context.Context, t *testing.T, store *cbornode.BasicIpldStore
 	require.NoError(t, err)
 	return rootCid
 }
+
+func createProposalAMT(ctx context.Context, t *testing.T, store *cbornode.BasicIpldStore, props map[abi.DealID]*market.DealProposal) cid.Cid {
+	root := amt.NewAMT(store)
+	for dealID, prop := range props {
+		err := root.Set(ctx, uint64(dealID), prop)
+		require.NoError(t, err)
+	}
+	rootCid, err := root.Flush(ctx)
+	require.NoError(t, err)
+	return rootCid
+}
+
+func createMinerState(ctx context.Context, t *testing.T, store *cbornode.BasicIpldStore, owner, worker address.Address, sectors []miner.SectorOnChainInfo) cid.Cid {
+	rootCid := createSectorsAMT(ctx, t, store, sectors)
+
+	state := createEmptyMinerState(ctx, t, store, owner, worker)
+	state.Sectors = rootCid
+
+	stateC, err := store.Put(ctx, state)
+	require.NoError(t, err)
+	return stateC
+}
+
+func createEmptyMinerState(ctx context.Context, t *testing.T, store *cbornode.BasicIpldStore, owner, worker address.Address) *miner.State {
+	emptyArrayCid, err := amt.NewAMT(store).Flush(context.TODO())
+	require.NoError(t, err)
+	emptyMap, err := store.Put(context.TODO(), hamt.NewNode(store, hamt.UseTreeBitWidth(5)))
+	require.NoError(t, err)
+
+	emptyDeadlines := miner.ConstructDeadlines()
+	emptyDeadlinesCid, err := store.Put(context.Background(), emptyDeadlines)
+	require.NoError(t, err)
+
+	state, err := miner.ConstructState(emptyArrayCid, emptyMap, emptyDeadlinesCid, owner, worker, abi.PeerID{'1'}, nil, abi.RegisteredSealProof_StackedDrg64GiBV1, 0)
+	require.NoError(t, err)
+	return state
+
+}
+
+func createSectorsAMT(ctx context.Context, t *testing.T, store *cbornode.BasicIpldStore, sectors []miner.SectorOnChainInfo) cid.Cid {
+	root := amt.NewAMT(store)
+	for _, sector := range sectors {
+		sector := sector
+		err := root.Set(ctx, uint64(sector.Info.SectorNumber), &sector)
+		require.NoError(t, err)
+	}
+	rootCid, err := root.Flush(ctx)
+	require.NoError(t, err)
+	return rootCid
+}
+
+// returns a unique SectorOnChainInfo with each invocation with SectorNumber set to `sectorNo`.
+func newSectorOnChainInfo(sectorNo abi.SectorNumber, sealed cid.Cid, weight big.Int, activation, expiration abi.ChainEpoch) miner.SectorOnChainInfo {
+	info := newSectorPreCommitInfo(sectorNo, sealed, expiration)
+	return miner.SectorOnChainInfo{
+		Info:               *info,
+		ActivationEpoch:    activation,
+		DealWeight:         weight,
+		VerifiedDealWeight: weight,
+	}
+}
+
+const (
+	sectorSealRandEpochValue = abi.ChainEpoch(1)
+)
+
+// returns a unique SectorPreCommitInfo with each invocation with SectorNumber set to `sectorNo`.
+func newSectorPreCommitInfo(sectorNo abi.SectorNumber, sealed cid.Cid, expiration abi.ChainEpoch) *miner.SectorPreCommitInfo {
+	return &miner.SectorPreCommitInfo{
+		SealProof:     abi.RegisteredSealProof_StackedDrg32GiBV1,
+		SectorNumber:  sectorNo,
+		SealedCID:     sealed,
+		SealRandEpoch: sectorSealRandEpochValue,
+		DealIDs:       nil,
+		Expiration:    expiration,
+	}
+}

chain/gen/gen.go

@@ -145,7 +145,7 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 		return nil, err
 	}
 
-	genm1, k1, err := seed.PreSeal(maddr1, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, numSectors, m1temp, []byte("some randomness"), nil)
+	genm1, k1, err := seed.PreSeal(maddr1, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, numSectors, m1temp, []byte("some randomness"), nil, true)
 	if err != nil {
 		return nil, err
 	}
@@ -157,7 +157,7 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 		return nil, err
 	}
 
-	genm2, k2, err := seed.PreSeal(maddr2, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, numSectors, m2temp, []byte("some randomness"), nil)
+	genm2, k2, err := seed.PreSeal(maddr2, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, numSectors, m2temp, []byte("some randomness"), nil, true)
 	if err != nil {
 		return nil, err
 	}

chain/stmgr/utils.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"os"
+	"reflect"
 
 	cid "github.com/ipfs/go-cid"
 	blockstore "github.com/ipfs/go-ipfs-blockstore"
@@ -17,10 +18,16 @@ import (
 	"github.com/filecoin-project/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/account"
+	"github.com/filecoin-project/specs-actors/actors/builtin/cron"
 	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	"github.com/filecoin-project/specs-actors/actors/builtin/market"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
+	"github.com/filecoin-project/specs-actors/actors/builtin/reward"
+	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 	"github.com/filecoin-project/specs-actors/actors/crypto"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 
@@ -38,7 +45,7 @@ func GetNetworkName(ctx context.Context, sm *StateManager, st cid.Cid) (dtypes.N
 	var state init_.State
 	_, err := sm.LoadActorStateRaw(ctx, builtin.InitActorAddr, &state, st)
 	if err != nil {
-		return "", xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
+		return "", xerrors.Errorf("(get sset) failed to load init actor state: %w", err)
 	}
 
 	return dtypes.NetworkName(state.NetworkName), nil
@@ -578,3 +585,60 @@ func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcn beacon.RandomBe
 		BeaconEntries:   entries,
 	}, nil
 }
+
+type methodMeta struct {
+	Name string
+
+	Params reflect.Type
+	Ret    reflect.Type
+}
+
+var MethodsMap = map[cid.Cid][]methodMeta{}
+
+func init() {
+	cidToMethods := map[cid.Cid][2]interface{}{
+		// builtin.SystemActorCodeID:        {builtin.MethodsSystem, system.Actor{} }- apparently it doesn't have methods
+		builtin.InitActorCodeID:             {builtin.MethodsInit, init_.Actor{}},
+		builtin.CronActorCodeID:             {builtin.MethodsCron, cron.Actor{}},
+		builtin.AccountActorCodeID:          {builtin.MethodsAccount, account.Actor{}},
+		builtin.StoragePowerActorCodeID:     {builtin.MethodsPower, power.Actor{}},
+		builtin.StorageMinerActorCodeID:     {builtin.MethodsMiner, miner.Actor{}},
+		builtin.StorageMarketActorCodeID:    {builtin.MethodsMarket, market.Actor{}},
+		builtin.PaymentChannelActorCodeID:   {builtin.MethodsPaych, paych.Actor{}},
+		builtin.MultisigActorCodeID:         {builtin.MethodsMultisig, multisig.Actor{}},
+		builtin.RewardActorCodeID:           {builtin.MethodsReward, reward.Actor{}},
+		builtin.VerifiedRegistryActorCodeID: {builtin.MethodsVerifiedRegistry, verifreg.Actor{}},
+	}
+
+	for c, m := range cidToMethods {
+		rt := reflect.TypeOf(m[0])
+		nf := rt.NumField()
+
+		MethodsMap[c] = append(MethodsMap[c], methodMeta{
+			Name:   "Send",
+			Params: reflect.TypeOf(new(adt.EmptyValue)),
+			Ret:    reflect.TypeOf(new(adt.EmptyValue)),
+		})
+
+		exports := m[1].(abi.Invokee).Exports()
+		for i := 0; i < nf; i++ {
+			export := reflect.TypeOf(exports[i+1])
+
+			MethodsMap[c] = append(MethodsMap[c], methodMeta{
+				Name:   rt.Field(i).Name,
+				Params: export.In(1),
+				Ret:    export.Out(0),
+			})
+		}
+	}
+}
+
+func GetReturnType(ctx context.Context, sm *StateManager, to address.Address, method abi.MethodNum, ts *types.TipSet) (cbg.CBORUnmarshaler, error) {
+	act, err := sm.GetActor(to, ts)
+	if err != nil {
+		return nil, err
+	}
+
+	m := MethodsMap[act.Code][method]
+	return reflect.New(m.Ret.Elem()).Interface().(cbg.CBORUnmarshaler), nil
+}

chain/store/store.go

@@ -20,6 +20,7 @@ import (
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/journal"
 	"github.com/filecoin-project/lotus/metrics"
 	"go.opencensus.io/stats"
 	"go.opencensus.io/trace"
@@ -324,6 +325,14 @@ func (cs *ChainStore) reorgWorker(ctx context.Context, initialNotifees []ReorgNo
 					continue
 				}
 
+				journal.Add("sync", map[string]interface{}{
+					"op":    "headChange",
+					"from":  r.old.Key(),
+					"to":    r.new.Key(),
+					"rev":   len(revert),
+					"apply": len(apply),
+				})
+
 				// reverse the apply array
 				for i := len(apply)/2 - 1; i >= 0; i-- {
 					opp := len(apply) - 1 - i

chain/sync.go

@@ -349,6 +349,10 @@ func zipTipSetAndMessages(bs cbor.IpldStore, ts *types.TipSet, allbmsgs []*types
 
 	fts := &store.FullTipSet{}
 	for bi, b := range ts.Blocks() {
+		if msgc := len(bmi[bi]) + len(smi[bi]); msgc > build.BlockMessageLimit {
+			return nil, fmt.Errorf("block %q has too many messages (%d)", b.Cid(), msgc)
+		}
+
 		var smsgs []*types.SignedMessage
 		var smsgCids []cbg.CBORMarshaler
 		for _, m := range smi[bi] {
@@ -365,10 +369,6 @@ func zipTipSetAndMessages(bs cbor.IpldStore, ts *types.TipSet, allbmsgs []*types
 			bmsgCids = append(bmsgCids, &c)
 		}
 
-		if msgc := len(bmsgCids) + len(smsgCids); msgc > build.BlockMessageLimit {
-			return nil, fmt.Errorf("block %q has too many messages (%d)", b.Cid(), msgc)
-		}
-
 		mrcid, err := computeMsgMeta(bs, bmsgCids, smsgCids)
 		if err != nil {
 			return nil, err
@@ -536,7 +536,7 @@ func (syncer *Syncer) ValidateTipSet(ctx context.Context, fts *store.FullTipSet)
 		futures = append(futures, async.Err(func() error {
 			if err := syncer.ValidateBlock(ctx, b); err != nil {
 				if isPermanent(err) {
-					syncer.bad.Add(b.Cid(), err.Error())
+					syncer.bad.Add(b.Cid(), NewBadBlockReason([]cid.Cid{b.Cid()}, err.Error()))
 				}
 				return xerrors.Errorf("validating block %s: %w", b.Cid(), err)
 			}
@@ -1069,17 +1069,14 @@ func extractSyncState(ctx context.Context) *SyncerState {
 
 // collectHeaders collects the headers from the blocks between any two tipsets.
 //
-// `from` is the heaviest/projected/target tipset we have learned about, and
-// `to` is usually an anchor tipset we already have in our view of the chain
+// `incoming` is the heaviest/projected/target tipset we have learned about, and
+// `known` is usually an anchor tipset we already have in our view of the chain
 // (which could be the genesis).
 //
 // collectHeaders checks if portions of the chain are in our ChainStore; falling
 // down to the network to retrieve the missing parts. If during the process, any
 // portion we receive is in our denylist (bad list), we short-circuit.
 //
-// {hint/naming}: `from` and `to` is in inverse order. `from` is the highest,
-// and `to` is the lowest. This method traverses the chain backwards.
-//
 // {hint/usage}: This is used by collectChain, which is in turn called from the
 // main Sync method (Syncer#Sync), so it's a pretty central method.
 //
@@ -1089,7 +1086,7 @@ func extractSyncState(ctx context.Context) *SyncerState {
 //     bad.
 //  2. Check the consistency of beacon entries in the from tipset. We check
 //     total equality of the BeaconEntries in each block.
-//  3. Travers the chain backwards, for each tipset:
+//  3. Traverse the chain backwards, for each tipset:
 //  	3a. Load it from the chainstore; if found, it move on to its parent.
 //      3b. Query our peers via BlockSync in batches, requesting up to a
 //      maximum of 500 tipsets every time.
@@ -1100,43 +1097,40 @@ func extractSyncState(ctx context.Context) *SyncerState {
 //
 // All throughout the process, we keep checking if the received blocks are in
 // the deny list, and short-circuit the process if so.
-func (syncer *Syncer) collectHeaders(ctx context.Context, from *types.TipSet, to *types.TipSet) ([]*types.TipSet, error) {
+func (syncer *Syncer) collectHeaders(ctx context.Context, incoming *types.TipSet, known *types.TipSet) ([]*types.TipSet, error) {
 	ctx, span := trace.StartSpan(ctx, "collectHeaders")
 	defer span.End()
 	ss := extractSyncState(ctx)
 
 	span.AddAttributes(
-		trace.Int64Attribute("fromHeight", int64(from.Height())),
-		trace.Int64Attribute("toHeight", int64(to.Height())),
+		trace.Int64Attribute("incomingHeight", int64(incoming.Height())),
+		trace.Int64Attribute("knownHeight", int64(known.Height())),
 	)
 
-	markBad := func(fmts string, args ...interface{}) {
-		for _, b := range from.Cids() {
-			syncer.bad.Add(b, fmt.Sprintf(fmts, args...))
-		}
-	}
-
 	// Check if the parents of the from block are in the denylist.
 	// i.e. if a fork of the chain has been requested that we know to be bad.
-	for _, pcid := range from.Parents().Cids() {
+	for _, pcid := range incoming.Parents().Cids() {
 		if reason, ok := syncer.bad.Has(pcid); ok {
-			markBad("linked to %s", pcid)
-			return nil, xerrors.Errorf("chain linked to block marked previously as bad (%s, %s) (reason: %s)", from.Cids(), pcid, reason)
+			newReason := reason.Linked("linked to %s", pcid)
+			for _, b := range incoming.Cids() {
+				syncer.bad.Add(b, newReason)
+			}
+			return nil, xerrors.Errorf("chain linked to block marked previously as bad (%s, %s) (reason: %s)", incoming.Cids(), pcid, reason)
 		}
 	}
 
 	{
 		// ensure consistency of beacon entires
-		targetBE := from.Blocks()[0].BeaconEntries
+		targetBE := incoming.Blocks()[0].BeaconEntries
 		sorted := sort.SliceIsSorted(targetBE, func(i, j int) bool {
 			return targetBE[i].Round < targetBE[j].Round
 		})
 		if !sorted {
-			syncer.bad.Add(from.Cids()[0], "wrong order of beacon entires")
+			syncer.bad.Add(incoming.Cids()[0], NewBadBlockReason(incoming.Cids(), "wrong order of beacon entires"))
 			return nil, xerrors.Errorf("wrong order of beacon entires")
 		}
 
-		for _, bh := range from.Blocks()[1:] {
+		for _, bh := range incoming.Blocks()[1:] {
 			if len(targetBE) != len(bh.BeaconEntries) {
 				// cannot mark bad, I think @Kubuxu
 				return nil, xerrors.Errorf("tipset contained different number for beacon entires")
@@ -1151,12 +1145,12 @@ func (syncer *Syncer) collectHeaders(ctx context.Context, from *types.TipSet, to
 		}
 	}
 
-	blockSet := []*types.TipSet{from}
+	blockSet := []*types.TipSet{incoming}
 
-	at := from.Parents()
+	at := incoming.Parents()
 
 	// we want to sync all the blocks until the height above the block we have
-	untilHeight := to.Height() + 1
+	untilHeight := known.Height() + 1
 
 	ss.SetHeight(blockSet[len(blockSet)-1].Height())
 
@@ -1166,11 +1160,12 @@ loop:
 	for blockSet[len(blockSet)-1].Height() > untilHeight {
 		for _, bc := range at.Cids() {
 			if reason, ok := syncer.bad.Has(bc); ok {
+				newReason := reason.Linked("change contained %s", bc)
 				for _, b := range acceptedBlocks {
-					syncer.bad.Add(b, fmt.Sprintf("chain contained %s", bc))
+					syncer.bad.Add(b, newReason)
 				}
 
-				return nil, xerrors.Errorf("chain contained block marked previously as bad (%s, %s) (reason: %s)", from.Cids(), bc, reason)
+				return nil, xerrors.Errorf("chain contained block marked previously as bad (%s, %s) (reason: %s)", incoming.Cids(), bc, reason)
 			}
 		}
 
@@ -1214,11 +1209,12 @@ loop:
 			}
 			for _, bc := range b.Cids() {
 				if reason, ok := syncer.bad.Has(bc); ok {
+					newReason := reason.Linked("change contained %s", bc)
 					for _, b := range acceptedBlocks {
-						syncer.bad.Add(b, fmt.Sprintf("chain contained %s", bc))
+						syncer.bad.Add(b, newReason)
 					}
 
-					return nil, xerrors.Errorf("chain contained block marked previously as bad (%s, %s) (reason: %s)", from.Cids(), bc, reason)
+					return nil, xerrors.Errorf("chain contained block marked previously as bad (%s, %s) (reason: %s)", incoming.Cids(), bc, reason)
 				}
 			}
 			blockSet = append(blockSet, b)
@@ -1230,23 +1226,23 @@ loop:
 		at = blks[len(blks)-1].Parents()
 	}
 
-	if !types.CidArrsEqual(blockSet[len(blockSet)-1].Parents().Cids(), to.Cids()) {
-		last := blockSet[len(blockSet)-1]
-		if last.Parents() == to.Parents() {
+	// base is the tipset in the candidate chain at the height equal to our known tipset height.
+	if base := blockSet[len(blockSet)-1]; !types.CidArrsEqual(base.Parents().Cids(), known.Cids()) {
+		if base.Parents() == known.Parents() {
 			// common case: receiving a block thats potentially part of the same tipset as our best block
 			return blockSet, nil
 		}
 
 		// We have now ascertained that this is *not* a 'fast forward'
 
-		log.Warnf("(fork detected) synced header chain (%s - %d) does not link to our best block (%s - %d)", from.Cids(), from.Height(), to.Cids(), to.Height())
-		fork, err := syncer.syncFork(ctx, last, to)
+		log.Warnf("(fork detected) synced header chain (%s - %d) does not link to our best block (%s - %d)", incoming.Cids(), incoming.Height(), known.Cids(), known.Height())
+		fork, err := syncer.syncFork(ctx, base, known)
 		if err != nil {
 			if xerrors.Is(err, ErrForkTooLong) {
 				// TODO: we're marking this block bad in the same way that we mark invalid blocks bad. Maybe distinguish?
 				log.Warn("adding forked chain to our bad tipset cache")
-				for _, b := range from.Blocks() {
-					syncer.bad.Add(b.Cid(), "fork past finality")
+				for _, b := range incoming.Blocks() {
+					syncer.bad.Add(b.Cid(), NewBadBlockReason(incoming.Cids(), "fork past finality"))
 				}
 			}
 			return nil, xerrors.Errorf("failed to sync fork: %w", err)
@@ -1266,13 +1262,13 @@ var ErrForkTooLong = fmt.Errorf("fork longer than threshold")
 // If the fork is too long (build.ForkLengthThreshold), we add the entire subchain to the
 // denylist. Else, we find the common ancestor, and add the missing chain
 // fragment until the fork point to the returned []TipSet.
-func (syncer *Syncer) syncFork(ctx context.Context, from *types.TipSet, to *types.TipSet) ([]*types.TipSet, error) {
-	tips, err := syncer.Bsync.GetBlocks(ctx, from.Parents(), int(build.ForkLengthThreshold))
+func (syncer *Syncer) syncFork(ctx context.Context, incoming *types.TipSet, known *types.TipSet) ([]*types.TipSet, error) {
+	tips, err := syncer.Bsync.GetBlocks(ctx, incoming.Parents(), int(build.ForkLengthThreshold))
 	if err != nil {
 		return nil, err
 	}
 
-	nts, err := syncer.store.LoadTipSet(to.Parents())
+	nts, err := syncer.store.LoadTipSet(known.Parents())
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load next local tipset: %w", err)
 	}
@@ -1282,7 +1278,7 @@ func (syncer *Syncer) syncFork(ctx context.Context, from *types.TipSet, to *type
 			if !syncer.Genesis.Equals(nts) {
 				return nil, xerrors.Errorf("somehow synced chain that linked back to a different genesis (bad genesis: %s)", nts.Key())
 			}
-			return nil, xerrors.Errorf("synced chain forked at genesis, refusing to sync")
+			return nil, xerrors.Errorf("synced chain forked at genesis, refusing to sync; incoming: %s")
 		}
 
 		if nts.Equals(tips[cur]) {
@@ -1499,12 +1495,14 @@ func (syncer *Syncer) State() []SyncerState {
 
 // MarkBad manually adds a block to the "bad blocks" cache.
 func (syncer *Syncer) MarkBad(blk cid.Cid) {
-	syncer.bad.Add(blk, "manually marked bad")
+	syncer.bad.Add(blk, NewBadBlockReason([]cid.Cid{blk}, "manually marked bad"))
 }
 
 func (syncer *Syncer) CheckBadBlockCache(blk cid.Cid) (string, bool) {
-	return syncer.bad.Has(blk)
+	bbr, ok := syncer.bad.Has(blk)
+	return bbr.String(), ok
 }
+
 func (syncer *Syncer) getLatestBeaconEntry(_ context.Context, ts *types.TipSet) (*types.BeaconEntry, error) {
 	cur := ts
 	for i := 0; i < 20; i++ {

chain/types/bigint_test.go

@@ -43,7 +43,7 @@ func TestBigIntSerializationRoundTrip(t *testing.T) {
 
 func TestFilRoundTrip(t *testing.T) {
 	testValues := []string{
-		"0", "1", "1.001", "100.10001", "101100", "5000.01", "5000",
+		"0 FIL", "1 FIL", "1.001 FIL", "100.10001 FIL", "101100 FIL", "5000.01 FIL", "5000 FIL",
 	}
 
 	for _, v := range testValues {

chain/types/fil.go

@@ -13,9 +13,9 @@ type FIL BigInt
 func (f FIL) String() 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) {
@@ -28,14 +28,35 @@ func (f FIL) Format(s fmt.State, ch rune) {
 }
 
 func ParseFIL(s string) (FIL, error) {
+	suffix := strings.TrimLeft(s, ".1234567890")
+	s = s[:len(s)-len(suffix)]
+	var attofil bool
+	if suffix != "" {
+		norm := strings.ToLower(strings.TrimSpace(suffix))
+		switch norm {
+		case "", "fil":
+		case "attofil", "afil":
+			attofil = true
+		default:
+			return FIL{}, fmt.Errorf("unrecognized suffix: %q", suffix)
+		}
+	}
+
 	r, ok := new(big.Rat).SetString(s)
 	if !ok {
 		return FIL{}, fmt.Errorf("failed to parse %q as a decimal number", s)
 	}
 
-	r = r.Mul(r, big.NewRat(int64(build.FilecoinPrecision), 1))
+	if !attofil {
+		r = r.Mul(r, big.NewRat(int64(build.FilecoinPrecision), 1))
+	}
+
 	if !r.IsInt() {
-		return FIL{}, fmt.Errorf("invalid FIL value: %q", s)
+		var pref string
+		if attofil {
+			pref = "atto"
+		}
+		return FIL{}, fmt.Errorf("invalid %sFIL value: %q", pref, s)
 	}
 
 	return FIL{r.Num()}, nil

chain/types/tipset.go

@@ -112,6 +112,10 @@ func NewTipSet(blks []*BlockHeader) (*TipSet, error) {
 			return nil, fmt.Errorf("cannot create tipset with mismatching heights")
 		}
 
+		if len(blks[0].Parents) != len(b.Parents) {
+			return nil, fmt.Errorf("cannot create tipset with mismatching number of parents")
+		}
+
 		for i, cid := range b.Parents {
 			if cid != blks[0].Parents[i] {
 				return nil, fmt.Errorf("cannot create tipset with mismatching parents")

cli/client.go

@@ -84,6 +84,11 @@ var clientImportCmd = &cli.Command{
 		}
 		defer closer()
 		ctx := ReqContext(cctx)
+
+		if cctx.NArg() != 1 {
+			return xerrors.New("expected input path as the only arg")
+		}
+
 		absPath, err := filepath.Abs(cctx.Args().First())
 		if err != nil {
 			return err
@@ -385,8 +390,8 @@ var clientRetrieveCmd = &cli.Command{
 	ArgsUsage: "[dataCid outputPath]",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
-			Name:  "address",
-			Usage: "address to use for transactions",
+			Name:  "from",
+			Usage: "address to send transactions from",
 		},
 		&cli.BoolFlag{
 			Name:  "car",
@@ -411,8 +416,8 @@ var clientRetrieveCmd = &cli.Command{
 		ctx := ReqContext(cctx)
 
 		var payer address.Address
-		if cctx.String("address") != "" {
-			payer, err = address.NewFromString(cctx.String("address"))
+		if cctx.String("from") != "" {
+			payer, err = address.NewFromString(cctx.String("from"))
 		} else {
 			payer, err = fapi.WalletDefaultAddress(ctx)
 		}
@@ -498,7 +503,7 @@ var clientQueryAskCmd = &cli.Command{
 	},
 	Action: func(cctx *cli.Context) error {
 		if cctx.NArg() != 1 {
-			fmt.Println("Usage: query-ask [address]")
+			fmt.Println("Usage: query-ask [minerAddress]")
 			return nil
 		}
 

cli/multisig.go

@@ -6,6 +6,7 @@ import (
 	"encoding/binary"
 	"encoding/hex"
 	"fmt"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	"os"
 	"sort"
 	"strconv"
@@ -30,17 +31,14 @@ import (
 var multisigCmd = &cli.Command{
 	Name:  "msig",
 	Usage: "Interact with a multisig wallet",
-	Flags: []cli.Flag{
-		&cli.StringFlag{
-			Name:  "source",
-			Usage: "specify the account to send propose from",
-		},
-	},
 	Subcommands: []*cli.Command{
 		msigCreateCmd,
 		msigInspectCmd,
 		msigProposeCmd,
 		msigApproveCmd,
+		msigSwapProposeCmd,
+		msigSwapApproveCmd,
+		msigSwapCancelCmd,
 	},
 }
 
@@ -50,7 +48,8 @@ var msigCreateCmd = &cli.Command{
 	ArgsUsage: "[address1 address2 ...]",
 	Flags: []cli.Flag{
 		&cli.Int64Flag{
-			Name: "required",
+			Name:  "required",
+			Usage: "number of required approvals (uses number of signers provided if omitted)",
 		},
 		&cli.StringFlag{
 			Name:  "value",
@@ -58,7 +57,12 @@ var msigCreateCmd = &cli.Command{
 			Value: "0",
 		},
 		&cli.StringFlag{
-			Name:  "sender",
+			Name:  "duration",
+			Usage: "length of the period over which funds unlock",
+			Value: "0",
+		},
+		&cli.StringFlag{
+			Name:  "from",
 			Usage: "account to send the create message from",
 		},
 	},
@@ -70,6 +74,10 @@ var msigCreateCmd = &cli.Command{
 		defer closer()
 		ctx := ReqContext(cctx)
 
+		if cctx.Args().Len() < 1 {
+			return fmt.Errorf("multisigs must have at least one signer")
+		}
+
 		var addrs []address.Address
 		for _, a := range cctx.Args().Slice() {
 			addr, err := address.NewFromString(a)
@@ -81,7 +89,7 @@ var msigCreateCmd = &cli.Command{
 
 		// get the address we're going to use to create the multisig (can be one of the above, as long as they have funds)
 		var sendAddr address.Address
-		if send := cctx.String("sender"); send == "" {
+		if send := cctx.String("from"); send == "" {
 			defaddr, err := api.WalletDefaultAddress(ctx)
 			if err != nil {
 				return err
@@ -110,9 +118,11 @@ var msigCreateCmd = &cli.Command{
 			required = int64(len(addrs))
 		}
 
+		d := abi.ChainEpoch(cctx.Uint64("duration"))
+
 		gp := types.NewInt(1)
 
-		msgCid, err := api.MsigCreate(ctx, required, addrs, intVal, sendAddr, gp)
+		msgCid, err := api.MsigCreate(ctx, required, addrs, d, intVal, sendAddr, gp)
 		if err != nil {
 			return err
 		}
@@ -264,7 +274,7 @@ var msigProposeCmd = &cli.Command{
 	ArgsUsage: "[multisigAddress destinationAddress value <methodId methodParams> (optional)]",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
-			Name:  "source",
+			Name:  "from",
 			Usage: "account to send the propose message from",
 		},
 	},
@@ -316,8 +326,8 @@ var msigProposeCmd = &cli.Command{
 		}
 
 		var from address.Address
-		if cctx.IsSet("source") {
-			f, err := address.NewFromString(cctx.String("source"))
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
 			if err != nil {
 				return err
 			}
@@ -363,7 +373,7 @@ var msigApproveCmd = &cli.Command{
 	ArgsUsage: "[multisigAddress messageId proposerAddress destination value <methodId methodParams> (optional)]",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
-			Name:  "source",
+			Name:  "from",
 			Usage: "account to send the approve message from",
 		},
 	},
@@ -432,8 +442,8 @@ var msigApproveCmd = &cli.Command{
 		}
 
 		var from address.Address
-		if cctx.IsSet("source") {
-			f, err := address.NewFromString(cctx.String("source"))
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
 			if err != nil {
 				return err
 			}
@@ -465,3 +475,234 @@ var msigApproveCmd = &cli.Command{
 		return nil
 	},
 }
+
+var msigSwapProposeCmd = &cli.Command{
+	Name:      "swap-propose",
+	Usage:     "Propose to swap signers",
+	ArgsUsage: "[multisigAddress oldAddress newAddress]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the approve message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if cctx.Args().Len() != 3 {
+			return fmt.Errorf("must pass multisig address, old signer address, new signer address")
+		}
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		oldAdd, err := address.NewFromString(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		newAdd, err := address.NewFromString(cctx.Args().Get(2))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		msgCid, err := api.MsigSwapPropose(ctx, msig, from, oldAdd, newAdd)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent swap proposal in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("swap proposal returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigSwapApproveCmd = &cli.Command{
+	Name:      "swap-approve",
+	Usage:     "Approve a message to swap signers",
+	ArgsUsage: "[multisigAddress proposerAddress txId oldAddress newAddress]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the approve message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if cctx.Args().Len() != 5 {
+			return fmt.Errorf("must pass multisig address, proposer address, transaction id, old signer address, new signer address")
+		}
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		prop, err := address.NewFromString(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		txid, err := strconv.ParseUint(cctx.Args().Get(2), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		oldAdd, err := address.NewFromString(cctx.Args().Get(3))
+		if err != nil {
+			return err
+		}
+
+		newAdd, err := address.NewFromString(cctx.Args().Get(4))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		msgCid, err := api.MsigSwapApprove(ctx, msig, from, txid, prop, oldAdd, newAdd)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent swap approval in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("swap approval returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigSwapCancelCmd = &cli.Command{
+	Name:      "swap-cancel",
+	Usage:     "Cancel a message to swap signers",
+	ArgsUsage: "[multisigAddress txId oldAddress newAddress]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the approve message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if cctx.Args().Len() != 4 {
+			return fmt.Errorf("must pass multisig address, transaction id, old signer address, new signer address")
+		}
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		txid, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		oldAdd, err := address.NewFromString(cctx.Args().Get(2))
+		if err != nil {
+			return err
+		}
+
+		newAdd, err := address.NewFromString(cctx.Args().Get(3))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		msgCid, err := api.MsigSwapCancel(ctx, msig, from, txid, oldAdd, newAdd)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent swap approval in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("swap approval returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}

cli/paych.go

@@ -29,7 +29,7 @@ var paychGetCmd = &cli.Command{
 	ArgsUsage: "[fromAddress toAddress amount]",
 	Action: func(cctx *cli.Context) error {
 		if cctx.Args().Len() != 3 {
-			return fmt.Errorf("must pass three arguments: <from> <to> <available funds>")
+			return fmt.Errorf("must pass three arguments: <from> <to> <available funds in FIL>")
 		}
 
 		from, err := address.NewFromString(cctx.Args().Get(0))
@@ -42,9 +42,9 @@ var paychGetCmd = &cli.Command{
 			return fmt.Errorf("failed to parse to address: %s", err)
 		}
 
-		amt, err := types.BigFromString(cctx.Args().Get(2))
+		amt, err := types.ParseFIL(cctx.Args().Get(2))
 		if err != nil {
-			return fmt.Errorf("parsing amount failed: %s", err)
+			return fmt.Errorf("parsing amount as whole FIL failed: %s", err)
 		}
 
 		api, closer, err := GetFullNodeAPI(cctx)
@@ -55,7 +55,7 @@ var paychGetCmd = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
-		info, err := api.PaychGet(ctx, from, to, amt)
+		info, err := api.PaychGet(ctx, from, to, types.BigInt(amt))
 		if err != nil {
 			return err
 		}

cli/send.go

@@ -14,7 +14,7 @@ var sendCmd = &cli.Command{
 	ArgsUsage: "[targetAddress] [amount]",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
-			Name:  "source",
+			Name:  "from",
 			Usage: "optionally specify the account to send funds from",
 		},
 		&cli.StringFlag{
@@ -52,7 +52,7 @@ var sendCmd = &cli.Command{
 		}
 
 		var fromAddr address.Address
-		if from := cctx.String("source"); from == "" {
+		if from := cctx.String("from"); from == "" {
 			defaddr, err := api.WalletDefaultAddress(ctx)
 			if err != nil {
 				return err

cli/state.go

@@ -23,72 +23,20 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/builtin/account"
-	"github.com/filecoin-project/specs-actors/actors/builtin/cron"
-	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	"github.com/filecoin-project/specs-actors/actors/builtin/market"
 	miner2 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
-	"github.com/filecoin-project/specs-actors/actors/builtin/reward"
-	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 	"github.com/filecoin-project/specs-actors/actors/runtime/exitcode"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 
 	"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"
 	"github.com/filecoin-project/lotus/miner"
 )
 
-type methodMeta struct {
-	Name string
-
-	params reflect.Type
-	ret    reflect.Type
-}
-
-var methods = map[cid.Cid][]methodMeta{}
-
-func init() {
-	cidToMethods := map[cid.Cid][2]interface{}{
-		// builtin.SystemActorCodeID:        {builtin.MethodsSystem, system.Actor{} }- apparently it doesn't have methods
-		builtin.InitActorCodeID:             {builtin.MethodsInit, init_.Actor{}},
-		builtin.CronActorCodeID:             {builtin.MethodsCron, cron.Actor{}},
-		builtin.AccountActorCodeID:          {builtin.MethodsAccount, account.Actor{}},
-		builtin.StoragePowerActorCodeID:     {builtin.MethodsPower, power.Actor{}},
-		builtin.StorageMinerActorCodeID:     {builtin.MethodsMiner, miner2.Actor{}},
-		builtin.StorageMarketActorCodeID:    {builtin.MethodsMarket, market.Actor{}},
-		builtin.PaymentChannelActorCodeID:   {builtin.MethodsPaych, paych.Actor{}},
-		builtin.MultisigActorCodeID:         {builtin.MethodsMultisig, multisig.Actor{}},
-		builtin.RewardActorCodeID:           {builtin.MethodsReward, reward.Actor{}},
-		builtin.VerifiedRegistryActorCodeID: {builtin.MethodsVerifiedRegistry, verifreg.Actor{}},
-	}
-
-	for c, m := range cidToMethods {
-		rt := reflect.TypeOf(m[0])
-		nf := rt.NumField()
-
-		methods[c] = append(methods[c], methodMeta{
-			Name:   "Send",
-			params: reflect.TypeOf(new(adt.EmptyValue)),
-			ret:    reflect.TypeOf(new(adt.EmptyValue)),
-		})
-
-		exports := m[1].(abi.Invokee).Exports()
-		for i := 0; i < nf; i++ {
-			export := reflect.TypeOf(exports[i+1])
-
-			methods[c] = append(methods[c], methodMeta{
-				Name:   rt.Field(i).Name,
-				params: export.In(1),
-				ret:    export.Out(0),
-			})
-		}
-	}
-}
-
 var stateCmd = &cli.Command{
 	Name:  "state",
 	Usage: "Interact with and query filecoin chain state",
@@ -389,7 +337,11 @@ var stateReplaySetCmd = &cli.Command{
 					return xerrors.Errorf("finding message in chain: %w", err)
 				}
 
-				ts, err = fapi.ChainGetTipSet(ctx, r.TipSet.Parents())
+				childTs, err := fapi.ChainGetTipSet(ctx, r.TipSet)
+				if err != nil {
+					return xerrors.Errorf("loading tipset: %w", err)
+				}
+				ts, err = fapi.ChainGetTipSet(ctx, childTs.Parents())
 			}
 			if err != nil {
 				return err
@@ -842,8 +794,8 @@ var stateComputeStateCmd = &cli.Command{
 	Usage: "Perform state computations",
 	Flags: []cli.Flag{
 		&cli.Uint64Flag{
-			Name:  "height",
-			Usage: "set the height to compute state at",
+			Name:  "vm-height",
+			Usage: "set the height that the vm will see",
 		},
 		&cli.BoolFlag{
 			Name:  "apply-mpool-messages",
@@ -872,7 +824,7 @@ var stateComputeStateCmd = &cli.Command{
 			return err
 		}
 
-		h := abi.ChainEpoch(cctx.Uint64("height"))
+		h := abi.ChainEpoch(cctx.Uint64("vm-height"))
 		if h == 0 {
 			if ts == nil {
 				head, err := api.ChainHead(ctx)
@@ -1191,7 +1143,7 @@ func codeStr(c cid.Cid) string {
 }
 
 func getMethod(code cid.Cid, method abi.MethodNum) string {
-	return methods[code][method].Name
+	return stmgr.MethodsMap[code][method].Name
 }
 
 func toFil(f types.BigInt) types.FIL {
@@ -1222,7 +1174,7 @@ func sumGas(changes []*types.GasTrace) types.GasTrace {
 }
 
 func jsonParams(code cid.Cid, method abi.MethodNum, params []byte) (string, error) {
-	re := reflect.New(methods[code][method].params.Elem())
+	re := reflect.New(stmgr.MethodsMap[code][method].Params.Elem())
 	p := re.Interface().(cbg.CBORUnmarshaler)
 	if err := p.UnmarshalCBOR(bytes.NewReader(params)); err != nil {
 		return "", err
@@ -1233,7 +1185,7 @@ func jsonParams(code cid.Cid, method abi.MethodNum, params []byte) (string, erro
 }
 
 func jsonReturn(code cid.Cid, method abi.MethodNum, ret []byte) (string, error) {
-	re := reflect.New(methods[code][method].ret.Elem())
+	re := reflect.New(stmgr.MethodsMap[code][method].Ret.Elem())
 	p := re.Interface().(cbg.CBORUnmarshaler)
 	if err := p.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
 		return "", err

cmd/lotus-chainwatch/dot.go

@@ -1,12 +1,15 @@
 package main
 
 import (
+	"database/sql"
 	"fmt"
 	"hash/crc32"
 	"strconv"
 
 	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
 )
 
 var dotCmd = &cli.Command{
@@ -14,10 +17,24 @@ var dotCmd = &cli.Command{
 	Usage:     "generate dot graphs",
 	ArgsUsage: "<minHeight> <toseeHeight>",
 	Action: func(cctx *cli.Context) error {
-		st, err := openStorage(cctx.String("db"))
+		ll := cctx.String("log-level")
+		if err := logging.SetLogLevel("*", ll); err != nil {
+			return err
+		}
+
+		db, err := sql.Open("postgres", cctx.String("db"))
 		if err != nil {
 			return err
 		}
+		defer func() {
+			if err := db.Close(); err != nil {
+				log.Errorw("Failed to close database", "error", err)
+			}
+		}()
+
+		if err := db.Ping(); err != nil {
+			return xerrors.Errorf("Database failed to respond to ping (is it online?): %w", err)
+		}
 
 		minH, err := strconv.ParseInt(cctx.Args().Get(0), 10, 32)
 		if err != nil {
@@ -29,7 +46,7 @@ var dotCmd = &cli.Command{
 		}
 		maxH := minH + tosee
 
-		res, err := st.db.Query(`select block, parent, b.miner, b.height, p.height from block_parents
+		res, err := db.Query(`select block, parent, b.miner, b.height, p.height from block_parents
     inner join blocks b on block_parents.block = b.cid
     inner join blocks p on block_parents.parent = p.cid
 where b.height > $1 and b.height < $2`, minH, maxH)
@@ -40,7 +57,10 @@ where b.height > $1 and b.height < $2`, minH, maxH)
 
 		fmt.Println("digraph D {")
 
-		hl := st.hasList()
+		hl, err := syncedBlocks(db)
+		if err != nil {
+			log.Fatal(err)
+		}
 
 		for res.Next() {
 			var block, parent, miner string
@@ -85,3 +105,27 @@ where b.height > $1 and b.height < $2`, minH, maxH)
 		return nil
 	},
 }
+
+func syncedBlocks(db *sql.DB) (map[cid.Cid]struct{}, error) {
+	// timestamp is used to return a configurable amount of rows based on when they were last added.
+	rws, err := db.Query(`select cid FROM blocks_synced`)
+	if err != nil {
+		return nil, xerrors.Errorf("Failed to query blocks_synced: %w", err)
+	}
+	out := map[cid.Cid]struct{}{}
+
+	for rws.Next() {
+		var c string
+		if err := rws.Scan(&c); err != nil {
+			return nil, xerrors.Errorf("Failed to scan blocks_synced: %w", err)
+		}
+
+		ci, err := cid.Parse(c)
+		if err != nil {
+			return nil, xerrors.Errorf("Failed to parse blocks_synced: %w", err)
+		}
+
+		out[ci] = struct{}{}
+	}
+	return out, nil
+}

cmd/lotus-chainwatch/main.go

@@ -1,34 +1,22 @@
 package main
 
 import (
-	"fmt"
-	"net/http"
 	_ "net/http/pprof"
 	"os"
 
+	"github.com/filecoin-project/lotus/build"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/urfave/cli/v2"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/build"
-	lcli "github.com/filecoin-project/lotus/cli"
 )
 
 var log = logging.Logger("chainwatch")
 
 func main() {
-	_ = logging.SetLogLevel("*", "INFO")
-	if err := logging.SetLogLevel("rpc", "error"); err != nil {
-		panic(err)
+	if err := logging.SetLogLevel("*", "info"); err != nil {
+		log.Fatal(err)
 	}
-
 	log.Info("Starting chainwatch")
 
-	local := []*cli.Command{
-		runCmd,
-		dotCmd,
-	}
-
 	app := &cli.App{
 		Name:    "lotus-chainwatch",
 		Usage:   "Devnet token distribution utility",
@@ -44,69 +32,19 @@ func main() {
 				EnvVars: []string{"LOTUS_DB"},
 				Value:   "",
 			},
+			&cli.StringFlag{
+				Name:    "log-level",
+				EnvVars: []string{"GOLOG_LOG_LEVEL"},
+				Value:   "info",
+			},
+		},
+		Commands: []*cli.Command{
+			dotCmd,
+			runCmd,
 		},
-
-		Commands: local,
 	}
 
 	if err := app.Run(os.Args); err != nil {
-		log.Warnf("%+v", err)
-		return
+		log.Fatal(err)
 	}
 }
-
-var runCmd = &cli.Command{
-	Name:  "run",
-	Usage: "Start lotus chainwatch",
-	Flags: []cli.Flag{
-		&cli.StringFlag{
-			Name:  "front",
-			Value: "127.0.0.1:8418",
-		},
-		&cli.IntFlag{
-			Name:  "max-batch",
-			Value: 1000,
-		},
-	},
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := lcli.GetFullNodeAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-		ctx := lcli.ReqContext(cctx)
-
-		v, err := api.Version(ctx)
-		if err != nil {
-			return err
-		}
-
-		log.Infof("Remote version: %s", v.Version)
-
-		maxBatch := cctx.Int("max-batch")
-
-		st, err := openStorage(cctx.String("db"))
-		if err != nil {
-			return err
-		}
-		defer st.close() //nolint:errcheck
-
-		runSyncer(ctx, api, st, maxBatch)
-
-		h, err := newHandler(api, st)
-		if err != nil {
-			return xerrors.Errorf("handler setup: %w", err)
-		}
-
-		http.Handle("/", h)
-
-		fmt.Printf("Open http://%s\n", cctx.String("front"))
-
-		go func() {
-			<-ctx.Done()
-			os.Exit(0)
-		}()
-
-		return http.ListenAndServe(cctx.String("front"), nil)
-	},
-}

cmd/lotus-chainwatch/mpool.go

@@ -1,60 +0,0 @@
-package main
-
-import (
-	"context"
-	"time"
-
-	"github.com/ipfs/go-cid"
-
-	aapi "github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func subMpool(ctx context.Context, api aapi.FullNode, st *storage) {
-	sub, err := api.MpoolSub(ctx)
-	if err != nil {
-		return
-	}
-
-	for {
-		var updates []aapi.MpoolUpdate
-
-		select {
-		case update := <-sub:
-			updates = append(updates, update)
-		case <-ctx.Done():
-			return
-		}
-
-	loop:
-		for {
-			time.Sleep(10 * time.Millisecond)
-			select {
-			case update := <-sub:
-				updates = append(updates, update)
-			default:
-				break loop
-			}
-		}
-
-		msgs := map[cid.Cid]*types.Message{}
-		for _, v := range updates {
-			if v.Type != aapi.MpoolAdd {
-				continue
-			}
-
-			msgs[v.Message.Message.Cid()] = &v.Message.Message
-		}
-
-		log.Debugf("Processing %d mpool updates", len(msgs))
-
-		err := st.storeMessages(msgs)
-		if err != nil {
-			log.Error(err)
-		}
-
-		if err := st.storeMpoolInclusions(updates); err != nil {
-			log.Error(err)
-		}
-	}
-}

cmd/lotus-chainwatch/processor/common_actors.go

@@ -0,0 +1,299 @@
+package processor
+
+import (
+	"bytes"
+	"context"
+	"time"
+
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/xerrors"
+
+	"github.com/ipfs/go-cid"
+	typegen "github.com/whyrusleeping/cbor-gen"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	_init "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	cw_util "github.com/filecoin-project/lotus/cmd/lotus-chainwatch/util"
+)
+
+func (p *Processor) setupCommonActors() error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create table if not exists id_address_map
+(
+	id text not null,
+	address text not null,
+	constraint id_address_map_pk
+		primary key (id, address)
+);
+
+create unique index if not exists id_address_map_id_uindex
+	on id_address_map (id);
+
+create unique index if not exists id_address_map_address_uindex
+	on id_address_map (address);
+
+create table if not exists actors
+  (
+	id text not null
+		constraint id_address_map_actors_id_fk
+			references id_address_map (id),
+	code text not null,
+	head text not null,
+	nonce int not null,
+	balance text not null,
+	stateroot text
+  );
+  
+create index if not exists actors_id_index
+	on actors (id);
+
+create index if not exists id_address_map_address_index
+	on id_address_map (address);
+
+create index if not exists id_address_map_id_index
+	on id_address_map (id);
+
+create or replace function actor_tips(epoch bigint)
+    returns table (id text,
+                    code text,
+                    head text,
+                    nonce int,
+                    balance text,
+                    stateroot text,
+                    height bigint,
+                    parentstateroot text) as
+$body$
+    select distinct on (id) * from actors
+        inner join state_heights sh on sh.parentstateroot = stateroot
+        where height < $1
+		order by id, height desc;
+$body$ language sql;
+
+create table if not exists actor_states
+(
+	head text not null,
+	code text not null,
+	state json not null
+);
+
+create unique index if not exists actor_states_head_code_uindex
+	on actor_states (head, code);
+
+create index if not exists actor_states_head_index
+	on actor_states (head);
+
+create index if not exists actor_states_code_head_index
+	on actor_states (head, code);
+
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) HandleCommonActorsChanges(ctx context.Context, actors map[cid.Cid]ActorTips) error {
+	if err := p.storeActorAddresses(ctx, actors); err != nil {
+		return err
+	}
+
+	grp, _ := errgroup.WithContext(ctx)
+
+	grp.Go(func() error {
+		if err := p.storeActorHeads(actors); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	grp.Go(func() error {
+		if err := p.storeActorStates(actors); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	return grp.Wait()
+}
+
+func (p Processor) storeActorAddresses(ctx context.Context, actors map[cid.Cid]ActorTips) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Actor Addresses", "duration", time.Since(start).String())
+	}()
+
+	addressToID := map[address.Address]address.Address{}
+	// HACK until genesis storage is figured out:
+	addressToID[builtin.SystemActorAddr] = builtin.SystemActorAddr
+	addressToID[builtin.InitActorAddr] = builtin.InitActorAddr
+	addressToID[builtin.RewardActorAddr] = builtin.RewardActorAddr
+	addressToID[builtin.CronActorAddr] = builtin.CronActorAddr
+	addressToID[builtin.StoragePowerActorAddr] = builtin.StoragePowerActorAddr
+	addressToID[builtin.StorageMarketActorAddr] = builtin.StorageMarketActorAddr
+	addressToID[builtin.VerifiedRegistryActorAddr] = builtin.VerifiedRegistryActorAddr
+	addressToID[builtin.BurntFundsActorAddr] = builtin.BurntFundsActorAddr
+	initActor, err := p.node.StateGetActor(ctx, builtin.InitActorAddr, types.EmptyTSK)
+	if err != nil {
+		return err
+	}
+
+	initActorRaw, err := p.node.ChainReadObj(ctx, initActor.Head)
+	if err != nil {
+		return err
+	}
+
+	var initActorState _init.State
+	if err := initActorState.UnmarshalCBOR(bytes.NewReader(initActorRaw)); err != nil {
+		return err
+	}
+	ctxStore := cw_util.NewAPIIpldStore(ctx, p.node)
+	addrMap, err := adt.AsMap(ctxStore, initActorState.AddressMap)
+	if err != nil {
+		return err
+	}
+	// gross..
+	var actorID typegen.CborInt
+	if err := addrMap.ForEach(&actorID, func(key string) error {
+		longAddr, err := address.NewFromBytes([]byte(key))
+		if err != nil {
+			return err
+		}
+		shortAddr, err := address.NewIDAddress(uint64(actorID))
+		if err != nil {
+			return err
+		}
+		addressToID[longAddr] = shortAddr
+		return nil
+	}); err != nil {
+		return err
+	}
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create temp table iam (like id_address_map excluding constraints) on commit drop;
+`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy iam (id, address) from STDIN `)
+	if err != nil {
+		return err
+	}
+
+	for a, i := range addressToID {
+		if i == address.Undef {
+			continue
+		}
+		if _, err := stmt.Exec(
+			i.String(),
+			a.String(),
+		); err != nil {
+			return err
+		}
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into id_address_map select * from iam on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeActorHeads(actors map[cid.Cid]ActorTips) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Actor Heads", "duration", time.Since(start).String())
+	}()
+	// Basic
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+	if _, err := tx.Exec(`
+		create temp table a (like actors excluding constraints) on commit drop;
+	`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy a (id, code, head, nonce, balance, stateroot) from stdin `)
+	if err != nil {
+		return err
+	}
+
+	for code, actTips := range actors {
+		for _, actorInfo := range actTips {
+			for _, a := range actorInfo {
+				if _, err := stmt.Exec(a.addr.String(), code.String(), a.act.Head.String(), a.act.Nonce, a.act.Balance.String(), a.stateroot.String()); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into actors select * from a on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeActorStates(actors map[cid.Cid]ActorTips) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Actor States", "duration", time.Since(start).String())
+	}()
+	// States
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+	if _, err := tx.Exec(`
+		create temp table a (like actor_states excluding constraints) on commit drop;
+	`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy a (head, code, state) from stdin `)
+	if err != nil {
+		return err
+	}
+
+	for code, actTips := range actors {
+		for _, actorInfo := range actTips {
+			for _, a := range actorInfo {
+				if _, err := stmt.Exec(a.act.Head.String(), code.String(), a.state); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into actor_states select * from a on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}

cmd/lotus-chainwatch/processor/market.go

@@ -0,0 +1,301 @@
+package processor
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/events/state"
+)
+
+func (p *Processor) setupMarket() error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create table if not exists market_deal_proposals
+(
+    deal_id bigint not null,
+    
+    state_root text not null,
+    
+    piece_cid text not null,
+    padded_piece_size bigint not null,
+    unpadded_piece_size bigint not null,
+    is_verified bool not null,
+    
+    client_id text not null,
+    provider_id text not null,
+    
+    start_epoch bigint not null,
+    end_epoch bigint not null,
+    slashed_epoch bigint,
+    storage_price_per_epoch text not null,
+    
+    provider_collateral text not null,
+    client_collateral text not null,
+    
+   constraint market_deal_proposal_pk
+ 		primary key (deal_id)
+);
+
+create table if not exists market_deal_states 
+(
+    deal_id bigint not null,
+    
+    sector_start_epoch bigint not null,
+    last_update_epoch bigint not null,
+    slash_epoch bigint not null,
+    
+    state_root text not null,
+    
+	unique (deal_id, sector_start_epoch, last_update_epoch, slash_epoch),
+ 
+	constraint market_deal_states_pk
+		primary key (deal_id, state_root)
+    
+);
+
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+type marketActorInfo struct {
+	common actorInfo
+}
+
+func (p *Processor) HandleMarketChanges(ctx context.Context, marketTips ActorTips) error {
+	marketChanges, err := p.processMarket(ctx, marketTips)
+	if err != nil {
+		log.Fatalw("Failed to process market actors", "error", err)
+	}
+
+	if err := p.persistMarket(ctx, marketChanges); err != nil {
+		log.Fatalw("Failed to persist market actors", "error", err)
+	}
+
+	if err := p.updateMarket(ctx, marketChanges); err != nil {
+		log.Fatalw("Failed to update market actors", "error", err)
+	}
+	return nil
+}
+
+func (p *Processor) processMarket(ctx context.Context, marketTips ActorTips) ([]marketActorInfo, error) {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Processed Market", "duration", time.Since(start).String())
+	}()
+
+	var out []marketActorInfo
+	for _, markets := range marketTips {
+		for _, mt := range markets {
+			// NB: here is where we can extract the market state when we need it.
+			out = append(out, marketActorInfo{common: mt})
+		}
+	}
+	return out, nil
+}
+
+func (p *Processor) persistMarket(ctx context.Context, info []marketActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Persisted Market", "duration", time.Since(start).String())
+	}()
+
+	grp, ctx := errgroup.WithContext(ctx)
+
+	grp.Go(func() error {
+		if err := p.storeMarketActorDealProposals(ctx, info); err != nil {
+			return xerrors.Errorf("Failed to store marker deal proposals: %w", err)
+		}
+		return nil
+	})
+
+	grp.Go(func() error {
+		if err := p.storeMarketActorDealStates(info); err != nil {
+			return xerrors.Errorf("Failed to store marker deal states: %w", err)
+		}
+		return nil
+	})
+
+	return grp.Wait()
+
+}
+
+func (p *Processor) updateMarket(ctx context.Context, info []marketActorInfo) error {
+	if err := p.updateMarketActorDealProposals(ctx, info); err != nil {
+		return xerrors.Errorf("Failed to update market info: %w", err)
+	}
+	return nil
+}
+
+func (p *Processor) storeMarketActorDealStates(marketTips []marketActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Market Deal States", "duration", time.Since(start).String())
+	}()
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+	if _, err := tx.Exec(`create temp table mds (like market_deal_states excluding constraints) on commit drop;`); err != nil {
+		return err
+	}
+	stmt, err := tx.Prepare(`copy mds (deal_id, sector_start_epoch, last_update_epoch, slash_epoch, state_root) from STDIN`)
+	if err != nil {
+		return err
+	}
+	for _, mt := range marketTips {
+		dealStates, err := p.node.StateMarketDeals(context.TODO(), mt.common.tsKey)
+		if err != nil {
+			return err
+		}
+
+		for dealID, ds := range dealStates {
+			id, err := strconv.ParseUint(dealID, 10, 64)
+			if err != nil {
+				return err
+			}
+
+			if _, err := stmt.Exec(
+				id,
+				ds.State.SectorStartEpoch,
+				ds.State.LastUpdatedEpoch,
+				ds.State.SlashEpoch,
+				mt.common.stateroot.String(),
+			); err != nil {
+				return err
+			}
+
+		}
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into market_deal_states select * from mds on conflict do nothing`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeMarketActorDealProposals(ctx context.Context, marketTips []marketActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Market Deal Proposals", "duration", time.Since(start).String())
+	}()
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`create temp table mdp (like market_deal_proposals excluding constraints) on commit drop;`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy mdp (deal_id, state_root, piece_cid, padded_piece_size, unpadded_piece_size, is_verified, client_id, provider_id, start_epoch, end_epoch, slashed_epoch, storage_price_per_epoch, provider_collateral, client_collateral) from STDIN`)
+	if err != nil {
+		return err
+	}
+
+	// insert in sorted order (lowest height -> highest height) since dealid is pk of table.
+	for _, mt := range marketTips {
+		dealStates, err := p.node.StateMarketDeals(ctx, mt.common.tsKey)
+		if err != nil {
+			return err
+		}
+
+		for dealID, ds := range dealStates {
+			id, err := strconv.ParseUint(dealID, 10, 64)
+			if err != nil {
+				return err
+			}
+
+			if _, err := stmt.Exec(
+				id,
+				mt.common.stateroot.String(),
+				ds.Proposal.PieceCID.String(),
+				ds.Proposal.PieceSize,
+				ds.Proposal.PieceSize.Unpadded(),
+				ds.Proposal.VerifiedDeal,
+				ds.Proposal.Client.String(),
+				ds.Proposal.Provider.String(),
+				ds.Proposal.StartEpoch,
+				ds.Proposal.EndEpoch,
+				nil, // slashed_epoch
+				ds.Proposal.StoragePricePerEpoch.String(),
+				ds.Proposal.ProviderCollateral.String(),
+				ds.Proposal.ClientCollateral.String(),
+			); err != nil {
+				return err
+			}
+
+		}
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+	if _, err := tx.Exec(`insert into market_deal_proposals select * from mdp on conflict do nothing`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+
+}
+
+func (p *Processor) updateMarketActorDealProposals(ctx context.Context, marketTip []marketActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Updated Market Deal Proposals", "duration", time.Since(start).String())
+	}()
+	pred := state.NewStatePredicates(p.node)
+
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	stmt, err := tx.Prepare(`update market_deal_proposals set slashed_epoch=$1 where deal_id=$2`)
+	if err != nil {
+		return err
+	}
+
+	for _, mt := range marketTip {
+		stateDiff := pred.OnStorageMarketActorChanged(pred.OnDealStateChanged(pred.OnDealStateAmtChanged()))
+
+		changed, val, err := stateDiff(ctx, mt.common.parentTsKey, mt.common.tsKey)
+		if err != nil {
+			log.Warnw("error getting market deal state diff", "error", err)
+		}
+		if !changed {
+			continue
+		}
+		changes, ok := val.(*state.MarketDealStateChanges)
+		if !ok {
+			return xerrors.Errorf("Unknown type returned by Deal State AMT predicate: %T", val)
+		}
+
+		for _, modified := range changes.Modified {
+			if modified.From.SlashEpoch != modified.To.SlashEpoch {
+				if _, err := stmt.Exec(modified.To.SlashEpoch, modified.ID); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}

cmd/lotus-chainwatch/processor/messages.go

@@ -0,0 +1,316 @@
+package processor
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/xerrors"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/parmap"
+)
+
+func (p *Processor) setupMessages() error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create table if not exists messages
+(
+	cid text not null
+		constraint messages_pk
+			primary key,
+	"from" text not null,
+	"to" text not null,
+	nonce bigint not null,
+	value text not null,
+	gasprice bigint not null,
+	gaslimit bigint not null,
+	method bigint,
+	params bytea
+);
+
+create unique index if not exists messages_cid_uindex
+	on messages (cid);
+
+create index if not exists messages_from_index
+	on messages ("from");
+
+create index if not exists messages_to_index
+	on messages ("to");
+
+create table if not exists block_messages
+(
+	block text not null
+	    constraint blocks_block_cids_cid_fk
+			references block_cids (cid),
+	message text not null,
+	constraint block_messages_pk
+		primary key (block, message)
+);
+
+create table if not exists mpool_messages
+(
+	msg text not null
+		constraint mpool_messages_pk
+			primary key
+		constraint mpool_messages_messages_cid_fk
+			references messages,
+	add_ts int not null
+);
+
+create unique index if not exists mpool_messages_msg_uindex
+	on mpool_messages (msg);
+
+create table if not exists receipts
+(
+	msg text not null,
+	state text not null,
+	idx int not null,
+	exit int not null,
+	gas_used int not null,
+	return bytea,
+	constraint receipts_pk
+		primary key (msg, state)
+);
+
+create index if not exists receipts_msg_state_index
+	on receipts (msg, state);
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) HandleMessageChanges(ctx context.Context, blocks map[cid.Cid]*types.BlockHeader) error {
+	if err := p.persistMessagesAndReceipts(ctx, blocks); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (p *Processor) persistMessagesAndReceipts(ctx context.Context, blocks map[cid.Cid]*types.BlockHeader) error {
+	messages, inclusions := p.fetchMessages(ctx, blocks)
+	receipts := p.fetchParentReceipts(ctx, blocks)
+
+	grp, _ := errgroup.WithContext(ctx)
+
+	grp.Go(func() error {
+		return p.storeMessages(messages)
+	})
+
+	grp.Go(func() error {
+		return p.storeMsgInclusions(inclusions)
+	})
+
+	grp.Go(func() error {
+		return p.storeReceipts(receipts)
+	})
+
+	return grp.Wait()
+}
+
+func (p *Processor) storeReceipts(recs map[mrec]*types.MessageReceipt) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Persisted Receipts", "duration", time.Since(start).String())
+	}()
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create temp table recs (like receipts excluding constraints) on commit drop;
+`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy recs (msg, state, idx, exit, gas_used, return) from stdin `)
+	if err != nil {
+		return err
+	}
+
+	for c, m := range recs {
+		if _, err := stmt.Exec(
+			c.msg.String(),
+			c.state.String(),
+			c.idx,
+			m.ExitCode,
+			m.GasUsed,
+			m.Return,
+		); err != nil {
+			return err
+		}
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into receipts select * from recs on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeMsgInclusions(incls map[cid.Cid][]cid.Cid) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Persisted Message Inclusions", "duration", time.Since(start).String())
+	}()
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create temp table mi (like block_messages excluding constraints) on commit drop;
+`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy mi (block, message) from STDIN `)
+	if err != nil {
+		return err
+	}
+
+	for b, msgs := range incls {
+		for _, msg := range msgs {
+			if _, err := stmt.Exec(
+				b.String(),
+				msg.String(),
+			); err != nil {
+				return err
+			}
+		}
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into block_messages select * from mi on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeMessages(msgs map[cid.Cid]*types.Message) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Persisted Messages", "duration", time.Since(start).String())
+	}()
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create temp table msgs (like messages excluding constraints) on commit drop;
+`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy msgs (cid, "from", "to", nonce, "value", gasprice, gaslimit, method, params) from stdin `)
+	if err != nil {
+		return err
+	}
+
+	for c, m := range msgs {
+		if _, err := stmt.Exec(
+			c.String(),
+			m.From.String(),
+			m.To.String(),
+			m.Nonce,
+			m.Value.String(),
+			m.GasPrice.String(),
+			m.GasLimit,
+			m.Method,
+			m.Params,
+		); err != nil {
+			return err
+		}
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into messages select * from msgs on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) fetchMessages(ctx context.Context, blocks map[cid.Cid]*types.BlockHeader) (map[cid.Cid]*types.Message, map[cid.Cid][]cid.Cid) {
+	var lk sync.Mutex
+	messages := map[cid.Cid]*types.Message{}
+	inclusions := map[cid.Cid][]cid.Cid{} // block -> msgs
+
+	parmap.Par(50, parmap.MapArr(blocks), func(header *types.BlockHeader) {
+		msgs, err := p.node.ChainGetBlockMessages(ctx, header.Cid())
+		if err != nil {
+			panic(err)
+		}
+
+		vmm := make([]*types.Message, 0, len(msgs.Cids))
+		for _, m := range msgs.BlsMessages {
+			vmm = append(vmm, m)
+		}
+
+		for _, m := range msgs.SecpkMessages {
+			vmm = append(vmm, &m.Message)
+		}
+
+		lk.Lock()
+		for _, message := range vmm {
+			messages[message.Cid()] = message
+			inclusions[header.Cid()] = append(inclusions[header.Cid()], message.Cid())
+		}
+		lk.Unlock()
+	})
+
+	return messages, inclusions
+}
+
+type mrec struct {
+	msg   cid.Cid
+	state cid.Cid
+	idx   int
+}
+
+func (p *Processor) fetchParentReceipts(ctx context.Context, toSync map[cid.Cid]*types.BlockHeader) map[mrec]*types.MessageReceipt {
+	var lk sync.Mutex
+	out := map[mrec]*types.MessageReceipt{}
+
+	parmap.Par(50, parmap.MapArr(toSync), func(header *types.BlockHeader) {
+		recs, err := p.node.ChainGetParentReceipts(ctx, header.Cid())
+		if err != nil {
+			panic(err)
+		}
+		msgs, err := p.node.ChainGetParentMessages(ctx, header.Cid())
+		if err != nil {
+			panic(err)
+		}
+
+		lk.Lock()
+		for i, r := range recs {
+			out[mrec{
+				msg:   msgs[i].Cid,
+				state: header.ParentStateRoot,
+				idx:   i,
+			}] = r
+		}
+		lk.Unlock()
+	})
+
+	return out
+}

cmd/lotus-chainwatch/processor/miner.go

@@ -0,0 +1,790 @@
+package processor
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/chain/events/state"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/xerrors"
+
+	"github.com/libp2p/go-libp2p-core/peer"
+
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/builtin/power"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	cw_util "github.com/filecoin-project/lotus/cmd/lotus-chainwatch/util"
+)
+
+func (p *Processor) setupMiners() error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+
+create table if not exists miner_info
+(
+	miner_id text not null,
+	owner_addr text not null,
+	worker_addr text not null,
+	peer_id text,
+	sector_size text not null,
+	
+	precommit_deposits text not null,
+	locked_funds text not null,
+	next_deadline_process_faults bigint not null,
+	constraint miner_info_pk
+		primary key (miner_id)
+);
+
+/*
+* captures miner-specific power state for any given stateroot
+*/
+create table if not exists miner_power
+(
+	miner_id text not null,
+	state_root text not null,
+	raw_bytes_power text not null,
+	quality_adjusted_power text not null,
+	constraint miner_power_pk
+		primary key (miner_id, state_root)
+);
+
+create table if not exists miner_precommits
+(
+	miner_id text not null,
+	sector_id bigint not null,
+	
+	precommit_deposit text not null,
+	precommit_epoch text not null,
+	constraint miner_precommits_pk
+		primary key (miner_id, sector_id)
+    
+);
+
+create table if not exists miner_sectors
+(
+	miner_id text not null,
+	sector_id bigint not null,
+	
+	activation_epoch bigint not null,
+	expiration_epoch bigint not null,
+	termination_epoch bigint,
+	
+	deal_weight text not null,
+	verified_deal_weight text not null,
+	seal_cid text not null,
+	seal_rand_epoch bigint not null,
+	constraint miner_sectors_pk
+		primary key (miner_id, sector_id)
+);
+
+/* used to tell when a miners sectors (proven-not-yet-expired) changed if the miner_sectors_cid's are different a new sector was added or removed (terminated/expired) */
+create table if not exists miner_sectors_heads
+(
+	miner_id text not null,
+	miner_sectors_cid text not null,
+	
+	state_root text not null,	
+	
+	constraint miner_sectors_heads_pk
+		primary key (miner_id,miner_sectors_cid)
+    
+);
+
+
+DO $$
+BEGIN
+    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'miner_sector_event_type') THEN
+        CREATE TYPE miner_sector_event_type AS ENUM
+        (
+			'PRECOMMIT', 'COMMIT', 'EXTENDED', 'EXPIRED', 'TERMINATED'
+        );
+    END IF;
+END$$;
+
+create table if not exists miner_sector_events
+(
+    miner_id text not null,
+    sector_id bigint not null,
+    state_root text not null,
+    event miner_sector_event_type not null,
+    
+	constraint miner_sector_events_pk
+		primary key (sector_id, event, miner_id, state_root)
+);
+
+create materialized view if not exists miner_sectors_view as
+select ms.miner_id, ms.sector_id, mp.precommit_epoch, ms.activation_epoch, ms.expiration_epoch, ms.termination_epoch, ms.deal_weight, ms.verified_deal_weight
+from miner_sectors ms
+left join miner_precommits mp on ms.sector_id = mp.sector_id and ms.miner_id = mp.miner_id
+
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+type minerActorInfo struct {
+	common actorInfo
+
+	state miner.State
+
+	// tracked by power actor
+	rawPower big.Int
+	qalPower big.Int
+}
+
+type sectorUpdate struct {
+	terminationEpoch abi.ChainEpoch
+	terminated       bool
+
+	expirationEpoch abi.ChainEpoch
+
+	sectorID abi.SectorNumber
+	minerID  address.Address
+}
+
+func (p *Processor) HandleMinerChanges(ctx context.Context, minerTips ActorTips) error {
+	minerChanges, err := p.processMiners(ctx, minerTips)
+	if err != nil {
+		log.Fatalw("Failed to process miner actors", "error", err)
+	}
+
+	if err := p.persistMiners(ctx, minerChanges); err != nil {
+		log.Fatalw("Failed to persist miner actors", "error", err)
+	}
+
+	if err := p.updateMiners(ctx, minerChanges); err != nil {
+		log.Fatalw("Failed to update miner actors", "error", err)
+	}
+	return nil
+}
+
+func (p *Processor) processMiners(ctx context.Context, minerTips map[types.TipSetKey][]actorInfo) ([]minerActorInfo, error) {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Processed Miners", "duration", time.Since(start).String())
+	}()
+
+	var out []minerActorInfo
+	// TODO add parallel calls if this becomes slow
+	for tipset, miners := range minerTips {
+		// get the power actors claims map
+		minersClaims, err := getPowerActorClaimsMap(ctx, p.node, tipset)
+		if err != nil {
+			return nil, err
+		}
+
+		// Get miner raw and quality power
+		for _, act := range miners {
+			var mi minerActorInfo
+			mi.common = act
+
+			var claim power.Claim
+			// get miner claim from power actors claim map and store if found, else the miner had no claim at
+			// this tipset
+			found, err := minersClaims.Get(adt.AddrKey(act.addr), &claim)
+			if err != nil {
+				return nil, err
+			}
+			if found {
+				mi.qalPower = claim.QualityAdjPower
+				mi.rawPower = claim.RawBytePower
+			}
+
+			// Get the miner state info
+			astb, err := p.node.ChainReadObj(ctx, act.act.Head)
+			if err != nil {
+				log.Warnw("failed to find miner actor state", "address", act.addr, "error", err)
+				continue
+			}
+			if err := mi.state.UnmarshalCBOR(bytes.NewReader(astb)); err != nil {
+				return nil, err
+			}
+			out = append(out, mi)
+		}
+	}
+	return out, nil
+}
+
+func (p *Processor) persistMiners(ctx context.Context, miners []minerActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Persisted Miners", "duration", time.Since(start).String())
+	}()
+
+	grp, _ := errgroup.WithContext(ctx)
+
+	grp.Go(func() error {
+		if err := p.storeMinersActorState(miners); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	grp.Go(func() error {
+		if err := p.storeMinersPower(miners); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	grp.Go(func() error {
+		if err := p.storeMinersSectorState(ctx, miners); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	grp.Go(func() error {
+		if err := p.storeMinersSectorHeads(miners); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	grp.Go(func() error {
+		if err := p.storeMinersPreCommitState(ctx, miners); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	return grp.Wait()
+}
+
+func (p *Processor) storeMinersActorState(miners []minerActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Miners Actor State", "duration", time.Since(start).String())
+	}()
+
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`create temp table mi (like miner_info excluding constraints) on commit drop;`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy mi (miner_id, owner_addr, worker_addr, peer_id, sector_size, precommit_deposits, locked_funds, next_deadline_process_faults) from STDIN`)
+	if err != nil {
+		return err
+	}
+	for _, m := range miners {
+		var pid string
+		if len(m.state.Info.PeerId) != 0 {
+			peerid, err := peer.IDFromBytes(m.state.Info.PeerId)
+			if err != nil {
+				// this should "never happen", but if it does we should still store info about the miner.
+				log.Warnw("failed to decode peerID", "peerID (bytes)", m.state.Info.PeerId, "miner", m.common.addr, "tipset", m.common.tsKey.String())
+			} else {
+				pid = peerid.String()
+			}
+		}
+		if _, err := stmt.Exec(
+			m.common.addr.String(),
+			m.state.Info.Owner.String(),
+			m.state.Info.Worker.String(),
+			pid,
+			m.state.Info.SectorSize.ShortString(),
+			m.state.PreCommitDeposits.String(),
+			m.state.LockedFunds.String(),
+			m.state.NextDeadlineToProcessFaults,
+		); err != nil {
+			log.Errorw("failed to store miner state", "state", m.state, "info", m.state.Info, "error", err)
+			return xerrors.Errorf("failed to store miner state: %w", err)
+		}
+
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into miner_info select * from mi on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeMinersPower(miners []minerActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Miners Power", "duration", time.Since(start).String())
+	}()
+
+	tx, err := p.db.Begin()
+	if err != nil {
+		return xerrors.Errorf("begin miner_power tx: %w", err)
+	}
+
+	if _, err := tx.Exec(`create temp table mp (like miner_power excluding constraints) on commit drop`); err != nil {
+		return xerrors.Errorf("prep miner_power temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy mp (miner_id, state_root, raw_bytes_power, quality_adjusted_power) from STDIN`)
+	if err != nil {
+		return xerrors.Errorf("prepare tmp miner_power: %w", err)
+	}
+
+	for _, m := range miners {
+		if _, err := stmt.Exec(
+			m.common.addr.String(),
+			m.common.stateroot.String(),
+			m.rawPower.String(),
+			m.qalPower.String(),
+		); err != nil {
+			log.Errorw("failed to store miner power", "miner", m.common.addr, "stateroot", m.common.stateroot, "error", err)
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return xerrors.Errorf("close prepared miner_power: %w", err)
+	}
+
+	if _, err := tx.Exec(`insert into miner_power select * from mp on conflict do nothing`); err != nil {
+		return xerrors.Errorf("insert miner_power from tmp: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return xerrors.Errorf("commit miner_power tx: %w", err)
+	}
+
+	return nil
+
+}
+
+func (p *Processor) storeMinersSectorState(ctx context.Context, miners []minerActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Miners Sector State", "duration", time.Since(start).String())
+	}()
+
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`create temp table ms (like miner_sectors excluding constraints) on commit drop;`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy ms (miner_id, sector_id, activation_epoch, expiration_epoch, deal_weight, verified_deal_weight, seal_cid, seal_rand_epoch) from STDIN`)
+	if err != nil {
+		return err
+	}
+
+	grp, ctx := errgroup.WithContext(ctx)
+	for _, m := range miners {
+		m := m
+		grp.Go(func() error {
+			sectors, err := p.node.StateMinerSectors(ctx, m.common.addr, nil, true, m.common.tsKey)
+			if err != nil {
+				log.Debugw("Failed to load sectors", "tipset", m.common.tsKey.String(), "miner", m.common.addr.String(), "error", err)
+			}
+
+			for _, sector := range sectors {
+				if _, err := stmt.Exec(
+					m.common.addr.String(),
+					uint64(sector.ID),
+					int64(sector.Info.ActivationEpoch),
+					int64(sector.Info.Info.Expiration),
+					sector.Info.DealWeight.String(),
+					sector.Info.VerifiedDealWeight.String(),
+					sector.Info.Info.SealedCID.String(),
+					int64(sector.Info.Info.SealRandEpoch),
+				); err != nil {
+					return err
+				}
+			}
+			return nil
+		})
+	}
+
+	if err := grp.Wait(); err != nil {
+		return err
+	}
+
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into miner_sectors select * from ms on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeMinersSectorHeads(miners []minerActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Miners Sector Heads", "duration", time.Since(start).String())
+	}()
+
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`create temp table msh (like miner_sectors_heads excluding constraints) on commit drop;`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy msh (miner_id, miner_sectors_cid, state_root) from STDIN`)
+	if err != nil {
+		return err
+	}
+
+	for _, m := range miners {
+		if _, err := stmt.Exec(
+			m.common.addr.String(),
+			m.state.Sectors.String(),
+			m.common.stateroot.String(),
+		); err != nil {
+			log.Errorw("failed to store miners sectors head", "state", m.state, "info", m.state.Info, "error", err)
+			return err
+		}
+
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into miner_sectors_heads select * from msh on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeMinersPreCommitState(ctx context.Context, miners []minerActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Infow("Stored Miners Precommit State", "duration", time.Since(start).String())
+	}()
+
+	precommitTx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := precommitTx.Exec(`create temp table mp (like miner_precommits excluding constraints) on commit drop;`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	precommitStmt, err := precommitTx.Prepare(`copy mp (miner_id, sector_id, precommit_deposit, precommit_epoch) from STDIN`)
+	if err != nil {
+		return err
+	}
+
+	for _, m := range miners {
+		m := m
+		pcMap, err := adt.AsMap(cw_util.NewAPIIpldStore(ctx, p.node), m.state.PreCommittedSectors)
+		if err != nil {
+			return err
+		}
+		precommit := new(miner.SectorPreCommitOnChainInfo)
+		if err := pcMap.ForEach(precommit, func(key string) error {
+			if _, err := precommitStmt.Exec(
+				m.common.addr.String(),
+				precommit.Info.SectorNumber,
+				precommit.PreCommitDeposit.String(),
+				precommit.PreCommitEpoch,
+			); err != nil {
+				return err
+			}
+
+			return nil
+		}); err != nil {
+			return err
+		}
+	}
+	if err := precommitStmt.Close(); err != nil {
+		return err
+	}
+	if _, err := precommitTx.Exec(`insert into miner_precommits select * from mp on conflict do nothing`); err != nil {
+		return err
+	}
+
+	return precommitTx.Commit()
+}
+
+func (p *Processor) updateMiners(ctx context.Context, miners []minerActorInfo) error {
+	// TODO when/if there is more than one update operation here use an errgroup as is done in persistMiners
+	if err := p.updateMinersSectors(ctx, miners); err != nil {
+		return err
+	}
+
+	if err := p.updateMinersPrecommits(ctx, miners); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (p *Processor) updateMinersPrecommits(ctx context.Context, miners []minerActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Infow("Updated Miner Precommits", "duration", time.Since(start).String())
+	}()
+
+	pred := state.NewStatePredicates(p.node)
+
+	eventTx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := eventTx.Exec(`create temp table mse (like miner_sector_events excluding constraints) on commit drop;`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	eventStmt, err := eventTx.Prepare(`copy mse (sector_id, event, miner_id, state_root) from STDIN `)
+	if err != nil {
+		return err
+	}
+
+	for _, m := range miners {
+		pcDiffFn := pred.OnMinerActorChange(m.common.addr, pred.OnMinerPreCommitChange())
+		changed, val, err := pcDiffFn(ctx, m.common.parentTsKey, m.common.tsKey)
+		if err != nil {
+			if strings.Contains(err.Error(), "address not found") {
+				continue
+			}
+			log.Errorw("error getting miner precommit diff", "miner", m.common.addr, "error", err)
+			return err
+		}
+		if !changed {
+			continue
+		}
+		changes, ok := val.(*state.MinerPreCommitChanges)
+		if !ok {
+			log.Fatal("Developer Error")
+		}
+		for _, added := range changes.Added {
+			if _, err := eventStmt.Exec(added.Info.SectorNumber, "PRECOMMIT", m.common.addr.String(), m.common.stateroot.String()); err != nil {
+				return err
+			}
+		}
+	}
+
+	if err := eventStmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := eventTx.Exec(`insert into miner_sector_events select * from mse on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return eventTx.Commit()
+}
+
+func (p *Processor) updateMinersSectors(ctx context.Context, miners []minerActorInfo) error {
+	log.Debugw("Updating Miners Sectors", "#miners", len(miners))
+	start := time.Now()
+	defer func() {
+		log.Debugw("Updated Miners Sectors", "duration", time.Since(start).String())
+	}()
+
+	pred := state.NewStatePredicates(p.node)
+
+	eventTx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := eventTx.Exec(`create temp table mse (like miner_sector_events excluding constraints) on commit drop;`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	eventStmt, err := eventTx.Prepare(`copy mse (sector_id, event, miner_id, state_root) from STDIN `)
+	if err != nil {
+		return err
+	}
+
+	var updateWg sync.WaitGroup
+	updateWg.Add(1)
+	sectorUpdatesCh := make(chan sectorUpdate)
+	var sectorUpdates []sectorUpdate
+	go func() {
+		for u := range sectorUpdatesCh {
+			sectorUpdates = append(sectorUpdates, u)
+		}
+		updateWg.Done()
+	}()
+
+	minerGrp, ctx := errgroup.WithContext(ctx)
+	complete := 0
+	for _, m := range miners {
+		m := m
+		if m.common.tsKey == p.genesisTs.Key() {
+			genSectors, err := p.node.StateMinerSectors(ctx, m.common.addr, nil, true, p.genesisTs.Key())
+			if err != nil {
+				return err
+			}
+			for _, sector := range genSectors {
+				if _, err := eventStmt.Exec(sector.ID, "COMMIT", m.common.addr.String(), m.common.stateroot.String()); err != nil {
+					return err
+				}
+			}
+			complete++
+			continue
+		}
+		minerGrp.Go(func() error {
+			// special case genesis miners
+			sectorDiffFn := pred.OnMinerActorChange(m.common.addr, pred.OnMinerSectorChange())
+			changed, val, err := sectorDiffFn(ctx, m.common.parentTsKey, m.common.tsKey)
+			if err != nil {
+				if strings.Contains(err.Error(), "address not found") {
+					return nil
+				}
+				log.Errorw("error getting miner sector diff", "miner", m.common.addr, "error", err)
+				return err
+			}
+			if !changed {
+				complete++
+				return nil
+			}
+			changes, ok := val.(*state.MinerSectorChanges)
+			if !ok {
+				log.Fatalw("Developer Error")
+			}
+			log.Debugw("sector changes for miner", "miner", m.common.addr.String(), "Added", len(changes.Added), "Extended", len(changes.Extended), "Removed", len(changes.Removed), "oldState", m.common.parentTsKey, "newState", m.common.tsKey)
+
+			for _, extended := range changes.Extended {
+				if _, err := eventStmt.Exec(extended.To.Info.SectorNumber, "EXTENDED", m.common.addr.String(), m.common.stateroot.String()); err != nil {
+					return err
+				}
+				sectorUpdatesCh <- sectorUpdate{
+					terminationEpoch: 0,
+					terminated:       false,
+					expirationEpoch:  extended.To.Info.Expiration,
+					sectorID:         extended.From.Info.SectorNumber,
+					minerID:          m.common.addr,
+				}
+
+				log.Debugw("sector extended", "miner", m.common.addr.String(), "sector", extended.To.Info.SectorNumber, "old", extended.To.Info.Expiration, "new", extended.From.Info.Expiration)
+			}
+			curTs, err := p.node.ChainGetTipSet(ctx, m.common.tsKey)
+			if err != nil {
+				return err
+			}
+
+			for _, removed := range changes.Removed {
+				log.Debugw("removed", "miner", m.common.addr)
+				// decide if they were terminated or extended
+				if removed.Info.Expiration > curTs.Height() {
+					if _, err := eventStmt.Exec(removed.Info.SectorNumber, "TERMINATED", m.common.addr.String(), m.common.stateroot.String()); err != nil {
+						return err
+					}
+					log.Debugw("sector terminated", "miner", m.common.addr.String(), "sector", removed.Info.SectorNumber, "old", "sectorExpiration", removed.Info.Expiration, "terminationEpoch", curTs.Height())
+					sectorUpdatesCh <- sectorUpdate{
+						terminationEpoch: curTs.Height(),
+						terminated:       true,
+						expirationEpoch:  removed.Info.Expiration,
+						sectorID:         removed.Info.SectorNumber,
+						minerID:          m.common.addr,
+					}
+
+				}
+				if _, err := eventStmt.Exec(removed.Info.SectorNumber, "EXPIRED", m.common.addr.String(), m.common.stateroot.String()); err != nil {
+					return err
+				}
+				log.Debugw("sector removed", "miner", m.common.addr.String(), "sector", removed.Info.SectorNumber, "old", "sectorExpiration", removed.Info.Expiration, "currEpoch", curTs.Height())
+			}
+
+			for _, added := range changes.Added {
+				if _, err := eventStmt.Exec(added.Info.SectorNumber, "COMMIT", m.common.addr.String(), m.common.stateroot.String()); err != nil {
+					return err
+				}
+			}
+			complete++
+			log.Debugw("Update Done", "complete", complete, "added", len(changes.Added), "removed", len(changes.Removed), "modified", len(changes.Extended))
+			return nil
+		})
+	}
+	if err := minerGrp.Wait(); err != nil {
+		return err
+	}
+	close(sectorUpdatesCh)
+	// wait for the update channel to be drained
+	updateWg.Wait()
+
+	if err := eventStmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := eventTx.Exec(`insert into miner_sector_events select * from mse on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	if err := eventTx.Commit(); err != nil {
+		return err
+	}
+
+	updateTx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	updateStmt, err := updateTx.Prepare(`UPDATE miner_sectors SET termination_epoch=$1, expiration_epoch=$2 WHERE miner_id=$3 AND sector_id=$4`)
+	if err != nil {
+		return err
+	}
+
+	for _, update := range sectorUpdates {
+		if update.terminated {
+			if _, err := updateStmt.Exec(update.terminationEpoch, update.expirationEpoch, update.minerID.String(), update.sectorID); err != nil {
+				return err
+			}
+		} else {
+			if _, err := updateStmt.Exec(nil, update.expirationEpoch, update.minerID.String(), update.sectorID); err != nil {
+				return err
+			}
+		}
+	}
+
+	if err := updateStmt.Close(); err != nil {
+		return err
+	}
+
+	return updateTx.Commit()
+}
+
+// load the power actor state clam as an adt.Map at the tipset `ts`.
+func getPowerActorClaimsMap(ctx context.Context, api api.FullNode, ts types.TipSetKey) (*adt.Map, error) {
+	powerActor, err := api.StateGetActor(ctx, builtin.StoragePowerActorAddr, ts)
+	if err != nil {
+		return nil, err
+	}
+
+	powerRaw, err := api.ChainReadObj(ctx, powerActor.Head)
+	if err != nil {
+		return nil, err
+	}
+
+	var powerActorState power.State
+	if err := powerActorState.UnmarshalCBOR(bytes.NewReader(powerRaw)); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal power actor state: %w", err)
+	}
+
+	s := cw_util.NewAPIIpldStore(ctx, api)
+	return adt.AsMap(s, powerActorState.Claims)
+}

cmd/lotus-chainwatch/processor/mpool.go

@@ -0,0 +1,103 @@
+package processor
+
+import (
+	"context"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func (p *Processor) subMpool(ctx context.Context) {
+	sub, err := p.node.MpoolSub(ctx)
+	if err != nil {
+		return
+	}
+
+	for {
+		var updates []api.MpoolUpdate
+
+		select {
+		case update := <-sub:
+			updates = append(updates, update)
+		case <-ctx.Done():
+			return
+		}
+
+	loop:
+		for {
+			time.Sleep(10 * time.Millisecond)
+			select {
+			case update := <-sub:
+				updates = append(updates, update)
+			default:
+				break loop
+			}
+		}
+
+		msgs := map[cid.Cid]*types.Message{}
+		for _, v := range updates {
+			if v.Type != api.MpoolAdd {
+				continue
+			}
+
+			msgs[v.Message.Message.Cid()] = &v.Message.Message
+		}
+
+		log.Debugf("Processing %d mpool updates", len(msgs))
+
+		err := p.storeMessages(msgs)
+		if err != nil {
+			log.Error(err)
+		}
+
+		if err := p.storeMpoolInclusions(updates); err != nil {
+			log.Error(err)
+		}
+	}
+}
+
+func (p *Processor) storeMpoolInclusions(msgs []api.MpoolUpdate) error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+		create temp table mi (like mpool_messages excluding constraints) on commit drop;
+	`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy mi (msg, add_ts) from stdin `)
+	if err != nil {
+		return err
+	}
+
+	for _, msg := range msgs {
+		if msg.Type != api.MpoolAdd {
+			continue
+		}
+
+		if _, err := stmt.Exec(
+			msg.Message.Message.Cid().String(),
+			time.Now().Unix(),
+		); err != nil {
+			return err
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into mpool_messages select * from mi on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}

cmd/lotus-chainwatch/processor/processor.go

@@ -0,0 +1,344 @@
+package processor
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"sync"
+	"time"
+
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/parmap"
+)
+
+var log = logging.Logger("processor")
+
+type Processor struct {
+	db *sql.DB
+
+	node api.FullNode
+
+	genesisTs *types.TipSet
+
+	// number of blocks processed at a time
+	batch int
+}
+
+type ActorTips map[types.TipSetKey][]actorInfo
+
+type actorInfo struct {
+	act types.Actor
+
+	stateroot cid.Cid
+	height    abi.ChainEpoch // so that we can walk the actor changes in chronological order.
+
+	tsKey       types.TipSetKey
+	parentTsKey types.TipSetKey
+
+	addr  address.Address
+	state string
+}
+
+func NewProcessor(db *sql.DB, node api.FullNode, batch int) *Processor {
+	return &Processor{
+		db:    db,
+		node:  node,
+		batch: batch,
+	}
+}
+
+func (p *Processor) setupSchemas() error {
+	if err := p.setupMarket(); err != nil {
+		return err
+	}
+
+	if err := p.setupMiners(); err != nil {
+		return err
+	}
+
+	if err := p.setupRewards(); err != nil {
+		return err
+	}
+
+	if err := p.setupMessages(); err != nil {
+		return err
+	}
+
+	if err := p.setupCommonActors(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (p *Processor) Start(ctx context.Context) {
+	log.Debug("Starting Processor")
+
+	if err := p.setupSchemas(); err != nil {
+		log.Fatalw("Failed to setup processor", "error", err)
+	}
+
+	var err error
+	p.genesisTs, err = p.node.ChainGetGenesis(ctx)
+	if err != nil {
+		log.Fatalw("Failed to get genesis state from lotus", "error", err.Error())
+	}
+
+	go p.subMpool(ctx)
+
+	// main processor loop
+	go func() {
+		for {
+			select {
+			case <-ctx.Done():
+				log.Debugw("Stopping Processor...")
+				return
+			default:
+				toProcess, err := p.unprocessedBlocks(ctx, p.batch)
+				if err != nil {
+					log.Fatalw("Failed to get unprocessed blocks", "error", err)
+				}
+
+				if len(toProcess) == 0 {
+					log.Debugw("No unprocessed blocks. Wait then try again...")
+					time.Sleep(time.Second * 10)
+					continue
+				}
+
+				// TODO special case genesis state handling here to avoid all the special cases that will be needed for it else where
+				// before doing "normal" processing.
+
+				actorChanges, err := p.collectActorChanges(ctx, toProcess)
+				if err != nil {
+					log.Fatalw("Failed to collect actor changes", "error", err)
+				}
+
+				grp, ctx := errgroup.WithContext(ctx)
+
+				grp.Go(func() error {
+					if err := p.HandleMarketChanges(ctx, actorChanges[builtin.StorageMarketActorCodeID]); err != nil {
+						return xerrors.Errorf("Failed to handle market changes: %w", err)
+					}
+					return nil
+				})
+
+				grp.Go(func() error {
+					if err := p.HandleMinerChanges(ctx, actorChanges[builtin.StorageMinerActorCodeID]); err != nil {
+						return xerrors.Errorf("Failed to handle miner changes: %w", err)
+					}
+					return nil
+				})
+
+				grp.Go(func() error {
+					if err := p.HandleRewardChanges(ctx, actorChanges[builtin.RewardActorCodeID]); err != nil {
+						return xerrors.Errorf("Failed to handle reward changes: %w", err)
+					}
+					return nil
+				})
+
+				grp.Go(func() error {
+					if err := p.HandleMessageChanges(ctx, toProcess); err != nil {
+						return xerrors.Errorf("Failed to handle message changes: %w", err)
+					}
+					return nil
+				})
+
+				grp.Go(func() error {
+					if err := p.HandleCommonActorsChanges(ctx, actorChanges); err != nil {
+						return xerrors.Errorf("Failed to handle common actor changes: %w", err)
+					}
+					return nil
+				})
+
+				if err := grp.Wait(); err != nil {
+					log.Errorw("Failed to handle actor changes...retrying", "error", err)
+					continue
+				}
+
+				if err := p.markBlocksProcessed(ctx, toProcess); err != nil {
+					log.Fatalw("Failed to mark blocks as processed", "error", err)
+				}
+
+				if err := p.refreshViews(); err != nil {
+					log.Errorw("Failed to refresh views", "error", err)
+				}
+			}
+		}
+	}()
+
+}
+
+func (p *Processor) refreshViews() error {
+	if _, err := p.db.Exec(`refresh materialized view state_heights`); err != nil {
+		return err
+	}
+
+	if _, err := p.db.Exec(`refresh materialized view miner_sectors_view`); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (p *Processor) collectActorChanges(ctx context.Context, toProcess map[cid.Cid]*types.BlockHeader) (map[cid.Cid]ActorTips, error) {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Collected Actor Changes", "duration", time.Since(start).String())
+	}()
+	// ActorCode - > tipset->[]actorInfo
+	out := map[cid.Cid]ActorTips{}
+	var outMu sync.Mutex
+
+	// map of addresses to changed actors
+	var changes map[string]types.Actor
+	actorsSeen := map[cid.Cid]struct{}{}
+
+	// collect all actor state that has changes between block headers
+	paDone := 0
+	parmap.Par(50, parmap.MapArr(toProcess), func(bh *types.BlockHeader) {
+		paDone++
+		if paDone%100 == 0 {
+			log.Debugw("Collecting actor changes", "done", paDone, "percent", (paDone*100)/len(toProcess))
+		}
+
+		pts, err := p.node.ChainGetTipSet(ctx, types.NewTipSetKey(bh.Parents...))
+		if err != nil {
+			panic(err)
+		}
+
+		// collect all actors that had state changes between the blockheader parent-state and its grandparent-state.
+		// TODO: changes will contain deleted actors, this causes needless processing further down the pipeline, consider
+		// a separate strategy for deleted actors
+		changes, err = p.node.StateChangedActors(ctx, pts.ParentState(), bh.ParentStateRoot)
+		if err != nil {
+			panic(err)
+		}
+
+		// record the state of all actors that have changed
+		for a, act := range changes {
+			act := act
+			a := a
+
+			addr, err := address.NewFromString(a)
+			if err != nil {
+				panic(err)
+			}
+
+			ast, err := p.node.StateReadState(ctx, addr, pts.Key())
+			if err != nil {
+				panic(err)
+			}
+
+			// TODO look here for an empty state, maybe thats a sign the actor was deleted?
+
+			state, err := json.Marshal(ast.State)
+			if err != nil {
+				panic(err)
+			}
+
+			outMu.Lock()
+			if _, ok := actorsSeen[act.Head]; !ok {
+				_, ok := out[act.Code]
+				if !ok {
+					out[act.Code] = map[types.TipSetKey][]actorInfo{}
+				}
+				out[act.Code][pts.Key()] = append(out[act.Code][pts.Key()], actorInfo{
+					act:         act,
+					stateroot:   bh.ParentStateRoot,
+					height:      bh.Height,
+					tsKey:       pts.Key(),
+					parentTsKey: pts.Parents(),
+					addr:        addr,
+					state:       string(state),
+				})
+			}
+			actorsSeen[act.Head] = struct{}{}
+			outMu.Unlock()
+		}
+	})
+	return out, nil
+}
+
+func (p *Processor) unprocessedBlocks(ctx context.Context, batch int) (map[cid.Cid]*types.BlockHeader, error) {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Gathered Blocks to process", "duration", time.Since(start).String())
+	}()
+	rows, err := p.db.Query(`
+with toProcess as (
+    select blocks.cid, blocks.height, rank() over (order by height) as rnk
+    from blocks
+        left join blocks_synced bs on blocks.cid = bs.cid
+    where bs.processed_at is null and blocks.height > 0
+)
+select cid
+from toProcess
+where rnk <= $1
+`, batch)
+	if err != nil {
+		return nil, xerrors.Errorf("Failed to query for unprocessed blocks: %w", err)
+	}
+	out := map[cid.Cid]*types.BlockHeader{}
+
+	// TODO consider parallel execution here for getting the blocks from the api as is done in fetchMessages()
+	for rows.Next() {
+		if rows.Err() != nil {
+			return nil, err
+		}
+		var c string
+		if err := rows.Scan(&c); err != nil {
+			return nil, xerrors.Errorf("Failed to scan unprocessed blocks: %w", err)
+		}
+		ci, err := cid.Parse(c)
+		if err != nil {
+			return nil, xerrors.Errorf("Failed to parse unprocessed blocks: %w", err)
+		}
+		bh, err := p.node.ChainGetBlock(ctx, ci)
+		if err != nil {
+			// this is a pretty serious issue.
+			return nil, xerrors.Errorf("Failed to get block header %s: %w", ci.String(), err)
+		}
+		out[ci] = bh
+	}
+	return out, rows.Close()
+}
+
+func (p *Processor) markBlocksProcessed(ctx context.Context, processed map[cid.Cid]*types.BlockHeader) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Marked blocks as Processed", "duration", time.Since(start).String())
+	}()
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	processedAt := time.Now().Unix()
+	stmt, err := tx.Prepare(`update blocks_synced set processed_at=$1 where cid=$2`)
+	if err != nil {
+		return err
+	}
+
+	for c := range processed {
+		if _, err := stmt.Exec(processedAt, c.String()); err != nil {
+			return err
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}

cmd/lotus-chainwatch/processor/reward.go

@@ -0,0 +1,231 @@
+package processor
+
+import (
+	"bytes"
+	"context"
+	"time"
+
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/reward"
+)
+
+type rewardActorInfo struct {
+	common actorInfo
+
+	// expected power in bytes during this epoch
+	baselinePower big.Int
+
+	// base reward in attofil for each block found during this epoch
+	baseBlockReward big.Int
+}
+
+func (p *Processor) setupRewards() error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+/*
+* captures base block reward per miner per state root and does not
+* include penalties or gas reward
+*/
+create table if not exists base_block_rewards
+(
+	state_root text not null
+		constraint block_rewards_pk
+			primary key,
+	base_block_reward numeric not null
+);
+
+/* captures chain-specific power state for any given stateroot */
+create table if not exists chain_power
+(
+	state_root text not null
+		constraint chain_power_pk
+			primary key,
+	baseline_power text not null
+);
+
+create materialized view if not exists top_miners_by_base_reward as
+	with total_rewards_by_miner as (
+		select
+			b.miner,
+			sum(bbr.base_block_reward) as total_reward
+		from blocks b
+		inner join base_block_rewards bbr on b.parentstateroot = bbr.state_root
+		group by 1
+	) select
+		rank() over (order by total_reward desc),
+		miner,
+		total_reward
+	from total_rewards_by_miner
+	group by 2, 3;
+
+create index if not exists top_miners_by_base_reward_miner_index
+	on top_miners_by_base_reward (miner);
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+
+}
+
+func (p *Processor) HandleRewardChanges(ctx context.Context, rewardTips ActorTips) error {
+	rewardChanges, err := p.processRewardActors(ctx, rewardTips)
+	if err != nil {
+		log.Fatalw("Failed to process reward actors", "error", err)
+	}
+
+	if err := p.persistRewardActors(ctx, rewardChanges); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (p *Processor) processRewardActors(ctx context.Context, rewardTips ActorTips) ([]rewardActorInfo, error) {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Processed Reward Actors", "duration", time.Since(start).String())
+	}()
+
+	var out []rewardActorInfo
+	for tipset, rewards := range rewardTips {
+		for _, act := range rewards {
+			var rw rewardActorInfo
+			rw.common = act
+
+			// get reward actor states at each tipset once for all updates
+			rewardActor, err := p.node.StateGetActor(ctx, builtin.RewardActorAddr, tipset)
+			if err != nil {
+				return nil, xerrors.Errorf("get reward state (@ %s): %w", rw.common.stateroot.String(), err)
+			}
+
+			rewardStateRaw, err := p.node.ChainReadObj(ctx, rewardActor.Head)
+			if err != nil {
+				return nil, xerrors.Errorf("read state obj (@ %s): %w", rw.common.stateroot.String(), err)
+			}
+
+			var rewardActorState reward.State
+			if err := rewardActorState.UnmarshalCBOR(bytes.NewReader(rewardStateRaw)); err != nil {
+				return nil, xerrors.Errorf("unmarshal state (@ %s): %w", rw.common.stateroot.String(), err)
+			}
+
+			rw.baseBlockReward = rewardActorState.LastPerEpochReward
+			rw.baselinePower = rewardActorState.BaselinePower
+			out = append(out, rw)
+		}
+	}
+	return out, nil
+}
+
+func (p *Processor) persistRewardActors(ctx context.Context, rewards []rewardActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Persisted Reward Actors", "duration", time.Since(start).String())
+	}()
+
+	grp, ctx := errgroup.WithContext(ctx)
+
+	grp.Go(func() error {
+		if err := p.storeChainPower(rewards); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	grp.Go(func() error {
+		if err := p.storeBaseBlockReward(rewards); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	return grp.Wait()
+}
+
+func (p *Processor) storeChainPower(rewards []rewardActorInfo) error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return xerrors.Errorf("begin chain_power tx: %w", err)
+	}
+
+	if _, err := tx.Exec(`create temp table cp (like chain_power excluding constraints) on commit drop`); err != nil {
+		return xerrors.Errorf("prep chain_power temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy cp (state_root, baseline_power) from STDIN`)
+	if err != nil {
+		return xerrors.Errorf("prepare tmp chain_power: %w", err)
+	}
+
+	for _, rewardState := range rewards {
+		if _, err := stmt.Exec(
+			rewardState.common.stateroot.String(),
+			rewardState.baselinePower.String(),
+		); err != nil {
+			log.Errorw("failed to store chain power", "state_root", rewardState.common.stateroot, "error", err)
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return xerrors.Errorf("close prepared chain_power: %w", err)
+	}
+
+	if _, err := tx.Exec(`insert into chain_power select * from cp on conflict do nothing`); err != nil {
+		return xerrors.Errorf("insert chain_power from tmp: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return xerrors.Errorf("commit chain_power tx: %w", err)
+	}
+
+	return nil
+}
+
+func (p *Processor) storeBaseBlockReward(rewards []rewardActorInfo) error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return xerrors.Errorf("begin base_block_reward tx: %w", err)
+	}
+
+	if _, err := tx.Exec(`create temp table bbr (like base_block_rewards excluding constraints) on commit drop`); err != nil {
+		return xerrors.Errorf("prep base_block_reward temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy bbr (state_root, base_block_reward) from STDIN`)
+	if err != nil {
+		return xerrors.Errorf("prepare tmp base_block_reward: %w", err)
+	}
+
+	for _, rewardState := range rewards {
+		baseBlockReward := big.Div(rewardState.baseBlockReward, big.NewIntUnsigned(build.BlocksPerEpoch))
+		if _, err := stmt.Exec(
+			rewardState.common.stateroot.String(),
+			baseBlockReward.String(),
+		); err != nil {
+			log.Errorw("failed to store base block reward", "state_root", rewardState.common.stateroot, "error", err)
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return xerrors.Errorf("close prepared base_block_reward: %w", err)
+	}
+
+	if _, err := tx.Exec(`insert into base_block_rewards select * from bbr on conflict do nothing`); err != nil {
+		return xerrors.Errorf("insert base_block_reward from tmp: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return xerrors.Errorf("commit base_block_reward tx: %w", err)
+	}
+
+	return nil
+}

cmd/lotus-chainwatch/run.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"database/sql"
+	"os"
+
+	_ "github.com/lib/pq"
+
+	lcli "github.com/filecoin-project/lotus/cli"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/cmd/lotus-chainwatch/processor"
+	"github.com/filecoin-project/lotus/cmd/lotus-chainwatch/syncer"
+)
+
+var runCmd = &cli.Command{
+	Name:  "run",
+	Usage: "Start lotus chainwatch",
+	Flags: []cli.Flag{
+		&cli.IntFlag{
+			Name:  "max-batch",
+			Value: 1000,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		ll := cctx.String("log-level")
+		if err := logging.SetLogLevel("*", ll); err != nil {
+			return err
+		}
+		if err := logging.SetLogLevel("rpc", "error"); err != nil {
+			return err
+		}
+
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		v, err := api.Version(ctx)
+		if err != nil {
+			return err
+		}
+
+		log.Infof("Remote version: %s", v.Version)
+
+		maxBatch := cctx.Int("max-batch")
+
+		db, err := sql.Open("postgres", cctx.String("db"))
+		if err != nil {
+			return err
+		}
+		defer func() {
+			if err := db.Close(); err != nil {
+				log.Errorw("Failed to close database", "error", err)
+			}
+		}()
+
+		if err := db.Ping(); err != nil {
+			return xerrors.Errorf("Database failed to respond to ping (is it online?): %w", err)
+		}
+		db.SetMaxOpenConns(1350)
+
+		sync := syncer.NewSyncer(db, api)
+		sync.Start(ctx)
+
+		proc := processor.NewProcessor(db, api, maxBatch)
+		proc.Start(ctx)
+
+		<-ctx.Done()
+		os.Exit(0)
+		return nil
+	},
+}

cmd/lotus-chainwatch/site/block.html

@@ -1,61 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Lotus ChainWatch</title>
-    <link rel="stylesheet" type="text/css" href="main.css">
-</head>
-<body>
-{{$cid := param "cid"}}
-
-<div class="Index">
-    <div class="Index-header">
-        <div>
-            <span>Lotus ChainWatch - Wallets</span>
-        </div>
-    </div>
-    <div class="Index-nodes">
-        <div class="Index-node">
-            <div>Miner: {{index (strings "blocks" "miner" "cid=$1" $cid) 0}}</div>
-            <div>Parents:</div>
-            <div>
-                {{range strings "block_parents" "parent" "block=$1" $cid}}
-                    {{$parent := .}}
-                    <a href="block.html?cid={{$parent}}">{{. | substr 54 62}}</a>
-                {{end}}
-            </div>
-            <div>Messages:</div>
-            <table>
-                {{range strings "block_messages" "message" "block=$1" $cid}}
-                    {{$msg := .}}
-                    <tr>
-                        <td><a href="message.html?cid={{$msg}}">{{$msg | substr 54 62}}</a></td>
-                        <td>
-                            {{$from := qstr "select \"from\" from messages where cid=$1" $msg}}
-                            {{$nonce := qstr "select nonce from messages where cid=$1" $msg}}
-                            <a href="key.html?w={{$from}}">{{$from}}</a> (N:{{$nonce}})
-                        </td>
-                        <td>-&gt;</td>
-                        <td>
-                            {{$to := qstr "select \"to\" from messages where cid=$1" $msg}}
-                            <a href="key.html?w={{$to}}">{{$to}}</a>
-                        </td>
-                        <td>
-                            Method:<b>{{qstr "select method from messages where cid=$1" $msg}}</b>
-                        </td>
-                        {{$rec := qstrs `select r.exit, r.gas_used from messages
-                            inner join block_messages bm on messages.cid = bm.message
-                            inner join blocks b on bm.block = b.cid
-                            inner join block_parents bp on b.cid = bp.parent
-                            inner join blocks chd on bp.block = chd.cid
-                            inner join receipts r on messages.cid = r.msg and chd.parentStateRoot = r.state
-                            where messages.cid=$1 and b.cid=$2` 2 $msg $cid}}
-                        <td>exit:<b>{{index $rec 0}}</b></td>
-                        <td>gasUsed:<b>{{index $rec 1}}</b></td>
-                    </tr>
-                {{end}}
-            </table>
-        </div>
-    </div>
-</div>
-</body>
-</html>

cmd/lotus-chainwatch/site/blocks.html

@@ -1,43 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Lotus ChainWatch</title>
-    <link rel="stylesheet" type="text/css" href="main.css">
-</head>
-<body>
-{{$start := param "start" | parseInt}}
-
-<div class="Index">
-    <div class="Index-header">
-        <div>
-            <span>Lotus ChainWatch - Wallets</span>
-        </div>
-    </div>
-    <div class="Index-nodes">
-        <div class="Index-node">
-            <table>
-                {{range pageDown $start 50}}
-                    <tr>
-                        <td>
-                            {{$h := .}}
-                            {{$h}};
-                        </td>
-                        <td>
-                            <b>{{qstr `select count(distinct block_messages.message) from block_messages
-                                    inner join blocks b on block_messages.block = b.cid
-                                    where b.height = $1` $h}}</b> Msgs
-                        </td>
-                        <td>
-                            {{range strings "blocks" "cid" "height = $1" $h}}
-                                <a href="block.html?cid={{.}}">{{. | substr 54 62}}</a>
-                            {{end}}
-                        </td>
-                    </tr>
-                {{end}}
-            </table>
-            <a href="blocks.html?start={{sub $start 50}}">Next 50</a>
-        </div>
-    </div>
-</div>
-</body>
-</html>

cmd/lotus-chainwatch/site/index.html

@@ -1,37 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Lotus ChainWatch</title>
-    <link rel="stylesheet" type="text/css" href="main.css">
-</head>
-<body>
-<div class="Index">
-    <div class="Index-header">
-        <div>
-            <span>Lotus ChainWatch</span>
-        </div>
-    </div>
-    <div class="Index-nodes">
-        <div class="Index-node">
-            <b>{{countCol "actors" "id"}}</b> Actors;
-            <b>{{countCol "miner_heads" "addr"}}</b> Miners;
-            <b>{{netPower "slashed_at = 0" | sizeStr}}</b> Power
-            (<b>{{netPower "" | sizeStr}}</b> Total;
-            <b>{{netPower "slashed_at > 0" | sizeStr}}</b> Slashed)
-        </div>
-        <div class="Index-node">
-            {{count "messages"}} Messages; {{count "actors"}}  state changes
-        </div>
-        <div class="Index-node">
-            {{count "id_address_map" "id != address"}} <a href="keys.html">Keys</a>;
-            E% FIL in wallets; F% FIL in miners; M% in market; %G Other actors; %H FIL it treasury
-        </div>
-        <div class="Index-node">
-            {{$maxH := queryNum "select max(height) from blocks inner join blocks_synced bs on blocks.cid = bs.cid"}}
-
-            {{count "blocks"}} <a href="blocks.html?start={{$maxH}}">Blocks</a>; Current Height: {{$maxH}};
-        </div>
-    </div>
-</div>
-</body>
-</html>

cmd/lotus-chainwatch/site/key.html

@@ -1,40 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Lotus ChainWatch</title>
-    <link rel="stylesheet" type="text/css" href="main.css">
-</head>
-<body>
-{{$wallet := param "w"}}
-
-<div class="Index">
-    <div class="Index-header">
-        <div>
-            <span>Lotus ChainWatch - Wallet {{$wallet}}</span>
-        </div>
-    </div>
-    <div class="Index-nodes">
-        <div class="Index-node">
-            Balance: {{queryNum "select balance from actors inner join id_address_map m on m.address = $1 where actors.id = m.id order by nonce desc limit 1" $wallet }}
-        </div>
-        <div class="Index-node">
-            Messages:
-            <table>
-                <tr><td>Dir</td><td>Peer</td><td>Nonce</td><td>Value</td><td>Block</td><td>Mpool Wait</td></tr>
-                {{ range messages "\"from\" = $1 or \"to\" = $1" $wallet}}
-                    <tr>
-                        {{ if eq .From.String $wallet }}
-                            <td>To</td><td><a href="key.html?w={{.To.String}}">{{.To.String}}</a></td>
-                        {{else}}
-                            <td>From</td><td><a href="key.html?w={{.From.String}}">{{.From.String}}</a></td>
-                        {{end}}
-                        <td>{{.Nonce}}</td>
-                        <td>{{.Value}}</td>
-                    </tr>
-                {{end}}
-            </table>
-        </div>
-    </div>
-</div>
-</body>
-</html>

cmd/lotus-chainwatch/site/keys.html

@@ -1,28 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Lotus ChainWatch</title>
-    <link rel="stylesheet" type="text/css" href="main.css">
-</head>
-<body>
-<div class="Index">
-    <div class="Index-header">
-        <div>
-            <span>Lotus ChainWatch - Wallets</span>
-        </div>
-    </div>
-    <div class="Index-nodes">
-        <div class="Index-node">
-           {{range strings "id_address_map" "address" "address != id"}}
-               {{$addr := .}}
-               <div>
-                   <a href="key.html?w={{$addr}}">{{$addr}}</a>
-                   <span><b>{{qstr "select count(distinct cid) from messages where \"from\"=$1" $addr}}</b> outmsgs;</span>
-                   <span><b>{{qstr "select count(distinct cid) from messages where \"to\"=$1" $addr}}</b> inmsgs</span>
-               </div>
-           {{end}}
-        </div>
-    </div>
-</div>
-</body>
-</html>

cmd/lotus-chainwatch/site/main.css

@@ -1,66 +0,0 @@
-body {
-    font-family: 'monospace';
-    background: #1f1f1f;
-    color: #f0f0f0;
-    padding: 0;
-    margin: 0;
-}
-
-b {
-    color: #aff;
-}
-
-.Index {
-    width: 100vw;
-    height: 100vh;
-    background: #1a1a1a;
-    color: #f0f0f0;
-    font-family: monospace;
-    overflow: auto;
-
-    display: grid;
-    grid-template-columns: auto 80vw auto;
-    grid-template-rows: 3em auto auto auto;
-    grid-template-areas:
-            "header header header header"
-            ". . . ."
-            ". main main ."
-            ". main main ."
-            ". main main ."
-            ". main main ."
-            ". main main ."
-            ". . . .";
-}
-
-.Index-header {
-    background: #2a2a2a;
-    grid-area: header;
-}
-
-.Index-Index-header > div {
-    padding-left: 0.7em;
-    padding-top: 0.7em;
-}
-
-.Index-nodes {
-    grid-area: main;
-    background: #2a2a2a;
-}
-
-.Index-node {
-    margin: 5px;
-    padding: 15px;
-    background: #1f1f1f;
-}
-
-a:link {
-    color: #50f020;
-}
-
-a:visited {
-    color: #50f020;
-}
-
-a:hover {
-    color: #30a00a;
-}

cmd/lotus-chainwatch/sync.go

@@ -1,596 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"container/list"
-	"context"
-	"encoding/json"
-	"fmt"
-	"math"
-	"sync"
-	"time"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-
-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/abi/big"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	"github.com/filecoin-project/specs-actors/actors/builtin/power"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-	parmap "github.com/filecoin-project/lotus/lib/parmap"
-)
-
-func runSyncer(ctx context.Context, api api.FullNode, st *storage, maxBatch int) {
-	notifs, err := api.ChainNotify(ctx)
-	if err != nil {
-		panic(err)
-	}
-	go func() {
-		for notif := range notifs {
-			for _, change := range notif {
-				switch change.Type {
-				case store.HCCurrent:
-					fallthrough
-				case store.HCApply:
-					syncHead(ctx, api, st, change.Val, maxBatch)
-				case store.HCRevert:
-					log.Warnf("revert todo")
-				}
-
-				if change.Type == store.HCCurrent {
-					go subMpool(ctx, api, st)
-					go subBlocks(ctx, api, st)
-				}
-			}
-		}
-	}()
-}
-
-type minerStateInfo struct {
-	// common
-	addr      address.Address
-	act       types.Actor
-	stateroot cid.Cid
-
-	// miner specific
-	state miner.State
-	info  miner.MinerInfo
-
-	// tracked by power actor
-	rawPower big.Int
-	qalPower big.Int
-	ssize    uint64
-	psize    uint64
-}
-
-type actorInfo struct {
-	stateroot cid.Cid
-	tsKey     types.TipSetKey
-	state     string
-}
-
-func syncHead(ctx context.Context, api api.FullNode, st *storage, headTs *types.TipSet, maxBatch int) {
-	var alk sync.Mutex
-
-	log.Infof("Getting synced block list")
-
-	hazlist := st.hasList()
-
-	log.Infof("Getting headers / actors")
-
-	// global list of all blocks that need to be synced
-	allToSync := map[cid.Cid]*types.BlockHeader{}
-	// a stack
-	toVisit := list.New()
-
-	for _, header := range headTs.Blocks() {
-		toVisit.PushBack(header)
-	}
-
-	// TODO consider making a db query to check where syncing left off at in the case of a restart and avoid reprocessing
-	// those entries, or write value to file on shutdown
-	// walk the entire chain starting from headTS
-	for toVisit.Len() > 0 {
-		bh := toVisit.Remove(toVisit.Back()).(*types.BlockHeader)
-		_, has := hazlist[bh.Cid()]
-		if _, seen := allToSync[bh.Cid()]; seen || has {
-			continue
-		}
-
-		allToSync[bh.Cid()] = bh
-		if len(allToSync)%500 == 10 {
-			log.Debugf("to visit: (%d) %s @%d", len(allToSync), bh.Cid(), bh.Height)
-		}
-
-		if len(bh.Parents) == 0 {
-			continue
-		}
-
-		pts, err := api.ChainGetTipSet(ctx, types.NewTipSetKey(bh.Parents...))
-		if err != nil {
-			log.Error(err)
-			continue
-		}
-
-		for _, header := range pts.Blocks() {
-			toVisit.PushBack(header)
-		}
-	}
-
-	// Main worker loop, this loop runs until all tipse from headTS to genesis have been processed.
-	for len(allToSync) > 0 {
-		// first map is addresses -> common actors states (head, code, balance, nonce)
-		// second map common actor states -> chain state (tipset, stateroot) & unique actor state (deserialization of their head CID) represented as json.
-		actors := map[address.Address]map[types.Actor]actorInfo{}
-
-		// map of actor public key address to ID address
-		addressToID := map[address.Address]address.Address{}
-		minH := abi.ChainEpoch(math.MaxInt64)
-
-		// find the blockheader with the lowest height
-		for _, header := range allToSync {
-			if header.Height < minH {
-				minH = header.Height
-			}
-		}
-
-		// toSync maps block cids to their headers and contains all block headers that will be synced in this batch
-		// `maxBatch` is a tunable parameter to control how many blocks we sync per iteration.
-		toSync := map[cid.Cid]*types.BlockHeader{}
-		for c, header := range allToSync {
-			if header.Height < minH+abi.ChainEpoch(maxBatch) {
-				toSync[c] = header
-				addressToID[header.Miner] = address.Undef
-			}
-		}
-		// remove everything we are syncing this round from the global list of blocks to sync
-		for c := range toSync {
-			delete(allToSync, c)
-		}
-
-		log.Infow("Starting Sync", "height", minH, "numBlocks", len(toSync), "maxBatch", maxBatch)
-
-		// map of addresses to changed actors
-		var changes map[string]types.Actor
-		// collect all actor state that has changes between block headers
-		paDone := 0
-		parmap.Par(50, parmap.MapArr(toSync), func(bh *types.BlockHeader) {
-			paDone++
-			if paDone%100 == 0 {
-				log.Infof("pa: %d %d%%", paDone, (paDone*100)/len(toSync))
-			}
-
-			if len(bh.Parents) == 0 { // genesis case
-				genesisTs, _ := types.NewTipSet([]*types.BlockHeader{bh})
-				aadrs, err := api.StateListActors(ctx, genesisTs.Key())
-				if err != nil {
-					log.Error(err)
-					return
-				}
-
-				// TODO suspicious there is not a lot to be gained by doing this in parallel since the genesis state
-				// is unlikely to contain a lot of actors, why not for loop here?
-				parmap.Par(50, aadrs, func(addr address.Address) {
-					act, err := api.StateGetActor(ctx, addr, genesisTs.Key())
-					if err != nil {
-						log.Error(err)
-						return
-					}
-
-					ast, err := api.StateReadState(ctx, addr, genesisTs.Key())
-					if err != nil {
-						log.Error(err)
-						return
-					}
-					state, err := json.Marshal(ast.State)
-					if err != nil {
-						log.Error(err)
-						return
-					}
-
-					alk.Lock()
-					_, ok := actors[addr]
-					if !ok {
-						actors[addr] = map[types.Actor]actorInfo{}
-					}
-					actors[addr][*act] = actorInfo{
-						stateroot: bh.ParentStateRoot,
-						tsKey:     genesisTs.Key(),
-						state:     string(state),
-					}
-					addressToID[addr] = address.Undef
-					alk.Unlock()
-				})
-
-				return
-			}
-
-			pts, err := api.ChainGetTipSet(ctx, types.NewTipSetKey(bh.Parents...))
-			if err != nil {
-				log.Error(err)
-				return
-			}
-
-			// TODO Does this return actors that have been deleted between states?
-			// collect all actors that had state changes between the blockheader parent-state and its grandparent-state.
-			changes, err = api.StateChangedActors(ctx, pts.ParentState(), bh.ParentStateRoot)
-			if err != nil {
-				log.Error(err)
-				return
-			}
-
-			// record the state of all actors that have changed
-			for a, act := range changes {
-				act := act
-
-				addr, err := address.NewFromString(a)
-				if err != nil {
-					log.Error(err)
-					return
-				}
-
-				ast, err := api.StateReadState(ctx, addr, pts.Key())
-
-				if err != nil {
-					log.Error(err)
-					return
-				}
-
-				state, err := json.Marshal(ast.State)
-				if err != nil {
-					log.Error(err)
-					return
-				}
-
-				alk.Lock()
-				_, ok := actors[addr]
-				if !ok {
-					actors[addr] = map[types.Actor]actorInfo{}
-				}
-				// a change occurred for the actor with address `addr` and state `act` at tipset `pts`.
-				actors[addr][act] = actorInfo{
-					stateroot: bh.ParentStateRoot,
-					state:     string(state),
-					tsKey:     pts.Key(),
-				}
-				addressToID[addr] = address.Undef
-				alk.Unlock()
-			}
-		})
-
-		// map of tipset to all miners that had a head-change at that tipset.
-		minerTips := make(map[types.TipSetKey][]*minerStateInfo, len(changes))
-		// heads we've seen, im being paranoid
-		headsSeen := make(map[cid.Cid]struct{}, len(actors))
-
-		log.Infof("Getting messages")
-
-		msgs, incls := fetchMessages(ctx, api, toSync)
-
-		log.Infof("Resolving addresses")
-
-		for _, message := range msgs {
-			addressToID[message.To] = address.Undef
-			addressToID[message.From] = address.Undef
-		}
-
-		parmap.Par(50, parmap.KMapArr(addressToID), func(addr address.Address) {
-			// FIXME: cannot use EmptyTSK here since actorID's can change during reorgs, need to use the corresponding tipset.
-			// TODO: figure out a way to get the corresponding tipset...
-			raddr, err := api.StateLookupID(ctx, addr, types.EmptyTSK)
-			if err != nil {
-				log.Warn(err)
-				return
-			}
-			alk.Lock()
-			addressToID[addr] = raddr
-			alk.Unlock()
-		})
-
-		log.Infof("Getting miner info")
-
-		minerChanges := 0
-		for addr, m := range actors {
-			for actor, c := range m {
-				if actor.Code != builtin.StorageMinerActorCodeID {
-					continue
-				}
-
-				// only want miner actors with head change events
-				if _, found := headsSeen[actor.Head]; found {
-					continue
-				}
-				minerChanges++
-
-				minerTips[c.tsKey] = append(minerTips[c.tsKey], &minerStateInfo{
-					addr:      addr,
-					act:       actor,
-					stateroot: c.stateroot,
-
-					state: miner.State{},
-					info:  miner.MinerInfo{},
-
-					rawPower: big.Zero(),
-					qalPower: big.Zero(),
-				})
-
-				headsSeen[actor.Head] = struct{}{}
-			}
-		}
-
-		minerProcessingStartedAt := time.Now()
-		log.Infow("Processing miners", "numTips", len(minerTips), "numMinerChanges", minerChanges)
-		// extract the power actor state at each tipset, loop over all miners that changed at said tipset and extract their
-		// claims from the power actor state. This ensures we only fetch the power actors state once for each tipset.
-		parmap.Par(50, parmap.KVMapArr(minerTips), func(it func() (types.TipSetKey, []*minerStateInfo)) {
-			tsKey, minerInfo := it()
-
-			// get the power actors claims map
-			mp, err := getPowerActorClaimsMap(ctx, api, tsKey)
-			if err != nil {
-				log.Error(err)
-				return
-			}
-			// Get miner raw and quality power
-			for _, mi := range minerInfo {
-				var claim power.Claim
-				// get miner claim from power actors claim map and store if found, else the miner had no claim at
-				// this tipset
-				found, err := mp.Get(adt.AddrKey(mi.addr), &claim)
-				if err != nil {
-					log.Error(err)
-				}
-				if found {
-					mi.qalPower = claim.QualityAdjPower
-					mi.rawPower = claim.RawBytePower
-				}
-
-				// Get the miner state info
-				astb, err := api.ChainReadObj(ctx, mi.act.Head)
-				if err != nil {
-					log.Error(err)
-					return
-				}
-				if err := mi.state.UnmarshalCBOR(bytes.NewReader(astb)); err != nil {
-					log.Error(err)
-					return
-				}
-				mi.info = mi.state.Info
-			}
-
-			// TODO Get the Sector Count
-			// FIXME this is returning a lot of "address not found" errors, which is strange given that StateChangedActors
-			// retruns all actors that had a state change at tipset `k.tsKey`, maybe its returning deleted miners too??
-			/*
-				sszs, err := api.StateMinerSectorCount(ctx, k.addr, k.tsKey)
-				if err != nil {
-					info.psize = 0
-					info.ssize = 0
-				} else {
-					info.psize = sszs.Pset
-					info.ssize = sszs.Sset
-				}
-			*/
-		})
-		log.Infow("Completed Miner Processing", "duration", time.Since(minerProcessingStartedAt).String(), "processed", minerChanges)
-
-		log.Info("Getting receipts")
-
-		receipts := fetchParentReceipts(ctx, api, toSync)
-
-		log.Info("Storing headers")
-
-		if err := st.storeHeaders(toSync, true); err != nil {
-			log.Errorf("%+v", err)
-			return
-		}
-
-		log.Info("Storing address mapping")
-
-		if err := st.storeAddressMap(addressToID); err != nil {
-			log.Error(err)
-			return
-		}
-
-		log.Info("Storing actors")
-
-		if err := st.storeActors(actors); err != nil {
-			log.Error(err)
-			return
-		}
-
-		log.Info("Storing miners")
-		if err := st.storeMiners(minerTips); err != nil {
-			log.Error(err)
-			return
-		}
-
-		log.Info("Storing miner sectors")
-		sectorStart := time.Now()
-		if err := st.storeSectors(minerTips, api); err != nil {
-			log.Error(err)
-			return
-		}
-		log.Infow("Finished storing miner sectors", "duration", time.Since(sectorStart).String())
-
-		log.Info("Storing miner sectors heads")
-		if err := st.storeMinerSectorsHeads(minerTips, api); err != nil {
-			log.Error(err)
-			return
-		}
-
-		log.Infof("Storing messages")
-
-		if err := st.storeMessages(msgs); err != nil {
-			log.Error(err)
-			return
-		}
-
-		log.Info("Storing message inclusions")
-
-		if err := st.storeMsgInclusions(incls); err != nil {
-			log.Error(err)
-			return
-		}
-
-		log.Infof("Storing parent receipts")
-
-		if err := st.storeReceipts(receipts); err != nil {
-			log.Error(err)
-			return
-		}
-		log.Infof("Sync stage done")
-	}
-
-	log.Infof("Get deals")
-
-	// TODO: incremental, gather expired
-	deals, err := api.StateMarketDeals(ctx, headTs.Key())
-	if err != nil {
-		log.Error(err)
-		return
-	}
-
-	log.Infof("Store deals")
-
-	if err := st.storeDeals(deals); err != nil {
-		log.Error(err)
-		return
-	}
-
-	log.Infof("Refresh views")
-
-	if err := st.refreshViews(); err != nil {
-		log.Error(err)
-		return
-	}
-
-	log.Infof("Sync done")
-}
-
-func fetchMessages(ctx context.Context, api api.FullNode, toSync map[cid.Cid]*types.BlockHeader) (map[cid.Cid]*types.Message, map[cid.Cid][]cid.Cid) {
-	var lk sync.Mutex
-	messages := map[cid.Cid]*types.Message{}
-	inclusions := map[cid.Cid][]cid.Cid{} // block -> msgs
-
-	parmap.Par(50, parmap.MapArr(toSync), func(header *types.BlockHeader) {
-		msgs, err := api.ChainGetBlockMessages(ctx, header.Cid())
-		if err != nil {
-			log.Error(err)
-			return
-		}
-
-		vmm := make([]*types.Message, 0, len(msgs.Cids))
-		for _, m := range msgs.BlsMessages {
-			vmm = append(vmm, m)
-		}
-
-		for _, m := range msgs.SecpkMessages {
-			vmm = append(vmm, &m.Message)
-		}
-
-		lk.Lock()
-		for _, message := range vmm {
-			messages[message.Cid()] = message
-			inclusions[header.Cid()] = append(inclusions[header.Cid()], message.Cid())
-		}
-		lk.Unlock()
-	})
-
-	return messages, inclusions
-}
-
-type mrec struct {
-	msg   cid.Cid
-	state cid.Cid
-	idx   int
-}
-
-func fetchParentReceipts(ctx context.Context, api api.FullNode, toSync map[cid.Cid]*types.BlockHeader) map[mrec]*types.MessageReceipt {
-	var lk sync.Mutex
-	out := map[mrec]*types.MessageReceipt{}
-
-	parmap.Par(50, parmap.MapArr(toSync), func(header *types.BlockHeader) {
-		recs, err := api.ChainGetParentReceipts(ctx, header.Cid())
-		if err != nil {
-			log.Error(err)
-			return
-		}
-		msgs, err := api.ChainGetParentMessages(ctx, header.Cid())
-		if err != nil {
-			log.Error(err)
-			return
-		}
-
-		lk.Lock()
-		for i, r := range recs {
-			out[mrec{
-				msg:   msgs[i].Cid,
-				state: header.ParentStateRoot,
-				idx:   i,
-			}] = r
-		}
-		lk.Unlock()
-	})
-
-	return out
-}
-
-// load the power actor state clam as an adt.Map at the tipset `ts`.
-func getPowerActorClaimsMap(ctx context.Context, api api.FullNode, ts types.TipSetKey) (*adt.Map, error) {
-	powerActor, err := api.StateGetActor(ctx, builtin.StoragePowerActorAddr, ts)
-	if err != nil {
-		return nil, err
-	}
-
-	powerRaw, err := api.ChainReadObj(ctx, powerActor.Head)
-	if err != nil {
-		return nil, err
-	}
-
-	var powerActorState power.State
-	if err := powerActorState.UnmarshalCBOR(bytes.NewReader(powerRaw)); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal power actor state: %w", err)
-	}
-
-	s := &apiIpldStore{ctx, api}
-	return adt.AsMap(s, powerActorState.Claims)
-}
-
-// require for AMT and HAMT access
-// TODO extract this to a common location in lotus and reuse the code
-type apiIpldStore struct {
-	ctx context.Context
-	api api.FullNode
-}
-
-func (ht *apiIpldStore) Context() context.Context {
-	return ht.ctx
-}
-
-func (ht *apiIpldStore) Get(ctx context.Context, c cid.Cid, out interface{}) error {
-	raw, err := ht.api.ChainReadObj(ctx, c)
-	if err != nil {
-		return err
-	}
-
-	cu, ok := out.(cbg.CBORUnmarshaler)
-	if ok {
-		if err := cu.UnmarshalCBOR(bytes.NewReader(raw)); err != nil {
-			return err
-		}
-		return nil
-	}
-	return fmt.Errorf("Object does not implement CBORUnmarshaler: %T", out)
-}
-
-func (ht *apiIpldStore) Put(ctx context.Context, v interface{}) (cid.Cid, error) {
-	return cid.Undef, fmt.Errorf("Put is not implemented on apiIpldStore")
-}

cmd/lotus-chainwatch/syncer/blockssub.go

@@ -1,25 +1,24 @@
-package main
+package syncer
 
 import (
 	"context"
+	"time"
 
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/ipfs/go-cid"
-
-	aapi "github.com/filecoin-project/lotus/api"
 )
 
-func subBlocks(ctx context.Context, api aapi.FullNode, st *storage) {
-	sub, err := api.SyncIncomingBlocks(ctx)
+func (s *Syncer) subBlocks(ctx context.Context) {
+	sub, err := s.node.SyncIncomingBlocks(ctx)
 	if err != nil {
 		log.Error(err)
 		return
 	}
 
 	for bh := range sub {
-		err := st.storeHeaders(map[cid.Cid]*types.BlockHeader{
+		err := s.storeHeaders(map[cid.Cid]*types.BlockHeader{
 			bh.Cid(): bh,
-		}, false)
+		}, false, time.Now())
 		if err != nil {
 			log.Errorf("%+v", err)
 		}

cmd/lotus-chainwatch/syncer/sync.go

@@ -0,0 +1,446 @@
+package syncer
+
+import (
+	"container/list"
+	"context"
+	"database/sql"
+	"sync"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+var log = logging.Logger("syncer")
+
+type Syncer struct {
+	db *sql.DB
+
+	headerLk sync.Mutex
+	node     api.FullNode
+}
+
+func NewSyncer(db *sql.DB, node api.FullNode) *Syncer {
+	return &Syncer{
+		db:   db,
+		node: node,
+	}
+}
+
+func (s *Syncer) setupSchemas() error {
+	tx, err := s.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create table if not exists block_cids
+(
+	cid text not null
+		constraint block_cids_pk
+			primary key
+);
+
+create unique index if not exists block_cids_cid_uindex
+	on block_cids (cid);
+
+create table if not exists blocks_synced
+(
+	cid text not null
+		constraint blocks_synced_pk
+			primary key
+	    constraint blocks_block_cids_cid_fk
+			references block_cids (cid),
+	synced_at int not null,
+	processed_at int
+);
+
+create unique index if not exists blocks_synced_cid_uindex
+	on blocks_synced (cid,processed_at);
+
+create table if not exists block_parents
+(
+	block text not null
+	    constraint blocks_block_cids_cid_fk
+			references block_cids (cid),
+	parent text not null
+);
+
+create unique index if not exists block_parents_block_parent_uindex
+	on block_parents (block, parent);
+
+create table if not exists drand_entries
+(
+    round bigint not null
+    	constraint drand_entries_pk
+			primary key,
+	data bytea not null
+);
+create unique index if not exists drand_entries_round_uindex
+	on drand_entries (round);
+
+create table if not exists block_drand_entries
+(
+    round bigint not null
+    	constraint block_drand_entries_drand_entries_round_fk
+			references drand_entries (round),
+	block text not null
+	    constraint blocks_block_cids_cid_fk
+			references block_cids (cid)
+);
+create unique index if not exists block_drand_entries_round_uindex
+	on block_drand_entries (round, block);
+
+create table if not exists blocks
+(
+	cid text not null
+		constraint blocks_pk
+			primary key
+	    constraint blocks_block_cids_cid_fk
+			references block_cids (cid),
+	parentWeight numeric not null,
+	parentStateRoot text not null,
+	height bigint not null,
+	miner text not null,
+	timestamp bigint not null,
+	ticket bytea not null,
+	eprof bytea,
+	forksig bigint not null
+);
+
+create unique index if not exists block_cid_uindex
+	on blocks (cid,height);
+
+create materialized view if not exists state_heights
+    as select distinct height, parentstateroot from blocks;
+
+create index if not exists state_heights_height_index
+	on state_heights (height);
+
+create index if not exists state_heights_parentstateroot_index
+	on state_heights (parentstateroot);
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (s *Syncer) Start(ctx context.Context) {
+	log.Debug("Starting Syncer")
+
+	if err := s.setupSchemas(); err != nil {
+		log.Fatal(err)
+	}
+
+	// doing the initial sync here lets us avoid the HCCurrent case in the switch
+	head, err := s.node.ChainHead(ctx)
+	if err != nil {
+		log.Fatalw("Failed to get chain head form lotus", "error", err)
+	}
+
+	unsynced, err := s.unsyncedBlocks(ctx, head, time.Unix(0, 0))
+	if err != nil {
+		log.Fatalw("failed to gather unsynced blocks", "error", err)
+	}
+
+	if err := s.storeHeaders(unsynced, true, time.Now()); err != nil {
+		log.Fatalw("failed to store unsynced blocks", "error", err)
+	}
+
+	// continue to keep the block headers table up to date.
+	notifs, err := s.node.ChainNotify(ctx)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	lastSynced := time.Now()
+	go func() {
+		for notif := range notifs {
+			for _, change := range notif {
+				switch change.Type {
+				case store.HCApply:
+					unsynced, err := s.unsyncedBlocks(ctx, change.Val, lastSynced)
+					if err != nil {
+						log.Errorw("failed to gather unsynced blocks", "error", err)
+					}
+
+					if len(unsynced) == 0 {
+						continue
+					}
+
+					if err := s.storeHeaders(unsynced, true, lastSynced); err != nil {
+						// so this is pretty bad, need some kind of retry..
+						// for now just log an error and the blocks will be attempted again on next notifi
+						log.Errorw("failed to store unsynced blocks", "error", err)
+					}
+
+					lastSynced = time.Now()
+				case store.HCRevert:
+					log.Debug("revert todo")
+				}
+			}
+		}
+	}()
+}
+
+func (s *Syncer) unsyncedBlocks(ctx context.Context, head *types.TipSet, since time.Time) (map[cid.Cid]*types.BlockHeader, error) {
+	// get a list of blocks we have already synced in the past 3 mins. This ensures we aren't returning the entire
+	// table every time.
+	lookback := since.Add(-(time.Minute * 3))
+	log.Debugw("Gathering unsynced blocks", "since", lookback.String())
+	hasList, err := s.syncedBlocks(lookback)
+	if err != nil {
+		return nil, err
+	}
+
+	// build a list of blocks that we have not synced.
+	toVisit := list.New()
+	for _, header := range head.Blocks() {
+		toVisit.PushBack(header)
+	}
+
+	toSync := map[cid.Cid]*types.BlockHeader{}
+
+	for toVisit.Len() > 0 {
+		bh := toVisit.Remove(toVisit.Back()).(*types.BlockHeader)
+		_, has := hasList[bh.Cid()]
+		if _, seen := toSync[bh.Cid()]; seen || has {
+			continue
+		}
+
+		toSync[bh.Cid()] = bh
+		if len(toSync)%500 == 10 {
+			log.Debugw("To visit", "toVisit", toVisit.Len(), "toSync", len(toSync), "current_height", bh.Height)
+		}
+
+		if len(bh.Parents) == 0 {
+			continue
+		}
+
+		pts, err := s.node.ChainGetTipSet(ctx, types.NewTipSetKey(bh.Parents...))
+		if err != nil {
+			log.Error(err)
+			continue
+		}
+
+		for _, header := range pts.Blocks() {
+			toVisit.PushBack(header)
+		}
+	}
+	log.Debugw("Gathered unsynced blocks", "count", len(toSync))
+	return toSync, nil
+}
+
+func (s *Syncer) syncedBlocks(timestamp time.Time) (map[cid.Cid]struct{}, error) {
+	// timestamp is used to return a configurable amount of rows based on when they were last added.
+	rws, err := s.db.Query(`select cid FROM blocks_synced where synced_at > $1`, timestamp.Unix())
+	if err != nil {
+		return nil, xerrors.Errorf("Failed to query blocks_synced: %w", err)
+	}
+	out := map[cid.Cid]struct{}{}
+
+	for rws.Next() {
+		var c string
+		if err := rws.Scan(&c); err != nil {
+			return nil, xerrors.Errorf("Failed to scan blocks_synced: %w", err)
+		}
+
+		ci, err := cid.Parse(c)
+		if err != nil {
+			return nil, xerrors.Errorf("Failed to parse blocks_synced: %w", err)
+		}
+
+		out[ci] = struct{}{}
+	}
+	return out, nil
+}
+
+func (s *Syncer) storeHeaders(bhs map[cid.Cid]*types.BlockHeader, sync bool, timestamp time.Time) error {
+	s.headerLk.Lock()
+	defer s.headerLk.Unlock()
+	if len(bhs) == 0 {
+		return nil
+	}
+	log.Debugw("Storing Headers", "count", len(bhs))
+
+	tx, err := s.db.Begin()
+	if err != nil {
+		return xerrors.Errorf("begin: %w", err)
+	}
+
+	if _, err := tx.Exec(`
+
+create temp table bc (like block_cids excluding constraints) on commit drop;
+create temp table de (like drand_entries excluding constraints) on commit drop;
+create temp table bde (like block_drand_entries excluding constraints) on commit drop;
+create temp table tbp (like block_parents excluding constraints) on commit drop;
+create temp table bs (like blocks_synced excluding constraints) on commit drop;
+create temp table b (like blocks excluding constraints) on commit drop;
+
+
+`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	{
+		stmt, err := tx.Prepare(`copy bc (cid) from STDIN`)
+		if err != nil {
+			return err
+		}
+
+		for _, bh := range bhs {
+			if _, err := stmt.Exec(bh.Cid().String()); err != nil {
+				log.Error(err)
+			}
+		}
+
+		if err := stmt.Close(); err != nil {
+			return err
+		}
+
+		if _, err := tx.Exec(`insert into block_cids select * from bc on conflict do nothing `); err != nil {
+			return xerrors.Errorf("drand entries put: %w", err)
+		}
+	}
+
+	{
+		stmt, err := tx.Prepare(`copy de (round, data) from STDIN`)
+		if err != nil {
+			return err
+		}
+
+		for _, bh := range bhs {
+			for _, ent := range bh.BeaconEntries {
+				if _, err := stmt.Exec(ent.Round, ent.Data); err != nil {
+					log.Error(err)
+				}
+			}
+		}
+
+		if err := stmt.Close(); err != nil {
+			return err
+		}
+
+		if _, err := tx.Exec(`insert into drand_entries select * from de on conflict do nothing `); err != nil {
+			return xerrors.Errorf("drand entries put: %w", err)
+		}
+	}
+
+	{
+		stmt, err := tx.Prepare(`copy bde (round, block) from STDIN`)
+		if err != nil {
+			return err
+		}
+
+		for _, bh := range bhs {
+			for _, ent := range bh.BeaconEntries {
+				if _, err := stmt.Exec(ent.Round, bh.Cid().String()); err != nil {
+					log.Error(err)
+				}
+			}
+		}
+
+		if err := stmt.Close(); err != nil {
+			return err
+		}
+
+		if _, err := tx.Exec(`insert into block_drand_entries select * from bde on conflict do nothing `); err != nil {
+			return xerrors.Errorf("block drand entries put: %w", err)
+		}
+	}
+
+	{
+		stmt, err := tx.Prepare(`copy tbp (block, parent) from STDIN`)
+		if err != nil {
+			return err
+		}
+
+		for _, bh := range bhs {
+			for _, parent := range bh.Parents {
+				if _, err := stmt.Exec(bh.Cid().String(), parent.String()); err != nil {
+					log.Error(err)
+				}
+			}
+		}
+
+		if err := stmt.Close(); err != nil {
+			return err
+		}
+
+		if _, err := tx.Exec(`insert into block_parents select * from tbp on conflict do nothing `); err != nil {
+			return xerrors.Errorf("parent put: %w", err)
+		}
+	}
+
+	if sync {
+
+		stmt, err := tx.Prepare(`copy bs (cid, synced_at) from stdin `)
+		if err != nil {
+			return err
+		}
+
+		for _, bh := range bhs {
+			if _, err := stmt.Exec(bh.Cid().String(), timestamp.Unix()); err != nil {
+				log.Error(err)
+			}
+		}
+
+		if err := stmt.Close(); err != nil {
+			return err
+		}
+
+		if _, err := tx.Exec(`insert into blocks_synced select * from bs on conflict do nothing `); err != nil {
+			return xerrors.Errorf("syncd put: %w", err)
+		}
+	}
+
+	stmt2, err := tx.Prepare(`copy b (cid, parentWeight, parentStateRoot, height, miner, "timestamp", ticket, eprof, forksig) from stdin`)
+	if err != nil {
+		return err
+	}
+
+	for _, bh := range bhs {
+		var eprof interface{}
+		if bh.ElectionProof != nil {
+			eprof = bh.ElectionProof.VRFProof
+		}
+
+		if bh.Ticket == nil {
+			log.Warnf("got a block with nil ticket")
+
+			bh.Ticket = &types.Ticket{
+				VRFProof: []byte{},
+			}
+		}
+
+		if _, err := stmt2.Exec(
+			bh.Cid().String(),
+			bh.ParentWeight.String(),
+			bh.ParentStateRoot.String(),
+			bh.Height,
+			bh.Miner.String(),
+			bh.Timestamp,
+			bh.Ticket.VRFProof,
+			eprof,
+			bh.ForkSignaling); err != nil {
+			log.Error(err)
+		}
+	}
+
+	if err := stmt2.Close(); err != nil {
+		return xerrors.Errorf("s2 close: %w", err)
+	}
+
+	if _, err := tx.Exec(`insert into blocks select * from b on conflict do nothing `); err != nil {
+		return xerrors.Errorf("blk put: %w", err)
+	}
+
+	return tx.Commit()
+}

cmd/lotus-chainwatch/templates.go

@@ -1,350 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"html/template"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strconv"
-
-	rice "github.com/GeertJohan/go.rice"
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/abi/big"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type handler struct {
-	api    api.FullNode
-	st     *storage
-	site   *rice.Box
-	assets http.Handler
-
-	templates map[string]*template.Template
-}
-
-func newHandler(api api.FullNode, st *storage) (*handler, error) {
-	h := &handler{
-		api:  api,
-		st:   st,
-		site: rice.MustFindBox("site"),
-
-		templates: map[string]*template.Template{},
-	}
-	h.assets = http.FileServer(h.site.HTTPBox())
-
-	funcs := template.FuncMap{
-		"count":    h.count,
-		"countCol": h.countCol,
-		"sum":      h.sum,
-		"netPower": h.netPower,
-		"queryNum": h.queryNum,
-		"sizeStr":  sizeStr,
-		"strings":  h.strings,
-		"qstr":     h.qstr,
-		"qstrs":    h.qstrs,
-		"messages": h.messages,
-
-		"pageDown": pageDown,
-		"parseInt": func(s string) (int, error) { i, e := strconv.ParseInt(s, 10, 64); return int(i), e },
-		"substr":   func(i, j int, s string) string { return s[i:j] },
-		"sub":      func(a, b int) int { return a - b }, // TODO: really not builtin?
-
-		"param": func(string) string { return "" }, // replaced in request handler
-	}
-
-	base := template.New("")
-
-	base.Funcs(funcs)
-
-	return h, h.site.Walk("", func(path string, info os.FileInfo, err error) error {
-		if filepath.Ext(path) != ".html" {
-			return nil
-		}
-		if err != nil {
-			return err
-		}
-		log.Info(path)
-
-		h.templates["/"+path], err = base.New(path).Parse(h.site.MustString(path))
-		return err
-	})
-}
-
-func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	h, err := newHandler(h.api, h.st) // for faster dev
-	if err != nil {
-		log.Error(err)
-		return
-	}
-
-	p := r.URL.Path
-	if p == "/" {
-		p = "/index.html"
-	}
-
-	t, ok := h.templates[p]
-	if !ok {
-		h.assets.ServeHTTP(w, r)
-		return
-	}
-
-	t, err = t.Clone()
-	if err != nil {
-		log.Error(err)
-		return
-	}
-
-	t.Funcs(map[string]interface{}{
-		"param": r.FormValue,
-	})
-
-	if err := t.Execute(w, nil); err != nil {
-		log.Errorf("%+v", err)
-		return
-	}
-
-	log.Info(r.URL.Path)
-}
-
-// Template funcs
-
-func (h *handler) count(table string, filters ...string) (int, error) {
-	// explicitly not caring about sql injection too much, this doesn't take user input
-
-	filts := ""
-	if len(filters) > 0 {
-		filts = " where "
-		for _, filter := range filters {
-			filts += filter + " and "
-		}
-		filts = filts[:len(filts)-5]
-	}
-
-	var c int
-	err := h.st.db.QueryRow("select count(1) from " + table + filts).Scan(&c)
-	if err != nil {
-		return 0, err
-	}
-
-	return c, nil
-}
-
-func (h *handler) countCol(table string, col string, filters ...string) (int, error) {
-	// explicitly not caring about sql injection too much, this doesn't take user input
-
-	filts := ""
-	if len(filters) > 0 {
-		filts = " where "
-		for _, filter := range filters {
-			filts += filter + " and "
-		}
-		filts = filts[:len(filts)-5]
-	}
-
-	var c int
-	err := h.st.db.QueryRow("select count(distinct " + col + ") from " + table + filts).Scan(&c)
-	if err != nil {
-		return 0, err
-	}
-
-	return c, nil
-}
-
-func (h *handler) sum(table string, col string) (types.BigInt, error) {
-	return h.queryNum("select sum(cast(" + col + " as bigint)) from " + table)
-}
-
-func (h *handler) netPower(slashFilt string) (types.BigInt, error) {
-	if slashFilt != "" {
-		slashFilt = " where " + slashFilt
-	}
-	return h.queryNum(`select sum(power) from (select distinct on (addr) power, slashed_at from miner_heads
-    inner join blocks b on miner_heads.stateroot = b.parentStateRoot
-order by addr, height desc) as p` + slashFilt)
-}
-
-func (h *handler) queryNum(q string, p ...interface{}) (types.BigInt, error) {
-	// explicitly not caring about sql injection too much, this doesn't take user input
-
-	var c string
-	err := h.st.db.QueryRow(q, p...).Scan(&c)
-	if err != nil {
-		log.Error("qnum ", q, p, err)
-		return types.NewInt(0), err
-	}
-
-	i := types.NewInt(0)
-	_, ok := i.SetString(c, 10)
-	if !ok {
-		return types.NewInt(0), xerrors.New("num parse error: " + c)
-	}
-	return i, nil
-}
-
-var units = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB"}
-
-func sizeStr(size types.BigInt) string {
-	size = types.BigMul(size, types.NewInt(100))
-	i := 0
-	for types.BigCmp(size, types.NewInt(102400)) >= 0 && i < len(units)-1 {
-		size = types.BigDiv(size, types.NewInt(1024))
-		i++
-	}
-	return fmt.Sprintf("%s.%s %s", types.BigDiv(size, types.NewInt(100)), types.BigMod(size, types.NewInt(100)), units[i])
-}
-
-func (h *handler) strings(table string, col string, filter string, args ...interface{}) (out []string, err error) {
-	if len(filter) > 0 {
-		filter = " where " + filter
-	}
-	log.Info("strings qstr ", "select "+col+" from "+table+filter, args)
-	rws, err := h.st.db.Query("select "+col+" from "+table+filter, args...)
-	if err != nil {
-		return nil, err
-	}
-	for rws.Next() {
-		var r string
-		if err := rws.Scan(&r); err != nil {
-			return nil, err
-		}
-		out = append(out, r)
-	}
-
-	return
-}
-
-func (h *handler) qstr(q string, p ...interface{}) (string, error) {
-	// explicitly not caring about sql injection too much, this doesn't take user input
-
-	r, err := h.qstrs(q, 1, p...)
-	if err != nil {
-		return "", err
-	}
-	return r[0], nil
-}
-
-func (h *handler) qstrs(q string, n int, p ...interface{}) ([]string, error) {
-	// explicitly not caring about sql injection too much, this doesn't take user input
-
-	c := make([]string, n)
-	ia := make([]interface{}, n)
-	for i := range c {
-		ia[i] = &c[i]
-	}
-	err := h.st.db.QueryRow(q, p...).Scan(ia...)
-	if err != nil {
-		log.Error("qnum ", q, p, err)
-		return nil, err
-	}
-
-	return c, nil
-}
-
-type sbig types.BigInt
-
-func (bi *sbig) Scan(value interface{}) error {
-	switch value := value.(type) {
-	case string:
-		i, ok := big.NewInt(0).SetString(value, 10)
-		if !ok {
-			if value == "<nil>" {
-				return nil
-			}
-			return xerrors.Errorf("failed to parse bigint string: '%s'", value)
-		}
-
-		bi.Int = i
-
-		return nil
-	case int64:
-		bi.Int = big.NewInt(value).Int
-		return nil
-	default:
-		return xerrors.Errorf("non-string types unsupported: %T", value)
-	}
-}
-
-type Message struct {
-	To   address.Address
-	From address.Address
-
-	Nonce uint64
-
-	Value sbig
-
-	GasPrice sbig
-	GasLimit int64
-
-	Method abi.MethodNum
-	Params []byte
-}
-
-func (h *handler) messages(filter string, args ...interface{}) (out []types.Message, err error) {
-	if len(filter) > 0 {
-		filter = " where " + filter
-	}
-
-	log.Info("select * from messages " + filter)
-
-	rws, err := h.st.db.Query("select * from messages "+filter, args...)
-	if err != nil {
-		return nil, err
-	}
-	for rws.Next() {
-		var r Message
-		var cs string
-
-		if err := rws.Scan(
-			&cs,
-			&r.From,
-			&r.To,
-			&r.Nonce,
-			&r.Value,
-			&r.GasPrice,
-			&r.GasLimit,
-			&r.Method,
-			&r.Params,
-		); err != nil {
-			return nil, err
-		}
-
-		c, err := cid.Parse(cs)
-		if err != nil {
-			return nil, err
-		}
-		tr := types.Message{
-			To:       r.To,
-			From:     r.From,
-			Nonce:    r.Nonce,
-			Value:    types.BigInt(r.Value),
-			GasPrice: types.BigInt(r.GasPrice),
-			GasLimit: r.GasLimit,
-			Method:   r.Method,
-			Params:   r.Params,
-		}
-		if c != tr.Cid() {
-			log.Warn("msg cid doesn't match")
-		}
-
-		out = append(out, tr)
-	}
-
-	return
-}
-
-func pageDown(base, n int) []int {
-	out := make([]int, n)
-	for i := range out {
-		out[i] = base - i
-	}
-
-	return out
-}
-
-var _ http.Handler = &handler{}

cmd/lotus-chainwatch/util/contextStore.go

@@ -0,0 +1,51 @@
+package util
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+
+	"github.com/filecoin-project/lotus/api"
+)
+
+// TODO extract this to a common location in lotus and reuse the code
+
+// APIIpldStore is required for AMT and HAMT access.
+type APIIpldStore struct {
+	ctx context.Context
+	api api.FullNode
+}
+
+func NewAPIIpldStore(ctx context.Context, api api.FullNode) *APIIpldStore {
+	return &APIIpldStore{
+		ctx: ctx,
+		api: api,
+	}
+}
+
+func (ht *APIIpldStore) Context() context.Context {
+	return ht.ctx
+}
+
+func (ht *APIIpldStore) Get(ctx context.Context, c cid.Cid, out interface{}) error {
+	raw, err := ht.api.ChainReadObj(ctx, c)
+	if err != nil {
+		return err
+	}
+
+	cu, ok := out.(cbg.CBORUnmarshaler)
+	if ok {
+		if err := cu.UnmarshalCBOR(bytes.NewReader(raw)); err != nil {
+			return err
+		}
+		return nil
+	}
+	return fmt.Errorf("Object does not implement CBORUnmarshaler: %T", out)
+}
+
+func (ht *APIIpldStore) Put(ctx context.Context, v interface{}) (cid.Cid, error) {
+	return cid.Undef, fmt.Errorf("Put is not implemented on APIIpldStore")
+}

cmd/lotus-fountain/main.go

@@ -4,9 +4,13 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"html/template"
+	"io"
+	"io/ioutil"
 	"net"
 	"net/http"
 	"os"
+	"sort"
 	"strconv"
 	"time"
 
@@ -28,12 +32,47 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 )
 
 var log = logging.Logger("main")
 
 var sendPerRequest, _ = types.ParseFIL("50")
 
+var supportedSectors struct {
+	SectorSizes []struct {
+		Name    string
+		Value   uint64
+		Default bool
+	}
+}
+
+func init() {
+	for supportedSector, _ := range miner.SupportedProofTypes {
+		sectorSize, err := supportedSector.SectorSize()
+		if err != nil {
+			panic(err)
+		}
+
+		supportedSectors.SectorSizes = append(supportedSectors.SectorSizes, struct {
+			Name    string
+			Value   uint64
+			Default bool
+		}{
+			Name:    sectorSize.ShortString(),
+			Value:   uint64(sectorSize),
+			Default: false,
+		})
+
+	}
+
+	sort.Slice(supportedSectors.SectorSizes[:], func(i, j int) bool {
+		return supportedSectors.SectorSizes[i].Value < supportedSectors.SectorSizes[j].Value
+	})
+
+	supportedSectors.SectorSizes[0].Default = true
+}
+
 func main() {
 	logging.SetLogLevel("*", "INFO")
 
@@ -125,6 +164,7 @@ var runCmd = &cli.Command{
 		}
 
 		http.Handle("/", http.FileServer(rice.MustFindBox("site").HTTPBox()))
+		http.HandleFunc("/miner.html", h.minerhtml)
 		http.HandleFunc("/send", h.send)
 		http.HandleFunc("/mkminer", h.mkminer)
 		http.HandleFunc("/msgwait", h.msgwait)
@@ -153,6 +193,37 @@ type handler struct {
 	defaultMinerPeer peer.ID
 }
 
+func (h *handler) minerhtml(w http.ResponseWriter, r *http.Request) {
+	f, err := rice.MustFindBox("site").Open("_miner.html")
+	if err != nil {
+		w.WriteHeader(500)
+		_, _ = w.Write([]byte(err.Error()))
+		return
+	}
+
+	tmpl, err := ioutil.ReadAll(f)
+	if err != nil {
+		w.WriteHeader(500)
+		_, _ = w.Write([]byte(err.Error()))
+		return
+	}
+
+	var executedTmpl bytes.Buffer
+
+	t, err := template.New("miner.html").Parse(string(tmpl))
+	if err := t.Execute(&executedTmpl, supportedSectors); err != nil {
+		w.WriteHeader(500)
+		_, _ = w.Write([]byte(err.Error()))
+		return
+	}
+
+	if _, err := io.Copy(w, &executedTmpl); err != nil {
+		log.Errorf("failed to write template to string %s", err)
+	}
+
+	return
+}
+
 func (h *handler) send(w http.ResponseWriter, r *http.Request) {
 	to, err := address.NewFromString(r.FormValue("address"))
 	if err != nil {

cmd/lotus-fountain/site/_miner.html

@@ -15,8 +15,9 @@
                 <span>Enter owner/worker address:</span>
                 <input type='text' name='address' style="width: 300px" placeholder="t3...">
                 <select name="sectorSize">
-                    <option selected value="34359738368">32GiB sectors</option>
-                    <option value="68719476736">64GiB sectors</option>
+                    {{range .SectorSizes}}
+                    <option {{if .Default}}selected{{end}} value="{{ .Value }}">{{ .Name }}</option>
+                    {{end}}
                 </select>
                 <button type='submit'>Create Miner</button>
             </form>

cmd/lotus-seed/main.go

@@ -89,6 +89,10 @@ var preSealCmd = &cli.Command{
 			Value: "",
 			Usage: "(optional) Key to use for signing / owner/worker addresses",
 		},
+		&cli.BoolFlag{
+			Name:  "fake-sectors",
+			Value: false,
+		},
 	},
 	Action: func(c *cli.Context) error {
 		sdir := c.String("sector-dir")
@@ -126,7 +130,7 @@ var preSealCmd = &cli.Command{
 			return err
 		}
 
-		gm, key, err := seed.PreSeal(maddr, rp, abi.SectorNumber(c.Uint64("sector-offset")), c.Int("num-sectors"), sbroot, []byte(c.String("ticket-preimage")), k)
+		gm, key, err := seed.PreSeal(maddr, rp, abi.SectorNumber(c.Uint64("sector-offset")), c.Int("num-sectors"), sbroot, []byte(c.String("ticket-preimage")), k, c.Bool("fake-sectors"))
 		if err != nil {
 			return err
 		}

cmd/lotus-seed/seed/seed.go

@@ -17,7 +17,9 @@ import (
 	"github.com/minio/blake2b-simd"
 	"golang.org/x/xerrors"
 
+	ffi "github.com/filecoin-project/filecoin-ffi"
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/sector-storage/zerocomm"
 	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"github.com/filecoin-project/specs-actors/actors/builtin/market"
@@ -33,7 +35,7 @@ import (
 
 var log = logging.Logger("preseal")
 
-func PreSeal(maddr address.Address, spt abi.RegisteredSealProof, offset abi.SectorNumber, sectors int, sbroot string, preimage []byte, key *types.KeyInfo) (*genesis.Miner, *types.KeyInfo, error) {
+func PreSeal(maddr address.Address, spt abi.RegisteredSealProof, offset abi.SectorNumber, sectors int, sbroot string, preimage []byte, key *types.KeyInfo, fakeSectors bool) (*genesis.Miner, *types.KeyInfo, error) {
 	mid, err := address.IDFromAddress(maddr)
 	if err != nil {
 		return nil, nil, err
@@ -68,41 +70,20 @@ func PreSeal(maddr address.Address, spt abi.RegisteredSealProof, offset abi.Sect
 		sid := abi.SectorID{Miner: abi.ActorID(mid), Number: next}
 		next++
 
-		pi, err := sb.AddPiece(context.TODO(), sid, nil, abi.PaddedPieceSize(ssize).Unpadded(), rand.Reader)
-		if err != nil {
-			return nil, nil, err
+		var preseal *genesis.PreSeal
+		if !fakeSectors {
+			preseal, err = presealSector(sb, sbfs, sid, spt, ssize, preimage)
+			if err != nil {
+				return nil, nil, err
+			}
+		} else {
+			preseal, err = presealSectorFake(sbfs, sid, spt, ssize)
+			if err != nil {
+				return nil, nil, err
+			}
 		}
 
-		trand := blake2b.Sum256(preimage)
-		ticket := abi.SealRandomness(trand[:])
-
-		fmt.Printf("sector-id: %d, piece info: %v\n", sid, pi)
-
-		in2, err := sb.SealPreCommit1(context.TODO(), sid, ticket, []abi.PieceInfo{pi})
-		if err != nil {
-			return nil, nil, xerrors.Errorf("commit: %w", err)
-		}
-
-		cids, err := sb.SealPreCommit2(context.TODO(), sid, in2)
-		if err != nil {
-			return nil, nil, xerrors.Errorf("commit: %w", err)
-		}
-
-		if err := sb.FinalizeSector(context.TODO(), sid, nil); err != nil {
-			return nil, nil, xerrors.Errorf("trim cache: %w", err)
-		}
-
-		if err := cleanupUnsealed(sbfs, sid); err != nil {
-			return nil, nil, xerrors.Errorf("remove unsealed file: %w", err)
-		}
-
-		log.Warn("PreCommitOutput: ", sid, cids.Sealed, cids.Unsealed)
-		sealedSectors = append(sealedSectors, &genesis.PreSeal{
-			CommR:     cids.Sealed,
-			CommD:     cids.Unsealed,
-			SectorID:  sid.Number,
-			ProofType: spt,
-		})
+		sealedSectors = append(sealedSectors, preseal)
 	}
 
 	var minerAddr *wallet.Key
@@ -165,6 +146,69 @@ func PreSeal(maddr address.Address, spt abi.RegisteredSealProof, offset abi.Sect
 	return miner, &minerAddr.KeyInfo, nil
 }
 
+func presealSector(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, sid abi.SectorID, spt abi.RegisteredSealProof, ssize abi.SectorSize, preimage []byte) (*genesis.PreSeal, error) {
+	pi, err := sb.AddPiece(context.TODO(), sid, nil, abi.PaddedPieceSize(ssize).Unpadded(), rand.Reader)
+	if err != nil {
+		return nil, err
+	}
+
+	trand := blake2b.Sum256(preimage)
+	ticket := abi.SealRandomness(trand[:])
+
+	fmt.Printf("sector-id: %d, piece info: %v\n", sid, pi)
+
+	in2, err := sb.SealPreCommit1(context.TODO(), sid, ticket, []abi.PieceInfo{pi})
+	if err != nil {
+		return nil, xerrors.Errorf("commit: %w", err)
+	}
+
+	cids, err := sb.SealPreCommit2(context.TODO(), sid, in2)
+	if err != nil {
+		return nil, xerrors.Errorf("commit: %w", err)
+	}
+
+	if err := sb.FinalizeSector(context.TODO(), sid, nil); err != nil {
+		return nil, xerrors.Errorf("trim cache: %w", err)
+	}
+
+	if err := cleanupUnsealed(sbfs, sid); err != nil {
+		return nil, xerrors.Errorf("remove unsealed file: %w", err)
+	}
+
+	log.Warn("PreCommitOutput: ", sid, cids.Sealed, cids.Unsealed)
+
+	return &genesis.PreSeal{
+		CommR:     cids.Sealed,
+		CommD:     cids.Unsealed,
+		SectorID:  sid.Number,
+		ProofType: spt,
+	}, nil
+}
+
+func presealSectorFake(sbfs *basicfs.Provider, sid abi.SectorID, spt abi.RegisteredSealProof, ssize abi.SectorSize) (*genesis.PreSeal, error) {
+	paths, done, err := sbfs.AcquireSector(context.TODO(), sid, 0, stores.FTSealed|stores.FTCache, true)
+	if err != nil {
+		return nil, xerrors.Errorf("acquire unsealed sector: %w", err)
+	}
+	defer done()
+
+	if err := os.Mkdir(paths.Cache, 0755); err != nil {
+		return nil, xerrors.Errorf("mkdir cache: %w", err)
+	}
+
+	commr, err := ffi.FauxRep(spt, paths.Cache, paths.Sealed)
+	if err != nil {
+		return nil, xerrors.Errorf("fauxrep: %w", err)
+	}
+
+	return &genesis.PreSeal{
+		CommR:     commr,
+		CommD:     zerocomm.ZeroPieceCommitment(abi.PaddedPieceSize(ssize).Unpadded()),
+		SectorID:  sid.Number,
+		ProofType: spt,
+	}, nil
+}
+
 func cleanupUnsealed(sbfs *basicfs.Provider, sid abi.SectorID) error {
 	paths, done, err := sbfs.AcquireSector(context.TODO(), sid, stores.FTUnsealed, stores.FTNone, stores.PathSealing)
 	if err != nil {

cmd/lotus-shed/keyinfo.go

@@ -121,8 +121,7 @@ var keyinfoImportCmd = &cli.Command{
 			fmt.Printf("%s\n", peerid.String())
 
 			break
-		case wallet.KTSecp256k1:
-		case wallet.KTBLS:
+		case wallet.KTSecp256k1, wallet.KTBLS:
 			w, err := wallet.NewWallet(keystore)
 			if err != nil {
 				return err
@@ -223,8 +222,7 @@ var keyinfoInfoCmd = &cli.Command{
 			kio.PublicKey = base64.StdEncoding.EncodeToString(pkBytes)
 
 			break
-		case wallet.KTSecp256k1:
-		case wallet.KTBLS:
+		case wallet.KTSecp256k1, wallet.KTBLS:
 			kio.Type = keyInfo.Type
 
 			key, err := wallet.NewKey(keyInfo)
@@ -311,8 +309,7 @@ var keyinfoNewCmd = &cli.Command{
 			keyInfo = ki
 
 			break
-		case wallet.KTSecp256k1:
-		case wallet.KTBLS:
+		case wallet.KTSecp256k1, wallet.KTBLS:
 			key, err := wallet.GenerateKey(wallet.ActSigType(keyType))
 			if err != nil {
 				return err

cmd/lotus-shed/verifreg.go

@@ -3,7 +3,9 @@ package main
 import (
 	"bytes"
 	"fmt"
+
 	"github.com/filecoin-project/lotus/build"
+	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/urfave/cli/v2"
@@ -199,7 +201,7 @@ var verifRegListVerifiersCmd = &cli.Command{
 			return err
 		}
 
-		vh, err := hamt.LoadNode(ctx, cst, st.Verifiers)
+		vh, err := hamt.LoadNode(ctx, cst, st.Verifiers, hamt.UseTreeBitWidth(5))
 		if err != nil {
 			return err
 		}
@@ -251,7 +253,7 @@ var verifRegListClientsCmd = &cli.Command{
 			return err
 		}
 
-		vh, err := hamt.LoadNode(ctx, cst, st.VerifiedClients)
+		vh, err := hamt.LoadNode(ctx, cst, st.VerifiedClients, hamt.UseTreeBitWidth(5))
 		if err != nil {
 			return err
 		}
@@ -312,14 +314,14 @@ var verifRegCheckClientCmd = &cli.Command{
 			return err
 		}
 
-		vh, err := hamt.LoadNode(ctx, cst, st.VerifiedClients)
+		vh, err := hamt.LoadNode(ctx, cst, st.VerifiedClients, hamt.UseTreeBitWidth(5))
 		if err != nil {
 			return err
 		}
 
 		var dcap verifreg.DataCap
 		if err := vh.Find(ctx, string(caddr.Bytes()), &dcap); err != nil {
-			return err
+			return xerrors.Errorf("failed to lookup address: %w", err)
 		}
 
 		fmt.Println(dcap)
@@ -361,7 +363,7 @@ var verifRegCheckVerifierCmd = &cli.Command{
 			return err
 		}
 
-		vh, err := hamt.LoadNode(ctx, cst, st.Verifiers)
+		vh, err := hamt.LoadNode(ctx, cst, st.Verifiers, hamt.UseTreeBitWidth(5))
 		if err != nil {
 			return err
 		}

cmd/lotus-stats/README.md

@@ -1,6 +1,6 @@
-# Stats
+# lotus-stats
 
-Stats is a small tool to push chain information into influxdb
+`lotus-stats` is a small tool to push chain information into influxdb
 
 ## Setup
 
@@ -14,13 +14,13 @@ INFLUX_PASS=""
 
 ## Usage
 
-Stats will be default look in `~/.lotus` to connect to a running daemon and resume collecting stats from last record block height.
+lotus-stats will be default look in `~/.lotus` to connect to a running daemon and resume collecting stats from last record block height.
 
-For other usage see `./stats --help`
+For other usage see `./lotus-stats --help`
 
 ```
-go build -o stats *.go 
-. env.stats && ./stats
+go build -o lotus-stats *.go 
+. env.stats && ./lotus-stats
 ```
 
 

cmd/lotus-stats/main.go

@@ -0,0 +1,72 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"os"
+
+	"github.com/filecoin-project/lotus/tools/stats"
+	logging "github.com/ipfs/go-log/v2"
+)
+
+var log = logging.Logger("stats")
+
+const (
+	influxAddrEnvVar = "INFLUX_ADDR"
+	influxUserEnvVar = "INFLUX_USER"
+	influxPassEnvVar = "INFLUX_PASS"
+)
+
+func main() {
+	var repo string = "~/.lotus"
+	var database string = "lotus"
+	var reset bool = false
+	var nosync bool = false
+	var height int64 = 0
+	var headlag int = 3
+
+	flag.StringVar(&repo, "repo", repo, "lotus repo path")
+	flag.StringVar(&database, "database", database, "influx database")
+	flag.Int64Var(&height, "height", height, "block height to start syncing from (0 will resume)")
+	flag.IntVar(&headlag, "head-lag", headlag, "number of head events to hold to protect against small reorgs")
+	flag.BoolVar(&reset, "reset", reset, "truncate database before starting stats gathering")
+	flag.BoolVar(&nosync, "nosync", nosync, "skip waiting for sync")
+
+	flag.Parse()
+
+	ctx := context.Background()
+
+	influx, err := stats.InfluxClient(os.Getenv(influxAddrEnvVar), os.Getenv(influxUserEnvVar), os.Getenv(influxPassEnvVar))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if reset {
+		if err := stats.ResetDatabase(influx, database); err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	if !reset && height == 0 {
+		h, err := stats.GetLastRecordedHeight(influx, database)
+		if err != nil {
+			log.Info(err)
+		}
+
+		height = h
+	}
+
+	api, closer, err := stats.GetFullNodeAPI(repo)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer closer()
+
+	if !nosync {
+		if err := stats.WaitForSyncComplete(ctx, api); err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	stats.Collect(ctx, api, influx, database, height, headlag)
+}

cmd/lotus-storage-miner/info.go

@@ -44,7 +44,7 @@ var infoCmd = &cli.Command{
 
 		ctx := lcli.ReqContext(cctx)
 
-		maddr, err := nodeApi.ActorAddress(ctx)
+		maddr, err := getActorAddress(ctx, nodeApi, cctx.String("actor"))
 		if err != nil {
 			return err
 		}

cmd/lotus-storage-miner/init.go

@@ -359,10 +359,8 @@ func migratePreSealMeta(ctx context.Context, api lapi.FullNode, metadata string,
 		}*/
 	}
 
-	log.Infof("Setting next sector ID to %d", maxSectorID+1)
-
 	buf := make([]byte, binary.MaxVarintLen64)
-	size := binary.PutUvarint(buf, uint64(maxSectorID+1))
+	size := binary.PutUvarint(buf, uint64(maxSectorID))
 	return mds.Put(datastore.NewKey(modules.StorageCounterDSPrefix), buf[:size])
 }
 

cmd/lotus-storage-miner/main.go

@@ -1,12 +1,16 @@
 package main
 
 import (
+	"context"
 	"os"
 
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/urfave/cli/v2"
 	"go.opencensus.io/trace"
+	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	lcli "github.com/filecoin-project/lotus/cli"
 	"github.com/filecoin-project/lotus/lib/lotuslog"
@@ -62,6 +66,12 @@ func main() {
 		Version:              build.UserVersion(),
 		EnableBashCompletion: true,
 		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "actor",
+				Value:   "",
+				Usage:   "specify other actor to check state for (read only)",
+				Aliases: []string{"a"},
+			},
 			&cli.StringFlag{
 				Name:    "repo",
 				EnvVars: []string{"LOTUS_PATH"},
@@ -85,3 +95,19 @@ func main() {
 		os.Exit(1)
 	}
 }
+
+func getActorAddress(ctx context.Context, nodeAPI api.StorageMiner, overrideMaddr string) (maddr address.Address, err error) {
+	if overrideMaddr != "" {
+		maddr, err = address.NewFromString(overrideMaddr)
+		if err != nil {
+			return maddr, err
+		}
+	}
+
+	maddr, err = nodeAPI.ActorAddress(ctx)
+	if err != nil {
+		return maddr, xerrors.Errorf("getting actor address: %w", err)
+	}
+
+	return maddr, nil
+}

cmd/lotus-storage-miner/proving.go

@@ -48,9 +48,9 @@ var provingFaultsCmd = &cli.Command{
 
 		ctx := lcli.ReqContext(cctx)
 
-		maddr, err := nodeApi.ActorAddress(ctx)
+		maddr, err := getActorAddress(ctx, nodeApi, cctx.String("actor"))
 		if err != nil {
-			return xerrors.Errorf("getting actor address: %w", err)
+			return err
 		}
 
 		var mas miner.State
@@ -73,6 +73,7 @@ var provingFaultsCmd = &cli.Command{
 		}
 		if len(faults) == 0 {
 			fmt.Println("no faulty sectors")
+			return nil
 		}
 		head, err := api.ChainHead(ctx)
 		if err != nil {
@@ -116,9 +117,9 @@ var provingInfoCmd = &cli.Command{
 
 		ctx := lcli.ReqContext(cctx)
 
-		maddr, err := nodeApi.ActorAddress(ctx)
+		maddr, err := getActorAddress(ctx, nodeApi, cctx.String("actor"))
 		if err != nil {
-			return xerrors.Errorf("getting actor address: %w", err)
+			return err
 		}
 
 		head, err := api.ChainHead(ctx)
@@ -136,11 +137,6 @@ var provingInfoCmd = &cli.Command{
 			return xerrors.Errorf("getting miner deadlines: %w", err)
 		}
 
-		curDeadlineSectors, err := deadlines.Due[cd.Index].Count()
-		if err != nil {
-			return xerrors.Errorf("counting deadline sectors: %w", err)
-		}
-
 		var mas miner.State
 		{
 			mact, err := api.StateGetActor(ctx, maddr, types.EmptyTSK)
@@ -199,7 +195,15 @@ var provingInfoCmd = &cli.Command{
 		fmt.Printf("New Sectors: %d\n\n", newSectors)
 
 		fmt.Printf("Deadline Index:       %d\n", cd.Index)
-		fmt.Printf("Deadline Sectors:     %d\n", curDeadlineSectors)
+
+		if cd.Index < uint64(len(deadlines.Due)) {
+			curDeadlineSectors, err := deadlines.Due[cd.Index].Count()
+			if err != nil {
+				return xerrors.Errorf("counting deadline sectors: %w", err)
+			}
+			fmt.Printf("Deadline Sectors:     %d\n", curDeadlineSectors)
+		}
+
 		fmt.Printf("Deadline Open:        %s\n", epochTime(cd.CurrentEpoch, cd.Open))
 		fmt.Printf("Deadline Close:       %s\n", epochTime(cd.CurrentEpoch, cd.Close))
 		fmt.Printf("Deadline Challenge:   %s\n", epochTime(cd.CurrentEpoch, cd.Challenge))
@@ -239,9 +243,9 @@ var provingDeadlinesCmd = &cli.Command{
 
 		ctx := lcli.ReqContext(cctx)
 
-		maddr, err := nodeApi.ActorAddress(ctx)
+		maddr, err := getActorAddress(ctx, nodeApi, cctx.String("actor"))
 		if err != nil {
-			return xerrors.Errorf("getting actor address: %w", err)
+			return err
 		}
 
 		deadlines, err := api.StateMinerDeadlines(ctx, maddr, types.EmptyTSK)

cmd/lotus/rpc.go

@@ -63,6 +63,7 @@ func serveRPC(a api.FullNode, stop node.StopFunc, addr multiaddr.Multiaddr, shut
 	srv := &http.Server{Handler: http.DefaultServeMux}
 
 	sigCh := make(chan os.Signal, 2)
+	shutdownDone := make(chan struct{})
 	go func() {
 		select {
 		case <-sigCh:
@@ -77,10 +78,17 @@ func serveRPC(a api.FullNode, stop node.StopFunc, addr multiaddr.Multiaddr, shut
 			log.Errorf("graceful shutting down failed: %s", err)
 		}
 		log.Warn("Graceful shutdown successful")
+		_ = log.Sync() //nolint:errcheck
+		close(shutdownDone)
 	}()
 	signal.Notify(sigCh, syscall.SIGTERM, syscall.SIGINT)
 
-	return srv.Serve(manet.NetListener(lst))
+	err = srv.Serve(manet.NetListener(lst))
+	if err == http.ErrServerClosed {
+		<-shutdownDone
+		return nil
+	}
+	return err
 }
 
 func handleImport(a *impl.FullNodeAPI) func(w http.ResponseWriter, r *http.Request) {

go.mod

@@ -10,6 +10,7 @@ require (
 	github.com/Gurpartap/async v0.0.0-20180927173644-4f7f499dd9ee
 	github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d // indirect
 	github.com/coreos/go-systemd/v22 v22.0.0
+	github.com/dgraph-io/badger/v2 v2.0.3
 	github.com/docker/go-units v0.4.0
 	github.com/drand/drand v0.9.2-0.20200616080806-a94e9c1636a4
 	github.com/drand/kyber v1.1.0
@@ -30,7 +31,7 @@ require (
 	github.com/filecoin-project/go-statestore v0.1.0
 	github.com/filecoin-project/go-storedcounter v0.0.0-20200421200003-1c99c62e8a5b
 	github.com/filecoin-project/sector-storage v0.0.0-20200630180318-4c1968f62a8f
-	github.com/filecoin-project/specs-actors v0.6.2-0.20200702170846-2cd72643a5cf
+	github.com/filecoin-project/specs-actors v0.6.2-0.20200724193152-534b25bdca30
 	github.com/filecoin-project/specs-storage v0.1.1-0.20200622113353-88a9704877ea
 	github.com/filecoin-project/storage-fsm v0.0.0-20200625160832-379a4655b044
 	github.com/gbrlsnchs/jwt/v3 v3.0.0-beta.1
@@ -48,7 +49,7 @@ require (
 	github.com/ipfs/go-cid v0.0.6
 	github.com/ipfs/go-cidutil v0.0.2
 	github.com/ipfs/go-datastore v0.4.4
-	github.com/ipfs/go-ds-badger2 v0.1.0
+	github.com/ipfs/go-ds-badger2 v0.1.1-0.20200708190120-187fc06f714e
 	github.com/ipfs/go-ds-leveldb v0.4.2
 	github.com/ipfs/go-ds-measure v0.1.0
 	github.com/ipfs/go-filestore v1.0.0
@@ -74,7 +75,7 @@ require (
 	github.com/ipld/go-car v0.1.1-0.20200526133713-1c7508d55aae
 	github.com/ipld/go-ipld-prime v0.0.2-0.20200428162820-8b59dc292b8e
 	github.com/kelseyhightower/envconfig v1.4.0
-	github.com/lib/pq v1.2.0
+	github.com/lib/pq v1.7.0
 	github.com/libp2p/go-eventbus v0.2.1
 	github.com/libp2p/go-libp2p v0.10.0
 	github.com/libp2p/go-libp2p-connmgr v0.2.4
@@ -101,7 +102,7 @@ require (
 	github.com/multiformats/go-multiaddr-dns v0.2.0
 	github.com/multiformats/go-multiaddr-net v0.1.5
 	github.com/multiformats/go-multibase v0.0.3
-	github.com/multiformats/go-multihash v0.0.13
+	github.com/multiformats/go-multihash v0.0.14
 	github.com/opentracing/opentracing-go v1.1.0
 	github.com/stretchr/objx v0.2.0 // indirect
 	github.com/stretchr/testify v1.6.1
@@ -117,6 +118,7 @@ require (
 	go.uber.org/multierr v1.5.0
 	go.uber.org/zap v1.15.0
 	go4.org v0.0.0-20190313082347-94abd6928b1d // indirect
+	golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a
 	golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980
 	golang.org/x/time v0.0.0-20191024005414-555d28b269f0
 	golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543

go.sum

@@ -262,8 +262,8 @@ github.com/filecoin-project/specs-actors v0.0.0-20200210130641-2d1fbd8672cf/go.m
 github.com/filecoin-project/specs-actors v0.3.0/go.mod h1:nQYnFbQ7Y0bHZyq6HDEuVlCPR+U3z5Q3wMOQ+2aiV+Y=
 github.com/filecoin-project/specs-actors v0.6.0/go.mod h1:dRdy3cURykh2R8O/DKqy8olScl70rmIS7GrB4hB1IDY=
 github.com/filecoin-project/specs-actors v0.6.1/go.mod h1:dRdy3cURykh2R8O/DKqy8olScl70rmIS7GrB4hB1IDY=
-github.com/filecoin-project/specs-actors v0.6.2-0.20200702170846-2cd72643a5cf h1:2ERozAZteHYef3tVLVJRepzYieLtJdxvfXNUel19CeU=
-github.com/filecoin-project/specs-actors v0.6.2-0.20200702170846-2cd72643a5cf/go.mod h1:dRdy3cURykh2R8O/DKqy8olScl70rmIS7GrB4hB1IDY=
+github.com/filecoin-project/specs-actors v0.6.2-0.20200724193152-534b25bdca30 h1:7wH0V1OhS5gkjlJF/PvwS6MuS1oeVqCJlNECgf9eabw=
+github.com/filecoin-project/specs-actors v0.6.2-0.20200724193152-534b25bdca30/go.mod h1:ppIYDlWQvcfzDW0zxar53Z1Ag69er4BmFvJAtV1uDMI=
 github.com/filecoin-project/specs-storage v0.1.0 h1:PkDgTOT5W5Ao7752onjDl4QSv+sgOVdJbvFjOnD5w94=
 github.com/filecoin-project/specs-storage v0.1.0/go.mod h1:Pr5ntAaxsh+sLG/LYiL4tKzvA83Vk5vLODYhfNwOg7k=
 github.com/filecoin-project/specs-storage v0.1.1-0.20200622113353-88a9704877ea h1:iixjULRQFPn7Q9KlIqfwLJnlAXO10bbkI+xy5GKGdLY=
@@ -504,6 +504,8 @@ github.com/ipfs/go-ds-badger v0.2.3 h1:J27YvAcpuA5IvZUbeBxOcQgqnYHUPxoygc6Qxxkod
 github.com/ipfs/go-ds-badger v0.2.3/go.mod h1:pEYw0rgg3FIrywKKnL+Snr+w/LjJZVMTBRn4FS6UHUk=
 github.com/ipfs/go-ds-badger2 v0.1.0 h1:784py6lXkwlVF+K6XSuqmdMgy5l8GI6k60ngBokb9Fg=
 github.com/ipfs/go-ds-badger2 v0.1.0/go.mod h1:pbR1p817OZbdId9EvLOhKBgUVTM3BMCSTan78lDDVaw=
+github.com/ipfs/go-ds-badger2 v0.1.1-0.20200708190120-187fc06f714e h1:Xi1nil8K2lBOorBS6Ys7+hmUCzH8fr3U9ipdL/IrcEI=
+github.com/ipfs/go-ds-badger2 v0.1.1-0.20200708190120-187fc06f714e/go.mod h1:lJnws7amT9Ehqzta0gwMrRsURU04caT0iRPr1W8AsOU=
 github.com/ipfs/go-ds-leveldb v0.0.1/go.mod h1:feO8V3kubwsEF22n0YRQCffeb79OOYIykR4L04tMOYc=
 github.com/ipfs/go-ds-leveldb v0.1.0/go.mod h1:hqAW8y4bwX5LWcCtku2rFNX3vjDZCy5LZCg+cSZvYb8=
 github.com/ipfs/go-ds-leveldb v0.4.1/go.mod h1:jpbku/YqBSsBc1qgME8BkWS4AxzF2cEu1Ii2r79Hh9s=
@@ -700,8 +702,8 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/pty v1.1.3/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/lib/pq v1.2.0 h1:LXpIM/LZ5xGFhOpXAQUIMM1HdyqzVYM13zNdjCEEcA0=
-github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/lib/pq v1.7.0 h1:h93mCPfUSkaul3Ka/VG8uZdmW1uMHDGxzu0NWHuJmHY=
+github.com/lib/pq v1.7.0/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/libp2p/go-addr-util v0.0.1/go.mod h1:4ac6O7n9rIAKB1dnd+s8IbbMXkt+oBpzX4/+RACcnlQ=
 github.com/libp2p/go-addr-util v0.0.2 h1:7cWK5cdA5x72jX0g8iLrQWm5TRJZ6CzGdPEhWj7plWU=
 github.com/libp2p/go-addr-util v0.0.2/go.mod h1:Ecd6Fb3yIuLzq4bD7VcywcVSBtefcAwnUISBM3WG15E=
@@ -1098,6 +1100,8 @@ github.com/multiformats/go-multihash v0.0.9/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa
 github.com/multiformats/go-multihash v0.0.10/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew=
 github.com/multiformats/go-multihash v0.0.13 h1:06x+mk/zj1FoMsgNejLpy6QTvJqlSt/BhLEy87zidlc=
 github.com/multiformats/go-multihash v0.0.13/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc=
+github.com/multiformats/go-multihash v0.0.14 h1:QoBceQYQQtNUuf6s7wHxnE2c8bhbMqhfGzNI032se/I=
+github.com/multiformats/go-multihash v0.0.14/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc=
 github.com/multiformats/go-multistream v0.0.1/go.mod h1:fJTiDfXJVmItycydCnNx4+wSzZ5NwG2FEVAI30fiovg=
 github.com/multiformats/go-multistream v0.0.4/go.mod h1:fJTiDfXJVmItycydCnNx4+wSzZ5NwG2FEVAI30fiovg=
 github.com/multiformats/go-multistream v0.1.0/go.mod h1:fJTiDfXJVmItycydCnNx4+wSzZ5NwG2FEVAI30fiovg=

journal/journal.go

@@ -0,0 +1,146 @@
+package journal
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	logging "github.com/ipfs/go-log"
+	"golang.org/x/xerrors"
+)
+
+func InitializeSystemJournal(dir string) error {
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return err
+	}
+	j, err := OpenFSJournal(dir)
+	if err != nil {
+		return err
+	}
+	currentJournal = j
+	return nil
+}
+
+func Add(sys string, val interface{}) {
+	if currentJournal == nil {
+		log.Warn("no journal configured")
+		return
+	}
+	currentJournal.AddEntry(sys, val)
+}
+
+var log = logging.Logger("journal")
+
+var currentJournal Journal
+
+type Journal interface {
+	AddEntry(system string, obj interface{})
+	Close() error
+}
+
+// fsJournal is a basic journal backed by files on a filesystem
+type fsJournal struct {
+	fi    *os.File
+	fSize int64
+
+	lk sync.Mutex
+
+	journalDir string
+
+	incoming         chan *JournalEntry
+	journalSizeLimit int64
+
+	closing chan struct{}
+}
+
+func OpenFSJournal(dir string) (*fsJournal, error) {
+	fsj := &fsJournal{
+		journalDir:       dir,
+		incoming:         make(chan *JournalEntry, 32),
+		journalSizeLimit: 1 << 30,
+		closing:          make(chan struct{}),
+	}
+
+	if err := fsj.rollJournalFile(); err != nil {
+		return nil, err
+	}
+
+	go fsj.runLoop()
+
+	return fsj, nil
+}
+
+type JournalEntry struct {
+	System    string
+	Timestamp time.Time
+	Val       interface{}
+}
+
+func (fsj *fsJournal) putEntry(je *JournalEntry) error {
+	b, err := json.Marshal(je)
+	if err != nil {
+		return err
+	}
+	n, err := fsj.fi.Write(append(b, '\n'))
+	if err != nil {
+		return err
+	}
+
+	fsj.fSize += int64(n)
+
+	if fsj.fSize >= fsj.journalSizeLimit {
+		fsj.rollJournalFile()
+	}
+
+	return nil
+}
+
+func (fsj *fsJournal) rollJournalFile() error {
+	if fsj.fi != nil {
+		fsj.fi.Close()
+	}
+
+	nfi, err := os.Create(filepath.Join(fsj.journalDir, fmt.Sprintf("lotus-journal-%s.ndjson", time.Now().Format(time.RFC3339))))
+	if err != nil {
+		return xerrors.Errorf("failed to open journal file: %w", err)
+	}
+
+	fsj.fi = nfi
+	fsj.fSize = 0
+	return nil
+}
+
+func (fsj *fsJournal) runLoop() {
+	for {
+		select {
+		case je := <-fsj.incoming:
+			if err := fsj.putEntry(je); err != nil {
+				log.Errorw("failed to write out journal entry", "entry", je, "err", err)
+			}
+		case <-fsj.closing:
+			fsj.fi.Close()
+			return
+		}
+	}
+}
+
+func (fsj *fsJournal) AddEntry(system string, obj interface{}) {
+	je := &JournalEntry{
+		System:    system,
+		Timestamp: time.Now(),
+		Val:       obj,
+	}
+	select {
+	case fsj.incoming <- je:
+	case <-fsj.closing:
+		log.Warnw("journal closed but tried to log event", "entry", je)
+	}
+}
+
+func (fsj *fsJournal) Close() error {
+	close(fsj.closing)
+	return nil
+}

lib/bufbstore/buf_bstore.go

@@ -104,10 +104,24 @@ func (bs *BufferedBS) Get(c cid.Cid) (block.Block, error) {
 }
 
 func (bs *BufferedBS) GetSize(c cid.Cid) (int, error) {
-	panic("nyi")
+	s, err := bs.read.GetSize(c)
+	if err == bstore.ErrNotFound || s == 0 {
+		return bs.write.GetSize(c)
+	}
+
+	return s, err
 }
 
 func (bs *BufferedBS) Put(blk block.Block) error {
+	has, err := bs.read.Has(blk.Cid())
+	if err != nil {
+		return err
+	}
+
+	if has {
+		return nil
+	}
+
 	return bs.write.Put(blk)
 }
 

lib/cachebs/cachebs.go

@@ -0,0 +1,86 @@
+package cachebs
+
+import (
+	"context"
+
+	lru "github.com/hashicorp/golang-lru"
+	block "github.com/ipfs/go-block-format"
+	"github.com/ipfs/go-cid"
+	blockstore "github.com/ipfs/go-ipfs-blockstore"
+	bstore "github.com/ipfs/go-ipfs-blockstore"
+	logging "github.com/ipfs/go-log/v2"
+)
+
+var log = logging.Logger("cachebs")
+
+type CacheBS struct {
+	cache *lru.ARCCache
+	bs    bstore.Blockstore
+}
+
+func NewBufferedBstore(base blockstore.Blockstore, size int) *CacheBS {
+	c, err := lru.NewARC(size)
+	if err != nil {
+		panic(err)
+	}
+	return &CacheBS{
+		cache: c,
+		bs:    base,
+	}
+}
+
+var _ (bstore.Blockstore) = &CacheBS{}
+
+func (bs *CacheBS) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
+	return bs.bs.AllKeysChan(ctx)
+}
+
+func (bs *CacheBS) DeleteBlock(c cid.Cid) error {
+	bs.cache.Remove(c)
+
+	return bs.bs.DeleteBlock(c)
+}
+
+func (bs *CacheBS) Get(c cid.Cid) (block.Block, error) {
+	v, ok := bs.cache.Get(c)
+	if ok {
+		return v.(block.Block), nil
+	}
+
+	out, err := bs.bs.Get(c)
+	if err != nil {
+		return nil, err
+	}
+
+	bs.cache.Add(c, out)
+	return out, nil
+}
+
+func (bs *CacheBS) GetSize(c cid.Cid) (int, error) {
+	return bs.bs.GetSize(c)
+}
+
+func (bs *CacheBS) Put(blk block.Block) error {
+	bs.cache.Add(blk.Cid(), blk)
+
+	return bs.bs.Put(blk)
+}
+
+func (bs *CacheBS) Has(c cid.Cid) (bool, error) {
+	if bs.cache.Contains(c) {
+		return true, nil
+	}
+
+	return bs.bs.Has(c)
+}
+
+func (bs *CacheBS) HashOnRead(hor bool) {
+	bs.bs.HashOnRead(hor)
+}
+
+func (bs *CacheBS) PutMany(blks []block.Block) error {
+	for _, blk := range blks {
+		bs.cache.Add(blk.Cid(), blk)
+	}
+	return bs.bs.PutMany(blks)
+}

lib/ipfsbstore/ipfsbstore.go

@@ -25,10 +25,14 @@ type IpfsBstore struct {
 }
 
 func NewIpfsBstore(ctx context.Context) (*IpfsBstore, error) {
-	api, err := httpapi.NewLocalApi()
+	localApi, err := httpapi.NewLocalApi()
 	if err != nil {
 		return nil, xerrors.Errorf("getting local ipfs api: %w", err)
 	}
+	api, err := localApi.WithOptions(options.Api.Offline(true))
+	if err != nil {
+		return nil, xerrors.Errorf("setting offline mode: %s", err)
+	}
 
 	return &IpfsBstore{
 		ctx: ctx,
@@ -37,9 +41,13 @@ func NewIpfsBstore(ctx context.Context) (*IpfsBstore, error) {
 }
 
 func NewRemoteIpfsBstore(ctx context.Context, maddr multiaddr.Multiaddr) (*IpfsBstore, error) {
-	api, err := httpapi.NewApi(maddr)
+	httpApi, err := httpapi.NewApi(maddr)
 	if err != nil {
-		return nil, xerrors.Errorf("getting remote ipfs api: %w", err)
+		return nil, xerrors.Errorf("setting remote ipfs api: %w", err)
+	}
+	api, err := httpApi.WithOptions(options.Api.Offline(true))
+	if err != nil {
+		return nil, xerrors.Errorf("applying offline mode: %s", err)
 	}
 
 	return &IpfsBstore{
@@ -55,6 +63,13 @@ func (i *IpfsBstore) DeleteBlock(cid cid.Cid) error {
 func (i *IpfsBstore) Has(cid cid.Cid) (bool, error) {
 	_, err := i.api.Block().Stat(i.ctx, path.IpldPath(cid))
 	if err != nil {
+		// The underlying client is running in Offline mode.
+		// Stat() will fail with an err if the block isn't in the
+		// blockstore. If that's the case, return false without
+		// an error since that's the original intention of this method.
+		if err.Error() == "blockservice: key not found" {
+			return false, nil
+		}
 		return false, xerrors.Errorf("getting ipfs block: %w", err)
 	}
 

lib/lotuslog/levels.go

@@ -18,4 +18,6 @@ func SetupLogLevels() {
 		_ = logging.SetLogLevel("stores", "DEBUG")
 		_ = logging.SetLogLevel("nat", "INFO")
 	}
+	// Always mute RtRefreshManager because it breaks terminals
+	_ = logging.SetLogLevel("dht/RtRefreshManager", "FATAL")
 }

lotuspond/spawn.go

@@ -49,7 +49,7 @@ func (api *api) Spawn() (nodeInfo, error) {
 		}
 
 		sbroot := filepath.Join(dir, "preseal")
-		genm, ki, err := seed.PreSeal(genMiner, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, 2, sbroot, []byte("8"), nil)
+		genm, ki, err := seed.PreSeal(genMiner, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, 2, sbroot, []byte("8"), nil, false)
 		if err != nil {
 			return nodeInfo{}, xerrors.Errorf("preseal failed: %w", err)
 		}

miner/miner.go

@@ -28,7 +28,7 @@ import (
 var log = logging.Logger("miner")
 
 // returns a callback reporting whether we mined a blocks in this round
-type waitFunc func(ctx context.Context, baseTime uint64) (func(bool), error)
+type waitFunc func(ctx context.Context, baseTime uint64) (func(bool, error), error)
 
 func NewMiner(api api.FullNode, epp gen.WinningPoStProver, addr address.Address) *Miner {
 	arc, err := lru.NewARC(10000)
@@ -40,12 +40,12 @@ func NewMiner(api api.FullNode, epp gen.WinningPoStProver, addr address.Address)
 		api:     api,
 		epp:     epp,
 		address: addr,
-		waitFunc: func(ctx context.Context, baseTime uint64) (func(bool), error) {
+		waitFunc: func(ctx context.Context, baseTime uint64) (func(bool, error), error) {
 			// Wait around for half the block time in case other parents come in
 			deadline := baseTime + build.PropagationDelaySecs
 			time.Sleep(time.Until(time.Unix(int64(deadline), 0)))
 
-			return func(bool) {}, nil
+			return func(bool, error) {}, nil
 		},
 		minedBlockHeights: arc,
 	}
@@ -158,11 +158,12 @@ func (m *Miner) mine(ctx context.Context) {
 		if err != nil {
 			log.Errorf("mining block failed: %+v", err)
 			m.niceSleep(time.Second)
+			onDone(false, err)
 			continue
 		}
 		lastBase = *base
 
-		onDone(b != nil)
+		onDone(b != nil, nil)
 
 		if b != nil {
 			btime := time.Unix(int64(b.Header.Timestamp), 0)

miner/testminer.go

@@ -9,7 +9,7 @@ import (
 	lru "github.com/hashicorp/golang-lru"
 )
 
-func NewTestMiner(nextCh <-chan func(bool), addr address.Address) func(api.FullNode, gen.WinningPoStProver) *Miner {
+func NewTestMiner(nextCh <-chan func(bool, error), addr address.Address) func(api.FullNode, gen.WinningPoStProver) *Miner {
 	return func(api api.FullNode, epp gen.WinningPoStProver) *Miner {
 		arc, err := lru.NewARC(10000)
 		if err != nil {
@@ -31,8 +31,8 @@ func NewTestMiner(nextCh <-chan func(bool), addr address.Address) func(api.FullN
 	}
 }
 
-func chanWaiter(next <-chan func(bool)) func(ctx context.Context, _ uint64) (func(bool), error) {
-	return func(ctx context.Context, _ uint64) (func(bool), error) {
+func chanWaiter(next <-chan func(bool, error)) func(ctx context.Context, _ uint64) (func(bool, error), error) {
+	return func(ctx context.Context, _ uint64) (func(bool, error), error) {
 		select {
 		case <-ctx.Done():
 			return nil, ctx.Err()

node/builder.go

@@ -119,6 +119,7 @@ const (
 	ExtractApiKey
 	HeadMetricsKey
 	RunPeerTaggerKey
+	JournalKey
 
 	SetApiEndpointKey
 
@@ -150,6 +151,7 @@ func defaults() []Option {
 		Override(new(record.Validator), modules.RecordValidator),
 		Override(new(dtypes.Bootstrapper), dtypes.Bootstrapper(false)),
 		Override(new(dtypes.ShutdownChan), make(chan struct{})),
+		Override(JournalKey, modules.SetupJournal),
 
 		// Filecoin modules
 

node/impl/client/client.go

@@ -102,7 +102,7 @@ func (a *API) ClientStartDeal(ctx context.Context, params *api.StartDealParams)
 
 	md, err := a.StateMinerProvingDeadline(ctx, params.Miner, types.EmptyTSK)
 	if err != nil {
-		return nil, xerrors.Errorf("failed getting peer ID: %w", err)
+		return nil, xerrors.Errorf("failed getting miner's deadline info: %w", err)
 	}
 
 	rt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)

node/impl/full/multisig.go

@@ -2,6 +2,7 @@ package full
 
 import (
 	"context"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
@@ -26,7 +27,7 @@ type MsigAPI struct {
 	MpoolAPI  MpoolAPI
 }
 
-func (a *MsigAPI) MsigCreate(ctx context.Context, req int64, addrs []address.Address, val types.BigInt, src address.Address, gp types.BigInt) (cid.Cid, error) {
+func (a *MsigAPI) MsigCreate(ctx context.Context, req int64, addrs []address.Address, duration abi.ChainEpoch, val types.BigInt, src address.Address, gp types.BigInt) (cid.Cid, error) {
 
 	lenAddrs := int64(len(addrs))
 
@@ -50,6 +51,7 @@ func (a *MsigAPI) MsigCreate(ctx context.Context, req int64, addrs []address.Add
 	msigParams := &samsig.ConstructorParams{
 		Signers:               addrs,
 		NumApprovalsThreshold: req,
+		UnlockDuration:        duration,
 	}
 
 	enc, actErr := actors.SerializeParams(msigParams)
@@ -134,12 +136,39 @@ func (a *MsigAPI) MsigPropose(ctx context.Context, msig address.Address, to addr
 	return smsg.Cid(), nil
 }
 
+func (a *MsigAPI) MsigSwapPropose(ctx context.Context, msig address.Address, src address.Address, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+	enc, actErr := serializeSwapParams(oldAdd, newAdd)
+	if actErr != nil {
+		return cid.Undef, actErr
+	}
+
+	return a.MsigPropose(ctx, msig, msig, big.Zero(), src, uint64(builtin.MethodsMultisig.SwapSigner), enc)
+}
+
+func (a *MsigAPI) MsigSwapApprove(ctx context.Context, msig address.Address, src address.Address, txID uint64, proposer address.Address, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+	enc, actErr := serializeSwapParams(oldAdd, newAdd)
+	if actErr != nil {
+		return cid.Undef, actErr
+	}
+
+	return a.MsigApprove(ctx, msig, txID, proposer, msig, big.Zero(), src, uint64(builtin.MethodsMultisig.SwapSigner), enc)
+}
+
+func (a *MsigAPI) MsigSwapCancel(ctx context.Context, msig address.Address, src address.Address, txID uint64, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+	enc, actErr := serializeSwapParams(oldAdd, newAdd)
+	if actErr != nil {
+		return cid.Undef, actErr
+	}
+
+	return a.MsigCancel(ctx, msig, txID, msig, big.Zero(), src, uint64(builtin.MethodsMultisig.SwapSigner), enc)
+}
+
 func (a *MsigAPI) MsigApprove(ctx context.Context, msig address.Address, txID uint64, proposer address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
 	return a.msigApproveOrCancel(ctx, api.MsigApprove, msig, txID, proposer, to, amt, src, method, params)
 }
 
-func (a *MsigAPI) MsigCancel(ctx context.Context, msig address.Address, txID uint64, proposer address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
-	return a.msigApproveOrCancel(ctx, api.MsigCancel, msig, txID, proposer, to, amt, src, method, params)
+func (a *MsigAPI) MsigCancel(ctx context.Context, msig address.Address, txID uint64, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+	return a.msigApproveOrCancel(ctx, api.MsigCancel, msig, txID, src, to, amt, src, method, params)
 }
 
 func (a *MsigAPI) msigApproveOrCancel(ctx context.Context, operation api.MsigProposeResponse, msig address.Address, txID uint64, proposer address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
@@ -222,3 +251,15 @@ func (a *MsigAPI) msigApproveOrCancel(ctx context.Context, operation api.MsigPro
 
 	return smsg.Cid(), nil
 }
+
+func serializeSwapParams(old address.Address, new address.Address) ([]byte, error) {
+	enc, actErr := actors.SerializeParams(&samsig.SwapSignerParams{
+		From: old,
+		To:   new,
+	})
+	if actErr != nil {
+		return nil, actErr
+	}
+
+	return enc, nil
+}

node/impl/full/state.go

@@ -361,9 +361,32 @@ func (a *StateAPI) StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uin
 		return nil, err
 	}
 
+	var returndec interface{}
+	if recpt.ExitCode == 0 && len(recpt.Return) > 0 {
+		cmsg, err := a.Chain.GetCMessage(msg)
+		if err != nil {
+			return nil, xerrors.Errorf("failed to load message after successful receipt search: %w", err)
+		}
+
+		vmsg := cmsg.VMMessage()
+
+		t, err := stmgr.GetReturnType(ctx, a.StateManager, vmsg.To, vmsg.Method, ts)
+		if err != nil {
+			return nil, xerrors.Errorf("failed to get return type: %w", err)
+		}
+
+		if err := t.UnmarshalCBOR(bytes.NewReader(recpt.Return)); err != nil {
+			return nil, err
+		}
+
+		returndec = t
+	}
+
 	return &api.MsgLookup{
-		Receipt: *recpt,
-		TipSet:  ts,
+		Receipt:   *recpt,
+		ReturnDec: returndec,
+		TipSet:    ts.Key(),
+		Height:    ts.Height(),
 	}, nil
 }
 
@@ -376,7 +399,8 @@ func (a *StateAPI) StateSearchMsg(ctx context.Context, msg cid.Cid) (*api.MsgLoo
 	if ts != nil {
 		return &api.MsgLookup{
 			Receipt: *recpt,
-			TipSet:  ts,
+			TipSet:  ts.Key(),
+			Height:  ts.Height(),
 		}, nil
 	} else {
 		return nil, nil

node/modules/core.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"io"
 	"io/ioutil"
+	"path/filepath"
 
 	"github.com/gbrlsnchs/jwt/v3"
 	logging "github.com/ipfs/go-log/v2"
@@ -18,6 +19,7 @@ import (
 	"github.com/filecoin-project/lotus/api/apistruct"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/journal"
 	"github.com/filecoin-project/lotus/lib/addrutil"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/repo"
@@ -93,3 +95,7 @@ func BuiltinBootstrap() (dtypes.BootstrapPeers, error) {
 func DrandBootstrap() (dtypes.DrandBootstrap, error) {
 	return build.DrandBootstrap()
 }
+
+func SetupJournal(lr repo.LockedRepo) error {
+	return journal.InitializeSystemJournal(filepath.Join(lr.Path(), "journal"))
+}

node/node_test.go

@@ -116,7 +116,7 @@ func testStorageNode(ctx context.Context, t *testing.T, waddr address.Address, a
 	// start node
 	var minerapi api.StorageMiner
 
-	mineBlock := make(chan func(bool))
+	mineBlock := make(chan func(bool, error))
 	// TODO: use stop
 	_, err = node.New(ctx,
 		node.StorageMiner(&minerapi),
@@ -141,7 +141,7 @@ func testStorageNode(ctx context.Context, t *testing.T, waddr address.Address, a
 
 	err = minerapi.NetConnect(ctx, remoteAddrs)
 	require.NoError(t, err)*/
-	mineOne := func(ctx context.Context, cb func(bool)) error {
+	mineOne := func(ctx context.Context, cb func(bool, error)) error {
 		select {
 		case mineBlock <- cb:
 			return nil
@@ -189,7 +189,7 @@ func builder(t *testing.T, nFull int, storage []test.StorageMiner) ([]test.TestN
 		if err != nil {
 			t.Fatal(err)
 		}
-		genm, k, err := seed.PreSeal(maddr, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, test.GenesisPreseals, tdir, []byte("make genesis mem random"), nil)
+		genm, k, err := seed.PreSeal(maddr, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, test.GenesisPreseals, tdir, []byte("make genesis mem random"), nil, true)
 		if err != nil {
 			t.Fatal(err)
 		}

node/repo/fsrepo_ds.go

@@ -1,16 +1,18 @@
 package repo
 
 import (
+	"os"
+	"path/filepath"
+
 	"github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/mount"
 	"github.com/ipfs/go-datastore/namespace"
 	"golang.org/x/xerrors"
-	"os"
-	"path/filepath"
 
+	dgbadger "github.com/dgraph-io/badger/v2"
 	badger "github.com/ipfs/go-ds-badger2"
 	levelds "github.com/ipfs/go-ds-leveldb"
-	"github.com/ipfs/go-ds-measure"
+	measure "github.com/ipfs/go-ds-measure"
 	ldbopts "github.com/syndtr/goleveldb/leveldb/opt"
 )
 
@@ -25,7 +27,8 @@ var fsDatastores = map[string]func(path string) (datastore.Batching, error){
 
 func badgerDs(path string) (datastore.Batching, error) {
 	opts := badger.DefaultOptions
-	opts.Truncate = true
+	opts.Options = dgbadger.DefaultOptions("").WithTruncate(true).
+		WithValueThreshold(1 << 10)
 
 	return badger.NewDatastore(path, &opts)
 }

storage/adapter_storage_miner.go

@@ -93,8 +93,8 @@ func (s SealingAPIAdapter) StateWaitMsg(ctx context.Context, mcid cid.Cid) (seal
 			Return:   wmsg.Receipt.Return,
 			GasUsed:  wmsg.Receipt.GasUsed,
 		},
-		TipSetTok: wmsg.TipSet.Key().Bytes(),
-		Height:    wmsg.TipSet.Height(),
+		TipSetTok: wmsg.TipSet.Bytes(),
+		Height:    wmsg.Height,
 	}, nil
 }
 

storage/wdpost_run.go

@@ -150,6 +150,17 @@ func (s *WindowPoStScheduler) checkNextRecoveries(ctx context.Context, deadline
 	if err != nil {
 		return xerrors.Errorf("checking unrecovered sectors: %w", err)
 	}
+	
+	// if all sectors failed to recover, don't declare recoveries
+	sbfCount, err := sbf.Count()
+	if err != nil {
+		return xerrors.Errorf("counting recovered sectors: %w", err)
+	}
+	
+	if sbfCount == 0 {
+	 	log.Warnw("No recoveries to declare", "deadline", deadline, "faulty", uc)
+	 	return nil
+	}
 
 	params := &miner.DeclareFaultsRecoveredParams{
 		Recoveries: []miner.RecoveryDeclaration{{Deadline: deadline, Sectors: sbf}},

tools/stats/collect.go

@@ -0,0 +1,63 @@
+package stats
+
+import (
+	"context"
+	"time"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	client "github.com/influxdata/influxdb1-client/v2"
+)
+
+func Collect(ctx context.Context, api api.FullNode, influx client.Client, database string, height int64, headlag int) {
+	tipsetsCh, err := GetTips(ctx, api, abi.ChainEpoch(height), headlag)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	wq := NewInfluxWriteQueue(ctx, influx)
+	defer wq.Close()
+
+	for tipset := range tipsetsCh {
+		log.Infow("Collect stats", "height", tipset.Height())
+		pl := NewPointList()
+		height := tipset.Height()
+
+		if err := RecordTipsetPoints(ctx, api, pl, tipset); err != nil {
+			log.Warnw("Failed to record tipset", "height", height, "error", err)
+			continue
+		}
+
+		if err := RecordTipsetMessagesPoints(ctx, api, pl, tipset); err != nil {
+			log.Warnw("Failed to record messages", "height", height, "error", err)
+			continue
+		}
+
+		if err := RecordTipsetStatePoints(ctx, api, pl, tipset); err != nil {
+			log.Warnw("Failed to record state", "height", height, "error", err)
+			continue
+		}
+
+		// Instead of having to pass around a bunch of generic stuff we want for each point
+		// we will just add them at the end.
+
+		tsTimestamp := time.Unix(int64(tipset.MinTimestamp()), int64(0))
+
+		nb, err := InfluxNewBatch()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		for _, pt := range pl.Points() {
+			pt.SetTime(tsTimestamp)
+
+			nb.AddPoint(NewPointFrom(pt))
+		}
+
+		nb.SetDatabase(database)
+
+		log.Infow("Adding points", "count", len(nb.Points()), "height", tipset.Height())
+
+		wq.AddBatch(nb)
+	}
+}

tools/stats/head_buffer.go

@@ -1,4 +1,4 @@
-package main
+package stats
 
 import (
 	"container/list"

tools/stats/head_buffer_test.go

@@ -1,4 +1,4 @@
-package main
+package stats
 
 import (
 	"testing"

tools/stats/main.go

@@ -1,126 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"os"
-	"time"
-
-	"github.com/filecoin-project/specs-actors/actors/abi"
-	logging "github.com/ipfs/go-log/v2"
-)
-
-var log = logging.Logger("stats")
-
-const (
-	INFLUX_ADDR = "INFLUX_ADDR"
-	INFLUX_USER = "INFLUX_USER"
-	INFLUX_PASS = "INFLUX_PASS"
-)
-
-func main() {
-	var repo string = "~/.lotus"
-	var database string = "lotus"
-	var reset bool = false
-	var nosync bool = false
-	var height int64 = 0
-	var headlag int = 3
-
-	flag.StringVar(&repo, "repo", repo, "lotus repo path")
-	flag.StringVar(&database, "database", database, "influx database")
-	flag.Int64Var(&height, "height", height, "block height to start syncing from (0 will resume)")
-	flag.IntVar(&headlag, "head-lag", headlag, "number of head events to hold to protect against small reorgs")
-	flag.BoolVar(&reset, "reset", reset, "truncate database before starting stats gathering")
-	flag.BoolVar(&nosync, "nosync", nosync, "skip waiting for sync")
-
-	flag.Parse()
-
-	influxAddr := os.Getenv(INFLUX_ADDR)
-	influxUser := os.Getenv(INFLUX_USER)
-	influxPass := os.Getenv(INFLUX_PASS)
-
-	ctx := context.Background()
-
-	influx, err := InfluxClient(influxAddr, influxUser, influxPass)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	if reset {
-		if err := ResetDatabase(influx, database); err != nil {
-			log.Fatal(err)
-		}
-	}
-
-	if !reset && height == 0 {
-		h, err := GetLastRecordedHeight(influx, database)
-		if err != nil {
-			log.Info(err)
-		}
-
-		height = h
-	}
-
-	api, closer, err := GetFullNodeAPI(repo)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer closer()
-
-	if !nosync {
-		if err := WaitForSyncComplete(ctx, api); err != nil {
-			log.Fatal(err)
-		}
-	}
-
-	tipsetsCh, err := GetTips(ctx, api, abi.ChainEpoch(height), headlag)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	wq := NewInfluxWriteQueue(ctx, influx)
-	defer wq.Close()
-
-	for tipset := range tipsetsCh {
-		log.Infow("Collect stats", "height", tipset.Height())
-		pl := NewPointList()
-		height := tipset.Height()
-
-		if err := RecordTipsetPoints(ctx, api, pl, tipset); err != nil {
-			log.Warnw("Failed to record tipset", "height", height, "error", err)
-			continue
-		}
-
-		if err := RecordTipsetMessagesPoints(ctx, api, pl, tipset); err != nil {
-			log.Warnw("Failed to record messages", "height", height, "error", err)
-			continue
-		}
-
-		if err := RecordTipsetStatePoints(ctx, api, pl, tipset); err != nil {
-			log.Warnw("Failed to record state", "height", height, "error", err)
-			continue
-		}
-
-		// Instead of having to pass around a bunch of generic stuff we want for each point
-		// we will just add them at the end.
-
-		tsTimestamp := time.Unix(int64(tipset.MinTimestamp()), int64(0))
-
-		nb, err := InfluxNewBatch()
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		for _, pt := range pl.Points() {
-			pt.SetTime(tsTimestamp)
-
-			nb.AddPoint(NewPointFrom(pt))
-		}
-
-		nb.SetDatabase(database)
-
-		log.Infow("Adding points", "count", len(nb.Points()), "height", tipset.Height())
-
-		wq.AddBatch(nb)
-	}
-}

tools/stats/metrics.go

@@ -1,4 +1,4 @@
-package main
+package stats
 
 import (
 	"bytes"
@@ -25,8 +25,12 @@ import (
 	_ "github.com/influxdata/influxdb1-client"
 	models "github.com/influxdata/influxdb1-client/models"
 	client "github.com/influxdata/influxdb1-client/v2"
+
+	logging "github.com/ipfs/go-log/v2"
 )
 
+var log = logging.Logger("stats")
+
 type PointList struct {
 	points []models.Point
 }
@@ -172,17 +176,18 @@ func (ht *apiIpldStore) Put(ctx context.Context, v interface{}) (cid.Cid, error)
 }
 
 func RecordTipsetStatePoints(ctx context.Context, api api.FullNode, pl *PointList, tipset *types.TipSet) error {
-	pc, err := api.StatePledgeCollateral(ctx, tipset.Key())
-	if err != nil {
-		return err
-	}
-
 	attoFil := types.NewInt(build.FilecoinPrecision).Int
 
-	pcFil := new(big.Rat).SetFrac(pc.Int, attoFil)
-	pcFilFloat, _ := pcFil.Float64()
-	p := NewPoint("chain.pledge_collateral", pcFilFloat)
-	pl.AddPoint(p)
+	//TODO: StatePledgeCollateral API is not implemented and is commented out - re-enable this block once the API is implemented again.
+	//pc, err := api.StatePledgeCollateral(ctx, tipset.Key())
+	//if err != nil {
+	//return err
+	//}
+
+	//pcFil := new(big.Rat).SetFrac(pc.Int, attoFil)
+	//pcFilFloat, _ := pcFil.Float64()
+	//p := NewPoint("chain.pledge_collateral", pcFilFloat)
+	//pl.AddPoint(p)
 
 	netBal, err := api.WalletBalance(ctx, builtin.RewardActorAddr)
 	if err != nil {
@@ -191,7 +196,7 @@ func RecordTipsetStatePoints(ctx context.Context, api api.FullNode, pl *PointLis
 
 	netBalFil := new(big.Rat).SetFrac(netBal.Int, attoFil)
 	netBalFilFloat, _ := netBalFil.Float64()
-	p = NewPoint("network.balance", netBalFilFloat)
+	p := NewPoint("network.balance", netBalFilFloat)
 	pl.AddPoint(p)
 
 	totalPower, err := api.StateMinerPower(ctx, address.Address{}, tipset.Key())

tools/stats/rpc.go

@@ -1,4 +1,4 @@
-package main
+package stats
 
 import (
 	"context"