Merge pull request #10990 from filecoin-project/sbansal/1.23.1-final-cut

chore: Update build version and changelog for final 1.23.1 cut

.gitignore

@@ -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

CHANGELOG.md

@@ -1,10 +1,168 @@
 # Lotus changelog
 
-# UNRELEASED
+# v1.23.1 / 2023-06-20
+
+This is an optional feature release of Lotus. This feature release includes numerous improvements and enhancements for node operators, ETH RPC-providers and storage providers.
+
+**☢️ Upgrade Warnings ☢️**
+
+If you are upgrading to this release candidate from Lotus v1.22.1, please make sure to read the upgrade warnings section in the [v1.23.0 release first.](https://github.com/filecoin-project/lotus/releases/tag/v1.23.0)
+
+- *Storage providers:* The Lotus-Miner legacy-markets has been disbled by default in this feature release and will be removed in the near term future. Users are adviced to migrate to [Boost](https://boost.filecoin.io) or other SP markets systems.
+
+## Highlights
+
+**🛣 Execution Lanes 🛣**
+This feature release introduces VM Execution Lanes! Execution lanes efficiently divide the workload between system processes  (chainsync) and RPC requests. This way syncing the chain will not be at the mercy of responding to users' requests and RPC providers nodes should have less problems catching up.
+
+To take advantage of VM Execution Lanes, you need to set up two environment variables:
+- `LOTUS_FVM_CONCURRENCY` - read more about how this value should be set to [here](https://lotus.filecoin.io/lotus/configure/ethereum-rpc/#environment-variables)
+- `LOTUS_FVM_CONCURRENCY_RESERVED = 4` 
+
+**🧱 Aggregation / Batching fixes 🔨**
+
+Numerous aggregation and batching fixes has been included in the feature release. Large `ProveCommitAggregate` and `PreCommitBatching` messages that exceeds the block limit will now automatically be split into smaller messages when sent to the chain.
+
+Additionally we have added a new feature that staggers the amount of ProveCommit messages sent simulatanously to the chain if a storage provider has been aggregating many sectors in ProveCommitAggregate message, but at the time of publishing the BaseFee is below the aggregation threshold. This stagger feature prevents issues where some of the ProveCommit messages fail with the SysErrorOutOfGas message. You can tweak how many messages will be staggered per epoch by changing `MaxSectorProveCommitsSubmittedPerEpoch` in the [sealing section of the config.toml file.](https://lotus.filecoin.io/storage-providers/advanced-configurations/sealing/#sealing-section)
+
+*NB:* While these fixes are great for the reliability of aggregation and batching on the Lotus side, it has been uncovered that aggregating ProveCommit messages for sectors containing verified deals are currently more expensive then single messages due to an issue on the actors side. We therefore do not reccomend our users to aggregate ProveCommit messages when doing verified deals until that issue has been resolved. You can follow the discussion on resolving the issue on the [actors side here.](https://github.com/filecoin-project/FIPs/discussions/689)
+
+**Unsealing CLI/API**
+
+This feature release adds a dedicated `lotus-miner sectors unseal` command and API, allowing you to unseal specific sealed sectors easily.
 
 ## 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))
+- feat: VM Execution Lanes ([filecoin-project/lotus#10551](https://github.com/filecoin-project/lotus/pull/10551))
-  - 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. 
+   - Adds VM exections lanes, efficiently dividing the workload between system processes and RPC-requests.
+- Add API and CLI to unseal sector (#10626) ([filecoin-project/lotus#10626](https://github.com/filecoin-project/lotus/pull/10626))
+   - Adds `lotus-miner sectors unseal` cmd, and a API-method to unseal a sector.
+- feat: sealing: Split PCA/PCB batches if gas used exceeds block limit ([filecoin-project/lotus#10647](https://github.com/filecoin-project/lotus/pull/10647))
+   - Splits ProveCommitAggregate and PreCommitBatch messages into multiple messages if the message exceeds the block limit.
+- Add feature to stagger sector prove commit submission (#10543) ([filecoin-project/lotus#10543](https://github.com/filecoin-project/lotus/pull/10543))
+   - Staggers the amount of ProveCommit messages sent simultanously if a storage provider has been aggregating many message, but at the moment of publishing the BaseFee is below the threshold for aggregation to prevent unwanted SysErrorOutOfGas issues.
+- Set default for MaxSectorProveCommitsSubmittedPerEpoch ([filecoin-project/lotus#10728](https://github.com/filecoin-project/lotus/pull/10728))
+   - Sets the default amount of ProveCommits submitted per epoch to 20.
+- feat: worker: Ensure tempdir exists (#10433) ([filecoin-project/lotus#10433](https://github.com/filecoin-project/lotus/pull/10433))
+   - Ensures that a temporary directory exists on start of a lotus-worker with a custom TMPDIR set.
+- feat: sync: harden chain sync (#10756) ([filecoin-project/lotus#10756](https://github.com/filecoin-project/lotus/pull/10756))
+- feat: populate the index on snapshot import ([filecoin-project/lotus#10556](https://github.com/filecoin-project/lotus/pull/10556))
+- feat:chain: Message Index (**HIGHLY EXPERIMENTAL**) ([filecoin-project/lotus#10452](https://github.com/filecoin-project/lotus/pull/10452))
+   - MVP of a message index that allows us to accelrate StateSearchMessage and related functionality, and eventually accelerate critical chain calls (follow up).
+- feat: Add small cache to execution traces ([filecoin-project/lotus#10517](https://github.com/filecoin-project/lotus/pull/10517))
+- feat: shed: incoming block-sub chainwatch tool ([filecoin-project/lotus#10513](https://github.com/filecoin-project/lotus/pull/10513))
+
+## Improvements
+- feat: daemon: Auto-resume interrupted snapshot imports ([filecoin-project/lotus#10636](https://github.com/filecoin-project/lotus/pull/10636))
+   - Auto-resumes interrupted snapshot imports when using an URL.
+- fix: storage: Remove temp fetching files after failed fetch ([filecoin-project/lotus#10661](https://github.com/filecoin-project/lotus/pull/10661))
+   - Clean up partially fetched failed after a failed fetch on a lotus-worker.
+- feat: chainstore: batch writes of tipsets ([filecoin-project/lotus#10800](https://github.com/filecoin-project/lotus/pull/10800))
+   - Reduces the time to persist all headers from 4-5 minutes, to < 15 seconds. 
+- Check if epoch is negative in GetTipsetByHeight
+- fix: sched: Address GET_32G_MAX_CONCURRENT regression
+- fix: cli: Hide legacy markets cmds
+   - Hides the lotus-miner legacy markets commands from the lotus-miner CLI.
+- fix: ci: Debugging m1 build
+- Disable lotus markets by default (#10809) ([filecoin-project/lotus#10809](https://github.com/filecoin-project/lotus/pull/10809))
+   - Disables lotus-miner legacy markets [EOL] by default.
+- perf: mempool: lower priority optimizations (#10693) ([filecoin-project/lotus#10693](https://github.com/filecoin-project/lotus/pull/10693))
+- perf: message pool: change locks to RWMutexes for performance ([filecoin-project/lotus#10561](https://github.com/filecoin-project/lotus/pull/10561))
+- perf: eth: gas estimate set applyTsMessages false (#10546) ([filecoin-project/lotus#10546](https://github.com/filecoin-project/lotus/pull/10546))
+- Change args check ([filecoin-project/lotus#10812](https://github.com/filecoin-project/lotus/pull/10812))
+- 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))
+- fix: prover: Propagate skipped sectors in local PoSt
+- fix: unseal: check if sealed/update sector exists ([filecoin-project/lotus#10639](https://github.com/filecoin-project/lotus/pull/10639))
+- fix: sealing pipeline: Allow nil message in TerminateWait ([filecoin-project/lotus#10696](https://github.com/filecoin-project/lotus/pull/10696))
+- fix: cli: Check if the sectorID exists before removing ([filecoin-project/lotus#10611](https://github.com/filecoin-project/lotus/pull/10611))
+- feat:splitstore:limit moving gc threads ([filecoin-project/lotus#10621](https://github.com/filecoin-project/lotus/pull/10621))
+- fix: cli: Make `net connect` to miner address work ([filecoin-project/lotus#10599](https://github.com/filecoin-project/lotus/pull/10599))
+- fix: log: Stop logging `file does not exists` ([filecoin-project/lotus#10588](https://github.com/filecoin-project/lotus/pull/10588))
+- 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: miner: correctly count sector extensions ([filecoin-project/lotus#10544](https://github.com/filecoin-project/lotus/pull/10544))
+- fix:mpool: prune excess messages before selection ([filecoin-project/lotus#10648](https://github.com/filecoin-project/lotus/pull/10648))
+- fix: proving: Initialize slice with with same length as partition ([filecoin-project/lotus#10569](https://github.com/filecoin-project/lotus/pull/10569))
+- perf: Address performance of EthGetTransactionCount  ([filecoin-project/lotus#10700](https://github.com/filecoin-project/lotus/pull/10700))
+- fix: sync: reduce log from error to info ([filecoin-project/lotus#10759](https://github.com/filecoin-project/lotus/pull/10759))
+- fix: state: lotus-miner info should show deals info without admin permission ([filecoin-project/lotus#10323](https://github.com/filecoin-project/lotus/pull/10323))
+- 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: chain: record heaviest tipset before notifying (#10694) ([filecoin-project/lotus#10694](https://github.com/filecoin-project/lotus/pull/10694))
+- 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))
+- feat: chainstore: optimize BlockMsgsForTipset ([filecoin-project/lotus#10552](https://github.com/filecoin-project/lotus/pull/10552))
+- refactor: stop using deprecated io/ioutil ([filecoin-project/lotus#10596](https://github.com/filecoin-project/lotus/pull/10596))
+- feat: shed: refactor market cron-state command ([filecoin-project/lotus#10746](https://github.com/filecoin-project/lotus/pull/10746))
+- fix: events: don't set GC confidence to 1 ([filecoin-project/lotus#10713](https://github.com/filecoin-project/lotus/pull/10713))
+- 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))
+- fix: remove pointless panic ([filecoin-project/lotus#10690](https://github.com/filecoin-project/lotus/pull/10690))
+- fix: check for nil bcastDict (#10646) ([filecoin-project/lotus#10646](https://github.com/filecoin-project/lotus/pull/10646))
+- fix: make state compute --html work with unknown methods ([filecoin-project/lotus#10619](https://github.com/filecoin-project/lotus/pull/10619))
+- shed: get balances of evm accounts  ([filecoin-project/lotus#10489](https://github.com/filecoin-project/lotus/pull/10489))
+- 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))
+- Fix: export-range: Ignore ipld Blocks not found in Receipts. ([filecoin-project/lotus#10535](https://github.com/filecoin-project/lotus/pull/10535))
+- 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))
+- Merge branch 'feat/new-gw-methods'
+
+## Dependencies
+- chore: deps: update to go-libp2p 0.27.5
+- devs: update libp2p #10937
+- chore: deps: update to FVM 3.3.1 ([filecoin-project/lotus#10786](https://github.com/filecoin-project/lotus/pull/10786))
+- chore: boxo: migrate from go-libipfs to boxo ([filecoin-project/lotus#10562](https://github.com/filecoin-project/lotus/pull/10562))
+- chore: deps: update to go-state-types v0.11.0-alpha-3 ([filecoin-project/lotus#10606](https://github.com/filecoin-project/lotus/pull/10606))
+- chore: bump go-libipfs ([filecoin-project/lotus#10531](https://github.com/filecoin-project/lotus/pull/10531))
+
+## Others
+- feat:networking:  (Synchronous) Consistent Broadcast for Filecoin EC ([filecoin-project/lotus#9858](https://github.com/filecoin-project/lotus/pull/9858))
+- Revert #9858 (consistent broadcast changes) ([filecoin-project/lotus#10777](https://github.com/filecoin-project/lotus/pull/10777))
+- Update build version for release/v1.23.1
+- chore: drop flaky TestBatchDealInput subcase ([filecoin-project/lotus#10810](https://github.com/filecoin-project/lotus/pull/10810))
+- 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))
+- chore: build: bump matser version to v1.23.1-dev ([filecoin-project/lotus#10709](https://github.com/filecoin-project/lotus/pull/10709))
+- fix: deflake: use 2 miners for flaky tests ([filecoin-project/lotus#10764](https://github.com/filecoin-project/lotus/pull/10764))
+- test: eth: deflake multiblock lookup test (#10769) ([filecoin-project/lotus#10769](https://github.com/filecoin-project/lotus/pull/10769))
+- shed: migrations: add reminder about continuity testing tool ([filecoin-project/lotus#10762](https://github.com/filecoin-project/lotus/pull/10762))
+- chore: merge releases into master ([filecoin-project/lotus#10742](https://github.com/filecoin-project/lotus/pull/10742))
+- test: events: fix race when recording tipsets (#10665) ([filecoin-project/lotus#10665](https://github.com/filecoin-project/lotus/pull/10665))
+- fix: build: add CBDeliveryDelay to testground ([filecoin-project/lotus#10613](https://github.com/filecoin-project/lotus/pull/10613))
+- fix: build: Fixed incorrect words that could not be compiled ([filecoin-project/lotus#10610](https://github.com/filecoin-project/lotus/pull/10610))
+- 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))
+- docs: api: clarify MpoolClear params ([filecoin-project/lotus#10550](https://github.com/filecoin-project/lotus/pull/10550))
+
+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
 

Dockerfile.lotus

@@ -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
+

api/api_full.go

@@ -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

api/api_gateway.go

@@ -98,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)

api/eth_aliases.go

@@ -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")

api/mocks/mock_full.go

@@ -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()

api/proxy_gen.go

@@ -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:"write"`
-
-	EthUnsubscribe func(p0 context.Context, p1 ethtypes.EthSubscriptionID) (bool, error) `perm:"read"`
 
 	FilecoinAddressToEthAddress func(p0 context.Context, p1 address.Address) (ethtypes.EthAddress, error) `perm:"read"`
 
@@ -724,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) ``
@@ -2426,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
@@ -4615,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

api/types.go

@@ -314,30 +314,31 @@ type NetworkParams struct {
 }
 
 type ForkUpgradeParams struct {
-	UpgradeSmokeHeight       abi.ChainEpoch
+	UpgradeSmokeHeight         abi.ChainEpoch
-	UpgradeBreezeHeight      abi.ChainEpoch
+	UpgradeBreezeHeight        abi.ChainEpoch
-	UpgradeIgnitionHeight    abi.ChainEpoch
+	UpgradeIgnitionHeight      abi.ChainEpoch
-	UpgradeLiftoffHeight     abi.ChainEpoch
+	UpgradeLiftoffHeight       abi.ChainEpoch
-	UpgradeAssemblyHeight    abi.ChainEpoch
+	UpgradeAssemblyHeight      abi.ChainEpoch
-	UpgradeRefuelHeight      abi.ChainEpoch
+	UpgradeRefuelHeight        abi.ChainEpoch
-	UpgradeTapeHeight        abi.ChainEpoch
+	UpgradeTapeHeight          abi.ChainEpoch
-	UpgradeKumquatHeight     abi.ChainEpoch
+	UpgradeKumquatHeight       abi.ChainEpoch
-	BreezeGasTampingDuration abi.ChainEpoch
+	UpgradePriceListOopsHeight abi.ChainEpoch
-	UpgradeCalicoHeight      abi.ChainEpoch
+	BreezeGasTampingDuration   abi.ChainEpoch
-	UpgradePersianHeight     abi.ChainEpoch
+	UpgradeCalicoHeight        abi.ChainEpoch
-	UpgradeOrangeHeight      abi.ChainEpoch
+	UpgradePersianHeight       abi.ChainEpoch
-	UpgradeClausHeight       abi.ChainEpoch
+	UpgradeOrangeHeight        abi.ChainEpoch
-	UpgradeTrustHeight       abi.ChainEpoch
+	UpgradeClausHeight         abi.ChainEpoch
-	UpgradeNorwegianHeight   abi.ChainEpoch
+	UpgradeTrustHeight         abi.ChainEpoch
-	UpgradeTurboHeight       abi.ChainEpoch
+	UpgradeNorwegianHeight     abi.ChainEpoch
-	UpgradeHyperdriveHeight  abi.ChainEpoch
+	UpgradeTurboHeight         abi.ChainEpoch
-	UpgradeChocolateHeight   abi.ChainEpoch
+	UpgradeHyperdriveHeight    abi.ChainEpoch
-	UpgradeOhSnapHeight      abi.ChainEpoch
+	UpgradeChocolateHeight     abi.ChainEpoch
-	UpgradeSkyrHeight        abi.ChainEpoch
+	UpgradeOhSnapHeight        abi.ChainEpoch
-	UpgradeSharkHeight       abi.ChainEpoch
+	UpgradeSkyrHeight          abi.ChainEpoch
-	UpgradeHyggeHeight       abi.ChainEpoch
+	UpgradeSharkHeight         abi.ChainEpoch
-	UpgradeLightningHeight   abi.ChainEpoch
+	UpgradeHyggeHeight         abi.ChainEpoch
-	UpgradeThunderHeight     abi.ChainEpoch
+	UpgradeLightningHeight     abi.ChainEpoch
+	UpgradeThunderHeight       abi.ChainEpoch
 }
 
 type NonceMapType map[address.Address]uint64

blockstore/splitstore/splitstore.go

@@ -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)

blockstore/splitstore/splitstore_check.go

@@ -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

blockstore/splitstore/splitstore_compact.go

@@ -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 {
+	if err := s.checkYield(); err != nil {
-		return 0, xerrors.Errorf("check closing: %w", err)
+		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 {
+	if err := s.checkYield(); err != nil {
-		return sz, xerrors.Errorf("check closing: %w", err)
+		return sz, err
 	}
 
 	var links []cid.Cid

blockstore/splitstore/splitstore_test.go

@@ -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() {

blockstore/splitstore/splitstore_warmup.go

@@ -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.mx.Lock()
-	s.warmupEpoch.Store(int64(epoch))
+	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))

build/version.go

@@ -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" {

chain/events/observer.go

@@ -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
 		}
 	}
 

chain/index/msgindex_test.go

@@ -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)
-
+	time.Sleep(CoalesceMinDelay + 10*time.Millisecond)
-	waitForCoalescerAfterLastEvent()
 
 	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)
-}

chain/messagepool/check.go

@@ -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()
+		log.Warnf("errored while getting pending mset: %w", err)
-		return nil, xerrors.Errorf("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()
+				log.Warnf("errored while getting pending mset: %w", err)
-				return nil, xerrors.Errorf("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()
+				log.Warnf("errored while getting pending mset: %w", err)
-				return nil, xerrors.Errorf("errored while getting pending mset: %w", err)
+				return nil, err
 			}
 			if ok && !interned {
 				st = &actorState{nextNonce: mset.nextNonce, requiredFunds: mset.requiredFunds}

chain/messagepool/messagepool.go

@@ -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 {
+func (mp *MessagePool) TryForEachPendingMessage(f func(cid.Cid) error) error {
-	mp.lk.Lock()
+	// 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

chain/stmgr/execute.go

@@ -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()
-		sm.execTraceCacheLock.Lock()
+	if entry, ok := sm.execTraceCache.Get(tsKey); ok {
-		if entry, ok := sm.execTraceCache.Get(tsKey); ok {
+		// we have to make a deep copy since caller can modify the invocTrace
-			// 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
-			// and we don't want that to change what we store in cache
+		invocTraceCopy := makeDeepCopy(entry.invocTrace)
-			invocTraceCopy := makeDeepCopy(entry.invocTrace)
-			sm.execTraceCacheLock.Unlock()
-			return entry.postStateRoot, invocTraceCopy, nil
-		}
 		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.execTraceCacheLock.Lock()
-		sm.execTraceCache.Add(tsKey, tipSetCacheEntry{st, invocTraceCopy})
+	sm.execTraceCache.Add(tsKey, tipSetCacheEntry{st, invocTraceCopy})
-		sm.execTraceCacheLock.Unlock()
+	sm.execTraceCacheLock.Unlock()
-	}
 
 	return st, invocTrace, nil
 }

chain/stmgr/stmgr.go

@@ -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)
+	execTraceCache, err := lru.NewARC[types.TipSetKey, tipSetCacheEntry](execTraceCacheSize)
-	var execTraceCache *lru.ARCCache[types.TipSetKey, tipSetCacheEntry]
+	if err != nil {
-	var err error
+		return nil, err
-	if execTraceCacheSize > 0 {
-		execTraceCache, err = lru.NewARC[types.TipSetKey, tipSetCacheEntry](execTraceCacheSize)
-		if err != nil {
-			return nil, err
-		}
 	}
 
 	return &StateManager{

chain/store/store.go

@@ -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

chain/sub/incoming.go

@@ -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"

chain/sub/incoming_test.go

@@ -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"

chain/types/ethtypes/eth_types.go

@@ -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"`

cli/info.go

@@ -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 {

cli/state.go

@@ -1528,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
 }

cmd/lotus-fountain/main.go

@@ -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:   10240,
-		},
 		&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")
+	to, err := address.NewFromString(r.FormValue("address"))
-
+	if err != nil {
-	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 {
 		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
+	smsg, err := h.api.MpoolPushMessage(h.ctx, &types.Message{
-	if r.RequestURI == "/send" {
+		Value: types.BigInt(h.sendPerRequest),
-		smsg, err = h.api.MpoolPushMessage(
+		From:  h.from,
-			h.ctx, &types.Message{
+		To:    to,
-				Value: types.BigInt(h.sendPerRequest),
+	}, nil)
-				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
-	}
-
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return

cmd/lotus-fountain/site/datacap.html

@@ -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("funds-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>

cmd/lotus-fountain/site/funds.html

@@ -15,13 +15,12 @@
 <div class="Index">
     <div class="Index-nodes">
         <div class="Index-node">
-            <h3>Send funds</h3>
+            [SENDING FUNDS]
-            <p>Please input your address to receive test FIL (tFIL) on the Calibration Testnet. This faucet dispenses 100 tFIL.</p>
         </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' 

cmd/lotus-fountain/site/index.html

@@ -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>
+            <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>
         </div>
     </div>
     <div class="Index-footer">

cmd/lotus-fountain/site/main.css

@@ -1,6 +1,7 @@
 body {
-    font-family: 'Helvetica Neue', sans-serif;
+    font-family: 'monospace';
-    background-color: #f0f0f0;
+    background: #1f1f1f;
+    color: #f0f0f0;
     padding: 0;
     margin: 0;
 }
@@ -8,22 +9,21 @@ body {
 .Index {
     width: 100vw;
     height: 100vh;
-    background-color: #f0f0f0;
+    background: #1a1a1a;
-    color: #333;
+    color: #f0f0f0;
-    font-family: 'Helvetica Neue', sans-serif;
+    font-family: monospace;
 
     display: grid;
     grid-template-columns: auto 40vw auto;
     grid-template-rows: auto auto auto 3em;
     grid-template-areas:
-    ". . . ."
+            ". . . ."
-    ". main main ."
+            ". main main ."
-    ". . . ."
+            ". . . ."
-    "footer footer footer footer";
+            "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;
+    background: #1f1f1f;
-    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;
 }
 
 a:link {
-    color: #333;
+    color: #50f020;
 }
 
 a:visited {
-    color: #333;
+    color: #50f020;
 }
 
 a:hover {
-    color: #555;
+    color: #30a00a;
 }

cmd/lotus-miner/actor.go

@@ -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",

cmd/lotus-miner/sectors.go

@@ -1922,31 +1922,10 @@ var sectorsBatchingPendingCommit = &cli.Command{
 			for _, sector := range pending {
 				fmt.Println(sector.Number)
 			}
-
+			return nil
-			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")
 		}
+
+		fmt.Println("No sectors queued to be committed")
 		return nil
 	},
 }
@@ -2001,31 +1980,10 @@ var sectorsBatchingPendingPreCommit = &cli.Command{
 			for _, sector := range pending {
 				fmt.Println(sector.Number)
 			}
-
+			return nil
-			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")
 		}
+
+		fmt.Println("No sectors queued to be committed")
 		return nil
 	},
 }

cmd/lotus-miner/storage.go

@@ -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() != 1 {
-		if cctx.NArg() == 0 && !cctx.IsSet("id") && !cctx.Bool("all") {
+			return lcli.IncorrectNumArgs(cctx)
-			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 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.
+		return xerrors.Errorf("either --all or --id must be specified")
-		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"))
 	},
 }
 

cmd/lotus-shed/actor.go

@@ -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",

cmd/lotus-shed/verifreg.go

@@ -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 {

cmd/lotus-worker/main.go

@@ -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)
+			taskTypes = append(taskTypes, sealtasks.TTAddPiece, sealtasks.TTDataCid)
-			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)
-			}
 		}
 		if (workerType == sealtasks.WorkerSealing || cctx.IsSet("sector-download")) && cctx.Bool("sector-download") {
 			taskTypes = append(taskTypes, sealtasks.TTDownloadSector)

cmd/lotus-worker/storage.go

@@ -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.
+		return xerrors.Errorf("either --all or --id must be specified")
-		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"))
 	},
 }

documentation/en/api-v0-methods.md

@@ -5430,6 +5430,7 @@ Response:
     "UpgradeRefuelHeight": 10101,
     "UpgradeTapeHeight": 10101,
     "UpgradeKumquatHeight": 10101,
+    "UpgradePriceListOopsHeight": 10101,
     "BreezeGasTampingDuration": 10101,
     "UpgradeCalicoHeight": 10101,
     "UpgradePersianHeight": 10101,

documentation/en/api-v1-unstable-methods.md

@@ -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
@@ -6942,6 +6932,7 @@ Response:
     "UpgradeRefuelHeight": 10101,
     "UpgradeTapeHeight": 10101,
     "UpgradeKumquatHeight": 10101,
+    "UpgradePriceListOopsHeight": 10101,
     "BreezeGasTampingDuration": 10101,
     "UpgradeCalicoHeight": 10101,
     "UpgradePersianHeight": 10101,

documentation/en/cli-lotus-miner.md

@@ -7,7 +7,7 @@ USAGE:
    lotus-miner [global options] command [command options] [arguments...]
 
 VERSION:
-   1.23.2-dev
+   1.23.1
 
 COMMANDS:
    init     Initialize a lotus miner repo
@@ -400,7 +400,7 @@ NAME:
    lotus-miner actor confirm-change-beneficiary - Confirm a beneficiary address change
 
 USAGE:
-   lotus-miner actor confirm-change-beneficiary [command options] [minerID]
+   lotus-miner actor confirm-change-beneficiary [command options] [minerAddress]
 
 OPTIONS:
    --existing-beneficiary  send confirmation from the existing beneficiary address (default: false)
@@ -1285,7 +1285,7 @@ USAGE:
 
 OPTIONS:
    --all           redeclare all storage paths (default: false)
-   --drop-missing  Drop index entries with missing files (default: true)
+   --drop-missing  Drop index entries with missing files (default: false)
    --id value      storage path ID
    
 ```

documentation/en/cli-lotus-worker.md

@@ -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
@@ -38,7 +38,6 @@ USAGE:
 OPTIONS:
    --addpiece                    enable addpiece (default: true) [$LOTUS_WORKER_ADDPIECE]
    --commit                      enable commit (default: true) [$LOTUS_WORKER_COMMIT]
-   --data-cid                    Run the data-cid task. true|false (default: inherits --addpiece)
    --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]
@@ -148,7 +147,7 @@ USAGE:
 
 OPTIONS:
    --all           redeclare all storage paths (default: false)
-   --drop-missing  Drop index entries with missing files (default: true)
+   --drop-missing  Drop index entries with missing files (default: false)
    --id value      storage path ID
    
 ```

documentation/en/cli-lotus.md

@@ -7,7 +7,7 @@ USAGE:
    lotus [global options] command [command options] [arguments...]
 
 VERSION:
-   1.23.2-dev
+   1.23.1
 
 COMMANDS:
    daemon   Start a lotus daemon process

documentation/en/default-lotus-config.toml

@@ -391,6 +391,7 @@
 
 
 [Index]
+  # EXPERIMENTAL FEATURE. USE WITH CAUTION
   # EnableMsgIndex enables indexing of messages on chain.
   #
   # type: bool

gateway/node.go

@@ -115,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)

gateway/proxy_eth.go

@@ -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

go.mod

@@ -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.1
+	github.com/filecoin-project/go-fil-markets v1.27.0-rc1
-	github.com/filecoin-project/go-jsonrpc v0.3.1
+	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.11.0
-	github.com/ipni/index-provider v0.12.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.3
+	github.com/libp2p/go-libp2p v0.27.5
 	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
@@ -286,7 +286,7 @@ require (
 	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

go.sum

@@ -312,8 +312,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-rc4 h1:Y5RMvFT4OthsAhDx7xKfkJ5QdiWq9Ox7N46Mi0PF0PE=
-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/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 +321,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.1 h1:2iq1o/ZY1RSbVU8OX7nwWO66SYtdjKEngshc4Jeua/Y=
+github.com/filecoin-project/go-fil-markets v1.27.0-rc1 h1:SYXKFONg6IaQlmXEqAEaPtb/xX57dZYMkx3LwjsLr7w=
-github.com/filecoin-project/go-fil-markets v1.28.1/go.mod h1:qy9LNu9t77I184VB6Pa4WKRtGfB8Vl0t8zfOLHkDqWY=
+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 +330,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.2.3 h1:xdixRQfLbD8gt56dpBNKiya9gvI/79nNM13IHKTfm5E=
-github.com/filecoin-project/go-jsonrpc v0.3.1/go.mod h1:jBSvPTl8V1N7gSTuCR4bis8wnQnIjHbRPpROol6iQKM=
+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=
@@ -738,8 +738,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.3 h1:IXH9S7AraMQ0J6Fzcl8rqSPqLn+es33bD8OW2KNyU/o=
-github.com/ipfs/go-graphsync v0.14.6/go.mod h1:yT0AfjFgicOoWdAlUJ96tQ5AkuGI4r1taIQX/aHbBQo=
+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 +885,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/index-provider v0.11.0 h1:q2PdK6JpYB9bzlntfkRYNBjhg4Qtko5+iXRonO88TAg=
-github.com/ipni/go-libipni v0.0.8/go.mod h1:paYP9U4N3/vOzGCuN9kU972vtvw9JUcQjOKyiCFGwRk=
+github.com/ipni/index-provider v0.11.0/go.mod h1:gB/wN4Mdz4MzikQubjyRRV97iS5BkD4FKB0U/bF/dY4=
-github.com/ipni/index-provider v0.12.0 h1:R3F6dxxKNv4XkE4GJZNLOG0bDEbBQ/S5iztXwSD8jhQ=
+github.com/ipni/storetheindex v0.5.10 h1:r97jIZsXPuwQvePJQuStu2a/kn+Zn8X4MAdA0rU2Pu4=
-github.com/ipni/index-provider v0.12.0/go.mod h1:GhyrADJp7n06fqoc1djzkvL4buZYHzV8SoWrlxEo5F4=
+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=
@@ -1005,8 +1005,8 @@ github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xS
 github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw=
 github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qDKwXujH5o=
 github.com/libp2p/go-libp2p v0.14.3/go.mod h1:d12V4PdKbpL0T1/gsUNN8DfgMuRPDX8bS2QxCZlwRH0=
-github.com/libp2p/go-libp2p v0.27.3 h1:tkV/zm3KCZ4R5er9Xcs2pt0YNB4JH0iBfGAtHJdLHRs=
+github.com/libp2p/go-libp2p v0.27.5 h1:KwA7pXKXpz8hG6Cr1fMA7UkgleogcwQj0sxl5qquWRg=
-github.com/libp2p/go-libp2p v0.27.3/go.mod h1:FAvvfQa/YOShUYdiSS03IR9OXzkcJXwcNA2FUCh9ImE=
+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-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8=
@@ -1325,8 +1325,8 @@ github.com/multiformats/go-multibase v0.2.0/go.mod h1:bFBZX4lKCA/2lyOFSAoKH5SS6o
 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.8.1 h1:ycepHwavHafh3grIbR1jIXnKCsFm0fqsfEOsJ8NtKE8=
-github.com/multiformats/go-multicodec v0.9.0/go.mod h1:L3QTQvMIaVBkXOXXtVmYE+LI16i14xuaojr/H7Ai54k=
+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=

itests/eth_balance_test.go

@@ -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)
+	bal, err := client.EVM().EthGetBalance(ctx, ethAddr, strconv.FormatInt(int64(ml.Height-2), 10))
-	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))
 	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())
 }

itests/eth_deploy_test.go

@@ -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())
-
+	ens.InterconnectAll().BeginMining(blockTime)
-	miners := 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.
+	var receipt *api.EthTxReceipt
-	for _, miner := range miners {
+	for i := 0; i < 20; i++ {
-		miner.Restart()
+		// 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
+	// should be able to get the block using latest as well
-	block3, err := client.EthGetBlockByHash(ctx, *chainTx.BlockHash, true)
+	block3, err := client.EthGetBlockByNumber(ctx, "latest", false)
 	require.Nil(t, err)
-	require.Equal(t, block3.Hash, *chainTx.BlockHash)
+	require.True(t, reflect.DeepEqual(block2, block3))
-	require.Equal(t, block3.Number, *chainTx.BlockNumber)
+
+	// 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
+	// make sure the block got from EthGetBlockByNumber is the same
-	block4, err := client.EthGetBlockByNumber(ctx, blkNum, true)
+	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)

itests/eth_fee_history_test.go

@@ -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,

itests/eth_filter_test.go

@@ -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) {

itests/kit/blockminer.go

@@ -236,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)
 			}
 
@@ -348,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)
 			}
 

itests/kit/client.go

@@ -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")

itests/paych_api_test.go

@@ -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)
+	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, policy.PaychSettleDelay)
-	require.NoError(t, err)
-
-	settleHeight := head.Height() + policy.PaychSettleDelay + 5
-	paymentReceiver.WaitTillChain(ctx, kit.HeightAtLeast(settleHeight))
-	paymentCreator.WaitTillChain(ctx, kit.HeightAtLeast(settleHeight))
 
 	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()

itests/sector_import_simple_test.go

@@ -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.EnsembleMinimal(t, kit.ThroughRPC())
-	client, miner, _, ens := kit.EnsembleOneTwo(t, kit.ThroughRPC())
-
 	ens.InterconnectAll().BeginMining(blockTime)
 
 	ctx := context.Background()

node/builder.go

@@ -89,7 +89,6 @@ const (
 
 	// health checks
 	CheckFDLimit
-	LegacyMarketsEOL
 
 	// libp2p
 	PstoreAddSelfKeysKey

node/builder_miner.go

@@ -147,10 +147,6 @@ func ConfigStorageMiner(c interface{}) Option {
 		),
 
 		If(cfg.Subsystems.EnableMarkets,
-
-			// Alert that legacy-markets is being deprecated
-			Override(LegacyMarketsEOL, modules.LegacyMarketsEOL),
-
 			// Markets
 			Override(new(dtypes.StagingBlockstore), modules.StagingBlockstore),
 			Override(new(dtypes.StagingGraphsync), modules.StagingGraphsync(cfg.Dealmaking.SimultaneousTransfersForStorage, cfg.Dealmaking.SimultaneousTransfersForStoragePerClient, cfg.Dealmaking.SimultaneousTransfersForRetrieval)),

node/config/doc_gen.go

@@ -473,7 +473,8 @@ Set to 0 to keep all mappings`,
 			Name: "EnableMsgIndex",
 			Type: "bool",
 
-			Comment: `EnableMsgIndex enables indexing of messages on chain.`,
+			Comment: `EXPERIMENTAL FEATURE. USE WITH CAUTION
+EnableMsgIndex enables indexing of messages on chain.`,
 		},
 	},
 	"IndexProviderConfig": []DocField{

node/config/types.go

@@ -736,6 +736,7 @@ type Events struct {
 }
 
 type IndexConfig struct {
+	// EXPERIMENTAL FEATURE. USE WITH CAUTION
 	// EnableMsgIndex enables indexing of messages on chain.
 	EnableMsgIndex bool
 }

node/impl/full/dummy.go

@@ -102,10 +102,6 @@ func (e *EthModuleDummy) EthChainId(ctx context.Context) (ethtypes.EthUint64, er
 	return 0, ErrModuleDisabled
 }
 
-func (e *EthModuleDummy) EthSyncing(ctx context.Context) (ethtypes.EthSyncingResult, error) {
-	return ethtypes.EthSyncingResult{}, ErrModuleDisabled
-}
-
 func (e *EthModuleDummy) NetVersion(ctx context.Context) (string, error) {
 	return "", ErrModuleDisabled
 }

node/impl/full/eth.go

@@ -9,7 +9,6 @@ import (
 	"os"
 	"sort"
 	"strconv"
-	"strings"
 	"sync"
 	"time"
 
@@ -67,7 +66,6 @@ type EthModuleAPI interface {
 	EthGetBalance(ctx context.Context, address ethtypes.EthAddress, blkParam string) (ethtypes.EthBigInt, error)
 	EthFeeHistory(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthFeeHistory, 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)
@@ -134,7 +132,6 @@ type EthModule struct {
 	ChainAPI
 	MpoolAPI
 	StateAPI
-	SyncAPI
 }
 
 var _ EthModuleAPI = (*EthModule)(nil)
@@ -390,7 +387,7 @@ func (a *EthModule) EthGetTransactionCount(ctx context.Context, sender ethtypes.
 
 	ts, err := a.parseBlkParam(ctx, blkParam, false)
 	if err != nil {
-		return ethtypes.EthUint64(0), xerrors.Errorf("failed to process block param: %s; %w", blkParam, err)
+		return ethtypes.EthUint64(0), xerrors.Errorf("cannot parse block param: %s", blkParam)
 	}
 
 	// First, handle the case where the "sender" is an EVM actor.
@@ -478,7 +475,7 @@ func (a *EthModule) EthGetCode(ctx context.Context, ethAddr ethtypes.EthAddress,
 
 	ts, err := a.parseBlkParam(ctx, blkParam, false)
 	if err != nil {
-		return nil, xerrors.Errorf("failed to process block param: %s; %w", blkParam, err)
+		return nil, xerrors.Errorf("cannot parse block param: %s", blkParam)
 	}
 
 	// StateManager.Call will panic if there is no parent
@@ -557,7 +554,7 @@ func (a *EthModule) EthGetCode(ctx context.Context, ethAddr ethtypes.EthAddress,
 func (a *EthModule) EthGetStorageAt(ctx context.Context, ethAddr ethtypes.EthAddress, position ethtypes.EthBytes, blkParam string) (ethtypes.EthBytes, error) {
 	ts, err := a.parseBlkParam(ctx, blkParam, false)
 	if err != nil {
-		return nil, xerrors.Errorf("failed to process block param: %s; %w", blkParam, err)
+		return nil, xerrors.Errorf("cannot parse block param: %s", blkParam)
 	}
 
 	l := len(position)
@@ -653,7 +650,7 @@ func (a *EthModule) EthGetBalance(ctx context.Context, address ethtypes.EthAddre
 
 	ts, err := a.parseBlkParam(ctx, blkParam, false)
 	if err != nil {
-		return ethtypes.EthBigInt{}, xerrors.Errorf("failed to process block param: %s; %w", blkParam, err)
+		return ethtypes.EthBigInt{}, xerrors.Errorf("cannot parse block param: %s", blkParam)
 	}
 
 	st, _, err := a.StateManager.TipSetState(ctx, ts)
@@ -675,42 +672,6 @@ func (a *EthModule) EthChainId(ctx context.Context) (ethtypes.EthUint64, error)
 	return ethtypes.EthUint64(build.Eip155ChainId), nil
 }
 
-func (a *EthModule) EthSyncing(ctx context.Context) (ethtypes.EthSyncingResult, error) {
-	state, err := a.SyncAPI.SyncState(ctx)
-	if err != nil {
-		return ethtypes.EthSyncingResult{}, fmt.Errorf("failed calling SyncState: %w", err)
-	}
-
-	if len(state.ActiveSyncs) == 0 {
-		return ethtypes.EthSyncingResult{}, errors.New("no active syncs, try again")
-	}
-
-	working := -1
-	for i, ss := range state.ActiveSyncs {
-		if ss.Stage == api.StageIdle {
-			continue
-		}
-		working = i
-	}
-	if working == -1 {
-		working = len(state.ActiveSyncs) - 1
-	}
-
-	ss := state.ActiveSyncs[working]
-	if ss.Base == nil || ss.Target == nil {
-		return ethtypes.EthSyncingResult{}, errors.New("missing syncing information, try again")
-	}
-
-	res := ethtypes.EthSyncingResult{
-		DoneSync:      ss.Stage == api.StageSyncComplete,
-		CurrentBlock:  ethtypes.EthUint64(ss.Height),
-		StartingBlock: ethtypes.EthUint64(ss.Base.Height()),
-		HighestBlock:  ethtypes.EthUint64(ss.Target.Height()),
-	}
-
-	return res, nil
-}
-
 func (a *EthModule) EthFeeHistory(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthFeeHistory, error) {
 	params, err := jsonrpc.DecodeParams[ethtypes.EthFeeHistoryParams](p)
 	if err != nil {
@@ -1120,7 +1081,7 @@ func (a *EthModule) EthCall(ctx context.Context, tx ethtypes.EthCall, blkParam s
 
 	ts, err := a.parseBlkParam(ctx, blkParam, false)
 	if err != nil {
-		return nil, xerrors.Errorf("failed to process block param: %s; %w", blkParam, err)
+		return nil, xerrors.Errorf("cannot parse block param: %s", blkParam)
 	}
 
 	invokeResult, err := a.applyMessage(ctx, msg, ts.Key())
@@ -1209,7 +1170,7 @@ func (e *EthEvent) installEthFilterSpec(ctx context.Context, filterSpec *ethtype
 			return nil, xerrors.Errorf("must not specify block hash and from/to block")
 		}
 
-		tipsetCid = filterSpec.BlockHash.ToCid()
+		// TODO: derive a tipset hash from eth hash - might need to push this down into the EventFilterManager
 	} else {
 		if filterSpec.FromBlock == nil || *filterSpec.FromBlock == "latest" {
 			ts := e.Chain.GetHeaviestTipSet()
@@ -1219,9 +1180,6 @@ func (e *EthEvent) installEthFilterSpec(ctx context.Context, filterSpec *ethtype
 		} else if *filterSpec.FromBlock == "pending" {
 			return nil, api.ErrNotSupported
 		} else {
-			if !strings.HasPrefix(*filterSpec.FromBlock, "0x") {
-				return nil, xerrors.Errorf("FromBlock is not a hex")
-			}
 			epoch, err := ethtypes.EthUint64FromHex(*filterSpec.FromBlock)
 			if err != nil {
 				return nil, xerrors.Errorf("invalid epoch")
@@ -1237,9 +1195,6 @@ func (e *EthEvent) installEthFilterSpec(ctx context.Context, filterSpec *ethtype
 		} else if *filterSpec.ToBlock == "pending" {
 			return nil, api.ErrNotSupported
 		} else {
-			if !strings.HasPrefix(*filterSpec.ToBlock, "0x") {
-				return nil, xerrors.Errorf("ToBlock is not a hex")
-			}
 			epoch, err := ethtypes.EthUint64FromHex(*filterSpec.ToBlock)
 			if err != nil {
 				return nil, xerrors.Errorf("invalid epoch")

node/modules/alerts.go

@@ -32,16 +32,6 @@ func CheckFdLimit(min uint64) func(al *alerting.Alerting) {
 	}
 }
 
-func LegacyMarketsEOL(al *alerting.Alerting) {
-	// Add alert if lotus-miner legacy markets subsystem is still in use
-	alert := al.AddAlertType("system", "EOL")
-
-	// Alert with a message to migrate to Boost or similar markets subsystems
-	al.Raise(alert, map[string]string{
-		"message": "The lotus-miner legacy markets subsystem is deprecated and will be removed in a future release. Please migrate to [Boost](https://boost.filecoin.io) or similar markets subsystems.",
-	})
-}
-
 // TODO: More things:
 //  * Space in repo dirs (taking into account mounts)
 //  * Miner

node/modules/chain.go

@@ -70,7 +70,7 @@ func MessagePool(lc fx.Lifecycle, mctx helpers.MetricsCtx, us stmgr.UpgradeSched
 			return mp.Close()
 		},
 	})
-	protector.AddProtector(mp.ForEachPendingMessage)
+	protector.AddProtector(mp.TryForEachPendingMessage)
 	return mp, nil
 }
 

node/modules/ethmodule.go

@@ -18,8 +18,8 @@ import (
 	"github.com/filecoin-project/lotus/node/repo"
 )
 
-func EthModuleAPI(cfg config.FevmConfig) func(helpers.MetricsCtx, repo.LockedRepo, fx.Lifecycle, *store.ChainStore, *stmgr.StateManager, EventAPI, *messagepool.MessagePool, full.StateAPI, full.ChainAPI, full.MpoolAPI, full.SyncAPI) (*full.EthModule, error) {
+func EthModuleAPI(cfg config.FevmConfig) func(helpers.MetricsCtx, repo.LockedRepo, fx.Lifecycle, *store.ChainStore, *stmgr.StateManager, EventAPI, *messagepool.MessagePool, full.StateAPI, full.ChainAPI, full.MpoolAPI) (*full.EthModule, error) {
-	return func(mctx helpers.MetricsCtx, r repo.LockedRepo, lc fx.Lifecycle, cs *store.ChainStore, sm *stmgr.StateManager, evapi EventAPI, mp *messagepool.MessagePool, stateapi full.StateAPI, chainapi full.ChainAPI, mpoolapi full.MpoolAPI, syncapi full.SyncAPI) (*full.EthModule, error) {
+	return func(mctx helpers.MetricsCtx, r repo.LockedRepo, lc fx.Lifecycle, cs *store.ChainStore, sm *stmgr.StateManager, evapi EventAPI, mp *messagepool.MessagePool, stateapi full.StateAPI, chainapi full.ChainAPI, mpoolapi full.MpoolAPI) (*full.EthModule, error) {
 		sqlitePath, err := r.SqlitePath()
 		if err != nil {
 			return nil, err
@@ -84,7 +84,6 @@ func EthModuleAPI(cfg config.FevmConfig) func(helpers.MetricsCtx, repo.LockedRep
 			ChainAPI: chainapi,
 			MpoolAPI: mpoolapi,
 			StateAPI: stateapi,
-			SyncAPI:  syncapi,
 
 			EthTxHashManager: &ethTxHashManager,
 		}, nil

node/modules/lp2p/pubsub.go

@@ -394,20 +394,6 @@ func GossipSub(in GossipIn) (service *pubsub.PubSub, err error) {
 
 		transports = append(transports, jsonTransport)
 	}
-
-	tps := make([]string, 0) // range of topics that will be submited to the traces
-	addTopicToList := func(topicList []string, newTopic string) []string {
-		// check if the topic is already in the list
-		for _, tp := range topicList {
-			if tp == newTopic {
-				return topicList
-			}
-		}
-		// add it otherwise
-		return append(topicList, newTopic)
-	}
-
-	// tracer
 	if in.Cfg.ElasticSearchTracer != "" {
 		elasticSearchTransport, err := tracer.NewElasticSearchTransport(
 			in.Cfg.ElasticSearchTracer,
@@ -417,9 +403,7 @@ func GossipSub(in GossipIn) (service *pubsub.PubSub, err error) {
 			return nil, err
 		}
 		transports = append(transports, elasticSearchTransport)
-		tps = addTopicToList(tps, build.BlocksTopic(in.Nn))
 	}
-
 	lt := tracer.NewLotusTracer(transports, in.Host.ID(), in.Cfg.TracerSourceAuth)
 
 	// tracer
@@ -428,25 +412,28 @@ func GossipSub(in GossipIn) (service *pubsub.PubSub, err error) {
 		if err != nil {
 			return nil, err
 		}
+
 		pi, err := peer.AddrInfoFromP2pAddr(a)
 		if err != nil {
 			return nil, err
 		}
+
 		tr, err := pubsub.NewRemoteTracer(context.TODO(), in.Host, *pi)
 		if err != nil {
 			return nil, err
 		}
+
 		pst := newPeerScoreTracker(lt, in.Sk)
-		trw := newTracerWrapper(tr, lt, tps...)
+		trw := newTracerWrapper(tr, lt, build.BlocksTopic(in.Nn))
 
 		options = append(options, pubsub.WithEventTracer(trw))
 		options = append(options, pubsub.WithPeerScoreInspect(pst.UpdatePeerScore, 10*time.Second))
 	} else {
 		// still instantiate a tracer for collecting metrics
-		pst := newPeerScoreTracker(lt, in.Sk)
+		trw := newTracerWrapper(nil, lt)
-		trw := newTracerWrapper(nil, lt, tps...)
-
 		options = append(options, pubsub.WithEventTracer(trw))
+
+		pst := newPeerScoreTracker(lt, in.Sk)
 		options = append(options, pubsub.WithPeerScoreInspect(pst.UpdatePeerScore, 10*time.Second))
 	}
 
@@ -470,6 +457,7 @@ func newTracerWrapper(
 			topicsMap[topic] = struct{}{}
 		}
 	}
+
 	return &tracerWrapper{lp2pTracer: lp2pTracer, lotusTracer: lotusTracer, topics: topicsMap}
 }
 
@@ -498,164 +486,71 @@ func (trw *tracerWrapper) Trace(evt *pubsub_pb.TraceEvent) {
 			if trw.lp2pTracer != nil {
 				trw.lp2pTracer.Trace(evt)
 			}
+
 			if trw.lotusTracer != nil {
 				trw.lotusTracer.Trace(evt)
 			}
 		}
-
 	case pubsub_pb.TraceEvent_DELIVER_MESSAGE:
 		stats.Record(context.TODO(), metrics.PubsubDeliverMessage.M(1))
+		if trw.traceMessage(evt.GetDeliverMessage().GetTopic()) {
+			if trw.lp2pTracer != nil {
+				trw.lp2pTracer.Trace(evt)
+			}
 
+			if trw.lotusTracer != nil {
+				trw.lotusTracer.Trace(evt)
+			}
+		}
 	case pubsub_pb.TraceEvent_REJECT_MESSAGE:
 		stats.Record(context.TODO(), metrics.PubsubRejectMessage.M(1))
 		if trw.traceMessage(evt.GetRejectMessage().GetTopic()) {
 			if trw.lp2pTracer != nil {
 				trw.lp2pTracer.Trace(evt)
 			}
+
 			if trw.lotusTracer != nil {
 				trw.lotusTracer.Trace(evt)
 			}
 		}
-
 	case pubsub_pb.TraceEvent_DUPLICATE_MESSAGE:
 		stats.Record(context.TODO(), metrics.PubsubDuplicateMessage.M(1))
-		if trw.traceMessage(evt.GetDuplicateMessage().GetTopic()) {
+	case pubsub_pb.TraceEvent_JOIN:
-			if trw.lp2pTracer != nil {
+		if trw.lp2pTracer != nil {
-				trw.lp2pTracer.Trace(evt)
+			trw.lp2pTracer.Trace(evt)
-			}
-			if trw.lotusTracer != nil {
-				trw.lotusTracer.Trace(evt)
-			}
 		}
 
-	case pubsub_pb.TraceEvent_JOIN:
+		if trw.lotusTracer != nil {
-		if trw.traceMessage(evt.GetJoin().GetTopic()) {
+			trw.lotusTracer.Trace(evt)
-			if trw.lp2pTracer != nil {
-				trw.lp2pTracer.Trace(evt)
-			}
-			if trw.lotusTracer != nil {
-				trw.lotusTracer.Trace(evt)
-			}
 		}
 	case pubsub_pb.TraceEvent_LEAVE:
-		if trw.traceMessage(evt.GetLeave().GetTopic()) {
+		if trw.lp2pTracer != nil {
-			if trw.lp2pTracer != nil {
+			trw.lp2pTracer.Trace(evt)
-				trw.lp2pTracer.Trace(evt)
-			}
-			if trw.lotusTracer != nil {
-				trw.lotusTracer.Trace(evt)
-			}
 		}
 
+		if trw.lotusTracer != nil {
+			trw.lotusTracer.Trace(evt)
+		}
 	case pubsub_pb.TraceEvent_GRAFT:
-		if trw.traceMessage(evt.GetGraft().GetTopic()) {
+		if trw.lp2pTracer != nil {
-			if trw.lp2pTracer != nil {
+			trw.lp2pTracer.Trace(evt)
-				trw.lp2pTracer.Trace(evt)
-			}
-
-			if trw.lotusTracer != nil {
-				trw.lotusTracer.Trace(evt)
-			}
 		}
 
+		if trw.lotusTracer != nil {
+			trw.lotusTracer.Trace(evt)
+		}
 	case pubsub_pb.TraceEvent_PRUNE:
-		if trw.traceMessage(evt.GetPrune().GetTopic()) {
-			if trw.lp2pTracer != nil {
-				trw.lp2pTracer.Trace(evt)
-			}
-			if trw.lotusTracer != nil {
-				trw.lotusTracer.Trace(evt)
-			}
-		}
-
-	case pubsub_pb.TraceEvent_ADD_PEER:
 		if trw.lp2pTracer != nil {
 			trw.lp2pTracer.Trace(evt)
 		}
+
 		if trw.lotusTracer != nil {
 			trw.lotusTracer.Trace(evt)
 		}
-
-	case pubsub_pb.TraceEvent_REMOVE_PEER:
-		if trw.lp2pTracer != nil {
-			trw.lp2pTracer.Trace(evt)
-		}
-		if trw.lotusTracer != nil {
-			trw.lotusTracer.Trace(evt)
-		}
-
 	case pubsub_pb.TraceEvent_RECV_RPC:
 		stats.Record(context.TODO(), metrics.PubsubRecvRPC.M(1))
-		// only track the RPC Calls from IWANT / IHAVE / BLOCK topic
-		controlRPC := evt.GetRecvRPC().GetMeta().GetControl()
-		ihave := controlRPC.GetIhave()
-		iwant := controlRPC.GetIwant()
-		msgsRPC := evt.GetRecvRPC().GetMeta().GetMessages()
-
-		// check if any of the messages we are sending belong to a trackable topic
-		var validTopic bool = false
-		for _, topic := range msgsRPC {
-			if trw.traceMessage(topic.GetTopic()) {
-				validTopic = true
-				break
-			}
-		}
-		// track if the Iwant / Ihave messages are from a valid Topic
-		var validIhave bool = false
-		for _, msgs := range ihave {
-			if trw.traceMessage(msgs.GetTopic()) {
-				validIhave = true
-				break
-			}
-		}
-		// check if we have any of iwant msgs (it doesn't classify per topic - just msg.ID)
-		validIwant := len(iwant) > 0
-
-		// trace the event if any of the flags was triggered
-		if validIhave || validIwant || validTopic {
-			if trw.lp2pTracer != nil {
-				trw.lp2pTracer.Trace(evt)
-			}
-			if trw.lotusTracer != nil {
-				trw.lotusTracer.Trace(evt)
-			}
-		}
 	case pubsub_pb.TraceEvent_SEND_RPC:
 		stats.Record(context.TODO(), metrics.PubsubSendRPC.M(1))
-		// only track the RPC Calls from IWANT / IHAVE / BLOCK topic
-		controlRPC := evt.GetSendRPC().GetMeta().GetControl()
-		ihave := controlRPC.GetIhave()
-		iwant := controlRPC.GetIwant()
-		msgsRPC := evt.GetSendRPC().GetMeta().GetMessages()
-
-		// check if any of the messages we are sending belong to a trackable topic
-		var validTopic bool = false
-		for _, topic := range msgsRPC {
-			if trw.traceMessage(topic.GetTopic()) {
-				validTopic = true
-				break
-			}
-		}
-		// track if the Iwant / Ihave messages are from a valid Topic
-		var validIhave bool = false
-		for _, msgs := range ihave {
-			if trw.traceMessage(msgs.GetTopic()) {
-				validIhave = true
-				break
-			}
-		}
-		// check if there was any of the Iwant msgs
-		validIwant := len(iwant) > 0
-
-		// trace the msgs if any of the flags was triggered
-		if validIhave || validIwant || validTopic {
-			if trw.lp2pTracer != nil {
-				trw.lp2pTracer.Trace(evt)
-			}
-			if trw.lotusTracer != nil {
-				trw.lotusTracer.Trace(evt)
-			}
-		}
 	case pubsub_pb.TraceEvent_DROP_RPC:
 		stats.Record(context.TODO(), metrics.PubsubDropRPC.M(1))
 	}

node/modules/storageminer_idxprov.go

@@ -64,7 +64,7 @@ func IndexProvider(cfg config.IndexProviderConfig) func(params IdxProv, marketHo
 		// If announcements to the network are enabled, then set options for datatransfer publisher.
 		if cfg.Enable {
 			// Join the indexer topic using the market's pubsub instance. Otherwise, the provider
-			// engine would create its own instance of pubsub down the line in dagsync, which has
+			// engine would create its own instance of pubsub down the line in go-legs, which has
 			// no validators by default.
 			t, err := ps.Join(topicName)
 			if err != nil {

node/modules/tracer/elasticsearch_transport.go

@@ -1,23 +1,18 @@
 package tracer
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
-	"net/http"
 	"net/url"
-	"time"
+	"strings"
 
 	"github.com/elastic/go-elasticsearch/v7"
-	"github.com/elastic/go-elasticsearch/v7/esutil"
+	"github.com/elastic/go-elasticsearch/v7/esapi"
 )
 
 const (
 	ElasticSearchDefaultIndex = "lotus-pubsub"
-	flushInterval             = 10 * time.Second
-	flushBytes                = 1024 * 1024 // MB
-	esWorkers                 = 2           // TODO: hardcoded
 )
 
 func NewElasticSearchTransport(connectionString string, elasticsearchIndex string) (TracerTransport, error) {
@@ -33,12 +28,12 @@ func NewElasticSearchTransport(connectionString string, elasticsearchIndex strin
 		Addresses: []string{
 			conUrl.Scheme + "://" + conUrl.Host,
 		},
-		Username:  username,
+		Username: username,
-		Password:  password,
+		Password: password,
-		Transport: &http.Transport{},
 	}
 
 	es, err := elasticsearch.NewClient(cfg)
+
 	if err != nil {
 		return nil, err
 	}
@@ -50,31 +45,14 @@ func NewElasticSearchTransport(connectionString string, elasticsearchIndex strin
 		esIndex = ElasticSearchDefaultIndex
 	}
 
-	// Create the BulkIndexer to batch ES trace submission
-	bi, err := esutil.NewBulkIndexer(esutil.BulkIndexerConfig{
-		Index:         esIndex,
-		Client:        es,
-		NumWorkers:    esWorkers,
-		FlushBytes:    int(flushBytes),
-		FlushInterval: flushInterval,
-		OnError: func(ctx context.Context, err error) {
-			log.Errorf("Error persisting queries %s", err.Error())
-		},
-	})
-	if err != nil {
-		return nil, err
-	}
-
 	return &elasticSearchTransport{
 		cl:      es,
-		bi:      bi,
 		esIndex: esIndex,
 	}, nil
 }
 
 type elasticSearchTransport struct {
 	cl      *elasticsearch.Client
-	bi      esutil.BulkIndexer
 	esIndex string
 }
 
@@ -94,18 +72,26 @@ func (est *elasticSearchTransport) Transport(evt TracerTransportEvent) error {
 		return fmt.Errorf("error while marshaling event: %s", err)
 	}
 
-	return est.bi.Add(
+	req := esapi.IndexRequest{
-		context.Background(),
+		Index:   est.esIndex,
-		esutil.BulkIndexerItem{
+		Body:    strings.NewReader(string(jsonEvt)),
-			Action: "index",
+		Refresh: "true",
-			Body:   bytes.NewReader(jsonEvt),
+	}
-			OnFailure: func(ctx context.Context, item esutil.BulkIndexerItem, res esutil.BulkIndexerResponseItem, err error) {
+
-				if err != nil {
+	// Perform the request with the client.
-					log.Errorf("unable to submit trace - %s", err)
+	res, err := req.Do(context.Background(), est.cl)
-				} else {
+	if err != nil {
-					log.Errorf("unable to submit trace %s: %s", res.Error.Type, res.Error.Reason)
+		return err
-				}
+	}
-			},
+
-		},
+	err = res.Body.Close()
-	)
+	if err != nil {
+		return err
+	}
+
+	if res.IsError() {
+		return fmt.Errorf("[%s] Error indexing document ID=%s", res.Status(), req.DocumentID)
+	}
+
+	return nil
 }

storage/sealer/manager_test.go

@@ -17,7 +17,6 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/ipfs/go-datastore"
-	syncds "github.com/ipfs/go-datastore/sync"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -144,7 +143,7 @@ func TestSimple(t *testing.T) {
 	logging.SetAllLoggers(logging.LevelDebug)
 
 	ctx := context.Background()
-	m, lstor, _, _, cleanup := newTestMgr(ctx, t, syncds.MutexWrap(datastore.NewMapDatastore()))
+	m, lstor, _, _, cleanup := newTestMgr(ctx, t, datastore.NewMapDatastore())
 	defer cleanup()
 
 	localTasks := []sealtasks.TaskType{
@@ -201,7 +200,7 @@ func (m NullReader) NullBytes() int64 {
 func TestSnapDeals(t *testing.T) {
 	logging.SetAllLoggers(logging.LevelWarn)
 	ctx := context.Background()
-	m, lstor, stor, idx, cleanup := newTestMgr(ctx, t, syncds.MutexWrap(datastore.NewMapDatastore()))
+	m, lstor, stor, idx, cleanup := newTestMgr(ctx, t, datastore.NewMapDatastore())
 	defer cleanup()
 
 	localTasks := []sealtasks.TaskType{
@@ -209,7 +208,7 @@ func TestSnapDeals(t *testing.T) {
 		sealtasks.TTFetch, sealtasks.TTReplicaUpdate, sealtasks.TTProveReplicaUpdate1, sealtasks.TTProveReplicaUpdate2, sealtasks.TTUnseal,
 		sealtasks.TTRegenSectorKey, sealtasks.TTFinalizeUnsealed,
 	}
-	wds := syncds.MutexWrap(datastore.NewMapDatastore())
+	wds := datastore.NewMapDatastore()
 
 	w := NewLocalWorker(WorkerConfig{TaskTypes: localTasks}, stor, lstor, idx, m, statestore.New(wds))
 	err := m.AddWorker(ctx, w)
@@ -330,7 +329,7 @@ func TestSnapDeals(t *testing.T) {
 func TestSnarkPackV2(t *testing.T) {
 	logging.SetAllLoggers(logging.LevelWarn)
 	ctx := context.Background()
-	m, lstor, stor, idx, cleanup := newTestMgr(ctx, t, syncds.MutexWrap(datastore.NewMapDatastore()))
+	m, lstor, stor, idx, cleanup := newTestMgr(ctx, t, datastore.NewMapDatastore())
 	defer cleanup()
 
 	localTasks := []sealtasks.TaskType{
@@ -338,7 +337,7 @@ func TestSnarkPackV2(t *testing.T) {
 		sealtasks.TTFetch, sealtasks.TTReplicaUpdate, sealtasks.TTProveReplicaUpdate1, sealtasks.TTProveReplicaUpdate2, sealtasks.TTUnseal,
 		sealtasks.TTRegenSectorKey, sealtasks.TTFinalizeUnsealed,
 	}
-	wds := syncds.MutexWrap(datastore.NewMapDatastore())
+	wds := datastore.NewMapDatastore()
 
 	w := NewLocalWorker(WorkerConfig{TaskTypes: localTasks}, stor, lstor, idx, m, statestore.New(wds))
 	err := m.AddWorker(ctx, w)
@@ -472,7 +471,7 @@ func TestRedoPC1(t *testing.T) {
 	logging.SetAllLoggers(logging.LevelDebug)
 
 	ctx := context.Background()
-	m, lstor, _, _, cleanup := newTestMgr(ctx, t, syncds.MutexWrap(datastore.NewMapDatastore()))
+	m, lstor, _, _, cleanup := newTestMgr(ctx, t, datastore.NewMapDatastore())
 	defer cleanup()
 
 	localTasks := []sealtasks.TaskType{
@@ -525,7 +524,7 @@ func TestRestartManager(t *testing.T) {
 			ctx, done := context.WithCancel(context.Background())
 			defer done()
 
-			ds := syncds.MutexWrap(datastore.NewMapDatastore())
+			ds := datastore.NewMapDatastore()
 
 			m, lstor, _, _, cleanup := newTestMgr(ctx, t, ds)
 			defer cleanup()
@@ -623,7 +622,7 @@ func TestRestartWorker(t *testing.T) {
 	ctx, done := context.WithCancel(context.Background())
 	defer done()
 
-	ds := syncds.MutexWrap(datastore.NewMapDatastore())
+	ds := datastore.NewMapDatastore()
 
 	m, lstor, stor, idx, cleanup := newTestMgr(ctx, t, ds)
 	defer cleanup()
@@ -632,7 +631,7 @@ func TestRestartWorker(t *testing.T) {
 		sealtasks.TTAddPiece, sealtasks.TTFetch,
 	}
 
-	wds := syncds.MutexWrap(datastore.NewMapDatastore())
+	wds := datastore.NewMapDatastore()
 
 	arch := make(chan chan apres)
 	w := newLocalWorker(func() (storiface.Storage, error) {
@@ -696,7 +695,7 @@ func TestReenableWorker(t *testing.T) {
 	ctx, done := context.WithCancel(context.Background())
 	defer done()
 
-	ds := syncds.MutexWrap(datastore.NewMapDatastore())
+	ds := datastore.NewMapDatastore()
 
 	m, lstor, stor, idx, cleanup := newTestMgr(ctx, t, ds)
 	defer cleanup()
@@ -769,7 +768,7 @@ func TestResUse(t *testing.T) {
 	ctx, done := context.WithCancel(context.Background())
 	defer done()
 
-	ds := syncds.MutexWrap(datastore.NewMapDatastore())
+	ds := datastore.NewMapDatastore()
 
 	m, lstor, stor, idx, cleanup := newTestMgr(ctx, t, ds)
 	defer cleanup()
@@ -778,7 +777,7 @@ func TestResUse(t *testing.T) {
 		sealtasks.TTAddPiece, sealtasks.TTFetch,
 	}
 
-	wds := syncds.MutexWrap(datastore.NewMapDatastore())
+	wds := datastore.NewMapDatastore()
 
 	arch := make(chan chan apres)
 	w := newLocalWorker(func() (storiface.Storage, error) {
@@ -827,7 +826,7 @@ func TestResOverride(t *testing.T) {
 	ctx, done := context.WithCancel(context.Background())
 	defer done()
 
-	ds := syncds.MutexWrap(datastore.NewMapDatastore())
+	ds := datastore.NewMapDatastore()
 
 	m, lstor, stor, idx, cleanup := newTestMgr(ctx, t, ds)
 	defer cleanup()
@@ -836,7 +835,7 @@ func TestResOverride(t *testing.T) {
 		sealtasks.TTAddPiece, sealtasks.TTFetch,
 	}
 
-	wds := syncds.MutexWrap(datastore.NewMapDatastore())
+	wds := datastore.NewMapDatastore()
 
 	arch := make(chan chan apres)
 	w := newLocalWorker(func() (storiface.Storage, error) {