diff --git a/.circleci/config.yml b/.circleci/config.yml
index e91c41129..70e435d3b 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -1,7 +1,7 @@
 version: 2.1
 orbs:
-  aws-cli: circleci/aws-cli@1.3.2
-  docker: circleci/docker@2.1.4
+  aws-cli: circleci/aws-cli@4.1.1
+  docker: circleci/docker@2.3.0
 
 executors:
   golang:
@@ -70,8 +70,6 @@ commands:
           name: Restore parameters cache
           keys:
             - 'v26-2k-lotus-params'
-          paths:
-            - /var/tmp/filecoin-proof-parameters/
       - run: ./lotus fetch-params 2048
       - save_cache:
           name: Save parameters cache
@@ -96,6 +94,7 @@ commands:
             git fetch --all
   install-ubuntu-deps:
     steps:
+      - run: sudo apt install curl ca-certificates gnupg
       - run: sudo apt-get update
       - run: sudo apt-get install ocl-icd-opencl-dev libhwloc-dev
   check-go-version:
@@ -143,9 +142,9 @@ jobs:
       Run tests with gotestsum.
     working_directory: ~/lotus
     parameters: &test-params
-      executor:
-        type: executor
-        default: golang
+      resource_class:
+        type: string
+        default: medium+
       go-test-flags:
         type: string
         default: "-timeout 20m"
@@ -164,7 +163,14 @@ jobs:
         type: string
         default: unit
         description: Test suite name to report to CircleCI.
-    executor: << parameters.executor >>
+    docker:
+      - image: cimg/go:1.20
+        environment:
+          LOTUS_HARMONYDB_HOSTS: yugabyte
+      - image: yugabytedb/yugabyte:2.18.0.0-b65
+        command: bin/yugabyted start --daemon=false
+        name: yugabyte
+    resource_class: << parameters.resource_class >>
     steps:
       - install-ubuntu-deps
       - attach_workspace:
@@ -182,6 +188,8 @@ jobs:
           command: |
             mkdir -p /tmp/test-reports/<< parameters.suite >>
             mkdir -p /tmp/test-artifacts
+            dockerize -wait tcp://yugabyte:5433 -timeout 3m
+            env
             gotestsum \
               --format standard-verbose \
               --junitfile /tmp/test-reports/<< parameters.suite >>/junit.xml \
@@ -209,7 +217,9 @@ jobs:
           Branch on github.com/filecoin-project/test-vectors to checkout and
           test with. If empty (the default) the commit defined by the git
           submodule is used.
-    executor: << parameters.executor >>
+    docker:
+      - image: cimg/go:1.20
+    resource_class: << parameters.resource_class >>
     steps:
       - install-ubuntu-deps
       - attach_workspace:
@@ -396,15 +406,14 @@ jobs:
       Run golangci-lint.
     working_directory: ~/lotus
     parameters:
-      executor:
-        type: executor
-        default: golang
       args:
         type: string
         default: ''
         description: |
           Arguments to pass to golangci-lint
-    executor: << parameters.executor >>
+    docker:
+      - image: cimg/go:1.20
+    resource_class: medium+
     steps:
       - install-ubuntu-deps
       - attach_workspace:
@@ -575,7 +584,7 @@ workflows:
             - build
           suite: itest-deals_concurrent
           target: "./itests/deals_concurrent_test.go"
-          executor: golang-2xl
+          resource_class: 2xlarge
       - test:
           name: test-itest-deals_invalid_utf8_label
           requires:
@@ -768,6 +777,18 @@ workflows:
             - build
           suite: itest-get_messages_in_ts
           target: "./itests/get_messages_in_ts_test.go"
+      - test:
+          name: test-itest-harmonydb
+          requires:
+            - build
+          suite: itest-harmonydb
+          target: "./itests/harmonydb_test.go"
+      - test:
+          name: test-itest-harmonytask
+          requires:
+            - build
+          suite: itest-harmonytask
+          target: "./itests/harmonytask_test.go"
       - test:
           name: test-itest-lite_migration
           requires:
@@ -976,14 +997,14 @@ workflows:
             - build
           suite: itest-wdpost_worker_config
           target: "./itests/wdpost_worker_config_test.go"
-          executor: golang-2xl
+          resource_class: 2xlarge
       - test:
           name: test-itest-worker
           requires:
             - build
           suite: itest-worker
           target: "./itests/worker_test.go"
-          executor: golang-2xl
+          resource_class: 2xlarge
       - test:
           name: test-itest-worker_upgrade
           requires:
@@ -996,32 +1017,28 @@ workflows:
             - build
           suite: utest-unit-cli
           target: "./cli/... ./cmd/... ./api/..."
+          resource_class: 2xlarge
           get-params: true
-          executor: golang-2xl
       - test:
           name: test-unit-node
           requires:
             - build
           suite: utest-unit-node
           target: "./node/..."
-          
-          
       - test:
           name: test-unit-rest
           requires:
             - build
           suite: utest-unit-rest
           target: "./blockstore/... ./build/... ./chain/... ./conformance/... ./gateway/... ./journal/... ./lib/... ./markets/... ./paychmgr/... ./tools/..."
-          
-          executor: golang-2xl
+          resource_class: 2xlarge
       - test:
           name: test-unit-storage
           requires:
             - build
           suite: utest-unit-storage
           target: "./storage/... ./extern/..."
-          
-          
+          get-params: true
       - test:
           go-test-flags: "-run=TestMulticoreSDR"
           requires:
diff --git a/.circleci/gen.go b/.circleci/gen.go
index 93f409df2..19329247a 100644
--- a/.circleci/gen.go
+++ b/.circleci/gen.go
@@ -10,11 +10,25 @@ import (
 	"text/template"
 )
 
+var GoVersion = "" // from init below. Ex: 1.19.7
+
 //go:generate go run ./gen.go ..
 
 //go:embed template.yml
 var templateFile embed.FS
 
+func init() {
+	b, err := os.ReadFile("../go.mod")
+	if err != nil {
+		panic("cannot find go.mod in parent folder")
+	}
+	for _, line := range strings.Split(string(b), "\n") {
+		if strings.HasPrefix(line, "go ") {
+			GoVersion = line[3:]
+		}
+	}
+}
+
 type (
 	dirs  = []string
 	suite = string
@@ -111,6 +125,7 @@ func main() {
 		Networks   []string
 		ItestFiles []string
 		UnitSuites map[string]string
+		GoVersion  string
 	}
 	in := data{
 		Networks:   []string{"mainnet", "butterflynet", "calibnet", "debug"},
@@ -125,6 +140,7 @@ func main() {
 			}
 			return ret
 		}(),
+		GoVersion: GoVersion,
 	}
 
 	out, err := os.Create("./config.yml")
diff --git a/.circleci/template.yml b/.circleci/template.yml
index 71616f05f..9011f1a86 100644
--- a/.circleci/template.yml
+++ b/.circleci/template.yml
@@ -1,7 +1,7 @@
 version: 2.1
 orbs:
-  aws-cli: circleci/aws-cli@1.3.2
-  docker: circleci/docker@2.1.4
+  aws-cli: circleci/aws-cli@4.1.1
+  docker: circleci/docker@2.3.0
 
 executors:
   golang:
@@ -70,8 +70,6 @@ commands:
           name: Restore parameters cache
           keys:
             - 'v26-2k-lotus-params'
-          paths:
-            - /var/tmp/filecoin-proof-parameters/
       - run: ./lotus fetch-params 2048
       - save_cache:
           name: Save parameters cache
@@ -96,6 +94,7 @@ commands:
             git fetch --all
   install-ubuntu-deps:
     steps:
+      - run: sudo apt install curl ca-certificates gnupg
       - run: sudo apt-get update
       - run: sudo apt-get install ocl-icd-opencl-dev libhwloc-dev
   check-go-version:
@@ -143,9 +142,9 @@ jobs:
       Run tests with gotestsum.
     working_directory: ~/lotus
     parameters: &test-params
-      executor:
-        type: executor
-        default: golang
+      resource_class:
+        type: string
+        default: medium+
       go-test-flags:
         type: string
         default: "-timeout 20m"
@@ -164,7 +163,14 @@ jobs:
         type: string
         default: unit
         description: Test suite name to report to CircleCI.
-    executor: << parameters.executor >>
+    docker:
+      - image: cimg/go:[[ .GoVersion]]
+        environment:
+          LOTUS_HARMONYDB_HOSTS: yugabyte
+      - image: yugabytedb/yugabyte:2.18.0.0-b65
+        command: bin/yugabyted start --daemon=false
+        name: yugabyte
+    resource_class: << parameters.resource_class >>
     steps:
       - install-ubuntu-deps
       - attach_workspace:
@@ -182,6 +188,8 @@ jobs:
           command: |
             mkdir -p /tmp/test-reports/<< parameters.suite >>
             mkdir -p /tmp/test-artifacts
+            dockerize -wait tcp://yugabyte:5433 -timeout 3m
+            env
             gotestsum \
               --format standard-verbose \
               --junitfile /tmp/test-reports/<< parameters.suite >>/junit.xml \
@@ -209,7 +217,9 @@ jobs:
           Branch on github.com/filecoin-project/test-vectors to checkout and
           test with. If empty (the default) the commit defined by the git
           submodule is used.
-    executor: << parameters.executor >>
+    docker:
+      - image: cimg/go:[[ .GoVersion]]
+    resource_class: << parameters.resource_class >>
     steps:
       - install-ubuntu-deps
       - attach_workspace:
@@ -396,15 +406,14 @@ jobs:
       Run golangci-lint.
     working_directory: ~/lotus
     parameters:
-      executor:
-        type: executor
-        default: golang
       args:
         type: string
         default: ''
         description: |
           Arguments to pass to golangci-lint
-    executor: << parameters.executor >>
+    docker:
+      - image: cimg/go:[[ .GoVersion]]
+    resource_class: medium+
     steps:
       - install-ubuntu-deps
       - attach_workspace:
@@ -543,7 +552,7 @@ workflows:
           suite: itest-[[ $name ]]
           target: "./itests/[[ $file ]]"
           [[- if or (eq $name "worker") (eq $name "deals_concurrent") (eq $name "wdpost_worker_config")]]
-          executor: golang-2xl
+          resource_class: 2xlarge
           [[- end]]
           [[- if or (eq $name "wdpost") (eq $name "sector_pledge")]]
           get-params: true
@@ -557,9 +566,16 @@ workflows:
             - build
           suite: utest-[[ $suite ]]
           target: "[[ $pkgs ]]"
-          [[if eq $suite "unit-cli"]]get-params: true[[end]]
-          [[if eq $suite "unit-cli"]]executor: golang-2xl[[end]]
-          [[- if eq $suite "unit-rest"]]executor: golang-2xl[[end]]
+          [[- if eq $suite "unit-storage"]]
+          get-params: true
+          [[- end -]]
+          [[- if eq $suite "unit-cli"]]
+          resource_class: 2xlarge
+          get-params: true
+          [[- end -]]
+          [[- if eq $suite "unit-rest"]]
+          resource_class: 2xlarge
+          [[- end -]]
       [[- end]]
       - test:
           go-test-flags: "-run=TestMulticoreSDR"
diff --git a/.gitignore b/.gitignore
index 23a0631c3..c40a76fd0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,7 @@
 /lotus-chainwatch
 /lotus-shed
 /lotus-sim
+/lotus-provider
 /lotus-townhall
 /lotus-fountain
 /lotus-stats
@@ -41,6 +42,7 @@ build/paramfetch.sh
 bin/ipget
 bin/tmp/*
 .idea
+.vscode
 scratchpad
 
 build/builtin-actors/v*
diff --git a/.golangci.yml b/.golangci.yml
index a4cca9bab..1d455e525 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -14,6 +14,7 @@ linters:
     - varcheck
     - deadcode
     - scopelint
+    - unused
 
 # We don't want to skip builtin/
 skip-dirs-use-default: false
diff --git a/CHANGELOG.md b/CHANGELOG.md
index fc7987e61..5da284702 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,192 @@
 # Lotus changelog
 
+# UNRELEASED
+
+## Improvements
+
+# v1.25.2 / 2024-01-11 
+
+This is an optional but **highly recommended feature release** of Lotus, as it includes fixes for synchronizations issues that users have experienced. The feature release also introduces `Lotus-Provider` in its alpha testing phase, as well as the ability to call external PC2-binaries during the sealing process.
+
+## ☢️ Upgrade Warnings ☢️
+
+There are no upgrade warnings for this feature release.
+
+## ⭐️ Highlights ⭐️
+
+### Lotus-Provider
+The feature release ships the alpha release of the new Lotus-Provider binary, together with its initial features - High Availability of WindowPoSt and WinningPoSt.
+
+So what is so exciting about Lotus-Provider:
+
+**High Availability**
+- You can run as many `Lotus-Provider` instances as you want for both WindowPoSt and WinningPOSt.
+- You can connect them to as many clustered Yugabyte instances as you want to. This allows for an NxN configuration where all instances can communicate with all others.
+- You have the option to connect different instances to different chain daemons.
+
+**Simplicity**
+- Once the configuration is in the database, setting up a new machine with Lotus-Provider is straightforward. Simply start the binary with the correct flags to find YugabyteDB and specify which configuration layers it should use.
+
+**Durability**
+- `Lotus-Provider` is designed with robustness in mind. Updates to the system are handled seamlessly, ensuring that performance and stability are maintained when taking down machines in your cluster for updates.
+
+Read more about [`Lotus-Provider` in the documentation here](https://lotus.filecoin.io/storage-providers/lotus-provider/overview/). And check out the how you can migrate from [Lotus-Miner to Lotus-Provider here](https://lotus.filecoin.io/storage-providers/lotus-provider/setup/). **(Only recommended in testnets while its in Alpha)**
+
+### External PC2-binaries 
+
+In this feature release, storage providers can call external PC2-binaries during the sealing process. This allows storage providers to leverage the SupraSeal PC2 binary, which has been shown to improve sealing speed in the PC2-phase. For instance, our current benchmarks show that an NVIDIA RTX A5000 card was able to complete PC2 in approximately 2.5 minutes.
+
+We have verified that SupraSeal PC2 functions properly with Committed Capacity (CC) sectors, both SyntheticPoReps and non-Synthetic PoReps. However calling SupraSeal PC2 with deal sectors is not supported in this feature release.
+
+For more information on how to use SupraSeal PC2 with your `lotus-worker`, as well as how to use feature, please [refer to the documentation](https://lotus.filecoin.io/tutorials/lotus-miner/supra-seal-pc2/).
+
+## New features
+- feat: sturdypost work branch ([filecoin-project/lotus#11405](https://github.com/filecoin-project/lotus/pull/11405))
+   - Adds the `Lotus-Provider` binary, and the HarmonyDB framework.
+- feat: worker: Support delegating precommit2 to external binary ([filecoin-project/lotus#11185](https://github.com/filecoin-project/lotus/pull/11185))
+   - Allows for delegating PreCommit2 to an exteranl binary.
+- feat: build: Add SupraSeal-PC2 binary script ([filecoin-project/lotus#11430](https://github.com/filecoin-project/lotus/pull/11430))
+   - Adds a script for building the SupraSeal-PC2 binary easily.
+- Feat: daemon: Auto remove existing chain if importing chain file or snapshot ([filecoin-project/lotus#11277](https://github.com/filecoin-project/lotus/pull/11277))
+   - Auto removes the existing chain when importing a snapshot. 
+- feat: Add ETA to lotus sync wait (#11211) ([filecoin-project/lotus#11211](https://github.com/filecoin-project/lotus/pull/11211))
+   - Adds a ETA indicator to `lotus sync wait`, so you can get an estimate for how long until sync is completed.
+- feat: mpool/wdpost: Maximize feecap config ([filecoin-project/lotus#9746](https://github.com/filecoin-project/lotus/pull/9746))
+   - Adds a Maximixe FeeCap Config
+- feat: Add lotus-bench cli option to stress test any binary ([filecoin-project/lotus#11270](https://github.com/filecoin-project/lotus/pull/11270))
+   - Enables the `Lotus-Bench` to run any binary and analyze their latency and histogram distribution, track most common errors, perform stress testing under different concurrency levels and see how it works under different QPS.
+- feat: chain import: don't walk to genesis - 2-3x faster snapshot import (#11446) ([filecoin-project/lotus#11446](https://github.com/filecoin-project/lotus/pull/11446))
+   - Improves Snapshot import speed, by not walking back to genesis on import.
+- feat: metric: export Mpool message count ([filecoin-project/lotus#11361](https://github.com/filecoin-project/lotus/pull/11361))
+   - Adds the mpool count as a prometheus metric.
+- feat: bench: flag to output GenerateWinningPoStWithVanilla params ([filecoin-project/lotus#11460](https://github.com/filecoin-project/lotus/pull/11460))
+
+## Improvements
+- feat: bootstrap: add glif bootstrap node on calibration ([filecoin-project/lotus#11175](https://github.com/filecoin-project/lotus/pull/11175))
+- fix: bench: Set ticket and seed to a non-all zero value ([filecoin-project/lotus#11429](https://github.com/filecoin-project/lotus/pull/11429))
+- fix: alert: Check UDPbuffer-size ([filecoin-project/lotus#11360](https://github.com/filecoin-project/lotus/pull/11360))
+- feat: cli: sort actor CIDs alphabetically before printing (#11345) ([filecoin-project/lotus#11345](https://github.com/filecoin-project/lotus/pull/11345))
+- fix: worker: Connect when --listen is not set ([filecoin-project/lotus#11294](https://github.com/filecoin-project/lotus/pull/11294))
+- fix: miner info: Show correct sector state counts ([filecoin-project/lotus#11456](https://github.com/filecoin-project/lotus/pull/11456))
+- feat: miner: defensive check for equivocation ([filecoin-project/lotus#11321](https://github.com/filecoin-project/lotus/pull/11321))
+- feat: Instructions for setting up Grafana/Prometheus for monitoring local lotus node ([filecoin-project/lotus#11276](https://github.com/filecoin-project/lotus/pull/11276))
+- fix: cli: Wrap error in wallet sign ([filecoin-project/lotus#11273](https://github.com/filecoin-project/lotus/pull/11273))
+- fix: Add time slicing to splitstore purging to reduce lock congestion ([filecoin-project/lotus#11269](https://github.com/filecoin-project/lotus/pull/11269))
+- feat: sealing: load SectorsSummary from sealing SectorStats instead of calling API each time ([filecoin-project/lotus#11353](https://github.com/filecoin-project/lotus/pull/11353))
+- fix: shed: additional metrics in `mpool miner-select-messages` ([filecoin-project/lotus#11253](https://github.com/filecoin-project/lotus/pull/11253))
+- storage: Return soft err when sector alloc fails in acquire ([filecoin-project/lotus#11338](https://github.com/filecoin-project/lotus/pull/11338))
+- feat: miner: log detailed timing breakdown when mining takes longer than the block's timestamp ([filecoin-project/lotus#11228](https://github.com/filecoin-project/lotus/pull/11228))
+- fix: shed: make invariants checker work with splitstore ([filecoin-project/lotus#11391](https://github.com/filecoin-project/lotus/pull/11391))
+- feat: eth: encode eth tx input as solidity ABI (#11402) ([filecoin-project/lotus#11402](https://github.com/filecoin-project/lotus/pull/11402))
+- fix: eth: use the correct state-tree when resolving addresses (#11387) ([filecoin-project/lotus#11387](https://github.com/filecoin-project/lotus/pull/11387))
+- fix: eth: remove trace sanity check (#11385) ([filecoin-project/lotus#11385](https://github.com/filecoin-project/lotus/pull/11385))
+- fix: chain: make failure to load the chain state fatal (#11426) ([filecoin-project/lotus#11426](https://github.com/filecoin-project/lotus/pull/11426))
+- fix: build: an epoch is near an upgrade iff the upgrade is enabled (#11401) ([filecoin-project/lotus#11401](https://github.com/filecoin-project/lotus/pull/11401))
+- fix: eth: handle unresolvable addresses (#11433) ([filecoin-project/lotus#11433](https://github.com/filecoin-project/lotus/pull/11433))
+- fix: eth: correctly encode and simplify native input/output encoding (#11382) ([filecoin-project/lotus#11382](https://github.com/filecoin-project/lotus/pull/11382))
+- fix: worker: listen for interrupt signals in GetStorageMinerAPI loop (#11309) ([filecoin-project/lotus#11309](https://github.com/filecoin-project/lotus/pull/11309))
+- fix: sync: iterate over returned messages directly (#11373) ([filecoin-project/lotus#11373](https://github.com/filecoin-project/lotus/pull/11373))
+- fix: miner: correct duration logs in mineOne ([filecoin-project/lotus#11241](https://github.com/filecoin-project/lotus/pull/11241))
+- fix: cli: Add print to unseal cmd ([filecoin-project/lotus#11271](https://github.com/filecoin-project/lotus/pull/11271))
+- fix: networking: avoid dialing when trying to handshake peers ([filecoin-project/lotus#11262](https://github.com/filecoin-project/lotus/pull/11262))
+- metric milliseconds computation with golang original method (#11403) ([filecoin-project/lotus#11403](https://github.com/filecoin-project/lotus/pull/11403))
+- feat: shed: fix blockstore prune (#11197) ([filecoin-project/lotus#11197](https://github.com/filecoin-project/lotus/pull/11197))
+- refactor:ffi: replace ClearLayerData with ClearCache (#11352) ([filecoin-project/lotus#11352](https://github.com/filecoin-project/lotus/pull/11352))
+- fix: api: compute gasUsedRatio based on max gas in the tipset (#11354) ([filecoin-project/lotus#11354](https://github.com/filecoin-project/lotus/pull/11354))
+- fix: api: compute the effective gas cost with the correct base-fee (#11357) ([filecoin-project/lotus#11357](https://github.com/filecoin-project/lotus/pull/11357))
+- fix: api: return errors on failure to lookup an eth txn receipt (#11329) ([filecoin-project/lotus#11329](https://github.com/filecoin-project/lotus/pull/11329))
+- fix: api: exclude reverted events in `eth_getLogs` results (#11318) ([filecoin-project/lotus#11318](https://github.com/filecoin-project/lotus/pull/11318))
+- api: Add block param to eth_estimateGas ([filecoin-project/lotus#11462](https://github.com/filecoin-project/lotus/pull/11462))
+- opt: fix duplicate check exitcode ([filecoin-project/lotus#11171](https://github.com/filecoin-project/lotus/pull/11171))
+- fix: lotus-provider: show addresses in log ([filecoin-project/lotus#11490](https://github.com/filecoin-project/lotus/pull/11490))
+- fix: lotus-provider: Wait for the correct taskID ([filecoin-project/lotus#11493](https://github.com/filecoin-project/lotus/pull/11493))
+- harmony: Fix task reclaim on restart ([filecoin-project/lotus#11498](https://github.com/filecoin-project/lotus/pull/11498))
+- fix: lotus-provider: Fix log output format in wdPostTaskCmd ([filecoin-project/lotus#11504](https://github.com/filecoin-project/lotus/pull/11504))
+- fix: lp docsgen ([filecoin-project/lotus#11488](https://github.com/filecoin-project/lotus/pull/11488))
+- fix: lotus-provider do not suggest default layer ([filecoin-project/lotus#11486](https://github.com/filecoin-project/lotus/pull/11486))
+- feat: syncer: optimize syncFork for one-epoch forks ([filecoin-project/lotus#11533](https://github.com/filecoin-project/lotus/pull/11533))
+- fix: sync: do not include incoming in return of syncFork ([filecoin-project/lotus#11541](https://github.com/filecoin-project/lotus/pull/11541))
+- fix: wdpost: fix vanilla proof indexes ([filecoin-project/lotus#11550](https://github.com/filecoin-project/lotus/pull/11550))
+- feat: exchange: change GetBlocks to always fetch the requested number of tipsets ([filecoin-project/lotus#11565](https://github.com/filecoin-project/lotus/pull/11565))
+
+## Dependencies
+- update go-libp2p to v0.31.0 ([filecoin-project/lotus#11225](https://github.com/filecoin-project/lotus/pull/11225))
+- deps: gostatetype (#11437) ([filecoin-project/lotus#11437](https://github.com/filecoin-project/lotus/pull/11437))
+- fix: deps: stop using go-libp2p deprecated peer.ID.Pretty ([filecoin-project/lotus#11263](https://github.com/filecoin-project/lotus/pull/11263))
+- chore:libp2p:update libp2p deps in release-v1.25.2 to v0.31.1 ([filecoin-project/lotus#11524](https://github.com/filecoin-project/lotus/pull/11524))
+- deps: update go-multiaddr to v0.12.0 ([filecoin-project/lotus#11524](https://github.com/filecoin-project/lotus/pull/11558))
+- dep: go-multi-address to v0.12.1 ([filecoin-project/lotus#11564](https://github.com/filecoin-project/lotus/pull/11564))
+
+## Others
+- chore: update FFI (#11431) ([filecoin-project/lotus#11431](https://github.com/filecoin-project/lotus/pull/11431))
+- chore: build: bump master to v1.25.1-dev ([filecoin-project/lotus#11450](https://github.com/filecoin-project/lotus/pull/11450))
+- chore: releases :merge releases into master  ([filecoin-project/lotus#11448](https://github.com/filecoin-project/lotus/pull/11448))
+- chore: actors: update v12 to the final release ([filecoin-project/lotus#11440](https://github.com/filecoin-project/lotus/pull/11440))
+- chore: Remove ipfs main bootstrap nodes (#11200) ([filecoin-project/lotus#11200](https://github.com/filecoin-project/lotus/pull/11200))
+- Remove PL's european bootstrap nodes from mainnet.pi ([filecoin-project/lotus#11315](https://github.com/filecoin-project/lotus/pull/11315))
+- chore: deps: update to go-state-types v0.12.7 ([filecoin-project/lotus#11428](https://github.com/filecoin-project/lotus/pull/11428))
+- fix: Add .vscode to gitignore ([filecoin-project/lotus#11275](https://github.com/filecoin-project/lotus/pull/11275))
+- fix: test: temporarily exempt SynthPorep constants from test ([filecoin-project/lotus#11259](https://github.com/filecoin-project/lotus/pull/11259))
+- feat: skip TestSealAndVerify3 until it's fixed ([filecoin-project/lotus#11230](https://github.com/filecoin-project/lotus/pull/11230))
+- Update RELEASE_ISSUE_TEMPLATE.md ([filecoin-project/lotus#11250](https://github.com/filecoin-project/lotus/pull/11250))
+- fix: config: Update ColdStoreType comments ([filecoin-project/lotus#11274](https://github.com/filecoin-project/lotus/pull/11274))
+- readme: bump up golang version (#11347) ([filecoin-project/lotus#11347](https://github.com/filecoin-project/lotus/pull/11347))
+- chore: watermelon: upgrade epoch ([filecoin-project/lotus#11374](https://github.com/filecoin-project/lotus/pull/11374))
+- add support for v12 check invariants and also a default case to reduce future confusion (#11371) ([filecoin-project/lotus#11371](https://github.com/filecoin-project/lotus/pull/11371))
+- test: drand: switch tests to drand testnet (from devnet) (#11359) ([filecoin-project/lotus#11359](https://github.com/filecoin-project/lotus/pull/11359))
+- feat: chain: light-weight patch to fix calibrationnet again by removing move_partitions from built-in actors (#11409) ([filecoin-project/lotus#11409](https://github.com/filecoin-project/lotus/pull/11409))
+- chore: cli: Revert move-partitions cmd ([filecoin-project/lotus#11408](https://github.com/filecoin-project/lotus/pull/11408))
+- chore: forward-port calibnet hotfix to master ([filecoin-project/lotus#11407](https://github.com/filecoin-project/lotus/pull/11407))
+- fix: migration: set premigration to 90 minutes ([filecoin-project/lotus#11395](https://github.com/filecoin-project/lotus/pull/11395))
+- feat: chain: light-weight patch to fix calibrationnet (#11363) ([filecoin-project/lotus#11363](https://github.com/filecoin-project/lotus/pull/11363))
+- chore: merge feat/nv21 into master ([filecoin-project/lotus#11336](https://github.com/filecoin-project/lotus/pull/11336))
+- docs: Link the release section in the release flow doc ([filecoin-project/lotus#11299](https://github.com/filecoin-project/lotus/pull/11299))
+- fix: ci: fetch params for the storage unit tests ([filecoin-project/lotus#11441](https://github.com/filecoin-project/lotus/pull/11441))
+- Update mainnet.pi ([filecoin-project/lotus#11288](https://github.com/filecoin-project/lotus/pull/11288))
+- add go linter - "unused" (#11235) ([filecoin-project/lotus#11235](https://github.com/filecoin-project/lotus/pull/11235))
+- Fix/texts (#11298) ([filecoin-project/lotus#11298](https://github.com/filecoin-project/lotus/pull/11298))
+- fix typo in rate-limit flag description (#11316) ([filecoin-project/lotus#11316](https://github.com/filecoin-project/lotus/pull/11316))
+- eth_filter flake debug ([filecoin-project/lotus#11261](https://github.com/filecoin-project/lotus/pull/11261))
+- fix: sealing: typo in FinalizeReplicaUpdate ([filecoin-project/lotus#11255](https://github.com/filecoin-project/lotus/pull/11255))
+- chore: slice loop replace (#11349) ([filecoin-project/lotus#11349](https://github.com/filecoin-project/lotus/pull/11349))
+- backport: docker build fix for v1.25.2 ([filecoin-project/lotus#11560](https://github.com/filecoin-project/lotus/pull/11560))
+
+## Contributors
+
+| Contributor | Commits | Lines ± | Files Changed |
+|-------------|---------|---------|---------------|
+| Andrew Jackson (Ajax) | 161 | +24328/-12464 | 4148 |
+| Łukasz Magiera | 99 | +5238/-2690 | 260 |
+| Shrenuj Bansal | 27 | +3402/-1265 | 76 |
+| Fridrik Asmundsson | 15 | +1148/-307 | 58 |
+| Steven Allen | 15 | +674/-337 | 35 |
+| Ian Norden | 1 | +625/-3 | 4 |
+| Aarsh Shah | 4 | +227/-167 | 14 |
+| Phi | 19 | +190/-183 | 32 |
+| Aayush Rajasekaran | 3 | +291/-56 | 16 |
+| Mikers | 2 | +76/-262 | 19 |
+| Aayush | 14 | +111/-59 | 21 |
+| Friðrik Ásmundsson | 1 | +101/-1 | 2 |
+| Alejandro Criado-Pérez | 1 | +36/-36 | 27 |
+| Jie Hou | 5 | +36/-10 | 5 |
+| Florian RUEN | 2 | +24/-19 | 5 |
+| Phi-rjan | 3 | +20/-8 | 3 |
+| Icarus9913 | 1 | +11/-11 | 6 |
+| Jiaying Wang | 3 | +8/-7 | 5 |
+| guangwu | 1 | +3/-10 | 2 |
+| Marten Seemann | 1 | +6/-6 | 2 |
+| simlecode | 1 | +0/-6 | 2 |
+| GlacierWalrus | 2 | +0/-5 | 2 |
+| Anton Evangelatov | 1 | +2/-2 | 1 |
+| Ales Dumikau | 3 | +2/-2 | 3 |
+| renran | 1 | +2/-1 | 1 |
+| Volker Mische | 1 | +1/-1 | 1 |
+| Icarus Wu | 1 | +1/-1 | 1 |
+| Hubert | 1 | +1/-1 | 1 |
+| Aloxaf | 1 | +1/-1 | 1 |
+| Alejandro | 1 | +1/-1 | 1 |
+| lazavikmaria | 1 | +1/-0 | 1 |
+
 # v1.25.1 / 2023-12-09
 
 This is a **highly recommended PATCH RELEASE.**  The patch release fixes the issue were node operators trying to catch up sync were unable to sync large message blocks/epochs due to an increased number of messages on the network.
@@ -9,6 +196,7 @@ This patch release allows for up to 10k messages per block. Additionally, it int
 ## Improvements
 - fix: exchange: allow up to 10k messages per block ([filecoin-project/lotus#11506](https://github.com/filecoin-project/lotus/pull/11506))
 
+>>>>>>> releases
 
 # v 1.25.0 / 2023-11-22
 
@@ -21,7 +209,7 @@ The full list of [protocol improvements delivered in the network upgrade can be
 ## ☢️ Upgrade Warnings ☢️
 
 - Read through the [changelog of the mandatory v1.24.0 release](https://github.com/filecoin-project/lotus/releases/tag/v1.24.0). Especially the `Migration` and `v12 Builtin Actor Bundle` sections.
-- Please remove and clone a new Lotus repo (`git clone https://github.com/filecoin-project/lotus.git`) when upgrading to this release. 
+- Please remove and clone a new Lotus repo (`git clone https://github.com/filecoin-project/lotus.git`) when upgrading to this release.
 - This feature release requires a minimum Go version of v1.20.7 or higher to successfully build Lotus. Go version 1.21.x is not supported yet.
 - EthRPC providers, please check out the [new tracing API to Lotus RPC](https://github.com/filecoin-project/lotus/pull/11100)
 
@@ -94,6 +282,9 @@ Lotus-workers can now be built to leverage the SupraSeal C2 sealing optimization
 - fix(client): single-root error message ([filecoin-project/lotus#11214](https://github.com/filecoin-project/lotus/pull/11214))
 - fix: worker: Convert `DC_[SectorSize]_[ResourceRestriction]` if set ([filecoin-project/lotus#11224](https://github.com/filecoin-project/lotus/pull/11224))
 - chore: backport #11338 onto release/v1.25.0 ([filecoin-project/lotus#11350](https://github.com/filecoin-project/lotus/pull/11350))
+- fix: lotus-provider: lotus-provider msg sending ([filecoin-project/lotus#11480](https://github.com/filecoin-project/lotus/pull/11480))
+- fix: lotus-provider: Fix winning PoSt ([filecoin-project/lotus#11483](https://github.com/filecoin-project/lotus/pull/11483))
+- chore: fix: sql Scan cannot write to an object ([filecoin-project/lotus#11487](https://github.com/filecoin-project/lotus/pull/11487))
 
 ## Dependencies
 - deps: update go-libp2p to v0.28.1 ([filecoin-project/lotus#10998](https://github.com/filecoin-project/lotus/pull/10998))
@@ -183,7 +374,7 @@ account           bafk2bzaceboftg75mdiba7xbo2i3uvgtca4brhnr3u5ptihonixgpnrvhpxoa
 init              bafk2bzacebllyegx5r6lggf6ymyetbp7amacwpuxakhtjvjtvoy2bfkzk3vms
 ```
 
-## Migration  
+## Migration
 
 We are expecting a heavier than normal state migration for this upgrade due to the amount of state changes introduced for miner sector info. (This is a similar migration as the Shark upgrade, however, we have introduced a couple of migration performance optimizations since then for a smoother upgrade experience.)
 
@@ -202,7 +393,7 @@ You can check out the [tutorial for benchmarking the network migration here.](ht
 
 ## BREAKING CHANGE
 
-There is a new protocol limit on how many partition could be submited in one PoSt - if you have any customized tooling for batching PoSts, please update accordingly. 
+There is a new protocol limit on how many partition could be submited in one PoSt - if you have any customized tooling for batching PoSts, please update accordingly.
 - feat: limit PoSted partitions to 3 ([filecoin-project/lotus#11327](https://github.com/filecoin-project/lotus/pull/11327))
 
 ## New features
@@ -214,7 +405,7 @@ There is a new protocol limit on how many partition could be submited in one PoS
    
 ## Improvements
 - Backport: feat: sealing: Switch to calling PreCommitSectorBatch2 ([filecoin-project/lotus#11215](https://github.com/filecoin-project/lotus/pull/11215))
-- updated the boostrap nodes 
+- updated the boostrap nodes
 
 ## Dependencies
 - github.com/filecoin-project/go-amt-ipld/v4 (v4.0.0 -> v4.2.0)
@@ -224,9 +415,9 @@ There is a new protocol limit on how many partition could be submited in one PoS
 - chore: deps: update libp2p to v0.30.0 #11434
 
 
-## Snapshots 
+## Snapshots
 
-The [Forest team](https://filecoinproject.slack.com/archives/C029LPZ5N73) at Chainsafe has launched a brand new lightweight snapshot service that is backed up by forest nodes! This is a great alternative service along with the fil-infra one, and it is compatible with lotus! We recommend lotus users to check it out [here](https://docs.filecoin.io/networks/mainnet#resources)! 
+The [Forest team](https://filecoinproject.slack.com/archives/C029LPZ5N73) at Chainsafe has launched a brand new lightweight snapshot service that is backed up by forest nodes! This is a great alternative service along with the fil-infra one, and it is compatible with lotus! We recommend lotus users to check it out [here](https://docs.filecoin.io/networks/mainnet#resources)!
 
 
 
@@ -255,7 +446,7 @@ This feature release requires a **minimum Go version of v1.19.12 or higher to su
   - feat: sealing: flag to run data_cid untied from addpiece ([filecoin-project/lotus#10797](https://github.com/filecoin-project/lotus/pull/10797))
   - feat: Lotus Gateway: add MpoolPending, ChainGetBlock and MinerGetBaseInfo ([filecoin-project/lotus#10929](https://github.com/filecoin-project/lotus/pull/10929))
 
-## Improvements && Bug Fixe
+## Improvements && Bug Fixes
   - chore: update ffi & fvm ([filecoin-project/lotus#11040](https://github.com/filecoin-project/lotus/pull/11040))
   - feat: Make sure we don't store duplidate actor events caused to reorgs in events.db ([filecoin-project/lotus#11015](https://github.com/filecoin-project/lotus/pull/11015))
   - sealing: Use only non-assigned deals when selecting snap sectors ([filecoin-project/lotus#11002](https://github.com/filecoin-project/lotus/pull/11002))
diff --git a/Dockerfile b/Dockerfile
index 00930fb0f..c9750a71f 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -109,6 +109,7 @@ COPY --from=lotus-builder /opt/filecoin/lotus-wallet   /usr/local/bin/
 COPY --from=lotus-builder /opt/filecoin/lotus-gateway  /usr/local/bin/
 COPY --from=lotus-builder /opt/filecoin/lotus-miner    /usr/local/bin/
 COPY --from=lotus-builder /opt/filecoin/lotus-worker   /usr/local/bin/
+COPY --from=lotus-builder /opt/filecoin/lotus-provider    /usr/local/bin/
 COPY --from=lotus-builder /opt/filecoin/lotus-stats    /usr/local/bin/
 COPY --from=lotus-builder /opt/filecoin/lotus-fountain /usr/local/bin/
 
@@ -117,11 +118,13 @@ RUN mkdir /var/lib/lotus
 RUN mkdir /var/lib/lotus-miner
 RUN mkdir /var/lib/lotus-worker
 RUN mkdir /var/lib/lotus-wallet
+RUN mkdir /var/lib/lotus-provider
 RUN chown fc: /var/tmp/filecoin-proof-parameters
 RUN chown fc: /var/lib/lotus
 RUN chown fc: /var/lib/lotus-miner
 RUN chown fc: /var/lib/lotus-worker
 RUN chown fc: /var/lib/lotus-wallet
+RUN chown fc: /var/lib/lotus-provider
 
 
 VOLUME /var/tmp/filecoin-proof-parameters
@@ -129,6 +132,7 @@ VOLUME /var/lib/lotus
 VOLUME /var/lib/lotus-miner
 VOLUME /var/lib/lotus-worker
 VOLUME /var/lib/lotus-wallet
+VOLUME /var/lib/lotus-provider
 
 EXPOSE 1234
 EXPOSE 2345
diff --git a/LOTUS_RELEASE_FLOW.md b/LOTUS_RELEASE_FLOW.md
index 4a327125a..8bb02d3c5 100644
--- a/LOTUS_RELEASE_FLOW.md
+++ b/LOTUS_RELEASE_FLOW.md
@@ -73,7 +73,7 @@ All releases under an odd minor version number indicate **feature releases**. Th
 
 Feature releases include new development and bug fixes. They are not mandatory, but still highly recommended, **as they may contain critical security fixes**. Note that some of these releases may be very small patch releases that include critical hotfixes.  There is no way to distinguish between a bug fix release and a feature release on the "feature" version. Both cases will use the "patch" version number.
 
-We aim to ship a new feature release of the Lotus software from our development (master) branch every 3 weeks, so users can expect a regular cadence of Lotus feature releases. Note that mandatory releases for network upgrades may disrupt this schedule. For more, see the Release Cycle section (TODO: Link).
+We aim to ship a new feature release of the Lotus software from our development (master) branch every 3 weeks, so users can expect a regular cadence of Lotus feature releases. Note that mandatory releases for network upgrades may disrupt this schedule. For more, see the [Release Cycle section](#release-cycle).
 
 ### Examples Scenarios
 
diff --git a/Makefile b/Makefile
index b94c13c0d..a17b50d09 100644
--- a/Makefile
+++ b/Makefile
@@ -66,7 +66,7 @@ CLEAN+=build/.update-modules
 deps: $(BUILD_DEPS)
 .PHONY: deps
 
-build-devnets: build lotus-seed lotus-shed
+build-devnets: build lotus-seed lotus-shed lotus-provider
 .PHONY: build-devnets
 
 debug: GOFLAGS+=-tags=debug
@@ -97,6 +97,15 @@ lotus-miner: $(BUILD_DEPS)
 .PHONY: lotus-miner
 BINS+=lotus-miner
 
+lotus-provider: $(BUILD_DEPS)
+	rm -f lotus-provider
+	$(GOCC) build $(GOFLAGS) -o lotus-provider ./cmd/lotus-provider
+.PHONY: lotus-provider
+BINS+=lotus-provider
+
+lp2k: GOFLAGS+=-tags=2k
+lp2k: lotus-provider
+
 lotus-worker: $(BUILD_DEPS)
 	rm -f lotus-worker
 	$(GOCC) build $(GOFLAGS) -o lotus-worker ./cmd/lotus-worker
@@ -115,13 +124,13 @@ lotus-gateway: $(BUILD_DEPS)
 .PHONY: lotus-gateway
 BINS+=lotus-gateway
 
-build: lotus lotus-miner lotus-worker
+build: lotus lotus-miner lotus-worker 
 	@[[ $$(type -P "lotus") ]] && echo "Caution: you have \
 an existing lotus binary in your PATH. This may cause problems if you don't run 'sudo make install'" || true
 
 .PHONY: build
 
-install: install-daemon install-miner install-worker
+install: install-daemon install-miner install-worker install-provider
 
 install-daemon:
 	install -C ./lotus /usr/local/bin/lotus
@@ -129,6 +138,9 @@ install-daemon:
 install-miner:
 	install -C ./lotus-miner /usr/local/bin/lotus-miner
 
+install-provider:
+	install -C ./lotus-provider /usr/local/bin/lotus-provider
+
 install-worker:
 	install -C ./lotus-worker /usr/local/bin/lotus-worker
 
@@ -144,6 +156,9 @@ uninstall-daemon:
 uninstall-miner:
 	rm -f /usr/local/bin/lotus-miner
 
+uninstall-provider:
+	rm -f /usr/local/bin/lotus-provider
+
 uninstall-worker:
 	rm -f /usr/local/bin/lotus-worker
 
@@ -241,6 +256,14 @@ install-miner-service: install-miner install-daemon-service
 	@echo
 	@echo "lotus-miner service installed. Don't forget to run 'sudo systemctl start lotus-miner' to start it and 'sudo systemctl enable lotus-miner' for it to be enabled on startup."
 
+install-provider-service: install-provider install-daemon-service
+	mkdir -p /etc/systemd/system
+	mkdir -p /var/log/lotus
+	install -C -m 0644 ./scripts/lotus-provider.service /etc/systemd/system/lotus-provider.service
+	systemctl daemon-reload
+	@echo
+	@echo "lotus-provider service installed. Don't forget to run 'sudo systemctl start lotus-provider' to start it and 'sudo systemctl enable lotus-provider' for it to be enabled on startup."
+
 install-main-services: install-miner-service
 
 install-all-services: install-main-services
@@ -259,6 +282,12 @@ clean-miner-service:
 	rm -f /etc/systemd/system/lotus-miner.service
 	systemctl daemon-reload
 
+clean-provider-service:
+	-systemctl stop lotus-provider
+	-systemctl disable lotus-provider
+	rm -f /etc/systemd/system/lotus-provider.service
+	systemctl daemon-reload
+
 clean-main-services: clean-daemon-service
 
 clean-all-services: clean-main-services
@@ -294,7 +323,8 @@ actors-code-gen:
 	$(GOCC) run ./chain/actors/agen
 	$(GOCC) fmt ./...
 
-actors-gen: actors-code-gen fiximports
+actors-gen: actors-code-gen 
+	./scripts/fiximports
 .PHONY: actors-gen
 
 bundle-gen:
@@ -328,7 +358,7 @@ docsgen-md-bin: api-gen actors-gen
 docsgen-openrpc-bin: api-gen actors-gen
 	$(GOCC) build $(GOFLAGS) -o docgen-openrpc ./api/docgen-openrpc/cmd
 
-docsgen-md: docsgen-md-full docsgen-md-storage docsgen-md-worker
+docsgen-md: docsgen-md-full docsgen-md-storage docsgen-md-worker docsgen-md-provider
 
 docsgen-md-full: docsgen-md-bin
 	./docgen-md "api/api_full.go" "FullNode" "api" "./api" > documentation/en/api-v1-unstable-methods.md
@@ -337,6 +367,8 @@ docsgen-md-storage: docsgen-md-bin
 	./docgen-md "api/api_storage.go" "StorageMiner" "api" "./api" > documentation/en/api-v0-methods-miner.md
 docsgen-md-worker: docsgen-md-bin
 	./docgen-md "api/api_worker.go" "Worker" "api" "./api" > documentation/en/api-v0-methods-worker.md
+docsgen-md-provider: docsgen-md-bin
+	./docgen-md "api/api_lp.go" "Provider" "api" "./api" > documentation/en/api-v0-methods-provider.md
 
 docsgen-openrpc: docsgen-openrpc-full docsgen-openrpc-storage docsgen-openrpc-worker docsgen-openrpc-gateway
 
@@ -354,21 +386,23 @@ docsgen-openrpc-gateway: docsgen-openrpc-bin
 fiximports:
 	./scripts/fiximports
 
-gen: actors-code-gen type-gen cfgdoc-gen docsgen api-gen circleci fiximports
+gen: actors-code-gen type-gen cfgdoc-gen docsgen api-gen circleci
+	./scripts/fiximports
 	@echo ">>> IF YOU'VE MODIFIED THE CLI OR CONFIG, REMEMBER TO ALSO RUN 'make docsgen-cli'"
 .PHONY: gen
 
 jen: gen
 
-snap: lotus lotus-miner lotus-worker
+snap: lotus lotus-miner lotus-worker lotus-provider
 	snapcraft
 	# snapcraft upload ./lotus_*.snap
 
 # separate from gen because it needs binaries
-docsgen-cli: lotus lotus-miner lotus-worker
+docsgen-cli: lotus lotus-miner lotus-worker lotus-provider
 	python3 ./scripts/generate-lotus-cli.py
 	./lotus config default > documentation/en/default-lotus-config.toml
 	./lotus-miner config default > documentation/en/default-lotus-miner-config.toml
+	./lotus-provider config default > documentation/en/default-lotus-provider-config.toml
 .PHONY: docsgen-cli
 
 print-%:
diff --git a/README.md b/README.md
index f6ac75932..c944d41e6 100644
--- a/README.md
+++ b/README.md
@@ -71,10 +71,10 @@ For other distributions you can find the required dependencies [here.](https://l
 
 #### Go
 
-To build Lotus, you need a working installation of [Go 1.19.12 or higher](https://golang.org/dl/):
+To build Lotus, you need a working installation of [Go 1.20.10 or higher](https://golang.org/dl/):
 
 ```bash
-wget -c https://golang.org/dl/go1.19.12.linux-amd64.tar.gz -O - | sudo tar -xz -C /usr/local
+wget -c https://golang.org/dl/go1.20.10.linux-amd64.tar.gz -O - | sudo tar -xz -C /usr/local
 ```
 
 **TIP:**
@@ -133,6 +133,8 @@ Note: The default branch `master` is the dev branch where the latest new feature
 
 6. You should now have Lotus installed. You can now [start the Lotus daemon and sync the chain](https://lotus.filecoin.io/lotus/install/linux/#start-the-lotus-daemon-and-sync-the-chain).
 
+7. (Optional) Follow the [Setting Up Prometheus and Grafana](https://github.com/filecoin-project/lotus/tree/master/metrics/README.md) guide for detailed instructions on setting up a working monitoring system running against a local running lotus node.
+
 ## License
 
 Dual-licensed under [MIT](https://github.com/filecoin-project/lotus/blob/master/LICENSE-MIT) + [Apache 2.0](https://github.com/filecoin-project/lotus/blob/master/LICENSE-APACHE)
diff --git a/api/api_full.go b/api/api_full.go
index f919bc13b..4ae2ea531 100644
--- a/api/api_full.go
+++ b/api/api_full.go
@@ -824,7 +824,7 @@ type FullNode interface {
 	EthFeeHistory(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthFeeHistory, error)                                                                          //perm:read
 
 	EthMaxPriorityFeePerGas(ctx context.Context) (ethtypes.EthBigInt, error)                                             //perm:read
-	EthEstimateGas(ctx context.Context, tx ethtypes.EthCall) (ethtypes.EthUint64, error)                                 //perm:read
+	EthEstimateGas(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthUint64, error)                                 //perm:read
 	EthCall(ctx context.Context, tx ethtypes.EthCall, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBytes, error) //perm:read
 
 	EthSendRawTransaction(ctx context.Context, rawTx ethtypes.EthBytes) (ethtypes.EthHash, error) //perm:read
diff --git a/api/api_gateway.go b/api/api_gateway.go
index 27e725457..238bf43ab 100644
--- a/api/api_gateway.go
+++ b/api/api_gateway.go
@@ -114,7 +114,7 @@ type Gateway interface {
 	EthGasPrice(ctx context.Context) (ethtypes.EthBigInt, error)
 	EthFeeHistory(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthFeeHistory, error)
 	EthMaxPriorityFeePerGas(ctx context.Context) (ethtypes.EthBigInt, error)
-	EthEstimateGas(ctx context.Context, tx ethtypes.EthCall) (ethtypes.EthUint64, error)
+	EthEstimateGas(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthUint64, error)
 	EthCall(ctx context.Context, tx ethtypes.EthCall, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBytes, error)
 	EthSendRawTransaction(ctx context.Context, rawTx ethtypes.EthBytes) (ethtypes.EthHash, error)
 	EthGetLogs(ctx context.Context, filter *ethtypes.EthFilterSpec) (*ethtypes.EthFilterResult, error)
diff --git a/api/api_lp.go b/api/api_lp.go
new file mode 100644
index 000000000..8b58379f8
--- /dev/null
+++ b/api/api_lp.go
@@ -0,0 +1,10 @@
+package api
+
+import "context"
+
+type LotusProvider interface {
+	Version(context.Context) (Version, error) //perm:admin
+
+	// Trigger shutdown
+	Shutdown(context.Context) error //perm:admin
+}
diff --git a/api/client/client.go b/api/client/client.go
index 8b159c5b1..4d51221f9 100644
--- a/api/client/client.go
+++ b/api/client/client.go
@@ -15,6 +15,16 @@ import (
 	"github.com/filecoin-project/lotus/lib/rpcenc"
 )
 
+// NewProviderRpc creates a new http jsonrpc client.
+func NewProviderRpc(ctx context.Context, addr string, requestHeader http.Header) (api.LotusProvider, jsonrpc.ClientCloser, error) {
+	var res v1api.LotusProviderStruct
+
+	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
+		api.GetInternalStructs(&res), requestHeader, jsonrpc.WithErrors(api.RPCErrors))
+
+	return &res, closer, err
+}
+
 // NewCommonRPCV0 creates a new http jsonrpc client.
 func NewCommonRPCV0(ctx context.Context, addr string, requestHeader http.Header) (api.CommonNet, jsonrpc.ClientCloser, error) {
 	var res v0api.CommonNetStruct
diff --git a/api/docgen/docgen.go b/api/docgen/docgen.go
index 018629600..5a05c8d0e 100644
--- a/api/docgen/docgen.go
+++ b/api/docgen/docgen.go
@@ -432,6 +432,10 @@ func GetAPIType(name, pkg string) (i interface{}, t reflect.Type, permStruct []r
 			i = &api.GatewayStruct{}
 			t = reflect.TypeOf(new(struct{ api.Gateway })).Elem()
 			permStruct = append(permStruct, reflect.TypeOf(api.GatewayStruct{}.Internal))
+		case "Provider":
+			i = &api.LotusProviderStruct{}
+			t = reflect.TypeOf(new(struct{ api.LotusProvider })).Elem()
+			permStruct = append(permStruct, reflect.TypeOf(api.LotusProviderStruct{}.Internal))
 		default:
 			panic("unknown type")
 		}
diff --git a/api/mocks/mock_full.go b/api/mocks/mock_full.go
index 856d83813..92b719550 100644
--- a/api/mocks/mock_full.go
+++ b/api/mocks/mock_full.go
@@ -1042,7 +1042,7 @@ func (mr *MockFullNodeMockRecorder) EthChainId(arg0 interface{}) *gomock.Call {
 }
 
 // EthEstimateGas mocks base method.
-func (m *MockFullNode) EthEstimateGas(arg0 context.Context, arg1 ethtypes.EthCall) (ethtypes.EthUint64, error) {
+func (m *MockFullNode) EthEstimateGas(arg0 context.Context, arg1 jsonrpc.RawParams) (ethtypes.EthUint64, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "EthEstimateGas", arg0, arg1)
 	ret0, _ := ret[0].(ethtypes.EthUint64)
diff --git a/api/permissioned.go b/api/permissioned.go
index 72d2239ee..f189cd78f 100644
--- a/api/permissioned.go
+++ b/api/permissioned.go
@@ -41,6 +41,12 @@ func PermissionedWorkerAPI(a Worker) Worker {
 	return &out
 }
 
+func PermissionedAPI[T, P any](a T) *P {
+	var out P
+	permissionedProxies(a, &out)
+	return &out
+}
+
 func PermissionedWalletAPI(a Wallet) Wallet {
 	var out WalletStruct
 	permissionedProxies(a, &out)
diff --git a/api/proxy_gen.go b/api/proxy_gen.go
index 2d1333495..6627a5afe 100644
--- a/api/proxy_gen.go
+++ b/api/proxy_gen.go
@@ -255,7 +255,7 @@ type FullNodeMethods struct {
 
 	EthChainId func(p0 context.Context) (ethtypes.EthUint64, error) `perm:"read"`
 
-	EthEstimateGas func(p0 context.Context, p1 ethtypes.EthCall) (ethtypes.EthUint64, error) `perm:"read"`
+	EthEstimateGas func(p0 context.Context, p1 jsonrpc.RawParams) (ethtypes.EthUint64, error) `perm:"read"`
 
 	EthFeeHistory func(p0 context.Context, p1 jsonrpc.RawParams) (ethtypes.EthFeeHistory, error) `perm:"read"`
 
@@ -679,7 +679,7 @@ type GatewayMethods struct {
 
 	EthChainId func(p0 context.Context) (ethtypes.EthUint64, error) ``
 
-	EthEstimateGas func(p0 context.Context, p1 ethtypes.EthCall) (ethtypes.EthUint64, error) ``
+	EthEstimateGas func(p0 context.Context, p1 jsonrpc.RawParams) (ethtypes.EthUint64, error) ``
 
 	EthFeeHistory func(p0 context.Context, p1 jsonrpc.RawParams) (ethtypes.EthFeeHistory, error) ``
 
@@ -831,6 +831,19 @@ type GatewayMethods struct {
 type GatewayStub struct {
 }
 
+type LotusProviderStruct struct {
+	Internal LotusProviderMethods
+}
+
+type LotusProviderMethods struct {
+	Shutdown func(p0 context.Context) error `perm:"admin"`
+
+	Version func(p0 context.Context) (Version, error) `perm:"admin"`
+}
+
+type LotusProviderStub struct {
+}
+
 type NetStruct struct {
 	Internal NetMethods
 }
@@ -2134,14 +2147,14 @@ func (s *FullNodeStub) EthChainId(p0 context.Context) (ethtypes.EthUint64, error
 	return *new(ethtypes.EthUint64), ErrNotSupported
 }
 
-func (s *FullNodeStruct) EthEstimateGas(p0 context.Context, p1 ethtypes.EthCall) (ethtypes.EthUint64, error) {
+func (s *FullNodeStruct) EthEstimateGas(p0 context.Context, p1 jsonrpc.RawParams) (ethtypes.EthUint64, error) {
 	if s.Internal.EthEstimateGas == nil {
 		return *new(ethtypes.EthUint64), ErrNotSupported
 	}
 	return s.Internal.EthEstimateGas(p0, p1)
 }
 
-func (s *FullNodeStub) EthEstimateGas(p0 context.Context, p1 ethtypes.EthCall) (ethtypes.EthUint64, error) {
+func (s *FullNodeStub) EthEstimateGas(p0 context.Context, p1 jsonrpc.RawParams) (ethtypes.EthUint64, error) {
 	return *new(ethtypes.EthUint64), ErrNotSupported
 }
 
@@ -4400,14 +4413,14 @@ func (s *GatewayStub) EthChainId(p0 context.Context) (ethtypes.EthUint64, error)
 	return *new(ethtypes.EthUint64), ErrNotSupported
 }
 
-func (s *GatewayStruct) EthEstimateGas(p0 context.Context, p1 ethtypes.EthCall) (ethtypes.EthUint64, error) {
+func (s *GatewayStruct) EthEstimateGas(p0 context.Context, p1 jsonrpc.RawParams) (ethtypes.EthUint64, error) {
 	if s.Internal.EthEstimateGas == nil {
 		return *new(ethtypes.EthUint64), ErrNotSupported
 	}
 	return s.Internal.EthEstimateGas(p0, p1)
 }
 
-func (s *GatewayStub) EthEstimateGas(p0 context.Context, p1 ethtypes.EthCall) (ethtypes.EthUint64, error) {
+func (s *GatewayStub) EthEstimateGas(p0 context.Context, p1 jsonrpc.RawParams) (ethtypes.EthUint64, error) {
 	return *new(ethtypes.EthUint64), ErrNotSupported
 }
 
@@ -5214,6 +5227,28 @@ func (s *GatewayStub) Web3ClientVersion(p0 context.Context) (string, error) {
 	return "", ErrNotSupported
 }
 
+func (s *LotusProviderStruct) Shutdown(p0 context.Context) error {
+	if s.Internal.Shutdown == nil {
+		return ErrNotSupported
+	}
+	return s.Internal.Shutdown(p0)
+}
+
+func (s *LotusProviderStub) Shutdown(p0 context.Context) error {
+	return ErrNotSupported
+}
+
+func (s *LotusProviderStruct) Version(p0 context.Context) (Version, error) {
+	if s.Internal.Version == nil {
+		return *new(Version), ErrNotSupported
+	}
+	return s.Internal.Version(p0)
+}
+
+func (s *LotusProviderStub) Version(p0 context.Context) (Version, error) {
+	return *new(Version), ErrNotSupported
+}
+
 func (s *NetStruct) ID(p0 context.Context) (peer.ID, error) {
 	if s.Internal.ID == nil {
 		return *new(peer.ID), ErrNotSupported
@@ -7442,6 +7477,7 @@ var _ CommonNet = new(CommonNetStruct)
 var _ EthSubscriber = new(EthSubscriberStruct)
 var _ FullNode = new(FullNodeStruct)
 var _ Gateway = new(GatewayStruct)
+var _ LotusProvider = new(LotusProviderStruct)
 var _ Net = new(NetStruct)
 var _ Signable = new(SignableStruct)
 var _ StorageMiner = new(StorageMinerStruct)
diff --git a/api/types.go b/api/types.go
index b1ec23f74..93ed4083f 100644
--- a/api/types.go
+++ b/api/types.go
@@ -56,9 +56,17 @@ type PubsubScore struct {
 	Score *pubsub.PeerScoreSnapshot
 }
 
+// MessageSendSpec contains optional fields which modify message sending behavior
 type MessageSendSpec struct {
-	MaxFee  abi.TokenAmount
+	// MaxFee specifies a cap on network fees related to this message
+	MaxFee abi.TokenAmount
+
+	// MsgUuid specifies a unique message identifier which can be used on node (or node cluster)
+	// level to prevent double-sends of messages even when nonce generation is not handled by sender
 	MsgUuid uuid.UUID
+
+	// MaximizeFeeCap makes message FeeCap be based entirely on MaxFee
+	MaximizeFeeCap bool
 }
 
 type MpoolMessageWhole struct {
diff --git a/api/v1api/latest.go b/api/v1api/latest.go
index aefb1543b..b8eeed2de 100644
--- a/api/v1api/latest.go
+++ b/api/v1api/latest.go
@@ -12,3 +12,5 @@ type RawFullNodeAPI FullNode
 func PermissionedFullAPI(a FullNode) FullNode {
 	return api.PermissionedFullAPI(a)
 }
+
+type LotusProviderStruct = api.LotusProviderStruct
diff --git a/api/version.go b/api/version.go
index 9c2113578..e968bf93b 100644
--- a/api/version.go
+++ b/api/version.go
@@ -59,6 +59,8 @@ var (
 
 	MinerAPIVersion0  = newVer(1, 5, 0)
 	WorkerAPIVersion0 = newVer(1, 7, 0)
+
+	ProviderAPIVersion0 = newVer(1, 0, 0)
 )
 
 //nolint:varcheck,deadcode
diff --git a/blockstore/idstore.go b/blockstore/idstore.go
index fb575dca7..a10aee575 100644
--- a/blockstore/idstore.go
+++ b/blockstore/idstore.go
@@ -183,3 +183,17 @@ func (b *idstore) Close() error {
 func (b *idstore) Flush(ctx context.Context) error {
 	return b.bs.Flush(ctx)
 }
+
+func (b *idstore) CollectGarbage(ctx context.Context, options ...BlockstoreGCOption) error {
+	if bs, ok := b.bs.(BlockstoreGC); ok {
+		return bs.CollectGarbage(ctx, options...)
+	}
+	return xerrors.Errorf("not supported")
+}
+
+func (b *idstore) GCOnce(ctx context.Context, options ...BlockstoreGCOption) error {
+	if bs, ok := b.bs.(BlockstoreGCOnce); ok {
+		return bs.GCOnce(ctx, options...)
+	}
+	return xerrors.Errorf("not supported")
+}
diff --git a/blockstore/splitstore/splitstore.go b/blockstore/splitstore/splitstore.go
index 1f1ba0e99..c1a95c8b0 100644
--- a/blockstore/splitstore/splitstore.go
+++ b/blockstore/splitstore/splitstore.go
@@ -182,7 +182,6 @@ type SplitStore struct {
 
 	compactionIndex int64
 	pruneIndex      int64
-	onlineGCCnt     int64
 
 	ctx    context.Context
 	cancel func()
diff --git a/blockstore/splitstore/splitstore_compact.go b/blockstore/splitstore/splitstore_compact.go
index 534565bf3..47caca886 100644
--- a/blockstore/splitstore/splitstore_compact.go
+++ b/blockstore/splitstore/splitstore_compact.go
@@ -66,8 +66,9 @@ var (
 )
 
 const (
-	batchSize  = 16384
-	cidKeySize = 128
+	batchSize              = 16384
+	cidKeySize             = 128
+	purgeWorkSliceDuration = time.Second
 )
 
 func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
@@ -1372,9 +1373,21 @@ func (s *SplitStore) purge(coldr *ColdSetReader, checkpoint *Checkpoint, markSet
 		return err
 	}
 
+	now := time.Now()
+
 	err := coldr.ForEach(func(c cid.Cid) error {
 		batch = append(batch, c)
 		if len(batch) == batchSize {
+			// add some time slicing to the purge as this a very disk I/O heavy operation that
+			// requires write access to txnLk that may starve other operations that require
+			// access to the blockstore.
+			elapsed := time.Since(now)
+			if elapsed > purgeWorkSliceDuration {
+				// work 1 slice, sleep 4 slices, or 20% utilization
+				time.Sleep(4 * elapsed)
+				now = time.Now()
+			}
+
 			return deleteBatch()
 		}
 
diff --git a/blockstore/splitstore/splitstore_test.go b/blockstore/splitstore/splitstore_test.go
index 63e77b47e..1b821654d 100644
--- a/blockstore/splitstore/splitstore_test.go
+++ b/blockstore/splitstore/splitstore_test.go
@@ -3,9 +3,9 @@ package splitstore
 
 import (
 	"context"
+	"crypto/rand"
 	"errors"
 	"fmt"
-	"math/rand"
 	"sync"
 	"sync/atomic"
 	"testing"
diff --git a/build/bootstrap/mainnet.pi b/build/bootstrap/mainnet.pi
index f053d4e29..7838158de 100644
--- a/build/bootstrap/mainnet.pi
+++ b/build/bootstrap/mainnet.pi
@@ -1,9 +1,6 @@
 /dns4/bootstrap-0.mainnet.filops.net/tcp/1347/p2p/12D3KooWCVe8MmsEMes2FzgTpt9fXtmCY7wrq91GRiaC8PHSCCBj
 /dns4/bootstrap-1.mainnet.filops.net/tcp/1347/p2p/12D3KooWCwevHg1yLCvktf2nvLu7L9894mcrJR4MsBCcm4syShVc
 /dns4/bootstrap-2.mainnet.filops.net/tcp/1347/p2p/12D3KooWEWVwHGn2yR36gKLozmb4YjDJGerotAPGxmdWZx2nxMC4
-/dns4/bootstrap-3.mainnet.filops.net/tcp/1347/p2p/12D3KooWKhgq8c7NQ9iGjbyK7v7phXvG6492HQfiDaGHLHLQjk7R
-/dns4/bootstrap-4.mainnet.filops.net/tcp/1347/p2p/12D3KooWL6PsFNPhYftrJzGgF5U18hFoaVhfGk7xwzD8yVrHJ3Uc
-/dns4/bootstrap-5.mainnet.filops.net/tcp/1347/p2p/12D3KooWLFynvDQiUpXoHroV1YxKHhPJgysQGH2k3ZGwtWzR4dFH
 /dns4/bootstrap-6.mainnet.filops.net/tcp/1347/p2p/12D3KooWP5MwCiqdMETF9ub1P3MbCvQCcfconnYHbWg6sUJcDRQQ
 /dns4/bootstrap-7.mainnet.filops.net/tcp/1347/p2p/12D3KooWRs3aY1p3juFjPy8gPN95PEQChm2QKGUCAdcDCC4EBMKf
 /dns4/bootstrap-8.mainnet.filops.net/tcp/1347/p2p/12D3KooWScFR7385LTyR4zU1bYdzSiiAb5rnNABfVahPvVSzyTkR
@@ -11,7 +8,5 @@
 /dns4/bootstrap-0.starpool.in/tcp/12757/p2p/12D3KooWGHpBMeZbestVEWkfdnC9u7p6uFHXL1n7m1ZBqsEmiUzz
 /dns4/bootstrap-1.starpool.in/tcp/12757/p2p/12D3KooWQZrGH1PxSNZPum99M1zNvjNFM33d1AAu5DcvdHptuU7u
 /dns4/node.glif.io/tcp/1235/p2p/12D3KooWBF8cpp65hp2u9LK5mh19x67ftAam84z9LsfaquTDSBpt
-/dns4/bootstrap-0.ipfsmain.cn/tcp/34721/p2p/12D3KooWQnwEGNqcM2nAcPtRR9rAX8Hrg4k9kJLCHoTR5chJfz6d
-/dns4/bootstrap-1.ipfsmain.cn/tcp/34723/p2p/12D3KooWMKxMkD5DMpSWsW7dBddKxKT7L2GgbNuckz9otxvkvByP
 /dns4/bootstarp-0.1475.io/tcp/61256/p2p/12D3KooWRzCVDwHUkgdK7eRgnoXbjDAELhxPErjHzbRLguSV1aRt
 /dns4/bootstrap-venus.mainnet.filincubator.com/tcp/8888/p2p/QmQu8C6deXwKvJP2D8B6QGyhngc3ZiDnFzEHBDx8yeBXST
diff --git a/build/isnearupgrade.go b/build/isnearupgrade.go
index 4273f0e9e..74975780f 100644
--- a/build/isnearupgrade.go
+++ b/build/isnearupgrade.go
@@ -5,5 +5,8 @@ import (
 )
 
 func IsNearUpgrade(epoch, upgradeEpoch abi.ChainEpoch) bool {
+	if upgradeEpoch < 0 {
+		return false
+	}
 	return epoch > upgradeEpoch-Finality && epoch < upgradeEpoch+Finality
 }
diff --git a/build/openrpc/full.json.gz b/build/openrpc/full.json.gz
index 4e8edaee0..dbfbbe1f0 100644
Binary files a/build/openrpc/full.json.gz and b/build/openrpc/full.json.gz differ
diff --git a/build/openrpc/gateway.json.gz b/build/openrpc/gateway.json.gz
index 3d83445ed..bde1ec8f4 100644
Binary files a/build/openrpc/gateway.json.gz and b/build/openrpc/gateway.json.gz differ
diff --git a/build/openrpc/miner.json.gz b/build/openrpc/miner.json.gz
index 0f75197d7..b5eb84c2f 100644
Binary files a/build/openrpc/miner.json.gz and b/build/openrpc/miner.json.gz differ
diff --git a/build/openrpc/worker.json.gz b/build/openrpc/worker.json.gz
index cbbe526db..63b778855 100644
Binary files a/build/openrpc/worker.json.gz and b/build/openrpc/worker.json.gz differ
diff --git a/build/version.go b/build/version.go
index dbf3c96f4..ebd744f8b 100644
--- a/build/version.go
+++ b/build/version.go
@@ -37,7 +37,7 @@ func BuildTypeString() string {
 }
 
 // BuildVersion is the local build version
-const BuildVersion = "1.25.1"
+const BuildVersion = "1.25.2"
 
 func UserVersion() string {
 	if os.Getenv("LOTUS_VERSION_IGNORE_COMMIT") == "1" {
diff --git a/chain/actors/builtin/miner/state.go.template b/chain/actors/builtin/miner/state.go.template
index b322b2283..3c7f05d9a 100644
--- a/chain/actors/builtin/miner/state.go.template
+++ b/chain/actors/builtin/miner/state.go.template
@@ -72,7 +72,7 @@ func (s *state{{.v}}) AvailableBalance(bal abi.TokenAmount) (available abi.Token
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available{{if (ge .v 2)}}, err{{end}} = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/miner/v0.go b/chain/actors/builtin/miner/v0.go
index 7d5eaf8e0..5301ed1cb 100644
--- a/chain/actors/builtin/miner/v0.go
+++ b/chain/actors/builtin/miner/v0.go
@@ -62,7 +62,7 @@ func (s *state0) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmoun
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/miner/v10.go b/chain/actors/builtin/miner/v10.go
index 4d47ba396..53dc90b45 100644
--- a/chain/actors/builtin/miner/v10.go
+++ b/chain/actors/builtin/miner/v10.go
@@ -62,7 +62,7 @@ func (s *state10) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmou
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available, err = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/miner/v11.go b/chain/actors/builtin/miner/v11.go
index a3ffd606f..11a91c26b 100644
--- a/chain/actors/builtin/miner/v11.go
+++ b/chain/actors/builtin/miner/v11.go
@@ -62,7 +62,7 @@ func (s *state11) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmou
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available, err = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/miner/v12.go b/chain/actors/builtin/miner/v12.go
index 787da7d0f..90ecc97fd 100644
--- a/chain/actors/builtin/miner/v12.go
+++ b/chain/actors/builtin/miner/v12.go
@@ -62,7 +62,7 @@ func (s *state12) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmou
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available, err = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/miner/v2.go b/chain/actors/builtin/miner/v2.go
index 14341ae38..5a81ad31f 100644
--- a/chain/actors/builtin/miner/v2.go
+++ b/chain/actors/builtin/miner/v2.go
@@ -61,7 +61,7 @@ func (s *state2) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmoun
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available, err = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/miner/v3.go b/chain/actors/builtin/miner/v3.go
index 52808da8c..aa1574cf4 100644
--- a/chain/actors/builtin/miner/v3.go
+++ b/chain/actors/builtin/miner/v3.go
@@ -62,7 +62,7 @@ func (s *state3) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmoun
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available, err = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/miner/v4.go b/chain/actors/builtin/miner/v4.go
index 5980ef769..1faf30c09 100644
--- a/chain/actors/builtin/miner/v4.go
+++ b/chain/actors/builtin/miner/v4.go
@@ -62,7 +62,7 @@ func (s *state4) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmoun
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available, err = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/miner/v5.go b/chain/actors/builtin/miner/v5.go
index 886300ea3..be4b5e0b2 100644
--- a/chain/actors/builtin/miner/v5.go
+++ b/chain/actors/builtin/miner/v5.go
@@ -62,7 +62,7 @@ func (s *state5) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmoun
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available, err = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/miner/v6.go b/chain/actors/builtin/miner/v6.go
index 4737b0ee2..fa8c30e40 100644
--- a/chain/actors/builtin/miner/v6.go
+++ b/chain/actors/builtin/miner/v6.go
@@ -62,7 +62,7 @@ func (s *state6) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmoun
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available, err = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/miner/v7.go b/chain/actors/builtin/miner/v7.go
index 72803eb75..d6bb0e16e 100644
--- a/chain/actors/builtin/miner/v7.go
+++ b/chain/actors/builtin/miner/v7.go
@@ -62,7 +62,7 @@ func (s *state7) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmoun
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available, err = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/miner/v8.go b/chain/actors/builtin/miner/v8.go
index 3e3739591..06a205e76 100644
--- a/chain/actors/builtin/miner/v8.go
+++ b/chain/actors/builtin/miner/v8.go
@@ -62,7 +62,7 @@ func (s *state8) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmoun
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available, err = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/miner/v9.go b/chain/actors/builtin/miner/v9.go
index 72d9dbd59..6cbbd509e 100644
--- a/chain/actors/builtin/miner/v9.go
+++ b/chain/actors/builtin/miner/v9.go
@@ -62,7 +62,7 @@ func (s *state9) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmoun
 			available = abi.NewTokenAmount(0)
 		}
 	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	// this panics if the miner doesn't have enough funds to cover their locked pledge
 	available, err = s.GetAvailableBalance(bal)
 	return available, err
 }
diff --git a/chain/actors/builtin/paych/actor.go.template b/chain/actors/builtin/paych/actor.go.template
index e19ac5e29..3498a7a49 100644
--- a/chain/actors/builtin/paych/actor.go.template
+++ b/chain/actors/builtin/paych/actor.go.template
@@ -29,7 +29,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
-// Load returns an abstract copy of payment channel state, irregardless of actor version
+// Load returns an abstract copy of payment channel state, regardless of actor version
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	if name, av, ok := actors.GetActorMetaByCode(act.Code); ok {
        if name != manifest.PaychKey {
diff --git a/chain/actors/builtin/paych/paych.go b/chain/actors/builtin/paych/paych.go
index 8a7979e95..fc8908cb4 100644
--- a/chain/actors/builtin/paych/paych.go
+++ b/chain/actors/builtin/paych/paych.go
@@ -29,7 +29,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
-// Load returns an abstract copy of payment channel state, irregardless of actor version
+// Load returns an abstract copy of payment channel state, regardless of actor version
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	if name, av, ok := actors.GetActorMetaByCode(act.Code); ok {
 		if name != manifest.PaychKey {
diff --git a/chain/actors/params.go b/chain/actors/params.go
index f09b0be55..866c72b99 100644
--- a/chain/actors/params.go
+++ b/chain/actors/params.go
@@ -13,7 +13,7 @@ import (
 func SerializeParams(i cbg.CBORMarshaler) ([]byte, aerrors.ActorError) {
 	buf := new(bytes.Buffer)
 	if err := i.MarshalCBOR(buf); err != nil {
-		// TODO: shouldnt this be a fatal error?
+		// TODO: shouldn't this be a fatal error?
 		return nil, aerrors.Absorb(err, exitcode.ErrSerialization, "failed to encode parameter")
 	}
 	return buf.Bytes(), nil
diff --git a/chain/actors/policy/policy.go b/chain/actors/policy/policy.go
index a0e4728fe..6d2b41154 100644
--- a/chain/actors/policy/policy.go
+++ b/chain/actors/policy/policy.go
@@ -867,6 +867,24 @@ func AggregatePreCommitNetworkFee(nwVer network.Version, aggregateSize int, base
 	}
 }
 
+var PoStToSealMap map[abi.RegisteredPoStProof]abi.RegisteredSealProof
+
+func init() {
+	PoStToSealMap = make(map[abi.RegisteredPoStProof]abi.RegisteredSealProof)
+	for sealProof, info := range abi.SealProofInfos {
+		PoStToSealMap[info.WinningPoStProof] = sealProof
+		PoStToSealMap[info.WindowPoStProof] = sealProof
+	}
+}
+
+func GetSealProofFromPoStProof(postProof abi.RegisteredPoStProof) (abi.RegisteredSealProof, error) {
+	sealProof, exists := PoStToSealMap[postProof]
+	if !exists {
+		return 0, xerrors.New("no corresponding RegisteredSealProof for the given RegisteredPoStProof")
+	}
+	return sealProof, nil
+}
+
 func min(a, b int) int {
 	if a < b {
 		return a
diff --git a/chain/actors/policy/policy.go.template b/chain/actors/policy/policy.go.template
index 8803c97e6..d13518e0a 100644
--- a/chain/actors/policy/policy.go.template
+++ b/chain/actors/policy/policy.go.template
@@ -343,9 +343,26 @@ func AggregatePreCommitNetworkFee(nwVer network.Version, aggregateSize int, base
 	}
 }
 
+var PoStToSealMap map[abi.RegisteredPoStProof]abi.RegisteredSealProof
+func init() {
+	PoStToSealMap = make(map[abi.RegisteredPoStProof]abi.RegisteredSealProof)
+	for sealProof, info := range abi.SealProofInfos {
+		PoStToSealMap[info.WinningPoStProof] = sealProof
+		PoStToSealMap[info.WindowPoStProof] = sealProof
+	}
+}
+
+func GetSealProofFromPoStProof(postProof abi.RegisteredPoStProof) (abi.RegisteredSealProof, error) {
+	sealProof, exists := PoStToSealMap[postProof]
+	if !exists {
+		return 0, xerrors.New("no corresponding RegisteredSealProof for the given RegisteredPoStProof")
+	}
+	return sealProof, nil
+}
+
 func min(a, b int) int {
     if a < b {
         return a
     }
     return b
-}
\ No newline at end of file
+}
diff --git a/chain/beacon/drand/drand.go b/chain/beacon/drand/drand.go
index aa5e36717..5825fa691 100644
--- a/chain/beacon/drand/drand.go
+++ b/chain/beacon/drand/drand.go
@@ -29,19 +29,6 @@ import (
 
 var log = logging.Logger("drand")
 
-type drandPeer struct {
-	addr string
-	tls  bool
-}
-
-func (dp *drandPeer) Address() string {
-	return dp.addr
-}
-
-func (dp *drandPeer) IsTLS() bool {
-	return dp.tls
-}
-
 // DrandBeacon connects Lotus with a drand network in order to provide
 // randomness to the system in a way that's aligned with Filecoin rounds/epochs.
 //
diff --git a/chain/beacon/drand/drand_test.go b/chain/beacon/drand/drand_test.go
index 7269139ca..7434241a5 100644
--- a/chain/beacon/drand/drand_test.go
+++ b/chain/beacon/drand/drand_test.go
@@ -17,7 +17,7 @@ import (
 )
 
 func TestPrintGroupInfo(t *testing.T) {
-	server := build.DrandConfigs[build.DrandDevnet].Servers[0]
+	server := build.DrandConfigs[build.DrandTestnet].Servers[0]
 	c, err := hclient.New(server, nil, nil)
 	assert.NoError(t, err)
 	cg := c.(interface {
@@ -31,7 +31,7 @@ func TestPrintGroupInfo(t *testing.T) {
 
 func TestMaxBeaconRoundForEpoch(t *testing.T) {
 	todayTs := uint64(1652222222)
-	db, err := NewDrandBeacon(todayTs, build.BlockDelaySecs, nil, build.DrandConfigs[build.DrandDevnet])
+	db, err := NewDrandBeacon(todayTs, build.BlockDelaySecs, nil, build.DrandConfigs[build.DrandTestnet])
 	assert.NoError(t, err)
 	mbr15 := db.MaxBeaconRoundForEpoch(network.Version15, 100)
 	mbr16 := db.MaxBeaconRoundForEpoch(network.Version16, 100)
diff --git a/chain/consensus/common.go b/chain/consensus/common.go
index 1d9fb3646..a7e5c40d2 100644
--- a/chain/consensus/common.go
+++ b/chain/consensus/common.go
@@ -362,7 +362,8 @@ func CreateBlockHeader(ctx context.Context, sm *stmgr.StateManager, pts *types.T
 	var blsMsgCids, secpkMsgCids []cid.Cid
 	var blsSigs []crypto.Signature
 	nv := sm.GetNetworkVersion(ctx, bt.Epoch)
-	for _, msg := range bt.Messages {
+	for _, msgTmp := range bt.Messages {
+		msg := msgTmp
 		if msg.Signature.Type == crypto.SigTypeBLS {
 			blsSigs = append(blsSigs, msg.Signature)
 			blsMessages = append(blsMessages, &msg.Message)
diff --git a/chain/consensus/compute_state.go b/chain/consensus/compute_state.go
index 1edeb60b7..4b993b3e7 100644
--- a/chain/consensus/compute_state.go
+++ b/chain/consensus/compute_state.go
@@ -147,9 +147,6 @@ func (t *TipSetExecutor) ApplyBlocks(ctx context.Context,
 				return xerrors.Errorf("callback failed on cron message: %w", err)
 			}
 		}
-		if ret.ExitCode != 0 {
-			return xerrors.Errorf("cron exit was non-zero: %d", ret.ExitCode)
-		}
 
 		return nil
 	}
diff --git a/chain/consensus/filcns/filecoin.go b/chain/consensus/filcns/filecoin.go
index b5ec13a60..bb70d5d11 100644
--- a/chain/consensus/filcns/filecoin.go
+++ b/chain/consensus/filcns/filecoin.go
@@ -91,9 +91,6 @@ var RewardFunc = func(ctx context.Context, vmi vm.Interface, em stmgr.ExecMonito
 		}
 	}
 
-	if ret.ExitCode != 0 {
-		return xerrors.Errorf("reward application message failed (exit %d): %s", ret.ExitCode, ret.ActorErr)
-	}
 	return nil
 }
 
diff --git a/chain/events/events_height.go b/chain/events/events_height.go
index 457933fc6..5789be753 100644
--- a/chain/events/events_height.go
+++ b/chain/events/events_height.go
@@ -180,7 +180,7 @@ func (e *heightEventsObserver) Revert(ctx context.Context, from, to *types.TipSe
 	// Update the head first so we don't accidental skip reverting a concurrent call to ChainAt.
 	e.updateHead(to)
 
-	// Call revert on all hights between the two tipsets, handling empty tipsets.
+	// Call revert on all heights between the two tipsets, handling empty tipsets.
 	for h := from.Height(); h > to.Height(); h-- {
 		e.lk.Lock()
 		triggers := e.tsHeights[h]
diff --git a/chain/events/events_test.go b/chain/events/events_test.go
index e2450909c..f16434355 100644
--- a/chain/events/events_test.go
+++ b/chain/events/events_test.go
@@ -673,7 +673,7 @@ func TestCalled(t *testing.T) {
 	}, 3, 20, matchAddrMethod(t0123, 5))
 	require.NoError(t, err)
 
-	// create few blocks to make sure nothing get's randomly called
+	// create few blocks to make sure nothing gets randomly called
 
 	fcs.advance(0, 4, 0, nil) // H=5
 	require.Equal(t, false, applied)
@@ -991,7 +991,7 @@ func TestCalledNull(t *testing.T) {
 	}, 3, 20, matchAddrMethod(t0123, 5))
 	require.NoError(t, err)
 
-	// create few blocks to make sure nothing get's randomly called
+	// create few blocks to make sure nothing gets randomly called
 
 	fcs.advance(0, 4, 0, nil) // H=5
 	require.Equal(t, false, applied)
@@ -1050,7 +1050,7 @@ func TestRemoveTriggersOnMessage(t *testing.T) {
 	}, 3, 20, matchAddrMethod(t0123, 5))
 	require.NoError(t, err)
 
-	// create few blocks to make sure nothing get's randomly called
+	// create few blocks to make sure nothing gets randomly called
 
 	fcs.advance(0, 4, 0, nil) // H=5
 	require.Equal(t, false, applied)
@@ -1155,7 +1155,7 @@ func TestStateChanged(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	// create few blocks to make sure nothing get's randomly called
+	// create few blocks to make sure nothing gets randomly called
 
 	fcs.advance(0, 4, 0, nil) // H=5
 	require.Equal(t, false, applied)
diff --git a/chain/events/filter/event.go b/chain/events/filter/event.go
index b821a2f83..24192a53e 100644
--- a/chain/events/filter/event.go
+++ b/chain/events/filter/event.go
@@ -388,7 +388,7 @@ func (m *EventFilterManager) Install(ctx context.Context, minHeight, maxHeight a
 
 	if m.EventIndex != nil && minHeight != -1 && minHeight < currentHeight {
 		// Filter needs historic events
-		if err := m.EventIndex.PrefillFilter(ctx, f); err != nil {
+		if err := m.EventIndex.PrefillFilter(ctx, f, true); err != nil {
 			return nil, err
 		}
 	}
diff --git a/chain/events/filter/index.go b/chain/events/filter/index.go
index bacba60d7..2b1890c73 100644
--- a/chain/events/filter/index.go
+++ b/chain/events/filter/index.go
@@ -481,7 +481,7 @@ func (ei *EventIndex) CollectEvents(ctx context.Context, te *TipSetEvents, rever
 }
 
 // PrefillFilter fills a filter's collection of events from the historic index
-func (ei *EventIndex) PrefillFilter(ctx context.Context, f *EventFilter) error {
+func (ei *EventIndex) PrefillFilter(ctx context.Context, f *EventFilter, excludeReverted bool) error {
 	clauses := []string{}
 	values := []any{}
 	joins := []string{}
@@ -500,6 +500,11 @@ func (ei *EventIndex) PrefillFilter(ctx context.Context, f *EventFilter) error {
 		}
 	}
 
+	if excludeReverted {
+		clauses = append(clauses, "event.reverted=?")
+		values = append(values, false)
+	}
+
 	if len(f.addresses) > 0 {
 		subclauses := []string{}
 		for _, addr := range f.addresses {
diff --git a/chain/events/filter/index_test.go b/chain/events/filter/index_test.go
index fcdb1ab05..f9b1b14ad 100644
--- a/chain/events/filter/index_test.go
+++ b/chain/events/filter/index_test.go
@@ -272,7 +272,7 @@ func TestEventIndexPrefillFilter(t *testing.T) {
 	for _, tc := range testCases {
 		tc := tc // appease lint
 		t.Run(tc.name, func(t *testing.T) {
-			if err := ei.PrefillFilter(context.Background(), tc.filter); err != nil {
+			if err := ei.PrefillFilter(context.Background(), tc.filter, false); err != nil {
 				require.NoError(t, err, "prefill filter events")
 			}
 
@@ -281,3 +281,619 @@ func TestEventIndexPrefillFilter(t *testing.T) {
 		})
 	}
 }
+
+func TestEventIndexPrefillFilterExcludeReverted(t *testing.T) {
+	rng := pseudo.New(pseudo.NewSource(299792458))
+	a1 := randomF4Addr(t, rng)
+	a2 := randomF4Addr(t, rng)
+	a3 := randomF4Addr(t, rng)
+
+	a1ID := abi.ActorID(1)
+	a2ID := abi.ActorID(2)
+
+	addrMap := addressMap{}
+	addrMap.add(a1ID, a1)
+	addrMap.add(a2ID, a2)
+
+	ev1 := fakeEvent(
+		a1ID,
+		[]kv{
+			{k: "type", v: []byte("approval")},
+			{k: "signer", v: []byte("addr1")},
+		},
+		[]kv{
+			{k: "amount", v: []byte("2988181")},
+		},
+	)
+	ev2 := fakeEvent(
+		a2ID,
+		[]kv{
+			{k: "type", v: []byte("approval")},
+			{k: "signer", v: []byte("addr2")},
+		},
+		[]kv{
+			{k: "amount", v: []byte("2988182")},
+		},
+	)
+
+	st := newStore()
+	events := []*types.Event{ev1}
+	revertedEvents := []*types.Event{ev2}
+	em := executedMessage{
+		msg: fakeMessage(randomF4Addr(t, rng), randomF4Addr(t, rng)),
+		rct: fakeReceipt(t, rng, st, events),
+		evs: events,
+	}
+	revertedEm := executedMessage{
+		msg: fakeMessage(randomF4Addr(t, rng), randomF4Addr(t, rng)),
+		rct: fakeReceipt(t, rng, st, revertedEvents),
+		evs: revertedEvents,
+	}
+
+	events14000 := buildTipSetEvents(t, rng, 14000, em)
+	revertedEvents14000 := buildTipSetEvents(t, rng, 14000, revertedEm)
+	cid14000, err := events14000.msgTs.Key().Cid()
+	require.NoError(t, err, "tipset cid")
+	reveredCID14000, err := revertedEvents14000.msgTs.Key().Cid()
+	require.NoError(t, err, "tipset cid")
+
+	noCollectedEvents := []*CollectedEvent{}
+	oneCollectedEvent := []*CollectedEvent{
+		{
+			Entries:     ev1.Entries,
+			EmitterAddr: a1,
+			EventIdx:    0,
+			Reverted:    false,
+			Height:      14000,
+			TipSetKey:   events14000.msgTs.Key(),
+			MsgIdx:      0,
+			MsgCid:      em.msg.Cid(),
+		},
+	}
+	twoCollectedEvent := []*CollectedEvent{
+		{
+			Entries:     ev1.Entries,
+			EmitterAddr: a1,
+			EventIdx:    0,
+			Reverted:    false,
+			Height:      14000,
+			TipSetKey:   events14000.msgTs.Key(),
+			MsgIdx:      0,
+			MsgCid:      em.msg.Cid(),
+		},
+		{
+			Entries:     ev2.Entries,
+			EmitterAddr: a2,
+			EventIdx:    0,
+			Reverted:    true,
+			Height:      14000,
+			TipSetKey:   revertedEvents14000.msgTs.Key(),
+			MsgIdx:      0,
+			MsgCid:      revertedEm.msg.Cid(),
+		},
+	}
+	oneCollectedRevertedEvent := []*CollectedEvent{
+		{
+			Entries:     ev2.Entries,
+			EmitterAddr: a2,
+			EventIdx:    0,
+			Reverted:    true,
+			Height:      14000,
+			TipSetKey:   revertedEvents14000.msgTs.Key(),
+			MsgIdx:      0,
+			MsgCid:      revertedEm.msg.Cid(),
+		},
+	}
+
+	workDir, err := os.MkdirTemp("", "lotusevents")
+	require.NoError(t, err, "create temporary work directory")
+
+	defer func() {
+		_ = os.RemoveAll(workDir)
+	}()
+	t.Logf("using work dir %q", workDir)
+
+	dbPath := filepath.Join(workDir, "actorevents.db")
+
+	ei, err := NewEventIndex(context.Background(), dbPath, nil)
+	require.NoError(t, err, "create event index")
+	if err := ei.CollectEvents(context.Background(), revertedEvents14000, false, addrMap.ResolveAddress); err != nil {
+		require.NoError(t, err, "collect reverted events")
+	}
+	if err := ei.CollectEvents(context.Background(), revertedEvents14000, true, addrMap.ResolveAddress); err != nil {
+		require.NoError(t, err, "revert reverted events")
+	}
+	if err := ei.CollectEvents(context.Background(), events14000, false, addrMap.ResolveAddress); err != nil {
+		require.NoError(t, err, "collect events")
+	}
+
+	inclusiveTestCases := []struct {
+		name   string
+		filter *EventFilter
+		te     *TipSetEvents
+		want   []*CollectedEvent
+	}{
+		{
+			name: "nomatch tipset min height",
+			filter: &EventFilter{
+				minHeight: 14001,
+				maxHeight: -1,
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "nomatch tipset max height",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: 13999,
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "match tipset min height",
+			filter: &EventFilter{
+				minHeight: 14000,
+				maxHeight: -1,
+			},
+			te:   events14000,
+			want: twoCollectedEvent,
+		},
+		{
+			name: "match tipset cid",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				tipsetCid: cid14000,
+			},
+			te:   events14000,
+			want: oneCollectedEvent,
+		},
+		{
+			name: "match tipset cid",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				tipsetCid: reveredCID14000,
+			},
+			te:   revertedEvents14000,
+			want: oneCollectedRevertedEvent,
+		},
+		{
+			name: "nomatch address",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				addresses: []address.Address{a3},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "match address 2",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				addresses: []address.Address{a2},
+			},
+			te:   revertedEvents14000,
+			want: oneCollectedRevertedEvent,
+		},
+		{
+			name: "match address 1",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				addresses: []address.Address{a1},
+			},
+			te:   events14000,
+			want: oneCollectedEvent,
+		},
+		{
+			name: "match one entry",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("approval"),
+					},
+				},
+			},
+			te:   events14000,
+			want: twoCollectedEvent,
+		},
+		{
+			name: "match one entry with alternate values",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("cancel"),
+						[]byte("propose"),
+						[]byte("approval"),
+					},
+				},
+			},
+			te:   events14000,
+			want: twoCollectedEvent,
+		},
+		{
+			name: "nomatch one entry by missing value",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("cancel"),
+						[]byte("propose"),
+					},
+				},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "nomatch one entry by missing key",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"method": {
+						[]byte("approval"),
+					},
+				},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "match one entry with multiple keys",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("approval"),
+					},
+					"signer": {
+						[]byte("addr1"),
+					},
+				},
+			},
+			te:   events14000,
+			want: oneCollectedEvent,
+		},
+		{
+			name: "match one entry with multiple keys",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("approval"),
+					},
+					"signer": {
+						[]byte("addr2"),
+					},
+				},
+			},
+			te:   revertedEvents14000,
+			want: oneCollectedRevertedEvent,
+		},
+		{
+			name: "nomatch one entry with one mismatching key",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("approval"),
+					},
+					"approver": {
+						[]byte("addr1"),
+					},
+				},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "nomatch one entry with one mismatching value",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("approval"),
+					},
+					"signer": {
+						[]byte("addr3"),
+					},
+				},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "nomatch one entry with one unindexed key",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"amount": {
+						[]byte("2988181"),
+					},
+				},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "nomatch one entry with one unindexed key",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"amount": {
+						[]byte("2988182"),
+					},
+				},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+	}
+
+	exclusiveTestCases := []struct {
+		name   string
+		filter *EventFilter
+		te     *TipSetEvents
+		want   []*CollectedEvent
+	}{
+		{
+			name: "nomatch tipset min height",
+			filter: &EventFilter{
+				minHeight: 14001,
+				maxHeight: -1,
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "nomatch tipset max height",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: 13999,
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "match tipset min height",
+			filter: &EventFilter{
+				minHeight: 14000,
+				maxHeight: -1,
+			},
+			te:   events14000,
+			want: oneCollectedEvent,
+		},
+		{
+			name: "match tipset cid",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				tipsetCid: cid14000,
+			},
+			te:   events14000,
+			want: oneCollectedEvent,
+		},
+		{
+			name: "match tipset cid but reverted",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				tipsetCid: reveredCID14000,
+			},
+			te:   revertedEvents14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "nomatch address",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				addresses: []address.Address{a3},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "nomatch address 2 but reverted",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				addresses: []address.Address{a2},
+			},
+			te:   revertedEvents14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "match address",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				addresses: []address.Address{a1},
+			},
+			te:   events14000,
+			want: oneCollectedEvent,
+		},
+		{
+			name: "match one entry",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("approval"),
+					},
+				},
+			},
+			te:   events14000,
+			want: oneCollectedEvent,
+		},
+		{
+			name: "match one entry with alternate values",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("cancel"),
+						[]byte("propose"),
+						[]byte("approval"),
+					},
+				},
+			},
+			te:   events14000,
+			want: oneCollectedEvent,
+		},
+		{
+			name: "nomatch one entry by missing value",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("cancel"),
+						[]byte("propose"),
+					},
+				},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "nomatch one entry by missing key",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"method": {
+						[]byte("approval"),
+					},
+				},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "match one entry with multiple keys",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("approval"),
+					},
+					"signer": {
+						[]byte("addr1"),
+					},
+				},
+			},
+			te:   events14000,
+			want: oneCollectedEvent,
+		},
+		{
+			name: "nomatch one entry with one mismatching key",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("approval"),
+					},
+					"approver": {
+						[]byte("addr1"),
+					},
+				},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "nomatch one entry with matching reverted value",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("approval"),
+					},
+					"signer": {
+						[]byte("addr2"),
+					},
+				},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "nomatch one entry with one mismatching value",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"type": {
+						[]byte("approval"),
+					},
+					"signer": {
+						[]byte("addr3"),
+					},
+				},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+		{
+			name: "nomatch one entry with one unindexed key",
+			filter: &EventFilter{
+				minHeight: -1,
+				maxHeight: -1,
+				keys: map[string][][]byte{
+					"amount": {
+						[]byte("2988181"),
+					},
+				},
+			},
+			te:   events14000,
+			want: noCollectedEvents,
+		},
+	}
+
+	for _, tc := range inclusiveTestCases {
+		tc := tc // appease lint
+		t.Run(tc.name, func(t *testing.T) {
+			if err := ei.PrefillFilter(context.Background(), tc.filter, false); err != nil {
+				require.NoError(t, err, "prefill filter events")
+			}
+
+			coll := tc.filter.TakeCollectedEvents(context.Background())
+			require.ElementsMatch(t, coll, tc.want, tc.name)
+		})
+	}
+
+	for _, tc := range exclusiveTestCases {
+		tc := tc // appease lint
+		t.Run(tc.name, func(t *testing.T) {
+			if err := ei.PrefillFilter(context.Background(), tc.filter, true); err != nil {
+				require.NoError(t, err, "prefill filter events")
+			}
+
+			coll := tc.filter.TakeCollectedEvents(context.Background())
+			require.ElementsMatch(t, coll, tc.want, tc.name)
+		})
+	}
+}
diff --git a/chain/events/state/ctxstore.go b/chain/events/state/ctxstore.go
deleted file mode 100644
index 12b45e425..000000000
--- a/chain/events/state/ctxstore.go
+++ /dev/null
@@ -1,25 +0,0 @@
-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)
-}
diff --git a/chain/exchange/client.go b/chain/exchange/client.go
index fca8249ce..9cbb44955 100644
--- a/chain/exchange/client.go
+++ b/chain/exchange/client.go
@@ -247,7 +247,7 @@ func (c *client) processResponse(req *Request, res *Response, tipsets []*types.T
 			// If we didn't request the headers they should have been provided
 			// by the caller.
 			if len(tipsets) < len(res.Chain) {
-				return nil, xerrors.Errorf("not enought tipsets provided for message response validation, needed %d, have %d", len(res.Chain), len(tipsets))
+				return nil, xerrors.Errorf("not enough tipsets provided for message response validation, needed %d, have %d", len(res.Chain), len(tipsets))
 			}
 			chain := make([]*BSTipSet, 0, resLength)
 			for i, resChain := range res.Chain {
@@ -284,16 +284,18 @@ func (c *client) validateCompressedIndices(chain []*BSTipSet) error {
 				len(msgs.SecpkIncludes), blocksNum)
 		}
 
+		blsLen := uint64(len(msgs.Bls))
+		secpLen := uint64(len(msgs.Secpk))
 		for blockIdx := 0; blockIdx < blocksNum; blockIdx++ {
 			for _, mi := range msgs.BlsIncludes[blockIdx] {
-				if int(mi) >= len(msgs.Bls) {
+				if mi >= blsLen {
 					return xerrors.Errorf("index in BlsIncludes (%d) exceeds number of messages (%d)",
 						mi, len(msgs.Bls))
 				}
 			}
 
 			for _, mi := range msgs.SecpkIncludes[blockIdx] {
-				if int(mi) >= len(msgs.Secpk) {
+				if mi >= secpLen {
 					return xerrors.Errorf("index in SecpkIncludes (%d) exceeds number of messages (%d)",
 						mi, len(msgs.Secpk))
 				}
@@ -315,18 +317,36 @@ func (c *client) GetBlocks(ctx context.Context, tsk types.TipSetKey, count int)
 		)
 	}
 
-	req := &Request{
-		Head:    tsk.Cids(),
-		Length:  uint64(count),
-		Options: Headers,
+	var ret []*types.TipSet
+	start := tsk.Cids()
+	for len(ret) < count {
+		req := &Request{
+			Head:    start,
+			Length:  uint64(count - len(ret)),
+			Options: Headers,
+		}
+
+		validRes, err := c.doRequest(ctx, req, nil, nil)
+		if err != nil {
+			return nil, xerrors.Errorf("failed to doRequest: %w", err)
+		}
+
+		if len(validRes.tipsets) == 0 {
+			return nil, xerrors.Errorf("doRequest fetched zero tipsets: %w", err)
+		}
+
+		ret = append(ret, validRes.tipsets...)
+
+		last := validRes.tipsets[len(validRes.tipsets)-1]
+		if last.Height() <= 1 {
+			// we've walked all the way up to genesis, return
+			break
+		}
+
+		start = last.Parents().Cids()
 	}
 
-	validRes, err := c.doRequest(ctx, req, nil, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return validRes.tipsets, nil
+	return ret, nil
 }
 
 // GetFullTipSet implements Client.GetFullTipSet(). Refer to the godocs there.
@@ -341,12 +361,16 @@ func (c *client) GetFullTipSet(ctx context.Context, peer peer.ID, tsk types.TipS
 
 	validRes, err := c.doRequest(ctx, req, &peer, nil)
 	if err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("failed to doRequest: %w", err)
 	}
 
-	return validRes.toFullTipSets()[0], nil
-	// If `doRequest` didn't fail we are guaranteed to have at least
-	//  *one* tipset here, so it's safe to index directly.
+	fullTipsets := validRes.toFullTipSets()
+
+	if len(fullTipsets) == 0 {
+		return nil, xerrors.New("unexpectedly got no tipsets in exchange")
+	}
+
+	return fullTipsets[0], nil
 }
 
 // GetChainMessages implements Client.GetChainMessages(). Refer to the godocs there.
@@ -386,7 +410,7 @@ func (c *client) sendRequestToPeer(ctx context.Context, peer peer.ID, req *Reque
 	defer span.End()
 	if span.IsRecordingEvents() {
 		span.AddAttributes(
-			trace.StringAttribute("peer", peer.Pretty()),
+			trace.StringAttribute("peer", peer.String()),
 		)
 	}
 	defer func() {
diff --git a/chain/exchange/interfaces.go b/chain/exchange/interfaces.go
index c95127929..ff11b63eb 100644
--- a/chain/exchange/interfaces.go
+++ b/chain/exchange/interfaces.go
@@ -28,8 +28,8 @@ type Server interface {
 // used by the Syncer.
 type Client interface {
 	// GetBlocks fetches block headers from the network, from the provided
-	// tipset *backwards*, returning as many tipsets as the count parameter,
-	// or less.
+	// tipset *backwards*, returning as many tipsets as the count parameter.
+	// The ONLY case in which we return fewer than `count` tipsets is if we hit genesis.
 	GetBlocks(ctx context.Context, tsk types.TipSetKey, count int) ([]*types.TipSet, error)
 
 	// GetChainMessages fetches messages from the network, starting from the first provided tipset
diff --git a/chain/gen/genesis/miners.go b/chain/gen/genesis/miners.go
index 0bac282d2..df8900cab 100644
--- a/chain/gen/genesis/miners.go
+++ b/chain/gen/genesis/miners.go
@@ -251,7 +251,8 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sys vm.Syscal
 			}
 
 			params := &markettypes.PublishStorageDealsParams{}
-			for _, preseal := range m.Sectors {
+			for _, presealTmp := range m.Sectors {
+				preseal := presealTmp
 				preseal.Deal.VerifiedDeal = true
 				preseal.Deal.EndEpoch = minerInfos[i].presealExp
 				p := markettypes.ClientDealProposal{
diff --git a/chain/index/msgindex.go b/chain/index/msgindex.go
index 27eeea73e..e9e81ae2c 100644
--- a/chain/index/msgindex.go
+++ b/chain/index/msgindex.go
@@ -131,7 +131,7 @@ func NewMsgIndex(lctx context.Context, basePath string, cs ChainStore) (MsgIndex
 
 	db, err := sql.Open("sqlite3", dbPath)
 	if err != nil {
-		// TODO [nice to have]: automaticaly delete corrupt databases
+		// TODO [nice to have]: automatically delete corrupt databases
 		//      but for now we can just error and let the operator delete.
 		return nil, xerrors.Errorf("error opening msgindex database: %w", err)
 	}
diff --git a/chain/market/store.go b/chain/market/store.go
index ece1248f6..10ab2abe1 100644
--- a/chain/market/store.go
+++ b/chain/market/store.go
@@ -39,23 +39,6 @@ func (ps *Store) save(ctx context.Context, state *FundedAddressState) error {
 	return ps.ds.Put(ctx, k, b)
 }
 
-// get the state for the given address
-func (ps *Store) get(ctx context.Context, addr address.Address) (*FundedAddressState, error) {
-	k := dskeyForAddr(addr)
-
-	data, err := ps.ds.Get(ctx, k)
-	if err != nil {
-		return nil, err
-	}
-
-	var state FundedAddressState
-	err = cborrpc.ReadCborRPC(bytes.NewReader(data), &state)
-	if err != nil {
-		return nil, err
-	}
-	return &state, nil
-}
-
 // forEach calls iter with each address in the datastore
 func (ps *Store) forEach(ctx context.Context, iter func(*FundedAddressState)) error {
 	res, err := ps.ds.Query(ctx, dsq.Query{Prefix: dsKeyAddr})
diff --git a/chain/messagepool/block_proba_test.go b/chain/messagepool/block_proba_test.go
index 6d121d222..2dc1dc25d 100644
--- a/chain/messagepool/block_proba_test.go
+++ b/chain/messagepool/block_proba_test.go
@@ -5,7 +5,6 @@ import (
 	"math"
 	"math/rand"
 	"testing"
-	"time"
 )
 
 func TestBlockProbability(t *testing.T) {
@@ -23,7 +22,6 @@ func TestBlockProbability(t *testing.T) {
 
 func TestWinnerProba(t *testing.T) {
 	//stm: @OTHER_IMPLEMENTATION_BLOCK_PROB_002
-	rand.Seed(time.Now().UnixNano())
 	const N = 1000000
 	winnerProba := noWinnersProb()
 	sum := 0
diff --git a/chain/messagepool/messagepool.go b/chain/messagepool/messagepool.go
index 6dc3f2239..7d55b0b16 100644
--- a/chain/messagepool/messagepool.go
+++ b/chain/messagepool/messagepool.go
@@ -21,6 +21,7 @@ import (
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/minio/blake2b-simd"
 	"github.com/raulk/clock"
+	"go.opencensus.io/stats"
 	"golang.org/x/xerrors"
 
 	ffi "github.com/filecoin-project/filecoin-ffi"
@@ -210,8 +211,10 @@ func ComputeRBF(curPrem abi.TokenAmount, replaceByFeeRatio types.Percent) abi.To
 
 func CapGasFee(mff dtypes.DefaultMaxFeeFunc, msg *types.Message, sendSpec *api.MessageSendSpec) {
 	var maxFee abi.TokenAmount
+	var maximizeFeeCap bool
 	if sendSpec != nil {
 		maxFee = sendSpec.MaxFee
+		maximizeFeeCap = sendSpec.MaximizeFeeCap
 	}
 	if maxFee.Int == nil || maxFee.Equals(big.Zero()) {
 		mf, err := mff()
@@ -222,15 +225,12 @@ func CapGasFee(mff dtypes.DefaultMaxFeeFunc, msg *types.Message, sendSpec *api.M
 		maxFee = mf
 	}
 
-	gl := types.NewInt(uint64(msg.GasLimit))
-	totalFee := types.BigMul(msg.GasFeeCap, gl)
-
-	if totalFee.LessThanEqual(maxFee) {
-		msg.GasPremium = big.Min(msg.GasFeeCap, msg.GasPremium) // cap premium at FeeCap
-		return
+	gaslimit := types.NewInt(uint64(msg.GasLimit))
+	totalFee := types.BigMul(msg.GasFeeCap, gaslimit)
+	if maximizeFeeCap || totalFee.GreaterThan(maxFee) {
+		msg.GasFeeCap = big.Div(maxFee, gaslimit)
 	}
 
-	msg.GasFeeCap = big.Div(maxFee, gl)
 	msg.GasPremium = big.Min(msg.GasFeeCap, msg.GasPremium) // cap premium at FeeCap
 }
 
@@ -1022,6 +1022,9 @@ func (mp *MessagePool) addLocked(ctx context.Context, m *types.SignedMessage, st
 		}
 	})
 
+	// Record the current size of the Mpool
+	stats.Record(ctx, metrics.MpoolMessageCount.M(int64(mp.currentSize)))
+
 	return nil
 }
 
@@ -1214,6 +1217,9 @@ func (mp *MessagePool) remove(ctx context.Context, from address.Address, nonce u
 			return
 		}
 	}
+
+	// Record the current size of the Mpool
+	stats.Record(ctx, metrics.MpoolMessageCount.M(int64(mp.currentSize)))
 }
 
 func (mp *MessagePool) Pending(ctx context.Context) ([]*types.SignedMessage, *types.TipSet) {
diff --git a/chain/state/statetree.go b/chain/state/statetree.go
index c71473e8f..61d7d500a 100644
--- a/chain/state/statetree.go
+++ b/chain/state/statetree.go
@@ -438,7 +438,8 @@ func (st *StateTree) Flush(ctx context.Context) (cid.Cid, error) {
 		return cid.Undef, xerrors.Errorf("tried to flush state tree with snapshots on the stack")
 	}
 
-	for addr, sto := range st.snaps.layers[0].actors {
+	for addr, stoTmp := range st.snaps.layers[0].actors {
+		sto := stoTmp
 		if sto.Delete {
 			if err := st.root.Delete(abi.AddrKey(addr)); err != nil {
 				return cid.Undef, err
@@ -570,7 +571,7 @@ func (st *StateTree) ForEach(f func(address.Address, *types.Actor) error) error
 			}
 
 			// no need to record anything here, there are no duplicates in the actors HAMT
-			// iself.
+			// itself.
 			if _, ok := seen[addr]; ok {
 				return nil
 			}
@@ -588,7 +589,7 @@ func (st *StateTree) ForEach(f func(address.Address, *types.Actor) error) error
 		}
 
 		// no need to record anything here, there are no duplicates in the actors HAMT
-		// iself.
+		// itself.
 		if _, ok := seen[addr]; ok {
 			return nil
 		}
diff --git a/chain/stmgr/forks.go b/chain/stmgr/forks.go
index 8d1ac1dfb..9dd66ee8b 100644
--- a/chain/stmgr/forks.go
+++ b/chain/stmgr/forks.go
@@ -235,11 +235,6 @@ func (sm *StateManager) hasExpensiveForkBetween(parent, height abi.ChainEpoch) b
 	return false
 }
 
-func (sm *StateManager) hasExpensiveFork(height abi.ChainEpoch) bool {
-	_, ok := sm.expensiveUpgrades[height]
-	return ok
-}
-
 func runPreMigration(ctx context.Context, sm *StateManager, fn PreMigrationFunc, cache *nv16.MemMigrationCache, ts *types.TipSet) {
 	height := ts.Height()
 	parent := ts.ParentState()
diff --git a/chain/store/index_test.go b/chain/store/index_test.go
index a3a4ad6ce..3cde40062 100644
--- a/chain/store/index_test.go
+++ b/chain/store/index_test.go
@@ -42,7 +42,7 @@ func TestIndexSeeks(t *testing.T) {
 	cs := store.NewChainStore(nbs, nbs, syncds.MutexWrap(datastore.NewMapDatastore()), filcns.Weight, nil)
 	defer cs.Close() //nolint:errcheck
 
-	_, err = cs.Import(ctx, bytes.NewReader(gencar))
+	_, _, err = cs.Import(ctx, bytes.NewReader(gencar))
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/chain/store/messages.go b/chain/store/messages.go
index 3686f74f4..c23f900d7 100644
--- a/chain/store/messages.go
+++ b/chain/store/messages.go
@@ -212,13 +212,8 @@ func (cs *ChainStore) MessagesForTipset(ctx context.Context, ts *types.TipSet) (
 
 	var out []types.ChainMsg
 	for _, bm := range bmsgs {
-		for _, blsm := range bm.BlsMessages {
-			out = append(out, blsm)
-		}
-
-		for _, secm := range bm.SecpkMessages {
-			out = append(out, secm)
-		}
+		out = append(out, bm.BlsMessages...)
+		out = append(out, bm.SecpkMessages...)
 	}
 
 	return out, nil
diff --git a/chain/store/snapshot.go b/chain/store/snapshot.go
index 5e218fa36..de2190c5d 100644
--- a/chain/store/snapshot.go
+++ b/chain/store/snapshot.go
@@ -60,7 +60,7 @@ func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRo
 	})
 }
 
-func (cs *ChainStore) Import(ctx context.Context, r io.Reader) (*types.TipSet, error) {
+func (cs *ChainStore) Import(ctx context.Context, r io.Reader) (head *types.TipSet, genesis *types.BlockHeader, err error) {
 	// TODO: writing only to the state blockstore is incorrect.
 	//  At this time, both the state and chain blockstores are backed by the
 	//  universal store. When we physically segregate the stores, we will need
@@ -69,7 +69,7 @@ func (cs *ChainStore) Import(ctx context.Context, r io.Reader) (*types.TipSet, e
 
 	br, err := carv2.NewBlockReader(r)
 	if err != nil {
-		return nil, xerrors.Errorf("loadcar failed: %w", err)
+		return nil, nil, xerrors.Errorf("loadcar failed: %w", err)
 	}
 
 	s := cs.StateBlockstore()
@@ -80,27 +80,51 @@ func (cs *ChainStore) Import(ctx context.Context, r io.Reader) (*types.TipSet, e
 		putThrottle <- nil
 	}
 
+	if len(br.Roots) == 0 {
+		return nil, nil, xerrors.Errorf("no roots in snapshot car file")
+	}
+	nextTailCid := br.Roots[0]
+
+	var tailBlock types.BlockHeader
+	tailBlock.Height = abi.ChainEpoch(-1)
+
 	var buf []blocks.Block
 	for {
 		blk, err := br.Next()
 		if err != nil {
+
+			// we're at the end
 			if err == io.EOF {
 				if len(buf) > 0 {
 					if err := s.PutMany(ctx, buf); err != nil {
-						return nil, err
+						return nil, nil, err
 					}
 				}
 
 				break
 			}
-			return nil, err
+			return nil, nil, err
 		}
 
+		// check for header block, looking for genesis
+		if blk.Cid() == nextTailCid && tailBlock.Height != 0 {
+			if err := tailBlock.UnmarshalCBOR(bytes.NewReader(blk.RawData())); err != nil {
+				return nil, nil, xerrors.Errorf("failed to unmarshal genesis block: %w", err)
+			}
+			if len(tailBlock.Parents) > 0 {
+				nextTailCid = tailBlock.Parents[0]
+			} else {
+				// note: even the 0th block has a parent linking to the cbor genesis block
+				return nil, nil, xerrors.Errorf("current block (epoch %d cid %s) has no parents", tailBlock.Height, tailBlock.Cid())
+			}
+		}
+
+		// append to batch
 		buf = append(buf, blk)
 
 		if len(buf) > 1000 {
 			if lastErr := <-putThrottle; lastErr != nil { // consume one error to have the right to add one
-				return nil, lastErr
+				return nil, nil, lastErr
 			}
 
 			go func(buf []blocks.Block) {
@@ -113,13 +137,17 @@ func (cs *ChainStore) Import(ctx context.Context, r io.Reader) (*types.TipSet, e
 	// check errors
 	for i := 0; i < parallelPuts; i++ {
 		if lastErr := <-putThrottle; lastErr != nil {
-			return nil, lastErr
+			return nil, nil, lastErr
 		}
 	}
 
+	if tailBlock.Height != 0 {
+		return nil, nil, xerrors.Errorf("expected genesis block to have height 0 (genesis), got %d: %s", tailBlock.Height, tailBlock.Cid())
+	}
+
 	root, err := cs.LoadTipSet(ctx, types.NewTipSetKey(br.Roots...))
 	if err != nil {
-		return nil, xerrors.Errorf("failed to load root tipset from chainfile: %w", err)
+		return nil, nil, xerrors.Errorf("failed to load root tipset from chainfile: %w", err)
 	}
 
 	ts := root
@@ -135,10 +163,10 @@ func (cs *ChainStore) Import(ctx context.Context, r io.Reader) (*types.TipSet, e
 	}
 
 	if err := cs.PersistTipsets(ctx, tssToPersist); err != nil {
-		return nil, xerrors.Errorf("failed to persist tipsets: %w", err)
+		return nil, nil, xerrors.Errorf("failed to persist tipsets: %w", err)
 	}
 
-	return root, nil
+	return root, &tailBlock, nil
 }
 
 type walkSchedTaskType int
@@ -167,7 +195,7 @@ func (t walkSchedTaskType) String() string {
 	case dagTask:
 		return "dag"
 	}
-	panic(fmt.Sprintf("unknow task %d", t))
+	panic(fmt.Sprintf("unknown task %d", t))
 }
 
 type walkTask struct {
@@ -656,9 +684,7 @@ func (cs *ChainStore) WalkSnapshot(ctx context.Context, ts *types.TipSet, inclRe
 		}
 
 		if b.Height > 0 {
-			for _, p := range b.Parents {
-				blocksToWalk = append(blocksToWalk, p)
-			}
+			blocksToWalk = append(blocksToWalk, b.Parents...)
 		} else {
 			// include the genesis block
 			cids = append(cids, b.Parents...)
diff --git a/chain/store/store_test.go b/chain/store/store_test.go
index 9c717fdbe..1ecfc474a 100644
--- a/chain/store/store_test.go
+++ b/chain/store/store_test.go
@@ -118,7 +118,7 @@ func TestChainExportImport(t *testing.T) {
 	cs := store.NewChainStore(nbs, nbs, datastore.NewMapDatastore(), filcns.Weight, nil)
 	defer cs.Close() //nolint:errcheck
 
-	root, err := cs.Import(context.TODO(), buf)
+	root, _, err := cs.Import(context.TODO(), buf)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -153,7 +153,7 @@ func TestChainImportTipsetKeyCid(t *testing.T) {
 	cs := store.NewChainStore(nbs, nbs, datastore.NewMapDatastore(), filcns.Weight, nil)
 	defer cs.Close() //nolint:errcheck
 
-	root, err := cs.Import(ctx, buf)
+	root, _, err := cs.Import(ctx, buf)
 	require.NoError(t, err)
 
 	require.Truef(t, root.Equals(last), "imported chain differed from exported chain")
@@ -202,7 +202,7 @@ func TestChainExportImportFull(t *testing.T) {
 	cs := store.NewChainStore(nbs, nbs, ds, filcns.Weight, nil)
 	defer cs.Close() //nolint:errcheck
 
-	root, err := cs.Import(context.TODO(), buf)
+	root, _, err := cs.Import(context.TODO(), buf)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/chain/sub/incoming.go b/chain/sub/incoming.go
index 3a11f7c98..b50ddc467 100644
--- a/chain/sub/incoming.go
+++ b/chain/sub/incoming.go
@@ -516,7 +516,7 @@ func (v *IndexerMessageValidator) Validate(ctx context.Context, pid peer.ID, msg
 		return pubsub.ValidationReject
 	}
 	if len(idxrMsg.ExtraData) == 0 {
-		log.Debugw("ignoring messsage missing miner id", "peer", originPeer)
+		log.Debugw("ignoring message missing miner id", "peer", originPeer)
 		return pubsub.ValidationIgnore
 	}
 
@@ -552,7 +552,7 @@ func (v *IndexerMessageValidator) Validate(ctx context.Context, pid peer.ID, msg
 		// Check that the miner ID maps to the peer that sent the message.
 		err = v.authenticateMessage(ctx, minerAddr, originPeer)
 		if err != nil {
-			log.Warnw("cannot authenticate messsage", "err", err, "peer", originPeer, "minerID", minerAddr)
+			log.Warnw("cannot authenticate message", "err", err, "peer", originPeer, "minerID", minerAddr)
 			stats.Record(ctx, metrics.IndexerMessageValidationFailure.M(1))
 			return pubsub.ValidationReject
 		}
diff --git a/chain/sub/ratelimit/queue_test.go b/chain/sub/ratelimit/queue_test.go
new file mode 100644
index 000000000..cd66a423e
--- /dev/null
+++ b/chain/sub/ratelimit/queue_test.go
@@ -0,0 +1,61 @@
+package ratelimit
+
+import (
+	"testing"
+)
+
+func TestQueue(t *testing.T) {
+	const size = 3
+	q := &queue{buf: make([]int64, size)}
+
+	if q.len() != 0 {
+		t.Fatalf("q.len() = %d, expect 0", q.len())
+	}
+
+	if q.cap() != size {
+		t.Fatalf("q.cap() = %d, expect %d", q.cap(), size)
+	}
+
+	for i := int64(0); i < int64(size); i++ {
+		err := q.push(i)
+		if err != nil {
+			t.Fatalf("cannot push element %d", i)
+		}
+	}
+
+	if q.len() != size {
+		t.Fatalf("q.len() = %d, expect %d", q.len(), size)
+	}
+
+	err := q.push(int64(size))
+	if err != ErrRateLimitExceeded {
+		t.Fatalf("pushing element beyond capacity should have failed with err: %s, got %s", ErrRateLimitExceeded, err)
+	}
+
+	if q.front() != 0 {
+		t.Fatalf("q.front() = %d, expect 0", q.front())
+	}
+
+	if q.back() != int64(size-1) {
+		t.Fatalf("q.back() = %d, expect %d", q.back(), size-1)
+	}
+
+	popVal := q.pop()
+	if popVal != 0 {
+		t.Fatalf("q.pop() = %d, expect 0", popVal)
+	}
+
+	if q.len() != size-1 {
+		t.Fatalf("q.len() = %d, expect %d", q.len(), size-1)
+	}
+
+	// Testing truncation.
+	threshold := int64(1)
+	q.truncate(threshold)
+	if q.len() != 1 {
+		t.Fatalf("q.len() after truncate = %d, expect 1", q.len())
+	}
+	if q.front() != 2 {
+		t.Fatalf("q.front() after truncate = %d, expect 2", q.front())
+	}
+}
diff --git a/chain/sync.go b/chain/sync.go
index 044f317d9..4dccc2036 100644
--- a/chain/sync.go
+++ b/chain/sync.go
@@ -844,7 +844,7 @@ loop:
 		return nil, xerrors.Errorf("failed to load next local tipset: %w", err)
 	}
 	if base.IsChildOf(knownParent) {
-		// common case: receiving a block thats potentially part of the same tipset as our best block
+		// common case: receiving a block that's potentially part of the same tipset as our best block
 		return blockSet, nil
 	}
 
@@ -886,6 +886,35 @@ func (syncer *Syncer) syncFork(ctx context.Context, incoming *types.TipSet, know
 		}
 	}
 
+	incomingParentsTsk := incoming.Parents()
+	commonParent := false
+	for _, incomingParent := range incomingParentsTsk.Cids() {
+		if known.Contains(incomingParent) {
+			commonParent = true
+		}
+	}
+
+	if commonParent {
+		// known contains at least one of incoming's Parents => the common ancestor is known's Parents (incoming's Grandparents)
+		// in this case, we need to return {incoming.Parents()}
+		incomingParents, err := syncer.store.LoadTipSet(ctx, incomingParentsTsk)
+		if err != nil {
+			// fallback onto the network
+			tips, err := syncer.Exchange.GetBlocks(ctx, incoming.Parents(), 1)
+			if err != nil {
+				return nil, xerrors.Errorf("failed to fetch incomingParents from the network: %w", err)
+			}
+
+			if len(tips) == 0 {
+				return nil, xerrors.Errorf("network didn't return any tipsets")
+			}
+
+			incomingParents = tips[0]
+		}
+
+		return []*types.TipSet{incomingParents}, nil
+	}
+
 	// TODO: Does this mean we always ask for ForkLengthThreshold blocks from the network, even if we just need, like, 2? Yes.
 	// Would it not be better to ask in smaller chunks, given that an ~ForkLengthThreshold is very rare?
 	tips, err := syncer.Exchange.GetBlocks(ctx, incoming.Parents(), int(build.ForkLengthThreshold))
diff --git a/chain/sync_test.go b/chain/sync_test.go
index ec960d7d0..be7759603 100644
--- a/chain/sync_test.go
+++ b/chain/sync_test.go
@@ -11,7 +11,6 @@ import (
 	"github.com/ipfs/go-cid"
 	ds "github.com/ipfs/go-datastore"
 	logging "github.com/ipfs/go-log/v2"
-	"github.com/libp2p/go-libp2p/core/peer"
 	mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
 	"github.com/stretchr/testify/require"
 
@@ -344,13 +343,6 @@ func (tu *syncTestUtil) addClientNode() int {
 	return len(tu.nds) - 1
 }
 
-func (tu *syncTestUtil) pid(n int) peer.ID {
-	nal, err := tu.nds[n].NetAddrsListen(tu.ctx)
-	require.NoError(tu.t, err)
-
-	return nal.ID
-}
-
 func (tu *syncTestUtil) connect(from, to int) {
 	toPI, err := tu.nds[to].NetAddrsListen(tu.ctx)
 	require.NoError(tu.t, err)
diff --git a/chain/types/blockmsg_test.go b/chain/types/blockmsg_test.go
index 02a622768..ea20f64a7 100644
--- a/chain/types/blockmsg_test.go
+++ b/chain/types/blockmsg_test.go
@@ -7,9 +7,6 @@ import (
 )
 
 func TestDecodeBlockMsg(t *testing.T) {
-	type args struct {
-		b []byte
-	}
 	tests := []struct {
 		name    string
 		data    []byte
diff --git a/chain/types/ethtypes/eth_transactions.go b/chain/types/ethtypes/eth_transactions.go
index 6c13c5bf6..a3b1d0150 100644
--- a/chain/types/ethtypes/eth_transactions.go
+++ b/chain/types/ethtypes/eth_transactions.go
@@ -62,9 +62,14 @@ type EthTxArgs struct {
 // - BlockHash
 // - BlockNumber
 // - TransactionIndex
-// - From
 // - Hash
 func EthTxFromSignedEthMessage(smsg *types.SignedMessage) (EthTx, error) {
+	// The from address is always an f410f address, never an ID or other address.
+	if !IsEthAddress(smsg.Message.From) {
+		return EthTx{}, xerrors.Errorf("sender must be an eth account, was %s", smsg.Message.From)
+	}
+
+	// Probably redundant, but we might as well check.
 	if smsg.Signature.Type != typescrypto.SigTypeDelegated {
 		return EthTx{}, xerrors.Errorf("signature is not delegated type, is type: %d", smsg.Signature.Type)
 	}
@@ -79,10 +84,18 @@ func EthTxFromSignedEthMessage(smsg *types.SignedMessage) (EthTx, error) {
 		return EthTx{}, xerrors.Errorf("failed to recover signature: %w", err)
 	}
 
+	from, err := EthAddressFromFilecoinAddress(smsg.Message.From)
+	if err != nil {
+		// This should be impossible as we've already asserted that we have an EthAddress
+		// sender...
+		return EthTx{}, xerrors.Errorf("sender was not an eth account")
+	}
+
 	return EthTx{
 		Nonce:                EthUint64(txArgs.Nonce),
 		ChainID:              EthUint64(txArgs.ChainID),
 		To:                   txArgs.To,
+		From:                 from,
 		Value:                EthBigInt(txArgs.Value),
 		Type:                 Eip1559TxType,
 		Gas:                  EthUint64(txArgs.GasLimit),
diff --git a/chain/types/ethtypes/eth_types.go b/chain/types/ethtypes/eth_types.go
index b796e6f56..b933329f4 100644
--- a/chain/types/ethtypes/eth_types.go
+++ b/chain/types/ethtypes/eth_types.go
@@ -799,6 +799,45 @@ func GetContractEthAddressFromCode(sender EthAddress, salt [32]byte, initcode []
 	return ethAddr, nil
 }
 
+// EthEstimateGasParams handles raw jsonrpc params for eth_estimateGas
+type EthEstimateGasParams struct {
+	Tx       EthCall
+	BlkParam *EthBlockNumberOrHash
+}
+
+func (e *EthEstimateGasParams) UnmarshalJSON(b []byte) error {
+	var params []json.RawMessage
+	err := json.Unmarshal(b, &params)
+	if err != nil {
+		return err
+	}
+
+	switch len(params) {
+	case 2:
+		err = json.Unmarshal(params[1], &e.BlkParam)
+		if err != nil {
+			return err
+		}
+		fallthrough
+	case 1:
+		err = json.Unmarshal(params[0], &e.Tx)
+		if err != nil {
+			return err
+		}
+	default:
+		return xerrors.Errorf("expected 1 or 2 params, got %d", len(params))
+	}
+
+	return nil
+}
+
+func (e EthEstimateGasParams) MarshalJSON() ([]byte, error) {
+	if e.BlkParam != nil {
+		return json.Marshal([]interface{}{e.Tx, e.BlkParam})
+	}
+	return json.Marshal([]interface{}{e.Tx})
+}
+
 // EthFeeHistoryParams handles raw jsonrpc params for eth_feeHistory
 type EthFeeHistoryParams struct {
 	BlkCount          EthUint64
diff --git a/chain/types/fil.go b/chain/types/fil.go
index 60a2940c6..2a0ccb460 100644
--- a/chain/types/fil.go
+++ b/chain/types/fil.go
@@ -12,6 +12,9 @@ import (
 type FIL BigInt
 
 func (f FIL) String() string {
+	if f.Int == nil {
+		return "0 FIL"
+	}
 	return f.Unitless() + " FIL"
 }
 
diff --git a/chain/types/message_receipt_cbor.go b/chain/types/message_receipt_cbor.go
index e1364e654..955ca4d85 100644
--- a/chain/types/message_receipt_cbor.go
+++ b/chain/types/message_receipt_cbor.go
@@ -140,7 +140,7 @@ func (t *messageReceiptV0) UnmarshalCBOR(r io.Reader) (err error) {
 		case cbg.MajNegativeInt:
 			extraI = int64(extra)
 			if extraI < 0 {
-				return fmt.Errorf("int64 negative oveflow")
+				return fmt.Errorf("int64 negative overflow")
 			}
 			extraI = -1 - extraI
 		default:
@@ -186,7 +186,7 @@ func (t *messageReceiptV0) UnmarshalCBOR(r io.Reader) (err error) {
 		case cbg.MajNegativeInt:
 			extraI = int64(extra)
 			if extraI < 0 {
-				return fmt.Errorf("int64 negative oveflow")
+				return fmt.Errorf("int64 negative overflow")
 			}
 			extraI = -1 - extraI
 		default:
@@ -278,7 +278,7 @@ func (t *messageReceiptV1) UnmarshalCBOR(r io.Reader) (err error) {
 		case cbg.MajNegativeInt:
 			extraI = int64(extra)
 			if extraI < 0 {
-				return fmt.Errorf("int64 negative oveflow")
+				return fmt.Errorf("int64 negative overflow")
 			}
 			extraI = -1 - extraI
 		default:
@@ -324,7 +324,7 @@ func (t *messageReceiptV1) UnmarshalCBOR(r io.Reader) (err error) {
 		case cbg.MajNegativeInt:
 			extraI = int64(extra)
 			if extraI < 0 {
-				return fmt.Errorf("int64 negative oveflow")
+				return fmt.Errorf("int64 negative overflow")
 			}
 			extraI = -1 - extraI
 		default:
diff --git a/chain/types/vmcontext.go b/chain/types/vmcontext.go
index 83ad81315..bab9c213f 100644
--- a/chain/types/vmcontext.go
+++ b/chain/types/vmcontext.go
@@ -27,24 +27,3 @@ type StateTree interface {
 
 	Version() StateTreeVersion
 }
-
-type storageWrapper struct {
-	s Storage
-}
-
-func (sw *storageWrapper) Put(i cbg.CBORMarshaler) (cid.Cid, error) {
-	c, err := sw.s.Put(i)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	return c, nil
-}
-
-func (sw *storageWrapper) Get(c cid.Cid, out cbg.CBORUnmarshaler) error {
-	if err := sw.s.Get(c, out); err != nil {
-		return err
-	}
-
-	return nil
-}
diff --git a/chain/vectors/gen/main.go b/chain/vectors/gen/main.go
index ce9f1baf8..f4b7c82da 100644
--- a/chain/vectors/gen/main.go
+++ b/chain/vectors/gen/main.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	crand "crypto/rand"
 	"encoding/json"
 	"fmt"
 	"math/rand"
@@ -145,7 +146,10 @@ func MakeUnsignedMessageVectors() []vectors.UnsignedMessageVector {
 		}
 
 		params := make([]byte, 32)
-		rand.Read(params)
+		_, err = crand.Read(params)
+		if err != nil {
+			panic(err)
+		}
 
 		msg := &types.Message{
 			To:         to,
diff --git a/cli/helper.go b/cli/helper.go
index 81a5bb033..fb1899e0a 100644
--- a/cli/helper.go
+++ b/cli/helper.go
@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -8,7 +9,6 @@ import (
 	"syscall"
 
 	ufcli "github.com/urfave/cli/v2"
-	"golang.org/x/xerrors"
 )
 
 type PrintHelpErr struct {
@@ -52,7 +52,7 @@ func RunApp(app *ufcli.App) {
 			fmt.Fprintf(os.Stderr, "ERROR: %s\n\n", err) // nolint:errcheck
 		}
 		var phe *PrintHelpErr
-		if xerrors.As(err, &phe) {
+		if errors.As(err, &phe) {
 			_ = ufcli.ShowCommandHelp(phe.Ctx, phe.Ctx.Command.Name)
 		}
 		os.Exit(1)
diff --git a/cli/net.go b/cli/net.go
index 516b44b7f..99ee92aef 100644
--- a/cli/net.go
+++ b/cli/net.go
@@ -282,7 +282,7 @@ var NetDisconnect = &cli.Command{
 				fmt.Println("failure")
 				return err
 			}
-			fmt.Printf("disconnect %s: ", pid.Pretty())
+			fmt.Printf("disconnect %s: ", pid)
 			err = api.NetDisconnect(ctx, pid)
 			if err != nil {
 				fmt.Println("failure")
@@ -312,7 +312,7 @@ var NetConnect = &cli.Command{
 		}
 
 		for _, pi := range pis {
-			fmt.Printf("connect %s: ", pi.ID.Pretty())
+			fmt.Printf("connect %s: ", pi.ID)
 			err := api.NetConnect(ctx, pi)
 			if err != nil {
 				fmt.Println("failure")
@@ -847,7 +847,8 @@ var NetStatCmd = &cli.Command{
 			})
 
 			for _, stat := range stats {
-				printScope(&stat.stat, name+stat.name)
+				tmp := stat.stat
+				printScope(&tmp, name+stat.name)
 			}
 
 		}
diff --git a/cli/state.go b/cli/state.go
index 667f6fb19..31666a21c 100644
--- a/cli/state.go
+++ b/cli/state.go
@@ -1920,8 +1920,29 @@ var StateSysActorCIDsCmd = &cli.Command{
 		if err != nil {
 			return err
 		}
-		for name, cid := range actorsCids {
-			_, _ = fmt.Fprintf(tw, "%v\t%v\n", name, cid)
+
+		var actorsCidTuples []struct {
+			actorName string
+			actorCid  cid.Cid
+		}
+
+		for name, actorCid := range actorsCids {
+			keyVal := struct {
+				actorName string
+				actorCid  cid.Cid
+			}{
+				actorName: name,
+				actorCid:  actorCid,
+			}
+			actorsCidTuples = append(actorsCidTuples, keyVal)
+		}
+
+		sort.Slice(actorsCidTuples, func(i, j int) bool {
+			return actorsCidTuples[i].actorName < actorsCidTuples[j].actorName
+		})
+
+		for _, keyVal := range actorsCidTuples {
+			_, _ = fmt.Fprintf(tw, "%v\t%v\n", keyVal.actorName, keyVal.actorCid)
 		}
 		return tw.Flush()
 	},
diff --git a/cli/sync.go b/cli/sync.go
index 89d2d94f0..18ff24bc2 100644
--- a/cli/sync.go
+++ b/cli/sync.go
@@ -14,6 +14,7 @@ import (
 	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
+	cliutil "github.com/filecoin-project/lotus/cli/util"
 )
 
 var SyncCmd = &cli.Command{
@@ -262,6 +263,9 @@ func SyncWait(ctx context.Context, napi v0api.FullNode, watch bool) error {
 	}
 	firstApp = state.VMApplied
 
+	// eta computes the ETA for the sync to complete (with a lookback of 10 processed items)
+	eta := cliutil.NewETA(10)
+
 	for {
 		state, err := napi.SyncState(ctx)
 		if err != nil {
@@ -312,8 +316,10 @@ func SyncWait(ctx context.Context, napi v0api.FullNode, watch bool) error {
 			fmt.Print("\r\x1b[2K\x1b[A")
 		}
 
+		todo := theight - ss.Height
+
 		fmt.Printf("Worker: %d; Base: %d; Target: %d (diff: %d)\n", workerID, baseHeight, theight, heightDiff)
-		fmt.Printf("State: %s; Current Epoch: %d; Todo: %d\n", ss.Stage, ss.Height, theight-ss.Height)
+		fmt.Printf("State: %s; Current Epoch: %d; Todo: %d, ETA: %s\n", ss.Stage, ss.Height, todo, eta.Update(int64(todo)))
 		lastLines = 2
 
 		if i%samples == 0 {
diff --git a/cli/util/api.go b/cli/util/api.go
index 1d6928c3f..3602b752d 100644
--- a/cli/util/api.go
+++ b/cli/util/api.go
@@ -119,7 +119,7 @@ func GetAPIInfoMulti(ctx *cli.Context, t repo.RepoType) ([]APIInfo, error) {
 		}
 	}
 
-	return []APIInfo{}, fmt.Errorf("could not determine API endpoint for node type: %v", t.Type())
+	return []APIInfo{}, fmt.Errorf("could not determine API endpoint for node type: %v. Try setting environment variable: %s", t.Type(), primaryEnv)
 }
 
 func GetAPIInfo(ctx *cli.Context, t repo.RepoType) (APIInfo, error) {
@@ -164,6 +164,28 @@ func GetRawAPIMulti(ctx *cli.Context, t repo.RepoType, version string) ([]HttpHe
 	return httpHeads, nil
 }
 
+func GetRawAPIMultiV2(ctx *cli.Context, ainfoCfg []string, version string) ([]HttpHead, error) {
+	var httpHeads []HttpHead
+
+	if len(ainfoCfg) == 0 {
+		return httpHeads, xerrors.Errorf("could not get API info: none configured. \nConsider getting base.toml with './lotus-provider config get base >/tmp/base.toml' \nthen adding   \n[APIs] \n ChainApiInfo = [\" result_from lotus auth api-info --perm=admin \"]\n  and updating it with './lotus-provider config set /tmp/base.toml'")
+	}
+	for _, i := range ainfoCfg {
+		ainfo := ParseApiInfo(i)
+		addr, err := ainfo.DialArgs(version)
+		if err != nil {
+			return httpHeads, xerrors.Errorf("could not get DialArgs: %w", err)
+		}
+		httpHeads = append(httpHeads, HttpHead{addr: addr, header: ainfo.AuthHeader()})
+	}
+
+	if IsVeryVerbose {
+		_, _ = fmt.Fprintf(ctx.App.Writer, "using raw API %s endpoint: %s\n", version, httpHeads[0].addr)
+	}
+
+	return httpHeads, nil
+}
+
 func GetRawAPI(ctx *cli.Context, t repo.RepoType, version string) (string, http.Header, error) {
 	heads, err := GetRawAPIMulti(ctx, t, version)
 	if err != nil {
@@ -393,6 +415,68 @@ func GetFullNodeAPIV1(ctx *cli.Context, opts ...GetFullNodeOption) (v1api.FullNo
 	return &v1API, finalCloser, nil
 }
 
+func GetFullNodeAPIV1LotusProvider(ctx *cli.Context, ainfoCfg []string, opts ...GetFullNodeOption) (v1api.FullNode, jsonrpc.ClientCloser, error) {
+	if tn, ok := ctx.App.Metadata["testnode-full"]; ok {
+		return tn.(v1api.FullNode), func() {}, nil
+	}
+
+	var options GetFullNodeOptions
+	for _, opt := range opts {
+		opt(&options)
+	}
+
+	var rpcOpts []jsonrpc.Option
+	if options.ethSubHandler != nil {
+		rpcOpts = append(rpcOpts, jsonrpc.WithClientHandler("Filecoin", options.ethSubHandler), jsonrpc.WithClientHandlerAlias("eth_subscription", "Filecoin.EthSubscription"))
+	}
+
+	heads, err := GetRawAPIMultiV2(ctx, ainfoCfg, "v1")
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if IsVeryVerbose {
+		_, _ = fmt.Fprintln(ctx.App.Writer, "using full node API v1 endpoint:", heads[0].addr)
+	}
+
+	var fullNodes []api.FullNode
+	var closers []jsonrpc.ClientCloser
+
+	for _, head := range heads {
+		v1api, closer, err := client.NewFullNodeRPCV1(ctx.Context, head.addr, head.header, rpcOpts...)
+		if err != nil {
+			log.Warnf("Not able to establish connection to node with addr: %s", head.addr)
+			continue
+		}
+		fullNodes = append(fullNodes, v1api)
+		closers = append(closers, closer)
+	}
+
+	// When running in cluster mode and trying to establish connections to multiple nodes, fail
+	// if less than 2 lotus nodes are actually running
+	if len(heads) > 1 && len(fullNodes) < 2 {
+		return nil, nil, xerrors.Errorf("Not able to establish connection to more than a single node")
+	}
+
+	finalCloser := func() {
+		for _, c := range closers {
+			c()
+		}
+	}
+
+	var v1API api.FullNodeStruct
+	FullNodeProxy(fullNodes, &v1API)
+
+	v, err := v1API.Version(ctx.Context)
+	if err != nil {
+		return nil, nil, err
+	}
+	if !v.APIVersion.EqMajorMinor(api.FullAPIVersion1) {
+		return nil, nil, xerrors.Errorf("Remote API version didn't match (expected %s, remote %s)", api.FullAPIVersion1, v.APIVersion)
+	}
+	return &v1API, finalCloser, nil
+}
+
 type GetStorageMinerOptions struct {
 	PreferHttp bool
 }
diff --git a/cli/util/eta.go b/cli/util/eta.go
new file mode 100644
index 000000000..de06ec1ff
--- /dev/null
+++ b/cli/util/eta.go
@@ -0,0 +1,94 @@
+package cliutil
+
+import (
+	"fmt"
+	"math"
+	"time"
+)
+
+// ETA implements a very simple eta calculator based on the number of remaining items. It does not
+// require knowing the work size in advance and is therefore suitable for streaming workloads and
+// also does not require that consecutive updates have a monotonically decreasing remaining value.
+type ETA struct {
+	// max number of items to keep in memory
+	maxItems int
+	// a queue of most recently updated items
+	items []item
+	// we store the last calculated ETA which we reuse if there was not change in remaining items
+	lastETA string
+}
+
+type item struct {
+	timestamp time.Time
+	remaining int64
+}
+
+// NewETA creates a new ETA calculator of the given size
+func NewETA(maxItems int) *ETA {
+	return &ETA{
+		maxItems: maxItems,
+		items:    make([]item, 0),
+	}
+}
+
+// Update updates the ETA calculator with the remaining number of items and returns the ETA
+func (e *ETA) Update(remaining int64) string {
+	item := item{
+		timestamp: time.Now(),
+		remaining: remaining,
+	}
+
+	if len(e.items) == 0 {
+		e.items = append(e.items, item)
+		return ""
+	}
+
+	if e.items[len(e.items)-1].remaining == remaining {
+		// we ignore updates with the same remaining value and just return the previous ETA
+		return e.lastETA
+	} else if e.items[len(e.items)-1].remaining < remaining {
+		// remaining went up from previous update, lets estimate how many items were processed using the
+		// average number processed items in the queue.
+		var avgProcessedPerItem int64 = 1
+		if len(e.items) > 1 {
+			diffRemaining := e.items[0].remaining - e.items[len(e.items)-1].remaining
+			avgProcessedPerItem = int64(math.Round(float64(diffRemaining) / float64(len(e.items))))
+		}
+
+		// diff is the difference in increase in remaining since last update plus the average number of processed
+		// items we estimate that were processed this round
+		diff := remaining - e.items[len(e.items)-1].remaining + avgProcessedPerItem
+
+		// we update all items in the queue by shifting their remaining value accordingly. This means that we
+		// always have strictly decreasing remaining values in the queue
+		for i := range e.items {
+			e.items[i].remaining += diff
+		}
+	}
+
+	// append the item to the queue and remove the oldest item if needed
+	if len(e.items) >= e.maxItems {
+		e.items = e.items[1:]
+	}
+	e.items = append(e.items, item)
+
+	// calculate the average processing time per item in the queue
+	diffMs := e.items[len(e.items)-1].timestamp.Sub(e.items[0].timestamp).Milliseconds()
+	nrItemsProcessed := e.items[0].remaining - e.items[len(e.items)-1].remaining
+	avg := diffMs / nrItemsProcessed
+
+	// use that average processing time to estimate how long the remaining items will take
+	// and cache that ETA so we don't have to recalculate it on every update unless the
+	// remaining value changes
+	e.lastETA = msToETA(avg * remaining)
+
+	return e.lastETA
+}
+
+func msToETA(ms int64) string {
+	seconds := ms / 1000
+	minutes := seconds / 60
+	hours := minutes / 60
+
+	return fmt.Sprintf("%02dh:%02dm:%02ds", hours, minutes%60, seconds%60)
+}
diff --git a/cli/wallet.go b/cli/wallet.go
index 628d6841d..faf7bc239 100644
--- a/cli/wallet.go
+++ b/cli/wallet.go
@@ -22,6 +22,7 @@ import (
 	"github.com/filecoin-project/go-state-types/network"
 
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/lib/tablewriter"
 )
@@ -459,7 +460,12 @@ var walletSign = &cli.Command{
 		sig, err := api.WalletSign(ctx, addr, msg)
 
 		if err != nil {
-			return err
+			// Check if the address is a multisig address
+			act, actErr := api.StateGetActor(ctx, addr, types.EmptyTSK)
+			if actErr == nil && builtin.IsMultisigActor(act.Code) {
+				return xerrors.Errorf("specified signer address is a multisig actor, it doesn’t have keys to sign transactions. To send a message with a multisig, signers of the multisig need to propose and approve transactions.")
+			}
+			return xerrors.Errorf("failed to sign message: %w", err)
 		}
 
 		sigBytes := append([]byte{byte(sig.Type)}, sig.Data...)
diff --git a/cmd/lotus-bench/cli.go b/cmd/lotus-bench/cli.go
new file mode 100644
index 000000000..0eaeb6ccb
--- /dev/null
+++ b/cmd/lotus-bench/cli.go
@@ -0,0 +1,312 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"os/signal"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/urfave/cli/v2"
+)
+
+var cliCmd = &cli.Command{
+	Name:  "cli",
+	Usage: "Runs a concurrent stress test on one or more binaries commands and prints the performance metrics including latency distribution and histogram",
+	Description: `This benchmark has the following features:
+* Can query each command both sequentially and concurrently
+* Supports rate limiting
+* Can query multiple different commands at once (supporting different concurrency level and rate limiting for each command)
+* Gives a nice reporting summary of the stress testing of each command (including latency distribution, histogram and more)
+* Easy to use
+
+To use this benchmark you must specify the commands you want to test using the --cmd options, the format of it is:
+
+  --cmd=CMD[:CONCURRENCY][:QPS] where only NAME is required.
+
+Here are some real examples:
+  lotus-bench cli --cmd='lotus-shed mpool miner-select-messages' // runs the command with default concurrency and qps
+  lotus-bench cli --cmd='lotus-shed mpool miner-select-messages:3'  // override concurrency to 3
+  lotus-bench cli --cmd='lotus-shed mpool miner-select-messages::100' // override to 100 qps while using default concurrency
+  lotus-bench cli --cmd='lotus-shed mpool miner-select-messages:3:100' // run using 3 workers but limit to 100 qps
+  lotus-bench cli --cmd='lotus-shed mpool miner-select-messages' --cmd='lotus sync wait' // run two commands at once
+`,
+	Flags: []cli.Flag{
+		&cli.DurationFlag{
+			Name:  "duration",
+			Value: 60 * time.Second,
+			Usage: "Duration of benchmark in seconds",
+		},
+		&cli.IntFlag{
+			Name:  "concurrency",
+			Value: 10,
+			Usage: "How many workers should be used per command (can be overridden per command)",
+		},
+		&cli.IntFlag{
+			Name:  "qps",
+			Value: 0,
+			Usage: "How many requests per second should be sent per command (can be overridden per command), a value of 0 means no limit",
+		},
+		&cli.StringSliceFlag{
+			Name:  "cmd",
+			Usage: `Command to benchmark, you can specify multiple commands by repeating this flag. You can also specify command specific options to set the concurrency and qps for each command (see usage).`,
+		},
+		&cli.DurationFlag{
+			Name:  "watch",
+			Value: 0 * time.Second,
+			Usage: "If >0 then generates reports every N seconds (only supports linux/unix)",
+		},
+		&cli.BoolFlag{
+			Name:  "print-response",
+			Value: false,
+			Usage: "print the response of each request",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if len(cctx.StringSlice("cmd")) == 0 {
+			return errors.New("you must specify and least one cmd to benchmark")
+		}
+
+		var cmds []*CMD
+		for _, str := range cctx.StringSlice("cmd") {
+			entries := strings.SplitN(str, ":", 3)
+			if len(entries) == 0 {
+				return errors.New("invalid cmd format")
+			}
+
+			// check if concurrency was specified
+			concurrency := cctx.Int("concurrency")
+			if len(entries) > 1 {
+				if len(entries[1]) > 0 {
+					var err error
+					concurrency, err = strconv.Atoi(entries[1])
+					if err != nil {
+						return fmt.Errorf("could not parse concurrency value from command %s: %v", entries[0], err)
+					}
+				}
+			}
+
+			// check if qps was specified
+			qps := cctx.Int("qps")
+			if len(entries) > 2 {
+				if len(entries[2]) > 0 {
+					var err error
+					qps, err = strconv.Atoi(entries[2])
+					if err != nil {
+						return fmt.Errorf("could not parse qps value from command %s: %v", entries[0], err)
+					}
+				}
+			}
+
+			cmds = append(cmds, &CMD{
+				w:           os.Stdout,
+				cmd:         entries[0],
+				concurrency: concurrency,
+				qps:         qps,
+				printResp:   cctx.Bool("print-response"),
+			})
+		}
+
+		// terminate early on ctrl+c
+		c := make(chan os.Signal, 1)
+		signal.Notify(c, os.Interrupt)
+		go func() {
+			<-c
+			fmt.Println("Received interrupt, stopping...")
+			for _, cmd := range cmds {
+				cmd.Stop()
+			}
+		}()
+
+		// stop all threads after duration
+		go func() {
+			time.Sleep(cctx.Duration("duration"))
+			for _, cmd := range cmds {
+				cmd.Stop()
+			}
+		}()
+
+		// start all threads
+		var wg sync.WaitGroup
+		wg.Add(len(cmds))
+
+		for _, cmd := range cmds {
+			go func(cmd *CMD) {
+				defer wg.Done()
+				err := cmd.Run()
+				if err != nil {
+					fmt.Printf("error running cmd: %v\n", err)
+				}
+			}(cmd)
+		}
+
+		// if watch is set then print a report every N seconds
+		var progressCh chan struct{}
+		if cctx.Duration("watch") > 0 {
+			progressCh = make(chan struct{}, 1)
+			go func(progressCh chan struct{}) {
+				ticker := time.NewTicker(cctx.Duration("watch"))
+				for {
+					clearAndPrintReport := func() {
+						// clear the screen move the cursor to the top left
+						fmt.Print("\033[2J")
+						fmt.Printf("\033[%d;%dH", 1, 1)
+						for i, cmd := range cmds {
+							cmd.Report()
+							if i < len(cmds)-1 {
+								fmt.Println()
+							}
+						}
+					}
+					select {
+					case <-ticker.C:
+						clearAndPrintReport()
+					case <-progressCh:
+						clearAndPrintReport()
+						return
+					}
+				}
+			}(progressCh)
+		}
+
+		wg.Wait()
+
+		if progressCh != nil {
+			// wait for the watch go routine to return
+			progressCh <- struct{}{}
+
+			// no need to print the report again
+			return nil
+		}
+
+		// print the report for each command
+		for i, cmd := range cmds {
+			cmd.Report()
+			if i < len(cmds)-1 {
+				fmt.Println()
+			}
+		}
+
+		return nil
+	},
+}
+
+// CMD handles the benchmarking of a single command.
+type CMD struct {
+	w io.Writer
+	// the cmd we want to benchmark
+	cmd string
+	// the number of concurrent requests to make to this command
+	concurrency int
+	// if >0 then limit to qps is the max number of requests per second to make to this command (0 = no limit)
+	qps int
+	// whether or not to print the response of each request (useful for debugging)
+	printResp bool
+	// instruct the worker go routines to stop
+	stopCh chan struct{}
+	// when the command bencharking started
+	start time.Time
+	// results channel is used by the workers to send results to the reporter
+	results chan *result
+	// reporter handles reading the results from workers and printing the report statistics
+	reporter *Reporter
+}
+
+func (c *CMD) Run() error {
+	var wg sync.WaitGroup
+	wg.Add(c.concurrency)
+
+	c.results = make(chan *result, c.concurrency*1_000)
+	c.stopCh = make(chan struct{}, c.concurrency)
+
+	go func() {
+		c.reporter = NewReporter(c.results, c.w)
+		c.reporter.Run()
+	}()
+
+	c.start = time.Now()
+
+	// throttle the number of requests per second
+	var qpsTicker *time.Ticker
+	if c.qps > 0 {
+		qpsTicker = time.NewTicker(time.Second / time.Duration(c.qps))
+	}
+
+	for i := 0; i < c.concurrency; i++ {
+		go func() {
+			c.startWorker(qpsTicker)
+			wg.Done()
+		}()
+	}
+	wg.Wait()
+
+	// close the results channel so reporter will stop
+	close(c.results)
+
+	// wait until the reporter is done
+	<-c.reporter.doneCh
+
+	return nil
+}
+
+func (c *CMD) startWorker(qpsTicker *time.Ticker) {
+	for {
+		// check if we should stop
+		select {
+		case <-c.stopCh:
+			return
+		default:
+		}
+
+		// wait for the next tick if we are rate limiting this command
+		if qpsTicker != nil {
+			<-qpsTicker.C
+		}
+
+		start := time.Now()
+
+		var statusCode int = 0
+
+		arr := strings.Fields(c.cmd)
+
+		data, err := exec.Command(arr[0], arr[1:]...).Output()
+		if err != nil {
+			fmt.Println("1")
+			if exitError, ok := err.(*exec.ExitError); ok {
+				statusCode = exitError.ExitCode()
+			} else {
+				statusCode = 1
+			}
+		} else {
+			if c.printResp {
+				fmt.Printf("[%s] %s", c.cmd, string(data))
+			}
+		}
+
+		c.results <- &result{
+			statusCode: &statusCode,
+			err:        err,
+			duration:   time.Since(start),
+		}
+	}
+}
+
+func (c *CMD) Stop() {
+	for i := 0; i < c.concurrency; i++ {
+		c.stopCh <- struct{}{}
+	}
+}
+
+func (c *CMD) Report() {
+	total := time.Since(c.start)
+	fmt.Fprintf(c.w, "[%s]:\n", c.cmd)
+	fmt.Fprintf(c.w, "- Options:\n")
+	fmt.Fprintf(c.w, "  - concurrency: %d\n", c.concurrency)
+	fmt.Fprintf(c.w, "  - qps: %d\n", c.qps)
+	c.reporter.Print(total, c.w)
+}
diff --git a/cmd/lotus-bench/import.go b/cmd/lotus-bench/import.go
index 9f43d9538..16adbad60 100644
--- a/cmd/lotus-bench/import.go
+++ b/cmd/lotus-bench/import.go
@@ -304,7 +304,7 @@ var importBenchCmd = &cli.Command{
 				return fmt.Errorf("no CAR file provided for import")
 			}
 
-			head, err = cs.Import(cctx.Context, carFile)
+			head, _, err = cs.Import(cctx.Context, carFile)
 			if err != nil {
 				return err
 			}
@@ -497,21 +497,6 @@ type Invocation struct {
 
 const GasPerNs = 10
 
-func countGasCosts(et *types.ExecutionTrace) int64 {
-	var cgas int64
-
-	for _, gc := range et.GasCharges {
-		cgas += gc.ComputeGas
-	}
-
-	for _, sub := range et.Subcalls {
-		c := countGasCosts(&sub) //nolint
-		cgas += c
-	}
-
-	return cgas
-}
-
 type stats struct {
 	timeTaken meanVar
 	gasRatio  meanVar
diff --git a/cmd/lotus-bench/main.go b/cmd/lotus-bench/main.go
index b70709ff2..7d3c0cde0 100644
--- a/cmd/lotus-bench/main.go
+++ b/cmd/lotus-bench/main.go
@@ -3,10 +3,10 @@ package main
 import (
 	"bytes"
 	"context"
+	"crypto/rand"
 	"encoding/json"
 	"fmt"
 	"math/big"
-	"math/rand"
 	"os"
 	"path/filepath"
 	"sync"
@@ -120,6 +120,7 @@ func main() {
 			sealBenchCmd,
 			simpleCmd,
 			importBenchCmd,
+			cliCmd,
 			rpcCmd,
 		},
 	}
@@ -546,7 +547,10 @@ var sealBenchCmd = &cli.Command{
 		}
 
 		var challenge [32]byte
-		rand.Read(challenge[:])
+		_, err = rand.Read(challenge[:])
+		if err != nil {
+			return err
+		}
 
 		beforePost := time.Now()
 
@@ -776,9 +780,7 @@ func runSeals(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, numSectors int, par
 		start := time.Now()
 		log.Infof("[%d] Writing piece into sector...", i)
 
-		r := rand.New(rand.NewSource(100 + int64(i)))
-
-		pi, err := sb.AddPiece(context.TODO(), sid, nil, abi.PaddedPieceSize(sectorSize).Unpadded(), r)
+		pi, err := sb.AddPiece(context.TODO(), sid, nil, abi.PaddedPieceSize(sectorSize).Unpadded(), rand.Reader)
 		if err != nil {
 			return nil, nil, err
 		}
diff --git a/cmd/lotus-bench/reporter.go b/cmd/lotus-bench/reporter.go
new file mode 100644
index 000000000..ad2ad6b9d
--- /dev/null
+++ b/cmd/lotus-bench/reporter.go
@@ -0,0 +1,181 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+	"sync"
+	"text/tabwriter"
+	"time"
+)
+
+// result is the result of a single rpc method request.
+type result struct {
+	err        error
+	statusCode *int
+	duration   time.Duration
+}
+
+// Reporter reads the results from the workers through the results channel and aggregates the results.
+type Reporter struct {
+	// write the report to this writer
+	w io.Writer
+	// the reporter read the results from this channel
+	results chan *result
+	// doneCh is used to signal that the reporter has finished reading the results (channel has closed)
+	doneCh chan bool
+
+	// lock protect the following fields during critical sections (if --watch was specified)
+	lock sync.Mutex
+	// the latencies of all requests
+	latencies []int64
+	// the number of requests that returned each status code
+	statusCodes map[int]int
+	// the number of errors that occurred
+	errors map[string]int
+}
+
+func NewReporter(results chan *result, w io.Writer) *Reporter {
+	return &Reporter{
+		w:           w,
+		results:     results,
+		doneCh:      make(chan bool, 1),
+		statusCodes: make(map[int]int),
+		errors:      make(map[string]int),
+	}
+}
+
+func (r *Reporter) Run() {
+	for res := range r.results {
+		r.lock.Lock()
+
+		r.latencies = append(r.latencies, res.duration.Milliseconds())
+
+		if res.statusCode != nil {
+			r.statusCodes[*res.statusCode]++
+		}
+
+		if res.err != nil {
+			if len(r.errors) < 1_000_000 {
+				r.errors[res.err.Error()]++
+			} else {
+				// we don't want to store too many errors in memory
+				r.errors["hidden"]++
+			}
+		} else {
+			r.errors["nil"]++
+		}
+
+		r.lock.Unlock()
+	}
+
+	r.doneCh <- true
+}
+
+func (r *Reporter) Print(elapsed time.Duration, w io.Writer) {
+	r.lock.Lock()
+	defer r.lock.Unlock()
+
+	nrReq := int64(len(r.latencies))
+	if nrReq == 0 {
+		fmt.Println("No requests were made")
+		return
+	}
+
+	// we need to sort the latencies slice to calculate the percentiles
+	sort.Slice(r.latencies, func(i, j int) bool {
+		return r.latencies[i] < r.latencies[j]
+	})
+
+	var totalLatency int64 = 0
+	for _, latency := range r.latencies {
+		totalLatency += latency
+	}
+
+	fmt.Fprintf(w, "- Total Requests: %d\n", nrReq)
+	fmt.Fprintf(w, "- Total Duration: %dms\n", elapsed.Milliseconds())
+	fmt.Fprintf(w, "- Requests/sec: %f\n", float64(nrReq)/elapsed.Seconds())
+	fmt.Fprintf(w, "- Avg latency: %dms\n", totalLatency/nrReq)
+	fmt.Fprintf(w, "- Median latency: %dms\n", r.latencies[nrReq/2])
+	fmt.Fprintf(w, "- Latency distribution:\n")
+	percentiles := []float64{0.1, 0.5, 0.9, 0.95, 0.99, 0.999}
+	for _, p := range percentiles {
+		idx := int64(p * float64(nrReq))
+		fmt.Fprintf(w, "    %s%% in %dms\n", fmt.Sprintf("%.2f", p*100.0), r.latencies[idx])
+	}
+
+	// create a simple histogram with 10 buckets spanning the range of latency
+	// into equal ranges
+	//
+	nrBucket := 10
+	buckets := make([]Bucket, nrBucket)
+	latencyRange := r.latencies[len(r.latencies)-1]
+	bucketRange := latencyRange / int64(nrBucket)
+
+	// mark the end of each bucket
+	for i := 0; i < nrBucket; i++ {
+		buckets[i].start = int64(i) * bucketRange
+		buckets[i].end = buckets[i].start + bucketRange
+		// extend the last bucked by any remaning range caused by the integer division
+		if i == nrBucket-1 {
+			buckets[i].end = latencyRange
+		}
+	}
+
+	// count the number of requests in each bucket
+	currBucket := 0
+	for i := 0; i < len(r.latencies); {
+		if r.latencies[i] <= buckets[currBucket].end {
+			buckets[currBucket].cnt++
+			i++
+		} else {
+			currBucket++
+		}
+	}
+
+	// print the histogram using a tabwriter which will align the columns nicely
+	fmt.Fprintf(w, "- Histogram:\n")
+	const padding = 2
+	tabWriter := tabwriter.NewWriter(w, 0, 0, padding, ' ', tabwriter.AlignRight|tabwriter.Debug)
+	for i := 0; i < nrBucket; i++ {
+		ratio := float64(buckets[i].cnt) / float64(nrReq)
+		bars := strings.Repeat("#", int(ratio*100))
+		fmt.Fprintf(tabWriter, "  %d-%dms\t%d\t%s (%s%%)\n", buckets[i].start, buckets[i].end, buckets[i].cnt, bars, fmt.Sprintf("%.2f", ratio*100))
+	}
+	tabWriter.Flush() //nolint:errcheck
+
+	fmt.Fprintf(w, "- Status codes:\n")
+	for code, cnt := range r.statusCodes {
+		fmt.Fprintf(w, "    [%d]: %d\n", code, cnt)
+	}
+
+	// print the 10 most occurring errors (in case error values are not unique)
+	//
+	type kv struct {
+		err string
+		cnt int
+	}
+	var sortedErrors []kv
+	for err, cnt := range r.errors {
+		sortedErrors = append(sortedErrors, kv{err, cnt})
+	}
+	sort.Slice(sortedErrors, func(i, j int) bool {
+		return sortedErrors[i].cnt > sortedErrors[j].cnt
+	})
+	fmt.Fprintf(w, "- Errors (top 10):\n")
+	for i, se := range sortedErrors {
+		if i > 10 {
+			break
+		}
+		fmt.Fprintf(w, "    [%s]: %d\n", se.err, se.cnt)
+	}
+}
+
+type Bucket struct {
+	start int64
+	// the end value of the bucket
+	end int64
+	// how many entries are in the bucket
+	cnt int
+}
diff --git a/cmd/lotus-bench/rpc.go b/cmd/lotus-bench/rpc.go
index 5da784c6e..4af4bdb27 100644
--- a/cmd/lotus-bench/rpc.go
+++ b/cmd/lotus-bench/rpc.go
@@ -9,11 +9,9 @@ import (
 	"net/http"
 	"os"
 	"os/signal"
-	"sort"
 	"strconv"
 	"strings"
 	"sync"
-	"text/tabwriter"
 	"time"
 
 	"github.com/urfave/cli/v2"
@@ -243,13 +241,6 @@ type RPCMethod struct {
 	reporter *Reporter
 }
 
-// result is the result of a single rpc method request.
-type result struct {
-	err        error
-	statusCode *int
-	duration   time.Duration
-}
-
 func (rpc *RPCMethod) Run() error {
 	client := &http.Client{
 		Timeout: 0,
@@ -411,166 +402,3 @@ func (rpc *RPCMethod) Report() {
 	fmt.Fprintf(rpc.w, "  - qps: %d\n", rpc.qps)
 	rpc.reporter.Print(total, rpc.w)
 }
-
-// Reporter reads the results from the workers through the results channel and aggregates the results.
-type Reporter struct {
-	// write the report to this writer
-	w io.Writer
-	// the reporter read the results from this channel
-	results chan *result
-	// doneCh is used to signal that the reporter has finished reading the results (channel has closed)
-	doneCh chan bool
-
-	// lock protect the following fields during critical sections (if --watch was specified)
-	lock sync.Mutex
-	// the latencies of all requests
-	latencies []int64
-	// the number of requests that returned each status code
-	statusCodes map[int]int
-	// the number of errors that occurred
-	errors map[string]int
-}
-
-func NewReporter(results chan *result, w io.Writer) *Reporter {
-	return &Reporter{
-		w:           w,
-		results:     results,
-		doneCh:      make(chan bool, 1),
-		statusCodes: make(map[int]int),
-		errors:      make(map[string]int),
-	}
-}
-
-func (r *Reporter) Run() {
-	for res := range r.results {
-		r.lock.Lock()
-
-		r.latencies = append(r.latencies, res.duration.Milliseconds())
-
-		if res.statusCode != nil {
-			r.statusCodes[*res.statusCode]++
-		}
-
-		if res.err != nil {
-			if len(r.errors) < 1_000_000 {
-				r.errors[res.err.Error()]++
-			} else {
-				// we don't want to store too many errors in memory
-				r.errors["hidden"]++
-			}
-		} else {
-			r.errors["nil"]++
-		}
-
-		r.lock.Unlock()
-	}
-
-	r.doneCh <- true
-}
-
-func (r *Reporter) Print(elapsed time.Duration, w io.Writer) {
-	r.lock.Lock()
-	defer r.lock.Unlock()
-
-	nrReq := int64(len(r.latencies))
-	if nrReq == 0 {
-		fmt.Println("No requests were made")
-		return
-	}
-
-	// we need to sort the latencies slice to calculate the percentiles
-	sort.Slice(r.latencies, func(i, j int) bool {
-		return r.latencies[i] < r.latencies[j]
-	})
-
-	var totalLatency int64 = 0
-	for _, latency := range r.latencies {
-		totalLatency += latency
-	}
-
-	fmt.Fprintf(w, "- Total Requests: %d\n", nrReq)
-	fmt.Fprintf(w, "- Total Duration: %dms\n", elapsed.Milliseconds())
-	fmt.Fprintf(w, "- Requests/sec: %f\n", float64(nrReq)/elapsed.Seconds())
-	fmt.Fprintf(w, "- Avg latency: %dms\n", totalLatency/nrReq)
-	fmt.Fprintf(w, "- Median latency: %dms\n", r.latencies[nrReq/2])
-	fmt.Fprintf(w, "- Latency distribution:\n")
-	percentiles := []float64{0.1, 0.5, 0.9, 0.95, 0.99, 0.999}
-	for _, p := range percentiles {
-		idx := int64(p * float64(nrReq))
-		fmt.Fprintf(w, "    %s%% in %dms\n", fmt.Sprintf("%.2f", p*100.0), r.latencies[idx])
-	}
-
-	// create a simple histogram with 10 buckets spanning the range of latency
-	// into equal ranges
-	//
-	nrBucket := 10
-	buckets := make([]Bucket, nrBucket)
-	latencyRange := r.latencies[len(r.latencies)-1]
-	bucketRange := latencyRange / int64(nrBucket)
-
-	// mark the end of each bucket
-	for i := 0; i < nrBucket; i++ {
-		buckets[i].start = int64(i) * bucketRange
-		buckets[i].end = buckets[i].start + bucketRange
-		// extend the last bucked by any remaning range caused by the integer division
-		if i == nrBucket-1 {
-			buckets[i].end = latencyRange
-		}
-	}
-
-	// count the number of requests in each bucket
-	currBucket := 0
-	for i := 0; i < len(r.latencies); {
-		if r.latencies[i] <= buckets[currBucket].end {
-			buckets[currBucket].cnt++
-			i++
-		} else {
-			currBucket++
-		}
-	}
-
-	// print the histogram using a tabwriter which will align the columns nicely
-	fmt.Fprintf(w, "- Histogram:\n")
-	const padding = 2
-	tabWriter := tabwriter.NewWriter(w, 0, 0, padding, ' ', tabwriter.AlignRight|tabwriter.Debug)
-	for i := 0; i < nrBucket; i++ {
-		ratio := float64(buckets[i].cnt) / float64(nrReq)
-		bars := strings.Repeat("#", int(ratio*100))
-		fmt.Fprintf(tabWriter, "  %d-%dms\t%d\t%s (%s%%)\n", buckets[i].start, buckets[i].end, buckets[i].cnt, bars, fmt.Sprintf("%.2f", ratio*100))
-	}
-	tabWriter.Flush() //nolint:errcheck
-
-	fmt.Fprintf(w, "- Status codes:\n")
-	for code, cnt := range r.statusCodes {
-		fmt.Fprintf(w, "    [%d]: %d\n", code, cnt)
-	}
-
-	// print the 10 most occurring errors (in case error values are not unique)
-	//
-	type kv struct {
-		err string
-		cnt int
-	}
-	var sortedErrors []kv
-	for err, cnt := range r.errors {
-		sortedErrors = append(sortedErrors, kv{err, cnt})
-	}
-	sort.Slice(sortedErrors, func(i, j int) bool {
-		return sortedErrors[i].cnt > sortedErrors[j].cnt
-	})
-	fmt.Fprintf(w, "- Errors (top 10):\n")
-	for i, se := range sortedErrors {
-		if i > 10 {
-			break
-		}
-		fmt.Fprintf(w, "    [%s]: %d\n", se.err, se.cnt)
-	}
-}
-
-type Bucket struct {
-	start int64
-	// the end value of the bucket
-	end int64
-	// how many entries are in the bucket
-	cnt int
-}
diff --git a/cmd/lotus-bench/simple.go b/cmd/lotus-bench/simple.go
index 8ae5713ad..35d909ffb 100644
--- a/cmd/lotus-bench/simple.go
+++ b/cmd/lotus-bench/simple.go
@@ -266,7 +266,10 @@ var simplePreCommit1 = &cli.Command{
 			ProofType: spt(sectorSize, cctx.Bool("synthetic")),
 		}
 
-		var ticket [32]byte // all zero
+		ticket := [32]byte{}
+		for i := range ticket {
+			ticket[i] = 1
+		}
 
 		pieces, err := ParsePieceInfos(cctx, 3)
 		if err != nil {
@@ -305,7 +308,36 @@ var simplePreCommit2 = &cli.Command{
 			Name:  "synthetic",
 			Usage: "generate synthetic PoRep proofs",
 		},
+		&cli.StringFlag{
+			Name:  "external-pc2",
+			Usage: "command for computing PC2 externally",
+		},
 	},
+	Description: `Compute PreCommit2 inputs and seal a sector.
+
+--external-pc2 can be used to compute the PreCommit2 inputs externally.
+The flag behaves similarly to the related lotus-worker flag, using it in
+lotus-bench may be useful for testing if the external PreCommit2 command is
+invoked correctly.
+
+The command will be called with a number of environment variables set:
+* EXTSEAL_PC2_SECTOR_NUM: the sector number
+* EXTSEAL_PC2_SECTOR_MINER: the miner id
+* EXTSEAL_PC2_PROOF_TYPE: the proof type
+* EXTSEAL_PC2_SECTOR_SIZE: the sector size in bytes
+* EXTSEAL_PC2_CACHE: the path to the cache directory
+* EXTSEAL_PC2_SEALED: the path to the sealed sector file (initialized with unsealed data by the caller)
+* EXTSEAL_PC2_PC1OUT: output from rust-fil-proofs precommit1 phase (base64 encoded json)
+
+The command is expected to:
+* Create cache sc-02-data-tree-r* files
+* Create cache sc-02-data-tree-c* files
+* Create cache p_aux / t_aux files
+* Transform the sealed file in place
+
+Example invocation of lotus-bench as external executor:
+'./lotus-bench simple precommit2 --sector-size $EXTSEAL_PC2_SECTOR_SIZE $EXTSEAL_PC2_SEALED $EXTSEAL_PC2_CACHE $EXTSEAL_PC2_PC1OUT'
+`,
 	ArgsUsage: "[sealed] [cache] [pc1 out]",
 	Action: func(cctx *cli.Context) error {
 		ctx := cctx.Context
@@ -330,7 +362,18 @@ var simplePreCommit2 = &cli.Command{
 			storiface.FTSealed: cctx.Args().Get(0),
 			storiface.FTCache:  cctx.Args().Get(1),
 		}
-		sealer, err := ffiwrapper.New(pp)
+
+		var opts []ffiwrapper.FFIWrapperOpt
+
+		if cctx.IsSet("external-pc2") {
+			extSeal := ffiwrapper.ExternalSealer{
+				PreCommit2: ffiwrapper.MakeExternPrecommit2(cctx.String("external-pc2")),
+			}
+
+			opts = append(opts, ffiwrapper.WithExternalSealCalls(extSeal))
+		}
+
+		sealer, err := ffiwrapper.New(pp, opts...)
 		if err != nil {
 			return err
 		}
@@ -420,7 +463,12 @@ var simpleCommit1 = &cli.Command{
 
 		start := time.Now()
 
-		var ticket, seed [32]byte // all zero
+		ticket := [32]byte{}
+		seed := [32]byte{}
+		for i := range ticket {
+			ticket[i] = 1
+			seed[i] = 1
+		}
 
 		commd, err := cid.Parse(cctx.Args().Get(2))
 		if err != nil {
@@ -650,6 +698,10 @@ var simpleWinningPost = &cli.Command{
 			Usage: "pass miner address (only necessary if using existing sectorbuilder)",
 			Value: "t01000",
 		},
+		&cli.BoolFlag{
+			Name:  "show-inputs",
+			Usage: "output inputs for winning post generation",
+		},
 	},
 	ArgsUsage: "[sealed] [cache] [comm R] [sector num]",
 	Action: func(cctx *cli.Context) error {
@@ -720,6 +772,17 @@ var simpleWinningPost = &cli.Command{
 		fmt.Printf("Vanilla %s (%s)\n", challenge.Sub(start), bps(sectorSize, 1, challenge.Sub(start)))
 		fmt.Printf("Proof %s (%s)\n", end.Sub(challenge), bps(sectorSize, 1, end.Sub(challenge)))
 		fmt.Println(base64.StdEncoding.EncodeToString(proof[0].ProofBytes))
+
+		if cctx.Bool("show-inputs") {
+			fmt.Println("GenerateWinningPoStWithVanilla info:")
+
+			fmt.Printf(" wpt: %d\n", wpt)
+			fmt.Printf(" mid: %d\n", mid)
+			fmt.Printf(" rand: %x\n", rand)
+			fmt.Printf(" vp: %x\n", vp)
+			fmt.Printf(" proof: %x\n", proof)
+		}
+
 		return nil
 	},
 }
diff --git a/cmd/lotus-gateway/main.go b/cmd/lotus-gateway/main.go
index 2023551ef..35a43e18b 100644
--- a/cmd/lotus-gateway/main.go
+++ b/cmd/lotus-gateway/main.go
@@ -143,7 +143,7 @@ var runCmd = &cli.Command{
 		},
 		&cli.DurationFlag{
 			Name:  "rate-limit-timeout",
-			Usage: "the maximum time to wait for the rate limter before returning an error to clients",
+			Usage: "the maximum time to wait for the rate limiter before returning an error to clients",
 			Value: gateway.DefaultRateLimitTimeout,
 		},
 		&cli.Int64Flag{
diff --git a/cmd/lotus-miner/init.go b/cmd/lotus-miner/init.go
index c109e85b9..1b76960e9 100644
--- a/cmd/lotus-miner/init.go
+++ b/cmd/lotus-miner/init.go
@@ -463,7 +463,7 @@ func storageMinerInit(ctx context.Context, cctx *cli.Context, api v1api.FullNode
 			wsts := statestore.New(namespace.Wrap(mds, modules.WorkerCallsPrefix))
 			smsts := statestore.New(namespace.Wrap(mds, modules.ManagerWorkPrefix))
 
-			si := paths.NewIndex(nil)
+			si := paths.NewMemIndex(nil)
 
 			lstor, err := paths.NewLocal(ctx, lr, si, nil)
 			if err != nil {
diff --git a/cmd/lotus-miner/proving.go b/cmd/lotus-miner/proving.go
index 3ecc58ba7..2fc1427b5 100644
--- a/cmd/lotus-miner/proving.go
+++ b/cmd/lotus-miner/proving.go
@@ -559,7 +559,8 @@ var provingCheckProvableCmd = &cli.Command{
 		for parIdx, par := range partitions {
 			sectors := make(map[abi.SectorNumber]struct{})
 
-			sectorInfos, err := api.StateMinerSectors(ctx, addr, &par.LiveSectors, types.EmptyTSK)
+			tmp := par.LiveSectors
+			sectorInfos, err := api.StateMinerSectors(ctx, addr, &tmp, types.EmptyTSK)
 			if err != nil {
 				return err
 			}
diff --git a/cmd/lotus-miner/sectors.go b/cmd/lotus-miner/sectors.go
index 6fd0fd709..07cc2e795 100644
--- a/cmd/lotus-miner/sectors.go
+++ b/cmd/lotus-miner/sectors.go
@@ -2566,6 +2566,8 @@ var sectorsUnsealCmd = &cli.Command{
 			return xerrors.Errorf("could not parse sector number: %w", err)
 		}
 
+		fmt.Printf("Unsealing sector %d\n", sectorNum)
+
 		return minerAPI.SectorUnseal(ctx, abi.SectorNumber(sectorNum))
 	},
 }
diff --git a/cmd/lotus-provider/config.go b/cmd/lotus-provider/config.go
new file mode 100644
index 000000000..5bd681429
--- /dev/null
+++ b/cmd/lotus-provider/config.go
@@ -0,0 +1,259 @@
+package main
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"strings"
+
+	"github.com/BurntSushi/toml"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/node/config"
+)
+
+var configCmd = &cli.Command{
+	Name:  "config",
+	Usage: "Manage node config by layers. The layer 'base' will always be applied. ",
+	Subcommands: []*cli.Command{
+		configDefaultCmd,
+		configSetCmd,
+		configGetCmd,
+		configListCmd,
+		configViewCmd,
+		configRmCmd,
+		configMigrateCmd,
+	},
+}
+
+var configDefaultCmd = &cli.Command{
+	Name:    "default",
+	Aliases: []string{"defaults"},
+	Usage:   "Print default node config",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "no-comment",
+			Usage: "don't comment default values",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		comment := !cctx.Bool("no-comment")
+		cfg, err := getDefaultConfig(comment)
+		if err != nil {
+			return err
+		}
+		fmt.Print(cfg)
+
+		return nil
+	},
+}
+
+func getDefaultConfig(comment bool) (string, error) {
+	c := config.DefaultLotusProvider()
+	cb, err := config.ConfigUpdate(c, nil, config.Commented(comment), config.DefaultKeepUncommented(), config.NoEnv())
+	if err != nil {
+		return "", err
+	}
+	return string(cb), nil
+}
+
+var configSetCmd = &cli.Command{
+	Name:      "set",
+	Aliases:   []string{"add", "update", "create"},
+	Usage:     "Set a config layer or the base by providing a filename or stdin.",
+	ArgsUsage: "a layer's file name",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "title",
+			Usage: "title of the config layer (req'd for stdin)",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		args := cctx.Args()
+
+		db, err := makeDB(cctx)
+		if err != nil {
+			return err
+		}
+
+		name := cctx.String("title")
+		var stream io.Reader = os.Stdin
+		if args.Len() != 1 {
+			if cctx.String("title") == "" {
+				return errors.New("must have a title for stdin, or a file name")
+			}
+		} else {
+			stream, err = os.Open(args.First())
+			if err != nil {
+				return fmt.Errorf("cannot open file %s: %w", args.First(), err)
+			}
+			if name == "" {
+				name = strings.Split(path.Base(args.First()), ".")[0]
+			}
+		}
+		bytes, err := io.ReadAll(stream)
+		if err != nil {
+			return fmt.Errorf("cannot read stream/file %w", err)
+		}
+
+		lp := config.DefaultLotusProvider() // ensure it's toml
+		_, err = toml.Decode(string(bytes), lp)
+		if err != nil {
+			return fmt.Errorf("cannot decode file: %w", err)
+		}
+		_ = lp
+
+		_, err = db.Exec(context.Background(),
+			`INSERT INTO harmony_config (title, config) VALUES ($1, $2) 
+			ON CONFLICT (title) DO UPDATE SET config = excluded.config`, name, string(bytes))
+		if err != nil {
+			return fmt.Errorf("unable to save config layer: %w", err)
+		}
+
+		fmt.Println("Layer " + name + " created/updated")
+		return nil
+	},
+}
+
+var configGetCmd = &cli.Command{
+	Name:      "get",
+	Aliases:   []string{"cat", "show"},
+	Usage:     "Get a config layer by name. You may want to pipe the output to a file, or use 'less'",
+	ArgsUsage: "layer name",
+	Action: func(cctx *cli.Context) error {
+		args := cctx.Args()
+		if args.Len() != 1 {
+			return fmt.Errorf("want 1 layer arg, got %d", args.Len())
+		}
+		db, err := makeDB(cctx)
+		if err != nil {
+			return err
+		}
+
+		var cfg string
+		err = db.QueryRow(context.Background(), `SELECT config FROM harmony_config WHERE title=$1`, args.First()).Scan(&cfg)
+		if err != nil {
+			return err
+		}
+		fmt.Println(cfg)
+
+		return nil
+	},
+}
+
+var configListCmd = &cli.Command{
+	Name:    "list",
+	Aliases: []string{"ls"},
+	Usage:   "List config layers you can get.",
+	Flags:   []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		db, err := makeDB(cctx)
+		if err != nil {
+			return err
+		}
+		var res []string
+		err = db.Select(context.Background(), &res, `SELECT title FROM harmony_config ORDER BY title`)
+		if err != nil {
+			return fmt.Errorf("unable to read from db: %w", err)
+		}
+		for _, r := range res {
+			fmt.Println(r)
+		}
+
+		return nil
+	},
+}
+
+var configRmCmd = &cli.Command{
+	Name:    "remove",
+	Aliases: []string{"rm", "del", "delete"},
+	Usage:   "Remove a named config layer.",
+	Flags:   []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		args := cctx.Args()
+		if args.Len() != 1 {
+			return errors.New("must have exactly 1 arg for the layer name")
+		}
+		db, err := makeDB(cctx)
+		if err != nil {
+			return err
+		}
+		ct, err := db.Exec(context.Background(), `DELETE FROM harmony_config WHERE title=$1`, args.First())
+		if err != nil {
+			return fmt.Errorf("unable to read from db: %w", err)
+		}
+		if ct == 0 {
+			return fmt.Errorf("no layer named %s", args.First())
+		}
+
+		return nil
+	},
+}
+var configViewCmd = &cli.Command{
+	Name:      "interpret",
+	Aliases:   []string{"view", "stacked", "stack"},
+	Usage:     "Interpret stacked config layers by this version of lotus-provider, with system-generated comments.",
+	ArgsUsage: "a list of layers to be interpreted as the final config",
+	Flags: []cli.Flag{
+		&cli.StringSliceFlag{
+			Name:     "layers",
+			Usage:    "comma or space separated list of layers to be interpreted",
+			Value:    cli.NewStringSlice("base"),
+			Required: true,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		db, err := makeDB(cctx)
+		if err != nil {
+			return err
+		}
+		lp, err := getConfig(cctx, db)
+		if err != nil {
+			return err
+		}
+		cb, err := config.ConfigUpdate(lp, config.DefaultLotusProvider(), config.Commented(true), config.DefaultKeepUncommented(), config.NoEnv())
+		if err != nil {
+			return xerrors.Errorf("cannot interpret config: %w", err)
+		}
+		fmt.Println(string(cb))
+		return nil
+	},
+}
+
+func getConfig(cctx *cli.Context, db *harmonydb.DB) (*config.LotusProviderConfig, error) {
+	lp := config.DefaultLotusProvider()
+	have := []string{}
+	layers := cctx.StringSlice("layers")
+	for _, layer := range layers {
+		text := ""
+		err := db.QueryRow(cctx.Context, `SELECT config FROM harmony_config WHERE title=$1`, layer).Scan(&text)
+		if err != nil {
+			if strings.Contains(err.Error(), sql.ErrNoRows.Error()) {
+				return nil, fmt.Errorf("missing layer '%s' ", layer)
+			}
+			if layer == "base" {
+				return nil, errors.New(`lotus-provider defaults to a layer named 'base'. 
+				Either use 'migrate' command or edit a base.toml and upload it with: lotus-provider config set base.toml`)
+			}
+			return nil, fmt.Errorf("could not read layer '%s': %w", layer, err)
+		}
+		meta, err := toml.Decode(text, &lp)
+		if err != nil {
+			return nil, fmt.Errorf("could not read layer, bad toml %s: %w", layer, err)
+		}
+		for _, k := range meta.Keys() {
+			have = append(have, strings.Join(k, " "))
+		}
+	}
+	_ = have // FUTURE: verify that required fields are here.
+	// If config includes 3rd-party config, consider JSONSchema as a way that
+	// 3rd-parties can dynamically include config requirements and we can
+	// validate the config. Because of layering, we must validate @ startup.
+	return lp, nil
+}
diff --git a/cmd/lotus-provider/main.go b/cmd/lotus-provider/main.go
new file mode 100644
index 000000000..19cc6f5f9
--- /dev/null
+++ b/cmd/lotus-provider/main.go
@@ -0,0 +1,160 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"runtime/debug"
+	"syscall"
+
+	"github.com/fatih/color"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/urfave/cli/v2"
+
+	"github.com/filecoin-project/lotus/build"
+	lcli "github.com/filecoin-project/lotus/cli"
+	cliutil "github.com/filecoin-project/lotus/cli/util"
+	"github.com/filecoin-project/lotus/lib/lotuslog"
+	"github.com/filecoin-project/lotus/lib/tracing"
+	"github.com/filecoin-project/lotus/node/repo"
+)
+
+var log = logging.Logger("main")
+
+func SetupCloseHandler() {
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-c
+		fmt.Println("\r- Ctrl+C pressed in Terminal")
+		debug.PrintStack()
+		os.Exit(1)
+	}()
+}
+
+func main() {
+	SetupCloseHandler()
+
+	lotuslog.SetupLogLevels()
+
+	local := []*cli.Command{
+		//initCmd,
+		runCmd,
+		stopCmd,
+		configCmd,
+		testCmd,
+		//backupCmd,
+		//lcli.WithCategory("chain", actorCmd),
+		//lcli.WithCategory("storage", sectorsCmd),
+		//lcli.WithCategory("storage", provingCmd),
+		//lcli.WithCategory("storage", storageCmd),
+		//lcli.WithCategory("storage", sealingCmd),
+	}
+
+	jaeger := tracing.SetupJaegerTracing("lotus")
+	defer func() {
+		if jaeger != nil {
+			_ = jaeger.ForceFlush(context.Background())
+		}
+	}()
+
+	for _, cmd := range local {
+		cmd := cmd
+		originBefore := cmd.Before
+		cmd.Before = func(cctx *cli.Context) error {
+			if jaeger != nil {
+				_ = jaeger.Shutdown(cctx.Context)
+			}
+			jaeger = tracing.SetupJaegerTracing("lotus/" + cmd.Name)
+
+			if cctx.IsSet("color") {
+				color.NoColor = !cctx.Bool("color")
+			}
+
+			if originBefore != nil {
+				return originBefore(cctx)
+			}
+
+			return nil
+		}
+	}
+
+	app := &cli.App{
+		Name:                 "lotus-provider",
+		Usage:                "Filecoin decentralized storage network provider",
+		Version:              build.UserVersion(),
+		EnableBashCompletion: true,
+		Flags: []cli.Flag{
+			&cli.BoolFlag{
+				// examined in the Before above
+				Name:        "color",
+				Usage:       "use color in display output",
+				DefaultText: "depends on output being a TTY",
+			},
+			&cli.StringFlag{
+				Name:    "panic-reports",
+				EnvVars: []string{"LOTUS_PANIC_REPORT_PATH"},
+				Hidden:  true,
+				Value:   "~/.lotusprovider", // should follow --repo default
+			},
+			&cli.StringFlag{
+				Name:    "db-host",
+				EnvVars: []string{"LOTUS_DB_HOST"},
+				Usage:   "Command separated list of hostnames for yugabyte cluster",
+				Value:   "yugabyte",
+			},
+			&cli.StringFlag{
+				Name:    "db-name",
+				EnvVars: []string{"LOTUS_DB_NAME", "LOTUS_HARMONYDB_HOSTS"},
+				Value:   "yugabyte",
+			},
+			&cli.StringFlag{
+				Name:    "db-user",
+				EnvVars: []string{"LOTUS_DB_USER", "LOTUS_HARMONYDB_USERNAME"},
+				Value:   "yugabyte",
+			},
+			&cli.StringFlag{
+				Name:    "db-password",
+				EnvVars: []string{"LOTUS_DB_PASSWORD", "LOTUS_HARMONYDB_PASSWORD"},
+				Value:   "yugabyte",
+			},
+			&cli.StringFlag{
+				Name:    "db-port",
+				EnvVars: []string{"LOTUS_DB_PORT", "LOTUS_HARMONYDB_PORT"},
+				Hidden:  true,
+				Value:   "5433",
+			},
+			&cli.StringFlag{
+				Name:    "layers",
+				EnvVars: []string{"LOTUS_LAYERS", "LOTUS_CONFIG_LAYERS"},
+				Value:   "base",
+			},
+			&cli.StringFlag{
+				Name:    FlagRepoPath,
+				EnvVars: []string{"LOTUS_REPO_PATH"},
+				Value:   "~/.lotusprovider",
+			},
+			cliutil.FlagVeryVerbose,
+		},
+		Commands: append(local, lcli.CommonCommands...),
+		Before: func(c *cli.Context) error {
+			return nil
+		},
+		After: func(c *cli.Context) error {
+			if r := recover(); r != nil {
+				// Generate report in LOTUS_PATH and re-raise panic
+				build.GeneratePanicReport(c.String("panic-reports"), c.String(FlagRepoPath), c.App.Name)
+				panic(r)
+			}
+			return nil
+		},
+	}
+	app.Setup()
+	app.Metadata["repoType"] = repo.Provider
+	lcli.RunApp(app)
+}
+
+const (
+	FlagRepoPath = "repo-path"
+)
diff --git a/cmd/lotus-provider/migrate.go b/cmd/lotus-provider/migrate.go
new file mode 100644
index 000000000..3869c7dfb
--- /dev/null
+++ b/cmd/lotus-provider/migrate.go
@@ -0,0 +1,247 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"strings"
+
+	"github.com/BurntSushi/toml"
+	"github.com/fatih/color"
+	"github.com/ipfs/go-datastore"
+	"github.com/samber/lo"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+
+	cliutil "github.com/filecoin-project/lotus/cli/util"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/node/config"
+	"github.com/filecoin-project/lotus/node/modules"
+	"github.com/filecoin-project/lotus/node/repo"
+)
+
+var configMigrateCmd = &cli.Command{
+	Name:        "from-miner",
+	Usage:       "Express a database config (for lotus-provider) from an existing miner.",
+	Description: "Express a database config (for lotus-provider) from an existing miner.",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:    FlagMinerRepo,
+			Aliases: []string{FlagMinerRepoDeprecation},
+			EnvVars: []string{"LOTUS_MINER_PATH", "LOTUS_STORAGE_PATH"},
+			Value:   "~/.lotusminer",
+			Usage:   fmt.Sprintf("Specify miner repo path. flag(%s) and env(LOTUS_STORAGE_PATH) are DEPRECATION, will REMOVE SOON", FlagMinerRepoDeprecation),
+		},
+		&cli.StringFlag{
+			Name:    "repo",
+			EnvVars: []string{"LOTUS_PATH"},
+			Hidden:  true,
+			Value:   "~/.lotus",
+		},
+		&cli.StringFlag{
+			Name:    "to-layer",
+			Aliases: []string{"t"},
+			Usage:   "The layer name for this data push. 'base' is recommended for single-miner setup.",
+		},
+		&cli.BoolFlag{
+			Name:    "overwrite",
+			Aliases: []string{"o"},
+			Usage:   "Use this with --to-layer to replace an existing layer",
+		},
+	},
+	Action: fromMiner,
+}
+
+const (
+	FlagMinerRepo = "miner-repo"
+)
+
+const FlagMinerRepoDeprecation = "storagerepo"
+
+func fromMiner(cctx *cli.Context) (err error) {
+	ctx := context.Background()
+	cliCommandColor := color.New(color.FgHiBlue).SprintFunc()
+	configColor := color.New(color.FgHiGreen).SprintFunc()
+
+	r, err := repo.NewFS(cctx.String(FlagMinerRepo))
+	if err != nil {
+		return err
+	}
+
+	ok, err := r.Exists()
+	if err != nil {
+		return err
+	}
+
+	if !ok {
+		return fmt.Errorf("repo not initialized")
+	}
+
+	lr, err := r.LockRO(repo.StorageMiner)
+	if err != nil {
+		return fmt.Errorf("locking repo: %w", err)
+	}
+	defer func() { _ = lr.Close() }()
+
+	cfgNode, err := lr.Config()
+	if err != nil {
+		return fmt.Errorf("getting node config: %w", err)
+	}
+	smCfg := cfgNode.(*config.StorageMiner)
+
+	db, err := harmonydb.NewFromConfig(smCfg.HarmonyDB)
+	if err != nil {
+		return fmt.Errorf("could not reach the database. Ensure the Miner config toml's HarmonyDB entry"+
+			" is setup to reach Yugabyte correctly: %w", err)
+	}
+
+	var titles []string
+	err = db.Select(ctx, &titles, `SELECT title FROM harmony_config WHERE LENGTH(config) > 0`)
+	if err != nil {
+		return fmt.Errorf("miner cannot reach the db. Ensure the config toml's HarmonyDB entry"+
+			" is setup to reach Yugabyte correctly: %s", err.Error())
+	}
+	name := cctx.String("to-layer")
+	if name == "" {
+		name = fmt.Sprintf("mig%d", len(titles))
+	} else {
+		if lo.Contains(titles, name) && !cctx.Bool("overwrite") {
+			return errors.New("the overwrite flag is needed to replace existing layer: " + name)
+		}
+	}
+	msg := "Layer " + configColor(name) + ` created. `
+
+	// Copy over identical settings:
+
+	buf, err := os.ReadFile(path.Join(lr.Path(), "config.toml"))
+	if err != nil {
+		return fmt.Errorf("could not read config.toml: %w", err)
+	}
+	var lpCfg config.LotusProviderConfig
+	_, err = toml.Decode(string(buf), &lpCfg)
+	if err != nil {
+		return fmt.Errorf("could not decode toml: %w", err)
+	}
+
+	// Populate Miner Address
+	mmeta, err := lr.Datastore(ctx, "/metadata")
+	if err != nil {
+		return xerrors.Errorf("opening miner metadata datastore: %w", err)
+	}
+	defer func() {
+		_ = mmeta.Close()
+	}()
+
+	maddrBytes, err := mmeta.Get(ctx, datastore.NewKey("miner-address"))
+	if err != nil {
+		return xerrors.Errorf("getting miner address datastore entry: %w", err)
+	}
+
+	addr, err := address.NewFromBytes(maddrBytes)
+	if err != nil {
+		return xerrors.Errorf("parsing miner actor address: %w", err)
+	}
+
+	lpCfg.Addresses.MinerAddresses = []string{addr.String()}
+
+	ks, err := lr.KeyStore()
+	if err != nil {
+		return xerrors.Errorf("keystore err: %w", err)
+	}
+	js, err := ks.Get(modules.JWTSecretName)
+	if err != nil {
+		return xerrors.Errorf("error getting JWTSecretName: %w", err)
+	}
+
+	lpCfg.Apis.StorageRPCSecret = base64.StdEncoding.EncodeToString(js.PrivateKey)
+
+	// Populate API Key
+	_, header, err := cliutil.GetRawAPI(cctx, repo.FullNode, "v0")
+	if err != nil {
+		return fmt.Errorf("cannot read API: %w", err)
+	}
+
+	ainfo, err := cliutil.GetAPIInfo(&cli.Context{}, repo.FullNode)
+	if err != nil {
+		return xerrors.Errorf(`could not get API info for FullNode: %w
+		Set the environment variable to the value of "lotus auth api-info --perm=admin"`, err)
+	}
+	lpCfg.Apis.ChainApiInfo = []string{header.Get("Authorization")[7:] + ":" + ainfo.Addr}
+
+	// Enable WindowPoSt
+	lpCfg.Subsystems.EnableWindowPost = true
+	msg += "\nBefore running lotus-provider, ensure any miner/worker answering of WindowPost is disabled by " +
+		"(on Miner) " + configColor("DisableBuiltinWindowPoSt=true") + " and (on Workers) not enabling windowpost on CLI or via " +
+		"environment variable " + configColor("LOTUS_WORKER_WINDOWPOST") + "."
+
+	// Express as configTOML
+	configTOML := &bytes.Buffer{}
+	if err = toml.NewEncoder(configTOML).Encode(lpCfg); err != nil {
+		return err
+	}
+
+	if !lo.Contains(titles, "base") {
+		cfg, err := getDefaultConfig(true)
+		if err != nil {
+			return xerrors.Errorf("Cannot get default config: %w", err)
+		}
+		_, err = db.Exec(ctx, "INSERT INTO harmony_config (title, config) VALUES ('base', $1)", cfg)
+
+		if err != nil {
+			return err
+		}
+	}
+
+	if cctx.Bool("overwrite") {
+		i, err := db.Exec(ctx, "DELETE FROM harmony_config WHERE title=$1", name)
+		if i != 0 {
+			fmt.Println("Overwriting existing layer")
+		}
+		if err != nil {
+			fmt.Println("Got error while deleting existing layer: " + err.Error())
+		}
+	}
+
+	_, err = db.Exec(ctx, "INSERT INTO harmony_config (title, config) VALUES ($1, $2)", name, configTOML.String())
+	if err != nil {
+		return err
+	}
+
+	dbSettings := ""
+	def := config.DefaultStorageMiner().HarmonyDB
+	if def.Hosts[0] != smCfg.HarmonyDB.Hosts[0] {
+		dbSettings += ` --db-host="` + strings.Join(smCfg.HarmonyDB.Hosts, ",") + `"`
+	}
+	if def.Port != smCfg.HarmonyDB.Port {
+		dbSettings += " --db-port=" + smCfg.HarmonyDB.Port
+	}
+	if def.Username != smCfg.HarmonyDB.Username {
+		dbSettings += ` --db-user="` + smCfg.HarmonyDB.Username + `"`
+	}
+	if def.Password != smCfg.HarmonyDB.Password {
+		dbSettings += ` --db-password="` + smCfg.HarmonyDB.Password + `"`
+	}
+	if def.Database != smCfg.HarmonyDB.Database {
+		dbSettings += ` --db-name="` + smCfg.HarmonyDB.Database + `"`
+	}
+
+	var layerMaybe string
+	if name != "base" {
+		layerMaybe = "--layer=" + name
+	}
+
+	msg += `
+To work with the config:
+` + cliCommandColor(`lotus-provider `+dbSettings+` config help `)
+	msg += `
+To run Lotus Provider: in its own machine or cgroup without other files, use the command: 
+` + cliCommandColor(`lotus-provider `+dbSettings+` run `+layerMaybe)
+	fmt.Println(msg)
+	return nil
+}
diff --git a/cmd/lotus-provider/proving.go b/cmd/lotus-provider/proving.go
new file mode 100644
index 000000000..a3211b176
--- /dev/null
+++ b/cmd/lotus-provider/proving.go
@@ -0,0 +1,198 @@
+package main
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/dline"
+
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/provider"
+)
+
+var testCmd = &cli.Command{
+	Name:  "test",
+	Usage: "Utility functions for testing",
+	Subcommands: []*cli.Command{
+		//provingInfoCmd,
+		wdPostCmd,
+	},
+}
+
+var wdPostCmd = &cli.Command{
+	Name:    "window-post",
+	Aliases: []string{"wd", "windowpost", "wdpost"},
+	Usage:   "Compute a proof-of-spacetime for a sector (requires the sector to be pre-sealed). These will not send to the chain.",
+	Subcommands: []*cli.Command{
+		wdPostHereCmd,
+		wdPostTaskCmd,
+	},
+}
+
+// wdPostTaskCmd writes to harmony_task and wdpost_partition_tasks, then waits for the result.
+// It is intended to be used to test the windowpost scheduler.
+// The end of the compute task puts the task_id onto wdpost_proofs, which is read by the submit task.
+// The submit task will not send test tasks to the chain, and instead will write the result to harmony_test.
+// The result is read by this command, and printed to stdout.
+var wdPostTaskCmd = &cli.Command{
+	Name:    "task",
+	Aliases: []string{"scheduled", "schedule", "async", "asynchronous"},
+	Usage:   "Test the windowpost scheduler by running it on the next available lotus-provider. ",
+	Flags: []cli.Flag{
+		&cli.Uint64Flag{
+			Name:  "deadline",
+			Usage: "deadline to compute WindowPoSt for ",
+			Value: 0,
+		},
+		&cli.StringSliceFlag{
+			Name:  "layers",
+			Usage: "list of layers to be interpreted (atop defaults). Default: base",
+			Value: cli.NewStringSlice("base"),
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		ctx := context.Background()
+
+		deps, err := getDeps(ctx, cctx)
+		if err != nil {
+			return err
+		}
+
+		ts, err := deps.full.ChainHead(ctx)
+		if err != nil {
+			return xerrors.Errorf("cannot get chainhead %w", err)
+		}
+		ht := ts.Height()
+
+		addr, err := address.NewFromString(deps.cfg.Addresses.MinerAddresses[0])
+		if err != nil {
+			return xerrors.Errorf("cannot get miner address %w", err)
+		}
+		maddr, err := address.IDFromAddress(addr)
+		if err != nil {
+			return xerrors.Errorf("cannot get miner id %w", err)
+		}
+		var id int64
+		_, err = deps.db.BeginTransaction(ctx, func(tx *harmonydb.Tx) (commit bool, err error) {
+			err = tx.QueryRow(`INSERT INTO harmony_task (name, posted_time, added_by) VALUES ('WdPost', CURRENT_TIMESTAMP, 123) RETURNING id`).Scan(&id)
+			if err != nil {
+				log.Error("inserting harmony_task: ", err)
+				return false, xerrors.Errorf("inserting harmony_task: %w", err)
+			}
+			_, err = tx.Exec(`INSERT INTO wdpost_partition_tasks 
+			(task_id, sp_id, proving_period_start, deadline_index, partition_index) VALUES ($1, $2, $3, $4, $5)`,
+				id, maddr, ht, cctx.Uint64("deadline"), 0)
+			if err != nil {
+				log.Error("inserting wdpost_partition_tasks: ", err)
+				return false, xerrors.Errorf("inserting wdpost_partition_tasks: %w", err)
+			}
+			_, err = tx.Exec("INSERT INTO harmony_test (task_id) VALUES ($1)", id)
+			if err != nil {
+				return false, xerrors.Errorf("inserting into harmony_tests: %w", err)
+			}
+			return true, nil
+		})
+		if err != nil {
+			return xerrors.Errorf("writing SQL transaction: %w", err)
+		}
+		fmt.Printf("Inserted task %v. Waiting for success ", id)
+		var result sql.NullString
+		for {
+			time.Sleep(time.Second)
+			err = deps.db.QueryRow(ctx, `SELECT result FROM harmony_test WHERE task_id=$1`, id).Scan(&result)
+			if err != nil {
+				return xerrors.Errorf("reading result from harmony_test: %w", err)
+			}
+			if result.Valid {
+				break
+			}
+			fmt.Print(".")
+		}
+		log.Infof("Result: %s", result.String)
+		return nil
+	},
+}
+
+// This command is intended to be used to verify PoSt compute performance.
+// It will not send any messages to the chain. Since it can compute any deadline, output may be incorrectly timed for the chain.
+// The entire processing happens in this process while you wait. It does not use the scheduler.
+var wdPostHereCmd = &cli.Command{
+	Name:    "here",
+	Aliases: []string{"cli"},
+	Usage:   "Compute WindowPoSt for performance and configuration testing.",
+	Description: `Note: This command is intended to be used to verify PoSt compute performance.
+It will not send any messages to the chain. Since it can compute any deadline, output may be incorrectly timed for the chain.`,
+	ArgsUsage: "[deadline index]",
+	Flags: []cli.Flag{
+		&cli.Uint64Flag{
+			Name:  "deadline",
+			Usage: "deadline to compute WindowPoSt for ",
+			Value: 0,
+		},
+		&cli.StringSliceFlag{
+			Name:  "layers",
+			Usage: "list of layers to be interpreted (atop defaults). Default: base",
+			Value: cli.NewStringSlice("base"),
+		},
+		&cli.StringFlag{
+			Name:  "storage-json",
+			Usage: "path to json file containing storage config",
+			Value: "~/.lotus-provider/storage.json",
+		},
+		&cli.Uint64Flag{
+			Name:  "partition",
+			Usage: "partition to compute WindowPoSt for",
+			Value: 0,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+
+		ctx := context.Background()
+		deps, err := getDeps(ctx, cctx)
+		if err != nil {
+			return err
+		}
+
+		wdPostTask, wdPoStSubmitTask, derlareRecoverTask, err := provider.WindowPostScheduler(ctx, deps.cfg.Fees, deps.cfg.Proving, deps.full, deps.verif, deps.lw, nil,
+			deps.as, deps.maddrs, deps.db, deps.stor, deps.si, deps.cfg.Subsystems.WindowPostMaxTasks)
+		if err != nil {
+			return err
+		}
+		_, _ = wdPoStSubmitTask, derlareRecoverTask
+
+		if len(deps.maddrs) == 0 {
+			return errors.New("no miners to compute WindowPoSt for")
+		}
+		head, err := deps.full.ChainHead(ctx)
+		if err != nil {
+			return xerrors.Errorf("failed to get chain head: %w", err)
+		}
+
+		di := dline.NewInfo(head.Height(), cctx.Uint64("deadline"), 0, 0, 0, 10 /*challenge window*/, 0, 0)
+
+		for _, maddr := range deps.maddrs {
+			out, err := wdPostTask.DoPartition(ctx, head, address.Address(maddr), di, cctx.Uint64("partition"))
+			if err != nil {
+				fmt.Println("Error computing WindowPoSt for miner", maddr, err)
+				continue
+			}
+			fmt.Println("Computed WindowPoSt for miner", maddr, ":")
+			err = json.NewEncoder(os.Stdout).Encode(out)
+			if err != nil {
+				fmt.Println("Could not encode WindowPoSt output for miner", maddr, err)
+				continue
+			}
+		}
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-provider/rpc/rpc.go b/cmd/lotus-provider/rpc/rpc.go
new file mode 100644
index 000000000..3ae3e2a1f
--- /dev/null
+++ b/cmd/lotus-provider/rpc/rpc.go
@@ -0,0 +1,51 @@
+package rpc
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/gorilla/mux"
+
+	// logging "github.com/ipfs/go-log/v2"
+	"github.com/filecoin-project/go-jsonrpc"
+	"github.com/filecoin-project/go-jsonrpc/auth"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/lib/rpcenc"
+	"github.com/filecoin-project/lotus/metrics/proxy"
+)
+
+//var log = logging.Logger("lp/rpc")
+
+func LotusProviderHandler(
+	authv func(ctx context.Context, token string) ([]auth.Permission, error),
+	remote http.HandlerFunc,
+	a api.LotusProvider,
+	permissioned bool) http.Handler {
+	mux := mux.NewRouter()
+	readerHandler, readerServerOpt := rpcenc.ReaderParamDecoder()
+	rpcServer := jsonrpc.NewServer(jsonrpc.WithServerErrors(api.RPCErrors), readerServerOpt)
+
+	wapi := proxy.MetricedAPI[api.LotusProvider, api.LotusProviderStruct](a)
+	if permissioned {
+		wapi = api.PermissionedAPI[api.LotusProvider, api.LotusProviderStruct](wapi)
+	}
+
+	rpcServer.Register("Filecoin", wapi)
+	rpcServer.AliasMethod("rpc.discover", "Filecoin.Discover")
+
+	mux.Handle("/rpc/v0", rpcServer)
+	mux.Handle("/rpc/streams/v0/push/{uuid}", readerHandler)
+	mux.PathPrefix("/remote").HandlerFunc(remote)
+	mux.PathPrefix("/").Handler(http.DefaultServeMux) // pprof
+
+	if !permissioned {
+		return mux
+	}
+
+	ah := &auth.Handler{
+		Verify: authv,
+		Next:   mux.ServeHTTP,
+	}
+	return ah
+}
diff --git a/cmd/lotus-provider/run.go b/cmd/lotus-provider/run.go
new file mode 100644
index 000000000..de97aa766
--- /dev/null
+++ b/cmd/lotus-provider/run.go
@@ -0,0 +1,467 @@
+package main
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/gbrlsnchs/jwt/v3"
+	"github.com/gorilla/mux"
+	ds "github.com/ipfs/go-datastore"
+	dssync "github.com/ipfs/go-datastore/sync"
+	"github.com/pkg/errors"
+	"github.com/samber/lo"
+	"github.com/urfave/cli/v2"
+	"go.opencensus.io/stats"
+	"go.opencensus.io/tag"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-jsonrpc/auth"
+	"github.com/filecoin-project/go-statestore"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	lcli "github.com/filecoin-project/lotus/cli"
+	cliutil "github.com/filecoin-project/lotus/cli/util"
+	"github.com/filecoin-project/lotus/cmd/lotus-provider/rpc"
+	"github.com/filecoin-project/lotus/journal"
+	"github.com/filecoin-project/lotus/journal/alerting"
+	"github.com/filecoin-project/lotus/journal/fsjournal"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonytask"
+	"github.com/filecoin-project/lotus/lib/ulimit"
+	"github.com/filecoin-project/lotus/metrics"
+	"github.com/filecoin-project/lotus/node"
+	"github.com/filecoin-project/lotus/node/config"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/filecoin-project/lotus/node/repo"
+	"github.com/filecoin-project/lotus/provider"
+	"github.com/filecoin-project/lotus/provider/lpmessage"
+	"github.com/filecoin-project/lotus/provider/lpwinning"
+	"github.com/filecoin-project/lotus/storage/ctladdr"
+	"github.com/filecoin-project/lotus/storage/paths"
+	"github.com/filecoin-project/lotus/storage/sealer"
+	"github.com/filecoin-project/lotus/storage/sealer/ffiwrapper"
+	"github.com/filecoin-project/lotus/storage/sealer/storiface"
+)
+
+type stackTracer interface {
+	StackTrace() errors.StackTrace
+}
+
+var runCmd = &cli.Command{
+	Name:  "run",
+	Usage: "Start a lotus provider process",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:    "listen",
+			Usage:   "host address and port the worker api will listen on",
+			Value:   "0.0.0.0:12300",
+			EnvVars: []string{"LOTUS_WORKER_LISTEN"},
+		},
+		&cli.BoolFlag{
+			Name:  "nosync",
+			Usage: "don't check full-node sync status",
+		},
+		&cli.BoolFlag{
+			Name:   "halt-after-init",
+			Usage:  "only run init, then return",
+			Hidden: true,
+		},
+		&cli.BoolFlag{
+			Name:  "manage-fdlimit",
+			Usage: "manage open file limit",
+			Value: true,
+		},
+		&cli.StringSliceFlag{
+			Name:  "layers",
+			Usage: "list of layers to be interpreted (atop defaults). Default: base",
+			Value: cli.NewStringSlice("base"),
+		},
+		&cli.StringFlag{
+			Name:  "storage-json",
+			Usage: "path to json file containing storage config",
+			Value: "~/.lotus-provider/storage.json",
+		},
+		&cli.StringFlag{
+			Name:  "journal",
+			Usage: "path to journal files",
+			Value: "~/.lotus-provider/",
+		},
+	},
+	Action: func(cctx *cli.Context) (err error) {
+		defer func() {
+			if err != nil {
+				if err, ok := err.(stackTracer); ok {
+					for _, f := range err.StackTrace() {
+						fmt.Printf("%+s:%d\n", f, f)
+					}
+				}
+			}
+		}()
+		if !cctx.Bool("enable-gpu-proving") {
+			err := os.Setenv("BELLMAN_NO_GPU", "true")
+			if err != nil {
+				return err
+			}
+		}
+
+		ctx, _ := tag.New(lcli.DaemonContext(cctx),
+			tag.Insert(metrics.Version, build.BuildVersion),
+			tag.Insert(metrics.Commit, build.CurrentCommit),
+			tag.Insert(metrics.NodeType, "provider"),
+		)
+		shutdownChan := make(chan struct{})
+		{
+			var ctxclose func()
+			ctx, ctxclose = context.WithCancel(ctx)
+			go func() {
+				<-shutdownChan
+				ctxclose()
+			}()
+		}
+		// Register all metric views
+		/*
+			if err := view.Register(
+				metrics.MinerNodeViews...,
+			); err != nil {
+				log.Fatalf("Cannot register the view: %v", err)
+			}
+		*/
+		// Set the metric to one so it is published to the exporter
+		stats.Record(ctx, metrics.LotusInfo.M(1))
+
+		if cctx.Bool("manage-fdlimit") {
+			if _, _, err := ulimit.ManageFdLimit(); err != nil {
+				log.Errorf("setting file descriptor limit: %s", err)
+			}
+		}
+
+		deps, err := getDeps(ctx, cctx)
+
+		if err != nil {
+			return err
+		}
+		cfg, db, full, verif, lw, as, maddrs, stor, si, localStore := deps.cfg, deps.db, deps.full, deps.verif, deps.lw, deps.as, deps.maddrs, deps.stor, deps.si, deps.localStore
+
+		var activeTasks []harmonytask.TaskInterface
+
+		sender, sendTask := lpmessage.NewSender(full, full, db)
+		activeTasks = append(activeTasks, sendTask)
+
+		///////////////////////////////////////////////////////////////////////
+		///// Task Selection
+		///////////////////////////////////////////////////////////////////////
+		{
+
+			if cfg.Subsystems.EnableWindowPost {
+				wdPostTask, wdPoStSubmitTask, derlareRecoverTask, err := provider.WindowPostScheduler(ctx, cfg.Fees, cfg.Proving, full, verif, lw, sender,
+					as, maddrs, db, stor, si, cfg.Subsystems.WindowPostMaxTasks)
+				if err != nil {
+					return err
+				}
+				activeTasks = append(activeTasks, wdPostTask, wdPoStSubmitTask, derlareRecoverTask)
+			}
+
+			if cfg.Subsystems.EnableWinningPost {
+				winPoStTask := lpwinning.NewWinPostTask(cfg.Subsystems.WinningPostMaxTasks, db, lw, verif, full, maddrs)
+				activeTasks = append(activeTasks, winPoStTask)
+			}
+		}
+		log.Infow("This lotus_provider instance handles",
+			"miner_addresses", minerAddressesToStrings(maddrs),
+			"tasks", lo.Map(activeTasks, func(t harmonytask.TaskInterface, _ int) string { return t.TypeDetails().Name }))
+
+		taskEngine, err := harmonytask.New(db, activeTasks, deps.listenAddr)
+		if err != nil {
+			return err
+		}
+
+		defer taskEngine.GracefullyTerminate(time.Hour)
+
+		fh := &paths.FetchHandler{Local: localStore, PfHandler: &paths.DefaultPartialFileHandler{}}
+		remoteHandler := func(w http.ResponseWriter, r *http.Request) {
+			if !auth.HasPerm(r.Context(), nil, api.PermAdmin) {
+				w.WriteHeader(401)
+				_ = json.NewEncoder(w).Encode(struct{ Error string }{"unauthorized: missing admin permission"})
+				return
+			}
+
+			fh.ServeHTTP(w, r)
+		}
+		// local APIs
+		{
+			// debugging
+			mux := mux.NewRouter()
+			mux.PathPrefix("/").Handler(http.DefaultServeMux) // pprof
+			mux.PathPrefix("/remote").HandlerFunc(remoteHandler)
+
+			/*ah := &auth.Handler{
+				Verify: authv,
+				Next:   mux.ServeHTTP,
+			}*/ // todo
+
+		}
+
+		var authVerify func(context.Context, string) ([]auth.Permission, error)
+		{
+			privateKey, err := base64.StdEncoding.DecodeString(deps.cfg.Apis.StorageRPCSecret)
+			if err != nil {
+				return xerrors.Errorf("decoding storage rpc secret: %w", err)
+			}
+			authVerify = func(ctx context.Context, token string) ([]auth.Permission, error) {
+				var payload jwtPayload
+				if _, err := jwt.Verify([]byte(token), jwt.NewHS256(privateKey), &payload); err != nil {
+					return nil, xerrors.Errorf("JWT Verification failed: %w", err)
+				}
+
+				return payload.Allow, nil
+			}
+		}
+		// Serve the RPC.
+		srv := &http.Server{
+			Handler: rpc.LotusProviderHandler(
+				authVerify,
+				remoteHandler,
+				&ProviderAPI{deps, shutdownChan},
+				true),
+			ReadHeaderTimeout: time.Minute * 3,
+			BaseContext: func(listener net.Listener) context.Context {
+				ctx, _ := tag.New(context.Background(), tag.Upsert(metrics.APIInterface, "lotus-worker"))
+				return ctx
+			},
+		}
+
+		go func() {
+			<-ctx.Done()
+			log.Warn("Shutting down...")
+			if err := srv.Shutdown(context.TODO()); err != nil {
+				log.Errorf("shutting down RPC server failed: %s", err)
+			}
+			log.Warn("Graceful shutdown successful")
+		}()
+
+		// Monitor for shutdown.
+		// TODO provide a graceful shutdown API on shutdownChan
+		finishCh := node.MonitorShutdown(shutdownChan) //node.ShutdownHandler{Component: "rpc server", StopFunc: rpcStopper},
+		//node.ShutdownHandler{Component: "provider", StopFunc: stop},
+
+		<-finishCh
+		return nil
+	},
+}
+
+func makeDB(cctx *cli.Context) (*harmonydb.DB, error) {
+	dbConfig := config.HarmonyDB{
+		Username: cctx.String("db-user"),
+		Password: cctx.String("db-password"),
+		Hosts:    strings.Split(cctx.String("db-host"), ","),
+		Database: cctx.String("db-name"),
+		Port:     cctx.String("db-port"),
+	}
+	return harmonydb.NewFromConfig(dbConfig)
+}
+
+type jwtPayload struct {
+	Allow []auth.Permission
+}
+
+func StorageAuth(apiKey string) (sealer.StorageAuth, error) {
+	if apiKey == "" {
+		return nil, xerrors.Errorf("no api key provided")
+	}
+
+	rawKey, err := base64.StdEncoding.DecodeString(apiKey)
+	if err != nil {
+		return nil, xerrors.Errorf("decoding api key: %w", err)
+	}
+
+	key := jwt.NewHS256(rawKey)
+
+	p := jwtPayload{
+		Allow: []auth.Permission{"admin"},
+	}
+
+	token, err := jwt.Sign(&p, key)
+	if err != nil {
+		return nil, err
+	}
+
+	headers := http.Header{}
+	headers.Add("Authorization", "Bearer "+string(token))
+	return sealer.StorageAuth(headers), nil
+}
+
+type Deps struct {
+	cfg        *config.LotusProviderConfig
+	db         *harmonydb.DB
+	full       api.FullNode
+	verif      storiface.Verifier
+	lw         *sealer.LocalWorker
+	as         *ctladdr.AddressSelector
+	maddrs     []dtypes.MinerAddress
+	stor       *paths.Remote
+	si         *paths.DBIndex
+	localStore *paths.Local
+	listenAddr string
+}
+
+func getDeps(ctx context.Context, cctx *cli.Context) (*Deps, error) {
+	// Open repo
+
+	repoPath := cctx.String(FlagRepoPath)
+	fmt.Println("repopath", repoPath)
+	r, err := repo.NewFS(repoPath)
+	if err != nil {
+		return nil, err
+	}
+
+	ok, err := r.Exists()
+	if err != nil {
+		return nil, err
+	}
+	if !ok {
+		if err := r.Init(repo.Provider); err != nil {
+			return nil, err
+		}
+	}
+
+	db, err := makeDB(cctx)
+	if err != nil {
+		return nil, err
+	}
+
+	///////////////////////////////////////////////////////////////////////
+	///// Dependency Setup
+	///////////////////////////////////////////////////////////////////////
+
+	// The config feeds into task runners & their helpers
+	cfg, err := getConfig(cctx, db)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Debugw("config", "config", cfg)
+
+	var verif storiface.Verifier = ffiwrapper.ProofVerifier
+
+	as, err := provider.AddressSelector(&cfg.Addresses)()
+	if err != nil {
+		return nil, err
+	}
+
+	de, err := journal.ParseDisabledEvents(cfg.Journal.DisabledEvents)
+	if err != nil {
+		return nil, err
+	}
+	j, err := fsjournal.OpenFSJournalPath(cctx.String("journal"), de)
+	if err != nil {
+		return nil, err
+	}
+
+	full, fullCloser, err := cliutil.GetFullNodeAPIV1LotusProvider(cctx, cfg.Apis.ChainApiInfo)
+	if err != nil {
+		return nil, err
+	}
+
+	go func() {
+		select {
+		case <-ctx.Done():
+			fullCloser()
+			_ = j.Close()
+		}
+	}()
+	sa, err := StorageAuth(cfg.Apis.StorageRPCSecret)
+	if err != nil {
+		return nil, xerrors.Errorf(`'%w' while parsing the config toml's 
+	[Apis]
+	StorageRPCSecret=%v
+Get it with: jq .PrivateKey ~/.lotus-miner/keystore/MF2XI2BNNJ3XILLQOJUXMYLUMU`, err, cfg.Apis.StorageRPCSecret)
+	}
+
+	al := alerting.NewAlertingSystem(j)
+	si := paths.NewDBIndex(al, db)
+	bls := &paths.BasicLocalStorage{
+		PathToJSON: cctx.String("storage-json"),
+	}
+
+	listenAddr := cctx.String("listen")
+	const unspecifiedAddress = "0.0.0.0"
+	addressSlice := strings.Split(listenAddr, ":")
+	if ip := net.ParseIP(addressSlice[0]); ip != nil {
+		if ip.String() == unspecifiedAddress {
+			rip, err := db.GetRoutableIP()
+			if err != nil {
+				return nil, err
+			}
+			listenAddr = rip + ":" + addressSlice[1]
+		}
+	}
+	localStore, err := paths.NewLocal(ctx, bls, si, []string{"http://" + listenAddr + "/remote"})
+	if err != nil {
+		return nil, err
+	}
+
+	stor := paths.NewRemote(localStore, si, http.Header(sa), 10, &paths.DefaultPartialFileHandler{})
+
+	wstates := statestore.New(dssync.MutexWrap(ds.NewMapDatastore()))
+
+	// todo localWorker isn't the abstraction layer we want to use here, we probably want to go straight to ffiwrapper
+	//  maybe with a lotus-provider specific abstraction. LocalWorker does persistent call tracking which we probably
+	//  don't need (ehh.. maybe we do, the async callback system may actually work decently well with harmonytask)
+	lw := sealer.NewLocalWorker(sealer.WorkerConfig{}, stor, localStore, si, nil, wstates)
+
+	var maddrs []dtypes.MinerAddress
+	for _, s := range cfg.Addresses.MinerAddresses {
+		addr, err := address.NewFromString(s)
+		if err != nil {
+			return nil, err
+		}
+		maddrs = append(maddrs, dtypes.MinerAddress(addr))
+	}
+
+	return &Deps{ // lint: intentionally not-named so it will fail if one is forgotten
+		cfg,
+		db,
+		full,
+		verif,
+		lw,
+		as,
+		maddrs,
+		stor,
+		si,
+		localStore,
+		listenAddr,
+	}, nil
+
+}
+
+type ProviderAPI struct {
+	*Deps
+	ShutdownChan chan struct{}
+}
+
+func (p *ProviderAPI) Version(context.Context) (api.Version, error) {
+	return api.ProviderAPIVersion0, nil
+}
+
+// Trigger shutdown
+func (p *ProviderAPI) Shutdown(context.Context) error {
+	close(p.ShutdownChan)
+	return nil
+}
+
+func minerAddressesToStrings(maddrs []dtypes.MinerAddress) []string {
+	strs := make([]string, len(maddrs))
+	for i, addr := range maddrs {
+		strs[i] = address.Address(addr).String()
+	}
+	return strs
+}
diff --git a/cmd/lotus-provider/stop.go b/cmd/lotus-provider/stop.go
new file mode 100644
index 000000000..3376d762a
--- /dev/null
+++ b/cmd/lotus-provider/stop.go
@@ -0,0 +1,29 @@
+package main
+
+import (
+	_ "net/http/pprof"
+
+	"github.com/urfave/cli/v2"
+
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+var stopCmd = &cli.Command{
+	Name:  "stop",
+	Usage: "Stop a running lotus provider",
+	Flags: []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		err = api.Shutdown(lcli.ReqContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/genesis-verify.go b/cmd/lotus-shed/genesis-verify.go
index 6795f1528..4ead8467e 100644
--- a/cmd/lotus-shed/genesis-verify.go
+++ b/cmd/lotus-shed/genesis-verify.go
@@ -62,7 +62,7 @@ var genesisVerifyCmd = &cli.Command{
 			return xerrors.Errorf("opening the car file: %w", err)
 		}
 
-		ts, err := cs.Import(cctx.Context, f)
+		ts, _, err := cs.Import(cctx.Context, f)
 		if err != nil {
 			return err
 		}
diff --git a/cmd/lotus-shed/invariants.go b/cmd/lotus-shed/invariants.go
index e74a0dd24..5c6fb2d4f 100644
--- a/cmd/lotus-shed/invariants.go
+++ b/cmd/lotus-shed/invariants.go
@@ -3,7 +3,8 @@ package main
 import (
 	"context"
 	"fmt"
-	"io"
+	"os"
+	"path/filepath"
 	"strconv"
 	"time"
 
@@ -21,6 +22,8 @@ import (
 	v9 "github.com/filecoin-project/go-state-types/builtin/v9"
 
 	"github.com/filecoin-project/lotus/blockstore"
+	badgerbs "github.com/filecoin-project/lotus/blockstore/badger"
+	"github.com/filecoin-project/lotus/blockstore/splitstore"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/consensus"
 	"github.com/filecoin-project/lotus/chain/consensus/filcns"
@@ -73,24 +76,52 @@ var invariantsCmd = &cli.Command{
 
 		defer lkrepo.Close() //nolint:errcheck
 
-		bs, err := lkrepo.Blockstore(ctx, repo.UniversalBlockstore)
+		cold, err := lkrepo.Blockstore(ctx, repo.UniversalBlockstore)
 		if err != nil {
-			return fmt.Errorf("failed to open blockstore: %w", err)
+			return fmt.Errorf("failed to open universal blockstore %w", err)
 		}
 
-		defer func() {
-			if c, ok := bs.(io.Closer); ok {
-				if err := c.Close(); err != nil {
-					log.Warnf("failed to close blockstore: %s", err)
-				}
-			}
-		}()
+		path, err := lkrepo.SplitstorePath()
+		if err != nil {
+			return err
+		}
+
+		path = filepath.Join(path, "hot.badger")
+		if err := os.MkdirAll(path, 0755); err != nil {
+			return err
+		}
+
+		opts, err := repo.BadgerBlockstoreOptions(repo.HotBlockstore, path, lkrepo.Readonly())
+		if err != nil {
+			return err
+		}
+
+		hot, err := badgerbs.Open(opts)
+		if err != nil {
+			return err
+		}
 
 		mds, err := lkrepo.Datastore(context.Background(), "/metadata")
 		if err != nil {
 			return err
 		}
 
+		cfg := &splitstore.Config{
+			MarkSetType:       "map",
+			DiscardColdBlocks: true,
+		}
+		ss, err := splitstore.Open(path, mds, hot, cold, cfg)
+		if err != nil {
+			return err
+		}
+		defer func() {
+			if err := ss.Close(); err != nil {
+				log.Warnf("failed to close blockstore: %s", err)
+
+			}
+		}()
+		bs := ss
+
 		cs := store.NewChainStore(bs, bs, mds, filcns.Weight, nil)
 		defer cs.Close() //nolint:errcheck
 
diff --git a/cmd/lotus-shed/mpool.go b/cmd/lotus-shed/mpool.go
index cfbff2abd..6b210bbc1 100644
--- a/cmd/lotus-shed/mpool.go
+++ b/cmd/lotus-shed/mpool.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"time"
 
 	"github.com/urfave/cli/v2"
 
@@ -43,10 +44,20 @@ var minerSelectMsgsCmd = &cli.Command{
 			return err
 		}
 
+		// Get the size of the mempool
+		pendingMsgs, err := api.MpoolPending(ctx, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+		mpoolSize := len(pendingMsgs)
+
+		// Measure the time taken by MpoolSelect
+		startTime := time.Now()
 		msgs, err := api.MpoolSelect(ctx, head.Key(), cctx.Float64("ticket-quality"))
 		if err != nil {
 			return err
 		}
+		duration := time.Since(startTime)
 
 		var totalGas int64
 		for i, f := range msgs {
@@ -64,6 +75,9 @@ var minerSelectMsgsCmd = &cli.Command{
 			totalGas += f.Message.GasLimit
 		}
 
+		// Log the duration, size of the mempool, selected messages and total gas limit of selected messages
+		fmt.Printf("Message selection took %s\n", duration)
+		fmt.Printf("Size of the mempool: %d\n", mpoolSize)
 		fmt.Println("selected messages: ", len(msgs))
 		fmt.Printf("total gas limit of selected messages: %d / %d (%0.2f%%)\n", totalGas, build.BlockGasLimit, 100*float64(totalGas)/float64(build.BlockGasLimit))
 		return nil
diff --git a/cmd/lotus-shed/pruning.go b/cmd/lotus-shed/pruning.go
index 275f3bc0a..c0bd453b1 100644
--- a/cmd/lotus-shed/pruning.go
+++ b/cmd/lotus-shed/pruning.go
@@ -12,7 +12,7 @@ import (
 
 	"github.com/filecoin-project/go-state-types/abi"
 
-	badgerbs "github.com/filecoin-project/lotus/blockstore/badger"
+	"github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/chain/consensus/filcns"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/node/repo"
@@ -144,13 +144,6 @@ var stateTreePruneCmd = &cli.Command{
 			}
 		}()
 
-		// After migrating to native blockstores, this has been made
-		// database-specific.
-		badgbs, ok := bs.(*badgerbs.Blockstore)
-		if !ok {
-			return fmt.Errorf("only badger blockstores are supported")
-		}
-
 		mds, err := lkrepo.Datastore(context.Background(), "/metadata")
 		if err != nil {
 			return err
@@ -160,8 +153,12 @@ var stateTreePruneCmd = &cli.Command{
 		const DiscardRatio = 0.2
 		if cctx.Bool("only-ds-gc") {
 			fmt.Println("running datastore gc....")
+			gbs, ok := bs.(blockstore.BlockstoreGCOnce)
+			if !ok {
+				return xerrors.Errorf("blockstore %T does not support GC", bs)
+			}
 			for i := 0; i < cctx.Int("gc-count"); i++ {
-				if err := badgbs.DB().RunValueLogGC(DiscardRatio); err != nil {
+				if err := gbs.GCOnce(ctx, blockstore.WithThreshold(DiscardRatio)); err != nil {
 					return xerrors.Errorf("datastore GC failed: %w", err)
 				}
 			}
@@ -208,13 +205,6 @@ var stateTreePruneCmd = &cli.Command{
 			return nil
 		}
 
-		b := badgbs.DB().NewWriteBatch()
-		defer b.Cancel()
-
-		markForRemoval := func(c cid.Cid) error {
-			return b.Delete(badgbs.StorageKey(nil, c))
-		}
-
 		keys, err := bs.AllKeysChan(context.Background())
 		if err != nil {
 			return xerrors.Errorf("failed to query blockstore: %w", err)
@@ -225,12 +215,12 @@ var stateTreePruneCmd = &cli.Command{
 		var deleteCount int
 		var goodHits int
 		for k := range keys {
-			if goodSet.HasRaw(k.Bytes()) {
+			if goodSet.Has(k) {
 				goodHits++
 				continue
 			}
 
-			if err := markForRemoval(k); err != nil {
+			if err := bs.DeleteBlock(ctx, k); err != nil {
 				return fmt.Errorf("failed to remove cid %s: %w", k, err)
 			}
 
@@ -243,13 +233,15 @@ var stateTreePruneCmd = &cli.Command{
 			}
 		}
 
-		if err := b.Flush(); err != nil {
-			return xerrors.Errorf("failed to flush final batch delete: %w", err)
+		fmt.Println("running datastore gc....")
+		gbs, ok := bs.(blockstore.BlockstoreGCOnce)
+		if !ok {
+			fmt.Println("gc not supported...")
+			return nil
 		}
 
-		fmt.Println("running datastore gc....")
 		for i := 0; i < cctx.Int("gc-count"); i++ {
-			if err := badgbs.DB().RunValueLogGC(DiscardRatio); err != nil {
+			if err := gbs.GCOnce(ctx, blockstore.WithThreshold(DiscardRatio)); err != nil {
 				return xerrors.Errorf("datastore GC failed: %w", err)
 			}
 		}
diff --git a/cmd/lotus-shed/terminations.go b/cmd/lotus-shed/terminations.go
index c5f35995a..563c1ba3a 100644
--- a/cmd/lotus-shed/terminations.go
+++ b/cmd/lotus-shed/terminations.go
@@ -157,7 +157,8 @@ var terminationsCmd = &cli.Command{
 				}
 
 				for _, t := range termParams.Terminations {
-					sectors, err := minerSt.LoadSectors(&t.Sectors)
+					tmp := t.Sectors
+					sectors, err := minerSt.LoadSectors(&tmp)
 					if err != nil {
 						return err
 					}
diff --git a/cmd/lotus-sim/simulation/stages/funding_stage.go b/cmd/lotus-sim/simulation/stages/funding_stage.go
index f75a9910d..4ce4afae1 100644
--- a/cmd/lotus-sim/simulation/stages/funding_stage.go
+++ b/cmd/lotus-sim/simulation/stages/funding_stage.go
@@ -166,7 +166,8 @@ func (fs *FundingStage) PackMessages(ctx context.Context, bb *blockbuilder.Block
 		)
 	}()
 
-	for _, actor := range targets {
+	for _, actorTmp := range targets {
+		actor := actorTmp
 		switch {
 		case builtin.IsAccountActor(actor.Code):
 			if _, err := bb.PushMessage(&types.Message{
diff --git a/cmd/lotus-worker/main.go b/cmd/lotus-worker/main.go
index 873dada47..41af11bdd 100644
--- a/cmd/lotus-worker/main.go
+++ b/cmd/lotus-worker/main.go
@@ -7,6 +7,7 @@ import (
 	"net"
 	"net/http"
 	"os"
+	"os/signal"
 	"path/filepath"
 	"reflect"
 	"strings"
@@ -38,6 +39,7 @@ import (
 	"github.com/filecoin-project/lotus/node/repo"
 	"github.com/filecoin-project/lotus/storage/paths"
 	"github.com/filecoin-project/lotus/storage/sealer"
+	"github.com/filecoin-project/lotus/storage/sealer/ffiwrapper"
 	"github.com/filecoin-project/lotus/storage/sealer/sealtasks"
 	"github.com/filecoin-project/lotus/storage/sealer/storiface"
 )
@@ -283,7 +285,36 @@ var runCmd = &cli.Command{
 			Value:       true,
 			DefaultText: "inherits --addpiece",
 		},
+		&cli.StringFlag{
+			Name:  "external-pc2",
+			Usage: "command for computing PC2 externally",
+		},
 	},
+	Description: `Run lotus-worker.
+
+--external-pc2 can be used to compute the PreCommit2 inputs externally.
+The flag behaves similarly to the related lotus-worker flag, using it in
+lotus-bench may be useful for testing if the external PreCommit2 command is
+invoked correctly.
+
+The command will be called with a number of environment variables set:
+* EXTSEAL_PC2_SECTOR_NUM: the sector number
+* EXTSEAL_PC2_SECTOR_MINER: the miner id
+* EXTSEAL_PC2_PROOF_TYPE: the proof type
+* EXTSEAL_PC2_SECTOR_SIZE: the sector size in bytes
+* EXTSEAL_PC2_CACHE: the path to the cache directory
+* EXTSEAL_PC2_SEALED: the path to the sealed sector file (initialized with unsealed data by the caller)
+* EXTSEAL_PC2_PC1OUT: output from rust-fil-proofs precommit1 phase (base64 encoded json)
+
+The command is expected to:
+* Create cache sc-02-data-tree-r* files
+* Create cache sc-02-data-tree-c* files
+* Create cache p_aux / t_aux files
+* Transform the sealed file in place
+
+Example invocation of lotus-bench as external executor:
+'./lotus-bench simple precommit2 --sector-size $EXTSEAL_PC2_SECTOR_SIZE $EXTSEAL_PC2_SEALED $EXTSEAL_PC2_CACHE $EXTSEAL_PC2_PC1OUT'
+`,
 	Before: func(cctx *cli.Context) error {
 		if cctx.IsSet("address") {
 			log.Warnf("The '--address' flag is deprecated, it has been replaced by '--listen'")
@@ -348,6 +379,18 @@ var runCmd = &cli.Command{
 		// Connect to storage-miner
 		ctx := lcli.ReqContext(cctx)
 
+		// Create a new context with cancel function
+		ctx, cancel := context.WithCancel(ctx)
+		defer cancel()
+
+		// Listen for interrupt signals
+		go func() {
+			c := make(chan os.Signal, 1)
+			signal.Notify(c, os.Interrupt)
+			<-c
+			cancel()
+		}()
+
 		var nodeApi api.StorageMiner
 		var closer func()
 		for {
@@ -359,14 +402,13 @@ var runCmd = &cli.Command{
 				}
 			}
 			fmt.Printf("\r\x1b[0KConnecting to miner API... (%s)", err)
-			time.Sleep(time.Second)
-			continue
+			select {
+			case <-ctx.Done():
+				return xerrors.New("Interrupted by user")
+			case <-time.After(time.Second):
+			}
 		}
-
 		defer closer()
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
-
 		// Register all metric views
 		if err := view.Register(
 			metrics.DefaultViews...,
@@ -611,18 +653,32 @@ var runCmd = &cli.Command{
 			fh.ServeHTTP(w, r)
 		}
 
+		// Parse ffi executor flags
+
+		var ffiOpts []ffiwrapper.FFIWrapperOpt
+
+		if cctx.IsSet("external-pc2") {
+			extSeal := ffiwrapper.ExternalSealer{
+				PreCommit2: ffiwrapper.MakeExternPrecommit2(cctx.String("external-pc2")),
+			}
+
+			ffiOpts = append(ffiOpts, ffiwrapper.WithExternalSealCalls(extSeal))
+		}
+
 		// Create / expose the worker
 
 		wsts := statestore.New(namespace.Wrap(ds, modules.WorkerCallsPrefix))
 
 		workerApi := &sealworker.Worker{
-			LocalWorker: sealer.NewLocalWorker(sealer.WorkerConfig{
-				TaskTypes:                 taskTypes,
-				NoSwap:                    cctx.Bool("no-swap"),
-				MaxParallelChallengeReads: cctx.Int("post-parallel-reads"),
-				ChallengeReadTimeout:      cctx.Duration("post-read-timeout"),
-				Name:                      cctx.String("name"),
-			}, remote, localStore, nodeApi, nodeApi, wsts),
+			LocalWorker: sealer.NewLocalWorkerWithExecutor(
+				sealer.FFIExec(ffiOpts...),
+				sealer.WorkerConfig{
+					TaskTypes:                 taskTypes,
+					NoSwap:                    cctx.Bool("no-swap"),
+					MaxParallelChallengeReads: cctx.Int("post-parallel-reads"),
+					ChallengeReadTimeout:      cctx.Duration("post-read-timeout"),
+					Name:                      cctx.String("name"),
+				}, os.LookupEnv, remote, localStore, nodeApi, nodeApi, wsts),
 			LocalStore: localStore,
 			Storage:    lr,
 		}
diff --git a/cmd/lotus-worker/sealworker/rpc.go b/cmd/lotus-worker/sealworker/rpc.go
index 97f78942e..4e720ef64 100644
--- a/cmd/lotus-worker/sealworker/rpc.go
+++ b/cmd/lotus-worker/sealworker/rpc.go
@@ -26,7 +26,11 @@ import (
 
 var log = logging.Logger("sealworker")
 
-func WorkerHandler(authv func(ctx context.Context, token string) ([]auth.Permission, error), remote http.HandlerFunc, a api.Worker, permissioned bool) http.Handler {
+func WorkerHandler(
+	authv func(ctx context.Context, token string) ([]auth.Permission, error),
+	remote http.HandlerFunc,
+	a api.Worker,
+	permissioned bool) http.Handler {
 	mux := mux.NewRouter()
 	readerHandler, readerServerOpt := rpcenc.ReaderParamDecoder()
 	rpcServer := jsonrpc.NewServer(jsonrpc.WithServerErrors(api.RPCErrors), readerServerOpt)
diff --git a/cmd/lotus/daemon.go b/cmd/lotus/daemon.go
index 7271a6e53..5d8096d1f 100644
--- a/cmd/lotus/daemon.go
+++ b/cmd/lotus/daemon.go
@@ -291,10 +291,55 @@ var DaemonCmd = &cli.Command{
 
 		chainfile := cctx.String("import-chain")
 		snapshot := cctx.String("import-snapshot")
+		willImportChain := false
 		if chainfile != "" || snapshot != "" {
 			if chainfile != "" && snapshot != "" {
 				return fmt.Errorf("cannot specify both 'import-snapshot' and 'import-chain'")
 			}
+			willImportChain = true
+		}
+
+		willRemoveChain := cctx.Bool("remove-existing-chain")
+		if willImportChain && !willRemoveChain {
+			// Confirm with the user about the intention to remove chain data.
+			reader := bufio.NewReader(os.Stdin)
+			fmt.Print("Importing chain or snapshot will by default delete existing local chain data. Do you want to proceed and delete? (yes/no): ")
+			userInput, err := reader.ReadString('\n')
+			if err != nil {
+				return xerrors.Errorf("reading user input: %w", err)
+			}
+			userInput = strings.ToLower(strings.TrimSpace(userInput))
+
+			if userInput == "yes" {
+				willRemoveChain = true
+			} else if userInput == "no" {
+				willRemoveChain = false
+			} else {
+				return fmt.Errorf("invalid input. please answer with 'yes' or 'no'")
+			}
+		}
+
+		if willRemoveChain {
+			lr, err := repo.NewFS(cctx.String("repo"))
+			if err != nil {
+				return xerrors.Errorf("error opening fs repo: %w", err)
+			}
+
+			exists, err := lr.Exists()
+			if err != nil {
+				return err
+			}
+			if !exists {
+				return xerrors.Errorf("lotus repo doesn't exist")
+			}
+
+			err = removeExistingChain(cctx, lr)
+			if err != nil {
+				return err
+			}
+		}
+
+		if willImportChain {
 			var issnapshot bool
 			if chainfile == "" {
 				chainfile = snapshot
@@ -540,7 +585,7 @@ func ImportChain(ctx context.Context, r repo.Repo, fname string, snapshot bool)
 	}
 
 	bar.Start()
-	ts, err := cst.Import(ctx, ir)
+	ts, gen, err := cst.Import(ctx, ir)
 	bar.Finish()
 
 	if err != nil {
@@ -551,18 +596,14 @@ func ImportChain(ctx context.Context, r repo.Repo, fname string, snapshot bool)
 		return xerrors.Errorf("flushing validation cache failed: %w", err)
 	}
 
-	gb, err := cst.GetTipsetByHeight(ctx, 0, ts, true)
-	if err != nil {
-		return err
-	}
-
-	err = cst.SetGenesis(ctx, gb.Blocks()[0])
+	log.Infof("setting genesis")
+	err = cst.SetGenesis(ctx, gen)
 	if err != nil {
 		return err
 	}
 
 	if !snapshot {
-		shd, err := drand.BeaconScheduleFromDrandSchedule(build.DrandConfigSchedule(), gb.MinTimestamp(), nil)
+		shd, err := drand.BeaconScheduleFromDrandSchedule(build.DrandConfigSchedule(), gen.Timestamp, nil)
 		if err != nil {
 			return xerrors.Errorf("failed to construct beacon schedule: %w", err)
 		}
diff --git a/documentation/en/api-v0-methods-provider.md b/documentation/en/api-v0-methods-provider.md
new file mode 100644
index 000000000..fc4a2daf7
--- /dev/null
+++ b/documentation/en/api-v0-methods-provider.md
@@ -0,0 +1,25 @@
+# Groups
+* [](#)
+  * [Shutdown](#Shutdown)
+  * [Version](#Version)
+## 
+
+
+### Shutdown
+
+
+Perms: admin
+
+Inputs: `null`
+
+Response: `{}`
+
+### Version
+
+
+Perms: admin
+
+Inputs: `null`
+
+Response: `131840`
+
diff --git a/documentation/en/api-v0-methods.md b/documentation/en/api-v0-methods.md
index 742f3de8e..9110c1c3b 100644
--- a/documentation/en/api-v0-methods.md
+++ b/documentation/en/api-v0-methods.md
@@ -2289,7 +2289,8 @@ Inputs:
   },
   {
     "MaxFee": "0",
-    "MsgUuid": "07070707-0707-0707-0707-070707070707"
+    "MsgUuid": "07070707-0707-0707-0707-070707070707",
+    "MaximizeFeeCap": true
   },
   [
     {
@@ -2766,7 +2767,8 @@ Inputs:
   ],
   {
     "MaxFee": "0",
-    "MsgUuid": "07070707-0707-0707-0707-070707070707"
+    "MsgUuid": "07070707-0707-0707-0707-070707070707",
+    "MaximizeFeeCap": true
   }
 ]
 ```
@@ -3025,7 +3027,8 @@ Inputs:
   },
   {
     "MaxFee": "0",
-    "MsgUuid": "07070707-0707-0707-0707-070707070707"
+    "MsgUuid": "07070707-0707-0707-0707-070707070707",
+    "MaximizeFeeCap": true
   }
 ]
 ```
diff --git a/documentation/en/api-v1-unstable-methods.md b/documentation/en/api-v1-unstable-methods.md
index e2c249395..c2929f0f5 100644
--- a/documentation/en/api-v1-unstable-methods.md
+++ b/documentation/en/api-v1-unstable-methods.md
@@ -2402,14 +2402,7 @@ Perms: read
 Inputs:
 ```json
 [
-  {
-    "from": "0x5cbeecf99d3fdb3f25e309cc264f240bb0664031",
-    "to": "0x5cbeecf99d3fdb3f25e309cc264f240bb0664031",
-    "gas": "0x5",
-    "gasPrice": "0x0",
-    "value": "0x0",
-    "data": "0x07"
-  }
+  "Bw=="
 ]
 ```
 
@@ -3357,7 +3350,8 @@ Inputs:
   },
   {
     "MaxFee": "0",
-    "MsgUuid": "07070707-0707-0707-0707-070707070707"
+    "MsgUuid": "07070707-0707-0707-0707-070707070707",
+    "MaximizeFeeCap": true
   },
   [
     {
@@ -3834,7 +3828,8 @@ Inputs:
   ],
   {
     "MaxFee": "0",
-    "MsgUuid": "07070707-0707-0707-0707-070707070707"
+    "MsgUuid": "07070707-0707-0707-0707-070707070707",
+    "MaximizeFeeCap": true
   }
 ]
 ```
@@ -4226,7 +4221,8 @@ Inputs:
   },
   {
     "MaxFee": "0",
-    "MsgUuid": "07070707-0707-0707-0707-070707070707"
+    "MsgUuid": "07070707-0707-0707-0707-070707070707",
+    "MaximizeFeeCap": true
   }
 ]
 ```
diff --git a/documentation/en/block-validation.md b/documentation/en/block-validation.md
index d178a0667..ac711c6bf 100644
--- a/documentation/en/block-validation.md
+++ b/documentation/en/block-validation.md
@@ -104,9 +104,9 @@ domain separation tag.
 ### Winning PoSt proof
 
 Draw randomness for current epoch with `WinningPoSt` domain separation tag.
-Get list of sectors challanged in this epoch for this miner, based on the randomness drawn. 
+Get list of sectors challenged in this epoch for this miner, based on the randomness drawn. 
 
-`V`: Use filecoin proofs system to verify that miner prooved access to sealed versions of these sectors.
+`V`: Use filecoin proofs system to verify that miner proved access to sealed versions of these sectors.
 
 ## `(*StateManager).TipSetState()`
 
diff --git a/documentation/en/cli-lotus-miner.md b/documentation/en/cli-lotus-miner.md
index 6693d2a79..7f1c0a01a 100644
--- a/documentation/en/cli-lotus-miner.md
+++ b/documentation/en/cli-lotus-miner.md
@@ -7,7 +7,7 @@ USAGE:
    lotus-miner [global options] command [command options] [arguments...]
 
 VERSION:
-   1.25.1
+   1.25.2
 
 COMMANDS:
    init     Initialize a lotus miner repo
@@ -231,8 +231,19 @@ OPTIONS:
    --help, -h  show help
 ```
 
-#### lotus-miner actor set-addresses, set-addrs
+### lotus-miner actor set-addresses
 ```
+NAME:
+   lotus-miner actor set-addresses - set addresses that your miner can be publicly dialed on
+
+USAGE:
+   lotus-miner actor set-addresses [command options] <multiaddrs>
+
+OPTIONS:
+   --from value       optionally specify the account to send the message from
+   --gas-limit value  set gas limit (default: 0)
+   --unset            unset address (default: false)
+   --help, -h         show help
 ```
 
 ### lotus-miner actor withdraw
@@ -1161,8 +1172,20 @@ OPTIONS:
    --help, -h  show help
 ```
 
-##### lotus-miner proving compute windowed-post, window-post
+#### lotus-miner proving compute windowed-post
 ```
+NAME:
+   lotus-miner proving compute windowed-post - Compute WindowPoSt for a specific deadline
+
+USAGE:
+   lotus-miner proving compute windowed-post [command options] [deadline index]
+
+DESCRIPTION:
+   Note: This command is intended to be used to verify PoSt compute performance.
+   It will not send any messages to the chain.
+
+OPTIONS:
+   --help, -h  show help
 ```
 
 ### lotus-miner proving recover-faults
diff --git a/documentation/en/cli-lotus-provider.md b/documentation/en/cli-lotus-provider.md
new file mode 100644
index 000000000..932350fe2
--- /dev/null
+++ b/documentation/en/cli-lotus-provider.md
@@ -0,0 +1,410 @@
+# lotus-provider
+```
+NAME:
+   lotus-provider - Filecoin decentralized storage network provider
+
+USAGE:
+   lotus-provider [global options] command [command options] [arguments...]
+
+VERSION:
+   1.25.2
+
+COMMANDS:
+   run      Start a lotus provider process
+   stop     Stop a running lotus provider
+   config   Manage node config by layers. The layer 'base' will always be applied. 
+   test     Utility functions for testing
+   version  Print version
+   help, h  Shows a list of commands or help for one command
+   DEVELOPER:
+     auth          Manage RPC permissions
+     log           Manage logging
+     wait-api      Wait for lotus api to come online
+     fetch-params  Fetch proving parameters
+
+GLOBAL OPTIONS:
+   --color              use color in display output (default: depends on output being a TTY)
+   --db-host value      Command separated list of hostnames for yugabyte cluster (default: "yugabyte") [$LOTUS_DB_HOST]
+   --db-name value      (default: "yugabyte") [$LOTUS_DB_NAME, $LOTUS_HARMONYDB_HOSTS]
+   --db-user value      (default: "yugabyte") [$LOTUS_DB_USER, $LOTUS_HARMONYDB_USERNAME]
+   --db-password value  (default: "yugabyte") [$LOTUS_DB_PASSWORD, $LOTUS_HARMONYDB_PASSWORD]
+   --layers value       (default: "base") [$LOTUS_LAYERS, $LOTUS_CONFIG_LAYERS]
+   --repo-path value    (default: "~/.lotusprovider") [$LOTUS_REPO_PATH]
+   --vv                 enables very verbose mode, useful for debugging the CLI (default: false)
+   --help, -h           show help
+   --version, -v        print the version
+```
+
+## lotus-provider run
+```
+NAME:
+   lotus-provider run - Start a lotus provider process
+
+USAGE:
+   lotus-provider run [command options] [arguments...]
+
+OPTIONS:
+   --listen value                     host address and port the worker api will listen on (default: "0.0.0.0:12300") [$LOTUS_WORKER_LISTEN]
+   --nosync                           don't check full-node sync status (default: false)
+   --manage-fdlimit                   manage open file limit (default: true)
+   --layers value [ --layers value ]  list of layers to be interpreted (atop defaults). Default: base (default: "base")
+   --storage-json value               path to json file containing storage config (default: "~/.lotus-provider/storage.json")
+   --journal value                    path to journal files (default: "~/.lotus-provider/")
+   --help, -h                         show help
+```
+
+## lotus-provider stop
+```
+NAME:
+   lotus-provider stop - Stop a running lotus provider
+
+USAGE:
+   lotus-provider stop [command options] [arguments...]
+
+OPTIONS:
+   --help, -h  show help
+```
+
+## lotus-provider config
+```
+NAME:
+   lotus-provider config - Manage node config by layers. The layer 'base' will always be applied. 
+
+USAGE:
+   lotus-provider config command [command options] [arguments...]
+
+COMMANDS:
+   default, defaults                Print default node config
+   set, add, update, create         Set a config layer or the base by providing a filename or stdin.
+   get, cat, show                   Get a config layer by name. You may want to pipe the output to a file, or use 'less'
+   list, ls                         List config layers you can get.
+   interpret, view, stacked, stack  Interpret stacked config layers by this version of lotus-provider, with system-generated comments.
+   remove, rm, del, delete          Remove a named config layer.
+   from-miner                       Express a database config (for lotus-provider) from an existing miner.
+   help, h                          Shows a list of commands or help for one command
+
+OPTIONS:
+   --help, -h  show help
+```
+
+### lotus-provider config default
+```
+NAME:
+   lotus-provider config default - Print default node config
+
+USAGE:
+   lotus-provider config default [command options] [arguments...]
+
+OPTIONS:
+   --no-comment  don't comment default values (default: false)
+   --help, -h    show help
+```
+
+### lotus-provider config set
+```
+NAME:
+   lotus-provider config set - Set a config layer or the base by providing a filename or stdin.
+
+USAGE:
+   lotus-provider config set [command options] a layer's file name
+
+OPTIONS:
+   --title value  title of the config layer (req'd for stdin)
+   --help, -h     show help
+```
+
+### lotus-provider config get
+```
+NAME:
+   lotus-provider config get - Get a config layer by name. You may want to pipe the output to a file, or use 'less'
+
+USAGE:
+   lotus-provider config get [command options] layer name
+
+OPTIONS:
+   --help, -h  show help
+```
+
+### lotus-provider config list
+```
+NAME:
+   lotus-provider config list - List config layers you can get.
+
+USAGE:
+   lotus-provider config list [command options] [arguments...]
+
+OPTIONS:
+   --help, -h  show help
+```
+
+### lotus-provider config interpret
+```
+NAME:
+   lotus-provider config interpret - Interpret stacked config layers by this version of lotus-provider, with system-generated comments.
+
+USAGE:
+   lotus-provider config interpret [command options] a list of layers to be interpreted as the final config
+
+OPTIONS:
+   --layers value [ --layers value ]  comma or space separated list of layers to be interpreted (default: "base")
+   --help, -h                         show help
+```
+
+### lotus-provider config remove
+```
+NAME:
+   lotus-provider config remove - Remove a named config layer.
+
+USAGE:
+   lotus-provider config remove [command options] [arguments...]
+
+OPTIONS:
+   --help, -h  show help
+```
+
+### lotus-provider config from-miner
+```
+NAME:
+   lotus-provider config from-miner - Express a database config (for lotus-provider) from an existing miner.
+
+USAGE:
+   lotus-provider config from-miner [command options] [arguments...]
+
+DESCRIPTION:
+   Express a database config (for lotus-provider) from an existing miner.
+
+OPTIONS:
+   --miner-repo value, --storagerepo value  Specify miner repo path. flag(storagerepo) and env(LOTUS_STORAGE_PATH) are DEPRECATION, will REMOVE SOON (default: "~/.lotusminer") [$LOTUS_MINER_PATH, $LOTUS_STORAGE_PATH]
+   --to-layer value, -t value               The layer name for this data push. 'base' is recommended for single-miner setup.
+   --overwrite, -o                          Use this with --to-layer to replace an existing layer (default: false)
+   --help, -h                               show help
+```
+
+## lotus-provider test
+```
+NAME:
+   lotus-provider test - Utility functions for testing
+
+USAGE:
+   lotus-provider test command [command options] [arguments...]
+
+COMMANDS:
+   window-post, wd, windowpost, wdpost  Compute a proof-of-spacetime for a sector (requires the sector to be pre-sealed). These will not send to the chain.
+   help, h                              Shows a list of commands or help for one command
+
+OPTIONS:
+   --help, -h  show help
+```
+
+### lotus-provider test window-post
+```
+NAME:
+   lotus-provider test window-post - Compute a proof-of-spacetime for a sector (requires the sector to be pre-sealed). These will not send to the chain.
+
+USAGE:
+   lotus-provider test window-post command [command options] [arguments...]
+
+COMMANDS:
+   here, cli                                       Compute WindowPoSt for performance and configuration testing.
+   task, scheduled, schedule, async, asynchronous  Test the windowpost scheduler by running it on the next available lotus-provider. 
+   help, h                                         Shows a list of commands or help for one command
+
+OPTIONS:
+   --help, -h  show help
+```
+
+#### lotus-provider test window-post here
+```
+NAME:
+   lotus-provider test window-post here - Compute WindowPoSt for performance and configuration testing.
+
+USAGE:
+   lotus-provider test window-post here [command options] [deadline index]
+
+DESCRIPTION:
+   Note: This command is intended to be used to verify PoSt compute performance.
+   It will not send any messages to the chain. Since it can compute any deadline, output may be incorrectly timed for the chain.
+
+OPTIONS:
+   --deadline value                   deadline to compute WindowPoSt for  (default: 0)
+   --layers value [ --layers value ]  list of layers to be interpreted (atop defaults). Default: base (default: "base")
+   --storage-json value               path to json file containing storage config (default: "~/.lotus-provider/storage.json")
+   --partition value                  partition to compute WindowPoSt for (default: 0)
+   --help, -h                         show help
+```
+
+#### lotus-provider test window-post task
+```
+NAME:
+   lotus-provider test window-post task - Test the windowpost scheduler by running it on the next available lotus-provider. 
+
+USAGE:
+   lotus-provider test window-post task [command options] [arguments...]
+
+OPTIONS:
+   --deadline value                   deadline to compute WindowPoSt for  (default: 0)
+   --layers value [ --layers value ]  list of layers to be interpreted (atop defaults). Default: base (default: "base")
+   --help, -h                         show help
+```
+
+## lotus-provider version
+```
+NAME:
+   lotus-provider version - Print version
+
+USAGE:
+   lotus-provider version [command options] [arguments...]
+
+OPTIONS:
+   --help, -h  show help
+```
+
+## lotus-provider auth
+```
+NAME:
+   lotus-provider auth - Manage RPC permissions
+
+USAGE:
+   lotus-provider auth command [command options] [arguments...]
+
+COMMANDS:
+   create-token  Create token
+   api-info      Get token with API info required to connect to this node
+   help, h       Shows a list of commands or help for one command
+
+OPTIONS:
+   --help, -h  show help
+```
+
+### lotus-provider auth create-token
+```
+NAME:
+   lotus-provider auth create-token - Create token
+
+USAGE:
+   lotus-provider auth create-token [command options] [arguments...]
+
+OPTIONS:
+   --perm value  permission to assign to the token, one of: read, write, sign, admin
+   --help, -h    show help
+```
+
+### lotus-provider auth api-info
+```
+NAME:
+   lotus-provider auth api-info - Get token with API info required to connect to this node
+
+USAGE:
+   lotus-provider auth api-info [command options] [arguments...]
+
+OPTIONS:
+   --perm value  permission to assign to the token, one of: read, write, sign, admin
+   --help, -h    show help
+```
+
+## lotus-provider log
+```
+NAME:
+   lotus-provider log - Manage logging
+
+USAGE:
+   lotus-provider log command [command options] [arguments...]
+
+COMMANDS:
+   list       List log systems
+   set-level  Set log level
+   alerts     Get alert states
+   help, h    Shows a list of commands or help for one command
+
+OPTIONS:
+   --help, -h  show help
+```
+
+### lotus-provider log list
+```
+NAME:
+   lotus-provider log list - List log systems
+
+USAGE:
+   lotus-provider log list [command options] [arguments...]
+
+OPTIONS:
+   --help, -h  show help
+```
+
+### lotus-provider log set-level
+```
+NAME:
+   lotus-provider log set-level - Set log level
+
+USAGE:
+   lotus-provider log set-level [command options] [level]
+
+DESCRIPTION:
+   Set the log level for logging systems:
+
+      The system flag can be specified multiple times.
+
+      eg) log set-level --system chain --system chainxchg debug
+
+      Available Levels:
+      debug
+      info
+      warn
+      error
+
+      Environment Variables:
+      GOLOG_LOG_LEVEL - Default log level for all log systems
+      GOLOG_LOG_FMT   - Change output log format (json, nocolor)
+      GOLOG_FILE      - Write logs to file
+      GOLOG_OUTPUT    - Specify whether to output to file, stderr, stdout or a combination, i.e. file+stderr
+
+
+OPTIONS:
+   --system value [ --system value ]  limit to log system
+   --help, -h                         show help
+```
+
+### lotus-provider log alerts
+```
+NAME:
+   lotus-provider log alerts - Get alert states
+
+USAGE:
+   lotus-provider log alerts [command options] [arguments...]
+
+OPTIONS:
+   --all       get all (active and inactive) alerts (default: false)
+   --help, -h  show help
+```
+
+## lotus-provider wait-api
+```
+NAME:
+   lotus-provider wait-api - Wait for lotus api to come online
+
+USAGE:
+   lotus-provider wait-api [command options] [arguments...]
+
+CATEGORY:
+   DEVELOPER
+
+OPTIONS:
+   --timeout value  duration to wait till fail (default: 30s)
+   --help, -h       show help
+```
+
+## lotus-provider fetch-params
+```
+NAME:
+   lotus-provider fetch-params - Fetch proving parameters
+
+USAGE:
+   lotus-provider fetch-params [command options] [sectorSize]
+
+CATEGORY:
+   DEVELOPER
+
+OPTIONS:
+   --help, -h  show help
+```
diff --git a/documentation/en/cli-lotus-worker.md b/documentation/en/cli-lotus-worker.md
index 733723bad..1da1165cf 100644
--- a/documentation/en/cli-lotus-worker.md
+++ b/documentation/en/cli-lotus-worker.md
@@ -7,7 +7,7 @@ USAGE:
    lotus-worker [global options] command [command options] [arguments...]
 
 VERSION:
-   1.25.1
+   1.25.2
 
 COMMANDS:
    run        Start lotus worker
@@ -34,6 +34,33 @@ NAME:
 USAGE:
    lotus-worker run [command options] [arguments...]
 
+DESCRIPTION:
+   Run lotus-worker.
+
+   --external-pc2 can be used to compute the PreCommit2 inputs externally.
+   The flag behaves similarly to the related lotus-worker flag, using it in
+   lotus-bench may be useful for testing if the external PreCommit2 command is
+   invoked correctly.
+
+   The command will be called with a number of environment variables set:
+   * EXTSEAL_PC2_SECTOR_NUM: the sector number
+   * EXTSEAL_PC2_SECTOR_MINER: the miner id
+   * EXTSEAL_PC2_PROOF_TYPE: the proof type
+   * EXTSEAL_PC2_SECTOR_SIZE: the sector size in bytes
+   * EXTSEAL_PC2_CACHE: the path to the cache directory
+   * EXTSEAL_PC2_SEALED: the path to the sealed sector file (initialized with unsealed data by the caller)
+   * EXTSEAL_PC2_PC1OUT: output from rust-fil-proofs precommit1 phase (base64 encoded json)
+
+   The command is expected to:
+   * Create cache sc-02-data-tree-r* files
+   * Create cache sc-02-data-tree-c* files
+   * Create cache p_aux / t_aux files
+   * Transform the sealed file in place
+
+   Example invocation of lotus-bench as external executor:
+   './lotus-bench simple precommit2 --sector-size $EXTSEAL_PC2_SECTOR_SIZE $EXTSEAL_PC2_SEALED $EXTSEAL_PC2_CACHE $EXTSEAL_PC2_PC1OUT'
+
+
 OPTIONS:
    --listen value                host address and port the worker api will listen on (default: "0.0.0.0:3456") [$LOTUS_WORKER_LISTEN]
    --no-local-storage            don't use storageminer repo for sector storage (default: false) [$LOTUS_WORKER_NO_LOCAL_STORAGE]
@@ -57,6 +84,7 @@ OPTIONS:
    --timeout value               used when 'listen' is unspecified. must be a valid duration recognized by golang's time.ParseDuration function (default: "30m") [$LOTUS_WORKER_TIMEOUT]
    --http-server-timeout value   (default: "30s")
    --data-cid                    Run the data-cid task. true|false (default: inherits --addpiece)
+   --external-pc2 value          command for computing PC2 externally
    --help, -h                    show help
 ```
 
diff --git a/documentation/en/cli-lotus.md b/documentation/en/cli-lotus.md
index c7a2cb09a..5e451dcad 100644
--- a/documentation/en/cli-lotus.md
+++ b/documentation/en/cli-lotus.md
@@ -7,7 +7,7 @@ USAGE:
    lotus [global options] command [command options] [arguments...]
 
 VERSION:
-   1.25.1
+   1.25.2
 
 COMMANDS:
    daemon   Start a lotus daemon process
@@ -1807,8 +1807,16 @@ OPTIONS:
    --help, -h   show help
 ```
 
-#### lotus state sector, sector-info
+### lotus state sector
 ```
+NAME:
+   lotus state sector - Get miner sector info
+
+USAGE:
+   lotus state sector [command options] [minerAddress] [sectorNumber]
+
+OPTIONS:
+   --help, -h  show help
 ```
 
 ### lotus state get-actor
@@ -1937,12 +1945,29 @@ OPTIONS:
    --help, -h  show help
 ```
 
-#### lotus state wait-msg, wait-message
+### lotus state wait-msg
 ```
+NAME:
+   lotus state wait-msg - Wait for a message to appear on chain
+
+USAGE:
+   lotus state wait-msg [command options] [messageCid]
+
+OPTIONS:
+   --timeout value  (default: "10m")
+   --help, -h       show help
 ```
 
-#### lotus state search-msg, search-message
+### lotus state search-msg
 ```
+NAME:
+   lotus state search-msg - Search to see whether a message has appeared on chain
+
+USAGE:
+   lotus state search-msg [command options] [messageCid]
+
+OPTIONS:
+   --help, -h  show help
 ```
 
 ### lotus state miner-info
@@ -2080,8 +2105,17 @@ OPTIONS:
    --help, -h  show help
 ```
 
-#### lotus chain get-block, getblock
+### lotus chain get-block
 ```
+NAME:
+   lotus chain get-block - Get a block and print its details
+
+USAGE:
+   lotus chain get-block [command options] [blockCid]
+
+OPTIONS:
+   --raw       print just the raw block header (default: false)
+   --help, -h  show help
 ```
 
 ### lotus chain read-obj
@@ -2132,16 +2166,46 @@ OPTIONS:
    --help, -h    show help
 ```
 
-##### lotus chain getmessage, get-message, get-msg
+### lotus chain getmessage
 ```
+NAME:
+   lotus chain getmessage - Get and print a message by its cid
+
+USAGE:
+   lotus chain getmessage [command options] [messageCid]
+
+OPTIONS:
+   --help, -h  show help
 ```
 
-#### lotus chain sethead, set-head
+### lotus chain sethead
 ```
+NAME:
+   lotus chain sethead - manually set the local nodes head tipset (Caution: normally only used for recovery)
+
+USAGE:
+   lotus chain sethead [command options] [tipsetkey]
+
+OPTIONS:
+   --genesis      reset head to genesis (default: false)
+   --epoch value  reset head to given epoch (default: 0)
+   --help, -h     show help
 ```
 
-#### lotus chain list, love
+### lotus chain list
 ```
+NAME:
+   lotus chain list - View a segment of the chain
+
+USAGE:
+   lotus chain list [command options] [arguments...]
+
+OPTIONS:
+   --height value  (default: current head)
+   --count value   (default: 30)
+   --format value  specify the format to print out tipsets (default: "<height>: (<time>) <blocks>")
+   --gas-stats     view gas statistics for the chain (default: false)
+   --help, -h      show help
 ```
 
 ### lotus chain get
@@ -2768,8 +2832,16 @@ OPTIONS:
    --help, -h  show help
 ```
 
-#### lotus net find-peer, findpeer
+### lotus net find-peer
 ```
+NAME:
+   lotus net find-peer - Find the addresses of a given peerID
+
+USAGE:
+   lotus net find-peer [command options] [peerId]
+
+OPTIONS:
+   --help, -h  show help
 ```
 
 ### lotus net scores
diff --git a/documentation/en/default-lotus-config.toml b/documentation/en/default-lotus-config.toml
index c37e40f74..1f143b896 100644
--- a/documentation/en/default-lotus-config.toml
+++ b/documentation/en/default-lotus-config.toml
@@ -195,7 +195,7 @@
 
   [Chainstore.Splitstore]
     # ColdStoreType specifies the type of the coldstore.
-    # It can be "messages" (default) to store only messages, "universal" to store all chain state or "discard" for discarding cold blocks.
+    # It can be "discard" (default) for discarding cold blocks, "messages" to store only messages or "universal" to store all chain state..
     #
     # type: string
     # env var: LOTUS_CHAINSTORE_SPLITSTORE_COLDSTORETYPE
diff --git a/documentation/en/default-lotus-miner-config.toml b/documentation/en/default-lotus-miner-config.toml
index ff1ede453..a65e82e95 100644
--- a/documentation/en/default-lotus-miner-config.toml
+++ b/documentation/en/default-lotus-miner-config.toml
@@ -145,6 +145,14 @@
   # env var: LOTUS_SUBSYSTEMS_ENABLEMARKETS
   #EnableMarkets = false
 
+  # When enabled, the sector index will reside in an external database
+  # as opposed to the local KV store in the miner process
+  # This is useful to allow workers to bypass the lotus miner to access sector information
+  #
+  # type: bool
+  # env var: LOTUS_SUBSYSTEMS_ENABLESECTORINDEXDB
+  #EnableSectorIndexDB = false
+
   # type: string
   # env var: LOTUS_SUBSYSTEMS_SEALERAPIINFO
   #SealerApiInfo = ""
@@ -153,6 +161,31 @@
   # env var: LOTUS_SUBSYSTEMS_SECTORINDEXAPIINFO
   #SectorIndexApiInfo = ""
 
+  # When window post is enabled, the miner will automatically submit window post proofs
+  # for all sectors that are eligible for window post
+  # IF WINDOW POST IS DISABLED, THE MINER WILL NOT SUBMIT WINDOW POST PROOFS
+  # THIS WILL RESULT IN FAULTS AND PENALTIES IF NO OTHER MECHANISM IS RUNNING
+  # TO SUBMIT WINDOW POST PROOFS.
+  # Note: This option is entirely disabling the window post scheduler,
+  # not just the builtin PoSt computation like Proving.DisableBuiltinWindowPoSt.
+  # This option will stop lotus-miner from performing any actions related
+  # to window post, including scheduling, submitting proofs, and recovering
+  # sectors.
+  #
+  # type: bool
+  # env var: LOTUS_SUBSYSTEMS_DISABLEWINDOWPOST
+  #DisableWindowPoSt = false
+
+  # When winning post is disabled, the miner process will NOT attempt to mine
+  # blocks. This should only be set when there's an external process mining
+  # blocks on behalf of the miner.
+  # When disabled and no external block producers are configured, all potential
+  # block rewards will be missed!
+  #
+  # type: bool
+  # env var: LOTUS_SUBSYSTEMS_DISABLEWINNINGPOST
+  #DisableWinningPoSt = false
+
 
 [Dealmaking]
   # When enabled, the miner can accept online deals
@@ -778,6 +811,10 @@
   # env var: LOTUS_FEES_MAXMARKETBALANCEADDFEE
   #MaxMarketBalanceAddFee = "0.007 FIL"
 
+  # type: bool
+  # env var: LOTUS_FEES_MAXIMIZEWINDOWPOSTFEECAP
+  #MaximizeWindowPoStFeeCap = true
+
   [Fees.MaxPreCommitBatchGasFee]
     # type: types.FIL
     # env var: LOTUS_FEES_MAXPRECOMMITBATCHGASFEE_BASE
@@ -892,3 +929,36 @@
   #GCInterval = "1m0s"
 
 
+[HarmonyDB]
+  # HOSTS is a list of hostnames to nodes running YugabyteDB
+  # in a cluster. Only 1 is required
+  #
+  # type: []string
+  # env var: LOTUS_HARMONYDB_HOSTS
+  #Hosts = ["127.0.0.1"]
+
+  # The Yugabyte server's username with full credentials to operate on Lotus' Database. Blank for default.
+  #
+  # type: string
+  # env var: LOTUS_HARMONYDB_USERNAME
+  #Username = "yugabyte"
+
+  # The password for the related username. Blank for default.
+  #
+  # type: string
+  # env var: LOTUS_HARMONYDB_PASSWORD
+  #Password = "yugabyte"
+
+  # The database (logical partition) within Yugabyte. Blank for default.
+  #
+  # type: string
+  # env var: LOTUS_HARMONYDB_DATABASE
+  #Database = "yugabyte"
+
+  # The port to find Yugabyte. Blank for default.
+  #
+  # type: string
+  # env var: LOTUS_HARMONYDB_PORT
+  #Port = "5433"
+
+
diff --git a/documentation/en/default-lotus-provider-config.toml b/documentation/en/default-lotus-provider-config.toml
new file mode 100644
index 000000000..91606e503
--- /dev/null
+++ b/documentation/en/default-lotus-provider-config.toml
@@ -0,0 +1,209 @@
+[Subsystems]
+  # type: bool
+  #EnableWindowPost = false
+
+  # type: int
+  #WindowPostMaxTasks = 0
+
+  # type: bool
+  #EnableWinningPost = false
+
+  # type: int
+  #WinningPostMaxTasks = 0
+
+
+[Fees]
+  # type: types.FIL
+  #DefaultMaxFee = "0.07 FIL"
+
+  # type: types.FIL
+  #MaxPreCommitGasFee = "0.025 FIL"
+
+  # type: types.FIL
+  #MaxCommitGasFee = "0.05 FIL"
+
+  # type: types.FIL
+  #MaxTerminateGasFee = "0.5 FIL"
+
+  # WindowPoSt is a high-value operation, so the default fee should be high.
+  #
+  # type: types.FIL
+  #MaxWindowPoStGasFee = "5 FIL"
+
+  # type: types.FIL
+  #MaxPublishDealsFee = "0.05 FIL"
+
+  [Fees.MaxPreCommitBatchGasFee]
+    # type: types.FIL
+    #Base = "0 FIL"
+
+    # type: types.FIL
+    #PerSector = "0.02 FIL"
+
+  [Fees.MaxCommitBatchGasFee]
+    # type: types.FIL
+    #Base = "0 FIL"
+
+    # type: types.FIL
+    #PerSector = "0.03 FIL"
+
+
+[Addresses]
+  # Addresses to send PreCommit messages from
+  #
+  # type: []string
+  #PreCommitControl = []
+
+  # Addresses to send Commit messages from
+  #
+  # type: []string
+  #CommitControl = []
+
+  # type: []string
+  #TerminateControl = []
+
+  # DisableOwnerFallback disables usage of the owner address for messages
+  # sent automatically
+  #
+  # type: bool
+  #DisableOwnerFallback = false
+
+  # DisableWorkerFallback disables usage of the worker address for messages
+  # sent automatically, if control addresses are configured.
+  # A control address that doesn't have enough funds will still be chosen
+  # over the worker address if this flag is set.
+  #
+  # type: bool
+  #DisableWorkerFallback = false
+
+
+[Proving]
+  # Maximum number of sector checks to run in parallel. (0 = unlimited)
+  # 
+  # WARNING: Setting this value too high may make the node crash by running out of stack
+  # WARNING: Setting this value too low may make sector challenge reading much slower, resulting in failed PoSt due
+  # to late submission.
+  # 
+  # After changing this option, confirm that the new value works in your setup by invoking
+  # 'lotus-miner proving compute window-post 0'
+  #
+  # type: int
+  #ParallelCheckLimit = 32
+
+  # Maximum amount of time a proving pre-check can take for a sector. If the check times out the sector will be skipped
+  # 
+  # WARNING: Setting this value too low risks in sectors being skipped even though they are accessible, just reading the
+  # test challenge took longer than this timeout
+  # WARNING: Setting this value too high risks missing PoSt deadline in case IO operations related to this sector are
+  # blocked (e.g. in case of disconnected NFS mount)
+  #
+  # type: Duration
+  #SingleCheckTimeout = "10m0s"
+
+  # Maximum amount of time a proving pre-check can take for an entire partition. If the check times out, sectors in
+  # the partition which didn't get checked on time will be skipped
+  # 
+  # WARNING: Setting this value too low risks in sectors being skipped even though they are accessible, just reading the
+  # test challenge took longer than this timeout
+  # WARNING: Setting this value too high risks missing PoSt deadline in case IO operations related to this partition are
+  # blocked or slow
+  #
+  # type: Duration
+  #PartitionCheckTimeout = "20m0s"
+
+  # Disable Window PoSt computation on the lotus-miner process even if no window PoSt workers are present.
+  # 
+  # WARNING: If no windowPoSt workers are connected, window PoSt WILL FAIL resulting in faulty sectors which will need
+  # to be recovered. Before enabling this option, make sure your PoSt workers work correctly.
+  # 
+  # After changing this option, confirm that the new value works in your setup by invoking
+  # 'lotus-miner proving compute window-post 0'
+  #
+  # type: bool
+  #DisableBuiltinWindowPoSt = false
+
+  # Disable Winning PoSt computation on the lotus-miner process even if no winning PoSt workers are present.
+  # 
+  # WARNING: If no WinningPoSt workers are connected, Winning PoSt WILL FAIL resulting in lost block rewards.
+  # Before enabling this option, make sure your PoSt workers work correctly.
+  #
+  # type: bool
+  #DisableBuiltinWinningPoSt = false
+
+  # Disable WindowPoSt provable sector readability checks.
+  # 
+  # In normal operation, when preparing to compute WindowPoSt, lotus-miner will perform a round of reading challenges
+  # from all sectors to confirm that those sectors can be proven. Challenges read in this process are discarded, as
+  # we're only interested in checking that sector data can be read.
+  # 
+  # When using builtin proof computation (no PoSt workers, and DisableBuiltinWindowPoSt is set to false), this process
+  # can save a lot of time and compute resources in the case that some sectors are not readable - this is caused by
+  # the builtin logic not skipping snark computation when some sectors need to be skipped.
+  # 
+  # When using PoSt workers, this process is mostly redundant, with PoSt workers challenges will be read once, and
+  # if challenges for some sectors aren't readable, those sectors will just get skipped.
+  # 
+  # Disabling sector pre-checks will slightly reduce IO load when proving sectors, possibly resulting in shorter
+  # time to produce window PoSt. In setups with good IO capabilities the effect of this option on proving time should
+  # be negligible.
+  # 
+  # NOTE: It likely is a bad idea to disable sector pre-checks in setups with no PoSt workers.
+  # 
+  # NOTE: Even when this option is enabled, recovering sectors will be checked before recovery declaration message is
+  # sent to the chain
+  # 
+  # After changing this option, confirm that the new value works in your setup by invoking
+  # 'lotus-miner proving compute window-post 0'
+  #
+  # type: bool
+  #DisableWDPoStPreChecks = false
+
+  # Maximum number of partitions to prove in a single SubmitWindowPoSt messace. 0 = network limit (3 in nv21)
+  # 
+  # A single partition may contain up to 2349 32GiB sectors, or 2300 64GiB sectors.
+  # //
+  # Note that setting this value lower may result in less efficient gas use - more messages will be sent,
+  # to prove each deadline, resulting in more total gas use (but each message will have lower gas limit)
+  # 
+  # Setting this value above the network limit has no effect
+  #
+  # type: int
+  #MaxPartitionsPerPoStMessage = 0
+
+  # In some cases when submitting DeclareFaultsRecovered messages,
+  # there may be too many recoveries to fit in a BlockGasLimit.
+  # In those cases it may be necessary to set this value to something low (eg 1);
+  # Note that setting this value lower may result in less efficient gas use - more messages will be sent than needed,
+  # resulting in more total gas use (but each message will have lower gas limit)
+  #
+  # type: int
+  #MaxPartitionsPerRecoveryMessage = 0
+
+  # Enable single partition per PoSt Message for partitions containing recovery sectors
+  # 
+  # In cases when submitting PoSt messages which contain recovering sectors, the default network limit may still be
+  # too high to fit in the block gas limit. In those cases, it becomes useful to only house the single partition
+  # with recovering sectors in the post message
+  # 
+  # Note that setting this value lower may result in less efficient gas use - more messages will be sent,
+  # to prove each deadline, resulting in more total gas use (but each message will have lower gas limit)
+  #
+  # type: bool
+  #SingleRecoveringPartitionPerPostMessage = false
+
+
+[Journal]
+  # Events of the form: "system1:event1,system1:event2[,...]"
+  #
+  # type: string
+  #DisabledEvents = ""
+
+
+[Apis]
+  # RPC Secret for the storage subsystem.
+  # If integrating with lotus-miner this must match the value from
+  # cat ~/.lotusminer/keystore/MF2XI2BNNJ3XILLQOJUXMYLUMU | jq -r .PrivateKey
+  #
+  # type: string
+  #StorageRPCSecret = ""
+
diff --git a/documentation/misc/RELEASE_ISSUE_TEMPLATE.md b/documentation/misc/RELEASE_ISSUE_TEMPLATE.md
index 116c615d3..42f44b955 100644
--- a/documentation/misc/RELEASE_ISSUE_TEMPLATE.md
+++ b/documentation/misc/RELEASE_ISSUE_TEMPLATE.md
@@ -14,11 +14,13 @@
 **Note for whoever is owning the release:** please capture notes as comments in this issue for anything you noticed that could be improved for future releases.  There is a *Post Release* step below for incorporating changes back into the [RELEASE_ISSUE_TEMPLATE](https://github.com/filecoin-project/lotus/blob/master/documentation/misc/RELEASE_ISSUE_TEMPLATE.md), and this is easier done by collecting notes from along the way rather than just thinking about it at the end.
 
 First steps:
-  - [ ] FFI: Fork a new branch (`release/lotus-vX.Y.Z`) from the filecoin-ffi `master` branch
-  - [ ] FFI: Tag the head of `release/lotus-vX.Y.Z` as `vX.Y.Z-pre1`
+  - [ ] Set shell variables vX.Y.Z `export X=1 && export Y=24 && export Z=3`
+  - [ ] FFI: Fork a new branch (`release/lotus-vX.Y.Z`) from the filecoin-ffi `master` branch: `git checkout master && git checkout -b release/lotus-v$X.$Y.$Z`
+  - [ ] FFI: Tag the head of `release/lotus-vX.Y.Z` as `vX.Y.Z-pre1`: `git tag -a v$X.$Y.$Z-pre1 -m"release"`
   - [ ] Open and land a PR in lotus `master` that updates the FFI dependency to `vX.Y.Z-pre1` as cut in the previous step
   - [ ] Fork a new branch (`release/vX.Y.Z`) from `master` and make any further release related changes to this branch. If any "non-trivial" changes get added to the release, uncheck all the checkboxes and return to this stage.
-  - [ ] Bump the version in `build/version.go` in the `master` branch to `vX.Y.(Z+1)-dev` (bump from feature release) or `vX.(Y+1).0-dev` (bump from mandatory release). Run make gen and make docsgen-cli before committing changes
+  - [ ] Bump the version in `build/version.go` in the `master` branch to `vX.Y.(Z+1)-dev` (bump from feature release) or `vX.(Y+1).0-dev` (bump from mandatory release).
+  - [ ] Run `make gen && make docsgen-cli` before committing changes
     
 **Prepping an RC**:
 
@@ -26,6 +28,7 @@ First steps:
 - [ ] run `make gen && make docsgen-cli`
 - [ ] Generate changelog using the script at scripts/mkreleaselog
 - [ ] Add contents of generated text to lotus/CHANGELOG.md in addition to other details
+- [ ] Commit using PR
 - [ ] tag commit with `vX.Y.Z-rcN`
 - [ ] cut a pre-release [here](https://github.com/filecoin-project/lotus/releases/new?prerelease=true)
 
diff --git a/extern/filecoin-ffi b/extern/filecoin-ffi
index 441fa8e61..4176a1e66 160000
--- a/extern/filecoin-ffi
+++ b/extern/filecoin-ffi
@@ -1 +1 @@
-Subproject commit 441fa8e61189dc32c2960c1f8d8ba56269f20366
+Subproject commit 4176a1e662e865834bfdc5861da921dc2d272b45
diff --git a/gateway/node.go b/gateway/node.go
index 367e645c1..f2464d274 100644
--- a/gateway/node.go
+++ b/gateway/node.go
@@ -131,7 +131,7 @@ type TargetAPI interface {
 	EthGasPrice(ctx context.Context) (ethtypes.EthBigInt, error)
 	EthFeeHistory(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthFeeHistory, error)
 	EthMaxPriorityFeePerGas(ctx context.Context) (ethtypes.EthBigInt, error)
-	EthEstimateGas(ctx context.Context, tx ethtypes.EthCall) (ethtypes.EthUint64, error)
+	EthEstimateGas(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthUint64, error)
 	EthCall(ctx context.Context, tx ethtypes.EthCall, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBytes, error)
 	EthSendRawTransaction(ctx context.Context, rawTx ethtypes.EthBytes) (ethtypes.EthHash, error)
 	EthGetLogs(ctx context.Context, filter *ethtypes.EthFilterSpec) (*ethtypes.EthFilterResult, error)
diff --git a/gateway/proxy_eth.go b/gateway/proxy_eth.go
index e6d433a17..13a12acfa 100644
--- a/gateway/proxy_eth.go
+++ b/gateway/proxy_eth.go
@@ -353,13 +353,19 @@ func (gw *Node) EthMaxPriorityFeePerGas(ctx context.Context) (ethtypes.EthBigInt
 	return gw.target.EthMaxPriorityFeePerGas(ctx)
 }
 
-func (gw *Node) EthEstimateGas(ctx context.Context, tx ethtypes.EthCall) (ethtypes.EthUint64, error) {
+func (gw *Node) EthEstimateGas(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthUint64, error) {
+	// validate params
+	_, err := jsonrpc.DecodeParams[ethtypes.EthEstimateGasParams](p)
+	if err != nil {
+		return ethtypes.EthUint64(0), xerrors.Errorf("decoding params: %w", err)
+	}
+
 	if err := gw.limit(ctx, stateRateLimitTokens); err != nil {
 		return 0, err
 	}
 
 	// todo limit gas? to what?
-	return gw.target.EthEstimateGas(ctx, tx)
+	return gw.target.EthEstimateGas(ctx, p)
 }
 
 func (gw *Node) EthCall(ctx context.Context, tx ethtypes.EthCall, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBytes, error) {
diff --git a/go.mod b/go.mod
index 01b9d1586..51ef2d4b0 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
 module github.com/filecoin-project/lotus
 
-go 1.19
+go 1.20
 
 retract v1.14.0 // Accidentally force-pushed tag, use v1.14.1+ instead.
 
@@ -62,6 +62,7 @@ require (
 	github.com/filecoin-project/test-vectors/schema v0.0.7
 	github.com/gbrlsnchs/jwt/v3 v3.0.1
 	github.com/gdamore/tcell/v2 v2.2.0
+	github.com/georgysavva/scany/v2 v2.0.0
 	github.com/go-openapi/spec v0.19.11
 	github.com/golang/mock v1.6.0
 	github.com/google/uuid v1.3.0
@@ -104,10 +105,12 @@ require (
 	github.com/ipld/go-ipld-selector-text-lite v0.0.1
 	github.com/ipni/go-libipni v0.0.8
 	github.com/ipni/index-provider v0.12.0
+	github.com/jackc/pgerrcode v0.0.0-20220416144525-469b46aa5efa
+	github.com/jackc/pgx/v5 v5.4.1
 	github.com/kelseyhightower/envconfig v1.4.0
 	github.com/koalacxr/quantile v0.0.1
 	github.com/libp2p/go-buffer-pool v0.1.0
-	github.com/libp2p/go-libp2p v0.30.0
+	github.com/libp2p/go-libp2p v0.31.1
 	github.com/libp2p/go-libp2p-consensus v0.0.1
 	github.com/libp2p/go-libp2p-gorpc v0.5.0
 	github.com/libp2p/go-libp2p-kad-dht v0.24.0
@@ -122,20 +125,24 @@ require (
 	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/multiformats/go-base32 v0.1.0
-	github.com/multiformats/go-multiaddr v0.11.0
+	github.com/multiformats/go-multiaddr v0.12.1
 	github.com/multiformats/go-multiaddr-dns v0.3.1
 	github.com/multiformats/go-multibase v0.2.0
 	github.com/multiformats/go-multicodec v0.9.0
 	github.com/multiformats/go-multihash v0.2.3
 	github.com/multiformats/go-varint v0.0.7
 	github.com/open-rpc/meta-schema v0.0.0-20201029221707-1b72ef2ea333
+	github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58
+	github.com/pkg/errors v0.9.1
 	github.com/polydawn/refmt v0.89.0
-	github.com/prometheus/client_golang v1.14.0
+	github.com/prometheus/client_golang v1.16.0
 	github.com/puzpuzpuz/xsync/v2 v2.4.0
 	github.com/raulk/clock v1.1.0
 	github.com/raulk/go-watchdog v1.3.0
+	github.com/samber/lo v1.38.1
 	github.com/stretchr/testify v1.8.4
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
+	github.com/triplewz/poseidon v0.0.0-20220525065023-a7cdb0e183e7
 	github.com/urfave/cli/v2 v2.25.5
 	github.com/whyrusleeping/bencher v0.0.0-20190829221104-bb6607aa8bba
 	github.com/whyrusleeping/cbor-gen v0.0.0-20230923211252-36a87e1ba72f
@@ -153,12 +160,12 @@ require (
 	go.uber.org/fx v1.20.0
 	go.uber.org/multierr v1.11.0
 	go.uber.org/zap v1.25.0
-	golang.org/x/crypto v0.12.0
+	golang.org/x/crypto v0.17.0
 	golang.org/x/exp v0.0.0-20230817173708-d852ddb80c63
 	golang.org/x/net v0.14.0
 	golang.org/x/sync v0.3.0
-	golang.org/x/sys v0.11.0
-	golang.org/x/term v0.11.0
+	golang.org/x/sys v0.15.0
+	golang.org/x/term v0.15.0
 	golang.org/x/time v0.0.0-20220722155302-e5dcc9cfc0b9
 	golang.org/x/tools v0.12.1-0.20230815132531-74c255bcf846
 	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2
@@ -246,6 +253,9 @@ require (
 	github.com/ipfs/go-verifcid v0.0.2 // indirect
 	github.com/ipld/go-ipld-adl-hamt v0.0.0-20220616142416-9004dbd839e0 // indirect
 	github.com/ipsn/go-secp256k1 v0.0.0-20180726113642-9d62b9f0bc52 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
+	github.com/jackc/puddle/v2 v2.2.0 // indirect
 	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
 	github.com/jbenet/go-random v0.0.0-20190219211222-123a90aedc0c // indirect
 	github.com/jbenet/go-temp-err-catcher v0.1.0 // indirect
@@ -287,17 +297,15 @@ require (
 	github.com/onsi/ginkgo/v2 v2.11.0 // indirect
 	github.com/opencontainers/runtime-spec v1.1.0 // indirect
 	github.com/opentracing/opentracing-go v1.2.0 // indirect
-	github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 // indirect
 	github.com/petar/GoLLRB v0.0.0-20210522233825-ae3b015fd3e9 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/prometheus/client_model v0.4.0 // indirect
 	github.com/prometheus/common v0.42.0 // indirect
-	github.com/prometheus/procfs v0.9.0 // indirect
+	github.com/prometheus/procfs v0.10.1 // indirect
 	github.com/prometheus/statsd_exporter v0.22.7 // indirect
 	github.com/quic-go/qpack v0.4.0 // indirect
 	github.com/quic-go/qtls-go1-20 v0.3.3 // indirect
-	github.com/quic-go/quic-go v0.37.6 // indirect
+	github.com/quic-go/quic-go v0.38.2 // indirect
 	github.com/quic-go/webtransport-go v0.5.3 // indirect
 	github.com/rivo/uniseg v0.1.0 // indirect
 	github.com/rs/cors v1.7.0 // indirect
@@ -307,7 +315,7 @@ require (
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
 	github.com/tidwall/gjson v1.14.4 // indirect
 	github.com/twmb/murmur3 v1.1.6 // indirect
-	github.com/ugorji/go/codec v1.2.6 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fasttemplate v1.0.1 // indirect
 	github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11 // indirect
@@ -324,7 +332,7 @@ require (
 	go.uber.org/dig v1.17.0 // indirect
 	go4.org v0.0.0-20230225012048-214862532bf5 // indirect
 	golang.org/x/mod v0.12.0 // indirect
-	golang.org/x/text v0.12.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
 	gonum.org/v1/gonum v0.13.0 // indirect
 	google.golang.org/genproto v0.0.0-20230306155012-7f2fa6fef1f4 // indirect
 	google.golang.org/grpc v1.55.0 // indirect
@@ -338,3 +346,5 @@ require (
 replace github.com/filecoin-project/filecoin-ffi => ./extern/filecoin-ffi
 
 replace github.com/filecoin-project/test-vectors => ./extern/test-vectors
+
+replace github.com/triplewz/poseidon => github.com/magik6k/poseidon v0.0.0-neptune
diff --git a/go.sum b/go.sum
index 5ec12dd27..68b53ffc5 100644
--- a/go.sum
+++ b/go.sum
@@ -169,6 +169,7 @@ github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp
 github.com/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/cockroachdb/cockroach-go/v2 v2.2.0 h1:/5znzg5n373N/3ESjHF5SMLxiW4RKB05Ql//KWfeTFs=
 github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
 github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
 github.com/codegangsta/cli v1.20.0/go.mod h1:/qJNoX69yVSKu5o4jLyXAENLRyk1uhi7zkbQ3slBdOA=
@@ -393,6 +394,8 @@ github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdk
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
 github.com/gdamore/tcell/v2 v2.2.0 h1:vSyEgKwraXPSOkvCk7IwOSyX+Pv3V2cV9CikJMXg4U4=
 github.com/gdamore/tcell/v2 v2.2.0/go.mod h1:cTTuF84Dlj/RqmaCIV5p4w8uG1zWdk0SF6oBpwHp4fU=
+github.com/georgysavva/scany/v2 v2.0.0 h1:RGXqxDv4row7/FYoK8MRXAZXqoWF/NM+NP0q50k3DKU=
+github.com/georgysavva/scany/v2 v2.0.0/go.mod h1:sigOdh+0qb/+aOs3TVhehVT10p8qJL7K/Zhyz8vWo38=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
 github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98=
@@ -450,6 +453,7 @@ github.com/godbus/dbus/v5 v5.0.3/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5x
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk=
 github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
 github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
 github.com/gogo/googleapis v1.4.1 h1:1Yx4Myt7BxzvUr5ldGSbwYiZG6t9wGBZ+8/fX3Wvtq0=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
@@ -855,6 +859,16 @@ github.com/ipni/index-provider v0.12.0 h1:R3F6dxxKNv4XkE4GJZNLOG0bDEbBQ/S5iztXwS
 github.com/ipni/index-provider v0.12.0/go.mod h1:GhyrADJp7n06fqoc1djzkvL4buZYHzV8SoWrlxEo5F4=
 github.com/ipsn/go-secp256k1 v0.0.0-20180726113642-9d62b9f0bc52 h1:QG4CGBqCeuBo6aZlGAamSkxWdgWfZGeE49eUOWJPA4c=
 github.com/ipsn/go-secp256k1 v0.0.0-20180726113642-9d62b9f0bc52/go.mod h1:fdg+/X9Gg4AsAIzWpEHwnqd+QY3b7lajxyjE1m4hkq4=
+github.com/jackc/pgerrcode v0.0.0-20220416144525-469b46aa5efa h1:s+4MhCQ6YrzisK6hFJUX53drDT4UsSW3DEhKn0ifuHw=
+github.com/jackc/pgerrcode v0.0.0-20220416144525-469b46aa5efa/go.mod h1:a/s9Lp5W7n/DD0VrVoyJ00FbP2ytTPDVOivvn2bMlds=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.4.1 h1:oKfB/FhuVtit1bBM3zNRRsZ925ZkMN3HXL+LgLUM9lE=
+github.com/jackc/pgx/v5 v5.4.1/go.mod h1:q6iHT8uDNXWiFNOlRqJzBTaSH3+2xCXkokxHZC5qWFY=
+github.com/jackc/puddle/v2 v2.2.0 h1:RdcDk92EJBuBS55nQMMYFXTxwstHug4jkhT5pq8VxPk=
+github.com/jackc/puddle/v2 v2.2.0/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/jackpal/gateway v1.0.5/go.mod h1:lTpwd4ACLXmpyiCTRtfiNyVnUmqT9RivzCDQetPfnjA=
 github.com/jackpal/go-nat-pmp v1.0.1/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
 github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
@@ -943,6 +957,9 @@ github.com/kr/pty v1.1.5/go.mod h1:9r2w37qlBe7rQ6e1fg1S/9xpWHSnaqNdHD3WcMdbPDA=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
+github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8=
+github.com/lib/pq v1.10.0 h1:Zx5DJFEYQXio93kgXnQ09fXNiUKsqv4OUEu2UtGcB1E=
 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/go.mod h1:Ecd6Fb3yIuLzq4bD7VcywcVSBtefcAwnUISBM3WG15E=
 github.com/libp2p/go-buffer-pool v0.0.1/go.mod h1:xtyIz9PMobb13WaxR6Zo1Pd1zXJKYg0a8KiIvDp3TzQ=
@@ -967,8 +984,8 @@ github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xS
 github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw=
 github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qDKwXujH5o=
 github.com/libp2p/go-libp2p v0.14.3/go.mod h1:d12V4PdKbpL0T1/gsUNN8DfgMuRPDX8bS2QxCZlwRH0=
-github.com/libp2p/go-libp2p v0.30.0 h1:9EZwFtJPFBcs/yJTnP90TpN1hgrT/EsFfM+OZuwV87U=
-github.com/libp2p/go-libp2p v0.30.0/go.mod h1:nr2g5V7lfftwgiJ78/HrID+pwvayLyqKCEirT2Y3Byg=
+github.com/libp2p/go-libp2p v0.31.1 h1:mUiFPwdzC2zMLIATKVddjCuPXVbtC3BsKKVPMs4+jzY=
+github.com/libp2p/go-libp2p v0.31.1/go.mod h1:+9TCv+XySSOdaxPF1WIgTK8rXP9jBb8WbemlMCSXGsU=
 github.com/libp2p/go-libp2p-asn-util v0.3.0 h1:gMDcMyYiZKkocGXDQ5nsUQyquC9+H+iLEQHwOCZ7s8s=
 github.com/libp2p/go-libp2p-asn-util v0.3.0/go.mod h1:B1mcOrKUE35Xq/ASTmQ4tN3LNzVVaMNmq2NACuqyB9w=
 github.com/libp2p/go-libp2p-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8=
@@ -1161,6 +1178,8 @@ github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0Q
 github.com/magefile/mage v1.9.0 h1:t3AU2wNwehMCW97vuqQLtw6puppWXHO+O2MHo5a50XE=
 github.com/magefile/mage v1.9.0/go.mod h1:z5UZb/iS3GoOSn0JgWuiw7dxlurVYTu+/jHXqQg881A=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/magik6k/poseidon v0.0.0-neptune h1:Dfz15iiYGGE9Esvn8pZFlbiiCrHuyZDxm6LGXQfaf9c=
+github.com/magik6k/poseidon v0.0.0-neptune/go.mod h1:QYG1d0B4YZD7TgF6qZndTTu4rxUGFCCZAQRDanDj+9c=
 github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/mailru/easyjson v0.0.0-20190312143242-1de009706dbe/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
@@ -1263,8 +1282,8 @@ github.com/multiformats/go-multiaddr v0.2.2/go.mod h1:NtfXiOtHvghW9KojvtySjH5y0u
 github.com/multiformats/go-multiaddr v0.3.0/go.mod h1:dF9kph9wfJ+3VLAaeBqo9Of8x4fJxp6ggJGteB8HQTI=
 github.com/multiformats/go-multiaddr v0.3.1/go.mod h1:uPbspcUPd5AfaP6ql3ujFY+QWzmBD8uLLL4bXW0XfGc=
 github.com/multiformats/go-multiaddr v0.3.3/go.mod h1:lCKNGP1EQ1eZ35Za2wlqnabm9xQkib3fyB+nZXHLag0=
-github.com/multiformats/go-multiaddr v0.11.0 h1:XqGyJ8ufbCE0HmTDwx2kPdsrQ36AGPZNZX6s6xfJH10=
-github.com/multiformats/go-multiaddr v0.11.0/go.mod h1:gWUm0QLR4thQ6+ZF6SXUw8YjtwQSPapICM+NmCkxHSM=
+github.com/multiformats/go-multiaddr v0.12.1 h1:vm+BA/WZA8QZDp1pF1FWhi5CT3g1tbi5GJmqpb6wnlk=
+github.com/multiformats/go-multiaddr v0.12.1/go.mod h1:7mPkiBMmLeFipt+nNSq9pHZUeJSt8lHBgH6yhj0YQzE=
 github.com/multiformats/go-multiaddr-dns v0.0.1/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q=
 github.com/multiformats/go-multiaddr-dns v0.0.2/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q=
 github.com/multiformats/go-multiaddr-dns v0.2.0/go.mod h1:TJ5pr5bBO7Y1B18djPuRsVkduhQH2YqYSbxWJzYGdK0=
@@ -1411,8 +1430,8 @@ github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqr
 github.com/prometheus/client_golang v1.12.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
 github.com/prometheus/client_golang v1.12.2/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
 github.com/prometheus/client_golang v1.13.0/go.mod h1:vTeo+zgvILHsnnj/39Ou/1fPN5nJFOEMgftOUOmlvYQ=
-github.com/prometheus/client_golang v1.14.0 h1:nJdhIvne2eSX/XRAFV9PcvFFRbrjbcTUj0VP62TMhnw=
-github.com/prometheus/client_golang v1.14.0/go.mod h1:8vpkKitgIVNcqrRBWh1C4TIUQgYNtG/XQE4E/Zae36Y=
+github.com/prometheus/client_golang v1.16.0 h1:yk/hx9hDbrGHovbci4BY+pRMfSuuat626eFsHb7tmT8=
+github.com/prometheus/client_golang v1.16.0/go.mod h1:Zsulrv/L9oM40tJ7T815tM89lFEugiJ9HzIqaAx4LKc=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
@@ -1446,8 +1465,8 @@ github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4O
 github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0uaxHdg830/4=
-github.com/prometheus/procfs v0.9.0 h1:wzCHvIvM5SxWqYvwgVL7yJY8Lz3PKn49KQtpgMYJfhI=
-github.com/prometheus/procfs v0.9.0/go.mod h1:+pB4zwohETzFnmlpe6yd2lSc+0/46IYZRB/chUwxUZY=
+github.com/prometheus/procfs v0.10.1 h1:kYK1Va/YMlutzCGazswoHKo//tZVlFpKYh+PymziUAg=
+github.com/prometheus/procfs v0.10.1/go.mod h1:nwNm2aOCAYw8uTR/9bWRREkZFxAUcWzPHWJq+XBB/FM=
 github.com/prometheus/statsd_exporter v0.22.7 h1:7Pji/i2GuhK6Lu7DHrtTkFmNBCudCPT1pX2CziuyQR0=
 github.com/prometheus/statsd_exporter v0.22.7/go.mod h1:N/TevpjkIh9ccs6nuzY3jQn9dFqnUakOjnEuMPJJJnI=
 github.com/puzpuzpuz/xsync/v2 v2.4.0 h1:5sXAMHrtx1bg9nbRZTOn8T4MkWe5V+o8yKRH02Eznag=
@@ -1456,8 +1475,8 @@ github.com/quic-go/qpack v0.4.0 h1:Cr9BXA1sQS2SmDUWjSofMPNKmvF6IiIfDRmgU0w1ZCo=
 github.com/quic-go/qpack v0.4.0/go.mod h1:UZVnYIfi5GRk+zI9UMaCPsmZ2xKJP7XBUvVyT1Knj9A=
 github.com/quic-go/qtls-go1-20 v0.3.3 h1:17/glZSLI9P9fDAeyCHBFSWSqJcwx1byhLwP5eUIDCM=
 github.com/quic-go/qtls-go1-20 v0.3.3/go.mod h1:X9Nh97ZL80Z+bX/gUXMbipO6OxdiDi58b/fMC9mAL+k=
-github.com/quic-go/quic-go v0.37.6 h1:2IIUmQzT5YNxAiaPGjs++Z4hGOtIR0q79uS5qE9ccfY=
-github.com/quic-go/quic-go v0.37.6/go.mod h1:YsbH1r4mSHPJcLF4k4zruUkLBqctEMBDR6VPvcYjIsU=
+github.com/quic-go/quic-go v0.38.2 h1:VWv/6gxIoB8hROQJhx1JEyiegsUQ+zMN3em3kynTGdg=
+github.com/quic-go/quic-go v0.38.2/go.mod h1:ijnZM7JsFIkp4cRyjxJNIzdSfCLmUMg9wdyhGmg+SN4=
 github.com/quic-go/webtransport-go v0.5.3 h1:5XMlzemqB4qmOlgIus5zB45AcZ2kCgCy2EptUrfOPWU=
 github.com/quic-go/webtransport-go v0.5.3/go.mod h1:OhmmgJIzTTqXK5xvtuX0oBpLV2GkLWNDA+UeTGJXErU=
 github.com/raulk/clock v1.1.0 h1:dpb29+UKMbLqiU/jqIJptgLR1nn23HLgMY0sTCDza5Y=
@@ -1482,6 +1501,8 @@ github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/rwcarlsen/goexif v0.0.0-20190401172101-9e8deecbddbd/go.mod h1:hPqNNc0+uJM6H+SuU8sEs5K5IQeKccPqeSjfgcKGgPk=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+github.com/samber/lo v1.38.1 h1:j2XEAqXKb09Am4ebOg31SpvzUTTs6EN3VfgeLUhPdXM=
+github.com/samber/lo v1.38.1/go.mod h1:+m/ZKRl6ClXCE2Lgf3MsQlWfh4bn1bz6CXEOxnEXnEA=
 github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
 github.com/sercand/kuberesolver v2.4.0+incompatible h1:WE2OlRf6wjLxHwNkkFLQGaZcVLEXjMjBPjjEU5vksH8=
@@ -1592,10 +1613,9 @@ github.com/twmb/murmur3 v1.1.6 h1:mqrRot1BRxm+Yct+vavLMou2/iJt0tNVTTC0QoIjaZg=
 github.com/twmb/murmur3 v1.1.6/go.mod h1:Qq/R7NUyOfr65zD+6Q5IHKsJLwP7exErjN6lyyq3OSQ=
 github.com/uber/jaeger-client-go v2.30.0+incompatible h1:D6wyKGCecFaSRUpo8lCVbaOOb6ThwMmTEbhRwtKR97o=
 github.com/uber/jaeger-lib v2.4.1+incompatible h1:td4jdvLcExb4cBISKIpHuGoVXh+dVKhn2Um6rjCsSsg=
-github.com/ugorji/go v1.2.6/go.mod h1:anCg0y61KIhDlPZmnH+so+RQbysYVyDko0IMgJv0Nn0=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
-github.com/ugorji/go/codec v1.2.6 h1:7kbGefxLoDBuYXOms4yD7223OpNMMPNPZxXk5TvFcyQ=
-github.com/ugorji/go/codec v1.2.6/go.mod h1:V6TCNZ4PHqoHGFZuSG1W8nrCzzdgA2DozYxWFFpvxTw=
+github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
 github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
 github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
@@ -1797,8 +1817,8 @@ golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5y
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=
-golang.org/x/crypto v0.12.0 h1:tFM/ta59kqch6LlvYnPa0yx5a83cL2nHflFhYKvv9Yk=
-golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
+golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -2016,6 +2036,7 @@ golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -2033,16 +2054,16 @@ golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
-golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
+golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.11.0 h1:F9tnn/DA/Im8nCwm+fX+1/eBwi4qFjRT++MhtVC4ZX0=
-golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
+golang.org/x/term v0.15.0 h1:y/Oo/a/q3IXu26lQgl04j/gjuBDOBlx7X6Om1j2CPW4=
+golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -2052,8 +2073,8 @@ golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
-golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
diff --git a/itests/api_test.go b/itests/api_test.go
index c87012cfe..ff43bd5c0 100644
--- a/itests/api_test.go
+++ b/itests/api_test.go
@@ -86,7 +86,7 @@ func (ts *apiSuite) testID(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	require.Regexp(t, "^12", id.Pretty())
+	require.Regexp(t, "^12", id.String())
 }
 
 func (ts *apiSuite) testConnectTwo(t *testing.T) {
diff --git a/itests/eth_account_abstraction_test.go b/itests/eth_account_abstraction_test.go
index 8d92d0a04..5ca672674 100644
--- a/itests/eth_account_abstraction_test.go
+++ b/itests/eth_account_abstraction_test.go
@@ -3,6 +3,7 @@ package itests
 import (
 	"context"
 	"encoding/hex"
+	"encoding/json"
 	"os"
 	"testing"
 	"time"
@@ -272,10 +273,13 @@ func TestEthAccountAbstractionFailsFromEvmActor(t *testing.T) {
 	contract, err := hex.DecodeString(string(contractHex))
 	require.NoError(t, err)
 
-	gaslimit, err := client.EthEstimateGas(ctx, ethtypes.EthCall{
+	gasParams, err := json.Marshal(ethtypes.EthEstimateGasParams{Tx: ethtypes.EthCall{
 		From: &ethAddr,
 		Data: contract,
-	})
+	}})
+	require.NoError(t, err)
+
+	gaslimit, err := client.EthEstimateGas(ctx, gasParams)
 	require.NoError(t, err)
 
 	maxPriorityFeePerGas, err := client.EthMaxPriorityFeePerGas(ctx)
diff --git a/itests/eth_conformance_test.go b/itests/eth_conformance_test.go
index 15b249977..9c1b2ae34 100644
--- a/itests/eth_conformance_test.go
+++ b/itests/eth_conformance_test.go
@@ -35,7 +35,7 @@ type ethAPIRaw struct {
 	EthBlockNumber                         func(context.Context) (json.RawMessage, error)
 	EthCall                                func(context.Context, ethtypes.EthCall, ethtypes.EthBlockNumberOrHash) (json.RawMessage, error)
 	EthChainId                             func(context.Context) (json.RawMessage, error)
-	EthEstimateGas                         func(context.Context, ethtypes.EthCall) (json.RawMessage, error)
+	EthEstimateGas                         func(context.Context, jsonrpc.RawParams) (json.RawMessage, error)
 	EthFeeHistory                          func(context.Context, ethtypes.EthUint64, string, []float64) (json.RawMessage, error)
 	EthGasPrice                            func(context.Context) (json.RawMessage, error)
 	EthGetBalance                          func(context.Context, ethtypes.EthAddress, ethtypes.EthBlockNumberOrHash) (json.RawMessage, error)
@@ -182,10 +182,13 @@ func TestEthOpenRPCConformance(t *testing.T) {
 		{
 			method: "eth_estimateGas",
 			call: func(a *ethAPIRaw) (json.RawMessage, error) {
-				return ethapi.EthEstimateGas(context.Background(), ethtypes.EthCall{
+				gasParams, err := json.Marshal(ethtypes.EthEstimateGasParams{Tx: ethtypes.EthCall{
 					From: &senderEthAddr,
 					Data: contractBin,
-				})
+				}})
+				require.NoError(t, err)
+
+				return ethapi.EthEstimateGas(ctx, gasParams)
 			},
 		},
 
@@ -448,10 +451,13 @@ func TestEthOpenRPCConformance(t *testing.T) {
 }
 
 func createRawSignedEthTx(ctx context.Context, t *testing.T, client *kit.TestFullNode, senderEthAddr ethtypes.EthAddress, receiverEthAddr ethtypes.EthAddress, senderKey *key.Key, contractBin []byte) []byte {
-	gaslimit, err := client.EthEstimateGas(ctx, ethtypes.EthCall{
+	gasParams, err := json.Marshal(ethtypes.EthEstimateGasParams{Tx: ethtypes.EthCall{
 		From: &senderEthAddr,
 		Data: contractBin,
-	})
+	}})
+	require.NoError(t, err)
+
+	gaslimit, err := client.EthEstimateGas(ctx, gasParams)
 	require.NoError(t, err)
 
 	maxPriorityFeePerGas, err := client.EthMaxPriorityFeePerGas(ctx)
diff --git a/itests/eth_deploy_test.go b/itests/eth_deploy_test.go
index ce4c94a28..68861f98f 100644
--- a/itests/eth_deploy_test.go
+++ b/itests/eth_deploy_test.go
@@ -60,10 +60,13 @@ func TestDeployment(t *testing.T) {
 	// verify the deployer address is an Placeholder.
 	client.AssertActorType(ctx, deployer, manifest.PlaceholderKey)
 
-	gaslimit, err := client.EthEstimateGas(ctx, ethtypes.EthCall{
+	gasParams, err := json.Marshal(ethtypes.EthEstimateGasParams{Tx: ethtypes.EthCall{
 		From: &ethAddr,
 		Data: contract,
-	})
+	}})
+	require.NoError(t, err)
+
+	gaslimit, err := client.EthEstimateGas(ctx, gasParams)
 	require.NoError(t, err)
 
 	maxPriorityFeePerGas, err := client.EthMaxPriorityFeePerGas(ctx)
diff --git a/itests/eth_filter_test.go b/itests/eth_filter_test.go
index 62ab5db54..9212e60fc 100644
--- a/itests/eth_filter_test.go
+++ b/itests/eth_filter_test.go
@@ -16,6 +16,7 @@ import (
 	"time"
 
 	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/xerrors"
 
@@ -543,6 +544,7 @@ func TestTxReceiptBloom(t *testing.T) {
 		kit.MockProofs(),
 		kit.ThroughRPC())
 	ens.InterconnectAll().BeginMining(blockTime)
+	logging.SetLogLevel("fullnode", "DEBUG")
 
 	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
 	defer cancel()
@@ -577,6 +579,10 @@ func TestTxReceiptBloom(t *testing.T) {
 		}
 	}
 
+	// Deflake plan: (Flake: 5 bits instead of 6)
+	//   Debug + search logs for "LogsBloom"
+	//   compare to passing case.
+	//
 	// 3 bits from the topic, 3 bits from the address
 	require.Equal(t, 6, bitsSet)
 }
diff --git a/itests/eth_hash_lookup_test.go b/itests/eth_hash_lookup_test.go
index 37d069796..0a2c11d3c 100644
--- a/itests/eth_hash_lookup_test.go
+++ b/itests/eth_hash_lookup_test.go
@@ -3,6 +3,7 @@ package itests
 import (
 	"context"
 	"encoding/hex"
+	"encoding/json"
 	"os"
 	"testing"
 	"time"
@@ -47,10 +48,13 @@ func TestTransactionHashLookup(t *testing.T) {
 	// send some funds to the f410 address
 	kit.SendFunds(ctx, t, client, deployer, types.FromFil(10))
 
-	gaslimit, err := client.EthEstimateGas(ctx, ethtypes.EthCall{
+	gasParams, err := json.Marshal(ethtypes.EthEstimateGasParams{Tx: ethtypes.EthCall{
 		From: &ethAddr,
 		Data: contract,
-	})
+	}})
+	require.NoError(t, err)
+
+	gaslimit, err := client.EthEstimateGas(ctx, gasParams)
 	require.NoError(t, err)
 
 	maxPriorityFeePerGas, err := client.EthMaxPriorityFeePerGas(ctx)
@@ -120,7 +124,6 @@ func TestTransactionHashLookupBlsFilecoinMessage(t *testing.T) {
 		kit.MockProofs(),
 		kit.ThroughRPC(),
 	)
-	ens.InterconnectAll().BeginMining(blocktime)
 
 	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
 	defer cancel()
@@ -146,9 +149,13 @@ func TestTransactionHashLookupBlsFilecoinMessage(t *testing.T) {
 	hash, err := ethtypes.EthHashFromCid(sm.Message.Cid())
 	require.NoError(t, err)
 
-	mpoolTx, err := client.EthGetTransactionByHash(ctx, &hash)
-	require.NoError(t, err)
-	require.Equal(t, hash, mpoolTx.Hash)
+	// Assert that BLS messages cannot be retrieved from the message pool until it lands
+	// on-chain via the eth API.
+	_, err = client.EthGetTransactionByHash(ctx, &hash)
+	require.Error(t, err)
+
+	// Now start mining.
+	ens.InterconnectAll().BeginMining(blocktime)
 
 	// Wait for message to land on chain
 	var receipt *api.EthTxReceipt
@@ -177,6 +184,25 @@ func TestTransactionHashLookupBlsFilecoinMessage(t *testing.T) {
 	require.NotEmpty(t, *chainTx.BlockHash)
 	require.NotNil(t, chainTx.TransactionIndex)
 	require.Equal(t, uint64(*chainTx.TransactionIndex), uint64(0)) // only transaction
+
+	// verify that we correctly reported the to address.
+	toId, err := client.StateLookupID(ctx, addr, types.EmptyTSK)
+	require.NoError(t, err)
+	toEth, err := client.FilecoinAddressToEthAddress(ctx, toId)
+	require.NoError(t, err)
+	require.Equal(t, &toEth, chainTx.To)
+
+	const expectedHex = "868e10c4" +
+		"0000000000000000000000000000000000000000000000000000000000000000" +
+		"0000000000000000000000000000000000000000000000000000000000000000" +
+		"0000000000000000000000000000000000000000000000000000000000000060" +
+		"0000000000000000000000000000000000000000000000000000000000000000"
+
+	// verify that the params are correctly encoded.
+	expected, err := hex.DecodeString(expectedHex)
+	require.NoError(t, err)
+
+	require.Equal(t, ethtypes.EthBytes(expected), chainTx.Input)
 }
 
 // TestTransactionHashLookupSecpFilecoinMessage tests to see if lotus can find a Secp Filecoin Message using the transaction hash
@@ -228,10 +254,6 @@ func TestTransactionHashLookupSecpFilecoinMessage(t *testing.T) {
 	hash, err := ethtypes.EthHashFromCid(secpSmsg.Cid())
 	require.NoError(t, err)
 
-	mpoolTx, err := client.EthGetTransactionByHash(ctx, &hash)
-	require.NoError(t, err)
-	require.Equal(t, hash, mpoolTx.Hash)
-
 	_, err = client.StateWaitMsg(ctx, secpSmsg.Cid(), 3, api.LookbackNoLimit, true)
 	require.NoError(t, err)
 
@@ -253,6 +275,25 @@ func TestTransactionHashLookupSecpFilecoinMessage(t *testing.T) {
 	require.NotEmpty(t, *chainTx.BlockHash)
 	require.NotNil(t, chainTx.TransactionIndex)
 	require.Equal(t, uint64(*chainTx.TransactionIndex), uint64(0)) // only transaction
+
+	// verify that we correctly reported the to address.
+	toId, err := client.StateLookupID(ctx, client.DefaultKey.Address, types.EmptyTSK)
+	require.NoError(t, err)
+	toEth, err := client.FilecoinAddressToEthAddress(ctx, toId)
+	require.NoError(t, err)
+	require.Equal(t, &toEth, chainTx.To)
+
+	const expectedHex = "868e10c4" +
+		"0000000000000000000000000000000000000000000000000000000000000000" +
+		"0000000000000000000000000000000000000000000000000000000000000000" +
+		"0000000000000000000000000000000000000000000000000000000000000060" +
+		"0000000000000000000000000000000000000000000000000000000000000000"
+
+	// verify that the params are correctly encoded.
+	expected, err := hex.DecodeString(expectedHex)
+	require.NoError(t, err)
+
+	require.Equal(t, ethtypes.EthBytes(expected), chainTx.Input)
 }
 
 // TestTransactionHashLookupSecpFilecoinMessage tests to see if lotus can find a Secp Filecoin Message using the transaction hash
@@ -313,10 +354,13 @@ func TestEthGetMessageCidByTransactionHashEthTx(t *testing.T) {
 	// send some funds to the f410 address
 	kit.SendFunds(ctx, t, client, deployer, types.FromFil(10))
 
-	gaslimit, err := client.EthEstimateGas(ctx, ethtypes.EthCall{
+	gasParams, err := json.Marshal(ethtypes.EthEstimateGasParams{Tx: ethtypes.EthCall{
 		From: &ethAddr,
 		Data: contract,
-	})
+	}})
+	require.NoError(t, err)
+
+	gaslimit, err := client.EthEstimateGas(ctx, gasParams)
 	require.NoError(t, err)
 
 	maxPriorityFeePerGas, err := client.EthMaxPriorityFeePerGas(ctx)
diff --git a/itests/eth_transactions_test.go b/itests/eth_transactions_test.go
index 6d60f6786..9e9fb7b87 100644
--- a/itests/eth_transactions_test.go
+++ b/itests/eth_transactions_test.go
@@ -3,17 +3,23 @@ package itests
 import (
 	"context"
 	"encoding/hex"
+	"encoding/json"
 	"os"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/require"
 
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
+	builtin2 "github.com/filecoin-project/go-state-types/builtin"
+	"github.com/filecoin-project/go-state-types/exitcode"
 	"github.com/filecoin-project/go-state-types/manifest"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/types/ethtypes"
@@ -42,12 +48,19 @@ func TestValueTransferValidSignature(t *testing.T) {
 
 	kit.SendFunds(ctx, t, client, deployer, types.FromFil(1000))
 
-	gaslimit, err := client.EthEstimateGas(ctx, ethtypes.EthCall{
-		From: &ethAddr,
-		Data: contract,
+	blkParam := ethtypes.NewEthBlockNumberOrHashFromPredefined("latest")
+	gasParams, err := json.Marshal(ethtypes.EthEstimateGasParams{
+		Tx: ethtypes.EthCall{
+			From: &ethAddr,
+			Data: contract,
+		},
+		BlkParam: &blkParam,
 	})
 	require.NoError(t, err)
 
+	gaslimit, err := client.EthEstimateGas(ctx, gasParams)
+	require.NoError(t, err)
+
 	maxPriorityFeePerGas, err := client.EthMaxPriorityFeePerGas(ctx)
 	require.NoError(t, err)
 
@@ -78,7 +91,7 @@ func TestValueTransferValidSignature(t *testing.T) {
 	client.EVM().SignTransaction(&tx, key.PrivateKey)
 	hash := client.EVM().SubmitTransaction(ctx, &tx)
 
-	receipt, err := waitForEthTxReceipt(ctx, client, hash)
+	receipt, err := client.EVM().WaitTransaction(ctx, hash)
 	require.NoError(t, err)
 	require.NotNil(t, receipt)
 	require.EqualValues(t, ethAddr, receipt.From)
@@ -166,7 +179,7 @@ func TestContractDeploymentValidSignature(t *testing.T) {
 	client.EVM().SignTransaction(tx, key.PrivateKey)
 	hash := client.EVM().SubmitTransaction(ctx, tx)
 
-	receipt, err := waitForEthTxReceipt(ctx, client, hash)
+	receipt, err := client.EVM().WaitTransaction(ctx, hash)
 	require.NoError(t, err)
 	require.NotNil(t, receipt)
 
@@ -213,7 +226,7 @@ func TestContractInvocation(t *testing.T) {
 	client.EVM().SignTransaction(tx, key.PrivateKey)
 	hash := client.EVM().SubmitTransaction(ctx, tx)
 
-	receipt, err := waitForEthTxReceipt(ctx, client, hash)
+	receipt, err := client.EVM().WaitTransaction(ctx, hash)
 	require.NoError(t, err)
 	require.NotNil(t, receipt)
 	require.EqualValues(t, ethtypes.EthUint64(0x1), receipt.Status)
@@ -229,11 +242,14 @@ func TestContractInvocation(t *testing.T) {
 	params, err := hex.DecodeString("f8b2cb4f000000000000000000000000ff00000000000000000000000000000000000064")
 	require.NoError(t, err)
 
-	gaslimit, err := client.EthEstimateGas(ctx, ethtypes.EthCall{
+	gasParams, err := json.Marshal(ethtypes.EthEstimateGasParams{Tx: ethtypes.EthCall{
 		From: &ethAddr,
 		To:   &contractAddr,
 		Data: params,
-	})
+	}})
+	require.NoError(t, err)
+
+	gaslimit, err := client.EthEstimateGas(ctx, gasParams)
 	require.NoError(t, err)
 
 	maxPriorityFeePerGas, err := client.EthMaxPriorityFeePerGas(ctx)
@@ -267,7 +283,7 @@ func TestContractInvocation(t *testing.T) {
 	client.EVM().SignTransaction(&invokeTx, key.PrivateKey)
 	hash = client.EVM().SubmitTransaction(ctx, &invokeTx)
 
-	receipt, err = waitForEthTxReceipt(ctx, client, hash)
+	receipt, err = client.EVM().WaitTransaction(ctx, hash)
 	require.NoError(t, err)
 	require.NotNil(t, receipt)
 
@@ -348,10 +364,15 @@ func TestGetBlockByNumber(t *testing.T) {
 }
 
 func deployContractTx(ctx context.Context, client *kit.TestFullNode, ethAddr ethtypes.EthAddress, contract []byte) (*ethtypes.EthTxArgs, error) {
-	gaslimit, err := client.EthEstimateGas(ctx, ethtypes.EthCall{
+	gasParams, err := json.Marshal(ethtypes.EthEstimateGasParams{Tx: ethtypes.EthCall{
 		From: &ethAddr,
 		Data: contract,
-	})
+	}})
+	if err != nil {
+		return nil, err
+	}
+
+	gaslimit, err := client.EthEstimateGas(ctx, gasParams)
 	if err != nil {
 		return nil, err
 	}
@@ -376,16 +397,213 @@ func deployContractTx(ctx context.Context, client *kit.TestFullNode, ethAddr eth
 	}, nil
 }
 
-func waitForEthTxReceipt(ctx context.Context, client *kit.TestFullNode, hash ethtypes.EthHash) (*api.EthTxReceipt, error) {
-	var receipt *api.EthTxReceipt
-	var err error
-	for i := 0; i < 10000000000; i++ {
-		receipt, err = client.EthGetTransactionReceipt(ctx, hash)
-		if err != nil || receipt == nil {
-			time.Sleep(500 * time.Millisecond)
-			continue
-		}
-		break
+// Invoke a contract with empty input.
+func TestEthTxFromNativeAccount_EmptyInput(t *testing.T) {
+	blockTime := 10 * time.Millisecond
+	client, _, ens := kit.EnsembleMinimal(t, kit.MockProofs(), kit.ThroughRPC())
+
+	ens.InterconnectAll().BeginMining(blockTime)
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	secpAddr, err := address.NewSecp256k1Address([]byte("foobar"))
+	require.NoError(t, err)
+
+	msg := &types.Message{
+		From:   client.DefaultKey.Address,
+		To:     secpAddr,
+		Value:  abi.TokenAmount(types.MustParseFIL("100")),
+		Method: builtin2.MethodsEVM.InvokeContract,
 	}
-	return receipt, err
+
+	sMsg, err := client.MpoolPushMessage(ctx, msg, nil)
+	require.NoError(t, err)
+	client.WaitMsg(ctx, sMsg.Cid())
+
+	hash, err := client.EthGetTransactionHashByCid(ctx, sMsg.Cid())
+	require.NoError(t, err)
+	tx, err := client.EthGetTransactionByHash(ctx, hash)
+	require.NoError(t, err)
+
+	// Expect empty input params given that we "invoked" the contract (well, invoked ourselves).
+	require.Equal(t, ethtypes.EthBytes{}, tx.Input)
+
+	// Validate the to/from addresses.
+	toId, err := client.StateLookupID(ctx, msg.To, types.EmptyTSK)
+	require.NoError(t, err)
+	fromId, err := client.StateLookupID(ctx, msg.From, types.EmptyTSK)
+	require.NoError(t, err)
+
+	expectedTo, err := ethtypes.EthAddressFromFilecoinAddress(toId)
+	require.NoError(t, err)
+	expectedFrom, err := ethtypes.EthAddressFromFilecoinAddress(fromId)
+	require.NoError(t, err)
+	require.Equal(t, &expectedTo, tx.To)
+	require.Equal(t, expectedFrom, tx.From)
+}
+
+// Invoke a contract with non-empty input.
+func TestEthTxFromNativeAccount_NonEmptyInput(t *testing.T) {
+	blockTime := 10 * time.Millisecond
+	client, _, ens := kit.EnsembleMinimal(t, kit.MockProofs(), kit.ThroughRPC())
+
+	ens.InterconnectAll().BeginMining(blockTime)
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	msg := &types.Message{
+		From:   client.DefaultKey.Address,
+		To:     client.DefaultKey.Address,
+		Value:  abi.TokenAmount(types.MustParseFIL("100")),
+		Method: builtin2.MethodsEVM.InvokeContract,
+	}
+
+	var err error
+	input := abi.CborBytes([]byte{0x1, 0x2, 0x3, 0x4})
+	msg.Params, err = actors.SerializeParams(&input)
+	require.NoError(t, err)
+
+	sMsg, err := client.MpoolPushMessage(ctx, msg, nil)
+	require.NoError(t, err)
+	client.WaitMsg(ctx, sMsg.Cid())
+	hash, err := client.EthGetTransactionHashByCid(ctx, sMsg.Cid())
+	require.NoError(t, err)
+	tx, err := client.EthGetTransactionByHash(ctx, hash)
+	require.NoError(t, err)
+
+	// Expect the decoded input.
+	require.EqualValues(t, input, tx.Input)
+}
+
+// Invoke a contract, but with incorrectly encoded input. We expect this to be abi-encoded as if it
+// were any other method call.
+func TestEthTxFromNativeAccount_BadInput(t *testing.T) {
+	blockTime := 10 * time.Millisecond
+	client, _, ens := kit.EnsembleMinimal(t, kit.MockProofs(), kit.ThroughRPC())
+
+	ens.InterconnectAll().BeginMining(blockTime)
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	msg := &types.Message{
+		From:   client.DefaultKey.Address,
+		To:     client.DefaultKey.Address,
+		Value:  abi.TokenAmount(types.MustParseFIL("100")),
+		Method: builtin2.MethodsEVM.InvokeContract,
+		Params: []byte{0x1, 0x2, 0x3, 0x4},
+	}
+
+	sMsg, err := client.MpoolPushMessage(ctx, msg, nil)
+	require.NoError(t, err)
+	client.WaitMsg(ctx, sMsg.Cid())
+	hash, err := client.EthGetTransactionHashByCid(ctx, sMsg.Cid())
+	require.NoError(t, err)
+	tx, err := client.EthGetTransactionByHash(ctx, hash)
+	require.NoError(t, err)
+
+	const expectedHex1 = "868e10c4" + // "handle filecoin method" function selector
+		// InvokeEVM method number
+		"00000000000000000000000000000000000000000000000000000000e525aa15" +
+		// CBOR multicodec (0x51)
+		"0000000000000000000000000000000000000000000000000000000000000051" +
+		// Offset
+		"0000000000000000000000000000000000000000000000000000000000000060" +
+		// Number of bytes in the input (4)
+		"0000000000000000000000000000000000000000000000000000000000000004" +
+		// Input: 1, 2, 3, 4
+		"0102030400000000000000000000000000000000000000000000000000000000"
+
+	input, err := hex.DecodeString(expectedHex1)
+	require.NoError(t, err)
+	require.EqualValues(t, input, tx.Input)
+
+}
+
+// Invoke a native method.
+func TestEthTxFromNativeAccount_NativeMethod(t *testing.T) {
+	blockTime := 10 * time.Millisecond
+	client, _, ens := kit.EnsembleMinimal(t, kit.MockProofs(), kit.ThroughRPC())
+
+	ens.InterconnectAll().BeginMining(blockTime)
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	msg := &types.Message{
+		From:   client.DefaultKey.Address,
+		To:     client.DefaultKey.Address,
+		Value:  abi.TokenAmount(types.MustParseFIL("100")),
+		Method: builtin2.MethodsEVM.InvokeContract + 1,
+		Params: []byte{0x1, 0x2, 0x3, 0x4},
+	}
+
+	sMsg, err := client.MpoolPushMessage(ctx, msg, nil)
+	require.NoError(t, err)
+	client.WaitMsg(ctx, sMsg.Cid())
+	hash, err := client.EthGetTransactionHashByCid(ctx, sMsg.Cid())
+	require.NoError(t, err)
+	tx, err := client.EthGetTransactionByHash(ctx, hash)
+	require.NoError(t, err)
+
+	const expectedHex = "868e10c4" + // "handle filecoin method" function selector
+		// InvokeEVM+1
+		"00000000000000000000000000000000000000000000000000000000e525aa16" +
+		// CBOR multicodec (0x51)
+		"0000000000000000000000000000000000000000000000000000000000000051" +
+		// Offset
+		"0000000000000000000000000000000000000000000000000000000000000060" +
+		// Number of bytes in the input (4)
+		"0000000000000000000000000000000000000000000000000000000000000004" +
+		// Input: 1, 2, 3, 4
+		"0102030400000000000000000000000000000000000000000000000000000000"
+	input, err := hex.DecodeString(expectedHex)
+	require.NoError(t, err)
+	require.EqualValues(t, input, tx.Input)
+}
+
+// Send to an invalid receiver. We're checking to make sure we correctly set `txn.To` to the special
+// "reverted" eth addr.
+func TestEthTxFromNativeAccount_InvalidReceiver(t *testing.T) {
+	blockTime := 10 * time.Millisecond
+	client, _, ens := kit.EnsembleMinimal(t, kit.MockProofs(), kit.ThroughRPC())
+
+	ens.InterconnectAll().BeginMining(blockTime)
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	to, err := address.NewActorAddress([]byte("foobar"))
+	require.NoError(t, err)
+
+	msg := &types.Message{
+		From:   client.DefaultKey.Address,
+		To:     to,
+		Value:  abi.TokenAmount(types.MustParseFIL("100")),
+		Method: builtin2.MethodsEVM.InvokeContract + 1,
+		Params: []byte{0x1, 0x2, 0x3, 0x4},
+		// We can't estimate gas for a failed message, so we hard-code these values.
+		GasLimit:  10_000_000,
+		GasFeeCap: abi.NewTokenAmount(10000),
+	}
+
+	// We expect the "to" address to be the special "reverted" eth address.
+	expectedTo, err := ethtypes.ParseEthAddress("ff0000000000000000000000ffffffffffffffff")
+	require.NoError(t, err)
+
+	sMsg, err := client.WalletSignMessage(ctx, client.DefaultKey.Address, msg)
+	require.NoError(t, err)
+	k, err := client.MpoolPush(ctx, sMsg)
+	require.NoError(t, err)
+	res, err := client.StateWaitMsg(ctx, k, 3, api.LookbackNoLimit, true)
+	require.NoError(t, err)
+	require.Equal(t, res.Receipt.ExitCode, exitcode.SysErrInvalidReceiver)
+
+	hash, err := client.EthGetTransactionHashByCid(ctx, k)
+	require.NoError(t, err)
+	tx, err := client.EthGetTransactionByHash(ctx, hash)
+	require.NoError(t, err)
+	require.EqualValues(t, &expectedTo, tx.To)
 }
diff --git a/itests/fevm_address_test.go b/itests/fevm_address_test.go
index 9eaac4647..aea56264e 100644
--- a/itests/fevm_address_test.go
+++ b/itests/fevm_address_test.go
@@ -1,7 +1,6 @@
 package itests
 
 import (
-	"bytes"
 	"context"
 	"encoding/hex"
 	"os"
@@ -14,8 +13,6 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	builtintypes "github.com/filecoin-project/go-state-types/builtin"
-	"github.com/filecoin-project/go-state-types/builtin/v10/eam"
-	"github.com/filecoin-project/go-state-types/exitcode"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/actors"
@@ -43,7 +40,7 @@ func effectiveEthAddressForCreate(t *testing.T, sender address.Address) ethtypes
 	panic("unreachable")
 }
 
-func createAndDeploy(ctx context.Context, t *testing.T, client *kit.TestFullNode, fromAddr address.Address, contract []byte) *api.MsgLookup {
+func createAndDeploy(ctx context.Context, t *testing.T, client *kit.TestFullNode, fromAddr address.Address, contract []byte) *api.EthTxReceipt {
 	// Create and deploy evm actor
 
 	method := builtintypes.MethodsEAM.CreateExternal
@@ -61,21 +58,13 @@ func createAndDeploy(ctx context.Context, t *testing.T, client *kit.TestFullNode
 	smsg, err := client.MpoolPushMessage(ctx, createMsg, nil)
 	require.NoError(t, err)
 
-	wait, err := client.StateWaitMsg(ctx, smsg.Cid(), 0, 0, false)
-	require.NoError(t, err)
-	require.Equal(t, exitcode.Ok, wait.Receipt.ExitCode)
-	return wait
-}
-
-func getEthAddressTX(ctx context.Context, t *testing.T, client *kit.TestFullNode, wait *api.MsgLookup, ethAddr ethtypes.EthAddress) ethtypes.EthAddress {
-	// Check if eth address returned from CreateExternal is the same as eth address predicted at the start
-	var createExternalReturn eam.CreateExternalReturn
-	err := createExternalReturn.UnmarshalCBOR(bytes.NewReader(wait.Receipt.Return))
+	txHash, err := client.EthGetTransactionHashByCid(ctx, smsg.Cid())
 	require.NoError(t, err)
 
-	createdEthAddr, err := ethtypes.CastEthAddress(createExternalReturn.EthAddress[:])
+	receipt, err := client.EVM().WaitTransaction(ctx, *txHash)
 	require.NoError(t, err)
-	return createdEthAddr
+	require.EqualValues(t, ethtypes.EthUint64(0x1), receipt.Status)
+	return receipt
 }
 
 func TestAddressCreationBeforeDeploy(t *testing.T) {
@@ -112,11 +101,11 @@ func TestAddressCreationBeforeDeploy(t *testing.T) {
 	require.True(t, builtin.IsPlaceholderActor(actor.Code))
 
 	// Create and deploy evm actor
-	wait := createAndDeploy(ctx, t, client, fromAddr, contract)
+	receipt := createAndDeploy(ctx, t, client, fromAddr, contract)
 
-	// Check if eth address returned from CreateExternal is the same as eth address predicted at the start
-	createdEthAddr := getEthAddressTX(ctx, t, client, wait, ethAddr)
-	require.Equal(t, ethAddr, createdEthAddr)
+	// Check if eth address returned from CreateExternal is the same as eth address predicted at
+	// the start
+	require.Equal(t, &ethAddr, receipt.ContractAddress)
 
 	// Check if newly deployed actor still has funds
 	actorPostCreate, err := client.StateGetActor(ctx, contractFilAddr, types.EmptyTSK)
@@ -158,11 +147,11 @@ func TestDeployAddressMultipleTimes(t *testing.T) {
 	require.True(t, builtin.IsPlaceholderActor(actor.Code))
 
 	// Create and deploy evm actor
-	wait := createAndDeploy(ctx, t, client, fromAddr, contract)
+	receipt := createAndDeploy(ctx, t, client, fromAddr, contract)
 
-	// Check if eth address returned from CreateExternal is the same as eth address predicted at the start
-	createdEthAddr := getEthAddressTX(ctx, t, client, wait, ethAddr)
-	require.Equal(t, ethAddr, createdEthAddr)
+	// Check if eth address returned from CreateExternal is the same as eth address predicted at
+	// the start
+	require.Equal(t, &ethAddr, receipt.ContractAddress)
 
 	// Check if newly deployed actor still has funds
 	actorPostCreate, err := client.StateGetActor(ctx, contractFilAddr, types.EmptyTSK)
@@ -171,10 +160,9 @@ func TestDeployAddressMultipleTimes(t *testing.T) {
 	require.True(t, builtin.IsEvmActor(actorPostCreate.Code))
 
 	// Create and deploy evm actor
-	wait = createAndDeploy(ctx, t, client, fromAddr, contract)
+	receipt = createAndDeploy(ctx, t, client, fromAddr, contract)
 
 	// Check that this time eth address returned from CreateExternal is not the same as eth address predicted at the start
-	createdEthAddr = getEthAddressTX(ctx, t, client, wait, ethAddr)
-	require.NotEqual(t, ethAddr, createdEthAddr)
+	require.NotEqual(t, &ethAddr, receipt.ContractAddress)
 
 }
diff --git a/itests/fevm_test.go b/itests/fevm_test.go
index cb69c036c..2dcb8ef1d 100644
--- a/itests/fevm_test.go
+++ b/itests/fevm_test.go
@@ -6,6 +6,7 @@ import (
 	"crypto/rand"
 	"encoding/binary"
 	"encoding/hex"
+	"encoding/json"
 	"fmt"
 	"testing"
 	"time"
@@ -657,11 +658,15 @@ func TestFEVMRecursiveActorCallEstimate(t *testing.T) {
 			t.Logf("running with %d recursive calls", r)
 
 			params := makeParams(r)
-			gaslimit, err := client.EthEstimateGas(ctx, ethtypes.EthCall{
+
+			gasParams, err := json.Marshal(ethtypes.EthEstimateGasParams{Tx: ethtypes.EthCall{
 				From: &ethAddr,
 				To:   &contractAddr,
 				Data: params,
-			})
+			}})
+			require.NoError(t, err)
+
+			gaslimit, err := client.EthEstimateGas(ctx, gasParams)
 			require.NoError(t, err)
 			require.LessOrEqual(t, int64(gaslimit), build.BlockGasLimit)
 
@@ -816,11 +821,14 @@ func TestFEVMBareTransferTriggersSmartContractLogic(t *testing.T) {
 	contractEth, err := ethtypes.EthAddressFromFilecoinAddress(contractAddr)
 	require.NoError(t, err)
 
-	gaslimit, err := client.EthEstimateGas(ctx, ethtypes.EthCall{
+	gasParams, err := json.Marshal(ethtypes.EthEstimateGasParams{Tx: ethtypes.EthCall{
 		From:  &accntEth,
 		To:    &contractEth,
 		Value: ethtypes.EthBigInt(big.NewInt(100)),
-	})
+	}})
+	require.NoError(t, err)
+
+	gaslimit, err := client.EthEstimateGas(ctx, gasParams)
 	require.NoError(t, err)
 
 	maxPriorityFeePerGas, err := client.EthMaxPriorityFeePerGas(ctx)
@@ -1034,10 +1042,13 @@ func TestFEVMErrorParsing(t *testing.T) {
 				require.ErrorContains(t, err, expected)
 			})
 			t.Run("EthEstimateGas", func(t *testing.T) {
-				_, err := e.EthEstimateGas(ctx, ethtypes.EthCall{
+				gasParams, err := json.Marshal(ethtypes.EthEstimateGasParams{Tx: ethtypes.EthCall{
 					To:   &contractAddrEth,
 					Data: entryPoint,
-				})
+				}})
+				require.NoError(t, err)
+
+				_, err = e.EthEstimateGas(ctx, gasParams)
 				require.ErrorContains(t, err, expected)
 			})
 		})
diff --git a/itests/harmonydb_test.go b/itests/harmonydb_test.go
new file mode 100644
index 000000000..8b1b61234
--- /dev/null
+++ b/itests/harmonydb_test.go
@@ -0,0 +1,174 @@
+package itests
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"testing"
+
+	"github.com/filecoin-project/lotus/itests/kit"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/node/impl"
+)
+
+func withSetup(t *testing.T, f func(*kit.TestMiner)) {
+	_, miner, _ := kit.EnsembleMinimal(t,
+		kit.LatestActorsAt(-1),
+		kit.MockProofs(),
+		kit.WithSectorIndexDB(),
+	)
+
+	f(miner)
+}
+
+func TestCrud(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	withSetup(t, func(miner *kit.TestMiner) {
+		cdb := miner.BaseAPI.(*impl.StorageMinerAPI).HarmonyDB
+		_, err := cdb.Exec(ctx, `
+			INSERT INTO 
+				itest_scratch (some_int, content) 
+			VALUES 
+				(11, 'cows'), 
+				(5, 'cats')
+		`)
+		if err != nil {
+			t.Fatal("Could not insert: ", err)
+		}
+		var ints []struct {
+			Count       int    `db:"some_int"`
+			Animal      string `db:"content"`
+			Unpopulated int
+		}
+		err = cdb.Select(ctx, &ints, "SELECT content, some_int FROM itest_scratch")
+		if err != nil {
+			t.Fatal("Could not select: ", err)
+		}
+		if len(ints) != 2 {
+			t.Fatal("unexpected count of returns. Want 2, Got ", len(ints))
+		}
+		if ints[0].Count != 11 || ints[1].Count != 5 {
+			t.Fatal("expected [11,5] got ", ints)
+		}
+		if ints[0].Animal != "cows" || ints[1].Animal != "cats" {
+			t.Fatal("expected, [cows, cats] ", ints)
+		}
+		fmt.Println("test completed")
+	})
+}
+
+func TestTransaction(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	withSetup(t, func(miner *kit.TestMiner) {
+		cdb := miner.BaseAPI.(*impl.StorageMinerAPI).HarmonyDB
+		if _, err := cdb.Exec(ctx, "INSERT INTO itest_scratch (some_int) VALUES (4), (5), (6)"); err != nil {
+			t.Fatal("E0", err)
+		}
+		_, err := cdb.BeginTransaction(ctx, func(tx *harmonydb.Tx) (commit bool, err error) {
+			if _, err := tx.Exec("INSERT INTO itest_scratch (some_int) VALUES (7), (8), (9)"); err != nil {
+				t.Fatal("E1", err)
+			}
+
+			// sum1 is read from OUTSIDE the transaction so it's the old value
+			var sum1 int
+			if err := cdb.QueryRow(ctx, "SELECT SUM(some_int) FROM itest_scratch").Scan(&sum1); err != nil {
+				t.Fatal("E2", err)
+			}
+			if sum1 != 4+5+6 {
+				t.Fatal("Expected 15, got ", sum1)
+			}
+
+			// sum2 is from INSIDE the transaction, so the updated value.
+			var sum2 int
+			if err := tx.QueryRow("SELECT SUM(some_int) FROM itest_scratch").Scan(&sum2); err != nil {
+				t.Fatal("E3", err)
+			}
+			if sum2 != 4+5+6+7+8+9 {
+				t.Fatal("Expected 39, got ", sum2)
+			}
+			return false, nil // rollback
+		})
+		if err != nil {
+			t.Fatal("ET", err)
+		}
+
+		var sum2 int
+		// Query() example (yes, QueryRow would be preferred here)
+		q, err := cdb.Query(ctx, "SELECT SUM(some_int) FROM itest_scratch")
+		if err != nil {
+			t.Fatal("E4", err)
+		}
+		defer q.Close()
+		var rowCt int
+		for q.Next() {
+			err := q.Scan(&sum2)
+			if err != nil {
+				t.Fatal("error scanning ", err)
+			}
+			rowCt++
+		}
+		if sum2 != 4+5+6 {
+			t.Fatal("Expected 15, got ", sum2)
+		}
+		if rowCt != 1 {
+			t.Fatal("unexpected count of rows")
+		}
+	})
+}
+
+func TestPartialWalk(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	withSetup(t, func(miner *kit.TestMiner) {
+		cdb := miner.BaseAPI.(*impl.StorageMinerAPI).HarmonyDB
+		if _, err := cdb.Exec(ctx, `
+			INSERT INTO 
+				itest_scratch (content, some_int) 
+			VALUES 
+				('andy was here', 5), 
+				('lotus is awesome', 6), 
+				('hello world', 7),
+				('3rd integration test', 8),
+				('fiddlesticks', 9)
+			`); err != nil {
+			t.Fatal("e1", err)
+		}
+
+		// TASK: FIND THE ID of the string with a specific SHA256
+		needle := "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
+		q, err := cdb.Query(ctx, `SELECT id, content FROM itest_scratch`)
+		if err != nil {
+			t.Fatal("e2", err)
+		}
+		defer q.Close()
+
+		var tmp struct {
+			Src string `db:"content"`
+			ID  int
+		}
+
+		var done bool
+		for q.Next() {
+
+			if err := q.StructScan(&tmp); err != nil {
+				t.Fatal("structscan err " + err.Error())
+			}
+
+			bSha := sha256.Sum256([]byte(tmp.Src))
+			if hex.EncodeToString(bSha[:]) == needle {
+				done = true
+				break
+			}
+		}
+		if !done {
+			t.Fatal("We didn't find it.")
+		}
+		// Answer: tmp.ID
+	})
+}
diff --git a/itests/harmonytask_test.go b/itests/harmonytask_test.go
new file mode 100644
index 000000000..ab54cbef4
--- /dev/null
+++ b/itests/harmonytask_test.go
@@ -0,0 +1,266 @@
+package itests
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sort"
+	"sync"
+	"testing"
+	"time"
+
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/lotus/itests/kit"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonytask"
+	"github.com/filecoin-project/lotus/lib/harmony/resources"
+	"github.com/filecoin-project/lotus/node/impl"
+)
+
+type task1 struct {
+	toAdd               []int
+	myPersonalTableLock sync.Mutex
+	myPersonalTable     map[harmonytask.TaskID]int // This would typically be a DB table
+	WorkCompleted       []string
+}
+
+func withDbSetup(t *testing.T, f func(*kit.TestMiner)) {
+	_, miner, _ := kit.EnsembleMinimal(t,
+		kit.LatestActorsAt(-1),
+		kit.MockProofs(),
+		kit.WithSectorIndexDB(),
+	)
+	logging.SetLogLevel("harmonytask", "debug")
+
+	f(miner)
+}
+
+func (t *task1) Do(tID harmonytask.TaskID, stillOwned func() bool) (done bool, err error) {
+	if !stillOwned() {
+		return false, errors.New("Why not still owned?")
+	}
+	t.myPersonalTableLock.Lock()
+	defer t.myPersonalTableLock.Unlock()
+	t.WorkCompleted = append(t.WorkCompleted, fmt.Sprintf("taskResult%d", t.myPersonalTable[tID]))
+	return true, nil
+}
+func (t *task1) CanAccept(list []harmonytask.TaskID, e *harmonytask.TaskEngine) (*harmonytask.TaskID, error) {
+	return &list[0], nil
+}
+func (t *task1) TypeDetails() harmonytask.TaskTypeDetails {
+	return harmonytask.TaskTypeDetails{
+		Max:         100,
+		Name:        "ThingOne",
+		MaxFailures: 1,
+		Cost: resources.Resources{
+			Cpu: 1,
+			Ram: 100 << 10, // at 100kb, it's tiny
+		},
+	}
+}
+func (t *task1) Adder(add harmonytask.AddTaskFunc) {
+	for _, vTmp := range t.toAdd {
+		v := vTmp
+		add(func(tID harmonytask.TaskID, tx *harmonydb.Tx) (bool, error) {
+			t.myPersonalTableLock.Lock()
+			defer t.myPersonalTableLock.Unlock()
+
+			t.myPersonalTable[tID] = v
+			return true, nil
+		})
+	}
+}
+
+func init() {
+	//logging.SetLogLevel("harmonydb", "debug")
+	//logging.SetLogLevel("harmonytask", "debug")
+}
+
+func TestHarmonyTasks(t *testing.T) {
+	//t.Parallel()
+	withDbSetup(t, func(m *kit.TestMiner) {
+		cdb := m.BaseAPI.(*impl.StorageMinerAPI).HarmonyDB
+		t1 := &task1{
+			toAdd:           []int{56, 73},
+			myPersonalTable: map[harmonytask.TaskID]int{},
+		}
+		harmonytask.POLL_DURATION = time.Millisecond * 100
+		e, err := harmonytask.New(cdb, []harmonytask.TaskInterface{t1}, "test:1")
+		require.NoError(t, err)
+		time.Sleep(time.Second) // do the work. FLAKYNESS RISK HERE.
+		e.GracefullyTerminate(time.Minute)
+		expected := []string{"taskResult56", "taskResult73"}
+		sort.Strings(t1.WorkCompleted)
+		require.Equal(t, expected, t1.WorkCompleted, "unexpected results")
+	})
+}
+
+type passthru struct {
+	dtl       harmonytask.TaskTypeDetails
+	do        func(tID harmonytask.TaskID, stillOwned func() bool) (done bool, err error)
+	canAccept func(list []harmonytask.TaskID, e *harmonytask.TaskEngine) (*harmonytask.TaskID, error)
+	adder     func(add harmonytask.AddTaskFunc)
+}
+
+func (t *passthru) Do(tID harmonytask.TaskID, stillOwned func() bool) (done bool, err error) {
+	return t.do(tID, stillOwned)
+}
+func (t *passthru) CanAccept(list []harmonytask.TaskID, e *harmonytask.TaskEngine) (*harmonytask.TaskID, error) {
+	return t.canAccept(list, e)
+}
+func (t *passthru) TypeDetails() harmonytask.TaskTypeDetails {
+	return t.dtl
+}
+func (t *passthru) Adder(add harmonytask.AddTaskFunc) {
+	if t.adder != nil {
+		t.adder(add)
+	}
+}
+
+// Common stuff
+var dtl = harmonytask.TaskTypeDetails{Name: "foo", Max: -1, Cost: resources.Resources{}}
+var lettersMutex sync.Mutex
+
+func fooLetterAdder(t *testing.T, cdb *harmonydb.DB) *passthru {
+	return &passthru{
+		dtl: dtl,
+		canAccept: func(list []harmonytask.TaskID, e *harmonytask.TaskEngine) (*harmonytask.TaskID, error) {
+			return nil, nil
+		},
+		adder: func(add harmonytask.AddTaskFunc) {
+			for _, vTmp := range []string{"A", "B"} {
+				v := vTmp
+				add(func(tID harmonytask.TaskID, tx *harmonydb.Tx) (bool, error) {
+					_, err := tx.Exec("INSERT INTO itest_scratch (some_int, content) VALUES ($1,$2)", tID, v)
+					require.NoError(t, err)
+					return true, nil
+				})
+			}
+		},
+	}
+}
+func fooLetterSaver(t *testing.T, cdb *harmonydb.DB, dest *[]string) *passthru {
+	return &passthru{
+		dtl: dtl,
+		canAccept: func(list []harmonytask.TaskID, e *harmonytask.TaskEngine) (*harmonytask.TaskID, error) {
+			return &list[0], nil
+		},
+		do: func(tID harmonytask.TaskID, stillOwned func() bool) (done bool, err error) {
+			var content string
+			err = cdb.QueryRow(context.Background(),
+				"SELECT content FROM itest_scratch WHERE some_int=$1", tID).Scan(&content)
+			require.NoError(t, err)
+			lettersMutex.Lock()
+			defer lettersMutex.Unlock()
+			*dest = append(*dest, content)
+			return true, nil
+		},
+	}
+}
+
+func TestHarmonyTasksWith2PartiesPolling(t *testing.T) {
+	//t.Parallel()
+	withDbSetup(t, func(m *kit.TestMiner) {
+		cdb := m.BaseAPI.(*impl.StorageMinerAPI).HarmonyDB
+		senderParty := fooLetterAdder(t, cdb)
+		var dest []string
+		workerParty := fooLetterSaver(t, cdb, &dest)
+		harmonytask.POLL_DURATION = time.Millisecond * 100
+		sender, err := harmonytask.New(cdb, []harmonytask.TaskInterface{senderParty}, "test:1")
+		require.NoError(t, err)
+		worker, err := harmonytask.New(cdb, []harmonytask.TaskInterface{workerParty}, "test:2")
+		require.NoError(t, err)
+		time.Sleep(time.Second) // do the work. FLAKYNESS RISK HERE.
+		sender.GracefullyTerminate(time.Second * 5)
+		worker.GracefullyTerminate(time.Second * 5)
+		sort.Strings(dest)
+		require.Equal(t, []string{"A", "B"}, dest)
+	})
+}
+
+func TestWorkStealing(t *testing.T) {
+	//t.Parallel()
+	withDbSetup(t, func(m *kit.TestMiner) {
+		cdb := m.BaseAPI.(*impl.StorageMinerAPI).HarmonyDB
+		ctx := context.Background()
+
+		// The dead worker will be played by a few SQL INSERTS.
+		_, err := cdb.Exec(ctx, `INSERT INTO harmony_machines
+		(id, last_contact,host_and_port, cpu, ram, gpu)
+		VALUES (300, DATE '2000-01-01', 'test:1', 4, 400000, 1)`)
+		require.ErrorIs(t, err, nil)
+		_, err = cdb.Exec(ctx, `INSERT INTO harmony_task 
+		(id, name, owner_id, posted_time, added_by) 
+		VALUES (1234, 'foo', 300, DATE '2000-01-01', 300)`)
+		require.ErrorIs(t, err, nil)
+		_, err = cdb.Exec(ctx, "INSERT INTO itest_scratch (some_int, content) VALUES (1234, 'M')")
+		require.ErrorIs(t, err, nil)
+
+		harmonytask.POLL_DURATION = time.Millisecond * 100
+		harmonytask.CLEANUP_FREQUENCY = time.Millisecond * 100
+		var dest []string
+		worker, err := harmonytask.New(cdb, []harmonytask.TaskInterface{fooLetterSaver(t, cdb, &dest)}, "test:2")
+		require.ErrorIs(t, err, nil)
+		time.Sleep(time.Second) // do the work. FLAKYNESS RISK HERE.
+		worker.GracefullyTerminate(time.Second * 5)
+		require.Equal(t, []string{"M"}, dest)
+	})
+}
+
+func TestTaskRetry(t *testing.T) {
+	//t.Parallel()
+	withDbSetup(t, func(m *kit.TestMiner) {
+		cdb := m.BaseAPI.(*impl.StorageMinerAPI).HarmonyDB
+		senderParty := fooLetterAdder(t, cdb)
+		harmonytask.POLL_DURATION = time.Millisecond * 100
+		sender, err := harmonytask.New(cdb, []harmonytask.TaskInterface{senderParty}, "test:1")
+		require.NoError(t, err)
+
+		alreadyFailed := map[string]bool{}
+		var dest []string
+		fails2xPerMsg := &passthru{
+			dtl: dtl,
+			canAccept: func(list []harmonytask.TaskID, e *harmonytask.TaskEngine) (*harmonytask.TaskID, error) {
+				return &list[0], nil
+			},
+			do: func(tID harmonytask.TaskID, stillOwned func() bool) (done bool, err error) {
+				var content string
+				err = cdb.QueryRow(context.Background(),
+					"SELECT content FROM itest_scratch WHERE some_int=$1", tID).Scan(&content)
+				require.NoError(t, err)
+				lettersMutex.Lock()
+				defer lettersMutex.Unlock()
+				if !alreadyFailed[content] {
+					alreadyFailed[content] = true
+					return false, errors.New("intentional 'error'")
+				}
+				dest = append(dest, content)
+				return true, nil
+			},
+		}
+		rcv, err := harmonytask.New(cdb, []harmonytask.TaskInterface{fails2xPerMsg}, "test:2")
+		require.NoError(t, err)
+		time.Sleep(time.Second)
+		sender.GracefullyTerminate(time.Hour)
+		rcv.GracefullyTerminate(time.Hour)
+		sort.Strings(dest)
+		require.Equal(t, []string{"A", "B"}, dest)
+		type hist struct {
+			TaskID int
+			Result bool
+			Err    string
+		}
+		var res []hist
+		require.NoError(t, cdb.Select(context.Background(), &res,
+			`SELECT task_id, result, err FROM harmony_task_history
+			 ORDER BY result DESC, task_id`))
+
+		require.Equal(t, []hist{
+			{1, true, ""},
+			{2, true, ""},
+			{1, false, "error: intentional 'error'"},
+			{2, false, "error: intentional 'error'"}}, res)
+	})
+}
diff --git a/itests/kit/ensemble.go b/itests/kit/ensemble.go
index 45f21786d..3c83ba896 100644
--- a/itests/kit/ensemble.go
+++ b/itests/kit/ensemble.go
@@ -49,11 +49,13 @@ import (
 	"github.com/filecoin-project/lotus/cmd/lotus-worker/sealworker"
 	"github.com/filecoin-project/lotus/gateway"
 	"github.com/filecoin-project/lotus/genesis"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
 	"github.com/filecoin-project/lotus/markets/idxprov"
 	"github.com/filecoin-project/lotus/markets/idxprov/idxprov_test"
 	lotusminer "github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node"
 	"github.com/filecoin-project/lotus/node/config"
+	"github.com/filecoin-project/lotus/node/impl"
 	"github.com/filecoin-project/lotus/node/modules"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	testing2 "github.com/filecoin-project/lotus/node/modules/testing"
@@ -359,6 +361,8 @@ func (n *Ensemble) Start() *Ensemble {
 		n.mn = mocknet.New()
 	}
 
+	sharedITestID := harmonydb.ITestNewID()
+
 	// ---------------------
 	//  FULL NODES
 	// ---------------------
@@ -603,6 +607,7 @@ func (n *Ensemble) Start() *Ensemble {
 		cfg.Subsystems.EnableMining = m.options.subsystems.Has(SMining)
 		cfg.Subsystems.EnableSealing = m.options.subsystems.Has(SSealing)
 		cfg.Subsystems.EnableSectorStorage = m.options.subsystems.Has(SSectorStorage)
+		cfg.Subsystems.EnableSectorIndexDB = m.options.subsystems.Has(SHarmony)
 		cfg.Dealmaking.MaxStagingDealsBytes = m.options.maxStagingDealsBytes
 
 		if m.options.mainMiner != nil {
@@ -724,6 +729,17 @@ func (n *Ensemble) Start() *Ensemble {
 
 			// upgrades
 			node.Override(new(stmgr.UpgradeSchedule), n.options.upgradeSchedule),
+
+			node.Override(new(harmonydb.ITestID), sharedITestID),
+			node.Override(new(config.HarmonyDB), func() config.HarmonyDB {
+				return config.HarmonyDB{
+					Hosts:    []string{envElse("LOTUS_HARMONYDB_HOSTS", "127.0.0.1")},
+					Database: "yugabyte",
+					Username: "yugabyte",
+					Password: "yugabyte",
+					Port:     "5433",
+				}
+			}),
 		}
 
 		if m.options.subsystems.Has(SMarkets) {
@@ -770,6 +786,12 @@ func (n *Ensemble) Start() *Ensemble {
 		require.NoError(n.t, err)
 
 		n.t.Cleanup(func() { _ = stop(context.Background()) })
+		mCopy := m
+		n.t.Cleanup(func() {
+			if mCopy.BaseAPI.(*impl.StorageMinerAPI).HarmonyDB != nil {
+				mCopy.BaseAPI.(*impl.StorageMinerAPI).HarmonyDB.ITestDeleteAll()
+			}
+		})
 
 		m.BaseAPI = m.StorageMiner
 
@@ -826,6 +848,8 @@ func (n *Ensemble) Start() *Ensemble {
 
 		auth := http.Header(nil)
 
+		// FUTURE: Use m.MinerNode.(BaseAPI).(impl.StorageMinerAPI).HarmonyDB to setup.
+
 		remote := paths.NewRemote(localStore, m.MinerNode, auth, 20, &paths.DefaultPartialFileHandler{})
 		store := m.options.workerStorageOpt(remote)
 
@@ -855,6 +879,7 @@ func (n *Ensemble) Start() *Ensemble {
 		require.NoError(n.t, err)
 
 		n.active.workers = append(n.active.workers, m)
+
 	}
 
 	// If we are here, we have processed all inactive workers and moved them
@@ -1067,3 +1092,10 @@ func importPreSealMeta(ctx context.Context, meta genesis.Miner, mds dtypes.Metad
 	size := binary.PutUvarint(buf, uint64(maxSectorID))
 	return mds.Put(ctx, datastore.NewKey(pipeline.StorageCounterDSPrefix), buf[:size])
 }
+
+func envElse(env, els string) string {
+	if v := os.Getenv(env); v != "" {
+		return v
+	}
+	return els
+}
diff --git a/itests/kit/evm.go b/itests/kit/evm.go
index 99844ca30..0d7af2578 100644
--- a/itests/kit/evm.go
+++ b/itests/kit/evm.go
@@ -17,6 +17,7 @@ import (
 	"github.com/stretchr/testify/require"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/crypto/sha3"
+	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
 	amt4 "github.com/filecoin-project/go-amt-ipld/v4"
@@ -291,6 +292,17 @@ func (e *EVM) InvokeContractByFuncNameExpectExit(ctx context.Context, fromAddr a
 	require.Equal(e.t, exit, wait.Receipt.ExitCode)
 }
 
+func (e *EVM) WaitTransaction(ctx context.Context, hash ethtypes.EthHash) (*api.EthTxReceipt, error) {
+	if mcid, err := e.EthGetMessageCidByTransactionHash(ctx, &hash); err != nil {
+		return nil, err
+	} else if mcid == nil {
+		return nil, xerrors.Errorf("couldn't find message CID for txn hash: %s", hash)
+	} else {
+		e.WaitMsg(ctx, *mcid)
+		return e.EthGetTransactionReceipt(ctx, hash)
+	}
+}
+
 // function signatures are the first 4 bytes of the hash of the function name and types
 func CalcFuncSignature(funcName string) []byte {
 	hasher := sha3.NewLegacyKeccak256()
diff --git a/itests/kit/node_miner.go b/itests/kit/node_miner.go
index 4b81c9df0..ee2ee3eaa 100644
--- a/itests/kit/node_miner.go
+++ b/itests/kit/node_miner.go
@@ -37,6 +37,8 @@ const (
 	SSealing
 	SSectorStorage
 
+	SHarmony
+
 	MinerSubsystems = iota
 )
 
diff --git a/itests/kit/node_opts.go b/itests/kit/node_opts.go
index 6469c0a30..9af284148 100644
--- a/itests/kit/node_opts.go
+++ b/itests/kit/node_opts.go
@@ -89,6 +89,13 @@ func WithAllSubsystems() NodeOpt {
 	}
 }
 
+func WithSectorIndexDB() NodeOpt {
+	return func(opts *nodeOpts) error {
+		opts.subsystems = opts.subsystems.Add(SHarmony)
+		return nil
+	}
+}
+
 func WithSubsystems(systems ...MinerSubsystem) NodeOpt {
 	return func(opts *nodeOpts) error {
 		for _, s := range systems {
diff --git a/itests/path_type_filters_test.go b/itests/path_type_filters_test.go
index d41e2c215..c668976ac 100644
--- a/itests/path_type_filters_test.go
+++ b/itests/path_type_filters_test.go
@@ -15,6 +15,7 @@ import (
 )
 
 func TestPathTypeFilters(t *testing.T) {
+
 	runTest := func(t *testing.T, name string, asserts func(t *testing.T, ctx context.Context, miner *kit.TestMiner, run func())) {
 		t.Run(name, func(t *testing.T) {
 			ctx, cancel := context.WithCancel(context.Background())
diff --git a/itests/sector_pledge_test.go b/itests/sector_pledge_test.go
index 1e045c79d..b4e5c1133 100644
--- a/itests/sector_pledge_test.go
+++ b/itests/sector_pledge_test.go
@@ -223,3 +223,29 @@ func TestPledgeSynth(t *testing.T) {
 		runTest(t, 3)
 	})
 }
+
+func TestSectorsSummary(t *testing.T) {
+	kit.QuietMiningLogs()
+
+	blockTime := 50 * time.Millisecond
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	nPreseal := 2
+
+	_, miner, ens := kit.EnsembleMinimal(t, kit.MockProofs(), kit.PresealSectors(nPreseal))
+	ens.InterconnectAll().BeginMining(blockTime)
+
+	miner.PledgeSectors(ctx, 1, 0, nil)
+
+	ms, err := miner.SectorsSummary(ctx)
+	require.NoError(t, err)
+
+	require.Len(t, ms, 1) // all proving
+
+	for st, n := range ms {
+		require.Equal(t, api.SectorState(sealing.Proving), st)
+		require.Equal(t, 1+nPreseal, n)
+	}
+}
diff --git a/itests/wdpost_worker_config_test.go b/itests/wdpost_worker_config_test.go
index d1672c20f..ca22d82e4 100644
--- a/itests/wdpost_worker_config_test.go
+++ b/itests/wdpost_worker_config_test.go
@@ -139,7 +139,7 @@ func TestWindowPostNoBuiltinWindowWithWorker(t *testing.T) {
 
 	t.Log("post message landed")
 
-	bm.MineBlocks(ctx, 2*time.Millisecond)
+	bm.MineBlocksMustPost(ctx, 2*time.Millisecond)
 
 	waitUntil = di.Open + di.WPoStChallengeWindow*3
 	t.Logf("End for head.Height > %d", waitUntil)
diff --git a/itests/worker_test.go b/itests/worker_test.go
index c4f885fb0..31ec40b59 100644
--- a/itests/worker_test.go
+++ b/itests/worker_test.go
@@ -146,7 +146,7 @@ func TestWindowPostWorker(t *testing.T) {
 	di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
-	bm := ens.InterconnectAll().BeginMining(2 * time.Millisecond)[0]
+	bm := ens.InterconnectAll().BeginMiningMustPost(2 * time.Millisecond)[0]
 
 	di = di.NextNotElapsed()
 
@@ -172,7 +172,7 @@ func TestWindowPostWorker(t *testing.T) {
 
 	t.Log("post message landed")
 
-	bm.MineBlocks(ctx, 2*time.Millisecond)
+	bm.MineBlocksMustPost(ctx, 2*time.Millisecond)
 
 	waitUntil = di.Open + di.WPoStChallengeWindow*3
 	t.Logf("End for head.Height > %d", waitUntil)
@@ -235,6 +235,8 @@ func TestWindowPostWorker(t *testing.T) {
 type badWorkerStorage struct {
 	paths.Store
 
+	t *testing.T
+
 	badsector   *uint64
 	notBadCount int
 }
@@ -242,10 +244,12 @@ type badWorkerStorage struct {
 func (bs *badWorkerStorage) GenerateSingleVanillaProof(ctx context.Context, minerID abi.ActorID, si storiface.PostSectorChallenge, ppt abi.RegisteredPoStProof) ([]byte, error) {
 	if atomic.LoadUint64(bs.badsector) == uint64(si.SectorNumber) {
 		bs.notBadCount--
+		bs.t.Logf("Generating proof for sector %d maybe bad nbc=%d", si.SectorNumber, bs.notBadCount)
 		if bs.notBadCount < 0 {
 			return nil, xerrors.New("no proof for you")
 		}
 	}
+	bs.t.Logf("Generating proof for sector %d", si.SectorNumber)
 	return bs.Store.GenerateSingleVanillaProof(ctx, minerID, si, ppt)
 }
 
@@ -268,6 +272,7 @@ func TestWindowPostWorkerSkipBadSector(t *testing.T) {
 			return &badWorkerStorage{
 				Store:     store,
 				badsector: &badsector,
+				t:         t,
 			}
 		}),
 		kit.ConstructorOpts(node.ApplyIf(node.IsType(repo.StorageMiner),
@@ -275,6 +280,7 @@ func TestWindowPostWorkerSkipBadSector(t *testing.T) {
 				return &badWorkerStorage{
 					Store:       store,
 					badsector:   &badsector,
+					t:           t,
 					notBadCount: 1,
 				}
 			}))))
@@ -506,157 +512,6 @@ func TestWorkerName(t *testing.T) {
 	require.True(t, found)
 }
 
-// Tests that V1_1 proofs on post workers with faults
-func TestWindowPostV1P1NV20WorkerFault(t *testing.T) {
-	kit.QuietMiningLogs()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	blocktime := 2 * time.Millisecond
-
-	sectors := 2 * 48 * 2
-	var badsector uint64 = 100000
-
-	client, miner, _, ens := kit.EnsembleWorker(t,
-		kit.PresealSectors(sectors), // 2 sectors per partition, 2 partitions in all 48 deadlines
-		kit.GenesisNetworkVersion(network.Version20),
-		kit.ConstructorOpts(
-			node.Override(new(config.ProvingConfig), func() config.ProvingConfig {
-				c := config.DefaultStorageMiner()
-				c.Proving.DisableBuiltinWindowPoSt = true
-				return c.Proving
-			}),
-			node.Override(new(*wdpost.WindowPoStScheduler), modules.WindowPostScheduler(
-				config.DefaultStorageMiner().Fees,
-				config.ProvingConfig{
-					DisableBuiltinWindowPoSt:  true,
-					DisableBuiltinWinningPoSt: false,
-					DisableWDPoStPreChecks:    false,
-				},
-			)),
-			node.Override(new(paths.Store), func(store *paths.Remote) paths.Store {
-				return &badWorkerStorage{
-					Store:       store,
-					badsector:   &badsector,
-					notBadCount: 1,
-				}
-			})),
-		kit.ThroughRPC(),
-		kit.WithTaskTypes([]sealtasks.TaskType{sealtasks.TTGenerateWindowPoSt}),
-		kit.WithWorkerStorage(func(store paths.Store) paths.Store {
-			return &badWorkerStorage{
-				Store:     store,
-				badsector: &badsector,
-			}
-		}))
-
-	bm := ens.InterconnectAll().BeginMining(blocktime)[0]
-
-	maddr, err := miner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	// wait for sectors to be committed
-	require.Eventually(t, func() bool {
-		di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-		require.NoError(t, err)
-
-		parts, err := client.StateMinerPartitions(ctx, maddr, di.Index, types.EmptyTSK)
-		require.NoError(t, err)
-
-		return len(parts) > 1
-	}, 30*time.Second, 100*time.Millisecond)
-
-	// Wait until just before a deadline opens
-	{
-		di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-		require.NoError(t, err)
-
-		di = di.NextNotElapsed()
-
-		t.Log("Running one proving period")
-		waitUntil := di.Open + di.WPoStChallengeWindow - di.WPoStChallengeLookback - 1
-		client.WaitTillChain(ctx, kit.HeightAtLeast(waitUntil))
-
-		t.Log("Waiting for post message")
-		bm.Stop()
-	}
-
-	// Remove one sector in the next deadline (so it's skipped)
-	{
-		di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-		require.NoError(t, err)
-
-		parts, err := client.StateMinerPartitions(ctx, maddr, di.Index+1, types.EmptyTSK)
-		require.NoError(t, err)
-		require.Greater(t, len(parts), 0)
-
-		secs := parts[0].AllSectors
-		n, err := secs.Count()
-		require.NoError(t, err)
-		require.Equal(t, uint64(2), n)
-
-		// Drop the sector in first partition
-		sid, err := secs.First()
-		require.NoError(t, err)
-
-		t.Logf("Drop sector %d; dl %d part %d", sid, di.Index, 0)
-
-		atomic.StoreUint64(&badsector, sid)
-		require.NoError(t, err)
-	}
-
-	bm.MineBlocksMustPost(ctx, 2*time.Millisecond)
-
-	mi, err := client.StateMinerInfo(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
-	require.NoError(t, err)
-	en := wact.Nonce
-
-	// wait for a new message to be sent from worker address, it will be a PoSt
-
-waitForProof:
-	for {
-		//stm: @CHAIN_STATE_GET_ACTOR_001
-		wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
-		require.NoError(t, err)
-		if wact.Nonce > en {
-			break waitForProof
-		}
-
-		build.Clock.Sleep(blocktime)
-	}
-
-	slm, err := client.StateListMessages(ctx, &api.MessageMatch{To: maddr}, types.EmptyTSK, 0)
-	require.NoError(t, err)
-
-	pmr, err := client.StateSearchMsg(ctx, types.EmptyTSK, slm[0], -1, false)
-	require.NoError(t, err)
-
-	nv, err := client.StateNetworkVersion(ctx, pmr.TipSet)
-	require.NoError(t, err)
-	require.Equal(t, network.Version20, nv)
-
-	require.True(t, pmr.Receipt.ExitCode.IsSuccess())
-
-	slmsg, err := client.ChainGetMessage(ctx, slm[0])
-	require.NoError(t, err)
-
-	var params miner11.SubmitWindowedPoStParams
-	require.NoError(t, params.UnmarshalCBOR(bytes.NewBuffer(slmsg.Params)))
-	require.Equal(t, abi.RegisteredPoStProof_StackedDrgWindow2KiBV1_1, params.Proofs[0].PoStProof)
-
-	require.Len(t, params.Partitions, 2)
-	sc0, err := params.Partitions[0].Skipped.Count()
-	require.NoError(t, err)
-	require.Equal(t, uint64(1), sc0)
-	sc1, err := params.Partitions[1].Skipped.Count()
-	require.NoError(t, err)
-	require.Equal(t, uint64(0), sc1)
-}
-
 // Tests that V1_1 proofs on post worker
 func TestWindowPostV1P1NV20Worker(t *testing.T) {
 	kit.QuietMiningLogs()
@@ -685,7 +540,7 @@ func TestWindowPostV1P1NV20Worker(t *testing.T) {
 		kit.ThroughRPC(),
 		kit.WithTaskTypes([]sealtasks.TaskType{sealtasks.TTGenerateWindowPoSt}))
 
-	ens.InterconnectAll().BeginMining(blocktime)
+	ens.InterconnectAll().BeginMiningMustPost(blocktime)
 
 	maddr, err := miner.ActorAddress(ctx)
 	require.NoError(t, err)
diff --git a/journal/fsjournal/fs.go b/journal/fsjournal/fs.go
index 71aaa95a5..b2eb946fd 100644
--- a/journal/fsjournal/fs.go
+++ b/journal/fsjournal/fs.go
@@ -37,7 +37,11 @@ type fsJournal struct {
 // OpenFSJournal constructs a rolling filesystem journal, with a default
 // per-file size limit of 1GiB.
 func OpenFSJournal(lr repo.LockedRepo, disabled journal.DisabledEvents) (journal.Journal, error) {
-	dir := filepath.Join(lr.Path(), "journal")
+	return OpenFSJournalPath(lr.Path(), disabled)
+}
+
+func OpenFSJournalPath(path string, disabled journal.DisabledEvents) (journal.Journal, error) {
+	dir := filepath.Join(path, "journal")
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return nil, fmt.Errorf("failed to mk directory %s for file journal: %w", dir, err)
 	}
diff --git a/journal/types.go b/journal/types.go
index af21607bf..c32fe37e4 100644
--- a/journal/types.go
+++ b/journal/types.go
@@ -26,6 +26,9 @@ func ParseDisabledEvents(s string) (DisabledEvents, error) {
 	s = strings.TrimSpace(s) // sanitize
 	evts := strings.Split(s, ",")
 	ret := make(DisabledEvents, 0, len(evts))
+	if len(s) == 0 {
+		return ret, nil
+	}
 	for _, evt := range evts {
 		evt = strings.TrimSpace(evt) // sanitize
 		s := strings.Split(evt, ":")
diff --git a/lib/consensus/raft/consensus.go b/lib/consensus/raft/consensus.go
index 60d9dc305..d74f200fa 100644
--- a/lib/consensus/raft/consensus.go
+++ b/lib/consensus/raft/consensus.go
@@ -342,7 +342,7 @@ func (cc *Consensus) RedirectToLeader(method string, arg interface{}, ret interf
 			return false, nil
 		}
 
-		logger.Debugf("redirecting %s to leader: %s", method, leader.Pretty())
+		logger.Debugf("redirecting %s to leader: %s", method, leader)
 		finalErr = cc.RpcClient.CallContext(
 			ctx,
 			leader,
@@ -394,7 +394,7 @@ func (cc *Consensus) Commit(ctx context.Context, op *ConsensusOp) error {
 func (cc *Consensus) AddPeer(ctx context.Context, pid peer.ID) error {
 	var finalErr error
 	for i := 0; i <= cc.config.CommitRetries; i++ {
-		logger.Debugf("attempt #%d: AddPeer %s", i, pid.Pretty())
+		logger.Debugf("attempt #%d: AddPeer %s", i, pid)
 		if finalErr != nil {
 			logger.Errorf("retrying to add peer. Attempt #%d failed: %s", i, finalErr)
 		}
@@ -408,7 +408,7 @@ func (cc *Consensus) AddPeer(ctx context.Context, pid peer.ID) error {
 			time.Sleep(cc.config.CommitRetryDelay)
 			continue
 		}
-		logger.Infof("peer added to Raft: %s", pid.Pretty())
+		logger.Infof("peer added to Raft: %s", pid)
 		break
 	}
 	return finalErr
@@ -419,7 +419,7 @@ func (cc *Consensus) AddPeer(ctx context.Context, pid peer.ID) error {
 func (cc *Consensus) RmPeer(ctx context.Context, pid peer.ID) error {
 	var finalErr error
 	for i := 0; i <= cc.config.CommitRetries; i++ {
-		logger.Debugf("attempt #%d: RmPeer %s", i, pid.Pretty())
+		logger.Debugf("attempt #%d: RmPeer %s", i, pid)
 		if finalErr != nil {
 			logger.Errorf("retrying to remove peer. Attempt #%d failed: %s", i, finalErr)
 		}
@@ -433,7 +433,7 @@ func (cc *Consensus) RmPeer(ctx context.Context, pid peer.ID) error {
 			time.Sleep(cc.config.CommitRetryDelay)
 			continue
 		}
-		logger.Infof("peer removed from Raft: %s", pid.Pretty())
+		logger.Infof("peer removed from Raft: %s", pid)
 		break
 	}
 	return finalErr
diff --git a/lib/consensus/raft/raft.go b/lib/consensus/raft/raft.go
index 8ff93caf2..8541e6f87 100644
--- a/lib/consensus/raft/raft.go
+++ b/lib/consensus/raft/raft.go
@@ -561,33 +561,3 @@ func find(s []string, elem string) bool {
 	}
 	return false
 }
-
-func (rw *raftWrapper) observePeers() {
-	obsCh := make(chan hraft.Observation, 1)
-	defer close(obsCh)
-
-	observer := hraft.NewObserver(obsCh, true, func(o *hraft.Observation) bool {
-		po, ok := o.Data.(hraft.PeerObservation)
-		return ok && po.Removed
-	})
-
-	rw.raft.RegisterObserver(observer)
-	defer rw.raft.DeregisterObserver(observer)
-
-	for {
-		select {
-		case obs := <-obsCh:
-			pObs := obs.Data.(hraft.PeerObservation)
-			logger.Info("raft peer departed. Removing from peerstore: ", pObs.Peer.ID)
-			pID, err := peer.Decode(string(pObs.Peer.ID))
-			if err != nil {
-				logger.Error(err)
-				continue
-			}
-			rw.host.Peerstore().ClearAddrs(pID)
-		case <-rw.ctx.Done():
-			logger.Debug("stopped observing raft peers")
-			return
-		}
-	}
-}
diff --git a/lib/harmony/harmonydb/doc.go b/lib/harmony/harmonydb/doc.go
new file mode 100644
index 000000000..ac60a0260
--- /dev/null
+++ b/lib/harmony/harmonydb/doc.go
@@ -0,0 +1,35 @@
+/*
+# HarmonyDB provides database abstractions over SP-wide Postgres-compatible instance(s).
+
+# Features
+
+	Rolling to secondary database servers on connection failure
+	Convenience features for Go + SQL
+	Prevention of SQL injection vulnerabilities
+	Monitors behavior via Prometheus stats and logging of errors.
+
+# Usage
+
+Processes should use New() to instantiate a *DB and keep it.
+Consumers can use this *DB concurrently.
+Creating and changing tables & views should happen in ./sql/ folder.
+Name the file "today's date" in the format: YYYYMMDD.sql (ex: 20231231.sql for the year's last day)
+
+	a. CREATE TABLE should NOT have a schema:
+		GOOD: CREATE TABLE foo ();
+		BAD:  CREATE TABLE me.foo ();
+	b. Schema is managed for you. It provides isolation for integraton tests & multi-use.
+	c. Git Merges: All run once, so old-after-new is OK when there are no deps.
+	d. NEVER change shipped sql files. Have later files make corrections.
+	e. Anything not ran will be ran, so an older date making it to master is OK.
+
+Write SQL with context, raw strings, and args:
+
+	name := "Alice"
+	var ID int
+	err := QueryRow(ctx, "SELECT id from people where first_name=?", name).Scan(&ID)
+	fmt.Println(ID)
+
+Note: Scan() is column-oriented, while Select() & StructScan() is field name/tag oriented.
+*/
+package harmonydb
diff --git a/lib/harmony/harmonydb/harmonydb.go b/lib/harmony/harmonydb/harmonydb.go
new file mode 100644
index 000000000..0fed176d2
--- /dev/null
+++ b/lib/harmony/harmonydb/harmonydb.go
@@ -0,0 +1,297 @@
+package harmonydb
+
+import (
+	"context"
+	"embed"
+	"fmt"
+	"math/rand"
+	"net"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/jackc/pgx/v5/pgxpool"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/node/config"
+)
+
+type ITestID string
+
+// ItestNewID see ITestWithID doc
+func ITestNewID() ITestID {
+	return ITestID(strconv.Itoa(rand.Intn(99999)))
+}
+
+type DB struct {
+	pgx       *pgxpool.Pool
+	cfg       *pgxpool.Config
+	schema    string
+	hostnames []string
+}
+
+var logger = logging.Logger("harmonydb")
+
+// NewFromConfig is a convenience function.
+// In usage:
+//
+//	db, err := NewFromConfig(config.HarmonyDB)  // in binary init
+func NewFromConfig(cfg config.HarmonyDB) (*DB, error) {
+	return New(
+		cfg.Hosts,
+		cfg.Username,
+		cfg.Password,
+		cfg.Database,
+		cfg.Port,
+		"",
+	)
+}
+
+func NewFromConfigWithITestID(cfg config.HarmonyDB) func(id ITestID) (*DB, error) {
+	return func(id ITestID) (*DB, error) {
+		return New(
+			cfg.Hosts,
+			cfg.Username,
+			cfg.Password,
+			cfg.Database,
+			cfg.Port,
+			id,
+		)
+	}
+}
+
+// New is to be called once per binary to establish the pool.
+// log() is for errors. It returns an upgraded database's connection.
+// This entry point serves both production and integration tests, so it's more DI.
+func New(hosts []string, username, password, database, port string, itestID ITestID) (*DB, error) {
+	itest := string(itestID)
+	connString := ""
+	if len(hosts) > 0 {
+		connString = "host=" + hosts[0] + " "
+	}
+	for k, v := range map[string]string{"user": username, "password": password, "dbname": database, "port": port} {
+		if strings.TrimSpace(v) != "" {
+			connString += k + "=" + v + " "
+		}
+	}
+
+	schema := "lotus"
+	if itest != "" {
+		schema = "itest_" + itest
+	}
+
+	if err := ensureSchemaExists(connString, schema); err != nil {
+		return nil, err
+	}
+	cfg, err := pgxpool.ParseConfig(connString + "search_path=" + schema)
+	if err != nil {
+		return nil, err
+	}
+
+	// enable multiple fallback hosts.
+	for _, h := range hosts[1:] {
+		cfg.ConnConfig.Fallbacks = append(cfg.ConnConfig.Fallbacks, &pgconn.FallbackConfig{Host: h})
+	}
+
+	cfg.ConnConfig.OnNotice = func(conn *pgconn.PgConn, n *pgconn.Notice) {
+		logger.Debug("database notice: " + n.Message + ": " + n.Detail)
+		DBMeasures.Errors.M(1)
+	}
+
+	db := DB{cfg: cfg, schema: schema, hostnames: hosts} // pgx populated in AddStatsAndConnect
+	if err := db.addStatsAndConnect(); err != nil {
+		return nil, err
+	}
+
+	return &db, db.upgrade()
+}
+
+type tracer struct {
+}
+
+type ctxkey string
+
+const SQL_START = ctxkey("sqlStart")
+const SQL_STRING = ctxkey("sqlString")
+
+func (t tracer) TraceQueryStart(ctx context.Context, conn *pgx.Conn, data pgx.TraceQueryStartData) context.Context {
+	return context.WithValue(context.WithValue(ctx, SQL_START, time.Now()), SQL_STRING, data.SQL)
+}
+func (t tracer) TraceQueryEnd(ctx context.Context, conn *pgx.Conn, data pgx.TraceQueryEndData) {
+	DBMeasures.Hits.M(1)
+	ms := time.Since(ctx.Value(SQL_START).(time.Time)).Milliseconds()
+	DBMeasures.TotalWait.M(ms)
+	DBMeasures.Waits.Observe(float64(ms))
+	if data.Err != nil {
+		DBMeasures.Errors.M(1)
+	}
+	logger.Debugw("SQL run",
+		"query", ctx.Value(SQL_STRING).(string),
+		"err", data.Err,
+		"rowCt", data.CommandTag.RowsAffected(),
+		"milliseconds", ms)
+}
+
+func (db *DB) GetRoutableIP() (string, error) {
+	tx, err := db.pgx.Begin(context.Background())
+	if err != nil {
+		return "", err
+	}
+	defer func() { _ = tx.Rollback(context.Background()) }()
+	local := tx.Conn().PgConn().Conn().LocalAddr()
+	addr, ok := local.(*net.TCPAddr)
+	if !ok {
+		return "", fmt.Errorf("could not get local addr from %v", addr)
+	}
+	return addr.IP.String(), nil
+}
+
+// addStatsAndConnect connects a prometheus logger. Be sure to run this before using the DB.
+func (db *DB) addStatsAndConnect() error {
+
+	db.cfg.ConnConfig.Tracer = tracer{}
+
+	hostnameToIndex := map[string]float64{}
+	for i, h := range db.hostnames {
+		hostnameToIndex[h] = float64(i)
+	}
+	db.cfg.AfterConnect = func(ctx context.Context, c *pgx.Conn) error {
+		s := db.pgx.Stat()
+		DBMeasures.OpenConnections.M(int64(s.TotalConns()))
+		DBMeasures.WhichHost.Observe(hostnameToIndex[c.Config().Host])
+
+		//FUTURE place for any connection seasoning
+		return nil
+	}
+
+	// Timeout the first connection so we know if the DB is down.
+	ctx, ctxClose := context.WithDeadline(context.Background(), time.Now().Add(5*time.Second))
+	defer ctxClose()
+	var err error
+	db.pgx, err = pgxpool.NewWithConfig(ctx, db.cfg)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Unable to connect to database: %v\n", err))
+		return err
+	}
+	return nil
+}
+
+// ITestDeleteAll will delete everything created for "this" integration test.
+// This must be called at the end of each integration test.
+func (db *DB) ITestDeleteAll() {
+	if !strings.HasPrefix(db.schema, "itest_") {
+		fmt.Println("Warning: this should never be called on anything but an itest schema.")
+		return
+	}
+	defer db.pgx.Close()
+	_, err := db.pgx.Exec(context.Background(), "DROP SCHEMA "+db.schema+" CASCADE")
+	if err != nil {
+		fmt.Println("warning: unclean itest shutdown: cannot delete schema: " + err.Error())
+		return
+	}
+}
+
+var schemaREString = "^[A-Za-z0-9_]+$"
+var schemaRE = regexp.MustCompile(schemaREString)
+
+func ensureSchemaExists(connString, schema string) error {
+	// FUTURE allow using fallback DBs for start-up.
+	ctx, cncl := context.WithDeadline(context.Background(), time.Now().Add(3*time.Second))
+	p, err := pgx.Connect(ctx, connString)
+	defer cncl()
+	if err != nil {
+		return xerrors.Errorf("unable to connect to db: %s, err: %v", connString, err)
+	}
+	defer func() { _ = p.Close(context.Background()) }()
+
+	if len(schema) < 5 || !schemaRE.MatchString(schema) {
+		return xerrors.New("schema must be of the form " + schemaREString + "\n Got: " + schema)
+	}
+	_, err = p.Exec(context.Background(), "CREATE SCHEMA IF NOT EXISTS "+schema)
+	if err != nil {
+		return xerrors.Errorf("cannot create schema: %w", err)
+	}
+	return nil
+}
+
+//go:embed sql
+var fs embed.FS
+
+func (db *DB) upgrade() error {
+	// Does the version table exist? if not, make it.
+	// NOTE: This cannot change except via the next sql file.
+	_, err := db.Exec(context.Background(), `CREATE TABLE IF NOT EXISTS base (
+		id SERIAL PRIMARY KEY,
+		entry CHAR(12),
+		applied TIMESTAMP DEFAULT current_timestamp
+	)`)
+	if err != nil {
+		logger.Error("Upgrade failed.")
+		return xerrors.Errorf("Cannot create base table %w", err)
+	}
+
+	// __Run scripts in order.__
+
+	landed := map[string]bool{}
+	{
+		var landedEntries []struct{ Entry string }
+		err = db.Select(context.Background(), &landedEntries, "SELECT entry FROM base")
+		if err != nil {
+			logger.Error("Cannot read entries: " + err.Error())
+			return xerrors.Errorf("cannot read entries: %w", err)
+		}
+		for _, l := range landedEntries {
+			landed[l.Entry[:8]] = true
+		}
+	}
+	dir, err := fs.ReadDir("sql")
+	if err != nil {
+		logger.Error("Cannot read fs entries: " + err.Error())
+		return err
+	}
+	sort.Slice(dir, func(i, j int) bool { return dir[i].Name() < dir[j].Name() })
+
+	if len(dir) == 0 {
+		logger.Error("No sql files found.")
+	}
+	for _, e := range dir {
+		name := e.Name()
+		if !strings.HasSuffix(name, ".sql") {
+			logger.Debug("Must have only SQL files here, found: " + name)
+			continue
+		}
+		if landed[name[:8]] {
+			logger.Debug("DB Schema " + name + " already applied.")
+			continue
+		}
+		file, err := fs.ReadFile("sql/" + name)
+		if err != nil {
+			logger.Error("weird embed file read err")
+			return err
+		}
+		for _, s := range strings.Split(string(file), ";") { // Implement the changes.
+			if len(strings.TrimSpace(s)) == 0 {
+				continue
+			}
+			_, err = db.pgx.Exec(context.Background(), s)
+			if err != nil {
+				msg := fmt.Sprintf("Could not upgrade! File %s, Query: %s, Returned: %s", name, s, err.Error())
+				logger.Error(msg)
+				return xerrors.New(msg) // makes devs lives easier by placing message at the end.
+			}
+		}
+
+		// Mark Completed.
+		_, err = db.Exec(context.Background(), "INSERT INTO base (entry) VALUES ($1)", name[:8])
+		if err != nil {
+			logger.Error("Cannot update base: " + err.Error())
+			return xerrors.Errorf("cannot insert into base: %w", err)
+		}
+	}
+	return nil
+}
diff --git a/lib/harmony/harmonydb/metrics.go b/lib/harmony/harmonydb/metrics.go
new file mode 100644
index 000000000..b29a76ad5
--- /dev/null
+++ b/lib/harmony/harmonydb/metrics.go
@@ -0,0 +1,77 @@
+package harmonydb
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+	"go.opencensus.io/stats"
+	"go.opencensus.io/stats/view"
+	"go.opencensus.io/tag"
+
+	"github.com/filecoin-project/lotus/metrics"
+)
+
+var (
+	dbTag, _         = tag.NewKey("db_name")
+	pre              = "harmonydb_base_"
+	waitsBuckets     = []float64{0, 10, 20, 30, 50, 80, 130, 210, 340, 550, 890}
+	whichHostBuckets = []float64{0, 1, 2, 3, 4, 5}
+)
+
+// DBMeasures groups all db metrics.
+var DBMeasures = struct {
+	Hits            *stats.Int64Measure
+	TotalWait       *stats.Int64Measure
+	Waits           prometheus.Histogram
+	OpenConnections *stats.Int64Measure
+	Errors          *stats.Int64Measure
+	WhichHost       prometheus.Histogram
+}{
+	Hits:      stats.Int64(pre+"hits", "Total number of uses.", stats.UnitDimensionless),
+	TotalWait: stats.Int64(pre+"total_wait", "Total delay. A numerator over hits to get average wait.", stats.UnitMilliseconds),
+	Waits: prometheus.NewHistogram(prometheus.HistogramOpts{
+		Name:    pre + "waits",
+		Buckets: waitsBuckets,
+		Help:    "The histogram of waits for query completions.",
+	}),
+	OpenConnections: stats.Int64(pre+"open_connections", "Total connection count.", stats.UnitDimensionless),
+	Errors:          stats.Int64(pre+"errors", "Total error count.", stats.UnitDimensionless),
+	WhichHost: prometheus.NewHistogram(prometheus.HistogramOpts{
+		Name:    pre + "which_host",
+		Buckets: whichHostBuckets,
+		Help:    "The index of the hostname being used",
+	}),
+}
+
+// CacheViews groups all cache-related default views.
+func init() {
+	metrics.RegisterViews(
+		&view.View{
+			Measure:     DBMeasures.Hits,
+			Aggregation: view.Sum(),
+			TagKeys:     []tag.Key{dbTag},
+		},
+		&view.View{
+			Measure:     DBMeasures.TotalWait,
+			Aggregation: view.Sum(),
+			TagKeys:     []tag.Key{dbTag},
+		},
+		&view.View{
+			Measure:     DBMeasures.OpenConnections,
+			Aggregation: view.LastValue(),
+			TagKeys:     []tag.Key{dbTag},
+		},
+		&view.View{
+			Measure:     DBMeasures.Errors,
+			Aggregation: view.Sum(),
+			TagKeys:     []tag.Key{dbTag},
+		},
+	)
+	err := prometheus.Register(DBMeasures.Waits)
+	if err != nil {
+		panic(err)
+	}
+
+	err = prometheus.Register(DBMeasures.WhichHost)
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/lib/harmony/harmonydb/sql/20230706.sql b/lib/harmony/harmonydb/sql/20230706.sql
new file mode 100644
index 000000000..a4a333b81
--- /dev/null
+++ b/lib/harmony/harmonydb/sql/20230706.sql
@@ -0,0 +1,7 @@
+CREATE TABLE itest_scratch (
+    id SERIAL PRIMARY KEY,
+	content TEXT,
+    some_int INTEGER,
+    second_int INTEGER,
+	update_time TIMESTAMP DEFAULT current_timestamp
+)
\ No newline at end of file
diff --git a/lib/harmony/harmonydb/sql/20230712.sql b/lib/harmony/harmonydb/sql/20230712.sql
new file mode 100644
index 000000000..750884c8c
--- /dev/null
+++ b/lib/harmony/harmonydb/sql/20230712.sql
@@ -0,0 +1,45 @@
+create table sector_location
+(
+    miner_id         bigint    not null,
+    sector_num       bigint    not null,
+    sector_filetype  int   not null,
+    storage_id       varchar not null,
+    is_primary       bool,
+    read_ts          timestamp(6),
+    read_refs        int,
+    write_ts         timestamp(6),
+    write_lock_owner varchar,
+    constraint sectorlocation_pk
+        primary key (miner_id, sector_num, sector_filetype, storage_id)
+);
+
+alter table sector_location
+    alter column read_refs set not null;
+
+alter table sector_location
+    alter column read_refs set default 0;
+
+create table storage_path
+(
+    "storage_id"  varchar not null
+        constraint "storage_path_pkey"
+            primary key,
+    "urls"       varchar, -- comma separated list of urls
+    "weight"     bigint,
+    "max_storage" bigint,
+    "can_seal"    bool,
+    "can_store"   bool,
+    "groups"     varchar, -- comma separated list of group names
+    "allow_to"    varchar, -- comma separated list of allowed groups
+    "allow_types" varchar,  -- comma separated list of allowed file types
+    "deny_types"  varchar, -- comma separated list of denied file types
+
+    "capacity" bigint,
+    "available" bigint,
+    "fs_available" bigint,
+    "reserved" bigint,
+    "used" bigint,
+    "last_heartbeat" timestamp(6),
+    "heartbeat_err"  varchar
+);
+
diff --git a/lib/harmony/harmonydb/sql/20230719.sql b/lib/harmony/harmonydb/sql/20230719.sql
new file mode 100644
index 000000000..e7b1795c5
--- /dev/null
+++ b/lib/harmony/harmonydb/sql/20230719.sql
@@ -0,0 +1,51 @@
+/* For HarmonyTask base implementation. */
+
+CREATE TABLE harmony_machines (
+    id SERIAL PRIMARY KEY NOT NULL,
+    last_contact TIMESTAMP NOT NULL DEFAULT current_timestamp,
+    host_and_port varchar(300) NOT NULL, 
+    cpu INTEGER NOT NULL, 
+    ram BIGINT NOT NULL, 
+    gpu FLOAT NOT NULL
+);
+
+CREATE TABLE harmony_task (
+    id SERIAL PRIMARY KEY NOT NULL,
+    initiated_by INTEGER,     
+    update_time TIMESTAMP NOT NULL DEFAULT current_timestamp,
+    posted_time TIMESTAMP NOT NULL,
+    owner_id INTEGER REFERENCES harmony_machines (id) ON DELETE SET NULL, 
+    added_by INTEGER NOT NULL,
+    previous_task INTEGER,
+    name varchar(16) NOT NULL
+);
+COMMENT ON COLUMN harmony_task.initiated_by IS 'The task ID whose completion occasioned this task.';
+COMMENT ON COLUMN harmony_task.owner_id IS 'The foreign key to harmony_machines.';
+COMMENT ON COLUMN harmony_task.name IS 'The name of the task type.';
+COMMENT ON COLUMN harmony_task.owner_id IS 'may be null if between owners or not yet taken';
+COMMENT ON COLUMN harmony_task.update_time IS 'When it was last modified. not a heartbeat';
+
+CREATE TABLE harmony_task_history (
+    id SERIAL PRIMARY KEY NOT NULL,  
+    task_id INTEGER NOT NULL, 
+    name VARCHAR(16) NOT NULL,
+    posted TIMESTAMP NOT NULL, 
+    work_start TIMESTAMP NOT NULL, 
+    work_end TIMESTAMP NOT NULL, 
+    result BOOLEAN NOT NULL, 
+    err varchar
+);
+COMMENT ON COLUMN harmony_task_history.result IS 'Use to detemine if this was a successful run.';
+
+CREATE TABLE harmony_task_follow (
+    id SERIAL PRIMARY KEY NOT NULL,  
+    owner_id INTEGER NOT NULL REFERENCES harmony_machines (id) ON DELETE CASCADE,
+    to_type VARCHAR(16) NOT NULL,
+    from_type VARCHAR(16) NOT NULL
+);
+
+CREATE TABLE harmony_task_impl (
+    id SERIAL PRIMARY KEY NOT NULL,  
+    owner_id INTEGER NOT NULL REFERENCES harmony_machines (id) ON DELETE CASCADE,
+    name VARCHAR(16) NOT NULL
+);
\ No newline at end of file
diff --git a/lib/harmony/harmonydb/sql/20230823.sql b/lib/harmony/harmonydb/sql/20230823.sql
new file mode 100644
index 000000000..c6f993d76
--- /dev/null
+++ b/lib/harmony/harmonydb/sql/20230823.sql
@@ -0,0 +1,48 @@
+create table wdpost_partition_tasks
+(
+    task_id              bigint not null
+        constraint wdpost_partition_tasks_pk
+            primary key,
+    sp_id                bigint not null,
+    proving_period_start bigint not null,
+    deadline_index       bigint not null,
+    partition_index      bigint not null,
+    constraint wdpost_partition_tasks_identity_key
+        unique (sp_id, proving_period_start, deadline_index, partition_index)
+);
+
+comment on column wdpost_partition_tasks.task_id is 'harmonytask task ID';
+comment on column wdpost_partition_tasks.sp_id is 'storage provider ID';
+comment on column wdpost_partition_tasks.proving_period_start is 'proving period start';
+comment on column wdpost_partition_tasks.deadline_index is 'deadline index within the proving period';
+comment on column wdpost_partition_tasks.partition_index is 'partition index within the deadline';
+
+create table wdpost_proofs
+(
+    sp_id                bigint not null,
+    proving_period_start bigint not null,
+    deadline             bigint not null,
+    partition            bigint not null,
+    submit_at_epoch      bigint not null,
+    submit_by_epoch      bigint not null,
+    proof_params         bytea,
+
+    submit_task_id       bigint,
+    message_cid          text,
+
+    constraint wdpost_proofs_identity_key
+        unique (sp_id, proving_period_start, deadline, partition)
+);
+
+create table wdpost_recovery_tasks
+(
+    task_id              bigint not null
+        constraint wdpost_recovery_tasks_pk
+            primary key,
+    sp_id                bigint not null,
+    proving_period_start bigint not null,
+    deadline_index       bigint not null,
+    partition_index      bigint not null,
+    constraint wdpost_recovery_tasks_identity_key
+        unique (sp_id, proving_period_start, deadline_index, partition_index)
+);
\ No newline at end of file
diff --git a/lib/harmony/harmonydb/sql/20230919.sql b/lib/harmony/harmonydb/sql/20230919.sql
new file mode 100644
index 000000000..84699a0d5
--- /dev/null
+++ b/lib/harmony/harmonydb/sql/20230919.sql
@@ -0,0 +1,5 @@
+CREATE TABLE harmony_config (
+    id SERIAL PRIMARY KEY NOT NULL,
+    title VARCHAR(300) UNIQUE NOT NULL,
+    config TEXT NOT NULL
+);
\ No newline at end of file
diff --git a/lib/harmony/harmonydb/sql/20231103.sql b/lib/harmony/harmonydb/sql/20231103.sql
new file mode 100644
index 000000000..e70cf3738
--- /dev/null
+++ b/lib/harmony/harmonydb/sql/20231103.sql
@@ -0,0 +1,55 @@
+create table message_sends
+(
+    from_key     text   not null,
+    to_addr      text   not null,
+    send_reason  text   not null,
+    send_task_id bigint not null,
+
+    unsigned_data bytea not null,
+    unsigned_cid  text  not null,
+
+    nonce        bigint,
+    signed_data  bytea,
+    signed_json  jsonb,
+    signed_cid   text,
+
+    send_time    timestamp default null,
+    send_success boolean   default null,
+    send_error   text,
+
+    constraint message_sends_pk
+        primary key (send_task_id, from_key)
+);
+
+comment on column message_sends.from_key is 'text f[1/3/4]... address';
+comment on column message_sends.to_addr is 'text f[0/1/2/3/4]... address';
+comment on column message_sends.send_reason is 'optional description of send reason';
+comment on column message_sends.send_task_id is 'harmony task id of the send task';
+
+comment on column message_sends.unsigned_data is 'unsigned message data';
+comment on column message_sends.unsigned_cid is 'unsigned message cid';
+
+comment on column message_sends.nonce is 'assigned message nonce, set while the send task is executing';
+comment on column message_sends.signed_data is 'signed message data, set while the send task is executing';
+comment on column message_sends.signed_cid is 'signed message cid, set while the send task is executing';
+
+comment on column message_sends.send_time is 'time when the send task was executed, set after pushing the message to the network';
+comment on column message_sends.send_success is 'whether this message was broadcasted to the network already, null if not yet attempted, true if successful, false if failed';
+comment on column message_sends.send_error is 'error message if send_success is false';
+
+create unique index message_sends_success_index
+    on message_sends (from_key, nonce)
+    where send_success is not false;
+
+comment on index message_sends_success_index is
+'message_sends_success_index enforces sender/nonce uniqueness, it is a conditional index that only indexes rows where send_success is not false. This allows us to have multiple rows with the same sender/nonce, as long as only one of them was successfully broadcasted (true) to the network or is in the process of being broadcasted (null).';
+
+create table message_send_locks
+(
+    from_key text   not null,
+    task_id  bigint not null,
+    claimed_at timestamp not null,
+
+    constraint message_send_locks_pk
+        primary key (from_key)
+);
diff --git a/lib/harmony/harmonydb/sql/20231110.sql b/lib/harmony/harmonydb/sql/20231110.sql
new file mode 100644
index 000000000..15b478f4d
--- /dev/null
+++ b/lib/harmony/harmonydb/sql/20231110.sql
@@ -0,0 +1,39 @@
+create table mining_tasks
+(
+    task_id bigint not null
+        constraint mining_tasks_pk
+            primary key,
+    sp_id   bigint not null,
+    epoch   bigint not null,
+    base_compute_time timestamp not null,
+
+    won bool not null default false,
+    mined_cid text,
+    mined_header jsonb,
+    mined_at timestamp,
+
+    submitted_at timestamp,
+
+    constraint mining_tasks_sp_epoch
+        unique (sp_id, epoch)
+);
+
+create table mining_base_block
+(
+    id        bigserial not null
+        constraint mining_base_block_pk
+            primary key,
+    task_id   bigint    not null
+        constraint mining_base_block_mining_tasks_task_id_fk
+            references mining_tasks
+            on delete cascade,
+    sp_id     bigint,
+    block_cid text      not null,
+
+    no_win    bool      not null default false,
+
+    constraint mining_base_block_pk2
+        unique (sp_id, task_id, block_cid)
+);
+
+CREATE UNIQUE INDEX mining_base_block_cid_k ON mining_base_block (sp_id, block_cid) WHERE no_win = false;
diff --git a/lib/harmony/harmonydb/sql/20231113.sql b/lib/harmony/harmonydb/sql/20231113.sql
new file mode 100644
index 000000000..7a71d98ae
--- /dev/null
+++ b/lib/harmony/harmonydb/sql/20231113.sql
@@ -0,0 +1 @@
+ALTER TABLE harmony_task_history ADD COLUMN completed_by_host_and_port varchar(300) NOT NULL;
\ No newline at end of file
diff --git a/lib/harmony/harmonydb/sql/20231120-testing1.sql b/lib/harmony/harmonydb/sql/20231120-testing1.sql
new file mode 100644
index 000000000..71daaef69
--- /dev/null
+++ b/lib/harmony/harmonydb/sql/20231120-testing1.sql
@@ -0,0 +1,8 @@
+CREATE TABLE harmony_test (
+    task_id bigint         
+        constraint harmony_test_pk
+            primary key,
+    options text,
+    result text
+);
+ALTER TABLE wdpost_proofs ADD COLUMN test_task_id bigint;
\ No newline at end of file
diff --git a/lib/harmony/harmonydb/userfuncs.go b/lib/harmony/harmonydb/userfuncs.go
new file mode 100644
index 000000000..788ca4a34
--- /dev/null
+++ b/lib/harmony/harmonydb/userfuncs.go
@@ -0,0 +1,158 @@
+package harmonydb
+
+import (
+	"context"
+	"errors"
+
+	"github.com/georgysavva/scany/v2/pgxscan"
+	"github.com/jackc/pgerrcode"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+)
+
+// rawStringOnly is _intentionally_private_ to force only basic strings in SQL queries.
+// In any package, raw strings will satisfy compilation.  Ex:
+//
+//	harmonydb.Exec("INSERT INTO version (number) VALUES (1)")
+//
+// This prevents SQL injection attacks where the input contains query fragments.
+type rawStringOnly string
+
+// Exec executes changes (INSERT, DELETE,  or UPDATE).
+// Note, for CREATE & DROP please keep these permanent and express
+// them in the ./sql/ files (next number).
+func (db *DB) Exec(ctx context.Context, sql rawStringOnly, arguments ...any) (count int, err error) {
+	res, err := db.pgx.Exec(ctx, string(sql), arguments...)
+	return int(res.RowsAffected()), err
+}
+
+type Qry interface {
+	Next() bool
+	Err() error
+	Close()
+	Scan(...any) error
+	Values() ([]any, error)
+}
+
+// Query offers Next/Err/Close/Scan/Values/StructScan
+type Query struct {
+	Qry
+}
+
+// Query allows iterating returned values to save memory consumption
+// with the downside of needing to `defer q.Close()`. For a simpler interface,
+// try Select()
+// Next() must be called to advance the row cursor, including the first time:
+// Ex:
+// q, err := db.Query(ctx, "SELECT id, name FROM users")
+// handleError(err)
+// defer q.Close()
+//
+//	for q.Next() {
+//		  var id int
+//	   var name string
+//	   handleError(q.Scan(&id, &name))
+//	   fmt.Println(id, name)
+//	}
+func (db *DB) Query(ctx context.Context, sql rawStringOnly, arguments ...any) (*Query, error) {
+	q, err := db.pgx.Query(ctx, string(sql), arguments...)
+	return &Query{q}, err
+}
+func (q *Query) StructScan(s any) error {
+	return pgxscan.ScanRow(s, q.Qry.(pgx.Rows))
+}
+
+type Row interface {
+	Scan(...any) error
+}
+
+// QueryRow gets 1 row using column order matching.
+// This is a timesaver for the special case of wanting the first row returned only.
+// EX:
+//
+//	var name, pet string
+//	var ID = 123
+//	err := db.QueryRow(ctx, "SELECT name, pet FROM users WHERE ID=?", ID).Scan(&name, &pet)
+func (db *DB) QueryRow(ctx context.Context, sql rawStringOnly, arguments ...any) Row {
+	return db.pgx.QueryRow(ctx, string(sql), arguments...)
+}
+
+/*
+Select multiple rows into a slice using name matching
+Ex:
+
+	type user struct {
+		Name string
+		ID int
+		Number string `db:"tel_no"`
+	}
+
+	var users []user
+	pet := "cat"
+	err := db.Select(ctx, &users, "SELECT name, id, tel_no FROM customers WHERE pet=?", pet)
+*/
+func (db *DB) Select(ctx context.Context, sliceOfStructPtr any, sql rawStringOnly, arguments ...any) error {
+	return pgxscan.Select(ctx, db.pgx, sliceOfStructPtr, string(sql), arguments...)
+}
+
+type Tx struct {
+	pgx.Tx
+	ctx context.Context
+}
+
+// BeginTransaction is how you can access transactions using this library.
+// The entire transaction happens in the function passed in.
+// The return must be true or a rollback will occur.
+func (db *DB) BeginTransaction(ctx context.Context, f func(*Tx) (commit bool, err error)) (didCommit bool, retErr error) {
+	tx, err := db.pgx.BeginTx(ctx, pgx.TxOptions{})
+	if err != nil {
+		return false, err
+	}
+	var commit bool
+	defer func() { // Panic clean-up.
+		if !commit {
+			if tmp := tx.Rollback(ctx); tmp != nil {
+				retErr = tmp
+			}
+		}
+	}()
+	commit, err = f(&Tx{tx, ctx})
+	if err != nil {
+		return false, err
+	}
+	if commit {
+		err = tx.Commit(ctx)
+		if err != nil {
+			return false, err
+		}
+		return true, nil
+	}
+	return false, nil
+}
+
+// Exec in a transaction.
+func (t *Tx) Exec(sql rawStringOnly, arguments ...any) (count int, err error) {
+	res, err := t.Tx.Exec(t.ctx, string(sql), arguments...)
+	return int(res.RowsAffected()), err
+}
+
+// Query in a transaction.
+func (t *Tx) Query(sql rawStringOnly, arguments ...any) (*Query, error) {
+	q, err := t.Tx.Query(t.ctx, string(sql), arguments...)
+	return &Query{q}, err
+}
+
+// QueryRow in a transaction.
+func (t *Tx) QueryRow(sql rawStringOnly, arguments ...any) Row {
+	return t.Tx.QueryRow(t.ctx, string(sql), arguments...)
+}
+
+// Select in a transaction.
+func (t *Tx) Select(sliceOfStructPtr any, sql rawStringOnly, arguments ...any) error {
+	return pgxscan.Select(t.ctx, t.Tx, sliceOfStructPtr, string(sql), arguments...)
+}
+
+func IsErrUniqueContraint(err error) bool {
+	var e2 *pgconn.PgError
+	return errors.As(err, &e2) && e2.Code == pgerrcode.UniqueViolation
+}
diff --git a/lib/harmony/harmonytask/doc.go b/lib/harmony/harmonytask/doc.go
new file mode 100644
index 000000000..f9e5a9898
--- /dev/null
+++ b/lib/harmony/harmonytask/doc.go
@@ -0,0 +1,71 @@
+/*
+Package harmonytask implements a pure (no task logic), distributed
+task manager. This clean interface allows a task implementer to completely
+avoid being concerned with task scheduling and management.
+It's based on the idea of tasks as small units of work broken from other
+work by hardware, parallelizabilty, reliability, or any other reason.
+Workers will be Greedy: vaccuuming up their favorite jobs from a list.
+Once 1 task is accepted, harmonydb tries to get other task runner
+machines to accept work (round robin) before trying again to accept.
+*
+Mental Model:
+
+	Things that block tasks:
+		- task not registered for any running server
+		- max was specified and reached
+		- resource exhaustion
+		- CanAccept() interface (per-task implmentation) does not accept it.
+	Ways tasks start:
+		- DB Read every 3 seconds
+		- Task was added (to db) by this process
+	Ways tasks get added:
+	    - Async Listener task (for chain, etc)
+		- Followers: Tasks get added because another task completed
+	When Follower collectors run:
+	    - If both sides are process-local, then this process will pick it up.
+		- If properly registered already, the http endpoint will be tried to start it.
+		- Otherwise, at the listen interval during db scrape it will be found.
+	How duplicate tasks are avoided:
+	    - that's up to the task definition, but probably a unique key
+
+*
+To use:
+1.Implement TaskInterface for a new task.
+2. Have New() receive this & all other ACTIVE implementations.
+*
+*
+As we are not expecting DBAs in this database, it's important to know
+what grows uncontrolled. The only growing harmony_* table is
+harmony_task_history (somewhat quickly). These will need a
+clean-up for after the task data could never be acted upon.
+but the design **requires** extraInfo tables to grow until the task's
+info could not possibly be used by a following task, including slow
+release rollout. This would normally be in the order of months old.
+*
+Other possible enhancements include more collaborative coordination
+to assign a task to machines closer to the data.
+
+__Database_Behavior__
+harmony_task is the list of work that has not been completed.
+
+	AddTaskFunc manages the additions, but is designed to have its
+	transactions failed-out on overlap with a similar task already written.
+	It's up to the TaskInterface implementer to discover this overlap via
+	some other table it uses (since overlap can mean very different things).
+
+harmony_task_history
+
+	This holds transactions that completed or saw too many retries. It also
+	serves as input for subsequent (follower) tasks to kick off. This is not
+	done machine-internally because a follower may not be on the same machine
+	as the previous task.
+
+harmony_task_machines
+
+	Managed by lib/harmony/resources, this is a reference to machines registered
+	via the resources. This registration does not obligate the machine to
+	anything, but serves as a discovery mechanism. Paths are hostnames + ports
+	which are presumed to support http, but this assumption is only used by
+	the task system.
+*/
+package harmonytask
diff --git a/lib/harmony/harmonytask/harmonytask.go b/lib/harmony/harmonytask/harmonytask.go
new file mode 100644
index 000000000..7577c5cf5
--- /dev/null
+++ b/lib/harmony/harmonytask/harmonytask.go
@@ -0,0 +1,307 @@
+package harmonytask
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"sync/atomic"
+	"time"
+
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/lib/harmony/resources"
+)
+
+// Consts (except for unit test)
+var POLL_DURATION = time.Second * 3     // Poll for Work this frequently
+var CLEANUP_FREQUENCY = 5 * time.Minute // Check for dead workers this often * everyone
+var FOLLOW_FREQUENCY = 1 * time.Minute  // Check for work to follow this often
+
+type TaskTypeDetails struct {
+	// Max returns how many tasks this machine can run of this type.
+	// Zero (default) or less means unrestricted.
+	Max int
+
+	// Name is the task name to be added to the task list.
+	Name string
+
+	// Peak costs to Do() the task.
+	Cost resources.Resources
+
+	// Max Failure count before the job is dropped.
+	// 0 = retry forever
+	MaxFailures uint
+
+	// Follow another task's completion via this task's creation.
+	// The function should populate extraInfo from data
+	// available from the previous task's tables, using the given TaskID.
+	// It should also return success if the trigger succeeded.
+	// NOTE: if refatoring tasks, see if your task is
+	// necessary. Ex: Is the sector state correct for your stage to run?
+	Follows map[string]func(TaskID, AddTaskFunc) (bool, error)
+}
+
+// TaskInterface must be implemented in order to have a task used by harmonytask.
+type TaskInterface interface {
+	// Do the task assigned. Call stillOwned before making single-writer-only
+	// changes to ensure the work has not been stolen.
+	// This is the ONLY function that should attempt to do the work, and must
+	// ONLY be called by harmonytask.
+	// Indicate if the task no-longer needs scheduling with done=true including
+	// cases where it's past the deadline.
+	Do(taskID TaskID, stillOwned func() bool) (done bool, err error)
+
+	// CanAccept should return if the task can run on this machine. It should
+	// return null if the task type is not allowed on this machine.
+	// It should select the task it most wants to accomplish.
+	// It is also responsible for determining & reserving disk space (including scratch).
+	CanAccept([]TaskID, *TaskEngine) (*TaskID, error)
+
+	// TypeDetails() returns static details about how this task behaves and
+	// how this machine will run it. Read once at the beginning.
+	TypeDetails() TaskTypeDetails
+
+	// This listener will consume all external sources continuously for work.
+	// Do() may also be called from a backlog of work. This must not
+	// start doing the work (it still must be scheduled).
+	// Note: Task de-duplication should happen in ExtraInfoFunc by
+	//  returning false, typically by determining from the tx that the work
+	//  exists already. The easy way is to have a unique joint index
+	//  across all fields that will be common.
+	// Adder should typically only add its own task type, but multiple
+	//   is possible for when 1 trigger starts 2 things.
+	// Usage Example:
+	// func (b *BazType)Adder(addTask AddTaskFunc) {
+	//	  for {
+	//      bazMaker := <- bazChannel
+	//	    addTask("baz", func(t harmonytask.TaskID, txn db.Transaction) (bool, error) {
+	//	       _, err := txn.Exec(`INSERT INTO bazInfoTable (taskID, qix, mot)
+	//			  VALUES ($1,$2,$3)`, id, bazMaker.qix, bazMaker.mot)
+	//         if err != nil {
+	//				scream(err)
+	//	 		 	return false
+	//		   }
+	// 		   return true
+	//		})
+	//	  }
+	// }
+	Adder(AddTaskFunc)
+}
+
+// AddTaskFunc is responsible for adding a task's details "extra info" to the DB.
+// It should return true if the task should be added, false if it was already there.
+// This is typically accomplished with a "unique" index on your detals table that
+// would cause the insert to fail.
+// The error indicates that instead of a conflict (which we should ignore) that we
+// actually have a serious problem that needs to be logged with context.
+type AddTaskFunc func(extraInfo func(TaskID, *harmonydb.Tx) (shouldCommit bool, seriousError error))
+
+type TaskEngine struct {
+	ctx            context.Context
+	handlers       []*taskTypeHandler
+	db             *harmonydb.DB
+	reg            *resources.Reg
+	grace          context.CancelFunc
+	taskMap        map[string]*taskTypeHandler
+	ownerID        int
+	follows        map[string][]followStruct
+	lastFollowTime time.Time
+	lastCleanup    atomic.Value
+	hostAndPort    string
+}
+type followStruct struct {
+	f    func(TaskID, AddTaskFunc) (bool, error)
+	h    *taskTypeHandler
+	name string
+}
+
+type TaskID int
+
+// New creates all the task definitions. Note that TaskEngine
+// knows nothing about the tasks themselves and serves to be a
+// generic container for common work
+func New(
+	db *harmonydb.DB,
+	impls []TaskInterface,
+	hostnameAndPort string) (*TaskEngine, error) {
+
+	reg, err := resources.Register(db, hostnameAndPort)
+	if err != nil {
+		return nil, fmt.Errorf("cannot get resources: %w", err)
+	}
+	ctx, grace := context.WithCancel(context.Background())
+	e := &TaskEngine{
+		ctx:         ctx,
+		grace:       grace,
+		db:          db,
+		reg:         reg,
+		ownerID:     reg.Resources.MachineID, // The current number representing "hostAndPort"
+		taskMap:     make(map[string]*taskTypeHandler, len(impls)),
+		follows:     make(map[string][]followStruct),
+		hostAndPort: hostnameAndPort,
+	}
+	e.lastCleanup.Store(time.Now())
+	for _, c := range impls {
+		h := taskTypeHandler{
+			TaskInterface:   c,
+			TaskTypeDetails: c.TypeDetails(),
+			TaskEngine:      e,
+		}
+
+		if len(h.Name) > 16 {
+			return nil, fmt.Errorf("task name too long: %s, max 16 characters", h.Name)
+		}
+
+		e.handlers = append(e.handlers, &h)
+		e.taskMap[h.TaskTypeDetails.Name] = &h
+	}
+
+	// resurrect old work
+	{
+		var taskRet []struct {
+			ID   int
+			Name string
+		}
+
+		err := db.Select(e.ctx, &taskRet, `SELECT id, name from harmony_task WHERE owner_id=$1`, e.ownerID)
+		if err != nil {
+			return nil, err
+		}
+		for _, w := range taskRet {
+			// edge-case: if old assignments are not available tasks, unlock them.
+			h := e.taskMap[w.Name]
+			if h == nil {
+				_, err := db.Exec(e.ctx, `UPDATE harmony_task SET owner=NULL WHERE id=$1`, w.ID)
+				if err != nil {
+					log.Errorw("Cannot remove self from owner field", "error", err)
+					continue // not really fatal, but not great
+				}
+			}
+			if !h.considerWork(workSourceRecover, []TaskID{TaskID(w.ID)}) {
+				log.Error("Strange: Unable to accept previously owned task: ", w.ID, w.Name)
+			}
+		}
+	}
+	for _, h := range e.handlers {
+		go h.Adder(h.AddTask)
+	}
+	go e.poller()
+
+	return e, nil
+}
+
+// GracefullyTerminate hangs until all present tasks have completed.
+// Call this to cleanly exit the process. As some processes are long-running,
+// passing a deadline will ignore those still running (to be picked-up later).
+func (e *TaskEngine) GracefullyTerminate(deadline time.Duration) {
+	e.grace()
+	e.reg.Shutdown()
+	deadlineChan := time.NewTimer(deadline).C
+top:
+	for _, h := range e.handlers {
+		if h.Count.Load() > 0 {
+			select {
+			case <-deadlineChan:
+				return
+			default:
+				time.Sleep(time.Millisecond)
+				goto top
+			}
+		}
+	}
+}
+
+func (e *TaskEngine) poller() {
+	for {
+		select {
+		case <-time.NewTicker(POLL_DURATION).C: // Find work periodically
+		case <-e.ctx.Done(): ///////////////////// Graceful exit
+			return
+		}
+		e.pollerTryAllWork()
+		if time.Since(e.lastFollowTime) > FOLLOW_FREQUENCY {
+			e.followWorkInDB()
+		}
+	}
+}
+
+// followWorkInDB implements "Follows"
+func (e *TaskEngine) followWorkInDB() {
+	// Step 1: What are we following?
+	var lastFollowTime time.Time
+	lastFollowTime, e.lastFollowTime = e.lastFollowTime, time.Now()
+
+	for fromName, srcs := range e.follows {
+		var cList []int // Which work is done (that we follow) since we last checked?
+		err := e.db.Select(e.ctx, &cList, `SELECT h.task_id FROM harmony_task_history 
+   		WHERE h.work_end>$1 AND h.name=$2`, lastFollowTime, fromName)
+		if err != nil {
+			log.Error("Could not query DB: ", err)
+			return
+		}
+		for _, src := range srcs {
+			for _, workAlreadyDone := range cList { // Were any tasks made to follow these tasks?
+				var ct int
+				err := e.db.QueryRow(e.ctx, `SELECT COUNT(*) FROM harmony_task 
+					WHERE name=$1 AND previous_task=$2`, src.h.Name, workAlreadyDone).Scan(&ct)
+				if err != nil {
+					log.Error("Could not query harmony_task: ", err)
+					return // not recoverable here
+				}
+				if ct > 0 {
+					continue
+				}
+				// we need to create this task
+				b, err := src.h.Follows[fromName](TaskID(workAlreadyDone), src.h.AddTask)
+				if err != nil {
+					log.Errorw("Could not follow: ", "error", err)
+					continue
+				}
+				if !b {
+					// But someone may have beaten us to it.
+					log.Debugf("Unable to add task %s following Task(%d, %s)", src.h.Name, workAlreadyDone, fromName)
+				}
+			}
+		}
+	}
+}
+
+// pollerTryAllWork starts the next 1 task
+func (e *TaskEngine) pollerTryAllWork() {
+	if time.Since(e.lastCleanup.Load().(time.Time)) > CLEANUP_FREQUENCY {
+		e.lastCleanup.Store(time.Now())
+		resources.CleanupMachines(e.ctx, e.db)
+	}
+	for _, v := range e.handlers {
+		if v.AssertMachineHasCapacity() != nil {
+			continue
+		}
+		var unownedTasks []TaskID
+		err := e.db.Select(e.ctx, &unownedTasks, `SELECT id 
+			FROM harmony_task
+			WHERE owner_id IS NULL AND name=$1
+			ORDER BY update_time`, v.Name)
+		if err != nil {
+			log.Error("Unable to read work ", err)
+			continue
+		}
+		if len(unownedTasks) > 0 {
+			accepted := v.considerWork(workSourcePoller, unownedTasks)
+			if accepted {
+				return // accept new work slowly and in priority order
+			}
+			log.Warn("Work not accepted for " + strconv.Itoa(len(unownedTasks)) + " " + v.Name + " task(s)")
+		}
+	}
+}
+
+// ResourcesAvailable determines what resources are still unassigned.
+func (e *TaskEngine) ResourcesAvailable() resources.Resources {
+	tmp := e.reg.Resources
+	for _, t := range e.handlers {
+		ct := t.Count.Load()
+		tmp.Cpu -= int(ct) * t.Cost.Cpu
+		tmp.Gpu -= float64(ct) * t.Cost.Gpu
+		tmp.Ram -= uint64(ct) * t.Cost.Ram
+	}
+	return tmp
+}
diff --git a/lib/harmony/harmonytask/task_type_handler.go b/lib/harmony/harmonytask/task_type_handler.go
new file mode 100644
index 000000000..34f7a5c3e
--- /dev/null
+++ b/lib/harmony/harmonytask/task_type_handler.go
@@ -0,0 +1,238 @@
+package harmonytask
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"runtime"
+	"strconv"
+	"sync/atomic"
+	"time"
+
+	logging "github.com/ipfs/go-log/v2"
+
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+)
+
+var log = logging.Logger("harmonytask")
+
+type taskTypeHandler struct {
+	TaskInterface
+	TaskTypeDetails
+	TaskEngine *TaskEngine
+	Count      atomic.Int32
+}
+
+func (h *taskTypeHandler) AddTask(extra func(TaskID, *harmonydb.Tx) (bool, error)) {
+	var tID TaskID
+	_, err := h.TaskEngine.db.BeginTransaction(h.TaskEngine.ctx, func(tx *harmonydb.Tx) (bool, error) {
+		// create taskID (from DB)
+		_, err := tx.Exec(`INSERT INTO harmony_task (name, added_by, posted_time) 
+			VALUES ($1, $2, CURRENT_TIMESTAMP) `, h.Name, h.TaskEngine.ownerID)
+		if err != nil {
+			return false, fmt.Errorf("could not insert into harmonyTask: %w", err)
+		}
+		err = tx.QueryRow("SELECT id FROM harmony_task ORDER BY update_time DESC LIMIT 1").Scan(&tID)
+		if err != nil {
+			return false, fmt.Errorf("Could not select ID: %v", err)
+		}
+		return extra(tID, tx)
+	})
+
+	if err != nil {
+		if harmonydb.IsErrUniqueContraint(err) {
+			log.Debugf("addtask(%s) saw unique constraint, so it's added already.", h.Name)
+			return
+		}
+		log.Error("Could not add task. AddTasFunc failed: %v", err)
+		return
+	}
+}
+
+const (
+	workSourcePoller  = "poller"
+	workSourceRecover = "recovered"
+)
+
+// considerWork is called to attempt to start work on a task-id of this task type.
+// It presumes single-threaded calling, so there should not be a multi-threaded re-entry.
+// The only caller should be the one work poller thread. This does spin off other threads,
+// but those should not considerWork. Work completing may lower the resource numbers
+// unexpectedly, but that will not invalidate work being already able to fit.
+func (h *taskTypeHandler) considerWork(from string, ids []TaskID) (workAccepted bool) {
+top:
+	if len(ids) == 0 {
+		return true // stop looking for takers
+	}
+
+	// 1. Can we do any more of this task type?
+	// NOTE: 0 is the default value, so this way people don't need to worry about
+	// this setting unless they want to limit the number of tasks of this type.
+	if h.Max > 0 && int(h.Count.Load()) >= h.Max {
+		log.Debugw("did not accept task", "name", h.Name, "reason", "at max already")
+		return false
+	}
+
+	// 2. Can we do any more work? From here onward, we presume the resource
+	// story will not change, so single-threaded calling is best.
+	err := h.AssertMachineHasCapacity()
+	if err != nil {
+		log.Debugw("did not accept task", "name", h.Name, "reason", "at capacity already: "+err.Error())
+		return false
+	}
+
+	// 3. What does the impl say?
+	tID, err := h.CanAccept(ids, h.TaskEngine)
+	if err != nil {
+		log.Error(err)
+		return false
+	}
+	if tID == nil {
+		log.Infow("did not accept task", "task_id", ids[0], "reason", "CanAccept() refused", "name", h.Name)
+		return false
+	}
+
+	// if recovering we don't need to try to claim anything because those tasks are already claimed by us
+	if from != workSourceRecover {
+		// 4. Can we claim the work for our hostname?
+		ct, err := h.TaskEngine.db.Exec(h.TaskEngine.ctx, "UPDATE harmony_task SET owner_id=$1 WHERE id=$2 AND owner_id IS NULL", h.TaskEngine.ownerID, *tID)
+		if err != nil {
+			log.Error(err)
+			return false
+		}
+		if ct == 0 {
+			log.Infow("did not accept task", "task_id", strconv.Itoa(int(*tID)), "reason", "already Taken", "name", h.Name)
+			var tryAgain = make([]TaskID, 0, len(ids)-1)
+			for _, id := range ids {
+				if id != *tID {
+					tryAgain = append(tryAgain, id)
+				}
+			}
+			ids = tryAgain
+			goto top
+		}
+	}
+
+	h.Count.Add(1)
+	go func() {
+		log.Infow("Beginning work on Task", "id", *tID, "from", from, "name", h.Name)
+
+		var done bool
+		var doErr error
+		workStart := time.Now()
+
+		defer func() {
+			if r := recover(); r != nil {
+				stackSlice := make([]byte, 4092)
+				sz := runtime.Stack(stackSlice, false)
+				log.Error("Recovered from a serious error "+
+					"while processing "+h.Name+" task "+strconv.Itoa(int(*tID))+": ", r,
+					" Stack: ", string(stackSlice[:sz]))
+			}
+			h.Count.Add(-1)
+
+			h.recordCompletion(*tID, workStart, done, doErr)
+			if done {
+				for _, fs := range h.TaskEngine.follows[h.Name] { // Do we know of any follows for this task type?
+					if _, err := fs.f(*tID, fs.h.AddTask); err != nil {
+						log.Error("Could not follow", "error", err, "from", h.Name, "to", fs.name)
+					}
+				}
+			}
+		}()
+
+		done, doErr = h.Do(*tID, func() bool {
+			var owner int
+			// Background here because we don't want GracefulRestart to block this save.
+			err := h.TaskEngine.db.QueryRow(context.Background(),
+				`SELECT owner_id FROM harmony_task WHERE id=$1`, *tID).Scan(&owner)
+			if err != nil {
+				log.Error("Cannot determine ownership: ", err)
+				return false
+			}
+			return owner == h.TaskEngine.ownerID
+		})
+		if doErr != nil {
+			log.Errorw("Do() returned error", "type", h.Name, "id", strconv.Itoa(int(*tID)), "error", doErr)
+		}
+	}()
+	return true
+}
+
+func (h *taskTypeHandler) recordCompletion(tID TaskID, workStart time.Time, done bool, doErr error) {
+	workEnd := time.Now()
+
+	cm, err := h.TaskEngine.db.BeginTransaction(h.TaskEngine.ctx, func(tx *harmonydb.Tx) (bool, error) {
+		var postedTime time.Time
+		err := tx.QueryRow(`SELECT posted_time FROM harmony_task WHERE id=$1`, tID).Scan(&postedTime)
+		if err != nil {
+			return false, fmt.Errorf("could not log completion: %w ", err)
+		}
+		result := "unspecified error"
+		if done {
+			_, err = tx.Exec("DELETE FROM harmony_task WHERE id=$1", tID)
+			if err != nil {
+
+				return false, fmt.Errorf("could not log completion: %w", err)
+			}
+			result = ""
+		} else {
+			if doErr != nil {
+				result = "error: " + doErr.Error()
+			}
+			var deleteTask bool
+			if h.MaxFailures > 0 {
+				ct := uint(0)
+				err = tx.QueryRow(`SELECT count(*) FROM harmony_task_history 
+				WHERE task_id=$1 AND result=FALSE`, tID).Scan(&ct)
+				if err != nil {
+					return false, fmt.Errorf("could not read task history: %w", err)
+				}
+				if ct >= h.MaxFailures {
+					deleteTask = true
+				}
+			}
+			if deleteTask {
+				_, err = tx.Exec("DELETE FROM harmony_task WHERE id=$1", tID)
+				if err != nil {
+					return false, fmt.Errorf("could not delete failed job: %w", err)
+				}
+				// Note: Extra Info is left laying around for later review & clean-up
+			} else {
+				_, err := tx.Exec(`UPDATE harmony_task SET owner_id=NULL WHERE id=$1`, tID)
+				if err != nil {
+					return false, fmt.Errorf("could not disown failed task: %v %v", tID, err)
+				}
+			}
+		}
+		_, err = tx.Exec(`INSERT INTO harmony_task_history 
+									 (task_id,   name, posted,    work_start, work_end, result, completed_by_host_and_port,      err)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`, tID, h.Name, postedTime, workStart, workEnd, done, h.TaskEngine.hostAndPort, result)
+		if err != nil {
+			return false, fmt.Errorf("could not write history: %w", err)
+		}
+		return true, nil
+	})
+	if err != nil {
+		log.Error("Could not record transaction: ", err)
+		return
+	}
+	if !cm {
+		log.Error("Committing the task records failed")
+	}
+}
+
+func (h *taskTypeHandler) AssertMachineHasCapacity() error {
+	r := h.TaskEngine.ResourcesAvailable()
+
+	if r.Cpu-h.Cost.Cpu < 0 {
+		return errors.New("Did not accept " + h.Name + " task: out of cpu")
+	}
+	if h.Cost.Ram > r.Ram {
+		return errors.New("Did not accept " + h.Name + " task: out of RAM")
+	}
+	if r.Gpu-h.Cost.Gpu < 0 {
+		return errors.New("Did not accept " + h.Name + " task: out of available GPU")
+	}
+	return nil
+}
diff --git a/lib/harmony/resources/getGPU.go b/lib/harmony/resources/getGPU.go
new file mode 100644
index 000000000..9a73bcd0d
--- /dev/null
+++ b/lib/harmony/resources/getGPU.go
@@ -0,0 +1,22 @@
+//go:build !darwin
+// +build !darwin
+
+package resources
+
+import (
+	"strings"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+)
+
+func getGPUDevices() float64 { // GPU boolean
+	gpus, err := ffi.GetGPUDevices()
+	if err != nil {
+		logger.Errorf("getting gpu devices failed: %+v", err)
+	}
+	all := strings.ToLower(strings.Join(gpus, ","))
+	if len(gpus) > 1 || strings.Contains(all, "ati") || strings.Contains(all, "nvidia") {
+		return float64(len(gpus))
+	}
+	return 0
+}
diff --git a/lib/harmony/resources/getGPU_darwin.go b/lib/harmony/resources/getGPU_darwin.go
new file mode 100644
index 000000000..a9c0a33cd
--- /dev/null
+++ b/lib/harmony/resources/getGPU_darwin.go
@@ -0,0 +1,8 @@
+//go:build darwin
+// +build darwin
+
+package resources
+
+func getGPUDevices() float64 {
+	return 10000.0 // unserious value intended for non-production use.
+}
diff --git a/lib/harmony/resources/memsys.go b/lib/harmony/resources/memsys.go
new file mode 100644
index 000000000..1a45b5b22
--- /dev/null
+++ b/lib/harmony/resources/memsys.go
@@ -0,0 +1,22 @@
+//go:build darwin || freebsd || openbsd || dragonfly || netbsd
+// +build darwin freebsd openbsd dragonfly netbsd
+
+package resources
+
+import (
+	"encoding/binary"
+	"syscall"
+)
+
+func sysctlUint64(name string) (uint64, error) {
+	s, err := syscall.Sysctl(name)
+	if err != nil {
+		return 0, err
+	}
+	// hack because the string conversion above drops a \0
+	b := []byte(s)
+	if len(b) < 8 {
+		b = append(b, 0)
+	}
+	return binary.LittleEndian.Uint64(b), nil
+}
diff --git a/lib/harmony/resources/miniopencl/cl.h b/lib/harmony/resources/miniopencl/cl.h
new file mode 100644
index 000000000..e90fb7692
--- /dev/null
+++ b/lib/harmony/resources/miniopencl/cl.h
@@ -0,0 +1,17 @@
+  
+#ifndef CL_H
+#define CL_H
+
+#define CL_USE_DEPRECATED_OPENCL_1_1_APIS
+#define CL_USE_DEPRECATED_OPENCL_1_2_APIS
+#define CL_USE_DEPRECATED_OPENCL_2_0_APIS
+
+#define CL_TARGET_OPENCL_VERSION 300
+
+#ifdef __APPLE__
+#include "OpenCL/opencl.h"
+#else
+#include "CL/opencl.h"
+#endif
+
+#endif /* CL_H */
\ No newline at end of file
diff --git a/lib/harmony/resources/miniopencl/mini_opencl.go b/lib/harmony/resources/miniopencl/mini_opencl.go
new file mode 100644
index 000000000..d2486a88f
--- /dev/null
+++ b/lib/harmony/resources/miniopencl/mini_opencl.go
@@ -0,0 +1,93 @@
+// Package cl was borrowed from the go-opencl library which is more complex and
+// doesn't compile well for our needs.
+package cl
+
+// #include "cl.h"
+import "C"
+import (
+	"fmt"
+	"unsafe"
+)
+
+const maxPlatforms = 32
+
+type Platform struct {
+	id C.cl_platform_id
+}
+
+// Obtain the list of platforms available.
+func GetPlatforms() ([]*Platform, error) {
+	var platformIds [maxPlatforms]C.cl_platform_id
+	var nPlatforms C.cl_uint
+	err := C.clGetPlatformIDs(C.cl_uint(maxPlatforms), &platformIds[0], &nPlatforms)
+	if err == -1001 { // No platforms found
+		return nil, nil
+	}
+	if err != C.CL_SUCCESS {
+		return nil, toError(err)
+	}
+	platforms := make([]*Platform, nPlatforms)
+	for i := 0; i < int(nPlatforms); i++ {
+		platforms[i] = &Platform{id: platformIds[i]}
+	}
+	return platforms, nil
+}
+
+const maxDeviceCount = 64
+
+type DeviceType uint
+
+const (
+	DeviceTypeAll DeviceType = C.CL_DEVICE_TYPE_ALL
+)
+
+type Device struct {
+	id C.cl_device_id
+}
+
+func (p *Platform) GetAllDevices() ([]*Device, error) {
+	var deviceIds [maxDeviceCount]C.cl_device_id
+	var numDevices C.cl_uint
+	var platformId C.cl_platform_id
+	if p != nil {
+		platformId = p.id
+	}
+	if err := C.clGetDeviceIDs(platformId, C.cl_device_type(DeviceTypeAll), C.cl_uint(maxDeviceCount), &deviceIds[0], &numDevices); err != C.CL_SUCCESS {
+		return nil, toError(err)
+	}
+	if numDevices > maxDeviceCount {
+		numDevices = maxDeviceCount
+	}
+	devices := make([]*Device, numDevices)
+	for i := 0; i < int(numDevices); i++ {
+		devices[i] = &Device{id: deviceIds[i]}
+	}
+	return devices, nil
+}
+
+func toError(code C.cl_int) error {
+	return ErrOther(code)
+}
+
+type ErrOther int
+
+func (e ErrOther) Error() string {
+	return fmt.Sprintf("OpenCL: error %d", int(e))
+}
+
+// Size of global device memory in bytes.
+func (d *Device) GlobalMemSize() int64 {
+	val, _ := d.getInfoUlong(C.CL_DEVICE_GLOBAL_MEM_SIZE, true)
+	return val
+}
+
+func (d *Device) getInfoUlong(param C.cl_device_info, panicOnError bool) (int64, error) {
+	var val C.cl_ulong
+	if err := C.clGetDeviceInfo(d.id, param, C.size_t(unsafe.Sizeof(val)), unsafe.Pointer(&val), nil); err != C.CL_SUCCESS {
+		if panicOnError {
+			panic("Should never fail")
+		}
+		return 0, toError(err)
+	}
+	return int64(val), nil
+}
diff --git a/lib/harmony/resources/resources.go b/lib/harmony/resources/resources.go
new file mode 100644
index 000000000..b129496d8
--- /dev/null
+++ b/lib/harmony/resources/resources.go
@@ -0,0 +1,142 @@
+package resources
+
+import (
+	"bytes"
+	"context"
+	"os/exec"
+	"regexp"
+	"runtime"
+	"sync/atomic"
+	"time"
+
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/pbnjay/memory"
+	"golang.org/x/sys/unix"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+)
+
+var LOOKS_DEAD_TIMEOUT = 10 * time.Minute // Time w/o minute heartbeats
+
+type Resources struct {
+	Cpu       int
+	Gpu       float64
+	Ram       uint64
+	MachineID int
+}
+type Reg struct {
+	Resources
+	shutdown atomic.Bool
+}
+
+var logger = logging.Logger("harmonytask")
+
+var lotusRE = regexp.MustCompile("lotus-worker|lotus-harmony|yugabyted|yb-master|yb-tserver")
+
+func Register(db *harmonydb.DB, hostnameAndPort string) (*Reg, error) {
+	var reg Reg
+	var err error
+	reg.Resources, err = getResources()
+	if err != nil {
+		return nil, err
+	}
+	ctx := context.Background()
+	{ // Learn our owner_id while updating harmony_machines
+		var ownerID *int
+
+		// Upsert query with last_contact update, fetch the machine ID
+		// (note this isn't a simple insert .. on conflict because host_and_port isn't unique)
+		err := db.QueryRow(ctx, `
+			WITH upsert AS (
+				UPDATE harmony_machines
+				SET cpu = $2, ram = $3, gpu = $4, last_contact = CURRENT_TIMESTAMP
+				WHERE host_and_port = $1
+				RETURNING id
+			),
+			inserted AS (
+				INSERT INTO harmony_machines (host_and_port, cpu, ram, gpu, last_contact)
+				SELECT $1, $2, $3, $4, CURRENT_TIMESTAMP
+				WHERE NOT EXISTS (SELECT id FROM upsert)
+				RETURNING id
+			)
+			SELECT id FROM upsert
+			UNION ALL
+			SELECT id FROM inserted;
+		`, hostnameAndPort, reg.Cpu, reg.Ram, reg.Gpu).Scan(&ownerID)
+		if err != nil {
+			return nil, xerrors.Errorf("inserting machine entry: %w", err)
+		}
+		if ownerID == nil {
+			return nil, xerrors.Errorf("no owner id")
+		}
+
+		reg.MachineID = *ownerID
+
+		cleaned := CleanupMachines(context.Background(), db)
+		logger.Infow("Cleaned up machines", "count", cleaned)
+	}
+	go func() {
+		for {
+			time.Sleep(time.Minute)
+			if reg.shutdown.Load() {
+				return
+			}
+			_, err := db.Exec(ctx, `UPDATE harmony_machines SET last_contact=CURRENT_TIMESTAMP`)
+			if err != nil {
+				logger.Error("Cannot keepalive ", err)
+			}
+		}
+	}()
+
+	return &reg, nil
+}
+
+func CleanupMachines(ctx context.Context, db *harmonydb.DB) int {
+	ct, err := db.Exec(ctx,
+		`DELETE FROM harmony_machines WHERE last_contact < CURRENT_TIMESTAMP - INTERVAL '1 MILLISECOND' * $1 `,
+		LOOKS_DEAD_TIMEOUT.Milliseconds()) // ms enables unit testing to change timeout.
+	if err != nil {
+		logger.Warn("unable to delete old machines: ", err)
+	}
+	return ct
+}
+
+func (res *Reg) Shutdown() {
+	res.shutdown.Store(true)
+}
+
+func getResources() (res Resources, err error) {
+	b, err := exec.Command(`ps`, `-ef`).CombinedOutput()
+	if err != nil {
+		logger.Warn("Could not safety check for 2+ processes: ", err)
+	} else {
+		found := 0
+		for _, b := range bytes.Split(b, []byte("\n")) {
+			if lotusRE.Match(b) {
+				found++
+			}
+		}
+		if found > 1 {
+			logger.Warn("lotus-provider's defaults are for running alone. Use task maximums or CGroups.")
+		}
+	}
+
+	res = Resources{
+		Cpu: runtime.NumCPU(),
+		Ram: memory.FreeMemory(),
+		Gpu: getGPUDevices(),
+	}
+
+	return res, nil
+}
+
+func DiskFree(path string) (uint64, error) {
+	s := unix.Statfs_t{}
+	err := unix.Statfs(path, &s)
+	if err != nil {
+		return 0, err
+	}
+
+	return s.Bfree * uint64(s.Bsize), nil
+}
diff --git a/lib/harmony/taskhelp/common.go b/lib/harmony/taskhelp/common.go
new file mode 100644
index 000000000..eaeb4a1bf
--- /dev/null
+++ b/lib/harmony/taskhelp/common.go
@@ -0,0 +1,19 @@
+package taskhelp
+
+// SubsetIf returns a subset of the slice for which the predicate is true.
+// It does not allocate memory, but rearranges the list in place.
+// A non-zero list input will always return a non-zero list.
+// The return value is the subset and a boolean indicating whether the subset was sliced.
+func SliceIfFound[T any](slice []T, f func(T) bool) ([]T, bool) {
+	ct := 0
+	for i, v := range slice {
+		if f(v) {
+			slice[ct], slice[i] = slice[i], slice[ct]
+			ct++
+		}
+	}
+	if ct == 0 {
+		return slice, false
+	}
+	return slice[:ct], true
+}
diff --git a/lib/promise/promise.go b/lib/promise/promise.go
new file mode 100644
index 000000000..9b6a5e2b0
--- /dev/null
+++ b/lib/promise/promise.go
@@ -0,0 +1,47 @@
+package promise
+
+import (
+	"context"
+	"sync"
+)
+
+type Promise[T any] struct {
+	val  T
+	done chan struct{}
+	mu   sync.Mutex
+}
+
+func (p *Promise[T]) Set(val T) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	// Set value
+	p.val = val
+
+	// Initialize the done channel if it hasn't been initialized
+	if p.done == nil {
+		p.done = make(chan struct{})
+	}
+
+	// Signal that the value is set
+	close(p.done)
+}
+
+func (p *Promise[T]) Val(ctx context.Context) T {
+	p.mu.Lock()
+	// Initialize the done channel if it hasn't been initialized
+	if p.done == nil {
+		p.done = make(chan struct{})
+	}
+	p.mu.Unlock()
+
+	select {
+	case <-ctx.Done():
+		return *new(T)
+	case <-p.done:
+		p.mu.Lock()
+		val := p.val
+		p.mu.Unlock()
+		return val
+	}
+}
diff --git a/lib/promise/promise_test.go b/lib/promise/promise_test.go
new file mode 100644
index 000000000..c2e9b656e
--- /dev/null
+++ b/lib/promise/promise_test.go
@@ -0,0 +1,65 @@
+package promise
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestPromiseSet(t *testing.T) {
+	p := &Promise[int]{}
+
+	p.Set(42)
+	if p.val != 42 {
+		t.Fatalf("expected 42, got %v", p.val)
+	}
+}
+
+func TestPromiseVal(t *testing.T) {
+	p := &Promise[int]{}
+
+	p.Set(42)
+
+	ctx := context.Background()
+	val := p.Val(ctx)
+
+	if val != 42 {
+		t.Fatalf("expected 42, got %v", val)
+	}
+}
+
+func TestPromiseValWaitsForSet(t *testing.T) {
+	p := &Promise[int]{}
+	var val int
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	go func() {
+		defer wg.Done()
+		ctx := context.Background()
+		val = p.Val(ctx)
+	}()
+
+	time.Sleep(100 * time.Millisecond) // Give some time for the above goroutine to execute
+	p.Set(42)
+	wg.Wait()
+
+	if val != 42 {
+		t.Fatalf("expected 42, got %v", val)
+	}
+}
+
+func TestPromiseValContextCancel(t *testing.T) {
+	p := &Promise[int]{}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel() // Cancel the context
+
+	val := p.Val(ctx)
+
+	var zeroValue int
+	if val != zeroValue {
+		t.Fatalf("expected zero-value, got %v", val)
+	}
+}
diff --git a/lib/shardedmutex/shardedmutex.go b/lib/shardedmutex/shardedmutex.go
index 922ac3994..4d1c11bdf 100644
--- a/lib/shardedmutex/shardedmutex.go
+++ b/lib/shardedmutex/shardedmutex.go
@@ -11,8 +11,8 @@ const cacheline = 64
 // name     old time/op  new time/op  delta
 // Locks-8  74.6ns ± 7%  12.3ns ± 2%  -83.54%  (p=0.000 n=20+18)
 type paddedMutex struct {
-	mt  sync.Mutex
-	pad [cacheline - 8]uint8
+	mt sync.Mutex
+	_  [cacheline - 8]uint8
 }
 
 type ShardedMutex struct {
diff --git a/metrics/README.md b/metrics/README.md
new file mode 100644
index 000000000..dce18e308
--- /dev/null
+++ b/metrics/README.md
@@ -0,0 +1,144 @@
+# Setting Up Prometheus and Grafana
+
+Lotus supports exporting a wide range of metrics, enabling users to gain insights into its behavior and effectively analyze performance issues. These metrics can be conveniently utilized with aggregation and visualization tools for in-depth analysis. In this document, we show how you can set up Prometheus and Grafana for monitoring and visualizing these metrics:
+
+- **Prometheus**: Prometheus is an open-source monitoring and alerting toolkit designed for collecting and storing time-series data from various systems and applications. It provides a robust querying language (PromQL) and a web-based interface for analyzing and visualizing metrics.
+
+- **Grafana**: Grafana is an open-source platform for creating, sharing, and visualizing interactive dashboards and graphs. It integrates with various data sources, including Prometheus, to help users create meaningful visual representations of their data and set up alerting based on specific conditions.
+
+## Prerequisites
+
+- You have a Linux or Mac based system.
+- You have root access to install software
+- You have lotus node already running
+
+**Note:** These instructions have been tested on Ubuntu 23.04 and on Mac M1.
+
+## Install and start Prometheus
+
+### On Ubuntu:
+
+```
+# install prometheus
+sudo apt-get install prometheus
+
+# copy the prometheus.yml config to the correct directory
+sudo cp metrics/prometheus.yml /etc/prometheus/prometheus.yml
+
+# start prometheus
+sudo systemctl start prometheus
+
+# enable prometheus on boot (optional)
+sudo systemctl enable prometheus
+```
+
+### On Mac:
+
+```
+# install prometheus
+brew install prometheus
+
+# start prometheus
+prometheus --config.file=lotus/metrics/prometheus.yml
+```
+
+## Install and start Grafana
+
+### On Ubuntu:
+
+```
+# download the Grafana GPG key in our keyring
+wget -q -O - https://packages.grafana.com/gpg.key | gpg --dearmor | sudo tee /usr/share/keyrings/grafana.gpg > /dev/null
+
+# add the Grafana repository to our APT sources
+echo "deb [signed-by=/usr/share/keyrings/grafana.gpg] https://packages.grafana.com/oss/deb stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list
+
+# update our APT cache
+sudo apt-get update
+
+# now we can install grafana
+sudo apt-get install grafana
+
+# start grafana
+sudo systemctl start grafana-server
+
+# start grafana on boot (optional)
+sudo systemctl enable grafana-server
+```
+
+### On Mac:
+
+```
+brew install grafana
+brew services start grafana
+```
+
+You should now have Prometheus and Grafana running on your machine where Prometheus is already collecting metrics from your Lotus node (if its running) and saving it to a database.
+
+You can confirm everything is setup correctly by visiting:
+- Prometheus (http://localhost:9090): You can open the metric explorer and view any of the aggregated metrics scraped from Lotus
+- Grafana (http://localhost:3000): Default username/password is admin/admin, remember to change it after login.
+
+## Add Prometheus as datasource in Grafana
+
+1. Log in to Grafana using the web interface.
+2. Navigate to "Home" > "Connections" > "Data Sources."
+3. Click "Add data source."
+4. Choose "Prometheus."
+5. In the "HTTP" section, set the URL to http://localhost:9090.
+6. Click "Save & Test" to verify the connection.
+
+## Import one of the existing dashboards in lotus/metrics/grafana
+
+1. Log in to Grafana using the web interface.
+2. Navigate to "Home" > "Dashboards" > Click the drop down menu in the "New" button and select "Import"
+3. Paste any of the existing dashboards in lotus/metrics/grafana into the "Import via panel json" panel.
+4. Click "Load"
+5. Select the Prometheus datasource you created earlier
+6. Click "Import"
+
+# Collect system metrics using node_exporter
+
+Although Lotus includes many useful metrics it does not include system metrics, such as information about cpu, memory, disk, network, etc. If you are investigating an issue and have Lotus metrics available, its often very useful to correlate certain events or behaviour with general system metrics.
+
+## Install node_exporter
+If you have followed this guide so far and have Prometheus and Grafana already running, you can run the following commands to also aggregate the system metrics:
+
+Ubuntu:
+
+```
+
+# download the newest release by https://github.com/prometheus/node_exporter/releases (it was 1.6.1 as of writing this doc)
+wget https://github.com/prometheus/node_exporter/releases/download/v1.6.1/node_exporter-1.6.1.linux-amd64.tar.gz
+
+# extract the release (it contains a single binary plus some docs)
+tar -xf node_exporter-1.6.1.linux-amd64.tar.gz
+
+# move it to /usr/local/bin
+sudo mv node_exporter-1.6.1.linux-amd64/node_exporter /usr/local/bin
+
+# run node_exporter
+node_exporter
+```
+
+Mac:
+
+```
+# install node_exporter
+brew install node_exporter
+
+# run node_exporter
+node_exporter
+```
+
+## Import system dashboard
+
+Since our `prometheus.yml` config already has configuration for node_exporter, we can go straight away and import a Grafana dashboard for viewing:
+
+1. Download the most recent dashboard from https://grafana.com/grafana/dashboards/1860-node-exporter-full/
+2. Log in to Grafana (http://localhost:3000) using the web interface.
+3. Navigate to "Home" > "Dashboards" > Click the drop down menu in the "New" button and select "Import"
+4. Paste any of the existing dashboards in lotus/metrics/grafana into the "Import via panel json" panel.
+5. Click "Load"
+6. Select the Prometheus datasource you created earlier
+7. Click "Import"
diff --git a/metrics/grafana/MessageExecution.json b/metrics/grafana/MessageExecution.json
new file mode 100644
index 000000000..1bdee4e0a
--- /dev/null
+++ b/metrics/grafana/MessageExecution.json
@@ -0,0 +1,241 @@
+{
+    "__inputs": [
+        {
+            "name": "DS_PROMETHEUS",
+            "label": "Prometheus",
+            "description": "",
+            "type": "datasource",
+            "pluginId": "prometheus",
+            "pluginName": "Prometheus"
+        }
+    ],
+    "__elements": {},
+    "__requires": [
+        {
+            "type": "grafana",
+            "id": "grafana",
+            "name": "Grafana",
+            "version": "10.1.1"
+        },
+        {
+            "type": "datasource",
+            "id": "prometheus",
+            "name": "Prometheus",
+            "version": "1.0.0"
+        },
+        {
+            "type": "panel",
+            "id": "timeseries",
+            "name": "Time series",
+            "version": ""
+        }
+    ],
+    "annotations": {
+        "list": [
+            {
+                "builtIn": 1,
+                "datasource": {
+                    "type": "grafana",
+                    "uid": "-- Grafana --"
+                },
+                "enable": true,
+                "hide": true,
+                "iconColor": "rgba(0, 211, 255, 1)",
+                "name": "Annotations & Alerts",
+                "type": "dashboard"
+            }
+        ]
+    },
+    "editable": true,
+    "fiscalYearStartMonth": 0,
+    "graphTooltip": 0,
+    "id": null,
+    "links": [],
+    "liveNow": false,
+    "panels": [
+        {
+            "datasource": {
+                "type": "prometheus",
+                "uid": "${DS_PROMETHEUS}"
+            },
+            "description": "Understand where time is spent in ApplyBlocks which is executed as part of ExecuteTipSet, its metric include:\n\n- applyblocks_total_ms (total): The total time spent in Applyblocks\n- applyblocks_cron (cron): Time spent in cron\n- applyblocks_early (early): Time spent in early apply-blocks (null cron, upgrades)\n- applyblocks_flush (flush): Time spent flushing vm state\n- applyblocks_messages (apply messages): Time spent applying block messages\n",
+            "fieldConfig": {
+                "defaults": {
+                    "color": {
+                        "mode": "palette-classic"
+                    },
+                    "custom": {
+                        "axisCenteredZero": false,
+                        "axisColorMode": "text",
+                        "axisLabel": "Time in MS",
+                        "axisPlacement": "auto",
+                        "barAlignment": 0,
+                        "drawStyle": "line",
+                        "fillOpacity": 0,
+                        "gradientMode": "none",
+                        "hideFrom": {
+                            "legend": false,
+                            "tooltip": false,
+                            "viz": false
+                        },
+                        "insertNulls": false,
+                        "lineInterpolation": "smooth",
+                        "lineWidth": 1,
+                        "pointSize": 5,
+                        "scaleDistribution": {
+                            "type": "linear"
+                        },
+                        "showPoints": "auto",
+                        "spanNulls": 60000,
+                        "stacking": {
+                            "group": "A",
+                            "mode": "none"
+                        },
+                        "thresholdsStyle": {
+                            "mode": "off"
+                        }
+                    },
+                    "mappings": [],
+                    "thresholds": {
+                        "mode": "absolute",
+                        "steps": [
+                            {
+                                "color": "green",
+                                "value": null
+                            },
+                            {
+                                "color": "red",
+                                "value": 80
+                            }
+                        ]
+                    }
+                },
+                "overrides": []
+            },
+            "gridPos": {
+                "h": 10,
+                "w": 12,
+                "x": 0,
+                "y": 0
+            },
+            "id": 1,
+            "options": {
+                "legend": {
+                    "calcs": [],
+                    "displayMode": "list",
+                    "placement": "bottom",
+                    "showLegend": true
+                },
+                "tooltip": {
+                    "mode": "single",
+                    "sort": "none"
+                }
+            },
+            "targets": [
+                {
+                    "datasource": {
+                        "type": "prometheus",
+                        "uid": "${DS_PROMETHEUS}"
+                    },
+                    "disableTextWrap": false,
+                    "editorMode": "builder",
+                    "expr": "histogram_quantile(0.99, sum by(le) (rate(lotus_vm_applyblocks_total_ms_bucket[$__rate_interval])))",
+                    "fullMetaSearch": false,
+                    "includeNullMetadata": false,
+                    "instant": false,
+                    "legendFormat": "Total",
+                    "range": true,
+                    "refId": "A",
+                    "useBackend": false
+                },
+                {
+                    "datasource": {
+                        "type": "prometheus",
+                        "uid": "${DS_PROMETHEUS}"
+                    },
+                    "disableTextWrap": false,
+                    "editorMode": "builder",
+                    "expr": "histogram_quantile(0.99, sum by(le) (rate(lotus_vm_applyblocks_cron_bucket[$__rate_interval])))",
+                    "fullMetaSearch": false,
+                    "hide": false,
+                    "includeNullMetadata": false,
+                    "instant": false,
+                    "legendFormat": "Cron",
+                    "range": true,
+                    "refId": "B",
+                    "useBackend": false
+                },
+                {
+                    "datasource": {
+                        "type": "prometheus",
+                        "uid": "${DS_PROMETHEUS}"
+                    },
+                    "disableTextWrap": false,
+                    "editorMode": "builder",
+                    "expr": "histogram_quantile(0.99, sum by(le) (rate(lotus_vm_applyblocks_early_bucket[$__rate_interval])))",
+                    "fullMetaSearch": false,
+                    "hide": false,
+                    "includeNullMetadata": false,
+                    "instant": false,
+                    "legendFormat": "Early",
+                    "range": true,
+                    "refId": "C",
+                    "useBackend": false
+                },
+                {
+                    "datasource": {
+                        "type": "prometheus",
+                        "uid": "${DS_PROMETHEUS}"
+                    },
+                    "disableTextWrap": false,
+                    "editorMode": "builder",
+                    "expr": "histogram_quantile(0.99, sum by(le) (rate(lotus_vm_applyblocks_flush_bucket[$__rate_interval])))",
+                    "fullMetaSearch": false,
+                    "hide": false,
+                    "includeNullMetadata": false,
+                    "instant": false,
+                    "legendFormat": "Flush",
+                    "range": true,
+                    "refId": "D",
+                    "useBackend": false
+                },
+                {
+                    "datasource": {
+                        "type": "prometheus",
+                        "uid": "${DS_PROMETHEUS}"
+                    },
+                    "disableTextWrap": false,
+                    "editorMode": "builder",
+                    "expr": "histogram_quantile(0.99, sum by(le) (rate(lotus_vm_applyblocks_messages_bucket[$__rate_interval])))",
+                    "fullMetaSearch": false,
+                    "hide": false,
+                    "includeNullMetadata": false,
+                    "instant": false,
+                    "legendFormat": "Apply messages",
+                    "range": true,
+                    "refId": "E",
+                    "useBackend": false
+                }
+            ],
+            "title": "ApplyBlocks (ms)",
+            "type": "timeseries"
+        }
+    ],
+    "refresh": "",
+    "schemaVersion": 38,
+    "style": "dark",
+    "tags": [],
+    "templating": {
+        "list": []
+    },
+    "time": {
+        "from": "now-5m",
+        "to": "now"
+    },
+    "timepicker": {},
+    "timezone": "",
+    "title": "Lotus Message Execution",
+    "uid": "a7bacd0e-f7a1-418f-98e5-3469c5e0b6ea",
+    "version": 5,
+    "weekStart": ""
+}
\ No newline at end of file
diff --git a/metrics/metrics.go b/metrics/metrics.go
index 822974f81..5d6ba79ec 100644
--- a/metrics/metrics.go
+++ b/metrics/metrics.go
@@ -106,6 +106,7 @@ var (
 	MpoolAddTsDuration                  = stats.Float64("mpool/addts_ms", "Duration of addTs in mpool", stats.UnitMilliseconds)
 	MpoolAddDuration                    = stats.Float64("mpool/add_ms", "Duration of Add in mpool", stats.UnitMilliseconds)
 	MpoolPushDuration                   = stats.Float64("mpool/push_ms", "Duration of Push in mpool", stats.UnitMilliseconds)
+	MpoolMessageCount                   = stats.Int64("mpool/message_count", "Number of messages in the mpool", stats.UnitDimensionless)
 	BlockPublished                      = stats.Int64("block/published", "Counter for total locally published blocks", stats.UnitDimensionless)
 	BlockReceived                       = stats.Int64("block/received", "Counter for total received blocks", stats.UnitDimensionless)
 	BlockValidationFailure              = stats.Int64("block/failure", "Counter for block validation failures", stats.UnitDimensionless)
@@ -307,6 +308,10 @@ var (
 		Measure:     MpoolPushDuration,
 		Aggregation: defaultMillisecondsDistribution,
 	}
+	MpoolMessageCountView = &view.View{
+		Measure:     MpoolMessageCount,
+		Aggregation: view.LastValue(),
+	}
 	PeerCountView = &view.View{
 		Measure:     PeerCount,
 		Aggregation: view.LastValue(),
@@ -700,46 +705,55 @@ var (
 	}
 )
 
+var views = []*view.View{
+	InfoView,
+	PeerCountView,
+	APIRequestDurationView,
+
+	GraphsyncReceivingPeersCountView,
+	GraphsyncReceivingActiveCountView,
+	GraphsyncReceivingCountCountView,
+	GraphsyncReceivingTotalMemoryAllocatedView,
+	GraphsyncReceivingTotalPendingAllocationsView,
+	GraphsyncReceivingPeersPendingView,
+	GraphsyncSendingPeersCountView,
+	GraphsyncSendingActiveCountView,
+	GraphsyncSendingCountCountView,
+	GraphsyncSendingTotalMemoryAllocatedView,
+	GraphsyncSendingTotalPendingAllocationsView,
+	GraphsyncSendingPeersPendingView,
+
+	RcmgrAllowConnView,
+	RcmgrBlockConnView,
+	RcmgrAllowStreamView,
+	RcmgrBlockStreamView,
+	RcmgrAllowPeerView,
+	RcmgrBlockPeerView,
+	RcmgrAllowProtoView,
+	RcmgrBlockProtoView,
+	RcmgrBlockProtoPeerView,
+	RcmgrAllowSvcView,
+	RcmgrBlockSvcView,
+	RcmgrBlockSvcPeerView,
+	RcmgrAllowMemView,
+	RcmgrBlockMemView,
+}
+
 // DefaultViews is an array of OpenCensus views for metric gathering purposes
 var DefaultViews = func() []*view.View {
-	views := []*view.View{
-		InfoView,
-		PeerCountView,
-		APIRequestDurationView,
-
-		GraphsyncReceivingPeersCountView,
-		GraphsyncReceivingActiveCountView,
-		GraphsyncReceivingCountCountView,
-		GraphsyncReceivingTotalMemoryAllocatedView,
-		GraphsyncReceivingTotalPendingAllocationsView,
-		GraphsyncReceivingPeersPendingView,
-		GraphsyncSendingPeersCountView,
-		GraphsyncSendingActiveCountView,
-		GraphsyncSendingCountCountView,
-		GraphsyncSendingTotalMemoryAllocatedView,
-		GraphsyncSendingTotalPendingAllocationsView,
-		GraphsyncSendingPeersPendingView,
-
-		RcmgrAllowConnView,
-		RcmgrBlockConnView,
-		RcmgrAllowStreamView,
-		RcmgrBlockStreamView,
-		RcmgrAllowPeerView,
-		RcmgrBlockPeerView,
-		RcmgrAllowProtoView,
-		RcmgrBlockProtoView,
-		RcmgrBlockProtoPeerView,
-		RcmgrAllowSvcView,
-		RcmgrBlockSvcView,
-		RcmgrBlockSvcPeerView,
-		RcmgrAllowMemView,
-		RcmgrBlockMemView,
-	}
-	views = append(views, blockstore.DefaultViews...)
-	views = append(views, rpcmetrics.DefaultViews...)
 	return views
 }()
 
+// RegisterViews adds views to the default list without modifying this file.
+func RegisterViews(v ...*view.View) {
+	views = append(views, v...)
+}
+
+func init() {
+	RegisterViews(blockstore.DefaultViews...)
+	RegisterViews(rpcmetrics.DefaultViews...)
+}
+
 var ChainNodeViews = append([]*view.View{
 	ChainNodeHeightView,
 	ChainNodeHeightExpectedView,
@@ -761,6 +775,7 @@ var ChainNodeViews = append([]*view.View{
 	MpoolAddTsDurationView,
 	MpoolAddDurationView,
 	MpoolPushDurationView,
+	MpoolMessageCountView,
 	PubsubPublishMessageView,
 	PubsubDeliverMessageView,
 	PubsubRejectMessageView,
@@ -833,7 +848,7 @@ var GatewayNodeViews = append([]*view.View{
 
 // SinceInMilliseconds returns the duration of time since the provide time as a float64.
 func SinceInMilliseconds(startTime time.Time) float64 {
-	return float64(time.Since(startTime).Nanoseconds()) / 1e6
+	return float64(time.Since(startTime).Milliseconds())
 }
 
 // Timer is a function stopwatch, calling it starts the timer,
diff --git a/metrics/prometheus.yml b/metrics/prometheus.yml
new file mode 100644
index 000000000..6d1564ab9
--- /dev/null
+++ b/metrics/prometheus.yml
@@ -0,0 +1,14 @@
+global:
+  scrape_interval: 1m
+
+scrape_configs:
+  - job_name: lotus
+    scrape_interval: 10s
+    metrics_path: '/debug/metrics'
+    static_configs:
+      - targets: ['localhost:1234']
+
+  - job_name: node_exporter
+    scrape_interval: 15s
+    static_configs:
+      - targets: ['localhost:9100']
diff --git a/metrics/proxy/proxy.go b/metrics/proxy/proxy.go
index dbadf255f..6885adfe9 100644
--- a/metrics/proxy/proxy.go
+++ b/metrics/proxy/proxy.go
@@ -10,6 +10,12 @@ import (
 	"github.com/filecoin-project/lotus/metrics"
 )
 
+func MetricedAPI[T, P any](a T) *P {
+	var out P
+	proxy(a, &out)
+	return &out
+}
+
 func MetricedStorMinerAPI(a api.StorageMiner) api.StorageMiner {
 	var out api.StorageMinerStruct
 	proxy(a, &out)
diff --git a/miner/miner.go b/miner/miner.go
index 1272e396f..d11e9d4aa 100644
--- a/miner/miner.go
+++ b/miner/miner.go
@@ -71,7 +71,7 @@ func NewMiner(api v1api.FullNode, epp gen.WinningPoStProver, addr address.Addres
 		api:     api,
 		epp:     epp,
 		address: addr,
-		waitFunc: func(ctx context.Context, baseTime uint64) (func(bool, abi.ChainEpoch, error), abi.ChainEpoch, error) {
+		propagationWaitFunc: func(ctx context.Context, baseTime uint64) (func(bool, abi.ChainEpoch, error), abi.ChainEpoch, error) {
 			// wait around for half the block time in case other parents come in
 			//
 			// if we're mining a block in the past via catch-up/rush mining,
@@ -114,7 +114,7 @@ type Miner struct {
 	stop     chan struct{}
 	stopping chan struct{}
 
-	waitFunc waitFunc
+	propagationWaitFunc waitFunc
 
 	// lastWork holds the last MiningBase we built upon.
 	lastWork *MiningBase
@@ -205,15 +205,21 @@ func (m *Miner) mine(ctx context.Context) {
 	ctx, span := trace.StartSpan(ctx, "/mine")
 	defer span.End()
 
+	// Perform the Winning PoSt warmup in a separate goroutine.
 	go m.doWinPoStWarmup(ctx)
 
 	var lastBase MiningBase
+
+	// Start the main mining loop.
 minerLoop:
 	for {
+		// Prepare a context for a single node operation.
 		ctx := cliutil.OnSingleNode(ctx)
 
+		// Handle stop signals.
 		select {
 		case <-m.stop:
+			// If a stop signal is received, clean up and exit the mining loop.
 			stopping := m.stopping
 			m.stop = nil
 			m.stopping = nil
@@ -223,10 +229,11 @@ minerLoop:
 		default:
 		}
 
-		var base *MiningBase
+		var base *MiningBase // NOTE: This points to m.lastWork; Incrementing nulls here will increment it there.
 		var onDone func(bool, abi.ChainEpoch, error)
 		var injectNulls abi.ChainEpoch
 
+		// Look for the best mining candidate.
 		for {
 			prebase, err := m.GetBestMiningCandidate(ctx)
 			if err != nil {
@@ -237,6 +244,7 @@ minerLoop:
 				continue
 			}
 
+			// Check if we have a new base or if the current base is still valid.
 			if base != nil && base.TipSet.Height() == prebase.TipSet.Height() && base.NullRounds == prebase.NullRounds {
 				base = prebase
 				break
@@ -253,13 +261,13 @@ minerLoop:
 			// best mining candidate at that time.
 
 			// Wait until propagation delay period after block we plan to mine on
-			onDone, injectNulls, err = m.waitFunc(ctx, prebase.TipSet.MinTimestamp())
+			onDone, injectNulls, err = m.propagationWaitFunc(ctx, prebase.TipSet.MinTimestamp())
 			if err != nil {
 				log.Error(err)
 				continue
 			}
 
-			// just wait for the beacon entry to become available before we select our final mining base
+			// Ensure the beacon entry is available before finalizing the mining base.
 			_, err = m.api.StateGetBeaconEntry(ctx, prebase.TipSet.Height()+prebase.NullRounds+1)
 			if err != nil {
 				log.Errorf("failed getting beacon entry: %s", err)
@@ -272,8 +280,9 @@ minerLoop:
 			base = prebase
 		}
 
-		base.NullRounds += injectNulls // testing
+		base.NullRounds += injectNulls // Adjust for testing purposes.
 
+		// Check for repeated mining candidates and handle sleep for the next round.
 		if base.TipSet.Equals(lastBase.TipSet) && lastBase.NullRounds == base.NullRounds {
 			log.Warnf("BestMiningCandidate from the previous round: %s (nulls:%d)", lastBase.TipSet.Cids(), lastBase.NullRounds)
 			if !m.niceSleep(time.Duration(build.BlockDelaySecs) * time.Second) {
@@ -282,6 +291,7 @@ minerLoop:
 			continue
 		}
 
+		// Attempt to mine a block.
 		b, err := m.mineOne(ctx, base)
 		if err != nil {
 			log.Errorf("mining block failed: %+v", err)
@@ -299,9 +309,12 @@ minerLoop:
 		}
 		onDone(b != nil, h, nil)
 
+		// Process the mined block.
 		if b != nil {
+			// Record the event of mining a block.
 			m.journal.RecordEvent(m.evtTypes[evtTypeBlockMined], func() interface{} {
 				return map[string]interface{}{
+					// Data about the mined block.
 					"parents":   base.TipSet.Cids(),
 					"nulls":     base.NullRounds,
 					"epoch":     b.Header.Height,
@@ -312,19 +325,23 @@ minerLoop:
 
 			btime := time.Unix(int64(b.Header.Timestamp), 0)
 			now := build.Clock.Now()
+			// Handle timing for broadcasting the block.
 			switch {
 			case btime == now:
 				// block timestamp is perfectly aligned with time.
 			case btime.After(now):
+				// Wait until it's time to broadcast the block.
 				if !m.niceSleep(build.Clock.Until(btime)) {
 					log.Warnf("received interrupt while waiting to broadcast block, will shutdown after block is sent out")
 					build.Clock.Sleep(build.Clock.Until(btime))
 				}
 			default:
+				// Log if the block was mined in the past.
 				log.Warnw("mined block in the past",
 					"block-time", btime, "time", build.Clock.Now(), "difference", build.Clock.Since(btime))
 			}
 
+			// Check for slash filter conditions.
 			if os.Getenv("LOTUS_MINER_NO_SLASHFILTER") != "_yes_i_know_i_can_and_probably_will_lose_all_my_fil_and_power_" && !build.IsNearUpgrade(base.TipSet.Height(), build.UpgradeWatermelonFixHeight) {
 				witness, fault, err := m.sf.MinedBlock(ctx, b.Header, base.TipSet.Height()+base.NullRounds)
 				if err != nil {
@@ -339,25 +356,27 @@ minerLoop:
 				}
 			}
 
+			// Check for blocks created at the same height.
 			if _, ok := m.minedBlockHeights.Get(b.Header.Height); ok {
 				log.Warnw("Created a block at the same height as another block we've created", "height", b.Header.Height, "miner", b.Header.Miner, "parents", b.Header.Parents)
 				continue
 			}
 
+			// Add the block height to the mined block heights.
 			m.minedBlockHeights.Add(b.Header.Height, true)
 
+			// Submit the newly mined block.
 			if err := m.api.SyncSubmitBlock(ctx, b); err != nil {
 				log.Errorf("failed to submit newly mined block: %+v", err)
 			}
 		} else {
+			// If no block was mined, increase the null rounds and wait for the next epoch.
 			base.NullRounds++
 
-			// Wait until the next epoch, plus the propagation delay, so a new tipset
-			// has enough time to form.
-			//
-			// See:  https://github.com/filecoin-project/lotus/issues/1845
+			// Calculate the time for the next round.
 			nextRound := time.Unix(int64(base.TipSet.MinTimestamp()+build.BlockDelaySecs*uint64(base.NullRounds))+int64(build.PropagationDelaySecs), 0)
 
+			// Wait for the next round or stop signal.
 			select {
 			case <-build.Clock.After(build.Clock.Until(nextRound)):
 			case <-m.stop:
@@ -562,7 +581,7 @@ func (m *Miner) mineOne(ctx context.Context, base *MiningBase) (minedBlock *type
 		return nil, err
 	}
 
-	tEquivocateWait := build.Clock.Now()
+	tPending := build.Clock.Now()
 
 	// This next block exists to "catch" equivocating miners,
 	// who submit 2 blocks at the same height at different times in order to split the network.
@@ -576,6 +595,8 @@ func (m *Miner) mineOne(ctx context.Context, base *MiningBase) (minedBlock *type
 		return nil, err
 	}
 
+	tEquivocateWait := build.Clock.Now()
+
 	// If the base has changed, we take the _intersection_ of our old base and new base,
 	// thus ejecting blocks from any equivocating miners, without taking any new blocks.
 	if newBase.TipSet.Height() == base.TipSet.Height() && !newBase.TipSet.Equals(base.TipSet) {
@@ -621,7 +642,7 @@ func (m *Miner) mineOne(ctx context.Context, base *MiningBase) (minedBlock *type
 		}
 	}
 
-	tPending := build.Clock.Now()
+	tIntersectAndRefresh := build.Clock.Now()
 
 	// TODO: winning post proof
 	minedBlock, err = m.createBlock(base, m.address, ticket, winner, bvals, postProof, msgs)
@@ -637,15 +658,16 @@ func (m *Miner) mineOne(ctx context.Context, base *MiningBase) (minedBlock *type
 		parentMiners[i] = header.Miner
 	}
 	log.Infow("mined new block", "cid", minedBlock.Cid(), "height", int64(minedBlock.Header.Height), "miner", minedBlock.Header.Miner, "parents", parentMiners, "parentTipset", base.TipSet.Key().String(), "took", dur)
-	if dur > time.Second*time.Duration(build.BlockDelaySecs) {
-		log.Warnw("CAUTION: block production took longer than the block delay. Your computer may not be fast enough to keep up",
+	if dur > time.Second*time.Duration(build.BlockDelaySecs) || time.Now().Compare(time.Unix(int64(minedBlock.Header.Timestamp), 0)) >= 0 {
+		log.Warnw("CAUTION: block production took us past the block time. Your computer may not be fast enough to keep up",
 			"tPowercheck ", tPowercheck.Sub(tStart),
 			"tTicket ", tTicket.Sub(tPowercheck),
 			"tSeed ", tSeed.Sub(tTicket),
 			"tProof ", tProof.Sub(tSeed),
-			"tEquivocateWait ", tEquivocateWait.Sub(tProof),
-			"tPending ", tPending.Sub(tEquivocateWait),
-			"tCreateBlock ", tCreateBlock.Sub(tPending))
+			"tPending ", tPending.Sub(tProof),
+			"tEquivocateWait ", tEquivocateWait.Sub(tPending),
+			"tIntersectAndRefresh ", tIntersectAndRefresh.Sub(tEquivocateWait),
+			"tCreateBlock ", tCreateBlock.Sub(tIntersectAndRefresh))
 	}
 
 	return minedBlock, nil
diff --git a/miner/testminer.go b/miner/testminer.go
index f1d11bae0..e23b26ae2 100644
--- a/miner/testminer.go
+++ b/miner/testminer.go
@@ -28,13 +28,13 @@ func NewTestMiner(nextCh <-chan MineReq, addr address.Address) func(v1api.FullNo
 		}
 
 		m := &Miner{
-			api:               api,
-			waitFunc:          chanWaiter(nextCh),
-			epp:               epp,
-			minedBlockHeights: arc,
-			address:           addr,
-			sf:                slashfilter.New(ds.NewMapDatastore()),
-			journal:           journal.NilJournal(),
+			api:                 api,
+			propagationWaitFunc: chanWaiter(nextCh),
+			epp:                 epp,
+			minedBlockHeights:   arc,
+			address:             addr,
+			sf:                  slashfilter.New(ds.NewMapDatastore()),
+			journal:             journal.NilJournal(),
 		}
 
 		if err := m.Start(context.TODO()); err != nil {
diff --git a/node/builder.go b/node/builder.go
index f1a825be9..128a99f87 100644
--- a/node/builder.go
+++ b/node/builder.go
@@ -90,6 +90,7 @@ const (
 	// health checks
 	CheckFDLimit
 	CheckFvmConcurrency
+	CheckUDPBufferSize
 	LegacyMarketsEOL
 
 	// libp2p
@@ -169,6 +170,7 @@ func defaults() []Option {
 
 		Override(CheckFDLimit, modules.CheckFdLimit(build.DefaultFDLimit)),
 		Override(CheckFvmConcurrency, modules.CheckFvmConcurrency()),
+		Override(CheckUDPBufferSize, modules.CheckUDPBufferSize(2048*1024)),
 
 		Override(new(system.MemoryConstraints), modules.MemoryConstraints),
 		Override(InitMemoryWatchdog, modules.MemoryWatchdog),
diff --git a/node/builder_miner.go b/node/builder_miner.go
index d9c92422d..08c71ba19 100644
--- a/node/builder_miner.go
+++ b/node/builder_miner.go
@@ -19,6 +19,7 @@ import (
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
 	"github.com/filecoin-project/lotus/markets/dagstore"
 	"github.com/filecoin-project/lotus/markets/dealfilter"
 	"github.com/filecoin-project/lotus/markets/idxprov"
@@ -102,6 +103,7 @@ func ConfigStorageMiner(c interface{}) Option {
 			If(cfg.Subsystems.EnableSealing, Error(xerrors.Errorf("sealing can only be enabled on a mining node"))),
 			If(cfg.Subsystems.EnableSectorStorage, Error(xerrors.Errorf("sealing can only be enabled on a mining node"))),
 		),
+
 		If(cfg.Subsystems.EnableMining,
 			If(!cfg.Subsystems.EnableSealing, Error(xerrors.Errorf("sealing can't be disabled on a mining node yet"))),
 			If(!cfg.Subsystems.EnableSectorStorage, Error(xerrors.Errorf("sealing can't be disabled on a mining node yet"))),
@@ -116,19 +118,35 @@ func ConfigStorageMiner(c interface{}) Option {
 
 			// Mining / proving
 			Override(new(*slashfilter.SlashFilter), modules.NewSlashFilter),
-			Override(new(*miner.Miner), modules.SetupBlockProducer),
-			Override(new(gen.WinningPoStProver), storage.NewWinningPoStProver),
+
+			If(!cfg.Subsystems.DisableWinningPoSt,
+				Override(new(*miner.Miner), modules.SetupBlockProducer),
+				Override(new(gen.WinningPoStProver), storage.NewWinningPoStProver),
+			),
+
 			Override(PreflightChecksKey, modules.PreflightChecks),
 			Override(new(*sealing.Sealing), modules.SealingPipeline(cfg.Fees)),
 
-			Override(new(*wdpost.WindowPoStScheduler), modules.WindowPostScheduler(cfg.Fees, cfg.Proving)),
+			If(!cfg.Subsystems.DisableWindowPoSt, Override(new(*wdpost.WindowPoStScheduler), modules.WindowPostScheduler(cfg.Fees, cfg.Proving))),
 			Override(new(sectorblocks.SectorBuilder), From(new(*sealing.Sealing))),
 		),
 
 		If(cfg.Subsystems.EnableSectorStorage,
 			// Sector storage
-			Override(new(*paths.Index), paths.NewIndex),
-			Override(new(paths.SectorIndex), From(new(*paths.Index))),
+			If(cfg.Subsystems.EnableSectorIndexDB,
+				Override(new(*paths.DBIndex), paths.NewDBIndex),
+				Override(new(paths.SectorIndex), From(new(*paths.DBIndex))),
+
+				// sector index db is the only thing on lotus-miner that will use harmonydb
+				Override(new(*harmonydb.DB), func(cfg config.HarmonyDB, id harmonydb.ITestID) (*harmonydb.DB, error) {
+					return harmonydb.NewFromConfigWithITestID(cfg)(id)
+				}),
+			),
+			If(!cfg.Subsystems.EnableSectorIndexDB,
+				Override(new(*paths.MemIndex), paths.NewMemIndex),
+				Override(new(paths.SectorIndex), From(new(*paths.MemIndex))),
+			),
+
 			Override(new(*sectorstorage.Manager), modules.SectorStorage),
 			Override(new(sectorstorage.Unsealer), From(new(*sectorstorage.Manager))),
 			Override(new(sectorstorage.SectorManager), From(new(*sectorstorage.Manager))),
@@ -230,6 +248,8 @@ func ConfigStorageMiner(c interface{}) Option {
 
 		Override(new(config.SealerConfig), cfg.Storage),
 		Override(new(config.ProvingConfig), cfg.Proving),
+		Override(new(config.HarmonyDB), cfg.HarmonyDB),
+		Override(new(harmonydb.ITestID), harmonydb.ITestID("")),
 		Override(new(*ctladdr.AddressSelector), modules.AddressSelector(&cfg.Addresses)),
 	)
 }
diff --git a/node/config/cfgdocgen/gen.go b/node/config/cfgdocgen/gen.go
index 577e85f9d..b13b7d799 100644
--- a/node/config/cfgdocgen/gen.go
+++ b/node/config/cfgdocgen/gen.go
@@ -104,7 +104,7 @@ var Doc = map[string][]DocField{
 	for _, typeName := range outt {
 		typ := out[typeName]
 
-		fmt.Printf("\t\"%s\": []DocField{\n", typeName)
+		fmt.Printf("\t\"%s\": {\n", typeName)
 
 		for _, f := range typ {
 			fmt.Println("\t\t{")
diff --git a/node/config/def.go b/node/config/def.go
index dd36803a0..dc358b140 100644
--- a/node/config/def.go
+++ b/node/config/def.go
@@ -238,6 +238,7 @@ func DefaultStorageMiner() *StorageMiner {
 			EnableSealing:       true,
 			EnableSectorStorage: true,
 			EnableMarkets:       false,
+			EnableSectorIndexDB: false,
 		},
 
 		Fees: MinerFeeConfig{
@@ -257,6 +258,8 @@ func DefaultStorageMiner() *StorageMiner {
 			MaxWindowPoStGasFee:    types.MustParseFIL("5"),
 			MaxPublishDealsFee:     types.MustParseFIL("0.05"),
 			MaxMarketBalanceAddFee: types.MustParseFIL("0.007"),
+
+			MaximizeWindowPoStFeeCap: true,
 		},
 
 		Addresses: MinerAddressConfig{
@@ -272,6 +275,13 @@ func DefaultStorageMiner() *StorageMiner {
 			MaxConcurrentUnseals:       5,
 			GCInterval:                 Duration(1 * time.Minute),
 		},
+		HarmonyDB: HarmonyDB{
+			Hosts:    []string{"127.0.0.1"},
+			Username: "yugabyte",
+			Password: "yugabyte",
+			Database: "yugabyte",
+			Port:     "5433",
+		},
 	}
 
 	cfg.Common.API.ListenAddress = "/ip4/127.0.0.1/tcp/2345/http"
@@ -338,3 +348,37 @@ func DefaultUserRaftConfig() *UserRaftConfig {
 
 	return &cfg
 }
+
+func DefaultLotusProvider() *LotusProviderConfig {
+	return &LotusProviderConfig{
+		Subsystems: ProviderSubsystemsConfig{},
+		Fees: LotusProviderFees{
+			DefaultMaxFee:      DefaultDefaultMaxFee,
+			MaxPreCommitGasFee: types.MustParseFIL("0.025"),
+			MaxCommitGasFee:    types.MustParseFIL("0.05"),
+
+			MaxPreCommitBatchGasFee: BatchFeeConfig{
+				Base:      types.MustParseFIL("0"),
+				PerSector: types.MustParseFIL("0.02"),
+			},
+			MaxCommitBatchGasFee: BatchFeeConfig{
+				Base:      types.MustParseFIL("0"),
+				PerSector: types.MustParseFIL("0.03"), // enough for 6 agg and 1nFIL base fee
+			},
+
+			MaxTerminateGasFee:  types.MustParseFIL("0.5"),
+			MaxWindowPoStGasFee: types.MustParseFIL("5"),
+			MaxPublishDealsFee:  types.MustParseFIL("0.05"),
+		},
+		Addresses: LotusProviderAddresses{
+			PreCommitControl: []string{},
+			CommitControl:    []string{},
+			TerminateControl: []string{},
+		},
+		Proving: ProvingConfig{
+			ParallelCheckLimit:    32,
+			PartitionCheckTimeout: Duration(20 * time.Minute),
+			SingleCheckTimeout:    Duration(10 * time.Minute),
+		},
+	}
+}
diff --git a/node/config/def_test.go b/node/config/def_test.go
index 1739339a2..627b65a56 100644
--- a/node/config/def_test.go
+++ b/node/config/def_test.go
@@ -71,6 +71,12 @@ func TestDefaultMinerRoundtrip(t *testing.T) {
 
 	fmt.Println(s)
 
+	// Differs between test envs
+	c.HarmonyDB = HarmonyDB{}
+	c2.(*StorageMiner).HarmonyDB = HarmonyDB{}
+
+	fmt.Println(c)
+	fmt.Println(c2)
 	require.True(t, reflect.DeepEqual(c, c2))
 }
 
diff --git a/node/config/doc_gen.go b/node/config/doc_gen.go
index 26eaef0d6..13ecb2706 100644
--- a/node/config/doc_gen.go
+++ b/node/config/doc_gen.go
@@ -9,7 +9,7 @@ type DocField struct {
 }
 
 var Doc = map[string][]DocField{
-	"API": []DocField{
+	"API": {
 		{
 			Name: "ListenAddress",
 			Type: "string",
@@ -29,7 +29,23 @@ var Doc = map[string][]DocField{
 			Comment: ``,
 		},
 	},
-	"Backup": []DocField{
+	"ApisConfig": {
+		{
+			Name: "ChainApiInfo",
+			Type: "[]string",
+
+			Comment: `ChainApiInfo is the API endpoint for the Lotus daemon.`,
+		},
+		{
+			Name: "StorageRPCSecret",
+			Type: "string",
+
+			Comment: `RPC Secret for the storage subsystem.
+If integrating with lotus-miner this must match the value from
+cat ~/.lotusminer/keystore/MF2XI2BNNJ3XILLQOJUXMYLUMU | jq -r .PrivateKey`,
+		},
+	},
+	"Backup": {
 		{
 			Name: "DisableMetadataLog",
 			Type: "bool",
@@ -41,7 +57,7 @@ Note that in case of metadata corruption it might be much harder to recover
 your node if metadata log is disabled`,
 		},
 	},
-	"BatchFeeConfig": []DocField{
+	"BatchFeeConfig": {
 		{
 			Name: "Base",
 			Type: "types.FIL",
@@ -55,7 +71,7 @@ your node if metadata log is disabled`,
 			Comment: ``,
 		},
 	},
-	"Chainstore": []DocField{
+	"Chainstore": {
 		{
 			Name: "EnableSplitstore",
 			Type: "bool",
@@ -69,7 +85,7 @@ your node if metadata log is disabled`,
 			Comment: ``,
 		},
 	},
-	"Client": []DocField{
+	"Client": {
 		{
 			Name: "UseIpfs",
 			Type: "bool",
@@ -117,7 +133,7 @@ without existing payment channels with available funds will fail instead
 of automatically performing on-chain operations.`,
 		},
 	},
-	"Common": []DocField{
+	"Common": {
 		{
 			Name: "API",
 			Type: "API",
@@ -149,7 +165,7 @@ of automatically performing on-chain operations.`,
 			Comment: ``,
 		},
 	},
-	"DAGStoreConfig": []DocField{
+	"DAGStoreConfig": {
 		{
 			Name: "RootDir",
 			Type: "string",
@@ -206,7 +222,7 @@ representation, e.g. 1m, 5m, 1h.
 Default value: 1 minute.`,
 		},
 	},
-	"DealmakingConfig": []DocField{
+	"DealmakingConfig": {
 		{
 			Name: "ConsiderOnlineStorageDeals",
 			Type: "bool",
@@ -341,7 +357,7 @@ see https://lotus.filecoin.io/storage-providers/advanced-configurations/market/#
 			Comment: ``,
 		},
 	},
-	"Events": []DocField{
+	"Events": {
 		{
 			Name: "DisableRealTimeFilterAPI",
 			Type: "bool",
@@ -394,7 +410,7 @@ the database must already exist and be writeable. If a relative path is provided
 relative to the CWD (current working directory).`,
 		},
 	},
-	"FaultReporterConfig": []DocField{
+	"FaultReporterConfig": {
 		{
 			Name: "EnableConsensusFaultReporter",
 			Type: "bool",
@@ -423,7 +439,7 @@ ReportConsensusFault messages. It will pay for gas fees, and receive any
 rewards. This address should have adequate funds to cover gas fees.`,
 		},
 	},
-	"FeeConfig": []DocField{
+	"FeeConfig": {
 		{
 			Name: "DefaultMaxFee",
 			Type: "types.FIL",
@@ -431,7 +447,7 @@ rewards. This address should have adequate funds to cover gas fees.`,
 			Comment: ``,
 		},
 	},
-	"FevmConfig": []DocField{
+	"FevmConfig": {
 		{
 			Name: "EnableEthRPC",
 			Type: "bool",
@@ -453,7 +469,7 @@ Set to 0 to keep all mappings`,
 			Comment: ``,
 		},
 	},
-	"FullNode": []DocField{
+	"FullNode": {
 		{
 			Name: "Client",
 			Type: "Client",
@@ -503,7 +519,40 @@ Set to 0 to keep all mappings`,
 			Comment: ``,
 		},
 	},
-	"IndexConfig": []DocField{
+	"HarmonyDB": {
+		{
+			Name: "Hosts",
+			Type: "[]string",
+
+			Comment: `HOSTS is a list of hostnames to nodes running YugabyteDB
+in a cluster. Only 1 is required`,
+		},
+		{
+			Name: "Username",
+			Type: "string",
+
+			Comment: `The Yugabyte server's username with full credentials to operate on Lotus' Database. Blank for default.`,
+		},
+		{
+			Name: "Password",
+			Type: "string",
+
+			Comment: `The password for the related username. Blank for default.`,
+		},
+		{
+			Name: "Database",
+			Type: "string",
+
+			Comment: `The database (logical partition) within Yugabyte. Blank for default.`,
+		},
+		{
+			Name: "Port",
+			Type: "string",
+
+			Comment: `The port to find Yugabyte. Blank for default.`,
+		},
+	},
+	"IndexConfig": {
 		{
 			Name: "EnableMsgIndex",
 			Type: "bool",
@@ -512,7 +561,7 @@ Set to 0 to keep all mappings`,
 EnableMsgIndex enables indexing of messages on chain.`,
 		},
 	},
-	"IndexProviderConfig": []DocField{
+	"IndexProviderConfig": {
 		{
 			Name: "Enable",
 			Type: "bool",
@@ -557,7 +606,15 @@ starts. By default, the cache is rehydrated from previously cached entries store
 datastore if any is present.`,
 		},
 	},
-	"Libp2p": []DocField{
+	"JournalConfig": {
+		{
+			Name: "DisabledEvents",
+			Type: "string",
+
+			Comment: `Events of the form: "system1:event1,system1:event2[,...]"`,
+		},
+	},
+	"Libp2p": {
 		{
 			Name: "ListenAddresses",
 			Type: "[]string",
@@ -624,7 +681,7 @@ count towards this limit.`,
 closed by the connection manager.`,
 		},
 	},
-	"Logging": []DocField{
+	"Logging": {
 		{
 			Name: "SubsystemLevels",
 			Type: "map[string]string",
@@ -632,7 +689,137 @@ closed by the connection manager.`,
 			Comment: `SubsystemLevels specify per-subsystem log levels`,
 		},
 	},
-	"MinerAddressConfig": []DocField{
+	"LotusProviderAddresses": {
+		{
+			Name: "PreCommitControl",
+			Type: "[]string",
+
+			Comment: `Addresses to send PreCommit messages from`,
+		},
+		{
+			Name: "CommitControl",
+			Type: "[]string",
+
+			Comment: `Addresses to send Commit messages from`,
+		},
+		{
+			Name: "TerminateControl",
+			Type: "[]string",
+
+			Comment: ``,
+		},
+		{
+			Name: "DisableOwnerFallback",
+			Type: "bool",
+
+			Comment: `DisableOwnerFallback disables usage of the owner address for messages
+sent automatically`,
+		},
+		{
+			Name: "DisableWorkerFallback",
+			Type: "bool",
+
+			Comment: `DisableWorkerFallback disables usage of the worker address for messages
+sent automatically, if control addresses are configured.
+A control address that doesn't have enough funds will still be chosen
+over the worker address if this flag is set.`,
+		},
+		{
+			Name: "MinerAddresses",
+			Type: "[]string",
+
+			Comment: `MinerAddresses are the addresses of the miner actors to use for sending messages`,
+		},
+	},
+	"LotusProviderConfig": {
+		{
+			Name: "Subsystems",
+			Type: "ProviderSubsystemsConfig",
+
+			Comment: ``,
+		},
+		{
+			Name: "Fees",
+			Type: "LotusProviderFees",
+
+			Comment: ``,
+		},
+		{
+			Name: "Addresses",
+			Type: "LotusProviderAddresses",
+
+			Comment: ``,
+		},
+		{
+			Name: "Proving",
+			Type: "ProvingConfig",
+
+			Comment: ``,
+		},
+		{
+			Name: "Journal",
+			Type: "JournalConfig",
+
+			Comment: ``,
+		},
+		{
+			Name: "Apis",
+			Type: "ApisConfig",
+
+			Comment: ``,
+		},
+	},
+	"LotusProviderFees": {
+		{
+			Name: "DefaultMaxFee",
+			Type: "types.FIL",
+
+			Comment: ``,
+		},
+		{
+			Name: "MaxPreCommitGasFee",
+			Type: "types.FIL",
+
+			Comment: ``,
+		},
+		{
+			Name: "MaxCommitGasFee",
+			Type: "types.FIL",
+
+			Comment: ``,
+		},
+		{
+			Name: "MaxPreCommitBatchGasFee",
+			Type: "BatchFeeConfig",
+
+			Comment: `maxBatchFee = maxBase + maxPerSector * nSectors`,
+		},
+		{
+			Name: "MaxCommitBatchGasFee",
+			Type: "BatchFeeConfig",
+
+			Comment: ``,
+		},
+		{
+			Name: "MaxTerminateGasFee",
+			Type: "types.FIL",
+
+			Comment: ``,
+		},
+		{
+			Name: "MaxWindowPoStGasFee",
+			Type: "types.FIL",
+
+			Comment: `WindowPoSt is a high-value operation, so the default fee should be high.`,
+		},
+		{
+			Name: "MaxPublishDealsFee",
+			Type: "types.FIL",
+
+			Comment: ``,
+		},
+	},
+	"MinerAddressConfig": {
 		{
 			Name: "PreCommitControl",
 			Type: "[]string",
@@ -674,7 +861,7 @@ A control address that doesn't have enough funds will still be chosen
 over the worker address if this flag is set.`,
 		},
 	},
-	"MinerFeeConfig": []DocField{
+	"MinerFeeConfig": {
 		{
 			Name: "MaxPreCommitGasFee",
 			Type: "types.FIL",
@@ -721,10 +908,16 @@ over the worker address if this flag is set.`,
 			Name: "MaxMarketBalanceAddFee",
 			Type: "types.FIL",
 
+			Comment: ``,
+		},
+		{
+			Name: "MaximizeWindowPoStFeeCap",
+			Type: "bool",
+
 			Comment: ``,
 		},
 	},
-	"MinerSubsystemConfig": []DocField{
+	"MinerSubsystemConfig": {
 		{
 			Name: "EnableMining",
 			Type: "bool",
@@ -749,6 +942,14 @@ over the worker address if this flag is set.`,
 
 			Comment: ``,
 		},
+		{
+			Name: "EnableSectorIndexDB",
+			Type: "bool",
+
+			Comment: `When enabled, the sector index will reside in an external database
+as opposed to the local KV store in the miner process
+This is useful to allow workers to bypass the lotus miner to access sector information`,
+		},
 		{
 			Name: "SealerApiInfo",
 			Type: "string",
@@ -761,8 +962,59 @@ over the worker address if this flag is set.`,
 
 			Comment: ``,
 		},
+		{
+			Name: "DisableWindowPoSt",
+			Type: "bool",
+
+			Comment: `When window post is enabled, the miner will automatically submit window post proofs
+for all sectors that are eligible for window post
+IF WINDOW POST IS DISABLED, THE MINER WILL NOT SUBMIT WINDOW POST PROOFS
+THIS WILL RESULT IN FAULTS AND PENALTIES IF NO OTHER MECHANISM IS RUNNING
+TO SUBMIT WINDOW POST PROOFS.
+Note: This option is entirely disabling the window post scheduler,
+not just the builtin PoSt computation like Proving.DisableBuiltinWindowPoSt.
+This option will stop lotus-miner from performing any actions related
+to window post, including scheduling, submitting proofs, and recovering
+sectors.`,
+		},
+		{
+			Name: "DisableWinningPoSt",
+			Type: "bool",
+
+			Comment: `When winning post is disabled, the miner process will NOT attempt to mine
+blocks. This should only be set when there's an external process mining
+blocks on behalf of the miner.
+When disabled and no external block producers are configured, all potential
+block rewards will be missed!`,
+		},
 	},
-	"ProvingConfig": []DocField{
+	"ProviderSubsystemsConfig": {
+		{
+			Name: "EnableWindowPost",
+			Type: "bool",
+
+			Comment: ``,
+		},
+		{
+			Name: "WindowPostMaxTasks",
+			Type: "int",
+
+			Comment: ``,
+		},
+		{
+			Name: "EnableWinningPost",
+			Type: "bool",
+
+			Comment: ``,
+		},
+		{
+			Name: "WinningPostMaxTasks",
+			Type: "int",
+
+			Comment: ``,
+		},
+	},
+	"ProvingConfig": {
 		{
 			Name: "ParallelCheckLimit",
 			Type: "int",
@@ -886,7 +1138,7 @@ Note that setting this value lower may result in less efficient gas use - more m
 to prove each deadline, resulting in more total gas use (but each message will have lower gas limit)`,
 		},
 	},
-	"Pubsub": []DocField{
+	"Pubsub": {
 		{
 			Name: "Bootstrapper",
 			Type: "bool",
@@ -946,7 +1198,7 @@ This property is used only if ElasticSearchTracer propery is set.`,
 			Comment: `Auth token that will be passed with logs to elasticsearch - used for weighted peers score.`,
 		},
 	},
-	"RetrievalPricing": []DocField{
+	"RetrievalPricing": {
 		{
 			Name: "Strategy",
 			Type: "string",
@@ -966,7 +1218,7 @@ This property is used only if ElasticSearchTracer propery is set.`,
 			Comment: ``,
 		},
 	},
-	"RetrievalPricingDefault": []DocField{
+	"RetrievalPricingDefault": {
 		{
 			Name: "VerifiedDealsFreeTransfer",
 			Type: "bool",
@@ -977,7 +1229,7 @@ This parameter is ONLY applicable if the retrieval pricing policy strategy has b
 default value is true`,
 		},
 	},
-	"RetrievalPricingExternal": []DocField{
+	"RetrievalPricingExternal": {
 		{
 			Name: "Path",
 			Type: "string",
@@ -986,7 +1238,7 @@ default value is true`,
 This parameter is ONLY applicable if the retrieval pricing policy strategy has been configured to "external".`,
 		},
 	},
-	"SealerConfig": []DocField{
+	"SealerConfig": {
 		{
 			Name: "ParallelFetchLimit",
 			Type: "int",
@@ -1087,7 +1339,7 @@ to use when evaluating tasks against this worker. An empty value defaults
 to "hardware".`,
 		},
 	},
-	"SealingConfig": []DocField{
+	"SealingConfig": {
 		{
 			Name: "MaxWaitDealsSectors",
 			Type: "uint64",
@@ -1299,13 +1551,13 @@ Submitting a smaller number of prove commits per epoch would reduce the possibil
 			Comment: `UseSyntheticPoRep, when set to true, will reduce the amount of cache data held on disk after the completion of PreCommit 2 to 11GiB.`,
 		},
 	},
-	"Splitstore": []DocField{
+	"Splitstore": {
 		{
 			Name: "ColdStoreType",
 			Type: "string",
 
 			Comment: `ColdStoreType specifies the type of the coldstore.
-It can be "messages" (default) to store only messages, "universal" to store all chain state or "discard" for discarding cold blocks.`,
+It can be "discard" (default) for discarding cold blocks, "messages" to store only messages or "universal" to store all chain state..`,
 		},
 		{
 			Name: "HotStoreType",
@@ -1366,7 +1618,7 @@ is set.  Moving GC will not occur when total moving size exceeds
 HotstoreMaxSpaceTarget - HotstoreMaxSpaceSafetyBuffer`,
 		},
 	},
-	"StorageMiner": []DocField{
+	"StorageMiner": {
 		{
 			Name: "Subsystems",
 			Type: "MinerSubsystemConfig",
@@ -1419,10 +1671,16 @@ HotstoreMaxSpaceTarget - HotstoreMaxSpaceSafetyBuffer`,
 			Name: "DAGStore",
 			Type: "DAGStoreConfig",
 
+			Comment: ``,
+		},
+		{
+			Name: "HarmonyDB",
+			Type: "HarmonyDB",
+
 			Comment: ``,
 		},
 	},
-	"UserRaftConfig": []DocField{
+	"UserRaftConfig": {
 		{
 			Name: "ClusterModeEnabled",
 			Type: "bool",
@@ -1484,7 +1742,7 @@ copies that we keep as backups (renaming) after cleanup.`,
 			Comment: `Tracing enables propagation of contexts across binary boundaries.`,
 		},
 	},
-	"Wallet": []DocField{
+	"Wallet": {
 		{
 			Name: "RemoteBackend",
 			Type: "string",
diff --git a/node/config/load.go b/node/config/load.go
index 913350912..fd015d533 100644
--- a/node/config/load.go
+++ b/node/config/load.go
@@ -124,6 +124,7 @@ func ValidateSplitstoreSet(cfgRaw string) error {
 type cfgUpdateOpts struct {
 	comment         bool
 	keepUncommented func(string) bool
+	noEnv           bool
 }
 
 // UpdateCfgOpt is a functional option for updating the config
@@ -149,6 +150,13 @@ func DefaultKeepUncommented() UpdateCfgOpt {
 	return KeepUncommented(MatchEnableSplitstoreField)
 }
 
+func NoEnv() UpdateCfgOpt {
+	return func(opts *cfgUpdateOpts) error {
+		opts.noEnv = true
+		return nil
+	}
+}
+
 // ConfigUpdate takes in a config and a default config and optionally comments out default values
 func ConfigUpdate(cfgCur, cfgDef interface{}, opts ...UpdateCfgOpt) ([]byte, error) {
 	var updateOpts cfgUpdateOpts
@@ -236,7 +244,9 @@ func ConfigUpdate(cfgCur, cfgDef interface{}, opts ...UpdateCfgOpt) ([]byte, err
 						outLines = append(outLines, pad+"# type: "+doc.Type)
 					}
 
-					outLines = append(outLines, pad+"# env var: LOTUS_"+strings.ToUpper(strings.ReplaceAll(section, ".", "_"))+"_"+strings.ToUpper(lf[0]))
+					if !updateOpts.noEnv {
+						outLines = append(outLines, pad+"# env var: LOTUS_"+strings.ToUpper(strings.ReplaceAll(section, ".", "_"))+"_"+strings.ToUpper(lf[0]))
+					}
 				}
 			}
 
diff --git a/node/config/storage.go b/node/config/storage.go
index dfe067840..ac5d57de8 100644
--- a/node/config/storage.go
+++ b/node/config/storage.go
@@ -2,8 +2,11 @@ package config
 
 import (
 	"encoding/json"
+	"errors"
 	"io"
+	"io/fs"
 	"os"
+	"path"
 
 	"golang.org/x/xerrors"
 
@@ -36,14 +39,31 @@ func StorageFromReader(reader io.Reader) (*storiface.StorageConfig, error) {
 	return &cfg, nil
 }
 
-func WriteStorageFile(path string, config storiface.StorageConfig) error {
+func WriteStorageFile(filePath string, config storiface.StorageConfig) error {
 	b, err := json.MarshalIndent(config, "", "  ")
 	if err != nil {
 		return xerrors.Errorf("marshaling storage config: %w", err)
 	}
 
-	if err := os.WriteFile(path, b, 0644); err != nil {
-		return xerrors.Errorf("persisting storage config (%s): %w", path, err)
+	info, err := os.Stat(filePath)
+	if err != nil {
+		if !errors.Is(err, fs.ErrNotExist) {
+			return xerrors.Errorf("statting storage config (%s): %w", filePath, err)
+		}
+		if path.Base(filePath) == "." {
+			filePath = path.Join(filePath, "storage.json")
+		}
+	} else {
+		if info.IsDir() || path.Base(filePath) == "." {
+			filePath = path.Join(filePath, "storage.json")
+		}
+	}
+
+	if err := os.MkdirAll(path.Dir(filePath), 0755); err != nil {
+		return xerrors.Errorf("making storage config parent directory: %w", err)
+	}
+	if err := os.WriteFile(filePath, b, 0644); err != nil {
+		return xerrors.Errorf("persisting storage config (%s): %w", filePath, err)
 	}
 
 	return nil
diff --git a/node/config/types.go b/node/config/types.go
index 908140ed3..2152e0795 100644
--- a/node/config/types.go
+++ b/node/config/types.go
@@ -62,6 +62,40 @@ type StorageMiner struct {
 	Fees          MinerFeeConfig
 	Addresses     MinerAddressConfig
 	DAGStore      DAGStoreConfig
+
+	HarmonyDB HarmonyDB
+}
+
+type LotusProviderConfig struct {
+	Subsystems ProviderSubsystemsConfig
+
+	Fees      LotusProviderFees
+	Addresses LotusProviderAddresses
+	Proving   ProvingConfig
+	Journal   JournalConfig
+	Apis      ApisConfig
+}
+
+type ApisConfig struct {
+	// ChainApiInfo is the API endpoint for the Lotus daemon.
+	ChainApiInfo []string
+
+	// RPC Secret for the storage subsystem.
+	// If integrating with lotus-miner this must match the value from
+	// cat ~/.lotusminer/keystore/MF2XI2BNNJ3XILLQOJUXMYLUMU | jq -r .PrivateKey
+	StorageRPCSecret string
+}
+
+type JournalConfig struct {
+	//Events of the form: "system1:event1,system1:event2[,...]"
+	DisabledEvents string
+}
+
+type ProviderSubsystemsConfig struct {
+	EnableWindowPost    bool
+	WindowPostMaxTasks  int
+	EnableWinningPost   bool
+	WinningPostMaxTasks int
 }
 
 type DAGStoreConfig struct {
@@ -109,8 +143,32 @@ type MinerSubsystemConfig struct {
 	EnableSectorStorage bool
 	EnableMarkets       bool
 
+	// When enabled, the sector index will reside in an external database
+	// as opposed to the local KV store in the miner process
+	// This is useful to allow workers to bypass the lotus miner to access sector information
+	EnableSectorIndexDB bool
+
 	SealerApiInfo      string // if EnableSealing == false
 	SectorIndexApiInfo string // if EnableSectorStorage == false
+
+	// When window post is enabled, the miner will automatically submit window post proofs
+	// for all sectors that are eligible for window post
+	// IF WINDOW POST IS DISABLED, THE MINER WILL NOT SUBMIT WINDOW POST PROOFS
+	// THIS WILL RESULT IN FAULTS AND PENALTIES IF NO OTHER MECHANISM IS RUNNING
+	// TO SUBMIT WINDOW POST PROOFS.
+	// Note: This option is entirely disabling the window post scheduler,
+	//   not just the builtin PoSt computation like Proving.DisableBuiltinWindowPoSt.
+	//   This option will stop lotus-miner from performing any actions related
+	//   to window post, including scheduling, submitting proofs, and recovering
+	//   sectors.
+	DisableWindowPoSt bool
+
+	// When winning post is disabled, the miner process will NOT attempt to mine
+	// blocks. This should only be set when there's an external process mining
+	// blocks on behalf of the miner.
+	// When disabled and no external block producers are configured, all potential
+	// block rewards will be missed!
+	DisableWinningPoSt bool
 }
 
 type DealmakingConfig struct {
@@ -490,8 +548,24 @@ type MinerFeeConfig struct {
 	MaxWindowPoStGasFee    types.FIL
 	MaxPublishDealsFee     types.FIL
 	MaxMarketBalanceAddFee types.FIL
+
+	MaximizeWindowPoStFeeCap bool
 }
 
+type LotusProviderFees struct {
+	DefaultMaxFee      types.FIL
+	MaxPreCommitGasFee types.FIL
+	MaxCommitGasFee    types.FIL
+
+	// maxBatchFee = maxBase + maxPerSector * nSectors
+	MaxPreCommitBatchGasFee BatchFeeConfig
+	MaxCommitBatchGasFee    BatchFeeConfig
+
+	MaxTerminateGasFee types.FIL
+	// WindowPoSt is a high-value operation, so the default fee should be high.
+	MaxWindowPoStGasFee types.FIL
+	MaxPublishDealsFee  types.FIL
+}
 type MinerAddressConfig struct {
 	// Addresses to send PreCommit messages from
 	PreCommitControl []string
@@ -510,6 +584,26 @@ type MinerAddressConfig struct {
 	DisableWorkerFallback bool
 }
 
+type LotusProviderAddresses struct {
+	// Addresses to send PreCommit messages from
+	PreCommitControl []string
+	// Addresses to send Commit messages from
+	CommitControl    []string
+	TerminateControl []string
+
+	// DisableOwnerFallback disables usage of the owner address for messages
+	// sent automatically
+	DisableOwnerFallback bool
+	// DisableWorkerFallback disables usage of the worker address for messages
+	// sent automatically, if control addresses are configured.
+	// A control address that doesn't have enough funds will still be chosen
+	// over the worker address if this flag is set.
+	DisableWorkerFallback bool
+
+	// MinerAddresses are the addresses of the miner actors to use for sending messages
+	MinerAddresses []string
+}
+
 // API contains configs for API endpoint
 type API struct {
 	// Binding address for the Lotus API
@@ -585,7 +679,7 @@ type Chainstore struct {
 
 type Splitstore struct {
 	// ColdStoreType specifies the type of the coldstore.
-	// It can be "messages" (default) to store only messages, "universal" to store all chain state or "discard" for discarding cold blocks.
+	// It can be "discard" (default) for discarding cold blocks, "messages" to store only messages or "universal" to store all chain state..
 	ColdStoreType string
 	// HotStoreType specifies the type of the hotstore.
 	// Only currently supported value is "badger".
@@ -733,6 +827,23 @@ type IndexConfig struct {
 	EnableMsgIndex bool
 }
 
+type HarmonyDB struct {
+	// HOSTS is a list of hostnames to nodes running YugabyteDB
+	// in a cluster. Only 1 is required
+	Hosts []string
+
+	// The Yugabyte server's username with full credentials to operate on Lotus' Database. Blank for default.
+	Username string
+
+	// The password for the related username. Blank for default.
+	Password string
+
+	// The database (logical partition) within Yugabyte. Blank for default.
+	Database string
+
+	// The port to find Yugabyte. Blank for default.
+	Port string
+}
 type FaultReporterConfig struct {
 	// EnableConsensusFaultReporter controls whether the node will monitor and
 	// report consensus faults. When enabled, the node will watch for malicious
diff --git a/node/impl/full/dummy.go b/node/impl/full/dummy.go
index 743eadf34..11ff95a63 100644
--- a/node/impl/full/dummy.go
+++ b/node/impl/full/dummy.go
@@ -122,7 +122,7 @@ func (e *EthModuleDummy) EthGasPrice(ctx context.Context) (ethtypes.EthBigInt, e
 	return ethtypes.EthBigIntZero, ErrModuleDisabled
 }
 
-func (e *EthModuleDummy) EthEstimateGas(ctx context.Context, tx ethtypes.EthCall) (ethtypes.EthUint64, error) {
+func (e *EthModuleDummy) EthEstimateGas(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthUint64, error) {
 	return 0, ErrModuleDisabled
 }
 
diff --git a/node/impl/full/eth.go b/node/impl/full/eth.go
index 2a7293956..d4298492f 100644
--- a/node/impl/full/eth.go
+++ b/node/impl/full/eth.go
@@ -66,7 +66,7 @@ type EthModuleAPI interface {
 	NetListening(ctx context.Context) (bool, error)
 	EthProtocolVersion(ctx context.Context) (ethtypes.EthUint64, error)
 	EthGasPrice(ctx context.Context) (ethtypes.EthBigInt, error)
-	EthEstimateGas(ctx context.Context, tx ethtypes.EthCall) (ethtypes.EthUint64, error)
+	EthEstimateGas(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthUint64, error)
 	EthCall(ctx context.Context, tx ethtypes.EthCall, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBytes, error)
 	EthMaxPriorityFeePerGas(ctx context.Context) (ethtypes.EthBigInt, error)
 	EthSendRawTransaction(ctx context.Context, rawTx ethtypes.EthBytes) (ethtypes.EthHash, error)
@@ -285,9 +285,20 @@ func (a *EthModule) EthGetTransactionByHashLimited(ctx context.Context, txHash *
 
 	for _, p := range pending {
 		if p.Cid() == c {
-			tx, err := newEthTxFromSignedMessage(ctx, p, a.StateAPI)
+			// We only return pending eth-account messages because we can't guarantee
+			// that the from/to addresses of other messages are conversable to 0x-style
+			// addresses. So we just ignore them.
+			//
+			// This should be "fine" as anyone using an "Ethereum-centric" block
+			// explorer shouldn't care about seeing pending messages from native
+			// accounts.
+			tx, err := ethtypes.EthTxFromSignedEthMessage(p)
 			if err != nil {
-				return nil, fmt.Errorf("could not convert Filecoin message into tx: %s", err)
+				return nil, fmt.Errorf("could not convert Filecoin message into tx: %w", err)
+			}
+			tx.Hash, err = tx.TxHash()
+			if err != nil {
+				return nil, fmt.Errorf("could not compute tx hash for eth txn: %w", err)
 			}
 			return &tx, nil
 		}
@@ -397,26 +408,31 @@ func (a *EthModule) EthGetTransactionReceiptLimited(ctx context.Context, txHash
 	}
 
 	msgLookup, err := a.StateAPI.StateSearchMsg(ctx, types.EmptyTSK, c, limit, true)
-	if err != nil || msgLookup == nil {
+	if err != nil {
+		return nil, xerrors.Errorf("failed to lookup Eth Txn %s as %s: %w", txHash, c, err)
+	}
+	if msgLookup == nil {
+		// This is the best we can do. In theory, we could have just not indexed this
+		// transaction, but there's no way to check that here.
 		return nil, nil
 	}
 
 	tx, err := newEthTxFromMessageLookup(ctx, msgLookup, -1, a.Chain, a.StateAPI)
 	if err != nil {
-		return nil, nil
+		return nil, xerrors.Errorf("failed to convert %s into an Eth Txn: %w", txHash, err)
 	}
 
 	var events []types.Event
 	if rct := msgLookup.Receipt; rct.EventsRoot != nil {
 		events, err = a.ChainAPI.ChainGetEvents(ctx, *rct.EventsRoot)
 		if err != nil {
-			return nil, nil
+			return nil, xerrors.Errorf("failed get events for %s", txHash)
 		}
 	}
 
 	receipt, err := newEthTxReceipt(ctx, tx, msgLookup, events, a.Chain, a.StateAPI)
 	if err != nil {
-		return nil, nil
+		return nil, xerrors.Errorf("failed to convert %s into an Eth Receipt: %w", txHash, err)
 	}
 
 	return &receipt, nil
@@ -713,7 +729,7 @@ func (a *EthModule) EthFeeHistory(ctx context.Context, p jsonrpc.RawParams) (eth
 	)
 
 	for blocksIncluded < int(params.BlkCount) && ts.Height() > 0 {
-		msgs, rcpts, err := messagesAndReceipts(ctx, ts, a.Chain, a.StateAPI)
+		_, msgs, rcpts, err := executeTipset(ctx, ts, a.Chain, a.StateAPI)
 		if err != nil {
 			return ethtypes.EthFeeHistory{}, xerrors.Errorf("failed to retrieve messages and receipts for height %d: %w", ts.Height(), err)
 		}
@@ -832,19 +848,14 @@ func (a *EthModule) EthTraceBlock(ctx context.Context, blkNum string) ([]*ethtyp
 		return nil, xerrors.Errorf("failed to get tipset: %w", err)
 	}
 
-	_, trace, err := a.StateManager.ExecutionTrace(ctx, ts)
+	stRoot, trace, err := a.StateManager.ExecutionTrace(ctx, ts)
 	if err != nil {
 		return nil, xerrors.Errorf("failed when calling ExecutionTrace: %w", err)
 	}
 
-	tsParent, err := a.ChainAPI.ChainGetTipSetByHeight(ctx, ts.Height()+1, a.Chain.GetHeaviestTipSet().Key())
+	st, err := a.StateManager.StateTree(stRoot)
 	if err != nil {
-		return nil, xerrors.Errorf("cannot get tipset at height: %v", ts.Height()+1)
-	}
-
-	msgs, err := a.ChainGetParentMessages(ctx, tsParent.Blocks()[0].Cid())
-	if err != nil {
-		return nil, xerrors.Errorf("failed to get parent messages: %w", err)
+		return nil, xerrors.Errorf("failed load computed state-tree: %w", err)
 	}
 
 	cid, err := ts.Key().Cid()
@@ -865,11 +876,6 @@ func (a *EthModule) EthTraceBlock(ctx context.Context, blkNum string) ([]*ethtyp
 			continue
 		}
 
-		// as we include TransactionPosition in the results, lets do sanity checking that the
-		// traces are indeed in the message execution order
-		if ir.Msg.Cid() != msgs[msgIdx].Message.Cid() {
-			return nil, xerrors.Errorf("traces are not in message execution order")
-		}
 		msgIdx++
 
 		txHash, err := a.EthGetTransactionHashByCid(ctx, ir.MsgCid)
@@ -882,7 +888,7 @@ func (a *EthModule) EthTraceBlock(ctx context.Context, blkNum string) ([]*ethtyp
 		}
 
 		traces := []*ethtypes.EthTrace{}
-		err = buildTraces(ctx, &traces, nil, []int{}, ir.ExecutionTrace, int64(ts.Height()), a.StateAPI)
+		err = buildTraces(&traces, nil, []int{}, ir.ExecutionTrace, int64(ts.Height()), st)
 		if err != nil {
 			return nil, xerrors.Errorf("failed building traces: %w", err)
 		}
@@ -914,11 +920,16 @@ func (a *EthModule) EthTraceReplayBlockTransactions(ctx context.Context, blkNum
 		return nil, xerrors.Errorf("failed to get tipset: %w", err)
 	}
 
-	_, trace, err := a.StateManager.ExecutionTrace(ctx, ts)
+	stRoot, trace, err := a.StateManager.ExecutionTrace(ctx, ts)
 	if err != nil {
 		return nil, xerrors.Errorf("failed when calling ExecutionTrace: %w", err)
 	}
 
+	st, err := a.StateManager.StateTree(stRoot)
+	if err != nil {
+		return nil, xerrors.Errorf("failed load computed state-tree: %w", err)
+	}
+
 	allTraces := make([]*ethtypes.EthTraceReplayBlockTransaction, 0, len(trace))
 	for _, ir := range trace {
 		// ignore messages from system actor
@@ -943,10 +954,7 @@ func (a *EthModule) EthTraceReplayBlockTransactions(ctx context.Context, blkNum
 				return nil, xerrors.Errorf("failed to decode payload: %w", err)
 			}
 		} else {
-			output, err = handleFilecoinMethodOutput(ir.ExecutionTrace.MsgRct.ExitCode, ir.ExecutionTrace.MsgRct.ReturnCodec, ir.ExecutionTrace.MsgRct.Return)
-			if err != nil {
-				return nil, xerrors.Errorf("could not convert output: %w", err)
-			}
+			output = encodeFilecoinReturnAsABI(ir.ExecutionTrace.MsgRct.ExitCode, ir.ExecutionTrace.MsgRct.ReturnCodec, ir.ExecutionTrace.MsgRct.Return)
 		}
 
 		t := ethtypes.EthTraceReplayBlockTransaction{
@@ -956,7 +964,7 @@ func (a *EthModule) EthTraceReplayBlockTransactions(ctx context.Context, blkNum
 			VmTrace:         nil,
 		}
 
-		err = buildTraces(ctx, &t.Trace, nil, []int{}, ir.ExecutionTrace, int64(ts.Height()), a.StateAPI)
+		err = buildTraces(&t.Trace, nil, []int{}, ir.ExecutionTrace, int64(ts.Height()), st)
 		if err != nil {
 			return nil, xerrors.Errorf("failed building traces: %w", err)
 		}
@@ -999,8 +1007,13 @@ func (a *EthModule) applyMessage(ctx context.Context, msg *types.Message, tsk ty
 	return res, nil
 }
 
-func (a *EthModule) EthEstimateGas(ctx context.Context, tx ethtypes.EthCall) (ethtypes.EthUint64, error) {
-	msg, err := ethCallToFilecoinMessage(ctx, tx)
+func (a *EthModule) EthEstimateGas(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthUint64, error) {
+	params, err := jsonrpc.DecodeParams[ethtypes.EthEstimateGasParams](p)
+	if err != nil {
+		return ethtypes.EthUint64(0), xerrors.Errorf("decoding params: %w", err)
+	}
+
+	msg, err := ethCallToFilecoinMessage(ctx, params.Tx)
 	if err != nil {
 		return ethtypes.EthUint64(0), err
 	}
@@ -1009,7 +1022,16 @@ func (a *EthModule) EthEstimateGas(ctx context.Context, tx ethtypes.EthCall) (et
 	// gas estimation actually run.
 	msg.GasLimit = 0
 
-	ts := a.Chain.GetHeaviestTipSet()
+	var ts *types.TipSet
+	if params.BlkParam == nil {
+		ts = a.Chain.GetHeaviestTipSet()
+	} else {
+		ts, err = getTipsetByEthBlockNumberOrHash(ctx, a.Chain, *params.BlkParam)
+		if err != nil {
+			return ethtypes.EthUint64(0), xerrors.Errorf("failed to process block param: %v; %w", params.BlkParam, err)
+		}
+	}
+
 	gassedMsg, err := a.GasAPI.GasEstimateMessageGas(ctx, msg, nil, ts.Key())
 	if err != nil {
 		// On failure, GasEstimateMessageGas doesn't actually return the invocation result,
@@ -1197,7 +1219,7 @@ func (e *EthEvent) EthGetLogs(ctx context.Context, filterSpec *ethtypes.EthFilte
 
 	_ = e.uninstallFilter(ctx, f)
 
-	return ethFilterResultFromEvents(ces, e.SubManager.StateAPI)
+	return ethFilterResultFromEvents(ctx, ces, e.SubManager.StateAPI)
 }
 
 func (e *EthEvent) EthGetFilterChanges(ctx context.Context, id ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) {
@@ -1212,11 +1234,11 @@ func (e *EthEvent) EthGetFilterChanges(ctx context.Context, id ethtypes.EthFilte
 
 	switch fc := f.(type) {
 	case filterEventCollector:
-		return ethFilterResultFromEvents(fc.TakeCollectedEvents(ctx), e.SubManager.StateAPI)
+		return ethFilterResultFromEvents(ctx, fc.TakeCollectedEvents(ctx), e.SubManager.StateAPI)
 	case filterTipSetCollector:
 		return ethFilterResultFromTipSets(fc.TakeCollectedTipSets(ctx))
 	case filterMessageCollector:
-		return ethFilterResultFromMessages(fc.TakeCollectedMessages(ctx), e.SubManager.StateAPI)
+		return ethFilterResultFromMessages(fc.TakeCollectedMessages(ctx))
 	}
 
 	return nil, xerrors.Errorf("unknown filter type")
@@ -1234,7 +1256,7 @@ func (e *EthEvent) EthGetFilterLogs(ctx context.Context, id ethtypes.EthFilterID
 
 	switch fc := f.(type) {
 	case filterEventCollector:
-		return ethFilterResultFromEvents(fc.TakeCollectedEvents(ctx), e.SubManager.StateAPI)
+		return ethFilterResultFromEvents(ctx, fc.TakeCollectedEvents(ctx), e.SubManager.StateAPI)
 	}
 
 	return nil, xerrors.Errorf("wrong filter type")
diff --git a/node/impl/full/eth_event.go b/node/impl/full/eth_event.go
index 69021e08a..54dd164ac 100644
--- a/node/impl/full/eth_event.go
+++ b/node/impl/full/eth_event.go
@@ -93,7 +93,7 @@ func ethLogFromEvent(entries []types.EventEntry) (data []byte, topics []ethtypes
 	return data, topics, true
 }
 
-func ethFilterResultFromEvents(evs []*filter.CollectedEvent, sa StateAPI) (*ethtypes.EthFilterResult, error) {
+func ethFilterResultFromEvents(ctx context.Context, evs []*filter.CollectedEvent, sa StateAPI) (*ethtypes.EthFilterResult, error) {
 	res := &ethtypes.EthFilterResult{}
 	for _, ev := range evs {
 		log := ethtypes.EthLog{
@@ -117,7 +117,7 @@ func ethFilterResultFromEvents(evs []*filter.CollectedEvent, sa StateAPI) (*etht
 			return nil, err
 		}
 
-		log.TransactionHash, err = ethTxHashFromMessageCid(context.TODO(), ev.MsgCid, sa)
+		log.TransactionHash, err = ethTxHashFromMessageCid(ctx, ev.MsgCid, sa)
 		if err != nil {
 			return nil, err
 		}
@@ -155,11 +155,11 @@ func ethFilterResultFromTipSets(tsks []types.TipSetKey) (*ethtypes.EthFilterResu
 	return res, nil
 }
 
-func ethFilterResultFromMessages(cs []*types.SignedMessage, sa StateAPI) (*ethtypes.EthFilterResult, error) {
+func ethFilterResultFromMessages(cs []*types.SignedMessage) (*ethtypes.EthFilterResult, error) {
 	res := &ethtypes.EthFilterResult{}
 
 	for _, c := range cs {
-		hash, err := ethTxHashFromSignedMessage(context.TODO(), c, sa)
+		hash, err := ethTxHashFromSignedMessage(c)
 		if err != nil {
 			return nil, err
 		}
@@ -321,14 +321,14 @@ func (e *ethSubscription) send(ctx context.Context, v interface{}) {
 }
 
 func (e *ethSubscription) start(ctx context.Context) {
-	for {
+	for ctx.Err() == nil {
 		select {
 		case <-ctx.Done():
 			return
 		case v := <-e.in:
 			switch vt := v.(type) {
 			case *filter.CollectedEvent:
-				evs, err := ethFilterResultFromEvents([]*filter.CollectedEvent{vt}, e.StateAPI)
+				evs, err := ethFilterResultFromEvents(ctx, []*filter.CollectedEvent{vt}, e.StateAPI)
 				if err != nil {
 					continue
 				}
@@ -344,7 +344,7 @@ func (e *ethSubscription) start(ctx context.Context) {
 
 				e.send(ctx, ev)
 			case *types.SignedMessage: // mpool txid
-				evs, err := ethFilterResultFromMessages([]*types.SignedMessage{vt}, e.StateAPI)
+				evs, err := ethFilterResultFromMessages([]*types.SignedMessage{vt})
 				if err != nil {
 					continue
 				}
diff --git a/node/impl/full/eth_test.go b/node/impl/full/eth_test.go
index 903c2c1d8..c364a4873 100644
--- a/node/impl/full/eth_test.go
+++ b/node/impl/full/eth_test.go
@@ -1,6 +1,7 @@
 package full
 
 import (
+	"encoding/hex"
 	"testing"
 
 	"github.com/ipfs/go-cid"
@@ -162,3 +163,17 @@ func TestRewardPercentiles(t *testing.T) {
 		require.Equal(t, ans, rewards)
 	}
 }
+
+func TestABIEncoding(t *testing.T) {
+	// Generated from https://abi.hashex.org/
+	const expected = "000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000510000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000001b1111111111111111111020200301000000044444444444444444010000000000"
+	const data = "111111111111111111102020030100000004444444444444444401"
+
+	expectedBytes, err := hex.DecodeString(expected)
+	require.NoError(t, err)
+
+	dataBytes, err := hex.DecodeString(data)
+	require.NoError(t, err)
+
+	require.Equal(t, expectedBytes, encodeAsABIHelper(22, 81, dataBytes))
+}
diff --git a/node/impl/full/eth_trace.go b/node/impl/full/eth_trace.go
index 3766c5448..9d24394d7 100644
--- a/node/impl/full/eth_trace.go
+++ b/node/impl/full/eth_trace.go
@@ -2,21 +2,16 @@ package full
 
 import (
 	"bytes"
-	"context"
-	"encoding/binary"
-	"fmt"
-	"io"
 
 	"github.com/multiformats/go-multicodec"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/builtin"
 	"github.com/filecoin-project/go-state-types/builtin/v10/evm"
-	"github.com/filecoin-project/go-state-types/exitcode"
 
 	builtinactors "github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/types/ethtypes"
 )
@@ -44,18 +39,18 @@ func decodePayload(payload []byte, codec uint64) (ethtypes.EthBytes, error) {
 }
 
 // buildTraces recursively builds the traces for a given ExecutionTrace by walking the subcalls
-func buildTraces(ctx context.Context, traces *[]*ethtypes.EthTrace, parent *ethtypes.EthTrace, addr []int, et types.ExecutionTrace, height int64, sa StateAPI) error {
+func buildTraces(traces *[]*ethtypes.EthTrace, parent *ethtypes.EthTrace, addr []int, et types.ExecutionTrace, height int64, st *state.StateTree) error {
 	// lookup the eth address from the from/to addresses. Note that this may fail but to support
 	// this we need to include the ActorID in the trace. For now, just log a warning and skip
 	// this trace.
 	//
 	// TODO: Add ActorID in trace, see https://github.com/filecoin-project/lotus/pull/11100#discussion_r1302442288
-	from, err := lookupEthAddress(ctx, et.Msg.From, sa)
+	from, err := lookupEthAddress(et.Msg.From, st)
 	if err != nil {
 		log.Warnf("buildTraces: failed to lookup from address %s: %v", et.Msg.From, err)
 		return nil
 	}
-	to, err := lookupEthAddress(ctx, et.Msg.To, sa)
+	to, err := lookupEthAddress(et.Msg.To, st)
 	if err != nil {
 		log.Warnf("buildTraces: failed to lookup to address %s: %w", et.Msg.To, err)
 		return nil
@@ -124,14 +119,8 @@ func buildTraces(ctx context.Context, traces *[]*ethtypes.EthTrace, parent *etht
 	} else {
 		// we are going to assume a native method, but we may change it in one of the edge cases below
 		// TODO: only do this if we know it's a native method (optimization)
-		trace.Action.Input, err = handleFilecoinMethodInput(et.Msg.Method, et.Msg.ParamsCodec, et.Msg.Params)
-		if err != nil {
-			return xerrors.Errorf("buildTraces: %w", err)
-		}
-		trace.Result.Output, err = handleFilecoinMethodOutput(et.MsgRct.ExitCode, et.MsgRct.ReturnCodec, et.MsgRct.Return)
-		if err != nil {
-			return xerrors.Errorf("buildTraces: %w", err)
-		}
+		trace.Action.Input = encodeFilecoinParamsAsABI(et.Msg.Method, et.Msg.ParamsCodec, et.Msg.Params)
+		trace.Result.Output = encodeFilecoinReturnAsABI(et.MsgRct.ExitCode, et.MsgRct.ReturnCodec, et.MsgRct.Return)
 	}
 
 	// TODO: is it OK to check this here or is this only specific to certain edge case (evm to evm)?
@@ -250,7 +239,7 @@ func buildTraces(ctx context.Context, traces *[]*ethtypes.EthTrace, parent *etht
 	*traces = append(*traces, trace)
 
 	for i, call := range et.Subcalls {
-		err := buildTraces(ctx, traces, trace, append(addr, i), call, height, sa)
+		err := buildTraces(traces, trace, append(addr, i), call, height, st)
 		if err != nil {
 			return err
 		}
@@ -258,96 +247,3 @@ func buildTraces(ctx context.Context, traces *[]*ethtypes.EthTrace, parent *etht
 
 	return nil
 }
-
-func writePadded(w io.Writer, data any, size int) error {
-	tmp := &bytes.Buffer{}
-
-	// first write data to tmp buffer to get the size
-	err := binary.Write(tmp, binary.BigEndian, data)
-	if err != nil {
-		return fmt.Errorf("writePadded: failed writing tmp data to buffer: %w", err)
-	}
-
-	if tmp.Len() > size {
-		return fmt.Errorf("writePadded: data is larger than size")
-	}
-
-	// write tailing zeros to pad up to size
-	cnt := size - tmp.Len()
-	for i := 0; i < cnt; i++ {
-		err = binary.Write(w, binary.BigEndian, uint8(0))
-		if err != nil {
-			return fmt.Errorf("writePadded: failed writing tailing zeros to buffer: %w", err)
-		}
-	}
-
-	// finally write the actual value
-	err = binary.Write(w, binary.BigEndian, tmp.Bytes())
-	if err != nil {
-		return fmt.Errorf("writePadded: failed writing data to buffer: %w", err)
-	}
-
-	return nil
-}
-
-func handleFilecoinMethodInput(method abi.MethodNum, codec uint64, params []byte) ([]byte, error) {
-	NATIVE_METHOD_SELECTOR := []byte{0x86, 0x8e, 0x10, 0xc4}
-	EVM_WORD_SIZE := 32
-
-	staticArgs := []uint64{
-		uint64(method),
-		codec,
-		uint64(EVM_WORD_SIZE) * 3,
-		uint64(len(params)),
-	}
-	totalWords := len(staticArgs) + (len(params) / EVM_WORD_SIZE)
-	if len(params)%EVM_WORD_SIZE != 0 {
-		totalWords++
-	}
-	len := 4 + totalWords*EVM_WORD_SIZE
-
-	w := &bytes.Buffer{}
-	err := binary.Write(w, binary.BigEndian, NATIVE_METHOD_SELECTOR)
-	if err != nil {
-		return nil, fmt.Errorf("handleFilecoinMethodInput: failed writing method selector: %w", err)
-	}
-
-	for _, arg := range staticArgs {
-		err := writePadded(w, arg, 32)
-		if err != nil {
-			return nil, fmt.Errorf("handleFilecoinMethodInput: %w", err)
-		}
-	}
-	err = binary.Write(w, binary.BigEndian, params)
-	if err != nil {
-		return nil, fmt.Errorf("handleFilecoinMethodInput: failed writing params: %w", err)
-	}
-	remain := len - w.Len()
-	for i := 0; i < remain; i++ {
-		err = binary.Write(w, binary.BigEndian, uint8(0))
-		if err != nil {
-			return nil, fmt.Errorf("handleFilecoinMethodInput: failed writing tailing zeros: %w", err)
-		}
-	}
-
-	return w.Bytes(), nil
-}
-
-func handleFilecoinMethodOutput(exitCode exitcode.ExitCode, codec uint64, data []byte) ([]byte, error) {
-	w := &bytes.Buffer{}
-
-	values := []interface{}{uint32(exitCode), codec, uint32(w.Len()), uint32(len(data))}
-	for _, v := range values {
-		err := writePadded(w, v, 32)
-		if err != nil {
-			return nil, fmt.Errorf("handleFilecoinMethodOutput: %w", err)
-		}
-	}
-
-	err := binary.Write(w, binary.BigEndian, data)
-	if err != nil {
-		return nil, fmt.Errorf("handleFilecoinMethodOutput: failed writing data: %w", err)
-	}
-
-	return w.Bytes(), nil
-}
diff --git a/node/impl/full/eth_utils.go b/node/impl/full/eth_utils.go
index 17695dd76..1e407a321 100644
--- a/node/impl/full/eth_utils.go
+++ b/node/impl/full/eth_utils.go
@@ -3,10 +3,12 @@ package full
 import (
 	"bytes"
 	"context"
+	"encoding/binary"
 	"errors"
 	"fmt"
 
 	"github.com/ipfs/go-cid"
+	"github.com/multiformats/go-multicodec"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
@@ -15,16 +17,30 @@ import (
 	builtintypes "github.com/filecoin-project/go-state-types/builtin"
 	"github.com/filecoin-project/go-state-types/builtin/v10/eam"
 	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/exitcode"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/types/ethtypes"
 	"github.com/filecoin-project/lotus/chain/vm"
 )
 
+// The address used in messages to actors that have since been deleted.
+//
+// 0xff0000000000000000000000ffffffffffffffff
+var revertedEthAddress ethtypes.EthAddress
+
+func init() {
+	revertedEthAddress[0] = 0xff
+	for i := 20 - 8; i < 20; i++ {
+		revertedEthAddress[i] = 0xff
+	}
+}
+
 func getTipsetByBlockNumber(ctx context.Context, chain *store.ChainStore, blkParam string, strict bool) (*types.TipSet, error) {
 	if blkParam == "earliest" {
 		return nil, fmt.Errorf("block param \"earliest\" is not supported")
@@ -188,7 +204,8 @@ func newEthBlockFromFilecoinTipSet(ctx context.Context, ts *types.TipSet, fullTx
 
 	bn := ethtypes.EthUint64(ts.Height())
 
-	blkCid, err := ts.Key().Cid()
+	tsk := ts.Key()
+	blkCid, err := tsk.Cid()
 	if err != nil {
 		return ethtypes.EthBlock{}, err
 	}
@@ -197,11 +214,16 @@ func newEthBlockFromFilecoinTipSet(ctx context.Context, ts *types.TipSet, fullTx
 		return ethtypes.EthBlock{}, err
 	}
 
-	msgs, rcpts, err := messagesAndReceipts(ctx, ts, cs, sa)
+	stRoot, msgs, rcpts, err := executeTipset(ctx, ts, cs, sa)
 	if err != nil {
 		return ethtypes.EthBlock{}, xerrors.Errorf("failed to retrieve messages and receipts: %w", err)
 	}
 
+	st, err := sa.StateManager.StateTree(stRoot)
+	if err != nil {
+		return ethtypes.EthBlock{}, xerrors.Errorf("failed to load state-tree root %q: %w", stRoot, err)
+	}
+
 	block := ethtypes.NewEthBlock(len(msgs) > 0)
 
 	gasUsed := int64(0)
@@ -223,7 +245,7 @@ func newEthBlockFromFilecoinTipSet(ctx context.Context, ts *types.TipSet, fullTx
 		default:
 			return ethtypes.EthBlock{}, xerrors.Errorf("failed to get signed msg %s: %w", msg.Cid(), err)
 		}
-		tx, err := newEthTxFromSignedMessage(ctx, smsg, sa)
+		tx, err := newEthTxFromSignedMessage(smsg, st)
 		if err != nil {
 			return ethtypes.EthBlock{}, xerrors.Errorf("failed to convert msg to ethTx: %w", err)
 		}
@@ -249,27 +271,27 @@ func newEthBlockFromFilecoinTipSet(ctx context.Context, ts *types.TipSet, fullTx
 	return block, nil
 }
 
-func messagesAndReceipts(ctx context.Context, ts *types.TipSet, cs *store.ChainStore, sa StateAPI) ([]types.ChainMsg, []types.MessageReceipt, error) {
+func executeTipset(ctx context.Context, ts *types.TipSet, cs *store.ChainStore, sa StateAPI) (cid.Cid, []types.ChainMsg, []types.MessageReceipt, error) {
 	msgs, err := cs.MessagesForTipset(ctx, ts)
 	if err != nil {
-		return nil, nil, xerrors.Errorf("error loading messages for tipset: %v: %w", ts, err)
+		return cid.Undef, nil, nil, xerrors.Errorf("error loading messages for tipset: %v: %w", ts, err)
 	}
 
-	_, rcptRoot, err := sa.StateManager.TipSetState(ctx, ts)
+	stRoot, rcptRoot, err := sa.StateManager.TipSetState(ctx, ts)
 	if err != nil {
-		return nil, nil, xerrors.Errorf("failed to compute state: %w", err)
+		return cid.Undef, nil, nil, xerrors.Errorf("failed to compute state: %w", err)
 	}
 
 	rcpts, err := cs.ReadReceipts(ctx, rcptRoot)
 	if err != nil {
-		return nil, nil, xerrors.Errorf("error loading receipts for tipset: %v: %w", ts, err)
+		return cid.Undef, nil, nil, xerrors.Errorf("error loading receipts for tipset: %v: %w", ts, err)
 	}
 
 	if len(msgs) != len(rcpts) {
-		return nil, nil, xerrors.Errorf("receipts and message array lengths didn't match for tipset: %v: %w", ts, err)
+		return cid.Undef, nil, nil, xerrors.Errorf("receipts and message array lengths didn't match for tipset: %v: %w", ts, err)
 	}
 
-	return msgs, rcpts, nil
+	return stRoot, msgs, rcpts, nil
 }
 
 const errorFunctionSelector = "\x08\xc3\x79\xa0" // Error(string)
@@ -359,7 +381,7 @@ func parseEthRevert(ret []byte) string {
 //  3. Otherwise, we fall back to returning a masked ID Ethereum address. If the supplied address is an f0 address, we
 //     use that ID to form the masked ID address.
 //  4. Otherwise, we fetch the actor's ID from the state tree and form the masked ID with it.
-func lookupEthAddress(ctx context.Context, addr address.Address, sa StateAPI) (ethtypes.EthAddress, error) {
+func lookupEthAddress(addr address.Address, st *state.StateTree) (ethtypes.EthAddress, error) {
 	// BLOCK A: We are trying to get an actual Ethereum address from an f410 address.
 	// Attempt to convert directly, if it's an f4 address.
 	ethAddr, err := ethtypes.EthAddressFromFilecoinAddress(addr)
@@ -368,7 +390,7 @@ func lookupEthAddress(ctx context.Context, addr address.Address, sa StateAPI) (e
 	}
 
 	// Lookup on the target actor and try to get an f410 address.
-	if actor, err := sa.StateGetActor(ctx, addr, types.EmptyTSK); err != nil {
+	if actor, err := st.GetActor(addr); err != nil {
 		return ethtypes.EthAddress{}, err
 	} else if actor.Address != nil {
 		if ethAddr, err := ethtypes.EthAddressFromFilecoinAddress(*actor.Address); err == nil && !ethAddr.IsMaskedID() {
@@ -383,7 +405,7 @@ func lookupEthAddress(ctx context.Context, addr address.Address, sa StateAPI) (e
 	}
 
 	// Otherwise, resolve the ID addr.
-	idAddr, err := sa.StateLookupID(ctx, addr, types.EmptyTSK)
+	idAddr, err := st.LookupID(addr)
 	if err != nil {
 		return ethtypes.EthAddress{}, err
 	}
@@ -410,7 +432,7 @@ func ethTxHashFromMessageCid(ctx context.Context, c cid.Cid, sa StateAPI) (ethty
 	smsg, err := sa.Chain.GetSignedMessage(ctx, c)
 	if err == nil {
 		// This is an Eth Tx, Secp message, Or BLS message in the mpool
-		return ethTxHashFromSignedMessage(ctx, smsg, sa)
+		return ethTxHashFromSignedMessage(smsg)
 	}
 
 	_, err = sa.Chain.GetMessage(ctx, c)
@@ -422,13 +444,14 @@ func ethTxHashFromMessageCid(ctx context.Context, c cid.Cid, sa StateAPI) (ethty
 	return ethtypes.EmptyEthHash, nil
 }
 
-func ethTxHashFromSignedMessage(ctx context.Context, smsg *types.SignedMessage, sa StateAPI) (ethtypes.EthHash, error) {
+func ethTxHashFromSignedMessage(smsg *types.SignedMessage) (ethtypes.EthHash, error) {
 	if smsg.Signature.Type == crypto.SigTypeDelegated {
-		ethTx, err := newEthTxFromSignedMessage(ctx, smsg, sa)
+		tx, err := ethtypes.EthTxFromSignedEthMessage(smsg)
 		if err != nil {
-			return ethtypes.EmptyEthHash, err
+			return ethtypes.EthHash{}, xerrors.Errorf("failed to convert from signed message: %w", err)
 		}
-		return ethTx.Hash, nil
+
+		return tx.TxHash()
 	} else if smsg.Signature.Type == crypto.SigTypeSecp256k1 {
 		return ethtypes.EthHashFromCid(smsg.Cid())
 	} else { // BLS message
@@ -436,7 +459,7 @@ func ethTxHashFromSignedMessage(ctx context.Context, smsg *types.SignedMessage,
 	}
 }
 
-func newEthTxFromSignedMessage(ctx context.Context, smsg *types.SignedMessage, sa StateAPI) (ethtypes.EthTx, error) {
+func newEthTxFromSignedMessage(smsg *types.SignedMessage, st *state.StateTree) (ethtypes.EthTx, error) {
 	var tx ethtypes.EthTx
 	var err error
 
@@ -451,42 +474,92 @@ func newEthTxFromSignedMessage(ctx context.Context, smsg *types.SignedMessage, s
 		if err != nil {
 			return ethtypes.EthTx{}, xerrors.Errorf("failed to calculate hash for ethTx: %w", err)
 		}
-
-		fromAddr, err := lookupEthAddress(ctx, smsg.Message.From, sa)
-		if err != nil {
-			return ethtypes.EthTx{}, xerrors.Errorf("failed to resolve Ethereum address: %w", err)
-		}
-
-		tx.From = fromAddr
 	} else if smsg.Signature.Type == crypto.SigTypeSecp256k1 { // Secp Filecoin Message
-		tx = ethTxFromNativeMessage(ctx, smsg.VMMessage(), sa)
+		tx, err = ethTxFromNativeMessage(smsg.VMMessage(), st)
+		if err != nil {
+			return ethtypes.EthTx{}, err
+		}
 		tx.Hash, err = ethtypes.EthHashFromCid(smsg.Cid())
 		if err != nil {
-			return tx, err
+			return ethtypes.EthTx{}, err
 		}
 	} else { // BLS Filecoin message
-		tx = ethTxFromNativeMessage(ctx, smsg.VMMessage(), sa)
+		tx, err = ethTxFromNativeMessage(smsg.VMMessage(), st)
+		if err != nil {
+			return ethtypes.EthTx{}, err
+		}
 		tx.Hash, err = ethtypes.EthHashFromCid(smsg.Message.Cid())
 		if err != nil {
-			return tx, err
+			return ethtypes.EthTx{}, err
 		}
 	}
 
 	return tx, nil
 }
 
+// Convert a native message to an eth transaction.
+//
+//   - The state-tree must be from after the message was applied (ideally the following tipset).
+//   - In some cases, the "to" address may be `0xff0000000000000000000000ffffffffffffffff`. This
+//     means that the "to" address has not been assigned in the passed state-tree and can only
+//     happen if the transaction reverted.
+//
 // ethTxFromNativeMessage does NOT populate:
 // - BlockHash
 // - BlockNumber
 // - TransactionIndex
 // - Hash
-func ethTxFromNativeMessage(ctx context.Context, msg *types.Message, sa StateAPI) ethtypes.EthTx {
-	// We don't care if we error here, conversion is best effort for non-eth transactions
-	from, _ := lookupEthAddress(ctx, msg.From, sa)
-	to, _ := lookupEthAddress(ctx, msg.To, sa)
+func ethTxFromNativeMessage(msg *types.Message, st *state.StateTree) (ethtypes.EthTx, error) {
+	// Lookup the from address. This must succeed.
+	from, err := lookupEthAddress(msg.From, st)
+	if err != nil {
+		return ethtypes.EthTx{}, xerrors.Errorf("failed to lookup sender address %s when converting a native message to an eth txn: %w", msg.From, err)
+	}
+	// Lookup the to address. If the recipient doesn't exist, we replace the address with a
+	// known sentinel address.
+	to, err := lookupEthAddress(msg.To, st)
+	if err != nil {
+		if !errors.Is(err, types.ErrActorNotFound) {
+			return ethtypes.EthTx{}, xerrors.Errorf("failed to lookup receiver address %s when converting a native message to an eth txn: %w", msg.To, err)
+		}
+		to = revertedEthAddress
+	}
+	toPtr := &to
+
+	// Finally, convert the input parameters to "solidity ABI".
+
+	// For empty, we use "0" as the codec. Otherwise, we use CBOR for message
+	// parameters.
+	var codec uint64
+	if len(msg.Params) > 0 {
+		codec = uint64(multicodec.Cbor)
+	}
+
+	// We try to decode the input as an EVM method invocation and/or a contract creation. If
+	// that fails, we encode the "native" parameters as Solidity ABI.
+	var input []byte
+	switch msg.Method {
+	case builtintypes.MethodsEVM.InvokeContract, builtintypes.MethodsEAM.CreateExternal:
+		inp, err := decodePayload(msg.Params, codec)
+		if err == nil {
+			// If this is a valid "create external", unset the "to" address.
+			if msg.Method == builtintypes.MethodsEAM.CreateExternal {
+				toPtr = nil
+			}
+			input = []byte(inp)
+			break
+		}
+		// Yeah, we're going to ignore errors here because the user can send whatever they
+		// want and may send garbage.
+		fallthrough
+	default:
+		input = encodeFilecoinParamsAsABI(msg.Method, codec, msg.Params)
+	}
+
 	return ethtypes.EthTx{
-		To:                   &to,
+		To:                   toPtr,
 		From:                 from,
+		Input:                input,
 		Nonce:                ethtypes.EthUint64(msg.Nonce),
 		ChainID:              ethtypes.EthUint64(build.Eip155ChainId),
 		Value:                ethtypes.EthBigInt(msg.Value),
@@ -495,7 +568,7 @@ func ethTxFromNativeMessage(ctx context.Context, msg *types.Message, sa StateAPI
 		MaxFeePerGas:         ethtypes.EthBigInt(msg.GasFeeCap),
 		MaxPriorityFeePerGas: ethtypes.EthBigInt(msg.GasPremium),
 		AccessList:           []ethtypes.EthHash{},
-	}
+	}, nil
 }
 
 func getSignedMessage(ctx context.Context, cs *store.ChainStore, msgCid cid.Cid) (*types.SignedMessage, error) {
@@ -564,7 +637,12 @@ func newEthTxFromMessageLookup(ctx context.Context, msgLookup *api.MsgLookup, tx
 		return ethtypes.EthTx{}, xerrors.Errorf("failed to get signed msg: %w", err)
 	}
 
-	tx, err := newEthTxFromSignedMessage(ctx, smsg, sa)
+	st, err := sa.StateManager.StateTree(ts.ParentState())
+	if err != nil {
+		return ethtypes.EthTx{}, xerrors.Errorf("failed to load message state tree: %w", err)
+	}
+
+	tx, err := newEthTxFromSignedMessage(smsg, st)
 	if err != nil {
 		return ethtypes.EthTx{}, err
 	}
@@ -574,7 +652,6 @@ func newEthTxFromMessageLookup(ctx context.Context, msgLookup *api.MsgLookup, tx
 		ti = ethtypes.EthUint64(txIdx)
 	)
 
-	tx.ChainID = ethtypes.EthUint64(build.Eip155ChainId)
 	tx.BlockHash = &blkHash
 	tx.BlockNumber = &bn
 	tx.TransactionIndex = &ti
@@ -627,6 +704,11 @@ func newEthTxReceipt(ctx context.Context, tx ethtypes.EthTx, lookup *api.MsgLook
 		return api.EthTxReceipt{}, xerrors.Errorf("failed to lookup tipset %s when constructing the eth txn receipt: %w", lookup.TipSet, err)
 	}
 
+	st, err := sa.StateManager.StateTree(ts.ParentState())
+	if err != nil {
+		return api.EthTxReceipt{}, xerrors.Errorf("failed to load the state %s when constructing the eth txn receipt: %w", ts.ParentState(), err)
+	}
+
 	// The tx is located in the parent tipset
 	parentTs, err := cs.LoadTipSet(ctx, ts.Parents())
 	if err != nil {
@@ -671,6 +753,7 @@ func newEthTxReceipt(ctx context.Context, tx ethtypes.EthTx, lookup *api.MsgLook
 				continue
 			}
 			for _, topic := range topics {
+				log.Debug("LogsBloom set for ", topic)
 				ethtypes.EthBloomSet(receipt.LogsBloom, topic[:])
 			}
 			l.Data = data
@@ -681,7 +764,7 @@ func newEthTxReceipt(ctx context.Context, tx ethtypes.EthTx, lookup *api.MsgLook
 				return api.EthTxReceipt{}, xerrors.Errorf("failed to create ID address: %w", err)
 			}
 
-			l.Address, err = lookupEthAddress(ctx, addr, sa)
+			l.Address, err = lookupEthAddress(addr, st)
 			if err != nil {
 				return api.EthTxReceipt{}, xerrors.Errorf("failed to resolve Ethereum address: %w", err)
 			}
@@ -693,3 +776,45 @@ func newEthTxReceipt(ctx context.Context, tx ethtypes.EthTx, lookup *api.MsgLook
 
 	return receipt, nil
 }
+
+func encodeFilecoinParamsAsABI(method abi.MethodNum, codec uint64, params []byte) []byte {
+	buf := []byte{0x86, 0x8e, 0x10, 0xc4} // Native method selector.
+	return append(buf, encodeAsABIHelper(uint64(method), codec, params)...)
+}
+
+func encodeFilecoinReturnAsABI(exitCode exitcode.ExitCode, codec uint64, data []byte) []byte {
+	return encodeAsABIHelper(uint64(exitCode), codec, data)
+}
+
+// Format 2 numbers followed by an arbitrary byte array as solidity ABI. Both our native
+// inputs/outputs follow the same pattern, so we can reuse this code.
+func encodeAsABIHelper(param1 uint64, param2 uint64, data []byte) []byte {
+	const EVM_WORD_SIZE = 32
+
+	// The first two params are "static" numbers. Then, we record the offset of the "data" arg,
+	// then, at that offset, we record the length of the data.
+	//
+	// In practice, this means we have 4 256-bit words back to back where the third arg (the
+	// offset) is _always_ '32*3'.
+	staticArgs := []uint64{param1, param2, EVM_WORD_SIZE * 3, uint64(len(data))}
+	// We always pad out to the next EVM "word" (32 bytes).
+	totalWords := len(staticArgs) + (len(data) / EVM_WORD_SIZE)
+	if len(data)%EVM_WORD_SIZE != 0 {
+		totalWords++
+	}
+	len := totalWords * EVM_WORD_SIZE
+	buf := make([]byte, len)
+	offset := 0
+	// Below, we use copy instead of "appending" to preserve all the zero padding.
+	for _, arg := range staticArgs {
+		// Write each "arg" into the last 8 bytes of each 32 byte word.
+		offset += EVM_WORD_SIZE
+		start := offset - 8
+		binary.BigEndian.PutUint64(buf[start:offset], arg)
+	}
+
+	// Finally, we copy in the data.
+	copy(buf[offset:], data)
+
+	return buf
+}
diff --git a/node/impl/full/txhashmanager.go b/node/impl/full/txhashmanager.go
index 6757cc6dd..64c488d37 100644
--- a/node/impl/full/txhashmanager.go
+++ b/node/impl/full/txhashmanager.go
@@ -11,6 +11,7 @@ import (
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/ethhashlookup"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/types/ethtypes"
 )
 
 type EthTxHashManager struct {
@@ -64,7 +65,7 @@ func (m *EthTxHashManager) Apply(ctx context.Context, from, to *types.TipSet) er
 				continue
 			}
 
-			hash, err := ethTxHashFromSignedMessage(ctx, smsg, m.StateAPI)
+			hash, err := ethTxHashFromSignedMessage(smsg)
 			if err != nil {
 				return err
 			}
@@ -84,13 +85,18 @@ func (m *EthTxHashManager) ProcessSignedMessage(ctx context.Context, msg *types.
 		return
 	}
 
-	ethTx, err := newEthTxFromSignedMessage(ctx, msg, m.StateAPI)
+	ethTx, err := ethtypes.EthTxFromSignedEthMessage(msg)
 	if err != nil {
 		log.Errorf("error converting filecoin message to eth tx: %s", err)
 		return
 	}
+	txHash, err := ethTx.TxHash()
+	if err != nil {
+		log.Errorf("error hashing transaction: %s", err)
+		return
+	}
 
-	err = m.TransactionHashLookup.UpsertHash(ethTx.Hash, msg.Cid())
+	err = m.TransactionHashLookup.UpsertHash(txHash, msg.Cid())
 	if err != nil {
 		log.Errorf("error inserting tx mapping to db: %s", err)
 		return
diff --git a/node/impl/net/rcmgr.go b/node/impl/net/rcmgr.go
index 872554755..c606aabc6 100644
--- a/node/impl/net/rcmgr.go
+++ b/node/impl/net/rcmgr.go
@@ -36,7 +36,7 @@ func (a *NetAPI) NetStat(ctx context.Context, scope string) (result api.NetStat,
 		if len(stat.Peers) > 0 {
 			result.Peers = make(map[string]network.ScopeStat, len(stat.Peers))
 			for p, stat := range stat.Peers {
-				result.Peers[p.Pretty()] = stat
+				result.Peers[p.String()] = stat
 			}
 		}
 
diff --git a/node/impl/storminer.go b/node/impl/storminer.go
index 6fd6045b4..2ce42c327 100644
--- a/node/impl/storminer.go
+++ b/node/impl/storminer.go
@@ -45,6 +45,7 @@ import (
 	lminer "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
 	mktsdagstore "github.com/filecoin-project/lotus/markets/dagstore"
 	"github.com/filecoin-project/lotus/markets/storageadapter"
 	"github.com/filecoin-project/lotus/miner"
@@ -122,6 +123,8 @@ type StorageMinerAPI struct {
 	GetSealingConfigFunc                        dtypes.GetSealingConfigFunc                        `optional:"true"`
 	GetExpectedSealDurationFunc                 dtypes.GetExpectedSealDurationFunc                 `optional:"true"`
 	SetExpectedSealDurationFunc                 dtypes.SetExpectedSealDurationFunc                 `optional:"true"`
+
+	HarmonyDB *harmonydb.DB `optional:"true"`
 }
 
 var _ api.StorageMiner = &StorageMinerAPI{}
@@ -336,19 +339,9 @@ func (sm *StorageMinerAPI) SectorsListInStates(ctx context.Context, states []api
 	return sns, nil
 }
 
+// Use SectorsSummary from stats (prometheus) for faster result
 func (sm *StorageMinerAPI) SectorsSummary(ctx context.Context) (map[api.SectorState]int, error) {
-	sectors, err := sm.Miner.ListSectors()
-	if err != nil {
-		return nil, err
-	}
-
-	out := make(map[api.SectorState]int)
-	for i := range sectors {
-		state := api.SectorState(sectors[i].State)
-		out[state]++
-	}
-
-	return out, nil
+	return sm.Miner.SectorsSummary(ctx), nil
 }
 
 func (sm *StorageMinerAPI) StorageLocal(ctx context.Context) (map[storiface.ID]string, error) {
diff --git a/node/modules/actorevent.go b/node/modules/actorevent.go
index e871ea005..4ce04cefd 100644
--- a/node/modules/actorevent.go
+++ b/node/modules/actorevent.go
@@ -126,8 +126,6 @@ func EthEventAPI(cfg config.FevmConfig) func(helpers.MetricsCtx, repo.LockedRepo
 			MaxFilterResults: cfg.Events.MaxFilterResults,
 		}
 
-		const ChainHeadConfidence = 1
-
 		lc.Append(fx.Hook{
 			OnStart: func(context.Context) error {
 				ev, err := events.NewEvents(ctx, &evapi)
diff --git a/node/modules/alerts.go b/node/modules/alerts.go
index 724761e3c..9976c6d0e 100644
--- a/node/modules/alerts.go
+++ b/node/modules/alerts.go
@@ -1,8 +1,10 @@
 package modules
 
 import (
+	"net"
 	"os"
 	"strconv"
+	"syscall"
 
 	"github.com/filecoin-project/lotus/journal/alerting"
 	"github.com/filecoin-project/lotus/lib/ulimit"
@@ -35,6 +37,69 @@ func CheckFdLimit(min uint64) func(al *alerting.Alerting) {
 	}
 }
 
+func CheckUDPBufferSize(wanted int) func(al *alerting.Alerting) {
+	return func(al *alerting.Alerting) {
+		conn, err := net.Dial("udp", "localhost:0")
+		if err != nil {
+			alert := al.AddAlertType("process", "udp-buffer-size")
+			al.Raise(alert, map[string]string{
+				"message": "Failed to create UDP connection",
+				"error":   err.Error(),
+			})
+			return
+		}
+		defer func() {
+			if err := conn.Close(); err != nil {
+				log.Warnf("Failed to close connection: %s", err)
+			}
+		}()
+
+		udpConn, ok := conn.(*net.UDPConn)
+		if !ok {
+			alert := al.AddAlertType("process", "udp-buffer-size")
+			al.Raise(alert, map[string]string{
+				"message": "Failed to cast connection to UDPConn",
+			})
+			return
+		}
+
+		file, err := udpConn.File()
+		if err != nil {
+			alert := al.AddAlertType("process", "udp-buffer-size")
+			al.Raise(alert, map[string]string{
+				"message": "Failed to get file descriptor from UDPConn",
+				"error":   err.Error(),
+			})
+			return
+		}
+		defer func() {
+			if err := file.Close(); err != nil {
+				log.Warnf("Failed to close file: %s", err)
+			}
+		}()
+
+		size, err := syscall.GetsockoptInt(int(file.Fd()), syscall.SOL_SOCKET, syscall.SO_RCVBUF)
+		if err != nil {
+			alert := al.AddAlertType("process", "udp-buffer-size")
+			al.Raise(alert, map[string]string{
+				"message": "Failed to get UDP buffer size",
+				"error":   err.Error(),
+			})
+			return
+		}
+
+		if size < wanted {
+			alert := al.AddAlertType("process", "udp-buffer-size")
+			al.Raise(alert, map[string]interface{}{
+				"message":      "UDP buffer size is low",
+				"current_size": size,
+				"wanted_size":  wanted,
+				"help":         "See https://github.com/quic-go/quic-go/wiki/UDP-Buffer-Sizes for details.",
+			})
+		}
+	}
+}
+
 func LegacyMarketsEOL(al *alerting.Alerting) {
 	// Add alert if lotus-miner legacy markets subsystem is still in use
 	alert := al.AddAlertType("system", "EOL")
diff --git a/node/modules/chain.go b/node/modules/chain.go
index d08b7dbec..70cb9b585 100644
--- a/node/modules/chain.go
+++ b/node/modules/chain.go
@@ -82,12 +82,12 @@ func ChainStore(lc fx.Lifecycle,
 	basebs dtypes.BaseBlockstore,
 	weight store.WeightFunc,
 	us stmgr.UpgradeSchedule,
-	j journal.Journal) *store.ChainStore {
+	j journal.Journal) (*store.ChainStore, error) {
 
 	chain := store.NewChainStore(cbs, sbs, ds, weight, j)
 
 	if err := chain.Load(helpers.LifecycleCtx(mctx, lc)); err != nil {
-		log.Warnf("loading chain state from disk: %s", err)
+		return nil, xerrors.Errorf("loading chain state from disk: %w", err)
 	}
 
 	var startHook func(context.Context) error
@@ -108,7 +108,7 @@ func ChainStore(lc fx.Lifecycle,
 		},
 	})
 
-	return chain
+	return chain, nil
 }
 
 func NetworkName(mctx helpers.MetricsCtx,
diff --git a/node/modules/lp2p/host.go b/node/modules/lp2p/host.go
index cc7a878fc..9c140b41e 100644
--- a/node/modules/lp2p/host.go
+++ b/node/modules/lp2p/host.go
@@ -41,7 +41,7 @@ func Peerstore() (peerstore.Peerstore, error) {
 func Host(mctx helpers.MetricsCtx, lc fx.Lifecycle, params P2PHostIn) (RawHost, error) {
 	pkey := params.Peerstore.PrivKey(params.ID)
 	if pkey == nil {
-		return nil, fmt.Errorf("missing private key for node ID: %s", params.ID.Pretty())
+		return nil, fmt.Errorf("missing private key for node ID: %s", params.ID)
 	}
 
 	opts := []libp2p.Option{
diff --git a/node/modules/storageminer.go b/node/modules/storageminer.go
index 12879cd64..0680029bf 100644
--- a/node/modules/storageminer.go
+++ b/node/modules/storageminer.go
@@ -311,12 +311,11 @@ func WindowPostScheduler(fc config.MinerFeeConfig, pc config.ProvingConfig) func
 			verif  = params.Verifier
 			j      = params.Journal
 			as     = params.AddrSel
-			maddr  = address.Address(params.Maddr)
 		)
 
 		ctx := helpers.LifecycleCtx(mctx, lc)
 
-		fps, err := wdpost.NewWindowedPoStScheduler(api, fc, pc, as, sealer, verif, sealer, j, maddr)
+		fps, err := wdpost.NewWindowedPoStScheduler(api, fc, pc, as, sealer, verif, sealer, j, []dtypes.MinerAddress{params.Maddr})
 
 		if err != nil {
 			return nil, err
diff --git a/node/repo/fsrepo.go b/node/repo/fsrepo.go
index 03ddd2d6c..d8e41fb2b 100644
--- a/node/repo/fsrepo.go
+++ b/node/repo/fsrepo.go
@@ -185,6 +185,30 @@ func (worker) APIInfoEnvVars() (primary string, fallbacks []string, deprecated [
 	return "WORKER_API_INFO", nil, nil
 }
 
+type provider struct{}
+
+var Provider provider
+
+func (provider) Type() string {
+	return "Provider"
+}
+
+func (provider) Config() interface{} {
+	return &struct{}{}
+}
+
+func (provider) APIFlags() []string {
+	return []string{"provider-api-url"}
+}
+
+func (provider) RepoFlags() []string {
+	return []string{"provider-repo"}
+}
+
+func (provider) APIInfoEnvVars() (primary string, fallbacks []string, deprecated []string) {
+	return "PROVIDER_API_INFO", nil, nil
+}
+
 var Wallet wallet
 
 type wallet struct {
@@ -322,7 +346,7 @@ func (fsr *FsRepo) APIEndpoint() (multiaddr.Multiaddr, error) {
 
 	f, err := os.Open(p)
 	if os.IsNotExist(err) {
-		return nil, ErrNoAPIEndpoint
+		return nil, xerrors.Errorf("No file (%s): %w", p, ErrNoAPIEndpoint)
 	} else if err != nil {
 		return nil, err
 	}
diff --git a/node/repo/repo_test.go b/node/repo/repo_test.go
index 16c101d44..c78afa9db 100644
--- a/node/repo/repo_test.go
+++ b/node/repo/repo_test.go
@@ -16,7 +16,7 @@ import (
 func basicTest(t *testing.T, repo Repo) {
 	apima, err := repo.APIEndpoint()
 	if assert.Error(t, err) {
-		assert.Equal(t, ErrNoAPIEndpoint, err)
+		assert.ErrorContains(t, err, ErrNoAPIEndpoint.Error())
 	}
 	assert.Nil(t, apima, "with no api endpoint, return should be nil")
 
@@ -72,7 +72,7 @@ func basicTest(t *testing.T, repo Repo) {
 	apima, err = repo.APIEndpoint()
 
 	if assert.Error(t, err) {
-		assert.Equal(t, ErrNoAPIEndpoint, err, "after closing repo, api should be nil")
+		assert.ErrorContains(t, err, ErrNoAPIEndpoint.Error(), "after closing repo, api should be nil")
 	}
 	assert.Nil(t, apima, "with closed repo, apima should be set back to nil")
 
diff --git a/paychmgr/paych.go b/paychmgr/paych.go
index 1eb496dba..2729513ce 100644
--- a/paychmgr/paych.go
+++ b/paychmgr/paych.go
@@ -482,7 +482,7 @@ func (ca *channelAccessor) listVouchers(ctx context.Context, ch address.Address)
 // the data store over the chain state
 func (ca *channelAccessor) laneState(ctx context.Context, state lpaych.State, ch address.Address) (map[uint64]lpaych.LaneState, error) {
 	// TODO: we probably want to call UpdateChannelState with all vouchers to be fully correct
-	//  (but technically dont't need to)
+	//  (but technically don't need to)
 
 	laneCount, err := state.LaneCount()
 	if err != nil {
diff --git a/paychmgr/paych_test.go b/paychmgr/paych_test.go
index 7de584784..e72a992a3 100644
--- a/paychmgr/paych_test.go
+++ b/paychmgr/paych_test.go
@@ -805,26 +805,6 @@ func createTestVoucher(t *testing.T, ch address.Address, voucherLane uint64, non
 	return sv
 }
 
-func createTestVoucherWithExtra(t *testing.T, ch address.Address, voucherLane uint64, nonce uint64, voucherAmount big.Int, key []byte) *paychtypes.SignedVoucher { //nolint:deadcode
-	sv := &paychtypes.SignedVoucher{
-		ChannelAddr: ch,
-		Lane:        voucherLane,
-		Nonce:       nonce,
-		Amount:      voucherAmount,
-		Extra: &paychtypes.ModVerifyParams{
-			Actor: tutils.NewActorAddr(t, "act"),
-		},
-	}
-
-	signingBytes, err := sv.SigningBytes()
-	require.NoError(t, err)
-	sig, err := sigs.Sign(crypto.SigTypeSecp256k1, key, signingBytes)
-	require.NoError(t, err)
-	sv.Signature = sig
-
-	return sv
-}
-
 type mockBestSpendableAPI struct {
 	mgr *Manager
 }
diff --git a/provider/address.go b/provider/address.go
new file mode 100644
index 000000000..f69ca3fac
--- /dev/null
+++ b/provider/address.go
@@ -0,0 +1,51 @@
+package provider
+
+import (
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+
+	"github.com/filecoin-project/lotus/node/config"
+	"github.com/filecoin-project/lotus/storage/ctladdr"
+)
+
+func AddressSelector(addrConf *config.LotusProviderAddresses) func() (*ctladdr.AddressSelector, error) {
+	return func() (*ctladdr.AddressSelector, error) {
+		as := &ctladdr.AddressSelector{}
+		if addrConf == nil {
+			return as, nil
+		}
+
+		as.DisableOwnerFallback = addrConf.DisableOwnerFallback
+		as.DisableWorkerFallback = addrConf.DisableWorkerFallback
+
+		for _, s := range addrConf.PreCommitControl {
+			addr, err := address.NewFromString(s)
+			if err != nil {
+				return nil, xerrors.Errorf("parsing precommit control address: %w", err)
+			}
+
+			as.PreCommitControl = append(as.PreCommitControl, addr)
+		}
+
+		for _, s := range addrConf.CommitControl {
+			addr, err := address.NewFromString(s)
+			if err != nil {
+				return nil, xerrors.Errorf("parsing commit control address: %w", err)
+			}
+
+			as.CommitControl = append(as.CommitControl, addr)
+		}
+
+		for _, s := range addrConf.TerminateControl {
+			addr, err := address.NewFromString(s)
+			if err != nil {
+				return nil, xerrors.Errorf("parsing terminate control address: %w", err)
+			}
+
+			as.TerminateControl = append(as.TerminateControl, addr)
+		}
+
+		return as, nil
+	}
+}
diff --git a/provider/builder.go b/provider/builder.go
new file mode 100644
index 000000000..81a1a7a0a
--- /dev/null
+++ b/provider/builder.go
@@ -0,0 +1,50 @@
+package provider
+
+import (
+	"context"
+	"time"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/node/config"
+	dtypes "github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/filecoin-project/lotus/provider/chainsched"
+	"github.com/filecoin-project/lotus/provider/lpmessage"
+	"github.com/filecoin-project/lotus/provider/lpwindow"
+	"github.com/filecoin-project/lotus/storage/ctladdr"
+	"github.com/filecoin-project/lotus/storage/paths"
+	"github.com/filecoin-project/lotus/storage/sealer"
+	"github.com/filecoin-project/lotus/storage/sealer/storiface"
+)
+
+//var log = logging.Logger("provider")
+
+func WindowPostScheduler(ctx context.Context, fc config.LotusProviderFees, pc config.ProvingConfig,
+	api api.FullNode, verif storiface.Verifier, lw *sealer.LocalWorker, sender *lpmessage.Sender,
+	as *ctladdr.AddressSelector, addresses []dtypes.MinerAddress, db *harmonydb.DB,
+	stor paths.Store, idx paths.SectorIndex, max int) (*lpwindow.WdPostTask, *lpwindow.WdPostSubmitTask, *lpwindow.WdPostRecoverDeclareTask, error) {
+
+	chainSched := chainsched.New(api)
+
+	// todo config
+	ft := lpwindow.NewSimpleFaultTracker(stor, idx, 32, 5*time.Second, 300*time.Second)
+
+	computeTask, err := lpwindow.NewWdPostTask(db, api, ft, lw, verif, chainSched, addresses, max)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	submitTask, err := lpwindow.NewWdPostSubmitTask(chainSched, sender, db, api, fc.MaxWindowPoStGasFee, as)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	recoverTask, err := lpwindow.NewWdPostRecoverDeclareTask(sender, db, api, ft, as, chainSched, fc.MaxWindowPoStGasFee, addresses)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	go chainSched.Run(ctx)
+
+	return computeTask, submitTask, recoverTask, nil
+}
diff --git a/provider/chainsched/chain_sched.go b/provider/chainsched/chain_sched.go
new file mode 100644
index 000000000..559a0274f
--- /dev/null
+++ b/provider/chainsched/chain_sched.go
@@ -0,0 +1,136 @@
+package chainsched
+
+import (
+	"context"
+	"time"
+
+	logging "github.com/ipfs/go-log/v2"
+	"go.opencensus.io/trace"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+var log = logging.Logger("chainsched")
+
+type NodeAPI interface {
+	ChainHead(context.Context) (*types.TipSet, error)
+	ChainNotify(context.Context) (<-chan []*api.HeadChange, error)
+}
+
+type ProviderChainSched struct {
+	api NodeAPI
+
+	callbacks []UpdateFunc
+	started   bool
+}
+
+func New(api NodeAPI) *ProviderChainSched {
+	return &ProviderChainSched{
+		api: api,
+	}
+}
+
+type UpdateFunc func(ctx context.Context, revert, apply *types.TipSet) error
+
+func (s *ProviderChainSched) AddHandler(ch UpdateFunc) error {
+	if s.started {
+		return xerrors.Errorf("cannot add handler after start")
+	}
+
+	s.callbacks = append(s.callbacks, ch)
+	return nil
+}
+
+func (s *ProviderChainSched) Run(ctx context.Context) {
+	s.started = true
+
+	var (
+		notifs <-chan []*api.HeadChange
+		err    error
+		gotCur bool
+	)
+
+	// not fine to panic after this point
+	for {
+		if notifs == nil {
+			notifs, err = s.api.ChainNotify(ctx)
+			if err != nil {
+				log.Errorf("ChainNotify error: %+v", err)
+
+				build.Clock.Sleep(10 * time.Second)
+				continue
+			}
+
+			gotCur = false
+			log.Info("restarting window post scheduler")
+		}
+
+		select {
+		case changes, ok := <-notifs:
+			if !ok {
+				log.Warn("window post scheduler notifs channel closed")
+				notifs = nil
+				continue
+			}
+
+			if !gotCur {
+				if len(changes) != 1 {
+					log.Errorf("expected first notif to have len = 1")
+					continue
+				}
+				chg := changes[0]
+				if chg.Type != store.HCCurrent {
+					log.Errorf("expected first notif to tell current ts")
+					continue
+				}
+
+				ctx, span := trace.StartSpan(ctx, "ProviderChainSched.headChange")
+
+				s.update(ctx, nil, chg.Val)
+
+				span.End()
+				gotCur = true
+				continue
+			}
+
+			ctx, span := trace.StartSpan(ctx, "ProviderChainSched.headChange")
+
+			var lowest, highest *types.TipSet = nil, nil
+
+			for _, change := range changes {
+				if change.Val == nil {
+					log.Errorf("change.Val was nil")
+				}
+				switch change.Type {
+				case store.HCRevert:
+					lowest = change.Val
+				case store.HCApply:
+					highest = change.Val
+				}
+			}
+
+			s.update(ctx, lowest, highest)
+
+			span.End()
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+func (s *ProviderChainSched) update(ctx context.Context, revert, apply *types.TipSet) {
+	if apply == nil {
+		log.Error("no new tipset in window post ProviderChainSched.update")
+		return
+	}
+
+	for _, ch := range s.callbacks {
+		if err := ch(ctx, revert, apply); err != nil {
+			log.Errorf("handling head updates in provider chain sched: %+v", err)
+		}
+	}
+}
diff --git a/provider/lpmessage/sender.go b/provider/lpmessage/sender.go
new file mode 100644
index 000000000..0db0c0b51
--- /dev/null
+++ b/provider/lpmessage/sender.go
@@ -0,0 +1,396 @@
+package lpmessage
+
+import (
+	"bytes"
+	"context"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+	"go.uber.org/multierr"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonytask"
+	"github.com/filecoin-project/lotus/lib/harmony/resources"
+	"github.com/filecoin-project/lotus/lib/promise"
+)
+
+var log = logging.Logger("lpmessage")
+
+var SendLockedWait = 100 * time.Millisecond
+
+type SenderAPI interface {
+	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
+	GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, tsk types.TipSetKey) (*types.Message, error)
+	WalletBalance(ctx context.Context, addr address.Address) (big.Int, error)
+	MpoolGetNonce(context.Context, address.Address) (uint64, error)
+	MpoolPush(context.Context, *types.SignedMessage) (cid.Cid, error)
+}
+
+type SignerAPI interface {
+	WalletSignMessage(context.Context, address.Address, *types.Message) (*types.SignedMessage, error)
+}
+
+// Sender abstracts away highly-available message sending with coordination through
+// HarmonyDB. It make sure that nonces are assigned transactionally, and that
+// messages are correctly broadcasted to the network. It ensures that messages
+// are sent serially, and that failures to send don't cause nonce gaps.
+type Sender struct {
+	api SenderAPI
+
+	sendTask *SendTask
+
+	db *harmonydb.DB
+}
+
+type SendTask struct {
+	sendTF promise.Promise[harmonytask.AddTaskFunc]
+
+	api    SenderAPI
+	signer SignerAPI
+
+	db *harmonydb.DB
+}
+
+func (s *SendTask) Do(taskID harmonytask.TaskID, stillOwned func() bool) (done bool, err error) {
+	ctx := context.TODO()
+
+	// get message from db
+
+	var dbMsg struct {
+		FromKey string `db:"from_key"`
+		ToAddr  string `db:"to_addr"`
+
+		UnsignedData []byte `db:"unsigned_data"`
+		UnsignedCid  string `db:"unsigned_cid"`
+
+		// may not be null if we have somehow already signed but failed to send this message
+		Nonce      *uint64 `db:"nonce"`
+		SignedData []byte  `db:"signed_data"`
+	}
+
+	err = s.db.QueryRow(ctx, `
+		SELECT from_key, nonce, to_addr, unsigned_data, unsigned_cid 
+		FROM message_sends 
+		WHERE send_task_id = $1`, taskID).Scan(
+		&dbMsg.FromKey, &dbMsg.Nonce, &dbMsg.ToAddr, &dbMsg.UnsignedData, &dbMsg.UnsignedCid)
+	if err != nil {
+		return false, xerrors.Errorf("getting message from db: %w", err)
+	}
+
+	// deserialize the message
+	var msg types.Message
+	err = msg.UnmarshalCBOR(bytes.NewReader(dbMsg.UnsignedData))
+	if err != nil {
+		return false, xerrors.Errorf("unmarshaling unsigned db message: %w", err)
+	}
+
+	// get db send lock
+	for {
+		// check if we still own the task
+		if !stillOwned() {
+			return false, xerrors.Errorf("lost ownership of task")
+		}
+
+		// try to acquire lock
+		cn, err := s.db.Exec(ctx, `
+			INSERT INTO message_send_locks (from_key, task_id, claimed_at) 
+			VALUES ($1, $2, CURRENT_TIMESTAMP) ON CONFLICT (from_key) DO UPDATE 
+			SET task_id = EXCLUDED.task_id, claimed_at = CURRENT_TIMESTAMP 
+			WHERE message_send_locks.task_id = $2;`, dbMsg.FromKey, taskID)
+		if err != nil {
+			return false, xerrors.Errorf("acquiring send lock: %w", err)
+		}
+
+		if cn == 1 {
+			// we got the lock
+			break
+		}
+
+		// we didn't get the lock, wait a bit and try again
+		log.Infow("waiting for send lock", "task_id", taskID, "from", dbMsg.FromKey)
+		time.Sleep(SendLockedWait)
+	}
+
+	// defer release db send lock
+	defer func() {
+		_, err2 := s.db.Exec(ctx, `
+			DELETE from message_send_locks WHERE from_key = $1 AND task_id = $2`, dbMsg.FromKey, taskID)
+		if err2 != nil {
+			log.Errorw("releasing send lock", "task_id", taskID, "from", dbMsg.FromKey, "error", err2)
+
+			// make sure harmony retries this task so that we eventually release this lock
+			done = false
+			err = multierr.Append(err, xerrors.Errorf("releasing send lock: %w", err2))
+		}
+	}()
+
+	// assign nonce IF NOT ASSIGNED (max(api.MpoolGetNonce, db nonce+1))
+	var sigMsg *types.SignedMessage
+
+	if dbMsg.Nonce == nil {
+		msgNonce, err := s.api.MpoolGetNonce(ctx, msg.From)
+		if err != nil {
+			return false, xerrors.Errorf("getting nonce from mpool: %w", err)
+		}
+
+		// get nonce from db
+		var dbNonce *uint64
+		r := s.db.QueryRow(ctx, `
+			SELECT MAX(nonce) FROM message_sends WHERE from_key = $1 AND send_success = true`, msg.From.String())
+		if err := r.Scan(&dbNonce); err != nil {
+			return false, xerrors.Errorf("getting nonce from db: %w", err)
+		}
+
+		if dbNonce != nil && *dbNonce+1 > msgNonce {
+			msgNonce = *dbNonce + 1
+		}
+
+		msg.Nonce = msgNonce
+
+		// sign message
+		sigMsg, err = s.signer.WalletSignMessage(ctx, msg.From, &msg)
+		if err != nil {
+			return false, xerrors.Errorf("signing message: %w", err)
+		}
+
+		data, err := sigMsg.Serialize()
+		if err != nil {
+			return false, xerrors.Errorf("serializing message: %w", err)
+		}
+
+		jsonBytes, err := sigMsg.MarshalJSON()
+		if err != nil {
+			return false, xerrors.Errorf("marshaling message: %w", err)
+		}
+
+		// write to db
+
+		n, err := s.db.Exec(ctx, `
+			UPDATE message_sends SET nonce = $1, signed_data = $2, signed_json = $3, signed_cid = $4 
+			WHERE send_task_id = $5`,
+			msg.Nonce, data, string(jsonBytes), sigMsg.Cid().String(), taskID)
+		if err != nil {
+			return false, xerrors.Errorf("updating db record: %w", err)
+		}
+		if n != 1 {
+			log.Errorw("updating db record: expected 1 row to be affected, got %d", n)
+			return false, xerrors.Errorf("updating db record: expected 1 row to be affected, got %d", n)
+		}
+	} else {
+		// Note: this handles an unlikely edge-case:
+		// We have previously signed the message but either failed to send it or failed to update the db
+		// note that when that happens the likely cause is the provider process losing its db connection
+		// or getting killed before it can update the db. In that case the message lock will still be held
+		// so it will be safe to rebroadcast the signed message
+
+		// deserialize the signed message
+		sigMsg = new(types.SignedMessage)
+		err = sigMsg.UnmarshalCBOR(bytes.NewReader(dbMsg.SignedData))
+		if err != nil {
+			return false, xerrors.Errorf("unmarshaling signed db message: %w", err)
+		}
+	}
+
+	// send!
+	_, err = s.api.MpoolPush(ctx, sigMsg)
+
+	// persist send result
+	var sendSuccess = err == nil
+	var sendError string
+	if err != nil {
+		sendError = err.Error()
+	}
+
+	_, err = s.db.Exec(ctx, `
+		UPDATE message_sends SET send_success = $1, send_error = $2, send_time = CURRENT_TIMESTAMP 
+		WHERE send_task_id = $3`, sendSuccess, sendError, taskID)
+	if err != nil {
+		return false, xerrors.Errorf("updating db record: %w", err)
+	}
+
+	return true, nil
+}
+
+func (s *SendTask) CanAccept(ids []harmonytask.TaskID, engine *harmonytask.TaskEngine) (*harmonytask.TaskID, error) {
+	if len(ids) == 0 {
+		// probably can't happen, but panicking is bad
+		return nil, nil
+	}
+
+	if s.signer == nil {
+		// can't sign messages here
+		return nil, nil
+	}
+
+	return &ids[0], nil
+}
+
+func (s *SendTask) TypeDetails() harmonytask.TaskTypeDetails {
+	return harmonytask.TaskTypeDetails{
+		Max:  1024,
+		Name: "SendMessage",
+		Cost: resources.Resources{
+			Cpu: 0,
+			Gpu: 0,
+			Ram: 1 << 20,
+		},
+		MaxFailures: 1000,
+		Follows:     nil,
+	}
+}
+
+func (s *SendTask) Adder(taskFunc harmonytask.AddTaskFunc) {
+	s.sendTF.Set(taskFunc)
+}
+
+var _ harmonytask.TaskInterface = &SendTask{}
+
+// NewSender creates a new Sender.
+func NewSender(api SenderAPI, signer SignerAPI, db *harmonydb.DB) (*Sender, *SendTask) {
+	st := &SendTask{
+		api:    api,
+		signer: signer,
+		db:     db,
+	}
+
+	return &Sender{
+		api: api,
+		db:  db,
+
+		sendTask: st,
+	}, st
+}
+
+// Send atomically assigns a nonce, signs, and pushes a message
+// to mempool.
+// maxFee is only used when GasFeeCap/GasPremium fields aren't specified
+//
+// When maxFee is set to 0, Send will guess appropriate fee
+// based on current chain conditions
+//
+// Send behaves much like fullnodeApi.MpoolPushMessage, but it coordinates
+// through HarmonyDB, making it safe to broadcast messages from multiple independent
+// API nodes
+//
+// Send is also currently more strict about required parameters than MpoolPushMessage
+func (s *Sender) Send(ctx context.Context, msg *types.Message, mss *api.MessageSendSpec, reason string) (cid.Cid, error) {
+	if mss == nil {
+		return cid.Undef, xerrors.Errorf("MessageSendSpec cannot be nil")
+	}
+	if (mss.MsgUuid != uuid.UUID{}) {
+		return cid.Undef, xerrors.Errorf("MessageSendSpec.MsgUuid must be zero")
+	}
+
+	fromA, err := s.api.StateAccountKey(ctx, msg.From, types.EmptyTSK)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("getting key address: %w", err)
+	}
+
+	msg.From = fromA
+
+	if msg.Nonce != 0 {
+		return cid.Undef, xerrors.Errorf("Send expects message nonce to be 0, was %d", msg.Nonce)
+	}
+
+	msg, err = s.api.GasEstimateMessageGas(ctx, msg, mss, types.EmptyTSK)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("GasEstimateMessageGas error: %w", err)
+	}
+
+	b, err := s.api.WalletBalance(ctx, msg.From)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("mpool push: getting origin balance: %w", err)
+	}
+
+	requiredFunds := big.Add(msg.Value, msg.RequiredFunds())
+	if b.LessThan(requiredFunds) {
+		return cid.Undef, xerrors.Errorf("mpool push: not enough funds: %s < %s", b, requiredFunds)
+	}
+
+	// push the task
+	taskAdder := s.sendTask.sendTF.Val(ctx)
+
+	unsBytes := new(bytes.Buffer)
+	err = msg.MarshalCBOR(unsBytes)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("marshaling message: %w", err)
+	}
+
+	var sendTaskID *harmonytask.TaskID
+	taskAdder(func(id harmonytask.TaskID, tx *harmonydb.Tx) (shouldCommit bool, seriousError error) {
+		_, err := tx.Exec(`insert into message_sends (from_key, to_addr, send_reason, unsigned_data, unsigned_cid, send_task_id) values ($1, $2, $3, $4, $5, $6)`,
+			msg.From.String(), msg.To.String(), reason, unsBytes.Bytes(), msg.Cid().String(), id)
+		if err != nil {
+			return false, xerrors.Errorf("inserting message into db: %w", err)
+		}
+
+		sendTaskID = &id
+
+		return true, nil
+	})
+
+	if sendTaskID == nil {
+		return cid.Undef, xerrors.Errorf("failed to add task")
+	}
+
+	// wait for exec
+	var (
+		pollInterval    = 50 * time.Millisecond
+		pollIntervalMul = 2
+		maxPollInterval = 5 * time.Second
+		pollLoops       = 0
+
+		sigCid  cid.Cid
+		sendErr error
+	)
+
+	for {
+		var err error
+		var sigCidStr, sendError *string
+		var sendSuccess *bool
+
+		err = s.db.QueryRow(ctx, `select signed_cid, send_success, send_error from message_sends where send_task_id = $1`, &sendTaskID).Scan(&sigCidStr, &sendSuccess, &sendError)
+		if err != nil {
+			return cid.Undef, xerrors.Errorf("getting cid for task: %w", err)
+		}
+
+		if sendSuccess == nil {
+			time.Sleep(pollInterval)
+			pollLoops++
+			pollInterval *= time.Duration(pollIntervalMul)
+			if pollInterval > maxPollInterval {
+				pollInterval = maxPollInterval
+			}
+
+			continue
+		}
+
+		if sigCidStr == nil || sendError == nil {
+			// should never happen because sendSuccess is already not null here
+			return cid.Undef, xerrors.Errorf("got null values for sigCidStr or sendError, this should never happen")
+		}
+
+		if !*sendSuccess {
+			sendErr = xerrors.Errorf("send error: %s", *sendError)
+		} else {
+			sigCid, err = cid.Parse(*sigCidStr)
+			if err != nil {
+				return cid.Undef, xerrors.Errorf("parsing signed cid: %w", err)
+			}
+		}
+
+		break
+	}
+
+	log.Infow("sent message", "cid", sigCid, "task_id", taskAdder, "send_error", sendErr, "poll_loops", pollLoops)
+
+	return sigCid, sendErr
+}
diff --git a/provider/lpwindow/compute_do.go b/provider/lpwindow/compute_do.go
new file mode 100644
index 000000000..7089ceb02
--- /dev/null
+++ b/provider/lpwindow/compute_do.go
@@ -0,0 +1,442 @@
+package lpwindow
+
+import (
+	"bytes"
+	"context"
+	"sort"
+	"sync"
+	"time"
+
+	"github.com/ipfs/go-cid"
+	"go.uber.org/multierr"
+	"golang.org/x/xerrors"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-bitfield"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/builtin"
+	miner2 "github.com/filecoin-project/go-state-types/builtin/v9/miner"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/dline"
+	"github.com/filecoin-project/go-state-types/proof"
+	proof7 "github.com/filecoin-project/specs-actors/v7/actors/runtime/proof"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	types "github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/storage/sealer"
+	"github.com/filecoin-project/lotus/storage/sealer/storiface"
+)
+
+const disablePreChecks = false // todo config
+
+func (t *WdPostTask) DoPartition(ctx context.Context, ts *types.TipSet, maddr address.Address, di *dline.Info, partIdx uint64) (out *miner2.SubmitWindowedPoStParams, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Errorf("recover: %s", r)
+			err = xerrors.Errorf("panic in doPartition: %s", r)
+		}
+	}()
+
+	buf := new(bytes.Buffer)
+	if err := maddr.MarshalCBOR(buf); err != nil {
+		return nil, xerrors.Errorf("failed to marshal address to cbor: %w", err)
+	}
+
+	headTs, err := t.api.ChainHead(ctx)
+	if err != nil {
+		return nil, xerrors.Errorf("getting current head: %w", err)
+	}
+
+	rand, err := t.api.StateGetRandomnessFromBeacon(ctx, crypto.DomainSeparationTag_WindowedPoStChallengeSeed, di.Challenge, buf.Bytes(), headTs.Key())
+	if err != nil {
+		return nil, xerrors.Errorf("failed to get chain randomness from beacon for window post (ts=%d; deadline=%d): %w", ts.Height(), di, err)
+	}
+
+	parts, err := t.api.StateMinerPartitions(ctx, maddr, di.Index, ts.Key())
+	if err != nil {
+		return nil, xerrors.Errorf("getting partitions: %w", err)
+	}
+
+	if partIdx >= uint64(len(parts)) {
+		return nil, xerrors.Errorf("invalid partIdx %d (deadline has %d partitions)", partIdx, len(parts))
+	}
+
+	partition := parts[partIdx]
+
+	params := miner2.SubmitWindowedPoStParams{
+		Deadline:   di.Index,
+		Partitions: make([]miner2.PoStPartition, 0, 1),
+		Proofs:     nil,
+	}
+
+	var partitions []miner2.PoStPartition
+	var xsinfos []proof7.ExtendedSectorInfo
+
+	{
+		toProve, err := bitfield.SubtractBitField(partition.LiveSectors, partition.FaultySectors)
+		if err != nil {
+			return nil, xerrors.Errorf("removing faults from set of sectors to prove: %w", err)
+		}
+		/*if manual {
+			// this is a check run, we want to prove faulty sectors, even
+			// if they are not declared as recovering.
+			toProve = partition.LiveSectors
+		}*/
+		toProve, err = bitfield.MergeBitFields(toProve, partition.RecoveringSectors)
+		if err != nil {
+			return nil, xerrors.Errorf("adding recoveries to set of sectors to prove: %w", err)
+		}
+
+		good, err := toProve.Copy()
+		if err != nil {
+			return nil, xerrors.Errorf("copy toProve: %w", err)
+		}
+		if !disablePreChecks {
+			good, err = checkSectors(ctx, t.api, t.faultTracker, maddr, toProve, ts.Key())
+			if err != nil {
+				return nil, xerrors.Errorf("checking sectors to skip: %w", err)
+			}
+		}
+
+		/*good, err = bitfield.SubtractBitField(good, postSkipped)
+		if err != nil {
+			return nil, xerrors.Errorf("toProve - postSkipped: %w", err)
+		}
+
+		post skipped is legacy retry mechanism, shouldn't be needed anymore
+		*/
+
+		skipped, err := bitfield.SubtractBitField(toProve, good)
+		if err != nil {
+			return nil, xerrors.Errorf("toProve - good: %w", err)
+		}
+
+		sc, err := skipped.Count()
+		if err != nil {
+			return nil, xerrors.Errorf("getting skipped sector count: %w", err)
+		}
+
+		skipCount := sc
+
+		ssi, err := t.sectorsForProof(ctx, maddr, good, partition.AllSectors, ts)
+		if err != nil {
+			return nil, xerrors.Errorf("getting sorted sector info: %w", err)
+		}
+
+		if len(ssi) == 0 {
+			return nil, xerrors.Errorf("no sectors to prove")
+		}
+
+		xsinfos = append(xsinfos, ssi...)
+		partitions = append(partitions, miner2.PoStPartition{
+			Index:   partIdx,
+			Skipped: skipped,
+		})
+
+		log.Infow("running window post",
+			"chain-random", rand,
+			"deadline", di,
+			"height", ts.Height(),
+			"skipped", skipCount)
+
+		tsStart := build.Clock.Now()
+
+		mid, err := address.IDFromAddress(maddr)
+		if err != nil {
+			return nil, err
+		}
+
+		nv, err := t.api.StateNetworkVersion(ctx, ts.Key())
+		if err != nil {
+			return nil, xerrors.Errorf("getting network version: %w", err)
+		}
+
+		ppt, err := xsinfos[0].SealProof.RegisteredWindowPoStProofByNetworkVersion(nv)
+		if err != nil {
+			return nil, xerrors.Errorf("failed to get window post type: %w", err)
+		}
+
+		postOut, ps, err := t.generateWindowPoSt(ctx, ppt, abi.ActorID(mid), xsinfos, append(abi.PoStRandomness{}, rand...))
+		elapsed := time.Since(tsStart)
+		log.Infow("computing window post", "partition", partIdx, "elapsed", elapsed, "skip", len(ps), "err", err)
+		if err != nil {
+			log.Errorf("error generating window post: %s", err)
+		}
+
+		if err == nil {
+			// If we proved nothing, something is very wrong.
+			if len(postOut) == 0 {
+				log.Errorf("len(postOut) == 0")
+				return nil, xerrors.Errorf("received no proofs back from generate window post")
+			}
+
+			headTs, err := t.api.ChainHead(ctx)
+			if err != nil {
+				return nil, xerrors.Errorf("getting current head: %w", err)
+			}
+
+			checkRand, err := t.api.StateGetRandomnessFromBeacon(ctx, crypto.DomainSeparationTag_WindowedPoStChallengeSeed, di.Challenge, buf.Bytes(), headTs.Key())
+			if err != nil {
+				return nil, xerrors.Errorf("failed to get chain randomness from beacon for window post (ts=%d; deadline=%d): %w", ts.Height(), di, err)
+			}
+
+			if !bytes.Equal(checkRand, rand) {
+				// this is a check from legacy code, there it would retry with new randomness.
+				// here we don't retry because the current network version uses beacon randomness
+				// which should never change. We do keep this check tho to detect potential issues.
+				return nil, xerrors.Errorf("post generation randomness was different from random beacon")
+			}
+
+			sinfos := make([]proof7.SectorInfo, len(xsinfos))
+			for i, xsi := range xsinfos {
+				sinfos[i] = proof7.SectorInfo{
+					SealProof:    xsi.SealProof,
+					SectorNumber: xsi.SectorNumber,
+					SealedCID:    xsi.SealedCID,
+				}
+			}
+			if correct, err := t.verifier.VerifyWindowPoSt(ctx, proof.WindowPoStVerifyInfo{
+				Randomness:        abi.PoStRandomness(checkRand),
+				Proofs:            postOut,
+				ChallengedSectors: sinfos,
+				Prover:            abi.ActorID(mid),
+			}); err != nil {
+				/*log.Errorw("window post verification failed", "post", postOut, "error", err)
+				time.Sleep(5 * time.Second)
+				continue todo retry loop */
+			} else if !correct {
+				_ = correct
+				/*log.Errorw("generated incorrect window post proof", "post", postOut, "error", err)
+				continue todo retry loop*/
+			}
+
+			// Proof generation successful, stop retrying
+			//somethingToProve = true
+			params.Partitions = partitions
+			params.Proofs = postOut
+			//break
+
+			return &params, nil
+		}
+	}
+
+	return nil, xerrors.Errorf("failed to generate window post")
+}
+
+type CheckSectorsAPI interface {
+	StateMinerSectors(ctx context.Context, addr address.Address, bf *bitfield.BitField, tsk types.TipSetKey) ([]*miner.SectorOnChainInfo, error)
+}
+
+func checkSectors(ctx context.Context, api CheckSectorsAPI, ft sealer.FaultTracker,
+	maddr address.Address, check bitfield.BitField, tsk types.TipSetKey) (bitfield.BitField, error) {
+	mid, err := address.IDFromAddress(maddr)
+	if err != nil {
+		return bitfield.BitField{}, xerrors.Errorf("failed to convert to ID addr: %w", err)
+	}
+
+	sectorInfos, err := api.StateMinerSectors(ctx, maddr, &check, tsk)
+	if err != nil {
+		return bitfield.BitField{}, xerrors.Errorf("failed to get sector infos: %w", err)
+	}
+
+	type checkSector struct {
+		sealed cid.Cid
+		update bool
+	}
+
+	sectors := make(map[abi.SectorNumber]checkSector)
+	var tocheck []storiface.SectorRef
+	for _, info := range sectorInfos {
+		sectors[info.SectorNumber] = checkSector{
+			sealed: info.SealedCID,
+			update: info.SectorKeyCID != nil,
+		}
+		tocheck = append(tocheck, storiface.SectorRef{
+			ProofType: info.SealProof,
+			ID: abi.SectorID{
+				Miner:  abi.ActorID(mid),
+				Number: info.SectorNumber,
+			},
+		})
+	}
+
+	if len(tocheck) == 0 {
+		return bitfield.BitField{}, nil
+	}
+
+	pp, err := tocheck[0].ProofType.RegisteredWindowPoStProof()
+	if err != nil {
+		return bitfield.BitField{}, xerrors.Errorf("failed to get window PoSt proof: %w", err)
+	}
+	pp, err = pp.ToV1_1PostProof()
+	if err != nil {
+		return bitfield.BitField{}, xerrors.Errorf("failed to convert to v1_1 post proof: %w", err)
+	}
+
+	bad, err := ft.CheckProvable(ctx, pp, tocheck, func(ctx context.Context, id abi.SectorID) (cid.Cid, bool, error) {
+		s, ok := sectors[id.Number]
+		if !ok {
+			return cid.Undef, false, xerrors.Errorf("sealed CID not found")
+		}
+		return s.sealed, s.update, nil
+	})
+	if err != nil {
+		return bitfield.BitField{}, xerrors.Errorf("checking provable sectors: %w", err)
+	}
+	for id := range bad {
+		delete(sectors, id.Number)
+	}
+
+	log.Warnw("Checked sectors", "checked", len(tocheck), "good", len(sectors))
+
+	sbf := bitfield.New()
+	for s := range sectors {
+		sbf.Set(uint64(s))
+	}
+
+	return sbf, nil
+}
+
+func (t *WdPostTask) sectorsForProof(ctx context.Context, maddr address.Address, goodSectors, allSectors bitfield.BitField, ts *types.TipSet) ([]proof7.ExtendedSectorInfo, error) {
+	sset, err := t.api.StateMinerSectors(ctx, maddr, &goodSectors, ts.Key())
+	if err != nil {
+		return nil, err
+	}
+
+	if len(sset) == 0 {
+		return nil, nil
+	}
+
+	sectorByID := make(map[uint64]proof7.ExtendedSectorInfo, len(sset))
+	for _, sector := range sset {
+		sectorByID[uint64(sector.SectorNumber)] = proof7.ExtendedSectorInfo{
+			SectorNumber: sector.SectorNumber,
+			SealedCID:    sector.SealedCID,
+			SealProof:    sector.SealProof,
+			SectorKey:    sector.SectorKeyCID,
+		}
+	}
+
+	proofSectors := make([]proof7.ExtendedSectorInfo, 0, len(sset))
+	if err := allSectors.ForEach(func(sectorNo uint64) error {
+		if info, found := sectorByID[sectorNo]; found {
+			proofSectors = append(proofSectors, info)
+		} //else {
+		//skip
+		// todo: testing: old logic used to put 'substitute' sectors here
+		//  that probably isn't needed post nv19, but we do need to check that
+		//}
+		return nil
+	}); err != nil {
+		return nil, xerrors.Errorf("iterating partition sector bitmap: %w", err)
+	}
+
+	return proofSectors, nil
+}
+
+func (t *WdPostTask) generateWindowPoSt(ctx context.Context, ppt abi.RegisteredPoStProof, minerID abi.ActorID, sectorInfo []proof.ExtendedSectorInfo, randomness abi.PoStRandomness) ([]proof.PoStProof, []abi.SectorID, error) {
+	var retErr error = nil
+	randomness[31] &= 0x3f
+
+	out := make([]proof.PoStProof, 0)
+
+	if len(sectorInfo) == 0 {
+		return nil, nil, xerrors.New("generate window post len(sectorInfo)=0")
+	}
+
+	maxPartitionSize, err := builtin.PoStProofWindowPoStPartitionSectors(ppt) // todo proxy through chain/actors
+	if err != nil {
+		return nil, nil, xerrors.Errorf("get sectors count of partition failed:%+v", err)
+	}
+
+	// The partitions number of this batch
+	// ceil(sectorInfos / maxPartitionSize)
+	partitionCount := uint64((len(sectorInfo) + int(maxPartitionSize) - 1) / int(maxPartitionSize))
+	if partitionCount > 1 {
+		return nil, nil, xerrors.Errorf("generateWindowPoSt partitionCount:%d, only support 1", partitionCount)
+	}
+
+	log.Infof("generateWindowPoSt maxPartitionSize:%d partitionCount:%d", maxPartitionSize, partitionCount)
+
+	var skipped []abi.SectorID
+	var flk sync.Mutex
+	cctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	sort.Slice(sectorInfo, func(i, j int) bool {
+		return sectorInfo[i].SectorNumber < sectorInfo[j].SectorNumber
+	})
+
+	sectorNums := make([]abi.SectorNumber, len(sectorInfo))
+	sectorMap := make(map[abi.SectorNumber]proof.ExtendedSectorInfo)
+	for i, s := range sectorInfo {
+		sectorNums[i] = s.SectorNumber
+		sectorMap[s.SectorNumber] = s
+	}
+
+	postChallenges, err := ffi.GeneratePoStFallbackSectorChallenges(ppt, minerID, randomness, sectorNums)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("generating fallback challenges: %v", err)
+	}
+
+	proofList := make([]ffi.PartitionProof, partitionCount)
+	var wg sync.WaitGroup
+	wg.Add(int(partitionCount))
+
+	for partIdx := uint64(0); partIdx < partitionCount; partIdx++ {
+		go func(partIdx uint64) {
+			defer wg.Done()
+
+			sectors := make([]storiface.PostSectorChallenge, 0)
+			for i := uint64(0); i < maxPartitionSize; i++ {
+				si := i + partIdx*maxPartitionSize
+				if si >= uint64(len(postChallenges.Sectors)) {
+					break
+				}
+
+				snum := postChallenges.Sectors[si]
+				sinfo := sectorMap[snum]
+
+				sectors = append(sectors, storiface.PostSectorChallenge{
+					SealProof:    sinfo.SealProof,
+					SectorNumber: snum,
+					SealedCID:    sinfo.SealedCID,
+					Challenge:    postChallenges.Challenges[snum],
+					Update:       sinfo.SectorKey != nil,
+				})
+			}
+
+			pr, err := t.prover.GenerateWindowPoStAdv(cctx, ppt, minerID, sectors, int(partIdx), randomness, true)
+			sk := pr.Skipped
+
+			if err != nil || len(sk) > 0 {
+				log.Errorf("generateWindowPost part:%d, skipped:%d, sectors: %d, err: %+v", partIdx, len(sk), len(sectors), err)
+				flk.Lock()
+				skipped = append(skipped, sk...)
+
+				if err != nil {
+					retErr = multierr.Append(retErr, xerrors.Errorf("partitionIndex:%d err:%+v", partIdx, err))
+				}
+				flk.Unlock()
+			}
+
+			proofList[partIdx] = ffi.PartitionProof(pr.PoStProofs)
+		}(partIdx)
+	}
+
+	wg.Wait()
+
+	if len(skipped) > 0 {
+		log.Warnw("generateWindowPoSt skipped sectors", "skipped", len(skipped))
+	}
+
+	postProofs, err := ffi.MergeWindowPoStPartitionProofs(ppt, proofList)
+	if err != nil {
+		return nil, skipped, xerrors.Errorf("merge windowPoSt partition proofs: %v", err)
+	}
+
+	out = append(out, *postProofs)
+	return out, skipped, retErr
+}
diff --git a/provider/lpwindow/compute_task.go b/provider/lpwindow/compute_task.go
new file mode 100644
index 000000000..e9d582704
--- /dev/null
+++ b/provider/lpwindow/compute_task.go
@@ -0,0 +1,428 @@
+package lpwindow
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strings"
+
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/samber/lo"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-bitfield"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/dline"
+	"github.com/filecoin-project/go-state-types/network"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonytask"
+	"github.com/filecoin-project/lotus/lib/harmony/resources"
+	"github.com/filecoin-project/lotus/lib/harmony/taskhelp"
+	"github.com/filecoin-project/lotus/lib/promise"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/filecoin-project/lotus/provider/chainsched"
+	"github.com/filecoin-project/lotus/storage/sealer"
+	"github.com/filecoin-project/lotus/storage/sealer/sealtasks"
+	"github.com/filecoin-project/lotus/storage/sealer/storiface"
+	"github.com/filecoin-project/lotus/storage/wdpost"
+)
+
+var log = logging.Logger("lpwindow")
+
+var EpochsPerDeadline = miner.WPoStProvingPeriod() / abi.ChainEpoch(miner.WPoStPeriodDeadlines)
+
+type WdPostTaskDetails struct {
+	Ts       *types.TipSet
+	Deadline *dline.Info
+}
+
+type WDPoStAPI interface {
+	ChainHead(context.Context) (*types.TipSet, error)
+	ChainGetTipSet(context.Context, types.TipSetKey) (*types.TipSet, error)
+	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (api.MinerInfo, error)
+	ChainGetTipSetAfterHeight(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)
+	StateMinerPartitions(context.Context, address.Address, uint64, types.TipSetKey) ([]api.Partition, error)
+	StateGetRandomnessFromBeacon(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error)
+	StateNetworkVersion(context.Context, types.TipSetKey) (network.Version, error)
+	StateMinerSectors(context.Context, address.Address, *bitfield.BitField, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)
+}
+
+type ProverPoSt interface {
+	GenerateWindowPoStAdv(ctx context.Context, ppt abi.RegisteredPoStProof, mid abi.ActorID, sectors []storiface.PostSectorChallenge, partitionIdx int, randomness abi.PoStRandomness, allowSkip bool) (storiface.WindowPoStResult, error)
+}
+
+type WdPostTask struct {
+	api WDPoStAPI
+	db  *harmonydb.DB
+
+	faultTracker sealer.FaultTracker
+	prover       ProverPoSt
+	verifier     storiface.Verifier
+
+	windowPoStTF promise.Promise[harmonytask.AddTaskFunc]
+
+	actors []dtypes.MinerAddress
+	max    int
+}
+
+type wdTaskIdentity struct {
+	SpID               uint64         `db:"sp_id"`
+	ProvingPeriodStart abi.ChainEpoch `db:"proving_period_start"`
+	DeadlineIndex      uint64         `db:"deadline_index"`
+	PartitionIndex     uint64         `db:"partition_index"`
+}
+
+func NewWdPostTask(db *harmonydb.DB,
+	api WDPoStAPI,
+	faultTracker sealer.FaultTracker,
+	prover ProverPoSt,
+	verifier storiface.Verifier,
+
+	pcs *chainsched.ProviderChainSched,
+	actors []dtypes.MinerAddress,
+	max int,
+) (*WdPostTask, error) {
+	t := &WdPostTask{
+		db:  db,
+		api: api,
+
+		faultTracker: faultTracker,
+		prover:       prover,
+		verifier:     verifier,
+
+		actors: actors,
+		max:    max,
+	}
+
+	if err := pcs.AddHandler(t.processHeadChange); err != nil {
+		return nil, err
+	}
+
+	return t, nil
+}
+
+func (t *WdPostTask) Do(taskID harmonytask.TaskID, stillOwned func() bool) (done bool, err error) {
+	log.Debugw("WdPostTask.Do()", "taskID", taskID)
+
+	var spID, pps, dlIdx, partIdx uint64
+
+	err = t.db.QueryRow(context.Background(),
+		`Select sp_id, proving_period_start, deadline_index, partition_index
+			from wdpost_partition_tasks 
+			where task_id = $1`, taskID).Scan(
+		&spID, &pps, &dlIdx, &partIdx,
+	)
+	if err != nil {
+		log.Errorf("WdPostTask.Do() failed to queryRow: %v", err)
+		return false, err
+	}
+
+	head, err := t.api.ChainHead(context.Background())
+	if err != nil {
+		log.Errorf("WdPostTask.Do() failed to get chain head: %v", err)
+		return false, err
+	}
+
+	deadline := wdpost.NewDeadlineInfo(abi.ChainEpoch(pps), dlIdx, head.Height())
+
+	if deadline.PeriodElapsed() {
+		log.Errorf("WdPost removed stale task: %v %v", taskID, deadline)
+		return true, nil
+	}
+
+	maddr, err := address.NewIDAddress(spID)
+	if err != nil {
+		log.Errorf("WdPostTask.Do() failed to NewIDAddress: %v", err)
+		return false, err
+	}
+
+	ts, err := t.api.ChainGetTipSetAfterHeight(context.Background(), deadline.Challenge, head.Key())
+	if err != nil {
+		log.Errorf("WdPostTask.Do() failed to ChainGetTipSetAfterHeight: %v", err)
+		return false, err
+	}
+
+	postOut, err := t.DoPartition(context.Background(), ts, maddr, deadline, partIdx)
+	if err != nil {
+		log.Errorf("WdPostTask.Do() failed to doPartition: %v", err)
+		return false, err
+	}
+
+	var msgbuf bytes.Buffer
+	if err := postOut.MarshalCBOR(&msgbuf); err != nil {
+		return false, xerrors.Errorf("marshaling PoSt: %w", err)
+	}
+
+	testTaskIDCt := 0
+	if err = t.db.QueryRow(context.Background(), `SELECT COUNT(*) FROM harmony_test WHERE task_id = $1`, taskID).Scan(&testTaskIDCt); err != nil {
+		return false, xerrors.Errorf("querying for test task: %w", err)
+	}
+	if testTaskIDCt == 1 {
+		// Do not send test tasks to the chain but to harmony_test & stdout.
+
+		data, err := json.MarshalIndent(map[string]any{
+			"sp_id":                spID,
+			"proving_period_start": pps,
+			"deadline":             deadline.Index,
+			"partition":            partIdx,
+			"submit_at_epoch":      deadline.Open,
+			"submit_by_epoch":      deadline.Close,
+			"proof_params":         msgbuf.Bytes(),
+		}, "", "  ")
+		if err != nil {
+			return false, xerrors.Errorf("marshaling message: %w", err)
+		}
+		ctx := context.Background()
+		_, err = t.db.Exec(ctx, `UPDATE harmony_test SET result=$1 WHERE task_id=$2`, string(data), taskID)
+		if err != nil {
+			return false, xerrors.Errorf("updating harmony_test: %w", err)
+		}
+		log.Infof("SKIPPED sending test message to chain. SELECT * FROM harmony_test WHERE task_id= %v", taskID)
+		return true, nil // nothing committed
+	}
+	// Insert into wdpost_proofs table
+	n, err := t.db.Exec(context.Background(),
+		`INSERT INTO wdpost_proofs (
+                               sp_id,
+                               proving_period_start,
+	                           deadline,
+	                           partition,
+	                           submit_at_epoch,
+	                           submit_by_epoch,
+                               proof_params)
+	    			 VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+		spID,
+		pps,
+		deadline.Index,
+		partIdx,
+		deadline.Open,
+		deadline.Close,
+		msgbuf.Bytes(),
+	)
+
+	if err != nil {
+		log.Errorf("WdPostTask.Do() failed to insert into wdpost_proofs: %v", err)
+		return false, err
+	}
+	if n != 1 {
+		log.Errorf("WdPostTask.Do() failed to insert into wdpost_proofs: %v", err)
+		return false, err
+	}
+
+	return true, nil
+}
+
+func entToStr[T any](t T, i int) string {
+	return fmt.Sprint(t)
+}
+
+func (t *WdPostTask) CanAccept(ids []harmonytask.TaskID, te *harmonytask.TaskEngine) (*harmonytask.TaskID, error) {
+	// GetEpoch
+	ts, err := t.api.ChainHead(context.Background())
+
+	if err != nil {
+		return nil, err
+	}
+
+	// GetData for tasks
+	type wdTaskDef struct {
+		TaskID             harmonytask.TaskID
+		SpID               uint64
+		ProvingPeriodStart abi.ChainEpoch
+		DeadlineIndex      uint64
+		PartitionIndex     uint64
+
+		dlInfo *dline.Info `pgx:"-"`
+		openTs *types.TipSet
+	}
+	var tasks []wdTaskDef
+
+	err = t.db.Select(context.Background(), &tasks,
+		`Select 
+			task_id,
+			sp_id,
+			proving_period_start,
+			deadline_index,
+			partition_index
+	from wdpost_partition_tasks 
+	where task_id IN (SELECT unnest(string_to_array($1, ','))::bigint)`, strings.Join(lo.Map(ids, entToStr[harmonytask.TaskID]), ","))
+	if err != nil {
+		return nil, err
+	}
+
+	// Accept those past deadline, then delete them in Do().
+	for i := range tasks {
+		tasks[i].dlInfo = wdpost.NewDeadlineInfo(tasks[i].ProvingPeriodStart, tasks[i].DeadlineIndex, ts.Height())
+
+		if tasks[i].dlInfo.PeriodElapsed() {
+			return &tasks[i].TaskID, nil
+		}
+
+		tasks[i].openTs, err = t.api.ChainGetTipSetAfterHeight(context.Background(), tasks[i].dlInfo.Open, ts.Key())
+		if err != nil {
+			return nil, xerrors.Errorf("getting task open tipset: %w", err)
+		}
+	}
+
+	// todo fix the block below
+	//  workAdderMutex is held by taskTypeHandler.considerWork, which calls this CanAccept
+	//  te.ResourcesAvailable will try to get that lock again, which will deadlock
+
+	// Discard those too big for our free RAM
+	/*freeRAM := te.ResourcesAvailable().Ram
+	tasks = lo.Filter(tasks, func(d wdTaskDef, _ int) bool {
+		maddr, err := address.NewIDAddress(tasks[0].Sp_id)
+		if err != nil {
+			log.Errorf("WdPostTask.CanAccept() failed to NewIDAddress: %v", err)
+			return false
+		}
+
+		mi, err := t.api.StateMinerInfo(context.Background(), maddr, ts.Key())
+		if err != nil {
+			log.Errorf("WdPostTask.CanAccept() failed to StateMinerInfo: %v", err)
+			return false
+		}
+
+		spt, err := policy.GetSealProofFromPoStProof(mi.WindowPoStProofType)
+		if err != nil {
+			log.Errorf("WdPostTask.CanAccept() failed to GetSealProofFromPoStProof: %v", err)
+			return false
+		}
+
+		return res[spt].MaxMemory <= freeRAM
+	})*/
+	if len(tasks) == 0 {
+		log.Infof("RAM too small for any WDPost task")
+		return nil, nil
+	}
+
+	// Ignore those with too many failures unless they are the only ones left.
+	tasks, _ = taskhelp.SliceIfFound(tasks, func(d wdTaskDef) bool {
+		var r int
+		err := t.db.QueryRow(context.Background(), `SELECT COUNT(*) 
+		FROM harmony_task_history 
+		WHERE task_id = $1 AND result = false`, d.TaskID).Scan(&r)
+		if err != nil {
+			log.Errorf("WdPostTask.CanAccept() failed to queryRow: %v", err)
+		}
+		return r < 2
+	})
+
+	// Select the one closest to the deadline
+	sort.Slice(tasks, func(i, j int) bool {
+		return tasks[i].dlInfo.Open < tasks[j].dlInfo.Open
+	})
+
+	return &tasks[0].TaskID, nil
+}
+
+var res = storiface.ResourceTable[sealtasks.TTGenerateWindowPoSt]
+
+func (t *WdPostTask) TypeDetails() harmonytask.TaskTypeDetails {
+	return harmonytask.TaskTypeDetails{
+		Name:        "WdPost",
+		Max:         t.max,
+		MaxFailures: 3,
+		Follows:     nil,
+		Cost: resources.Resources{
+			Cpu: 1,
+
+			// todo set to something for 32/64G sector sizes? Technically windowPoSt is happy on a CPU
+			//  but it will use a GPU if available
+			Gpu: 0,
+
+			// RAM of smallest proof's max is listed here
+			Ram: lo.Reduce(lo.Keys(res), func(i uint64, k abi.RegisteredSealProof, _ int) uint64 {
+				if res[k].MaxMemory < i {
+					return res[k].MaxMemory
+				}
+				return i
+			}, 1<<63),
+		},
+	}
+}
+
+func (t *WdPostTask) Adder(taskFunc harmonytask.AddTaskFunc) {
+	t.windowPoStTF.Set(taskFunc)
+}
+
+func (t *WdPostTask) processHeadChange(ctx context.Context, revert, apply *types.TipSet) error {
+	for _, act := range t.actors {
+		maddr := address.Address(act)
+
+		aid, err := address.IDFromAddress(maddr)
+		if err != nil {
+			return xerrors.Errorf("getting miner ID: %w", err)
+		}
+
+		di, err := t.api.StateMinerProvingDeadline(ctx, maddr, apply.Key())
+		if err != nil {
+			return err
+		}
+
+		if !di.PeriodStarted() {
+			return nil // not proving anything yet
+		}
+
+		partitions, err := t.api.StateMinerPartitions(ctx, maddr, di.Index, apply.Key())
+		if err != nil {
+			return xerrors.Errorf("getting partitions: %w", err)
+		}
+
+		// TODO: Batch Partitions??
+
+		for pidx := range partitions {
+			tid := wdTaskIdentity{
+				SpID:               aid,
+				ProvingPeriodStart: di.PeriodStart,
+				DeadlineIndex:      di.Index,
+				PartitionIndex:     uint64(pidx),
+			}
+
+			tf := t.windowPoStTF.Val(ctx)
+			if tf == nil {
+				return xerrors.Errorf("no task func")
+			}
+
+			tf(func(id harmonytask.TaskID, tx *harmonydb.Tx) (bool, error) {
+				return t.addTaskToDB(id, tid, tx)
+			})
+		}
+	}
+
+	return nil
+}
+
+func (t *WdPostTask) addTaskToDB(taskId harmonytask.TaskID, taskIdent wdTaskIdentity, tx *harmonydb.Tx) (bool, error) {
+
+	_, err := tx.Exec(
+		`INSERT INTO wdpost_partition_tasks (
+                         task_id,
+                          sp_id,
+                          proving_period_start,
+                          deadline_index,
+                          partition_index
+                        ) VALUES ($1, $2, $3, $4, $5)`,
+		taskId,
+		taskIdent.SpID,
+		taskIdent.ProvingPeriodStart,
+		taskIdent.DeadlineIndex,
+		taskIdent.PartitionIndex,
+	)
+	if err != nil {
+		return false, xerrors.Errorf("insert partition task: %w", err)
+	}
+
+	return true, nil
+}
+
+var _ harmonytask.TaskInterface = &WdPostTask{}
diff --git a/provider/lpwindow/faults_simple.go b/provider/lpwindow/faults_simple.go
new file mode 100644
index 000000000..d43e8ee19
--- /dev/null
+++ b/provider/lpwindow/faults_simple.go
@@ -0,0 +1,152 @@
+package lpwindow
+
+import (
+	"context"
+	"crypto/rand"
+	"fmt"
+	"sync"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/storage/paths"
+	"github.com/filecoin-project/lotus/storage/sealer/storiface"
+)
+
+type SimpleFaultTracker struct {
+	storage paths.Store
+	index   paths.SectorIndex
+
+	parallelCheckLimit    int // todo live config?
+	singleCheckTimeout    time.Duration
+	partitionCheckTimeout time.Duration
+}
+
+func NewSimpleFaultTracker(storage paths.Store, index paths.SectorIndex,
+	parallelCheckLimit int, singleCheckTimeout time.Duration, partitionCheckTimeout time.Duration) *SimpleFaultTracker {
+	return &SimpleFaultTracker{
+		storage: storage,
+		index:   index,
+
+		parallelCheckLimit:    parallelCheckLimit,
+		singleCheckTimeout:    singleCheckTimeout,
+		partitionCheckTimeout: partitionCheckTimeout,
+	}
+}
+
+func (m *SimpleFaultTracker) CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storiface.SectorRef, rg storiface.RGetter) (map[abi.SectorID]string, error) {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	if rg == nil {
+		return nil, xerrors.Errorf("rg is nil")
+	}
+
+	var bad = make(map[abi.SectorID]string)
+	var badLk sync.Mutex
+
+	var postRand abi.PoStRandomness = make([]byte, abi.RandomnessLength)
+	_, _ = rand.Read(postRand)
+	postRand[31] &= 0x3f
+
+	limit := m.parallelCheckLimit
+	if limit <= 0 {
+		limit = len(sectors)
+	}
+	throttle := make(chan struct{}, limit)
+
+	addBad := func(s abi.SectorID, reason string) {
+		badLk.Lock()
+		bad[s] = reason
+		badLk.Unlock()
+	}
+
+	if m.partitionCheckTimeout > 0 {
+		var cancel2 context.CancelFunc
+		ctx, cancel2 = context.WithTimeout(ctx, m.partitionCheckTimeout)
+		defer cancel2()
+	}
+
+	var wg sync.WaitGroup
+	wg.Add(len(sectors))
+
+	for _, sector := range sectors {
+		select {
+		case throttle <- struct{}{}:
+		case <-ctx.Done():
+			addBad(sector.ID, fmt.Sprintf("waiting for check worker: %s", ctx.Err()))
+			wg.Done()
+			continue
+		}
+
+		go func(sector storiface.SectorRef) {
+			defer wg.Done()
+			defer func() {
+				<-throttle
+			}()
+			ctx, cancel := context.WithCancel(ctx)
+			defer cancel()
+
+			commr, update, err := rg(ctx, sector.ID)
+			if err != nil {
+				log.Warnw("CheckProvable Sector FAULT: getting commR", "sector", sector, "sealed", "err", err)
+				addBad(sector.ID, fmt.Sprintf("getting commR: %s", err))
+				return
+			}
+
+			toLock := storiface.FTSealed | storiface.FTCache
+			if update {
+				toLock = storiface.FTUpdate | storiface.FTUpdateCache
+			}
+
+			locked, err := m.index.StorageTryLock(ctx, sector.ID, toLock, storiface.FTNone)
+			if err != nil {
+				addBad(sector.ID, fmt.Sprintf("tryLock error: %s", err))
+				return
+			}
+
+			if !locked {
+				log.Warnw("CheckProvable Sector FAULT: can't acquire read lock", "sector", sector)
+				addBad(sector.ID, fmt.Sprint("can't acquire read lock"))
+				return
+			}
+
+			ch, err := ffi.GeneratePoStFallbackSectorChallenges(pp, sector.ID.Miner, postRand, []abi.SectorNumber{
+				sector.ID.Number,
+			})
+			if err != nil {
+				log.Warnw("CheckProvable Sector FAULT: generating challenges", "sector", sector, "err", err)
+				addBad(sector.ID, fmt.Sprintf("generating fallback challenges: %s", err))
+				return
+			}
+
+			vctx := ctx
+
+			if m.singleCheckTimeout > 0 {
+				var cancel2 context.CancelFunc
+				vctx, cancel2 = context.WithTimeout(ctx, m.singleCheckTimeout)
+				defer cancel2()
+			}
+
+			_, err = m.storage.GenerateSingleVanillaProof(vctx, sector.ID.Miner, storiface.PostSectorChallenge{
+				SealProof:    sector.ProofType,
+				SectorNumber: sector.ID.Number,
+				SealedCID:    commr,
+				Challenge:    ch.Challenges[sector.ID.Number],
+				Update:       update,
+			}, pp)
+			if err != nil {
+				log.Warnw("CheckProvable Sector FAULT: generating vanilla proof", "sector", sector, "err", err)
+				addBad(sector.ID, fmt.Sprintf("generating vanilla proof: %s", err))
+				return
+			}
+		}(sector)
+	}
+
+	wg.Wait()
+
+	return bad, nil
+}
diff --git a/provider/lpwindow/recover_task.go b/provider/lpwindow/recover_task.go
new file mode 100644
index 000000000..12f8522b5
--- /dev/null
+++ b/provider/lpwindow/recover_task.go
@@ -0,0 +1,322 @@
+package lpwindow
+
+import (
+	"context"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-bitfield"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/builtin"
+	"github.com/filecoin-project/go-state-types/dline"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonytask"
+	"github.com/filecoin-project/lotus/lib/harmony/resources"
+	"github.com/filecoin-project/lotus/lib/promise"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/filecoin-project/lotus/provider/chainsched"
+	"github.com/filecoin-project/lotus/provider/lpmessage"
+	"github.com/filecoin-project/lotus/storage/ctladdr"
+	"github.com/filecoin-project/lotus/storage/sealer"
+	"github.com/filecoin-project/lotus/storage/wdpost"
+)
+
+type WdPostRecoverDeclareTask struct {
+	sender       *lpmessage.Sender
+	db           *harmonydb.DB
+	api          WdPostRecoverDeclareTaskApi
+	faultTracker sealer.FaultTracker
+
+	maxDeclareRecoveriesGasFee types.FIL
+	as                         *ctladdr.AddressSelector
+	actors                     []dtypes.MinerAddress
+
+	startCheckTF promise.Promise[harmonytask.AddTaskFunc]
+}
+
+type WdPostRecoverDeclareTaskApi interface {
+	ChainHead(context.Context) (*types.TipSet, error)
+	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
+	StateMinerPartitions(context.Context, address.Address, uint64, types.TipSetKey) ([]api.Partition, error)
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (api.MinerInfo, error)
+	StateMinerSectors(ctx context.Context, addr address.Address, bf *bitfield.BitField, tsk types.TipSetKey) ([]*miner.SectorOnChainInfo, error)
+
+	GasEstimateMessageGas(context.Context, *types.Message, *api.MessageSendSpec, types.TipSetKey) (*types.Message, error)
+	GasEstimateFeeCap(context.Context, *types.Message, int64, types.TipSetKey) (types.BigInt, error)
+	GasEstimateGasPremium(_ context.Context, nblocksincl uint64, sender address.Address, gaslimit int64, tsk types.TipSetKey) (types.BigInt, error)
+
+	WalletBalance(context.Context, address.Address) (types.BigInt, error)
+	WalletHas(context.Context, address.Address) (bool, error)
+	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+}
+
+func NewWdPostRecoverDeclareTask(sender *lpmessage.Sender,
+	db *harmonydb.DB,
+	api WdPostRecoverDeclareTaskApi,
+	faultTracker sealer.FaultTracker,
+	as *ctladdr.AddressSelector,
+	pcs *chainsched.ProviderChainSched,
+
+	maxDeclareRecoveriesGasFee types.FIL,
+	actors []dtypes.MinerAddress) (*WdPostRecoverDeclareTask, error) {
+	t := &WdPostRecoverDeclareTask{
+		sender:       sender,
+		db:           db,
+		api:          api,
+		faultTracker: faultTracker,
+
+		maxDeclareRecoveriesGasFee: maxDeclareRecoveriesGasFee,
+		as:                         as,
+		actors:                     actors,
+	}
+
+	if err := pcs.AddHandler(t.processHeadChange); err != nil {
+		return nil, err
+	}
+
+	return t, nil
+}
+
+func (w *WdPostRecoverDeclareTask) Do(taskID harmonytask.TaskID, stillOwned func() bool) (done bool, err error) {
+	log.Debugw("WdPostRecoverDeclareTask.Do()", "taskID", taskID)
+	ctx := context.Background()
+
+	var spID, pps, dlIdx, partIdx uint64
+
+	err = w.db.QueryRow(context.Background(),
+		`Select sp_id, proving_period_start, deadline_index, partition_index
+			from wdpost_recovery_tasks 
+			where task_id = $1`, taskID).Scan(
+		&spID, &pps, &dlIdx, &partIdx,
+	)
+	if err != nil {
+		log.Errorf("WdPostRecoverDeclareTask.Do() failed to queryRow: %v", err)
+		return false, err
+	}
+
+	head, err := w.api.ChainHead(context.Background())
+	if err != nil {
+		log.Errorf("WdPostRecoverDeclareTask.Do() failed to get chain head: %v", err)
+		return false, err
+	}
+
+	deadline := wdpost.NewDeadlineInfo(abi.ChainEpoch(pps), dlIdx, head.Height())
+
+	if deadline.FaultCutoffPassed() {
+		log.Errorf("WdPostRecover removed stale task: %v %v", taskID, deadline)
+		return true, nil
+	}
+
+	maddr, err := address.NewIDAddress(spID)
+	if err != nil {
+		log.Errorf("WdPostTask.Do() failed to NewIDAddress: %v", err)
+		return false, err
+	}
+
+	partitions, err := w.api.StateMinerPartitions(context.Background(), maddr, dlIdx, head.Key())
+	if err != nil {
+		log.Errorf("WdPostRecoverDeclareTask.Do() failed to get partitions: %v", err)
+		return false, err
+	}
+
+	if partIdx >= uint64(len(partitions)) {
+		log.Errorf("WdPostRecoverDeclareTask.Do() failed to get partitions: partIdx >= len(partitions)")
+		return false, err
+	}
+
+	partition := partitions[partIdx]
+
+	unrecovered, err := bitfield.SubtractBitField(partition.FaultySectors, partition.RecoveringSectors)
+	if err != nil {
+		return false, xerrors.Errorf("subtracting recovered set from fault set: %w", err)
+	}
+
+	uc, err := unrecovered.Count()
+	if err != nil {
+		return false, xerrors.Errorf("counting unrecovered sectors: %w", err)
+	}
+
+	if uc == 0 {
+		log.Warnw("nothing to declare recovered", "maddr", maddr, "deadline", deadline, "partition", partIdx)
+		return true, nil
+	}
+
+	recovered, err := checkSectors(ctx, w.api, w.faultTracker, maddr, unrecovered, head.Key())
+	if err != nil {
+		return false, xerrors.Errorf("checking unrecovered sectors: %w", err)
+	}
+
+	// if all sectors failed to recover, don't declare recoveries
+	recoveredCount, err := recovered.Count()
+	if err != nil {
+		return false, xerrors.Errorf("counting recovered sectors: %w", err)
+	}
+
+	if recoveredCount == 0 {
+		log.Warnw("no sectors recovered", "maddr", maddr, "deadline", deadline, "partition", partIdx)
+		return true, nil
+	}
+
+	recDecl := miner.RecoveryDeclaration{
+		Deadline:  dlIdx,
+		Partition: partIdx,
+		Sectors:   recovered,
+	}
+
+	params := &miner.DeclareFaultsRecoveredParams{
+		Recoveries: []miner.RecoveryDeclaration{recDecl},
+	}
+
+	enc, aerr := actors.SerializeParams(params)
+	if aerr != nil {
+		return false, xerrors.Errorf("could not serialize declare recoveries parameters: %w", aerr)
+	}
+
+	msg := &types.Message{
+		To:     maddr,
+		Method: builtin.MethodsMiner.DeclareFaultsRecovered,
+		Params: enc,
+		Value:  types.NewInt(0),
+	}
+
+	msg, mss, err := preparePoStMessage(w.api, w.as, maddr, msg, abi.TokenAmount(w.maxDeclareRecoveriesGasFee))
+	if err != nil {
+		return false, xerrors.Errorf("sending declare recoveries message: %w", err)
+	}
+
+	mc, err := w.sender.Send(ctx, msg, mss, "declare-recoveries")
+	if err != nil {
+		return false, xerrors.Errorf("sending declare recoveries message: %w", err)
+	}
+
+	log.Debugw("WdPostRecoverDeclareTask.Do() sent declare recoveries message", "maddr", maddr, "deadline", deadline, "partition", partIdx, "mc", mc)
+	return true, nil
+}
+
+func (w *WdPostRecoverDeclareTask) CanAccept(ids []harmonytask.TaskID, engine *harmonytask.TaskEngine) (*harmonytask.TaskID, error) {
+	if len(ids) == 0 {
+		// probably can't happen, but panicking is bad
+		return nil, nil
+	}
+
+	if w.sender == nil {
+		// we can't send messages
+		return nil, nil
+	}
+
+	return &ids[0], nil
+}
+
+func (w *WdPostRecoverDeclareTask) TypeDetails() harmonytask.TaskTypeDetails {
+	return harmonytask.TaskTypeDetails{
+		Max:  128,
+		Name: "WdPostRecover",
+		Cost: resources.Resources{
+			Cpu: 1,
+			Gpu: 0,
+			Ram: 128 << 20,
+		},
+		MaxFailures: 10,
+		Follows:     nil,
+	}
+}
+
+func (w *WdPostRecoverDeclareTask) Adder(taskFunc harmonytask.AddTaskFunc) {
+	w.startCheckTF.Set(taskFunc)
+}
+
+func (w *WdPostRecoverDeclareTask) processHeadChange(ctx context.Context, revert, apply *types.TipSet) error {
+	tf := w.startCheckTF.Val(ctx)
+
+	for _, act := range w.actors {
+		maddr := address.Address(act)
+
+		aid, err := address.IDFromAddress(maddr)
+		if err != nil {
+			return xerrors.Errorf("getting miner ID: %w", err)
+		}
+
+		di, err := w.api.StateMinerProvingDeadline(ctx, maddr, apply.Key())
+		if err != nil {
+			return err
+		}
+
+		if !di.PeriodStarted() {
+			return nil // not proving anything yet
+		}
+
+		// declaring two deadlines ahead
+		declDeadline := (di.Index + 2) % di.WPoStPeriodDeadlines
+
+		pps := di.PeriodStart
+		if declDeadline != di.Index+2 {
+			pps = di.NextPeriodStart()
+		}
+
+		partitions, err := w.api.StateMinerPartitions(ctx, maddr, declDeadline, apply.Key())
+		if err != nil {
+			return xerrors.Errorf("getting partitions: %w", err)
+		}
+
+		for pidx, partition := range partitions {
+			unrecovered, err := bitfield.SubtractBitField(partition.FaultySectors, partition.RecoveringSectors)
+			if err != nil {
+				return xerrors.Errorf("subtracting recovered set from fault set: %w", err)
+			}
+
+			uc, err := unrecovered.Count()
+			if err != nil {
+				return xerrors.Errorf("counting unrecovered sectors: %w", err)
+			}
+
+			if uc == 0 {
+				log.Debugw("WdPostRecoverDeclareTask.processHeadChange() uc == 0, skipping", "maddr", maddr, "declDeadline", declDeadline, "pidx", pidx)
+				continue
+			}
+
+			tid := wdTaskIdentity{
+				SpID:               aid,
+				ProvingPeriodStart: pps,
+				DeadlineIndex:      declDeadline,
+				PartitionIndex:     uint64(pidx),
+			}
+
+			tf(func(id harmonytask.TaskID, tx *harmonydb.Tx) (bool, error) {
+				return w.addTaskToDB(id, tid, tx)
+			})
+		}
+	}
+
+	return nil
+}
+
+func (w *WdPostRecoverDeclareTask) addTaskToDB(taskId harmonytask.TaskID, taskIdent wdTaskIdentity, tx *harmonydb.Tx) (bool, error) {
+	_, err := tx.Exec(
+		`INSERT INTO wdpost_recovery_tasks (
+                         task_id,
+                          sp_id,
+                          proving_period_start,
+                          deadline_index,
+                          partition_index
+                        ) VALUES ($1, $2, $3, $4, $5)`,
+		taskId,
+		taskIdent.SpID,
+		taskIdent.ProvingPeriodStart,
+		taskIdent.DeadlineIndex,
+		taskIdent.PartitionIndex,
+	)
+	if err != nil {
+		return false, xerrors.Errorf("insert partition task: %w", err)
+	}
+
+	return true, nil
+}
+
+var _ harmonytask.TaskInterface = &WdPostRecoverDeclareTask{}
diff --git a/provider/lpwindow/submit_task.go b/provider/lpwindow/submit_task.go
new file mode 100644
index 000000000..72f2499f6
--- /dev/null
+++ b/provider/lpwindow/submit_task.go
@@ -0,0 +1,305 @@
+package lpwindow
+
+import (
+	"bytes"
+	"context"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/builtin"
+	"github.com/filecoin-project/go-state-types/builtin/v9/miner"
+	"github.com/filecoin-project/go-state-types/crypto"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonytask"
+	"github.com/filecoin-project/lotus/lib/harmony/resources"
+	"github.com/filecoin-project/lotus/lib/promise"
+	"github.com/filecoin-project/lotus/provider/chainsched"
+	"github.com/filecoin-project/lotus/provider/lpmessage"
+	"github.com/filecoin-project/lotus/storage/ctladdr"
+	"github.com/filecoin-project/lotus/storage/wdpost"
+)
+
+type WdPoStSubmitTaskApi interface {
+	ChainHead(context.Context) (*types.TipSet, error)
+
+	WalletBalance(context.Context, address.Address) (types.BigInt, error)
+	WalletHas(context.Context, address.Address) (bool, error)
+
+	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (api.MinerInfo, error)
+	StateGetRandomnessFromTickets(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error)
+
+	GasEstimateMessageGas(context.Context, *types.Message, *api.MessageSendSpec, types.TipSetKey) (*types.Message, error)
+	GasEstimateFeeCap(context.Context, *types.Message, int64, types.TipSetKey) (types.BigInt, error)
+	GasEstimateGasPremium(_ context.Context, nblocksincl uint64, sender address.Address, gaslimit int64, tsk types.TipSetKey) (types.BigInt, error)
+}
+
+type WdPostSubmitTask struct {
+	sender *lpmessage.Sender
+	db     *harmonydb.DB
+	api    WdPoStSubmitTaskApi
+
+	maxWindowPoStGasFee types.FIL
+	as                  *ctladdr.AddressSelector
+
+	submitPoStTF promise.Promise[harmonytask.AddTaskFunc]
+}
+
+func NewWdPostSubmitTask(pcs *chainsched.ProviderChainSched, send *lpmessage.Sender, db *harmonydb.DB, api WdPoStSubmitTaskApi, maxWindowPoStGasFee types.FIL, as *ctladdr.AddressSelector) (*WdPostSubmitTask, error) {
+	res := &WdPostSubmitTask{
+		sender: send,
+		db:     db,
+		api:    api,
+
+		maxWindowPoStGasFee: maxWindowPoStGasFee,
+		as:                  as,
+	}
+
+	if err := pcs.AddHandler(res.processHeadChange); err != nil {
+		return nil, err
+	}
+
+	return res, nil
+}
+
+func (w *WdPostSubmitTask) Do(taskID harmonytask.TaskID, stillOwned func() bool) (done bool, err error) {
+	log.Debugw("WdPostSubmitTask.Do", "taskID", taskID)
+
+	var spID uint64
+	var deadline uint64
+	var partition uint64
+	var pps, submitAtEpoch, submitByEpoch abi.ChainEpoch
+	var earlyParamBytes []byte
+	var dbTask uint64
+
+	err = w.db.QueryRow(
+		context.Background(), `SELECT sp_id, proving_period_start, deadline, partition, submit_at_epoch, submit_by_epoch, proof_params, submit_task_id
+		FROM wdpost_proofs WHERE submit_task_id = $1`, taskID,
+	).Scan(&spID, &pps, &deadline, &partition, &submitAtEpoch, &submitByEpoch, &earlyParamBytes, &dbTask)
+	if err != nil {
+		return false, xerrors.Errorf("query post proof: %w", err)
+	}
+
+	if dbTask != uint64(taskID) {
+		return false, xerrors.Errorf("taskID mismatch: %d != %d", dbTask, taskID)
+	}
+
+	head, err := w.api.ChainHead(context.Background())
+	if err != nil {
+		return false, xerrors.Errorf("getting chain head: %w", err)
+	}
+
+	if head.Height() > submitByEpoch {
+		// we missed the deadline, no point in submitting
+		log.Errorw("missed submit deadline", "spID", spID, "deadline", deadline, "partition", partition, "submitByEpoch", submitByEpoch, "headHeight", head.Height())
+		return true, nil
+	}
+
+	if head.Height() < submitAtEpoch {
+		log.Errorw("submit epoch not reached", "spID", spID, "deadline", deadline, "partition", partition, "submitAtEpoch", submitAtEpoch, "headHeight", head.Height())
+		return false, xerrors.Errorf("submit epoch not reached: %d < %d", head.Height(), submitAtEpoch)
+	}
+
+	dlInfo := wdpost.NewDeadlineInfo(pps, deadline, head.Height())
+
+	var params miner.SubmitWindowedPoStParams
+	if err := params.UnmarshalCBOR(bytes.NewReader(earlyParamBytes)); err != nil {
+		return false, xerrors.Errorf("unmarshaling proof message: %w", err)
+	}
+
+	commEpoch := dlInfo.Challenge
+
+	commRand, err := w.api.StateGetRandomnessFromTickets(context.Background(), crypto.DomainSeparationTag_PoStChainCommit, commEpoch, nil, head.Key())
+	if err != nil {
+		err = xerrors.Errorf("failed to get chain randomness from tickets for windowPost (epoch=%d): %w", commEpoch, err)
+		log.Errorf("submitPoStMessage failed: %+v", err)
+
+		return false, xerrors.Errorf("getting post commit randomness: %w", err)
+	}
+
+	params.ChainCommitEpoch = commEpoch
+	params.ChainCommitRand = commRand
+
+	var pbuf bytes.Buffer
+	if err := params.MarshalCBOR(&pbuf); err != nil {
+		return false, xerrors.Errorf("marshaling proof message: %w", err)
+	}
+
+	maddr, err := address.NewIDAddress(spID)
+	if err != nil {
+		return false, xerrors.Errorf("invalid miner address: %w", err)
+	}
+
+	msg := &types.Message{
+		To:     maddr,
+		Method: builtin.MethodsMiner.SubmitWindowedPoSt,
+		Params: pbuf.Bytes(),
+		Value:  big.Zero(),
+	}
+
+	msg, mss, err := preparePoStMessage(w.api, w.as, maddr, msg, abi.TokenAmount(w.maxWindowPoStGasFee))
+	if err != nil {
+		return false, xerrors.Errorf("preparing proof message: %w", err)
+	}
+
+	ctx := context.Background()
+	smsg, err := w.sender.Send(ctx, msg, mss, "wdpost")
+	if err != nil {
+		return false, xerrors.Errorf("sending proof message: %w", err)
+	}
+
+	// set message_cid in the wdpost_proofs entry
+
+	_, err = w.db.Exec(ctx, `UPDATE wdpost_proofs SET message_cid = $1 WHERE sp_id = $2 AND proving_period_start = $3 AND deadline = $4 AND partition = $5`, smsg.String(), spID, pps, deadline, partition)
+	if err != nil {
+		return true, xerrors.Errorf("updating wdpost_proofs: %w", err)
+	}
+
+	return true, nil
+}
+
+func (w *WdPostSubmitTask) CanAccept(ids []harmonytask.TaskID, engine *harmonytask.TaskEngine) (*harmonytask.TaskID, error) {
+	if len(ids) == 0 {
+		// probably can't happen, but panicking is bad
+		return nil, nil
+	}
+
+	if w.sender == nil {
+		// we can't send messages
+		return nil, nil
+	}
+
+	return &ids[0], nil
+}
+
+func (w *WdPostSubmitTask) TypeDetails() harmonytask.TaskTypeDetails {
+	return harmonytask.TaskTypeDetails{
+		Max:  128,
+		Name: "WdPostSubmit",
+		Cost: resources.Resources{
+			Cpu: 0,
+			Gpu: 0,
+			Ram: 10 << 20,
+		},
+		MaxFailures: 10,
+		Follows:     nil, // ??
+	}
+}
+
+func (w *WdPostSubmitTask) Adder(taskFunc harmonytask.AddTaskFunc) {
+	w.submitPoStTF.Set(taskFunc)
+}
+
+func (w *WdPostSubmitTask) processHeadChange(ctx context.Context, revert, apply *types.TipSet) error {
+	tf := w.submitPoStTF.Val(ctx)
+
+	qry, err := w.db.Query(ctx, `SELECT sp_id, proving_period_start, deadline, partition, submit_at_epoch FROM wdpost_proofs WHERE submit_task_id IS NULL AND submit_at_epoch <= $1`, apply.Height())
+	if err != nil {
+		return err
+	}
+	defer qry.Close()
+
+	for qry.Next() {
+		var spID int64
+		var pps int64
+		var deadline uint64
+		var partition uint64
+		var submitAtEpoch uint64
+		if err := qry.Scan(&spID, &pps, &deadline, &partition, &submitAtEpoch); err != nil {
+			return xerrors.Errorf("scan submittable posts: %w", err)
+		}
+
+		tf(func(id harmonytask.TaskID, tx *harmonydb.Tx) (shouldCommit bool, err error) {
+			// update in transaction iff submit_task_id is still null
+			res, err := tx.Exec(`UPDATE wdpost_proofs SET submit_task_id = $1 WHERE sp_id = $2 AND proving_period_start = $3 AND deadline = $4 AND partition = $5 AND submit_task_id IS NULL`, id, spID, pps, deadline, partition)
+			if err != nil {
+				return false, xerrors.Errorf("query ready proof: %w", err)
+			}
+			if res != 1 {
+				return false, nil
+			}
+
+			return true, nil
+		})
+	}
+	if err := qry.Err(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+type MsgPrepAPI interface {
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (api.MinerInfo, error)
+	GasEstimateMessageGas(context.Context, *types.Message, *api.MessageSendSpec, types.TipSetKey) (*types.Message, error)
+	GasEstimateFeeCap(context.Context, *types.Message, int64, types.TipSetKey) (types.BigInt, error)
+	GasEstimateGasPremium(ctx context.Context, nblocksincl uint64, sender address.Address, gaslimit int64, tsk types.TipSetKey) (types.BigInt, error)
+
+	WalletBalance(context.Context, address.Address) (types.BigInt, error)
+	WalletHas(context.Context, address.Address) (bool, error)
+	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+}
+
+func preparePoStMessage(w MsgPrepAPI, as *ctladdr.AddressSelector, maddr address.Address, msg *types.Message, maxFee abi.TokenAmount) (*types.Message, *api.MessageSendSpec, error) {
+	mi, err := w.StateMinerInfo(context.Background(), maddr, types.EmptyTSK)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("error getting miner info: %w", err)
+	}
+
+	// set the worker as a fallback
+	msg.From = mi.Worker
+
+	mss := &api.MessageSendSpec{
+		MaxFee: maxFee,
+	}
+
+	// (optimal) initial estimation with some overestimation that guarantees
+	// block inclusion within the next 20 tipsets.
+	gm, err := w.GasEstimateMessageGas(context.Background(), msg, mss, types.EmptyTSK)
+	if err != nil {
+		log.Errorw("estimating gas", "error", err)
+		return nil, nil, xerrors.Errorf("estimating gas: %w", err)
+	}
+	*msg = *gm
+
+	// calculate a more frugal estimation; premium is estimated to guarantee
+	// inclusion within 5 tipsets, and fee cap is estimated for inclusion
+	// within 4 tipsets.
+	minGasFeeMsg := *msg
+
+	minGasFeeMsg.GasPremium, err = w.GasEstimateGasPremium(context.Background(), 5, msg.From, msg.GasLimit, types.EmptyTSK)
+	if err != nil {
+		log.Errorf("failed to estimate minimum gas premium: %+v", err)
+		minGasFeeMsg.GasPremium = msg.GasPremium
+	}
+
+	minGasFeeMsg.GasFeeCap, err = w.GasEstimateFeeCap(context.Background(), &minGasFeeMsg, 4, types.EmptyTSK)
+	if err != nil {
+		log.Errorf("failed to estimate minimum gas fee cap: %+v", err)
+		minGasFeeMsg.GasFeeCap = msg.GasFeeCap
+	}
+
+	// goodFunds = funds needed for optimal inclusion probability.
+	// minFunds  = funds needed for more speculative inclusion probability.
+	goodFunds := big.Add(minGasFeeMsg.RequiredFunds(), minGasFeeMsg.Value)
+	minFunds := big.Min(big.Add(minGasFeeMsg.RequiredFunds(), minGasFeeMsg.Value), goodFunds)
+
+	from, _, err := as.AddressFor(context.Background(), w, mi, api.PoStAddr, goodFunds, minFunds)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("error getting address: %w", err)
+	}
+
+	msg.From = from
+
+	return msg, mss, nil
+}
+
+var _ harmonytask.TaskInterface = &WdPostSubmitTask{}
diff --git a/provider/lpwinning/winning_task.go b/provider/lpwinning/winning_task.go
new file mode 100644
index 000000000..907b594fd
--- /dev/null
+++ b/provider/lpwinning/winning_task.go
@@ -0,0 +1,671 @@
+package lpwinning
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"encoding/binary"
+	"encoding/json"
+	"time"
+
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+	"golang.org/x/xerrors"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/network"
+	prooftypes "github.com/filecoin-project/go-state-types/proof"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/gen"
+	lrand "github.com/filecoin-project/lotus/chain/rand"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonytask"
+	"github.com/filecoin-project/lotus/lib/harmony/resources"
+	"github.com/filecoin-project/lotus/lib/promise"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/filecoin-project/lotus/storage/sealer/storiface"
+)
+
+var log = logging.Logger("lpwinning")
+
+type WinPostTask struct {
+	max int
+	db  *harmonydb.DB
+
+	prover   ProverWinningPoSt
+	verifier storiface.Verifier
+
+	api    WinPostAPI
+	actors []dtypes.MinerAddress
+
+	mineTF promise.Promise[harmonytask.AddTaskFunc]
+}
+
+type WinPostAPI interface {
+	ChainHead(context.Context) (*types.TipSet, error)
+	ChainTipSetWeight(context.Context, types.TipSetKey) (types.BigInt, error)
+	ChainGetTipSet(context.Context, types.TipSetKey) (*types.TipSet, error)
+
+	StateGetBeaconEntry(context.Context, abi.ChainEpoch) (*types.BeaconEntry, error)
+	SyncSubmitBlock(context.Context, *types.BlockMsg) error
+	StateGetRandomnessFromBeacon(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error)
+	StateGetRandomnessFromTickets(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error)
+	StateNetworkVersion(context.Context, types.TipSetKey) (network.Version, error)
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (api.MinerInfo, error)
+
+	MinerGetBaseInfo(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*api.MiningBaseInfo, error)
+	MinerCreateBlock(context.Context, *api.BlockTemplate) (*types.BlockMsg, error)
+	MpoolSelect(context.Context, types.TipSetKey, float64) ([]*types.SignedMessage, error)
+
+	WalletSign(context.Context, address.Address, []byte) (*crypto.Signature, error)
+}
+
+type ProverWinningPoSt interface {
+	GenerateWinningPoSt(ctx context.Context, ppt abi.RegisteredPoStProof, minerID abi.ActorID, sectorInfo []storiface.PostSectorChallenge, randomness abi.PoStRandomness) ([]prooftypes.PoStProof, error)
+}
+
+func NewWinPostTask(max int, db *harmonydb.DB, prover ProverWinningPoSt, verifier storiface.Verifier, api WinPostAPI, actors []dtypes.MinerAddress) *WinPostTask {
+	t := &WinPostTask{
+		max:      max,
+		db:       db,
+		prover:   prover,
+		verifier: verifier,
+		api:      api,
+		actors:   actors,
+	}
+	// TODO: run warmup
+
+	go t.mineBasic(context.TODO())
+
+	return t
+}
+
+func (t *WinPostTask) Do(taskID harmonytask.TaskID, stillOwned func() bool) (done bool, err error) {
+	log.Debugw("WinPostTask.Do()", "taskID", taskID)
+
+	ctx := context.TODO()
+
+	type BlockCID struct {
+		CID string
+	}
+
+	type MiningTaskDetails struct {
+		SpID      uint64
+		Epoch     uint64
+		BlockCIDs []BlockCID
+		CompTime  time.Time
+	}
+
+	var details MiningTaskDetails
+
+	// First query to fetch from mining_tasks
+	err = t.db.QueryRow(ctx, `SELECT sp_id, epoch, base_compute_time FROM mining_tasks WHERE task_id = $1`, taskID).Scan(&details.SpID, &details.Epoch, &details.CompTime)
+	if err != nil {
+		return false, err
+	}
+
+	// Second query to fetch from mining_base_block
+	rows, err := t.db.Query(ctx, `SELECT block_cid FROM mining_base_block WHERE task_id = $1`, taskID)
+	if err != nil {
+		return false, err
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var cid BlockCID
+		if err := rows.Scan(&cid.CID); err != nil {
+			return false, err
+		}
+		details.BlockCIDs = append(details.BlockCIDs, cid)
+	}
+
+	if err := rows.Err(); err != nil {
+		return false, err
+	}
+
+	// construct base
+	maddr, err := address.NewIDAddress(details.SpID)
+	if err != nil {
+		return false, err
+	}
+
+	var bcids []cid.Cid
+	for _, c := range details.BlockCIDs {
+		bcid, err := cid.Parse(c.CID)
+		if err != nil {
+			return false, err
+		}
+		bcids = append(bcids, bcid)
+	}
+
+	tsk := types.NewTipSetKey(bcids...)
+	baseTs, err := t.api.ChainGetTipSet(ctx, tsk)
+	if err != nil {
+		return false, xerrors.Errorf("loading base tipset: %w", err)
+	}
+
+	base := MiningBase{
+		TipSet:      baseTs,
+		AddRounds:   abi.ChainEpoch(details.Epoch) - baseTs.Height() - 1,
+		ComputeTime: details.CompTime,
+	}
+
+	persistNoWin := func() error {
+		_, err := t.db.Exec(ctx, `UPDATE mining_base_block SET no_win = true WHERE task_id = $1`, taskID)
+		if err != nil {
+			return xerrors.Errorf("marking base as not-won: %w", err)
+		}
+
+		return nil
+	}
+
+	// ensure we have a beacon entry for the epoch we're mining on
+	round := base.epoch()
+
+	_ = retry1(func() (*types.BeaconEntry, error) {
+		return t.api.StateGetBeaconEntry(ctx, round)
+	})
+
+	// MAKE A MINING ATTEMPT!!
+	log.Debugw("attempting to mine a block", "tipset", types.LogCids(base.TipSet.Cids()))
+
+	mbi, err := t.api.MinerGetBaseInfo(ctx, maddr, round, base.TipSet.Key())
+	if err != nil {
+		return false, xerrors.Errorf("failed to get mining base info: %w", err)
+	}
+	if mbi == nil {
+		// not eligible to mine on this base, we're done here
+		log.Debugw("WinPoSt not eligible to mine on this base", "tipset", types.LogCids(base.TipSet.Cids()))
+		return true, persistNoWin()
+	}
+
+	if !mbi.EligibleForMining {
+		// slashed or just have no power yet, we're done here
+		log.Debugw("WinPoSt not eligible for mining", "tipset", types.LogCids(base.TipSet.Cids()))
+		return true, persistNoWin()
+	}
+
+	if len(mbi.Sectors) == 0 {
+		log.Warnw("WinPoSt no sectors to mine", "tipset", types.LogCids(base.TipSet.Cids()))
+		return false, xerrors.Errorf("no sectors selected for winning PoSt")
+	}
+
+	var rbase types.BeaconEntry
+	var bvals []types.BeaconEntry
+	var eproof *types.ElectionProof
+
+	// winner check
+	{
+		bvals = mbi.BeaconEntries
+		rbase = mbi.PrevBeaconEntry
+		if len(bvals) > 0 {
+			rbase = bvals[len(bvals)-1]
+		}
+
+		eproof, err = gen.IsRoundWinner(ctx, round, maddr, rbase, mbi, t.api)
+		if err != nil {
+			log.Warnw("WinPoSt failed to check if we win next round", "error", err)
+			return false, xerrors.Errorf("failed to check if we win next round: %w", err)
+		}
+
+		if eproof == nil {
+			// not a winner, we're done here
+			log.Debugw("WinPoSt not a winner", "tipset", types.LogCids(base.TipSet.Cids()))
+			return true, persistNoWin()
+		}
+	}
+
+	// winning PoSt
+	var wpostProof []prooftypes.PoStProof
+	{
+		buf := new(bytes.Buffer)
+		if err := maddr.MarshalCBOR(buf); err != nil {
+			err = xerrors.Errorf("failed to marshal miner address: %w", err)
+			return false, err
+		}
+
+		brand, err := lrand.DrawRandomnessFromBase(rbase.Data, crypto.DomainSeparationTag_WinningPoStChallengeSeed, round, buf.Bytes())
+		if err != nil {
+			err = xerrors.Errorf("failed to get randomness for winning post: %w", err)
+			return false, err
+		}
+
+		prand := abi.PoStRandomness(brand)
+		prand[31] &= 0x3f // make into fr
+
+		sectorNums := make([]abi.SectorNumber, len(mbi.Sectors))
+		for i, s := range mbi.Sectors {
+			sectorNums[i] = s.SectorNumber
+		}
+
+		ppt, err := mbi.Sectors[0].SealProof.RegisteredWinningPoStProof()
+		if err != nil {
+			return false, xerrors.Errorf("mapping sector seal proof type to post proof type: %w", err)
+		}
+
+		postChallenges, err := ffi.GeneratePoStFallbackSectorChallenges(ppt, abi.ActorID(details.SpID), prand, sectorNums)
+		if err != nil {
+			return false, xerrors.Errorf("generating election challenges: %v", err)
+		}
+
+		sectorChallenges := make([]storiface.PostSectorChallenge, len(mbi.Sectors))
+		for i, s := range mbi.Sectors {
+			sectorChallenges[i] = storiface.PostSectorChallenge{
+				SealProof:    s.SealProof,
+				SectorNumber: s.SectorNumber,
+				SealedCID:    s.SealedCID,
+				Challenge:    postChallenges.Challenges[s.SectorNumber],
+				Update:       s.SectorKey != nil,
+			}
+		}
+
+		wpostProof, err = t.prover.GenerateWinningPoSt(ctx, ppt, abi.ActorID(details.SpID), sectorChallenges, prand)
+		if err != nil {
+			err = xerrors.Errorf("failed to compute winning post proof: %w", err)
+			return false, err
+		}
+	}
+
+	ticket, err := t.computeTicket(ctx, maddr, &rbase, round, base.TipSet.MinTicket(), mbi)
+	if err != nil {
+		return false, xerrors.Errorf("scratching ticket failed: %w", err)
+	}
+
+	// get pending messages early,
+	msgs, err := t.api.MpoolSelect(ctx, base.TipSet.Key(), ticket.Quality())
+	if err != nil {
+		return false, xerrors.Errorf("failed to select messages for block: %w", err)
+	}
+
+	// equivocation handling
+	{
+		// This next block exists to "catch" equivocating miners,
+		// who submit 2 blocks at the same height at different times in order to split the network.
+		// To safeguard against this, we make sure it's been EquivocationDelaySecs since our base was calculated,
+		// then re-calculate it.
+		// If the daemon detected equivocated blocks, those blocks will no longer be in the new base.
+		time.Sleep(time.Until(base.ComputeTime.Add(time.Duration(build.EquivocationDelaySecs) * time.Second)))
+
+		bestTs, err := t.api.ChainHead(ctx)
+		if err != nil {
+			return false, xerrors.Errorf("failed to get chain head: %w", err)
+		}
+
+		headWeight, err := t.api.ChainTipSetWeight(ctx, bestTs.Key())
+		if err != nil {
+			return false, xerrors.Errorf("failed to get chain head weight: %w", err)
+		}
+
+		baseWeight, err := t.api.ChainTipSetWeight(ctx, base.TipSet.Key())
+		if err != nil {
+			return false, xerrors.Errorf("failed to get base weight: %w", err)
+		}
+		if types.BigCmp(headWeight, baseWeight) <= 0 {
+			bestTs = base.TipSet
+		}
+
+		// If the base has changed, we take the _intersection_ of our old base and new base,
+		// thus ejecting blocks from any equivocating miners, without taking any new blocks.
+		if bestTs.Height() == base.TipSet.Height() && !bestTs.Equals(base.TipSet) {
+			log.Warnf("base changed from %s to %s, taking intersection", base.TipSet.Key(), bestTs.Key())
+			newBaseMap := map[cid.Cid]struct{}{}
+			for _, newBaseBlk := range bestTs.Cids() {
+				newBaseMap[newBaseBlk] = struct{}{}
+			}
+
+			refreshedBaseBlocks := make([]*types.BlockHeader, 0, len(base.TipSet.Cids()))
+			for _, baseBlk := range base.TipSet.Blocks() {
+				if _, ok := newBaseMap[baseBlk.Cid()]; ok {
+					refreshedBaseBlocks = append(refreshedBaseBlocks, baseBlk)
+				}
+			}
+
+			if len(refreshedBaseBlocks) != 0 && len(refreshedBaseBlocks) != len(base.TipSet.Blocks()) {
+				refreshedBase, err := types.NewTipSet(refreshedBaseBlocks)
+				if err != nil {
+					return false, xerrors.Errorf("failed to create new tipset when refreshing: %w", err)
+				}
+
+				if !base.TipSet.MinTicket().Equals(refreshedBase.MinTicket()) {
+					log.Warn("recomputing ticket due to base refresh")
+
+					ticket, err = t.computeTicket(ctx, maddr, &rbase, round, refreshedBase.MinTicket(), mbi)
+					if err != nil {
+						return false, xerrors.Errorf("failed to refresh ticket: %w", err)
+					}
+				}
+
+				log.Warn("re-selecting messages due to base refresh")
+				// refresh messages, as the selected messages may no longer be valid
+				msgs, err = t.api.MpoolSelect(ctx, refreshedBase.Key(), ticket.Quality())
+				if err != nil {
+					return false, xerrors.Errorf("failed to re-select messages for block: %w", err)
+				}
+
+				base.TipSet = refreshedBase
+			}
+		}
+	}
+
+	// block construction
+	var blockMsg *types.BlockMsg
+	{
+		uts := base.TipSet.MinTimestamp() + build.BlockDelaySecs*(uint64(base.AddRounds)+1)
+
+		blockMsg, err = t.api.MinerCreateBlock(context.TODO(), &api.BlockTemplate{
+			Miner:            maddr,
+			Parents:          base.TipSet.Key(),
+			Ticket:           ticket,
+			Eproof:           eproof,
+			BeaconValues:     bvals,
+			Messages:         msgs,
+			Epoch:            round,
+			Timestamp:        uts,
+			WinningPoStProof: wpostProof,
+		})
+		if err != nil {
+			return false, xerrors.Errorf("failed to create block: %w", err)
+		}
+	}
+
+	// persist in db
+	{
+		bhjson, err := json.Marshal(blockMsg.Header)
+		if err != nil {
+			return false, xerrors.Errorf("failed to marshal block header: %w", err)
+		}
+
+		_, err = t.db.Exec(ctx, `UPDATE mining_tasks
+            SET won = true, mined_cid = $2, mined_header = $3, mined_at = $4
+            WHERE task_id = $1`, taskID, blockMsg.Header.Cid(), string(bhjson), time.Now().UTC())
+		if err != nil {
+			return false, xerrors.Errorf("failed to update mining task: %w", err)
+		}
+	}
+
+	// wait until block timestamp
+	{
+		time.Sleep(time.Until(time.Unix(int64(blockMsg.Header.Timestamp), 0)))
+	}
+
+	// submit block!!
+	{
+		if err := t.api.SyncSubmitBlock(ctx, blockMsg); err != nil {
+			return false, xerrors.Errorf("failed to submit block: %w", err)
+		}
+	}
+
+	log.Infow("mined a block", "tipset", types.LogCids(blockMsg.Header.Parents), "height", blockMsg.Header.Height, "miner", maddr, "cid", blockMsg.Header.Cid())
+
+	// persist that we've submitted the block
+	{
+		_, err = t.db.Exec(ctx, `UPDATE mining_tasks
+		SET submitted_at = $2
+		WHERE task_id = $1`, taskID, time.Now().UTC())
+		if err != nil {
+			return false, xerrors.Errorf("failed to update mining task: %w", err)
+		}
+	}
+
+	return true, nil
+}
+
+func (t *WinPostTask) CanAccept(ids []harmonytask.TaskID, engine *harmonytask.TaskEngine) (*harmonytask.TaskID, error) {
+	if len(ids) == 0 {
+		// probably can't happen, but panicking is bad
+		return nil, nil
+	}
+
+	// select lowest epoch
+	var lowestEpoch abi.ChainEpoch
+	var lowestEpochID = ids[0]
+	for _, id := range ids {
+		var epoch uint64
+		err := t.db.QueryRow(context.Background(), `SELECT epoch FROM mining_tasks WHERE task_id = $1`, id).Scan(&epoch)
+		if err != nil {
+			return nil, err
+		}
+
+		if lowestEpoch == 0 || abi.ChainEpoch(epoch) < lowestEpoch {
+			lowestEpoch = abi.ChainEpoch(epoch)
+			lowestEpochID = id
+		}
+	}
+
+	return &lowestEpochID, nil
+}
+
+func (t *WinPostTask) TypeDetails() harmonytask.TaskTypeDetails {
+	return harmonytask.TaskTypeDetails{
+		Name:        "WinPost",
+		Max:         t.max,
+		MaxFailures: 3,
+		Follows:     nil,
+		Cost: resources.Resources{
+			Cpu: 1,
+
+			// todo set to something for 32/64G sector sizes? Technically windowPoSt is happy on a CPU
+			//  but it will use a GPU if available
+			Gpu: 0,
+
+			Ram: 1 << 30, // todo arbitrary number
+		},
+	}
+}
+
+func (t *WinPostTask) Adder(taskFunc harmonytask.AddTaskFunc) {
+	t.mineTF.Set(taskFunc)
+}
+
+// MiningBase is the tipset on top of which we plan to construct our next block.
+// Refer to godocs on GetBestMiningCandidate.
+type MiningBase struct {
+	TipSet      *types.TipSet
+	ComputeTime time.Time
+	AddRounds   abi.ChainEpoch
+}
+
+func (mb MiningBase) epoch() abi.ChainEpoch {
+	// return the epoch that will result from mining on this base
+	return mb.TipSet.Height() + mb.AddRounds + 1
+}
+
+func (mb MiningBase) baseTime() time.Time {
+	tsTime := time.Unix(int64(mb.TipSet.MinTimestamp()), 0)
+	roundDelay := build.BlockDelaySecs * uint64(mb.AddRounds+1)
+	tsTime = tsTime.Add(time.Duration(roundDelay) * time.Second)
+	return tsTime
+}
+
+func (mb MiningBase) afterPropDelay() time.Time {
+	return mb.baseTime().Add(randTimeOffset(time.Second))
+}
+
+func (t *WinPostTask) mineBasic(ctx context.Context) {
+	var workBase MiningBase
+
+	taskFn := t.mineTF.Val(ctx)
+
+	// initialize workbase
+	{
+		head := retry1(func() (*types.TipSet, error) {
+			return t.api.ChainHead(ctx)
+		})
+
+		workBase = MiningBase{
+			TipSet:      head,
+			AddRounds:   0,
+			ComputeTime: time.Now(),
+		}
+	}
+
+	/*
+
+		         /- T+0 == workBase.baseTime
+		         |
+		>--------*------*--------[wait until next round]----->
+		                |
+		                |- T+PD == workBase.afterPropDelay+(~1s)
+		                |- Here we acquire the new workBase, and start a new round task
+		                \- Then we loop around, and wait for the next head
+
+		time -->
+	*/
+
+	for {
+		// limit the rate at which we mine blocks to at least EquivocationDelaySecs
+		// this is to prevent races on devnets in catch up mode. Acts as a minimum
+		// delay for the sleep below.
+		time.Sleep(time.Duration(build.EquivocationDelaySecs)*time.Second + time.Second)
+
+		// wait for *NEXT* propagation delay
+		time.Sleep(time.Until(workBase.afterPropDelay()))
+
+		// check current best candidate
+		maybeBase := retry1(func() (*types.TipSet, error) {
+			return t.api.ChainHead(ctx)
+		})
+
+		if workBase.TipSet.Equals(maybeBase) {
+			// workbase didn't change in the new round so we have a null round here
+			workBase.AddRounds++
+			log.Debugw("workbase update", "tipset", workBase.TipSet.Cids(), "nulls", workBase.AddRounds, "lastUpdate", time.Since(workBase.ComputeTime), "type", "same-tipset")
+		} else {
+			btsw := retry1(func() (types.BigInt, error) {
+				return t.api.ChainTipSetWeight(ctx, maybeBase.Key())
+			})
+
+			ltsw := retry1(func() (types.BigInt, error) {
+				return t.api.ChainTipSetWeight(ctx, workBase.TipSet.Key())
+			})
+
+			if types.BigCmp(btsw, ltsw) <= 0 {
+				// new tipset for some reason has less weight than the old one, assume null round here
+				// NOTE: the backing node may have reorged, or manually changed head
+				workBase.AddRounds++
+				log.Debugw("workbase update", "tipset", workBase.TipSet.Cids(), "nulls", workBase.AddRounds, "lastUpdate", time.Since(workBase.ComputeTime), "type", "prefer-local-weight")
+			} else {
+				// new tipset has more weight, so we should mine on it, no null round here
+				log.Debugw("workbase update", "tipset", workBase.TipSet.Cids(), "nulls", workBase.AddRounds, "lastUpdate", time.Since(workBase.ComputeTime), "type", "prefer-new-tipset")
+
+				workBase = MiningBase{
+					TipSet:      maybeBase,
+					AddRounds:   0,
+					ComputeTime: time.Now(),
+				}
+			}
+		}
+
+		// dispatch mining task
+		// (note equivocation prevention is handled by the mining code)
+
+		baseEpoch := workBase.TipSet.Height()
+
+		for _, act := range t.actors {
+			spID, err := address.IDFromAddress(address.Address(act))
+			if err != nil {
+				log.Errorf("failed to get spID from address %s: %s", act, err)
+				continue
+			}
+
+			taskFn(func(id harmonytask.TaskID, tx *harmonydb.Tx) (shouldCommit bool, seriousError error) {
+				// First we check if the mining base includes blocks we may have mined previously to avoid getting slashed
+				// select mining_tasks where epoch==base_epoch if win=true to maybe get base block cid which has to be included in our tipset
+				var baseBlockCids []string
+				err := tx.Select(&baseBlockCids, `SELECT mined_cid FROM mining_tasks WHERE epoch = $1 AND sp_id = $2 AND won = true`, baseEpoch, spID)
+				if err != nil {
+					return false, xerrors.Errorf("querying mining_tasks: %w", err)
+				}
+				if len(baseBlockCids) >= 1 {
+					baseBlockCid := baseBlockCids[0]
+					c, err := cid.Parse(baseBlockCid)
+					if err != nil {
+						return false, xerrors.Errorf("parsing mined_cid: %w", err)
+					}
+
+					// we have mined in the previous round, make sure that our block is included in the tipset
+					// if it's not we risk getting slashed
+
+					var foundOurs bool
+					for _, c2 := range workBase.TipSet.Cids() {
+						if c == c2 {
+							foundOurs = true
+							break
+						}
+					}
+					if !foundOurs {
+						log.Errorw("our block was not included in the tipset, aborting", "tipset", workBase.TipSet.Cids(), "ourBlock", c)
+						return false, xerrors.Errorf("our block was not included in the tipset, aborting")
+					}
+				}
+
+				_, err = tx.Exec(`INSERT INTO mining_tasks (task_id, sp_id, epoch, base_compute_time) VALUES ($1, $2, $3, $4)`, id, spID, workBase.epoch(), workBase.ComputeTime.UTC())
+				if err != nil {
+					return false, xerrors.Errorf("inserting mining_tasks: %w", err)
+				}
+
+				for _, c := range workBase.TipSet.Cids() {
+					_, err = tx.Exec(`INSERT INTO mining_base_block (task_id, sp_id, block_cid) VALUES ($1, $2, $3)`, id, spID, c)
+					if err != nil {
+						return false, xerrors.Errorf("inserting mining base blocks: %w", err)
+					}
+				}
+
+				return true, nil // no errors, commit the transaction
+			})
+		}
+	}
+}
+
+func (t *WinPostTask) computeTicket(ctx context.Context, maddr address.Address, brand *types.BeaconEntry, round abi.ChainEpoch, chainRand *types.Ticket, mbi *api.MiningBaseInfo) (*types.Ticket, error) {
+	buf := new(bytes.Buffer)
+	if err := maddr.MarshalCBOR(buf); err != nil {
+		return nil, xerrors.Errorf("failed to marshal address to cbor: %w", err)
+	}
+
+	if round > build.UpgradeSmokeHeight {
+		buf.Write(chainRand.VRFProof)
+	}
+
+	input, err := lrand.DrawRandomnessFromBase(brand.Data, crypto.DomainSeparationTag_TicketProduction, round-build.TicketRandomnessLookback, buf.Bytes())
+	if err != nil {
+		return nil, err
+	}
+
+	vrfOut, err := gen.ComputeVRF(ctx, t.api.WalletSign, mbi.WorkerKey, input)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.Ticket{
+		VRFProof: vrfOut,
+	}, nil
+}
+
+func randTimeOffset(width time.Duration) time.Duration {
+	buf := make([]byte, 8)
+	rand.Reader.Read(buf) //nolint:errcheck
+	val := time.Duration(binary.BigEndian.Uint64(buf) % uint64(width))
+
+	return val - (width / 2)
+}
+
+func retry1[R any](f func() (R, error)) R {
+	for {
+		r, err := f()
+		if err == nil {
+			return r
+		}
+
+		log.Errorw("error in mining loop, retrying", "error", err)
+		time.Sleep(time.Second)
+	}
+}
+
+var _ harmonytask.TaskInterface = &WinPostTask{}
diff --git a/scripts/generate-lotus-cli.py b/scripts/generate-lotus-cli.py
index b0d3fd19d..1e1fee9a6 100644
--- a/scripts/generate-lotus-cli.py
+++ b/scripts/generate-lotus-cli.py
@@ -32,8 +32,8 @@ def generate_lotus_cli(prog):
                     cmd_flag = False
                 if cmd_flag is True and line[-1] != ':' and 'help, h' not in line:
                     gap_pos = None
-                    sub_cmd = line
-                    if ' ' in line:
+                    sub_cmd = line.split(',')[0].strip()  # only take the first sub-command before the comma
+                    if ' ' in sub_cmd:
                         gap_pos = sub_cmd.index('  ')
                     sub_cmd = cur_cmd + ' ' + sub_cmd[:gap_pos]
                     get_cmd_recursively(sub_cmd)
@@ -55,3 +55,4 @@ if __name__ == "__main__":
     generate_lotus_cli('lotus')
     generate_lotus_cli('lotus-miner')
     generate_lotus_cli('lotus-worker')
+    generate_lotus_cli('lotus-provider')
\ No newline at end of file
diff --git a/scripts/lotus-provider.service b/scripts/lotus-provider.service
new file mode 100644
index 000000000..ddec181ba
--- /dev/null
+++ b/scripts/lotus-provider.service
@@ -0,0 +1,12 @@
+[Unit]
+Description=Lotus Provider
+After=network.target
+After=lotus-daemon.service
+
+[Service]
+ExecStart=/usr/local/bin/lotus-provider run
+Environment=GOLOG_FILE="/var/log/lotus/provider.log"
+Environment=GOLOG_LOG_FMT="json"
+LimitNOFILE=1000000
+[Install]
+WantedBy=multi-user.target
diff --git a/scripts/supraseal-pc2.sh b/scripts/supraseal-pc2.sh
new file mode 100755
index 000000000..5f8c3ee5b
--- /dev/null
+++ b/scripts/supraseal-pc2.sh
@@ -0,0 +1,53 @@
+#!/bin/sh
+set -eu
+#set -o xtrace
+
+# By default compile for 512MiB and 32GiB sectors only, use `-r` to compile for
+# other sector test sector sizes as well.
+SECTOR_SIZE=""
+while getopts r flag
+do
+    case "${flag}" in
+        r) SECTOR_SIZE="-DRUNTIME_SECTOR_SIZE";;
+        *) ;;
+    esac
+done
+
+if [ ! -d "supra_seal" ]; then
+    git clone https://github.com/supranational/supra_seal.git
+fi
+
+cd supra_seal
+
+rm -fr obj
+mkdir -p obj
+
+rm -fr bin
+mkdir -p bin
+
+mkdir -p deps
+if [ ! -d "deps/sppark" ]; then
+    git clone https://github.com/supranational/sppark.git deps/sppark
+fi
+if [ ! -d "deps/blst" ]; then
+    git clone https://github.com/supranational/blst.git deps/blst
+    (cd deps/blst
+     ./build.sh -march=native)
+fi
+
+# Generate .h files for the Poseidon constants
+xxd -i poseidon/constants/constants_2  > obj/constants_2.h
+xxd -i poseidon/constants/constants_4  > obj/constants_4.h
+xxd -i poseidon/constants/constants_8  > obj/constants_8.h
+xxd -i poseidon/constants/constants_11 > obj/constants_11.h
+xxd -i poseidon/constants/constants_16 > obj/constants_16.h
+xxd -i poseidon/constants/constants_24 > obj/constants_24.h
+xxd -i poseidon/constants/constants_36 > obj/constants_36.h
+
+nvcc ${SECTOR_SIZE} -DNO_SPDK -DSTREAMING_NODE_READER_FILES \
+     -arch=sm_80 -gencode arch=compute_70,code=sm_70 -t0 \
+     -std=c++17 -g -O3 -Xcompiler -march=native \
+     -Xcompiler -Wall,-Wextra,-Werror \
+     -Xcompiler -Wno-subobject-linkage,-Wno-unused-parameter \
+     -x cu tools/pc2.cu -o bin/pc2 \
+     -Iposeidon -Ideps/sppark -Ideps/sppark/util -Ideps/blst/src -L deps/blst -lblst -lconfig++
\ No newline at end of file
diff --git a/storage/paths/db_index.go b/storage/paths/db_index.go
new file mode 100644
index 000000000..1e4abfab1
--- /dev/null
+++ b/storage/paths/db_index.go
@@ -0,0 +1,1001 @@
+package paths
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"net/url"
+	gopath "path"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"go.opencensus.io/stats"
+	"go.opencensus.io/tag"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/journal/alerting"
+	"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
+	"github.com/filecoin-project/lotus/metrics"
+	"github.com/filecoin-project/lotus/storage/sealer/fsutil"
+	"github.com/filecoin-project/lotus/storage/sealer/storiface"
+)
+
+var errAlreadyLocked = errors.New("already locked")
+
+type DBIndex struct {
+	alerting   *alerting.Alerting
+	pathAlerts map[storiface.ID]alerting.AlertType
+
+	harmonyDB *harmonydb.DB
+}
+
+func NewDBIndex(al *alerting.Alerting, db *harmonydb.DB) *DBIndex {
+	return &DBIndex{
+		harmonyDB: db,
+
+		alerting:   al,
+		pathAlerts: map[storiface.ID]alerting.AlertType{},
+	}
+}
+
+func (dbi *DBIndex) StorageList(ctx context.Context) (map[storiface.ID][]storiface.Decl, error) {
+
+	var sectorEntries []struct {
+		StorageId      string
+		MinerId        sql.NullInt64
+		SectorNum      sql.NullInt64
+		SectorFiletype sql.NullInt32 `db:"sector_filetype"`
+		IsPrimary      sql.NullBool
+	}
+
+	err := dbi.harmonyDB.Select(ctx, &sectorEntries,
+		"SELECT stor.storage_id, miner_id, sector_num, sector_filetype, is_primary FROM storage_path stor LEFT JOIN sector_location sec on stor.storage_id=sec.storage_id")
+	if err != nil {
+		return nil, xerrors.Errorf("StorageList DB query fails: %v", err)
+	}
+
+	byID := map[storiface.ID]map[abi.SectorID]storiface.SectorFileType{}
+	for _, entry := range sectorEntries {
+		id := storiface.ID(entry.StorageId)
+		_, ok := byID[id]
+		if !ok {
+			byID[id] = map[abi.SectorID]storiface.SectorFileType{}
+		}
+
+		// skip sector info for storage paths with no sectors
+		if !entry.MinerId.Valid {
+			continue
+		}
+
+		sectorId := abi.SectorID{
+			Miner:  abi.ActorID(entry.MinerId.Int64),
+			Number: abi.SectorNumber(entry.SectorNum.Int64),
+		}
+
+		byID[id][sectorId] |= storiface.SectorFileType(entry.SectorFiletype.Int32)
+	}
+
+	out := map[storiface.ID][]storiface.Decl{}
+	for id, m := range byID {
+		out[id] = []storiface.Decl{}
+		for sectorID, fileType := range m {
+			out[id] = append(out[id], storiface.Decl{
+				SectorID:       sectorID,
+				SectorFileType: fileType,
+			})
+		}
+	}
+
+	return out, nil
+}
+
+func union(a, b []string) []string {
+	m := make(map[string]bool)
+
+	for _, elem := range a {
+		m[elem] = true
+	}
+
+	for _, elem := range b {
+		if _, ok := m[elem]; !ok {
+			a = append(a, elem)
+		}
+	}
+	return a
+}
+
+func splitString(str string) []string {
+	if str == "" {
+		return []string{}
+	}
+	return strings.Split(str, ",")
+}
+
+func (dbi *DBIndex) StorageAttach(ctx context.Context, si storiface.StorageInfo, st fsutil.FsStat) error {
+	var allow, deny = make([]string, 0, len(si.AllowTypes)), make([]string, 0, len(si.DenyTypes))
+
+	if _, hasAlert := dbi.pathAlerts[si.ID]; dbi.alerting != nil && !hasAlert {
+		dbi.pathAlerts[si.ID] = dbi.alerting.AddAlertType("sector-index", "pathconf-"+string(si.ID))
+	}
+
+	var hasConfigIssues bool
+
+	for id, typ := range si.AllowTypes {
+		_, err := storiface.TypeFromString(typ)
+		if err != nil {
+			//No need to hard-fail here, just warn the user
+			//(note that even with all-invalid entries we'll deny all types, so nothing unexpected should enter the path)
+			hasConfigIssues = true
+
+			if dbi.alerting != nil {
+				dbi.alerting.Raise(dbi.pathAlerts[si.ID], map[string]interface{}{
+					"message":   "bad path type in AllowTypes",
+					"path":      string(si.ID),
+					"idx":       id,
+					"path_type": typ,
+					"error":     err.Error(),
+				})
+			}
+
+			continue
+		}
+		allow = append(allow, typ)
+	}
+	for id, typ := range si.DenyTypes {
+		_, err := storiface.TypeFromString(typ)
+		if err != nil {
+			//No need to hard-fail here, just warn the user
+			hasConfigIssues = true
+
+			if dbi.alerting != nil {
+				dbi.alerting.Raise(dbi.pathAlerts[si.ID], map[string]interface{}{
+					"message":   "bad path type in DenyTypes",
+					"path":      string(si.ID),
+					"idx":       id,
+					"path_type": typ,
+					"error":     err.Error(),
+				})
+			}
+
+			continue
+		}
+		deny = append(deny, typ)
+	}
+	si.AllowTypes = allow
+	si.DenyTypes = deny
+
+	if dbi.alerting != nil && !hasConfigIssues && dbi.alerting.IsRaised(dbi.pathAlerts[si.ID]) {
+		dbi.alerting.Resolve(dbi.pathAlerts[si.ID], map[string]string{
+			"message": "path config is now correct",
+		})
+	}
+
+	for _, u := range si.URLs {
+		if _, err := url.Parse(u); err != nil {
+			return xerrors.Errorf("failed to parse url %s: %w", si.URLs, err)
+		}
+	}
+
+	// Single transaction to attach storage which is not present in the DB
+	_, err := dbi.harmonyDB.BeginTransaction(ctx, func(tx *harmonydb.Tx) (commit bool, err error) {
+
+		var urls sql.NullString
+		var storageId sql.NullString
+		err = dbi.harmonyDB.QueryRow(ctx,
+			"Select storage_id, urls FROM storage_path WHERE storage_id = $1", string(si.ID)).Scan(&storageId, &urls)
+		if err != nil && !strings.Contains(err.Error(), "no rows in result set") {
+			return false, xerrors.Errorf("storage attach select fails: %v", err)
+		}
+
+		// Storage ID entry exists
+		// TODO: Consider using insert into .. on conflict do update set ... below
+		if storageId.Valid {
+			var currUrls []string
+			if urls.Valid {
+				currUrls = strings.Split(urls.String, ",")
+			}
+			currUrls = union(currUrls, si.URLs)
+
+			_, err = dbi.harmonyDB.Exec(ctx,
+				"UPDATE storage_path set urls=$1, weight=$2, max_storage=$3, can_seal=$4, can_store=$5, groups=$6, allow_to=$7, allow_types=$8, deny_types=$9 WHERE storage_id=$10",
+				strings.Join(currUrls, ","),
+				si.Weight,
+				si.MaxStorage,
+				si.CanSeal,
+				si.CanStore,
+				strings.Join(si.Groups, ","),
+				strings.Join(si.AllowTo, ","),
+				strings.Join(si.AllowTypes, ","),
+				strings.Join(si.DenyTypes, ","),
+				si.ID)
+			if err != nil {
+				return false, xerrors.Errorf("storage attach UPDATE fails: %v", err)
+			}
+
+			return true, nil
+		}
+
+		// Insert storage id
+		_, err = dbi.harmonyDB.Exec(ctx,
+			"INSERT INTO storage_path "+
+				"Values($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)",
+			si.ID,
+			strings.Join(si.URLs, ","),
+			si.Weight,
+			si.MaxStorage,
+			si.CanSeal,
+			si.CanStore,
+			strings.Join(si.Groups, ","),
+			strings.Join(si.AllowTo, ","),
+			strings.Join(si.AllowTypes, ","),
+			strings.Join(si.DenyTypes, ","),
+			st.Capacity,
+			st.Available,
+			st.FSAvailable,
+			st.Reserved,
+			st.Used,
+			time.Now())
+		if err != nil {
+			return false, xerrors.Errorf("StorageAttach insert fails: %v", err)
+		}
+		return true, nil
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (dbi *DBIndex) StorageDetach(ctx context.Context, id storiface.ID, url string) error {
+
+	// If url not in path urls, error out
+	// if this is only path url for this storage path, drop storage path and sector decls which have this as a storage path
+
+	var qUrls string
+	err := dbi.harmonyDB.QueryRow(ctx, "SELECT COALESCE(urls,'') FROM storage_path WHERE storage_id=$1", string(id)).Scan(&qUrls)
+	if err != nil {
+		return err
+	}
+	urls := splitString(qUrls)
+
+	var modUrls []string
+	for _, u := range urls {
+		if u != url {
+			modUrls = append(modUrls, u)
+		}
+	}
+
+	// noop if url doesn't exist in urls
+	if len(modUrls) == len(urls) {
+		return nil
+	}
+
+	if len(modUrls) > 0 {
+		newUrls := strings.Join(modUrls, ",")
+		_, err := dbi.harmonyDB.Exec(ctx, "UPDATE storage_path set urls=$1 WHERE storage_id=$2", newUrls, id)
+		if err != nil {
+			return err
+		}
+
+		log.Warnw("Dropping sector path endpoint", "path", id, "url", url)
+	} else {
+		// Single transaction to drop storage path and sector decls which have this as a storage path
+		_, err := dbi.harmonyDB.BeginTransaction(ctx, func(tx *harmonydb.Tx) (commit bool, err error) {
+			// Drop storage path completely
+			_, err = dbi.harmonyDB.Exec(ctx, "DELETE FROM storage_path WHERE storage_id=$1", id)
+			if err != nil {
+				return false, err
+			}
+
+			// Drop all sectors entries which use this storage path
+			_, err = dbi.harmonyDB.Exec(ctx, "DELETE FROM sector_location WHERE storage_id=$1", id)
+			if err != nil {
+				return false, err
+			}
+			return true, nil
+		})
+		if err != nil {
+			return err
+		}
+		log.Warnw("Dropping sector storage", "path", id)
+	}
+
+	return nil
+}
+
+func (dbi *DBIndex) StorageReportHealth(ctx context.Context, id storiface.ID, report storiface.HealthReport) error {
+
+	var canSeal, canStore bool
+	err := dbi.harmonyDB.QueryRow(ctx,
+		"SELECT can_seal, can_store FROM storage_path WHERE storage_id=$1", id).Scan(&canSeal, &canStore)
+	if err != nil {
+		return xerrors.Errorf("Querying for storage id %s fails with err %v", id, err)
+	}
+
+	_, err = dbi.harmonyDB.Exec(ctx,
+		"UPDATE storage_path set capacity=$1, available=$2, fs_available=$3, reserved=$4, used=$5, last_heartbeat=$6",
+		report.Stat.Capacity,
+		report.Stat.Available,
+		report.Stat.FSAvailable,
+		report.Stat.Reserved,
+		report.Stat.Used,
+		time.Now())
+	if err != nil {
+		return xerrors.Errorf("updating storage health in DB fails with err: %v", err)
+	}
+
+	if report.Stat.Capacity > 0 {
+		ctx, _ = tag.New(ctx,
+			tag.Upsert(metrics.StorageID, string(id)),
+			tag.Upsert(metrics.PathStorage, fmt.Sprint(canStore)),
+			tag.Upsert(metrics.PathSeal, fmt.Sprint(canSeal)),
+		)
+
+		stats.Record(ctx, metrics.StorageFSAvailable.M(float64(report.Stat.FSAvailable)/float64(report.Stat.Capacity)))
+		stats.Record(ctx, metrics.StorageAvailable.M(float64(report.Stat.Available)/float64(report.Stat.Capacity)))
+		stats.Record(ctx, metrics.StorageReserved.M(float64(report.Stat.Reserved)/float64(report.Stat.Capacity)))
+
+		stats.Record(ctx, metrics.StorageCapacityBytes.M(report.Stat.Capacity))
+		stats.Record(ctx, metrics.StorageFSAvailableBytes.M(report.Stat.FSAvailable))
+		stats.Record(ctx, metrics.StorageAvailableBytes.M(report.Stat.Available))
+		stats.Record(ctx, metrics.StorageReservedBytes.M(report.Stat.Reserved))
+
+		if report.Stat.Max > 0 {
+			stats.Record(ctx, metrics.StorageLimitUsed.M(float64(report.Stat.Used)/float64(report.Stat.Max)))
+			stats.Record(ctx, metrics.StorageLimitUsedBytes.M(report.Stat.Used))
+			stats.Record(ctx, metrics.StorageLimitMaxBytes.M(report.Stat.Max))
+		}
+	}
+
+	return nil
+}
+
+// function to check if a filetype is valid
+func (dbi *DBIndex) checkFileType(fileType storiface.SectorFileType) bool {
+	ftValid := false
+	for _, fileTypeValid := range storiface.PathTypes {
+		if fileTypeValid&fileType == 0 {
+			ftValid = true
+			break
+		}
+	}
+	return ftValid
+}
+
+func (dbi *DBIndex) StorageDeclareSector(ctx context.Context, storageID storiface.ID, s abi.SectorID, ft storiface.SectorFileType, primary bool) error {
+
+	if !dbi.checkFileType(ft) {
+		return xerrors.Errorf("invalid filetype")
+	}
+
+	_, err := dbi.harmonyDB.BeginTransaction(ctx, func(tx *harmonydb.Tx) (commit bool, err error) {
+		var currPrimary sql.NullBool
+		err = dbi.harmonyDB.QueryRow(ctx,
+			"SELECT is_primary FROM sector_location WHERE miner_id=$1 and sector_num=$2 and sector_filetype=$3 and storage_id=$4",
+			uint64(s.Miner), uint64(s.Number), int(ft), string(storageID)).Scan(&currPrimary)
+		if err != nil && !strings.Contains(err.Error(), "no rows in result set") {
+			return false, xerrors.Errorf("DB SELECT fails: %v", err)
+		}
+
+		// If storage id already exists for this sector, update primary if need be
+		if currPrimary.Valid {
+			if !currPrimary.Bool && primary {
+				_, err = dbi.harmonyDB.Exec(ctx,
+					"UPDATE sector_location set is_primary = TRUE WHERE miner_id=$1 and sector_num=$2 and sector_filetype=$3 and storage_id=$4",
+					s.Miner, s.Number, ft, storageID)
+				if err != nil {
+					return false, xerrors.Errorf("DB update fails: %v", err)
+				}
+			} else {
+				log.Warnf("sector %v redeclared in %s", s, storageID)
+			}
+		} else {
+			_, err = dbi.harmonyDB.Exec(ctx,
+				"INSERT INTO sector_location "+
+					"values($1, $2, $3, $4, $5)",
+				s.Miner, s.Number, ft, storageID, primary)
+			if err != nil {
+				return false, xerrors.Errorf("DB insert fails: %v", err)
+			}
+		}
+
+		return true, nil
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (dbi *DBIndex) StorageDropSector(ctx context.Context, storageID storiface.ID, s abi.SectorID, ft storiface.SectorFileType) error {
+
+	if !dbi.checkFileType(ft) {
+		return xerrors.Errorf("invalid filetype")
+	}
+
+	_, err := dbi.harmonyDB.Exec(ctx,
+		"DELETE FROM sector_location WHERE miner_id=$1 and sector_num=$2 and sector_filetype=$3 and storage_id=$4",
+		int(s.Miner), int(s.Number), int(ft), string(storageID))
+	if err != nil {
+		return xerrors.Errorf("StorageDropSector DELETE query fails: %v", err)
+	}
+
+	return nil
+}
+
+func (dbi *DBIndex) StorageFindSector(ctx context.Context, s abi.SectorID, ft storiface.SectorFileType, ssize abi.SectorSize, allowFetch bool) ([]storiface.SectorStorageInfo, error) {
+
+	var result []storiface.SectorStorageInfo
+
+	allowList := make(map[string]struct{})
+	storageWithSector := map[string]bool{}
+
+	type dbRes struct {
+		StorageId  string
+		Count      uint64
+		IsPrimary  bool
+		Urls       string
+		Weight     uint64
+		CanSeal    bool
+		CanStore   bool
+		Groups     string
+		AllowTo    string
+		AllowTypes string
+		DenyTypes  string
+	}
+
+	var rows []dbRes
+
+	fts := ft.AllSet()
+	// Find all storage info which already hold this sector + filetype
+	err := dbi.harmonyDB.Select(ctx, &rows,
+		`		SELECT DISTINCT ON (stor.storage_id)
+						  stor.storage_id,
+						  COUNT(*) OVER(PARTITION BY stor.storage_id) as count, 
+						  BOOL_OR(is_primary) OVER(PARTITION BY stor.storage_id) AS is_primary,
+						  urls,
+						  weight,
+						  can_seal,
+						  can_store,
+						  groups,
+						  allow_to,
+						  allow_types,
+						  deny_types
+						FROM sector_location sec
+						JOIN storage_path stor ON sec.storage_id = stor.storage_id 
+						WHERE sec.miner_id = $1
+						  AND sec.sector_num = $2 
+						  AND sec.sector_filetype = ANY($3)  
+						ORDER BY stor.storage_id`,
+		s.Miner, s.Number, fts)
+	if err != nil {
+		return nil, xerrors.Errorf("Finding sector storage from DB fails with err: %v", err)
+	}
+
+	for _, row := range rows {
+
+		// Parse all urls
+		var urls, burls []string
+		for _, u := range splitString(row.Urls) {
+			rl, err := url.Parse(u)
+			if err != nil {
+				return nil, xerrors.Errorf("failed to parse url: %w", err)
+			}
+			rl.Path = gopath.Join(rl.Path, ft.String(), storiface.SectorName(s))
+			urls = append(urls, rl.String())
+			burls = append(burls, u)
+		}
+
+		result = append(result, storiface.SectorStorageInfo{
+			ID:         storiface.ID(row.StorageId),
+			URLs:       urls,
+			BaseURLs:   burls,
+			Weight:     row.Weight * row.Count,
+			CanSeal:    row.CanSeal,
+			CanStore:   row.CanStore,
+			Primary:    row.IsPrimary,
+			AllowTypes: splitString(row.AllowTypes),
+			DenyTypes:  splitString(row.DenyTypes),
+		})
+
+		storageWithSector[row.StorageId] = true
+
+		allowTo := splitString(row.AllowTo)
+		if allowList != nil && len(allowTo) > 0 {
+			for _, group := range allowTo {
+				allowList[group] = struct{}{}
+			}
+		} else {
+			allowList = nil // allow to any
+		}
+	}
+
+	// Find all storage paths which can hold this sector if allowFetch is true
+	if allowFetch {
+		spaceReq, err := ft.SealSpaceUse(ssize)
+		if err != nil {
+			return nil, xerrors.Errorf("estimating required space: %w", err)
+		}
+
+		// Conditions to satisfy when choosing a sector
+		// 1. CanSeal is true
+		// 2. Available >= spaceReq
+		// 3. curr_time - last_heartbeat < SkippedHeartbeatThresh
+		// 4. heartbeat_err is NULL
+		// 5. not one of the earlier picked storage ids
+		// 6. !ft.AnyAllowed(st.info.AllowTypes, st.info.DenyTypes)
+		// 7. Storage path is part of the groups which are allowed from the storage paths which already hold the sector
+
+		var rows []struct {
+			StorageId  string
+			Urls       string
+			Weight     uint64
+			CanSeal    bool
+			CanStore   bool
+			Groups     string
+			AllowTypes string
+			DenyTypes  string
+		}
+		err = dbi.harmonyDB.Select(ctx, &rows,
+			`SELECT storage_id, 
+					  	urls, 
+					  	weight,
+					  	can_seal,
+					  	can_store,
+					  	groups, 
+					  	allow_types, 
+					  	deny_types
+				FROM storage_path 
+				WHERE can_seal=true 
+				  and available >= $1 
+				  and NOW()-last_heartbeat < $2 
+				  and heartbeat_err is null`,
+			spaceReq, SkippedHeartbeatThresh)
+		if err != nil {
+			return nil, xerrors.Errorf("Selecting allowfetch storage paths from DB fails err: %v", err)
+		}
+
+		for _, row := range rows {
+			if ok := storageWithSector[row.StorageId]; ok {
+				continue
+			}
+
+			if !ft.AnyAllowed(splitString(row.AllowTypes), splitString(row.DenyTypes)) {
+				log.Debugf("not selecting on %s, not allowed by file type filters", row.StorageId)
+				continue
+			}
+
+			if allowList != nil {
+				groups := splitString(row.Groups)
+				allow := false
+				for _, group := range groups {
+					if _, found := allowList[group]; found {
+						log.Debugf("path %s in allowed group %s", row.StorageId, group)
+						allow = true
+						break
+					}
+				}
+
+				if !allow {
+					log.Debugf("not selecting on %s, not in allowed group, allow %+v; path has %+v", row.StorageId, allowList, groups)
+					continue
+				}
+			}
+
+			var urls, burls []string
+			for _, u := range splitString(row.Urls) {
+				rl, err := url.Parse(u)
+				if err != nil {
+					return nil, xerrors.Errorf("failed to parse url: %w", err)
+				}
+				rl.Path = gopath.Join(rl.Path, ft.String(), storiface.SectorName(s))
+				urls = append(urls, rl.String())
+				burls = append(burls, u)
+			}
+
+			result = append(result, storiface.SectorStorageInfo{
+				ID:         storiface.ID(row.StorageId),
+				URLs:       urls,
+				BaseURLs:   burls,
+				Weight:     row.Weight * 0,
+				CanSeal:    row.CanSeal,
+				CanStore:   row.CanStore,
+				Primary:    false,
+				AllowTypes: splitString(row.AllowTypes),
+				DenyTypes:  splitString(row.DenyTypes),
+			})
+		}
+	}
+
+	return result, nil
+}
+
+func (dbi *DBIndex) StorageInfo(ctx context.Context, id storiface.ID) (storiface.StorageInfo, error) {
+
+	var qResults []struct {
+		Urls       string
+		Weight     uint64
+		MaxStorage uint64
+		CanSeal    bool
+		CanStore   bool
+		Groups     string
+		AllowTo    string
+		AllowTypes string
+		DenyTypes  string
+	}
+
+	err := dbi.harmonyDB.Select(ctx, &qResults,
+		"SELECT urls, weight, max_storage, can_seal, can_store, groups, allow_to, allow_types, deny_types "+
+			"FROM storage_path WHERE storage_id=$1", string(id))
+	if err != nil {
+		return storiface.StorageInfo{}, xerrors.Errorf("StorageInfo query fails: %v", err)
+	}
+
+	var sinfo storiface.StorageInfo
+	sinfo.ID = id
+	sinfo.URLs = splitString(qResults[0].Urls)
+	sinfo.Weight = qResults[0].Weight
+	sinfo.MaxStorage = qResults[0].MaxStorage
+	sinfo.CanSeal = qResults[0].CanSeal
+	sinfo.CanStore = qResults[0].CanStore
+	sinfo.Groups = splitString(qResults[0].Groups)
+	sinfo.AllowTo = splitString(qResults[0].AllowTo)
+	sinfo.AllowTypes = splitString(qResults[0].AllowTypes)
+	sinfo.DenyTypes = splitString(qResults[0].DenyTypes)
+
+	return sinfo, nil
+}
+
+func (dbi *DBIndex) StorageBestAlloc(ctx context.Context, allocate storiface.SectorFileType, ssize abi.SectorSize, pathType storiface.PathType) ([]storiface.StorageInfo, error) {
+	var err error
+	var spaceReq uint64
+	switch pathType {
+	case storiface.PathSealing:
+		spaceReq, err = allocate.SealSpaceUse(ssize)
+	case storiface.PathStorage:
+		spaceReq, err = allocate.StoreSpaceUse(ssize)
+	default:
+		return nil, xerrors.Errorf("unexpected path type")
+	}
+	if err != nil {
+		return nil, xerrors.Errorf("estimating required space: %w", err)
+	}
+
+	var rows []struct {
+		StorageId  string
+		Urls       string
+		Weight     uint64
+		MaxStorage uint64
+		CanSeal    bool
+		CanStore   bool
+		Groups     string
+		AllowTo    string
+		AllowTypes string
+		DenyTypes  string
+	}
+
+	err = dbi.harmonyDB.Select(ctx, &rows,
+		`SELECT storage_id, 
+								urls, 
+								weight,
+								max_storage, 
+								can_seal, 
+								can_store, 
+								groups, 
+								allow_to, 
+								allow_types, 
+								deny_types 
+						 FROM storage_path 
+						 WHERE available >= $1
+						 and NOW()-last_heartbeat < $2 
+						 and heartbeat_err is null
+						 and ($3 and can_seal = TRUE or $4 and can_store = TRUE)
+						order by (available::numeric * weight) desc`,
+		spaceReq,
+		SkippedHeartbeatThresh,
+		pathType == storiface.PathSealing,
+		pathType == storiface.PathStorage,
+	)
+	if err != nil {
+		return nil, xerrors.Errorf("Querying for best storage sectors fails with err %w: ", err)
+	}
+
+	var result []storiface.StorageInfo
+	for _, row := range rows {
+		result = append(result, storiface.StorageInfo{
+			ID:         storiface.ID(row.StorageId),
+			URLs:       splitString(row.Urls),
+			Weight:     row.Weight,
+			MaxStorage: row.MaxStorage,
+			CanSeal:    row.CanSeal,
+			CanStore:   row.CanStore,
+			Groups:     splitString(row.Groups),
+			AllowTo:    splitString(row.AllowTo),
+			AllowTypes: splitString(row.AllowTypes),
+			DenyTypes:  splitString(row.DenyTypes),
+		})
+	}
+
+	return result, nil
+}
+
+// timeout after which we consider a lock to be stale
+const LockTimeOut = 300 * time.Second
+
+func isLocked(ts sql.NullTime) bool {
+	return ts.Valid && ts.Time.After(time.Now().Add(-LockTimeOut))
+}
+
+func (dbi *DBIndex) lock(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType, lockUuid uuid.UUID) (bool, error) {
+	if read|write == 0 {
+		return false, nil
+	}
+
+	if read|write > (1<<storiface.FileTypes)-1 {
+		return false, xerrors.Errorf("unknown file types specified")
+	}
+
+	var rows []struct {
+		SectorFileType storiface.SectorFileType `db:"sector_filetype"`
+		ReadTs         sql.NullTime
+		ReadRefs       int
+		WriteTs        sql.NullTime
+	}
+	_, err := dbi.harmonyDB.BeginTransaction(ctx, func(tx *harmonydb.Tx) (commit bool, err error) {
+
+		fts := (read | write).AllSet()
+		err = dbi.harmonyDB.Select(ctx, &rows,
+			`SELECT sector_filetype, read_ts, read_refs, write_ts 
+								 FROM sector_location 
+								 WHERE miner_id=$1 
+								   AND sector_num=$2
+								   AND sector_filetype = ANY($3)`,
+			sector.Miner, sector.Number, fts)
+		if err != nil {
+			return false, xerrors.Errorf("StorageLock SELECT fails: %v", err)
+		}
+
+		type locks struct {
+			readTs   sql.NullTime
+			readRefs int
+			writeTs  sql.NullTime
+		}
+		lockMap := make(map[storiface.SectorFileType]locks)
+		for _, row := range rows {
+			lockMap[row.SectorFileType] = locks{
+				readTs:   row.ReadTs,
+				readRefs: row.ReadRefs,
+				writeTs:  row.WriteTs,
+			}
+		}
+
+		// Check if we can acquire write locks
+		// Conditions: No write lock or write lock is stale, No read lock or read lock is stale
+		for _, wft := range write.AllSet() {
+			if isLocked(lockMap[wft].writeTs) || isLocked(lockMap[wft].readTs) {
+				return false, xerrors.Errorf("cannot acquire writelock for sector %v filetype %d already locked: %w", sector, wft, errAlreadyLocked)
+			}
+		}
+
+		// Check if we can acquire read locks
+		// Conditions: No write lock or write lock is stale
+		for _, rft := range read.AllSet() {
+			if isLocked(lockMap[rft].writeTs) {
+				return false, xerrors.Errorf("cannot acquire read lock for sector %v filetype %d already locked for writing: %w", sector, rft, errAlreadyLocked)
+			}
+		}
+
+		// Acquire write locks
+		_, err = dbi.harmonyDB.Exec(ctx,
+			`UPDATE sector_location
+							 	SET write_ts = NOW(), write_lock_owner = $1
+							 	WHERE miner_id=$2
+							 		AND sector_num=$3
+							 		AND sector_filetype = ANY($4)`,
+			lockUuid.String(),
+			sector.Miner,
+			sector.Number,
+			write.AllSet())
+		if err != nil {
+			return false, xerrors.Errorf("acquiring write locks for sector %v fails with err: %v", sector, err)
+		}
+
+		// Acquire read locks
+		_, err = dbi.harmonyDB.Exec(ctx,
+			`UPDATE sector_location
+							 	SET read_ts = NOW(), read_refs = read_refs + 1
+							 	WHERE miner_id=$1
+							 		AND sector_num=$2
+							 		AND sector_filetype = ANY($3)`,
+			sector.Miner,
+			sector.Number,
+			read.AllSet())
+		if err != nil {
+			return false, xerrors.Errorf("acquiring read locks for sector %v fails with err: %v", sector, err)
+		}
+
+		return true, nil
+	})
+	if err != nil {
+		return false, err
+	}
+
+	return true, nil
+}
+
+func (dbi *DBIndex) unlock(sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType, lockUuid uuid.UUID) (bool, error) {
+	ctx := context.Background()
+
+	if read|write == 0 {
+		return false, nil
+	}
+
+	if read|write > (1<<storiface.FileTypes)-1 {
+		return false, xerrors.Errorf("unknown file types specified")
+	}
+
+	// Relinquish write locks
+	_, err := dbi.harmonyDB.Exec(ctx,
+		`UPDATE sector_location
+				SET write_ts = NULL, write_lock_owner = NULL
+				WHERE miner_id=$1
+					AND sector_num=$2
+					AND write_lock_owner=$3
+					AND sector_filetype = ANY($4)`,
+		sector.Miner,
+		sector.Number,
+		lockUuid.String(),
+		write.AllSet())
+	if err != nil {
+		return false, xerrors.Errorf("relinquishing write locks for sector %v fails with err: %v", sector, err)
+	}
+
+	// Relinquish read locks
+	_, err = dbi.harmonyDB.Exec(ctx,
+		`UPDATE sector_location
+				SET read_refs = read_refs-1,
+					read_ts = CASE WHEN read_refs - 1 = 0 THEN NULL ELSE read_ts END
+				WHERE miner_id=$1
+					AND sector_num=$2
+					AND sector_filetype = ANY($3)`,
+		sector.Miner,
+		sector.Number,
+		read.AllSet())
+	if err != nil {
+		return false, xerrors.Errorf("relinquishing read locks for sector %v fails with err: %v", sector, err)
+	}
+
+	return true, nil
+
+}
+
+func (dbi *DBIndex) StorageLock(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) error {
+
+	retries := 5
+	maxWaitTime := 300 // Set max wait time to 5 minutes
+
+	waitTime := 1
+	// generate uuid for this lock owner
+	lockUuid := uuid.New()
+
+	// retry with exponential backoff and block until lock is acquired
+	for {
+		locked, err := dbi.lock(ctx, sector, read, write, lockUuid)
+		// if err is not nil and is not because we cannot acquire lock, retry
+		if err != nil && !errors.Is(err, errAlreadyLocked) {
+			retries--
+			if retries == 0 {
+				return err
+			}
+		}
+
+		if locked {
+			break
+		}
+
+		select {
+		case <-time.After(time.Duration(waitTime) * time.Second):
+			if waitTime < maxWaitTime {
+				waitTime *= 2
+			}
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+
+	go func() {
+		<-ctx.Done()
+		_, err := dbi.unlock(sector, read, write, lockUuid)
+		if err != nil {
+			log.Errorf("unlocking sector %v for filetypes: read=%d, write=%d, fails with err: %v", sector, read, write, err)
+		}
+
+	}()
+
+	return nil
+}
+
+func (dbi *DBIndex) StorageTryLock(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) (bool, error) {
+	lockUuid := uuid.New()
+	locked, err := dbi.lock(ctx, sector, read, write, lockUuid)
+	if err != nil {
+		return false, err
+	}
+
+	if locked {
+		go func() {
+			<-ctx.Done()
+			_, err := dbi.unlock(sector, read, write, lockUuid)
+			if err != nil {
+				log.Errorf("unlocking sector %v for filetypes: read=%d, write=%d, fails with err: %v", sector, read, write, err)
+			}
+		}()
+	}
+
+	return locked, nil
+}
+
+func (dbi *DBIndex) StorageGetLocks(ctx context.Context) (storiface.SectorLocks, error) {
+
+	var rows []struct {
+		MinerId        uint64
+		SectorNum      uint64
+		SectorFileType int `db:"sector_filetype"`
+		ReadTs         sql.NullTime
+		ReadRefs       int
+		WriteTs        sql.NullTime
+	}
+
+	err := dbi.harmonyDB.Select(ctx, &rows,
+		"SELECT miner_id, sector_num, sector_filetype, read_ts, read_refs, write_ts FROM sector_location")
+	if err != nil {
+		return storiface.SectorLocks{}, err
+	}
+
+	type locks struct {
+		sectorFileType storiface.SectorFileType
+		readRefs       uint
+		writeLk        bool
+	}
+	sectorLocks := make(map[abi.SectorID]locks)
+	for _, row := range rows {
+		sector := abi.SectorID{
+			Miner:  abi.ActorID(row.MinerId),
+			Number: abi.SectorNumber(row.SectorNum),
+		}
+
+		var readRefs uint
+		if isLocked(row.ReadTs) {
+			readRefs = uint(row.ReadRefs)
+		}
+
+		sectorLocks[sector] = locks{
+			sectorFileType: storiface.SectorFileType(row.SectorFileType),
+			readRefs:       readRefs,
+			writeLk:        isLocked(row.WriteTs),
+		}
+	}
+
+	var result storiface.SectorLocks
+	for sector, locks := range sectorLocks {
+		var lock storiface.SectorLock
+		lock.Sector = sector
+		lock.Read[locks.sectorFileType] = locks.readRefs
+		if locks.writeLk {
+			lock.Write[locks.sectorFileType] = 1
+		} else {
+			lock.Write[locks.sectorFileType] = 0
+		}
+		result.Locks = append(result.Locks, lock)
+	}
+
+	return result, nil
+}
+
+var _ SectorIndex = &DBIndex{}
diff --git a/storage/paths/index.go b/storage/paths/index.go
index 8d70fce2a..49ee11e09 100644
--- a/storage/paths/index.go
+++ b/storage/paths/index.go
@@ -61,7 +61,7 @@ type storageEntry struct {
 	heartbeatErr  error
 }
 
-type Index struct {
+type MemIndex struct {
 	*indexLocks
 	lk sync.RWMutex
 
@@ -73,8 +73,8 @@ type Index struct {
 	stores  map[storiface.ID]*storageEntry
 }
 
-func NewIndex(al *alerting.Alerting) *Index {
-	return &Index{
+func NewMemIndex(al *alerting.Alerting) *MemIndex {
+	return &MemIndex{
 		indexLocks: &indexLocks{
 			locks: map[abi.SectorID]*sectorLock{},
 		},
@@ -87,7 +87,7 @@ func NewIndex(al *alerting.Alerting) *Index {
 	}
 }
 
-func (i *Index) StorageList(ctx context.Context) (map[storiface.ID][]storiface.Decl, error) {
+func (i *MemIndex) StorageList(ctx context.Context) (map[storiface.ID][]storiface.Decl, error) {
 	i.lk.RLock()
 	defer i.lk.RUnlock()
 
@@ -116,7 +116,7 @@ func (i *Index) StorageList(ctx context.Context) (map[storiface.ID][]storiface.D
 	return out, nil
 }
 
-func (i *Index) StorageAttach(ctx context.Context, si storiface.StorageInfo, st fsutil.FsStat) error {
+func (i *MemIndex) StorageAttach(ctx context.Context, si storiface.StorageInfo, st fsutil.FsStat) error {
 	var allow, deny = make([]string, 0, len(si.AllowTypes)), make([]string, 0, len(si.DenyTypes))
 
 	if _, hasAlert := i.pathAlerts[si.ID]; i.alerting != nil && !hasAlert {
@@ -215,10 +215,11 @@ func (i *Index) StorageAttach(ctx context.Context, si storiface.StorageInfo, st
 
 		lastHeartbeat: time.Now(),
 	}
+
 	return nil
 }
 
-func (i *Index) StorageDetach(ctx context.Context, id storiface.ID, url string) error {
+func (i *MemIndex) StorageDetach(ctx context.Context, id storiface.ID, url string) error {
 	i.lk.Lock()
 	defer i.lk.Unlock()
 
@@ -306,7 +307,7 @@ func (i *Index) StorageDetach(ctx context.Context, id storiface.ID, url string)
 	return nil
 }
 
-func (i *Index) StorageReportHealth(ctx context.Context, id storiface.ID, report storiface.HealthReport) error {
+func (i *MemIndex) StorageReportHealth(ctx context.Context, id storiface.ID, report storiface.HealthReport) error {
 	i.lk.Lock()
 	defer i.lk.Unlock()
 
@@ -349,7 +350,7 @@ func (i *Index) StorageReportHealth(ctx context.Context, id storiface.ID, report
 	return nil
 }
 
-func (i *Index) StorageDeclareSector(ctx context.Context, storageID storiface.ID, s abi.SectorID, ft storiface.SectorFileType, primary bool) error {
+func (i *MemIndex) StorageDeclareSector(ctx context.Context, storageID storiface.ID, s abi.SectorID, ft storiface.SectorFileType, primary bool) error {
 	i.lk.Lock()
 	defer i.lk.Unlock()
 
@@ -381,7 +382,7 @@ loop:
 	return nil
 }
 
-func (i *Index) StorageDropSector(ctx context.Context, storageID storiface.ID, s abi.SectorID, ft storiface.SectorFileType) error {
+func (i *MemIndex) StorageDropSector(ctx context.Context, storageID storiface.ID, s abi.SectorID, ft storiface.SectorFileType) error {
 	i.lk.Lock()
 	defer i.lk.Unlock()
 
@@ -415,7 +416,7 @@ func (i *Index) StorageDropSector(ctx context.Context, storageID storiface.ID, s
 	return nil
 }
 
-func (i *Index) StorageFindSector(ctx context.Context, s abi.SectorID, ft storiface.SectorFileType, ssize abi.SectorSize, allowFetch bool) ([]storiface.SectorStorageInfo, error) {
+func (i *MemIndex) StorageFindSector(ctx context.Context, s abi.SectorID, ft storiface.SectorFileType, ssize abi.SectorSize, allowFetch bool) ([]storiface.SectorStorageInfo, error) {
 	i.lk.RLock()
 	defer i.lk.RUnlock()
 
@@ -563,7 +564,7 @@ func (i *Index) StorageFindSector(ctx context.Context, s abi.SectorID, ft storif
 	return out, nil
 }
 
-func (i *Index) StorageInfo(ctx context.Context, id storiface.ID) (storiface.StorageInfo, error) {
+func (i *MemIndex) StorageInfo(ctx context.Context, id storiface.ID) (storiface.StorageInfo, error) {
 	i.lk.RLock()
 	defer i.lk.RUnlock()
 
@@ -575,7 +576,7 @@ func (i *Index) StorageInfo(ctx context.Context, id storiface.ID) (storiface.Sto
 	return *si.info, nil
 }
 
-func (i *Index) StorageBestAlloc(ctx context.Context, allocate storiface.SectorFileType, ssize abi.SectorSize, pathType storiface.PathType) ([]storiface.StorageInfo, error) {
+func (i *MemIndex) StorageBestAlloc(ctx context.Context, allocate storiface.SectorFileType, ssize abi.SectorSize, pathType storiface.PathType) ([]storiface.StorageInfo, error) {
 	i.lk.RLock()
 	defer i.lk.RUnlock()
 
@@ -640,7 +641,7 @@ func (i *Index) StorageBestAlloc(ctx context.Context, allocate storiface.SectorF
 	return out, nil
 }
 
-func (i *Index) FindSector(id abi.SectorID, typ storiface.SectorFileType) ([]storiface.ID, error) {
+func (i *MemIndex) FindSector(id abi.SectorID, typ storiface.SectorFileType) ([]storiface.ID, error) {
 	i.lk.RLock()
 	defer i.lk.RUnlock()
 
@@ -659,4 +660,4 @@ func (i *Index) FindSector(id abi.SectorID, typ storiface.SectorFileType) ([]sto
 	return out, nil
 }
 
-var _ SectorIndex = &Index{}
+var _ SectorIndex = &MemIndex{}
diff --git a/storage/paths/index_test.go b/storage/paths/index_test.go
index 9a241da23..96e17ce7d 100644
--- a/storage/paths/index_test.go
+++ b/storage/paths/index_test.go
@@ -42,7 +42,7 @@ const s32g = 32 << 30
 func TestFindSimple(t *testing.T) {
 	ctx := context.Background()
 
-	i := NewIndex(nil)
+	i := NewMemIndex(nil)
 	stor1 := newTestStorage()
 	stor2 := newTestStorage()
 
@@ -79,7 +79,7 @@ func TestFindSimple(t *testing.T) {
 func TestFindNoAllow(t *testing.T) {
 	ctx := context.Background()
 
-	i := NewIndex(nil)
+	i := NewMemIndex(nil)
 	stor1 := newTestStorage()
 	stor1.AllowTo = []storiface.Group{"grp1"}
 	stor2 := newTestStorage()
@@ -111,7 +111,7 @@ func TestFindNoAllow(t *testing.T) {
 func TestFindAllow(t *testing.T) {
 	ctx := context.Background()
 
-	i := NewIndex(nil)
+	i := NewMemIndex(nil)
 
 	stor1 := newTestStorage()
 	stor1.AllowTo = []storiface.Group{"grp1"}
diff --git a/storage/paths/local_test.go b/storage/paths/local_test.go
index bfa138ff6..4bc2642dc 100644
--- a/storage/paths/local_test.go
+++ b/storage/paths/local_test.go
@@ -80,7 +80,7 @@ func TestLocalStorage(t *testing.T) {
 		root: root,
 	}
 
-	index := NewIndex(nil)
+	index := NewMemIndex(nil)
 
 	st, err := NewLocal(ctx, tstor, index, nil)
 	require.NoError(t, err)
diff --git a/storage/paths/localstorage.go b/storage/paths/localstorage.go
new file mode 100644
index 000000000..6f67a18f8
--- /dev/null
+++ b/storage/paths/localstorage.go
@@ -0,0 +1,44 @@
+package paths
+
+import (
+	"github.com/filecoin-project/lotus/node/config"
+	"github.com/filecoin-project/lotus/storage/sealer/fsutil"
+	"github.com/filecoin-project/lotus/storage/sealer/storiface"
+)
+
+type BasicLocalStorage struct {
+	PathToJSON string
+}
+
+var _ LocalStorage = &BasicLocalStorage{}
+
+func (ls *BasicLocalStorage) GetStorage() (storiface.StorageConfig, error) {
+	var def storiface.StorageConfig
+	c, err := config.StorageFromFile(ls.PathToJSON, &def)
+	if err != nil {
+		return storiface.StorageConfig{}, err
+	}
+	return *c, nil
+}
+
+func (ls *BasicLocalStorage) SetStorage(f func(*storiface.StorageConfig)) error {
+	var def storiface.StorageConfig
+	c, err := config.StorageFromFile(ls.PathToJSON, &def)
+	if err != nil {
+		return err
+	}
+	f(c)
+	return config.WriteStorageFile(ls.PathToJSON, *c)
+}
+
+func (ls *BasicLocalStorage) Stat(path string) (fsutil.FsStat, error) {
+	return fsutil.Statfs(path)
+}
+
+func (ls *BasicLocalStorage) DiskUsage(path string) (int64, error) {
+	si, err := fsutil.FileSize(path)
+	if err != nil {
+		return 0, err
+	}
+	return si.OnDisk, nil
+}
diff --git a/storage/paths/remote_test.go b/storage/paths/remote_test.go
index e3376e6fa..7aea63729 100644
--- a/storage/paths/remote_test.go
+++ b/storage/paths/remote_test.go
@@ -59,7 +59,7 @@ func createTestStorage(t *testing.T, p string, seal bool, att ...*paths.Local) s
 func TestMoveShared(t *testing.T) {
 	logging.SetAllLoggers(logging.LevelDebug)
 
-	index := paths.NewIndex(nil)
+	index := paths.NewMemIndex(nil)
 
 	ctx := context.Background()
 
diff --git a/storage/pipeline/sealing.go b/storage/pipeline/sealing.go
index 65d3fb14b..936bd8b39 100644
--- a/storage/pipeline/sealing.go
+++ b/storage/pipeline/sealing.go
@@ -304,6 +304,20 @@ func (m *Sealing) TerminateSector(ctx context.Context, sid abi.SectorNumber) err
 	return m.sectors.Send(uint64(sid), SectorTerminate{})
 }
 
+func (m *Sealing) SectorsSummary(ctx context.Context) map[api.SectorState]int {
+	m.stats.lk.Lock()
+	defer m.stats.lk.Unlock()
+
+	out := make(map[api.SectorState]int)
+
+	for st, count := range m.stats.byState {
+		state := api.SectorState(st)
+		out[state] = int(count)
+	}
+
+	return out
+}
+
 func (m *Sealing) TerminateFlush(ctx context.Context) (*cid.Cid, error) {
 	return m.terminator.Flush(ctx)
 }
diff --git a/storage/pipeline/stats.go b/storage/pipeline/stats.go
index 696cd56a5..a558421ae 100644
--- a/storage/pipeline/stats.go
+++ b/storage/pipeline/stats.go
@@ -44,6 +44,10 @@ func (ss *SectorStats) updateSector(ctx context.Context, cfg sealiface.Config, i
 		ss.totals[toStatState(oldst, cfg.FinalizeEarly)]--
 		ss.byState[oldst]--
 
+		if ss.byState[oldst] <= 0 {
+			delete(ss.byState, oldst)
+		}
+
 		mctx, _ := tag.New(ctx, tag.Upsert(metrics.SectorState, string(oldst)))
 		stats.Record(mctx, metrics.SectorStates.M(ss.byState[oldst]))
 	}
diff --git a/storage/sealer/commitment/commd.go b/storage/sealer/commitment/commd.go
new file mode 100644
index 000000000..b7dc9998a
--- /dev/null
+++ b/storage/sealer/commitment/commd.go
@@ -0,0 +1,34 @@
+package commitment
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+)
+
+const treeDFile = "sc-02-data-tree-d.dat"
+
+// TreeDCommD reads CommD from tree-d
+func TreeDCommD(cache string) ([32]byte, error) {
+	// Open the tree-d file for reading
+	file, err := os.Open(filepath.Join(cache, treeDFile))
+	if err != nil {
+		return [32]byte{}, err
+	}
+	defer file.Close() // nolint:errcheck
+
+	// Seek to 32 bytes from the end of the file
+	_, err = file.Seek(-32, io.SeekEnd)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	// Read the last 32 bytes
+	var commD [32]byte
+	_, err = file.Read(commD[:])
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	return commD, nil
+}
diff --git a/storage/sealer/commitment/commr.go b/storage/sealer/commitment/commr.go
new file mode 100644
index 000000000..d5f5b0844
--- /dev/null
+++ b/storage/sealer/commitment/commr.go
@@ -0,0 +1,64 @@
+package commitment
+
+import (
+	"math/big"
+	"os"
+	"path/filepath"
+
+	"github.com/triplewz/poseidon"
+	ff "github.com/triplewz/poseidon/bls12_381"
+	"golang.org/x/xerrors"
+)
+
+const pauxFile = "p_aux"
+
+func CommR(commC, commRLast [32]byte) ([32]byte, error) {
+	// reverse commC and commRLast so that endianness is correct
+	for i, j := 0, len(commC)-1; i < j; i, j = i+1, j-1 {
+		commC[i], commC[j] = commC[j], commC[i]
+		commRLast[i], commRLast[j] = commRLast[j], commRLast[i]
+	}
+
+	input_a := new(big.Int)
+	input_a.SetBytes(commC[:])
+	input_b := new(big.Int)
+	input_b.SetBytes(commRLast[:])
+	input := []*big.Int{input_a, input_b}
+
+	cons, err := poseidon.GenPoseidonConstants(3)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	h1, err := poseidon.Hash(input, cons, poseidon.OptimizedStatic)
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	h1element := new(ff.Element).SetBigInt(h1).Bytes()
+
+	// reverse the bytes so that endianness is correct
+	for i, j := 0, len(h1element)-1; i < j; i, j = i+1, j-1 {
+		h1element[i], h1element[j] = h1element[j], h1element[i]
+	}
+
+	return h1element, nil
+}
+
+// PAuxCommR reads p_aux and computes CommR
+func PAuxCommR(cache string) ([32]byte, error) {
+	commCcommRLast, err := os.ReadFile(filepath.Join(cache, pauxFile))
+	if err != nil {
+		return [32]byte{}, err
+	}
+
+	if len(commCcommRLast) != 64 {
+		return [32]byte{}, xerrors.Errorf("invalid commCcommRLast length %d", len(commCcommRLast))
+	}
+
+	var commC, commRLast [32]byte
+	copy(commC[:], commCcommRLast[:32])
+	copy(commRLast[:], commCcommRLast[32:])
+
+	return CommR(commC, commRLast)
+}
diff --git a/storage/sealer/commitment/commr_test.go b/storage/sealer/commitment/commr_test.go
new file mode 100644
index 000000000..107f483d2
--- /dev/null
+++ b/storage/sealer/commitment/commr_test.go
@@ -0,0 +1,35 @@
+package commitment
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestCommR(t *testing.T) {
+	var commC = [32]byte{
+		0x09, 0x1e, 0x07, 0x3b, 0x98, 0x2f, 0x66, 0xf0,
+		0x13, 0xc0, 0x26, 0xda, 0x6e, 0x54, 0xd8, 0x7d,
+		0xbf, 0x8b, 0xba, 0x84, 0x8e, 0xf5, 0x7a, 0x55,
+		0x29, 0xc7, 0xe7, 0xf7, 0x2c, 0x82, 0x88, 0x43,
+	}
+
+	var commRLast = [32]byte{
+		0xf0, 0xc5, 0x78, 0x5c, 0x6c, 0x8c, 0xf6, 0x2d,
+		0x96, 0x8b, 0x1e, 0xcd, 0x68, 0xed, 0xb9, 0xd9,
+		0x1e, 0xb9, 0x44, 0x5c, 0x78, 0x58, 0xa6, 0x00,
+		0x26, 0xf8, 0x82, 0x68, 0x60, 0xf7, 0xe7, 0x68,
+	}
+
+	res, err := CommR(commC, commRLast)
+	require.NoError(t, err)
+
+	var expected = [32]byte{
+		0xe6, 0x74, 0xd1, 0x9e, 0x6c, 0xe7, 0xfc, 0xf3,
+		0x3b, 0xbf, 0xd9, 0xb3, 0x43, 0xa0, 0xce, 0xb1,
+		0x2d, 0x28, 0x31, 0xd1, 0xda, 0x54, 0x31, 0x61,
+		0x89, 0x1e, 0xbc, 0xca, 0xd2, 0xc6, 0xdb, 0x01,
+	}
+
+	require.Equal(t, res, expected)
+}
diff --git a/storage/sealer/ffiwrapper/extern_pc2.go b/storage/sealer/ffiwrapper/extern_pc2.go
new file mode 100644
index 000000000..de9246efc
--- /dev/null
+++ b/storage/sealer/ffiwrapper/extern_pc2.go
@@ -0,0 +1,88 @@
+package ffiwrapper
+
+import (
+	"context"
+	"encoding/base64"
+	"fmt"
+	"os"
+	"os/exec"
+
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	commcid "github.com/filecoin-project/go-fil-commcid"
+
+	"github.com/filecoin-project/lotus/storage/sealer/commitment"
+	"github.com/filecoin-project/lotus/storage/sealer/storiface"
+)
+
+// MakeExternPrecommit2 creates an implementation of ExternPrecommit2 backed by
+// an external command specified by the command string.
+//
+// The command will be called with a number of environment variables set:
+// * EXTSEAL_PC2_SECTOR_NUM: the sector number
+// * EXTSEAL_PC2_SECTOR_MINER: the miner id
+// * EXTSEAL_PC2_PROOF_TYPE: the proof type
+// * EXTSEAL_PC2_SECTOR_SIZE: the sector size in bytes
+// * EXTSEAL_PC2_CACHE: the path to the cache directory
+// * EXTSEAL_PC2_SEALED: the path to the sealed sector file (initialized with unsealed data by the caller)
+// * EXTSEAL_PC2_PC1OUT: output from rust-fil-proofs precommit1 phase (base64 encoded json)
+//
+// The command is expected to:
+// * Create cache sc-02-data-tree-r* files
+// * Create cache sc-02-data-tree-c* files
+// * Create cache p_aux / t_aux files
+// * Transform the sealed file in place
+func MakeExternPrecommit2(command string) ExternPrecommit2 {
+	return func(ctx context.Context, sector storiface.SectorRef, cache, sealed string, pc1out storiface.PreCommit1Out) (sealedCID cid.Cid, unsealedCID cid.Cid, err error) {
+		ssize, err := sector.ProofType.SectorSize()
+		if err != nil {
+			return cid.Undef, cid.Undef, err
+		}
+
+		// Set environment variables for the external command
+		env := []string{
+			"EXTSEAL_PC2_SECTOR_NUM=" + sector.ID.Number.String(),
+			"EXTSEAL_PC2_SECTOR_MINER=" + sector.ID.Miner.String(),
+			"EXTSEAL_PC2_PROOF_TYPE=" + fmt.Sprintf("%d", sector.ProofType),
+			"EXTSEAL_PC2_SECTOR_SIZE=" + fmt.Sprintf("%d", ssize),
+			"EXTSEAL_PC2_CACHE=" + cache,
+			"EXTSEAL_PC2_SEALED=" + sealed,
+			"EXTSEAL_PC2_PC1OUT=" + base64.StdEncoding.EncodeToString(pc1out),
+		}
+
+		log.Infow("running external sealing call", "method", "precommit2", "command", command, "env", env)
+
+		// Create and run the external command
+		cmd := exec.CommandContext(ctx, "sh", "-c", command)
+		cmd.Env = env
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+
+		if err := cmd.Run(); err != nil {
+			return cid.Cid{}, cid.Cid{}, xerrors.Errorf("external command error: %w", err)
+		}
+
+		commr, err := commitment.PAuxCommR(cache)
+		if err != nil {
+			return cid.Undef, cid.Undef, xerrors.Errorf("reading p_aux: %w", err)
+		}
+
+		sealedCID, err = commcid.ReplicaCommitmentV1ToCID(commr[:])
+		if err != nil {
+			return cid.Cid{}, cid.Cid{}, err
+		}
+
+		commd, err := commitment.TreeDCommD(cache)
+		if err != nil {
+			return cid.Undef, cid.Undef, xerrors.Errorf("reading CommD from tree-d: %w", err)
+		}
+
+		unsealedCID, err = commcid.DataCommitmentV1ToCID(commd[:])
+		if err != nil {
+			return cid.Cid{}, cid.Cid{}, err
+		}
+
+		return sealedCID, unsealedCID, nil
+	}
+}
diff --git a/storage/sealer/ffiwrapper/sealer.go b/storage/sealer/ffiwrapper/sealer.go
index 39cb8fa1b..00374ddf5 100644
--- a/storage/sealer/ffiwrapper/sealer.go
+++ b/storage/sealer/ffiwrapper/sealer.go
@@ -1,13 +1,28 @@
 package ffiwrapper
 
 import (
+	"context"
+
+	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log/v2"
+
+	"github.com/filecoin-project/lotus/storage/sealer/storiface"
 )
 
 var log = logging.Logger("ffiwrapper")
 
+type ExternPrecommit2 func(ctx context.Context, sector storiface.SectorRef, cache, sealed string, pc1out storiface.PreCommit1Out) (sealedCID cid.Cid, unsealedCID cid.Cid, err error)
+
+type ExternalSealer struct {
+	PreCommit2 ExternPrecommit2
+}
+
 type Sealer struct {
-	sectors  SectorProvider
+	sectors SectorProvider
+
+	// externCalls cointain overrides for calling alternative sealing logic
+	externCalls ExternalSealer
+
 	stopping chan struct{}
 }
 
diff --git a/storage/sealer/ffiwrapper/sealer_cgo.go b/storage/sealer/ffiwrapper/sealer_cgo.go
index fec12f231..04e891665 100644
--- a/storage/sealer/ffiwrapper/sealer_cgo.go
+++ b/storage/sealer/ffiwrapper/sealer_cgo.go
@@ -40,10 +40,30 @@ import (
 
 var _ storiface.Storage = &Sealer{}
 
-func New(sectors SectorProvider) (*Sealer, error) {
+type FFIWrapperOpts struct {
+	ext ExternalSealer
+}
+
+type FFIWrapperOpt func(*FFIWrapperOpts)
+
+func WithExternalSealCalls(ext ExternalSealer) FFIWrapperOpt {
+	return func(o *FFIWrapperOpts) {
+		o.ext = ext
+	}
+}
+
+func New(sectors SectorProvider, opts ...FFIWrapperOpt) (*Sealer, error) {
+	options := &FFIWrapperOpts{}
+
+	for _, o := range opts {
+		o(options)
+	}
+
 	sb := &Sealer{
 		sectors: sectors,
 
+		externCalls: options.ext,
+
 		stopping: make(chan struct{}),
 	}
 
@@ -147,8 +167,10 @@ func (sb *Sealer) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize,
 		})
 	}
 
+	/*  #nosec G601 -- length is verified */
 	if len(piecePromises) == 1 {
-		return piecePromises[0]()
+		p := piecePromises[0]
+		return p()
 	}
 
 	var payloadRoundedBytes abi.PaddedPieceSize
@@ -347,8 +369,10 @@ func (sb *Sealer) AddPiece(ctx context.Context, sector storiface.SectorRef, exis
 	}
 	stagedFile = nil
 
+	/*  #nosec G601 -- length is verified */
 	if len(piecePromises) == 1 {
-		return piecePromises[0]()
+		p := piecePromises[0]
+		return p()
 	}
 
 	var payloadRoundedBytes abi.PaddedPieceSize
@@ -881,9 +905,18 @@ func (sb *Sealer) SealPreCommit2(ctx context.Context, sector storiface.SectorRef
 	}
 	defer done()
 
-	sealedCID, unsealedCID, err := ffi.SealPreCommitPhase2(phase1Out, paths.Cache, paths.Sealed)
-	if err != nil {
-		return storiface.SectorCids{}, xerrors.Errorf("presealing sector %d (%s): %w", sector.ID.Number, paths.Unsealed, err)
+	var sealedCID, unsealedCID cid.Cid
+
+	if sb.externCalls.PreCommit2 == nil {
+		sealedCID, unsealedCID, err = ffi.SealPreCommitPhase2(phase1Out, paths.Cache, paths.Sealed)
+		if err != nil {
+			return storiface.SectorCids{}, xerrors.Errorf("presealing sector %d (%s): %w", sector.ID.Number, paths.Unsealed, err)
+		}
+	} else {
+		sealedCID, unsealedCID, err = sb.externCalls.PreCommit2(ctx, sector, paths.Cache, paths.Sealed, phase1Out)
+		if err != nil {
+			return storiface.SectorCids{}, xerrors.Errorf("presealing sector (extern-pc2) %d (%s): %w", sector.ID.Number, paths.Unsealed, err)
+		}
 	}
 
 	ssize, err := sector.ProofType.SectorSize()
@@ -928,7 +961,7 @@ func (sb *Sealer) SealPreCommit2(ctx context.Context, sector storiface.SectorRef
 				return storiface.SectorCids{}, xerrors.Errorf("generate synth proofs: %w", err)
 			}
 
-			if err = ffi.ClearLayerData(ssize, paths.Cache); err != nil {
+			if err = ffi.ClearCache(uint64(ssize), paths.Cache); err != nil {
 				log.Warn("failed to GenerateSynthProofs(): ", err)
 				log.Warnf("num:%d tkt:%v, sealedCID:%v, unsealedCID:%v", sector.ID.Number, ticket, sealedCID, unsealedCID)
 				return storiface.SectorCids{
diff --git a/storage/sealer/ffiwrapper/sealer_test.go b/storage/sealer/ffiwrapper/sealer_test.go
index c0cdb77a9..59821e795 100644
--- a/storage/sealer/ffiwrapper/sealer_test.go
+++ b/storage/sealer/ffiwrapper/sealer_test.go
@@ -3,6 +3,7 @@ package ffiwrapper
 import (
 	"bytes"
 	"context"
+	crand "crypto/rand"
 	"fmt"
 	"io"
 	"io/fs"
@@ -30,6 +31,7 @@ import (
 
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/storage/pipeline/lib/nullreader"
+	"github.com/filecoin-project/lotus/storage/sealer/commitment"
 	"github.com/filecoin-project/lotus/storage/sealer/ffiwrapper/basicfs"
 	"github.com/filecoin-project/lotus/storage/sealer/storiface"
 )
@@ -425,6 +427,7 @@ func TestMain(m *testing.M) {
 }
 
 func TestSealAndVerify3(t *testing.T) {
+	t.Skip("i flake on CI, re-enable me when you have a fix pls")
 	if testing.Short() {
 		t.Skip("skipping test in short mode")
 	}
@@ -970,7 +973,9 @@ func TestMulticoreSDR(t *testing.T) {
 
 func TestPoStChallengeAssumptions(t *testing.T) {
 	var r [32]byte
-	rand.Read(r[:])
+	if _, err := crand.Read(r[:]); err != nil {
+		panic(err)
+	}
 	r[31] &= 0x3f
 
 	// behaves like a pure function
@@ -1089,7 +1094,11 @@ func TestDCAPCloses(t *testing.T) {
 }
 
 func TestSealAndVerifySynth(t *testing.T) {
+	origSealProofType := sealProofType
 	sealProofType = abi.RegisteredSealProof_StackedDrg2KiBV1_1_Feat_SyntheticPoRep
+	t.Cleanup(func() {
+		sealProofType = origSealProofType
+	})
 
 	if testing.Short() {
 		t.Skip("skipping test in short mode")
@@ -1210,6 +1219,61 @@ func (c *closeAssertReader) Close() error {
 
 var _ io.Closer = &closeAssertReader{}
 
+func TestSealCommDRInGo(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode")
+	}
+
+	defer requireFDsClosed(t, openFDs(t))
+
+	cdir, err := os.MkdirTemp("", "sbtest-c-")
+	require.NoError(t, err)
+	miner := abi.ActorID(123)
+
+	sp := &basicfs.Provider{
+		Root: cdir,
+	}
+	sb, err := New(sp)
+	require.NoError(t, err)
+
+	t.Cleanup(func() {
+		if t.Failed() {
+			fmt.Printf("not removing %s\n", cdir)
+			return
+		}
+		if err := os.RemoveAll(cdir); err != nil {
+			t.Error(err)
+		}
+	})
+
+	si := storiface.SectorRef{
+		ID:        abi.SectorID{Miner: miner, Number: 1},
+		ProofType: sealProofType,
+	}
+
+	s := seal{ref: si}
+
+	s.precommit(t, sb, si, func() {})
+
+	p, _, err := sp.AcquireSector(context.Background(), si, storiface.FTCache, storiface.FTNone, storiface.PathStorage)
+	require.NoError(t, err)
+
+	commr, err := commitment.PAuxCommR(p.Cache)
+	require.NoError(t, err)
+
+	commd, err := commitment.TreeDCommD(p.Cache)
+	require.NoError(t, err)
+
+	sealCid, err := commcid.ReplicaCommitmentV1ToCID(commr[:])
+	require.NoError(t, err)
+
+	unsealedCid, err := commcid.DataCommitmentV1ToCID(commd[:])
+	require.NoError(t, err)
+
+	require.Equal(t, s.cids.Sealed, sealCid)
+	require.Equal(t, s.cids.Unsealed, unsealedCid)
+}
+
 func TestGenerateSDR(t *testing.T) {
 	d := t.TempDir()
 
diff --git a/storage/sealer/fr32/fr32_test.go b/storage/sealer/fr32/fr32_test.go
index 437fa4e43..d5f094df4 100644
--- a/storage/sealer/fr32/fr32_test.go
+++ b/storage/sealer/fr32/fr32_test.go
@@ -2,8 +2,8 @@ package fr32_test
 
 import (
 	"bytes"
+	"crypto/rand"
 	"io"
-	"math/rand"
 	"os"
 	"testing"
 
@@ -70,10 +70,13 @@ func TestPadChunkFFI(t *testing.T) {
 }
 
 func TestPadChunkRandEqFFI(t *testing.T) {
+
 	for i := 0; i < 200; i++ {
 		var input [127]byte
-		rand.Read(input[:])
-
+		_, err := rand.Read(input[:])
+		if err != nil {
+			panic(err)
+		}
 		var buf [128]byte
 
 		fr32.Pad(input[:], buf[:])
@@ -109,8 +112,10 @@ func TestRoundtrip(t *testing.T) {
 func TestRoundtripChunkRand(t *testing.T) {
 	for i := 0; i < 200; i++ {
 		var input [127]byte
-		rand.Read(input[:])
-
+		_, err := rand.Read(input[:])
+		if err != nil {
+			panic(err)
+		}
 		var buf [128]byte
 		copy(buf[:], input[:])
 
@@ -127,8 +132,10 @@ func TestRoundtrip16MRand(t *testing.T) {
 	up := abi.PaddedPieceSize(16 << 20).Unpadded()
 
 	input := make([]byte, up)
-	rand.Read(input[:])
-
+	_, err := rand.Read(input[:])
+	if err != nil {
+		panic(err)
+	}
 	buf := make([]byte, 16<<20)
 
 	fr32.Pad(input, buf)
diff --git a/storage/sealer/manager.go b/storage/sealer/manager.go
index 700a5aec5..41b3a1b39 100644
--- a/storage/sealer/manager.go
+++ b/storage/sealer/manager.go
@@ -802,7 +802,7 @@ func (m *Manager) FinalizeReplicaUpdate(ctx context.Context, sector storiface.Se
 
 	{
 		unsealedStores, ferr := m.index.StorageFindSector(ctx, sector.ID, storiface.FTUnsealed, 0, false)
-		if err != nil {
+		if ferr != nil {
 			err = multierr.Append(err, xerrors.Errorf("find unsealed sector before move: %w", ferr))
 		} else if len(unsealedStores) > 0 {
 			// if we found unsealed files, AND have been asked to keep at least one piece, move unsealed
diff --git a/storage/sealer/manager_test.go b/storage/sealer/manager_test.go
index 7c3e1a1f2..bd03cd097 100644
--- a/storage/sealer/manager_test.go
+++ b/storage/sealer/manager_test.go
@@ -100,10 +100,10 @@ func (t *testStorage) Stat(path string) (fsutil.FsStat, error) {
 
 var _ paths.LocalStorage = &testStorage{}
 
-func newTestMgr(ctx context.Context, t *testing.T, ds datastore.Datastore) (*Manager, *paths.Local, *paths.Remote, *paths.Index, func()) {
+func newTestMgr(ctx context.Context, t *testing.T, ds datastore.Datastore) (*Manager, *paths.Local, *paths.Remote, *paths.MemIndex, func()) {
 	st := newTestStorage(t)
 
-	si := paths.NewIndex(nil)
+	si := paths.NewMemIndex(nil)
 
 	lstor, err := paths.NewLocal(ctx, st, si, nil)
 	require.NoError(t, err)
@@ -648,7 +648,7 @@ func TestRestartWorker(t *testing.T) {
 	wds := syncds.MutexWrap(datastore.NewMapDatastore())
 
 	arch := make(chan chan apres)
-	w := newLocalWorker(func() (storiface.Storage, error) {
+	w := NewLocalWorkerWithExecutor(func(_ *LocalWorker) (storiface.Storage, error) {
 		return &testExec{apch: arch}, nil
 	}, WorkerConfig{
 		TaskTypes: localTasks,
@@ -685,7 +685,7 @@ func TestRestartWorker(t *testing.T) {
 	}
 
 	// restart the worker
-	w = newLocalWorker(func() (storiface.Storage, error) {
+	w = NewLocalWorkerWithExecutor(func(_ *LocalWorker) (storiface.Storage, error) {
 		return &testExec{apch: arch}, nil
 	}, WorkerConfig{
 		TaskTypes: localTasks,
@@ -721,7 +721,7 @@ func TestReenableWorker(t *testing.T) {
 	wds := datastore.NewMapDatastore()
 
 	arch := make(chan chan apres)
-	w := newLocalWorker(func() (storiface.Storage, error) {
+	w := NewLocalWorkerWithExecutor(func(_ *LocalWorker) (storiface.Storage, error) {
 		return &testExec{apch: arch}, nil
 	}, WorkerConfig{
 		TaskTypes: localTasks,
@@ -794,7 +794,7 @@ func TestResUse(t *testing.T) {
 	wds := syncds.MutexWrap(datastore.NewMapDatastore())
 
 	arch := make(chan chan apres)
-	w := newLocalWorker(func() (storiface.Storage, error) {
+	w := NewLocalWorkerWithExecutor(func(_ *LocalWorker) (storiface.Storage, error) {
 		return &testExec{apch: arch}, nil
 	}, WorkerConfig{
 		TaskTypes: localTasks,
@@ -852,7 +852,7 @@ func TestResOverride(t *testing.T) {
 	wds := syncds.MutexWrap(datastore.NewMapDatastore())
 
 	arch := make(chan chan apres)
-	w := newLocalWorker(func() (storiface.Storage, error) {
+	w := NewLocalWorkerWithExecutor(func(_ *LocalWorker) (storiface.Storage, error) {
 		return &testExec{apch: arch}, nil
 	}, WorkerConfig{
 		TaskTypes: localTasks,
diff --git a/storage/sealer/mock/mock.go b/storage/sealer/mock/mock.go
index cb498492f..e33be8477 100644
--- a/storage/sealer/mock/mock.go
+++ b/storage/sealer/mock/mock.go
@@ -3,10 +3,10 @@ package mock
 import (
 	"bytes"
 	"context"
+	"crypto/rand"
 	"crypto/sha256"
 	"fmt"
 	"io"
-	"math/rand"
 	"sync"
 
 	"github.com/ipfs/go-cid"
@@ -478,7 +478,7 @@ func (mgr *SectorMgr) StageFakeData(mid abi.ActorID, spt abi.RegisteredSealProof
 	}
 
 	buf := make([]byte, usize)
-	_, _ = rand.Read(buf) // nolint:gosec
+	_, _ = rand.Reader.Read(buf)
 
 	id := storiface.SectorRef{
 		ID: abi.SectorID{
diff --git a/storage/sealer/piece_provider_test.go b/storage/sealer/piece_provider_test.go
index 4cbc79a93..2acea47a5 100644
--- a/storage/sealer/piece_provider_test.go
+++ b/storage/sealer/piece_provider_test.go
@@ -3,8 +3,8 @@ package sealer
 import (
 	"bytes"
 	"context"
+	"crypto/rand"
 	"io"
-	"math/rand"
 	"net"
 	"net/http"
 	"os"
@@ -180,7 +180,7 @@ func TestReadPieceRemoteWorkers(t *testing.T) {
 
 type pieceProviderTestHarness struct {
 	ctx         context.Context
-	index       *paths.Index
+	index       *paths.MemIndex
 	pp          PieceProvider
 	sector      storiface.SectorRef
 	mgr         *Manager
@@ -195,7 +195,10 @@ type pieceProviderTestHarness struct {
 
 func generatePieceData(size uint64) []byte {
 	bz := make([]byte, size)
-	rand.Read(bz)
+	_, err := rand.Read(bz)
+	if err != nil {
+		panic(err)
+	}
 	return bz
 }
 
@@ -207,7 +210,7 @@ func newPieceProviderTestHarness(t *testing.T, mgrConfig config.SealerConfig, se
 	require.NoError(t, err)
 
 	// create index, storage, local store & remote store.
-	index := paths.NewIndex(nil)
+	index := paths.NewMemIndex(nil)
 	storage := newTestStorage(t)
 	localStore, err := paths.NewLocal(ctx, storage, index, []string{"http://" + nl.Addr().String() + "/remote"})
 	require.NoError(t, err)
@@ -286,7 +289,7 @@ func (p *pieceProviderTestHarness) addRemoteWorker(t *testing.T, tasks []sealtas
 	dstore := ds_sync.MutexWrap(datastore.NewMapDatastore())
 	csts := statestore.New(namespace.Wrap(dstore, datastore.NewKey("/stmgr/calls")))
 
-	worker := newLocalWorker(nil, WorkerConfig{
+	worker := NewLocalWorkerWithExecutor(nil, WorkerConfig{
 		TaskTypes: tasks,
 	}, os.LookupEnv, remote, localStore, p.index, p.mgr, csts)
 
diff --git a/storage/sealer/sched_test.go b/storage/sealer/sched_test.go
index 2e2b05ab2..03e947b8a 100644
--- a/storage/sealer/sched_test.go
+++ b/storage/sealer/sched_test.go
@@ -187,7 +187,7 @@ func (s *schedTestWorker) Close() error {
 
 var _ Worker = &schedTestWorker{}
 
-func addTestWorker(t *testing.T, sched *Scheduler, index *paths.Index, name string, taskTypes map[sealtasks.TaskType]struct{}, resources storiface.WorkerResources, ignoreResources bool) {
+func addTestWorker(t *testing.T, sched *Scheduler, index *paths.MemIndex, name string, taskTypes map[sealtasks.TaskType]struct{}, resources storiface.WorkerResources, ignoreResources bool) {
 	w := &schedTestWorker{
 		name:      name,
 		taskTypes: taskTypes,
@@ -231,7 +231,7 @@ func TestSchedStartStop(t *testing.T) {
 	require.NoError(t, err)
 	go sched.runSched()
 
-	addTestWorker(t, sched, paths.NewIndex(nil), "fred", nil, decentWorkerResources, false)
+	addTestWorker(t, sched, paths.NewMemIndex(nil), "fred", nil, decentWorkerResources, false)
 
 	require.NoError(t, sched.Close(context.TODO()))
 }
@@ -264,13 +264,13 @@ func TestSched(t *testing.T) {
 		wg sync.WaitGroup
 	}
 
-	type task func(*testing.T, *Scheduler, *paths.Index, *runMeta)
+	type task func(*testing.T, *Scheduler, *paths.MemIndex, *runMeta)
 
 	sched := func(taskName, expectWorker string, sid abi.SectorNumber, taskType sealtasks.TaskType) task {
 		_, _, l, _ := runtime.Caller(1)
 		_, _, l2, _ := runtime.Caller(2)
 
-		return func(t *testing.T, sched *Scheduler, index *paths.Index, rm *runMeta) {
+		return func(t *testing.T, sched *Scheduler, index *paths.MemIndex, rm *runMeta) {
 			done := make(chan struct{})
 			rm.done[taskName] = done
 
@@ -324,7 +324,7 @@ func TestSched(t *testing.T) {
 	taskStarted := func(name string) task {
 		_, _, l, _ := runtime.Caller(1)
 		_, _, l2, _ := runtime.Caller(2)
-		return func(t *testing.T, sched *Scheduler, index *paths.Index, rm *runMeta) {
+		return func(t *testing.T, sched *Scheduler, index *paths.MemIndex, rm *runMeta) {
 			select {
 			case rm.done[name] <- struct{}{}:
 			case <-ctx.Done():
@@ -336,7 +336,7 @@ func TestSched(t *testing.T) {
 	taskDone := func(name string) task {
 		_, _, l, _ := runtime.Caller(1)
 		_, _, l2, _ := runtime.Caller(2)
-		return func(t *testing.T, sched *Scheduler, index *paths.Index, rm *runMeta) {
+		return func(t *testing.T, sched *Scheduler, index *paths.MemIndex, rm *runMeta) {
 			select {
 			case rm.done[name] <- struct{}{}:
 			case <-ctx.Done():
@@ -349,7 +349,7 @@ func TestSched(t *testing.T) {
 	taskNotScheduled := func(name string) task {
 		_, _, l, _ := runtime.Caller(1)
 		_, _, l2, _ := runtime.Caller(2)
-		return func(t *testing.T, sched *Scheduler, index *paths.Index, rm *runMeta) {
+		return func(t *testing.T, sched *Scheduler, index *paths.MemIndex, rm *runMeta) {
 			select {
 			case rm.done[name] <- struct{}{}:
 				t.Fatal("not expected", l, l2)
@@ -360,7 +360,7 @@ func TestSched(t *testing.T) {
 
 	testFunc := func(workers []workerSpec, tasks []task) func(t *testing.T) {
 		return func(t *testing.T) {
-			index := paths.NewIndex(nil)
+			index := paths.NewMemIndex(nil)
 
 			sched, err := newScheduler(ctx, "")
 			require.NoError(t, err)
@@ -389,7 +389,7 @@ func TestSched(t *testing.T) {
 	}
 
 	multTask := func(tasks ...task) task {
-		return func(t *testing.T, s *Scheduler, index *paths.Index, meta *runMeta) {
+		return func(t *testing.T, s *Scheduler, index *paths.MemIndex, meta *runMeta) {
 			for _, tsk := range tasks {
 				tsk(t, s, index, meta)
 			}
@@ -503,7 +503,7 @@ func TestSched(t *testing.T) {
 	}
 
 	diag := func() task {
-		return func(t *testing.T, s *Scheduler, index *paths.Index, meta *runMeta) {
+		return func(t *testing.T, s *Scheduler, index *paths.MemIndex, meta *runMeta) {
 			time.Sleep(20 * time.Millisecond)
 			for _, request := range s.diag().Requests {
 				log.Infof("!!! sDIAG: sid(%d) task(%s)", request.Sector.Number, request.TaskType)
diff --git a/storage/sealer/storiface/paths.go b/storage/sealer/storiface/paths.go
index 624b71d77..2cb4f34d3 100644
--- a/storage/sealer/storiface/paths.go
+++ b/storage/sealer/storiface/paths.go
@@ -16,10 +16,6 @@ const (
 	AcquireCopy AcquireMode = "copy"
 )
 
-type Refs struct {
-	RefCount [FileTypes]uint
-}
-
 type SectorLock struct {
 	Sector abi.SectorID
 	Write  [FileTypes]uint
diff --git a/storage/sealer/worker_local.go b/storage/sealer/worker_local.go
index cc4a81599..7fc494955 100644
--- a/storage/sealer/worker_local.go
+++ b/storage/sealer/worker_local.go
@@ -47,7 +47,7 @@ type WorkerConfig struct {
 }
 
 // used do provide custom proofs impl (mostly used in testing)
-type ExecutorFunc func() (storiface.Storage, error)
+type ExecutorFunc func(w *LocalWorker) (storiface.Storage, error)
 type EnvFunc func(string) (string, bool)
 
 type LocalWorker struct {
@@ -77,7 +77,7 @@ type LocalWorker struct {
 	closing     chan struct{}
 }
 
-func newLocalWorker(executor ExecutorFunc, wcfg WorkerConfig, envLookup EnvFunc, store paths.Store, local *paths.Local, sindex paths.SectorIndex, ret storiface.WorkerReturn, cst *statestore.StateStore) *LocalWorker {
+func NewLocalWorkerWithExecutor(executor ExecutorFunc, wcfg WorkerConfig, envLookup EnvFunc, store paths.Store, local *paths.Local, sindex paths.SectorIndex, ret storiface.WorkerReturn, cst *statestore.StateStore) *LocalWorker {
 	acceptTasks := map[sealtasks.TaskType]struct{}{}
 	for _, taskType := range wcfg.TaskTypes {
 		acceptTasks[taskType] = struct{}{}
@@ -116,7 +116,7 @@ func newLocalWorker(executor ExecutorFunc, wcfg WorkerConfig, envLookup EnvFunc,
 	}
 
 	if w.executor == nil {
-		w.executor = w.ffiExec
+		w.executor = FFIExec()
 	}
 
 	unfinished, err := w.ct.unfinished()
@@ -143,7 +143,7 @@ func newLocalWorker(executor ExecutorFunc, wcfg WorkerConfig, envLookup EnvFunc,
 }
 
 func NewLocalWorker(wcfg WorkerConfig, store paths.Store, local *paths.Local, sindex paths.SectorIndex, ret storiface.WorkerReturn, cst *statestore.StateStore) *LocalWorker {
-	return newLocalWorker(nil, wcfg, os.LookupEnv, store, local, sindex, ret, cst)
+	return NewLocalWorkerWithExecutor(nil, wcfg, os.LookupEnv, store, local, sindex, ret, cst)
 }
 
 type localWorkerPathProvider struct {
@@ -180,12 +180,14 @@ func (l *localWorkerPathProvider) AcquireSector(ctx context.Context, sector stor
 	}, nil
 }
 
-func (l *localWorkerPathProvider) AcquireSectorCopy(ctx context.Context, id storiface.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, ptype storiface.PathType) (storiface.SectorPaths, func(), error) {
-	return (&localWorkerPathProvider{w: l.w, op: storiface.AcquireCopy}).AcquireSector(ctx, id, existing, allocate, ptype)
+func FFIExec(opts ...ffiwrapper.FFIWrapperOpt) func(l *LocalWorker) (storiface.Storage, error) {
+	return func(l *LocalWorker) (storiface.Storage, error) {
+		return ffiwrapper.New(&localWorkerPathProvider{w: l}, opts...)
+	}
 }
 
-func (l *LocalWorker) ffiExec() (storiface.Storage, error) {
-	return ffiwrapper.New(&localWorkerPathProvider{w: l})
+func (l *localWorkerPathProvider) AcquireSectorCopy(ctx context.Context, id storiface.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, ptype storiface.PathType) (storiface.SectorPaths, func(), error) {
+	return (&localWorkerPathProvider{w: l.w, op: storiface.AcquireCopy}).AcquireSector(ctx, id, existing, allocate, ptype)
 }
 
 type ReturnType string
@@ -343,7 +345,7 @@ func doReturn(ctx context.Context, rt ReturnType, ci storiface.CallID, ret stori
 }
 
 func (l *LocalWorker) NewSector(ctx context.Context, sector storiface.SectorRef) error {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return err
 	}
@@ -352,7 +354,7 @@ func (l *LocalWorker) NewSector(ctx context.Context, sector storiface.SectorRef)
 }
 
 func (l *LocalWorker) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -363,7 +365,7 @@ func (l *LocalWorker) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSi
 }
 
 func (l *LocalWorker) AddPiece(ctx context.Context, sector storiface.SectorRef, epcs []abi.UnpaddedPieceSize, sz abi.UnpaddedPieceSize, r io.Reader) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -398,7 +400,7 @@ func (l *LocalWorker) SealPreCommit1(ctx context.Context, sector storiface.Secto
 			}
 		}
 
-		sb, err := l.executor()
+		sb, err := l.executor(l)
 		if err != nil {
 			return nil, err
 		}
@@ -408,7 +410,7 @@ func (l *LocalWorker) SealPreCommit1(ctx context.Context, sector storiface.Secto
 }
 
 func (l *LocalWorker) SealPreCommit2(ctx context.Context, sector storiface.SectorRef, phase1Out storiface.PreCommit1Out) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -419,7 +421,7 @@ func (l *LocalWorker) SealPreCommit2(ctx context.Context, sector storiface.Secto
 }
 
 func (l *LocalWorker) SealCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storiface.SectorCids) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -430,7 +432,7 @@ func (l *LocalWorker) SealCommit1(ctx context.Context, sector storiface.SectorRe
 }
 
 func (l *LocalWorker) SealCommit2(ctx context.Context, sector storiface.SectorRef, phase1Out storiface.Commit1Out) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -441,7 +443,7 @@ func (l *LocalWorker) SealCommit2(ctx context.Context, sector storiface.SectorRe
 }
 
 func (l *LocalWorker) ReplicaUpdate(ctx context.Context, sector storiface.SectorRef, pieces []abi.PieceInfo) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -453,7 +455,7 @@ func (l *LocalWorker) ReplicaUpdate(ctx context.Context, sector storiface.Sector
 }
 
 func (l *LocalWorker) ProveReplicaUpdate1(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -464,7 +466,7 @@ func (l *LocalWorker) ProveReplicaUpdate1(ctx context.Context, sector storiface.
 }
 
 func (l *LocalWorker) ProveReplicaUpdate2(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storiface.ReplicaVanillaProofs) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -475,7 +477,7 @@ func (l *LocalWorker) ProveReplicaUpdate2(ctx context.Context, sector storiface.
 }
 
 func (l *LocalWorker) GenerateSectorKeyFromData(ctx context.Context, sector storiface.SectorRef, commD cid.Cid) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -486,7 +488,7 @@ func (l *LocalWorker) GenerateSectorKeyFromData(ctx context.Context, sector stor
 }
 
 func (l *LocalWorker) FinalizeSector(ctx context.Context, sector storiface.SectorRef) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -497,7 +499,7 @@ func (l *LocalWorker) FinalizeSector(ctx context.Context, sector storiface.Secto
 }
 
 func (l *LocalWorker) FinalizeReplicaUpdate(ctx context.Context, sector storiface.SectorRef) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -508,7 +510,7 @@ func (l *LocalWorker) FinalizeReplicaUpdate(ctx context.Context, sector storifac
 }
 
 func (l *LocalWorker) ReleaseUnsealed(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -564,7 +566,7 @@ func (l *LocalWorker) MoveStorage(ctx context.Context, sector storiface.SectorRe
 }
 
 func (l *LocalWorker) UnsealPiece(ctx context.Context, sector storiface.SectorRef, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, cid cid.Cid) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -591,7 +593,7 @@ func (l *LocalWorker) UnsealPiece(ctx context.Context, sector storiface.SectorRe
 }
 
 func (l *LocalWorker) DownloadSectorData(ctx context.Context, sector storiface.SectorRef, finalized bool, src map[storiface.SectorFileType]storiface.SectorLocation) (storiface.CallID, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.UndefCall, err
 	}
@@ -602,7 +604,7 @@ func (l *LocalWorker) DownloadSectorData(ctx context.Context, sector storiface.S
 }
 
 func (l *LocalWorker) GenerateWinningPoSt(ctx context.Context, ppt abi.RegisteredPoStProof, mid abi.ActorID, sectors []storiface.PostSectorChallenge, randomness abi.PoStRandomness) ([]proof.PoStProof, error) {
-	sb, err := l.executor()
+	sb, err := l.executor(l)
 	if err != nil {
 		return nil, err
 	}
@@ -647,7 +649,11 @@ func (l *LocalWorker) GenerateWinningPoSt(ctx context.Context, ppt abi.Registere
 }
 
 func (l *LocalWorker) GenerateWindowPoSt(ctx context.Context, ppt abi.RegisteredPoStProof, mid abi.ActorID, sectors []storiface.PostSectorChallenge, partitionIdx int, randomness abi.PoStRandomness) (storiface.WindowPoStResult, error) {
-	sb, err := l.executor()
+	return l.GenerateWindowPoStAdv(ctx, ppt, mid, sectors, partitionIdx, randomness, false)
+}
+
+func (l *LocalWorker) GenerateWindowPoStAdv(ctx context.Context, ppt abi.RegisteredPoStProof, mid abi.ActorID, sectors []storiface.PostSectorChallenge, partitionIdx int, randomness abi.PoStRandomness, allowSkip bool) (storiface.WindowPoStResult, error) {
+	sb, err := l.executor(l)
 	if err != nil {
 		return storiface.WindowPoStResult{}, err
 	}
@@ -701,7 +707,7 @@ func (l *LocalWorker) GenerateWindowPoSt(ctx context.Context, ppt abi.Registered
 	}
 	wg.Wait()
 
-	if len(skipped) > 0 {
+	if len(skipped) > 0 && !allowSkip {
 		// This should happen rarely because before entering GenerateWindowPoSt we check all sectors by reading challenges.
 		// When it does happen, window post runner logic will just re-check sectors, and retry with newly-discovered-bad sectors skipped
 		log.Errorf("couldn't read some challenges (skipped %d)", len(skipped))
@@ -710,6 +716,22 @@ func (l *LocalWorker) GenerateWindowPoSt(ctx context.Context, ppt abi.Registered
 		return storiface.WindowPoStResult{Skipped: skipped}, nil
 	}
 
+	// compact skipped sectors
+	var skippedSoFar int
+	for i := range vproofs {
+		if len(vproofs[i]) == 0 {
+			skippedSoFar++
+			continue
+		}
+
+		if skippedSoFar > 0 {
+			vproofs[i-skippedSoFar] = vproofs[i]
+		}
+	}
+
+	vproofs = vproofs[:len(vproofs)-skippedSoFar]
+
+	// compute the PoSt!
 	res, err := sb.GenerateWindowPoStWithVanilla(ctx, ppt, mid, randomness, vproofs, partitionIdx)
 	r := storiface.WindowPoStResult{
 		PoStProofs: res,
@@ -800,6 +822,7 @@ func (l *LocalWorker) Info(context.Context) (storiface.WorkerInfo, error) {
 	if err != nil {
 		log.Errorf("getting gpu devices failed: %+v", err)
 	}
+	log.Infow("Detected GPU devices.", "count", len(gpus))
 
 	memPhysical, memUsed, memSwap, memSwapUsed, err := l.memInfo()
 	if err != nil {
diff --git a/storage/wdpost/wdpost_changehandler.go b/storage/wdpost/wdpost_changehandler.go
index 5f4b0ca0c..ce58f1489 100644
--- a/storage/wdpost/wdpost_changehandler.go
+++ b/storage/wdpost/wdpost_changehandler.go
@@ -20,9 +20,9 @@ const (
 type CompleteGeneratePoSTCb func(posts []miner.SubmitWindowedPoStParams, err error)
 type CompleteSubmitPoSTCb func(err error)
 
-// wdPoStCommands is the subset of the WindowPoStScheduler + full node APIs used
+// WdPoStCommands is the subset of the WindowPoStScheduler + full node APIs used
 // by the changeHandler to execute actions and query state.
-type wdPoStCommands interface {
+type WdPoStCommands interface {
 	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
 
 	startGeneratePoST(ctx context.Context, ts *types.TipSet, deadline *dline.Info, onComplete CompleteGeneratePoSTCb) context.CancelFunc
@@ -32,13 +32,13 @@ type wdPoStCommands interface {
 }
 
 type changeHandler struct {
-	api        wdPoStCommands
+	api        WdPoStCommands
 	actor      address.Address
 	proveHdlr  *proveHandler
 	submitHdlr *submitHandler
 }
 
-func newChangeHandler(api wdPoStCommands, actor address.Address) *changeHandler {
+func newChangeHandler(api WdPoStCommands, actor address.Address) *changeHandler {
 	posts := newPostsCache()
 	p := newProver(api, posts)
 	s := newSubmitter(api, posts)
@@ -148,7 +148,7 @@ type postResult struct {
 
 // proveHandler generates proofs
 type proveHandler struct {
-	api   wdPoStCommands
+	api   WdPoStCommands
 	posts *postsCache
 
 	postResults chan *postResult
@@ -165,7 +165,7 @@ type proveHandler struct {
 }
 
 func newProver(
-	api wdPoStCommands,
+	api WdPoStCommands,
 	posts *postsCache,
 ) *proveHandler {
 	ctx, cancel := context.WithCancel(context.Background())
@@ -230,7 +230,7 @@ func (p *proveHandler) processHeadChange(ctx context.Context, newTS *types.TipSe
 	// next post window
 	_, complete := p.posts.get(di)
 	for complete {
-		di = nextDeadline(di)
+		di = NextDeadline(di)
 		_, complete = p.posts.get(di)
 	}
 
@@ -297,7 +297,7 @@ type postInfo struct {
 
 // submitHandler submits proofs on-chain
 type submitHandler struct {
-	api   wdPoStCommands
+	api   WdPoStCommands
 	posts *postsCache
 
 	submitResults chan *submitResult
@@ -321,7 +321,7 @@ type submitHandler struct {
 }
 
 func newSubmitter(
-	api wdPoStCommands,
+	api WdPoStCommands,
 	posts *postsCache,
 ) *submitHandler {
 	ctx, cancel := context.WithCancel(context.Background())
@@ -525,8 +525,8 @@ func (s *submitHandler) getPostWindow(di *dline.Info) *postWindow {
 	return <-out
 }
 
-// nextDeadline gets deadline info for the subsequent deadline
-func nextDeadline(currentDeadline *dline.Info) *dline.Info {
+// NextDeadline gets deadline info for the subsequent deadline
+func NextDeadline(currentDeadline *dline.Info) *dline.Info {
 	periodStart := currentDeadline.PeriodStart
 	newDeadline := currentDeadline.Index + 1
 	if newDeadline == miner.WPoStPeriodDeadlines {
diff --git a/storage/wdpost/wdpost_changehandler_test.go b/storage/wdpost/wdpost_changehandler_test.go
index dac6c4558..44d0dfe6d 100644
--- a/storage/wdpost/wdpost_changehandler_test.go
+++ b/storage/wdpost/wdpost_changehandler_test.go
@@ -441,7 +441,7 @@ func TestChangeHandlerStartProvingNextDeadline(t *testing.T) {
 	// Trigger head change that advances the chain to the Challenge epoch for
 	// the next deadline
 	go func() {
-		di = nextDeadline(di)
+		di = NextDeadline(di)
 		currentEpoch = di.Challenge + ChallengeConfidence
 		triggerHeadAdvance(t, s, currentEpoch)
 	}()
@@ -474,7 +474,7 @@ func TestChangeHandlerProvingRounds(t *testing.T) {
 		<-s.ch.proveHdlr.processedHeadChanges
 
 		completeProofEpoch := di.Open + completeProofIndex
-		next := nextDeadline(di)
+		next := NextDeadline(di)
 		//fmt.Println("epoch", currentEpoch, s.mock.getPostStatus(di), "next", s.mock.getPostStatus(next))
 		if currentEpoch >= next.Challenge {
 			require.Equal(t, postStatusComplete, s.mock.getPostStatus(di))
@@ -962,7 +962,7 @@ func TestChangeHandlerSubmitRevertTwoEpochs(t *testing.T) {
 	require.Equal(t, postStatusComplete, s.mock.getPostStatus(diE1))
 
 	// Move to the challenge epoch for the next deadline
-	diE2 := nextDeadline(diE1)
+	diE2 := NextDeadline(diE1)
 	currentEpoch = diE2.Challenge + ChallengeConfidence
 	go triggerHeadAdvance(t, s, currentEpoch)
 
@@ -1067,7 +1067,7 @@ func TestChangeHandlerSubmitRevertAdvanceLess(t *testing.T) {
 	require.Equal(t, postStatusComplete, s.mock.getPostStatus(diE1))
 
 	// Move to the challenge epoch for the next deadline
-	diE2 := nextDeadline(diE1)
+	diE2 := NextDeadline(diE1)
 	currentEpoch = diE2.Challenge + ChallengeConfidence
 	go triggerHeadAdvance(t, s, currentEpoch)
 
diff --git a/storage/wdpost/wdpost_nextdl_test.go b/storage/wdpost/wdpost_nextdl_test.go
index d591c1e88..ef140de30 100644
--- a/storage/wdpost/wdpost_nextdl_test.go
+++ b/storage/wdpost/wdpost_nextdl_test.go
@@ -24,7 +24,7 @@ func TestNextDeadline(t *testing.T) {
 
 	for i := 1; i < 1+int(minertypes.WPoStPeriodDeadlines)*2; i++ {
 		//stm: @WDPOST_NEXT_DEADLINE_001
-		di = nextDeadline(di)
+		di = NextDeadline(di)
 		deadlineIdx = i % int(minertypes.WPoStPeriodDeadlines)
 		expPeriodStart := int(minertypes.WPoStProvingPeriod) * (i / int(minertypes.WPoStPeriodDeadlines))
 		expOpen := expPeriodStart + deadlineIdx*int(minertypes.WPoStChallengeWindow)
diff --git a/storage/wdpost/wdpost_run.go b/storage/wdpost/wdpost_run.go
index d70d0254f..edc088ccf 100644
--- a/storage/wdpost/wdpost_run.go
+++ b/storage/wdpost/wdpost_run.go
@@ -32,6 +32,8 @@ import (
 )
 
 // recordPoStFailure records a failure in the journal.
+//
+//nolint:unused
 func (s *WindowPoStScheduler) recordPoStFailure(err error, ts *types.TipSet, deadline *dline.Info) {
 	s.journal.RecordEvent(s.evtTypes[evtTypeWdPoStScheduler], func() interface{} {
 		c := evtCommon{Error: err}
@@ -311,6 +313,7 @@ func (s *WindowPoStScheduler) runPoStCycle(ctx context.Context, manual bool, di
 	// allowed in a single message
 	partitionBatches, err := s.BatchPartitions(partitions, nv)
 	if err != nil {
+		log.Errorf("batch partitions failed: %+v", err)
 		return nil, err
 	}
 
@@ -648,7 +651,7 @@ func (s *WindowPoStScheduler) submitPoStMessage(ctx context.Context, proof *mine
 		Params: enc,
 		Value:  types.NewInt(0),
 	}
-	spec := &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee)}
+	spec := &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee), MaximizeFeeCap: s.feeCfg.MaximizeWindowPoStFeeCap}
 	if err := s.prepareMessage(ctx, msg, spec); err != nil {
 		return nil, err
 	}
diff --git a/storage/wdpost/wdpost_run_faults.go b/storage/wdpost/wdpost_run_faults.go
index ebdd66a69..3a41cc4cc 100644
--- a/storage/wdpost/wdpost_run_faults.go
+++ b/storage/wdpost/wdpost_run_faults.go
@@ -168,11 +168,11 @@ func (s *WindowPoStScheduler) declareRecoveries(ctx context.Context, dlIdx uint6
 			Params: enc,
 			Value:  types.NewInt(0),
 		}
-		spec := &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee)}
+		spec := &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee), MaximizeFeeCap: s.feeCfg.MaximizeWindowPoStFeeCap}
 		if err := s.prepareMessage(ctx, msg, spec); err != nil {
 			return nil, nil, err
 		}
-		sm, err := s.api.MpoolPushMessage(ctx, msg, &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee)})
+		sm, err := s.api.MpoolPushMessage(ctx, msg, spec)
 		if err != nil {
 			return nil, nil, xerrors.Errorf("pushing message to mpool: %w", err)
 		}
@@ -195,106 +195,6 @@ func (s *WindowPoStScheduler) declareRecoveries(ctx context.Context, dlIdx uint6
 	return batchedRecoveryDecls, msgs, nil
 }
 
-// declareFaults identifies the sectors on the specified proving deadline that
-// are faulty, and reports the faults on chain via the `DeclareFaults` message
-// to our miner actor.
-//
-// NOTE: THIS CODE ISN'T INVOKED AFTER THE IGNITION UPGRADE
-// This is always invoked ahead of time, before the deadline for the evaluated
-// sectors arrives. That way, faults are declared before a penalty is accrued.
-//
-// If a declaration is made, it awaits for build.MessageConfidence confirmations
-// on chain before returning.
-//
-// TODO: the waiting should happen in the background. Right now this
-//
-//	is blocking/delaying the actual generation and submission of WindowPoSts in
-//	this deadline!
-func (s *WindowPoStScheduler) declareFaults(ctx context.Context, dlIdx uint64, partitions []api.Partition, tsk types.TipSetKey) ([]miner.FaultDeclaration, *types.SignedMessage, error) {
-	ctx, span := trace.StartSpan(ctx, "storage.declareFaults")
-	defer span.End()
-
-	bad := uint64(0)
-	params := &miner.DeclareFaultsParams{
-		Faults: []miner.FaultDeclaration{},
-	}
-
-	for partIdx, partition := range partitions {
-		nonFaulty, err := bitfield.SubtractBitField(partition.LiveSectors, partition.FaultySectors)
-		if err != nil {
-			return nil, nil, xerrors.Errorf("determining non faulty sectors: %w", err)
-		}
-
-		good, err := s.checkSectors(ctx, nonFaulty, tsk)
-		if err != nil {
-			return nil, nil, xerrors.Errorf("checking sectors: %w", err)
-		}
-
-		newFaulty, err := bitfield.SubtractBitField(nonFaulty, good)
-		if err != nil {
-			return nil, nil, xerrors.Errorf("calculating faulty sector set: %w", err)
-		}
-
-		c, err := newFaulty.Count()
-		if err != nil {
-			return nil, nil, xerrors.Errorf("counting faulty sectors: %w", err)
-		}
-
-		if c == 0 {
-			continue
-		}
-
-		bad += c
-
-		params.Faults = append(params.Faults, miner.FaultDeclaration{
-			Deadline:  dlIdx,
-			Partition: uint64(partIdx),
-			Sectors:   newFaulty,
-		})
-	}
-
-	faults := params.Faults
-	if len(faults) == 0 {
-		return faults, nil, nil
-	}
-
-	log.Errorw("DETECTED FAULTY SECTORS, declaring faults", "count", bad)
-
-	enc, aerr := actors.SerializeParams(params)
-	if aerr != nil {
-		return faults, nil, xerrors.Errorf("could not serialize declare faults parameters: %w", aerr)
-	}
-
-	msg := &types.Message{
-		To:     s.actor,
-		Method: builtin.MethodsMiner.DeclareFaults,
-		Params: enc,
-		Value:  types.NewInt(0), // TODO: Is there a fee?
-	}
-	spec := &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee)}
-	if err := s.prepareMessage(ctx, msg, spec); err != nil {
-		return faults, nil, err
-	}
-
-	sm, err := s.api.MpoolPushMessage(ctx, msg, spec)
-	if err != nil {
-		return faults, sm, xerrors.Errorf("pushing message to mpool: %w", err)
-	}
-
-	log.Warnw("declare faults Message CID", "cid", sm.Cid())
-
-	rec, err := s.api.StateWaitMsg(context.TODO(), sm.Cid(), build.MessageConfidence, api.LookbackNoLimit, true)
-	if err != nil {
-		return faults, sm, xerrors.Errorf("declare faults wait error: %w", err)
-	}
-
-	if rec.Receipt.ExitCode != 0 {
-		return faults, sm, xerrors.Errorf("declare faults wait non-0 exit code: %d", rec.Receipt.ExitCode)
-	}
-
-	return faults, sm, nil
-}
-
 func (s *WindowPoStScheduler) asyncFaultRecover(di dline.Info, ts *types.TipSet) {
 	go func() {
 		// check faults / recoveries for the *next* deadline. It's already too
diff --git a/storage/wdpost/wdpost_sched.go b/storage/wdpost/wdpost_sched.go
index 8e2a8bc96..bbf4596fe 100644
--- a/storage/wdpost/wdpost_sched.go
+++ b/storage/wdpost/wdpost_sched.go
@@ -23,6 +23,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/journal"
 	"github.com/filecoin-project/lotus/node/config"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/storage/ctladdr"
 	"github.com/filecoin-project/lotus/storage/sealer"
 	"github.com/filecoin-project/lotus/storage/sealer/storiface"
@@ -33,6 +34,7 @@ var log = logging.Logger("wdpost")
 type NodeAPI interface {
 	ChainHead(context.Context) (*types.TipSet, error)
 	ChainNotify(context.Context) (<-chan []*api.HeadChange, error)
+	ChainGetTipSet(context.Context, types.TipSetKey) (*types.TipSet, error)
 
 	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (api.MinerInfo, error)
 	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
@@ -86,6 +88,11 @@ type WindowPoStScheduler struct {
 	// failLk sync.Mutex
 }
 
+type ActorInfo struct {
+	address.Address
+	api.MinerInfo
+}
+
 // NewWindowedPoStScheduler creates a new WindowPoStScheduler scheduler.
 func NewWindowedPoStScheduler(api NodeAPI,
 	cfg config.MinerFeeConfig,
@@ -95,12 +102,18 @@ func NewWindowedPoStScheduler(api NodeAPI,
 	verif storiface.Verifier,
 	ft sealer.FaultTracker,
 	j journal.Journal,
-	actor address.Address) (*WindowPoStScheduler, error) {
-	mi, err := api.StateMinerInfo(context.TODO(), actor, types.EmptyTSK)
-	if err != nil {
-		return nil, xerrors.Errorf("getting sector size: %w", err)
+	actors []dtypes.MinerAddress) (*WindowPoStScheduler, error) {
+	var actorInfos []ActorInfo
+
+	for _, actor := range actors {
+		mi, err := api.StateMinerInfo(context.TODO(), address.Address(actor), types.EmptyTSK)
+		if err != nil {
+			return nil, xerrors.Errorf("getting sector size: %w", err)
+		}
+		actorInfos = append(actorInfos, ActorInfo{address.Address(actor), mi})
 	}
 
+	// TODO I punted here knowing that actorInfos will be consumed differently later.
 	return &WindowPoStScheduler{
 		api:                                     api,
 		feeCfg:                                  cfg,
@@ -108,13 +121,13 @@ func NewWindowedPoStScheduler(api NodeAPI,
 		prover:                                  sp,
 		verifier:                                verif,
 		faultTracker:                            ft,
-		proofType:                               mi.WindowPoStProofType,
-		partitionSectors:                        mi.WindowPoStPartitionSectors,
+		proofType:                               actorInfos[0].WindowPoStProofType,
+		partitionSectors:                        actorInfos[0].WindowPoStPartitionSectors,
+		actor:                                   address.Address(actors[0]),
 		disablePreChecks:                        pcfg.DisableWDPoStPreChecks,
 		maxPartitionsPerPostMessage:             pcfg.MaxPartitionsPerPoStMessage,
 		maxPartitionsPerRecoveryMessage:         pcfg.MaxPartitionsPerRecoveryMessage,
 		singleRecoveringPartitionPerPostMessage: pcfg.SingleRecoveringPartitionPerPostMessage,
-		actor:                                   actor,
 		evtTypes: [...]journal.EventType{
 			evtTypeWdPoStScheduler:  j.RegisterEventType("wdpost", "scheduler"),
 			evtTypeWdPoStProofs:     j.RegisterEventType("wdpost", "proofs_processed"),
@@ -126,8 +139,6 @@ func NewWindowedPoStScheduler(api NodeAPI,
 }
 
 func (s *WindowPoStScheduler) Run(ctx context.Context) {
-	// Initialize change handler.
-
 	// callbacks is a union of the fullNodeFilteredAPI and ourselves.
 	callbacks := struct {
 		NodeAPI
@@ -224,6 +235,8 @@ func (s *WindowPoStScheduler) update(ctx context.Context, revert, apply *types.T
 }
 
 // onAbort is called when generating proofs or submitting proofs is aborted
+//
+//nolint:unused
 func (s *WindowPoStScheduler) onAbort(ts *types.TipSet, deadline *dline.Info) {
 	s.journal.RecordEvent(s.evtTypes[evtTypeWdPoStScheduler], func() interface{} {
 		c := evtCommon{}