use msgindex as epoch=>tipsetkey index to speed up eth_getBlockByNumber queries

Include execution tipset in GetMsgInfo
This commit updates the GetMsgInfo to include the execution tipset of the message (if it exists). This allows us to call GetTipSetByCid instead of GetTipsetByHeight which should be considerably faster and help speed up both StateSearcMessage and StateWaitForMessage calls.
2023-05-26 09:10:40 -05:00 · 2023-04-06 14:30:54 +02:00 · 2023-04-05 12:04:51 -04:00 · 2023-04-05 11:23:55 -04:00 · 2023-04-04 14:07:36 -06:00 · 2023-04-04 13:53:23 -04:00
345 changed files with 13389 additions and 6382 deletions
@@ -7,14 +7,19 @@ executors:
  golang:
    docker:
      # Must match GO_VERSION_MIN in project root
-      - image: cimg/go:1.18.8
+      - image: cimg/go:1.19.7
+    resource_class: medium+
+  golang-2xl:
+    docker:
+      # Must match GO_VERSION_MIN in project root
+      - image: cimg/go:1.19.7
    resource_class: 2xlarge
  ubuntu:
    docker:
      - image: ubuntu:20.04

 commands:
-  prepare:
+  build-platform-specific:
    parameters:
      linux:
        default: true
@@ -31,22 +36,13 @@ commands:
    steps:
      - checkout
      - git_fetch_all_tags
+      - run: git submodule sync
+      - run: git submodule update --init
      - when:
          condition: <<parameters.linux>>
          steps:
-            - run:
-                name: Check Go Version
-                command: |
-                  v=`go version | { read _ _ v _; echo ${v#go}; }`
-                  if [[ $v != `cat GO_VERSION_MIN` ]]; then
-                    echo "GO_VERSION_MIN file does not match the go version being used."
-                    echo "Please update image to cimg/go:`cat GO_VERSION_MIN` or update GO_VERSION_MIN to $v."
-                    exit 1
-                  fi
-            - run: sudo apt-get update
-            - run: sudo apt-get install ocl-icd-opencl-dev libhwloc-dev
-            - run: sudo apt-get install python-is-python3
-
+            - install-ubuntu-deps
+            - check-go-version
      - when:
          condition: <<parameters.darwin>>
          steps:
@@ -67,8 +63,7 @@ commands:
                name: Install Rust
                command: |
                  curl https://sh.rustup.rs -sSf | sh -s -- -y
-      - run: git submodule sync
-      - run: git submodule update --init
+      - run: make deps lotus
  download-params:
    steps:
      - restore_cache:
@@ -77,7 +72,7 @@ commands:
            - 'v26-2k-lotus-params'
          paths:
            - /var/tmp/filecoin-proof-parameters/
-      - run:  ./lotus fetch-params 2048
+      - run: ./lotus fetch-params 2048
      - save_cache:
          name: Save parameters cache
          key: 'v26-2k-lotus-params'
@@ -99,12 +94,43 @@ commands:
          name: fetch all tags
          command: |
            git fetch --all
+  install-ubuntu-deps:
+    steps:
+      - run: sudo apt-get update
+      - run: sudo apt-get install ocl-icd-opencl-dev libhwloc-dev
+  check-go-version:
+    steps:
+      - run: |
+          v=`go version | { read _ _ v _; echo ${v#go}; }`
+          if [[ $v != `cat GO_VERSION_MIN` ]]; then
+            echo "GO_VERSION_MIN file does not match the go version being used."
+            echo "Please update image to cimg/go:`cat GO_VERSION_MIN` or update GO_VERSION_MIN to $v."
+            exit 1
+          fi

 jobs:
+  build:
+    executor: golang
+    working_directory: ~/lotus
+    steps:
+      - checkout
+      - git_fetch_all_tags
+      - run: git submodule sync
+      - run: git submodule update --init
+      - install-ubuntu-deps
+      - check-go-version
+      - run: make deps lotus
+      - persist_to_workspace:
+          root: ~/
+          paths:
+            - "lotus"
  mod-tidy-check:
    executor: golang
+    working_directory: ~/lotus
    steps:
-      - prepare
+      - install-ubuntu-deps
+      - attach_workspace:
+          at: ~/
      - run: go mod tidy -v
      - run:
          name: Check git diff
@@ -115,13 +141,14 @@ jobs:
  test:
    description: |
      Run tests with gotestsum.
+    working_directory: ~/lotus
    parameters: &test-params
      executor:
        type: executor
        default: golang
      go-test-flags:
        type: string
-        default: "-timeout 30m"
+        default: "-timeout 20m"
        description: Flags passed to go test.
      target:
        type: string
@@ -130,21 +157,22 @@ jobs:
      proofs-log-test:
        type: string
        default: "0"
+      get-params:
+        type: boolean
+        default: false
      suite:
        type: string
        default: unit
        description: Test suite name to report to CircleCI.
-      gotestsum-format:
-        type: string
-        default: standard-verbose
-        description: gotestsum format. https://github.com/gotestyourself/gotestsum#format
    executor: << parameters.executor >>
    steps:
-      - prepare
-      - run:
-          command: make deps lotus
-          no_output_timeout: 30m
-      - download-params
+      - install-ubuntu-deps
+      - attach_workspace:
+          at: ~/
+      - when:
+          condition: << parameters.get-params >>
+          steps:
+            - download-params
      - run:
          name: go test
          environment:
@@ -155,12 +183,11 @@ jobs:
            mkdir -p /tmp/test-reports/<< parameters.suite >>
            mkdir -p /tmp/test-artifacts
            gotestsum \
-              --format << parameters.gotestsum-format >> \
+              --format standard-verbose \
              --junitfile /tmp/test-reports/<< parameters.suite >>/junit.xml \
              --jsonfile /tmp/test-artifacts/<< parameters.suite >>.json \
-              -- \
-              << parameters.go-test-flags >> \
-              << parameters.target >>
+              --packages="<< parameters.target >>" \
+              -- << parameters.go-test-flags >>
          no_output_timeout: 30m
      - store_test_results:
          path: /tmp/test-reports
@@ -168,6 +195,7 @@ jobs:
          path: /tmp/test-artifacts/<< parameters.suite >>.json

  test-conformance:
+    working_directory: ~/lotus
    description: |
      Run tests using a corpus of interoperable test vectors for Filecoin
      implementations to test their correctness and compliance with the Filecoin
@@ -183,10 +211,9 @@ jobs:
          submodule is used.
    executor: << parameters.executor >>
    steps:
-      - prepare
-      - run:
-          command: make deps lotus
-          no_output_timeout: 30m
+      - install-ubuntu-deps
+      - attach_workspace:
+          at: ~/
      - download-params
      - when:
          condition:
@@ -229,7 +256,7 @@ jobs:
  build-linux-amd64:
    executor: golang
    steps:
-      - prepare
+      - build-platform-specific
      - run: make lotus lotus-miner lotus-worker
      - run:
          name: check tag and version output match
@@ -248,7 +275,7 @@ jobs:
    macos:
      xcode: "13.4.1"
    steps:
-      - prepare:
+      - build-platform-specific:
          linux: false
          darwin: true
          darwin-architecture: amd64
@@ -272,7 +299,7 @@ jobs:
    resource_class: filecoin-project/self-hosted-m1
    steps:
      - run: echo 'export PATH=/opt/homebrew/bin:"$PATH"' >> "$BASH_ENV"
-      - prepare:
+      - build-platform-specific:
          linux: false
          darwin: true
          darwin-architecture: arm64
@@ -330,16 +357,18 @@ jobs:

  gofmt:
    executor: golang
+    working_directory: ~/lotus
    steps:
-      - prepare
      - run:
          command: "! go fmt ./... 2>&1 | read"

  gen-check:
    executor: golang
+    working_directory: ~/lotus
    steps:
-      - prepare
-      - run: make deps
+      - install-ubuntu-deps
+      - attach_workspace:
+          at: ~/
      - run: go install golang.org/x/tools/cmd/goimports
      - run: go install github.com/hannahhoward/cbor-gen-for
      - run: make gen
@@ -349,32 +378,29 @@ jobs:

  docs-check:
    executor: golang
+    working_directory: ~/lotus
    steps:
-      - prepare
+      - install-ubuntu-deps
+      - attach_workspace:
+          at: ~/
      - run: go install golang.org/x/tools/cmd/goimports
      - run: zcat build/openrpc/full.json.gz | jq > ../pre-openrpc-full
      - run: zcat build/openrpc/miner.json.gz | jq > ../pre-openrpc-miner
      - run: zcat build/openrpc/worker.json.gz | jq > ../pre-openrpc-worker
-      - run: make deps
      - run: make docsgen
      - run: zcat build/openrpc/full.json.gz | jq > ../post-openrpc-full
      - run: zcat build/openrpc/miner.json.gz | jq > ../post-openrpc-miner
      - run: zcat build/openrpc/worker.json.gz | jq > ../post-openrpc-worker
      - run: diff ../pre-openrpc-full ../post-openrpc-full && diff ../pre-openrpc-miner ../post-openrpc-miner && diff ../pre-openrpc-worker ../post-openrpc-worker && git --no-pager diff && git --no-pager diff --quiet

-  lint: &lint
+  lint-all:
    description: |
      Run golangci-lint.
+    working_directory: ~/lotus
    parameters:
      executor:
        type: executor
        default: golang
-      concurrency:
-        type: string
-        default: '2'
-        description: |
-          Concurrency used to run linters. Defaults to 2 because NumCPU is not
-          aware of container CPU limits.
      args:
        type: string
        default: ''
@@ -382,17 +408,14 @@ jobs:
          Arguments to pass to golangci-lint
    executor: << parameters.executor >>
    steps:
-      - prepare
-      - run:
-          command: make deps
-          no_output_timeout: 30m
+      - install-ubuntu-deps
+      - attach_workspace:
+          at: ~/
      - run:
          name: Lint
          command: |
-            golangci-lint run -v --timeout 2m \
-              --concurrency << parameters.concurrency >> << parameters.args >>
-  lint-all:
-    <<: *lint
+            golangci-lint run -v --timeout 10m \
+              --concurrency 4 << parameters.args >>

  build-docker:
    description: >
@@ -494,437 +517,551 @@ jobs:
                      extra_build_args: --target <<parameters.image>> --build-arg GOFLAGS=-tags=<<parameters.network>>

 workflows:
-  version: 2.1
  ci:
    jobs:
+      - build
      - lint-all:
-          concurrency: "16"   # expend all docker 2xlarge CPUs.
-      - mod-tidy-check
-      - gofmt
-      - gen-check
-      - docs-check
+          requires:
+            - build
+      - mod-tidy-check:
+          requires:
+            - build
+      - gofmt:
+          requires:
+            - build
+      - gen-check:
+          requires:
+            - build
+      - docs-check:
+          requires:
+            - build
      - test:
          name: test-itest-api
+          requires:
+            - build
          suite: itest-api
          target: "./itests/api_test.go"
-      
      - test:
          name: test-itest-batch_deal
+          requires:
+            - build
          suite: itest-batch_deal
          target: "./itests/batch_deal_test.go"
-      
      - test:
          name: test-itest-ccupgrade
+          requires:
+            - build
          suite: itest-ccupgrade
          target: "./itests/ccupgrade_test.go"
-      
      - test:
          name: test-itest-cli
+          requires:
+            - build
          suite: itest-cli
          target: "./itests/cli_test.go"
-      
      - test:
          name: test-itest-deadlines
+          requires:
+            - build
          suite: itest-deadlines
          target: "./itests/deadlines_test.go"
-      
      - test:
          name: test-itest-deals_512mb
+          requires:
+            - build
          suite: itest-deals_512mb
          target: "./itests/deals_512mb_test.go"
-      
      - test:
          name: test-itest-deals_anycid
+          requires:
+            - build
          suite: itest-deals_anycid
          target: "./itests/deals_anycid_test.go"
-      
      - test:
          name: test-itest-deals_concurrent
+          requires:
+            - build
          suite: itest-deals_concurrent
          target: "./itests/deals_concurrent_test.go"
-      
+          executor: golang-2xl
      - test:
          name: test-itest-deals_invalid_utf8_label
+          requires:
+            - build
          suite: itest-deals_invalid_utf8_label
          target: "./itests/deals_invalid_utf8_label_test.go"
-      
      - test:
          name: test-itest-deals_max_staging_deals
+          requires:
+            - build
          suite: itest-deals_max_staging_deals
          target: "./itests/deals_max_staging_deals_test.go"
-      
      - test:
          name: test-itest-deals_offline
+          requires:
+            - build
          suite: itest-deals_offline
          target: "./itests/deals_offline_test.go"
-      
      - test:
          name: test-itest-deals_padding
+          requires:
+            - build
          suite: itest-deals_padding
          target: "./itests/deals_padding_test.go"
-      
      - test:
          name: test-itest-deals_partial_retrieval_dm-level
+          requires:
+            - build
          suite: itest-deals_partial_retrieval_dm-level
          target: "./itests/deals_partial_retrieval_dm-level_test.go"
-      
      - test:
          name: test-itest-deals_partial_retrieval
+          requires:
+            - build
          suite: itest-deals_partial_retrieval
          target: "./itests/deals_partial_retrieval_test.go"
-      
      - test:
          name: test-itest-deals_power
+          requires:
+            - build
          suite: itest-deals_power
          target: "./itests/deals_power_test.go"
-      
      - test:
          name: test-itest-deals_pricing
+          requires:
+            - build
          suite: itest-deals_pricing
          target: "./itests/deals_pricing_test.go"
-      
      - test:
          name: test-itest-deals_publish
+          requires:
+            - build
          suite: itest-deals_publish
          target: "./itests/deals_publish_test.go"
-      
      - test:
          name: test-itest-deals_remote_retrieval
+          requires:
+            - build
          suite: itest-deals_remote_retrieval
          target: "./itests/deals_remote_retrieval_test.go"
-      
      - test:
          name: test-itest-deals_retry_deal_no_funds
+          requires:
+            - build
          suite: itest-deals_retry_deal_no_funds
          target: "./itests/deals_retry_deal_no_funds_test.go"
-      
      - test:
          name: test-itest-deals
+          requires:
+            - build
          suite: itest-deals
          target: "./itests/deals_test.go"
-      
      - test:
          name: test-itest-decode_params
+          requires:
+            - build
          suite: itest-decode_params
          target: "./itests/decode_params_test.go"
-      
      - test:
          name: test-itest-dup_mpool_messages
+          requires:
+            - build
          suite: itest-dup_mpool_messages
          target: "./itests/dup_mpool_messages_test.go"
-      
      - test:
          name: test-itest-eth_account_abstraction
+          requires:
+            - build
          suite: itest-eth_account_abstraction
          target: "./itests/eth_account_abstraction_test.go"
-      
      - test:
          name: test-itest-eth_api
+          requires:
+            - build
          suite: itest-eth_api
          target: "./itests/eth_api_test.go"
-      
      - test:
          name: test-itest-eth_balance
+          requires:
+            - build
          suite: itest-eth_balance
          target: "./itests/eth_balance_test.go"
-      
      - test:
          name: test-itest-eth_block_hash
+          requires:
+            - build
          suite: itest-eth_block_hash
          target: "./itests/eth_block_hash_test.go"
-      
      - test:
          name: test-itest-eth_bytecode
+          requires:
+            - build
          suite: itest-eth_bytecode
          target: "./itests/eth_bytecode_test.go"
-      
      - test:
          name: test-itest-eth_config
+          requires:
+            - build
          suite: itest-eth_config
          target: "./itests/eth_config_test.go"
-      
      - test:
          name: test-itest-eth_conformance
+          requires:
+            - build
          suite: itest-eth_conformance
          target: "./itests/eth_conformance_test.go"
-      
      - test:
          name: test-itest-eth_deploy
+          requires:
+            - build
          suite: itest-eth_deploy
          target: "./itests/eth_deploy_test.go"
-      
      - test:
          name: test-itest-eth_fee_history
+          requires:
+            - build
          suite: itest-eth_fee_history
          target: "./itests/eth_fee_history_test.go"
-      
      - test:
          name: test-itest-eth_filter
+          requires:
+            - build
          suite: itest-eth_filter
          target: "./itests/eth_filter_test.go"
-      
      - test:
          name: test-itest-eth_hash_lookup
+          requires:
+            - build
          suite: itest-eth_hash_lookup
          target: "./itests/eth_hash_lookup_test.go"
-      
      - test:
          name: test-itest-eth_transactions
+          requires:
+            - build
          suite: itest-eth_transactions
          target: "./itests/eth_transactions_test.go"
-      
      - test:
          name: test-itest-fevm_address
+          requires:
+            - build
          suite: itest-fevm_address
          target: "./itests/fevm_address_test.go"
-      
      - test:
          name: test-itest-fevm_events
+          requires:
+            - build
          suite: itest-fevm_events
          target: "./itests/fevm_events_test.go"
-      
      - test:
          name: test-itest-fevm
+          requires:
+            - build
          suite: itest-fevm
          target: "./itests/fevm_test.go"
-      
      - test:
          name: test-itest-gas_estimation
+          requires:
+            - build
          suite: itest-gas_estimation
          target: "./itests/gas_estimation_test.go"
-      
      - test:
          name: test-itest-gateway
+          requires:
+            - build
          suite: itest-gateway
          target: "./itests/gateway_test.go"
-      
      - test:
          name: test-itest-get_messages_in_ts
+          requires:
+            - build
          suite: itest-get_messages_in_ts
          target: "./itests/get_messages_in_ts_test.go"
-      
      - test:
          name: test-itest-lite_migration
+          requires:
+            - build
          suite: itest-lite_migration
          target: "./itests/lite_migration_test.go"
-      
      - test:
          name: test-itest-lookup_robust_address
+          requires:
+            - build
          suite: itest-lookup_robust_address
          target: "./itests/lookup_robust_address_test.go"
-      
      - test:
          name: test-itest-mempool
+          requires:
+            - build
          suite: itest-mempool
          target: "./itests/mempool_test.go"
-      
      - test:
          name: test-itest-migration_nv17
+          requires:
+            - build
          suite: itest-migration_nv17
          target: "./itests/migration_nv17_test.go"
-      
      - test:
          name: test-itest-migration_nv18
+          requires:
+            - build
          suite: itest-migration_nv18
          target: "./itests/migration_nv18_test.go"
-      
      - test:
          name: test-itest-mpool_msg_uuid
+          requires:
+            - build
          suite: itest-mpool_msg_uuid
          target: "./itests/mpool_msg_uuid_test.go"
-      
      - test:
          name: test-itest-mpool_push_with_uuid
+          requires:
+            - build
          suite: itest-mpool_push_with_uuid
          target: "./itests/mpool_push_with_uuid_test.go"
-      
+      - test:
+          name: test-itest-msgindex
+          requires:
+            - build
+          suite: itest-msgindex
+          target: "./itests/msgindex_test.go"
      - test:
          name: test-itest-multisig
+          requires:
+            - build
          suite: itest-multisig
          target: "./itests/multisig_test.go"
-      
      - test:
          name: test-itest-net
+          requires:
+            - build
          suite: itest-net
          target: "./itests/net_test.go"
-      
      - test:
          name: test-itest-nonce
+          requires:
+            - build
          suite: itest-nonce
          target: "./itests/nonce_test.go"
-      
      - test:
          name: test-itest-path_detach_redeclare
+          requires:
+            - build
          suite: itest-path_detach_redeclare
          target: "./itests/path_detach_redeclare_test.go"
-      
      - test:
          name: test-itest-path_type_filters
+          requires:
+            - build
          suite: itest-path_type_filters
          target: "./itests/path_type_filters_test.go"
-      
      - test:
          name: test-itest-paych_api
+          requires:
+            - build
          suite: itest-paych_api
          target: "./itests/paych_api_test.go"
-      
      - test:
          name: test-itest-paych_cli
+          requires:
+            - build
          suite: itest-paych_cli
          target: "./itests/paych_cli_test.go"
-      
      - test:
          name: test-itest-pending_deal_allocation
+          requires:
+            - build
          suite: itest-pending_deal_allocation
          target: "./itests/pending_deal_allocation_test.go"
-      
      - test:
          name: test-itest-raft_messagesigner
+          requires:
+            - build
          suite: itest-raft_messagesigner
          target: "./itests/raft_messagesigner_test.go"
-      
      - test:
          name: test-itest-remove_verifreg_datacap
+          requires:
+            - build
          suite: itest-remove_verifreg_datacap
          target: "./itests/remove_verifreg_datacap_test.go"
-      
      - test:
          name: test-itest-sdr_upgrade
+          requires:
+            - build
          suite: itest-sdr_upgrade
          target: "./itests/sdr_upgrade_test.go"
-      
      - test:
          name: test-itest-sector_finalize_early
+          requires:
+            - build
          suite: itest-sector_finalize_early
          target: "./itests/sector_finalize_early_test.go"
-      
      - test:
          name: test-itest-sector_import_full
+          requires:
+            - build
          suite: itest-sector_import_full
          target: "./itests/sector_import_full_test.go"
-      
      - test:
          name: test-itest-sector_import_simple
+          requires:
+            - build
          suite: itest-sector_import_simple
          target: "./itests/sector_import_simple_test.go"
-      
      - test:
          name: test-itest-sector_make_cc_avail
+          requires:
+            - build
          suite: itest-sector_make_cc_avail
          target: "./itests/sector_make_cc_avail_test.go"
-      
      - test:
          name: test-itest-sector_miner_collateral
+          requires:
+            - build
          suite: itest-sector_miner_collateral
          target: "./itests/sector_miner_collateral_test.go"
-      
      - test:
          name: test-itest-sector_numassign
+          requires:
+            - build
          suite: itest-sector_numassign
          target: "./itests/sector_numassign_test.go"
-      
      - test:
          name: test-itest-sector_pledge
+          requires:
+            - build
          suite: itest-sector_pledge
          target: "./itests/sector_pledge_test.go"
-      
      - test:
          name: test-itest-sector_prefer_no_upgrade
+          requires:
+            - build
          suite: itest-sector_prefer_no_upgrade
          target: "./itests/sector_prefer_no_upgrade_test.go"
-      
      - test:
          name: test-itest-sector_revert_available
+          requires:
+            - build
          suite: itest-sector_revert_available
          target: "./itests/sector_revert_available_test.go"
-      
      - test:
          name: test-itest-sector_terminate
+          requires:
+            - build
          suite: itest-sector_terminate
          target: "./itests/sector_terminate_test.go"
-      
      - test:
          name: test-itest-sector_unseal
+          requires:
+            - build
          suite: itest-sector_unseal
          target: "./itests/sector_unseal_test.go"
-      
      - test:
          name: test-itest-self_sent_txn
+          requires:
+            - build
          suite: itest-self_sent_txn
          target: "./itests/self_sent_txn_test.go"
-      
      - test:
          name: test-itest-splitstore
+          requires:
+            - build
          suite: itest-splitstore
          target: "./itests/splitstore_test.go"
-      
      - test:
          name: test-itest-tape
+          requires:
+            - build
          suite: itest-tape
          target: "./itests/tape_test.go"
-      
      - test:
          name: test-itest-verifreg
+          requires:
+            - build
          suite: itest-verifreg
          target: "./itests/verifreg_test.go"
-      
      - test:
          name: test-itest-wdpost_config
+          requires:
+            - build
          suite: itest-wdpost_config
          target: "./itests/wdpost_config_test.go"
-      
      - test:
          name: test-itest-wdpost_dispute
+          requires:
+            - build
          suite: itest-wdpost_dispute
          target: "./itests/wdpost_dispute_test.go"
-      
      - test:
          name: test-itest-wdpost_no_miner_storage
+          requires:
+            - build
          suite: itest-wdpost_no_miner_storage
          target: "./itests/wdpost_no_miner_storage_test.go"
-      
      - test:
          name: test-itest-wdpost
+          requires:
+            - build
          suite: itest-wdpost
          target: "./itests/wdpost_test.go"
-      
      - test:
          name: test-itest-wdpost_worker_config
+          requires:
+            - build
          suite: itest-wdpost_worker_config
          target: "./itests/wdpost_worker_config_test.go"
-      
+          executor: golang-2xl
      - test:
          name: test-itest-worker
+          requires:
+            - build
          suite: itest-worker
          target: "./itests/worker_test.go"
-      
+          executor: golang-2xl
      - test:
          name: test-itest-worker_upgrade
+          requires:
+            - build
          suite: itest-worker_upgrade
          target: "./itests/worker_upgrade_test.go"
-      
      - test:
          name: test-unit-cli
+          requires:
+            - build
          suite: utest-unit-cli
          target: "./cli/... ./cmd/... ./api/..."
+          get-params: true
      - 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: "./api/... ./blockstore/... ./build/... ./chain/... ./cli/... ./cmd/... ./conformance/... ./extern/... ./gateway/... ./journal/... ./lib/... ./markets/... ./node/... ./paychmgr/... ./storage/... ./tools/..."
+          executor: golang-2xl
      - test:
          name: test-unit-storage
+          requires:
+            - build
          suite: utest-unit-storage
          target: "./storage/... ./extern/..."
+          
      - test:
          go-test-flags: "-run=TestMulticoreSDR"
+          requires:
+            - build
          suite: multicore-sdr-check
          target: "./storage/sealer/ffiwrapper"
          proofs-log-test: "1"
      - test-conformance:
+          requires:
+            - build
          suite: conformance
          target: "./conformance"

@@ -7,14 +7,19 @@ executors:
  golang:
    docker:
      # Must match GO_VERSION_MIN in project root
-      - image: cimg/go:1.18.8
+      - image: cimg/go:1.19.7
+    resource_class: medium+
+  golang-2xl:
+    docker:
+      # Must match GO_VERSION_MIN in project root
+      - image: cimg/go:1.19.7
    resource_class: 2xlarge
  ubuntu:
    docker:
      - image: ubuntu:20.04

 commands:
-  prepare:
+  build-platform-specific:
    parameters:
      linux:
        default: true
@@ -31,22 +36,13 @@ commands:
    steps:
      - checkout
      - git_fetch_all_tags
+      - run: git submodule sync
+      - run: git submodule update --init
      - when:
          condition: <<parameters.linux>>
          steps:
-            - run:
-                name: Check Go Version
-                command: |
-                  v=`go version | { read _ _ v _; echo ${v#go}; }`
-                  if [["[[ $v != `cat GO_VERSION_MIN` ]]"]]; then
-                    echo "GO_VERSION_MIN file does not match the go version being used."
-                    echo "Please update image to cimg/go:`cat GO_VERSION_MIN` or update GO_VERSION_MIN to $v."
-                    exit 1
-                  fi
-            - run: sudo apt-get update
-            - run: sudo apt-get install ocl-icd-opencl-dev libhwloc-dev
-            - run: sudo apt-get install python-is-python3
-
+            - install-ubuntu-deps
+            - check-go-version
      - when:
          condition: <<parameters.darwin>>
          steps:
@@ -67,8 +63,7 @@ commands:
                name: Install Rust
                command: |
                  curl https://sh.rustup.rs -sSf | sh -s -- -y
-      - run: git submodule sync
-      - run: git submodule update --init
+      - run: make deps lotus
  download-params:
    steps:
      - restore_cache:
@@ -77,7 +72,7 @@ commands:
            - 'v26-2k-lotus-params'
          paths:
            - /var/tmp/filecoin-proof-parameters/
-      - run:  ./lotus fetch-params 2048
+      - run: ./lotus fetch-params 2048
      - save_cache:
          name: Save parameters cache
          key: 'v26-2k-lotus-params'
@@ -99,12 +94,43 @@ commands:
          name: fetch all tags
          command: |
            git fetch --all
+  install-ubuntu-deps:
+    steps:
+      - run: sudo apt-get update
+      - run: sudo apt-get install ocl-icd-opencl-dev libhwloc-dev
+  check-go-version:
+    steps:
+      - run: |
+          v=`go version | { read _ _ v _; echo ${v#go}; }`
+          if [["[[ $v != `cat GO_VERSION_MIN` ]]"]]; then
+            echo "GO_VERSION_MIN file does not match the go version being used."
+            echo "Please update image to cimg/go:`cat GO_VERSION_MIN` or update GO_VERSION_MIN to $v."
+            exit 1
+          fi

 jobs:
+  build:
+    executor: golang
+    working_directory: ~/lotus
+    steps:
+      - checkout
+      - git_fetch_all_tags
+      - run: git submodule sync
+      - run: git submodule update --init
+      - install-ubuntu-deps
+      - check-go-version
+      - run: make deps lotus
+      - persist_to_workspace:
+          root: ~/
+          paths:
+            - "lotus"
  mod-tidy-check:
    executor: golang
+    working_directory: ~/lotus
    steps:
-      - prepare
+      - install-ubuntu-deps
+      - attach_workspace:
+          at: ~/
      - run: go mod tidy -v
      - run:
          name: Check git diff
@@ -115,13 +141,14 @@ jobs:
  test:
    description: |
      Run tests with gotestsum.
+    working_directory: ~/lotus
    parameters: &test-params
      executor:
        type: executor
        default: golang
      go-test-flags:
        type: string
-        default: "-timeout 30m"
+        default: "-timeout 20m"
        description: Flags passed to go test.
      target:
        type: string
@@ -130,21 +157,22 @@ jobs:
      proofs-log-test:
        type: string
        default: "0"
+      get-params:
+        type: boolean
+        default: false
      suite:
        type: string
        default: unit
        description: Test suite name to report to CircleCI.
-      gotestsum-format:
-        type: string
-        default: standard-verbose
-        description: gotestsum format. https://github.com/gotestyourself/gotestsum#format
    executor: << parameters.executor >>
    steps:
-      - prepare
-      - run:
-          command: make deps lotus
-          no_output_timeout: 30m
-      - download-params
+      - install-ubuntu-deps
+      - attach_workspace:
+          at: ~/
+      - when:
+          condition: << parameters.get-params >>
+          steps:
+            - download-params
      - run:
          name: go test
          environment:
@@ -155,12 +183,11 @@ jobs:
            mkdir -p /tmp/test-reports/<< parameters.suite >>
            mkdir -p /tmp/test-artifacts
            gotestsum \
-              --format << parameters.gotestsum-format >> \
+              --format standard-verbose \
              --junitfile /tmp/test-reports/<< parameters.suite >>/junit.xml \
              --jsonfile /tmp/test-artifacts/<< parameters.suite >>.json \
-              -- \
-              << parameters.go-test-flags >> \
-              << parameters.target >>
+              --packages="<< parameters.target >>" \
+              -- << parameters.go-test-flags >>
          no_output_timeout: 30m
      - store_test_results:
          path: /tmp/test-reports
@@ -168,6 +195,7 @@ jobs:
          path: /tmp/test-artifacts/<< parameters.suite >>.json

  test-conformance:
+    working_directory: ~/lotus
    description: |
      Run tests using a corpus of interoperable test vectors for Filecoin
      implementations to test their correctness and compliance with the Filecoin
@@ -183,10 +211,9 @@ jobs:
          submodule is used.
    executor: << parameters.executor >>
    steps:
-      - prepare
-      - run:
-          command: make deps lotus
-          no_output_timeout: 30m
+      - install-ubuntu-deps
+      - attach_workspace:
+          at: ~/
      - download-params
      - when:
          condition:
@@ -229,7 +256,7 @@ jobs:
  build-linux-amd64:
    executor: golang
    steps:
-      - prepare
+      - build-platform-specific
      - run: make lotus lotus-miner lotus-worker
      - run:
          name: check tag and version output match
@@ -248,7 +275,7 @@ jobs:
    macos:
      xcode: "13.4.1"
    steps:
-      - prepare:
+      - build-platform-specific:
          linux: false
          darwin: true
          darwin-architecture: amd64
@@ -272,7 +299,7 @@ jobs:
    resource_class: filecoin-project/self-hosted-m1
    steps:
      - run: echo 'export PATH=/opt/homebrew/bin:"$PATH"' >> "$BASH_ENV"
-      - prepare:
+      - build-platform-specific:
          linux: false
          darwin: true
          darwin-architecture: arm64
@@ -330,16 +357,18 @@ jobs:

  gofmt:
    executor: golang
+    working_directory: ~/lotus
    steps:
-      - prepare
      - run:
          command: "! go fmt ./... 2>&1 | read"

  gen-check:
    executor: golang
+    working_directory: ~/lotus
    steps:
-      - prepare
-      - run: make deps
+      - install-ubuntu-deps
+      - attach_workspace:
+          at: ~/
      - run: go install golang.org/x/tools/cmd/goimports
      - run: go install github.com/hannahhoward/cbor-gen-for
      - run: make gen
@@ -349,32 +378,29 @@ jobs:

  docs-check:
    executor: golang
+    working_directory: ~/lotus
    steps:
-      - prepare
+      - install-ubuntu-deps
+      - attach_workspace:
+          at: ~/
      - run: go install golang.org/x/tools/cmd/goimports
      - run: zcat build/openrpc/full.json.gz | jq > ../pre-openrpc-full
      - run: zcat build/openrpc/miner.json.gz | jq > ../pre-openrpc-miner
      - run: zcat build/openrpc/worker.json.gz | jq > ../pre-openrpc-worker
-      - run: make deps
      - run: make docsgen
      - run: zcat build/openrpc/full.json.gz | jq > ../post-openrpc-full
      - run: zcat build/openrpc/miner.json.gz | jq > ../post-openrpc-miner
      - run: zcat build/openrpc/worker.json.gz | jq > ../post-openrpc-worker
      - run: diff ../pre-openrpc-full ../post-openrpc-full && diff ../pre-openrpc-miner ../post-openrpc-miner && diff ../pre-openrpc-worker ../post-openrpc-worker && git --no-pager diff && git --no-pager diff --quiet

-  lint: &lint
+  lint-all:
    description: |
      Run golangci-lint.
+    working_directory: ~/lotus
    parameters:
      executor:
        type: executor
        default: golang
-      concurrency:
-        type: string
-        default: '2'
-        description: |
-          Concurrency used to run linters. Defaults to 2 because NumCPU is not
-          aware of container CPU limits.
      args:
        type: string
        default: ''
@@ -382,17 +408,14 @@ jobs:
          Arguments to pass to golangci-lint
    executor: << parameters.executor >>
    steps:
-      - prepare
-      - run:
-          command: make deps
-          no_output_timeout: 30m
+      - install-ubuntu-deps
+      - attach_workspace:
+          at: ~/
      - run:
          name: Lint
          command: |
-            golangci-lint run -v --timeout 2m \
-              --concurrency << parameters.concurrency >> << parameters.args >>
-  lint-all:
-    <<: *lint
+            golangci-lint run -v --timeout 10m \
+              --concurrency 4 << parameters.args >>

  build-docker:
    description: >
@@ -494,37 +517,58 @@ jobs:
                      extra_build_args: --target <<parameters.image>> --build-arg GOFLAGS=-tags=<<parameters.network>>

 workflows:
-  version: 2.1
  ci:
    jobs:
+      - build
      - lint-all:
-          concurrency: "16"   # expend all docker 2xlarge CPUs.
-      - mod-tidy-check
-      - gofmt
-      - gen-check
-      - docs-check
+          requires:
+            - build
+      - mod-tidy-check:
+          requires:
+            - build
+      - gofmt:
+          requires:
+            - build
+      - gen-check:
+          requires:
+            - build
+      - docs-check:
+          requires:
+            - build

      [[- range $file := .ItestFiles -]]
      [[ with $name := $file | stripSuffix ]]
      - test:
          name: test-itest-[[ $name ]]
+          requires:
+            - build
          suite: itest-[[ $name ]]
          target: "./itests/[[ $file ]]"
-      [[ end ]]
-      [[- end -]]
+          [[- if or (eq $name "worker") (eq $name "deals_concurrent") (eq $name "wdpost_worker_config")]]
+          executor: golang-2xl
+          [[- end]]
+      [[- end ]][[- end]]

-      [[range $suite, $pkgs := .UnitSuites]]
+      [[- range $suite, $pkgs := .UnitSuites]]
      - test:
          name: test-[[ $suite ]]
+          requires:
+            - build
          suite: utest-[[ $suite ]]
          target: "[[ $pkgs ]]"
+          [[if eq $suite "unit-cli"]]get-params: true[[end]]
+          [[- if eq $suite "unit-rest"]]executor: golang-2xl[[end]]
      [[- end]]
      - test:
          go-test-flags: "-run=TestMulticoreSDR"
+          requires:
+            - build
          suite: multicore-sdr-check
          target: "./storage/sealer/ffiwrapper"
          proofs-log-test: "1"
      - test-conformance:
+          requires:
+            - build
          suite: conformance
          target: "./conformance"

@@ -9,15 +9,9 @@ body:
    options:
      - label: This is **not** a security-related bug/issue. If it is, please follow please follow the [security policy](https://github.com/filecoin-project/lotus/security/policy).
        required: true
-      - label: This is **not** a question or a support request. If you have any lotus related questions, please ask in the [lotus forum](https://github.com/filecoin-project/lotus/discussions).
-        required: true
-      - label: This is **not** a new feature request. If it is, please file a [feature request](https://github.com/filecoin-project/lotus/issues/new?assignees=&labels=need%2Ftriage%2Ckind%2Ffeature&template=feature_request.yml) instead.
-        required: true
-      - label: This is **not** an enhancement request. If it is, please file a [improvement suggestion](https://github.com/filecoin-project/lotus/issues/new?assignees=&labels=need%2Ftriage%2Ckind%2Fenhancement&template=enhancement.yml) instead.
-        required: true
      - label: I **have** searched on the [issue tracker](https://github.com/filecoin-project/lotus/issues) and the [lotus forum](https://github.com/filecoin-project/lotus/discussions), and there is no existing related issue or discussion.
        required: true
-      - label: I am running the [`Latest release`](https://github.com/filecoin-project/lotus/releases), or the most recent RC(release canadiate) for the upcoming release or the dev branch(master), or have an issue updating to any of these.
+      - label: I am running the [`Latest release`](https://github.com/filecoin-project/lotus/releases), the most recent RC(release canadiate) for the upcoming release or the dev branch(master), or have an issue updating to any of these.
        required: true
      - label: I did not make any code changes to lotus.
        required: false
@@ -28,19 +22,11 @@ body:
    options:
      - label: lotus daemon - chain sync
        required: false
-      - label: lotus miner - mining and block production
+      - label: lotus fvm/fevm - Lotus FVM and FEVM interactions
        required: false
      - label: lotus miner/worker - sealing
        required: false
-      - label: lotus miner - proving(WindowPoSt)
-        required: false
-      - label: lotus miner/market - storage deal
-        required: false
-      - label: lotus miner/market - retrieval deal
-        required: false
-      - label: lotus miner/market - data transfer
-        required: false
-      - label: lotus client
+      - label: lotus miner - proving(WindowPoSt/WinningPoSt)
        required: false
      - label: lotus JSON-RPC API
        required: false
@@ -56,22 +42,33 @@ body:
    description: Enter the output of `lotus version` and `lotus-miner version` if applicable.
    placeholder: |
      e.g. 
-      Daemon:1.11.0-rc2+debug+git.0519cd371.dirty+api1.3.0 
-      Local: lotus version 1.11.0-rc2+debug+git.0519cd371.dirty
+      Daemon:  1.19.0+mainnet+git.64059ca87+api1.5.0
+      Local: lotus-miner version 1.19.0+mainnet+git.64059ca87
  validations:
    required: true
+- type: textarea
+  id: ReproSteps
+  attributes:
+    label: Repro Steps
+    description: "Steps to reproduce the behavior"
+    value: |
+      1. Run '...'
+      2. Do '...'
+      3. See error '...'
+      ...
+  validations:
+    required: false
 - type: textarea
  id: Description
  attributes:
    label: Describe the Bug
    description: |
      This is where you get to tell us what went wrong, when doing so, please try to provide a clear and concise description of the bug with all related information:
-      * What you were doding when you experienced the bug?
+      * What you were doing when you experienced the bug?
      * Any *error* messages you saw, *where* you saw them, and what you believe may have caused them (if you have any ideas).
      * What is the expected behaviour?
      * For sealing issues, include the output of `lotus-miner sectors status --log <sectorId>` for the failed sector(s).
      * For proving issues, include the output of `lotus-miner proving` info.
-      * For deal making issues, include the output of `lotus client list-deals -v` and/or `lotus-miner storage-deals|retrieval-deals|data-transfers list [-v]` commands for the deal(s) in question.
  validations:
    required: true
 - type: textarea
@@ -83,18 +80,6 @@ body:
      Please provide debug logs of the problem, remember you can get set log level control for:
      * lotus: use `lotus log list` to get all log systems available and set level by `lotus log set-level`. An example can be found [here](https://lotus.filecoin.io/lotus/configure/defaults/#log-level-control).
      * lotus-miner:`lotus-miner log list` to get all log systems available and set level by `lotus-miner log set-level
-      If you don't provide detailed logs when you raise the issue it will almost certainly be the first request I make before furthur diagnosing the problem.
+      If you don't provide detailed logs when you raise the issue it will almost certainly be the first request we make before furthur diagnosing the problem.
  validations:
-    required: true
- type: textarea
-  id: RepoSteps
-  attributes:
-    label: Repo Steps
-    description: "Steps to reproduce the behavior"
-    value: |
-      1. Run '...'
-      2. Do '...'
-      3. See error '...'
-      ...
-  validations:
-    required: false
+    required: true
@@ -0,0 +1,8 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Ask a question about Lotus or get support
+    url: https://github.com/filecoin-project/lotus/discussions/new/choose
+    about: Ask a question or request support for using Lotus
+  - name: Filecoin protocol feature or enhancement
+    url: https://github.com/filecoin-project/FIPs/discussions/new/choose
+    about: Write a discussion in the Filecoin Improvement Proposal repo
@@ -7,13 +7,7 @@ body:
    label: Checklist
    description: Please check off the following boxes before continuing to create an improvement suggestion!
    options:
-      - label: This is **not** a new feature or an enhancement to the Filecoin protocol. If it is,  please open an [FIP issue](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0001.md).
-        required: true
-      - label: This is **not** a new feature request. If it is, please file a [feature request](https://github.com/filecoin-project/lotus/issues/new?assignees=&labels=need%2Ftriage%2Ckind%2Ffeature&template=feature_request.yml) instead.
-        required: true
-      - label: This is **not** brainstorming ideas. If you have an idea you'd like to discuss, please open a new discussion on [the lotus forum](https://github.com/filecoin-project/lotus/discussions/categories/ideas) and select the category as `Ideas`.
-        required: true
-      - label: I **have** a specific, actionable, and well motivated improvement to propose.
+      - label: I **have** a specific, actionable, and well motivated improvement to an existing lotus feature.
        required: true
 - type: checkboxes
  attributes:
@@ -22,19 +16,11 @@ body:
    options:
      - label: lotus daemon - chain sync
        required: false
-      - label: lotus miner - mining and block production
+      - label: lotus fvm/fevm - Lotus FVM and FEVM interactions
        required: false
      - label: lotus miner/worker - sealing
        required: false
-      - label: lotus miner - proving(WindowPoSt)
-        required: false
-      - label: lotus miner/market - storage deal
-        required: false
-      - label: lotus miner/market - retrieval deal
-        required: false
-      - label: lotus miner/market - data transfer
-        required: false
-      - label: lotus client
+      - label: lotus miner - proving(WindowPoSt/WinningPoSt)
        required: false
      - label: lotus JSON-RPC API
        required: false
@@ -45,9 +31,17 @@ body:
 - type: textarea
  id: request
  attributes:
-    label: Improvement Suggestion
-    description: A clear and concise description of what the motivation or the current problem is and what is the suggested improvement?
-    placeholder: Ex. Currently lotus... However, as a storage provider, I'd like...
+    label: Enhancement Suggestion
+    description: A clear and concise description of the suggested enhancement?
+    placeholder: Ex. Currently lotus... However it would be great if [enhancement] was implemented... With the ability to...
+  validations:
+    required: true
+- type: textarea
+  id: request
+  attributes:
+    label: Use-Case
+    description: How would this enhancement help you?
+    placeholder: Ex. With the [enhancement] node operators would be able to... For Storage Providers it would enable...
  validations:
    required: true

@@ -7,8 +7,6 @@ body:
    label: Checklist
    description: Please check off the following boxes before continuing to create a new feature request!
    options:
-      - label: This is **not** a new feature or an enhancement to the Filecoin protocol. If it is,  please open an [FIP issue](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0001.md).
-        required: true
      - label: This is **not** brainstorming ideas. If you have an idea you'd like to discuss, please open a new discussion on [the lotus forum](https://github.com/filecoin-project/lotus/discussions/categories/ideas) and select the category as `Ideas`.
        required: true
      - label: I **have** a specific, actionable, and well motivated feature request to propose.
@@ -20,19 +18,11 @@ body:
    options:
      - label: lotus daemon - chain sync
        required: false
-      - label: lotus miner - mining and block production
+      - label: lotus fvm/fevm - Lotus FVM and FEVM interactions
        required: false
      - label: lotus miner/worker - sealing
        required: false
-      - label: lotus miner - proving(WindowPoSt)
-        required: false
-      - label: lotus miner/market - storage deal
-        required: false
-      - label: lotus miner/market - retrieval deal
-        required: false
-      - label: lotus miner/market - data transfer
-        required: false
-      - label: lotus client
+      - label: lotus miner - proving(WindowPoSt/WinningPoSt)
        required: false
      - label: lotus JSON-RPC API
        required: false
@@ -56,7 +46,7 @@ body:
  validations:
    required: true
 - type: textarea
-  id: alternates
+  id: alternatives
  attributes:
    label: Describe alternatives you've considered
    description: A clear and concise description of any alternative solutions or features you've considered.
@@ -69,4 +59,3 @@ body:
    description: Add any other context, design docs or screenshots about the feature request here.
  validations:
    required: false
-
@@ -0,0 +1,83 @@
+name: "Bug Report - developer/service provider"
+description: "Bug report template about FEVM/FVM for developers/service providers"
+labels: [need/triage, kind/bug, area/fevm]
+body:
+- type: checkboxes
+  attributes:
+    label: Checklist
+    description: Please check off the following boxes before continuing to file a bug report!
+    options:
+      - label: This is **not** a security-related bug/issue. If it is, please follow please follow the [security policy](https://github.com/filecoin-project/lotus/security/policy).
+        required: true
+      - label: I **have** searched on the [issue tracker](https://github.com/filecoin-project/lotus/issues) and the [lotus forum](https://github.com/filecoin-project/lotus/discussions), and there is no existing related issue or discussion.
+        required: true
+      - label: I did not make any code changes to lotus.
+        required: false
+- type: checkboxes
+  attributes:
+    label: Lotus component
+    description: Please select the lotus component you are filing a bug for
+    options:
+      - label: lotus Ethereum RPC
+        required: false
+      - label: lotus FVM - Lotus FVM interactions
+        required: false
+      - label: FEVM tooling
+        required: false
+      - label:  Other
+        required: false
+- type: textarea
+  id: version
+  attributes:
+    label: Lotus Version
+    render: text
+    description: Enter the output of `lotus version` if applicable.
+    placeholder: |
+      e.g. 
+      Daemon:  1.19.0+mainnet+git.64059ca87+api1.5.0
+      Local: lotus-miner version 1.19.0+mainnet+git.64059ca87
+  validations:
+    required: true
+- type: textarea
+  id: repro
+  attributes:
+    label: Repro Steps
+    description: "Steps to reproduce the behavior"
+    value: |
+      1. Run '...'
+      2. Do '...'
+      3. See error '...'
+      ...
+  validations:
+    required: false
+- type: textarea
+  id: Description
+  attributes:
+    label: Describe the Bug
+    description: |
+      This is where you get to tell us what went wrong, when doing so, please try to provide a clear and concise description of the bug with all related information:
+      * What you were doing when you experienced the bug? What are you trying to build?
+      * Any *error* messages and logs you saw, *where* you saw them, and what you believe may have caused them (if you have any ideas).
+      * What is the expected behaviour? Links to the actual code?
+  validations:
+    required: true
+- type: textarea
+  id: toolingInfo
+  attributes:
+    label: Tooling
+    render: text
+    description: |
+      What kind of tooling are you using:
+      * Are you using ether.js, Alchemy, Hardhat, etc.
+  validations:
+    required: true
+- type: textarea
+  id: extraInfo
+  attributes:
+    label: Configuration Options
+    render: text
+    description: |
+      Please provide your updated FEVM related configuration options, or custome enviroment variables related to Lotus FEVM
+      * lotus: use `lotus config updated` to get your configuration options, and copy the [FEVM] section
+  validations:
+    required: true
@@ -1,5 +1,178 @@
 # Lotus changelog

+# UNRELEASED
+
+## Execution Trace Format Changes
+
+Execution traces (returned from `lotus state exec-trace`, `lotus state replay`, etc.), has changed to account for changes introduced by the FVM. Specifically:
+
+- The `Msg` field no longer matches the Filecoin message format as many of the message fields didn't make sense in on-chain sub-calls. Instead, it now has the fields `To`, `From`, `Value`, `Method`, `Params`, and `ParamsCodec` where `ParamsCodec` is a new field indicating the IPLD codec of the parameters.
+    - Importantly, the `Msg.CID` field has been removed. This field is still present in top-level invocation results, just not inside the execution trace itself.
+- The `MsgRct` field no longer includes a `GasUsed` field and now has a `ReturnCodec` field to indicating the IPLD codec of the return value.
+- The `Error` and `Duration` fields have been removed as these are not set by the FVM. The top-level message "invocation result" retains the `Error` and `Duration` fields, they've only been removed from the trace itself.
+- Gas Charges no longer include "virtual" gas fields (those starting with `v...`) or source location information (`loc`) as neither field is set by the FVM.
+
+A note on "codecs": FVM parameters and return values are IPLD blocks where the "codec" specifies the data encoding. The codec will generally be one of:
+
+- `0x51`, `0x71` - CBOR or DagCBOR. You should generally treat these as equivalent.
+- `0x55` - Raw bytes.
+- `0x00` - Nothing. If the codec is `0x00`, the parameter and/or return value should be empty and should be treated as "void" (not specified).
+
+<details>
+<summary>
+Old <code>ExecutionTrace</code>:
+</summary>
+
+```json
+{
+  "Msg": {
+    "Version": 0,
+    "To": "f01234",
+    "From": "f04321",
+    "Nonce": 1,
+    "Value": "0",
+    "GasLimit": 0,
+    "GasFeeCap": "1234",
+    "GasPremium": "1234",
+    "Method": 42,
+    "Params": "<base64-data-or-null>",
+    "CID": {
+        "/": "bafyxyz....."
+    },
+  },
+  "MsgRct": {
+    "ExitCode": 0,
+    "Return": "<base64-data-or-null>",
+    "GasUsed": 12345,
+  },
+  "Error": "",
+  "Duration": 568191845,
+  "GasCharges": [
+    {
+      "Name": "OnMethodInvocation",
+      "loc": null,
+      "tg": 23856,
+      "cg": 23856,
+      "sg": 0,
+      "vtg": 0,
+      "vcg": 0,
+      "vsg": 0,
+      "tt": 0
+    },
+    {
+      "Name": "wasm_exec",
+      "loc": null,
+      "tg": 1764,
+      "cg": 1764,
+      "sg": 0,
+      "vtg": 0,
+      "vcg": 0,
+      "vsg": 0,
+      "tt": 0
+    },
+    {
+      "Name": "OnSyscall",
+      "loc": null,
+      "tg": 14000,
+      "cg": 14000,
+      "sg": 0,
+      "vtg": 0,
+      "vcg": 0,
+      "vsg": 0,
+      "tt": 0
+    },
+  ],
+  "Subcalls": [
+    {
+      "Msg": { },
+      "MsgRct": { },
+      "Error": "",
+      "Duration": 1235,
+      "GasCharges": [],
+      "Subcalls": [],
+    },
+  ]
+}
+```
+</details>
+
+<details>
+<summary>
+New <code>ExecutionTrace</code>:
+</summary>
+
+```json
+{
+  "Msg": {
+    "To": "f01234",
+    "From": "f04321",
+    "Value": "0",
+    "Method": 42,
+    "Params": "<base64-data-or-null>",
+    "ParamsCodec": 81
+  },
+  "MsgRct": {
+    "ExitCode": 0,
+    "Return": "<base64-data-or-null>",
+    "ReturnCodec": 81
+  },
+  "GasCharges": [
+    {
+      "Name": "OnMethodInvocation",
+      "loc": null,
+      "tg": 23856,
+      "cg": 23856,
+      "tt": 0
+    },
+    {
+      "Name": "wasm_exec",
+      "loc": null,
+      "tg": 1764,
+      "cg": 1764,
+      "sg": 0,
+      "tt": 0
+    },
+    {
+      "Name": "OnSyscall",
+      "loc": null,
+      "tg": 14000,
+      "cg": 14000,
+      "sg": 0,
+      "tt": 0
+    },
+  ],
+  "Subcalls": [
+    {
+      "Msg": { },
+      "MsgRct": { },
+      "GasCharges": [],
+      "Subcalls": [],
+    },
+  ]
+}
+```
+
+</details>
+
+# v1.20.3 / 2023-03-09
+
+A 🐈 stepped on the ⌨️ and made a mistake while resolving conflicts 😨. This releases only includes #10439 to fix that mistake. v1.20.2 is retracted - Please skip v1.20.2 and **only** update to v1.20.3!!!
+
+## Changelog
+> compare to v1.20.1
+
+This is a HIGHLY RECOMMENDED patch release for node operators/API service providers that run ETH RPC service and an optional release for Storage Providers.
+
+## Bug fixes
+- fix: EthAPI: use StateCompute for feeHistory; apply minimum gas premium #10413
+- fix: eth API: return correct txIdx around null blocks #10419
+- fix: Eth API: make block parameter parsing sounder. #10427
+
+## Improvement
+- feat: Lotus Gateway: Add missing methods - master #10420
+- feat: mempool: Reduce minimum replace fee from 1.25x to 1.1x #10416
+- We recommend storage providers to update your nodes to this patch, that will help improve developers who use Ethereum tooling's experience.
+
 # v1.20.2 / 2023-03-09

 This is a HIGHLY RECOMMENDED patch release for node operators/API service providers that run ETH RPC service and an optional release for Storage Providers.
@@ -1,5 +1,5 @@
 #####################################
-FROM golang:1.18.8-buster AS lotus-builder
+FROM golang:1.19.7-buster AS lotus-builder
 MAINTAINER Lotus Development Team

 RUN apt-get update && apt-get install -y ca-certificates build-essential clang ocl-icd-opencl-dev ocl-icd-libopencl1 jq libhwloc-dev
@@ -1,6 +1,6 @@
 ##### DEPRECATED

-FROM golang:1.18.8-buster AS builder-deps
+FROM golang:1.19.7-buster AS builder-deps
 MAINTAINER Lotus Development Team

 RUN apt-get update && apt-get install -y ca-certificates build-essential clang ocl-icd-opencl-dev ocl-icd-libopencl1 jq libhwloc-dev
@@ -1 +1 @@
-1.18.8
+1.19.7
@@ -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.18.8 or higher](https://golang.org/dl/):
+To build Lotus, you need a working installation of [Go 1.19.7 or higher](https://golang.org/dl/):

 ```bash
-wget -c https://golang.org/dl/go1.18.8.linux-amd64.tar.gz -O - | sudo tar -xz -C /usr/local
+wget -c https://golang.org/dl/go1.19.7.linux-amd64.tar.gz -O - | sudo tar -xz -C /usr/local
 ```

 **TIP:**
@@ -13,7 +13,7 @@ import (

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
+	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-jsonrpc"
@@ -173,10 +173,24 @@ type FullNode interface {
 	// If oldmsgskip is set, messages from before the requested roots are also not included.
 	ChainExport(ctx context.Context, nroots abi.ChainEpoch, oldmsgskip bool, tsk types.TipSetKey) (<-chan []byte, error) //perm:read

-	// ChainPrune prunes the stored chain state and garbage collects; only supported if you
+	// ChainExportRangeInternal triggers the export of a chain
+	// CAR-snapshot directly to disk. It is similar to ChainExport,
+	// except, depending on options, the snapshot can include receipts,
+	// messages and stateroots for the length between the specified head
+	// and tail, thus producing "archival-grade" snapshots that include
+	// all the on-chain data.  The header chain is included back to
+	// genesis and these snapshots can be used to initialize Filecoin
+	// nodes.
+	ChainExportRangeInternal(ctx context.Context, head, tail types.TipSetKey, cfg ChainExportConfig) error //perm:admin
+
+	// ChainPrune forces compaction on cold store and garbage collects; only supported if you
 	// are using the splitstore
 	ChainPrune(ctx context.Context, opts PruneOpts) error //perm:admin

+	// ChainHotGC does online (badger) GC on the hot store; only supported if you are using
+	// the splitstore
+	ChainHotGC(ctx context.Context, opts HotGCOpts) error //perm:admin
+
 	// ChainCheckBlockstore performs an (asynchronous) health check on the chain/state blockstore
 	// if supported by the underlying implementation.
 	ChainCheckBlockstore(context.Context) error //perm:admin
@@ -283,8 +297,10 @@ type FullNode interface {
 	MpoolGetNonce(context.Context, address.Address) (uint64, error) //perm:read
 	MpoolSub(context.Context) (<-chan MpoolUpdate, error)           //perm:read

-	// MpoolClear clears pending messages from the mpool
-	MpoolClear(context.Context, bool) error //perm:write
+	// MpoolClear clears pending messages from the mpool.
+	// If clearLocal is true, ALL messages will be cleared.
+	// If clearLocal is false, local messages will be protected, all others will be cleared.
+	MpoolClear(ctx context.Context, clearLocal bool) error //perm:write

 	// MpoolGetConfig returns (a copy of) the current mpool config
 	MpoolGetConfig(context.Context) (*types.MpoolConfig, error) //perm:read
@@ -783,10 +799,12 @@ type FullNode interface {
 	EthGetBlockByHash(ctx context.Context, blkHash ethtypes.EthHash, fullTxInfo bool) (ethtypes.EthBlock, error)                               //perm:read
 	EthGetBlockByNumber(ctx context.Context, blkNum string, fullTxInfo bool) (ethtypes.EthBlock, error)                                        //perm:read
 	EthGetTransactionByHash(ctx context.Context, txHash *ethtypes.EthHash) (*ethtypes.EthTx, error)                                            //perm:read
+	EthGetTransactionByHashLimited(ctx context.Context, txHash *ethtypes.EthHash, limit abi.ChainEpoch) (*ethtypes.EthTx, error)               //perm:read
 	EthGetTransactionHashByCid(ctx context.Context, cid cid.Cid) (*ethtypes.EthHash, error)                                                    //perm:read
 	EthGetMessageCidByTransactionHash(ctx context.Context, txHash *ethtypes.EthHash) (*cid.Cid, error)                                         //perm:read
 	EthGetTransactionCount(ctx context.Context, sender ethtypes.EthAddress, blkOpt string) (ethtypes.EthUint64, error)                         //perm:read
 	EthGetTransactionReceipt(ctx context.Context, txHash ethtypes.EthHash) (*EthTxReceipt, error)                                              //perm:read
+	EthGetTransactionReceiptLimited(ctx context.Context, txHash ethtypes.EthHash, limit abi.ChainEpoch) (*EthTxReceipt, error)                 //perm:read
 	EthGetTransactionByBlockHashAndIndex(ctx context.Context, blkHash ethtypes.EthHash, txIndex ethtypes.EthUint64) (ethtypes.EthTx, error)    //perm:read
 	EthGetTransactionByBlockNumberAndIndex(ctx context.Context, blkNum ethtypes.EthUint64, txIndex ethtypes.EthUint64) (ethtypes.EthTx, error) //perm:read

@@ -1344,6 +1362,12 @@ type PruneOpts struct {
 	RetainState int64
 }

+type HotGCOpts struct {
+	Threshold float64
+	Periodic  bool
+	Moving    bool
+}
+
 type EthTxReceipt struct {
 	TransactionHash   ethtypes.EthHash     `json:"transactionHash"`
 	TransactionIndex  ethtypes.EthUint64   `json:"transactionIndex"`
@@ -26,13 +26,16 @@ import (
 // When adding / changing methods in this file:
 // * Do the change here
 // * Adjust implementation in `node/impl/`
-// * Run `make gen` - this will:
+// * Run `make clean && make deps && make gen` - this will:
 //  * Generate proxy structs
 //  * Generate mocks
 //  * Generate markdown docs
 //  * Generate openrpc blobs

 type Gateway interface {
+	StateMinerSectorCount(context.Context, address.Address, types.TipSetKey) (MinerSectors, error)
+	GasEstimateGasPremium(context.Context, uint64, address.Address, int64, types.TipSetKey) (types.BigInt, error)
+	StateReplay(context.Context, types.TipSetKey, cid.Cid) (*InvocResult, error)
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
 	ChainPutObj(context.Context, blocks.Block) error
 	ChainHead(ctx context.Context) (*types.TipSet, error)
@@ -70,6 +73,7 @@ type Gateway interface {
 	StateNetworkName(context.Context) (dtypes.NetworkName, error)
 	StateNetworkVersion(context.Context, types.TipSetKey) (apitypes.NetworkVersion, error)
 	StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error)
+	StateVerifierStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 	StateSearchMsg(ctx context.Context, from types.TipSetKey, msg cid.Cid, limit abi.ChainEpoch, allowReplaced bool) (*MsgLookup, error)
 	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64, limit abi.ChainEpoch, allowReplaced bool) (*MsgLookup, error)
@@ -84,12 +88,12 @@ type Gateway interface {
 	EthGetBlockByHash(ctx context.Context, blkHash ethtypes.EthHash, fullTxInfo bool) (ethtypes.EthBlock, error)
 	EthGetBlockByNumber(ctx context.Context, blkNum string, fullTxInfo bool) (ethtypes.EthBlock, error)
 	EthGetTransactionByHash(ctx context.Context, txHash *ethtypes.EthHash) (*ethtypes.EthTx, error)
+	EthGetTransactionByHashLimited(ctx context.Context, txHash *ethtypes.EthHash, limit abi.ChainEpoch) (*ethtypes.EthTx, error)
 	EthGetTransactionHashByCid(ctx context.Context, cid cid.Cid) (*ethtypes.EthHash, error)
 	EthGetMessageCidByTransactionHash(ctx context.Context, txHash *ethtypes.EthHash) (*cid.Cid, error)
 	EthGetTransactionCount(ctx context.Context, sender ethtypes.EthAddress, blkOpt string) (ethtypes.EthUint64, error)
 	EthGetTransactionReceipt(ctx context.Context, txHash ethtypes.EthHash) (*EthTxReceipt, error)
-	EthGetTransactionByBlockHashAndIndex(ctx context.Context, blkHash ethtypes.EthHash, txIndex ethtypes.EthUint64) (ethtypes.EthTx, error)
-	EthGetTransactionByBlockNumberAndIndex(ctx context.Context, blkNum ethtypes.EthUint64, txIndex ethtypes.EthUint64) (ethtypes.EthTx, error)
+	EthGetTransactionReceiptLimited(ctx context.Context, txHash ethtypes.EthHash, limit abi.ChainEpoch) (*EthTxReceipt, error)
 	EthGetCode(ctx context.Context, address ethtypes.EthAddress, blkOpt string) (ethtypes.EthBytes, error)
 	EthGetStorageAt(ctx context.Context, address ethtypes.EthAddress, position ethtypes.EthBytes, blkParam string) (ethtypes.EthBytes, error)
 	EthGetBalance(ctx context.Context, address ethtypes.EthAddress, blkParam string) (ethtypes.EthBigInt, error)
@@ -11,7 +11,7 @@ import (

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
+	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
 	"github.com/filecoin-project/go-fil-markets/piecestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
@@ -212,9 +212,11 @@ type StorageMiner interface {
 	StorageDetachLocal(ctx context.Context, path string) error                           //perm:admin
 	StorageRedeclareLocal(ctx context.Context, id *storiface.ID, dropMissing bool) error //perm:admin

-	MarketImportDealData(ctx context.Context, propcid cid.Cid, path string) error                                                                                                        //perm:write
-	MarketListDeals(ctx context.Context) ([]*MarketDeal, error)                                                                                                                          //perm:read
-	MarketListRetrievalDeals(ctx context.Context) ([]retrievalmarket.ProviderDealState, error)                                                                                           //perm:read
+	MarketImportDealData(ctx context.Context, propcid cid.Cid, path string) error //perm:write
+	MarketListDeals(ctx context.Context) ([]*MarketDeal, error)                   //perm:read
+
+	// MarketListRetrievalDeals is deprecated, returns empty list
+	MarketListRetrievalDeals(ctx context.Context) ([]struct{}, error)                                                                                                                    //perm:read
 	MarketGetDealUpdates(ctx context.Context) (<-chan storagemarket.MinerDeal, error)                                                                                                    //perm:read
 	MarketListIncompleteDeals(ctx context.Context) ([]storagemarket.MinerDeal, error)                                                                                                    //perm:read
 	MarketSetAsk(ctx context.Context, price types.BigInt, verifiedPrice types.BigInt, duration abi.ChainEpoch, minPieceSize abi.PaddedPieceSize, maxPieceSize abi.PaddedPieceSize) error //perm:admin
@@ -50,22 +50,6 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
 		return err
 	}

-	// t.WaitSentinel (cid.Cid) (struct)
-	if len("WaitSentinel") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"WaitSentinel\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("WaitSentinel"))); err != nil {
-		return err
-	}
-	if _, err := io.WriteString(w, string("WaitSentinel")); err != nil {
-		return err
-	}
-
-	if err := cbg.WriteCid(cw, t.WaitSentinel); err != nil {
-		return xerrors.Errorf("failed to write cid field t.WaitSentinel: %w", err)
-	}
-
 	// t.Vouchers ([]*paych.SignedVoucher) (slice)
 	if len("Vouchers") > cbg.MaxLength {
 		return xerrors.Errorf("Value in field \"Vouchers\" was too long")
@@ -90,6 +74,23 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
 			return err
 		}
 	}
+
+	// t.WaitSentinel (cid.Cid) (struct)
+	if len("WaitSentinel") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"WaitSentinel\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("WaitSentinel"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("WaitSentinel")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteCid(cw, t.WaitSentinel); err != nil {
+		return xerrors.Errorf("failed to write cid field t.WaitSentinel: %w", err)
+	}
+
 	return nil
 }

@@ -140,19 +141,6 @@ func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) (err error) {
 					return xerrors.Errorf("unmarshaling t.Channel: %w", err)
 				}

-			}
-			// t.WaitSentinel (cid.Cid) (struct)
-		case "WaitSentinel":
-
-			{
-
-				c, err := cbg.ReadCid(cr)
-				if err != nil {
-					return xerrors.Errorf("failed to read cid field t.WaitSentinel: %w", err)
-				}
-
-				t.WaitSentinel = c
-
 			}
 			// t.Vouchers ([]*paych.SignedVoucher) (slice)
 		case "Vouchers":
@@ -184,6 +172,20 @@ func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) (err error) {
 				t.Vouchers[i] = &v
 			}

+			// t.WaitSentinel (cid.Cid) (struct)
+		case "WaitSentinel":
+
+			{
+
+				c, err := cbg.ReadCid(cr)
+				if err != nil {
+					return xerrors.Errorf("failed to read cid field t.WaitSentinel: %w", err)
+				}
+
+				t.WaitSentinel = c
+
+			}
+
 		default:
 			// Field doesn't exist on this type, so ignore it
 			cbg.ScanForLinks(r, func(cid.Cid) {})
@@ -204,19 +206,19 @@ func (t *SealedRef) MarshalCBOR(w io.Writer) error {
 		return err
 	}

-	// t.SectorID (abi.SectorNumber) (uint64)
-	if len("SectorID") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"SectorID\" was too long")
+	// t.Size (abi.UnpaddedPieceSize) (uint64)
+	if len("Size") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Size\" was too long")
 	}

-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("SectorID"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Size"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, string("SectorID")); err != nil {
+	if _, err := io.WriteString(w, string("Size")); err != nil {
 		return err
 	}

-	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.SectorID)); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
 		return err
 	}

@@ -236,19 +238,19 @@ func (t *SealedRef) MarshalCBOR(w io.Writer) error {
 		return err
 	}

-	// t.Size (abi.UnpaddedPieceSize) (uint64)
-	if len("Size") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"Size\" was too long")
+	// t.SectorID (abi.SectorNumber) (uint64)
+	if len("SectorID") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"SectorID\" was too long")
 	}

-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Size"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("SectorID"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, string("Size")); err != nil {
+	if _, err := io.WriteString(w, string("SectorID")); err != nil {
 		return err
 	}

-	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.SectorID)); err != nil {
 		return err
 	}

@@ -293,8 +295,8 @@ func (t *SealedRef) UnmarshalCBOR(r io.Reader) (err error) {
 		}

 		switch name {
-		// t.SectorID (abi.SectorNumber) (uint64)
-		case "SectorID":
+		// t.Size (abi.UnpaddedPieceSize) (uint64)
+		case "Size":

 			{

@@ -305,7 +307,7 @@ func (t *SealedRef) UnmarshalCBOR(r io.Reader) (err error) {
 				if maj != cbg.MajUnsignedInt {
 					return fmt.Errorf("wrong type for uint64 field")
 				}
-				t.SectorID = abi.SectorNumber(extra)
+				t.Size = abi.UnpaddedPieceSize(extra)

 			}
 			// t.Offset (abi.PaddedPieceSize) (uint64)
@@ -323,8 +325,8 @@ func (t *SealedRef) UnmarshalCBOR(r io.Reader) (err error) {
 				t.Offset = abi.PaddedPieceSize(extra)

 			}
-			// t.Size (abi.UnpaddedPieceSize) (uint64)
-		case "Size":
+			// t.SectorID (abi.SectorNumber) (uint64)
+		case "SectorID":

 			{

@@ -335,7 +337,7 @@ func (t *SealedRef) UnmarshalCBOR(r io.Reader) (err error) {
 				if maj != cbg.MajUnsignedInt {
 					return fmt.Errorf("wrong type for uint64 field")
 				}
-				t.Size = abi.UnpaddedPieceSize(extra)
+				t.SectorID = abi.SectorNumber(extra)

 			}

@@ -474,6 +476,28 @@ func (t *SealTicket) MarshalCBOR(w io.Writer) error {
 		return err
 	}

+	// t.Epoch (abi.ChainEpoch) (int64)
+	if len("Epoch") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Epoch\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Epoch"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Epoch")); err != nil {
+		return err
+	}
+
+	if t.Epoch >= 0 {
+		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Epoch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Epoch-1)); err != nil {
+			return err
+		}
+	}
+
 	// t.Value (abi.SealRandomness) (slice)
 	if len("Value") > cbg.MaxLength {
 		return xerrors.Errorf("Value in field \"Value\" was too long")
@@ -497,28 +521,6 @@ func (t *SealTicket) MarshalCBOR(w io.Writer) error {
 	if _, err := cw.Write(t.Value[:]); err != nil {
 		return err
 	}
-
-	// t.Epoch (abi.ChainEpoch) (int64)
-	if len("Epoch") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"Epoch\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Epoch"))); err != nil {
-		return err
-	}
-	if _, err := io.WriteString(w, string("Epoch")); err != nil {
-		return err
-	}
-
-	if t.Epoch >= 0 {
-		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Epoch)); err != nil {
-			return err
-		}
-	} else {
-		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Epoch-1)); err != nil {
-			return err
-		}
-	}
 	return nil
 }

@@ -560,7 +562,33 @@ func (t *SealTicket) UnmarshalCBOR(r io.Reader) (err error) {
 		}

 		switch name {
-		// t.Value (abi.SealRandomness) (slice)
+		// t.Epoch (abi.ChainEpoch) (int64)
+		case "Epoch":
+			{
+				maj, extra, err := cr.ReadHeader()
+				var extraI int64
+				if err != nil {
+					return err
+				}
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
+					}
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative overflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
+				}
+
+				t.Epoch = abi.ChainEpoch(extraI)
+			}
+			// t.Value (abi.SealRandomness) (slice)
 		case "Value":

 			maj, extra, err = cr.ReadHeader()
@@ -582,32 +610,6 @@ func (t *SealTicket) UnmarshalCBOR(r io.Reader) (err error) {
 			if _, err := io.ReadFull(cr, t.Value[:]); err != nil {
 				return err
 			}
-			// t.Epoch (abi.ChainEpoch) (int64)
-		case "Epoch":
-			{
-				maj, extra, err := cr.ReadHeader()
-				var extraI int64
-				if err != nil {
-					return err
-				}
-				switch maj {
-				case cbg.MajUnsignedInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 positive overflow")
-					}
-				case cbg.MajNegativeInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 negative oveflow")
-					}
-					extraI = -1 - extraI
-				default:
-					return fmt.Errorf("wrong type for int64 field: %d", maj)
-				}
-
-				t.Epoch = abi.ChainEpoch(extraI)
-			}

 		default:
 			// Field doesn't exist on this type, so ignore it
@@ -629,6 +631,28 @@ func (t *SealSeed) MarshalCBOR(w io.Writer) error {
 		return err
 	}

+	// t.Epoch (abi.ChainEpoch) (int64)
+	if len("Epoch") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Epoch\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Epoch"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Epoch")); err != nil {
+		return err
+	}
+
+	if t.Epoch >= 0 {
+		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Epoch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Epoch-1)); err != nil {
+			return err
+		}
+	}
+
 	// t.Value (abi.InteractiveSealRandomness) (slice)
 	if len("Value") > cbg.MaxLength {
 		return xerrors.Errorf("Value in field \"Value\" was too long")
@@ -652,28 +676,6 @@ func (t *SealSeed) MarshalCBOR(w io.Writer) error {
 	if _, err := cw.Write(t.Value[:]); err != nil {
 		return err
 	}
-
-	// t.Epoch (abi.ChainEpoch) (int64)
-	if len("Epoch") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"Epoch\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Epoch"))); err != nil {
-		return err
-	}
-	if _, err := io.WriteString(w, string("Epoch")); err != nil {
-		return err
-	}
-
-	if t.Epoch >= 0 {
-		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Epoch)); err != nil {
-			return err
-		}
-	} else {
-		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Epoch-1)); err != nil {
-			return err
-		}
-	}
 	return nil
 }

@@ -715,7 +717,33 @@ func (t *SealSeed) UnmarshalCBOR(r io.Reader) (err error) {
 		}

 		switch name {
-		// t.Value (abi.InteractiveSealRandomness) (slice)
+		// t.Epoch (abi.ChainEpoch) (int64)
+		case "Epoch":
+			{
+				maj, extra, err := cr.ReadHeader()
+				var extraI int64
+				if err != nil {
+					return err
+				}
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
+					}
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative overflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
+				}
+
+				t.Epoch = abi.ChainEpoch(extraI)
+			}
+			// t.Value (abi.InteractiveSealRandomness) (slice)
 		case "Value":

 			maj, extra, err = cr.ReadHeader()
@@ -737,32 +765,6 @@ func (t *SealSeed) UnmarshalCBOR(r io.Reader) (err error) {
 			if _, err := io.ReadFull(cr, t.Value[:]); err != nil {
 				return err
 			}
-			// t.Epoch (abi.ChainEpoch) (int64)
-		case "Epoch":
-			{
-				maj, extra, err := cr.ReadHeader()
-				var extraI int64
-				if err != nil {
-					return err
-				}
-				switch maj {
-				case cbg.MajUnsignedInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 positive overflow")
-					}
-				case cbg.MajNegativeInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 negative oveflow")
-					}
-					extraI = -1 - extraI
-				default:
-					return fmt.Errorf("wrong type for int64 field: %d", maj)
-				}
-
-				t.Epoch = abi.ChainEpoch(extraI)
-			}

 		default:
 			// Field doesn't exist on this type, so ignore it
@@ -784,6 +786,22 @@ func (t *PieceDealInfo) MarshalCBOR(w io.Writer) error {
 		return err
 	}

+	// t.DealID (abi.DealID) (uint64)
+	if len("DealID") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"DealID\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("DealID"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("DealID")); err != nil {
+		return err
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.DealID)); err != nil {
+		return err
+	}
+
 	// t.PublishCid (cid.Cid) (struct)
 	if len("PublishCid") > cbg.MaxLength {
 		return xerrors.Errorf("Value in field \"PublishCid\" was too long")
@@ -806,22 +824,6 @@ func (t *PieceDealInfo) MarshalCBOR(w io.Writer) error {
 		}
 	}

-	// t.DealID (abi.DealID) (uint64)
-	if len("DealID") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"DealID\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("DealID"))); err != nil {
-		return err
-	}
-	if _, err := io.WriteString(w, string("DealID")); err != nil {
-		return err
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.DealID)); err != nil {
-		return err
-	}
-
 	// t.DealProposal (market.DealProposal) (struct)
 	if len("DealProposal") > cbg.MaxLength {
 		return xerrors.Errorf("Value in field \"DealProposal\" was too long")
@@ -910,7 +912,22 @@ func (t *PieceDealInfo) UnmarshalCBOR(r io.Reader) (err error) {
 		}

 		switch name {
-		// t.PublishCid (cid.Cid) (struct)
+		// t.DealID (abi.DealID) (uint64)
+		case "DealID":
+
+			{
+
+				maj, extra, err = cr.ReadHeader()
+				if err != nil {
+					return err
+				}
+				if maj != cbg.MajUnsignedInt {
+					return fmt.Errorf("wrong type for uint64 field")
+				}
+				t.DealID = abi.DealID(extra)
+
+			}
+			// t.PublishCid (cid.Cid) (struct)
 		case "PublishCid":

 			{
@@ -932,21 +949,6 @@ func (t *PieceDealInfo) UnmarshalCBOR(r io.Reader) (err error) {
 					t.PublishCid = &c
 				}

-			}
-			// t.DealID (abi.DealID) (uint64)
-		case "DealID":
-
-			{
-
-				maj, extra, err = cr.ReadHeader()
-				if err != nil {
-					return err
-				}
-				if maj != cbg.MajUnsignedInt {
-					return fmt.Errorf("wrong type for uint64 field")
-				}
-				t.DealID = abi.DealID(extra)
-
 			}
 			// t.DealProposal (market.DealProposal) (struct)
 		case "DealProposal":
@@ -1140,28 +1142,6 @@ func (t *DealSchedule) MarshalCBOR(w io.Writer) error {
 		return err
 	}

-	// t.StartEpoch (abi.ChainEpoch) (int64)
-	if len("StartEpoch") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"StartEpoch\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("StartEpoch"))); err != nil {
-		return err
-	}
-	if _, err := io.WriteString(w, string("StartEpoch")); err != nil {
-		return err
-	}
-
-	if t.StartEpoch >= 0 {
-		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.StartEpoch)); err != nil {
-			return err
-		}
-	} else {
-		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.StartEpoch-1)); err != nil {
-			return err
-		}
-	}
-
 	// t.EndEpoch (abi.ChainEpoch) (int64)
 	if len("EndEpoch") > cbg.MaxLength {
 		return xerrors.Errorf("Value in field \"EndEpoch\" was too long")
@@ -1183,6 +1163,28 @@ func (t *DealSchedule) MarshalCBOR(w io.Writer) error {
 			return err
 		}
 	}
+
+	// t.StartEpoch (abi.ChainEpoch) (int64)
+	if len("StartEpoch") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"StartEpoch\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("StartEpoch"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("StartEpoch")); err != nil {
+		return err
+	}
+
+	if t.StartEpoch >= 0 {
+		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.StartEpoch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.StartEpoch-1)); err != nil {
+			return err
+		}
+	}
 	return nil
 }

@@ -1224,33 +1226,7 @@ func (t *DealSchedule) UnmarshalCBOR(r io.Reader) (err error) {
 		}

 		switch name {
-		// t.StartEpoch (abi.ChainEpoch) (int64)
-		case "StartEpoch":
-			{
-				maj, extra, err := cr.ReadHeader()
-				var extraI int64
-				if err != nil {
-					return err
-				}
-				switch maj {
-				case cbg.MajUnsignedInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 positive overflow")
-					}
-				case cbg.MajNegativeInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 negative oveflow")
-					}
-					extraI = -1 - extraI
-				default:
-					return fmt.Errorf("wrong type for int64 field: %d", maj)
-				}
-
-				t.StartEpoch = abi.ChainEpoch(extraI)
-			}
-			// t.EndEpoch (abi.ChainEpoch) (int64)
+		// t.EndEpoch (abi.ChainEpoch) (int64)
 		case "EndEpoch":
 			{
 				maj, extra, err := cr.ReadHeader()
@@ -1267,7 +1243,7 @@ func (t *DealSchedule) 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:
@@ -1276,6 +1252,32 @@ func (t *DealSchedule) UnmarshalCBOR(r io.Reader) (err error) {

 				t.EndEpoch = abi.ChainEpoch(extraI)
 			}
+			// t.StartEpoch (abi.ChainEpoch) (int64)
+		case "StartEpoch":
+			{
+				maj, extra, err := cr.ReadHeader()
+				var extraI int64
+				if err != nil {
+					return err
+				}
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
+					}
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative overflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
+				}
+
+				t.StartEpoch = abi.ChainEpoch(extraI)
+			}

 		default:
 			// Field doesn't exist on this type, so ignore it
@@ -27,7 +27,7 @@ import (

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
+	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
 	"github.com/filecoin-project/go-fil-markets/filestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-jsonrpc/auth"
@@ -152,8 +152,8 @@ func init() {
 	addExample(map[string]int{"name": 42})
 	addExample(map[string]time.Time{"name": time.Unix(1615243938, 0).UTC()})
 	addExample(&types.ExecutionTrace{
-		Msg:    ExampleValue("init", reflect.TypeOf(&types.Message{}), nil).(*types.Message),
-		MsgRct: ExampleValue("init", reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
+		Msg:    ExampleValue("init", reflect.TypeOf(types.MessageTrace{}), nil).(types.MessageTrace),
+		MsgRct: ExampleValue("init", reflect.TypeOf(types.ReturnTrace{}), nil).(types.ReturnTrace),
 	})
 	addExample(map[string]types.Actor{
 		"t01236": ExampleValue("init", reflect.TypeOf(types.Actor{}), nil).(types.Actor),
@@ -21,7 +21,7 @@ import (

 	address "github.com/filecoin-project/go-address"
 	bitfield "github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
+	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
 	retrievalmarket "github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	jsonrpc "github.com/filecoin-project/go-jsonrpc"
 	auth "github.com/filecoin-project/go-jsonrpc/auth"
@@ -155,6 +155,20 @@ func (mr *MockFullNodeMockRecorder) ChainExport(arg0, arg1, arg2, arg3 interface
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainExport", reflect.TypeOf((*MockFullNode)(nil).ChainExport), arg0, arg1, arg2, arg3)
 }

+// ChainExportRangeInternal mocks base method.
+func (m *MockFullNode) ChainExportRangeInternal(arg0 context.Context, arg1, arg2 types.TipSetKey, arg3 api.ChainExportConfig) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ChainExportRangeInternal", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ChainExportRangeInternal indicates an expected call of ChainExportRangeInternal.
+func (mr *MockFullNodeMockRecorder) ChainExportRangeInternal(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainExportRangeInternal", reflect.TypeOf((*MockFullNode)(nil).ChainExportRangeInternal), arg0, arg1, arg2, arg3)
+}
+
 // ChainGetBlock mocks base method.
 func (m *MockFullNode) ChainGetBlock(arg0 context.Context, arg1 cid.Cid) (*types.BlockHeader, error) {
 	m.ctrl.T.Helper()
@@ -380,6 +394,20 @@ func (mr *MockFullNodeMockRecorder) ChainHead(arg0 interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainHead", reflect.TypeOf((*MockFullNode)(nil).ChainHead), arg0)
 }

+// ChainHotGC mocks base method.
+func (m *MockFullNode) ChainHotGC(arg0 context.Context, arg1 api.HotGCOpts) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ChainHotGC", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ChainHotGC indicates an expected call of ChainHotGC.
+func (mr *MockFullNodeMockRecorder) ChainHotGC(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainHotGC", reflect.TypeOf((*MockFullNode)(nil).ChainHotGC), arg0, arg1)
+}
+
 // ChainNotify mocks base method.
 func (m *MockFullNode) ChainNotify(arg0 context.Context) (<-chan []*api.HeadChange, error) {
 	m.ctrl.T.Helper()
@@ -1268,6 +1296,21 @@ func (mr *MockFullNodeMockRecorder) EthGetTransactionByHash(arg0, arg1 interface
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EthGetTransactionByHash", reflect.TypeOf((*MockFullNode)(nil).EthGetTransactionByHash), arg0, arg1)
 }

+// EthGetTransactionByHashLimited mocks base method.
+func (m *MockFullNode) EthGetTransactionByHashLimited(arg0 context.Context, arg1 *ethtypes.EthHash, arg2 abi.ChainEpoch) (*ethtypes.EthTx, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EthGetTransactionByHashLimited", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*ethtypes.EthTx)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// EthGetTransactionByHashLimited indicates an expected call of EthGetTransactionByHashLimited.
+func (mr *MockFullNodeMockRecorder) EthGetTransactionByHashLimited(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EthGetTransactionByHashLimited", reflect.TypeOf((*MockFullNode)(nil).EthGetTransactionByHashLimited), arg0, arg1, arg2)
+}
+
 // EthGetTransactionCount mocks base method.
 func (m *MockFullNode) EthGetTransactionCount(arg0 context.Context, arg1 ethtypes.EthAddress, arg2 string) (ethtypes.EthUint64, error) {
 	m.ctrl.T.Helper()
@@ -1313,6 +1356,21 @@ func (mr *MockFullNodeMockRecorder) EthGetTransactionReceipt(arg0, arg1 interfac
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EthGetTransactionReceipt", reflect.TypeOf((*MockFullNode)(nil).EthGetTransactionReceipt), arg0, arg1)
 }

+// EthGetTransactionReceiptLimited mocks base method.
+func (m *MockFullNode) EthGetTransactionReceiptLimited(arg0 context.Context, arg1 ethtypes.EthHash, arg2 abi.ChainEpoch) (*api.EthTxReceipt, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "EthGetTransactionReceiptLimited", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*api.EthTxReceipt)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// EthGetTransactionReceiptLimited indicates an expected call of EthGetTransactionReceiptLimited.
+func (mr *MockFullNodeMockRecorder) EthGetTransactionReceiptLimited(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EthGetTransactionReceiptLimited", reflect.TypeOf((*MockFullNode)(nil).EthGetTransactionReceiptLimited), arg0, arg1, arg2)
+}
+
 // EthMaxPriorityFeePerGas mocks base method.
 func (m *MockFullNode) EthMaxPriorityFeePerGas(arg0 context.Context) (ethtypes.EthBigInt, error) {
 	m.ctrl.T.Helper()
@@ -18,7 +18,7 @@ import (

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
+	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
 	"github.com/filecoin-project/go-fil-markets/piecestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
@@ -117,7 +117,7 @@ type EthSubscriberStruct struct {
 }

 type EthSubscriberMethods struct {
-	EthSubscription func(p0 context.Context, p1 jsonrpc.RawParams) error `notify:"true"rpc_method:"eth_subscription"`
+	EthSubscription func(p0 context.Context, p1 jsonrpc.RawParams) error `notify:"true" rpc_method:"eth_subscription"`
 }

 type EthSubscriberStub struct {
@@ -140,6 +140,8 @@ type FullNodeMethods struct {

 	ChainExport func(p0 context.Context, p1 abi.ChainEpoch, p2 bool, p3 types.TipSetKey) (<-chan []byte, error) `perm:"read"`

+	ChainExportRangeInternal func(p0 context.Context, p1 types.TipSetKey, p2 types.TipSetKey, p3 ChainExportConfig) error `perm:"admin"`
+
 	ChainGetBlock func(p0 context.Context, p1 cid.Cid) (*types.BlockHeader, error) `perm:"read"`

 	ChainGetBlockMessages func(p0 context.Context, p1 cid.Cid) (*BlockMessages, error) `perm:"read"`
@@ -170,6 +172,8 @@ type FullNodeMethods struct {

 	ChainHead func(p0 context.Context) (*types.TipSet, error) `perm:"read"`

+	ChainHotGC func(p0 context.Context, p1 HotGCOpts) error `perm:"admin"`
+
 	ChainNotify func(p0 context.Context) (<-chan []*HeadChange, error) `perm:"read"`

 	ChainPrune func(p0 context.Context, p1 PruneOpts) error `perm:"admin"`
@@ -286,12 +290,16 @@ type FullNodeMethods struct {

 	EthGetTransactionByHash func(p0 context.Context, p1 *ethtypes.EthHash) (*ethtypes.EthTx, error) `perm:"read"`

+	EthGetTransactionByHashLimited func(p0 context.Context, p1 *ethtypes.EthHash, p2 abi.ChainEpoch) (*ethtypes.EthTx, error) `perm:"read"`
+
 	EthGetTransactionCount func(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthUint64, error) `perm:"read"`

 	EthGetTransactionHashByCid func(p0 context.Context, p1 cid.Cid) (*ethtypes.EthHash, error) `perm:"read"`

 	EthGetTransactionReceipt func(p0 context.Context, p1 ethtypes.EthHash) (*EthTxReceipt, error) `perm:"read"`

+	EthGetTransactionReceiptLimited func(p0 context.Context, p1 ethtypes.EthHash, p2 abi.ChainEpoch) (*EthTxReceipt, error) `perm:"read"`
+
 	EthMaxPriorityFeePerGas func(p0 context.Context) (ethtypes.EthBigInt, error) `perm:"read"`

 	EthNewBlockFilter func(p0 context.Context) (ethtypes.EthFilterID, error) `perm:"write"`
@@ -688,18 +696,18 @@ type GatewayMethods struct {

 	EthGetStorageAt func(p0 context.Context, p1 ethtypes.EthAddress, p2 ethtypes.EthBytes, p3 string) (ethtypes.EthBytes, error) ``

-	EthGetTransactionByBlockHashAndIndex func(p0 context.Context, p1 ethtypes.EthHash, p2 ethtypes.EthUint64) (ethtypes.EthTx, error) ``
-
-	EthGetTransactionByBlockNumberAndIndex func(p0 context.Context, p1 ethtypes.EthUint64, p2 ethtypes.EthUint64) (ethtypes.EthTx, error) ``
-
 	EthGetTransactionByHash func(p0 context.Context, p1 *ethtypes.EthHash) (*ethtypes.EthTx, error) ``

+	EthGetTransactionByHashLimited func(p0 context.Context, p1 *ethtypes.EthHash, p2 abi.ChainEpoch) (*ethtypes.EthTx, error) ``
+
 	EthGetTransactionCount func(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthUint64, error) ``

 	EthGetTransactionHashByCid func(p0 context.Context, p1 cid.Cid) (*ethtypes.EthHash, error) ``

 	EthGetTransactionReceipt func(p0 context.Context, p1 ethtypes.EthHash) (*EthTxReceipt, error) ``

+	EthGetTransactionReceiptLimited func(p0 context.Context, p1 ethtypes.EthHash, p2 abi.ChainEpoch) (*EthTxReceipt, error) ``
+
 	EthMaxPriorityFeePerGas func(p0 context.Context) (ethtypes.EthBigInt, error) ``

 	EthNewBlockFilter func(p0 context.Context) (ethtypes.EthFilterID, error) ``
@@ -718,6 +726,8 @@ type GatewayMethods struct {

 	EthUnsubscribe func(p0 context.Context, p1 ethtypes.EthSubscriptionID) (bool, error) ``

+	GasEstimateGasPremium func(p0 context.Context, p1 uint64, p2 address.Address, p3 int64, p4 types.TipSetKey) (types.BigInt, error) ``
+
 	GasEstimateMessageGas func(p0 context.Context, p1 *types.Message, p2 *MessageSendSpec, p3 types.TipSetKey) (*types.Message, error) ``

 	MpoolGetNonce func(p0 context.Context, p1 address.Address) (uint64, error) ``
@@ -760,18 +770,24 @@ type GatewayMethods struct {

 	StateMinerProvingDeadline func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*dline.Info, error) ``

+	StateMinerSectorCount func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (MinerSectors, error) ``
+
 	StateNetworkName func(p0 context.Context) (dtypes.NetworkName, error) ``

 	StateNetworkVersion func(p0 context.Context, p1 types.TipSetKey) (apitypes.NetworkVersion, error) ``

 	StateReadState func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*ActorState, error) ``

+	StateReplay func(p0 context.Context, p1 types.TipSetKey, p2 cid.Cid) (*InvocResult, error) ``
+
 	StateSearchMsg func(p0 context.Context, p1 types.TipSetKey, p2 cid.Cid, p3 abi.ChainEpoch, p4 bool) (*MsgLookup, error) ``

 	StateSectorGetInfo func(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*miner.SectorOnChainInfo, error) ``

 	StateVerifiedClientStatus func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*abi.StoragePower, error) ``

+	StateVerifierStatus func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*abi.StoragePower, error) ``
+
 	StateWaitMsg func(p0 context.Context, p1 cid.Cid, p2 uint64, p3 abi.ChainEpoch, p4 bool) (*MsgLookup, error) ``

 	Version func(p0 context.Context) (APIVersion, error) ``
@@ -951,7 +967,7 @@ type StorageMinerMethods struct {

 	MarketListIncompleteDeals func(p0 context.Context) ([]storagemarket.MinerDeal, error) `perm:"read"`

-	MarketListRetrievalDeals func(p0 context.Context) ([]retrievalmarket.ProviderDealState, error) `perm:"read"`
+	MarketListRetrievalDeals func(p0 context.Context) ([]struct{}, error) `perm:"read"`

 	MarketPendingDeals func(p0 context.Context) (PendingDealInfo, error) `perm:"write"`

@@ -1447,6 +1463,17 @@ func (s *FullNodeStub) ChainExport(p0 context.Context, p1 abi.ChainEpoch, p2 boo
 	return nil, ErrNotSupported
 }

+func (s *FullNodeStruct) ChainExportRangeInternal(p0 context.Context, p1 types.TipSetKey, p2 types.TipSetKey, p3 ChainExportConfig) error {
+	if s.Internal.ChainExportRangeInternal == nil {
+		return ErrNotSupported
+	}
+	return s.Internal.ChainExportRangeInternal(p0, p1, p2, p3)
+}
+
+func (s *FullNodeStub) ChainExportRangeInternal(p0 context.Context, p1 types.TipSetKey, p2 types.TipSetKey, p3 ChainExportConfig) error {
+	return ErrNotSupported
+}
+
 func (s *FullNodeStruct) ChainGetBlock(p0 context.Context, p1 cid.Cid) (*types.BlockHeader, error) {
 	if s.Internal.ChainGetBlock == nil {
 		return nil, ErrNotSupported
@@ -1612,6 +1639,17 @@ func (s *FullNodeStub) ChainHead(p0 context.Context) (*types.TipSet, error) {
 	return nil, ErrNotSupported
 }

+func (s *FullNodeStruct) ChainHotGC(p0 context.Context, p1 HotGCOpts) error {
+	if s.Internal.ChainHotGC == nil {
+		return ErrNotSupported
+	}
+	return s.Internal.ChainHotGC(p0, p1)
+}
+
+func (s *FullNodeStub) ChainHotGC(p0 context.Context, p1 HotGCOpts) error {
+	return ErrNotSupported
+}
+
 func (s *FullNodeStruct) ChainNotify(p0 context.Context) (<-chan []*HeadChange, error) {
 	if s.Internal.ChainNotify == nil {
 		return nil, ErrNotSupported
@@ -2250,6 +2288,17 @@ func (s *FullNodeStub) EthGetTransactionByHash(p0 context.Context, p1 *ethtypes.
 	return nil, ErrNotSupported
 }

+func (s *FullNodeStruct) EthGetTransactionByHashLimited(p0 context.Context, p1 *ethtypes.EthHash, p2 abi.ChainEpoch) (*ethtypes.EthTx, error) {
+	if s.Internal.EthGetTransactionByHashLimited == nil {
+		return nil, ErrNotSupported
+	}
+	return s.Internal.EthGetTransactionByHashLimited(p0, p1, p2)
+}
+
+func (s *FullNodeStub) EthGetTransactionByHashLimited(p0 context.Context, p1 *ethtypes.EthHash, p2 abi.ChainEpoch) (*ethtypes.EthTx, error) {
+	return nil, ErrNotSupported
+}
+
 func (s *FullNodeStruct) EthGetTransactionCount(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthUint64, error) {
 	if s.Internal.EthGetTransactionCount == nil {
 		return *new(ethtypes.EthUint64), ErrNotSupported
@@ -2283,6 +2332,17 @@ func (s *FullNodeStub) EthGetTransactionReceipt(p0 context.Context, p1 ethtypes.
 	return nil, ErrNotSupported
 }

+func (s *FullNodeStruct) EthGetTransactionReceiptLimited(p0 context.Context, p1 ethtypes.EthHash, p2 abi.ChainEpoch) (*EthTxReceipt, error) {
+	if s.Internal.EthGetTransactionReceiptLimited == nil {
+		return nil, ErrNotSupported
+	}
+	return s.Internal.EthGetTransactionReceiptLimited(p0, p1, p2)
+}
+
+func (s *FullNodeStub) EthGetTransactionReceiptLimited(p0 context.Context, p1 ethtypes.EthHash, p2 abi.ChainEpoch) (*EthTxReceipt, error) {
+	return nil, ErrNotSupported
+}
+
 func (s *FullNodeStruct) EthMaxPriorityFeePerGas(p0 context.Context) (ethtypes.EthBigInt, error) {
 	if s.Internal.EthMaxPriorityFeePerGas == nil {
 		return *new(ethtypes.EthBigInt), ErrNotSupported
@@ -4395,28 +4455,6 @@ func (s *GatewayStub) EthGetStorageAt(p0 context.Context, p1 ethtypes.EthAddress
 	return *new(ethtypes.EthBytes), ErrNotSupported
 }

-func (s *GatewayStruct) EthGetTransactionByBlockHashAndIndex(p0 context.Context, p1 ethtypes.EthHash, p2 ethtypes.EthUint64) (ethtypes.EthTx, error) {
-	if s.Internal.EthGetTransactionByBlockHashAndIndex == nil {
-		return *new(ethtypes.EthTx), ErrNotSupported
-	}
-	return s.Internal.EthGetTransactionByBlockHashAndIndex(p0, p1, p2)
-}
-
-func (s *GatewayStub) EthGetTransactionByBlockHashAndIndex(p0 context.Context, p1 ethtypes.EthHash, p2 ethtypes.EthUint64) (ethtypes.EthTx, error) {
-	return *new(ethtypes.EthTx), ErrNotSupported
-}
-
-func (s *GatewayStruct) EthGetTransactionByBlockNumberAndIndex(p0 context.Context, p1 ethtypes.EthUint64, p2 ethtypes.EthUint64) (ethtypes.EthTx, error) {
-	if s.Internal.EthGetTransactionByBlockNumberAndIndex == nil {
-		return *new(ethtypes.EthTx), ErrNotSupported
-	}
-	return s.Internal.EthGetTransactionByBlockNumberAndIndex(p0, p1, p2)
-}
-
-func (s *GatewayStub) EthGetTransactionByBlockNumberAndIndex(p0 context.Context, p1 ethtypes.EthUint64, p2 ethtypes.EthUint64) (ethtypes.EthTx, error) {
-	return *new(ethtypes.EthTx), ErrNotSupported
-}
-
 func (s *GatewayStruct) EthGetTransactionByHash(p0 context.Context, p1 *ethtypes.EthHash) (*ethtypes.EthTx, error) {
 	if s.Internal.EthGetTransactionByHash == nil {
 		return nil, ErrNotSupported
@@ -4428,6 +4466,17 @@ func (s *GatewayStub) EthGetTransactionByHash(p0 context.Context, p1 *ethtypes.E
 	return nil, ErrNotSupported
 }

+func (s *GatewayStruct) EthGetTransactionByHashLimited(p0 context.Context, p1 *ethtypes.EthHash, p2 abi.ChainEpoch) (*ethtypes.EthTx, error) {
+	if s.Internal.EthGetTransactionByHashLimited == nil {
+		return nil, ErrNotSupported
+	}
+	return s.Internal.EthGetTransactionByHashLimited(p0, p1, p2)
+}
+
+func (s *GatewayStub) EthGetTransactionByHashLimited(p0 context.Context, p1 *ethtypes.EthHash, p2 abi.ChainEpoch) (*ethtypes.EthTx, error) {
+	return nil, ErrNotSupported
+}
+
 func (s *GatewayStruct) EthGetTransactionCount(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthUint64, error) {
 	if s.Internal.EthGetTransactionCount == nil {
 		return *new(ethtypes.EthUint64), ErrNotSupported
@@ -4461,6 +4510,17 @@ func (s *GatewayStub) EthGetTransactionReceipt(p0 context.Context, p1 ethtypes.E
 	return nil, ErrNotSupported
 }

+func (s *GatewayStruct) EthGetTransactionReceiptLimited(p0 context.Context, p1 ethtypes.EthHash, p2 abi.ChainEpoch) (*EthTxReceipt, error) {
+	if s.Internal.EthGetTransactionReceiptLimited == nil {
+		return nil, ErrNotSupported
+	}
+	return s.Internal.EthGetTransactionReceiptLimited(p0, p1, p2)
+}
+
+func (s *GatewayStub) EthGetTransactionReceiptLimited(p0 context.Context, p1 ethtypes.EthHash, p2 abi.ChainEpoch) (*EthTxReceipt, error) {
+	return nil, ErrNotSupported
+}
+
 func (s *GatewayStruct) EthMaxPriorityFeePerGas(p0 context.Context) (ethtypes.EthBigInt, error) {
 	if s.Internal.EthMaxPriorityFeePerGas == nil {
 		return *new(ethtypes.EthBigInt), ErrNotSupported
@@ -4560,6 +4620,17 @@ func (s *GatewayStub) EthUnsubscribe(p0 context.Context, p1 ethtypes.EthSubscrip
 	return false, ErrNotSupported
 }

+func (s *GatewayStruct) GasEstimateGasPremium(p0 context.Context, p1 uint64, p2 address.Address, p3 int64, p4 types.TipSetKey) (types.BigInt, error) {
+	if s.Internal.GasEstimateGasPremium == nil {
+		return *new(types.BigInt), ErrNotSupported
+	}
+	return s.Internal.GasEstimateGasPremium(p0, p1, p2, p3, p4)
+}
+
+func (s *GatewayStub) GasEstimateGasPremium(p0 context.Context, p1 uint64, p2 address.Address, p3 int64, p4 types.TipSetKey) (types.BigInt, error) {
+	return *new(types.BigInt), ErrNotSupported
+}
+
 func (s *GatewayStruct) GasEstimateMessageGas(p0 context.Context, p1 *types.Message, p2 *MessageSendSpec, p3 types.TipSetKey) (*types.Message, error) {
 	if s.Internal.GasEstimateMessageGas == nil {
 		return nil, ErrNotSupported
@@ -4791,6 +4862,17 @@ func (s *GatewayStub) StateMinerProvingDeadline(p0 context.Context, p1 address.A
 	return nil, ErrNotSupported
 }

+func (s *GatewayStruct) StateMinerSectorCount(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (MinerSectors, error) {
+	if s.Internal.StateMinerSectorCount == nil {
+		return *new(MinerSectors), ErrNotSupported
+	}
+	return s.Internal.StateMinerSectorCount(p0, p1, p2)
+}
+
+func (s *GatewayStub) StateMinerSectorCount(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (MinerSectors, error) {
+	return *new(MinerSectors), ErrNotSupported
+}
+
 func (s *GatewayStruct) StateNetworkName(p0 context.Context) (dtypes.NetworkName, error) {
 	if s.Internal.StateNetworkName == nil {
 		return *new(dtypes.NetworkName), ErrNotSupported
@@ -4824,6 +4906,17 @@ func (s *GatewayStub) StateReadState(p0 context.Context, p1 address.Address, p2
 	return nil, ErrNotSupported
 }

+func (s *GatewayStruct) StateReplay(p0 context.Context, p1 types.TipSetKey, p2 cid.Cid) (*InvocResult, error) {
+	if s.Internal.StateReplay == nil {
+		return nil, ErrNotSupported
+	}
+	return s.Internal.StateReplay(p0, p1, p2)
+}
+
+func (s *GatewayStub) StateReplay(p0 context.Context, p1 types.TipSetKey, p2 cid.Cid) (*InvocResult, error) {
+	return nil, ErrNotSupported
+}
+
 func (s *GatewayStruct) StateSearchMsg(p0 context.Context, p1 types.TipSetKey, p2 cid.Cid, p3 abi.ChainEpoch, p4 bool) (*MsgLookup, error) {
 	if s.Internal.StateSearchMsg == nil {
 		return nil, ErrNotSupported
@@ -4857,6 +4950,17 @@ func (s *GatewayStub) StateVerifiedClientStatus(p0 context.Context, p1 address.A
 	return nil, ErrNotSupported
 }

+func (s *GatewayStruct) StateVerifierStatus(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*abi.StoragePower, error) {
+	if s.Internal.StateVerifierStatus == nil {
+		return nil, ErrNotSupported
+	}
+	return s.Internal.StateVerifierStatus(p0, p1, p2)
+}
+
+func (s *GatewayStub) StateVerifierStatus(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*abi.StoragePower, error) {
+	return nil, ErrNotSupported
+}
+
 func (s *GatewayStruct) StateWaitMsg(p0 context.Context, p1 cid.Cid, p2 uint64, p3 abi.ChainEpoch, p4 bool) (*MsgLookup, error) {
 	if s.Internal.StateWaitMsg == nil {
 		return nil, ErrNotSupported
@@ -5671,15 +5775,15 @@ func (s *StorageMinerStub) MarketListIncompleteDeals(p0 context.Context) ([]stor
 	return *new([]storagemarket.MinerDeal), ErrNotSupported
 }

-func (s *StorageMinerStruct) MarketListRetrievalDeals(p0 context.Context) ([]retrievalmarket.ProviderDealState, error) {
+func (s *StorageMinerStruct) MarketListRetrievalDeals(p0 context.Context) ([]struct{}, error) {
 	if s.Internal.MarketListRetrievalDeals == nil {
-		return *new([]retrievalmarket.ProviderDealState), ErrNotSupported
+		return *new([]struct{}), ErrNotSupported
 	}
 	return s.Internal.MarketListRetrievalDeals(p0)
 }

-func (s *StorageMinerStub) MarketListRetrievalDeals(p0 context.Context) ([]retrievalmarket.ProviderDealState, error) {
-	return *new([]retrievalmarket.ProviderDealState), ErrNotSupported
+func (s *StorageMinerStub) MarketListRetrievalDeals(p0 context.Context) ([]struct{}, error) {
+	return *new([]struct{}), ErrNotSupported
 }

 func (s *StorageMinerStruct) MarketPendingDeals(p0 context.Context) (PendingDealInfo, error) {
@@ -8,13 +8,15 @@ import (
 	"github.com/google/uuid"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-graphsync"
+	"github.com/ipld/go-ipld-prime"
+	"github.com/ipld/go-ipld-prime/codec/dagjson"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
 	ma "github.com/multiformats/go-multiaddr"

 	"github.com/filecoin-project/go-address"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
+	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/builtin/v9/miner"
@@ -110,16 +112,12 @@ func NewDataTransferChannel(hostID peer.ID, channelState datatransfer.ChannelSta
 		IsSender:   channelState.Sender() == hostID,
 		Message:    channelState.Message(),
 	}
-	stringer, ok := channelState.Voucher().(fmt.Stringer)
-	if ok {
-		channel.Voucher = stringer.String()
+	voucher := channelState.Voucher()
+	voucherJSON, err := ipld.Encode(voucher.Voucher, dagjson.Encode)
+	if err != nil {
+		channel.Voucher = fmt.Errorf("Voucher Serialization: %w", err).Error()
 	} else {
-		voucherJSON, err := json.Marshal(channelState.Voucher())
-		if err != nil {
-			channel.Voucher = fmt.Errorf("Voucher Serialization: %w", err).Error()
-		} else {
-			channel.Voucher = string(voucherJSON)
-		}
+		channel.Voucher = string(voucherJSON)
 	}
 	if channel.IsSender {
 		channel.IsInitiator = !channelState.IsPull()
@@ -398,3 +396,12 @@ func (m *MsgUuidMapType) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// ChainExportConfig holds configuration for chain ranged exports.
+type ChainExportConfig struct {
+	WriteBufferSize   int
+	NumWorkers        int
+	IncludeMessages   bool
+	IncludeReceipts   bool
+	IncludeStateRoots bool
+}
@@ -10,7 +10,7 @@ import (

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
+	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-state-types/abi"
@@ -35,6 +35,9 @@ import (
 //  * Generate openrpc blobs

 type Gateway interface {
+	StateMinerSectorCount(context.Context, address.Address, types.TipSetKey) (api.MinerSectors, error)
+	GasEstimateGasPremium(context.Context, uint64, address.Address, int64, types.TipSetKey) (types.BigInt, error)
+	StateReplay(context.Context, types.TipSetKey, cid.Cid) (*api.InvocResult, error)
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
 	ChainPutObj(context.Context, blocks.Block) error
 	ChainHead(ctx context.Context) (*types.TipSet, error)
@@ -12,7 +12,7 @@ import (

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
+	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-state-types/abi"
@@ -449,6 +449,8 @@ type GatewayMethods struct {

 	ChainReadObj func(p0 context.Context, p1 cid.Cid) ([]byte, error) ``

+	GasEstimateGasPremium func(p0 context.Context, p1 uint64, p2 address.Address, p3 int64, p4 types.TipSetKey) (types.BigInt, error) ``
+
 	GasEstimateMessageGas func(p0 context.Context, p1 *types.Message, p2 *api.MessageSendSpec, p3 types.TipSetKey) (*types.Message, error) ``

 	MpoolGetNonce func(p0 context.Context, p1 address.Address) (uint64, error) ``
@@ -487,10 +489,14 @@ type GatewayMethods struct {

 	StateMinerProvingDeadline func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*dline.Info, error) ``

+	StateMinerSectorCount func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (api.MinerSectors, error) ``
+
 	StateNetworkName func(p0 context.Context) (dtypes.NetworkName, error) ``

 	StateNetworkVersion func(p0 context.Context, p1 types.TipSetKey) (abinetwork.Version, error) ``

+	StateReplay func(p0 context.Context, p1 types.TipSetKey, p2 cid.Cid) (*api.InvocResult, error) ``
+
 	StateSearchMsg func(p0 context.Context, p1 cid.Cid) (*api.MsgLookup, error) ``

 	StateSectorGetInfo func(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*miner.SectorOnChainInfo, error) ``
@@ -2674,6 +2680,17 @@ func (s *GatewayStub) ChainReadObj(p0 context.Context, p1 cid.Cid) ([]byte, erro
 	return *new([]byte), ErrNotSupported
 }

+func (s *GatewayStruct) GasEstimateGasPremium(p0 context.Context, p1 uint64, p2 address.Address, p3 int64, p4 types.TipSetKey) (types.BigInt, error) {
+	if s.Internal.GasEstimateGasPremium == nil {
+		return *new(types.BigInt), ErrNotSupported
+	}
+	return s.Internal.GasEstimateGasPremium(p0, p1, p2, p3, p4)
+}
+
+func (s *GatewayStub) GasEstimateGasPremium(p0 context.Context, p1 uint64, p2 address.Address, p3 int64, p4 types.TipSetKey) (types.BigInt, error) {
+	return *new(types.BigInt), ErrNotSupported
+}
+
 func (s *GatewayStruct) GasEstimateMessageGas(p0 context.Context, p1 *types.Message, p2 *api.MessageSendSpec, p3 types.TipSetKey) (*types.Message, error) {
 	if s.Internal.GasEstimateMessageGas == nil {
 		return nil, ErrNotSupported
@@ -2883,6 +2900,17 @@ func (s *GatewayStub) StateMinerProvingDeadline(p0 context.Context, p1 address.A
 	return nil, ErrNotSupported
 }

+func (s *GatewayStruct) StateMinerSectorCount(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (api.MinerSectors, error) {
+	if s.Internal.StateMinerSectorCount == nil {
+		return *new(api.MinerSectors), ErrNotSupported
+	}
+	return s.Internal.StateMinerSectorCount(p0, p1, p2)
+}
+
+func (s *GatewayStub) StateMinerSectorCount(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (api.MinerSectors, error) {
+	return *new(api.MinerSectors), ErrNotSupported
+}
+
 func (s *GatewayStruct) StateNetworkName(p0 context.Context) (dtypes.NetworkName, error) {
 	if s.Internal.StateNetworkName == nil {
 		return *new(dtypes.NetworkName), ErrNotSupported
@@ -2905,6 +2933,17 @@ func (s *GatewayStub) StateNetworkVersion(p0 context.Context, p1 types.TipSetKey
 	return *new(abinetwork.Version), ErrNotSupported
 }

+func (s *GatewayStruct) StateReplay(p0 context.Context, p1 types.TipSetKey, p2 cid.Cid) (*api.InvocResult, error) {
+	if s.Internal.StateReplay == nil {
+		return nil, ErrNotSupported
+	}
+	return s.Internal.StateReplay(p0, p1, p2)
+}
+
+func (s *GatewayStub) StateReplay(p0 context.Context, p1 types.TipSetKey, p2 cid.Cid) (*api.InvocResult, error) {
+	return nil, ErrNotSupported
+}
+
 func (s *GatewayStruct) StateSearchMsg(p0 context.Context, p1 cid.Cid) (*api.MsgLookup, error) {
 	if s.Internal.StateSearchMsg == nil {
 		return nil, ErrNotSupported
@@ -20,7 +20,7 @@ import (

 	address "github.com/filecoin-project/go-address"
 	bitfield "github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
+	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
 	retrievalmarket "github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	storagemarket "github.com/filecoin-project/go-fil-markets/storagemarket"
 	auth "github.com/filecoin-project/go-jsonrpc/auth"
@@ -20,6 +20,7 @@ import (
 	pool "github.com/libp2p/go-buffer-pool"
 	"github.com/multiformats/go-base32"
 	"go.uber.org/zap"
+	"golang.org/x/xerrors"

 	"github.com/filecoin-project/lotus/blockstore"
 )
@@ -44,7 +45,8 @@ const (
 	// MemoryMap is equivalent to badger/options.MemoryMap.
 	MemoryMap = options.MemoryMap
 	// LoadToRAM is equivalent to badger/options.LoadToRAM.
-	LoadToRAM = options.LoadToRAM
+	LoadToRAM          = options.LoadToRAM
+	defaultGCThreshold = 0.125
 )

 // Options embeds the badger options themselves, and augments them with
@@ -394,6 +396,9 @@ func (b *Blockstore) doCopy(from, to *badger.DB) error {
 	if workers < 2 {
 		workers = 2
 	}
+	if workers > 8 {
+		workers = 8
+	}

 	stream := from.NewStream()
 	stream.NumGo = workers
@@ -439,7 +444,7 @@ func (b *Blockstore) deleteDB(path string) {
 	}
 }

-func (b *Blockstore) onlineGC() error {
+func (b *Blockstore) onlineGC(ctx context.Context, threshold float64) error {
 	b.lockDB()
 	defer b.unlockDB()

@@ -448,6 +453,9 @@ func (b *Blockstore) onlineGC() error {
 	if nworkers < 2 {
 		nworkers = 2
 	}
+	if nworkers > 7 { // max out at 1 goroutine per badger level
+		nworkers = 7
+	}

 	err := b.db.Flatten(nworkers)
 	if err != nil {
@@ -455,7 +463,12 @@ func (b *Blockstore) onlineGC() error {
 	}

 	for err == nil {
-		err = b.db.RunValueLogGC(0.125)
+		select {
+		case <-ctx.Done():
+			err = ctx.Err()
+		default:
+			err = b.db.RunValueLogGC(threshold)
+		}
 	}

 	if err == badger.ErrNoRewrite {
@@ -468,7 +481,7 @@ func (b *Blockstore) onlineGC() error {

 // CollectGarbage compacts and runs garbage collection on the value log;
 // implements the BlockstoreGC trait
-func (b *Blockstore) CollectGarbage(opts ...blockstore.BlockstoreGCOption) error {
+func (b *Blockstore) CollectGarbage(ctx context.Context, opts ...blockstore.BlockstoreGCOption) error {
 	if err := b.access(); err != nil {
 		return err
 	}
@@ -485,8 +498,48 @@ func (b *Blockstore) CollectGarbage(opts ...blockstore.BlockstoreGCOption) error
 	if options.FullGC {
 		return b.movingGC()
 	}
+	threshold := options.Threshold
+	if threshold == 0 {
+		threshold = defaultGCThreshold
+	}
+	return b.onlineGC(ctx, threshold)
+}

-	return b.onlineGC()
+// GCOnce runs garbage collection on the value log;
+// implements BlockstoreGCOnce trait
+func (b *Blockstore) GCOnce(ctx context.Context, opts ...blockstore.BlockstoreGCOption) error {
+	if err := b.access(); err != nil {
+		return err
+	}
+	defer b.viewers.Done()
+
+	var options blockstore.BlockstoreGCOptions
+	for _, opt := range opts {
+		err := opt(&options)
+		if err != nil {
+			return err
+		}
+	}
+	if options.FullGC {
+		return xerrors.Errorf("FullGC option specified for GCOnce but full GC is non incremental")
+	}
+
+	threshold := options.Threshold
+	if threshold == 0 {
+		threshold = defaultGCThreshold
+	}
+
+	b.lockDB()
+	defer b.unlockDB()
+
+	// Note no compaction needed before single GC as we will hit at most one vlog anyway
+	err := b.db.RunValueLogGC(threshold)
+	if err == badger.ErrNoRewrite {
+		// not really an error in this case, it signals the end of GC
+		return nil
+	}
+
+	return err
 }

 // Size returns the aggregate size of the blockstore
@@ -551,6 +604,18 @@ func (b *Blockstore) View(ctx context.Context, cid cid.Cid, fn func([]byte) erro
 	})
 }

+func (b *Blockstore) Flush(context.Context) error {
+	if err := b.access(); err != nil {
+		return err
+	}
+	defer b.viewers.Done()
+
+	b.lockDB()
+	defer b.unlockDB()
+
+	return b.db.Sync()
+}
+
 // Has implements Blockstore.Has.
 func (b *Blockstore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
 	if err := b.access(); err != nil {
@@ -145,7 +145,7 @@ func testMove(t *testing.T, optsF func(string) Options) {
 		return nil
 	})
 	g.Go(func() error {
-		return db.CollectGarbage(blockstore.WithFullGC(true))
+		return db.CollectGarbage(ctx, blockstore.WithFullGC(true))
 	})

 	err = g.Wait()
@@ -230,7 +230,7 @@ func testMove(t *testing.T, optsF func(string) Options) {
 	checkPath()

 	// now do another FullGC to test the double move and following of symlinks
-	if err := db.CollectGarbage(blockstore.WithFullGC(true)); err != nil {
+	if err := db.CollectGarbage(ctx, blockstore.WithFullGC(true)); err != nil {
 		t.Fatal(err)
 	}

@@ -18,6 +18,7 @@ type Blockstore interface {
 	blockstore.Blockstore
 	blockstore.Viewer
 	BatchDeleter
+	Flusher
 }

 // BasicBlockstore is an alias to the original IPFS Blockstore.
@@ -25,6 +26,10 @@ type BasicBlockstore = blockstore.Blockstore

 type Viewer = blockstore.Viewer

+type Flusher interface {
+	Flush(context.Context) error
+}
+
 type BatchDeleter interface {
 	DeleteMany(ctx context.Context, cids []cid.Cid) error
 }
@@ -36,7 +41,12 @@ type BlockstoreIterator interface {

 // BlockstoreGC is a trait for blockstores that support online garbage collection
 type BlockstoreGC interface {
-	CollectGarbage(options ...BlockstoreGCOption) error
+	CollectGarbage(ctx context.Context, options ...BlockstoreGCOption) error
+}
+
+// BlockstoreGCOnce is a trait for a blockstore that supports incremental online garbage collection
+type BlockstoreGCOnce interface {
+	GCOnce(ctx context.Context, options ...BlockstoreGCOption) error
 }

 // BlockstoreGCOption is a functional interface for controlling blockstore GC options
@@ -45,6 +55,8 @@ type BlockstoreGCOption = func(*BlockstoreGCOptions) error
 // BlockstoreGCOptions is a struct with GC options
 type BlockstoreGCOptions struct {
 	FullGC bool
+	// fraction of garbage in badger vlog before its worth processing in online GC
+	Threshold float64
 }

 func WithFullGC(fullgc bool) BlockstoreGCOption {
@@ -54,6 +66,13 @@ func WithFullGC(fullgc bool) BlockstoreGCOption {
 	}
 }

+func WithThreshold(threshold float64) BlockstoreGCOption {
+	return func(opts *BlockstoreGCOptions) error {
+		opts.Threshold = threshold
+		return nil
+	}
+}
+
 // BlockstoreSize is a trait for on-disk blockstores that can report their size
 type BlockstoreSize interface {
 	Size() (int64, error)
@@ -92,6 +111,13 @@ type adaptedBlockstore struct {

 var _ Blockstore = (*adaptedBlockstore)(nil)

+func (a *adaptedBlockstore) Flush(ctx context.Context) error {
+	if flusher, canFlush := a.Blockstore.(Flusher); canFlush {
+		return flusher.Flush(ctx)
+	}
+	return nil
+}
+
 func (a *adaptedBlockstore) View(ctx context.Context, cid cid.Cid, callback func([]byte) error) error {
 	blk, err := a.Get(ctx, cid)
 	if err != nil {
@@ -46,6 +46,8 @@ var (
 	_ Viewer     = (*BufferedBlockstore)(nil)
 )

+func (bs *BufferedBlockstore) Flush(ctx context.Context) error { return bs.write.Flush(ctx) }
+
 func (bs *BufferedBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
 	a, err := bs.read.AllKeysChan(ctx)
 	if err != nil {
@@ -38,6 +38,10 @@ func (b *discardstore) View(ctx context.Context, cid cid.Cid, f func([]byte) err
 	return b.bs.View(ctx, cid, f)
 }

+func (b *discardstore) Flush(ctx context.Context) error {
+	return nil
+}
+
 func (b *discardstore) Put(ctx context.Context, blk blocks.Block) error {
 	return nil
 }
@@ -179,3 +179,7 @@ func (b *idstore) Close() error {
 	}
 	return nil
 }
+
+func (b *idstore) Flush(ctx context.Context) error {
+	return b.bs.Flush(ctx)
+}
@@ -3,7 +3,7 @@ package blockstore
 import (
 	"bytes"
 	"context"
-	"io/ioutil"
+	"io"

 	"github.com/ipfs/go-cid"
 	httpapi "github.com/ipfs/go-ipfs-http-client"
@@ -103,7 +103,7 @@ func (i *IPFSBlockstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, er
 		return nil, xerrors.Errorf("getting ipfs block: %w", err)
 	}

-	data, err := ioutil.ReadAll(rd)
+	data, err := io.ReadAll(rd)
 	if err != nil {
 		return nil, err
 	}
@@ -17,6 +17,8 @@ func NewMemory() MemBlockstore {
 // To match behavior of badger blockstore we index by multihash only.
 type MemBlockstore map[string]blocks.Block

+func (MemBlockstore) Flush(context.Context) error { return nil }
+
 func (m MemBlockstore) DeleteBlock(ctx context.Context, k cid.Cid) error {
 	delete(m, string(k.Hash()))
 	return nil
@@ -410,6 +410,8 @@ func (n *NetworkStore) HashOnRead(enabled bool) {
 	return
 }

+func (*NetworkStore) Flush(context.Context) error { return nil }
+
 func (n *NetworkStore) Stop(ctx context.Context) error {
 	close(n.closing)

@@ -11,6 +11,8 @@ import (
 	"github.com/ipfs/go-cid"
 	"go.uber.org/zap"
 	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/system"
 )

 type BadgerMarkSetEnv struct {
@@ -349,7 +351,7 @@ func (s *BadgerMarkSet) write(seqno int) (err error) {
 	persist := s.persist
 	s.mx.RUnlock()

-	if persist {
+	if persist && !system.BadgerFsyncDisable { // WARNING: disabling sync makes recovery from crash during critical section unsound
 		return s.db.Sync()
 	}

@@ -115,6 +115,23 @@ type Config struct {
 	// A positive value is the number of compactions before a full GC is performed;
 	// a value of 1 will perform full GC in every compaction.
 	HotStoreFullGCFrequency uint64
+
+	// HotstoreMaxSpaceTarget suggests the max allowed space the hotstore can take.
+	// This is not a hard limit, it is possible for the hotstore to exceed the target
+	// for example if state grows massively between compactions. The splitstore
+	// will make a best effort to avoid overflowing the target and in practice should
+	// never overflow.  This field is used when doing GC at the end of a compaction to
+	// adaptively choose moving GC
+	HotstoreMaxSpaceTarget uint64
+
+	// Moving GC will be triggered when total moving size exceeds
+	// HotstoreMaxSpaceTarget - HotstoreMaxSpaceThreshold
+	HotstoreMaxSpaceThreshold uint64
+
+	// Safety buffer to prevent moving GC from overflowing disk.
+	// Moving GC will not occur when total moving size exceeds
+	// HotstoreMaxSpaceTarget - HotstoreMaxSpaceSafetyBuffer
+	HotstoreMaxSpaceSafetyBuffer uint64
 }

 // ChainAccessor allows the Splitstore to access the chain. It will most likely
@@ -165,6 +182,7 @@ type SplitStore struct {

 	compactionIndex int64
 	pruneIndex      int64
+	onlineGCCnt     int64

 	ctx    context.Context
 	cancel func()
@@ -195,6 +213,17 @@ type SplitStore struct {

 	// registered protectors
 	protectors []func(func(cid.Cid) error) error
+
+	// dag sizes measured during latest compaction
+	// logged and used for GC strategy
+
+	// protected by compaction lock
+	szWalk          int64
+	szProtectedTxns int64
+	szKeys          int64 // approximate, not counting keys protected when entering critical section
+
+	// protected by txnLk
+	szMarkedLiveRefs int64
 }

 var _ bstore.Blockstore = (*SplitStore)(nil)
@@ -447,6 +476,23 @@ func (s *SplitStore) GetSize(ctx context.Context, cid cid.Cid) (int, error) {
 	}
 }

+func (s *SplitStore) Flush(ctx context.Context) error {
+	s.txnLk.RLock()
+	defer s.txnLk.RUnlock()
+
+	if err := s.cold.Flush(ctx); err != nil {
+		return err
+	}
+	if err := s.hot.Flush(ctx); err != nil {
+		return err
+	}
+	if err := s.ds.Sync(ctx, dstore.Key{}); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (s *SplitStore) Put(ctx context.Context, blk blocks.Block) error {
 	if isIdentiyCid(blk.Cid()) {
 		return nil
@@ -95,7 +95,7 @@ func (s *SplitStore) doCheck(curTs *types.TipSet) error {
 	}
 	defer visitor.Close() //nolint

-	err = s.walkChain(curTs, boundaryEpoch, boundaryEpoch, visitor,
+	size := s.walkChain(curTs, boundaryEpoch, boundaryEpoch, visitor,
 		func(c cid.Cid) error {
 			if isUnitaryObject(c) {
 				return errStopWalk
@@ -133,7 +133,7 @@ func (s *SplitStore) doCheck(curTs *types.TipSet) error {
 		return err
 	}

-	log.Infow("check done", "cold", *coldCnt, "missing", *missingCnt)
+	log.Infow("check done", "cold", *coldCnt, "missing", *missingCnt, "walk size", size)
 	write("--")
 	write("cold: %d missing: %d", *coldCnt, *missingCnt)
 	write("DONE")
@@ -66,7 +66,8 @@ var (
 )

 const (
-	batchSize = 16384
+	batchSize  = 16384
+	cidKeySize = 128
 )

 func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
@@ -115,8 +116,6 @@ func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
 		return nil
 	}

-	// Prioritize hot store compaction over cold store prune
-
 	if epoch-s.baseEpoch > CompactionThreshold {
 		// it's time to compact -- prepare the transaction and go!
 		s.beginTxnProtect()
@@ -176,6 +175,8 @@ func (s *SplitStore) protectTipSets(apply []*types.TipSet) {
 		timestamp := time.Unix(int64(curTs.MinTimestamp()), 0)
 		doSync := time.Since(timestamp) < SyncWaitTime
 		go func() {
+			// we are holding the txnLk while marking
+			// so critical section cannot delete
 			if doSync {
 				defer func() {
 					s.txnSyncMx.Lock()
@@ -199,9 +200,11 @@ func (s *SplitStore) markLiveRefs(cids []cid.Cid) {
 	log.Debugf("marking %d live refs", len(cids))
 	startMark := time.Now()

+	szMarked := new(int64)
+
 	count := new(int32)
 	visitor := newConcurrentVisitor()
-	walkObject := func(c cid.Cid) error {
+	walkObject := func(c cid.Cid) (int64, error) {
 		return s.walkObjectIncomplete(c, visitor,
 			func(c cid.Cid) error {
 				if isUnitaryObject(c) {
@@ -228,10 +231,12 @@ func (s *SplitStore) markLiveRefs(cids []cid.Cid) {

 	// optimize the common case of single put
 	if len(cids) == 1 {
-		if err := walkObject(cids[0]); err != nil {
+		sz, err := walkObject(cids[0])
+		if err != nil {
 			log.Errorf("error marking tipset refs: %s", err)
 		}
 		log.Debugw("marking live refs done", "took", time.Since(startMark), "marked", *count)
+		atomic.AddInt64(szMarked, sz)
 		return
 	}

@@ -243,9 +248,11 @@ func (s *SplitStore) markLiveRefs(cids []cid.Cid) {

 	worker := func() error {
 		for c := range workch {
-			if err := walkObject(c); err != nil {
+			sz, err := walkObject(c)
+			if err != nil {
 				return err
 			}
+			atomic.AddInt64(szMarked, sz)
 		}

 		return nil
@@ -268,7 +275,8 @@ func (s *SplitStore) markLiveRefs(cids []cid.Cid) {
 		log.Errorf("error marking tipset refs: %s", err)
 	}

-	log.Debugw("marking live refs done", "took", time.Since(startMark), "marked", *count)
+	log.Debugw("marking live refs done", "took", time.Since(startMark), "marked", *count, "size marked", *szMarked)
+	s.szMarkedLiveRefs += atomic.LoadInt64(szMarked)
 }

 // transactionally protect a view
@@ -361,6 +369,7 @@ func (s *SplitStore) protectTxnRefs(markSet MarkSet) error {

 		log.Infow("protecting transactional references", "refs", len(txnRefs))
 		count := 0
+		sz := new(int64)
 		workch := make(chan cid.Cid, len(txnRefs))
 		startProtect := time.Now()

@@ -393,10 +402,11 @@ func (s *SplitStore) protectTxnRefs(markSet MarkSet) error {

 		worker := func() error {
 			for c := range workch {
-				err := s.doTxnProtect(c, markSet)
+				szTxn, err := s.doTxnProtect(c, markSet)
 				if err != nil {
 					return xerrors.Errorf("error protecting transactional references to %s: %w", c, err)
 				}
+				atomic.AddInt64(sz, szTxn)
 			}
 			return nil
 		}
@@ -409,16 +419,16 @@ func (s *SplitStore) protectTxnRefs(markSet MarkSet) error {
 		if err := g.Wait(); err != nil {
 			return err
 		}
-
-		log.Infow("protecting transactional refs done", "took", time.Since(startProtect), "protected", count)
+		s.szProtectedTxns += atomic.LoadInt64(sz)
+		log.Infow("protecting transactional refs done", "took", time.Since(startProtect), "protected", count, "protected size", sz)
 	}
 }

 // transactionally protect a reference by walking the object and marking.
 // concurrent markings are short circuited by checking the markset.
-func (s *SplitStore) doTxnProtect(root cid.Cid, markSet MarkSet) error {
+func (s *SplitStore) doTxnProtect(root cid.Cid, markSet MarkSet) (int64, error) {
 	if err := s.checkClosing(); err != nil {
-		return err
+		return 0, err
 	}

 	// Note: cold objects are deleted heaviest first, so the consituents of an object
@@ -442,7 +452,7 @@ func (s *SplitStore) doTxnProtect(root cid.Cid, markSet MarkSet) error {
 		},
 		func(c cid.Cid) error {
 			if s.txnMissing != nil {
-				log.Warnf("missing object reference %s in %s", c, root)
+				log.Debugf("missing object reference %s in %s", c, root)
 				s.txnRefsMx.Lock()
 				s.txnMissing[c] = struct{}{}
 				s.txnRefsMx.Unlock()
@@ -509,6 +519,7 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 		// might be potentially inconsistent; abort compaction and notify the user to intervene.
 		return xerrors.Errorf("checkpoint exists; aborting compaction")
 	}
+	s.clearSizeMeasurements()

 	currentEpoch := curTs.Height()
 	boundaryEpoch := currentEpoch - CompactionBoundary
@@ -598,7 +609,6 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	}

 	err = s.walkChain(curTs, boundaryEpoch, inclMsgsEpoch, &noopVisitor{}, fHot, fCold)
-
 	if err != nil {
 		return xerrors.Errorf("error marking: %w", err)
 	}
@@ -638,7 +648,7 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	defer purgew.Close() //nolint:errcheck

 	// some stats for logging
-	var hotCnt, coldCnt, purgeCnt int
+	var hotCnt, coldCnt, purgeCnt int64
 	err = s.hot.ForEachKey(func(c cid.Cid) error {
 		// was it marked?
 		mark, err := markSet.Has(c)
@@ -689,9 +699,10 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {

 	log.Infow("cold collection done", "took", time.Since(startCollect))

-	log.Infow("compaction stats", "hot", hotCnt, "cold", coldCnt)
-	stats.Record(s.ctx, metrics.SplitstoreCompactionHot.M(int64(hotCnt)))
-	stats.Record(s.ctx, metrics.SplitstoreCompactionCold.M(int64(coldCnt)))
+	log.Infow("compaction stats", "hot", hotCnt, "cold", coldCnt, "purge", purgeCnt)
+	s.szKeys = hotCnt * cidKeySize
+	stats.Record(s.ctx, metrics.SplitstoreCompactionHot.M(hotCnt))
+	stats.Record(s.ctx, metrics.SplitstoreCompactionCold.M(coldCnt))

 	if err := s.checkClosing(); err != nil {
 		return err
@@ -773,8 +784,8 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 		return xerrors.Errorf("error purging cold objects: %w", err)
 	}
 	log.Infow("purging cold objects from hotstore done", "took", time.Since(startPurge))
-
 	s.endCriticalSection()
+	log.Infow("critical section done", "total protected size", s.szProtectedTxns, "total marked live size", s.szMarkedLiveRefs)

 	if err := checkpoint.Close(); err != nil {
 		log.Warnf("error closing checkpoint: %s", err)
@@ -788,10 +799,13 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	if err := os.Remove(s.coldSetPath()); err != nil {
 		log.Warnf("error removing coldset: %s", err)
 	}
+	if err := os.Remove(s.discardSetPath()); err != nil {
+		log.Warnf("error removing discardset: %s", err)
+	}

 	// we are done; do some housekeeping
 	s.endTxnProtect()
-	s.gcHotstore()
+	s.gcHotAfterCompaction()

 	err = s.setBaseEpoch(boundaryEpoch)
 	if err != nil {
@@ -904,6 +918,7 @@ func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEp
 	copy(toWalk, ts.Cids())
 	walkCnt := new(int64)
 	scanCnt := new(int64)
+	szWalk := new(int64)

 	tsRef := func(blkCids []cid.Cid) (cid.Cid, error) {
 		return types.NewTipSetKey(blkCids...).Cid()
@@ -939,48 +954,64 @@ func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEp
 		if err != nil {
 			return xerrors.Errorf("error computing cid reference to parent tipset")
 		}
-		if err := s.walkObjectIncomplete(pRef, visitor, fHot, stopWalk); err != nil {
+		sz, err := s.walkObjectIncomplete(pRef, visitor, fHot, stopWalk)
+		if err != nil {
 			return xerrors.Errorf("error walking parent tipset cid reference")
 		}
+		atomic.AddInt64(szWalk, sz)

 		// message are retained if within the inclMsgs boundary
 		if hdr.Height >= inclMsgs && hdr.Height > 0 {
 			if inclMsgs < inclState {
 				// we need to use walkObjectIncomplete here, as messages/receipts may be missing early on if we
 				// synced from snapshot and have a long HotStoreMessageRetentionPolicy.
-				if err := s.walkObjectIncomplete(hdr.Messages, visitor, fHot, stopWalk); err != nil {
+				sz, err := s.walkObjectIncomplete(hdr.Messages, visitor, fHot, stopWalk)
+				if err != nil {
 					return xerrors.Errorf("error walking messages (cid: %s): %w", hdr.Messages, err)
 				}
+				atomic.AddInt64(szWalk, sz)

-				if err := s.walkObjectIncomplete(hdr.ParentMessageReceipts, visitor, fHot, stopWalk); err != nil {
+				sz, err = s.walkObjectIncomplete(hdr.ParentMessageReceipts, visitor, fHot, stopWalk)
+				if err != nil {
 					return xerrors.Errorf("error walking messages receipts (cid: %s): %w", hdr.ParentMessageReceipts, err)
 				}
+				atomic.AddInt64(szWalk, sz)
 			} else {
-				if err := s.walkObject(hdr.Messages, visitor, fHot); err != nil {
+				sz, err = s.walkObject(hdr.Messages, visitor, fHot)
+				if err != nil {
 					return xerrors.Errorf("error walking messages (cid: %s): %w", hdr.Messages, err)
 				}
+				atomic.AddInt64(szWalk, sz)

-				if err := s.walkObject(hdr.ParentMessageReceipts, visitor, fHot); err != nil {
+				sz, err := s.walkObjectIncomplete(hdr.ParentMessageReceipts, visitor, fHot, stopWalk)
+				if err != nil {
 					return xerrors.Errorf("error walking message receipts (cid: %s): %w", hdr.ParentMessageReceipts, err)
 				}
+				atomic.AddInt64(szWalk, sz)
 			}
 		}

 		// messages and receipts outside of inclMsgs are included in the cold store
 		if hdr.Height < inclMsgs && hdr.Height > 0 {
-			if err := s.walkObjectIncomplete(hdr.Messages, visitor, fCold, stopWalk); err != nil {
+			sz, err := s.walkObjectIncomplete(hdr.Messages, visitor, fCold, stopWalk)
+			if err != nil {
 				return xerrors.Errorf("error walking messages (cid: %s): %w", hdr.Messages, err)
 			}
-			if err := s.walkObjectIncomplete(hdr.ParentMessageReceipts, visitor, fCold, stopWalk); err != nil {
+			atomic.AddInt64(szWalk, sz)
+			sz, err = s.walkObjectIncomplete(hdr.ParentMessageReceipts, visitor, fCold, stopWalk)
+			if err != nil {
 				return xerrors.Errorf("error walking messages receipts (cid: %s): %w", hdr.ParentMessageReceipts, err)
 			}
+			atomic.AddInt64(szWalk, sz)
 		}

 		// state is only retained if within the inclState boundary, with the exception of genesis
 		if hdr.Height >= inclState || hdr.Height == 0 {
-			if err := s.walkObject(hdr.ParentStateRoot, visitor, fHot); err != nil {
+			sz, err := s.walkObject(hdr.ParentStateRoot, visitor, fHot)
+			if err != nil {
 				return xerrors.Errorf("error walking state root (cid: %s): %w", hdr.ParentStateRoot, err)
 			}
+			atomic.AddInt64(szWalk, sz)
 			atomic.AddInt64(scanCnt, 1)
 		}

@@ -998,9 +1029,11 @@ func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEp
 	if err != nil {
 		return xerrors.Errorf("error computing cid reference to parent tipset")
 	}
-	if err := s.walkObjectIncomplete(hRef, visitor, fHot, stopWalk); err != nil {
+	sz, err := s.walkObjectIncomplete(hRef, visitor, fHot, stopWalk)
+	if err != nil {
 		return xerrors.Errorf("error walking parent tipset cid reference")
 	}
+	atomic.AddInt64(szWalk, sz)

 	for len(toWalk) > 0 {
 		// walking can take a while, so check this with every opportunity
@@ -1044,123 +1077,129 @@ func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEp
 		}
 	}

-	log.Infow("chain walk done", "walked", *walkCnt, "scanned", *scanCnt)
-
+	log.Infow("chain walk done", "walked", *walkCnt, "scanned", *scanCnt, "walk size", szWalk)
+	s.szWalk = atomic.LoadInt64(szWalk)
 	return nil
 }

-func (s *SplitStore) walkObject(c cid.Cid, visitor ObjectVisitor, f func(cid.Cid) error) error {
+func (s *SplitStore) walkObject(c cid.Cid, visitor ObjectVisitor, f func(cid.Cid) error) (int64, error) {
+	var sz int64
 	visit, err := visitor.Visit(c)
 	if err != nil {
-		return xerrors.Errorf("error visiting object: %w", err)
+		return 0, xerrors.Errorf("error visiting object: %w", err)
 	}

 	if !visit {
-		return nil
+		return sz, nil
 	}

 	if err := f(c); err != nil {
 		if err == errStopWalk {
-			return nil
+			return sz, nil
 		}

-		return err
+		return 0, err
 	}

 	if c.Prefix().Codec != cid.DagCBOR {
-		return nil
+		return sz, nil
 	}

 	// check this before recursing
 	if err := s.checkClosing(); err != nil {
-		return err
+		return 0, err
 	}

 	var links []cid.Cid
 	err = s.view(c, func(data []byte) error {
+		sz += int64(len(data))
 		return cbg.ScanForLinks(bytes.NewReader(data), func(c cid.Cid) {
 			links = append(links, c)
 		})
 	})

 	if err != nil {
-		return xerrors.Errorf("error scanning linked block (cid: %s): %w", c, err)
+		return 0, xerrors.Errorf("error scanning linked block (cid: %s): %w", c, err)
 	}

 	for _, c := range links {
-		err := s.walkObject(c, visitor, f)
+		szLink, err := s.walkObject(c, visitor, f)
 		if err != nil {
-			return xerrors.Errorf("error walking link (cid: %s): %w", c, err)
+			return 0, xerrors.Errorf("error walking link (cid: %s): %w", c, err)
 		}
+		sz += szLink
 	}

-	return nil
+	return sz, nil
 }

 // like walkObject, but the object may be potentially incomplete (references missing)
-func (s *SplitStore) walkObjectIncomplete(c cid.Cid, visitor ObjectVisitor, f, missing func(cid.Cid) error) error {
+func (s *SplitStore) walkObjectIncomplete(c cid.Cid, visitor ObjectVisitor, f, missing func(cid.Cid) error) (int64, error) {
+	var sz int64
 	visit, err := visitor.Visit(c)
 	if err != nil {
-		return xerrors.Errorf("error visiting object: %w", err)
+		return 0, xerrors.Errorf("error visiting object: %w", err)
 	}

 	if !visit {
-		return nil
+		return sz, nil
 	}

 	// occurs check -- only for DAGs
 	if c.Prefix().Codec == cid.DagCBOR {
 		has, err := s.has(c)
 		if err != nil {
-			return xerrors.Errorf("error occur checking %s: %w", c, err)
+			return 0, xerrors.Errorf("error occur checking %s: %w", c, err)
 		}

 		if !has {
 			err = missing(c)
 			if err == errStopWalk {
-				return nil
+				return sz, nil
 			}

-			return err
+			return 0, err
 		}
 	}

 	if err := f(c); err != nil {
 		if err == errStopWalk {
-			return nil
+			return sz, nil
 		}

-		return err
+		return 0, err
 	}

 	if c.Prefix().Codec != cid.DagCBOR {
-		return nil
+		return sz, nil
 	}

 	// check this before recursing
 	if err := s.checkClosing(); err != nil {
-		return err
+		return sz, err
 	}

 	var links []cid.Cid
 	err = s.view(c, func(data []byte) error {
+		sz += int64(len(data))
 		return cbg.ScanForLinks(bytes.NewReader(data), func(c cid.Cid) {
 			links = append(links, c)
 		})
 	})

 	if err != nil {
-		return xerrors.Errorf("error scanning linked block (cid: %s): %w", c, err)
+		return 0, xerrors.Errorf("error scanning linked block (cid: %s): %w", c, err)
 	}

 	for _, c := range links {
-		err := s.walkObjectIncomplete(c, visitor, f, missing)
+		szLink, err := s.walkObjectIncomplete(c, visitor, f, missing)
 		if err != nil {
-			return xerrors.Errorf("error walking link (cid: %s): %w", c, err)
+			return 0, xerrors.Errorf("error walking link (cid: %s): %w", c, err)
 		}
+		sz += szLink
 	}

-	return nil
+	return sz, nil
 }

 // internal version used during compaction and related operations
@@ -1426,8 +1465,9 @@ func (s *SplitStore) completeCompaction() error {
 	}
 	s.compactType = none

-	// Note: at this point we can start the splitstore; a compaction should run on
-	//       the first head change, which will trigger gc on the hotstore.
+	// Note: at this point we can start the splitstore; base epoch is not
+	//       incremented here so a compaction should run on the first head
+	//       change, which will trigger gc on the hotstore.
 	//       We don't mind the second (back-to-back) compaction as the head will
 	//       have advanced during marking and coldset accumulation.
 	return nil
@@ -1485,6 +1525,13 @@ func (s *SplitStore) completePurge(coldr *ColdSetReader, checkpoint *Checkpoint,
 	return nil
 }

+func (s *SplitStore) clearSizeMeasurements() {
+	s.szKeys = 0
+	s.szMarkedLiveRefs = 0
+	s.szProtectedTxns = 0
+	s.szWalk = 0
+}
+
 // I really don't like having this code, but we seem to have some occasional DAG references with
 // missing constituents. During testing in mainnet *some* of these references *sometimes* appeared
 // after a little bit.
@@ -1525,7 +1572,7 @@ func (s *SplitStore) waitForMissingRefs(markSet MarkSet) {
 		missing = make(map[cid.Cid]struct{})

 		for c := range towalk {
-			err := s.walkObjectIncomplete(c, visitor,
+			_, err := s.walkObjectIncomplete(c, visitor,
 				func(c cid.Cid) error {
 					if isUnitaryObject(c) {
 						return errStopWalk
@@ -77,6 +77,10 @@ func (es *exposedSplitStore) GetSize(ctx context.Context, c cid.Cid) (int, error
 	return size, err
 }

+func (es *exposedSplitStore) Flush(ctx context.Context) error {
+	return es.s.Flush(ctx)
+}
+
 func (es *exposedSplitStore) Put(ctx context.Context, blk blocks.Block) error {
 	return es.s.Put(ctx, blk)
 }
@@ -7,15 +7,61 @@ import (
 	bstore "github.com/filecoin-project/lotus/blockstore"
 )

-func (s *SplitStore) gcHotstore() {
+const (
+	// Fraction of garbage in badger vlog for online GC traversal to collect garbage
+	AggressiveOnlineGCThreshold = 0.0001
+)
+
+func (s *SplitStore) gcHotAfterCompaction() {
+	// Measure hotstore size, determine if we should do full GC, determine if we can do full GC.
+	// We should do full GC if
+	//  FullGCFrequency is specified and compaction index matches frequency
+	//  OR HotstoreMaxSpaceTarget is specified and total moving space is within 150 GB of target
+	// We can do full if
+	//  HotstoreMaxSpaceTarget is not specified
+	//  OR total moving space would not exceed 50 GB below target
+	//
+	// 	a) If we should not do full GC => online GC
+	//  b) If we should do full GC and can => moving GC
+	//  c) If we should do full GC and can't => aggressive online GC
+	getSize := func() int64 {
+		sizer, ok := s.hot.(bstore.BlockstoreSize)
+		if ok {
+			size, err := sizer.Size()
+			if err != nil {
+				log.Warnf("error getting hotstore size: %s, estimating empty hot store for targeting", err)
+				return 0
+			}
+			return size
+		}
+		log.Errorf("Could not measure hotstore size, assuming it is 0 bytes, which it is not")
+		return 0
+	}
+	hotSize := getSize()
+
+	copySizeApprox := s.szKeys + s.szMarkedLiveRefs + s.szProtectedTxns + s.szWalk
+	shouldTarget := s.cfg.HotstoreMaxSpaceTarget > 0 && hotSize+copySizeApprox > int64(s.cfg.HotstoreMaxSpaceTarget)-int64(s.cfg.HotstoreMaxSpaceThreshold)
+	shouldFreq := s.cfg.HotStoreFullGCFrequency > 0 && s.compactionIndex%int64(s.cfg.HotStoreFullGCFrequency) == 0
+	shouldDoFull := shouldTarget || shouldFreq
+	canDoFull := s.cfg.HotstoreMaxSpaceTarget == 0 || hotSize+copySizeApprox < int64(s.cfg.HotstoreMaxSpaceTarget)-int64(s.cfg.HotstoreMaxSpaceSafetyBuffer)
+	log.Debugw("approximating new hot store size", "key size", s.szKeys, "marked live refs", s.szMarkedLiveRefs, "protected txns", s.szProtectedTxns, "walked DAG", s.szWalk)
+	log.Infof("measured hot store size: %d, approximate new size: %d, should do full %t, can do full %t", hotSize, copySizeApprox, shouldDoFull, canDoFull)
+
 	var opts []bstore.BlockstoreGCOption
-	if s.cfg.HotStoreFullGCFrequency > 0 && s.compactionIndex%int64(s.cfg.HotStoreFullGCFrequency) == 0 {
+	if shouldDoFull && canDoFull {
 		opts = append(opts, bstore.WithFullGC(true))
+	} else if shouldDoFull && !canDoFull {
+		log.Warnf("Attention! Estimated moving GC size %d is not within safety buffer %d of target max %d, performing aggressive online GC to attempt to bring hotstore size down safely", copySizeApprox, s.cfg.HotstoreMaxSpaceSafetyBuffer, s.cfg.HotstoreMaxSpaceTarget)
+		log.Warn("If problem continues you can 1) temporarily allocate more disk space to hotstore and 2) reflect in HotstoreMaxSpaceTarget OR trigger manual move with `lotus chain prune hot-moving`")
+		log.Warn("If problem continues and you do not have any more disk space you can run continue to manually trigger online GC at aggressive thresholds (< 0.01) with `lotus chain prune hot`")
+
+		opts = append(opts, bstore.WithThreshold(AggressiveOnlineGCThreshold))
 	}

 	if err := s.gcBlockstore(s.hot, opts); err != nil {
 		log.Warnf("error garbage collecting hostore: %s", err)
 	}
+	log.Infof("measured hot store size after GC: %d", getSize())
 }

 func (s *SplitStore) gcBlockstore(b bstore.Blockstore, opts []bstore.BlockstoreGCOption) error {
@@ -23,7 +69,7 @@ func (s *SplitStore) gcBlockstore(b bstore.Blockstore, opts []bstore.BlockstoreG
 		log.Info("garbage collecting blockstore")
 		startGC := time.Now()

-		if err := gc.CollectGarbage(opts...); err != nil {
+		if err := gc.CollectGarbage(s.ctx, opts...); err != nil {
 			return err
 		}

@@ -33,3 +79,19 @@ func (s *SplitStore) gcBlockstore(b bstore.Blockstore, opts []bstore.BlockstoreG

 	return fmt.Errorf("blockstore doesn't support garbage collection: %T", b)
 }
+
+func (s *SplitStore) gcBlockstoreOnce(b bstore.Blockstore, opts []bstore.BlockstoreGCOption) error {
+	if gc, ok := b.(bstore.BlockstoreGCOnce); ok {
+		log.Debug("gc blockstore once")
+		startGC := time.Now()
+
+		if err := gc.GCOnce(s.ctx, opts...); err != nil {
+			return err
+		}
+
+		log.Debugw("gc blockstore once done", "took", time.Since(startGC))
+		return nil
+	}
+
+	return fmt.Errorf("blockstore doesn't support gc once: %T", b)
+}
@@ -47,6 +47,23 @@ var (
 	PruneThreshold = 7 * build.Finality
 )

+// GCHotstore runs online GC on the chain state in the hotstore according the to options specified
+func (s *SplitStore) GCHotStore(opts api.HotGCOpts) error {
+	if opts.Moving {
+		gcOpts := []bstore.BlockstoreGCOption{bstore.WithFullGC(true)}
+		return s.gcBlockstore(s.hot, gcOpts)
+	}
+
+	gcOpts := []bstore.BlockstoreGCOption{bstore.WithThreshold(opts.Threshold)}
+	var err error
+	if opts.Periodic {
+		err = s.gcBlockstore(s.hot, gcOpts)
+	} else {
+		err = s.gcBlockstoreOnce(s.hot, gcOpts)
+	}
+	return err
+}
+
 // PruneChain instructs the SplitStore to prune chain state in the coldstore, according to the
 // options specified.
 func (s *SplitStore) PruneChain(opts api.PruneOpts) error {
@@ -329,9 +346,9 @@ func (s *SplitStore) doPrune(curTs *types.TipSet, retainStateP func(int64) bool,
 	}

 	s.pruneIndex++
-	err = s.ds.Put(s.ctx, pruneIndexKey, int64ToBytes(s.compactionIndex))
+	err = s.ds.Put(s.ctx, pruneIndexKey, int64ToBytes(s.pruneIndex))
 	if err != nil {
-		return xerrors.Errorf("error saving compaction index: %w", err)
+		return xerrors.Errorf("error saving prune index: %w", err)
 	}

 	return nil
@@ -101,7 +101,7 @@ func (s *SplitStore) doReify(c cid.Cid) {
 	defer s.txnLk.RUnlock()

 	count := 0
-	err := s.walkObjectIncomplete(c, newTmpVisitor(),
+	_, err := s.walkObjectIncomplete(c, newTmpVisitor(),
 		func(c cid.Cid) error {
 			if isUnitaryObject(c) {
 				return errStopWalk
@@ -757,6 +757,8 @@ func (b *mockStore) DeleteMany(_ context.Context, cids []cid.Cid) error {
 	return nil
 }

+func (b *mockStore) Flush(context.Context) error { return nil }
+
 func (b *mockStore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
 	return nil, errors.New("not implemented")
 }
@@ -20,6 +20,8 @@ type SyncBlockstore struct {
 	bs MemBlockstore // specifically use a memStore to save indirection overhead.
 }

+func (*SyncBlockstore) Flush(context.Context) error { return nil }
+
 func (m *SyncBlockstore) DeleteBlock(ctx context.Context, k cid.Cid) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -93,6 +93,16 @@ func (t *TimedCacheBlockstore) rotate() {
 	t.mu.Unlock()
 }

+func (t *TimedCacheBlockstore) Flush(ctx context.Context) error {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+
+	if err := t.active.Flush(ctx); err != nil {
+		return err
+	}
+	return t.inactive.Flush(ctx)
+}
+
 func (t *TimedCacheBlockstore) Put(ctx context.Context, b blocks.Block) error {
 	// Don't check the inactive set here. We want to keep this block for at
 	// least one interval.
@@ -55,6 +55,15 @@ func (m unionBlockstore) GetSize(ctx context.Context, cid cid.Cid) (size int, er
 	return size, err
 }

+func (m unionBlockstore) Flush(ctx context.Context) (err error) {
+	for _, bs := range m {
+		if err = bs.Flush(ctx); err != nil {
+			break
+		}
+	}
+	return err
+}
+
 func (m unionBlockstore) Put(ctx context.Context, block blocks.Block) (err error) {
 	for _, bs := range m {
 		if err = bs.Put(ctx, block); err != nil {
@@ -69,10 +69,6 @@ var DrandConfigs = map[DrandEnum]dtypes.DrandConfig{
 		ChainInfoJSON: `{"public_key":"8cda589f88914aa728fd183f383980b35789ce81b274e5daee1f338b77d02566ef4d3fb0098af1f844f10f9c803c1827","period":25,"genesis_time":1595348225,"hash":"e73b7dc3c4f6a236378220c0dd6aa110eb16eed26c11259606e07ee122838d4f","groupHash":"567d4785122a5a3e75a9bc9911d7ea807dd85ff76b78dc4ff06b075712898607"}`,
 	},
 	DrandIncentinet: {
-		Servers: []string{
-			"https://dev1.drand.sh",
-			"https://dev2.drand.sh",
-		},
 		ChainInfoJSON: `{"public_key":"8cad0c72c606ab27d36ee06de1d5b2db1faf92e447025ca37575ab3a8aac2eaae83192f846fc9e158bc738423753d000","period":30,"genesis_time":1595873820,"hash":"80c8b872c714f4c00fdd3daa465d5514049f457f01f85a4caf68cdcd394ba039","groupHash":"d9406aaed487f7af71851b4399448e311f2328923d454e971536c05398ce2d9b"}`,
 	},
 }
@@ -6,6 +6,7 @@ package build
 import (
 	"os"
 	"strconv"
+	"time"

 	"github.com/ipfs/go-cid"

@@ -139,3 +140,7 @@ const BootstrapPeerThreshold = 1
 const Eip155ChainId = 31415926

 var WhitelistedBlock = cid.Undef
+
+// Reducing the delivery delay for equivocation of
+// consistent broadcast to just half a second.
+var CBDeliveryDelay = 500 * time.Millisecond
@@ -4,6 +4,8 @@
 package build

 import (
+	"time"
+
 	"github.com/ipfs/go-cid"

 	"github.com/filecoin-project/go-address"
@@ -87,3 +89,8 @@ const BootstrapPeerThreshold = 2
 const Eip155ChainId = 3141592

 var WhitelistedBlock = cid.Undef
+
+// CBDeliveryDelay is the delay before deliver in the synchronous consistent broadcast.
+// This determines the wait time for the detection of potential equivocations.
+// It is a variable instead of a constant so it can be conveniently configured in tests
+var CBDeliveryDelay = 2 * time.Second
@@ -6,6 +6,7 @@ package build
 import (
 	"os"
 	"strconv"
+	"time"

 	"github.com/ipfs/go-cid"

@@ -122,3 +123,8 @@ const BootstrapPeerThreshold = 4
 const Eip155ChainId = 314159

 var WhitelistedBlock = cid.Undef
+
+// CBDeliveryDelay is the delay before deliver in the synchronous consistent broadcast.
+// This determines the wait time for the detection of potential equivocations.
+// It is a variable instead of a constant so it can be conveniently configured in tests
+var CBDeliveryDelay = 2 * time.Second
@@ -6,6 +6,7 @@ package build
 import (
 	"os"
 	"strconv"
+	"time"

 	"github.com/ipfs/go-cid"

@@ -128,3 +129,8 @@ const BootstrapPeerThreshold = 2
 const Eip155ChainId = 3141592

 var WhitelistedBlock = cid.Undef
+
+// CBDeliveryDelay is the delay before deliver in the synchronous consistent broadcast.
+// This determines the wait time for the detection of potential equivocations.
+// It is a variable instead of a constant so it can be conveniently configured in tests
+var CBDeliveryDelay = 2 * time.Second
@@ -7,6 +7,7 @@ import (
 	"math"
 	"os"
 	"strconv"
+	"time"

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
@@ -137,3 +138,8 @@ const Eip155ChainId = 314

 // we skip checks on message validity in this block to sidestep the zero-bls signature
 var WhitelistedBlock = MustParseCid("bafy2bzaceapyg2uyzk7vueh3xccxkuwbz3nxewjyguoxvhx77malc2lzn2ybi")
+
+// CBDeliveryDelay is the delay before deliver in the synchronous consistent broadcast.
+// This determines the wait time for the detection of potential equivocations.
+// It is a variable instead of a constant so it can be conveniently configured in tests
+var CBDeliveryDelay = 2 * time.Second
@@ -9,6 +9,7 @@ package build

 import (
 	"math/big"
+	"time"

 	"github.com/ipfs/go-cid"

@@ -135,3 +136,7 @@ const BootstrapPeerThreshold = 1
 // ChainId defines the chain ID used in the Ethereum JSON-RPC endpoint.
 // As per https://github.com/ethereum-lists/chains
 const Eip155ChainId = 31415926
+
+// Reducing the delivery delay for equivocation of
+// consistent broadcast to just half a second.
+var CBDeliveryDelay = 500 * time.Millisecond
@@ -37,7 +37,7 @@ func BuildTypeString() string {
 }

 // BuildVersion is the local build version
-const BuildVersion = "1.20.3"
+const BuildVersion = "1.21.0-dev"

 func UserVersion() string {
 	if os.Getenv("LOTUS_VERSION_IGNORE_COMMIT") == "1" {
@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"fmt"
 	"go/format"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -66,7 +65,7 @@ func generateAdapters() error {
 		}

 		{
-			af, err := ioutil.ReadFile(filepath.Join(actDir, "actor.go.template"))
+			af, err := os.ReadFile(filepath.Join(actDir, "actor.go.template"))
 			if err != nil {
 				return xerrors.Errorf("loading actor template: %w", err)
 			}
@@ -90,7 +89,7 @@ func generateAdapters() error {
 				return err
 			}

-			if err := ioutil.WriteFile(filepath.Join(actDir, fmt.Sprintf("%s.go", act)), fmted, 0666); err != nil {
+			if err := os.WriteFile(filepath.Join(actDir, fmt.Sprintf("%s.go", act)), fmted, 0666); err != nil {
 				return err
 			}
 		}
@@ -100,7 +99,7 @@ func generateAdapters() error {
 }

 func generateState(actDir string, versions []int) error {
-	af, err := ioutil.ReadFile(filepath.Join(actDir, "state.go.template"))
+	af, err := os.ReadFile(filepath.Join(actDir, "state.go.template"))
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil // skip
@@ -123,7 +122,7 @@ func generateState(actDir string, versions []int) error {
 			return err
 		}

-		if err := ioutil.WriteFile(filepath.Join(actDir, fmt.Sprintf("v%d.go", version)), b.Bytes(), 0666); err != nil {
+		if err := os.WriteFile(filepath.Join(actDir, fmt.Sprintf("v%d.go", version)), b.Bytes(), 0666); err != nil {
 			return err
 		}
 	}
@@ -132,7 +131,7 @@ func generateState(actDir string, versions []int) error {
 }

 func generateMessages(actDir string) error {
-	af, err := ioutil.ReadFile(filepath.Join(actDir, "message.go.template"))
+	af, err := os.ReadFile(filepath.Join(actDir, "message.go.template"))
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil // skip
@@ -155,7 +154,7 @@ func generateMessages(actDir string) error {
 			return err
 		}

-		if err := ioutil.WriteFile(filepath.Join(actDir, fmt.Sprintf("message%d.go", version)), b.Bytes(), 0666); err != nil {
+		if err := os.WriteFile(filepath.Join(actDir, fmt.Sprintf("message%d.go", version)), b.Bytes(), 0666); err != nil {
 			return err
 		}
 	}
@@ -165,7 +164,7 @@ func generateMessages(actDir string) error {

 func generatePolicy(policyPath string) error {

-	pf, err := ioutil.ReadFile(policyPath + ".template")
+	pf, err := os.ReadFile(policyPath + ".template")
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil // skip
@@ -187,7 +186,7 @@ func generatePolicy(policyPath string) error {
 		return err
 	}

-	if err := ioutil.WriteFile(policyPath, b.Bytes(), 0666); err != nil {
+	if err := os.WriteFile(policyPath, b.Bytes(), 0666); err != nil {
 		return err
 	}

@@ -196,7 +195,7 @@ func generatePolicy(policyPath string) error {

 func generateBuiltin(builtinPath string) error {

-	bf, err := ioutil.ReadFile(builtinPath + ".template")
+	bf, err := os.ReadFile(builtinPath + ".template")
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil // skip
@@ -218,7 +217,7 @@ func generateBuiltin(builtinPath string) error {
 		return err
 	}

-	if err := ioutil.WriteFile(builtinPath, b.Bytes(), 0666); err != nil {
+	if err := os.WriteFile(builtinPath, b.Bytes(), 0666); err != nil {
 		return err
 	}

@@ -227,7 +226,7 @@ func generateBuiltin(builtinPath string) error {

 func generateRegistry(registryPath string) error {

-	bf, err := ioutil.ReadFile(registryPath + ".template")
+	bf, err := os.ReadFile(registryPath + ".template")
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil // skip
@@ -248,7 +247,7 @@ func generateRegistry(registryPath string) error {
 		return err
 	}

-	if err := ioutil.WriteFile(registryPath, b.Bytes(), 0666); err != nil {
+	if err := os.WriteFile(registryPath, b.Bytes(), 0666); err != nil {
 		return err
 	}

@@ -83,6 +83,7 @@ type State interface {
 	GetAllocations(clientIdAddr address.Address) (map[AllocationId]Allocation, error)
 	GetClaim(providerIdAddr address.Address, claimId ClaimId) (*Claim, bool, error)
 	GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, error)
+	GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error)
 	GetState() interface{}
 }

@@ -170,6 +170,27 @@ func (s *state{{.v}}) GetClaims(providerIdAddr address.Address) (map[ClaimId]Cla
 {{end}}
 }

+func (s *state{{.v}}) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) {
+{{if (le .v 8)}}
+    return nil, xerrors.Errorf("unsupported in actors v{{.v}}")
+{{else}}
+	v{{.v}}Map, err := s.LoadClaimsToMap(s.store, providerIdAddr)
+
+	retMap := make(map[abi.SectorNumber][]ClaimId)
+	for k, v := range v{{.v}}Map {
+		claims, ok := retMap[v.Sector]
+		if !ok {
+			retMap[v.Sector] = []ClaimId{ClaimId(k)}
+		} else {
+			retMap[v.Sector] = append(claims, ClaimId(k))
+		}
+	}
+
+	return retMap, err
+
+{{end}}
+}
+
 func (s *state{{.v}}) ActorKey() string {
    return manifest.VerifregKey
 }
@@ -118,6 +118,12 @@ func (s *state0) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, e

 }

+func (s *state0) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) {
+
+	return nil, xerrors.Errorf("unsupported in actors v0")
+
+}
+
 func (s *state0) ActorKey() string {
 	return manifest.VerifregKey
 }
@@ -134,6 +134,24 @@ func (s *state10) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim,

 }

+func (s *state10) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) {
+
+	v10Map, err := s.LoadClaimsToMap(s.store, providerIdAddr)
+
+	retMap := make(map[abi.SectorNumber][]ClaimId)
+	for k, v := range v10Map {
+		claims, ok := retMap[v.Sector]
+		if !ok {
+			retMap[v.Sector] = []ClaimId{ClaimId(k)}
+		} else {
+			retMap[v.Sector] = append(claims, ClaimId(k))
+		}
+	}
+
+	return retMap, err
+
+}
+
 func (s *state10) ActorKey() string {
 	return manifest.VerifregKey
 }
@@ -118,6 +118,12 @@ func (s *state2) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, e

 }

+func (s *state2) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) {
+
+	return nil, xerrors.Errorf("unsupported in actors v2")
+
+}
+
 func (s *state2) ActorKey() string {
 	return manifest.VerifregKey
 }
@@ -119,6 +119,12 @@ func (s *state3) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, e

 }

+func (s *state3) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) {
+
+	return nil, xerrors.Errorf("unsupported in actors v3")
+
+}
+
 func (s *state3) ActorKey() string {
 	return manifest.VerifregKey
 }
@@ -119,6 +119,12 @@ func (s *state4) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, e

 }

+func (s *state4) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) {
+
+	return nil, xerrors.Errorf("unsupported in actors v4")
+
+}
+
 func (s *state4) ActorKey() string {
 	return manifest.VerifregKey
 }
@@ -119,6 +119,12 @@ func (s *state5) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, e

 }

+func (s *state5) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) {
+
+	return nil, xerrors.Errorf("unsupported in actors v5")
+
+}
+
 func (s *state5) ActorKey() string {
 	return manifest.VerifregKey
 }
@@ -119,6 +119,12 @@ func (s *state6) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, e

 }

+func (s *state6) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) {
+
+	return nil, xerrors.Errorf("unsupported in actors v6")
+
+}
+
 func (s *state6) ActorKey() string {
 	return manifest.VerifregKey
 }
@@ -118,6 +118,12 @@ func (s *state7) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, e

 }

+func (s *state7) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) {
+
+	return nil, xerrors.Errorf("unsupported in actors v7")
+
+}
+
 func (s *state7) ActorKey() string {
 	return manifest.VerifregKey
 }
@@ -118,6 +118,12 @@ func (s *state8) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, e

 }

+func (s *state8) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) {
+
+	return nil, xerrors.Errorf("unsupported in actors v8")
+
+}
+
 func (s *state8) ActorKey() string {
 	return manifest.VerifregKey
 }
@@ -133,6 +133,24 @@ func (s *state9) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, e

 }

+func (s *state9) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) {
+
+	v9Map, err := s.LoadClaimsToMap(s.store, providerIdAddr)
+
+	retMap := make(map[abi.SectorNumber][]ClaimId)
+	for k, v := range v9Map {
+		claims, ok := retMap[v.Sector]
+		if !ok {
+			retMap[v.Sector] = []ClaimId{ClaimId(k)}
+		} else {
+			retMap[v.Sector] = append(claims, ClaimId(k))
+		}
+	}
+
+	return retMap, err
+
+}
+
 func (s *state9) ActorKey() string {
 	return manifest.VerifregKey
 }
@@ -131,6 +131,7 @@ type State interface {
 	GetAllocations(clientIdAddr address.Address) (map[AllocationId]Allocation, error)
 	GetClaim(providerIdAddr address.Address, claimId ClaimId) (*Claim, bool, error)
 	GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, error)
+	GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error)
 	GetState() interface{}
 }

@@ -3,14 +3,14 @@ package chain
 import (
 	"fmt"

-	lru "github.com/hashicorp/golang-lru"
+	lru "github.com/hashicorp/golang-lru/v2"
 	"github.com/ipfs/go-cid"

 	"github.com/filecoin-project/lotus/build"
 )

 type BadBlockCache struct {
-	badBlocks *lru.ARCCache
+	badBlocks *lru.ARCCache[cid.Cid, BadBlockReason]
 }

 type BadBlockReason struct {
@@ -43,7 +43,7 @@ func (bbr BadBlockReason) String() string {
 }

 func NewBadBlockCache() *BadBlockCache {
-	cache, err := lru.NewARC(build.BadBlockCacheSize)
+	cache, err := lru.NewARC[cid.Cid, BadBlockReason](build.BadBlockCacheSize)
 	if err != nil {
 		panic(err) // ok
 	}
@@ -66,10 +66,5 @@ func (bts *BadBlockCache) Purge() {
 }

 func (bts *BadBlockCache) Has(c cid.Cid) (BadBlockReason, bool) {
-	rval, ok := bts.badBlocks.Get(c)
-	if !ok {
-		return BadBlockReason{}, false
-	}
-
-	return rval.(BadBlockReason), true
+	return bts.badBlocks.Get(c)
 }
@@ -8,14 +8,14 @@ import (
 	dchain "github.com/drand/drand/chain"
 	dclient "github.com/drand/drand/client"
 	hclient "github.com/drand/drand/client/http"
+	"github.com/drand/drand/common/scheme"
 	dlog "github.com/drand/drand/log"
 	gclient "github.com/drand/drand/lp2p/client"
 	"github.com/drand/kyber"
-	kzap "github.com/go-kit/kit/log/zap"
-	lru "github.com/hashicorp/golang-lru"
+	lru "github.com/hashicorp/golang-lru/v2"
 	logging "github.com/ipfs/go-log/v2"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"go.uber.org/zap/zapcore"
+	"go.uber.org/zap"
 	"golang.org/x/xerrors"

 	"github.com/filecoin-project/go-state-types/abi"
@@ -61,7 +61,7 @@ type DrandBeacon struct {
 	filGenTime   uint64
 	filRoundTime uint64

-	localCache *lru.Cache
+	localCache *lru.Cache[uint64, *types.BeaconEntry]
 }

 // DrandHTTPClient interface overrides the user agent used by drand
@@ -69,6 +69,18 @@ type DrandHTTPClient interface {
 	SetUserAgent(string)
 }

+type logger struct {
+	*zap.SugaredLogger
+}
+
+func (l *logger) With(args ...interface{}) dlog.Logger {
+	return &logger{l.SugaredLogger.With(args...)}
+}
+
+func (l *logger) Named(s string) dlog.Logger {
+	return &logger{l.SugaredLogger.Named(s)}
+}
+
 func NewDrandBeacon(genesisTs, interval uint64, ps *pubsub.PubSub, config dtypes.DrandConfig) (*DrandBeacon, error) {
 	if genesisTs == 0 {
 		panic("what are you doing this cant be zero")
@@ -79,9 +91,6 @@ func NewDrandBeacon(genesisTs, interval uint64, ps *pubsub.PubSub, config dtypes
 		return nil, xerrors.Errorf("unable to unmarshal drand chain info: %w", err)
 	}

-	dlogger := dlog.NewKitLoggerFrom(kzap.NewZapSugarLogger(
-		log.SugaredLogger.Desugar(), zapcore.InfoLevel))
-
 	var clients []dclient.Client
 	for _, url := range config.Servers {
 		hc, err := hclient.NewWithInfo(url, drandChain, nil)
@@ -96,7 +105,7 @@ func NewDrandBeacon(genesisTs, interval uint64, ps *pubsub.PubSub, config dtypes
 	opts := []dclient.Option{
 		dclient.WithChainInfo(drandChain),
 		dclient.WithCacheSize(1024),
-		dclient.WithLogger(dlogger),
+		dclient.WithLogger(&logger{&log.SugaredLogger}),
 	}

 	if ps != nil {
@@ -110,7 +119,7 @@ func NewDrandBeacon(genesisTs, interval uint64, ps *pubsub.PubSub, config dtypes
 		return nil, xerrors.Errorf("creating drand client: %w", err)
 	}

-	lc, err := lru.New(1024)
+	lc, err := lru.New[uint64, *types.BeaconEntry](1024)
 	if err != nil {
 		return nil, err
 	}
@@ -160,16 +169,12 @@ func (db *DrandBeacon) Entry(ctx context.Context, round uint64) <-chan beacon.Re
 	return out
 }
 func (db *DrandBeacon) cacheValue(e types.BeaconEntry) {
-	db.localCache.Add(e.Round, e)
+	db.localCache.Add(e.Round, &e)
 }

 func (db *DrandBeacon) getCachedValue(round uint64) *types.BeaconEntry {
-	v, ok := db.localCache.Get(round)
-	if !ok {
-		return nil
-	}
-	e, _ := v.(types.BeaconEntry)
-	return &e
+	v, _ := db.localCache.Get(round)
+	return v
 }

 func (db *DrandBeacon) VerifyEntry(curr types.BeaconEntry, prev types.BeaconEntry) error {
@@ -194,7 +199,7 @@ func (db *DrandBeacon) VerifyEntry(curr types.BeaconEntry, prev types.BeaconEntr
 		Round:       curr.Round,
 		Signature:   curr.Data,
 	}
-	err := dchain.VerifyBeacon(db.pubkey, b)
+	err := dchain.NewVerifier(scheme.GetSchemeFromEnv()).VerifyBeacon(*b, db.pubkey)
 	if err == nil {
 		db.cacheValue(curr)
 	}
@@ -3,6 +3,7 @@
 package drand

 import (
+	"context"
 	"os"
 	"testing"

@@ -20,11 +21,11 @@ func TestPrintGroupInfo(t *testing.T) {
 	c, err := hclient.New(server, nil, nil)
 	assert.NoError(t, err)
 	cg := c.(interface {
-		FetchChainInfo(groupHash []byte) (*dchain.Info, error)
+		FetchChainInfo(ctx context.Context, groupHash []byte) (*dchain.Info, error)
 	})
-	chain, err := cg.FetchChainInfo(nil)
+	chain, err := cg.FetchChainInfo(context.Background(), nil)
 	assert.NoError(t, err)
-	err = chain.ToJSON(os.Stdout)
+	err = chain.ToJSON(os.Stdout, nil)
 	assert.NoError(t, err)
 }

@@ -5,7 +5,7 @@ import (
 	"sync"
 	"time"

-	lru "github.com/hashicorp/golang-lru"
+	lru "github.com/hashicorp/golang-lru/v2"
 	"github.com/libp2p/go-libp2p/core/peer"

 	"github.com/filecoin-project/lotus/build"
@@ -17,7 +17,7 @@ type blockReceiptTracker struct {

 	// using an LRU cache because i don't want to handle all the edge cases for
 	// manual cleanup and maintenance of a fixed size set
-	cache *lru.Cache
+	cache *lru.Cache[types.TipSetKey, *peerSet]
 }

 type peerSet struct {
@@ -25,7 +25,7 @@ type peerSet struct {
 }

 func newBlockReceiptTracker() *blockReceiptTracker {
-	c, _ := lru.New(512)
+	c, _ := lru.New[types.TipSetKey, *peerSet](512)
 	return &blockReceiptTracker{
 		cache: c,
 	}
@@ -46,20 +46,18 @@ func (brt *blockReceiptTracker) Add(p peer.ID, ts *types.TipSet) {
 		return
 	}

-	val.(*peerSet).peers[p] = build.Clock.Now()
+	val.peers[p] = build.Clock.Now()
 }

 func (brt *blockReceiptTracker) GetPeers(ts *types.TipSet) []peer.ID {
 	brt.lk.Lock()
 	defer brt.lk.Unlock()

-	val, ok := brt.cache.Get(ts.Key())
+	ps, ok := brt.cache.Get(ts.Key())
 	if !ok {
 		return nil
 	}

-	ps := val.(*peerSet)
-
 	out := make([]peer.ID, 0, len(ps.peers))
 	for p := range ps.peers {
 		out = append(out, p)
@@ -0,0 +1,514 @@
+package consensus
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/hashicorp/go-multierror"
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log/v2"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/multiformats/go-varint"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"go.opencensus.io/stats"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	builtintypes "github.com/filecoin-project/go-state-types/builtin"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/network"
+	blockadt "github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/api"
+	bstore "github.com/filecoin-project/lotus/blockstore"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/lib/async"
+	"github.com/filecoin-project/lotus/metrics"
+)
+
+// Common operations shared by all consensus algorithm implementations.
+var log = logging.Logger("consensus-common")
+
+// RunAsyncChecks accepts a list of checks to perform in parallel.
+//
+// Each consensus algorithm may choose to perform a set of different
+// checks when a new blocks is received.
+func RunAsyncChecks(ctx context.Context, await []async.ErrorFuture) error {
+	var merr error
+	for _, fut := range await {
+		if err := fut.AwaitContext(ctx); err != nil {
+			merr = multierror.Append(merr, err)
+		}
+	}
+	if merr != nil {
+		mulErr := merr.(*multierror.Error)
+		mulErr.ErrorFormat = func(es []error) string {
+			if len(es) == 1 {
+				return fmt.Sprintf("1 error occurred:\n\t* %+v\n\n", es[0])
+			}
+
+			points := make([]string, len(es))
+			for i, err := range es {
+				points[i] = fmt.Sprintf("* %+v", err)
+			}
+
+			return fmt.Sprintf(
+				"%d errors occurred:\n\t%s\n\n",
+				len(es), strings.Join(points, "\n\t"))
+		}
+		return mulErr
+	}
+
+	return nil
+}
+
+// CommonBlkChecks performed by all consensus implementations.
+func CommonBlkChecks(ctx context.Context, sm *stmgr.StateManager, cs *store.ChainStore,
+	b *types.FullBlock, baseTs *types.TipSet) []async.ErrorFuture {
+	h := b.Header
+	msgsCheck := async.Err(func() error {
+		if b.Cid() == build.WhitelistedBlock {
+			return nil
+		}
+
+		if err := checkBlockMessages(ctx, sm, cs, b, baseTs); err != nil {
+			return xerrors.Errorf("block had invalid messages: %w", err)
+		}
+		return nil
+	})
+
+	baseFeeCheck := async.Err(func() error {
+		baseFee, err := cs.ComputeBaseFee(ctx, baseTs)
+		if err != nil {
+			return xerrors.Errorf("computing base fee: %w", err)
+		}
+		if types.BigCmp(baseFee, b.Header.ParentBaseFee) != 0 {
+			return xerrors.Errorf("base fee doesn't match: %s (header) != %s (computed)",
+				b.Header.ParentBaseFee, baseFee)
+		}
+		return nil
+	})
+
+	stateRootCheck := async.Err(func() error {
+		stateroot, precp, err := sm.TipSetState(ctx, baseTs)
+		if err != nil {
+			return xerrors.Errorf("get tipsetstate(%d, %s) failed: %w", h.Height, h.Parents, err)
+		}
+
+		if stateroot != h.ParentStateRoot {
+			msgs, err := cs.MessagesForTipset(ctx, baseTs)
+			if err != nil {
+				log.Error("failed to load messages for tipset during tipset state mismatch error: ", err)
+			} else {
+				log.Warn("Messages for tipset with mismatching state:")
+				for i, m := range msgs {
+					mm := m.VMMessage()
+					log.Warnf("Message[%d]: from=%s to=%s method=%d params=%x", i, mm.From, mm.To, mm.Method, mm.Params)
+				}
+			}
+
+			return xerrors.Errorf("parent state root did not match computed state (%s != %s)", h.ParentStateRoot, stateroot)
+		}
+
+		if precp != h.ParentMessageReceipts {
+			return xerrors.Errorf("parent receipts root did not match computed value (%s != %s)", precp, h.ParentMessageReceipts)
+		}
+		return nil
+	})
+
+	return []async.ErrorFuture{
+		msgsCheck,
+		baseFeeCheck,
+		stateRootCheck,
+	}
+}
+
+func IsValidForSending(nv network.Version, act *types.Actor) bool {
+	// Before nv18 (Hygge), we only supported built-in account actors as senders.
+	//
+	// Note: this gate is probably superfluous, since:
+	// 1. Placeholder actors cannot be created before nv18.
+	// 2. EthAccount actors cannot be created before nv18.
+	// 3. Delegated addresses cannot be created before nv18.
+	//
+	// But it's a safeguard.
+	//
+	// Note 2: ad-hoc checks for network versions like this across the codebase
+	// will be problematic with networks with diverging version lineages
+	// (e.g. Hyperspace). We need to revisit this strategy entirely.
+	if nv < network.Version18 {
+		return builtin.IsAccountActor(act.Code)
+	}
+
+	// After nv18, we also support other kinds of senders.
+	if builtin.IsAccountActor(act.Code) || builtin.IsEthAccountActor(act.Code) {
+		return true
+	}
+
+	// Allow placeholder actors with a delegated address and nonce 0 to send a message.
+	// These will be converted to an EthAccount actor on first send.
+	if !builtin.IsPlaceholderActor(act.Code) || act.Nonce != 0 || act.Address == nil || act.Address.Protocol() != address.Delegated {
+		return false
+	}
+
+	// Only allow such actors to send if their delegated address is in the EAM's namespace.
+	id, _, err := varint.FromUvarint(act.Address.Payload())
+	return err == nil && id == builtintypes.EthereumAddressManagerActorID
+}
+
+func checkBlockMessages(ctx context.Context, sm *stmgr.StateManager, cs *store.ChainStore, b *types.FullBlock, baseTs *types.TipSet) error {
+	{
+		var sigCids []cid.Cid // this is what we get for people not wanting the marshalcbor method on the cid type
+		var pubks [][]byte
+
+		for _, m := range b.BlsMessages {
+			sigCids = append(sigCids, m.Cid())
+
+			pubk, err := sm.GetBlsPublicKey(ctx, m.From, baseTs)
+			if err != nil {
+				return xerrors.Errorf("failed to load bls public to validate block: %w", err)
+			}
+
+			pubks = append(pubks, pubk)
+		}
+
+		if err := VerifyBlsAggregate(ctx, b.Header.BLSAggregate, sigCids, pubks); err != nil {
+			return xerrors.Errorf("bls aggregate signature was invalid: %w", err)
+		}
+	}
+
+	nonces := make(map[address.Address]uint64)
+
+	stateroot, _, err := sm.TipSetState(ctx, baseTs)
+	if err != nil {
+		return xerrors.Errorf("failed to compute tipsettate for %s: %w", baseTs.Key(), err)
+	}
+
+	st, err := state.LoadStateTree(cs.ActorStore(ctx), stateroot)
+	if err != nil {
+		return xerrors.Errorf("failed to load base state tree: %w", err)
+	}
+
+	nv := sm.GetNetworkVersion(ctx, b.Header.Height)
+	pl := vm.PricelistByEpoch(b.Header.Height)
+	var sumGasLimit int64
+	checkMsg := func(msg types.ChainMsg) error {
+		m := msg.VMMessage()
+
+		// Phase 1: syntactic validation, as defined in the spec
+		minGas := pl.OnChainMessage(msg.ChainLength())
+		if err := m.ValidForBlockInclusion(minGas.Total(), nv); err != nil {
+			return xerrors.Errorf("msg %s invalid for block inclusion: %w", m.Cid(), err)
+		}
+
+		// ValidForBlockInclusion checks if any single message does not exceed BlockGasLimit
+		// So below is overflow safe
+		sumGasLimit += m.GasLimit
+		if sumGasLimit > build.BlockGasLimit {
+			return xerrors.Errorf("block gas limit exceeded")
+		}
+
+		// Phase 2: (Partial) semantic validation:
+		// the sender exists and is an account actor, and the nonces make sense
+		var sender address.Address
+		if nv >= network.Version13 {
+			sender, err = st.LookupID(m.From)
+			if err != nil {
+				return xerrors.Errorf("failed to lookup sender %s: %w", m.From, err)
+			}
+		} else {
+			sender = m.From
+		}
+
+		if _, ok := nonces[sender]; !ok {
+			// `GetActor` does not validate that this is an account actor.
+			act, err := st.GetActor(sender)
+			if err != nil {
+				return xerrors.Errorf("failed to get actor: %w", err)
+			}
+
+			if !IsValidForSending(nv, act) {
+				return xerrors.New("Sender must be an account actor")
+			}
+			nonces[sender] = act.Nonce
+		}
+
+		if nonces[sender] != m.Nonce {
+			return xerrors.Errorf("wrong nonce (exp: %d, got: %d)", nonces[sender], m.Nonce)
+		}
+		nonces[sender]++
+
+		return nil
+	}
+
+	// Validate message arrays in a temporary blockstore.
+	tmpbs := bstore.NewMemory()
+	tmpstore := blockadt.WrapStore(ctx, cbor.NewCborStore(tmpbs))
+
+	bmArr := blockadt.MakeEmptyArray(tmpstore)
+	for i, m := range b.BlsMessages {
+		if err := checkMsg(m); err != nil {
+			return xerrors.Errorf("block had invalid bls message at index %d: %w", i, err)
+		}
+
+		c, err := store.PutMessage(ctx, tmpbs, m)
+		if err != nil {
+			return xerrors.Errorf("failed to store message %s: %w", m.Cid(), err)
+		}
+
+		k := cbg.CborCid(c)
+		if err := bmArr.Set(uint64(i), &k); err != nil {
+			return xerrors.Errorf("failed to put bls message at index %d: %w", i, err)
+		}
+	}
+
+	smArr := blockadt.MakeEmptyArray(tmpstore)
+	for i, m := range b.SecpkMessages {
+		if nv >= network.Version14 && !IsValidSecpkSigType(nv, m.Signature.Type) {
+			return xerrors.Errorf("block had invalid signed message at index %d: %w", i, err)
+		}
+
+		if err := checkMsg(m); err != nil {
+			return xerrors.Errorf("block had invalid secpk message at index %d: %w", i, err)
+		}
+
+		// `From` being an account actor is only validated inside the `vm.ResolveToDeterministicAddr` call
+		// in `StateManager.ResolveToDeterministicAddress` here (and not in `checkMsg`).
+		kaddr, err := sm.ResolveToDeterministicAddress(ctx, m.Message.From, baseTs)
+		if err != nil {
+			return xerrors.Errorf("failed to resolve key addr: %w", err)
+		}
+
+		if err := AuthenticateMessage(m, kaddr); err != nil {
+			return xerrors.Errorf("failed to validate signature: %w", err)
+		}
+
+		c, err := store.PutMessage(ctx, tmpbs, m)
+		if err != nil {
+			return xerrors.Errorf("failed to store message %s: %w", m.Cid(), err)
+		}
+		k := cbg.CborCid(c)
+		if err := smArr.Set(uint64(i), &k); err != nil {
+			return xerrors.Errorf("failed to put secpk message at index %d: %w", i, err)
+		}
+	}
+
+	bmroot, err := bmArr.Root()
+	if err != nil {
+		return xerrors.Errorf("failed to root bls msgs: %w", err)
+
+	}
+
+	smroot, err := smArr.Root()
+	if err != nil {
+		return xerrors.Errorf("failed to root secp msgs: %w", err)
+	}
+
+	mrcid, err := tmpstore.Put(ctx, &types.MsgMeta{
+		BlsMessages:   bmroot,
+		SecpkMessages: smroot,
+	})
+	if err != nil {
+		return xerrors.Errorf("failed to put msg meta: %w", err)
+	}
+
+	if b.Header.Messages != mrcid {
+		return fmt.Errorf("messages didnt match message root in header")
+	}
+
+	// Finally, flush.
+	err = vm.Copy(ctx, tmpbs, cs.ChainBlockstore(), mrcid)
+	if err != nil {
+		return xerrors.Errorf("failed to flush:%w", err)
+	}
+
+	return nil
+}
+
+// CreateBlockHeader generates the block header from the block template of
+// the block being proposed.
+func CreateBlockHeader(ctx context.Context, sm *stmgr.StateManager, pts *types.TipSet,
+	bt *api.BlockTemplate) (*types.BlockHeader, []*types.Message, []*types.SignedMessage, error) {
+
+	st, recpts, err := sm.TipSetState(ctx, pts)
+	if err != nil {
+		return nil, nil, nil, xerrors.Errorf("failed to load tipset state: %w", err)
+	}
+	next := &types.BlockHeader{
+		Miner:         bt.Miner,
+		Parents:       bt.Parents.Cids(),
+		Ticket:        bt.Ticket,
+		ElectionProof: bt.Eproof,
+
+		BeaconEntries:         bt.BeaconValues,
+		Height:                bt.Epoch,
+		Timestamp:             bt.Timestamp,
+		WinPoStProof:          bt.WinningPoStProof,
+		ParentStateRoot:       st,
+		ParentMessageReceipts: recpts,
+	}
+
+	var blsMessages []*types.Message
+	var secpkMessages []*types.SignedMessage
+
+	var blsMsgCids, secpkMsgCids []cid.Cid
+	var blsSigs []crypto.Signature
+	nv := sm.GetNetworkVersion(ctx, bt.Epoch)
+	for _, msg := range bt.Messages {
+		if msg.Signature.Type == crypto.SigTypeBLS {
+			blsSigs = append(blsSigs, msg.Signature)
+			blsMessages = append(blsMessages, &msg.Message)
+
+			c, err := sm.ChainStore().PutMessage(ctx, &msg.Message)
+			if err != nil {
+				return nil, nil, nil, err
+			}
+
+			blsMsgCids = append(blsMsgCids, c)
+		} else if IsValidSecpkSigType(nv, msg.Signature.Type) {
+			c, err := sm.ChainStore().PutMessage(ctx, msg)
+			if err != nil {
+				return nil, nil, nil, err
+			}
+
+			secpkMsgCids = append(secpkMsgCids, c)
+			secpkMessages = append(secpkMessages, msg)
+
+		} else {
+			return nil, nil, nil, xerrors.Errorf("unknown sig type: %d", msg.Signature.Type)
+		}
+	}
+
+	store := sm.ChainStore().ActorStore(ctx)
+	blsmsgroot, err := ToMessagesArray(store, blsMsgCids)
+	if err != nil {
+		return nil, nil, nil, xerrors.Errorf("building bls amt: %w", err)
+	}
+	secpkmsgroot, err := ToMessagesArray(store, secpkMsgCids)
+	if err != nil {
+		return nil, nil, nil, xerrors.Errorf("building secpk amt: %w", err)
+	}
+
+	mmcid, err := store.Put(store.Context(), &types.MsgMeta{
+		BlsMessages:   blsmsgroot,
+		SecpkMessages: secpkmsgroot,
+	})
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	next.Messages = mmcid
+
+	aggSig, err := AggregateSignatures(blsSigs)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	next.BLSAggregate = aggSig
+	pweight, err := sm.ChainStore().Weight(ctx, pts)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	next.ParentWeight = pweight
+
+	baseFee, err := sm.ChainStore().ComputeBaseFee(ctx, pts)
+	if err != nil {
+		return nil, nil, nil, xerrors.Errorf("computing base fee: %w", err)
+	}
+	next.ParentBaseFee = baseFee
+
+	return next, blsMessages, secpkMessages, err
+
+}
+
+// Basic sanity-checks performed when a block is proposed locally.
+func validateLocalBlock(ctx context.Context, msg *pubsub.Message) (pubsub.ValidationResult, string) {
+	stats.Record(ctx, metrics.BlockPublished.M(1))
+
+	if size := msg.Size(); size > 1<<20-1<<15 {
+		log.Errorf("ignoring oversize block (%dB)", size)
+		return pubsub.ValidationIgnore, "oversize_block"
+	}
+
+	blk, what, err := decodeAndCheckBlock(msg)
+	if err != nil {
+		log.Errorf("got invalid local block: %s", err)
+		return pubsub.ValidationIgnore, what
+	}
+
+	msg.ValidatorData = blk
+	stats.Record(ctx, metrics.BlockValidationSuccess.M(1))
+	return pubsub.ValidationAccept, ""
+}
+
+func decodeAndCheckBlock(msg *pubsub.Message) (*types.BlockMsg, string, error) {
+	blk, err := types.DecodeBlockMsg(msg.GetData())
+	if err != nil {
+		return nil, "invalid", xerrors.Errorf("error decoding block: %w", err)
+	}
+
+	if count := len(blk.BlsMessages) + len(blk.SecpkMessages); count > build.BlockMessageLimit {
+		return nil, "too_many_messages", fmt.Errorf("block contains too many messages (%d)", count)
+	}
+
+	// make sure we have a signature
+	if blk.Header.BlockSig == nil {
+		return nil, "missing_signature", fmt.Errorf("block without a signature")
+	}
+
+	return blk, "", nil
+}
+
+func validateMsgMeta(ctx context.Context, msg *types.BlockMsg) error {
+	// TODO there has to be a simpler way to do this without the blockstore dance
+	// block headers use adt0
+	store := blockadt.WrapStore(ctx, cbor.NewCborStore(bstore.NewMemory()))
+	bmArr := blockadt.MakeEmptyArray(store)
+	smArr := blockadt.MakeEmptyArray(store)
+
+	for i, m := range msg.BlsMessages {
+		c := cbg.CborCid(m)
+		if err := bmArr.Set(uint64(i), &c); err != nil {
+			return err
+		}
+	}
+
+	for i, m := range msg.SecpkMessages {
+		c := cbg.CborCid(m)
+		if err := smArr.Set(uint64(i), &c); err != nil {
+			return err
+		}
+	}
+
+	bmroot, err := bmArr.Root()
+	if err != nil {
+		return err
+	}
+
+	smroot, err := smArr.Root()
+	if err != nil {
+		return err
+	}
+
+	mrcid, err := store.Put(store.Context(), &types.MsgMeta{
+		BlsMessages:   bmroot,
+		SecpkMessages: smroot,
+	})
+
+	if err != nil {
+		return err
+	}
+
+	if msg.Header.Messages != mrcid {
+		return fmt.Errorf("messages didn't match root cid in header")
+	}
+
+	return nil
+}
@@ -1,8 +1,9 @@
-package filcns
+package consensus

 import (
 	"context"
 	"sync/atomic"
+	"time"

 	"github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
@@ -26,7 +27,6 @@ import (

 	"github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/cron"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
@@ -55,10 +55,12 @@ func NewActorRegistry() *vm.ActorRegistry {
 	return inv
 }

-type TipSetExecutor struct{}
+type TipSetExecutor struct {
+	reward RewardFunc
+}

-func NewTipSetExecutor() *TipSetExecutor {
-	return &TipSetExecutor{}
+func NewTipSetExecutor(r RewardFunc) *TipSetExecutor {
+	return &TipSetExecutor{reward: r}
 }

 func (t *TipSetExecutor) NewActorRegistry() *vm.ActorRegistry {
@@ -107,11 +109,14 @@ func (t *TipSetExecutor) ApplyBlocks(ctx context.Context,
 			TipSetGetter:   stmgr.TipSetGetterForTipset(sm.ChainStore(), ts),
 			Tracing:        vmTracing,
 			ReturnEvents:   sm.ChainStore().IsStoringEvents(),
+			ExecutionLane:  vm.ExecutionLanePriority,
 		}

 		return sm.VMConstructor()(ctx, vmopt)
 	}

+	var cronGas int64
+
 	runCron := func(vmCron vm.Interface, epoch abi.ChainEpoch) error {
 		cronMsg := &types.Message{
 			To:         cron.Address,
@@ -129,6 +134,8 @@ func (t *TipSetExecutor) ApplyBlocks(ctx context.Context,
 			return xerrors.Errorf("running cron: %w", err)
 		}

+		cronGas += ret.GasUsed
+
 		if em != nil {
 			if err := em.MessageApplied(ctx, ts, cronMsg.Cid(), cronMsg, ret, true); err != nil {
 				return xerrors.Errorf("callback failed on cron message: %w", err)
@@ -180,7 +187,9 @@ func (t *TipSetExecutor) ApplyBlocks(ctx context.Context,
 		}
 	}

-	partDone()
+	vmEarly := partDone()
+	earlyCronGas := cronGas
+	cronGas = 0
 	partDone = metrics.Timer(ctx, metrics.VMApplyMessages)

 	vmi, err := makeVm(pstate, epoch, ts.MinTimestamp())
@@ -195,6 +204,8 @@ func (t *TipSetExecutor) ApplyBlocks(ctx context.Context,
 		processedMsgs = make(map[cid.Cid]struct{})
 	)

+	var msgGas int64
+
 	for _, b := range bms {
 		penalty := types.NewInt(0)
 		gasReward := big.Zero()
@@ -209,6 +220,8 @@ func (t *TipSetExecutor) ApplyBlocks(ctx context.Context,
 				return cid.Undef, cid.Undef, err
 			}

+			msgGas += r.GasUsed
+
 			receipts = append(receipts, &r.MessageReceipt)
 			gasReward = big.Add(gasReward, r.GasCosts.MinerTip)
 			penalty = big.Add(penalty, r.GasCosts.MinerPenalty)
@@ -226,50 +239,26 @@ func (t *TipSetExecutor) ApplyBlocks(ctx context.Context,
 			processedMsgs[m.Cid()] = struct{}{}
 		}

-		params, err := actors.SerializeParams(&reward.AwardBlockRewardParams{
+		params := &reward.AwardBlockRewardParams{
 			Miner:     b.Miner,
 			Penalty:   penalty,
 			GasReward: gasReward,
 			WinCount:  b.WinCount,
-		})
-		if err != nil {
-			return cid.Undef, cid.Undef, xerrors.Errorf("failed to serialize award params: %w", err)
 		}
-
-		rwMsg := &types.Message{
-			From:       builtin.SystemActorAddr,
-			To:         reward.Address,
-			Nonce:      uint64(epoch),
-			Value:      types.NewInt(0),
-			GasFeeCap:  types.NewInt(0),
-			GasPremium: types.NewInt(0),
-			GasLimit:   1 << 30,
-			Method:     reward.Methods.AwardBlockReward,
-			Params:     params,
-		}
-		ret, actErr := vmi.ApplyImplicitMessage(ctx, rwMsg)
-		if actErr != nil {
-			return cid.Undef, cid.Undef, xerrors.Errorf("failed to apply reward message for miner %s: %w", b.Miner, actErr)
-		}
-		if em != nil {
-			if err := em.MessageApplied(ctx, ts, rwMsg.Cid(), rwMsg, ret, true); err != nil {
-				return cid.Undef, cid.Undef, xerrors.Errorf("callback failed on reward message: %w", err)
-			}
-		}
-
-		if ret.ExitCode != 0 {
-			return cid.Undef, cid.Undef, xerrors.Errorf("reward application message failed (exit %d): %s", ret.ExitCode, ret.ActorErr)
+		rErr := t.reward(ctx, vmi, em, epoch, ts, params)
+		if rErr != nil {
+			return cid.Undef, cid.Undef, xerrors.Errorf("error applying reward: %w", rErr)
 		}
 	}

-	partDone()
+	vmMsg := partDone()
 	partDone = metrics.Timer(ctx, metrics.VMApplyCron)

 	if err := runCron(vmi, epoch); err != nil {
 		return cid.Cid{}, cid.Cid{}, err
 	}

-	partDone()
+	vmCron := partDone()
 	partDone = metrics.Timer(ctx, metrics.VMApplyFlush)

 	rectarr := blockadt.MakeEmptyArray(sm.ChainStore().ActorStore(ctx))
@@ -305,6 +294,11 @@ func (t *TipSetExecutor) ApplyBlocks(ctx context.Context,
 		return cid.Undef, cid.Undef, xerrors.Errorf("vm flush failed: %w", err)
 	}

+	vmFlush := partDone()
+	partDone = func() time.Duration { return time.Duration(0) }
+
+	log.Infow("ApplyBlocks stats", "early", vmEarly, "earlyCronGas", earlyCronGas, "vmMsg", vmMsg, "msgGas", msgGas, "vmCron", vmCron, "cronGas", cronGas, "vmFlush", vmFlush, "epoch", epoch, "tsk", ts.Key())
+
 	stats.Record(ctx, metrics.VMSends.M(int64(atomic.LoadUint64(&vm.StatSends))),
 		metrics.VMApplied.M(int64(atomic.LoadUint64(&vm.StatApplied))))

@@ -4,46 +4,36 @@ import (
 	"bytes"
 	"context"
 	"errors"
-	"fmt"
 	"os"
-	"strings"
 	"time"

-	"github.com/hashicorp/go-multierror"
 	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
 	logging "github.com/ipfs/go-log/v2"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"github.com/multiformats/go-varint"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"go.opencensus.io/stats"
 	"go.opencensus.io/trace"
 	"golang.org/x/xerrors"

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	builtintypes "github.com/filecoin-project/go-state-types/builtin"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/network"
-	blockadt "github.com/filecoin-project/specs-actors/actors/util/adt"
 	"github.com/filecoin-project/specs-actors/v7/actors/runtime/proof"

-	bstore "github.com/filecoin-project/lotus/blockstore"
+	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain"
+	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
 	"github.com/filecoin-project/lotus/chain/beacon"
 	"github.com/filecoin-project/lotus/chain/consensus"
 	"github.com/filecoin-project/lotus/chain/rand"
-	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
 	"github.com/filecoin-project/lotus/lib/async"
 	"github.com/filecoin-project/lotus/lib/sigs"
-	"github.com/filecoin-project/lotus/metrics"
 	"github.com/filecoin-project/lotus/storage/sealer/ffiwrapper"
 	"github.com/filecoin-project/lotus/storage/sealer/storiface"
 )
@@ -69,6 +59,39 @@ type FilecoinEC struct {
 // the theoretical max height based on systime are quickly rejected
 const MaxHeightDrift = 5

+var RewardFunc = func(ctx context.Context, vmi vm.Interface, em stmgr.ExecMonitor,
+	epoch abi.ChainEpoch, ts *types.TipSet, params *reward.AwardBlockRewardParams) error {
+	ser, err := actors.SerializeParams(params)
+	if err != nil {
+		return xerrors.Errorf("failed to serialize award params: %w", err)
+	}
+	rwMsg := &types.Message{
+		From:       builtin.SystemActorAddr,
+		To:         reward.Address,
+		Nonce:      uint64(epoch),
+		Value:      types.NewInt(0),
+		GasFeeCap:  types.NewInt(0),
+		GasPremium: types.NewInt(0),
+		GasLimit:   1 << 30,
+		Method:     reward.Methods.AwardBlockReward,
+		Params:     ser,
+	}
+	ret, actErr := vmi.ApplyImplicitMessage(ctx, rwMsg)
+	if actErr != nil {
+		return xerrors.Errorf("failed to apply reward message: %w", actErr)
+	}
+	if em != nil {
+		if err := em.MessageApplied(ctx, ts, rwMsg.Cid(), rwMsg, ret, true); err != nil {
+			return xerrors.Errorf("callback failed on reward message: %w", err)
+		}
+	}
+
+	if ret.ExitCode != 0 {
+		return xerrors.Errorf("reward application message failed (exit %d): %s", ret.ExitCode, ret.ActorErr)
+	}
+	return nil
+}
+
 func NewFilecoinExpectedConsensus(sm *stmgr.StateManager, beacon beacon.Schedule, verifier storiface.Verifier, genesis chain.Genesis) consensus.Consensus {
 	if build.InsecurePoStValidation {
 		log.Warn("*********************************************************************************************")
@@ -127,17 +150,6 @@ func (filec *FilecoinEC) ValidateBlock(ctx context.Context, b *types.FullBlock)
 		log.Warn("Got block from the future, but within threshold", h.Timestamp, build.Clock.Now().Unix())
 	}

-	msgsCheck := async.Err(func() error {
-		if b.Cid() == build.WhitelistedBlock {
-			return nil
-		}
-
-		if err := filec.checkBlockMessages(ctx, b, baseTs); err != nil {
-			return xerrors.Errorf("block had invalid messages: %w", err)
-		}
-		return nil
-	})
-
 	minerCheck := async.Err(func() error {
 		if err := filec.minerIsValid(ctx, h.Miner, baseTs); err != nil {
 			return xerrors.Errorf("minerIsValid failed: %w", err)
@@ -145,17 +157,6 @@ func (filec *FilecoinEC) ValidateBlock(ctx context.Context, b *types.FullBlock)
 		return nil
 	})

-	baseFeeCheck := async.Err(func() error {
-		baseFee, err := filec.store.ComputeBaseFee(ctx, baseTs)
-		if err != nil {
-			return xerrors.Errorf("computing base fee: %w", err)
-		}
-		if types.BigCmp(baseFee, b.Header.ParentBaseFee) != 0 {
-			return xerrors.Errorf("base fee doesn't match: %s (header) != %s (computed)",
-				b.Header.ParentBaseFee, baseFee)
-		}
-		return nil
-	})
 	pweight, err := filec.store.Weight(ctx, baseTs)
 	if err != nil {
 		return xerrors.Errorf("getting parent weight: %w", err)
@@ -166,34 +167,6 @@ func (filec *FilecoinEC) ValidateBlock(ctx context.Context, b *types.FullBlock)
 			b.Header.ParentWeight, pweight)
 	}

-	stateRootCheck := async.Err(func() error {
-		stateroot, precp, err := filec.sm.TipSetState(ctx, baseTs)
-		if err != nil {
-			return xerrors.Errorf("get tipsetstate(%d, %s) failed: %w", h.Height, h.Parents, err)
-		}
-
-		if stateroot != h.ParentStateRoot {
-			msgs, err := filec.store.MessagesForTipset(ctx, baseTs)
-			if err != nil {
-				log.Error("failed to load messages for tipset during tipset state mismatch error: ", err)
-			} else {
-				log.Warn("Messages for tipset with mismatching state:")
-				for i, m := range msgs {
-					mm := m.VMMessage()
-					log.Warnf("Message[%d]: from=%s to=%s method=%d params=%x", i, mm.From, mm.To, mm.Method, mm.Params)
-				}
-			}
-
-			return xerrors.Errorf("parent state root did not match computed state (%s != %s)", h.ParentStateRoot, stateroot)
-		}
-
-		if precp != h.ParentMessageReceipts {
-			return xerrors.Errorf("parent receipts root did not match computed value (%s != %s)", precp, h.ParentMessageReceipts)
-		}
-
-		return nil
-	})
-
 	// Stuff that needs worker address
 	waddr, err := stmgr.GetMinerWorkerRaw(ctx, filec.sm, lbst, h.Miner)
 	if err != nil {
@@ -255,10 +228,11 @@ func (filec *FilecoinEC) ValidateBlock(ctx context.Context, b *types.FullBlock)
 	})

 	blockSigCheck := async.Err(func() error {
-		if err := sigs.CheckBlockSignature(ctx, h, waddr); err != nil {
+		if err := verifyBlockSignature(ctx, h, waddr); err != nil {
 			return xerrors.Errorf("check block signature failed: %w", err)
 		}
 		return nil
+
 	})

 	beaconValuesCheck := async.Err(func() error {
@@ -307,44 +281,17 @@ func (filec *FilecoinEC) ValidateBlock(ctx context.Context, b *types.FullBlock)
 		return nil
 	})

-	await := []async.ErrorFuture{
+	commonChecks := consensus.CommonBlkChecks(ctx, filec.sm, filec.store, b, baseTs)
+	await := append([]async.ErrorFuture{
 		minerCheck,
 		tktsCheck,
 		blockSigCheck,
 		beaconValuesCheck,
 		wproofCheck,
 		winnerCheck,
-		msgsCheck,
-		baseFeeCheck,
-		stateRootCheck,
-	}
+	}, commonChecks...)

-	var merr error
-	for _, fut := range await {
-		if err := fut.AwaitContext(ctx); err != nil {
-			merr = multierror.Append(merr, err)
-		}
-	}
-	if merr != nil {
-		mulErr := merr.(*multierror.Error)
-		mulErr.ErrorFormat = func(es []error) string {
-			if len(es) == 1 {
-				return fmt.Sprintf("1 error occurred:\n\t* %+v\n\n", es[0])
-			}
-
-			points := make([]string, len(es))
-			for i, err := range es {
-				points[i] = fmt.Sprintf("* %+v", err)
-			}
-
-			return fmt.Sprintf(
-				"%d errors occurred:\n\t%s\n\n",
-				len(es), strings.Join(points, "\n\t"))
-		}
-		return mulErr
-	}
-
-	return nil
+	return consensus.RunAsyncChecks(ctx, await)
 }

 func blockSanityChecks(h *types.BlockHeader) error {
@@ -435,209 +382,6 @@ func (filec *FilecoinEC) VerifyWinningPoStProof(ctx context.Context, nv network.
 	return nil
 }

-func IsValidForSending(nv network.Version, act *types.Actor) bool {
-	// Before nv18 (Hygge), we only supported built-in account actors as senders.
-	//
-	// Note: this gate is probably superfluous, since:
-	// 1. Placeholder actors cannot be created before nv18.
-	// 2. EthAccount actors cannot be created before nv18.
-	// 3. Delegated addresses cannot be created before nv18.
-	//
-	// But it's a safeguard.
-	//
-	// Note 2: ad-hoc checks for network versions like this across the codebase
-	// will be problematic with networks with diverging version lineages
-	// (e.g. Hyperspace). We need to revisit this strategy entirely.
-	if nv < network.Version18 {
-		return builtin.IsAccountActor(act.Code)
-	}
-
-	// After nv18, we also support other kinds of senders.
-	if builtin.IsAccountActor(act.Code) || builtin.IsEthAccountActor(act.Code) {
-		return true
-	}
-
-	// Allow placeholder actors with a delegated address and nonce 0 to send a message.
-	// These will be converted to an EthAccount actor on first send.
-	if !builtin.IsPlaceholderActor(act.Code) || act.Nonce != 0 || act.Address == nil || act.Address.Protocol() != address.Delegated {
-		return false
-	}
-
-	// Only allow such actors to send if their delegated address is in the EAM's namespace.
-	id, _, err := varint.FromUvarint(act.Address.Payload())
-	return err == nil && id == builtintypes.EthereumAddressManagerActorID
-}
-
-// TODO: We should extract this somewhere else and make the message pool and miner use the same logic
-func (filec *FilecoinEC) checkBlockMessages(ctx context.Context, b *types.FullBlock, baseTs *types.TipSet) error {
-	{
-		var sigCids []cid.Cid // this is what we get for people not wanting the marshalcbor method on the cid type
-		var pubks [][]byte
-
-		for _, m := range b.BlsMessages {
-			sigCids = append(sigCids, m.Cid())
-
-			pubk, err := filec.sm.GetBlsPublicKey(ctx, m.From, baseTs)
-			if err != nil {
-				return xerrors.Errorf("failed to load bls public to validate block: %w", err)
-			}
-
-			pubks = append(pubks, pubk)
-		}
-
-		if err := consensus.VerifyBlsAggregate(ctx, b.Header.BLSAggregate, sigCids, pubks); err != nil {
-			return xerrors.Errorf("bls aggregate signature was invalid: %w", err)
-		}
-	}
-
-	nonces := make(map[address.Address]uint64)
-
-	stateroot, _, err := filec.sm.TipSetState(ctx, baseTs)
-	if err != nil {
-		return xerrors.Errorf("failed to compute tipsettate for %s: %w", baseTs.Key(), err)
-	}
-
-	st, err := state.LoadStateTree(filec.store.ActorStore(ctx), stateroot)
-	if err != nil {
-		return xerrors.Errorf("failed to load base state tree: %w", err)
-	}
-
-	nv := filec.sm.GetNetworkVersion(ctx, b.Header.Height)
-	pl := vm.PricelistByEpoch(b.Header.Height)
-	var sumGasLimit int64
-	checkMsg := func(msg types.ChainMsg) error {
-		m := msg.VMMessage()
-
-		// Phase 1: syntactic validation, as defined in the spec
-		minGas := pl.OnChainMessage(msg.ChainLength())
-		if err := m.ValidForBlockInclusion(minGas.Total(), nv); err != nil {
-			return xerrors.Errorf("msg %s invalid for block inclusion: %w", m.Cid(), err)
-		}
-
-		// ValidForBlockInclusion checks if any single message does not exceed BlockGasLimit
-		// So below is overflow safe
-		sumGasLimit += m.GasLimit
-		if sumGasLimit > build.BlockGasLimit {
-			return xerrors.Errorf("block gas limit exceeded")
-		}
-
-		// Phase 2: (Partial) semantic validation:
-		// the sender exists and is an account actor, and the nonces make sense
-		var sender address.Address
-		if nv >= network.Version13 {
-			sender, err = st.LookupID(m.From)
-			if err != nil {
-				return xerrors.Errorf("failed to lookup sender %s: %w", m.From, err)
-			}
-		} else {
-			sender = m.From
-		}
-
-		if _, ok := nonces[sender]; !ok {
-			// `GetActor` does not validate that this is an account actor.
-			act, err := st.GetActor(sender)
-			if err != nil {
-				return xerrors.Errorf("failed to get actor: %w", err)
-			}
-
-			if !IsValidForSending(nv, act) {
-				return xerrors.New("Sender must be an account actor")
-			}
-			nonces[sender] = act.Nonce
-		}
-
-		if nonces[sender] != m.Nonce {
-			return xerrors.Errorf("wrong nonce (exp: %d, got: %d)", nonces[sender], m.Nonce)
-		}
-		nonces[sender]++
-
-		return nil
-	}
-
-	// Validate message arrays in a temporary blockstore.
-	tmpbs := bstore.NewMemory()
-	tmpstore := blockadt.WrapStore(ctx, cbor.NewCborStore(tmpbs))
-
-	bmArr := blockadt.MakeEmptyArray(tmpstore)
-	for i, m := range b.BlsMessages {
-		if err := checkMsg(m); err != nil {
-			return xerrors.Errorf("block had invalid bls message at index %d: %w", i, err)
-		}
-
-		c, err := store.PutMessage(ctx, tmpbs, m)
-		if err != nil {
-			return xerrors.Errorf("failed to store message %s: %w", m.Cid(), err)
-		}
-
-		k := cbg.CborCid(c)
-		if err := bmArr.Set(uint64(i), &k); err != nil {
-			return xerrors.Errorf("failed to put bls message at index %d: %w", i, err)
-		}
-	}
-
-	smArr := blockadt.MakeEmptyArray(tmpstore)
-	for i, m := range b.SecpkMessages {
-		if nv >= network.Version14 && !chain.IsValidSecpkSigType(nv, m.Signature.Type) {
-			return xerrors.Errorf("block had invalid signed message at index %d: %w", i, err)
-		}
-
-		if err := checkMsg(m); err != nil {
-			return xerrors.Errorf("block had invalid secpk message at index %d: %w", i, err)
-		}
-
-		// `From` being an account actor is only validated inside the `vm.ResolveToDeterministicAddr` call
-		// in `StateManager.ResolveToDeterministicAddress` here (and not in `checkMsg`).
-		kaddr, err := filec.sm.ResolveToDeterministicAddress(ctx, m.Message.From, baseTs)
-		if err != nil {
-			return xerrors.Errorf("failed to resolve key addr: %w", err)
-		}
-
-		if err := chain.AuthenticateMessage(m, kaddr); err != nil {
-			return xerrors.Errorf("failed to validate signature: %w", err)
-		}
-
-		c, err := store.PutMessage(ctx, tmpbs, m)
-		if err != nil {
-			return xerrors.Errorf("failed to store message %s: %w", m.Cid(), err)
-		}
-		k := cbg.CborCid(c)
-		if err := smArr.Set(uint64(i), &k); err != nil {
-			return xerrors.Errorf("failed to put secpk message at index %d: %w", i, err)
-		}
-	}
-
-	bmroot, err := bmArr.Root()
-	if err != nil {
-		return xerrors.Errorf("failed to root bls msgs: %w", err)
-
-	}
-
-	smroot, err := smArr.Root()
-	if err != nil {
-		return xerrors.Errorf("failed to root secp msgs: %w", err)
-	}
-
-	mrcid, err := tmpstore.Put(ctx, &types.MsgMeta{
-		BlsMessages:   bmroot,
-		SecpkMessages: smroot,
-	})
-	if err != nil {
-		return xerrors.Errorf("failed to put msg meta: %w", err)
-	}
-
-	if b.Header.Messages != mrcid {
-		return fmt.Errorf("messages didnt match message root in header")
-	}
-
-	// Finally, flush.
-	err = vm.Copy(ctx, tmpbs, filec.store.ChainBlockstore(), mrcid)
-	if err != nil {
-		return xerrors.Errorf("failed to flush:%w", err)
-	}
-
-	return nil
-}
-
 func (filec *FilecoinEC) IsEpochBeyondCurrMax(epoch abi.ChainEpoch) bool {
 	if filec.genesis == nil {
 		return false
@@ -693,140 +437,7 @@ func VerifyVRF(ctx context.Context, worker address.Address, vrfBase, vrfproof []
 var ErrSoftFailure = errors.New("soft validation failure")
 var ErrInsufficientPower = errors.New("incoming block's miner does not have minimum power")

-func (filec *FilecoinEC) ValidateBlockPubsub(ctx context.Context, self bool, msg *pubsub.Message) (pubsub.ValidationResult, string) {
-	if self {
-		return filec.validateLocalBlock(ctx, msg)
-	}
-
-	// track validation time
-	begin := build.Clock.Now()
-	defer func() {
-		log.Debugf("block validation time: %s", build.Clock.Since(begin))
-	}()
-
-	stats.Record(ctx, metrics.BlockReceived.M(1))
-
-	recordFailureFlagPeer := func(what string) {
-		// bv.Validate will flag the peer in that case
-		panic(what)
-	}
-
-	blk, what, err := filec.decodeAndCheckBlock(msg)
-	if err != nil {
-		log.Error("got invalid block over pubsub: ", err)
-		recordFailureFlagPeer(what)
-		return pubsub.ValidationReject, what
-	}
-
-	// validate the block meta: the Message CID in the header must match the included messages
-	err = filec.validateMsgMeta(ctx, blk)
-	if err != nil {
-		log.Warnf("error validating message metadata: %s", err)
-		recordFailureFlagPeer("invalid_block_meta")
-		return pubsub.ValidationReject, "invalid_block_meta"
-	}
-
-	reject, err := filec.validateBlockHeader(ctx, blk.Header)
-	if err != nil {
-		if reject == "" {
-			log.Warn("ignoring block msg: ", err)
-			return pubsub.ValidationIgnore, reject
-		}
-		recordFailureFlagPeer(reject)
-		return pubsub.ValidationReject, reject
-	}
-
-	// all good, accept the block
-	msg.ValidatorData = blk
-	stats.Record(ctx, metrics.BlockValidationSuccess.M(1))
-	return pubsub.ValidationAccept, ""
-}
-
-func (filec *FilecoinEC) validateLocalBlock(ctx context.Context, msg *pubsub.Message) (pubsub.ValidationResult, string) {
-	stats.Record(ctx, metrics.BlockPublished.M(1))
-
-	if size := msg.Size(); size > 1<<20-1<<15 {
-		log.Errorf("ignoring oversize block (%dB)", size)
-		return pubsub.ValidationIgnore, "oversize_block"
-	}
-
-	blk, what, err := filec.decodeAndCheckBlock(msg)
-	if err != nil {
-		log.Errorf("got invalid local block: %s", err)
-		return pubsub.ValidationIgnore, what
-	}
-
-	msg.ValidatorData = blk
-	stats.Record(ctx, metrics.BlockValidationSuccess.M(1))
-	return pubsub.ValidationAccept, ""
-}
-
-func (filec *FilecoinEC) decodeAndCheckBlock(msg *pubsub.Message) (*types.BlockMsg, string, error) {
-	blk, err := types.DecodeBlockMsg(msg.GetData())
-	if err != nil {
-		return nil, "invalid", xerrors.Errorf("error decoding block: %w", err)
-	}
-
-	if count := len(blk.BlsMessages) + len(blk.SecpkMessages); count > build.BlockMessageLimit {
-		return nil, "too_many_messages", fmt.Errorf("block contains too many messages (%d)", count)
-	}
-
-	// make sure we have a signature
-	if blk.Header.BlockSig == nil {
-		return nil, "missing_signature", fmt.Errorf("block without a signature")
-	}
-
-	return blk, "", nil
-}
-
-func (filec *FilecoinEC) validateMsgMeta(ctx context.Context, msg *types.BlockMsg) error {
-	// TODO there has to be a simpler way to do this without the blockstore dance
-	// block headers use adt0
-	store := blockadt.WrapStore(ctx, cbor.NewCborStore(bstore.NewMemory()))
-	bmArr := blockadt.MakeEmptyArray(store)
-	smArr := blockadt.MakeEmptyArray(store)
-
-	for i, m := range msg.BlsMessages {
-		c := cbg.CborCid(m)
-		if err := bmArr.Set(uint64(i), &c); err != nil {
-			return err
-		}
-	}
-
-	for i, m := range msg.SecpkMessages {
-		c := cbg.CborCid(m)
-		if err := smArr.Set(uint64(i), &c); err != nil {
-			return err
-		}
-	}
-
-	bmroot, err := bmArr.Root()
-	if err != nil {
-		return err
-	}
-
-	smroot, err := smArr.Root()
-	if err != nil {
-		return err
-	}
-
-	mrcid, err := store.Put(store.Context(), &types.MsgMeta{
-		BlsMessages:   bmroot,
-		SecpkMessages: smroot,
-	})
-
-	if err != nil {
-		return err
-	}
-
-	if msg.Header.Messages != mrcid {
-		return fmt.Errorf("messages didn't match root cid in header")
-	}
-
-	return nil
-}
-
-func (filec *FilecoinEC) validateBlockHeader(ctx context.Context, b *types.BlockHeader) (rejectReason string, err error) {
+func (filec *FilecoinEC) ValidateBlockHeader(ctx context.Context, b *types.BlockHeader) (rejectReason string, err error) {

 	// we want to ensure that it is a block from a known miner; we reject blocks from unknown miners
 	// to prevent spam attacks.
@@ -901,4 +512,27 @@ func (filec *FilecoinEC) isChainNearSynced() bool {
 	return build.Clock.Since(timestampTime) < 6*time.Hour
 }

+func verifyBlockSignature(ctx context.Context, h *types.BlockHeader,
+	addr address.Address) error {
+	return sigs.CheckBlockSignature(ctx, h, addr)
+}
+
+func signBlock(ctx context.Context, w api.Wallet,
+	addr address.Address, next *types.BlockHeader) error {
+
+	nosigbytes, err := next.SigningBytes()
+	if err != nil {
+		return xerrors.Errorf("failed to get signing bytes for block: %w", err)
+	}
+
+	sig, err := w.WalletSign(ctx, addr, nosigbytes, api.MsgMeta{
+		Type: api.MTBlock,
+	})
+	if err != nil {
+		return xerrors.Errorf("failed to sign new block: %w", err)
+	}
+	next.BlockSig = sig
+	return nil
+}
+
 var _ consensus.Consensus = &FilecoinEC{}
@@ -3,13 +3,9 @@ package filcns
 import (
 	"context"

-	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"

-	"github.com/filecoin-project/go-state-types/crypto"
-
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain"
 	"github.com/filecoin-project/lotus/chain/consensus"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -21,11 +17,6 @@ func (filec *FilecoinEC) CreateBlock(ctx context.Context, w api.Wallet, bt *api.
 		return nil, xerrors.Errorf("failed to load parent tipset: %w", err)
 	}

-	st, recpts, err := filec.sm.TipSetState(ctx, pts)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to load tipset state: %w", err)
-	}
-
 	_, lbst, err := stmgr.GetLookbackTipSetForRound(ctx, filec.sm, pts, bt.Epoch)
 	if err != nil {
 		return nil, xerrors.Errorf("getting lookback miner actor state: %w", err)
@@ -36,102 +27,15 @@ func (filec *FilecoinEC) CreateBlock(ctx context.Context, w api.Wallet, bt *api.
 		return nil, xerrors.Errorf("failed to get miner worker: %w", err)
 	}

-	next := &types.BlockHeader{
-		Miner:         bt.Miner,
-		Parents:       bt.Parents.Cids(),
-		Ticket:        bt.Ticket,
-		ElectionProof: bt.Eproof,
-
-		BeaconEntries:         bt.BeaconValues,
-		Height:                bt.Epoch,
-		Timestamp:             bt.Timestamp,
-		WinPoStProof:          bt.WinningPoStProof,
-		ParentStateRoot:       st,
-		ParentMessageReceipts: recpts,
-	}
-
-	var blsMessages []*types.Message
-	var secpkMessages []*types.SignedMessage
-
-	var blsMsgCids, secpkMsgCids []cid.Cid
-	var blsSigs []crypto.Signature
-	nv := filec.sm.GetNetworkVersion(ctx, bt.Epoch)
-	for _, msg := range bt.Messages {
-		if msg.Signature.Type == crypto.SigTypeBLS {
-			blsSigs = append(blsSigs, msg.Signature)
-			blsMessages = append(blsMessages, &msg.Message)
-
-			c, err := filec.sm.ChainStore().PutMessage(ctx, &msg.Message)
-			if err != nil {
-				return nil, err
-			}
-
-			blsMsgCids = append(blsMsgCids, c)
-		} else if chain.IsValidSecpkSigType(nv, msg.Signature.Type) {
-			c, err := filec.sm.ChainStore().PutMessage(ctx, msg)
-			if err != nil {
-				return nil, err
-			}
-
-			secpkMsgCids = append(secpkMsgCids, c)
-			secpkMessages = append(secpkMessages, msg)
-
-		} else {
-			return nil, xerrors.Errorf("unknown sig type: %d", msg.Signature.Type)
-		}
-	}
-
-	store := filec.sm.ChainStore().ActorStore(ctx)
-	blsmsgroot, err := consensus.ToMessagesArray(store, blsMsgCids)
+	next, blsMessages, secpkMessages, err := consensus.CreateBlockHeader(ctx, filec.sm, pts, bt)
 	if err != nil {
-		return nil, xerrors.Errorf("building bls amt: %w", err)
-	}
-	secpkmsgroot, err := consensus.ToMessagesArray(store, secpkMsgCids)
-	if err != nil {
-		return nil, xerrors.Errorf("building secpk amt: %w", err)
+		return nil, xerrors.Errorf("failed to process messages from block template: %w", err)
 	}

-	mmcid, err := store.Put(store.Context(), &types.MsgMeta{
-		BlsMessages:   blsmsgroot,
-		SecpkMessages: secpkmsgroot,
-	})
-	if err != nil {
-		return nil, err
-	}
-	next.Messages = mmcid
-
-	aggSig, err := consensus.AggregateSignatures(blsSigs)
-	if err != nil {
-		return nil, err
-	}
-
-	next.BLSAggregate = aggSig
-	pweight, err := filec.sm.ChainStore().Weight(ctx, pts)
-	if err != nil {
-		return nil, err
-	}
-	next.ParentWeight = pweight
-
-	baseFee, err := filec.sm.ChainStore().ComputeBaseFee(ctx, pts)
-	if err != nil {
-		return nil, xerrors.Errorf("computing base fee: %w", err)
-	}
-	next.ParentBaseFee = baseFee
-
-	nosigbytes, err := next.SigningBytes()
-	if err != nil {
-		return nil, xerrors.Errorf("failed to get signing bytes for block: %w", err)
-	}
-
-	sig, err := w.WalletSign(ctx, worker, nosigbytes, api.MsgMeta{
-		Type: api.MTBlock,
-	})
-	if err != nil {
+	if err := signBlock(ctx, w, worker, next); err != nil {
 		return nil, xerrors.Errorf("failed to sign new block: %w", err)
 	}

-	next.BlockSig = sig
-
 	fullBlock := &types.FullBlock{
 		Header:        next,
 		BlsMessages:   blsMessages,
@@ -517,12 +517,11 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *stmgr.StateManager, _ st
 			MessageReceipt: *stmgr.MakeFakeRct(),
 			ActorErr:       nil,
 			ExecutionTrace: types.ExecutionTrace{
-				Msg:        fakeMsg,
-				MsgRct:     stmgr.MakeFakeRct(),
-				Error:      "",
-				Duration:   0,
-				GasCharges: nil,
-				Subcalls:   subcalls,
+				Msg: types.MessageTrace{
+					To:   fakeMsg.To,
+					From: fakeMsg.From,
+				},
+				Subcalls: subcalls,
 			},
 			Duration: 0,
 			GasCosts: nil,
@@ -695,12 +694,11 @@ func splitGenesisMultisig0(ctx context.Context, em stmgr.ExecMonitor, addr addre
 			MessageReceipt: *stmgr.MakeFakeRct(),
 			ActorErr:       nil,
 			ExecutionTrace: types.ExecutionTrace{
-				Msg:        fakeMsg,
-				MsgRct:     stmgr.MakeFakeRct(),
-				Error:      "",
-				Duration:   0,
-				GasCharges: nil,
-				Subcalls:   subcalls,
+				Msg: types.MessageTrace{
+					From: fakeMsg.From,
+					To:   fakeMsg.To,
+				},
+				Subcalls: subcalls,
 			},
 			Duration: 0,
 			GasCosts: nil,
@@ -4,17 +4,99 @@ import (
 	"context"

 	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"go.opencensus.io/stats"

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

 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
+	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/metrics"
 )

 type Consensus interface {
+	// ValidateBlockHeader is called by peers when they receive a new block through the network.
+	//
+	// This is a fast sanity-check validation performed by the PubSub protocol before delivering
+	// it to the syncer. It checks that the block has the right format and it performs
+	// other consensus-specific light verifications like ensuring that the block is signed by
+	// a valid miner, or that it includes all the data required for a full verification.
+	ValidateBlockHeader(ctx context.Context, b *types.BlockHeader) (rejectReason string, err error)
+
+	// ValidateBlock is called by the syncer to determine if to accept a block or not.
+	//
+	// It performs all the checks needed by the syncer to accept
+	// the block (signature verifications, VRF checks, message validity, etc.)
 	ValidateBlock(ctx context.Context, b *types.FullBlock) (err error)
-	ValidateBlockPubsub(ctx context.Context, self bool, msg *pubsub.Message) (pubsub.ValidationResult, string)
+
+	// IsEpochBeyondCurrMax is used to configure the fork rules for longest-chain
+	// consensus protocols.
 	IsEpochBeyondCurrMax(epoch abi.ChainEpoch) bool

+	// CreateBlock implements all the logic required to propose and assemble a new Filecoin block.
+	//
+	// This function encapsulate all the consensus-specific actions to propose a new block
+	// such as the ordering of transactions, the inclusion of consensus proofs, the signature
+	// of the block, etc.
 	CreateBlock(ctx context.Context, w api.Wallet, bt *api.BlockTemplate) (*types.FullBlock, error)
 }
+
+// RewardFunc parametrizes the logic for rewards when a message is executed.
+//
+// Each consensus implementation can set their own reward function.
+type RewardFunc func(ctx context.Context, vmi vm.Interface, em stmgr.ExecMonitor,
+	epoch abi.ChainEpoch, ts *types.TipSet, params *reward.AwardBlockRewardParams) error
+
+// ValidateBlockPubsub implements the common checks performed by all consensus implementations
+// when a block is received through the pubsub channel.
+func ValidateBlockPubsub(ctx context.Context, cns Consensus, self bool, msg *pubsub.Message) (pubsub.ValidationResult, string) {
+	if self {
+		return validateLocalBlock(ctx, msg)
+	}
+
+	// track validation time
+	begin := build.Clock.Now()
+	defer func() {
+		log.Debugf("block validation time: %s", build.Clock.Since(begin))
+	}()
+
+	stats.Record(ctx, metrics.BlockReceived.M(1))
+
+	recordFailureFlagPeer := func(what string) {
+		// bv.Validate will flag the peer in that case
+		panic(what)
+	}
+
+	blk, what, err := decodeAndCheckBlock(msg)
+	if err != nil {
+		log.Error("got invalid block over pubsub: ", err)
+		recordFailureFlagPeer(what)
+		return pubsub.ValidationReject, what
+	}
+
+	// validate the block meta: the Message CID in the header must match the included messages
+	err = validateMsgMeta(ctx, blk)
+	if err != nil {
+		log.Warnf("error validating message metadata: %s", err)
+		recordFailureFlagPeer("invalid_block_meta")
+		return pubsub.ValidationReject, "invalid_block_meta"
+	}
+
+	reject, err := cns.ValidateBlockHeader(ctx, blk.Header)
+	if err != nil {
+		if reject == "" {
+			log.Warn("ignoring block msg: ", err)
+			return pubsub.ValidationIgnore, reject
+		}
+		recordFailureFlagPeer(reject)
+		return pubsub.ValidationReject, reject
+	}
+
+	// all good, accept the block
+	msg.ValidatorData = blk
+	stats.Record(ctx, metrics.BlockValidationSuccess.M(1))
+	return pubsub.ValidationAccept, ""
+}
@@ -1,4 +1,4 @@
-package chain
+package consensus

 import (
 	"golang.org/x/xerrors"
@@ -4,7 +4,7 @@ import (
 	"context"
 	"sync"

-	lru "github.com/hashicorp/golang-lru"
+	lru "github.com/hashicorp/golang-lru/v2"
 	"github.com/ipfs/go-cid"

 	"github.com/filecoin-project/lotus/api"
@@ -14,14 +14,14 @@ type messageCache struct {
 	api EventAPI

 	blockMsgLk    sync.Mutex
-	blockMsgCache *lru.ARCCache
+	blockMsgCache *lru.ARCCache[cid.Cid, *api.BlockMessages]
 }

-func newMessageCache(api EventAPI) *messageCache {
-	blsMsgCache, _ := lru.NewARC(500)
+func newMessageCache(a EventAPI) *messageCache {
+	blsMsgCache, _ := lru.NewARC[cid.Cid, *api.BlockMessages](500)

 	return &messageCache{
-		api:           api,
+		api:           a,
 		blockMsgCache: blsMsgCache,
 	}
 }
@@ -30,14 +30,14 @@ func (c *messageCache) ChainGetBlockMessages(ctx context.Context, blkCid cid.Cid
 	c.blockMsgLk.Lock()
 	defer c.blockMsgLk.Unlock()

-	msgsI, ok := c.blockMsgCache.Get(blkCid)
+	msgs, ok := c.blockMsgCache.Get(blkCid)
 	var err error
 	if !ok {
-		msgsI, err = c.api.ChainGetBlockMessages(ctx, blkCid)
+		msgs, err = c.api.ChainGetBlockMessages(ctx, blkCid)
 		if err != nil {
 			return nil, err
 		}
-		c.blockMsgCache.Add(blkCid, msgsI)
+		c.blockMsgCache.Add(blkCid, msgs)
 	}
-	return msgsI.(*api.BlockMessages), nil
+	return msgs, nil
 }
@@ -5,7 +5,7 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"io/ioutil"
+	"os"
 	"sync/atomic"
 	"time"

@@ -31,8 +31,10 @@ import (
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/beacon"
+	"github.com/filecoin-project/lotus/chain/consensus"
 	"github.com/filecoin-project/lotus/chain/consensus/filcns"
 	genesis2 "github.com/filecoin-project/lotus/chain/gen/genesis"
+	"github.com/filecoin-project/lotus/chain/index"
 	"github.com/filecoin-project/lotus/chain/rand"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
@@ -166,7 +168,7 @@ func NewGeneratorWithSectorsAndUpgradeSchedule(numSectors int, us stmgr.UpgradeS

 	maddr1 := genesis2.MinerAddress(0)

-	m1temp, err := ioutil.TempDir("", "preseal")
+	m1temp, err := os.MkdirTemp("", "preseal")
 	if err != nil {
 		return nil, err
 	}
@@ -178,7 +180,7 @@ func NewGeneratorWithSectorsAndUpgradeSchedule(numSectors int, us stmgr.UpgradeS

 	maddr2 := genesis2.MinerAddress(1)

-	m2temp, err := ioutil.TempDir("", "preseal")
+	m2temp, err := os.MkdirTemp("", "preseal")
 	if err != nil {
 		return nil, err
 	}
@@ -255,7 +257,7 @@ func NewGeneratorWithSectorsAndUpgradeSchedule(numSectors int, us stmgr.UpgradeS
 	//return nil, xerrors.Errorf("creating drand beacon: %w", err)
 	//}

-	sm, err := stmgr.NewStateManager(cs, filcns.NewTipSetExecutor(), sys, us, beac)
+	sm, err := stmgr.NewStateManager(cs, consensus.NewTipSetExecutor(filcns.RewardFunc), sys, us, beac, ds, index.DummyMsgIndex)
 	if err != nil {
 		return nil, xerrors.Errorf("initing stmgr: %w", err)
 	}
@@ -38,7 +38,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/system"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/verifreg"
-	"github.com/filecoin-project/lotus/chain/consensus/filcns"
+	"github.com/filecoin-project/lotus/chain/consensus"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -486,7 +486,7 @@ func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, sys vm.Sysca
 		Epoch:          0,
 		Rand:           &fakeRand{},
 		Bstore:         cs.StateBlockstore(),
-		Actors:         filcns.NewActorRegistry(),
+		Actors:         consensus.NewActorRegistry(),
 		Syscalls:       mkFakedSigSyscalls(sys),
 		CircSupplyCalc: csc,
 		NetworkVersion: nv,
@@ -40,7 +40,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
-	"github.com/filecoin-project/lotus/chain/consensus/filcns"
+	"github.com/filecoin-project/lotus/chain/consensus"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -94,7 +94,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sys vm.Syscal
 			Epoch:          0,
 			Rand:           &fakeRand{},
 			Bstore:         cs.StateBlockstore(),
-			Actors:         filcns.NewActorRegistry(),
+			Actors:         consensus.NewActorRegistry(),
 			Syscalls:       mkFakedSigSyscalls(sys),
 			CircSupplyCalc: csc,
 			NetworkVersion: nv,
@@ -0,0 +1,66 @@
+package index
+
+import (
+	"context"
+	"errors"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+var ErrNotFound = errors.New("message not found")
+var ErrClosed = errors.New("index closed")
+
+// MsgInfo is the Message metadata the index tracks.
+type MsgInfo struct {
+	// the message this record refers to
+	Message cid.Cid
+	// the tipset where this message was included
+	TipSet cid.Cid
+	// the epoch where this message was included
+	Epoch abi.ChainEpoch
+}
+
+// MsgIndex is the interface to the message index
+type MsgIndex interface {
+	// GetMsgInfo looks up the message in index and retrieves its metadata and execution
+	// tipset cid.
+	// The lookup is done using the onchain message Cid; that is the signed message Cid
+	// for SECP messages and unsigned message Cid for BLS messages.
+	GetMsgInfo(ctx context.Context, mCid cid.Cid) (MsgInfo, cid.Cid, error)
+	// Close closes the index
+	Close() error
+}
+
+// TipsetIndex is the interface to the tipset index
+type TipsetIndex interface {
+	// GetTipsetCID returns the tipset cid for the given epoch
+	GetTipsetCID(ctx context.Context, epoch abi.ChainEpoch) (*cid.Cid, error)
+	// Close closes the index
+	Close() error
+}
+
+type dummyMsgIndex struct{}
+
+func (dummyMsgIndex) GetMsgInfo(ctx context.Context, mCid cid.Cid) (MsgInfo, cid.Cid, error) {
+	return MsgInfo{}, cid.Undef, ErrNotFound
+}
+
+func (dummyMsgIndex) Close() error {
+	return nil
+}
+
+var DummyMsgIndex MsgIndex = dummyMsgIndex{}
+
+type dummyTipsetIndex struct{}
+
+func (dummyTipsetIndex) GetTipsetCID(ctx context.Context, epoch abi.ChainEpoch) (*cid.Cid, error) {
+	return nil, ErrNotFound
+}
+
+func (dummyTipsetIndex) Close() error {
+	return nil
+}
+
+var DummyTipsetIndex TipsetIndex = dummyTipsetIndex{}
@@ -0,0 +1,604 @@
+package index
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"io/fs"
+	"os"
+	"path"
+	"sync"
+	"time"
+
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+	_ "github.com/mattn/go-sqlite3"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+var log = logging.Logger("msgindex")
+
+var dbName = "msgindex.db"
+var dbDefs = []string{
+	`CREATE TABLE IF NOT EXISTS messages (
+     cid VARCHAR(80) PRIMARY KEY ON CONFLICT REPLACE,
+     tipset_cid VARCHAR(80) NOT NULL,
+     epoch INTEGER NOT NULL
+   )`,
+	`CREATE INDEX IF NOT EXISTS tipset_cids ON messages (tipset_cid)`,
+	`CREATE INDEX IF NOT EXISTS tipset_epochs ON messages (epoch)`,
+	`CREATE TABLE IF NOT EXISTS _meta (
+    	version UINT64 NOT NULL UNIQUE
+	)`,
+	`INSERT OR IGNORE INTO _meta (version) VALUES (1)`,
+}
+var dbPragmas = []string{}
+
+const (
+	// prepared stmts
+	dbqGetMessageInfo       = "SELECT tipset_cid, epoch FROM messages WHERE cid = ?"
+	dbqInsertMessage        = "INSERT INTO messages VALUES (?, ?, ?)"
+	dbqDeleteTipsetMessages = "DELETE FROM messages WHERE tipset_cid = ?"
+	dbqGetTipsetByEpoch     = "SELECT tipset_cid FROM messages WHERE epoch = ? LIMIT 1"
+	// reconciliation
+	dbqCountMessages         = "SELECT COUNT(*) FROM messages"
+	dbqMinEpoch              = "SELECT MIN(epoch) FROM messages"
+	dbqCountTipsetMessages   = "SELECT COUNT(*) FROM messages WHERE tipset_cid = ?"
+	dbqDeleteMessagesByEpoch = "DELETE FROM messages WHERE epoch >= ?"
+)
+
+// coalescer configuration (TODO: use observer instead)
+// these are exposed to make tests snappy
+var (
+	CoalesceMinDelay      = time.Second
+	CoalesceMaxDelay      = 15 * time.Second
+	CoalesceMergeInterval = time.Second
+)
+
+// chain store interface; we could use store.ChainStore directly,
+// but this simplifies unit testing.
+type ChainStore interface {
+	SubscribeHeadChanges(f store.ReorgNotifee)
+	MessagesForTipset(ctx context.Context, ts *types.TipSet) ([]types.ChainMsg, error)
+	GetHeaviestTipSet() *types.TipSet
+	GetTipSetFromKey(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error)
+}
+
+var _ ChainStore = (*store.ChainStore)(nil)
+
+type msgIndex struct {
+	cs ChainStore
+
+	db               *sql.DB
+	selectMsgStmt    *sql.Stmt
+	selectTipsetStmt *sql.Stmt
+	insertMsgStmt    *sql.Stmt
+	deleteTipSetStmt *sql.Stmt
+
+	sema chan struct{}
+	mx   sync.Mutex
+	pend []headChange
+
+	cancel  func()
+	workers sync.WaitGroup
+	closeLk sync.RWMutex
+	closed  bool
+}
+
+var _ MsgIndex = (*msgIndex)(nil)
+
+type headChange struct {
+	rev []*types.TipSet
+	app []*types.TipSet
+}
+
+func NewMsgIndex(lctx context.Context, basePath string, cs ChainStore) (MsgIndex, error) {
+	var (
+		dbPath string
+		exists bool
+		err    error
+	)
+
+	err = os.MkdirAll(basePath, 0755)
+	if err != nil {
+		return nil, xerrors.Errorf("error creating msgindex base directory: %w", err)
+	}
+
+	dbPath = path.Join(basePath, dbName)
+	_, err = os.Stat(dbPath)
+	switch {
+	case err == nil:
+		exists = true
+
+	case errors.Is(err, fs.ErrNotExist):
+
+	case err != nil:
+		return nil, xerrors.Errorf("error stating msgindex database: %w", err)
+	}
+
+	db, err := sql.Open("sqlite3", dbPath)
+	if err != nil {
+		// TODO [nice to have]: automaticaly 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)
+	}
+
+	if err := prepareDB(db); err != nil {
+		return nil, xerrors.Errorf("error creating msgindex database: %w", err)
+	}
+
+	// TODO we may consider populating the index when first creating the db
+	if exists {
+		if err := reconcileIndex(db, cs); err != nil {
+			return nil, xerrors.Errorf("error reconciling msgindex database: %w", err)
+		}
+	}
+
+	ctx, cancel := context.WithCancel(lctx)
+
+	msgIndex := &msgIndex{
+		db:     db,
+		cs:     cs,
+		sema:   make(chan struct{}, 1),
+		cancel: cancel,
+	}
+
+	err = msgIndex.prepareStatements()
+	if err != nil {
+		if err := db.Close(); err != nil {
+			log.Errorf("error closing msgindex database: %s", err)
+		}
+
+		return nil, xerrors.Errorf("error preparing msgindex database statements: %w", err)
+	}
+
+	rnf := store.WrapHeadChangeCoalescer(
+		msgIndex.onHeadChange,
+		CoalesceMinDelay,
+		CoalesceMaxDelay,
+		CoalesceMergeInterval,
+	)
+	cs.SubscribeHeadChanges(rnf)
+
+	msgIndex.workers.Add(1)
+	go msgIndex.background(ctx)
+
+	return msgIndex, nil
+}
+
+func PopulateAfterSnapshot(lctx context.Context, basePath string, cs ChainStore) error {
+	err := os.MkdirAll(basePath, 0755)
+	if err != nil {
+		return xerrors.Errorf("error creating msgindex base directory: %w", err)
+	}
+
+	dbPath := path.Join(basePath, dbName)
+
+	// if a database already exists, we try to delete it and create a new one
+	if _, err := os.Stat(dbPath); err == nil {
+		if err = os.Remove(dbPath); err != nil {
+			return xerrors.Errorf("msgindex already exists at %s and can't be deleted", dbPath)
+		}
+	}
+
+	db, err := sql.Open("sqlite3", dbPath)
+	if err != nil {
+		return xerrors.Errorf("error opening msgindex database: %w", err)
+	}
+	defer func() {
+		if err := db.Close(); err != nil {
+			log.Errorf("error closing msgindex database: %s", err)
+		}
+	}()
+
+	if err := prepareDB(db); err != nil {
+		return xerrors.Errorf("error creating msgindex database: %w", err)
+	}
+
+	tx, err := db.Begin()
+	if err != nil {
+		return xerrors.Errorf("error when starting transaction: %w", err)
+	}
+
+	rollback := func() {
+		if err := tx.Rollback(); err != nil {
+			log.Errorf("error in rollback: %s", err)
+		}
+	}
+
+	insertStmt, err := tx.Prepare(dbqInsertMessage)
+	if err != nil {
+		rollback()
+		return xerrors.Errorf("error preparing insertStmt: %w", err)
+	}
+
+	curTs := cs.GetHeaviestTipSet()
+	startHeight := curTs.Height()
+	for curTs != nil {
+		tscid, err := curTs.Key().Cid()
+		if err != nil {
+			rollback()
+			return xerrors.Errorf("error computing tipset cid: %w", err)
+		}
+
+		tskey := tscid.String()
+		epoch := int64(curTs.Height())
+
+		msgs, err := cs.MessagesForTipset(lctx, curTs)
+		if err != nil {
+			log.Infof("stopping import after %d tipsets", startHeight-curTs.Height())
+			break
+		}
+
+		for _, msg := range msgs {
+			key := msg.Cid().String()
+			if _, err := insertStmt.Exec(key, tskey, epoch); err != nil {
+				rollback()
+				return xerrors.Errorf("error inserting message: %w", err)
+			}
+		}
+
+		curTs, err = cs.GetTipSetFromKey(lctx, curTs.Parents())
+		if err != nil {
+			rollback()
+			return xerrors.Errorf("error walking chain: %w", err)
+		}
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return xerrors.Errorf("error committing transaction: %w", err)
+	}
+
+	return nil
+}
+
+// init utilities
+func prepareDB(db *sql.DB) error {
+	for _, stmt := range dbDefs {
+		if _, err := db.Exec(stmt); err != nil {
+			return xerrors.Errorf("error executing sql statement '%s': %w", stmt, err)
+		}
+	}
+
+	for _, stmt := range dbPragmas {
+		if _, err := db.Exec(stmt); err != nil {
+			return xerrors.Errorf("error executing sql statement '%s': %w", stmt, err)
+		}
+	}
+
+	return nil
+}
+
+func reconcileIndex(db *sql.DB, cs ChainStore) error {
+	// Invariant: after reconciliation, every tipset in the index is in the current chain; ie either
+	//  the chain head or reachable by walking the chain.
+	// Algorithm:
+	//  1. Count messages in index; if none, trivially reconciled.
+	//     TODO we may consider populating the index in that case
+	//  2. Find the minimum tipset in the index; this will mark the end of the reconciliation walk
+	//  3. Walk from current tipset until we find a tipset in the index.
+	//  4. Delete (revert!) all tipsets above the found tipset.
+	//  5. If the walk ends in the boundary epoch, then delete everything.
+	//
+
+	row := db.QueryRow(dbqCountMessages)
+
+	var result int64
+	if err := row.Scan(&result); err != nil {
+		return xerrors.Errorf("error counting messages: %w", err)
+	}
+
+	if result == 0 {
+		return nil
+	}
+
+	row = db.QueryRow(dbqMinEpoch)
+	if err := row.Scan(&result); err != nil {
+		return xerrors.Errorf("error finding boundary epoch: %w", err)
+	}
+
+	boundaryEpoch := abi.ChainEpoch(result)
+
+	countMsgsStmt, err := db.Prepare(dbqCountTipsetMessages)
+	if err != nil {
+		return xerrors.Errorf("error preparing statement: %w", err)
+	}
+
+	curTs := cs.GetHeaviestTipSet()
+	for curTs != nil && curTs.Height() >= boundaryEpoch {
+		tsCid, err := curTs.Key().Cid()
+		if err != nil {
+			return xerrors.Errorf("error computing tipset cid: %w", err)
+		}
+
+		key := tsCid.String()
+		row = countMsgsStmt.QueryRow(key)
+		if err := row.Scan(&result); err != nil {
+			return xerrors.Errorf("error counting messages: %w", err)
+		}
+
+		if result > 0 {
+			// found it!
+			boundaryEpoch = curTs.Height() + 1
+			break
+		}
+
+		// walk up
+		parents := curTs.Parents()
+		curTs, err = cs.GetTipSetFromKey(context.TODO(), parents)
+		if err != nil {
+			return xerrors.Errorf("error walking chain: %w", err)
+		}
+	}
+
+	// delete everything above the minEpoch
+	if _, err = db.Exec(dbqDeleteMessagesByEpoch, int64(boundaryEpoch)); err != nil {
+		return xerrors.Errorf("error deleting stale reorged out message: %w", err)
+	}
+
+	return nil
+}
+
+func (x *msgIndex) prepareStatements() error {
+	stmt, err := x.db.Prepare(dbqGetMessageInfo)
+	if err != nil {
+		return xerrors.Errorf("prepare selectMsgStmt: %w", err)
+	}
+	x.selectMsgStmt = stmt
+
+	stmt, err = x.db.Prepare(dbqGetTipsetByEpoch)
+	if err != nil {
+		return xerrors.Errorf("prepare selectTipsetStmt: %w", err)
+	}
+	x.selectTipsetStmt = stmt
+
+	stmt, err = x.db.Prepare(dbqInsertMessage)
+	if err != nil {
+		return xerrors.Errorf("prepare insertMsgStmt: %w", err)
+	}
+	x.insertMsgStmt = stmt
+
+	stmt, err = x.db.Prepare(dbqDeleteTipsetMessages)
+	if err != nil {
+		return xerrors.Errorf("prepare deleteTipSetStmt: %w", err)
+	}
+	x.deleteTipSetStmt = stmt
+
+	return nil
+}
+
+// head change notifee
+func (x *msgIndex) onHeadChange(rev, app []*types.TipSet) error {
+	x.closeLk.RLock()
+	defer x.closeLk.RUnlock()
+
+	if x.closed {
+		return nil
+	}
+
+	// do it in the background to avoid blocking head change processing
+	x.mx.Lock()
+	x.pend = append(x.pend, headChange{rev: rev, app: app})
+	pendLen := len(x.pend)
+	x.mx.Unlock()
+
+	// complain loudly if this is building backlog
+	if pendLen > 10 {
+		log.Warnf("message index head change processing is building backlog: %d pending head changes", pendLen)
+	}
+
+	select {
+	case x.sema <- struct{}{}:
+	default:
+	}
+
+	return nil
+}
+
+func (x *msgIndex) background(ctx context.Context) {
+	defer x.workers.Done()
+
+	for {
+		select {
+		case <-x.sema:
+			err := x.processHeadChanges(ctx)
+			if err != nil {
+				// we can't rely on an inconsistent index, so shut it down.
+				log.Errorf("error processing head change notifications: %s; shutting down message index", err)
+				if err2 := x.Close(); err2 != nil {
+					log.Errorf("error shutting down index: %s", err2)
+				}
+			}
+
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+func (x *msgIndex) processHeadChanges(ctx context.Context) error {
+	x.mx.Lock()
+	pend := x.pend
+	x.pend = nil
+	x.mx.Unlock()
+
+	tx, err := x.db.Begin()
+	if err != nil {
+		return xerrors.Errorf("error creating transaction: %w", err)
+	}
+
+	for _, hc := range pend {
+		for _, ts := range hc.rev {
+			if err := x.doRevert(ctx, tx, ts); err != nil {
+				if err2 := tx.Rollback(); err2 != nil {
+					log.Errorf("error rolling back transaction: %s", err2)
+				}
+				return xerrors.Errorf("error reverting %s: %w", ts, err)
+			}
+		}
+
+		for _, ts := range hc.app {
+			if err := x.doApply(ctx, tx, ts); err != nil {
+				if err2 := tx.Rollback(); err2 != nil {
+					log.Errorf("error rolling back transaction: %s", err2)
+				}
+				return xerrors.Errorf("error applying %s: %w", ts, err)
+			}
+		}
+	}
+
+	return tx.Commit()
+}
+
+func (x *msgIndex) doRevert(ctx context.Context, tx *sql.Tx, ts *types.TipSet) error {
+	tskey, err := ts.Key().Cid()
+	if err != nil {
+		return xerrors.Errorf("error computing tipset cid: %w", err)
+	}
+
+	key := tskey.String()
+	_, err = tx.Stmt(x.deleteTipSetStmt).Exec(key)
+	return err
+}
+
+func (x *msgIndex) doApply(ctx context.Context, tx *sql.Tx, ts *types.TipSet) error {
+	tscid, err := ts.Key().Cid()
+	if err != nil {
+		return xerrors.Errorf("error computing tipset cid: %w", err)
+	}
+
+	tskey := tscid.String()
+	epoch := int64(ts.Height())
+
+	msgs, err := x.cs.MessagesForTipset(ctx, ts)
+	if err != nil {
+		return xerrors.Errorf("error retrieving messages for tipset %s: %w", ts, err)
+	}
+
+	insertStmt := tx.Stmt(x.insertMsgStmt)
+	for _, msg := range msgs {
+		key := msg.Cid().String()
+		if _, err := insertStmt.Exec(key, tskey, epoch); err != nil {
+			return xerrors.Errorf("error inserting message: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// interface
+func (x *msgIndex) GetMsgInfo(ctx context.Context, mCid cid.Cid) (MsgInfo, cid.Cid, error) {
+	x.closeLk.RLock()
+	defer x.closeLk.RUnlock()
+
+	if x.closed {
+		return MsgInfo{}, cid.Undef, ErrClosed
+	}
+
+	// fetch message from index (if it exists)
+	//
+	var tipset string
+	var epoch int64
+	err := x.selectMsgStmt.QueryRow(mCid.String()).Scan(&tipset, &epoch)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			// mCid not in index, its fine
+			return MsgInfo{}, cid.Undef, ErrNotFound
+		}
+
+		return MsgInfo{}, cid.Undef, xerrors.Errorf("error querying msgindex database: %w", err)
+	}
+	tsCid, err := cid.Decode(tipset)
+	if err != nil {
+		return MsgInfo{}, cid.Undef, xerrors.Errorf("error decoding tipset cid: %w", err)
+	}
+
+	msgInfo := MsgInfo{
+		Message: mCid,
+		TipSet:  tsCid,
+		Epoch:   abi.ChainEpoch(epoch),
+	}
+
+	// fetch execution tipset of message (if it exists)
+	//
+	var xTipset string
+	err = x.selectTipsetStmt.QueryRow(epoch + 1).Scan(&xTipset)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			// execution tipset not in index, its fine
+			return msgInfo, cid.Undef, nil
+		}
+
+		return MsgInfo{}, cid.Undef, xerrors.Errorf("error querying for execution tipset: %w", err)
+	}
+	xtsCid, err := cid.Decode(xTipset)
+	if err != nil {
+		return MsgInfo{}, cid.Undef, xerrors.Errorf("error decoding execution tipset cid: %w", err)
+	}
+
+	return msgInfo, xtsCid, nil
+}
+
+func (x *msgIndex) GetTipsetCID(ctx context.Context, epoch abi.ChainEpoch) (*cid.Cid, error) {
+	x.closeLk.RLock()
+	defer x.closeLk.RUnlock()
+
+	if x.closed {
+		return nil, ErrClosed
+	}
+
+	var tipset string
+
+	row := x.selectTipsetStmt.QueryRow(epoch)
+	err := row.Scan(&tipset)
+	switch {
+	case err == sql.ErrNoRows:
+		return nil, ErrNotFound
+
+	case err != nil:
+		return nil, xerrors.Errorf("error querying msgindex database: %w", err)
+	}
+
+	tipsetCid, err := cid.Decode(tipset)
+	if err != nil {
+		return nil, xerrors.Errorf("error decoding tipset cid: %w", err)
+	}
+	return &tipsetCid, nil
+}
+
+func (x *msgIndex) Close() error {
+	x.closeLk.Lock()
+	defer x.closeLk.Unlock()
+
+	if x.closed {
+		return nil
+	}
+
+	x.closed = true
+
+	x.cancel()
+	x.workers.Wait()
+
+	return x.db.Close()
+}
+
+// informal apis for itests; not exposed in the main interface
+func (x *msgIndex) CountMessages() (int64, error) {
+	x.closeLk.RLock()
+	defer x.closeLk.RUnlock()
+
+	if x.closed {
+		return 0, ErrClosed
+	}
+
+	var result int64
+	row := x.db.QueryRow(dbqCountMessages)
+	err := row.Scan(&result)
+	return result, err
+}
@@ -0,0 +1,298 @@
+package index
+
+import (
+	"context"
+	"errors"
+	"math/rand"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-libipfs/blocks"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-address"
+
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/types/mock"
+)
+
+func TestBasicMsgIndex(t *testing.T) {
+	// the most basic of tests:
+	// 1. Create an index with mock chain store
+	// 2. Advance the chain for a few tipsets
+	// 3. Verify that the index contains all messages with the correct tipset/epoch
+	cs := newMockChainStore()
+	cs.genesis()
+
+	tmp := t.TempDir()
+	t.Cleanup(func() { _ = os.RemoveAll(tmp) })
+
+	msgIndex, err := NewMsgIndex(context.Background(), tmp, cs)
+	require.NoError(t, err)
+
+	defer msgIndex.Close() //nolint
+
+	for i := 0; i < 10; i++ {
+		t.Logf("advance to epoch %d", i+1)
+		err := cs.advance()
+		require.NoError(t, err)
+		// wait for the coalescer to notify
+		time.Sleep(CoalesceMinDelay + 10*time.Millisecond)
+	}
+
+	t.Log("verifying index")
+	verifyIndex(t, cs, msgIndex)
+}
+
+func TestReorgMsgIndex(t *testing.T) {
+	// slightly more nuanced test that includes reorgs
+	// 1. Create an index with mock chain store
+	// 2. Advance/Reorg the chain for a few tipsets
+	// 3. Verify that the index contains all messages with the correct tipst/epoch
+	cs := newMockChainStore()
+	cs.genesis()
+
+	tmp := t.TempDir()
+	t.Cleanup(func() { _ = os.RemoveAll(tmp) })
+
+	msgIndex, err := NewMsgIndex(context.Background(), tmp, cs)
+	require.NoError(t, err)
+
+	defer msgIndex.Close() //nolint
+
+	for i := 0; i < 10; i++ {
+		t.Logf("advance to epoch %d", i+1)
+		err := cs.advance()
+		require.NoError(t, err)
+		// wait for the coalescer to notify
+		time.Sleep(CoalesceMinDelay + 10*time.Millisecond)
+	}
+
+	// a simple reorg
+	t.Log("doing reorg")
+	reorgme := cs.curTs
+	reorgmeParent, err := cs.GetTipSetFromKey(context.Background(), reorgme.Parents())
+	require.NoError(t, err)
+	cs.setHead(reorgmeParent)
+	reorgmeChild := cs.makeBlk()
+	err = cs.reorg([]*types.TipSet{reorgme}, []*types.TipSet{reorgmeChild})
+	require.NoError(t, err)
+	time.Sleep(CoalesceMinDelay + 10*time.Millisecond)
+
+	t.Log("verifying index")
+	verifyIndex(t, cs, msgIndex)
+
+	t.Log("verifying that reorged messages are not present")
+	verifyMissing(t, cs, msgIndex, reorgme)
+}
+
+func TestReconcileMsgIndex(t *testing.T) {
+	// test that exercises the reconciliation code paths
+	// 1. Create  and populate a basic msgindex, similar to TestBasicMsgIndex.
+	// 2. Close  it
+	// 3. Reorg the mock chain store
+	// 4. Reopen the index to trigger reconciliation
+	// 5. Enxure that only the stable messages remain.
+	cs := newMockChainStore()
+	cs.genesis()
+
+	tmp := t.TempDir()
+	t.Cleanup(func() { _ = os.RemoveAll(tmp) })
+
+	msgIndex, err := NewMsgIndex(context.Background(), tmp, cs)
+	require.NoError(t, err)
+
+	for i := 0; i < 10; i++ {
+		t.Logf("advance to epoch %d", i+1)
+		err := cs.advance()
+		require.NoError(t, err)
+		// wait for the coalescer to notify
+		time.Sleep(CoalesceMinDelay + 10*time.Millisecond)
+	}
+
+	// Close it and reorg
+	err = msgIndex.Close()
+	require.NoError(t, err)
+	cs.notify = nil
+
+	// a simple reorg
+	t.Log("doing reorg")
+	reorgme := cs.curTs
+	reorgmeParent, err := cs.GetTipSetFromKey(context.Background(), reorgme.Parents())
+	require.NoError(t, err)
+	cs.setHead(reorgmeParent)
+	reorgmeChild := cs.makeBlk()
+	err = cs.reorg([]*types.TipSet{reorgme}, []*types.TipSet{reorgmeChild})
+	require.NoError(t, err)
+
+	// reopen to reconcile
+	msgIndex, err = NewMsgIndex(context.Background(), tmp, cs)
+	require.NoError(t, err)
+
+	defer msgIndex.Close() //nolint
+
+	t.Log("verifying index")
+	// need to step one up because the last tipset is not known by the index
+	cs.setHead(reorgmeParent)
+	verifyIndex(t, cs, msgIndex)
+
+	t.Log("verifying that reorged and unknown messages are not present")
+	verifyMissing(t, cs, msgIndex, reorgme, reorgmeChild)
+}
+
+func verifyIndex(t *testing.T, cs *mockChainStore, msgIndex MsgIndex) {
+	for ts := cs.curTs; ts.Height() > 0; {
+		t.Logf("verify at height %d", ts.Height())
+		blks := ts.Blocks()
+		if len(blks) == 0 {
+			break
+		}
+
+		tsCid, err := ts.Key().Cid()
+		require.NoError(t, err)
+
+		msgs, err := cs.MessagesForTipset(context.Background(), ts)
+		require.NoError(t, err)
+		for _, m := range msgs {
+			minfo, _, err := msgIndex.GetMsgInfo(context.Background(), m.Cid())
+			require.NoError(t, err)
+			require.Equal(t, tsCid, minfo.TipSet)
+			require.Equal(t, ts.Height(), minfo.Epoch)
+		}
+
+		parents := ts.Parents()
+		ts, err = cs.GetTipSetFromKey(context.Background(), parents)
+		require.NoError(t, err)
+	}
+}
+
+func verifyMissing(t *testing.T, cs *mockChainStore, msgIndex MsgIndex, missing ...*types.TipSet) {
+	for _, ts := range missing {
+		msgs, err := cs.MessagesForTipset(context.Background(), ts)
+		require.NoError(t, err)
+		for _, m := range msgs {
+			_, _, err := msgIndex.GetMsgInfo(context.Background(), m.Cid())
+			require.Equal(t, ErrNotFound, err)
+		}
+	}
+}
+
+type mockChainStore struct {
+	notify store.ReorgNotifee
+
+	curTs   *types.TipSet
+	tipsets map[types.TipSetKey]*types.TipSet
+	msgs    map[types.TipSetKey][]types.ChainMsg
+
+	nonce uint64
+}
+
+var _ ChainStore = (*mockChainStore)(nil)
+
+var systemAddr address.Address
+var rng *rand.Rand
+
+func init() {
+	systemAddr, _ = address.NewIDAddress(0)
+	rng = rand.New(rand.NewSource(314159))
+
+	// adjust those to make tests snappy
+	CoalesceMinDelay = 100 * time.Millisecond
+	CoalesceMaxDelay = time.Second
+	CoalesceMergeInterval = 100 * time.Millisecond
+}
+
+func newMockChainStore() *mockChainStore {
+	return &mockChainStore{
+		tipsets: make(map[types.TipSetKey]*types.TipSet),
+		msgs:    make(map[types.TipSetKey][]types.ChainMsg),
+	}
+}
+
+func (cs *mockChainStore) genesis() {
+	genBlock := mock.MkBlock(nil, 0, 0)
+	genTs := mock.TipSet(genBlock)
+	cs.msgs[genTs.Key()] = nil
+	cs.setHead(genTs)
+}
+
+func (cs *mockChainStore) setHead(ts *types.TipSet) {
+	cs.curTs = ts
+	cs.tipsets[ts.Key()] = ts
+}
+
+func (cs *mockChainStore) advance() error {
+	ts := cs.makeBlk()
+	return cs.reorg(nil, []*types.TipSet{ts})
+}
+
+func (cs *mockChainStore) reorg(rev, app []*types.TipSet) error {
+	for _, ts := range rev {
+		parents := ts.Parents()
+		cs.curTs = cs.tipsets[parents]
+	}
+
+	for _, ts := range app {
+		cs.tipsets[ts.Key()] = ts
+		cs.curTs = ts
+	}
+
+	if cs.notify != nil {
+		return cs.notify(rev, app)
+	}
+
+	return nil
+}
+
+func (cs *mockChainStore) makeBlk() *types.TipSet {
+	height := cs.curTs.Height() + 1
+
+	blk := mock.MkBlock(cs.curTs, uint64(height), uint64(height))
+	blk.Messages = cs.makeGarbageCid()
+
+	ts := mock.TipSet(blk)
+	msg1 := cs.makeMsg()
+	msg2 := cs.makeMsg()
+	cs.msgs[ts.Key()] = []types.ChainMsg{msg1, msg2}
+
+	return ts
+}
+
+func (cs *mockChainStore) makeMsg() *types.Message {
+	nonce := cs.nonce
+	cs.nonce++
+	return &types.Message{To: systemAddr, From: systemAddr, Nonce: nonce}
+}
+
+func (cs *mockChainStore) makeGarbageCid() cid.Cid {
+	garbage := blocks.NewBlock([]byte{byte(rng.Intn(256)), byte(rng.Intn(256)), byte(rng.Intn(256))})
+	return garbage.Cid()
+}
+
+func (cs *mockChainStore) SubscribeHeadChanges(f store.ReorgNotifee) {
+	cs.notify = f
+}
+
+func (cs *mockChainStore) MessagesForTipset(ctx context.Context, ts *types.TipSet) ([]types.ChainMsg, error) {
+	msgs, ok := cs.msgs[ts.Key()]
+	if !ok {
+		return nil, errors.New("unknown tipset")
+	}
+
+	return msgs, nil
+}
+
+func (cs *mockChainStore) GetHeaviestTipSet() *types.TipSet {
+	return cs.curTs
+}
+
+func (cs *mockChainStore) GetTipSetFromKey(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error) {
+	ts, ok := cs.tipsets[tsk]
+	if !ok {
+		return nil, errors.New("unknown tipset")
+	}
+	return ts, nil
+}
@@ -32,14 +32,14 @@ func (mp *MessagePool) CheckMessages(ctx context.Context, protos []*api.MessageP
 // CheckPendingMessages performs a set of logical sets for all messages pending from a given actor
 func (mp *MessagePool) CheckPendingMessages(ctx context.Context, from address.Address) ([][]api.MessageCheckStatus, error) {
 	var msgs []*types.Message
-	mp.lk.Lock()
+	mp.lk.RLock()
 	mset, ok := mp.pending[from]
 	if ok {
 		for _, sm := range mset.msgs {
 			msgs = append(msgs, &sm.Message)
 		}
 	}
-	mp.lk.Unlock()
+	mp.lk.RUnlock()

 	if len(msgs) == 0 {
 		return nil, nil
@@ -58,7 +58,7 @@ func (mp *MessagePool) CheckReplaceMessages(ctx context.Context, replace []*type
 	msgMap := make(map[address.Address]map[uint64]*types.Message)
 	count := 0

-	mp.lk.Lock()
+	mp.lk.RLock()
 	for _, m := range replace {
 		mmap, ok := msgMap[m.From]
 		if !ok {
@@ -76,7 +76,7 @@ func (mp *MessagePool) CheckReplaceMessages(ctx context.Context, replace []*type
 		}
 		mmap[m.Nonce] = m
 	}
-	mp.lk.Unlock()
+	mp.lk.RUnlock()

 	msgs := make([]*types.Message, 0, count)
 	start := 0
@@ -103,9 +103,9 @@ func (mp *MessagePool) checkMessages(ctx context.Context, msgs []*types.Message,
 	if mp.api.IsLite() {
 		return nil, nil
 	}
-	mp.curTsLk.Lock()
+	mp.curTsLk.RLock()
 	curTs := mp.curTs
-	mp.curTsLk.Unlock()
+	mp.curTsLk.RUnlock()

 	epoch := curTs.Height() + 1

@@ -143,7 +143,7 @@ func (mp *MessagePool) checkMessages(ctx context.Context, msgs []*types.Message,

 		st, ok := state[m.From]
 		if !ok {
-			mp.lk.Lock()
+			mp.lk.RLock()
 			mset, ok := mp.pending[m.From]
 			if ok && !interned {
 				st = &actorState{nextNonce: mset.nextNonce, requiredFunds: mset.requiredFunds}
@@ -151,14 +151,14 @@ func (mp *MessagePool) checkMessages(ctx context.Context, msgs []*types.Message,
 					st.requiredFunds = new(stdbig.Int).Add(st.requiredFunds, m.Message.Value.Int)
 				}
 				state[m.From] = st
-				mp.lk.Unlock()
+				mp.lk.RUnlock()

 				check.OK = true
 				check.Hint = map[string]interface{}{
 					"nonce": st.nextNonce,
 				}
 			} else {
-				mp.lk.Unlock()
+				mp.lk.RUnlock()

 				stateNonce, err := mp.getStateNonce(ctx, m.From, curTs)
 				if err != nil {
@@ -12,7 +12,7 @@ import (
 	"time"

 	"github.com/hashicorp/go-multierror"
-	lru "github.com/hashicorp/golang-lru"
+	lru "github.com/hashicorp/golang-lru/v2"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/namespace"
@@ -33,8 +33,7 @@ import (

 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain"
-	"github.com/filecoin-project/lotus/chain/consensus/filcns"
+	"github.com/filecoin-project/lotus/chain/consensus"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -119,7 +118,7 @@ func init() {
 }

 type MessagePool struct {
-	lk sync.Mutex
+	lk sync.RWMutex

 	ds dtypes.MetadataDS

@@ -138,9 +137,9 @@ type MessagePool struct {
 	// do NOT access this map directly, use getPendingMset, setPendingMset, deletePendingMset, forEachPending, and clearPending respectively
 	pending map[address.Address]*msgSet

-	keyCache map[address.Address]address.Address
+	keyCache *lru.Cache[address.Address, address.Address]

-	curTsLk sync.Mutex // DO NOT LOCK INSIDE lk
+	curTsLk sync.RWMutex // DO NOT LOCK INSIDE lk
 	curTs   *types.TipSet

 	cfgLk sync.RWMutex
@@ -160,7 +159,7 @@ type MessagePool struct {
 	// pruneCooldown is a channel used to allow a cooldown time between prunes
 	pruneCooldown chan struct{}

-	blsSigCache *lru.TwoQueueCache
+	blsSigCache *lru.TwoQueueCache[cid.Cid, crypto.Signature]

 	changes *lps.PubSub

@@ -168,9 +167,9 @@ type MessagePool struct {

 	netName dtypes.NetworkName

-	sigValCache *lru.TwoQueueCache
+	sigValCache *lru.TwoQueueCache[string, struct{}]

-	nonceCache *lru.Cache
+	nonceCache *lru.Cache[nonceCacheKey, uint64]

 	evtTypes [3]journal.EventType
 	journal  journal.Journal
@@ -370,9 +369,10 @@ func (ms *msgSet) toSlice() []*types.SignedMessage {
 }

 func New(ctx context.Context, api Provider, ds dtypes.MetadataDS, us stmgr.UpgradeSchedule, netName dtypes.NetworkName, j journal.Journal) (*MessagePool, error) {
-	cache, _ := lru.New2Q(build.BlsSignatureCacheSize)
-	verifcache, _ := lru.New2Q(build.VerifSigCacheSize)
-	noncecache, _ := lru.New(256)
+	cache, _ := lru.New2Q[cid.Cid, crypto.Signature](build.BlsSignatureCacheSize)
+	verifcache, _ := lru.New2Q[string, struct{}](build.VerifSigCacheSize)
+	noncecache, _ := lru.New[nonceCacheKey, uint64](256)
+	keycache, _ := lru.New[address.Address, address.Address](1_000_000)

 	cfg, err := loadConfig(ctx, ds)
 	if err != nil {
@@ -391,7 +391,7 @@ func New(ctx context.Context, api Provider, ds dtypes.MetadataDS, us stmgr.Upgra
 		repubTrigger:   make(chan struct{}, 1),
 		localAddrs:     make(map[address.Address]struct{}),
 		pending:        make(map[address.Address]*msgSet),
-		keyCache:       make(map[address.Address]address.Address),
+		keyCache:       keycache,
 		minGasPrice:    types.NewInt(0),
 		getNtwkVersion: us.GetNtwkVersion,
 		pruneTrigger:   make(chan struct{}, 1),
@@ -475,8 +475,8 @@ func (mp *MessagePool) TryForEachPendingMessage(f func(cid.Cid) error) error {

 func (mp *MessagePool) resolveToKey(ctx context.Context, addr address.Address) (address.Address, error) {
 	// check the cache
-	a, f := mp.keyCache[addr]
-	if f {
+	a, ok := mp.keyCache.Get(addr)
+	if ok {
 		return a, nil
 	}

@@ -487,8 +487,8 @@ func (mp *MessagePool) resolveToKey(ctx context.Context, addr address.Address) (
 	}

 	// place both entries in the cache (may both be key addresses, which is fine)
-	mp.keyCache[addr] = ka
-	mp.keyCache[ka] = ka
+	mp.keyCache.Add(addr, ka)
+	mp.keyCache.Add(ka, ka)

 	return ka, nil
 }
@@ -764,7 +764,28 @@ func (mp *MessagePool) Add(ctx context.Context, m *types.SignedMessage) error {
 		<-mp.addSema
 	}()

+	mp.curTsLk.RLock()
+	tmpCurTs := mp.curTs
+	mp.curTsLk.RUnlock()
+
+	//ensures computations are cached without holding lock
+	_, _ = mp.api.GetActorAfter(m.Message.From, tmpCurTs)
+	_, _ = mp.getStateNonce(ctx, m.Message.From, tmpCurTs)
+
 	mp.curTsLk.Lock()
+	if tmpCurTs == mp.curTs {
+		//with the lock enabled, mp.curTs is the same Ts as we just had, so we know that our computations are cached
+	} else {
+		//curTs has been updated so we want to cache the new one:
+		tmpCurTs = mp.curTs
+		//we want to release the lock, cache the computations then grab it again
+		mp.curTsLk.Unlock()
+		_, _ = mp.api.GetActorAfter(m.Message.From, tmpCurTs)
+		_, _ = mp.getStateNonce(ctx, m.Message.From, tmpCurTs)
+		mp.curTsLk.Lock()
+		//now that we have the lock, we continue, we could do this as a loop forever, but that's bad to loop forever, and this was added as an optimization and it seems once is enough because the computation < block time
+	}
+
 	defer mp.curTsLk.Unlock()

 	_, err = mp.addTs(ctx, m, mp.curTs, false, false)
@@ -798,7 +819,7 @@ func (mp *MessagePool) VerifyMsgSig(m *types.SignedMessage) error {
 		return nil
 	}

-	if err := chain.AuthenticateMessage(m, m.Message.From); err != nil {
+	if err := consensus.AuthenticateMessage(m, m.Message.From); err != nil {
 		return xerrors.Errorf("failed to validate signature: %w", err)
 	}

@@ -853,9 +874,6 @@ func (mp *MessagePool) addTs(ctx context.Context, m *types.SignedMessage, curTs
 		return false, xerrors.Errorf("minimum expected nonce is %d: %w", snonce, ErrNonceTooLow)
 	}

-	mp.lk.Lock()
-	defer mp.lk.Unlock()
-
 	senderAct, err := mp.api.GetActorAfter(m.Message.From, curTs)
 	if err != nil {
 		return false, xerrors.Errorf("failed to get sender actor: %w", err)
@@ -866,10 +884,13 @@ func (mp *MessagePool) addTs(ctx context.Context, m *types.SignedMessage, curTs
 	nv := mp.api.StateNetworkVersion(ctx, epoch)

 	// TODO: I'm not thrilled about depending on filcns here, but I prefer this to duplicating logic
-	if !filcns.IsValidForSending(nv, senderAct) {
+	if !consensus.IsValidForSending(nv, senderAct) {
 		return false, xerrors.Errorf("sender actor %s is not a valid top-level sender", m.Message.From)
 	}

+	mp.lk.Lock()
+	defer mp.lk.Unlock()
+
 	publish, err := mp.verifyMsgBeforeAdd(ctx, m, curTs, local)
 	if err != nil {
 		return false, xerrors.Errorf("verify msg failed: %w", err)
@@ -1002,19 +1023,19 @@ func (mp *MessagePool) addLocked(ctx context.Context, m *types.SignedMessage, st
 }

 func (mp *MessagePool) GetNonce(ctx context.Context, addr address.Address, _ types.TipSetKey) (uint64, error) {
-	mp.curTsLk.Lock()
-	defer mp.curTsLk.Unlock()
+	mp.curTsLk.RLock()
+	defer mp.curTsLk.RUnlock()

-	mp.lk.Lock()
-	defer mp.lk.Unlock()
+	mp.lk.RLock()
+	defer mp.lk.RUnlock()

 	return mp.getNonceLocked(ctx, addr, mp.curTs)
 }

 // GetActor should not be used. It is only here to satisfy interface mess caused by lite node handling
 func (mp *MessagePool) GetActor(_ context.Context, addr address.Address, _ types.TipSetKey) (*types.Actor, error) {
-	mp.curTsLk.Lock()
-	defer mp.curTsLk.Unlock()
+	mp.curTsLk.RLock()
+	defer mp.curTsLk.RUnlock()
 	return mp.api.GetActorAfter(addr, mp.curTs)
 }

@@ -1054,7 +1075,7 @@ func (mp *MessagePool) getStateNonce(ctx context.Context, addr address.Address,

 	n, ok := mp.nonceCache.Get(nk)
 	if ok {
-		return n.(uint64), nil
+		return n, nil
 	}

 	act, err := mp.api.GetActorAfter(addr, ts)
@@ -1165,11 +1186,11 @@ func (mp *MessagePool) remove(ctx context.Context, from address.Address, nonce u
 }

 func (mp *MessagePool) Pending(ctx context.Context) ([]*types.SignedMessage, *types.TipSet) {
-	mp.curTsLk.Lock()
-	defer mp.curTsLk.Unlock()
+	mp.curTsLk.RLock()
+	defer mp.curTsLk.RUnlock()

-	mp.lk.Lock()
-	defer mp.lk.Unlock()
+	mp.lk.RLock()
+	defer mp.lk.RUnlock()

 	return mp.allPending(ctx)
 }
@@ -1185,11 +1206,11 @@ func (mp *MessagePool) allPending(ctx context.Context) ([]*types.SignedMessage,
 }

 func (mp *MessagePool) PendingFor(ctx context.Context, a address.Address) ([]*types.SignedMessage, *types.TipSet) {
-	mp.curTsLk.Lock()
-	defer mp.curTsLk.Unlock()
+	mp.curTsLk.RLock()
+	defer mp.curTsLk.RUnlock()

-	mp.lk.Lock()
-	defer mp.lk.Unlock()
+	mp.lk.RLock()
+	defer mp.lk.RUnlock()
 	return mp.pendingFor(ctx, a), mp.curTs
 }

@@ -1238,9 +1259,9 @@ func (mp *MessagePool) HeadChange(ctx context.Context, revert []*types.TipSet, a

 	maybeRepub := func(cid cid.Cid) {
 		if !repubTrigger {
-			mp.lk.Lock()
+			mp.lk.RLock()
 			_, republished := mp.republished[cid]
-			mp.lk.Unlock()
+			mp.lk.RUnlock()
 			if republished {
 				repubTrigger = true
 			}
@@ -1311,9 +1332,9 @@ func (mp *MessagePool) HeadChange(ctx context.Context, revert []*types.TipSet, a
 	}

 	if len(revert) > 0 && futureDebug {
-		mp.lk.Lock()
+		mp.lk.RLock()
 		msgs, ts := mp.allPending(ctx)
-		mp.lk.Unlock()
+		mp.lk.RUnlock()

 		buckets := map[address.Address]*statBucket{}

@@ -1474,15 +1495,10 @@ func (mp *MessagePool) MessagesForBlocks(ctx context.Context, blks []*types.Bloc
 }

 func (mp *MessagePool) RecoverSig(msg *types.Message) *types.SignedMessage {
-	val, ok := mp.blsSigCache.Get(msg.Cid())
+	sig, ok := mp.blsSigCache.Get(msg.Cid())
 	if !ok {
 		return nil
 	}
-	sig, ok := val.(crypto.Signature)
-	if !ok {
-		log.Errorf("value in signature cache was not a signature (got %T)", val)
-		return nil
-	}

 	return &types.SignedMessage{
 		Message:   *msg,
@@ -20,17 +20,18 @@ const repubMsgLimit = 30
 var RepublishBatchDelay = 100 * time.Millisecond

 func (mp *MessagePool) republishPendingMessages(ctx context.Context) error {
-	mp.curTsLk.Lock()
+	mp.curTsLk.RLock()
 	ts := mp.curTs

 	baseFee, err := mp.api.ChainComputeBaseFee(context.TODO(), ts)
+	mp.curTsLk.RUnlock()
 	if err != nil {
-		mp.curTsLk.Unlock()
 		return xerrors.Errorf("computing basefee: %w", err)
 	}
 	baseFeeLowerBound := getBaseFeeLowerBound(baseFee, baseFeeLowerBoundFactor)

 	pending := make(map[address.Address]map[uint64]*types.SignedMessage)
+	mp.curTsLk.Lock()
 	mp.lk.Lock()
 	mp.republished = nil // clear this to avoid races triggering an early republish
 	mp.forEachLocal(ctx, func(ctx context.Context, actor address.Address) {
@@ -43,6 +43,7 @@ func (mp *MessagePool) SelectMessages(ctx context.Context, ts *types.TipSet, tq
 	mp.curTsLk.Lock()
 	defer mp.curTsLk.Unlock()

+	//TODO confirm if we can switch to RLock here for performance
 	mp.lk.Lock()
 	defer mp.lk.Unlock()

@@ -52,8 +52,8 @@ func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.
 }

 // CallWithGas calculates the state for a given tipset, and then applies the given message on top of that state.
-func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, priorMsgs []types.ChainMsg, ts *types.TipSet) (*api.InvocResult, error) {
-	return sm.callInternal(ctx, msg, priorMsgs, ts, cid.Undef, sm.GetNetworkVersion, true, true)
+func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, priorMsgs []types.ChainMsg, ts *types.TipSet, applyTsMessages bool) (*api.InvocResult, error) {
+	return sm.callInternal(ctx, msg, priorMsgs, ts, cid.Undef, sm.GetNetworkVersion, true, applyTsMessages)
 }

 // CallAtStateAndVersion allows you to specify a message to execute on the given stateCid and network version.
@@ -117,12 +117,22 @@ func (sm *StateManager) callInternal(ctx context.Context, msg *types.Message, pr
 	if stateCid == cid.Undef {
 		stateCid = ts.ParentState()
 	}
+	tsMsgs, err := sm.cs.MessagesForTipset(ctx, ts)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to lookup messages for parent tipset: %w", err)
+	}
+
 	if applyTsMessages {
-		tsMsgs, err := sm.cs.MessagesForTipset(ctx, ts)
-		if err != nil {
-			return nil, xerrors.Errorf("failed to lookup messages for parent tipset: %w", err)
-		}
 		priorMsgs = append(tsMsgs, priorMsgs...)
+	} else {
+		var filteredTsMsgs []types.ChainMsg
+		for _, tsMsg := range tsMsgs {
+			//TODO we should technically be normalizing the filecoin address of from when we compare here
+			if tsMsg.VMMessage().From == msg.VMMessage().From {
+				filteredTsMsgs = append(filteredTsMsgs, tsMsg)
+			}
+		}
+		priorMsgs = append(filteredTsMsgs, priorMsgs...)
 	}

 	// Technically, the tipset we're passing in here should be ts+1, but that may not exist.
@@ -8,6 +8,7 @@ import (
 	"go.opencensus.io/trace"

 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 )

@@ -52,6 +53,22 @@ func (sm *StateManager) TipSetState(ctx context.Context, ts *types.TipSet) (st c

 	sm.stlk.Unlock()

+	if ts.Height() == 0 {
+		// NB: This is here because the process that executes blocks requires that the
+		// block miner reference a valid miner in the state tree. Unless we create some
+		// magical genesis miner, this won't work properly, so we short circuit here
+		// This avoids the question of 'who gets paid the genesis block reward'.
+		// This also makes us not attempt to lookup the tipset state with
+		// tryLookupTipsetState, which would cause a very long, very slow walk.
+		return ts.Blocks()[0].ParentStateRoot, ts.Blocks()[0].ParentMessageReceipts, nil
+	}
+
+	// First, try to find the tipset in the current chain. If found, we can avoid re-executing
+	// it.
+	if st, rec, found := tryLookupTipsetState(ctx, sm.cs, ts); found {
+		return st, rec, nil
+	}
+
 	st, rec, err = sm.tsExec.ExecuteTipSet(ctx, sm, ts, sm.tsExecMonitor, false)
 	if err != nil {
 		return cid.Undef, cid.Undef, err
@@ -60,16 +77,94 @@ func (sm *StateManager) TipSetState(ctx context.Context, ts *types.TipSet) (st c
 	return st, rec, nil
 }

+// Try to lookup a state & receipt CID for a given tipset by walking the chain instead of executing
+// it. This will only successfully return the state/receipt CIDs if they're found in the state
+// store.
+//
+// NOTE: This _won't_ recursively walk the receipt/state trees. It assumes that having the root
+// implies having the rest of the tree. However, lotus generally makes that assumption anyways.
+func tryLookupTipsetState(ctx context.Context, cs *store.ChainStore, ts *types.TipSet) (cid.Cid, cid.Cid, bool) {
+	nextTs, err := cs.GetTipsetByHeight(ctx, ts.Height()+1, nil, false)
+	if err != nil {
+		// Nothing to see here. The requested height may be beyond the current head.
+		return cid.Undef, cid.Undef, false
+	}
+
+	// Make sure we're on the correct fork.
+	if nextTs.Parents() != ts.Key() {
+		// Also nothing to see here. This just means that the requested tipset is on a
+		// different fork.
+		return cid.Undef, cid.Undef, false
+	}
+
+	stateCid := nextTs.ParentState()
+	receiptCid := nextTs.ParentMessageReceipts()
+
+	// Make sure we have the parent state.
+	if hasState, err := cs.StateBlockstore().Has(ctx, stateCid); err != nil {
+		log.Errorw("failed to lookup state-root in blockstore", "cid", stateCid, "error", err)
+		return cid.Undef, cid.Undef, false
+	} else if !hasState {
+		// We have the chain but don't have the state. It looks like we need to try
+		// executing?
+		return cid.Undef, cid.Undef, false
+	}
+
+	// Make sure we have the receipts.
+	if hasReceipts, err := cs.ChainBlockstore().Has(ctx, receiptCid); err != nil {
+		log.Errorw("failed to lookup receipts in blockstore", "cid", receiptCid, "error", err)
+		return cid.Undef, cid.Undef, false
+	} else if !hasReceipts {
+		// If we don't have the receipts, re-execute and try again.
+		return cid.Undef, cid.Undef, false
+	}
+
+	return stateCid, receiptCid, true
+}
+
 func (sm *StateManager) ExecutionTraceWithMonitor(ctx context.Context, ts *types.TipSet, em ExecMonitor) (cid.Cid, error) {
 	st, _, err := sm.tsExec.ExecuteTipSet(ctx, sm, ts, em, true)
 	return st, err
 }

 func (sm *StateManager) ExecutionTrace(ctx context.Context, ts *types.TipSet) (cid.Cid, []*api.InvocResult, error) {
+	tsKey := ts.Key()
+
+	// check if we have the trace for this tipset in the cache
+	sm.execTraceCacheLock.Lock()
+	if entry, ok := sm.execTraceCache.Get(tsKey); ok {
+		// we have to make a deep copy since caller can modify the invocTrace
+		// and we don't want that to change what we store in cache
+		invocTraceCopy := makeDeepCopy(entry.invocTrace)
+		sm.execTraceCacheLock.Unlock()
+		return entry.postStateRoot, invocTraceCopy, nil
+	}
+	sm.execTraceCacheLock.Unlock()
+
 	var invocTrace []*api.InvocResult
 	st, err := sm.ExecutionTraceWithMonitor(ctx, ts, &InvocationTracer{trace: &invocTrace})
 	if err != nil {
 		return cid.Undef, nil, err
 	}
+
+	invocTraceCopy := makeDeepCopy(invocTrace)
+
+	sm.execTraceCacheLock.Lock()
+	sm.execTraceCache.Add(tsKey, tipSetCacheEntry{st, invocTraceCopy})
+	sm.execTraceCacheLock.Unlock()
+
 	return st, invocTrace, nil
 }
+
+func makeDeepCopy(invocTrace []*api.InvocResult) []*api.InvocResult {
+	c := make([]*api.InvocResult, len(invocTrace))
+	for i, ir := range invocTrace {
+		if ir == nil {
+			continue
+		}
+		tmp := *ir
+		c[i] = &tmp
+	}
+
+	return c
+}
@@ -4,7 +4,9 @@ import (
 	"bytes"
 	"context"
 	"encoding/binary"
+	"os"
 	"sort"
+	"strings"
 	"sync"
 	"time"

@@ -26,6 +28,9 @@ import (
 	"github.com/filecoin-project/lotus/chain/vm"
 )

+// EnvDisablePreMigrations when set to '1' stops pre-migrations from running
+const EnvDisablePreMigrations = "LOTUS_DISABLE_PRE_MIGRATIONS"
+
 // MigrationCache can be used to cache information used by a migration. This is primarily useful to
 // "pre-compute" some migration state ahead of time, and make it accessible in the migration itself.
 type MigrationCache interface {
@@ -169,9 +174,16 @@ func (us UpgradeSchedule) GetNtwkVersion(e abi.ChainEpoch) (network.Version, err

 func (sm *StateManager) HandleStateForks(ctx context.Context, root cid.Cid, height abi.ChainEpoch, cb ExecMonitor, ts *types.TipSet) (cid.Cid, error) {
 	retCid := root
-	var err error
 	u := sm.stateMigrations[height]
 	if u != nil && u.upgrade != nil {
+		migCid, ok, err := u.migrationResultCache.Get(ctx, root)
+		if err == nil && ok {
+			log.Infow("CACHED migration", "height", height, "from", root, "to", migCid)
+			return migCid, nil
+		} else if err != nil {
+			log.Errorw("failed to lookup previous migration result", "err", err)
+		}
+
 		startTime := time.Now()
 		log.Warnw("STARTING migration", "height", height, "from", root)
 		// Yes, we clone the cache, even for the final upgrade epoch. Why? Reverts. We may
@@ -192,6 +204,11 @@ func (sm *StateManager) HandleStateForks(ctx context.Context, root cid.Cid, heig
 			"to", retCid,
 			"duration", time.Since(startTime),
 		)
+
+		// Only set if migration ran, we do not want a root => root mapping
+		if err := u.migrationResultCache.Store(ctx, root, retCid); err != nil {
+			log.Errorw("failed to store migration result", "err", err)
+		}
 	}

 	return retCid, nil
@@ -218,6 +235,11 @@ func runPreMigration(ctx context.Context, sm *StateManager, fn PreMigrationFunc,
 	height := ts.Height()
 	parent := ts.ParentState()

+	if disabled := os.Getenv(EnvDisablePreMigrations); strings.TrimSpace(disabled) == "1" {
+		log.Warnw("SKIPPING pre-migration", "height", height)
+		return
+	}
+
 	startTime := time.Now()

 	log.Warn("STARTING pre-migration")
@@ -347,12 +369,11 @@ func DoTransfer(tree types.StateTree, from, to address.Address, amt abi.TokenAmo
 		// record the transfer in execution traces

 		cb(types.ExecutionTrace{
-			Msg:        MakeFakeMsg(from, to, amt, 0),
-			MsgRct:     MakeFakeRct(),
-			Error:      "",
-			Duration:   0,
-			GasCharges: nil,
-			Subcalls:   nil,
+			Msg: types.MessageTrace{
+				From:  from,
+				To:    to,
+				Value: amt,
+			},
 		})
 	}

@@ -5,10 +5,12 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"os"
 	"sync"
 	"testing"

 	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-datastore"
 	ipldcbor "github.com/ipfs/go-ipld-cbor"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/stretchr/testify/require"
@@ -31,8 +33,11 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	_init "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
+	"github.com/filecoin-project/lotus/chain/consensus"
 	"github.com/filecoin-project/lotus/chain/consensus/filcns"
 	"github.com/filecoin-project/lotus/chain/gen"
+	"github.com/filecoin-project/lotus/chain/index"
+	"github.com/filecoin-project/lotus/chain/stmgr"
 	. "github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
@@ -128,7 +133,7 @@ func TestForkHeightTriggers(t *testing.T) {
 	}

 	sm, err := NewStateManager(
-		cg.ChainStore(), filcns.NewTipSetExecutor(), cg.StateManager().VMSys(), UpgradeSchedule{{
+		cg.ChainStore(), consensus.NewTipSetExecutor(filcns.RewardFunc), cg.StateManager().VMSys(), UpgradeSchedule{{
 			Network: network.Version1,
 			Height:  testForkHeight,
 			Migration: func(ctx context.Context, sm *StateManager, cache MigrationCache, cb ExecMonitor,
@@ -164,12 +169,12 @@ func TestForkHeightTriggers(t *testing.T) {
 				}

 				return st.Flush(ctx)
-			}}}, cg.BeaconSchedule())
+			}}}, cg.BeaconSchedule(), datastore.NewMapDatastore(), index.DummyMsgIndex)
 	if err != nil {
 		t.Fatal(err)
 	}

-	inv := filcns.NewActorRegistry()
+	inv := consensus.NewActorRegistry()
 	registry := builtin.MakeRegistryLegacy([]rtt.VMActor{testActor{}})
 	inv.Register(actorstypes.Version0, nil, registry)

@@ -274,7 +279,7 @@ func testForkRefuseCall(t *testing.T, nullsBefore, nullsAfter int) {

 	var migrationCount int
 	sm, err := NewStateManager(
-		cg.ChainStore(), filcns.NewTipSetExecutor(), cg.StateManager().VMSys(), UpgradeSchedule{{
+		cg.ChainStore(), consensus.NewTipSetExecutor(filcns.RewardFunc), cg.StateManager().VMSys(), UpgradeSchedule{{
 			Network:   network.Version1,
 			Expensive: true,
 			Height:    testForkHeight,
@@ -282,12 +287,12 @@ func testForkRefuseCall(t *testing.T, nullsBefore, nullsAfter int) {
 				root cid.Cid, height abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
 				migrationCount++
 				return root, nil
-			}}}, cg.BeaconSchedule())
+			}}}, cg.BeaconSchedule(), datastore.NewMapDatastore(), index.DummyMsgIndex)
 	if err != nil {
 		t.Fatal(err)
 	}

-	inv := filcns.NewActorRegistry()
+	inv := consensus.NewActorRegistry()
 	registry := builtin.MakeRegistryLegacy([]rtt.VMActor{testActor{}})
 	inv.Register(actorstypes.Version0, nil, registry)

@@ -336,7 +341,7 @@ func testForkRefuseCall(t *testing.T, nullsBefore, nullsAfter int) {
 		currentHeight := ts.TipSet.TipSet().Height()

 		// CallWithGas calls on top of the given tipset.
-		ret, err := sm.CallWithGas(ctx, m, nil, ts.TipSet.TipSet())
+		ret, err := sm.CallWithGas(ctx, m, nil, ts.TipSet.TipSet(), true)
 		if parentHeight <= testForkHeight && currentHeight >= testForkHeight {
 			// If I had a fork, or I _will_ have a fork, it should fail.
 			require.Equal(t, ErrExpensiveFork, err)
@@ -357,7 +362,7 @@ func testForkRefuseCall(t *testing.T, nullsBefore, nullsAfter int) {
 		// Calls without a tipset should walk back to the last non-fork tipset.
 		// We _verify_ that the migration wasn't run multiple times at the end of the
 		// test.
-		ret, err = sm.CallWithGas(ctx, m, nil, nil)
+		ret, err = sm.CallWithGas(ctx, m, nil, nil, true)
 		require.NoError(t, err)
 		require.True(t, ret.MsgRct.ExitCode.IsSuccess())

@@ -412,7 +417,7 @@ func TestForkPreMigration(t *testing.T) {
 	counter := make(chan struct{}, 10)

 	sm, err := NewStateManager(
-		cg.ChainStore(), filcns.NewTipSetExecutor(), cg.StateManager().VMSys(), UpgradeSchedule{{
+		cg.ChainStore(), consensus.NewTipSetExecutor(filcns.RewardFunc), cg.StateManager().VMSys(), UpgradeSchedule{{
 			Network: network.Version1,
 			Height:  testForkHeight,
 			Migration: func(ctx context.Context, sm *StateManager, cache MigrationCache, cb ExecMonitor,
@@ -500,7 +505,7 @@ func TestForkPreMigration(t *testing.T) {
 					return nil
 				},
 			}}},
-		}, cg.BeaconSchedule())
+		}, cg.BeaconSchedule(), datastore.NewMapDatastore(), index.DummyMsgIndex)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -509,7 +514,7 @@ func TestForkPreMigration(t *testing.T) {
 		require.NoError(t, sm.Stop(context.Background()))
 	}()

-	inv := filcns.NewActorRegistry()
+	inv := consensus.NewActorRegistry()
 	registry := builtin.MakeRegistryLegacy([]rtt.VMActor{testActor{}})
 	inv.Register(actorstypes.Version0, nil, registry)

@@ -534,3 +539,173 @@ func TestForkPreMigration(t *testing.T) {
 	// to this channel.
 	require.Equal(t, 6, len(counter))
 }
+
+func TestDisablePreMigration(t *testing.T) {
+	logging.SetAllLoggers(logging.LevelInfo)
+
+	cg, err := gen.NewGenerator()
+	require.NoError(t, err)
+
+	err = os.Setenv(EnvDisablePreMigrations, "1")
+	require.NoError(t, err)
+
+	defer func() {
+		err := os.Unsetenv(EnvDisablePreMigrations)
+		require.NoError(t, err)
+	}()
+
+	counter := make(chan struct{}, 10)
+
+	sm, err := NewStateManager(
+		cg.ChainStore(),
+		consensus.NewTipSetExecutor(filcns.RewardFunc),
+		cg.StateManager().VMSys(),
+		UpgradeSchedule{{
+			Network: network.Version1,
+			Height:  testForkHeight,
+			Migration: func(_ context.Context, _ *StateManager, _ MigrationCache, _ ExecMonitor,
+				root cid.Cid, _ abi.ChainEpoch, _ *types.TipSet) (cid.Cid, error) {
+
+				counter <- struct{}{}
+
+				return root, nil
+			},
+			PreMigrations: []PreMigration{{
+				StartWithin: 20,
+				PreMigration: func(ctx context.Context, _ *StateManager, _ MigrationCache,
+					_ cid.Cid, _ abi.ChainEpoch, _ *types.TipSet) error {
+					panic("should be skipped")
+				},
+			}}},
+		},
+		cg.BeaconSchedule(),
+		datastore.NewMapDatastore(),
+		index.DummyMsgIndex,
+	)
+	require.NoError(t, err)
+	require.NoError(t, sm.Start(context.Background()))
+	defer func() {
+		require.NoError(t, sm.Stop(context.Background()))
+	}()
+
+	inv := consensus.NewActorRegistry()
+	registry := builtin.MakeRegistryLegacy([]rtt.VMActor{testActor{}})
+	inv.Register(actorstypes.Version0, nil, registry)
+
+	sm.SetVMConstructor(func(ctx context.Context, vmopt *vm.VMOpts) (vm.Interface, error) {
+		nvm, err := vm.NewLegacyVM(ctx, vmopt)
+		require.NoError(t, err)
+		nvm.SetInvoker(inv)
+		return nvm, nil
+	})
+
+	cg.SetStateManager(sm)
+
+	for i := 0; i < 50; i++ {
+		_, err := cg.NextTipSet()
+		require.NoError(t, err)
+	}
+
+	require.Equal(t, 1, len(counter))
+}
+
+func TestMigrtionCache(t *testing.T) {
+	logging.SetAllLoggers(logging.LevelInfo)
+
+	cg, err := gen.NewGenerator()
+	require.NoError(t, err)
+
+	counter := make(chan struct{}, 10)
+	metadataDs := datastore.NewMapDatastore()
+
+	sm, err := NewStateManager(
+		cg.ChainStore(),
+		consensus.NewTipSetExecutor(filcns.RewardFunc),
+		cg.StateManager().VMSys(),
+		UpgradeSchedule{{
+			Network: network.Version1,
+			Height:  testForkHeight,
+			Migration: func(_ context.Context, _ *StateManager, _ MigrationCache, _ ExecMonitor,
+				root cid.Cid, _ abi.ChainEpoch, _ *types.TipSet) (cid.Cid, error) {
+
+				counter <- struct{}{}
+
+				return root, nil
+			}},
+		},
+		cg.BeaconSchedule(),
+		metadataDs,
+		index.DummyMsgIndex,
+	)
+	require.NoError(t, err)
+	require.NoError(t, sm.Start(context.Background()))
+	defer func() {
+		require.NoError(t, sm.Stop(context.Background()))
+	}()
+
+	inv := consensus.NewActorRegistry()
+	registry := builtin.MakeRegistryLegacy([]rtt.VMActor{testActor{}})
+	inv.Register(actorstypes.Version0, nil, registry)
+
+	sm.SetVMConstructor(func(ctx context.Context, vmopt *vm.VMOpts) (vm.Interface, error) {
+		nvm, err := vm.NewLegacyVM(ctx, vmopt)
+		require.NoError(t, err)
+		nvm.SetInvoker(inv)
+		return nvm, nil
+	})
+
+	cg.SetStateManager(sm)
+
+	for i := 0; i < 50; i++ {
+		_, err := cg.NextTipSet()
+		require.NoError(t, err)
+	}
+
+	ts, err := cg.ChainStore().GetTipsetByHeight(context.Background(), testForkHeight, nil, false)
+	require.NoError(t, err)
+
+	root, _, err := stmgr.ComputeState(context.Background(), sm, testForkHeight+1, []*types.Message{}, ts)
+	require.NoError(t, err)
+	t.Log(root)
+
+	require.Equal(t, 1, len(counter))
+
+	{
+		sm, err := NewStateManager(
+			cg.ChainStore(),
+			consensus.NewTipSetExecutor(filcns.RewardFunc),
+			cg.StateManager().VMSys(),
+			UpgradeSchedule{{
+				Network: network.Version1,
+				Height:  testForkHeight,
+				Migration: func(_ context.Context, _ *StateManager, _ MigrationCache, _ ExecMonitor,
+					root cid.Cid, _ abi.ChainEpoch, _ *types.TipSet) (cid.Cid, error) {
+
+					counter <- struct{}{}
+
+					return root, nil
+				}},
+			},
+			cg.BeaconSchedule(),
+			metadataDs,
+			index.DummyMsgIndex,
+		)
+		require.NoError(t, err)
+		sm.SetVMConstructor(func(ctx context.Context, vmopt *vm.VMOpts) (vm.Interface, error) {
+			nvm, err := vm.NewLegacyVM(ctx, vmopt)
+			require.NoError(t, err)
+			nvm.SetInvoker(inv)
+			return nvm, nil
+		})
+
+		ctx := context.Background()
+
+		base, _, err := sm.ExecutionTrace(ctx, ts)
+		require.NoError(t, err)
+		_, err = sm.HandleStateForks(context.Background(), base, ts.Height(), nil, ts)
+		require.NoError(t, err)
+
+		// Should not have increased as we should be using the cached results in the metadataDs
+		require.Equal(t, 1, len(counter))
+	}
+}
@@ -10,6 +10,7 @@ import (

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

+	"github.com/filecoin-project/lotus/chain/index"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 )
@@ -18,6 +19,7 @@ import (
 // happened, with an optional limit to how many epochs it will search. It guarantees that the message has been on
 // chain for at least confidence epochs without being reverted before returning.
 func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confidence uint64, lookbackLimit abi.ChainEpoch, allowReplaced bool) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
+	// TODO use the index to speed this up.
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()

@@ -55,10 +57,15 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
 	var backFm cid.Cid
 	backSearchWait := make(chan struct{})
 	go func() {
-		fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head[0].Val, msg, lookbackLimit, allowReplaced)
-		if err != nil {
-			log.Warnf("failed to look back through chain for message: %v", err)
-			return
+		fts, r, foundMsg, err := sm.searchForIndexedMsg(ctx, mcid, msg)
+
+		found := (err == nil && r != nil && foundMsg.Defined())
+		if !found {
+			fts, r, foundMsg, err = sm.searchBackForMsg(ctx, head[0].Val, msg, lookbackLimit, allowReplaced)
+			if err != nil {
+				log.Warnf("failed to look back through chain for message: %v", err)
+				return
+			}
 		}

 		backTs = fts
@@ -145,7 +152,30 @@ func (sm *StateManager) SearchForMessage(ctx context.Context, head *types.TipSet
 		return head, r, foundMsg, nil
 	}

-	fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head, msg, lookbackLimit, allowReplaced)
+	fts, r, foundMsg, err := sm.searchForIndexedMsg(ctx, mcid, msg)
+
+	switch {
+	case err == nil:
+		if r != nil && foundMsg.Defined() {
+			return fts, r, foundMsg, nil
+		}
+
+		// debug log this, it's noteworthy
+		if r == nil {
+			log.Debugf("missing receipt for message in index for %s", mcid)
+		}
+		if !foundMsg.Defined() {
+			log.Debugf("message %s not found", mcid)
+		}
+
+	case errors.Is(err, index.ErrNotFound):
+		// ok for the index to have incomplete data
+
+	default:
+		log.Warnf("error searching message index: %s", err)
+	}
+
+	fts, r, foundMsg, err = sm.searchBackForMsg(ctx, head, msg, lookbackLimit, allowReplaced)

 	if err != nil {
 		log.Warnf("failed to look back through chain for message %s", mcid)
@@ -159,6 +189,52 @@ func (sm *StateManager) SearchForMessage(ctx context.Context, head *types.TipSet
 	return fts, r, foundMsg, nil
 }

+func (sm *StateManager) searchForIndexedMsg(ctx context.Context, mcid cid.Cid, m types.ChainMsg) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
+	minfo, xtsCid, err := sm.msgIndex.GetMsgInfo(ctx, mcid)
+	if err != nil {
+		return nil, nil, cid.Undef, xerrors.Errorf("error looking up message in index: %w", err)
+	}
+
+	// check the height against the current tipset; minimum execution confidence requires that the
+	// inclusion tipset height is lower than the current head + 1
+	curTs := sm.cs.GetHeaviestTipSet()
+	if curTs.Height() <= minfo.Epoch+1 {
+		return nil, nil, cid.Undef, xerrors.Errorf("indexed message does not appear before the current tipset; index epoch: %d, current epoch: %d", minfo.Epoch, curTs.Height())
+	}
+
+	// now get the execution tipset
+	var xts *types.TipSet = nil
+	if xtsCid != cid.Undef {
+		// lookup by cid which is faster
+		xts, err = sm.cs.GetTipSetByCid(ctx, xtsCid)
+		if err != nil {
+			return nil, nil, cid.Undef, xerrors.Errorf("error calling GetTipSetByCid: %w", err)
+		}
+	} else {
+		xts, err = sm.cs.GetTipsetByHeight(ctx, minfo.Epoch+1, curTs, false)
+		if err != nil {
+			return nil, nil, cid.Undef, xerrors.Errorf("error calling GetTipsetByHeight: %w", err)
+		}
+	}
+
+	// check that the parent of the execution index is indeed the inclusion tipset
+	parent := xts.Parents()
+	parentCid, err := parent.Cid()
+	if err != nil {
+		return nil, nil, cid.Undef, xerrors.Errorf("error computing tipset cid: %w", err)
+	}
+
+	if !parentCid.Equals(minfo.TipSet) {
+		return nil, nil, cid.Undef, xerrors.Errorf("inclusion tipset mismatch: have %s, expected %s", parentCid, minfo.TipSet)
+	}
+
+	r, foundMsg, err := sm.tipsetExecutedMessage(ctx, xts, mcid, m.VMMessage(), false)
+	if err != nil {
+		return nil, nil, cid.Undef, xerrors.Errorf("error in tipstExecutedMessage: %w", err)
+	}
+	return xts, r, foundMsg, nil
+}
+
 // searchBackForMsg searches up to limit tipsets backwards from the given
 // tipset for a message receipt.
 // If limit is
@@ -2,10 +2,14 @@ package stmgr

 import (
 	"context"
+	"fmt"
 	"sync"

+	lru "github.com/hashicorp/golang-lru/v2"
 	"github.com/ipfs/go-cid"
+	dstore "github.com/ipfs/go-datastore"
 	cbor "github.com/ipfs/go-ipld-cbor"
+	ipld "github.com/ipfs/go-ipld-format"
 	logging "github.com/ipfs/go-log/v2"
 	"golang.org/x/xerrors"

@@ -22,6 +26,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/beacon"
+	"github.com/filecoin-project/lotus/chain/index"
 	"github.com/filecoin-project/lotus/chain/rand"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/store"
@@ -35,6 +40,8 @@ import (
 const LookbackNoLimit = api.LookbackNoLimit
 const ReceiptAmtBitwidth = 3

+const execTraceCacheSize = 16
+
 var log = logging.Logger("statemgr")

 type StateManagerAPI interface {
@@ -51,9 +58,47 @@ type versionSpec struct {
 }

 type migration struct {
-	upgrade       MigrationFunc
-	preMigrations []PreMigration
-	cache         *nv16.MemMigrationCache
+	upgrade              MigrationFunc
+	preMigrations        []PreMigration
+	cache                *nv16.MemMigrationCache
+	migrationResultCache *migrationResultCache
+}
+
+type migrationResultCache struct {
+	ds        dstore.Batching
+	keyPrefix string
+}
+
+func (m *migrationResultCache) keyForMigration(root cid.Cid) dstore.Key {
+	kStr := fmt.Sprintf("%s/%s", m.keyPrefix, root)
+	return dstore.NewKey(kStr)
+}
+
+func (m *migrationResultCache) Get(ctx context.Context, root cid.Cid) (cid.Cid, bool, error) {
+	k := m.keyForMigration(root)
+
+	bs, err := m.ds.Get(ctx, k)
+	if ipld.IsNotFound(err) {
+		return cid.Undef, false, nil
+	} else if err != nil {
+		return cid.Undef, false, xerrors.Errorf("error loading migration result: %w", err)
+	}
+
+	c, err := cid.Parse(bs)
+	if err != nil {
+		return cid.Undef, false, xerrors.Errorf("error parsing migration result: %w", err)
+	}
+
+	return c, true, nil
+}
+
+func (m *migrationResultCache) Store(ctx context.Context, root cid.Cid, resultCid cid.Cid) error {
+	k := m.keyForMigration(root)
+	if err := m.ds.Put(ctx, k, resultCid.Bytes()); err != nil {
+		return err
+	}
+
+	return nil
 }

 type Executor interface {
@@ -89,12 +134,20 @@ type StateManager struct {
 	postIgnitionVesting []msig0.State
 	postCalicoVesting   []msig0.State

-	genesisPledge      abi.TokenAmount
-	genesisMarketFunds abi.TokenAmount
+	genesisPledge abi.TokenAmount

 	tsExec        Executor
 	tsExecMonitor ExecMonitor
 	beacon        beacon.Schedule
+
+	msgIndex index.MsgIndex
+
+	// We keep a small cache for calls to ExecutionTrace which helps improve
+	// performance for node operators like exchanges and block explorers
+	execTraceCache *lru.ARCCache[types.TipSetKey, tipSetCacheEntry]
+	// We need a lock while making the copy as to prevent other callers
+	// overwrite the cache while making the copy
+	execTraceCacheLock sync.Mutex
 }

 // Caches a single state tree
@@ -103,7 +156,12 @@ type treeCache struct {
 	tree *state.StateTree
 }

-func NewStateManager(cs *store.ChainStore, exec Executor, sys vm.SyscallBuilder, us UpgradeSchedule, beacon beacon.Schedule) (*StateManager, error) {
+type tipSetCacheEntry struct {
+	postStateRoot cid.Cid
+	invocTrace    []*api.InvocResult
+}
+
+func NewStateManager(cs *store.ChainStore, exec Executor, sys vm.SyscallBuilder, us UpgradeSchedule, beacon beacon.Schedule, metadataDs dstore.Batching, msgIndex index.MsgIndex) (*StateManager, error) {
 	// If we have upgrades, make sure they're in-order and make sense.
 	if err := us.Validate(); err != nil {
 		return nil, err
@@ -122,12 +180,18 @@ func NewStateManager(cs *store.ChainStore, exec Executor, sys vm.SyscallBuilder,
 					upgrade:       upgrade.Migration,
 					preMigrations: upgrade.PreMigrations,
 					cache:         nv16.NewMemMigrationCache(),
+					migrationResultCache: &migrationResultCache{
+						keyPrefix: fmt.Sprintf("/migration-cache/nv%d", upgrade.Network),
+						ds:        metadataDs,
+					},
 				}
+
 				stateMigrations[upgrade.Height] = migration
 			}
 			if upgrade.Expensive {
 				expensiveUpgrades[upgrade.Height] = struct{}{}
 			}
+
 			networkVersions = append(networkVersions, versionSpec{
 				networkVersion: lastVersion,
 				atOrBelow:      upgrade.Height,
@@ -136,6 +200,11 @@ func NewStateManager(cs *store.ChainStore, exec Executor, sys vm.SyscallBuilder,
 		}
 	}

+	execTraceCache, err := lru.NewARC[types.TipSetKey, tipSetCacheEntry](execTraceCacheSize)
+	if err != nil {
+		return nil, err
+	}
+
 	return &StateManager{
 		networkVersions:   networkVersions,
 		latestVersion:     lastVersion,
@@ -151,12 +220,14 @@ func NewStateManager(cs *store.ChainStore, exec Executor, sys vm.SyscallBuilder,
 			root: cid.Undef,
 			tree: nil,
 		},
-		compWait: make(map[string]chan struct{}),
+		compWait:       make(map[string]chan struct{}),
+		msgIndex:       msgIndex,
+		execTraceCache: execTraceCache,
 	}, nil
 }

-func NewStateManagerWithUpgradeScheduleAndMonitor(cs *store.ChainStore, exec Executor, sys vm.SyscallBuilder, us UpgradeSchedule, b beacon.Schedule, em ExecMonitor) (*StateManager, error) {
-	sm, err := NewStateManager(cs, exec, sys, us, b)
+func NewStateManagerWithUpgradeScheduleAndMonitor(cs *store.ChainStore, exec Executor, sys vm.SyscallBuilder, us UpgradeSchedule, b beacon.Schedule, em ExecMonitor, metadataDs dstore.Batching, msgIndex index.MsgIndex) (*StateManager, error) {
+	sm, err := NewStateManager(cs, exec, sys, us, b, metadataDs, msgIndex)
 	if err != nil {
 		return nil, err
 	}
@@ -51,17 +51,13 @@ func (sm *StateManager) setupGenesisVestingSchedule(ctx context.Context) error {
 		return xerrors.Errorf("loading state tree: %w", err)
 	}

-	gmf, err := getFilMarketLocked(ctx, sTree)
-	if err != nil {
-		return xerrors.Errorf("setting up genesis market funds: %w", err)
-	}
-
 	gp, err := getFilPowerLocked(ctx, sTree)
 	if err != nil {
 		return xerrors.Errorf("setting up genesis pledge: %w", err)
 	}

-	sm.genesisMarketFunds = gmf
+	sm.genesisMsigLk.Lock()
+	defer sm.genesisMsigLk.Unlock()
 	sm.genesisPledge = gp

 	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
@@ -128,6 +124,8 @@ func (sm *StateManager) setupPostIgnitionVesting(ctx context.Context) error {
 	totalsByEpoch[sixYears] = big.NewInt(100_000_000)
 	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))

+	sm.genesisMsigLk.Lock()
+	defer sm.genesisMsigLk.Unlock()
 	sm.postIgnitionVesting = make([]msig0.State, 0, len(totalsByEpoch))
 	for k, v := range totalsByEpoch {
 		ns := msig0.State{
@@ -178,6 +176,9 @@ func (sm *StateManager) setupPostCalicoVesting(ctx context.Context) error {
 	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))
 	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(9_805_053))

+	sm.genesisMsigLk.Lock()
+	defer sm.genesisMsigLk.Unlock()
+
 	sm.postCalicoVesting = make([]msig0.State, 0, len(totalsByEpoch))
 	for k, v := range totalsByEpoch {
 		ns := msig0.State{
@@ -198,21 +199,20 @@ func (sm *StateManager) setupPostCalicoVesting(ctx context.Context) error {
 func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch) (abi.TokenAmount, error) {
 	vf := big.Zero()

-	sm.genesisMsigLk.Lock()
-	defer sm.genesisMsigLk.Unlock()
-
 	// TODO: combine all this?
-	if sm.preIgnitionVesting == nil || sm.genesisPledge.IsZero() || sm.genesisMarketFunds.IsZero() {
+	if sm.preIgnitionVesting == nil || sm.genesisPledge.IsZero() {
 		err := sm.setupGenesisVestingSchedule(ctx)
 		if err != nil {
 			return vf, xerrors.Errorf("failed to setup pre-ignition vesting schedule: %w", err)
 		}
+
 	}
 	if sm.postIgnitionVesting == nil {
 		err := sm.setupPostIgnitionVesting(ctx)
 		if err != nil {
 			return vf, xerrors.Errorf("failed to setup post-ignition vesting schedule: %w", err)
 		}
+
 	}
 	if sm.postCalicoVesting == nil {
 		err := sm.setupPostCalicoVesting(ctx)
@@ -246,8 +246,6 @@ func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch)
 	if height <= build.UpgradeAssemblyHeight {
 		// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
 		vf = big.Add(vf, sm.genesisPledge)
-		// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
-		vf = big.Add(vf, sm.genesisMarketFunds)
 	}

 	return vf, nil
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 .18.8
 .19.7