update cl (#10819 )

Update changelog.md for release/v1.23.1
Update build version for release/v1.23.1
2023-05-03 19:07:15 -04:00 · 2023-05-03 18:32:10 -04:00 · 2023-05-03 17:20:57 -04:00
146 changed files with 3412 additions and 4929 deletions
@@ -63,7 +63,7 @@ commands:
                name: Install Rust
                command: |
                  curl https://sh.rustup.rs -sSf | sh -s -- -y
-      - run: make deps
+      - run: make deps lotus
  download-params:
    steps:
      - restore_cache:
@@ -304,7 +304,9 @@ jobs:
          darwin: true
          darwin-architecture: arm64
      - run: |
-          export CPATH=$(brew --prefix)/include && export LIBRARY_PATH=$(brew --prefix)/lib && make lotus lotus-miner lotus-worker
+          export CPATH=$(brew --prefix)/include
+          export LIBRARY_PATH=$(brew --prefix)/lib
+          make lotus lotus-miner lotus-worker
      - run: otool -hv lotus
      - run:
          name: check tag and version output match
@@ -882,12 +884,6 @@ workflows:
            - build
          suite: itest-sdr_upgrade
          target: "./itests/sdr_upgrade_test.go"
-      - test:
-          name: test-itest-sealing_resources
-          requires:
-            - build
-          suite: itest-sealing_resources
-          target: "./itests/sealing_resources_test.go"
      - test:
          name: test-itest-sector_finalize_early
          requires:
@@ -1073,7 +1069,6 @@ workflows:
            branches:
              only:
                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
-                - /^ci\/.*$/
            tags:
              only:
                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
@@ -1083,7 +1078,6 @@ workflows:
            branches:
              only:
                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
-                - /^ci\/.*$/
            tags:
              only:
                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
@@ -1093,7 +1087,6 @@ workflows:
            branches:
              only:
                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
-                - /^ci\/.*$/
            tags:
              only:
                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
@@ -1106,7 +1099,7 @@ workflows:
          filters:
            branches:
              ignore:
-                - /^.*$/
+                - /.*/
            tags:
              only:
                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
@@ -1121,7 +1114,6 @@ workflows:
            branches:
              only:
                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
-                - /^ci\/.*$/
      - build-docker:
          name: "Docker push (lotus-all-in-one / stable / mainnet)"
          image: lotus-all-in-one
@@ -63,7 +63,7 @@ commands:
                name: Install Rust
                command: |
                  curl https://sh.rustup.rs -sSf | sh -s -- -y
-      - run: make deps
+      - run: make deps lotus
  download-params:
    steps:
      - restore_cache:
@@ -304,7 +304,9 @@ jobs:
          darwin: true
          darwin-architecture: arm64
      - run: |
-          export CPATH=$(brew --prefix)/include && export LIBRARY_PATH=$(brew --prefix)/lib && make lotus lotus-miner lotus-worker
+          export CPATH=$(brew --prefix)/include
+          export LIBRARY_PATH=$(brew --prefix)/lib
+          make lotus lotus-miner lotus-worker
      - run: otool -hv lotus
      - run:
          name: check tag and version output match
@@ -581,7 +583,6 @@ workflows:
            branches:
              only:
                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
-                - /^ci\/.*$/
            tags:
              only:
                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
@@ -591,7 +592,6 @@ workflows:
            branches:
              only:
                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
-                - /^ci\/.*$/
            tags:
              only:
                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
@@ -601,7 +601,6 @@ workflows:
            branches:
              only:
                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
-                - /^ci\/.*$/
            tags:
              only:
                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
@@ -614,7 +613,7 @@ workflows:
          filters:
            branches:
              ignore:
-                - /^.*$/
+                - /.*/
            tags:
              only:
                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
@@ -629,7 +628,6 @@ workflows:
            branches:
              only:
                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
-                - /^ci\/.*$/
      [[- range .Networks]]
      - build-docker:
          name: "Docker push (lotus-all-in-one / stable / [[.]])"
@@ -52,4 +52,3 @@ dist/
 # The following files are checked into git and result
 # in dirty git state if removed from the docker context
 !extern/filecoin-ffi/rust/filecoin.pc
-!extern/test-vectors
@@ -1,10 +1,115 @@
 # Lotus changelog

-# UNRELEASED
+# v1.23.1 / 2023-05-03

-## New features
- feat: Added new environment variable `LOTUS_EXEC_TRACE_CACHE_SIZE` to configure execution trace cache size ([filecoin-project/lotus#10585](https://github.com/filecoin-project/lotus/pull/10585))
-  - If unset, we default to caching 16 most recent execution traces. Node operatores may want to set this to 0 while exchanges may want to crank it up. 
+# What's changed
+  - Update build version for release/v1.23.1
+  - Disable lotus markets by default (#10809) ([filecoin-project/lotus#10809](https://github.com/filecoin-project/lotus/pull/10809))
+  - perf: mempool: lower priority optimizations (#10693) ([filecoin-project/lotus#10693](https://github.com/filecoin-project/lotus/pull/10693))
+  - Change args check ([filecoin-project/lotus#10812](https://github.com/filecoin-project/lotus/pull/10812))
+  - chore: drop flaky TestBatchDealInput subcase ([filecoin-project/lotus#10810](https://github.com/filecoin-project/lotus/pull/10810))
+  - fix: sealing: Make lotus-worker report GPU usage to miner during ReplicaUpdate task (#10806) ([filecoin-project/lotus#10806](https://github.com/filecoin-project/lotus/pull/10806))
+  - fix:splitstore:Don't block when potentially holding txnLk as writer ([filecoin-project/lotus#10811](https://github.com/filecoin-project/lotus/pull/10811))
+  - feat: worker: Ensure tempdir exists (#10433) ([filecoin-project/lotus#10433](https://github.com/filecoin-project/lotus/pull/10433))
+  - feat: chainstore: batch writes of tipsets ([filecoin-project/lotus#10800](https://github.com/filecoin-project/lotus/pull/10800))
+  - chore: changelog clean up ([filecoin-project/lotus#10744](https://github.com/filecoin-project/lotus/pull/10744))
+  - chore: refactor: drop unused IsTicketWinner (#10801) ([filecoin-project/lotus#10801](https://github.com/filecoin-project/lotus/pull/10801))
+  - Revert #9858 (consistent broadcast changes) ([filecoin-project/lotus#10777](https://github.com/filecoin-project/lotus/pull/10777))
+  - chore: deps: update to FVM 3.3.1 ([filecoin-project/lotus#10786](https://github.com/filecoin-project/lotus/pull/10786))
+  - Set default for MaxSectorProveCommitsSubmittedPerEpoch ([filecoin-project/lotus#10728](https://github.com/filecoin-project/lotus/pull/10728))
+  - fix: deflake: use 2 miners for flaky tests ([filecoin-project/lotus#10764](https://github.com/filecoin-project/lotus/pull/10764))
+  - fix: prover: Propagate skipped sectors in local PoSt
+  - test: eth: deflake multiblock lookup test (#10769) ([filecoin-project/lotus#10769](https://github.com/filecoin-project/lotus/pull/10769))
+  - feat: sync: harden chain sync (#10756) ([filecoin-project/lotus#10756](https://github.com/filecoin-project/lotus/pull/10756))
+  - fix: tvx: make extract-multiple support the FVM ([filecoin-project/lotus#10714](https://github.com/filecoin-project/lotus/pull/10714))
+  - feat: badger: add a has check before writing to reduce duplicates ([filecoin-project/lotus#10680](https://github.com/filecoin-project/lotus/pull/10680))
+  - fix: events: don't set GC confidence to 1 ([filecoin-project/lotus#10713](https://github.com/filecoin-project/lotus/pull/10713))
+  - fix: sync: reduce log from error to info ([filecoin-project/lotus#10759](https://github.com/filecoin-project/lotus/pull/10759))
+  - shed: migrations: add reminder about continuity testing tool ([filecoin-project/lotus#10762](https://github.com/filecoin-project/lotus/pull/10762))
+  - fix: chain: record heaviest tipset before notifying (#10694) ([filecoin-project/lotus#10694](https://github.com/filecoin-project/lotus/pull/10694))
+  - fix: sealing pipeline: Allow nil message in TerminateWait ([filecoin-project/lotus#10696](https://github.com/filecoin-project/lotus/pull/10696))
+  - fix: storage: Remove temp fetching files after failed fetch ([filecoin-project/lotus#10661](https://github.com/filecoin-project/lotus/pull/10661))
+  - feat: daemon: Auto-resume interrupted snapshot imports ([filecoin-project/lotus#10636](https://github.com/filecoin-project/lotus/pull/10636))
+  - feat: shed: refactor market cron-state command ([filecoin-project/lotus#10746](https://github.com/filecoin-project/lotus/pull/10746))
+  - fix: Eth JSON-RPC api: handle messages with gasFeeCap less than baseFee (#10614) ([filecoin-project/lotus#10614](https://github.com/filecoin-project/lotus/pull/10614))
+  - chore: merge releases into master ([filecoin-project/lotus#10742](https://github.com/filecoin-project/lotus/pull/10742))
+  - feat: sync: validate (early) that blocks fall within range (#10691) ([filecoin-project/lotus#10691](https://github.com/filecoin-project/lotus/pull/10691))
+  - chainstore: Fix raw blocks getting scanned for links during snapshots (#10684) ([filecoin-project/lotus#10684](https://github.com/filecoin-project/lotus/pull/10684))
+  - perf: Address performance of EthGetTransactionCount  ([filecoin-project/lotus#10700](https://github.com/filecoin-project/lotus/pull/10700))
+  - feat: sealing: Split PCA/PCB batches if gas used exceeds block limit ([filecoin-project/lotus#10647](https://github.com/filecoin-project/lotus/pull/10647))
+  - fix: remove pointless panic ([filecoin-project/lotus#10690](https://github.com/filecoin-project/lotus/pull/10690))
+  - chore: build: bump matser version to v1.23.1-dev ([filecoin-project/lotus#10709](https://github.com/filecoin-project/lotus/pull/10709))
+  -  chore: boxo: migrate from go-libipfs to boxo ([filecoin-project/lotus#10562](https://github.com/filecoin-project/lotus/pull/10562))
+  - fix: unseal: check if sealed/update sector exists ([filecoin-project/lotus#10639](https://github.com/filecoin-project/lotus/pull/10639))
+  - fix: check for nil bcastDict (#10646) ([filecoin-project/lotus#10646](https://github.com/filecoin-project/lotus/pull/10646))
+  - Add API and CLI to unseal sector (#10626) ([filecoin-project/lotus#10626](https://github.com/filecoin-project/lotus/pull/10626))
+  - test: events: fix race when recording tipsets (#10665) ([filecoin-project/lotus#10665](https://github.com/filecoin-project/lotus/pull/10665))
+  - fix:mpool: prune excess messages before selection ([filecoin-project/lotus#10648](https://github.com/filecoin-project/lotus/pull/10648))
+  - Update config default value (#10605) ([filecoin-project/lotus#10605](https://github.com/filecoin-project/lotus/pull/10605))
+  - fix: cap the message gas limit at the block gas limit (#10637) ([filecoin-project/lotus#10637](https://github.com/filecoin-project/lotus/pull/10637))
+  - fix: build: add CBDeliveryDelay to testground ([filecoin-project/lotus#10613](https://github.com/filecoin-project/lotus/pull/10613))
+  - feat:splitstore:limit moving gc threads ([filecoin-project/lotus#10621](https://github.com/filecoin-project/lotus/pull/10621))
+  - feat: chainstore: optimize BlockMsgsForTipset ([filecoin-project/lotus#10552](https://github.com/filecoin-project/lotus/pull/10552))
+  - fix: make state compute --html work with unknown methods ([filecoin-project/lotus#10619](https://github.com/filecoin-project/lotus/pull/10619))
+  - fix: cli: Check if the sectorID exists before removing ([filecoin-project/lotus#10611](https://github.com/filecoin-project/lotus/pull/10611))
+  - Fixed incorrect words that could not be compiled ([filecoin-project/lotus#10610](https://github.com/filecoin-project/lotus/pull/10610))
+  - Add feature to stagger sector prove commit submission (#10543) ([filecoin-project/lotus#10543](https://github.com/filecoin-project/lotus/pull/10543))
+  - shed: get balances of evm accounts  ([filecoin-project/lotus#10489](https://github.com/filecoin-project/lotus/pull/10489))
+  - chore: deps: update to go-state-types v0.11.0-alpha-3 ([filecoin-project/lotus#10606](https://github.com/filecoin-project/lotus/pull/10606))
+  - fix: cli: Make `net connect` to miner address work ([filecoin-project/lotus#10599](https://github.com/filecoin-project/lotus/pull/10599))
+  - feat: VM Execution Lanes ([filecoin-project/lotus#10551](https://github.com/filecoin-project/lotus/pull/10551))
+  - fix: log: Stop logging `file does not exists` ([filecoin-project/lotus#10588](https://github.com/filecoin-project/lotus/pull/10588))
+  - perf: message pool: change locks to RWMutexes for performance ([filecoin-project/lotus#10561](https://github.com/filecoin-project/lotus/pull/10561))
+  - fix: miner: correctly count sector extensions ([filecoin-project/lotus#10544](https://github.com/filecoin-project/lotus/pull/10544))
+  - feat:networking:  (Synchronous) Consistent Broadcast for Filecoin EC ([filecoin-project/lotus#9858](https://github.com/filecoin-project/lotus/pull/9858))
+  - refactor: stop using deprecated io/ioutil ([filecoin-project/lotus#10596](https://github.com/filecoin-project/lotus/pull/10596))
+  - feat: Use MessageIndex in WaitForMessage ([filecoin-project/lotus#10587](https://github.com/filecoin-project/lotus/pull/10587))
+  - fix: searchForIndexedMsg always returns an error ([filecoin-project/lotus#10586](https://github.com/filecoin-project/lotus/pull/10586))
+  - build: docker: Update GO-version ([filecoin-project/lotus#10581](https://github.com/filecoin-project/lotus/pull/10581))
+  - fix: itests: Don't call t.Error in MineBlocks goroutine ([filecoin-project/lotus#10572](https://github.com/filecoin-project/lotus/pull/10572))
+  - Fix: export-range: Ignore ipld Blocks not found in Receipts. ([filecoin-project/lotus#10535](https://github.com/filecoin-project/lotus/pull/10535))
+  - feat: populate the index on snapshot import ([filecoin-project/lotus#10556](https://github.com/filecoin-project/lotus/pull/10556))
+  - feat: Add small cache to execution traces ([filecoin-project/lotus#10517](https://github.com/filecoin-project/lotus/pull/10517))
+  - docs: api: clarify MpoolClear params ([filecoin-project/lotus#10550](https://github.com/filecoin-project/lotus/pull/10550))
+  - fix: proving: Initialize slice with with same length as partition ([filecoin-project/lotus#10569](https://github.com/filecoin-project/lotus/pull/10569))
+  - perf: eth: gas estimate set applyTsMessages false (#10546) ([filecoin-project/lotus#10546](https://github.com/filecoin-project/lotus/pull/10546))
+  - feat: shed: incoming block-sub chainwatch tool ([filecoin-project/lotus#10513](https://github.com/filecoin-project/lotus/pull/10513))
+  - feat: stmgr: speed up calculation of genesis circ supply ([filecoin-project/lotus#10553](https://github.com/filecoin-project/lotus/pull/10553))
+  - fix: gas estimation: don't special case paych collects ([filecoin-project/lotus#10549](https://github.com/filecoin-project/lotus/pull/10549))
+  - fix: tracer: emit raw peer ids for compatibility with libp2p tracer ([filecoin-project/lotus#10271](https://github.com/filecoin-project/lotus/pull/10271))
+  - fix: state: lotus-miner info should show deals info without admin permission ([filecoin-project/lotus#10323](https://github.com/filecoin-project/lotus/pull/10323))
+  - Merge branch 'feat/new-gw-methods'
+  - chore: bump go-libipfs ([filecoin-project/lotus#10531](https://github.com/filecoin-project/lotus/pull/10531))
+  - feat:chain: Message Index ([filecoin-project/lotus#10452](https://github.com/filecoin-project/lotus/pull/10452))
+
+Contributors
+
+| Contributor | Commits | Lines ± | Files Changed |
+|-------------|---------|---------|---------------|
+| vyzo | 70 | +1990/-429 | 135 |
+| Alfonso de la Rocha | 25 | +814/-299 | 56 |
+| Steven Allen | 14 | +125/-539 | 28 |
+| Shrenuj Bansal | 13 | +482/-138 | 52 |
+| Aayush | 17 | +317/-301 | 90 |
+| Łukasz Magiera | 13 | +564/-26 | 16 |
+| Jennifer Wang | 7 | +401/-140 | 10 |
+| Fridrik Asmundsson | 14 | +315/-84 | 20 |
+| Jorropo | 2 | +139/-137 | 74 |
+| Mikers | 6 | +114/-43 | 14 |
+| Hector Sanjuan | 5 | +92/-44 | 5 |
+| Ales Dumikau | 1 | +117/-0 | 10 |
+| Mike Seiler | 4 | +51/-51 | 6 |
+| zenground0 | 6 | +33/-25 | 8 |
+| Phi | 8 | +32/-10 | 10 |
+| Aayush Rajasekaran | 1 | +1/-32 | 2 |
+| Ian Davis | 2 | +7/-10 | 3 |
+| Marcel Telka | 1 | +5/-7 | 1 |
+| ychiao | 1 | +8/-3 | 2 |
+| jennijuju | 1 | +4/-4 | 8 |
+| adlrocha | 2 | +2/-2 | 2 |
+| Jiaying Wang | 1 | +0/-4 | 1 |
+| ZenGround0 | 1 | +2/-1 | 2 |
+| Zeng Li | 1 | +1/-1 | 1 |

 # v1.23.0 / 2023-04-21

@@ -0,0 +1,273 @@
+##### DEPRECATED
+
+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
+
+ENV XDG_CACHE_HOME="/tmp"
+
+### taken from https://github.com/rust-lang/docker-rust/blob/master/1.63.0/buster/Dockerfile
+ENV RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    PATH=/usr/local/cargo/bin:$PATH \
+    RUST_VERSION=1.63.0
+
+RUN set -eux; \
+    dpkgArch="$(dpkg --print-architecture)"; \
+    case "${dpkgArch##*-}" in \
+        amd64) rustArch='x86_64-unknown-linux-gnu'; rustupSha256='5cc9ffd1026e82e7fb2eec2121ad71f4b0f044e88bca39207b3f6b769aaa799c' ;; \
+        arm64) rustArch='aarch64-unknown-linux-gnu'; rustupSha256='e189948e396d47254103a49c987e7fb0e5dd8e34b200aa4481ecc4b8e41fb929' ;; \
+        *) echo >&2 "unsupported architecture: ${dpkgArch}"; exit 1 ;; \
+    esac; \
+    url="https://static.rust-lang.org/rustup/archive/1.25.1/${rustArch}/rustup-init"; \
+    wget "$url"; \
+    echo "${rustupSha256} *rustup-init" | sha256sum -c -; \
+    chmod +x rustup-init; \
+    ./rustup-init -y --no-modify-path --profile minimal --default-toolchain $RUST_VERSION --default-host ${rustArch}; \
+    rm rustup-init; \
+    chmod -R a+w $RUSTUP_HOME $CARGO_HOME; \
+    rustup --version; \
+    cargo --version; \
+    rustc --version;
+### end rust
+
+FROM builder-deps AS builder-local
+MAINTAINER Lotus Development Team
+
+COPY ./ /opt/filecoin
+WORKDIR /opt/filecoin
+
+### make configurable filecoin-ffi build
+ARG FFI_BUILD_FROM_SOURCE=0
+ENV FFI_BUILD_FROM_SOURCE=${FFI_BUILD_FROM_SOURCE}
+
+RUN make clean deps
+
+
+FROM builder-local AS builder-test
+MAINTAINER Lotus Development Team
+
+WORKDIR /opt/filecoin
+
+RUN make debug
+
+
+FROM builder-local AS builder
+MAINTAINER Lotus Development Team
+
+WORKDIR /opt/filecoin
+
+ARG RUSTFLAGS=""
+ARG GOFLAGS=""
+
+RUN make lotus lotus-miner lotus-worker lotus-shed lotus-wallet lotus-gateway lotus-stats
+
+
+FROM ubuntu:20.04 AS base
+MAINTAINER Lotus Development Team
+
+# Base resources
+COPY --from=builder /etc/ssl/certs                           /etc/ssl/certs
+COPY --from=builder /lib/*/libdl.so.2         /lib/
+COPY --from=builder /lib/*/librt.so.1         /lib/
+COPY --from=builder /lib/*/libgcc_s.so.1      /lib/
+COPY --from=builder /lib/*/libutil.so.1       /lib/
+COPY --from=builder /usr/lib/*/libltdl.so.7   /lib/
+COPY --from=builder /usr/lib/*/libnuma.so.1   /lib/
+COPY --from=builder /usr/lib/*/libhwloc.so.5  /lib/
+COPY --from=builder /usr/lib/*/libOpenCL.so.1 /lib/
+
+RUN useradd -r -u 532 -U fc \
+ && mkdir -p /etc/OpenCL/vendors \
+ && echo "libnvidia-opencl.so.1" > /etc/OpenCL/vendors/nvidia.icd
+
+###
+FROM base AS lotus
+MAINTAINER Lotus Development Team
+
+COPY --from=builder /opt/filecoin/lotus /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-shed /usr/local/bin/
+COPY scripts/docker-lotus-entrypoint.sh /
+
+ENV FILECOIN_PARAMETER_CACHE /var/tmp/filecoin-proof-parameters
+ENV LOTUS_PATH /var/lib/lotus
+ENV DOCKER_LOTUS_IMPORT_SNAPSHOT https://fil-chain-snapshots-fallback.s3.amazonaws.com/mainnet/minimal_finality_stateroots_latest.car
+ENV DOCKER_LOTUS_IMPORT_WALLET ""
+
+RUN mkdir /var/lib/lotus /var/tmp/filecoin-proof-parameters
+RUN chown fc: /var/lib/lotus /var/tmp/filecoin-proof-parameters
+
+VOLUME /var/lib/lotus
+VOLUME /var/tmp/filecoin-proof-parameters
+
+USER fc
+
+EXPOSE 1234
+
+ENTRYPOINT ["/docker-lotus-entrypoint.sh"]
+
+CMD ["-help"]
+
+###
+FROM base AS lotus-wallet
+MAINTAINER Lotus Development Team
+
+COPY --from=builder /opt/filecoin/lotus-wallet /usr/local/bin/
+
+ENV WALLET_PATH /var/lib/lotus-wallet
+
+RUN mkdir /var/lib/lotus-wallet
+RUN chown fc: /var/lib/lotus-wallet
+
+VOLUME /var/lib/lotus-wallet
+
+USER fc
+
+EXPOSE 1777
+
+ENTRYPOINT ["/usr/local/bin/lotus-wallet"]
+
+CMD ["-help"]
+
+###
+FROM base AS lotus-gateway
+MAINTAINER Lotus Development Team
+
+COPY --from=builder /opt/filecoin/lotus-gateway /usr/local/bin/
+
+USER fc
+
+EXPOSE 1234
+
+ENTRYPOINT ["/usr/local/bin/lotus-gateway"]
+
+CMD ["-help"]
+
+
+###
+FROM base AS lotus-miner
+MAINTAINER Lotus Development Team
+
+COPY --from=builder /opt/filecoin/lotus-miner /usr/local/bin/
+COPY scripts/docker-lotus-miner-entrypoint.sh /
+
+ENV FILECOIN_PARAMETER_CACHE /var/tmp/filecoin-proof-parameters
+ENV LOTUS_MINER_PATH /var/lib/lotus-miner
+
+RUN mkdir /var/lib/lotus-miner /var/tmp/filecoin-proof-parameters
+RUN chown fc: /var/lib/lotus-miner /var/tmp/filecoin-proof-parameters
+
+VOLUME /var/lib/lotus-miner
+VOLUME /var/tmp/filecoin-proof-parameters
+
+USER fc
+
+EXPOSE 2345
+
+ENTRYPOINT ["/docker-lotus-miner-entrypoint.sh"]
+
+CMD ["-help"]
+
+
+###
+FROM base AS lotus-worker
+MAINTAINER Lotus Development Team
+
+COPY --from=builder /opt/filecoin/lotus-worker /usr/local/bin/
+
+ENV FILECOIN_PARAMETER_CACHE /var/tmp/filecoin-proof-parameters
+ENV LOTUS_WORKER_PATH /var/lib/lotus-worker
+
+RUN mkdir /var/lib/lotus-worker
+RUN chown fc: /var/lib/lotus-worker
+
+VOLUME /var/lib/lotus-worker
+
+USER fc
+
+EXPOSE 3456
+
+ENTRYPOINT ["/usr/local/bin/lotus-worker"]
+
+CMD ["-help"]
+
+
+###
+from base as lotus-all-in-one
+
+ENV FILECOIN_PARAMETER_CACHE /var/tmp/filecoin-proof-parameters
+ENV LOTUS_MINER_PATH /var/lib/lotus-miner
+ENV LOTUS_PATH /var/lib/lotus
+ENV LOTUS_WORKER_PATH /var/lib/lotus-worker
+ENV WALLET_PATH /var/lib/lotus-wallet
+ENV DOCKER_LOTUS_IMPORT_SNAPSHOT https://fil-chain-snapshots-fallback.s3.amazonaws.com/mainnet/minimal_finality_stateroots_latest.car
+
+COPY --from=builder /opt/filecoin/lotus      /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-shed /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-wallet /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-gateway /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-miner /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-worker /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-stats /usr/local/bin/
+
+RUN mkdir /var/tmp/filecoin-proof-parameters
+RUN mkdir /var/lib/lotus
+RUN mkdir /var/lib/lotus-miner
+RUN mkdir /var/lib/lotus-worker
+RUN mkdir /var/lib/lotus-wallet
+RUN chown fc: /var/tmp/filecoin-proof-parameters
+RUN chown fc: /var/lib/lotus
+RUN chown fc: /var/lib/lotus-miner
+RUN chown fc: /var/lib/lotus-worker
+RUN chown fc: /var/lib/lotus-wallet
+
+
+VOLUME /var/tmp/filecoin-proof-parameters
+VOLUME /var/lib/lotus
+VOLUME /var/lib/lotus-miner
+VOLUME /var/lib/lotus-worker
+VOLUME /var/lib/lotus-wallet
+
+EXPOSE 1234
+EXPOSE 2345
+EXPOSE 3456
+EXPOSE 1777
+
+###
+from base as lotus-test
+
+ENV FILECOIN_PARAMETER_CACHE /var/tmp/filecoin-proof-parameters
+ENV LOTUS_MINER_PATH /var/lib/lotus-miner
+ENV LOTUS_PATH /var/lib/lotus
+ENV LOTUS_WORKER_PATH /var/lib/lotus-worker
+ENV WALLET_PATH /var/lib/lotus-wallet
+
+COPY --from=builder-test /opt/filecoin/lotus      /usr/local/bin/
+COPY --from=builder-test /opt/filecoin/lotus-miner /usr/local/bin/
+COPY --from=builder-test /opt/filecoin/lotus-worker /usr/local/bin/
+COPY --from=builder-test /opt/filecoin/lotus-seed /usr/local/bin/
+
+RUN mkdir /var/tmp/filecoin-proof-parameters
+RUN mkdir /var/lib/lotus
+RUN mkdir /var/lib/lotus-miner
+RUN mkdir /var/lib/lotus-worker
+RUN mkdir /var/lib/lotus-wallet
+RUN chown fc: /var/tmp/filecoin-proof-parameters
+RUN chown fc: /var/lib/lotus
+RUN chown fc: /var/lib/lotus-miner
+RUN chown fc: /var/lib/lotus-worker
+RUN chown fc: /var/lib/lotus-wallet
+
+
+VOLUME /var/tmp/filecoin-proof-parameters
+VOLUME /var/lib/lotus
+VOLUME /var/lib/lotus-miner
+VOLUME /var/lib/lotus-worker
+VOLUME /var/lib/lotus-wallet
+
+EXPOSE 1234
+EXPOSE 2345
+EXPOSE 3456
+EXPOSE 1777
+
@@ -355,7 +355,7 @@ fiximports:
 	./scripts/fiximports

 gen: actors-code-gen type-gen cfgdoc-gen docsgen api-gen circleci fiximports
-	@echo ">>> IF YOU'VE MODIFIED THE CLI OR CONFIG, REMEMBER TO ALSO RUN 'make docsgen-cli'"
+	@echo ">>> IF YOU'VE MODIFIED THE CLI OR CONFIG, REMEMBER TO ALSO MAKE docsgen-cli"
 .PHONY: gen

 jen: gen
@@ -812,7 +812,6 @@ type FullNode interface {
 	EthGetStorageAt(ctx context.Context, address ethtypes.EthAddress, position ethtypes.EthBytes, blkParam string) (ethtypes.EthBytes, error) //perm:read
 	EthGetBalance(ctx context.Context, address ethtypes.EthAddress, blkParam string) (ethtypes.EthBigInt, error)                              //perm:read
 	EthChainId(ctx context.Context) (ethtypes.EthUint64, error)                                                                               //perm:read
-	EthSyncing(ctx context.Context) (ethtypes.EthSyncingResult, error)                                                                        //perm:read
 	NetVersion(ctx context.Context) (string, error)                                                                                           //perm:read
 	NetListening(ctx context.Context) (bool, error)                                                                                           //perm:read
 	EthProtocolVersion(ctx context.Context) (ethtypes.EthUint64, error)                                                                       //perm:read
@@ -830,23 +829,23 @@ type FullNode interface {

 	// Polling method for a filter, returns event logs which occurred since last poll.
 	// (requires write perm since timestamp of last filter execution will be written)
-	EthGetFilterChanges(ctx context.Context, id ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) //perm:read
+	EthGetFilterChanges(ctx context.Context, id ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) //perm:write

 	// Returns event logs matching filter with given id.
 	// (requires write perm since timestamp of last filter execution will be written)
-	EthGetFilterLogs(ctx context.Context, id ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) //perm:read
+	EthGetFilterLogs(ctx context.Context, id ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) //perm:write

 	// Installs a persistent filter based on given filter spec.
-	EthNewFilter(ctx context.Context, filter *ethtypes.EthFilterSpec) (ethtypes.EthFilterID, error) //perm:read
+	EthNewFilter(ctx context.Context, filter *ethtypes.EthFilterSpec) (ethtypes.EthFilterID, error) //perm:write

 	// Installs a persistent filter to notify when a new block arrives.
-	EthNewBlockFilter(ctx context.Context) (ethtypes.EthFilterID, error) //perm:read
+	EthNewBlockFilter(ctx context.Context) (ethtypes.EthFilterID, error) //perm:write

 	// Installs a persistent filter to notify when new messages arrive in the message pool.
-	EthNewPendingTransactionFilter(ctx context.Context) (ethtypes.EthFilterID, error) //perm:read
+	EthNewPendingTransactionFilter(ctx context.Context) (ethtypes.EthFilterID, error) //perm:write

 	// Uninstalls a filter with given id.
-	EthUninstallFilter(ctx context.Context, id ethtypes.EthFilterID) (bool, error) //perm:read
+	EthUninstallFilter(ctx context.Context, id ethtypes.EthFilterID) (bool, error) //perm:write

 	// Subscribe to different event types using websockets
 	// eventTypes is one or more of:
@@ -855,10 +854,10 @@ type FullNode interface {
 	//  - logs: notify new event logs that match a criteria
 	// params contains additional parameters used with the log event type
 	// The client will receive a stream of EthSubscriptionResponse values until EthUnsubscribe is called.
-	EthSubscribe(ctx context.Context, params jsonrpc.RawParams) (ethtypes.EthSubscriptionID, error) //perm:read
+	EthSubscribe(ctx context.Context, params jsonrpc.RawParams) (ethtypes.EthSubscriptionID, error) //perm:write

 	// Unsubscribe from a websocket subscription
-	EthUnsubscribe(ctx context.Context, id ethtypes.EthSubscriptionID) (bool, error) //perm:read
+	EthUnsubscribe(ctx context.Context, id ethtypes.EthSubscriptionID) (bool, error) //perm:write

 	// Returns the client version
 	Web3ClientVersion(ctx context.Context) (string, error) //perm:read
@@ -33,9 +33,6 @@ import (
 //  * Generate openrpc blobs

 type Gateway interface {
-	MpoolPending(context.Context, types.TipSetKey) ([]*types.SignedMessage, error)
-	ChainGetBlock(context.Context, cid.Cid) (*types.BlockHeader, error)
-	MinerGetBaseInfo(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*MiningBaseInfo, error)
 	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)
@@ -101,7 +98,6 @@ type Gateway interface {
 	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)
 	EthChainId(ctx context.Context) (ethtypes.EthUint64, error)
-	EthSyncing(ctx context.Context) (ethtypes.EthSyncingResult, error)
 	NetVersion(ctx context.Context) (string, error)
 	NetListening(ctx context.Context) (bool, error)
 	EthProtocolVersion(ctx context.Context) (ethtypes.EthUint64, error)
@@ -73,5 +73,5 @@ type CommonNet interface {

 type NatInfo struct {
 	Reachability network.Reachability
-	PublicAddrs  []string
+	PublicAddr   string
 }
@@ -86,7 +86,6 @@ func init() {
 	}

 	ExampleValues[reflect.TypeOf(addr)] = addr
-	ExampleValues[reflect.TypeOf(&addr)] = &addr

 	pid, err := peer.Decode("12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf")
 	if err != nil {
@@ -21,7 +21,6 @@ func CreateEthRPCAliases(as apitypes.Aliaser) {
 	as.AliasMethod("eth_getStorageAt", "Filecoin.EthGetStorageAt")
 	as.AliasMethod("eth_getBalance", "Filecoin.EthGetBalance")
 	as.AliasMethod("eth_chainId", "Filecoin.EthChainId")
-	as.AliasMethod("eth_syncing", "Filecoin.EthSyncing")
 	as.AliasMethod("eth_feeHistory", "Filecoin.EthFeeHistory")
 	as.AliasMethod("eth_protocolVersion", "Filecoin.EthProtocolVersion")
 	as.AliasMethod("eth_maxPriorityFeePerGas", "Filecoin.EthMaxPriorityFeePerGas")
@@ -1476,21 +1476,6 @@ func (mr *MockFullNodeMockRecorder) EthSubscribe(arg0, arg1 interface{}) *gomock
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EthSubscribe", reflect.TypeOf((*MockFullNode)(nil).EthSubscribe), arg0, arg1)
 }

-// EthSyncing mocks base method.
-func (m *MockFullNode) EthSyncing(arg0 context.Context) (ethtypes.EthSyncingResult, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "EthSyncing", arg0)
-	ret0, _ := ret[0].(ethtypes.EthSyncingResult)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// EthSyncing indicates an expected call of EthSyncing.
-func (mr *MockFullNodeMockRecorder) EthSyncing(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EthSyncing", reflect.TypeOf((*MockFullNode)(nil).EthSyncing), arg0)
-}
-
 // EthUninstallFilter mocks base method.
 func (m *MockFullNode) EthUninstallFilter(arg0 context.Context, arg1 ethtypes.EthFilterID) (bool, error) {
 	m.ctrl.T.Helper()
@@ -274,9 +274,9 @@ type FullNodeMethods struct {

 	EthGetCode func(p0 context.Context, p1 ethtypes.EthAddress, p2 string) (ethtypes.EthBytes, error) `perm:"read"`

-	EthGetFilterChanges func(p0 context.Context, p1 ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) `perm:"read"`
+	EthGetFilterChanges func(p0 context.Context, p1 ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) `perm:"write"`

-	EthGetFilterLogs func(p0 context.Context, p1 ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) `perm:"read"`
+	EthGetFilterLogs func(p0 context.Context, p1 ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) `perm:"write"`

 	EthGetLogs func(p0 context.Context, p1 *ethtypes.EthFilterSpec) (*ethtypes.EthFilterResult, error) `perm:"read"`

@@ -302,23 +302,21 @@ type FullNodeMethods struct {

 	EthMaxPriorityFeePerGas func(p0 context.Context) (ethtypes.EthBigInt, error) `perm:"read"`

-	EthNewBlockFilter func(p0 context.Context) (ethtypes.EthFilterID, error) `perm:"read"`
+	EthNewBlockFilter func(p0 context.Context) (ethtypes.EthFilterID, error) `perm:"write"`

-	EthNewFilter func(p0 context.Context, p1 *ethtypes.EthFilterSpec) (ethtypes.EthFilterID, error) `perm:"read"`
+	EthNewFilter func(p0 context.Context, p1 *ethtypes.EthFilterSpec) (ethtypes.EthFilterID, error) `perm:"write"`

-	EthNewPendingTransactionFilter func(p0 context.Context) (ethtypes.EthFilterID, error) `perm:"read"`
+	EthNewPendingTransactionFilter func(p0 context.Context) (ethtypes.EthFilterID, error) `perm:"write"`

 	EthProtocolVersion func(p0 context.Context) (ethtypes.EthUint64, error) `perm:"read"`

 	EthSendRawTransaction func(p0 context.Context, p1 ethtypes.EthBytes) (ethtypes.EthHash, error) `perm:"read"`

-	EthSubscribe func(p0 context.Context, p1 jsonrpc.RawParams) (ethtypes.EthSubscriptionID, error) `perm:"read"`
+	EthSubscribe func(p0 context.Context, p1 jsonrpc.RawParams) (ethtypes.EthSubscriptionID, error) `perm:"write"`

-	EthSyncing func(p0 context.Context) (ethtypes.EthSyncingResult, error) `perm:"read"`
+	EthUninstallFilter func(p0 context.Context, p1 ethtypes.EthFilterID) (bool, error) `perm:"write"`

-	EthUninstallFilter func(p0 context.Context, p1 ethtypes.EthFilterID) (bool, error) `perm:"read"`
-
-	EthUnsubscribe func(p0 context.Context, p1 ethtypes.EthSubscriptionID) (bool, error) `perm:"read"`
+	EthUnsubscribe func(p0 context.Context, p1 ethtypes.EthSubscriptionID) (bool, error) `perm:"write"`

 	FilecoinAddressToEthAddress func(p0 context.Context, p1 address.Address) (ethtypes.EthAddress, error) `perm:"read"`

@@ -632,8 +630,6 @@ type GatewayStruct struct {
 }

 type GatewayMethods struct {
-	ChainGetBlock func(p0 context.Context, p1 cid.Cid) (*types.BlockHeader, error) ``
-
 	ChainGetBlockMessages func(p0 context.Context, p1 cid.Cid) (*BlockMessages, error) ``

 	ChainGetGenesis func(p0 context.Context) (*types.TipSet, error) ``
@@ -726,8 +722,6 @@ type GatewayMethods struct {

 	EthSubscribe func(p0 context.Context, p1 jsonrpc.RawParams) (ethtypes.EthSubscriptionID, error) ``

-	EthSyncing func(p0 context.Context) (ethtypes.EthSyncingResult, error) ``
-
 	EthUninstallFilter func(p0 context.Context, p1 ethtypes.EthFilterID) (bool, error) ``

 	EthUnsubscribe func(p0 context.Context, p1 ethtypes.EthSubscriptionID) (bool, error) ``
@@ -736,12 +730,8 @@ type GatewayMethods struct {

 	GasEstimateMessageGas func(p0 context.Context, p1 *types.Message, p2 *MessageSendSpec, p3 types.TipSetKey) (*types.Message, error) ``

-	MinerGetBaseInfo func(p0 context.Context, p1 address.Address, p2 abi.ChainEpoch, p3 types.TipSetKey) (*MiningBaseInfo, error) ``
-
 	MpoolGetNonce func(p0 context.Context, p1 address.Address) (uint64, error) ``

-	MpoolPending func(p0 context.Context, p1 types.TipSetKey) ([]*types.SignedMessage, error) ``
-
 	MpoolPush func(p0 context.Context, p1 *types.SignedMessage) (cid.Cid, error) ``

 	MsigGetAvailableBalance func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (types.BigInt, error) ``
@@ -2432,17 +2422,6 @@ func (s *FullNodeStub) EthSubscribe(p0 context.Context, p1 jsonrpc.RawParams) (e
 	return *new(ethtypes.EthSubscriptionID), ErrNotSupported
 }

-func (s *FullNodeStruct) EthSyncing(p0 context.Context) (ethtypes.EthSyncingResult, error) {
-	if s.Internal.EthSyncing == nil {
-		return *new(ethtypes.EthSyncingResult), ErrNotSupported
-	}
-	return s.Internal.EthSyncing(p0)
-}
-
-func (s *FullNodeStub) EthSyncing(p0 context.Context) (ethtypes.EthSyncingResult, error) {
-	return *new(ethtypes.EthSyncingResult), ErrNotSupported
-}
-
 func (s *FullNodeStruct) EthUninstallFilter(p0 context.Context, p1 ethtypes.EthFilterID) (bool, error) {
 	if s.Internal.EthUninstallFilter == nil {
 		return false, ErrNotSupported
@@ -4115,17 +4094,6 @@ func (s *FullNodeStub) Web3ClientVersion(p0 context.Context) (string, error) {
 	return "", ErrNotSupported
 }

-func (s *GatewayStruct) ChainGetBlock(p0 context.Context, p1 cid.Cid) (*types.BlockHeader, error) {
-	if s.Internal.ChainGetBlock == nil {
-		return nil, ErrNotSupported
-	}
-	return s.Internal.ChainGetBlock(p0, p1)
-}
-
-func (s *GatewayStub) ChainGetBlock(p0 context.Context, p1 cid.Cid) (*types.BlockHeader, error) {
-	return nil, ErrNotSupported
-}
-
 func (s *GatewayStruct) ChainGetBlockMessages(p0 context.Context, p1 cid.Cid) (*BlockMessages, error) {
 	if s.Internal.ChainGetBlockMessages == nil {
 		return nil, ErrNotSupported
@@ -4632,17 +4600,6 @@ func (s *GatewayStub) EthSubscribe(p0 context.Context, p1 jsonrpc.RawParams) (et
 	return *new(ethtypes.EthSubscriptionID), ErrNotSupported
 }

-func (s *GatewayStruct) EthSyncing(p0 context.Context) (ethtypes.EthSyncingResult, error) {
-	if s.Internal.EthSyncing == nil {
-		return *new(ethtypes.EthSyncingResult), ErrNotSupported
-	}
-	return s.Internal.EthSyncing(p0)
-}
-
-func (s *GatewayStub) EthSyncing(p0 context.Context) (ethtypes.EthSyncingResult, error) {
-	return *new(ethtypes.EthSyncingResult), ErrNotSupported
-}
-
 func (s *GatewayStruct) EthUninstallFilter(p0 context.Context, p1 ethtypes.EthFilterID) (bool, error) {
 	if s.Internal.EthUninstallFilter == nil {
 		return false, ErrNotSupported
@@ -4687,17 +4644,6 @@ func (s *GatewayStub) GasEstimateMessageGas(p0 context.Context, p1 *types.Messag
 	return nil, ErrNotSupported
 }

-func (s *GatewayStruct) MinerGetBaseInfo(p0 context.Context, p1 address.Address, p2 abi.ChainEpoch, p3 types.TipSetKey) (*MiningBaseInfo, error) {
-	if s.Internal.MinerGetBaseInfo == nil {
-		return nil, ErrNotSupported
-	}
-	return s.Internal.MinerGetBaseInfo(p0, p1, p2, p3)
-}
-
-func (s *GatewayStub) MinerGetBaseInfo(p0 context.Context, p1 address.Address, p2 abi.ChainEpoch, p3 types.TipSetKey) (*MiningBaseInfo, error) {
-	return nil, ErrNotSupported
-}
-
 func (s *GatewayStruct) MpoolGetNonce(p0 context.Context, p1 address.Address) (uint64, error) {
 	if s.Internal.MpoolGetNonce == nil {
 		return 0, ErrNotSupported
@@ -4709,17 +4655,6 @@ func (s *GatewayStub) MpoolGetNonce(p0 context.Context, p1 address.Address) (uin
 	return 0, ErrNotSupported
 }

-func (s *GatewayStruct) MpoolPending(p0 context.Context, p1 types.TipSetKey) ([]*types.SignedMessage, error) {
-	if s.Internal.MpoolPending == nil {
-		return *new([]*types.SignedMessage), ErrNotSupported
-	}
-	return s.Internal.MpoolPending(p0, p1)
-}
-
-func (s *GatewayStub) MpoolPending(p0 context.Context, p1 types.TipSetKey) ([]*types.SignedMessage, error) {
-	return *new([]*types.SignedMessage), ErrNotSupported
-}
-
 func (s *GatewayStruct) MpoolPush(p0 context.Context, p1 *types.SignedMessage) (cid.Cid, error) {
 	if s.Internal.MpoolPush == nil {
 		return *new(cid.Cid), ErrNotSupported
@@ -299,7 +299,6 @@ type MinerInfo struct {
 	SectorSize                 abi.SectorSize
 	WindowPoStPartitionSectors uint64
 	ConsensusFaultElapsed      abi.ChainEpoch
-	PendingOwnerAddress        *address.Address
 	Beneficiary                address.Address
 	BeneficiaryTerm            *miner.BeneficiaryTerm
 	PendingBeneficiaryTerm     *miner.PendingBeneficiaryChange
@@ -315,30 +314,31 @@ type NetworkParams struct {
 }

 type ForkUpgradeParams struct {
-	UpgradeSmokeHeight       abi.ChainEpoch
-	UpgradeBreezeHeight      abi.ChainEpoch
-	UpgradeIgnitionHeight    abi.ChainEpoch
-	UpgradeLiftoffHeight     abi.ChainEpoch
-	UpgradeAssemblyHeight    abi.ChainEpoch
-	UpgradeRefuelHeight      abi.ChainEpoch
-	UpgradeTapeHeight        abi.ChainEpoch
-	UpgradeKumquatHeight     abi.ChainEpoch
-	BreezeGasTampingDuration abi.ChainEpoch
-	UpgradeCalicoHeight      abi.ChainEpoch
-	UpgradePersianHeight     abi.ChainEpoch
-	UpgradeOrangeHeight      abi.ChainEpoch
-	UpgradeClausHeight       abi.ChainEpoch
-	UpgradeTrustHeight       abi.ChainEpoch
-	UpgradeNorwegianHeight   abi.ChainEpoch
-	UpgradeTurboHeight       abi.ChainEpoch
-	UpgradeHyperdriveHeight  abi.ChainEpoch
-	UpgradeChocolateHeight   abi.ChainEpoch
-	UpgradeOhSnapHeight      abi.ChainEpoch
-	UpgradeSkyrHeight        abi.ChainEpoch
-	UpgradeSharkHeight       abi.ChainEpoch
-	UpgradeHyggeHeight       abi.ChainEpoch
-	UpgradeLightningHeight   abi.ChainEpoch
-	UpgradeThunderHeight     abi.ChainEpoch
+	UpgradeSmokeHeight         abi.ChainEpoch
+	UpgradeBreezeHeight        abi.ChainEpoch
+	UpgradeIgnitionHeight      abi.ChainEpoch
+	UpgradeLiftoffHeight       abi.ChainEpoch
+	UpgradeAssemblyHeight      abi.ChainEpoch
+	UpgradeRefuelHeight        abi.ChainEpoch
+	UpgradeTapeHeight          abi.ChainEpoch
+	UpgradeKumquatHeight       abi.ChainEpoch
+	UpgradePriceListOopsHeight abi.ChainEpoch
+	BreezeGasTampingDuration   abi.ChainEpoch
+	UpgradeCalicoHeight        abi.ChainEpoch
+	UpgradePersianHeight       abi.ChainEpoch
+	UpgradeOrangeHeight        abi.ChainEpoch
+	UpgradeClausHeight         abi.ChainEpoch
+	UpgradeTrustHeight         abi.ChainEpoch
+	UpgradeNorwegianHeight     abi.ChainEpoch
+	UpgradeTurboHeight         abi.ChainEpoch
+	UpgradeHyperdriveHeight    abi.ChainEpoch
+	UpgradeChocolateHeight     abi.ChainEpoch
+	UpgradeOhSnapHeight        abi.ChainEpoch
+	UpgradeSkyrHeight          abi.ChainEpoch
+	UpgradeSharkHeight         abi.ChainEpoch
+	UpgradeHyggeHeight         abi.ChainEpoch
+	UpgradeLightningHeight     abi.ChainEpoch
+	UpgradeThunderHeight       abi.ChainEpoch
 }

 type NonceMapType map[address.Address]uint64
@@ -35,9 +35,6 @@ import (
 //  * Generate openrpc blobs

 type Gateway interface {
-	MpoolPending(context.Context, types.TipSetKey) ([]*types.SignedMessage, error)
-	ChainGetBlock(context.Context, cid.Cid) (*types.BlockHeader, error)
-	MinerGetBaseInfo(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*api.MiningBaseInfo, error)
 	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)
@@ -431,8 +431,6 @@ type GatewayStruct struct {
 }

 type GatewayMethods struct {
-	ChainGetBlock func(p0 context.Context, p1 cid.Cid) (*types.BlockHeader, error) ``
-
 	ChainGetBlockMessages func(p0 context.Context, p1 cid.Cid) (*api.BlockMessages, error) ``

 	ChainGetMessage func(p0 context.Context, p1 cid.Cid) (*types.Message, error) ``
@@ -455,12 +453,8 @@ type GatewayMethods struct {

 	GasEstimateMessageGas func(p0 context.Context, p1 *types.Message, p2 *api.MessageSendSpec, p3 types.TipSetKey) (*types.Message, error) ``

-	MinerGetBaseInfo func(p0 context.Context, p1 address.Address, p2 abi.ChainEpoch, p3 types.TipSetKey) (*api.MiningBaseInfo, error) ``
-
 	MpoolGetNonce func(p0 context.Context, p1 address.Address) (uint64, error) ``

-	MpoolPending func(p0 context.Context, p1 types.TipSetKey) ([]*types.SignedMessage, error) ``
-
 	MpoolPush func(p0 context.Context, p1 *types.SignedMessage) (cid.Cid, error) ``

 	MsigGetAvailableBalance func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (types.BigInt, error) ``
@@ -2587,17 +2581,6 @@ func (s *FullNodeStub) WalletVerify(p0 context.Context, p1 address.Address, p2 [
 	return false, ErrNotSupported
 }

-func (s *GatewayStruct) ChainGetBlock(p0 context.Context, p1 cid.Cid) (*types.BlockHeader, error) {
-	if s.Internal.ChainGetBlock == nil {
-		return nil, ErrNotSupported
-	}
-	return s.Internal.ChainGetBlock(p0, p1)
-}
-
-func (s *GatewayStub) ChainGetBlock(p0 context.Context, p1 cid.Cid) (*types.BlockHeader, error) {
-	return nil, ErrNotSupported
-}
-
 func (s *GatewayStruct) ChainGetBlockMessages(p0 context.Context, p1 cid.Cid) (*api.BlockMessages, error) {
 	if s.Internal.ChainGetBlockMessages == nil {
 		return nil, ErrNotSupported
@@ -2719,17 +2702,6 @@ func (s *GatewayStub) GasEstimateMessageGas(p0 context.Context, p1 *types.Messag
 	return nil, ErrNotSupported
 }

-func (s *GatewayStruct) MinerGetBaseInfo(p0 context.Context, p1 address.Address, p2 abi.ChainEpoch, p3 types.TipSetKey) (*api.MiningBaseInfo, error) {
-	if s.Internal.MinerGetBaseInfo == nil {
-		return nil, ErrNotSupported
-	}
-	return s.Internal.MinerGetBaseInfo(p0, p1, p2, p3)
-}
-
-func (s *GatewayStub) MinerGetBaseInfo(p0 context.Context, p1 address.Address, p2 abi.ChainEpoch, p3 types.TipSetKey) (*api.MiningBaseInfo, error) {
-	return nil, ErrNotSupported
-}
-
 func (s *GatewayStruct) MpoolGetNonce(p0 context.Context, p1 address.Address) (uint64, error) {
 	if s.Internal.MpoolGetNonce == nil {
 		return 0, ErrNotSupported
@@ -2741,17 +2713,6 @@ func (s *GatewayStub) MpoolGetNonce(p0 context.Context, p1 address.Address) (uin
 	return 0, ErrNotSupported
 }

-func (s *GatewayStruct) MpoolPending(p0 context.Context, p1 types.TipSetKey) ([]*types.SignedMessage, error) {
-	if s.Internal.MpoolPending == nil {
-		return *new([]*types.SignedMessage), ErrNotSupported
-	}
-	return s.Internal.MpoolPending(p0, p1)
-}
-
-func (s *GatewayStub) MpoolPending(p0 context.Context, p1 types.TipSetKey) ([]*types.SignedMessage, error) {
-	return *new([]*types.SignedMessage), ErrNotSupported
-}
-
 func (s *GatewayStruct) MpoolPush(p0 context.Context, p1 *types.SignedMessage) (cid.Cid, error) {
 	if s.Internal.MpoolPush == nil {
 		return *new(cid.Cid), ErrNotSupported
@@ -660,60 +660,6 @@ func (b *Blockstore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
 	}
 }

-// GetMany implements a GetMany method for the badgerDB blockstore
-// This method returns empty slices and an error if an error other than ErrKeyNotFound is encountered
-// For every ErrKeyNotFound, the missing CID is returned but the rest of the results are returned without error
-func (b *Blockstore) GetMany(ctx context.Context, cids []cid.Cid) ([]blocks.Block, []cid.Cid, error) {
-	if err := b.access(); err != nil {
-		return nil, nil, err
-	}
-	defer b.viewers.Done()
-
-	b.lockDB()
-	defer b.unlockDB()
-
-	blks := make([]blocks.Block, 0, len(cids))
-	missingCids := make([]cid.Cid, 0, len(cids))
-	err := b.db.View(func(txn *badger.Txn) error {
-		f := func(c cid.Cid) error { // encapsulate in an anonymous function to handle key pool deferral for each key
-			if !c.Defined() {
-				return ipld.ErrNotFound{Cid: c}
-			}
-			k, pooled := b.PooledStorageKey(c)
-			if pooled {
-				defer KeyPool.Put(k)
-			}
-			switch item, err := txn.Get(k); err {
-			case nil:
-				val, err := item.ValueCopy(nil)
-				if err != nil {
-					return err
-				}
-				blk, err := blocks.NewBlockWithCid(val, c)
-				if err != nil {
-					return err
-				}
-				blks = append(blks, blk)
-			case badger.ErrKeyNotFound:
-				missingCids = append(missingCids, c)
-			default:
-				return fmt.Errorf("failed to get block from badger blockstore: %w", err)
-			}
-			return nil
-		}
-		for _, c := range cids {
-			if err := f(c); err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, nil, err
-	}
-	return blks, missingCids, nil
-}
-
 // Get implements Blockstore.Get.
 func (b *Blockstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) {
 	if !cid.Defined() {
@@ -164,7 +164,7 @@ type SplitStore struct {
 	path string

 	mx          sync.Mutex
-	warmupEpoch atomic.Int64
+	warmupEpoch abi.ChainEpoch // protected by mx
 	baseEpoch   abi.ChainEpoch // protected by compaction lock
 	pruneEpoch  abi.ChainEpoch // protected by compaction lock

@@ -684,7 +684,9 @@ func (s *SplitStore) View(ctx context.Context, cid cid.Cid, cb func([]byte) erro
 }

 func (s *SplitStore) isWarm() bool {
-	return s.warmupEpoch.Load() > 0
+	s.mx.Lock()
+	defer s.mx.Unlock()
+	return s.warmupEpoch > 0
 }

 // State tracking
@@ -755,7 +757,7 @@ func (s *SplitStore) Start(chain ChainAccessor, us stmgr.UpgradeSchedule) error
 	bs, err = s.ds.Get(s.ctx, warmupEpochKey)
 	switch err {
 	case nil:
-		s.warmupEpoch.Store(bytesToInt64(bs))
+		s.warmupEpoch = bytesToEpoch(bs)

 	case dstore.ErrNotFound:
 		warmup = true
@@ -789,7 +791,7 @@ func (s *SplitStore) Start(chain ChainAccessor, us stmgr.UpgradeSchedule) error
 		return xerrors.Errorf("error loading compaction index: %w", err)
 	}

-	log.Infow("starting splitstore", "baseEpoch", s.baseEpoch, "warmupEpoch", s.warmupEpoch.Load())
+	log.Infow("starting splitstore", "baseEpoch", s.baseEpoch, "warmupEpoch", s.warmupEpoch)

 	if warmup {
 		err = s.warmup(curTs)
@@ -145,7 +145,7 @@ func (s *SplitStore) doCheck(curTs *types.TipSet) error {
 func (s *SplitStore) Info() map[string]interface{} {
 	info := make(map[string]interface{})
 	info["base epoch"] = s.baseEpoch
-	info["warmup epoch"] = s.warmupEpoch.Load()
+	info["warmup epoch"] = s.warmupEpoch
 	info["compactions"] = s.compactionIndex
 	info["prunes"] = s.pruneIndex
 	info["compacting"] = s.compacting == 1
@@ -1114,17 +1114,13 @@ func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEp
 					if err := walkBlock(c); err != nil {
 						return xerrors.Errorf("error walking block (cid: %s): %w", c, err)
 					}
-
-					if err := s.checkYield(); err != nil {
-						return xerrors.Errorf("check yield: %w", err)
-					}
 				}
 				return nil
 			})
 		}

 		if err := g.Wait(); err != nil {
-			return xerrors.Errorf("walkBlock workers errored: %w", err)
+			return err
 		}
 	}

@@ -1157,8 +1153,8 @@ func (s *SplitStore) walkObject(c cid.Cid, visitor ObjectVisitor, f func(cid.Cid
 	}

 	// check this before recursing
-	if err := s.checkClosing(); err != nil {
-		return 0, xerrors.Errorf("check closing: %w", err)
+	if err := s.checkYield(); err != nil {
+		return 0, err
 	}

 	var links []cid.Cid
@@ -1226,8 +1222,8 @@ func (s *SplitStore) walkObjectIncomplete(c cid.Cid, visitor ObjectVisitor, f, m
 	}

 	// check this before recursing
-	if err := s.checkClosing(); err != nil {
-		return sz, xerrors.Errorf("check closing: %w", err)
+	if err := s.checkYield(); err != nil {
+		return sz, err
 	}

 	var links []cid.Cid
@@ -429,7 +429,7 @@ func testSplitStoreReification(t *testing.T, f func(context.Context, blockstore.
 	}
 	defer ss.Close() //nolint

-	ss.warmupEpoch.Store(1)
+	ss.warmupEpoch = 1
 	go ss.reifyOrchestrator()

 	waitForReification := func() {
@@ -529,7 +529,7 @@ func testSplitStoreReificationLimit(t *testing.T, f func(context.Context, blocks
 	}
 	defer ss.Close() //nolint

-	ss.warmupEpoch.Store(1)
+	ss.warmupEpoch = 1
 	go ss.reifyOrchestrator()

 	waitForReification := func() {
@@ -136,8 +136,9 @@ func (s *SplitStore) doWarmup(curTs *types.TipSet) error {
 	if err != nil {
 		return xerrors.Errorf("error saving warm up epoch: %w", err)
 	}
-
-	s.warmupEpoch.Store(int64(epoch))
+	s.mx.Lock()
+	s.warmupEpoch = epoch
+	s.mx.Unlock()

 	// also save the compactionIndex, as this is used as an indicator of warmup for upgraded nodes
 	err = s.ds.Put(s.ctx, compactionIndexKey, int64ToBytes(s.compactionIndex))
@@ -49,11 +49,16 @@ var UpgradeHyperdriveHeight = abi.ChainEpoch(-16)
 var UpgradeChocolateHeight = abi.ChainEpoch(-17)
 var UpgradeOhSnapHeight = abi.ChainEpoch(-18)
 var UpgradeSkyrHeight = abi.ChainEpoch(-19)
-var UpgradeSharkHeight = abi.ChainEpoch(-20)
-var UpgradeHyggeHeight = abi.ChainEpoch(-21)
-var UpgradeLightningHeight = abi.ChainEpoch(-22)

-const UpgradeThunderHeight = 50
+const UpgradeSharkHeight = abi.ChainEpoch(-20)
+
+const UpgradeHyggeHeight = abi.ChainEpoch(100)
+
+// ??????????
+const UpgradeLightningHeight = 200
+
+// ??????????????????
+const UpgradeThunderHeight = 300

 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0: DrandMainnet,
@@ -37,7 +37,7 @@ func BuildTypeString() string {
 }

 // BuildVersion is the local build version
-const BuildVersion = "1.23.2-dev"
+const BuildVersion = "1.23.1"

 func UserVersion() string {
 	if os.Getenv("LOTUS_VERSION_IGNORE_COMMIT") == "1" {
@@ -61,10 +61,6 @@ const (
 	MaxPreCommitRandomnessLookback = builtin11.EpochsInDay + SealRandomnessLookback
 )

-var (
-	MarketDefaultAllocationTermBuffer = market11.MarketDefaultAllocationTermBuffer
-)
-
 // SetSupportedProofTypes sets supported proof types, across all actor versions.
 // This should only be used for testing.
 func SetSupportedProofTypes(types ...abi.RegisteredSealProof) {
@@ -39,10 +39,6 @@ const (
 	MaxPreCommitRandomnessLookback = builtin{{.latestVersion}}.EpochsInDay + SealRandomnessLookback
 )

-var (
-	MarketDefaultAllocationTermBuffer = market{{.latestVersion}}.MarketDefaultAllocationTermBuffer
-)
-
 // SetSupportedProofTypes sets supported proof types, across all actor versions.
 // This should only be used for testing.
 func SetSupportedProofTypes(types ...abi.RegisteredSealProof) {
@@ -125,7 +125,7 @@ func (o *observer) listenHeadChangesOnce(ctx context.Context) error {

 	for changes := range notifs {
 		if err := o.applyChanges(ctx, changes); err != nil {
-			return xerrors.Errorf("failed to apply a change notification: %w", err)
+			return err
 		}
 	}

@@ -11,6 +11,7 @@ import (

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

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

@@ -26,20 +27,24 @@ func New(dstore ds.Batching) *SlashFilter {
 	}
 }

-func (f *SlashFilter) MinedBlock(ctx context.Context, bh *types.BlockHeader, parentEpoch abi.ChainEpoch) (cid.Cid, error) {
+func (f *SlashFilter) MinedBlock(ctx context.Context, bh *types.BlockHeader, parentEpoch abi.ChainEpoch) error {
+	if build.IsNearUpgrade(bh.Height, build.UpgradeOrangeHeight) {
+		return nil
+	}
+
 	epochKey := ds.NewKey(fmt.Sprintf("/%s/%d", bh.Miner, bh.Height))
 	{
 		// double-fork mining (2 blocks at one epoch)
-		if witness, err := checkFault(ctx, f.byEpoch, epochKey, bh, "double-fork mining faults"); err != nil {
-			return witness, xerrors.Errorf("check double-fork mining faults: %w", err)
+		if err := checkFault(ctx, f.byEpoch, epochKey, bh, "double-fork mining faults"); err != nil {
+			return err
 		}
 	}

 	parentsKey := ds.NewKey(fmt.Sprintf("/%s/%x", bh.Miner, types.NewTipSetKey(bh.Parents...).Bytes()))
 	{
 		// time-offset mining faults (2 blocks with the same parents)
-		if witness, err := checkFault(ctx, f.byParents, parentsKey, bh, "time-offset mining faults"); err != nil {
-			return witness, xerrors.Errorf("check time-offset mining faults: %w", err)
+		if err := checkFault(ctx, f.byParents, parentsKey, bh, "time-offset mining faults"); err != nil {
+			return err
 		}
 	}

@@ -50,19 +55,19 @@ func (f *SlashFilter) MinedBlock(ctx context.Context, bh *types.BlockHeader, par
 		parentEpochKey := ds.NewKey(fmt.Sprintf("/%s/%d", bh.Miner, parentEpoch))
 		have, err := f.byEpoch.Has(ctx, parentEpochKey)
 		if err != nil {
-			return cid.Undef, err
+			return err
 		}

 		if have {
 			// If we had, make sure it's in our parent tipset
 			cidb, err := f.byEpoch.Get(ctx, parentEpochKey)
 			if err != nil {
-				return cid.Undef, xerrors.Errorf("getting other block cid: %w", err)
+				return xerrors.Errorf("getting other block cid: %w", err)
 			}

 			_, parent, err := cid.CidFromBytes(cidb)
 			if err != nil {
-				return cid.Undef, err
+				return err
 			}

 			var found bool
@@ -73,45 +78,45 @@ func (f *SlashFilter) MinedBlock(ctx context.Context, bh *types.BlockHeader, par
 			}

 			if !found {
-				return parent, xerrors.Errorf("produced block would trigger 'parent-grinding fault' consensus fault; miner: %s; bh: %s, expected parent: %s", bh.Miner, bh.Cid(), parent)
+				return xerrors.Errorf("produced block would trigger 'parent-grinding fault' consensus fault; miner: %s; bh: %s, expected parent: %s", bh.Miner, bh.Cid(), parent)
 			}
 		}
 	}

 	if err := f.byParents.Put(ctx, parentsKey, bh.Cid().Bytes()); err != nil {
-		return cid.Undef, xerrors.Errorf("putting byEpoch entry: %w", err)
+		return xerrors.Errorf("putting byEpoch entry: %w", err)
 	}

 	if err := f.byEpoch.Put(ctx, epochKey, bh.Cid().Bytes()); err != nil {
-		return cid.Undef, xerrors.Errorf("putting byEpoch entry: %w", err)
+		return xerrors.Errorf("putting byEpoch entry: %w", err)
 	}

-	return cid.Undef, nil
+	return nil
 }

-func checkFault(ctx context.Context, t ds.Datastore, key ds.Key, bh *types.BlockHeader, faultType string) (cid.Cid, error) {
+func checkFault(ctx context.Context, t ds.Datastore, key ds.Key, bh *types.BlockHeader, faultType string) error {
 	fault, err := t.Has(ctx, key)
 	if err != nil {
-		return cid.Undef, xerrors.Errorf("failed to read from datastore: %w", err)
+		return err
 	}

 	if fault {
 		cidb, err := t.Get(ctx, key)
 		if err != nil {
-			return cid.Undef, xerrors.Errorf("getting other block cid: %w", err)
+			return xerrors.Errorf("getting other block cid: %w", err)
 		}

 		_, other, err := cid.CidFromBytes(cidb)
 		if err != nil {
-			return cid.Undef, err
+			return err
 		}

 		if other == bh.Cid() {
-			return cid.Undef, nil
+			return nil
 		}

-		return other, xerrors.Errorf("produced block would trigger '%s' consensus fault; miner: %s; bh: %s, other: %s", faultType, bh.Miner, bh.Cid(), other)
+		return xerrors.Errorf("produced block would trigger '%s' consensus fault; miner: %s; bh: %s, other: %s", faultType, bh.Miner, bh.Cid(), other)
 	}

-	return cid.Undef, nil
+	return nil
 }
@@ -37,17 +37,7 @@ var dbDefs = []string{
 	)`,
 	`INSERT OR IGNORE INTO _meta (version) VALUES (1)`,
 }
-
-var dbPragmas = []string{
-	"PRAGMA synchronous = normal",
-	"PRAGMA temp_store = memory",
-	"PRAGMA mmap_size = 30000000000",
-	"PRAGMA page_size = 32768",
-	"PRAGMA auto_vacuum = NONE",
-	"PRAGMA automatic_index = OFF",
-	"PRAGMA journal_mode = WAL",
-	"PRAGMA read_uncommitted = ON",
-}
+var dbPragmas = []string{}

 const (
 	// prepared stmts
@@ -39,10 +39,10 @@ func TestBasicMsgIndex(t *testing.T) {
 		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)
 	}

-	waitForCoalescerAfterLastEvent()
-
 	t.Log("verifying index")
 	verifyIndex(t, cs, msgIndex)
 }
@@ -51,7 +51,7 @@ 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 tipset/epoch
+	// 3. Verify that the index contains all messages with the correct tipst/epoch
 	cs := newMockChainStore()
 	cs.genesis()

@@ -67,10 +67,10 @@ func TestReorgMsgIndex(t *testing.T) {
 		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)
 	}

-	waitForCoalescerAfterLastEvent()
-
 	// a simple reorg
 	t.Log("doing reorg")
 	reorgme := cs.curTs
@@ -80,8 +80,7 @@ func TestReorgMsgIndex(t *testing.T) {
 	reorgmeChild := cs.makeBlk()
 	err = cs.reorg([]*types.TipSet{reorgme}, []*types.TipSet{reorgmeChild})
 	require.NoError(t, err)
-
-	waitForCoalescerAfterLastEvent()
+	time.Sleep(CoalesceMinDelay + 10*time.Millisecond)

 	t.Log("verifying index")
 	verifyIndex(t, cs, msgIndex)
@@ -110,10 +109,10 @@ func TestReconcileMsgIndex(t *testing.T) {
 		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)
 	}

-	waitForCoalescerAfterLastEvent()
-
 	// Close it and reorg
 	err = msgIndex.Close()
 	require.NoError(t, err)
@@ -297,11 +296,3 @@ func (cs *mockChainStore) GetTipSetFromKey(ctx context.Context, tsk types.TipSet
 	}
 	return ts, nil
 }
-
-func waitForCoalescerAfterLastEvent() {
-	// It can take up to CoalesceMinDelay for the coalescer timer to fire after the last event.
-	// When the timer fires, it can wait up to CoalesceMinDelay again for more events.
-	// Therefore the total wait is 2 * CoalesceMinDelay.
-	// Then we wait another second for the listener (the index) to actually process events.
-	time.Sleep(2*CoalesceMinDelay + time.Second)
-}
@@ -35,8 +35,8 @@ func (mp *MessagePool) CheckPendingMessages(ctx context.Context, from address.Ad
 	mp.lk.RLock()
 	mset, ok, err := mp.getPendingMset(ctx, from)
 	if err != nil {
-		mp.lk.RUnlock()
-		return nil, xerrors.Errorf("errored while getting pending mset: %w", err)
+		log.Warnf("errored while getting pending mset: %w", err)
+		return nil, err
 	}
 	if ok {
 		msgs = make([]*types.Message, 0, len(mset.msgs))
@@ -71,8 +71,8 @@ func (mp *MessagePool) CheckReplaceMessages(ctx context.Context, replace []*type
 			msgMap[m.From] = mmap
 			mset, ok, err := mp.getPendingMset(ctx, m.From)
 			if err != nil {
-				mp.lk.RUnlock()
-				return nil, xerrors.Errorf("errored while getting pending mset: %w", err)
+				log.Warnf("errored while getting pending mset: %w", err)
+				return nil, err
 			}
 			if ok {
 				count += len(mset.msgs)
@@ -155,8 +155,8 @@ func (mp *MessagePool) checkMessages(ctx context.Context, msgs []*types.Message,
 			mp.lk.RLock()
 			mset, ok, err := mp.getPendingMset(ctx, m.From)
 			if err != nil {
-				mp.lk.RUnlock()
-				return nil, xerrors.Errorf("errored while getting pending mset: %w", err)
+				log.Warnf("errored while getting pending mset: %w", err)
+				return nil, err
 			}
 			if ok && !interned {
 				st = &actorState{nextNonce: mset.nextNonce, requiredFunds: mset.requiredFunds}
@@ -448,8 +448,12 @@ func New(ctx context.Context, api Provider, ds dtypes.MetadataDS, us stmgr.Upgra
 	return mp, nil
 }

-func (mp *MessagePool) ForEachPendingMessage(f func(cid.Cid) error) error {
-	mp.lk.Lock()
+func (mp *MessagePool) TryForEachPendingMessage(f func(cid.Cid) error) error {
+	// avoid deadlocks in splitstore compaction when something else needs to access the blockstore
+	// while holding the mpool lock
+	if !mp.lk.TryLock() {
+		return xerrors.Errorf("mpool TryForEachPendingMessage: could not acquire lock")
+	}
 	defer mp.lk.Unlock()

 	for _, mset := range mp.pending {
@@ -745,7 +749,8 @@ func (mp *MessagePool) checkMessage(ctx context.Context, m *types.SignedMessage)
 	}

 	if err := mp.VerifyMsgSig(m); err != nil {
-		return xerrors.Errorf("signature verification failed: %s", err)
+		log.Warnf("signature verification failed: %s", err)
+		return err
 	}

 	return nil
@@ -964,11 +969,13 @@ func (mp *MessagePool) addLocked(ctx context.Context, m *types.SignedMessage, st
 	}

 	if _, err := mp.api.PutMessage(ctx, m); err != nil {
-		return xerrors.Errorf("mpooladd cs.PutMessage failed: %s", err)
+		log.Warnf("mpooladd cs.PutMessage failed: %s", err)
+		return err
 	}

 	if _, err := mp.api.PutMessage(ctx, &m.Message); err != nil {
-		return xerrors.Errorf("mpooladd cs.PutMessage failed: %s", err)
+		log.Warnf("mpooladd cs.PutMessage failed: %s", err)
+		return err
 	}

 	// Note: If performance becomes an issue, making this getOrCreatePendingMset will save some work
@@ -11,11 +11,9 @@ import (
 	"github.com/ipfs/go-datastore"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	big2 "github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/network"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
@@ -526,36 +524,6 @@ func TestPruningSimple(t *testing.T) {
 	}
 }

-func TestGasRewardNegative(t *testing.T) {
-	var mp MessagePool
-
-	msg := types.SignedMessage{
-		Message: types.Message{
-			GasLimit:   1000,
-			GasFeeCap:  big2.NewInt(20000),
-			GasPremium: big2.NewInt(15000),
-		},
-	}
-	baseFee := big2.NewInt(30000)
-	// Over the GasPremium, but under the BaseFee
-	gr1 := mp.getGasReward(&msg, baseFee)
-
-	msg.Message.GasFeeCap = big2.NewInt(15000)
-	// Equal to GasPremium, under the BaseFee
-	gr2 := mp.getGasReward(&msg, baseFee)
-
-	msg.Message.GasFeeCap = big2.NewInt(10000)
-	// Under both GasPremium and BaseFee
-	gr3 := mp.getGasReward(&msg, baseFee)
-
-	require.True(t, gr1.Sign() < 0)
-	require.True(t, gr2.Sign() < 0)
-	require.True(t, gr3.Sign() < 0)
-
-	require.True(t, gr1.Cmp(gr2) > 0)
-	require.True(t, gr2.Cmp(gr3) > 0)
-}
-
 func TestLoadLocal(t *testing.T) {
 	tma := newTestMpoolAPI()
 	ds := datastore.NewMapDatastore()
@@ -13,7 +13,6 @@ import (
 	"os"
 	"sort"
 	"testing"
-	"time"

 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
@@ -1691,188 +1690,3 @@ readLoop:
 	}

 }
-
-func TestRealWorldSelectionTiming(t *testing.T) {
-	//stm: @TOKEN_WALLET_NEW_001, @TOKEN_WALLET_SIGN_001, @CHAIN_MEMPOOL_SELECT_001
-
-	// load test-messages.json.gz and rewrite the messages so that
-	// 1) we map each real actor to a test actor so that we can sign the messages
-	// 2) adjust the nonces so that they start from 0
-	file, err := os.Open("test-messages2.json.gz")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	gzr, err := gzip.NewReader(file)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	dec := json.NewDecoder(gzr)
-
-	var msgs []*types.SignedMessage
-	baseNonces := make(map[address.Address]uint64)
-
-readLoop:
-	for {
-		m := new(types.SignedMessage)
-		err := dec.Decode(m)
-		switch err {
-		case nil:
-			msgs = append(msgs, m)
-			nonce, ok := baseNonces[m.Message.From]
-			if !ok || m.Message.Nonce < nonce {
-				baseNonces[m.Message.From] = m.Message.Nonce
-			}
-
-		case io.EOF:
-			break readLoop
-
-		default:
-			t.Fatal(err)
-		}
-	}
-
-	actorMap := make(map[address.Address]address.Address)
-	actorWallets := make(map[address.Address]api.Wallet)
-
-	for _, m := range msgs {
-		baseNonce := baseNonces[m.Message.From]
-
-		localActor, ok := actorMap[m.Message.From]
-		if !ok {
-			w, err := wallet.NewWallet(wallet.NewMemKeyStore())
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			a, err := w.WalletNew(context.Background(), types.KTSecp256k1)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			actorMap[m.Message.From] = a
-			actorWallets[a] = w
-			localActor = a
-		}
-
-		w, ok := actorWallets[localActor]
-		if !ok {
-			t.Fatalf("failed to lookup wallet for actor %s", localActor)
-		}
-
-		m.Message.From = localActor
-		m.Message.Nonce -= baseNonce
-
-		sig, err := w.WalletSign(context.TODO(), localActor, m.Message.Cid().Bytes(), api.MsgMeta{})
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		m.Signature = *sig
-	}
-
-	mp, tma := makeTestMpool()
-
-	block := tma.nextBlockWithHeight(uint64(build.UpgradeHyggeHeight) + 10)
-	ts := mock.TipSet(block)
-	tma.applyBlock(t, block)
-
-	for _, a := range actorMap {
-		tma.setBalance(a, 1000000)
-	}
-
-	tma.baseFee = types.NewInt(800_000_000)
-
-	sort.Slice(msgs, func(i, j int) bool {
-		return msgs[i].Message.Nonce < msgs[j].Message.Nonce
-	})
-
-	// add the messages
-	for _, m := range msgs {
-		mustAdd(t, mp, m)
-	}
-
-	// do message selection and check block packing
-	minGasLimit := int64(0.9 * float64(build.BlockGasLimit))
-
-	// greedy first
-	start := time.Now()
-	selected, err := mp.SelectMessages(context.Background(), ts, 1.0)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Logf("selected %d messages in %s", len(selected), time.Since(start))
-
-	gasLimit := int64(0)
-	for _, m := range selected {
-		gasLimit += m.Message.GasLimit
-	}
-	if gasLimit < minGasLimit {
-		t.Fatalf("failed to pack with tq=1.0; packed %d, minimum packing: %d", gasLimit, minGasLimit)
-	}
-
-	// high quality ticket
-	start = time.Now()
-	selected, err = mp.SelectMessages(context.Background(), ts, .8)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Logf("selected %d messages in %s", len(selected), time.Since(start))
-
-	gasLimit = int64(0)
-	for _, m := range selected {
-		gasLimit += m.Message.GasLimit
-	}
-	if gasLimit < minGasLimit {
-		t.Fatalf("failed to pack with tq=0.8; packed %d, minimum packing: %d", gasLimit, minGasLimit)
-	}
-
-	// mid quality ticket
-	start = time.Now()
-	selected, err = mp.SelectMessages(context.Background(), ts, .4)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Logf("selected %d messages in %s", len(selected), time.Since(start))
-
-	gasLimit = int64(0)
-	for _, m := range selected {
-		gasLimit += m.Message.GasLimit
-	}
-	if gasLimit < minGasLimit {
-		t.Fatalf("failed to pack with tq=0.4; packed %d, minimum packing: %d", gasLimit, minGasLimit)
-	}
-
-	// low quality ticket
-	start = time.Now()
-	selected, err = mp.SelectMessages(context.Background(), ts, .1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Logf("selected %d messages in %s", len(selected), time.Since(start))
-
-	gasLimit = int64(0)
-	for _, m := range selected {
-		gasLimit += m.Message.GasLimit
-	}
-	if gasLimit < minGasLimit {
-		t.Fatalf("failed to pack with tq=0.1; packed %d, minimum packing: %d", gasLimit, minGasLimit)
-	}
-
-	// very low quality ticket
-	start = time.Now()
-	selected, err = mp.SelectMessages(context.Background(), ts, .01)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Logf("selected %d messages in %s", len(selected), time.Since(start))
-
-	gasLimit = int64(0)
-	for _, m := range selected {
-		gasLimit += m.Message.GasLimit
-	}
-	if gasLimit < minGasLimit {
-		t.Fatalf("failed to pack with tq=0.01; packed %d, minimum packing: %d", gasLimit, minGasLimit)
-	}
-}
@@ -131,17 +131,15 @@ func (sm *StateManager) ExecutionTrace(ctx context.Context, ts *types.TipSet) (c
 	tsKey := ts.Key()

 	// check if we have the trace for this tipset in the cache
-	if execTraceCacheSize > 0 {
-		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.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})
@@ -149,13 +147,11 @@ func (sm *StateManager) ExecutionTrace(ctx context.Context, ts *types.TipSet) (c
 		return cid.Undef, nil, err
 	}

-	if execTraceCacheSize > 0 {
-		invocTraceCopy := makeDeepCopy(invocTrace)
+	invocTraceCopy := makeDeepCopy(invocTrace)

-		sm.execTraceCacheLock.Lock()
-		sm.execTraceCache.Add(tsKey, tipSetCacheEntry{st, invocTraceCopy})
-		sm.execTraceCacheLock.Unlock()
-	}
+	sm.execTraceCacheLock.Lock()
+	sm.execTraceCache.Add(tsKey, tipSetCacheEntry{st, invocTraceCopy})
+	sm.execTraceCacheLock.Unlock()

 	return st, invocTrace, nil
 }
@@ -3,8 +3,6 @@ package stmgr
 import (
 	"context"
 	"fmt"
-	"os"
-	"strconv"
 	"sync"

 	lru "github.com/hashicorp/golang-lru/v2"
@@ -42,7 +40,8 @@ import (
 const LookbackNoLimit = api.LookbackNoLimit
 const ReceiptAmtBitwidth = 3

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

 type StateManagerAPI interface {
@@ -75,17 +74,6 @@ func (m *migrationResultCache) keyForMigration(root cid.Cid) dstore.Key {
 	return dstore.NewKey(kStr)
 }

-func init() {
-	if s := os.Getenv("LOTUS_EXEC_TRACE_CACHE_SIZE"); s != "" {
-		letc, err := strconv.Atoi(s)
-		if err != nil {
-			log.Errorf("failed to parse 'LOTUS_EXEC_TRACE_CACHE_SIZE' env var: %s", err)
-		} else {
-			execTraceCacheSize = letc
-		}
-	}
-}
-
 func (m *migrationResultCache) Get(ctx context.Context, root cid.Cid) (cid.Cid, bool, error) {
 	k := m.keyForMigration(root)

@@ -212,14 +200,9 @@ func NewStateManager(cs *store.ChainStore, exec Executor, sys vm.SyscallBuilder,
 		}
 	}

-	log.Debugf("execTraceCache size: %d", execTraceCacheSize)
-	var execTraceCache *lru.ARCCache[types.TipSetKey, tipSetCacheEntry]
-	var err error
-	if execTraceCacheSize > 0 {
-		execTraceCache, err = lru.NewARC[types.TipSetKey, tipSetCacheEntry](execTraceCacheSize)
-		if err != nil {
-			return nil, err
-		}
+	execTraceCache, err := lru.NewARC[types.TipSetKey, tipSetCacheEntry](execTraceCacheSize)
+	if err != nil {
+		return nil, err
 	}

 	return &StateManager{
@@ -72,7 +72,7 @@ func ComputeState(ctx context.Context, sm *StateManager, height abi.ChainEpoch,

 	base, trace, err := sm.ExecutionTrace(ctx, ts)
 	if err != nil {
-		return cid.Undef, nil, xerrors.Errorf("failed to compute base state: %w", err)
+		return cid.Undef, nil, err
 	}

 	for i := ts.Height(); i < height; i++ {
@@ -116,21 +116,6 @@ func ComputeState(ctx context.Context, sm *StateManager, height abi.ChainEpoch,
 		if ret.ExitCode != 0 {
 			log.Infof("compute state apply message %d failed (exit: %d): %s", i, ret.ExitCode, ret.ActorErr)
 		}
-
-		ir := &api.InvocResult{
-			MsgCid:         msg.Cid(),
-			Msg:            msg,
-			MsgRct:         &ret.MessageReceipt,
-			ExecutionTrace: ret.ExecutionTrace,
-			Duration:       ret.Duration,
-		}
-		if ret.ActorErr != nil {
-			ir.Error = ret.ActorErr.Error()
-		}
-		if ret.GasCosts != nil {
-			ir.GasCost = MakeMsgGasCost(msg, ret)
-		}
-		trace = append(trace, ir)
 	}

 	root, err := vmi.Flush(ctx)
@@ -2,21 +2,18 @@ package store

 import (
 	"context"
-	"hash/maphash"
 	"os"
 	"strconv"
+	"sync"

-	"github.com/puzpuzpuz/xsync/v2"
 	"golang.org/x/xerrors"

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

 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/lib/shardedmutex"
 )

-// DefaultChainIndexCacheSize no longer sets the maximum size, just the initial size of the map.
-var DefaultChainIndexCacheSize = 1 << 15
+var DefaultChainIndexCacheSize = 32 << 15

 func init() {
 	if s := os.Getenv("LOTUS_CHAIN_INDEX_CACHE"); s != "" {
@@ -30,9 +27,8 @@ func init() {
 }

 type ChainIndex struct {
-	indexCache *xsync.MapOf[types.TipSetKey, *lbEntry]
-
-	fillCacheLock shardedmutex.ShardedMutexFor[types.TipSetKey]
+	indexCacheLk sync.Mutex
+	indexCache   map[types.TipSetKey]*lbEntry

 	loadTipSet loadTipSetFunc

@@ -40,16 +36,11 @@ type ChainIndex struct {
 }
 type loadTipSetFunc func(context.Context, types.TipSetKey) (*types.TipSet, error)

-func maphashTSK(s maphash.Seed, tsk types.TipSetKey) uint64 {
-	return maphash.Bytes(s, tsk.Bytes())
-}
-
 func NewChainIndex(lts loadTipSetFunc) *ChainIndex {
 	return &ChainIndex{
-		indexCache:    xsync.NewTypedMapOfPresized[types.TipSetKey, *lbEntry](maphashTSK, DefaultChainIndexCacheSize),
-		fillCacheLock: shardedmutex.NewFor(maphashTSK, 32),
-		loadTipSet:    lts,
-		skipLength:    20,
+		indexCache: make(map[types.TipSetKey]*lbEntry, DefaultChainIndexCacheSize),
+		loadTipSet: lts,
+		skipLength: 20,
 	}
 }

@@ -68,23 +59,17 @@ func (ci *ChainIndex) GetTipsetByHeight(ctx context.Context, from *types.TipSet,
 		return nil, xerrors.Errorf("failed to round down: %w", err)
 	}

+	ci.indexCacheLk.Lock()
+	defer ci.indexCacheLk.Unlock()
 	cur := rounded.Key()
 	for {
-		lbe, ok := ci.indexCache.Load(cur) // check the cache
+		lbe, ok := ci.indexCache[cur]
 		if !ok {
-			lk := ci.fillCacheLock.GetLock(cur)
-			lk.Lock()                         // if entry is missing, take the lock
-			lbe, ok = ci.indexCache.Load(cur) // check if someone else added it while we waited for lock
-			if !ok {
-				fc, err := ci.fillCache(ctx, cur)
-				if err != nil {
-					lk.Unlock()
-					return nil, xerrors.Errorf("failed to fill cache: %w", err)
-				}
-				lbe = fc
-				ci.indexCache.Store(cur, lbe)
+			fc, err := ci.fillCache(ctx, cur)
+			if err != nil {
+				return nil, xerrors.Errorf("failed to fill cache: %w", err)
 			}
-			lk.Unlock()
+			lbe = fc
 		}

 		if to == lbe.targetHeight {
@@ -152,6 +137,7 @@ func (ci *ChainIndex) fillCache(ctx context.Context, tsk types.TipSetKey) (*lbEn
 		targetHeight: skipTarget.Height(),
 		target:       skipTarget.Key(),
 	}
+	ci.indexCache[tsk] = lbe

 	return lbe, nil
 }
@@ -425,11 +425,6 @@ func (cs *ChainStore) MaybeTakeHeavierTipSet(ctx context.Context, ts *types.TipS
 	}

 	defer cs.heaviestLk.Unlock()
-
-	if ts.Equals(cs.heaviest) {
-		return nil
-	}
-
 	w, err := cs.weight(ctx, cs.StateBlockstore(), ts)
 	if err != nil {
 		return err
@@ -1161,10 +1156,6 @@ func (cs *ChainStore) TryFillTipSet(ctx context.Context, ts *types.TipSet) (*Ful
 // selects the tipset before the null round if true, and the tipset following
 // the null round if false.
 func (cs *ChainStore) GetTipsetByHeight(ctx context.Context, h abi.ChainEpoch, ts *types.TipSet, prev bool) (*types.TipSet, error) {
-	if h < 0 {
-		return nil, xerrors.Errorf("height %d is negative", h)
-	}
-
 	if ts == nil {
 		ts = cs.GetHeaviestTipSet()
 	}
@@ -12,7 +12,7 @@ import (
 	bserv "github.com/ipfs/go-blockservice"
 	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log/v2"
-	"github.com/ipni/go-libipni/announce/message"
+	"github.com/ipni/storetheindex/announce/message"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/libp2p/go-libp2p/core/connmgr"
 	"github.com/libp2p/go-libp2p/core/peer"
@@ -358,11 +358,7 @@ func (mv *MessageValidator) Validate(ctx context.Context, pid peer.ID, msg *pubs
 			fallthrough
 		case xerrors.Is(err, messagepool.ErrNonceGap):
 			fallthrough
-		case xerrors.Is(err, messagepool.ErrGasFeeCapTooLow):
-			fallthrough
 		case xerrors.Is(err, messagepool.ErrNonceTooLow):
-			fallthrough
-		case xerrors.Is(err, messagepool.ErrExistingNonce):
 			return pubsub.ValidationIgnore
 		default:
 			return pubsub.ValidationReject
@@ -9,7 +9,7 @@ import (
 	"github.com/golang/mock/gomock"
 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	"github.com/ipni/go-libipni/announce/message"
+	"github.com/ipni/storetheindex/announce/message"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	pb "github.com/libp2p/go-libp2p-pubsub/pb"
 	"github.com/libp2p/go-libp2p/core/peer"
@@ -2,7 +2,6 @@ package types

 import (
 	"bytes"
-	"fmt"

 	"github.com/ipfs/go-cid"
 )
@@ -15,13 +14,10 @@ type BlockMsg struct {

 func DecodeBlockMsg(b []byte) (*BlockMsg, error) {
 	var bm BlockMsg
-	data := bytes.NewReader(b)
-	if err := bm.UnmarshalCBOR(data); err != nil {
+	if err := bm.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
 		return nil, err
 	}
-	if l := data.Len(); l != 0 {
-		return nil, fmt.Errorf("extraneous data in BlockMsg CBOR encoding: got %d unexpected bytes", l)
-	}
+
 	return &bm, nil
 }

@@ -1,40 +0,0 @@
-package types
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestDecodeBlockMsg(t *testing.T) {
-	type args struct {
-		b []byte
-	}
-	tests := []struct {
-		name    string
-		data    []byte
-		want    *BlockMsg
-		wantErr bool
-	}{
-		{"decode empty BlockMsg with extra data at the end", []byte{0x83, 0xf6, 0x80, 0x80, 0x20}, nil, true},
-		{"decode valid empty BlockMsg", []byte{0x83, 0xf6, 0x80, 0x80}, new(BlockMsg), false},
-		{"decode invalid cbor", []byte{0x83, 0xf6, 0x80}, nil, true},
-	}
-	for _, tt := range tests {
-		data := tt.data
-		want := tt.want
-		wantErr := tt.wantErr
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := DecodeBlockMsg(data)
-			if wantErr {
-				assert.Errorf(t, err, "DecodeBlockMsg(%x)", data)
-				return
-			}
-			assert.NoErrorf(t, err, "DecodeBlockMsg(%x)", data)
-			assert.Equalf(t, want, got, "DecodeBlockMsg(%x)", data)
-			serialized, err := got.Serialize()
-			assert.NoErrorf(t, err, "DecodeBlockMsg(%x)", data)
-			assert.Equalf(t, serialized, data, "DecodeBlockMsg(%x)", data)
-		})
-	}
-}
@@ -238,30 +238,6 @@ func (c *EthCall) UnmarshalJSON(b []byte) error {
 	return nil
 }

-type EthSyncingResult struct {
-	DoneSync      bool
-	StartingBlock EthUint64
-	CurrentBlock  EthUint64
-	HighestBlock  EthUint64
-}
-
-func (sr EthSyncingResult) MarshalJSON() ([]byte, error) {
-	if sr.DoneSync {
-		// when done syncing, the json response should be '"result": false'
-		return []byte("false"), nil
-	}
-
-	// need to do an anonymous struct to avoid infinite recursion
-	return json.Marshal(&struct {
-		StartingBlock EthUint64 `json:"startingblock"`
-		CurrentBlock  EthUint64 `json:"currentblock"`
-		HighestBlock  EthUint64 `json:"highestblock"`
-	}{
-		StartingBlock: sr.StartingBlock,
-		CurrentBlock:  sr.CurrentBlock,
-		HighestBlock:  sr.HighestBlock})
-}
-
 const (
 	EthAddressLength = 20
 	EthHashLength    = 32
@@ -572,12 +548,12 @@ func (h EthSubscriptionID) String() string {
 }

 type EthFilterSpec struct {
-	// Interpreted as an epoch (in hex) or one of "latest" for last mined block, "earliest" for first,
+	// Interpreted as an epoch or one of "latest" for last mined block, "earliest" for first,
 	// "pending" for not yet committed messages.
 	// Optional, default: "latest".
 	FromBlock *string `json:"fromBlock,omitempty"`

-	// Interpreted as an epoch (in hex) or one of "latest" for last mined block, "earliest" for first,
+	// Interpreted as an epoch or one of "latest" for last mined block, "earliest" for first,
 	// "pending" for not yet committed messages.
 	// Optional, default: "latest".
 	ToBlock *string `json:"toBlock,omitempty"`
@@ -20,7 +20,6 @@ import (
 	"github.com/filecoin-project/lotus/api/v1api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/journal/alerting"
 )

 var infoCmd = &cli.Command{
@@ -63,21 +62,6 @@ func infoCmdAct(cctx *cli.Context) error {
 	fmt.Printf(" [epoch %s]\n", color.MagentaString(("%d"), status.SyncStatus.Epoch))
 	fmt.Printf("Peers to: [publish messages %d] [publish blocks %d]\n", status.PeerStatus.PeersToPublishMsgs, status.PeerStatus.PeersToPublishBlocks)

-	alerts, err := fullapi.LogAlerts(ctx)
-	if err != nil {
-		fmt.Printf("ERROR: getting alerts: %s\n", err)
-	}
-
-	activeAlerts := make([]alerting.Alert, 0)
-	for _, alert := range alerts {
-		if alert.Active {
-			activeAlerts = append(activeAlerts, alert)
-		}
-	}
-	if len(activeAlerts) > 0 {
-		fmt.Printf("%s (check %s)\n", color.RedString("⚠ %d Active alerts", len(activeAlerts)), color.YellowString("lotus log alerts"))
-	}
-
 	//Chain health calculated as percentage: amount of blocks in last finality / very healthy amount of blocks in a finality (900 epochs * 5 blocks per tipset)
 	health := (100 * (900 * status.ChainStatus.BlocksPerTipsetLastFinality) / (900 * 5))
 	switch {
@@ -445,8 +445,8 @@ var NetReachability = &cli.Command{
 		}

 		fmt.Println("AutoNAT status: ", i.Reachability.String())
-		if len(i.PublicAddrs) > 0 {
-			fmt.Println("Public address:", i.PublicAddrs)
+		if i.PublicAddr != "" {
+			fmt.Println("Public address: ", i.PublicAddr)
 		}
 		return nil
 	},
@@ -1065,19 +1065,12 @@ var StateComputeStateCmd = &cli.Command{

 		ctx := ReqContext(cctx)

-		h := abi.ChainEpoch(cctx.Uint64("vm-height"))
-		var ts *types.TipSet
-		if tss := cctx.String("tipset"); tss != "" {
-			ts, err = ParseTipSetRef(ctx, api, tss)
-		} else if h > 0 {
-			ts, err = api.ChainGetTipSetByHeight(ctx, h, types.EmptyTSK)
-		} else {
-			ts, err = api.ChainHead(ctx)
-		}
+		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
 		}

+		h := abi.ChainEpoch(cctx.Uint64("vm-height"))
 		if h == 0 {
 			h = ts.Height()
 		}
@@ -1535,9 +1528,6 @@ func printMsg(ctx context.Context, api v0api.FullNode, msg cid.Cid, mw *lapi.Msg
 	if err := printReceiptReturn(ctx, api, m, mw.Receipt); err != nil {
 		return err
 	}
-	if mw.Receipt.EventsRoot != nil {
-		fmt.Printf("Events Root: %s\n", mw.Receipt.EventsRoot)
-	}

 	return nil
 }
@@ -98,16 +98,14 @@ func main() {
 	log.Info("Starting lotus-bench")

 	app := &cli.App{
-		Name:                      "lotus-bench",
-		Usage:                     "Benchmark performance of lotus on your hardware",
-		Version:                   build.UserVersion(),
-		DisableSliceFlagSeparator: true,
+		Name:    "lotus-bench",
+		Usage:   "Benchmark performance of lotus on your hardware",
+		Version: build.UserVersion(),
 		Commands: []*cli.Command{
 			proveCmd,
 			sealBenchCmd,
 			simpleCmd,
 			importBenchCmd,
-			rpcCmd,
 		},
 	}

@@ -1,576 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"os/signal"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-	"text/tabwriter"
-	"time"
-
-	"github.com/urfave/cli/v2"
-)
-
-var rpcCmd = &cli.Command{
-	Name:  "rpc",
-	Usage: "Runs a concurrent stress test on one or more rpc methods and prints the performance metrics including latency distribution and histogram",
-	Description: `This benchmark is designed to stress test the rpc methods of a lotus node so that we can simulate real world usage and measure the performance of rpc methods on the node.
-	
-This benchmark has the following features:
-* Can query each method both sequentially and concurrently
-* Supports rate limiting
-* Can query multiple different endpoints at once (supporting different concurrency level and rate limiting for each method)
-* Gives a nice reporting summary of the stress testing of each method (including latency distribution, histogram and more)
-* Easy to use
-
-To use this benchmark you must specify the rpc methods you want to test using the --method options, the format of it is:
-
-  --method=NAME[:CONCURRENCY][:QPS][:PARAMS] where only NAME is required.
-
-Here are some real examples:
-  lotus-bench rpc --method='eth_chainId' // run eth_chainId with default concurrency and qps
-  lotus-bench rpc --method='eth_chainId:3'  // override concurrency to 3
-  lotus-bench rpc --method='eth_chainId::100' // override to 100 qps while using default concurrency
-  lotus-bench rpc --method='eth_chainId:3:100' // run using 3 workers but limit to 100 qps
-  lotus-bench rpc --method='eth_getTransactionCount:::["0xd4c70007F3F502f212c7e6794b94C06F36173B36", "latest"]' // run using optional params while using default concurrency and qps
-  lotus-bench rpc --method='eth_chainId' --method='eth_getTransactionCount:10:0:["0xd4c70007F3F502f212c7e6794b94C06F36173B36", "latest"]' // run multiple methods at once
-
-NOTE: The last two examples will not work until we upgrade urfave dependency (tracked in https://github.com/urfave/cli/issues/1734)`,
-	Flags: []cli.Flag{
-		&cli.StringFlag{
-			Name:  "endpoint",
-			Value: "http://127.0.0.1:1234/rpc/v1",
-			Usage: "The rpc endpoint to benchmark",
-		},
-		&cli.DurationFlag{
-			Name:  "duration",
-			Value: 60 * time.Second,
-			Usage: "Duration of benchmark in seconds",
-		},
-		&cli.IntFlag{
-			Name:  "concurrency",
-			Value: 10,
-			Usage: "How many workers should be used per rpc method (can be overridden per method)",
-		},
-		&cli.IntFlag{
-			Name:  "qps",
-			Value: 0,
-			Usage: "How many requests per second should be sent per rpc method (can be overridden per method), a value of 0 means no limit",
-		},
-		&cli.StringSliceFlag{
-			Name: "method",
-			Usage: `Method to benchmark, you can specify multiple methods by repeating this flag. You can also specify method specific options to set the concurrency and qps for each method (see usage).
-`,
-		},
-		&cli.DurationFlag{
-			Name:  "watch",
-			Value: 0 * time.Second,
-			Usage: "If >0 then generates reports every N seconds (only supports linux/unix)",
-		},
-		&cli.BoolFlag{
-			Name:  "print-response",
-			Value: false,
-			Usage: "print the response of each request",
-		},
-	},
-	Action: func(cctx *cli.Context) error {
-		if len(cctx.StringSlice("method")) == 0 {
-			return errors.New("you must specify and least one method to benchmark")
-		}
-
-		var rpcMethods []*RPCMethod
-		for _, str := range cctx.StringSlice("method") {
-			entries := strings.SplitN(str, ":", 4)
-			if len(entries) == 0 {
-				return errors.New("invalid method format")
-			}
-
-			// check if concurrency was specified
-			concurrency := cctx.Int("concurrency")
-			if len(entries) > 1 {
-				if len(entries[1]) > 0 {
-					var err error
-					concurrency, err = strconv.Atoi(entries[1])
-					if err != nil {
-						return fmt.Errorf("could not parse concurrency value from method %s: %v", entries[0], err)
-					}
-				}
-			}
-
-			// check if qps was specified
-			qps := cctx.Int("qps")
-			if len(entries) > 2 {
-				if len(entries[2]) > 0 {
-					var err error
-					qps, err = strconv.Atoi(entries[2])
-					if err != nil {
-						return fmt.Errorf("could not parse qps value from method %s: %v", entries[0], err)
-					}
-				}
-			}
-
-			// check if params was specified
-			params := "[]"
-			if len(entries) > 3 {
-				params = entries[3]
-			}
-
-			rpcMethods = append(rpcMethods, &RPCMethod{
-				w:           os.Stdout,
-				uri:         cctx.String("endpoint"),
-				method:      entries[0],
-				concurrency: concurrency,
-				qps:         qps,
-				params:      params,
-				printResp:   cctx.Bool("print-response"),
-			})
-		}
-
-		// terminate early on ctrl+c
-		c := make(chan os.Signal, 1)
-		signal.Notify(c, os.Interrupt)
-		go func() {
-			<-c
-			fmt.Println("Received interrupt, stopping...")
-			for _, method := range rpcMethods {
-				method.Stop()
-			}
-		}()
-
-		// stop all threads after duration
-		go func() {
-			time.Sleep(cctx.Duration("duration"))
-			for _, e := range rpcMethods {
-				e.Stop()
-			}
-		}()
-
-		// start all threads
-		var wg sync.WaitGroup
-		wg.Add(len(rpcMethods))
-
-		for _, e := range rpcMethods {
-			go func(e *RPCMethod) {
-				defer wg.Done()
-				err := e.Run()
-				if err != nil {
-					fmt.Printf("error running rpc method: %v\n", err)
-				}
-			}(e)
-		}
-
-		// if watch is set then print a report every N seconds
-		var progressCh chan struct{}
-		if cctx.Duration("watch") > 0 {
-			progressCh = make(chan struct{}, 1)
-			go func(progressCh chan struct{}) {
-				ticker := time.NewTicker(cctx.Duration("watch"))
-				for {
-					clearAndPrintReport := func() {
-						// clear the screen move the curser to the top left
-						fmt.Print("\033[2J")
-						fmt.Printf("\033[%d;%dH", 1, 1)
-						for i, e := range rpcMethods {
-							e.Report()
-							if i < len(rpcMethods)-1 {
-								fmt.Println()
-							}
-						}
-					}
-					select {
-					case <-ticker.C:
-						clearAndPrintReport()
-					case <-progressCh:
-						clearAndPrintReport()
-						return
-					}
-				}
-			}(progressCh)
-		}
-
-		wg.Wait()
-
-		if progressCh != nil {
-			// wait for the watch go routine to return
-			progressCh <- struct{}{}
-
-			// no need to print the report again
-			return nil
-		}
-
-		// print the report for each endpoint
-		for i, e := range rpcMethods {
-			e.Report()
-			if i < len(rpcMethods)-1 {
-				fmt.Println()
-			}
-		}
-
-		return nil
-	},
-}
-
-// RPCMethod handles the benchmarking of a single endpoint method.
-type RPCMethod struct {
-	w io.Writer
-	// the endpoint uri
-	uri string
-	// the rpc method we want to benchmark
-	method string
-	// the number of concurrent requests to make to this endpoint
-	concurrency int
-	// if >0 then limit to qps is the max number of requests per second to make to this endpoint (0 = no limit)
-	qps int
-	// many endpoints require specific parameters to be passed
-	params string
-	// whether or not to print the response of each request (useful for debugging)
-	printResp bool
-	// instruct the worker go routines to stop
-	stopCh chan struct{}
-	// when the endpoint bencharking started
-	start time.Time
-	// results channel is used by the workers to send results to the reporter
-	results chan *result
-	// reporter handles reading the results from workers and printing the report statistics
-	reporter *Reporter
-}
-
-// result is the result of a single rpc method request.
-type result struct {
-	err        error
-	statusCode *int
-	duration   time.Duration
-}
-
-func (rpc *RPCMethod) Run() error {
-	client := &http.Client{
-		Timeout: 0,
-	}
-
-	var wg sync.WaitGroup
-	wg.Add(rpc.concurrency)
-
-	rpc.results = make(chan *result, rpc.concurrency*1_000)
-	rpc.stopCh = make(chan struct{}, rpc.concurrency)
-
-	go func() {
-		rpc.reporter = NewReporter(rpc.results, rpc.w)
-		rpc.reporter.Run()
-	}()
-
-	rpc.start = time.Now()
-
-	// throttle the number of requests per second
-	var qpsTicker *time.Ticker
-	if rpc.qps > 0 {
-		qpsTicker = time.NewTicker(time.Second / time.Duration(rpc.qps))
-	}
-
-	for i := 0; i < rpc.concurrency; i++ {
-		go func() {
-			rpc.startWorker(client, qpsTicker)
-			wg.Done()
-		}()
-	}
-	wg.Wait()
-
-	// close the results channel so reporter will stop
-	close(rpc.results)
-
-	// wait until the reporter is done
-	<-rpc.reporter.doneCh
-
-	return nil
-}
-
-func (rpc *RPCMethod) startWorker(client *http.Client, qpsTicker *time.Ticker) {
-	for {
-		// check if we should stop
-		select {
-		case <-rpc.stopCh:
-			return
-		default:
-		}
-
-		// wait for the next tick if we are rate limiting this endpoint
-		if qpsTicker != nil {
-			<-qpsTicker.C
-		}
-
-		req, err := rpc.buildRequest()
-		if err != nil {
-			log.Fatalln(err)
-		}
-
-		start := time.Now()
-
-		var statusCode *int
-
-		// send request the endpoint
-		resp, err := client.Do(req)
-		if err != nil {
-			err = fmt.Errorf("HTTP error: %s", err.Error())
-		} else {
-			statusCode = &resp.StatusCode
-
-			// there was not a HTTP error but we need to still check the json response for errrors
-			var data []byte
-			data, err = io.ReadAll(resp.Body)
-			if err != nil {
-				log.Fatalln(err)
-			}
-
-			// we are only interested if it has the error field in the response
-			type respData struct {
-				Error struct {
-					Code    int    `json:"code"`
-					Message string `json:"message"`
-				} `json:"error"`
-			}
-
-			// unmarshal the response into a struct so we can check for errors
-			var d respData
-			err = json.Unmarshal(data, &d)
-			if err != nil {
-				log.Fatalln(err)
-			}
-
-			// if the response has an error json message then it should be considered an error just like any http error
-			if len(d.Error.Message) > 0 {
-				// truncate the error message if it is too long
-				if len(d.Error.Message) > 1000 {
-					d.Error.Message = d.Error.Message[:1000] + "..."
-				}
-				// remove newlines from the error message so we don't screw up the report
-				d.Error.Message = strings.ReplaceAll(d.Error.Message, "\n", "")
-
-				err = fmt.Errorf("JSON error: code:%d, message:%s", d.Error.Code, d.Error.Message)
-			}
-
-			if rpc.printResp {
-				fmt.Printf("[%s] %s", rpc.method, string(data))
-			}
-
-			resp.Body.Close() //nolint:errcheck
-		}
-
-		rpc.results <- &result{
-			statusCode: statusCode,
-			err:        err,
-			duration:   time.Since(start),
-		}
-	}
-}
-
-func (rpc *RPCMethod) buildRequest() (*http.Request, error) {
-	jreq, err := json.Marshal(struct {
-		Jsonrpc string          `json:"jsonrpc"`
-		ID      int             `json:"id"`
-		Method  string          `json:"method"`
-		Params  json.RawMessage `json:"params"`
-	}{
-		Jsonrpc: "2.0",
-		Method:  rpc.method,
-		Params:  json.RawMessage(rpc.params),
-		ID:      0,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	req, err := http.NewRequest("POST", rpc.uri, bytes.NewReader(jreq))
-	if err != nil {
-		return nil, err
-	}
-
-	req.Header.Set("Accept", "application/json")
-
-	return req, nil
-}
-
-func (rpc *RPCMethod) Stop() {
-	for i := 0; i < rpc.concurrency; i++ {
-		rpc.stopCh <- struct{}{}
-	}
-}
-
-func (rpc *RPCMethod) Report() {
-	total := time.Since(rpc.start)
-	fmt.Fprintf(rpc.w, "[%s]:\n", rpc.method)
-	fmt.Fprintf(rpc.w, "- Options:\n")
-	fmt.Fprintf(rpc.w, "  - concurrency: %d\n", rpc.concurrency)
-	fmt.Fprintf(rpc.w, "  - params: %s\n", rpc.params)
-	fmt.Fprintf(rpc.w, "  - qps: %d\n", rpc.qps)
-	rpc.reporter.Print(total, rpc.w)
-}
-
-// Reporter reads the results from the workers through the results channel and aggregates the results.
-type Reporter struct {
-	// write the report to this writer
-	w io.Writer
-	// the reporter read the results from this channel
-	results chan *result
-	// doneCh is used to signal that the reporter has finished reading the results (channel has closed)
-	doneCh chan bool
-
-	// lock protect the following fields during critical sections (if --watch was specified)
-	lock sync.Mutex
-	// the latencies of all requests
-	latencies []int64
-	// the number of requests that returned each status code
-	statusCodes map[int]int
-	// the number of errors that occurred
-	errors map[string]int
-}
-
-func NewReporter(results chan *result, w io.Writer) *Reporter {
-	return &Reporter{
-		w:           w,
-		results:     results,
-		doneCh:      make(chan bool, 1),
-		statusCodes: make(map[int]int),
-		errors:      make(map[string]int),
-	}
-}
-
-func (r *Reporter) Run() {
-	for res := range r.results {
-		r.lock.Lock()
-
-		r.latencies = append(r.latencies, res.duration.Milliseconds())
-
-		if res.statusCode != nil {
-			r.statusCodes[*res.statusCode]++
-		}
-
-		if res.err != nil {
-			if len(r.errors) < 1_000_000 {
-				r.errors[res.err.Error()]++
-			} else {
-				// we don't want to store too many errors in memory
-				r.errors["hidden"]++
-			}
-		} else {
-			r.errors["nil"]++
-		}
-
-		r.lock.Unlock()
-	}
-
-	r.doneCh <- true
-}
-
-func (r *Reporter) Print(elapsed time.Duration, w io.Writer) {
-	r.lock.Lock()
-	defer r.lock.Unlock()
-
-	nrReq := int64(len(r.latencies))
-	if nrReq == 0 {
-		fmt.Println("No requests were made")
-		return
-	}
-
-	// we need to sort the latencies slice to calculate the percentiles
-	sort.Slice(r.latencies, func(i, j int) bool {
-		return r.latencies[i] < r.latencies[j]
-	})
-
-	var totalLatency int64 = 0
-	for _, latency := range r.latencies {
-		totalLatency += latency
-	}
-
-	fmt.Fprintf(w, "- Total Requests: %d\n", nrReq)
-	fmt.Fprintf(w, "- Total Duration: %dms\n", elapsed.Milliseconds())
-	fmt.Fprintf(w, "- Requests/sec: %f\n", float64(nrReq)/elapsed.Seconds())
-	fmt.Fprintf(w, "- Avg latency: %dms\n", totalLatency/nrReq)
-	fmt.Fprintf(w, "- Median latency: %dms\n", r.latencies[nrReq/2])
-	fmt.Fprintf(w, "- Latency distribution:\n")
-	percentiles := []float64{0.1, 0.5, 0.9, 0.95, 0.99, 0.999}
-	for _, p := range percentiles {
-		idx := int64(p * float64(nrReq))
-		fmt.Fprintf(w, "    %s%% in %dms\n", fmt.Sprintf("%.2f", p*100.0), r.latencies[idx])
-	}
-
-	// create a simple histogram with 10 buckets spanning the range of latency
-	// into equal ranges
-	//
-	nrBucket := 10
-	buckets := make([]Bucket, nrBucket)
-	latencyRange := r.latencies[len(r.latencies)-1]
-	bucketRange := latencyRange / int64(nrBucket)
-
-	// mark the end of each bucket
-	for i := 0; i < nrBucket; i++ {
-		buckets[i].start = int64(i) * bucketRange
-		buckets[i].end = buckets[i].start + bucketRange
-		// extend the last bucked by any remaning range caused by the integer division
-		if i == nrBucket-1 {
-			buckets[i].end = latencyRange
-		}
-	}
-
-	// count the number of requests in each bucket
-	currBucket := 0
-	for i := 0; i < len(r.latencies); {
-		if r.latencies[i] <= buckets[currBucket].end {
-			buckets[currBucket].cnt++
-			i++
-		} else {
-			currBucket++
-		}
-	}
-
-	// print the histogram using a tabwriter which will align the columns nicely
-	fmt.Fprintf(w, "- Histogram:\n")
-	const padding = 2
-	tabWriter := tabwriter.NewWriter(w, 0, 0, padding, ' ', tabwriter.AlignRight|tabwriter.Debug)
-	for i := 0; i < nrBucket; i++ {
-		ratio := float64(buckets[i].cnt) / float64(nrReq)
-		bars := strings.Repeat("#", int(ratio*100))
-		fmt.Fprintf(tabWriter, "  %d-%dms\t%d\t%s (%s%%)\n", buckets[i].start, buckets[i].end, buckets[i].cnt, bars, fmt.Sprintf("%.2f", ratio*100))
-	}
-	tabWriter.Flush() //nolint:errcheck
-
-	fmt.Fprintf(w, "- Status codes:\n")
-	for code, cnt := range r.statusCodes {
-		fmt.Fprintf(w, "    [%d]: %d\n", code, cnt)
-	}
-
-	// print the 10 most occurring errors (in case error values are not unique)
-	//
-	type kv struct {
-		err string
-		cnt int
-	}
-	var sortedErrors []kv
-	for err, cnt := range r.errors {
-		sortedErrors = append(sortedErrors, kv{err, cnt})
-	}
-	sort.Slice(sortedErrors, func(i, j int) bool {
-		return sortedErrors[i].cnt > sortedErrors[j].cnt
-	})
-	fmt.Fprintf(w, "- Errors (top 10):\n")
-	for i, se := range sortedErrors {
-		if i > 10 {
-			break
-		}
-		fmt.Fprintf(w, "    [%s]: %d\n", se.err, se.cnt)
-	}
-}
-
-type Bucket struct {
-	start int64
-	// the end value of the bucket
-	end int64
-	// how many entries are in the bucket
-	cnt int
-}
@@ -7,7 +7,6 @@ import (
 	"net"
 	"net/http"
 	"os"
-	"strings"
 	"time"

 	rice "github.com/GeertJohan/go.rice"
@@ -16,14 +15,10 @@ import (
 	"golang.org/x/xerrors"

 	"github.com/filecoin-project/go-address"
-	verifregtypes9 "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"

 	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/verifreg"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/types/ethtypes"
 	lcli "github.com/filecoin-project/lotus/cli"
 )

@@ -75,11 +70,6 @@ var runCmd = &cli.Command{
 			EnvVars: []string{"LOTUS_FOUNTAIN_AMOUNT"},
 			Value:   "50",
 		},
-		&cli.Uint64Flag{
-			Name:    "data-cap",
-			EnvVars: []string{"LOTUS_DATACAP_AMOUNT"},
-			Value:   verifregtypes9.MinVerifiedDealSize.Uint64(),
-		},
 		&cli.Float64Flag{
 			Name:  "captcha-threshold",
 			Value: 0.5,
@@ -118,7 +108,6 @@ var runCmd = &cli.Command{
 			ctx:            ctx,
 			api:            nodeApi,
 			from:           from,
-			allowance:      types.NewInt(cctx.Uint64("data-cap")),
 			sendPerRequest: sendPerRequest,
 			limiter: NewLimiter(LimiterConfig{
 				TotalRate:   500 * time.Millisecond,
@@ -135,8 +124,6 @@ var runCmd = &cli.Command{
 		http.Handle("/", http.FileServer(box.HTTPBox()))
 		http.HandleFunc("/funds.html", prepFundsHtml(box))
 		http.Handle("/send", h)
-		http.HandleFunc("/datacap.html", prepDataCapHtml(box))
-		http.Handle("/datacap", h)
 		fmt.Printf("Open http://%s\n", cctx.String("front"))

 		go func() {
@@ -169,24 +156,12 @@ func prepFundsHtml(box *rice.Box) http.HandlerFunc {
 	}
 }

-func prepDataCapHtml(box *rice.Box) http.HandlerFunc {
-	tmpl := template.Must(template.New("datacaps").Parse(box.MustString("datacap.html")))
-	return func(w http.ResponseWriter, r *http.Request) {
-		err := tmpl.Execute(w, os.Getenv("RECAPTCHA_SITE_KEY"))
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadGateway)
-			return
-		}
-	}
-}
-
 type handler struct {
 	ctx context.Context
 	api v0api.FullNode

 	from           address.Address
 	sendPerRequest types.FIL
-	allowance      types.BigInt

 	limiter        *Limiter
 	recapThreshold float64
@@ -212,41 +187,24 @@ func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, err.Error(), http.StatusBadGateway)
 		return
 	}
-
 	if !capResp.Success || capResp.Score < h.recapThreshold {
 		log.Infow("spam", "capResp", capResp)
 		http.Error(w, "spam protection", http.StatusUnprocessableEntity)
 		return
 	}

-	addressInput := r.FormValue("address")
-
-	var filecoinAddress address.Address
-	var decodeError error
-
-	if strings.HasPrefix(addressInput, "0x") {
-		ethAddress, err := ethtypes.ParseEthAddress(addressInput)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-
-		filecoinAddress, decodeError = ethAddress.ToFilecoinAddress()
-	} else {
-		filecoinAddress, decodeError = address.NewFromString(addressInput)
-	}
-
-	if decodeError != nil {
+	to, err := address.NewFromString(r.FormValue("address"))
+	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	if filecoinAddress == address.Undef {
+	if to == address.Undef {
 		http.Error(w, "empty address", http.StatusBadRequest)
 		return
 	}

 	// Limit based on wallet address
-	limiter := h.limiter.GetWalletLimiter(filecoinAddress.String())
+	limiter := h.limiter.GetWalletLimiter(to.String())
 	if !limiter.Allow() {
 		http.Error(w, http.StatusText(http.StatusTooManyRequests)+": wallet limit", http.StatusTooManyRequests)
 		return
@@ -269,37 +227,11 @@ func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		return
 	}

-	var smsg *types.SignedMessage
-	if r.RequestURI == "/send" {
-		smsg, err = h.api.MpoolPushMessage(
-			h.ctx, &types.Message{
-				Value: types.BigInt(h.sendPerRequest),
-				From:  h.from,
-				To:    filecoinAddress,
-			}, nil)
-	} else if r.RequestURI == "/datacap" {
-		var params []byte
-		params, err = actors.SerializeParams(
-			&verifregtypes9.AddVerifiedClientParams{
-				Address:   filecoinAddress,
-				Allowance: h.allowance,
-			})
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-		smsg, err = h.api.MpoolPushMessage(
-			h.ctx, &types.Message{
-				Params: params,
-				From:   h.from,
-				To:     verifreg.Address,
-				Method: verifreg.Methods.AddVerifiedClient,
-			}, nil)
-	} else {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
+	smsg, err := h.api.MpoolPushMessage(h.ctx, &types.Message{
+		Value: types.BigInt(h.sendPerRequest),
+		From:  h.from,
+		To:    to,
+	}, nil)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
@@ -1,41 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Grant DataCap - Lotus Fountain</title>
-    <link rel="stylesheet" type="text/css" href="main.css">
-	<script src="https://www.google.com/recaptcha/api.js"></script>
-	<script>
-   		function onSubmit(token) {
-     	document.getElementById("datacap-form").submit();
-   	}
-	</script>
-
-</head>
-<body>
-<div class="Index">
-    <div class="Index-nodes">
-        <div class="Index-node">
-            <h3>Grant datacap</h3>
-            <p>Please input your address to receive a data cap on the Calibration Testnet.</p>
-        </div>
-        <div class="Index-node">
-            <form action='/datacap' method='post' id='datacap-form'>
-                <span>Enter destination address:</span>
-                <input type='text' name='address' style="width: 300px" placeholder="t0/1/2/3/4 or 0xETH">
-                <button class="g-recaptcha"
-                        data-sitekey="{{ . }}"
-                        data-callback='onSubmit'
-                        data-action='submit'>Grant Datacap</button>
-            </form>
-        </div>
-    </div>
-
-    <div class="Index-footer">
-        <div>
-            <a href="index.html">[Back]</a>
-            <span style="float: right">Not dispensing real Filecoin tokens</span>
-        </div>
-    </div>
-</div>
-</body>
-</html>
@@ -15,13 +15,12 @@
 <div class="Index">
    <div class="Index-nodes">
        <div class="Index-node">
-            <h3>Send funds</h3>
-            <p>Please input your address to receive test FIL (tFIL) on the Calibration Testnet. This faucet dispenses 100 tFIL.</p>
+            [SENDING FUNDS]
        </div>
        <div class="Index-node">
            <form action='/send' method='post' id='funds-form'>
                <span>Enter destination address:</span>
-                <input type='text' name='address' style="width: 300px" placeholder="Enter t0/1/2/3/4 or 0xETH">
+				<input type='text' name='address' style="width: 300px">
 				<button class="g-recaptcha" 
 						data-sitekey="{{ . }}"
 						data-callback='onSubmit' 
@@ -8,16 +8,10 @@
 <div class="Index">
    <div class="Index-nodes">
        <div class="Index-node">
-            LOTUS DEVNET FAUCET
+            [LOTUS DEVNET FAUCET]
        </div>
        <div class="Index-node">
-            <a href="funds.html">Send Funds</a>
-        </div>
-        <div class="Index-node">
-            LOTUS DEVNET GRANT DATACAP
-        </div>
-        <div class="Index-node">
-            <a href="datacap.html">Grant DataCap</a>
+            <a href="funds.html">[Send Funds]</a>
        </div>
    </div>
    <div class="Index-footer">
@@ -1,6 +1,7 @@
 body {
-    font-family: 'Helvetica Neue', sans-serif;
-    background-color: #f0f0f0;
+    font-family: 'monospace';
+    background: #1f1f1f;
+    color: #f0f0f0;
    padding: 0;
    margin: 0;
 }
@@ -8,22 +9,21 @@ body {
 .Index {
    width: 100vw;
    height: 100vh;
-    background-color: #f0f0f0;
-    color: #333;
-    font-family: 'Helvetica Neue', sans-serif;
+    background: #1a1a1a;
+    color: #f0f0f0;
+    font-family: monospace;

    display: grid;
    grid-template-columns: auto 40vw auto;
    grid-template-rows: auto auto auto 3em;
    grid-template-areas:
-    ". . . ."
-    ". main main ."
-    ". . . ."
-    "footer footer footer footer";
+            ". . . ."
+            ". main main ."
+            ". . . ."
+            "footer footer footer footer";
 }
-
 .Index-footer {
-    background-color: #333;
+    background: #2a2a2a;
    grid-area: footer;
 }

@@ -34,49 +34,23 @@ body {

 .Index-nodes {
    grid-area: main;
+    background: #2a2a2a;
 }

 .Index-node {
    margin: 5px;
    padding: 15px;
-    background-color: #fff;
-    box-shadow: 0 0 5px rgba(0, 0, 0, 0.1);
-}
-
-span {
-    display: block;
-    margin-bottom: 5px;
-}
-
-input[type="text"] {
-    width: 100%;
-    padding: 10px;
-    border-radius: 5px;
-    border: 1px solid #ccc;
-    margin-bottom: 10px;
-}
-
-button {
-    background-color: #4c9aff;
-    color: #fff;
-    border: none;
-    border-radius: 5px;
-    padding: 10px 20px;
-    font-size: 1.2em;
-}
-
-button:hover {
-    background-color: #4c7eff;
+    background: #1f1f1f;
 }

 a:link {
-    color: #333;
+    color: #50f020;
 }

 a:visited {
-    color: #333;
+    color: #50f020;
 }

 a:hover {
-    color: #555;
+    color: #30a00a;
 }
@@ -1166,7 +1166,7 @@ var actorConfirmChangeWorker = &cli.Command{
 var actorConfirmChangeBeneficiary = &cli.Command{
 	Name:      "confirm-change-beneficiary",
 	Usage:     "Confirm a beneficiary address change",
-	ArgsUsage: "[minerID]",
+	ArgsUsage: "[minerAddress]",
 	Flags: []cli.Flag{
 		&cli.BoolFlag{
 			Name:  "really-do-it",
@@ -43,16 +43,16 @@ func main() {
 		backupCmd,
 		lcli.WithCategory("chain", actorCmd),
 		lcli.WithCategory("chain", infoCmd),
-		lcli.WithCategory("market", setHidden(storageDealsCmd)),
-		lcli.WithCategory("market", setHidden(retrievalDealsCmd)),
-		lcli.WithCategory("market", setHidden(dataTransfersCmd)),
-		lcli.WithCategory("market", setHidden(dagstoreCmd)),
-		lcli.WithCategory("market", setHidden(indexProvCmd)),
+		lcli.WithCategory("market", storageDealsCmd),
+		lcli.WithCategory("market", retrievalDealsCmd),
+		lcli.WithCategory("market", dataTransfersCmd),
+		lcli.WithCategory("market", dagstoreCmd),
+		lcli.WithCategory("market", indexProvCmd),
 		lcli.WithCategory("storage", sectorsCmd),
 		lcli.WithCategory("storage", provingCmd),
 		lcli.WithCategory("storage", storageCmd),
 		lcli.WithCategory("storage", sealingCmd),
-		lcli.WithCategory("retrieval", setHidden(piecesCmd)),
+		lcli.WithCategory("retrieval", piecesCmd),
 	}

 	jaeger := tracing.SetupJaegerTracing("lotus")
@@ -86,7 +86,6 @@ func main() {
 	// adapt the Net* commands to always hit the node running the markets
 	// subsystem, as that is the only one that runs a libp2p node.
 	netCmd := *lcli.NetCmd // make a copy.
-	netCmd.Hidden = true
 	prev := netCmd.Before
 	netCmd.Before = func(c *cli.Context) error {
 		if prev != nil {
@@ -138,12 +137,11 @@ func main() {
 			&cli.StringFlag{
 				Name:    FlagMarketsRepo,
 				EnvVars: []string{"LOTUS_MARKETS_PATH"},
-				Hidden:  true,
+				Usage:   fmt.Sprintf("Markets repo path"),
 			},
 			&cli.BoolFlag{
-				Name:   "call-on-markets",
-				Usage:  "(experimental; may be removed) call this command against a markets node; use only with common commands like net, auth, pprof, etc. whose target may be ambiguous",
-				Hidden: true,
+				Name:  "call-on-markets",
+				Usage: "(experimental; may be removed) call this command against a markets node; use only with common commands like net, auth, pprof, etc. whose target may be ambiguous",
 			},
 			cliutil.FlagVeryVerbose,
 		},
@@ -192,8 +190,3 @@ func getActorAddress(ctx context.Context, cctx *cli.Context) (maddr address.Addr

 	return maddr, nil
 }
-
-func setHidden(cmd *cli.Command) *cli.Command {
-	cmd.Hidden = true
-	return cmd
-}
@@ -2,11 +2,9 @@ package main

 import (
 	"bufio"
-	"encoding/csv"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"math"
 	"os"
 	"sort"
 	"strconv"
@@ -320,9 +318,6 @@ var sectorsListCmd = &cli.Command{
 			Value: parallelSectorChecks,
 		},
 	},
-	Subcommands: []*cli.Command{
-		sectorsListUpgradeBoundsCmd,
-	},
 	Action: func(cctx *cli.Context) error {
 		// http mode allows for parallel json decoding/encoding, which was a bottleneck here
 		minerApi, closer, err := lcli.GetStorageMinerAPI(cctx, cliutil.StorageMinerUseHttp)
@@ -590,169 +585,6 @@ var sectorsListCmd = &cli.Command{
 	},
 }

-var sectorsListUpgradeBoundsCmd = &cli.Command{
-	Name:  "upgrade-bounds",
-	Usage: "Output upgrade bounds for available sectors",
-	Flags: []cli.Flag{
-		&cli.IntFlag{
-			Name:  "buckets",
-			Value: 25,
-		},
-		&cli.BoolFlag{
-			Name:  "csv",
-			Usage: "output machine-readable values",
-		},
-		&cli.BoolFlag{
-			Name:  "deal-terms",
-			Usage: "bucket by how many deal-sectors can start at a given expiration",
-		},
-	},
-	Action: func(cctx *cli.Context) error {
-		minerApi, closer, err := lcli.GetStorageMinerAPI(cctx, cliutil.StorageMinerUseHttp)
-		if err != nil {
-			return err
-		}
-		defer closer()
-
-		fullApi, closer2, err := lcli.GetFullNodeAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer2()
-
-		ctx := lcli.ReqContext(cctx)
-
-		list, err := minerApi.SectorsListInStates(ctx, []api.SectorState{
-			api.SectorState(sealing.Available),
-		})
-		if err != nil {
-			return xerrors.Errorf("getting sector list: %w", err)
-		}
-
-		head, err := fullApi.ChainHead(ctx)
-		if err != nil {
-			return xerrors.Errorf("getting chain head: %w", err)
-		}
-
-		filter := bitfield.New()
-
-		for _, s := range list {
-			filter.Set(uint64(s))
-		}
-
-		maddr, err := minerApi.ActorAddress(ctx)
-		if err != nil {
-			return err
-		}
-
-		sset, err := fullApi.StateMinerSectors(ctx, maddr, &filter, head.Key())
-		if err != nil {
-			return err
-		}
-
-		if len(sset) == 0 {
-			return nil
-		}
-
-		var minExpiration, maxExpiration abi.ChainEpoch
-
-		for _, s := range sset {
-			if s.Expiration < minExpiration || minExpiration == 0 {
-				minExpiration = s.Expiration
-			}
-			if s.Expiration > maxExpiration {
-				maxExpiration = s.Expiration
-			}
-		}
-
-		buckets := cctx.Int("buckets")
-		bucketSize := (maxExpiration - minExpiration) / abi.ChainEpoch(buckets)
-		bucketCounts := make([]int, buckets+1)
-
-		for b := range bucketCounts {
-			bucketMin := minExpiration + abi.ChainEpoch(b)*bucketSize
-			bucketMax := minExpiration + abi.ChainEpoch(b+1)*bucketSize
-
-			if cctx.Bool("deal-terms") {
-				bucketMax = bucketMax + policy.MarketDefaultAllocationTermBuffer
-			}
-
-			for _, s := range sset {
-				isInBucket := s.Expiration >= bucketMin && s.Expiration < bucketMax
-
-				if isInBucket {
-					bucketCounts[b]++
-				}
-			}
-
-		}
-
-		// Creating CSV writer
-		writer := csv.NewWriter(os.Stdout)
-
-		// Writing CSV headers
-		err = writer.Write([]string{"Max Expiration in Bucket", "Sector Count"})
-		if err != nil {
-			return xerrors.Errorf("writing csv headers: %w", err)
-		}
-
-		// Writing bucket details
-
-		if cctx.Bool("csv") {
-			for i := 0; i < buckets; i++ {
-				maxExp := minExpiration + abi.ChainEpoch(i+1)*bucketSize
-
-				timeStr := strconv.FormatInt(int64(maxExp), 10)
-
-				err = writer.Write([]string{
-					timeStr,
-					strconv.Itoa(bucketCounts[i]),
-				})
-				if err != nil {
-					return xerrors.Errorf("writing csv row: %w", err)
-				}
-			}
-
-			// Flush to make sure all data is written to the underlying writer
-			writer.Flush()
-
-			if err := writer.Error(); err != nil {
-				return xerrors.Errorf("flushing csv writer: %w", err)
-			}
-
-			return nil
-		}
-
-		tw := tablewriter.New(
-			tablewriter.Col("Bucket Expiration"),
-			tablewriter.Col("Sector Count"),
-			tablewriter.Col("Bar"),
-		)
-
-		var barCols = 40
-		var maxCount int
-
-		for _, c := range bucketCounts {
-			if c > maxCount {
-				maxCount = c
-			}
-		}
-
-		for i := 0; i < buckets; i++ {
-			maxExp := minExpiration + abi.ChainEpoch(i+1)*bucketSize
-			timeStr := cliutil.EpochTime(head.Height(), maxExp)
-
-			tw.Write(map[string]interface{}{
-				"Bucket Expiration": timeStr,
-				"Sector Count":      color.YellowString("%d", bucketCounts[i]),
-				"Bar":               "[" + color.GreenString(strings.Repeat("|", bucketCounts[i]*barCols/maxCount)) + strings.Repeat(" ", barCols-bucketCounts[i]*barCols/maxCount) + "]",
-			})
-		}
-
-		return tw.Flush(os.Stdout)
-	},
-}
-
 var sectorsRefsCmd = &cli.Command{
 	Name:  "refs",
 	Usage: "List References to sectors",
@@ -2090,31 +1922,10 @@ var sectorsBatchingPendingCommit = &cli.Command{
 			for _, sector := range pending {
 				fmt.Println(sector.Number)
 			}
-
-			reader := bufio.NewReader(os.Stdin)
-			fmt.Print("Do you want to publish these sectors now? (yes/no): ")
-			userInput, err := reader.ReadString('\n')
-			if err != nil {
-				return xerrors.Errorf("reading user input: %w", err)
-			}
-			userInput = strings.ToLower(strings.TrimSpace(userInput))
-
-			if userInput == "yes" {
-				err := cctx.Set("publish-now", "true")
-				if err != nil {
-					return xerrors.Errorf("setting publish-now flag: %w", err)
-				}
-				return cctx.Command.Action(cctx)
-			} else if userInput == "no" {
-				return nil
-			} else {
-				fmt.Println("Invalid input. Please answer with 'yes' or 'no'.")
-				return nil
-			}
-
-		} else {
-			fmt.Println("No sectors queued to be committed")
+			return nil
 		}
+
+		fmt.Println("No sectors queued to be committed")
 		return nil
 	},
 }
@@ -2169,31 +1980,10 @@ var sectorsBatchingPendingPreCommit = &cli.Command{
 			for _, sector := range pending {
 				fmt.Println(sector.Number)
 			}
-
-			reader := bufio.NewReader(os.Stdin)
-			fmt.Print("Do you want to publish these sectors now? (yes/no): ")
-			userInput, err := reader.ReadString('\n')
-			if err != nil {
-				return xerrors.Errorf("reading user input: %w", err)
-			}
-			userInput = strings.ToLower(strings.TrimSpace(userInput))
-
-			if userInput == "yes" {
-				err := cctx.Set("publish-now", "true")
-				if err != nil {
-					return xerrors.Errorf("setting publish-now flag: %w", err)
-				}
-				return cctx.Command.Action(cctx)
-			} else if userInput == "no" {
-				return nil
-			} else {
-				fmt.Println("Invalid input. Please answer with 'yes' or 'no'.")
-				return nil
-			}
-
-		} else {
-			fmt.Println("No sectors queued to be committed")
+			return nil
 		}
+
+		fmt.Println("No sectors queued to be committed")
 		return nil
 	},
 }
@@ -2224,6 +2014,7 @@ func yesno(b bool) string {
 	return color.RedString("NO")
 }

+// TODO simulate this call if --really-do-it is not used
 var sectorsCompactPartitionsCmd = &cli.Command{
 	Name:  "compact-partitions",
 	Usage: "removes dead sectors from partitions and reduces the number of partitions used if possible",
@@ -2249,7 +2040,12 @@ var sectorsCompactPartitionsCmd = &cli.Command{
 		},
 	},
 	Action: func(cctx *cli.Context) error {
-		fullNodeAPI, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if !cctx.Bool("really-do-it") {
+			fmt.Println("Pass --really-do-it to actually execute this action")
+			return nil
+		}
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
 		}
@@ -2262,7 +2058,7 @@ var sectorsCompactPartitionsCmd = &cli.Command{
 			return err
 		}

-		minfo, err := fullNodeAPI.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+		minfo, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
 		if err != nil {
 			return err
 		}
@@ -2278,118 +2074,46 @@ var sectorsCompactPartitionsCmd = &cli.Command{
 		}
 		fmt.Printf("compacting %d paritions\n", len(parts))

-		var makeMsgForPartitions func(partitionsBf bitfield.BitField) ([]*types.Message, error)
-		makeMsgForPartitions = func(partitionsBf bitfield.BitField) ([]*types.Message, error) {
-			params := miner.CompactPartitionsParams{
-				Deadline:   deadline,
-				Partitions: partitionsBf,
-			}
-
-			sp, aerr := actors.SerializeParams(&params)
-			if aerr != nil {
-				return nil, xerrors.Errorf("serializing params: %w", err)
-			}
-
-			msg := &types.Message{
-				From:   minfo.Worker,
-				To:     maddr,
-				Method: builtin.MethodsMiner.CompactPartitions,
-				Value:  big.Zero(),
-				Params: sp,
-			}
-
-			estimatedMsg, err := fullNodeAPI.GasEstimateMessageGas(ctx, msg, nil, types.EmptyTSK)
-			if err != nil && xerrors.Is(err, &api.ErrOutOfGas{}) {
-				// the message is too big -- split into 2
-				partitionsSlice, err := partitionsBf.All(math.MaxUint64)
-				if err != nil {
-					return nil, err
-				}
-
-				partitions1 := bitfield.New()
-				for i := 0; i < len(partitionsSlice)/2; i++ {
-					partitions1.Set(uint64(i))
-				}
-
-				msgs1, err := makeMsgForPartitions(partitions1)
-				if err != nil {
-					return nil, err
-				}
-
-				// time for the second half
-				partitions2 := bitfield.New()
-				for i := len(partitionsSlice) / 2; i < len(partitionsSlice); i++ {
-					partitions2.Set(uint64(i))
-				}
-
-				msgs2, err := makeMsgForPartitions(partitions2)
-				if err != nil {
-					return nil, err
-				}
-
-				return append(msgs1, msgs2...), nil
-			} else if err != nil {
-				return nil, err
-			}
-
-			return []*types.Message{estimatedMsg}, nil
-		}
-
 		partitions := bitfield.New()
 		for _, partition := range parts {
 			partitions.Set(uint64(partition))
 		}

-		msgs, err := makeMsgForPartitions(partitions)
+		params := miner.CompactPartitionsParams{
+			Deadline:   deadline,
+			Partitions: partitions,
+		}
+
+		sp, err := actors.SerializeParams(&params)
 		if err != nil {
-			return xerrors.Errorf("failed to make messages: %w", err)
+			return xerrors.Errorf("serializing params: %w", err)
 		}

-		// Actually send the messages if really-do-it provided, simulate otherwise
-		if cctx.Bool("really-do-it") {
-			smsgs, err := fullNodeAPI.MpoolBatchPushMessage(ctx, msgs, nil)
-			if err != nil {
-				return xerrors.Errorf("mpool push: %w", err)
-			}
-
-			if len(smsgs) == 1 {
-				fmt.Printf("Requested compact partitions in message %s\n", smsgs[0].Cid())
-			} else {
-				fmt.Printf("Requested compact partitions in %d messages\n\n", len(smsgs))
-				for _, v := range smsgs {
-					fmt.Println(v.Cid())
-				}
-			}
-
-			for _, v := range smsgs {
-				wait, err := fullNodeAPI.StateWaitMsg(ctx, v.Cid(), 2)
-				if err != nil {
-					return err
-				}
-
-				// check it executed successfully
-				if wait.Receipt.ExitCode.IsError() {
-					fmt.Println(cctx.App.Writer, "compact partitions msg %s failed!", v.Cid())
-					return err
-				}
-			}
-
-			return nil
+		smsg, err := api.MpoolPushMessage(ctx, &types.Message{
+			From:   minfo.Worker,
+			To:     maddr,
+			Method: builtin.MethodsMiner.CompactPartitions,
+			Value:  big.Zero(),
+			Params: sp,
+		}, nil)
+		if err != nil {
+			return xerrors.Errorf("mpool push: %w", err)
 		}

-		for i, v := range msgs {
-			fmt.Printf("total of %d CompactPartitions msgs would be sent\n", len(msgs))
+		fmt.Printf("Requested compact partitions in message %s\n", smsg.Cid())

-			estMsg, err := fullNodeAPI.GasEstimateMessageGas(ctx, v, nil, types.EmptyTSK)
-			if err != nil {
-				return err
-			}
+		wait, err := api.StateWaitMsg(ctx, smsg.Cid(), 0)
+		if err != nil {
+			return err
+		}

-			fmt.Printf("msg %d would cost up to %s\n", i+1, types.FIL(estMsg.RequiredFunds()))
+		// check it executed successfully
+		if wait.Receipt.ExitCode.IsError() {
+			fmt.Println(cctx.App.Writer, "compact partitions failed!")
+			return err
 		}

 		return nil
-
 	},
 }

@@ -225,7 +225,6 @@ var storageRedeclareCmd = &cli.Command{
 		&cli.BoolFlag{
 			Name:  "drop-missing",
 			Usage: "Drop index entries with missing files",
-			Value: true,
 		},
 	},
 	Action: func(cctx *cli.Context) error {
@@ -236,19 +235,14 @@ var storageRedeclareCmd = &cli.Command{
 		defer closer()
 		ctx := lcli.ReqContext(cctx)

-		// check if no argument and no --id or --all flag is provided
-		if cctx.NArg() == 0 && !cctx.IsSet("id") && !cctx.Bool("all") {
-			return xerrors.Errorf("You must specify a storage path, or --id, or --all")
+		if cctx.NArg() != 1 {
+			return lcli.IncorrectNumArgs(cctx)
 		}

 		if cctx.IsSet("id") && cctx.Bool("all") {
 			return xerrors.Errorf("--id and --all can't be passed at the same time")
 		}

-		if cctx.Bool("all") && cctx.NArg() > 0 {
-			return xerrors.Errorf("No additional arguments are expected when --all is set")
-		}
-
 		if cctx.IsSet("id") {
 			id := storiface.ID(cctx.String("id"))
 			return minerApi.StorageRedeclareLocal(ctx, &id, cctx.Bool("drop-missing"))
@@ -258,28 +252,7 @@ var storageRedeclareCmd = &cli.Command{
 			return minerApi.StorageRedeclareLocal(ctx, nil, cctx.Bool("drop-missing"))
 		}

-		// As no --id or --all flag is set, we can assume the argument is a path.
-		path := cctx.Args().First()
-		metaFilePath := filepath.Join(path, "sectorstore.json")
-
-		var meta storiface.LocalStorageMeta
-		metaFile, err := os.Open(metaFilePath)
-		if err != nil {
-			return xerrors.Errorf("Failed to open file: %w", err)
-		}
-		defer func() {
-			if closeErr := metaFile.Close(); closeErr != nil {
-				log.Error("Failed to close the file: %v", closeErr)
-			}
-		}()
-
-		err = json.NewDecoder(metaFile).Decode(&meta)
-		if err != nil {
-			return xerrors.Errorf("Failed to decode file: %w", err)
-		}
-
-		id := meta.ID
-		return minerApi.StorageRedeclareLocal(ctx, &id, cctx.Bool("drop-missing"))
+		return xerrors.Errorf("either --all or --id must be specified")
 	},
 }

@@ -968,7 +968,7 @@ var actorProposeChangeBeneficiary = &cli.Command{
 var actorConfirmChangeBeneficiary = &cli.Command{
 	Name:      "confirm-change-beneficiary",
 	Usage:     "Confirm a beneficiary address change",
-	ArgsUsage: "[minerID]",
+	ArgsUsage: "[minerAddress]",
 	Flags: []cli.Flag{
 		&cli.BoolFlag{
 			Name:  "really-do-it",
@@ -9,7 +9,6 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"

 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/types/ethtypes"
 	lcli "github.com/filecoin-project/lotus/cli"
 )

@@ -24,7 +23,6 @@ var ethCmd = &cli.Command{
 	},
 	Subcommands: []*cli.Command{
 		checkTipsetsCmd,
-		computeEthHashCmd,
 	},
 }

@@ -72,36 +70,3 @@ var checkTipsetsCmd = &cli.Command{
 		return nil
 	},
 }
-
-var computeEthHashCmd = &cli.Command{
-	Name:  "compute-eth-hash",
-	Usage: "Compute the eth hash for a given message CID",
-	Action: func(cctx *cli.Context) error {
-		if cctx.NArg() != 1 {
-			return lcli.IncorrectNumArgs(cctx)
-		}
-
-		msg, err := messageFromString(cctx, cctx.Args().First())
-		if err != nil {
-			return err
-		}
-
-		switch msg := msg.(type) {
-		case *types.SignedMessage:
-			tx, err := ethtypes.EthTxFromSignedEthMessage(msg)
-			if err != nil {
-				return fmt.Errorf("failed to convert from signed message: %w", err)
-			}
-
-			tx.Hash, err = tx.TxHash()
-			if err != nil {
-				return fmt.Errorf("failed to call TxHash: %w", err)
-			}
-			fmt.Println(tx.Hash)
-		default:
-			return fmt.Errorf("not a signed message")
-		}
-
-		return nil
-	},
-}
@@ -1,337 +0,0 @@
-package main
-
-import (
-	"database/sql"
-	"fmt"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"github.com/mitchellh/go-homedir"
-	"github.com/urfave/cli/v2"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/crypto"
-
-	"github.com/filecoin-project/lotus/chain/types/ethtypes"
-	lcli "github.com/filecoin-project/lotus/cli"
-)
-
-func withCategory(cat string, cmd *cli.Command) *cli.Command {
-	cmd.Category = strings.ToUpper(cat)
-	return cmd
-}
-
-var indexesCmd = &cli.Command{
-	Name:            "indexes",
-	Usage:           "Commands related to managing sqlite indexes",
-	HideHelpCommand: true,
-	Subcommands: []*cli.Command{
-		withCategory("msgindex", backfillMsgIndexCmd),
-		withCategory("msgindex", pruneMsgIndexCmd),
-		withCategory("txhash", backfillTxHashCmd),
-	},
-}
-
-var backfillMsgIndexCmd = &cli.Command{
-	Name:  "backfill-msgindex",
-	Usage: "Backfill the msgindex.db for a number of epochs starting from a specified height",
-	Flags: []cli.Flag{
-		&cli.IntFlag{
-			Name:  "from",
-			Value: 0,
-			Usage: "height to start the backfill; uses the current head if omitted",
-		},
-		&cli.IntFlag{
-			Name:  "epochs",
-			Value: 1800,
-			Usage: "number of epochs to backfill; defaults to 1800 (2 finalities)",
-		},
-	},
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := lcli.GetFullNodeAPI(cctx)
-		if err != nil {
-			return err
-		}
-
-		defer closer()
-		ctx := lcli.ReqContext(cctx)
-
-		curTs, err := api.ChainHead(ctx)
-		if err != nil {
-			return err
-		}
-
-		startHeight := int64(cctx.Int("from"))
-		if startHeight == 0 {
-			startHeight = int64(curTs.Height()) - 1
-		}
-		epochs := cctx.Int("epochs")
-
-		basePath, err := homedir.Expand(cctx.String("repo"))
-		if err != nil {
-			return err
-		}
-
-		dbPath := path.Join(basePath, "sqlite", "msgindex.db")
-		db, err := sql.Open("sqlite3", dbPath)
-		if err != nil {
-			return err
-		}
-
-		defer func() {
-			err := db.Close()
-			if err != nil {
-				fmt.Printf("ERROR: closing db: %s", err)
-			}
-		}()
-
-		insertStmt, err := db.Prepare("INSERT OR IGNORE INTO messages (cid, tipset_cid, epoch) VALUES (?, ?, ?)")
-		if err != nil {
-			return err
-		}
-
-		var nrRowsAffected int64
-		for i := 0; i < epochs; i++ {
-			epoch := abi.ChainEpoch(startHeight - int64(i))
-
-			if i%100 == 0 {
-				log.Infof("%d/%d processing epoch:%d, nrRowsAffected:%d", i, epochs, epoch, nrRowsAffected)
-			}
-
-			ts, err := api.ChainGetTipSetByHeight(ctx, epoch, curTs.Key())
-			if err != nil {
-				return fmt.Errorf("failed to get tipset at epoch %d: %w", epoch, err)
-			}
-
-			tsCid, err := ts.Key().Cid()
-			if err != nil {
-				return fmt.Errorf("failed to get tipset cid at epoch %d: %w", epoch, err)
-			}
-
-			msgs, err := api.ChainGetMessagesInTipset(ctx, ts.Key())
-			if err != nil {
-				return fmt.Errorf("failed to get messages in tipset at epoch %d: %w", epoch, err)
-			}
-
-			for _, msg := range msgs {
-				key := msg.Cid.String()
-				tskey := tsCid.String()
-				res, err := insertStmt.Exec(key, tskey, int64(epoch))
-				if err != nil {
-					return fmt.Errorf("failed to insert message cid %s in tipset %s at epoch %d: %w", key, tskey, epoch, err)
-				}
-				rowsAffected, err := res.RowsAffected()
-				if err != nil {
-					return fmt.Errorf("failed to get rows affected for message cid %s in tipset %s at epoch %d: %w", key, tskey, epoch, err)
-				}
-				nrRowsAffected += rowsAffected
-			}
-		}
-
-		log.Infof("Done backfilling, nrRowsAffected:%d", nrRowsAffected)
-
-		return nil
-	},
-}
-
-var pruneMsgIndexCmd = &cli.Command{
-	Name:  "prune-msgindex",
-	Usage: "Prune the msgindex.db for messages included before a given epoch",
-	Flags: []cli.Flag{
-		&cli.IntFlag{
-			Name:  "from",
-			Usage: "height to start the prune; if negative it indicates epochs from current head",
-		},
-	},
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := lcli.GetFullNodeAPI(cctx)
-		if err != nil {
-			return err
-		}
-
-		defer closer()
-		ctx := lcli.ReqContext(cctx)
-
-		startHeight := int64(cctx.Int("from"))
-		if startHeight < 0 {
-			curTs, err := api.ChainHead(ctx)
-			if err != nil {
-				return err
-			}
-
-			startHeight += int64(curTs.Height())
-
-			if startHeight < 0 {
-				return xerrors.Errorf("bogus start height %d", startHeight)
-			}
-		}
-
-		basePath, err := homedir.Expand(cctx.String("repo"))
-		if err != nil {
-			return err
-		}
-
-		dbPath := path.Join(basePath, "sqlite", "msgindex.db")
-		db, err := sql.Open("sqlite3", dbPath)
-		if err != nil {
-			return err
-		}
-
-		defer func() {
-			err := db.Close()
-			if err != nil {
-				fmt.Printf("ERROR: closing db: %s", err)
-			}
-		}()
-
-		tx, err := db.Begin()
-		if err != nil {
-			return err
-		}
-
-		if _, err := tx.Exec("DELETE FROM messages WHERE epoch < ?", startHeight); err != nil {
-			if err := tx.Rollback(); err != nil {
-				fmt.Printf("ERROR: rollback: %s", err)
-			}
-			return err
-		}
-
-		if err := tx.Commit(); err != nil {
-			return err
-		}
-
-		return nil
-	},
-}
-
-var backfillTxHashCmd = &cli.Command{
-	Name:  "backfill-txhash",
-	Usage: "Backfills the txhash.db for a number of epochs starting from a specified height",
-	Flags: []cli.Flag{
-		&cli.UintFlag{
-			Name:  "from",
-			Value: 0,
-			Usage: "the tipset height to start backfilling from (0 is head of chain)",
-		},
-		&cli.IntFlag{
-			Name:  "epochs",
-			Value: 2000,
-			Usage: "the number of epochs to backfill",
-		},
-	},
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := lcli.GetFullNodeAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-
-		ctx := lcli.ReqContext(cctx)
-
-		curTs, err := api.ChainHead(ctx)
-		if err != nil {
-			return err
-		}
-
-		startHeight := int64(cctx.Int("from"))
-		if startHeight == 0 {
-			startHeight = int64(curTs.Height()) - 1
-		}
-
-		epochs := cctx.Int("epochs")
-
-		basePath, err := homedir.Expand(cctx.String("repo"))
-		if err != nil {
-			return err
-		}
-
-		dbPath := filepath.Join(basePath, "sqlite", "txhash.db")
-		db, err := sql.Open("sqlite3", dbPath)
-		if err != nil {
-			return err
-		}
-
-		defer func() {
-			err := db.Close()
-			if err != nil {
-				fmt.Printf("ERROR: closing db: %s", err)
-			}
-		}()
-
-		insertStmt, err := db.Prepare("INSERT OR IGNORE INTO eth_tx_hashes(hash, cid) VALUES(?, ?)")
-		if err != nil {
-			return err
-		}
-
-		var totalRowsAffected int64 = 0
-		for i := 0; i < epochs; i++ {
-			epoch := abi.ChainEpoch(startHeight - int64(i))
-
-			select {
-			case <-cctx.Done():
-				fmt.Println("request cancelled")
-				return nil
-			default:
-			}
-
-			curTsk := curTs.Parents()
-			execTs, err := api.ChainGetTipSet(ctx, curTsk)
-			if err != nil {
-				return fmt.Errorf("failed to call ChainGetTipSet for %s: %w", curTsk, err)
-			}
-
-			if i%100 == 0 {
-				log.Infof("%d/%d processing epoch:%d", i, epochs, epoch)
-			}
-
-			for _, blockheader := range execTs.Blocks() {
-				blkMsgs, err := api.ChainGetBlockMessages(ctx, blockheader.Cid())
-				if err != nil {
-					log.Infof("Could not get block messages at epoch: %d, stopping walking up the chain", epoch)
-					epochs = i
-					break
-				}
-
-				for _, smsg := range blkMsgs.SecpkMessages {
-					if smsg.Signature.Type != crypto.SigTypeDelegated {
-						continue
-					}
-
-					tx, err := ethtypes.EthTxFromSignedEthMessage(smsg)
-					if err != nil {
-						return fmt.Errorf("failed to convert from signed message: %w at epoch: %d", err, epoch)
-					}
-
-					tx.Hash, err = tx.TxHash()
-					if err != nil {
-						return fmt.Errorf("failed to calculate hash for ethTx: %w at epoch: %d", err, epoch)
-					}
-
-					res, err := insertStmt.Exec(tx.Hash.String(), smsg.Cid().String())
-					if err != nil {
-						return fmt.Errorf("error inserting tx mapping to db: %s at epoch: %d", err, epoch)
-					}
-
-					rowsAffected, err := res.RowsAffected()
-					if err != nil {
-						return fmt.Errorf("error getting rows affected: %s at epoch: %d", err, epoch)
-					}
-
-					if rowsAffected > 0 {
-						log.Debugf("Inserted txhash %s, cid: %s at epoch: %d", tx.Hash.String(), smsg.Cid().String(), epoch)
-					}
-
-					totalRowsAffected += rowsAffected
-				}
-			}
-
-			curTs = execTs
-		}
-
-		log.Infof("Done, inserted %d missing txhashes", totalRowsAffected)
-
-		return nil
-	},
-}
@@ -1,10 +1,8 @@
 package main

 import (
-	"context"
 	"fmt"
 	"os"
-	"os/signal"

 	logging "github.com/ipfs/go-log/v2"
 	"github.com/urfave/cli/v2"
@@ -86,7 +84,7 @@ func main() {
 		invariantsCmd,
 		gasTraceCmd,
 		replayOfflineCmd,
-		indexesCmd,
+		msgindexCmd,
 		FevmAnalyticsCmd,
 		mismatchesCmd,
 	}
@@ -120,20 +118,7 @@ func main() {
 		},
 	}

-	// terminate early on ctrl+c
-	c := make(chan os.Signal, 1)
-	signal.Notify(c, os.Interrupt)
-	ctx, cancel := context.WithCancel(context.Background())
-	go func() {
-		<-c
-		cancel()
-		fmt.Println("Received interrupt, shutting down... Press CTRL+C again to force shutdown")
-		<-c
-		fmt.Println("Forcing stop")
-		os.Exit(1)
-	}()
-
-	if err := app.RunContext(ctx, os.Args); err != nil {
+	if err := app.Run(os.Args); err != nil {
 		log.Errorf("%+v", err)
 		os.Exit(1)
 		return
@@ -0,0 +1,221 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"path"
+
+	"github.com/ipfs/go-cid"
+	_ "github.com/mattn/go-sqlite3"
+	"github.com/mitchellh/go-homedir"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+var msgindexCmd = &cli.Command{
+	Name:  "msgindex",
+	Usage: "Tools for managing the message index",
+	Subcommands: []*cli.Command{
+		msgindexBackfillCmd,
+		msgindexPruneCmd,
+	},
+}
+
+var msgindexBackfillCmd = &cli.Command{
+	Name:  "backfill",
+	Usage: "Backfill the message index for a number of epochs starting from a specified height",
+	Flags: []cli.Flag{
+		&cli.IntFlag{
+			Name:  "from",
+			Value: 0,
+			Usage: "height to start the backfill; uses the current head if omitted",
+		},
+		&cli.IntFlag{
+			Name:  "epochs",
+			Value: 1800,
+			Usage: "number of epochs to backfill; defaults to 1800 (2 finalities)",
+		},
+		&cli.StringFlag{
+			Name:  "repo",
+			Value: "~/.lotus",
+			Usage: "path to the repo",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		curTs, err := api.ChainHead(ctx)
+		if err != nil {
+			return err
+		}
+
+		startHeight := int64(cctx.Int("from"))
+		if startHeight == 0 {
+			startHeight = int64(curTs.Height()) - 1
+		}
+		epochs := cctx.Int("epochs")
+
+		basePath, err := homedir.Expand(cctx.String("repo"))
+		if err != nil {
+			return err
+		}
+
+		dbPath := path.Join(basePath, "sqlite", "msgindex.db")
+		db, err := sql.Open("sqlite3", dbPath)
+		if err != nil {
+			return err
+		}
+
+		defer func() {
+			err := db.Close()
+			if err != nil {
+				fmt.Printf("ERROR: closing db: %s", err)
+			}
+		}()
+
+		tx, err := db.Begin()
+		if err != nil {
+			return err
+		}
+
+		insertStmt, err := tx.Prepare("INSERT INTO messages VALUES (?, ?, ?)")
+		if err != nil {
+			return err
+		}
+
+		insertMsg := func(cid, tsCid cid.Cid, epoch abi.ChainEpoch) error {
+			key := cid.String()
+			tskey := tsCid.String()
+			if _, err := insertStmt.Exec(key, tskey, int64(epoch)); err != nil {
+				return err
+			}
+
+			return nil
+		}
+		rollback := func() {
+			if err := tx.Rollback(); err != nil {
+				fmt.Printf("ERROR: rollback: %s", err)
+			}
+		}
+
+		for i := 0; i < epochs; i++ {
+			epoch := abi.ChainEpoch(startHeight - int64(i))
+
+			ts, err := api.ChainGetTipSetByHeight(ctx, epoch, curTs.Key())
+			if err != nil {
+				rollback()
+				return err
+			}
+
+			tsCid, err := ts.Key().Cid()
+			if err != nil {
+				rollback()
+				return err
+			}
+
+			msgs, err := api.ChainGetMessagesInTipset(ctx, ts.Key())
+			if err != nil {
+				rollback()
+				return err
+			}
+
+			for _, msg := range msgs {
+				if err := insertMsg(msg.Cid, tsCid, epoch); err != nil {
+					rollback()
+					return err
+				}
+			}
+		}
+
+		if err := tx.Commit(); err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
+var msgindexPruneCmd = &cli.Command{
+	Name:  "prune",
+	Usage: "Prune the message index for messages included before a given epoch",
+	Flags: []cli.Flag{
+		&cli.IntFlag{
+			Name:  "from",
+			Usage: "height to start the prune; if negative it indicates epochs from current head",
+		},
+		&cli.StringFlag{
+			Name:  "repo",
+			Value: "~/.lotus",
+			Usage: "path to the repo",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		startHeight := int64(cctx.Int("from"))
+		if startHeight < 0 {
+			curTs, err := api.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+
+			startHeight += int64(curTs.Height())
+
+			if startHeight < 0 {
+				return xerrors.Errorf("bogus start height %d", startHeight)
+			}
+		}
+
+		basePath, err := homedir.Expand(cctx.String("repo"))
+		if err != nil {
+			return err
+		}
+
+		dbPath := path.Join(basePath, "sqlite", "msgindex.db")
+		db, err := sql.Open("sqlite3", dbPath)
+		if err != nil {
+			return err
+		}
+
+		defer func() {
+			err := db.Close()
+			if err != nil {
+				fmt.Printf("ERROR: closing db: %s", err)
+			}
+		}()
+
+		tx, err := db.Begin()
+		if err != nil {
+			return err
+		}
+
+		if _, err := tx.Exec("DELETE FROM messages WHERE epoch < ?", startHeight); err != nil {
+			if err := tx.Rollback(); err != nil {
+				fmt.Printf("ERROR: rollback: %s", err)
+			}
+			return err
+		}
+
+		if err := tx.Commit(); err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
@@ -653,7 +653,7 @@ fr32 padding is removed from the output.`,
 			return xerrors.Errorf("getting reader: %w", err)
 		}

-		rd, err := readStarter(0, storiface.PaddedByteIndex(length))
+		rd, err := readStarter(0)
 		if err != nil {
 			return xerrors.Errorf("starting reader: %w", err)
 		}
@@ -474,7 +474,7 @@ var verifRegRemoveVerifiedClientDataCapCmd = &cli.Command{

 		st, err := multisig.Load(store, vrkState)
 		if err != nil {
-			return fmt.Errorf("load vrk failed: %w ", err)
+			return err
 		}

 		signers, err := st.Signers()
@@ -508,13 +508,14 @@ var verifRegRemoveVerifiedClientDataCapCmd = &cli.Command{
 			return err
 		}

-		sm, err := lcli.InteractiveSend(ctx, cctx, srv, proto)
+		sm, _, err := srv.PublishMessage(ctx, proto, false)
 		if err != nil {
 			return err
 		}

 		msgCid := sm.Cid()
-		fmt.Println("sending msg: ", msgCid)
+
+		fmt.Printf("message sent, now waiting on cid: %s\n", msgCid)

 		mwait, err := api.StateWaitMsg(ctx, msgCid, uint64(cctx.Int("confidence")), build.Finality, true)
 		if err != nil {
@@ -275,12 +275,6 @@ var runCmd = &cli.Command{
 			Name:  "http-server-timeout",
 			Value: "30s",
 		},
-		&cli.BoolFlag{
-			Name:        "data-cid",
-			Usage:       "Run the data-cid task. true|false",
-			Value:       true,
-			DefaultText: "inherits --addpiece",
-		},
 	},
 	Before: func(cctx *cli.Context) error {
 		if cctx.IsSet("address") {
@@ -392,19 +386,8 @@ var runCmd = &cli.Command{
 			}
 		}

-		ttDataCidDefault := false
 		if (workerType == sealtasks.WorkerSealing || cctx.IsSet("addpiece")) && cctx.Bool("addpiece") {
-			taskTypes = append(taskTypes, sealtasks.TTAddPiece)
-			ttDataCidDefault = true
-		}
-		if workerType == sealtasks.WorkerSealing {
-			if cctx.IsSet("data-cid") {
-				if cctx.Bool("data-cid") {
-					taskTypes = append(taskTypes, sealtasks.TTDataCid)
-				}
-			} else if ttDataCidDefault {
-				taskTypes = append(taskTypes, sealtasks.TTDataCid)
-			}
+			taskTypes = append(taskTypes, sealtasks.TTAddPiece, sealtasks.TTDataCid)
 		}
 		if (workerType == sealtasks.WorkerSealing || cctx.IsSet("sector-download")) && cctx.Bool("sector-download") {
 			taskTypes = append(taskTypes, sealtasks.TTDownloadSector)
@@ -178,7 +178,6 @@ var storageRedeclareCmd = &cli.Command{
 		&cli.BoolFlag{
 			Name:  "drop-missing",
 			Usage: "Drop index entries with missing files",
-			Value: true,
 		},
 	},
 	Action: func(cctx *cli.Context) error {
@@ -189,19 +188,10 @@ var storageRedeclareCmd = &cli.Command{
 		defer closer()
 		ctx := lcli.ReqContext(cctx)

-		// check if no argument and no --id or --all flag is provided
-		if cctx.NArg() == 0 && !cctx.IsSet("id") && !cctx.Bool("all") {
-			return xerrors.Errorf("You must specify a storage path, or --id, or --all")
-		}
-
 		if cctx.IsSet("id") && cctx.Bool("all") {
 			return xerrors.Errorf("--id and --all can't be passed at the same time")
 		}

-		if cctx.Bool("all") && cctx.NArg() > 0 {
-			return xerrors.Errorf("No additional arguments are expected when --all is set")
-		}
-
 		if cctx.IsSet("id") {
 			id := storiface.ID(cctx.String("id"))
 			return nodeApi.StorageRedeclareLocal(ctx, &id, cctx.Bool("drop-missing"))
@@ -211,27 +201,6 @@ var storageRedeclareCmd = &cli.Command{
 			return nodeApi.StorageRedeclareLocal(ctx, nil, cctx.Bool("drop-missing"))
 		}

-		// As no --id or --all flag is set, we can assume the argument is a path.
-		path := cctx.Args().First()
-		metaFilePath := filepath.Join(path, "sectorstore.json")
-
-		var meta storiface.LocalStorageMeta
-		metaFile, err := os.Open(metaFilePath)
-		if err != nil {
-			return xerrors.Errorf("Failed to open file: %w", err)
-		}
-		defer func() {
-			if closeErr := metaFile.Close(); closeErr != nil {
-				log.Error("Failed to close the file: %v", closeErr)
-			}
-		}()
-
-		err = json.NewDecoder(metaFile).Decode(&meta)
-		if err != nil {
-			return xerrors.Errorf("Failed to decode file: %w", err)
-		}
-
-		id := meta.ID
-		return nodeApi.StorageRedeclareLocal(ctx, &id, cctx.Bool("drop-missing"))
+		return xerrors.Errorf("either --all or --id must be specified")
 	},
 }
@@ -16,12 +16,9 @@ import (
 	"strings"

 	"github.com/DataDog/zstd"
-	"github.com/ipfs/go-cid"
-	levelds "github.com/ipfs/go-ds-leveldb"
 	metricsprom "github.com/ipfs/go-metrics-prometheus"
 	"github.com/mitchellh/go-homedir"
 	"github.com/multiformats/go-multiaddr"
-	ldbopts "github.com/syndtr/goleveldb/leveldb/opt"
 	"github.com/urfave/cli/v2"
 	"go.opencensus.io/plugin/runmetrics"
 	"go.opencensus.io/stats"
@@ -30,19 +27,13 @@ import (
 	"golang.org/x/xerrors"
 	"gopkg.in/cheggaaa/pb.v1"

-	"github.com/filecoin-project/go-address"
-	cborutil "github.com/filecoin-project/go-cbor-util"
 	"github.com/filecoin-project/go-jsonrpc"
 	"github.com/filecoin-project/go-paramfetch"
-	"github.com/filecoin-project/go-state-types/builtin"
-	"github.com/filecoin-project/specs-actors/actors/builtin/miner"

 	lapi "github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/consensus"
 	"github.com/filecoin-project/lotus/chain/consensus/filcns"
-	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
 	"github.com/filecoin-project/lotus/chain/index"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
@@ -169,19 +160,6 @@ var DaemonCmd = &cli.Command{
 			Name:  "restore-config",
 			Usage: "config file to use when restoring from backup",
 		},
-		&cli.BoolFlag{
-			Name:  "slash-consensus",
-			Usage: "Report consensus fault",
-			Value: false,
-		},
-		&cli.StringFlag{
-			Name:  "slasher-sender",
-			Usage: "optionally specify the account to report consensus from",
-		},
-		&cli.StringFlag{
-			Name:  "slashdb-dir",
-			Value: "slash watch db dir path",
-		},
 	},
 	Action: func(cctx *cli.Context) error {
 		isLite := cctx.Bool("lite")
@@ -402,14 +380,7 @@ var DaemonCmd = &cli.Command{
 		if err != nil {
 			return fmt.Errorf("failed to start json-rpc endpoint: %s", err)
 		}
-		if cctx.IsSet("slash-consensus") && cctx.IsSet("slashdb-dir") {
-			go func() {
-				err := slashConsensus(api, cctx.String("slashdb-dir"), cctx.String("slasher-sender"))
-				if err != nil {
-					panic("slashConsensus error")
-				}
-			}()
-		}
+
 		// Monitor for shutdown.
 		finishCh := node.MonitorShutdown(shutdownChan,
 			node.ShutdownHandler{Component: "rpc server", StopFunc: rpcStopper},
@@ -603,122 +574,3 @@ func ImportChain(ctx context.Context, r repo.Repo, fname string, snapshot bool)

 	return nil
 }
-
-func slashConsensus(a lapi.FullNode, p string, from string) error {
-	ctx := context.Background()
-	var fromAddr address.Address
-
-	ds, err := levelds.NewDatastore(p, &levelds.Options{
-		Compression: ldbopts.NoCompression,
-		NoSync:      false,
-		Strict:      ldbopts.StrictAll,
-		ReadOnly:    false,
-	})
-	if err != nil {
-		return xerrors.Errorf("open leveldb: %w", err)
-	}
-	sf := slashfilter.New(ds)
-	if from == "" {
-		defaddr, err := a.WalletDefaultAddress(ctx)
-		if err != nil {
-			return err
-		}
-		fromAddr = defaddr
-	} else {
-		addr, err := address.NewFromString(from)
-		if err != nil {
-			return err
-		}
-
-		fromAddr = addr
-	}
-
-	blocks, err := a.SyncIncomingBlocks(ctx)
-	if err != nil {
-		return xerrors.Errorf("sync incoming blocks failed: %w", err)
-	}
-	for block := range blocks {
-		log.Infof("deal with block: %d, %v, %s", block.Height, block.Miner, block.Cid())
-		if otherBlock, extraBlock, err := slashFilterMinedBlock(ctx, sf, a, block); err != nil {
-			if otherBlock == nil {
-				continue
-			}
-			log.Errorf("<!!> SLASH FILTER ERROR: %s", err)
-			bh1, err := cborutil.Dump(otherBlock)
-			if err != nil {
-				log.Errorf("could not dump otherblock:%s, err:%s", otherBlock.Cid(), err)
-				continue
-			}
-
-			bh2, err := cborutil.Dump(block)
-			if err != nil {
-				log.Errorf("could not dump block:%s, err:%s", block.Cid(), err)
-				continue
-			}
-
-			params := miner.ReportConsensusFaultParams{
-				BlockHeader1: bh1,
-				BlockHeader2: bh2,
-			}
-			if extraBlock != nil {
-				be, err := cborutil.Dump(extraBlock)
-				if err != nil {
-					log.Errorf("could not dump block:%s, err:%s", block.Cid(), err)
-					continue
-				}
-				params.BlockHeaderExtra = be
-			}
-
-			enc, err := actors.SerializeParams(&params)
-			if err != nil {
-				log.Errorf("could not serialize declare faults parameters: %s", err)
-				continue
-			}
-			message, err := a.MpoolPushMessage(ctx, &types.Message{
-				To:     block.Miner,
-				From:   fromAddr,
-				Value:  types.NewInt(0),
-				Method: builtin.MethodsMiner.ReportConsensusFault,
-				Params: enc,
-			}, nil)
-			if err != nil {
-				log.Errorf("ReportConsensusFault to messagepool error:%w", err)
-				continue
-			}
-			log.Infof("ReportConsensusFault message CID:%s", message.Cid())
-
-		}
-	}
-	return err
-}
-
-func slashFilterMinedBlock(ctx context.Context, sf *slashfilter.SlashFilter, a lapi.FullNode, blockB *types.BlockHeader) (*types.BlockHeader, *types.BlockHeader, error) {
-	blockC, err := a.ChainGetBlock(ctx, blockB.Parents[0])
-	if err != nil {
-		return nil, nil, xerrors.Errorf("chain get block error:%s", err)
-	}
-	otherCid, err := sf.MinedBlock(ctx, blockB, blockC.Height)
-	if err != nil {
-		return nil, nil, xerrors.Errorf("slash filter check block error:%s", err)
-	}
-	if otherCid != cid.Undef {
-		otherHeader, err := a.ChainGetBlock(ctx, otherCid)
-		return otherHeader, nil, xerrors.Errorf("chain get other block error:%s", err)
-	}
-	blockA, err := a.ChainGetBlock(ctx, otherCid)
-
-	// (c) parent-grinding fault
-	// Here extra is the "witness", a third block that shows the connection between A and B as
-	// A's sibling and B's parent.
-	// Specifically, since A is of lower height, it must be that B was mined omitting A from its tipset
-	//
-	//      B
-	//      |
-	//  [A, C]
-	if types.CidArrsEqual(blockA.Parents, blockC.Parents) && blockA.Height == blockC.Height &&
-		types.CidArrsContains(blockB.Parents, blockC.Cid()) && !types.CidArrsContains(blockB.Parents, blockA.Cid()) {
-		return blockA, blockC, xerrors.Errorf("chain get other block error:%s", err)
-	}
-
-	return nil, nil, nil
-}
@@ -1702,9 +1702,7 @@ Response:
 ```json
 {
  "Reachability": 1,
-  "PublicAddrs": [
-    "string value"
-  ]
+  "PublicAddr": "string value"
 }
 ```

@@ -3710,9 +3710,7 @@ Response:
 ```json
 {
  "Reachability": 1,
-  "PublicAddrs": [
-    "string value"
-  ]
+  "PublicAddr": "string value"
 }
 ```

@@ -4202,7 +4200,7 @@ Inputs:
 Response:
 ```json
 {
-  "Channel": "f01234",
+  "Channel": "\u003cempty\u003e",
  "From": "f01234",
  "To": "f01234",
  "ConfirmedAmt": "0",
@@ -4233,7 +4231,7 @@ Inputs:
 Response:
 ```json
 {
-  "Channel": "f01234",
+  "Channel": "\u003cempty\u003e",
  "From": "f01234",
  "To": "f01234",
  "ConfirmedAmt": "0",
@@ -4953,7 +4951,7 @@ Response:
    },
    "Nonce": 42,
    "Balance": "0",
-    "Address": "f01234"
+    "Address": "\u003cempty\u003e"
  }
 }
 ```
@@ -5242,7 +5240,7 @@ Response:
  },
  "Nonce": 42,
  "Balance": "0",
-  "Address": "f01234"
+  "Address": "\u003cempty\u003e"
 }
 ```

@@ -5430,6 +5428,7 @@ Response:
    "UpgradeRefuelHeight": 10101,
    "UpgradeTapeHeight": 10101,
    "UpgradeKumquatHeight": 10101,
+    "UpgradePriceListOopsHeight": 10101,
    "BreezeGasTampingDuration": 10101,
    "UpgradeCalicoHeight": 10101,
    "UpgradePersianHeight": 10101,
@@ -5985,7 +5984,6 @@ Response:
  "SectorSize": 34359738368,
  "WindowPoStPartitionSectors": 42,
  "ConsensusFaultElapsed": 10101,
-  "PendingOwnerAddress": "f01234",
  "Beneficiary": "f01234",
  "BeneficiaryTerm": {
    "Quota": "0",
@@ -103,7 +103,6 @@
  * [EthProtocolVersion](#EthProtocolVersion)
  * [EthSendRawTransaction](#EthSendRawTransaction)
  * [EthSubscribe](#EthSubscribe)
-  * [EthSyncing](#EthSyncing)
  * [EthUninstallFilter](#EthUninstallFilter)
  * [EthUnsubscribe](#EthUnsubscribe)
 * [Filecoin](#Filecoin)
@@ -2599,7 +2598,7 @@ Polling method for a filter, returns event logs which occurred since last poll.
 (requires write perm since timestamp of last filter execution will be written)


-Perms: read
+Perms: write

 Inputs:
 ```json
@@ -2620,7 +2619,7 @@ Returns event logs matching filter with given id.
 (requires write perm since timestamp of last filter execution will be written)


-Perms: read
+Perms: write

 Inputs:
 ```json
@@ -2991,7 +2990,7 @@ Response: `"0x0"`
 Installs a persistent filter to notify when a new block arrives.


-Perms: read
+Perms: write

 Inputs: `null`

@@ -3001,7 +3000,7 @@ Response: `"0x37690cfec6c1bf4c3b9288c7a5d783e98731e90b0a4c177c2a374c7a9427355e"`
 Installs a persistent filter based on given filter spec.


-Perms: read
+Perms: write

 Inputs:
 ```json
@@ -3022,7 +3021,7 @@ Response: `"0x37690cfec6c1bf4c3b9288c7a5d783e98731e90b0a4c177c2a374c7a9427355e"`
 Installs a persistent filter to notify when new messages arrive in the message pool.


-Perms: read
+Perms: write

 Inputs: `null`

@@ -3061,7 +3060,7 @@ params contains additional parameters used with the log event type
 The client will receive a stream of EthSubscriptionResponse values until EthUnsubscribe is called.


-Perms: read
+Perms: write

 Inputs:
 ```json
@@ -3072,20 +3071,11 @@ Inputs:

 Response: `"0x37690cfec6c1bf4c3b9288c7a5d783e98731e90b0a4c177c2a374c7a9427355e"`

-### EthSyncing
-
-
-Perms: read
-
-Inputs: `null`
-
-Response: `false`
-
 ### EthUninstallFilter
 Uninstalls a filter with given id.


-Perms: read
+Perms: write

 Inputs:
 ```json
@@ -3100,7 +3090,7 @@ Response: `true`
 Unsubscribe from a websocket subscription


-Perms: read
+Perms: write

 Inputs:
 ```json
@@ -5032,9 +5022,7 @@ Response:
 ```json
 {
  "Reachability": 1,
-  "PublicAddrs": [
-    "string value"
-  ]
+  "PublicAddr": "string value"
 }
 ```

@@ -5576,7 +5564,7 @@ Inputs:
 Response:
 ```json
 {
-  "Channel": "f01234",
+  "Channel": "\u003cempty\u003e",
  "From": "f01234",
  "To": "f01234",
  "ConfirmedAmt": "0",
@@ -5607,7 +5595,7 @@ Inputs:
 Response:
 ```json
 {
-  "Channel": "f01234",
+  "Channel": "\u003cempty\u003e",
  "From": "f01234",
  "To": "f01234",
  "ConfirmedAmt": "0",
@@ -6390,7 +6378,7 @@ Response:
    },
    "Nonce": 42,
    "Balance": "0",
-    "Address": "f01234"
+    "Address": "\u003cempty\u003e"
  }
 }
 ```
@@ -6730,7 +6718,7 @@ Response:
  },
  "Nonce": 42,
  "Balance": "0",
-  "Address": "f01234"
+  "Address": "\u003cempty\u003e"
 }
 ```

@@ -6942,6 +6930,7 @@ Response:
    "UpgradeRefuelHeight": 10101,
    "UpgradeTapeHeight": 10101,
    "UpgradeKumquatHeight": 10101,
+    "UpgradePriceListOopsHeight": 10101,
    "BreezeGasTampingDuration": 10101,
    "UpgradeCalicoHeight": 10101,
    "UpgradePersianHeight": 10101,
@@ -7505,7 +7494,6 @@ Response:
  "SectorSize": 34359738368,
  "WindowPoStPartitionSectors": 42,
  "ConsensusFaultElapsed": 10101,
-  "PendingOwnerAddress": "f01234",
  "Beneficiary": "f01234",
  "BeneficiaryTerm": {
    "Quota": "0",
@@ -7,7 +7,7 @@ USAGE:
   lotus-worker [global options] command [command options] [arguments...]

 VERSION:
-   1.23.2-dev
+   1.23.1

 COMMANDS:
   run        Start lotus worker
@@ -19,11 +19,12 @@ COMMANDS:
   help, h    Shows a list of commands or help for one command

 GLOBAL OPTIONS:
-   --worker-repo value, --workerrepo value  Specify worker repo path. flag workerrepo and env WORKER_PATH are DEPRECATION, will REMOVE SOON (default: "~/.lotusworker") [$LOTUS_WORKER_PATH, $WORKER_PATH]
-   --miner-repo value, --storagerepo value  Specify miner repo path. flag storagerepo and env LOTUS_STORAGE_PATH are DEPRECATION, will REMOVE SOON (default: "~/.lotusminer") [$LOTUS_MINER_PATH, $LOTUS_STORAGE_PATH]
   --enable-gpu-proving                     enable use of GPU for mining operations (default: true) [$LOTUS_WORKER_ENABLE_GPU_PROVING]
-   --help, -h                               show help
-   --version, -v                            print the version
+   --help, -h                               show help (default: false)
+   --miner-repo value, --storagerepo value  Specify miner repo path. flag storagerepo and env LOTUS_STORAGE_PATH are DEPRECATION, will REMOVE SOON (default: "~/.lotusminer") [$LOTUS_MINER_PATH, $LOTUS_STORAGE_PATH]
+   --version, -v                            print the version (default: false)
+   --worker-repo value, --workerrepo value  Specify worker repo path. flag workerrepo and env WORKER_PATH are DEPRECATION, will REMOVE SOON (default: "~/.lotusworker") [$LOTUS_WORKER_PATH, $WORKER_PATH]
+   
 ```

 ## lotus-worker run
@@ -35,29 +36,28 @@ USAGE:
   lotus-worker run [command options] [arguments...]

 OPTIONS:
+   --addpiece                    enable addpiece (default: true) [$LOTUS_WORKER_ADDPIECE]
+   --commit                      enable commit (default: true) [$LOTUS_WORKER_COMMIT]
+   --http-server-timeout value   (default: "30s")
   --listen value                host address and port the worker api will listen on (default: "0.0.0.0:3456") [$LOTUS_WORKER_LISTEN]
+   --name value                  custom worker name (default: hostname) [$LOTUS_WORKER_NAME]
+   --no-default                  disable all default compute tasks, use the worker for storage/fetching only (default: false) [$LOTUS_WORKER_NO_DEFAULT]
   --no-local-storage            don't use storageminer repo for sector storage (default: false) [$LOTUS_WORKER_NO_LOCAL_STORAGE]
   --no-swap                     don't use swap (default: false) [$LOTUS_WORKER_NO_SWAP]
-   --name value                  custom worker name (default: hostname) [$LOTUS_WORKER_NAME]
-   --addpiece                    enable addpiece (default: true) [$LOTUS_WORKER_ADDPIECE]
-   --precommit1                  enable precommit1 (default: true) [$LOTUS_WORKER_PRECOMMIT1]
-   --unseal                      enable unsealing (default: true) [$LOTUS_WORKER_UNSEAL]
-   --precommit2                  enable precommit2 (default: true) [$LOTUS_WORKER_PRECOMMIT2]
-   --commit                      enable commit (default: true) [$LOTUS_WORKER_COMMIT]
-   --replica-update              enable replica update (default: true) [$LOTUS_WORKER_REPLICA_UPDATE]
-   --prove-replica-update2       enable prove replica update 2 (default: true) [$LOTUS_WORKER_PROVE_REPLICA_UPDATE2]
-   --regen-sector-key            enable regen sector key (default: true) [$LOTUS_WORKER_REGEN_SECTOR_KEY]
-   --sector-download             enable external sector data download (default: false) [$LOTUS_WORKER_SECTOR_DOWNLOAD]
-   --windowpost                  enable window post (default: false) [$LOTUS_WORKER_WINDOWPOST]
-   --winningpost                 enable winning post (default: false) [$LOTUS_WORKER_WINNINGPOST]
-   --no-default                  disable all default compute tasks, use the worker for storage/fetching only (default: false) [$LOTUS_WORKER_NO_DEFAULT]
   --parallel-fetch-limit value  maximum fetch operations to run in parallel (default: 5) [$LOTUS_WORKER_PARALLEL_FETCH_LIMIT]
   --post-parallel-reads value   maximum number of parallel challenge reads (0 = no limit) (default: 32) [$LOTUS_WORKER_POST_PARALLEL_READS]
   --post-read-timeout value     time limit for reading PoSt challenges (0 = no limit) (default: 0s) [$LOTUS_WORKER_POST_READ_TIMEOUT]
+   --precommit1                  enable precommit1 (default: true) [$LOTUS_WORKER_PRECOMMIT1]
+   --precommit2                  enable precommit2 (default: true) [$LOTUS_WORKER_PRECOMMIT2]
+   --prove-replica-update2       enable prove replica update 2 (default: true) [$LOTUS_WORKER_PROVE_REPLICA_UPDATE2]
+   --regen-sector-key            enable regen sector key (default: true) [$LOTUS_WORKER_REGEN_SECTOR_KEY]
+   --replica-update              enable replica update (default: true) [$LOTUS_WORKER_REPLICA_UPDATE]
+   --sector-download             enable external sector data download (default: false) [$LOTUS_WORKER_SECTOR_DOWNLOAD]
   --timeout value               used when 'listen' is unspecified. must be a valid duration recognized by golang's time.ParseDuration function (default: "30m") [$LOTUS_WORKER_TIMEOUT]
-   --http-server-timeout value   (default: "30s")
-   --data-cid                    Run the data-cid task. true|false (default: inherits --addpiece)
-   --help, -h                    show help
+   --unseal                      enable unsealing (default: true) [$LOTUS_WORKER_UNSEAL]
+   --windowpost                  enable window post (default: false) [$LOTUS_WORKER_WINDOWPOST]
+   --winningpost                 enable winning post (default: false) [$LOTUS_WORKER_WINNINGPOST]
+   
 ```

 ## lotus-worker stop
@@ -69,7 +69,8 @@ USAGE:
   lotus-worker stop [command options] [arguments...]

 OPTIONS:
-   --help, -h  show help
+   --help, -h  show help (default: false)
+   
 ```

 ## lotus-worker info
@@ -81,7 +82,8 @@ USAGE:
   lotus-worker info [command options] [arguments...]

 OPTIONS:
-   --help, -h  show help
+   --help, -h  show help (default: false)
+   
 ```

 ## lotus-worker storage
@@ -93,13 +95,14 @@ USAGE:
   lotus-worker storage command [command options] [arguments...]

 COMMANDS:
-   attach     attach local storage path
-   detach     detach local storage path
-   redeclare  redeclare sectors in a local storage path
-   help, h    Shows a list of commands or help for one command
+     attach     attach local storage path
+     detach     detach local storage path
+     redeclare  redeclare sectors in a local storage path
+     help, h    Shows a list of commands or help for one command

 OPTIONS:
-   --help, -h  show help
+   --help, -h  show help (default: false)
+   
 ```

 ### lotus-worker storage attach
@@ -111,14 +114,14 @@ USAGE:
   lotus-worker storage attach [command options] [arguments...]

 OPTIONS:
+   --allow-to value [ --allow-to value ]  path groups allowed to pull data from this path (allow all if not specified)
+   --groups value [ --groups value ]      path group names
   --init                                 initialize the path first (default: false)
-   --weight value                         (for init) path weight (default: 10)
+   --max-storage value                    (for init) limit storage space for sectors (expensive for very large paths!)
   --seal                                 (for init) use path for sealing (default: false)
   --store                                (for init) use path for long-term storage (default: false)
-   --max-storage value                    (for init) limit storage space for sectors (expensive for very large paths!)
-   --groups value [ --groups value ]      path group names
-   --allow-to value [ --allow-to value ]  path groups allowed to pull data from this path (allow all if not specified)
-   --help, -h                             show help
+   --weight value                         (for init) path weight (default: 10)
+   
 ```

 ### lotus-worker storage detach
@@ -131,7 +134,7 @@ USAGE:

 OPTIONS:
   --really-do-it  (default: false)
-   --help, -h      show help
+   
 ```

 ### lotus-worker storage redeclare
@@ -143,10 +146,10 @@ USAGE:
   lotus-worker storage redeclare [command options] [arguments...]

 OPTIONS:
-   --id value      storage path ID
   --all           redeclare all storage paths (default: false)
-   --drop-missing  Drop index entries with missing files (default: true)
-   --help, -h      show help
+   --drop-missing  Drop index entries with missing files (default: false)
+   --id value      storage path ID
+   
 ```

 ## lotus-worker resources
@@ -158,9 +161,9 @@ USAGE:
   lotus-worker resources [command options] [arguments...]

 OPTIONS:
-   --all       print all resource envvars (default: false)
-   --default   print default resource envvars (default: false)
-   --help, -h  show help
+   --all      print all resource envvars (default: false)
+   --default  print default resource envvars (default: false)
+   
 ```

 ## lotus-worker tasks
@@ -172,12 +175,13 @@ USAGE:
   lotus-worker tasks command [command options] [arguments...]

 COMMANDS:
-   enable   Enable a task type
-   disable  Disable a task type
-   help, h  Shows a list of commands or help for one command
+     enable   Enable a task type
+     disable  Disable a task type
+     help, h  Shows a list of commands or help for one command

 OPTIONS:
-   --help, -h  show help
+   --help, -h  show help (default: false)
+   
 ```

 ### lotus-worker tasks enable
@@ -189,8 +193,8 @@ USAGE:
   lotus-worker tasks enable [command options] --all | [UNS|C2|PC2|PC1|PR2|RU|AP|DC|GSK]

 OPTIONS:
-   --all       Enable all task types (default: false)
-   --help, -h  show help
+   --all  Enable all task types (default: false)
+   
 ```

 ### lotus-worker tasks disable
@@ -202,6 +206,6 @@ USAGE:
   lotus-worker tasks disable [command options] --all | [UNS|C2|PC2|PC1|PR2|RU|AP|DC|GSK]

 OPTIONS:
-   --all       Disable all task types (default: false)
-   --help, -h  show help
+   --all  Disable all task types (default: false)
+   
 ```
@@ -38,7 +38,7 @@
  #
  # type: []string
  # env var: LOTUS_LIBP2P_LISTENADDRESSES
-  #ListenAddresses = ["/ip4/0.0.0.0/tcp/0", "/ip6/::/tcp/0", "/ip4/0.0.0.0/udp/0/quic-v1", "/ip6/::/udp/0/quic-v1", "/ip4/0.0.0.0/udp/0/quic-v1/webtransport", "/ip6/::/udp/0/quic-v1/webtransport"]
+  #ListenAddresses = ["/ip4/0.0.0.0/tcp/0", "/ip6/::/tcp/0"]

  # Addresses to explicitally announce to other peers. If not specified,
  # all interface addresses are announced
@@ -391,7 +391,6 @@


 [Index]
-  # EXPERIMENTAL FEATURE. USE WITH CAUTION
  # EnableMsgIndex enables indexing of messages on chain.
  #
  # type: bool
@@ -38,7 +38,7 @@
  #
  # type: []string
  # env var: LOTUS_LIBP2P_LISTENADDRESSES
-  #ListenAddresses = ["/ip4/0.0.0.0/tcp/0", "/ip6/::/tcp/0", "/ip4/0.0.0.0/udp/0/quic-v1", "/ip6/::/udp/0/quic-v1", "/ip4/0.0.0.0/udp/0/quic-v1/webtransport", "/ip6/::/udp/0/quic-v1/webtransport"]
+  #ListenAddresses = ["/ip4/0.0.0.0/tcp/0", "/ip6/::/tcp/0"]

  # Addresses to explicitally announce to other peers. If not specified,
  # all interface addresses are announced
@@ -515,7 +515,15 @@
  # env var: LOTUS_SEALING_MINUPGRADESECTOREXPIRATION
  #MinUpgradeSectorExpiration = 0

-  # DEPRECATED: Target expiration is no longer used
+  # When set to a non-zero value, minimum number of epochs until sector expiration above which upgrade candidates will
+  # be selected based on lowest initial pledge.
+  # 
+  # Target sector expiration is calculated by looking at the input deal queue, sorting it by deal expiration, and
+  # selecting N deals from the queue up to sector size. The target expiration will be Nth deal end epoch, or in case
+  # where there weren't enough deals to fill a sector, DealMaxDuration (540 days = 1555200 epochs)
+  # 
+  # Setting this to a high value (for example to maximum deal duration - 1555200) will disable selection based on
+  # initial pledge - upgrade sectors will always be chosen based on longest expiration
  #
  # type: uint64
  # env var: LOTUS_SEALING_MINTARGETUPGRADESECTOREXPIRATION
@@ -2,8 +2,8 @@

 The gas balancing process targets to set gas costs of syscalls to be in line with
 10 gas per nanosecond on reference hardware.
-The process can be either performed for all syscalls based on existing messages and chains or targeted
-at a single syscall.
+The process can be either performed for all syscalls based on existing messages and chain or targeted
+at single syscall.

 #### Reference hardware

@@ -12,14 +12,14 @@ may be subject to change.

 ### Complete gas balancing

-Complete gas balancing is performed using a `lotus-bench` the process is based on importing a chain export
+Complete gas balancing is performed using `lotus-bench` the process is based on importing a chain export
 and collecting gas traces which are later aggregated.

 Before building `lotus-bench` make sure `EnableDetailedTracing` in `chain/vm/runtime.go` is set to `true`.

 The process can be started using `./lotus-bench import` with `--car` flag set to the location of
-CAR chain export. `--start-epoch` and `--end-epoch` can be used to limit the range of epochs to run
-the benchmark. Note that the state tree of `start-epoch` needs to be in the CAR file or has to be previously computed
+CAR chain export. `--start-epoch` and `--end-epoch` can be used to to limit the range of epochs to run
+the benchmark. Note that state tree of `start-epoch` needs to be in the CAR file or has to be previously computed
 to work.

 The output will be a `bench.json` file containing information about every syscall invoked
@@ -29,7 +29,7 @@ spare space.
 After the bench run is complete the `bench.json` file can be analyzed with `./lotus-bench import analyze bench.json`.

 It will compute means, standard deviations and co-variances (when applicable) of syscall runtimes. 
-The output is in nanoseconds, so the gas values for syscalls should be 10x that. In cases where the co-variance of
+The output is in nanoseconds, so the gas values for syscalls should be 10x that. In cases where co-variance of
 execution time to some parameter is evaluated, the strength of the correlation should be taken into account.

 #### Special cases
@@ -40,15 +40,15 @@ during block execution (when gas traces are formed) objects are only written to

 ### Targeted gas balancing

-In some cases complete gas balancing is infeasible, either a new syscall gets introduced or
+In some cases complete gas balancing is infeasible, either new syscall gets introduced or
 complete balancing is too time consuming.

-In these cases, the recommended way to estimate gas for a given syscall is to perform an `in-vivo` benchmark.
+In these cases the recommended way to estimate gas for given syscall is to perform an `in-vivo` benchmark.
 In the past `in-vitro` as in standalone benchmarks were found to be highly inaccurate when compared to results
 of real execution.

-An in-vivo benchmark can be performed by running an example of such a syscall during block execution.
-The best place to hook-in such a benchmark is the message execution loop in
-`chain/stmgr/stmgr.go` in `ApplyBlocks()`. Depending on the time required to complete the syscall it might be
+A in-vivo benchmark can be performed by running an example of such syscall during block execution.
+The best place to hook-in such benchmark is message execution loop in
+`chain/stmgr/stmgr.go` in `ApplyBlocks()`. Depending of time required to complete the syscall it might be
 advisable to run the execution only once every few messages.

@@ -43,9 +43,6 @@ const (
 // TargetAPI defines the API methods that the Node depends on
 // (to make it easy to mock for tests)
 type TargetAPI interface {
-	MpoolPending(context.Context, types.TipSetKey) ([]*types.SignedMessage, error)
-	ChainGetBlock(context.Context, cid.Cid) (*types.BlockHeader, error)
-	MinerGetBaseInfo(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*api.MiningBaseInfo, error)
 	GasEstimateGasPremium(context.Context, uint64, address.Address, int64, types.TipSetKey) (types.BigInt, error)
 	StateReplay(context.Context, types.TipSetKey, cid.Cid) (*api.InvocResult, error)
 	StateMinerSectorCount(context.Context, address.Address, types.TipSetKey) (api.MinerSectors, error)
@@ -118,7 +115,6 @@ type TargetAPI interface {
 	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)
 	EthChainId(ctx context.Context) (ethtypes.EthUint64, error)
-	EthSyncing(ctx context.Context) (ethtypes.EthSyncingResult, error)
 	NetVersion(ctx context.Context) (string, error)
 	NetListening(ctx context.Context) (bool, error)
 	EthProtocolVersion(ctx context.Context) (ethtypes.EthUint64, error)
@@ -252,14 +252,6 @@ func (gw *Node) EthChainId(ctx context.Context) (ethtypes.EthUint64, error) {
 	return gw.target.EthChainId(ctx)
 }

-func (gw *Node) EthSyncing(ctx context.Context) (ethtypes.EthSyncingResult, error) {
-	if err := gw.limit(ctx, basicRateLimitTokens); err != nil {
-		return ethtypes.EthSyncingResult{}, err
-	}
-
-	return gw.target.EthSyncing(ctx)
-}
-
 func (gw *Node) NetVersion(ctx context.Context) (string, error) {
 	if err := gw.limit(ctx, stateRateLimitTokens); err != nil {
 		return "", err
@@ -23,33 +23,6 @@ import (
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )

-func (gw *Node) MpoolPending(ctx context.Context, tsk types.TipSetKey) ([]*types.SignedMessage, error) {
-	if err := gw.limit(ctx, stateRateLimitTokens); err != nil {
-		return nil, err
-	}
-	if err := gw.checkTipsetKey(ctx, tsk); err != nil {
-		return nil, err
-	}
-	return gw.target.MpoolPending(ctx, tsk)
-}
-
-func (gw *Node) ChainGetBlock(ctx context.Context, c cid.Cid) (*types.BlockHeader, error) {
-	if err := gw.limit(ctx, chainRateLimitTokens); err != nil {
-		return nil, err
-	}
-	return gw.target.ChainGetBlock(ctx, c)
-}
-
-func (gw *Node) MinerGetBaseInfo(ctx context.Context, addr address.Address, h abi.ChainEpoch, tsk types.TipSetKey) (*api.MiningBaseInfo, error) {
-	if err := gw.limit(ctx, stateRateLimitTokens); err != nil {
-		return nil, err
-	}
-	if err := gw.checkTipsetKey(ctx, tsk); err != nil {
-		return nil, err
-	}
-	return gw.target.MinerGetBaseInfo(ctx, addr, h, tsk)
-}
-
 func (gw *Node) StateReplay(ctx context.Context, tsk types.TipSetKey, c cid.Cid) (*api.InvocResult, error) {
 	if err := gw.limit(ctx, chainRateLimitTokens); err != nil {
 		return nil, err
@@ -16,8 +16,8 @@ require (
 	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d
 	github.com/alecthomas/jsonschema v0.0.0-20200530073317-71f438968921
 	github.com/buger/goterm v1.0.3
-	github.com/chzyer/readline v1.5.1
-	github.com/containerd/cgroups v1.1.0
+	github.com/chzyer/readline v1.5.0
+	github.com/containerd/cgroups v1.0.4
 	github.com/coreos/go-systemd/v22 v22.5.0
 	github.com/detailyang/go-fallocate v0.0.0-20180908115635-432fa640bd2e
 	github.com/dgraph-io/badger/v2 v2.2007.4
@@ -38,11 +38,11 @@ require (
 	github.com/filecoin-project/go-cbor-util v0.0.1
 	github.com/filecoin-project/go-commp-utils v0.1.3
 	github.com/filecoin-project/go-crypto v0.0.1
-	github.com/filecoin-project/go-data-transfer/v2 v2.0.0-rc7
+	github.com/filecoin-project/go-data-transfer/v2 v2.0.0-rc4
 	github.com/filecoin-project/go-fil-commcid v0.1.0
 	github.com/filecoin-project/go-fil-commp-hashhash v0.1.0
-	github.com/filecoin-project/go-fil-markets v1.28.2
-	github.com/filecoin-project/go-jsonrpc v0.3.1
+	github.com/filecoin-project/go-fil-markets v1.27.0-rc1
+	github.com/filecoin-project/go-jsonrpc v0.2.3
 	github.com/filecoin-project/go-padreader v0.0.1
 	github.com/filecoin-project/go-paramfetch v0.0.4
 	github.com/filecoin-project/go-state-types v0.11.1
@@ -87,7 +87,7 @@ require (
 	github.com/ipfs/go-ds-leveldb v0.5.0
 	github.com/ipfs/go-ds-measure v0.2.0
 	github.com/ipfs/go-fs-lock v0.0.7
-	github.com/ipfs/go-graphsync v0.14.6
+	github.com/ipfs/go-graphsync v0.14.3
 	github.com/ipfs/go-ipfs-blockstore v1.3.0
 	github.com/ipfs/go-ipfs-blocksutil v0.0.1
 	github.com/ipfs/go-ipfs-chunker v0.0.5
@@ -111,12 +111,12 @@ require (
 	github.com/ipld/go-codec-dagpb v1.6.0
 	github.com/ipld/go-ipld-prime v0.20.0
 	github.com/ipld/go-ipld-selector-text-lite v0.0.1
-	github.com/ipni/go-libipni v0.0.8
-	github.com/ipni/index-provider v0.12.0
+	github.com/ipni/index-provider v0.11.0
+	github.com/ipni/storetheindex v0.5.10
 	github.com/kelseyhightower/envconfig v1.4.0
 	github.com/koalacxr/quantile v0.0.1
 	github.com/libp2p/go-buffer-pool v0.1.0
-	github.com/libp2p/go-libp2p v0.27.5
+	github.com/libp2p/go-libp2p v0.26.3
 	github.com/libp2p/go-libp2p-consensus v0.0.1
 	github.com/libp2p/go-libp2p-gorpc v0.5.0
 	github.com/libp2p/go-libp2p-kad-dht v0.21.1
@@ -126,25 +126,24 @@ require (
 	github.com/libp2p/go-libp2p-routing-helpers v0.4.0
 	github.com/libp2p/go-maddr-filter v0.1.0
 	github.com/libp2p/go-msgio v0.3.0
-	github.com/mattn/go-isatty v0.0.18
+	github.com/mattn/go-isatty v0.0.17
 	github.com/mattn/go-sqlite3 v1.14.16
 	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/multiformats/go-base32 v0.1.0
-	github.com/multiformats/go-multiaddr v0.9.0
+	github.com/multiformats/go-multiaddr v0.8.0
 	github.com/multiformats/go-multiaddr-dns v0.3.1
-	github.com/multiformats/go-multibase v0.2.0
+	github.com/multiformats/go-multibase v0.1.1
 	github.com/multiformats/go-multihash v0.2.1
 	github.com/multiformats/go-varint v0.0.7
 	github.com/open-rpc/meta-schema v0.0.0-20201029221707-1b72ef2ea333
 	github.com/polydawn/refmt v0.89.0
 	github.com/prometheus/client_golang v1.14.0
-	github.com/puzpuzpuz/xsync/v2 v2.4.0
 	github.com/raulk/clock v1.1.0
 	github.com/raulk/go-watchdog v1.3.0
 	github.com/stretchr/testify v1.8.2
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
-	github.com/urfave/cli/v2 v2.25.5
+	github.com/urfave/cli/v2 v2.16.3
 	github.com/whyrusleeping/bencher v0.0.0-20190829221104-bb6607aa8bba
 	github.com/whyrusleeping/cbor-gen v0.0.0-20230126041949-52956bd4c9aa
 	github.com/whyrusleeping/ledger-filecoin-go v0.9.1-0.20201010031517-c3dcc1bddce4
@@ -158,16 +157,16 @@ require (
 	go.opentelemetry.io/otel/exporters/jaeger v1.2.0
 	go.opentelemetry.io/otel/sdk v1.11.1
 	go.uber.org/atomic v1.10.0
-	go.uber.org/fx v1.19.2
-	go.uber.org/multierr v1.11.0
+	go.uber.org/fx v1.18.2
+	go.uber.org/multierr v1.9.0
 	go.uber.org/zap v1.24.0
-	golang.org/x/crypto v0.7.0
-	golang.org/x/exp v0.0.0-20230321023759-10a507213a29
-	golang.org/x/net v0.8.0
+	golang.org/x/crypto v0.6.0
+	golang.org/x/exp v0.0.0-20230213192124-5e25df0256eb
+	golang.org/x/net v0.7.0
 	golang.org/x/sync v0.1.0
-	golang.org/x/sys v0.7.0
+	golang.org/x/sys v0.6.0
 	golang.org/x/time v0.0.0-20220722155302-e5dcc9cfc0b9
-	golang.org/x/tools v0.7.0
+	golang.org/x/tools v0.3.0
 	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2
 	gopkg.in/cheggaaa/pb.v1 v1.0.28
 	gotest.tools v2.2.0+incompatible
@@ -179,7 +178,7 @@ require (
 	github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect
 	github.com/StackExchange/wmi v1.2.1 // indirect
 	github.com/akavel/rsrc v0.8.0 // indirect
-	github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137 // indirect
+	github.com/alecthomas/units v0.0.0-20210927113745-59d0afb8317a // indirect
 	github.com/armon/go-metrics v0.3.9 // indirect
 	github.com/benbjohnson/clock v1.3.0 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
@@ -187,7 +186,7 @@ require (
 	github.com/boltdb/bolt v1.3.1 // indirect
 	github.com/cespare/xxhash v1.1.0 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
-	github.com/cilium/ebpf v0.9.1 // indirect
+	github.com/cilium/ebpf v0.4.0 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
 	github.com/crackcomm/go-gitignore v0.0.0-20170627025303-887ab5e44cc3 // indirect
 	github.com/cskr/pubsub v1.0.2 // indirect
@@ -218,22 +217,22 @@ require (
 	github.com/go-openapi/jsonpointer v0.19.3 // indirect
 	github.com/go-openapi/jsonreference v0.19.4 // indirect
 	github.com/go-openapi/swag v0.19.11 // indirect
-	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
+	github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 // indirect
 	github.com/godbus/dbus/v5 v5.1.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/glog v1.0.0 // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/go-cmp v0.5.9 // indirect
 	github.com/google/gopacket v1.1.19 // indirect
-	github.com/google/pprof v0.0.0-20230405160723-4a4c7d95572b // indirect
+	github.com/google/pprof v0.0.0-20221203041831-ce31453925ec // indirect
 	github.com/hannahhoward/cbor-gen-for v0.0.0-20230214144701-5d17c9d5243c // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/hashicorp/go-immutable-radix v1.3.1 // indirect
 	github.com/hashicorp/go-msgpack v0.5.5 // indirect
 	github.com/hashicorp/golang-lru v0.6.0 // indirect
-	github.com/huin/goupnp v1.1.0 // indirect
+	github.com/huin/goupnp v1.0.3 // indirect
 	github.com/iancoleman/orderedmap v0.1.0 // indirect
 	github.com/ipfs/go-bitfield v1.1.0 // indirect
 	github.com/ipfs/go-filestore v1.2.0 // indirect
@@ -260,12 +259,12 @@ require (
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/jpillora/backoff v1.0.0 // indirect
 	github.com/kilic/bls12-381 v0.1.0 // indirect
-	github.com/klauspost/compress v1.16.4 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
-	github.com/koron/go-ssdp v0.0.4 // indirect
+	github.com/klauspost/compress v1.15.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.3 // indirect
+	github.com/koron/go-ssdp v0.0.3 // indirect
 	github.com/libp2p/go-cidranger v1.1.0 // indirect
 	github.com/libp2p/go-flow-metrics v0.1.0 // indirect
-	github.com/libp2p/go-libp2p-asn-util v0.3.0 // indirect
+	github.com/libp2p/go-libp2p-asn-util v0.2.0 // indirect
 	github.com/libp2p/go-libp2p-gostream v0.6.0 // indirect
 	github.com/libp2p/go-libp2p-kbucket v0.5.0 // indirect
 	github.com/libp2p/go-nat v0.1.0 // indirect
@@ -279,18 +278,18 @@ require (
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-runewidth v0.0.10 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
-	github.com/miekg/dns v1.1.53 // indirect
+	github.com/miekg/dns v1.1.50 // indirect
 	github.com/mikioh/tcpinfo v0.0.0-20190314235526-30a79bb1804b // indirect
 	github.com/mikioh/tcpopt v0.0.0-20190314235656-172688c1accc // indirect
 	github.com/minio/sha256-simd v1.0.0 // indirect
 	github.com/mr-tron/base58 v1.2.0 // indirect
 	github.com/multiformats/go-base36 v0.2.0 // indirect
 	github.com/multiformats/go-multiaddr-fmt v0.1.0 // indirect
-	github.com/multiformats/go-multicodec v0.9.0 // indirect
+	github.com/multiformats/go-multicodec v0.8.1 // indirect
 	github.com/multiformats/go-multistream v0.4.1 // indirect
 	github.com/nikkolasg/hexjson v0.1.0 // indirect
 	github.com/nkovacs/streamquote v1.0.0 // indirect
-	github.com/onsi/ginkgo/v2 v2.9.2 // indirect
+	github.com/onsi/ginkgo/v2 v2.5.1 // indirect
 	github.com/opencontainers/runtime-spec v1.0.2 // indirect
 	github.com/opentracing/opentracing-go v1.2.0 // indirect
 	github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 // indirect
@@ -298,12 +297,12 @@ require (
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/prometheus/client_model v0.3.0 // indirect
-	github.com/prometheus/common v0.42.0 // indirect
-	github.com/prometheus/procfs v0.9.0 // indirect
+	github.com/prometheus/common v0.37.0 // indirect
+	github.com/prometheus/procfs v0.8.0 // indirect
 	github.com/prometheus/statsd_exporter v0.21.0 // indirect
 	github.com/quic-go/qpack v0.4.0 // indirect
-	github.com/quic-go/qtls-go1-19 v0.3.2 // indirect
-	github.com/quic-go/qtls-go1-20 v0.2.2 // indirect
+	github.com/quic-go/qtls-go1-19 v0.2.1 // indirect
+	github.com/quic-go/qtls-go1-20 v0.1.1 // indirect
 	github.com/quic-go/quic-go v0.33.0 // indirect
 	github.com/quic-go/webtransport-go v0.5.2 // indirect
 	github.com/rivo/uniseg v0.1.0 // indirect
@@ -327,14 +326,14 @@ require (
 	go.opentelemetry.io/otel/metric v0.33.0 // indirect
 	go.opentelemetry.io/otel/sdk/metric v0.33.0 // indirect
 	go.opentelemetry.io/otel/trace v1.14.0 // indirect
-	go.uber.org/dig v1.16.1 // indirect
+	go.uber.org/dig v1.15.0 // indirect
 	go4.org v0.0.0-20200411211856-f5505b9728dd // indirect
-	golang.org/x/mod v0.10.0 // indirect
-	golang.org/x/term v0.6.0 // indirect
-	golang.org/x/text v0.8.0 // indirect
+	golang.org/x/mod v0.7.0 // indirect
+	golang.org/x/term v0.5.0 // indirect
+	golang.org/x/text v0.7.0 // indirect
 	google.golang.org/genproto v0.0.0-20210917145530-b395a37504d4 // indirect
 	google.golang.org/grpc v1.45.0 // indirect
-	google.golang.org/protobuf v1.30.0 // indirect
+	google.golang.org/protobuf v1.28.1 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	howett.net/plist v0.0.0-20181124034731-591f970eefbb // indirect
@@ -91,8 +91,8 @@ github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuy
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
-github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137 h1:s6gZFSlWYmbqAuRjVTiNNhvNRfY2Wxp9nhfyel4rklc=
-github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137/go.mod h1:OMCwj8VM1Kc9e19TLln2VL61YJF0x1XFtfdL4JdbSyE=
+github.com/alecthomas/units v0.0.0-20210927113745-59d0afb8317a h1:E/8AP5dFtMhl5KPJz66Kt9G0n+7Sn41Fy1wv9/jHOrc=
+github.com/alecthomas/units v0.0.0-20210927113745-59d0afb8317a/go.mod h1:OMCwj8VM1Kc9e19TLln2VL61YJF0x1XFtfdL4JdbSyE=
 github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
 github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
@@ -148,21 +148,22 @@ github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA
 github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
 github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cheekybits/genny v1.0.0/go.mod h1:+tQajlRqAUrPI7DOSpB0XAqZYtQakVtB7wXkRAgjxjQ=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM=
-github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ=
+github.com/chzyer/logex v1.2.0 h1:+eqR0HfOetur4tgnC8ftU5imRnhi4te+BadWS95c5AM=
+github.com/chzyer/logex v1.2.0/go.mod h1:9+9sk7u7pGNWYMkh0hdiL++6OeibzJccyQU4p4MedaY=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
-github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI=
-github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObkaSkeBlk=
+github.com/chzyer/readline v1.5.0 h1:lSwwFrbNviGePhkewF1az4oLmcwqCZijQ2/Wi3BGHAI=
+github.com/chzyer/readline v1.5.0/go.mod h1:x22KAscuvRqlLoK9CsoYsmxoXZMMFVyOl86cAH8qUic=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04=
-github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8=
+github.com/chzyer/test v0.0.0-20210722231415-061457976a23 h1:dZ0/VyGgQdVGAss6Ju0dt5P0QltE0SFY5Woh6hbIfiQ=
+github.com/chzyer/test v0.0.0-20210722231415-061457976a23/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
 github.com/cilium/ebpf v0.2.0/go.mod h1:To2CFviqOWL/M0gIMsvSMlqe7em/l1ALkX1PyjrX2Qs=
-github.com/cilium/ebpf v0.9.1 h1:64sn2K3UKw8NbP/blsixRpF3nXuyhz/VjRlRzvlBRu4=
-github.com/cilium/ebpf v0.9.1/go.mod h1:+OhNOIXx/Fnu1IE8bJz2dzOA+VSfyTfdNUVdlQnxUFY=
+github.com/cilium/ebpf v0.4.0 h1:QlHdikaxALkqWasW8hAC1mfR0jdmvbfaBdBPFmRSglA=
+github.com/cilium/ebpf v0.4.0/go.mod h1:4tRaxcgiL706VnOzHOdBlY8IEAIdxINsQBcU4xJJXRs=
 github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag=
 github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I=
 github.com/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE=
@@ -178,8 +179,8 @@ github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:z
 github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
 github.com/codegangsta/cli v1.20.0/go.mod h1:/qJNoX69yVSKu5o4jLyXAENLRyk1uhi7zkbQ3slBdOA=
 github.com/containerd/cgroups v0.0.0-20201119153540-4cbc285b3327/go.mod h1:ZJeTFisyysqgcCdecO57Dj79RfL0LNeGiFUqLYQRYLE=
-github.com/containerd/cgroups v1.1.0 h1:v8rEWFl6EoqHB+swVNjVoCJE8o3jX7e8nqBGPLaDFBM=
-github.com/containerd/cgroups v1.1.0/go.mod h1:6ppBcbh/NOOUU+dMKrykgaBnK9lCIBxHqJDGwsa1mIw=
+github.com/containerd/cgroups v1.0.4 h1:jN/mbWBEaz+T1pi5OFtnkQ+8qnmEbAr1Oo1FRm5B0dA=
+github.com/containerd/cgroups v1.0.4/go.mod h1:nLNQtsF7Sl2HxNebu77i1R0oDlhiTG+kO4JTrUzo6IA=
 github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
 github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
 github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
@@ -312,8 +313,8 @@ github.com/filecoin-project/go-commp-utils/nonffi v0.0.0-20220905160352-62059082
 github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
 github.com/filecoin-project/go-crypto v0.0.1 h1:AcvpSGGCgjaY8y1az6AMfKQWreF/pWO2JJGLl6gCq6o=
 github.com/filecoin-project/go-crypto v0.0.1/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
-github.com/filecoin-project/go-data-transfer/v2 v2.0.0-rc7 h1:v+zJS5B6pA3ptWZS4t8tbt1Hz9qENnN4nVr1w99aSWc=
-github.com/filecoin-project/go-data-transfer/v2 v2.0.0-rc7/go.mod h1:V3Y4KbttaCwyg1gwkP7iai8CbQx4mZUGjd3h9GZWLKE=
+github.com/filecoin-project/go-data-transfer/v2 v2.0.0-rc4 h1:Y5RMvFT4OthsAhDx7xKfkJ5QdiWq9Ox7N46Mi0PF0PE=
+github.com/filecoin-project/go-data-transfer/v2 v2.0.0-rc4/go.mod h1:1WDoUgWYB2KvogfPTdDmoyBTa9cb9+oGwqKCCipnJeY=
 github.com/filecoin-project/go-ds-versioning v0.1.2 h1:to4pTadv3IeV1wvgbCbN6Vqd+fu+7tveXgv/rCEZy6w=
 github.com/filecoin-project/go-ds-versioning v0.1.2/go.mod h1:C9/l9PnB1+mwPa26BBVpCjG/XQCB0yj/q5CK2J8X1I4=
 github.com/filecoin-project/go-fil-commcid v0.0.0-20201016201715-d41df56b4f6a/go.mod h1:Eaox7Hvus1JgPrL5+M3+h7aSPHc0cVqpSxA+TxIEpZQ=
@@ -321,8 +322,8 @@ github.com/filecoin-project/go-fil-commcid v0.1.0 h1:3R4ds1A9r6cr8mvZBfMYxTS88Oq
 github.com/filecoin-project/go-fil-commcid v0.1.0/go.mod h1:Eaox7Hvus1JgPrL5+M3+h7aSPHc0cVqpSxA+TxIEpZQ=
 github.com/filecoin-project/go-fil-commp-hashhash v0.1.0 h1:imrrpZWEHRnNqqv0tN7LXep5bFEVOVmQWHJvl2mgsGo=
 github.com/filecoin-project/go-fil-commp-hashhash v0.1.0/go.mod h1:73S8WSEWh9vr0fDJVnKADhfIv/d6dCbAGaAGWbdJEI8=
-github.com/filecoin-project/go-fil-markets v1.28.2 h1:Ev9o8BYow+lo97Bwc6oOmZ2OxdiHeIDCQsfF/w/Vldc=
-github.com/filecoin-project/go-fil-markets v1.28.2/go.mod h1:qy9LNu9t77I184VB6Pa4WKRtGfB8Vl0t8zfOLHkDqWY=
+github.com/filecoin-project/go-fil-markets v1.27.0-rc1 h1:SYXKFONg6IaQlmXEqAEaPtb/xX57dZYMkx3LwjsLr7w=
+github.com/filecoin-project/go-fil-markets v1.27.0-rc1/go.mod h1:JkW4rU0+LqfO/DLi/wyR58AqxaUdnlSofWeu8un2XLU=
 github.com/filecoin-project/go-hamt-ipld v0.1.5 h1:uoXrKbCQZ49OHpsTCkrThPNelC4W3LPEk0OrS/ytIBM=
 github.com/filecoin-project/go-hamt-ipld v0.1.5/go.mod h1:6Is+ONR5Cd5R6XZoCse1CWaXZc0Hdb/JeX+EQCQzX24=
 github.com/filecoin-project/go-hamt-ipld/v2 v2.0.0 h1:b3UDemBYN2HNfk3KOXNuxgTTxlWi3xVvbQP0IT38fvM=
@@ -330,8 +331,8 @@ github.com/filecoin-project/go-hamt-ipld/v2 v2.0.0/go.mod h1:7aWZdaQ1b16BVoQUYR+
 github.com/filecoin-project/go-hamt-ipld/v3 v3.0.1/go.mod h1:gXpNmr3oQx8l3o7qkGyDjJjYSRX7hp/FGOStdqrWyDI=
 github.com/filecoin-project/go-hamt-ipld/v3 v3.1.0 h1:rVVNq0x6RGQIzCo1iiJlGFm9AGIZzeifggxtKMU7zmI=
 github.com/filecoin-project/go-hamt-ipld/v3 v3.1.0/go.mod h1:bxmzgT8tmeVQA1/gvBwFmYdT8SOFUwB3ovSUfG1Ux0g=
-github.com/filecoin-project/go-jsonrpc v0.3.1 h1:qwvAUc5VwAkooquKJmfz9R2+F8znhiqcNHYjEp/NM10=
-github.com/filecoin-project/go-jsonrpc v0.3.1/go.mod h1:jBSvPTl8V1N7gSTuCR4bis8wnQnIjHbRPpROol6iQKM=
+github.com/filecoin-project/go-jsonrpc v0.2.3 h1:xdixRQfLbD8gt56dpBNKiya9gvI/79nNM13IHKTfm5E=
+github.com/filecoin-project/go-jsonrpc v0.2.3/go.mod h1:jBSvPTl8V1N7gSTuCR4bis8wnQnIjHbRPpROol6iQKM=
 github.com/filecoin-project/go-padreader v0.0.0-20200903213702-ed5fae088b20/go.mod h1:mPn+LRRd5gEKNAtc+r3ScpW2JRU/pj4NBKdADYWHiak=
 github.com/filecoin-project/go-padreader v0.0.1 h1:8h2tVy5HpoNbr2gBRr+WD6zV6VD6XHig+ynSGJg8ZOs=
 github.com/filecoin-project/go-padreader v0.0.1/go.mod h1:VYVPJqwpsfmtoHnAmPx6MUwmrK6HIcDqZJiuZhtmfLQ=
@@ -412,6 +413,7 @@ github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o=
 github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
+github.com/go-kit/log v0.2.0/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
 github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU=
 github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
@@ -452,8 +454,8 @@ github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1
 github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
 github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
-github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
+github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 h1:p104kn46Q8WdvHunIJ9dAyjPVtrBPhSr3KT2yUst43I=
+github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
 github.com/go-yaml/yaml v2.1.0+incompatible/go.mod h1:w2MrLa16VYP0jy6N7M5kHaCkaLENm+P+Tv+MfurjSw0=
 github.com/gobuffalo/envy v1.7.0/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI=
 github.com/gobuffalo/logger v1.0.0/go.mod h1:2zbswyIUa45I+c+FLXuWl9zSWEiVuthsk8ze5s8JvPs=
@@ -515,9 +517,8 @@ github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QD
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
@@ -555,8 +556,8 @@ github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hf
 github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
 github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
 github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20230405160723-4a4c7d95572b h1:Qcx5LM0fSiks9uCyFZwDBUasd3lxd1RM0GYpL+Li5o4=
-github.com/google/pprof v0.0.0-20230405160723-4a4c7d95572b/go.mod h1:79YE0hCXdHag9sBkw2o+N/YnZtTkXi0UT9Nnixa5eYk=
+github.com/google/pprof v0.0.0-20221203041831-ce31453925ec h1:fR20TYVVwhK4O7r7y+McjRYyaTH6/vjwJOajE+XhlzM=
+github.com/google/pprof v0.0.0-20221203041831-ce31453925ec/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
@@ -649,8 +650,8 @@ github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/J
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg=
 github.com/huin/goupnp v1.0.0/go.mod h1:n9v9KO1tAxYH82qOn+UTIFQDmx5n1Zxd/ClZDMX7Bnc=
-github.com/huin/goupnp v1.1.0 h1:gEe0Dp/lZmPZiDFzJJaOfUpOvv2MKUkoBX8lDrn9vKU=
-github.com/huin/goupnp v1.1.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8=
+github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ=
+github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixHM7Y=
 github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o=
 github.com/iancoleman/orderedmap v0.0.0-20190318233801-ac98e3ecb4b0/go.mod h1:N0Wam8K1arqPXNWjMo21EXnBPOPp36vB07FNRdD2geA=
 github.com/iancoleman/orderedmap v0.1.0 h1:2orAxZBJsvimgEBmMWfXaFlzSG2fbQil5qzP3F6cCkg=
@@ -738,8 +739,8 @@ github.com/ipfs/go-filestore v1.2.0/go.mod h1:HLJrCxRXquTeEEpde4lTLMaE/MYJZD7WHL
 github.com/ipfs/go-fs-lock v0.0.6/go.mod h1:OTR+Rj9sHiRubJh3dRhD15Juhd/+w6VPOY28L7zESmM=
 github.com/ipfs/go-fs-lock v0.0.7 h1:6BR3dajORFrFTkb5EpCUFIAypsoxpGpDSVUdFwzgL9U=
 github.com/ipfs/go-fs-lock v0.0.7/go.mod h1:Js8ka+FNYmgQRLrRXzU3CB/+Csr1BwrRilEcvYrHhhc=
-github.com/ipfs/go-graphsync v0.14.6 h1:NPxvuUy4Z08Mg8dwpBzwgbv/PGLIufSJ1sle6iAX8yo=
-github.com/ipfs/go-graphsync v0.14.6/go.mod h1:yT0AfjFgicOoWdAlUJ96tQ5AkuGI4r1taIQX/aHbBQo=
+github.com/ipfs/go-graphsync v0.14.3 h1:IXH9S7AraMQ0J6Fzcl8rqSPqLn+es33bD8OW2KNyU/o=
+github.com/ipfs/go-graphsync v0.14.3/go.mod h1:yT0AfjFgicOoWdAlUJ96tQ5AkuGI4r1taIQX/aHbBQo=
 github.com/ipfs/go-ipfs-blockstore v0.0.1/go.mod h1:d3WClOmRQKFnJ0Jz/jj/zmksX0ma1gROTlovZKBmN08=
 github.com/ipfs/go-ipfs-blockstore v0.1.0/go.mod h1:5aD0AvHPi7mZc6Ci1WCAhiBQu2IsfTduLl+422H6Rqw=
 github.com/ipfs/go-ipfs-blockstore v0.2.1/go.mod h1:jGesd8EtCM3/zPgx+qr0/feTXGUeRai6adgwC+Q+JvE=
@@ -885,10 +886,10 @@ github.com/ipld/go-ipld-prime/storage/bsadapter v0.0.0-20211210234204-ce2a1c70cd
 github.com/ipld/go-ipld-prime/storage/bsadapter v0.0.0-20230102063945-1a409dc236dd h1:gMlw/MhNr2Wtp5RwGdsW23cs+yCuj9k2ON7i9MiJlRo=
 github.com/ipld/go-ipld-selector-text-lite v0.0.1 h1:lNqFsQpBHc3p5xHob2KvEg/iM5dIFn6iw4L/Hh+kS1Y=
 github.com/ipld/go-ipld-selector-text-lite v0.0.1/go.mod h1:U2CQmFb+uWzfIEF3I1arrDa5rwtj00PrpiwwCO+k1RM=
-github.com/ipni/go-libipni v0.0.8 h1:0wLfZRSBG84swmZwmaLKul/iB/FlBkkl9ZcR1ub+Z+w=
-github.com/ipni/go-libipni v0.0.8/go.mod h1:paYP9U4N3/vOzGCuN9kU972vtvw9JUcQjOKyiCFGwRk=
-github.com/ipni/index-provider v0.12.0 h1:R3F6dxxKNv4XkE4GJZNLOG0bDEbBQ/S5iztXwSD8jhQ=
-github.com/ipni/index-provider v0.12.0/go.mod h1:GhyrADJp7n06fqoc1djzkvL4buZYHzV8SoWrlxEo5F4=
+github.com/ipni/index-provider v0.11.0 h1:q2PdK6JpYB9bzlntfkRYNBjhg4Qtko5+iXRonO88TAg=
+github.com/ipni/index-provider v0.11.0/go.mod h1:gB/wN4Mdz4MzikQubjyRRV97iS5BkD4FKB0U/bF/dY4=
+github.com/ipni/storetheindex v0.5.10 h1:r97jIZsXPuwQvePJQuStu2a/kn+Zn8X4MAdA0rU2Pu4=
+github.com/ipni/storetheindex v0.5.10/go.mod h1:SJKFCnSx4X/4ekQuZvq8pVU/7tmxkEv632Qmgu3m2bQ=
 github.com/ipsn/go-secp256k1 v0.0.0-20180726113642-9d62b9f0bc52 h1:QG4CGBqCeuBo6aZlGAamSkxWdgWfZGeE49eUOWJPA4c=
 github.com/ipsn/go-secp256k1 v0.0.0-20180726113642-9d62b9f0bc52/go.mod h1:fdg+/X9Gg4AsAIzWpEHwnqd+QY3b7lajxyjE1m4hkq4=
 github.com/jackpal/gateway v1.0.5/go.mod h1:lTpwd4ACLXmpyiCTRtfiNyVnUmqT9RivzCDQetPfnjA=
@@ -928,6 +929,7 @@ github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/u
 github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
 github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
 github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
@@ -951,13 +953,13 @@ github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+o
 github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4=
 github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/compress v1.12.3/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg=
-github.com/klauspost/compress v1.16.4 h1:91KN02FnsOYhuunwU4ssRe8lc2JosWmizWa91B5v1PU=
-github.com/klauspost/compress v1.16.4/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/compress v1.15.12 h1:YClS/PImqYbn+UILDnqxQCZ3RehC9N318SU3kElDUEM=
+github.com/klauspost/compress v1.15.12/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
 github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.0.6/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk=
-github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/klauspost/cpuid/v2 v2.2.3 h1:sxCkb+qR91z4vsqw4vGGZlDgPz3G7gjaLyK3V8y70BU=
+github.com/klauspost/cpuid/v2 v2.2.3/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
 github.com/koalacxr/quantile v0.0.1 h1:wAW+SQ286Erny9wOjVww96t8ws+x5Zj6AKHDULUK+o0=
 github.com/koalacxr/quantile v0.0.1/go.mod h1:bGN/mCZLZ4lrSDHRQ6Lglj9chowGux8sGUIND+DQeD0=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
@@ -965,8 +967,8 @@ github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxv
 github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/koron/go-ssdp v0.0.0-20180514024734-4a0ed625a78b/go.mod h1:5Ky9EC2xfoUKUor0Hjgi2BJhCSXJfMOFlmyYrVKGQMk=
 github.com/koron/go-ssdp v0.0.0-20191105050749-2e1c40ed0b5d/go.mod h1:5Ky9EC2xfoUKUor0Hjgi2BJhCSXJfMOFlmyYrVKGQMk=
-github.com/koron/go-ssdp v0.0.4 h1:1IDwrghSKYM7yLf7XCzbByg2sJ/JcNOZRXS2jczTwz0=
-github.com/koron/go-ssdp v0.0.4/go.mod h1:oDXq+E5IL5q0U8uSBcoAXzTzInwy5lEgC91HoKtbmZk=
+github.com/koron/go-ssdp v0.0.3 h1:JivLMY45N76b4p/vsWGOKewBQu6uf39y8l+AQ7sDKx8=
+github.com/koron/go-ssdp v0.0.3/go.mod h1:b2MxI6yh02pKrsyNoQUsk4+YNikaGhe4894J+Q5lDvA=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
@@ -1005,10 +1007,10 @@ github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xS
 github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw=
 github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qDKwXujH5o=
 github.com/libp2p/go-libp2p v0.14.3/go.mod h1:d12V4PdKbpL0T1/gsUNN8DfgMuRPDX8bS2QxCZlwRH0=
-github.com/libp2p/go-libp2p v0.27.5 h1:KwA7pXKXpz8hG6Cr1fMA7UkgleogcwQj0sxl5qquWRg=
-github.com/libp2p/go-libp2p v0.27.5/go.mod h1:oMfQGTb9CHnrOuSM6yMmyK2lXz3qIhnkn2+oK3B1Y2g=
-github.com/libp2p/go-libp2p-asn-util v0.3.0 h1:gMDcMyYiZKkocGXDQ5nsUQyquC9+H+iLEQHwOCZ7s8s=
-github.com/libp2p/go-libp2p-asn-util v0.3.0/go.mod h1:B1mcOrKUE35Xq/ASTmQ4tN3LNzVVaMNmq2NACuqyB9w=
+github.com/libp2p/go-libp2p v0.26.3 h1:6g/psubqwdaBqNNoidbRKSTBEYgaOuKBhHl8Q5tO+PM=
+github.com/libp2p/go-libp2p v0.26.3/go.mod h1:x75BN32YbwuY0Awm2Uix4d4KOz+/4piInkp4Wr3yOo8=
+github.com/libp2p/go-libp2p-asn-util v0.2.0 h1:rg3+Os8jbnO5DxkC7K/Utdi+DkY3q/d1/1q+8WeNAsw=
+github.com/libp2p/go-libp2p-asn-util v0.2.0/go.mod h1:WoaWxbHKBymSN41hWSq/lGKJEca7TNm58+gGJi2WsLI=
 github.com/libp2p/go-libp2p-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8=
 github.com/libp2p/go-libp2p-autonat v0.1.1/go.mod h1:OXqkeGOY2xJVWKAGV2inNF5aKN/djNA3fdpCWloIudE=
 github.com/libp2p/go-libp2p-autonat v0.2.0/go.mod h1:DX+9teU4pEEoZUqR1PiMlqliONQdNbfzE1C718tcViI=
@@ -1227,8 +1229,8 @@ github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Ky
 github.com/mattn/go-isatty v0.0.13/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98=
-github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng=
+github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/mattn/go-runewidth v0.0.10 h1:CoZ3S2P7pvtP45xOtBw+/mDL2z0RKI576gSkzRRpdGg=
@@ -1244,8 +1246,8 @@ github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3N
 github.com/miekg/dns v1.1.12/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
 github.com/miekg/dns v1.1.28/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
 github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI=
-github.com/miekg/dns v1.1.53 h1:ZBkuHr5dxHtB1caEOlZTLPo7D3L3TWckgUUs/RHfDxw=
-github.com/miekg/dns v1.1.53/go.mod h1:uInx36IzPl7FYnDcMeVWxj9byh7DutNykX4G9Sj60FY=
+github.com/miekg/dns v1.1.50 h1:DQUfb9uc6smULcREF09Uc+/Gd46YWqJd5DbpPE9xkcA=
+github.com/miekg/dns v1.1.50/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7XnME=
 github.com/mikioh/tcp v0.0.0-20190314235350-803a9b46060c h1:bzE/A84HN25pxAuk9Eej1Kz9OUelF97nAc82bDquQI8=
 github.com/mikioh/tcp v0.0.0-20190314235350-803a9b46060c/go.mod h1:0SQS9kMwD2VsyFEB++InYyBJroV/FRmBgcydeSUcJms=
 github.com/mikioh/tcpinfo v0.0.0-20190314235526-30a79bb1804b h1:z78hV3sbSMAUoyUMM0I83AUIT6Hu17AWfgjzIbtrYFc=
@@ -1276,6 +1278,7 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJ
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
 github.com/mr-tron/base58 v1.1.1/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
 github.com/mr-tron/base58 v1.1.2/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
@@ -1300,8 +1303,8 @@ github.com/multiformats/go-multiaddr v0.2.2/go.mod h1:NtfXiOtHvghW9KojvtySjH5y0u
 github.com/multiformats/go-multiaddr v0.3.0/go.mod h1:dF9kph9wfJ+3VLAaeBqo9Of8x4fJxp6ggJGteB8HQTI=
 github.com/multiformats/go-multiaddr v0.3.1/go.mod h1:uPbspcUPd5AfaP6ql3ujFY+QWzmBD8uLLL4bXW0XfGc=
 github.com/multiformats/go-multiaddr v0.3.3/go.mod h1:lCKNGP1EQ1eZ35Za2wlqnabm9xQkib3fyB+nZXHLag0=
-github.com/multiformats/go-multiaddr v0.9.0 h1:3h4V1LHIk5w4hJHekMKWALPXErDfz/sggzwC/NcqbDQ=
-github.com/multiformats/go-multiaddr v0.9.0/go.mod h1:mI67Lb1EeTOYb8GQfL/7wpIZwc46ElrvzhYnoJOmTT0=
+github.com/multiformats/go-multiaddr v0.8.0 h1:aqjksEcqK+iD/Foe1RRFsGZh8+XFiGo7FgUCZlpv3LU=
+github.com/multiformats/go-multiaddr v0.8.0/go.mod h1:Fs50eBDWvZu+l3/9S6xAE7ZYj6yhxlvaVZjakWN7xRs=
 github.com/multiformats/go-multiaddr-dns v0.0.1/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q=
 github.com/multiformats/go-multiaddr-dns v0.0.2/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q=
 github.com/multiformats/go-multiaddr-dns v0.2.0/go.mod h1:TJ5pr5bBO7Y1B18djPuRsVkduhQH2YqYSbxWJzYGdK0=
@@ -1320,13 +1323,13 @@ github.com/multiformats/go-multiaddr-net v0.1.5/go.mod h1:ilNnaM9HbmVFqsb/qcNysj
 github.com/multiformats/go-multiaddr-net v0.2.0/go.mod h1:gGdH3UXny6U3cKKYCvpXI5rnK7YaOIEOPVDI9tsJbEA=
 github.com/multiformats/go-multibase v0.0.1/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs=
 github.com/multiformats/go-multibase v0.0.3/go.mod h1:5+1R4eQrT3PkYZ24C3W2Ue2tPwIdYQD509ZjSb5y9Oc=
-github.com/multiformats/go-multibase v0.2.0 h1:isdYCVLvksgWlMW9OZRYJEa9pZETFivncJHmHnnd87g=
-github.com/multiformats/go-multibase v0.2.0/go.mod h1:bFBZX4lKCA/2lyOFSAoKH5SS6oPyjtnzK/XTFDPkNuk=
+github.com/multiformats/go-multibase v0.1.1 h1:3ASCDsuLX8+j4kx58qnJ4YFq/JWTJpCyDW27ztsVTOI=
+github.com/multiformats/go-multibase v0.1.1/go.mod h1:ZEjHE+IsUrgp5mhlEAYjMtZwK1k4haNkcaPg9aoe1a8=
 github.com/multiformats/go-multicodec v0.3.0/go.mod h1:qGGaQmioCDh+TeFOnxrbU0DaIPw8yFgAZgFG0V7p1qQ=
 github.com/multiformats/go-multicodec v0.3.1-0.20210902112759-1539a079fd61/go.mod h1:1Hj/eHRaVWSXiSNNfcEPcwZleTmdNP81xlxDLnWU9GQ=
 github.com/multiformats/go-multicodec v0.6.0/go.mod h1:GUC8upxSBE4oG+q3kWZRw/+6yC1BqO550bjhWsJbZlw=
-github.com/multiformats/go-multicodec v0.9.0 h1:pb/dlPnzee/Sxv/j4PmkDRxCOi3hXTz3IbPKOXWJkmg=
-github.com/multiformats/go-multicodec v0.9.0/go.mod h1:L3QTQvMIaVBkXOXXtVmYE+LI16i14xuaojr/H7Ai54k=
+github.com/multiformats/go-multicodec v0.8.1 h1:ycepHwavHafh3grIbR1jIXnKCsFm0fqsfEOsJ8NtKE8=
+github.com/multiformats/go-multicodec v0.8.1/go.mod h1:L3QTQvMIaVBkXOXXtVmYE+LI16i14xuaojr/H7Ai54k=
 github.com/multiformats/go-multihash v0.0.1/go.mod h1:w/5tugSrLEbWqlcgJabL3oHFKTwfvkofsjW2Qa1ct4U=
 github.com/multiformats/go-multihash v0.0.5/go.mod h1:lt/HCbqlQwlPBz7lv0sQCdtfcMtlJvakRUn/0Ual8po=
 github.com/multiformats/go-multihash v0.0.8/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew=
@@ -1378,15 +1381,15 @@ github.com/onsi/ginkgo v1.12.0/go.mod h1:oUhWkIvk5aDxtKvDDuw8gItl8pKl42LzjC9KZE0
 github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
 github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
 github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
-github.com/onsi/ginkgo/v2 v2.9.2 h1:BA2GMJOtfGAfagzYtrAlufIP0lq6QERkFmHLMLPwFSU=
-github.com/onsi/ginkgo/v2 v2.9.2/go.mod h1:WHcJJG2dIlcCqVfBAwUCrJxSPFb6v4azBwgxeMeDuts=
+github.com/onsi/ginkgo/v2 v2.5.1 h1:auzK7OI497k6x4OvWq+TKAcpcSAlod0doAH72oIN0Jw=
+github.com/onsi/ginkgo/v2 v2.5.1/go.mod h1:63DOGlLAH8+REH8jUGdL3YpCpu7JODesutUjdENfUAc=
 github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.9.0/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
-github.com/onsi/gomega v1.27.4 h1:Z2AnStgsdSayCMDiCU42qIz+HLqEPcgiOCXjAU/w+8E=
+github.com/onsi/gomega v1.24.0 h1:+0glovB9Jd6z3VR+ScSwQqXVTIfJcGA9UBM8yzQxhqg=
 github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=
 github.com/open-rpc/meta-schema v0.0.0-20201029221707-1b72ef2ea333 h1:CznVS40zms0Dj5he4ERo+fRPtO0qxUk8lA8Xu3ddet0=
 github.com/open-rpc/meta-schema v0.0.0-20201029221707-1b72ef2ea333/go.mod h1:Ag6rSXkHIckQmjFBCweJEEt1mrTPBv8b9W4aU/NQWfI=
@@ -1443,6 +1446,7 @@ github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3O
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
 github.com/prometheus/client_golang v1.10.0/go.mod h1:WJM3cc3yu7XKBKa/I8WeZm+V3eltZnBwfENSU7mdogU=
 github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
+github.com/prometheus/client_golang v1.12.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
 github.com/prometheus/client_golang v1.14.0 h1:nJdhIvne2eSX/XRAFV9PcvFFRbrjbcTUj0VP62TMhnw=
 github.com/prometheus/client_golang v1.14.0/go.mod h1:8vpkKitgIVNcqrRBWh1C4TIUQgYNtG/XQE4E/Zae36Y=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
@@ -1463,8 +1467,9 @@ github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB8
 github.com/prometheus/common v0.18.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s=
 github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
 github.com/prometheus/common v0.28.0/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
-github.com/prometheus/common v0.42.0 h1:EKsfXEYo4JpWMHH5cg+KOUWeuJSov1Id8zGR8eeI1YM=
-github.com/prometheus/common v0.42.0/go.mod h1:xBwqVerjNdUDjgODMpudtOMwlOwf2SaTr1yjz4b7Zbc=
+github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
+github.com/prometheus/common v0.37.0 h1:ccBbHCgIiT9uSoFY0vX8H3zsNR5eLt17/RQLUvn8pXE=
+github.com/prometheus/common v0.37.0/go.mod h1:phzohg0JFMnBEFGxTDbfu3QyL5GI8gTQJFhYO5B3mfA=
 github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20181204211112-1dc9a6cbc91a/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
@@ -1474,18 +1479,17 @@ github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsT
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
 github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
-github.com/prometheus/procfs v0.9.0 h1:wzCHvIvM5SxWqYvwgVL7yJY8Lz3PKn49KQtpgMYJfhI=
-github.com/prometheus/procfs v0.9.0/go.mod h1:+pB4zwohETzFnmlpe6yd2lSc+0/46IYZRB/chUwxUZY=
+github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/procfs v0.8.0 h1:ODq8ZFEaYeCaZOJlZZdJA2AbQR98dSHSM1KW/You5mo=
+github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0uaxHdg830/4=
 github.com/prometheus/statsd_exporter v0.21.0 h1:hA05Q5RFeIjgwKIYEdFd59xu5Wwaznf33yKI+pyX6T8=
 github.com/prometheus/statsd_exporter v0.21.0/go.mod h1:rbT83sZq2V+p73lHhPZfMc3MLCHmSHelCh9hSGYNLTQ=
-github.com/puzpuzpuz/xsync/v2 v2.4.0 h1:5sXAMHrtx1bg9nbRZTOn8T4MkWe5V+o8yKRH02Eznag=
-github.com/puzpuzpuz/xsync/v2 v2.4.0/go.mod h1:gD2H2krq/w52MfPLE+Uy64TzJDVY7lP2znR9qmR35kU=
 github.com/quic-go/qpack v0.4.0 h1:Cr9BXA1sQS2SmDUWjSofMPNKmvF6IiIfDRmgU0w1ZCo=
 github.com/quic-go/qpack v0.4.0/go.mod h1:UZVnYIfi5GRk+zI9UMaCPsmZ2xKJP7XBUvVyT1Knj9A=
-github.com/quic-go/qtls-go1-19 v0.3.2 h1:tFxjCFcTQzK+oMxG6Zcvp4Dq8dx4yD3dDiIiyc86Z5U=
-github.com/quic-go/qtls-go1-19 v0.3.2/go.mod h1:ySOI96ew8lnoKPtSqx2BlI5wCpUVPT05RMAlajtnyOI=
-github.com/quic-go/qtls-go1-20 v0.2.2 h1:WLOPx6OY/hxtTxKV1Zrq20FtXtDEkeY00CGQm8GEa3E=
-github.com/quic-go/qtls-go1-20 v0.2.2/go.mod h1:JKtK6mjbAVcUTN/9jZpvLbGxvdWIKS8uT7EiStoU1SM=
+github.com/quic-go/qtls-go1-19 v0.2.1 h1:aJcKNMkH5ASEJB9FXNeZCyTEIHU1J7MmHyz1Q1TSG1A=
+github.com/quic-go/qtls-go1-19 v0.2.1/go.mod h1:ySOI96ew8lnoKPtSqx2BlI5wCpUVPT05RMAlajtnyOI=
+github.com/quic-go/qtls-go1-20 v0.1.1 h1:KbChDlg82d3IHqaj2bn6GfKRj84Per2VGf5XV3wSwQk=
+github.com/quic-go/qtls-go1-20 v0.1.1/go.mod h1:JKtK6mjbAVcUTN/9jZpvLbGxvdWIKS8uT7EiStoU1SM=
 github.com/quic-go/quic-go v0.33.0 h1:ItNoTDN/Fm/zBlq769lLJc8ECe9gYaW40veHCCco7y0=
 github.com/quic-go/quic-go v0.33.0/go.mod h1:YMuhaAV9/jIu0XclDXwZPAsP/2Kgr5yMYhe9oxhhOFA=
 github.com/quic-go/webtransport-go v0.5.2 h1:GA6Bl6oZY+g/flt00Pnu0XtivSD8vukOu3lYhJjnGEk=
@@ -1630,8 +1634,8 @@ github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtX
 github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/urfave/cli v1.22.10/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/urfave/cli/v2 v2.0.0/go.mod h1:SE9GqnLQmjVa0iPEY0f1w3ygNIYcIJ0OKPMoW2caLfQ=
-github.com/urfave/cli/v2 v2.25.5 h1:d0NIAyhh5shGscroL7ek/Ya9QYQE0KNabJgiUinIQkc=
-github.com/urfave/cli/v2 v2.25.5/go.mod h1:GHupkWPMM0M/sj1a2b4wUrWBPzazNrIjouW6fmdJLxc=
+github.com/urfave/cli/v2 v2.16.3 h1:gHoFIwpPjoyIMbJp/VFd+/vuD0dAgFK4B6DpEMFJfQk=
+github.com/urfave/cli/v2 v2.16.3/go.mod h1:1CNUng3PtjQMtRzJO4FMXBQvkGtuYRxxiR9xMa7jMwI=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasttemplate v1.0.1 h1:tY9CJiPnMXf1ERmG2EyK7gNUd+c6RKGD0IfU8WdUSz8=
@@ -1762,10 +1766,10 @@ go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/atomic v1.10.0 h1:9qC72Qh0+3MqyJbAn8YU5xVq1frD8bn3JtD2oXtafVQ=
 go.uber.org/atomic v1.10.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
-go.uber.org/dig v1.16.1 h1:+alNIBsl0qfY0j6epRubp/9obgtrObRAc5aD+6jbWY8=
-go.uber.org/dig v1.16.1/go.mod h1:557JTAUZT5bUK0SvCwikmLPPtdQhfvLYtO5tJgQSbnk=
-go.uber.org/fx v1.19.2 h1:SyFgYQFr1Wl0AYstE8vyYIzP4bFz2URrScjwC4cwUvY=
-go.uber.org/fx v1.19.2/go.mod h1:43G1VcqSzbIv77y00p1DRAsyZS8WdzuYdhZXmEUkMyQ=
+go.uber.org/dig v1.15.0 h1:vq3YWr8zRj1eFGC7Gvf907hE0eRjPTZ1d3xHadD6liE=
+go.uber.org/dig v1.15.0/go.mod h1:pKHs0wMynzL6brANhB2hLMro+zalv1osARTviTcqHLM=
+go.uber.org/fx v1.18.2 h1:bUNI6oShr+OVFQeU8cDNbnN7VFsu+SsjHzUF51V/GAU=
+go.uber.org/fx v1.18.2/go.mod h1:g0V1KMQ66zIRk8bLu3Ea5Jt2w/cHlOIp4wdRsgh0JaY=
 go.uber.org/goleak v1.0.0/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A=
 go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
 go.uber.org/goleak v1.1.12 h1:gZAh5/EyT/HQwlpkCy6wTpqfH9H8Lz8zbm3dZh+OyzA=
@@ -1775,8 +1779,8 @@ go.uber.org/multierr v1.4.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+
 go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=
 go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
 go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak=
-go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
-go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI=
+go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ=
 go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
@@ -1829,8 +1833,8 @@ golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5y
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=
-golang.org/x/crypto v0.7.0 h1:AvwMYaRytfdeVt3u6mLaxYtErKYjxA2OXjJ1HHq6t3A=
-golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
+golang.org/x/crypto v0.6.0 h1:qfktjS5LUO+fFKeJXZ+ikTRijMmljikvG68fpMMruSc=
+golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -1844,8 +1848,8 @@ golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EH
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
 golang.org/x/exp v0.0.0-20210615023648-acb5c1269671/go.mod h1:DVyR6MI7P4kEQgvZJSj1fQGrWIi2RzIrfYWycwheUAc=
 golang.org/x/exp v0.0.0-20210714144626-1041f73d31d8/go.mod h1:DVyR6MI7P4kEQgvZJSj1fQGrWIi2RzIrfYWycwheUAc=
-golang.org/x/exp v0.0.0-20230321023759-10a507213a29 h1:ooxPy7fPvB4kwsA2h+iBNHkAbp/4JxTSwCmvdjEYmug=
-golang.org/x/exp v0.0.0-20230321023759-10a507213a29/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
+golang.org/x/exp v0.0.0-20230213192124-5e25df0256eb h1:PaBZQdo+iSDyHT053FjUCgZQ/9uqVwPOcl7KSWhKn6w=
+golang.org/x/exp v0.0.0-20230213192124-5e25df0256eb/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
@@ -1872,8 +1876,8 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.10.0 h1:lFO9qtOdlre5W1jxS3r/4szv2/6iXxScdzjoBMXNhYk=
-golang.org/x/mod v0.10.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.7.0 h1:LapD9S96VoQRhi/GrNTqeBJFrUjs5UHCAtTlgwA5oZA=
+golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -1929,11 +1933,14 @@ golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLd
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20210423184538-5f58ad60dda6/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
 golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
-golang.org/x/net v0.8.0 h1:Zrh2ngAOFYneWTAIAPethzeaQLuHwhuBkuV6ZiRnUaQ=
-golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
+golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
+golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -1942,6 +1949,7 @@ golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4Iltr
 golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
 golang.org/x/perf v0.0.0-20180704124530-6e6d33e29852/go.mod h1:JLpeXjPJfIyPr5TlbXLkXWLhP8nz10XfvxElABhCtcw=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -2048,6 +2056,7 @@ golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -2057,16 +2066,15 @@ golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.6.0 h1:clScbb1cHjoCkyRbWwBEUZ5H/tIFu5TAXIqaZD0Gcjw=
-golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
+golang.org/x/term v0.5.0 h1:n2a8QNdAb0sZNpU9R1ALUXBbY+w51fCQDN+7EdxNBsY=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -2076,8 +2084,8 @@ golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.8.0 h1:57P1ETyNKtuIjB4SRd15iJxuhj8Gc416Y78H3qgMh68=
-golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -2143,9 +2151,10 @@ golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4f
 golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
 golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.7.0 h1:W4OVu8VVOaIO0yzWMNdepAulS7YfoS3Zabrm8DOXXU4=
-golang.org/x/tools v0.7.0/go.mod h1:4pg6aUX35JBAogB10C9AtvVL+qowtN4pT3CGSQex14s=
+golang.org/x/tools v0.3.0 h1:SrNbZl6ECOS1qFzgTdQfWXZM9XBkiA6tkFrH9YSTPHM=
+golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -2257,8 +2266,8 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
-google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
+google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -48,9 +48,9 @@ func TestDMLevelPartialRetrieval(t *testing.T) {
 	ctx := context.Background()

 	kit.QuietMiningLogs()
-	client, miner, ens := kit.EnsembleMinimal(t, kit.ThroughRPC())
+	client, miner, ens := kit.EnsembleMinimal(t, kit.ThroughRPC(), kit.MockProofs())
 	dh := kit.NewDealHarness(t, client, miner, miner)
-	ens.InterconnectAll().BeginMiningMustPost(50 * time.Millisecond)
+	ens.InterconnectAll().BeginMining(50 * time.Millisecond)

 	_, err := client.ClientImport(ctx, api.FileRef{Path: adlFixtureCar, IsCAR: true})
 	require.NoError(t, err)
@@ -121,24 +121,15 @@ func TestEthBalanceCorrectLookup(t *testing.T) {
 	require.NoError(t, err)
 	require.True(t, ml.Receipt.ExitCode.IsSuccess())

-	execTs, err := client.ChainGetTipSet(ctx, ml.TipSet)
-	require.NoError(t, err)
-
-	inclTs, err := client.ChainGetTipSet(ctx, execTs.Parents())
-	require.NoError(t, err)
-
-	inclTsParents, err := client.ChainGetTipSet(ctx, inclTs.Parents())
-	require.NoError(t, err)
-
-	bal, err := client.EVM().EthGetBalance(ctx, ethAddr, strconv.FormatInt(int64(inclTsParents.Height()), 10))
+	bal, err := client.EVM().EthGetBalance(ctx, ethAddr, strconv.FormatInt(int64(ml.Height-2), 10))
 	require.NoError(t, err)
 	require.Equal(t, int64(0), bal.Int64())

-	bal, err = client.EVM().EthGetBalance(ctx, ethAddr, strconv.FormatInt(int64(inclTs.Height()), 10))
+	bal, err = client.EVM().EthGetBalance(ctx, ethAddr, strconv.FormatInt(int64(ml.Height-1), 10))
 	require.NoError(t, err)
 	require.Equal(t, val, bal.Int64())

-	bal, err = client.EVM().EthGetBalance(ctx, ethAddr, strconv.FormatInt(int64(execTs.Height()), 10))
+	bal, err = client.EVM().EthGetBalance(ctx, ethAddr, strconv.FormatInt(int64(ml.Height), 10))
 	require.NoError(t, err)
 	require.Equal(t, val, bal.Int64())
 }
@@ -29,13 +29,18 @@ import (
 // TestDeployment smoke tests the deployment of a contract via the
 // Ethereum JSON-RPC endpoint, from an EEOA.
 func TestDeployment(t *testing.T) {
-	blockTime := 100 * time.Millisecond
+	// TODO::FVM @raulk the contract installation and invocation can be lifted into utility methods
+	// He who writes the second test, shall do that.
+	// kit.QuietMiningLogs()
+
+	// reasonable blocktime so that the tx sits in the mpool for a bit during the test.
+	// although this is non-deterministic...
+	blockTime := 1 * time.Second
 	client, _, ens := kit.EnsembleMinimal(
 		t,
 		kit.MockProofs(),
 		kit.ThroughRPC())
-
-	miners := ens.InterconnectAll().BeginMining(blockTime)
+	ens.InterconnectAll().BeginMining(blockTime)

 	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
 	defer cancel()
@@ -88,11 +93,6 @@ func TestDeployment(t *testing.T) {
 	pendingFilter, err := client.EthNewPendingTransactionFilter(ctx)
 	require.NoError(t, err)

-	// Pause so we can test that everything works while the message is in the message pool.
-	for _, miner := range miners {
-		miner.Pause()
-	}
-
 	hash := client.EVM().SubmitTransaction(ctx, &tx)

 	mpoolTx, err := client.EthGetTransactionByHash(ctx, &hash)
@@ -103,40 +103,31 @@ func TestDeployment(t *testing.T) {
 	require.Equal(t, hash, mpoolTx.Hash)

 	// these fields should be nil because the tx hasn't landed on chain.
+	// TODO::FVM @raulk We can either skip the assertion if the msg has already
+	//  landed, or pause mining between the embryo creation and this assertion.
 	require.Nil(t, mpoolTx.BlockNumber)
 	require.Nil(t, mpoolTx.BlockHash)
 	require.Nil(t, mpoolTx.TransactionIndex)

-	// We should be able to get the message CID immediately.
-	mCid, err := client.EthGetMessageCidByTransactionHash(ctx, &hash)
-	require.NoError(t, err)
-	require.NotNil(t, mCid)
-
-	// ... and it should map back to the transaction hash.
-	mHash, err := client.EthGetTransactionHashByCid(ctx, *mCid)
-	require.NoError(t, err)
-	require.NotNil(t, mHash)
-	require.Equal(t, hash, *mHash)
-
 	changes, err := client.EthGetFilterChanges(ctx, pendingFilter)
 	require.NoError(t, err)
 	require.Len(t, changes.Results, 1)
 	require.Equal(t, hash.String(), changes.Results[0])

-	// Unpause mining.
-	for _, miner := range miners {
-		miner.Restart()
+	var receipt *api.EthTxReceipt
+	for i := 0; i < 20; i++ {
+		// TODO::FVM @raulk The right time to exit this loop isn't after
+		//  20 iterations, but when StateWaitMsg returns -- let's wait on that
+		//  event while continuing to make this assertion
+		receipt, err = client.EthGetTransactionReceipt(ctx, hash)
+		if err != nil || receipt == nil {
+			time.Sleep(500 * time.Millisecond)
+			continue
+		}
+		break
 	}
-
-	// Wait for the message to land.
-	_, err = client.StateWaitMsg(ctx, *mCid, 3, api.LookbackNoLimit, false)
-	require.NoError(t, err)
-
-	// Then lookup the receipt.
-	receipt, err := client.EthGetTransactionReceipt(ctx, hash)
 	require.NoError(t, err)
 	require.NotNil(t, receipt)
-
 	// logs must be an empty array, not a nil value, to avoid tooling compatibility issues
 	require.Empty(t, receipt.Logs)
 	// a correctly formed logs bloom, albeit empty, has 256 zeroes
@@ -182,16 +173,21 @@ func TestDeployment(t *testing.T) {
 	require.Nil(t, err)
 	require.True(t, reflect.DeepEqual(block1, block2))

-	// verify that the block contains full tx objects
-	block3, err := client.EthGetBlockByHash(ctx, *chainTx.BlockHash, true)
+	// should be able to get the block using latest as well
+	block3, err := client.EthGetBlockByNumber(ctx, "latest", false)
 	require.Nil(t, err)
-	require.Equal(t, block3.Hash, *chainTx.BlockHash)
-	require.Equal(t, block3.Number, *chainTx.BlockNumber)
+	require.True(t, reflect.DeepEqual(block2, block3))
+
+	// verify that the block contains full tx objects
+	block4, err := client.EthGetBlockByHash(ctx, *chainTx.BlockHash, true)
+	require.Nil(t, err)
+	require.Equal(t, block4.Hash, *chainTx.BlockHash)
+	require.Equal(t, block4.Number, *chainTx.BlockNumber)

 	// the call went through json-rpc and the response was unmarshaled
 	// into map[string]interface{}, so it has to be converted into ethtypes.EthTx
 	var foundTx *ethtypes.EthTx
-	for _, obj := range block3.Transactions {
+	for _, obj := range block4.Transactions {
 		j, err := json.Marshal(obj)
 		require.Nil(t, err)

@@ -206,10 +202,10 @@ func TestDeployment(t *testing.T) {
 	require.NotNil(t, foundTx)
 	require.True(t, reflect.DeepEqual(*foundTx, *chainTx))

-	// make sure the _full_ block got from EthGetBlockByNumber is the same
-	block4, err := client.EthGetBlockByNumber(ctx, blkNum, true)
+	// make sure the block got from EthGetBlockByNumber is the same
+	block5, err := client.EthGetBlockByNumber(ctx, blkNum, true)
 	require.Nil(t, err)
-	require.True(t, reflect.DeepEqual(block3, block4))
+	require.True(t, reflect.DeepEqual(block4, block5))

 	// Verify that the deployer is now an account.
 	client.AssertActorType(ctx, deployer, manifest.EthAccountKey)
@@ -50,6 +50,19 @@ func TestEthFeeHistory(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
 	defer cancel()

+	heads, err := client.ChainNotify(ctx)
+	require.NoError(err)
+
+	// Save the full view of the tipsets to calculate the answer when there are null rounds
+	tsHeights := []int{1}
+	go func() {
+		for chg := range heads {
+			for _, c := range chg {
+				tsHeights = append(tsHeights, int(c.Val.Height()))
+			}
+		}
+	}()
+
 	miner := ens.InterconnectAll().BeginMining(blockTime)

 	client.WaitTillChain(ctx, kit.HeightAtLeast(7))
@@ -76,16 +89,6 @@ func TestEthFeeHistory(t *testing.T) {
 		}
 	}()

-	currTs, err := client.ChainHead(ctx)
-	require.NoError(err)
-
-	var tsHeights []int
-	for currTs.Height() != 0 {
-		tsHeights = append(tsHeights, int(currTs.Height()))
-		currTs, err = client.ChainGetTipSet(ctx, currTs.Parents())
-		require.NoError(err)
-	}
-
 	sort.Ints(tsHeights)

 	// because of the deferred execution, the last tipset is not executed yet,
@@ -425,11 +425,6 @@ func TestEthNewFilterDefaultSpec(t *testing.T) {
 	elogs, err := parseEthLogsFromFilterResult(res)
 	require.NoError(err)
 	AssertEthLogs(t, elogs, expected, received)
-
-	// giving a number to fromBlock/toBlock needs to be in hex format, so make sure passing in decimal fails
-	blockNrInDecimal := "2812200"
-	_, err = client.EthNewFilter(ctx, &ethtypes.EthFilterSpec{FromBlock: &blockNrInDecimal, ToBlock: &blockNrInDecimal})
-	require.Error(err, "expected error when fromBlock/toBlock is not in hex format")
 }

 func TestEthGetLogsBasic(t *testing.T) {
@@ -184,8 +184,7 @@ func (bm *BlockMiner) MineBlocksMustPost(ctx context.Context, blocktime time.Dur

 			dlinfo, err := bm.miner.FullNode.StateMinerProvingDeadline(ctx, bm.miner.ActorAddr, ts.Key())
 			require.NoError(bm.t, err)
-			if ts.Height()+5+abi.ChainEpoch(nulls) >= dlinfo.Last() { // Next block brings us past the last epoch in dline, we need to wait for miner to post
-				bm.t.Logf("forcing post to get in before deadline closes at %d", dlinfo.Last())
+			if ts.Height()+1+abi.ChainEpoch(nulls) >= dlinfo.Last() { // Next block brings us past the last epoch in dline, we need to wait for miner to post
 				bm.forcePoSt(ctx, ts, dlinfo)
 			}

@@ -217,8 +216,7 @@ func (bm *BlockMiner) MineBlocksMustPost(ctx context.Context, blocktime time.Dur
 				}
 				if !success {
 					// if we are mining a new null block and it brings us past deadline boundary we need to wait for miner to post
-					if ts.Height()+5+abi.ChainEpoch(nulls+i) >= dlinfo.Last() {
-						bm.t.Logf("forcing post to get in before deadline closes at %d", dlinfo.Last())
+					if ts.Height()+1+abi.ChainEpoch(nulls+i) >= dlinfo.Last() {
 						bm.forcePoSt(ctx, ts, dlinfo)
 					}
 				}
@@ -238,7 +236,7 @@ func (bm *BlockMiner) MineBlocksMustPost(ctx context.Context, blocktime time.Dur
 					break
 				}

-				require.NotEqual(bm.t, i, nloops-1, "block at height %d never managed to sync to node, which is at height %d", target, ts.Height())
+				require.NotEqual(bm.t, i, nloops-1, "block never managed to sync to node")
 				time.Sleep(time.Millisecond * 10)
 			}

@@ -350,7 +348,7 @@ func (bm *BlockMiner) MineUntilBlock(ctx context.Context, fn *TestFullNode, cb f
 					break
 				}

-				require.NotEqual(bm.t, i, nloops-1, "block at height %d never managed to sync to node, which is at height %d", epoch, ts.Height())
+				require.NotEqual(bm.t, i, nloops-1, "block never managed to sync to node")
 				time.Sleep(time.Millisecond * 10)
 			}

@@ -80,7 +80,7 @@ func RunClientTest(t *testing.T, cmds []*lcli.Command, clientNode *TestFullNode)
 	dealStatus := ""
 	for {
 		// client list-deals
-		out = clientCLI.RunCmd("client", "list-deals", "--show-failed")
+		out = clientCLI.RunCmd("client", "list-deals")
 		fmt.Println("list-deals:\n", out)

 		lines := strings.Split(out, "\n")
@@ -5,7 +5,6 @@ import (
 	"context"
 	"fmt"
 	"testing"
-	"time"

 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
@@ -221,17 +220,14 @@ func TestNetBlockIPAddr(t *testing.T) {
 	firstAddrInfo, _ := firstNode.NetAddrsListen(ctx)
 	secondAddrInfo, _ := secondNode.NetAddrsListen(ctx)

-	secondNodeIPsMap := map[string]struct{}{} // so we can deduplicate
+	var secondNodeIPs []string
+
 	for _, addr := range secondAddrInfo.Addrs {
 		ip, err := manet.ToIP(addr)
 		if err != nil {
 			continue
 		}
-		secondNodeIPsMap[ip.String()] = struct{}{}
-	}
-	var secondNodeIPs []string
-	for s := range secondNodeIPsMap {
-		secondNodeIPs = append(secondNodeIPs, s)
+		secondNodeIPs = append(secondNodeIPs, ip.String())
 	}

 	// Sanity check that we're not already connected somehow
@@ -247,8 +243,6 @@ func TestNetBlockIPAddr(t *testing.T) {
 	list, err := firstNode.NetBlockList(ctx)
 	require.NoError(t, err)

-	fmt.Println(list.IPAddrs)
-	fmt.Println(secondNodeIPs)
 	require.Equal(t, len(list.IPAddrs), len(secondNodeIPs), "expected %d blocked IPs", len(secondNodeIPs))
 	for _, blockedIP := range list.IPAddrs {
 		found := false
@@ -262,14 +256,10 @@ func TestNetBlockIPAddr(t *testing.T) {
 		require.True(t, found, "blocked IP %s is not one of secondNodeIPs", blockedIP)
 	}

-	// a QUIC connection might still succeed when gated, but will be killed right after the handshake
-	_ = secondNode.NetConnect(ctx, firstAddrInfo)
-
-	require.Eventually(t, func() bool {
-		connectedness, err = secondNode.NetConnectedness(ctx, firstAddrInfo.ID)
-		require.NoError(t, err, "failed to determine connectedness")
-		return connectedness != network.Connected
-	}, time.Second*5, time.Millisecond*10)
+	require.Error(t, secondNode.NetConnect(ctx, firstAddrInfo), "shouldn't be able to connect to second node")
+	connectedness, err = secondNode.NetConnectedness(ctx, firstAddrInfo.ID)
+	require.NoError(t, err, "failed to determine connectedness")
+	require.NotEqual(t, connectedness, network.Connected)

 	// stm: @NETWORK_COMMON_BLOCK_REMOVE_001
 	err = firstNode.NetBlockRemove(ctx, api.NetBlockList{IPAddrs: secondNodeIPs})
@@ -10,6 +10,7 @@ import (
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"github.com/stretchr/testify/require"

+	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	paychtypes "github.com/filecoin-project/go-state-types/builtin/v8/paych"
@@ -18,6 +19,7 @@ import (
 	"github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/events"
@@ -50,7 +52,8 @@ func TestPaymentChannelsAPI(t *testing.T) {
 		Miner(&miner, &paymentCreator, kit.WithAllSubsystems()).
 		Start().
 		InterconnectAll()
-	ens.BeginMiningMustPost(blockTime)
+	bms := ens.BeginMiningMustPost(blockTime)
+	bm := bms[0]

 	waitRecvInSync := func() {
 		// paymentCreator is the block miner, in some cases paymentReceiver may fall behind, so we wait for it to catch up
@@ -194,12 +197,7 @@ func TestPaymentChannelsAPI(t *testing.T) {
 	require.Errorf(t, err, "Expected shortfall error of %d", excessAmt)

 	// wait for the settlement period to pass before collecting
-	head, err := paymentReceiver.ChainHead(ctx)
-	require.NoError(t, err)
-
-	settleHeight := head.Height() + policy.PaychSettleDelay + 5
-	paymentReceiver.WaitTillChain(ctx, kit.HeightAtLeast(settleHeight))
-	paymentCreator.WaitTillChain(ctx, kit.HeightAtLeast(settleHeight))
+	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, policy.PaychSettleDelay)

 	creatorPreCollectBalance, err := paymentCreator.WalletBalance(ctx, createrAddr)
 	require.NoError(t, err)
@@ -228,6 +226,31 @@ func TestPaymentChannelsAPI(t *testing.T) {
 	require.EqualValues(t, abi.NewTokenAmount(expectedRefund), delta, "did not send correct funds from creator: expected %d, got %d", expectedRefund, delta)
 }

+func waitForBlocks(ctx context.Context, t *testing.T, bm *kit.BlockMiner, paymentReceiver kit.TestFullNode, receiverAddr address.Address, count int) {
+	// We need to add null blocks in batches, if we add too many the chain can't sync
+	batchSize := 60
+	for i := 0; i < count; i += batchSize {
+		size := batchSize
+		if i > count {
+			size = count - i
+		}
+
+		// Add a batch of null blocks to advance the chain quicker through finalities.
+		bm.InjectNulls(abi.ChainEpoch(size - 1))
+
+		// Add a real block
+		m, err := paymentReceiver.MpoolPushMessage(ctx, &types.Message{
+			To:    builtin.BurntFundsActorAddr,
+			From:  receiverAddr,
+			Value: types.NewInt(0),
+		}, nil)
+		require.NoError(t, err)
+
+		_, err = paymentReceiver.StateWaitMsg(ctx, m.Cid(), 1, api.LookbackNoLimit, true)
+		require.NoError(t, err)
+	}
+}
+
 func waitForMessage(ctx context.Context, t *testing.T, paymentCreator kit.TestFullNode, msgCid cid.Cid, duration time.Duration, desc string) *api.MsgLookup {
 	ctx, cancel := context.WithTimeout(ctx, duration)
 	defer cancel()
@@ -1,64 +0,0 @@
-package itests
-
-import (
-	"context"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/filecoin-project/lotus/itests/kit"
-	"github.com/filecoin-project/lotus/storage/sealer/storiface"
-)
-
-// Regression check for a fix introduced in https://github.com/filecoin-project/lotus/pull/10633
-func TestPledgeMaxConcurrentGet(t *testing.T) {
-	require.NoError(t, os.Setenv("GET_2K_MAX_CONCURRENT", "1"))
-	t.Cleanup(func() {
-		require.NoError(t, os.Unsetenv("GET_2K_MAX_CONCURRENT"))
-	})
-
-	kit.QuietMiningLogs()
-
-	blockTime := 50 * time.Millisecond
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	_, miner, ens := kit.EnsembleMinimal(t, kit.NoStorage()) // no mock proofs
-	ens.InterconnectAll().BeginMiningMustPost(blockTime)
-
-	// separate sealed and storage paths so that finalize move needs to happen
-	miner.AddStorage(ctx, t, func(meta *storiface.LocalStorageMeta) {
-		meta.CanSeal = true
-	})
-	miner.AddStorage(ctx, t, func(meta *storiface.LocalStorageMeta) {
-		meta.CanStore = true
-	})
-
-	// NOTE: This test only repros the issue when Fetch tasks take ~10s, there's
-	// no great way to do that in a non-horribly-hacky way
-
-	/* The horribly hacky way:
-
-	diff --git a/storage/sealer/sched_worker.go b/storage/sealer/sched_worker.go
-	index 35acd755d..76faec859 100644
-	--- a/storage/sealer/sched_worker.go
-	+++ b/storage/sealer/sched_worker.go
-	@@ -513,6 +513,10 @@ func (sw *schedWorker) startProcessingTask(req *WorkerRequest) error {
-	                        tw.start()
-	                        err = <-werr
-
-	+                       if req.TaskType == sealtasks.TTFetch {
-	+                               time.Sleep(10 * time.Second)
-	+                       }
-	+
-	                        select {
-	                        case req.ret <- workerResponse{err: err}:
-	                        case <-req.Ctx.Done():
-
-	*/
-
-	miner.PledgeSectors(ctx, 3, 0, nil)
-}
@@ -31,8 +31,8 @@ func TestDealsWithFinalizeEarly(t *testing.T) {
 	var blockTime = 50 * time.Millisecond

 	// We use two miners so that in case the actively tested miner misses PoSt, we still have a blockchain
-	client, miner, poster, ens := kit.EnsembleOneTwo(t, kit.ThroughRPC(), kit.MutateSealingConfig(func(sc *config.SealingConfig) { sc.FinalizeEarly = true })) // no mock proofs.
-	ens.InterconnectAll().BeginMiningMustPost(blockTime, poster)
+	client, miner, _, ens := kit.EnsembleOneTwo(t, kit.ThroughRPC(), kit.MutateSealingConfig(func(sc *config.SealingConfig) { sc.FinalizeEarly = true })) // no mock proofs.
+	ens.InterconnectAll().BeginMining(blockTime)
 	dh := kit.NewDealHarness(t, client, miner, miner)

 	ctx := context.Background()
@@ -39,9 +39,7 @@ func TestSectorImportAfterPC2(t *testing.T) {
 	////////
 	// Start a miner node

-	// We use two miners so that in case the actively tested miner misses PoSt, we still have a blockchain
-	client, miner, _, ens := kit.EnsembleOneTwo(t, kit.ThroughRPC())
-
+	client, miner, ens := kit.EnsembleMinimal(t, kit.ThroughRPC())
 	ens.InterconnectAll().BeginMining(blockTime)

 	ctx := context.Background()
@@ -1,7 +1,6 @@
 package itests

 import (
-	"bytes"
 	"context"
 	"strings"
 	"sync/atomic"
@@ -14,17 +13,13 @@ import (

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner"
-	"github.com/filecoin-project/go-state-types/network"

 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/itests/kit"
 	"github.com/filecoin-project/lotus/node"
-	"github.com/filecoin-project/lotus/node/config"
 	"github.com/filecoin-project/lotus/node/impl"
-	"github.com/filecoin-project/lotus/node/modules"
 	"github.com/filecoin-project/lotus/node/repo"
 	"github.com/filecoin-project/lotus/storage/paths"
 	sealing "github.com/filecoin-project/lotus/storage/pipeline"
@@ -505,228 +500,3 @@ func TestWorkerName(t *testing.T) {

 	require.True(t, found)
 }
-
-// Tests that V1_1 proofs on post workers with faults
-func TestWindowPostV1P1NV20WorkerFault(t *testing.T) {
-	kit.QuietMiningLogs()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	blocktime := 2 * time.Millisecond
-
-	sectors := 2 * 48 * 2
-	var badsector uint64 = 100000
-
-	client, miner, _, ens := kit.EnsembleWorker(t,
-		kit.PresealSectors(sectors), // 2 sectors per partition, 2 partitions in all 48 deadlines
-		kit.GenesisNetworkVersion(network.Version20),
-		kit.ConstructorOpts(
-			node.Override(new(config.ProvingConfig), func() config.ProvingConfig {
-				c := config.DefaultStorageMiner()
-				c.Proving.DisableBuiltinWindowPoSt = true
-				return c.Proving
-			}),
-			node.Override(new(*wdpost.WindowPoStScheduler), modules.WindowPostScheduler(
-				config.DefaultStorageMiner().Fees,
-				config.ProvingConfig{
-					DisableBuiltinWindowPoSt:  true,
-					DisableBuiltinWinningPoSt: false,
-					DisableWDPoStPreChecks:    false,
-				},
-			)),
-			node.Override(new(paths.Store), func(store *paths.Remote) paths.Store {
-				return &badWorkerStorage{
-					Store:       store,
-					badsector:   &badsector,
-					notBadCount: 1,
-				}
-			})),
-		kit.ThroughRPC(),
-		kit.WithTaskTypes([]sealtasks.TaskType{sealtasks.TTGenerateWindowPoSt}),
-		kit.WithWorkerStorage(func(store paths.Store) paths.Store {
-			return &badWorkerStorage{
-				Store:     store,
-				badsector: &badsector,
-			}
-		}))
-
-	bm := ens.InterconnectAll().BeginMining(blocktime)[0]
-
-	maddr, err := miner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	// wait for sectors to be committed
-	require.Eventually(t, func() bool {
-		di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-		require.NoError(t, err)
-
-		parts, err := client.StateMinerPartitions(ctx, maddr, di.Index, types.EmptyTSK)
-		require.NoError(t, err)
-
-		return len(parts) > 1
-	}, 30*time.Second, 100*time.Millisecond)
-
-	// Wait until just before a deadline opens
-	{
-		di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-		require.NoError(t, err)
-
-		di = di.NextNotElapsed()
-
-		t.Log("Running one proving period")
-		waitUntil := di.Open + di.WPoStChallengeWindow - di.WPoStChallengeLookback - 1
-		client.WaitTillChain(ctx, kit.HeightAtLeast(waitUntil))
-
-		t.Log("Waiting for post message")
-		bm.Stop()
-	}
-
-	// Remove one sector in the next deadline (so it's skipped)
-	{
-		di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-		require.NoError(t, err)
-
-		parts, err := client.StateMinerPartitions(ctx, maddr, di.Index+1, types.EmptyTSK)
-		require.NoError(t, err)
-		require.Greater(t, len(parts), 0)
-
-		secs := parts[0].AllSectors
-		n, err := secs.Count()
-		require.NoError(t, err)
-		require.Equal(t, uint64(2), n)
-
-		// Drop the sector in first partition
-		sid, err := secs.First()
-		require.NoError(t, err)
-
-		t.Logf("Drop sector %d; dl %d part %d", sid, di.Index, 0)
-
-		atomic.StoreUint64(&badsector, sid)
-		require.NoError(t, err)
-	}
-
-	bm.MineBlocksMustPost(ctx, 2*time.Millisecond)
-
-	mi, err := client.StateMinerInfo(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
-	require.NoError(t, err)
-	en := wact.Nonce
-
-	// wait for a new message to be sent from worker address, it will be a PoSt
-
-waitForProof:
-	for {
-		//stm: @CHAIN_STATE_GET_ACTOR_001
-		wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
-		require.NoError(t, err)
-		if wact.Nonce > en {
-			break waitForProof
-		}
-
-		build.Clock.Sleep(blocktime)
-	}
-
-	slm, err := client.StateListMessages(ctx, &api.MessageMatch{To: maddr}, types.EmptyTSK, 0)
-	require.NoError(t, err)
-
-	pmr, err := client.StateSearchMsg(ctx, types.EmptyTSK, slm[0], -1, false)
-	require.NoError(t, err)
-
-	nv, err := client.StateNetworkVersion(ctx, pmr.TipSet)
-	require.NoError(t, err)
-	require.Equal(t, network.Version20, nv)
-
-	require.True(t, pmr.Receipt.ExitCode.IsSuccess())
-
-	slmsg, err := client.ChainGetMessage(ctx, slm[0])
-	require.NoError(t, err)
-
-	var params miner11.SubmitWindowedPoStParams
-	require.NoError(t, params.UnmarshalCBOR(bytes.NewBuffer(slmsg.Params)))
-	require.Equal(t, abi.RegisteredPoStProof_StackedDrgWindow2KiBV1_1, params.Proofs[0].PoStProof)
-
-	require.Len(t, params.Partitions, 2)
-	sc0, err := params.Partitions[0].Skipped.Count()
-	require.NoError(t, err)
-	require.Equal(t, uint64(1), sc0)
-	sc1, err := params.Partitions[1].Skipped.Count()
-	require.NoError(t, err)
-	require.Equal(t, uint64(0), sc1)
-}
-
-// Tests that V1_1 proofs on post worker
-func TestWindowPostV1P1NV20Worker(t *testing.T) {
-	kit.QuietMiningLogs()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	blocktime := 2 * time.Millisecond
-
-	client, miner, _, ens := kit.EnsembleWorker(t,
-		kit.GenesisNetworkVersion(network.Version20),
-		kit.ConstructorOpts(
-			node.Override(new(config.ProvingConfig), func() config.ProvingConfig {
-				c := config.DefaultStorageMiner()
-				c.Proving.DisableBuiltinWindowPoSt = true
-				return c.Proving
-			}),
-			node.Override(new(*wdpost.WindowPoStScheduler), modules.WindowPostScheduler(
-				config.DefaultStorageMiner().Fees,
-				config.ProvingConfig{
-					DisableBuiltinWindowPoSt:  true,
-					DisableBuiltinWinningPoSt: false,
-					DisableWDPoStPreChecks:    false,
-				},
-			))),
-		kit.ThroughRPC(),
-		kit.WithTaskTypes([]sealtasks.TaskType{sealtasks.TTGenerateWindowPoSt}))
-
-	ens.InterconnectAll().BeginMining(blocktime)
-
-	maddr, err := miner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	mi, err := client.StateMinerInfo(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
-	require.NoError(t, err)
-	en := wact.Nonce
-
-	// wait for a new message to be sent from worker address, it will be a PoSt
-
-waitForProof:
-	for {
-		//stm: @CHAIN_STATE_GET_ACTOR_001
-		wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
-		require.NoError(t, err)
-		if wact.Nonce > en {
-			break waitForProof
-		}
-
-		build.Clock.Sleep(blocktime)
-	}
-
-	slm, err := client.StateListMessages(ctx, &api.MessageMatch{To: maddr}, types.EmptyTSK, 0)
-	require.NoError(t, err)
-
-	pmr, err := client.StateSearchMsg(ctx, types.EmptyTSK, slm[0], -1, false)
-	require.NoError(t, err)
-
-	nv, err := client.StateNetworkVersion(ctx, pmr.TipSet)
-	require.NoError(t, err)
-	require.Equal(t, network.Version20, nv)
-
-	require.True(t, pmr.Receipt.ExitCode.IsSuccess())
-
-	slmsg, err := client.ChainGetMessage(ctx, slm[0])
-	require.NoError(t, err)
-
-	var params miner11.SubmitWindowedPoStParams
-	require.NoError(t, params.UnmarshalCBOR(bytes.NewBuffer(slmsg.Params)))
-	require.Equal(t, abi.RegisteredPoStProof_StackedDrgWindow2KiBV1_1, params.Proofs[0].PoStProof)
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Shrenuj Bansal	e8dcf9f838	update cl (#10819 )	2023-05-03 19:07:15 -04:00
Shrenuj Bansal	a03535ae20	Update changelog.md for release/v1.23.1	2023-05-03 18:32:10 -04:00
Shrenuj Bansal	fadc94f253	Update build version for release/v1.23.1	2023-05-03 17:20:57 -04:00