fix lotus-sim build

.circleci/template.yml

@@ -1,28 +1,23 @@
 version: 2.1
 orbs:
+  go: gotest/tools@0.0.13
   aws-cli: circleci/aws-cli@1.3.2
+  packer: salaxander/packer@0.0.3
 
 executors:
   golang:
     docker:
-      # Must match GO_VERSION_MIN in project root
-      - image: cimg/go:1.18.1
+      - image: circleci/golang:1.16.4
     resource_class: 2xlarge
   ubuntu:
     docker:
       - image: ubuntu:20.04
-  packer:
-    description: |
-      The HashiCorp provided Packer container
-    parameters:
-      packer-version:
-        type: string
-        default: "1.8"
-    docker:
-      - image: hashicorp/packer:<< parameters.packer-version >>
-
 
 commands:
+  install-deps:
+    steps:
+      - go/install-ssh
+      - go/install: {package: git}
   prepare:
     parameters:
       linux:
@@ -36,42 +31,12 @@ commands:
     steps:
       - checkout
       - git_fetch_all_tags
+      - checkout
       - when:
-          condition: <<parameters.linux>>
+          condition: << parameters.linux >>
           steps:
-            - run:
-                name: Check Go Version
-                command: |
-                  v=`go version | { read _ _ v _; echo ${v#go}; }`
-                  if [["[[ $v != `cat GO_VERSION_MIN` ]]"]]; then
-                    echo "GO_VERSION_MIN file does not match the go version being used."
-                    echo "Please update image to cimg/go:`cat GO_VERSION_MIN` or update GO_VERSION_MIN to $v."
-                    exit 1
-                  fi
             - run: sudo apt-get update
             - run: sudo apt-get install ocl-icd-opencl-dev libhwloc-dev
-            - run: sudo apt-get install python-is-python3
-
-      - when:
-          condition: <<parameters.darwin>>
-          steps:
-            - run:
-                name: Install Go
-                command: |
-                  curl https://dl.google.com/go/go`cat GO_VERSION_MIN`.darwin-amd64.pkg -o /tmp/go.pkg && \
-                  sudo installer -pkg /tmp/go.pkg -target /
-            - run:
-                name: Export Go
-                command: |
-                  echo 'export GOPATH="${HOME}/go"' >> $BASH_ENV
-            - run: go version
-            - run:
-                name: Install dependencies with Homebrew
-                command: HOMEBREW_NO_AUTO_UPDATE=1 brew install pkg-config coreutils jq hwloc
-            - run:
-                name: Install Rust
-                command: |
-                  curl https://sh.rustup.rs -sSf | sh -s -- -y
       - run: git submodule sync
       - run: git submodule update --init
   download-params:
@@ -91,50 +56,64 @@ commands:
   install_ipfs:
     steps:
       - run: |
-          curl -O https://dist.ipfs.tech/kubo/v0.16.0/kubo_v0.16.0_linux-amd64.tar.gz
-          tar -xvzf kubo_v0.16.0_linux-amd64.tar.gz
-          pushd kubo
-          sudo bash install.sh
-          popd
-          rm -rf kubo
-          rm kubo_v0.16.0_linux-amd64.tar.gz
+          apt update
+          apt install -y wget
+          wget https://github.com/ipfs/go-ipfs/releases/download/v0.4.22/go-ipfs_v0.4.22_linux-amd64.tar.gz
+          wget https://github.com/ipfs/go-ipfs/releases/download/v0.4.22/go-ipfs_v0.4.22_linux-amd64.tar.gz.sha512
+          if [ "$(sha512sum go-ipfs_v0.4.22_linux-amd64.tar.gz)" != "$(cat go-ipfs_v0.4.22_linux-amd64.tar.gz.sha512)" ]
+          then
+            echo "ipfs failed checksum check"
+            exit 1
+          fi
+          tar -xf go-ipfs_v0.4.22_linux-amd64.tar.gz
+          mv go-ipfs/ipfs /usr/local/bin/ipfs
+          chmod +x /usr/local/bin/ipfs
   git_fetch_all_tags:
     steps:
       - run:
           name: fetch all tags
           command: |
             git fetch --all
-  packer_build:
-    description: "Run a packer build"
-    parameters:
-      template:
-        description: |
-          The name of the packer template file
-        type: string
-        default: packer.json
-      args:
-        description: |
-          Arguments to pass to the packer build command
-        type: string
-        default: ""
-
-    steps:
-      - run:
-          name: "Run a packer build"
-          command: packer build << parameters.args >> << parameters.template >>
-          no_output_timeout: 1h
 
 jobs:
   mod-tidy-check:
     executor: golang
     steps:
+      - install-deps
       - prepare
-      - run: go mod tidy -v
+      - go/mod-tidy-check
+
+  build-all:
+    executor: golang
+    steps:
+      - install-deps
+      - prepare
+      - run: sudo apt-get update
+      - run: sudo apt-get install npm
       - run:
-          name: Check git diff
-          command: |
-            git --no-pager diff go.mod go.sum
-            git --no-pager diff --quiet go.mod go.sum
+          command: make buildall
+      - run:
+          name: check tag and version output match
+          command: ./scripts/version-check.sh ./lotus
+      - store_artifacts:
+          path: lotus
+      - store_artifacts:
+          path: lotus-miner
+      - store_artifacts:
+          path: lotus-worker
+      - run: mkdir linux && mv lotus lotus-miner lotus-worker linux/
+      - persist_to_workspace:
+          root: "."
+          paths:
+            - linux
+
+  build-debug:
+    executor: golang
+    steps:
+      - install-deps
+      - prepare
+      - run:
+          command: make debug
 
   test:
     description: |
@@ -162,19 +141,32 @@ jobs:
         type: string
         default: standard-verbose
         description: gotestsum format. https://github.com/gotestyourself/gotestsum#format
+      coverage:
+        type: string
+        default: -coverprofile=coverage.txt -coverpkg=github.com/filecoin-project/lotus/...
+        description: Coverage flag. Set to the empty string to disable.
+      codecov-upload:
+        type: boolean
+        default: true
+        description: |
+          Upload coverage report to https://codecov.io/. Requires the codecov API token to be
+          set as an environment variable for private projects.
     executor: << parameters.executor >>
     steps:
+      - install-deps
       - prepare
       - run:
           command: make deps lotus
           no_output_timeout: 30m
       - download-params
+      - go/install-gotestsum:
+          gobin: $HOME/.local/bin
+          version: 0.5.2
       - run:
           name: go test
           environment:
             TEST_RUSTPROOFS_LOGS: << parameters.proofs-log-test >>
             SKIP_CONFORMANCE: "1"
-            LOTUS_SRC_DIR: /home/circleci/project
           command: |
             mkdir -p /tmp/test-reports/<< parameters.suite >>
             mkdir -p /tmp/test-artifacts
@@ -183,6 +175,7 @@ jobs:
               --junitfile /tmp/test-reports/<< parameters.suite >>/junit.xml \
               --jsonfile /tmp/test-artifacts/<< parameters.suite >>.json \
               -- \
+              << parameters.coverage >> \
               << parameters.go-test-flags >> \
               << parameters.target >>
           no_output_timeout: 30m
@@ -190,10 +183,19 @@ jobs:
           path: /tmp/test-reports
       - store_artifacts:
           path: /tmp/test-artifacts/<< parameters.suite >>.json
+      - when:
+          condition: << parameters.codecov-upload >>
+          steps:
+            - go/install: {package: bash}
+            - go/install: {package: curl}
+            - run:
+                shell: /bin/bash -eo pipefail
+                command: |
+                  bash <(curl -s https://codecov.io/bash)
 
   test-conformance:
     description: |
-      Run tests using a corpus of interoperable test vectors for Filecoin
+      Run tests using a corpus of interoperable test vectors for Filecoin 
       implementations to test their correctness and compliance with the Filecoin
       specifications.
     parameters:
@@ -207,6 +209,7 @@ jobs:
           submodule is used.
     executor: << parameters.executor >>
     steps:
+      - install-deps
       - prepare
       - run:
           command: make deps lotus
@@ -223,6 +226,9 @@ jobs:
                   cd extern/test-vectors
                   git fetch
                   git checkout origin/<< parameters.vectors-branch >>
+      - go/install-gotestsum:
+          gobin: $HOME/.local/bin
+          version: 0.5.2
       - run:
           name: install statediff globally
           command: |
@@ -249,104 +255,138 @@ jobs:
           path: /tmp/test-reports
       - store_artifacts:
           path: /tmp/test-artifacts/conformance-coverage.html
-
-  build-linux-amd64:
-    executor: golang
-    steps:
-      - prepare
-      - run: make lotus lotus-miner lotus-worker
-      - run:
-          name: check tag and version output match
-          command: ./scripts/version-check.sh ./lotus
-      - run: |
-          mkdir -p /tmp/workspace/linux_amd64_v1 && \
-          mv lotus lotus-miner lotus-worker /tmp/workspace/linux_amd64_v1/
-      - persist_to_workspace:
-          root: /tmp/workspace
-          paths:
-            - linux_amd64_v1
-
-  build-darwin-amd64:
-    description: build darwin lotus binary
-    working_directory: ~/go/src/github.com/filecoin-project/lotus
-    macos:
-      xcode: "13.4.1"
-    steps:
-      - prepare:
-          linux: false
-          darwin: true
-      - run: make lotus lotus-miner lotus-worker
-      - run:
-          name: check tag and version output match
-          command: ./scripts/version-check.sh ./lotus
-      - run: |
-          mkdir -p /tmp/workspace/darwin_amd64_v1 && \
-          mv lotus lotus-miner lotus-worker /tmp/workspace/darwin_amd64_v1/
-      - persist_to_workspace:
-          root: /tmp/workspace
-          paths:
-            - darwin_amd64_v1
-
-  build-darwin-arm64:
-    description: self-hosted m1 runner
-    working_directory: ~/go/src/github.com/filecoin-project/lotus
-    machine: true
-    resource_class: filecoin-project/self-hosted-m1
-    steps:
-      - run: echo 'export PATH=/opt/homebrew/bin:"$PATH"' >> "$BASH_ENV"
-      - prepare:
-          linux: false
-          darwin: true
-      - run: |
-          export CPATH=$(brew --prefix)/include
-          export LIBRARY_PATH=$(brew --prefix)/lib
-          make lotus lotus-miner lotus-worker
-      - run:
-          name: check tag and version output match
-          command: ./scripts/version-check.sh ./lotus
-      - run: |
-          mkdir -p /tmp/workspace/darwin_arm64 && \
-          mv lotus lotus-miner lotus-worker /tmp/workspace/darwin_arm64/
-      - persist_to_workspace:
-          root: /tmp/workspace
-          paths:
-            - darwin_arm64
-      - run:
-          command: make clean
-          when: always
-      - run:
-          name: cleanup homebrew
-          command: HOMEBREW_NO_AUTO_UPDATE=1 brew uninstall pkg-config coreutils jq hwloc
-          when: always
-
-  release:
-    executor: golang
+  build-ntwk-calibration:
+    description: |
+      Compile lotus binaries for the calibration network
     parameters:
-      dry-run:
-        default: false
-        description: should this release actually publish it's artifacts?
-        type: boolean
+      <<: *test-params
+    executor: << parameters.executor >>
     steps:
-      - checkout
-      - run: |
-          echo 'deb [trusted=yes] https://repo.goreleaser.com/apt/ /' | sudo tee /etc/apt/sources.list.d/goreleaser.list
-          sudo apt update
-          sudo apt install goreleaser-pro
-      - install_ipfs
-      - attach_workspace:
-          at: /tmp/workspace
-      - when:
-          condition: << parameters.dry-run >>
-          steps:
-            - run: goreleaser release --rm-dist --snapshot --debug
-            - run: ./scripts/generate-checksums.sh
-      - when:
-          condition:
-            not: << parameters.dry-run >>
-          steps:
-            - run: goreleaser release --rm-dist --debug
-            - run: ./scripts/generate-checksums.sh
-            - run: ./scripts/publish-checksums.sh
+      - install-deps
+      - prepare
+      - run: make calibnet
+      - run: mkdir linux-calibrationnet && mv lotus lotus-miner lotus-worker linux-calibrationnet
+      - persist_to_workspace:
+          root: "."
+          paths:
+            - linux-calibrationnet
+  build-ntwk-butterfly:
+    description: |
+      Compile lotus binaries for the butterfly network
+    parameters:
+      <<: *test-params
+    executor: << parameters.executor >>
+    steps:
+      - install-deps
+      - prepare
+      - run: make butterflynet
+      - run: mkdir linux-butterflynet && mv lotus lotus-miner lotus-worker linux-butterflynet
+      - persist_to_workspace:
+          root: "."
+          paths:
+            - linux-butterflynet
+  build-lotus-soup:
+    description: |
+      Compile `lotus-soup` Testground test plan
+    parameters:
+      <<: *test-params
+    executor: << parameters.executor >>
+    steps:
+      - install-deps
+      - prepare
+      - run: cd extern/filecoin-ffi && make
+      - run:
+          name: "go get lotus@master"
+          command: cd testplans/lotus-soup && go mod edit -replace=github.com/filecoin-project/lotus=../.. && go mod tidy
+      - run:
+          name: "build lotus-soup testplan"
+          command: pushd testplans/lotus-soup && go build -tags=testground .
+  trigger-testplans:
+    description: |
+      Trigger `lotus-soup` test cases on TaaS
+    parameters:
+      <<: *test-params
+    executor: << parameters.executor >>
+    steps:
+      - install-deps
+      - prepare
+      - run:
+          name: "download testground"
+          command: wget https://gist.github.com/nonsense/5fbf3167cac79945f658771aed32fc44/raw/2e17eb0debf7ec6bdf027c1bdafc2c92dd97273b/testground-d3e9603 -O ~/testground-cli && chmod +x ~/testground-cli
+      - run:
+          name: "prepare .env.toml"
+          command: pushd testplans/lotus-soup && mkdir -p $HOME/testground && cp env-ci.toml $HOME/testground/.env.toml && echo 'endpoint="https://ci.testground.ipfs.team"' >> $HOME/testground/.env.toml && echo 'user="circleci"' >> $HOME/testground/.env.toml
+      - run:
+          name: "prepare testground home dir and link test plans"
+          command: mkdir -p $HOME/testground/plans && ln -s $(pwd)/testplans/lotus-soup $HOME/testground/plans/lotus-soup
+      - run:
+          name: "go get lotus@master"
+          command: cd testplans/lotus-soup && go get github.com/filecoin-project/lotus@master
+      - run:
+          name: "trigger deals baseline testplan on taas"
+          command: ~/testground-cli run composition -f $HOME/testground/plans/lotus-soup/_compositions/baseline-k8s-3-1.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
+      - run:
+          name: "trigger payment channel stress testplan on taas"
+          command: ~/testground-cli run composition -f $HOME/testground/plans/lotus-soup/_compositions/paych-stress-k8s.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
+
+  build-macos:
+    description: build darwin lotus binary
+    macos:
+      xcode: "12.5.0"
+    working_directory: ~/go/src/github.com/filecoin-project/lotus
+    steps:
+      - prepare:
+          linux: false
+          darwin: true
+      - run:
+          name: Install go
+          command: |
+            curl -O https://dl.google.com/go/go1.16.4.darwin-amd64.pkg && \
+            sudo installer -pkg go1.16.4.darwin-amd64.pkg -target /
+      - run:
+          name: Install pkg-config
+          command: HOMEBREW_NO_AUTO_UPDATE=1 brew install pkg-config
+      - run: go version
+      - run:
+          name: Install Rust
+          command: |
+            curl https://sh.rustup.rs -sSf | sh -s -- -y
+      - run:
+          name: Install hwloc
+          command: |
+            mkdir ~/hwloc
+            curl --location https://download.open-mpi.org/release/hwloc/v2.4/hwloc-2.4.1.tar.gz --output ~/hwloc/hwloc-2.4.1.tar.gz
+            cd ~/hwloc
+            tar -xvzpf hwloc-2.4.1.tar.gz
+            cd hwloc-2.4.1
+            ./configure && make && sudo make install
+      - restore_cache:
+          name: restore cargo cache
+          key: v3-go-deps-{{ arch }}-{{ checksum "~/go/src/github.com/filecoin-project/lotus/go.sum" }}
+      - install-deps
+      - run:
+          command: make build
+          no_output_timeout: 30m
+      - run:
+          name: check tag and version output match
+          command: ./scripts/version-check.sh ./lotus
+      - store_artifacts:
+          path: lotus
+      - store_artifacts:
+          path: lotus-miner
+      - store_artifacts:
+          path: lotus-worker
+      - run: mkdir darwin && mv lotus lotus-miner lotus-worker darwin/
+      - persist_to_workspace:
+          root: "."
+          paths:
+            - darwin
+      - save_cache:
+          name: save cargo cache
+          key: v3-go-deps-{{ arch }}-{{ checksum "~/go/src/github.com/filecoin-project/lotus/go.sum" }}
+          paths:
+            - "~/.rustup"
+            - "~/.cargo"
 
   build-appimage:
     machine:
@@ -354,14 +394,7 @@ jobs:
     steps:
       - checkout
       - attach_workspace:
-          at: /tmp/workspace
-      - run:
-          name: Update Go
-          command: |
-            sudo rm -rf /usr/local/go && \
-            curl -L https://golang.org/dl/go`cat GO_VERSION_MIN`.linux-amd64.tar.gz -o /tmp/go.tar.gz && \
-            sudo tar -C /usr/local -xvf /tmp/go.tar.gz
-      - run: go version
+          at: "."
       - run:
           name: install appimage-builder
           command: |
@@ -389,11 +422,13 @@ jobs:
           command: |
             sed -i "s/version: latest/version: ${CIRCLE_TAG:-latest}/" AppImageBuilder.yml
             make appimage
-      - run: |
-            mkdir -p /tmp/workspace/appimage && \
-            mv Lotus-*.AppImage /tmp/workspace/appimage/
+      - run:
+          name: prepare workspace
+          command: |
+            mkdir appimage
+            mv Lotus-*.AppImage appimage
       - persist_to_workspace:
-          root: /tmp/workspace
+          root: "."
           paths:
             - appimage
 
@@ -401,6 +436,7 @@ jobs:
   gofmt:
     executor: golang
     steps:
+      - install-deps
       - prepare
       - run:
           command: "! go fmt ./... 2>&1 | read"
@@ -408,6 +444,7 @@ jobs:
   gen-check:
     executor: golang
     steps:
+      - install-deps
       - prepare
       - run: make deps
       - run: go install golang.org/x/tools/cmd/goimports
@@ -422,6 +459,7 @@ jobs:
   docs-check:
     executor: golang
     steps:
+      - install-deps
       - prepare
       - run: go install golang.org/x/tools/cmd/goimports
       - run: zcat build/openrpc/full.json.gz | jq > ../pre-openrpc-full
@@ -445,6 +483,9 @@ jobs:
       executor:
         type: executor
         default: golang
+      golangci-lint-version:
+        type: string
+        default: 1.27.0
       concurrency:
         type: string
         default: '2'
@@ -458,14 +499,18 @@ jobs:
           Arguments to pass to golangci-lint
     executor: << parameters.executor >>
     steps:
+      - install-deps
       - prepare
       - run:
           command: make deps
           no_output_timeout: 30m
+      - go/install-golangci-lint:
+          gobin: $HOME/.local/bin
+          version: << parameters.golangci-lint-version >>
       - run:
           name: Lint
           command: |
-            golangci-lint run -v --timeout 2m \
+            $HOME/.local/bin/golangci-lint run -v --timeout 2m \
               --concurrency << parameters.concurrency >> << parameters.args >>
   lint-all:
     <<: *lint
@@ -473,35 +518,22 @@ jobs:
   publish:
     description: publish binary artifacts
     executor: ubuntu
-    parameters:
-      linux:
-        default: false
-        description: publish linux binaries?
-        type: boolean
-      appimage:
-        default: false
-        description: publish appimage binaries?
-        type: boolean
     steps:
       - run:
           name: Install git jq curl
-          command: apt update && apt install -y git jq curl sudo
+          command: apt update && apt install -y git jq curl
       - checkout
       - git_fetch_all_tags
       - checkout
       - install_ipfs
       - attach_workspace:
-          at: /tmp/workspace
-      - when:
-          condition: << parameters.linux >>
-          steps:
-            - run: ./scripts/build-arch-bundle.sh linux
-            - run: ./scripts/publish-arch-release.sh linux
-      - when:
-          condition: << parameters.appimage >>
-          steps:
-            - run: ./scripts/build-appimage-bundle.sh
-            - run: ./scripts/publish-arch-release.sh appimage
+          at: "."
+      - run:
+          name: Create bundles
+          command: ./scripts/build-bundle.sh
+      - run:
+          name: Publish release
+          command: ./scripts/publish-release.sh
 
   publish-snapcraft:
     description: build and push snapcraft
@@ -513,29 +545,22 @@ jobs:
         type: string
         default: "edge"
         description: snapcraft channel
-      snap-name:
-        type: string
-        default: 'lotus-filecoin'
-        description: name of snap in snap store
     steps:
       - checkout
       - run:
-          name: Install snapcraft
+          name: install snapcraft
           command: sudo snap install snapcraft --classic
       - run:
-          name: Build << parameters.snap-name >> snap
+          name: create snapcraft config file
           command: |
-            if [ "<< parameters.snap-name >>" != 'lotus-filecoin' ]; then
-              cat snap/snapcraft.yaml | sed 's/lotus-filecoin/lotus/' > edited-snapcraft.yaml
-              mv edited-snapcraft.yaml snap/snapcraft.yaml
-            fi
-
-            snapcraft --use-lxd --debug
+            mkdir -p ~/.config/snapcraft
+            echo "$SNAPCRAFT_LOGIN_FILE" | base64 -d > ~/.config/snapcraft/snapcraft.cfg
       - run:
-          name: Publish snap to << parameters.channel >> channel
-          shell: /bin/bash -o pipefail
-          command: |
-            snapcraft upload *.snap --release << parameters.channel >>
+          name: build snap
+          command: snapcraft --use-lxd
+      - run:
+          name: publish snap
+          command: snapcraft push *.snap --release << parameters.channel >>
 
   build-and-push-image:
     description: build and push docker images to public AWS ECR registry
@@ -660,13 +685,52 @@ jobs:
               docker push $<<parameters.account-url>>/<<parameters.repo>>:${tag}
             done
 
+  publish-packer-mainnet:
+    description: build and push AWS IAM and DigitalOcean droplet.
+    executor:
+      name: packer/default
+      packer-version: 1.6.6
+    steps:
+      - checkout
+      - attach_workspace:
+          at: "."
+      - packer/build:
+          template: tools/packer/lotus.pkr.hcl
+          args: "-var ci_workspace_bins=./linux -var lotus_network=mainnet -var git_tag=$CIRCLE_TAG"
+  publish-packer-calibrationnet:
+    description: build and push AWS IAM and DigitalOcean droplet.
+    executor:
+      name: packer/default
+      packer-version: 1.6.6
+    steps:
+      - checkout
+      - attach_workspace:
+          at: "."
+      - packer/build:
+          template: tools/packer/lotus.pkr.hcl
+          args: "-var ci_workspace_bins=./linux-calibrationnet -var lotus_network=calibrationnet -var git_tag=$CIRCLE_TAG"
+  publish-packer-butterflynet:
+    description: build and push AWS IAM and DigitalOcean droplet.
+    executor:
+      name: packer/default
+      packer-version: 1.6.6
+    steps:
+      - checkout
+      - attach_workspace:
+          at: "."
+      - packer/build:
+          template: tools/packer/lotus.pkr.hcl
+          args: "-var ci_workspace_bins=./linux-butterflynet -var lotus_network=butterflynet -var git_tag=$CIRCLE_TAG"
   publish-packer-snap:
     description: build packer image with snap. mainnet only.
     executor:
-      name: packer
+      name: packer/default
+      packer-version: 1.6.6
     steps:
       - checkout
-      - packer_build:
+      - attach_workspace:
+          at: "."
+      - packer/build:
           template: tools/packer/lotus-snap.pkr.hcl
   publish-dockerhub:
     description: publish to dockerhub
@@ -685,32 +749,26 @@ jobs:
           name: docker build
           command: |
             docker build --target lotus -t filecoin/lotus:<< parameters.tag >> -f Dockerfile.lotus .
-            docker build --target lotus-gateway -t filecoin/lotus-gateway:<< parameters.tag >> -f Dockerfile.lotus .
             docker build --target lotus-all-in-one -t filecoin/lotus-all-in-one:<< parameters.tag >> -f Dockerfile.lotus .
             if [["[[ ! -z $CIRCLE_SHA1 ]]"]]; then
               docker build --target lotus -t filecoin/lotus:$CIRCLE_SHA1 -f Dockerfile.lotus .
-              docker build --target lotus-gateway -t filecoin/lotus-gateway:$CIRCLE_SHA1 -f Dockerfile.lotus .
               docker build --target lotus-all-in-one -t filecoin/lotus-all-in-one:$CIRCLE_SHA1 -f Dockerfile.lotus .
             fi
             if [["[[ ! -z $CIRCLE_TAG ]]"]]; then
               docker build --target lotus -t filecoin/lotus:$CIRCLE_TAG -f Dockerfile.lotus .
-              docker build --target lotus-gateway -t filecoin/lotus-gateway:$CIRCLE_TAG -f Dockerfile.lotus .
               docker build --target lotus-all-in-one -t filecoin/lotus-all-in-one:$CIRCLE_TAG -f Dockerfile.lotus .
             fi
       - run:
           name: docker push
           command: |
             docker push filecoin/lotus:<< parameters.tag >>
-            docker push filecoin/lotus-gateway:<< parameters.tag >>
             docker push filecoin/lotus-all-in-one:<< parameters.tag >>
             if [["[[ ! -z $CIRCLE_SHA1 ]]"]]; then
               docker push filecoin/lotus:$CIRCLE_SHA1
-              docker push filecoin/lotus-gateway:$CIRCLE_SHA1
               docker push filecoin/lotus-all-in-one:$CIRCLE_SHA1
             fi
             if [["[[ ! -z $CIRCLE_TAG ]]"]]; then
               docker push filecoin/lotus:$CIRCLE_TAG
-              docker push filecoin/lotus-gateway:$CIRCLE_TAG
               docker push filecoin/lotus-all-in-one:$CIRCLE_TAG
             fi
 
@@ -743,52 +801,41 @@ workflows:
       - test:
           go-test-flags: "-run=TestMulticoreSDR"
           suite: multicore-sdr-check
-          target: "./storage/sealer/ffiwrapper"
+          target: "./extern/sector-storage/ffiwrapper"
           proofs-log-test: "1"
       - test-conformance:
           suite: conformance
+          codecov-upload: false
           target: "./conformance"
       - test-conformance:
           name: test-conformance-bleeding-edge
+          codecov-upload: false
           suite: conformance-bleeding-edge
           target: "./conformance"
           vectors-branch: specs-actors-v7
-
-  release:
-    jobs:
-      - build-linux-amd64:
-          name: "Build ( linux / amd64 )"
+      - trigger-testplans:
           filters:
             branches:
               only:
-                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
-            tags:
-              only:
-                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
-      - build-darwin-amd64:
-          name: "Build ( darwin / amd64 )"
+                - master
+      - build-debug
+      - build-all:
           filters:
-            branches:
-              only:
-                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
             tags:
               only:
                 - /^v\d+\.\d+\.\d+(-rc\d+)?$/
-      - build-darwin-arm64:
-          name: "Build ( darwin / arm64 )"
+      - build-ntwk-calibration:
           filters:
-            branches:
-              only:
-                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
             tags:
               only:
                 - /^v\d+\.\d+\.\d+(-rc\d+)?$/
-      - release:
-          name: "Release"
-          requires:
-            - "Build ( darwin / amd64 )"
-            - "Build ( linux / amd64 )"
-            - "Build ( darwin / arm64 )"
+      - build-ntwk-butterfly:
+          filters:
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - build-lotus-soup
+      - build-macos:
           filters:
             branches:
               ignore:
@@ -796,31 +843,19 @@ workflows:
             tags:
               only:
                 - /^v\d+\.\d+\.\d+(-rc\d+)?$/
-      - release:
-          name: "Release (dry-run)"
-          dry-run: true
-          requires:
-            - "Build ( darwin / amd64 )"
-            - "Build ( linux / amd64 )"
-            - "Build ( darwin / arm64 )"
-          filters:
-            branches:
-              only:
-                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
       - build-appimage:
-          name: "Build AppImage"
           filters:
             branches:
-              only:
-                - /^release\/v\d+\.\d+\.\d+(-rc\d+)?$/
+              ignore:
+                - /.*/
             tags:
               only:
                 - /^v\d+\.\d+\.\d+(-rc\d+)?$/
       - publish:
-          name: "Publish AppImage"
-          appimage: true
           requires:
-            - "Build AppImage"
+            - build-all
+            - build-macos
+            - build-appimage
           filters:
             branches:
               ignore:
@@ -829,65 +864,59 @@ workflows:
               only:
                 - /^v\d+\.\d+\.\d+(-rc\d+)?$/
       - build-and-push-image:
-          name: "Publish ECR (lotus-all-in-one)"
           dockerfile: Dockerfile.lotus
           path: .
           repo: lotus-dev
           tag: '${CIRCLE_SHA1:0:8}'
           target: lotus-all-in-one
       - build-and-push-image:
-          name: "Publish ECR (lotus-test)"
           dockerfile: Dockerfile.lotus
           path: .
           repo: lotus-test
           tag: '${CIRCLE_SHA1:0:8}'
           target: lotus-test
+      - publish-packer-mainnet:
+          requires:
+            - build-all
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - publish-packer-calibrationnet:
+          requires:
+            - build-ntwk-calibration
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - publish-packer-butterflynet:
+          requires:
+            - build-ntwk-butterfly
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
       - publish-snapcraft:
-          name: "Publish Snapcraft (lotus-filecoin / candidate)"
+          name: publish-snapcraft-stable
           channel: stable
-          snap-name: lotus-filecoin
           filters:
             branches:
               ignore:
                 - /.*/
             tags:
               only:
-                - /^v\d+\.\d+\.\d+$/
-      - publish-snapcraft:
-          name: "Publish Snapcraft (lotus-filecoin / candidate)"
-          channel: candidate
-          snap-name: lotus-filecoin
-          filters:
-            branches:
-              ignore:
-                - /.*/
-            tags:
-              only:
-                - /^v\d+\.\d+\.\d+-rc\d+$/
-      - publish-snapcraft:
-          name: "Publish Snapcraft (lotus / stable)"
-          channel: stable
-          snap-name: lotus
-          filters:
-            branches:
-              ignore:
-                - /.*/
-            tags:
-              only:
-                - /^v\d+\.\d+\.\d+$/
-      - publish-snapcraft:
-          name: "Publish Snapcraft (lotus / candidate)"
-          channel: candidate
-          snap-name: lotus
-          filters:
-            branches:
-              ignore:
-                - /.*/
-            tags:
-              only:
-                - /^v\d+\.\d+\.\d+-rc\d+$/
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
       - publish-dockerhub:
-          name: "Publish Dockerhub (stable)"
+          name: publish-dockerhub
           tag: stable
           filters:
             branches:
@@ -895,17 +924,7 @@ workflows:
                 - /.*/
             tags:
               only:
-                - /^v\d+\.\d+\.\d+$/
-      - publish-dockerhub:
-          name: "Publish Dockerhub (candidate)"
-          tag: candidate
-          filters:
-            branches:
-              ignore:
-                - /.*/
-            tags:
-              only:
-                - /^v\d+\.\d+\.\d+-rc\d+$/
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
 
   nightly:
     triggers:
@@ -917,20 +936,15 @@ workflows:
                 - master
     jobs:
       - publish-snapcraft:
-          name: "Publish Snapcraft Nightly (lotus-filecoin / edge)"
+          name: publish-snapcraft-nightly
           channel: edge
-          snap-name: lotus-filecoin
-      - publish-snapcraft:
-          name: "Publish Snapcraft Nightly (lotus / edge)"
-          channel: edge
-          snap-name: lotus
       - publish-dockerhub:
           name: publish-dockerhub-nightly
           tag: nightly
-  biweekly:
+  monthly:
     triggers:
       - schedule:
-          cron: "0 0 1,15 * *"
+          cron: "0 0 1 * *"
           filters:
             branches:
               only:

.codecov.yml

@@ -0,0 +1,73 @@
+ignore:
+  # Auto generated
+  - "^.*_gen.go$"
+  - "^.*/mock_full.go$"
+  # Old actors.
+  - "^chain/actors/builtin/[^/]*/(message|state|v)[0-4]\\.go$" # We test the latest version only.
+  # Tests
+  - "api/test/**"
+  - "conformance/**"
+  # Generators
+  - "gen/**"
+  - "chain/actors/agen/**"
+  # Non-critical utilities
+  - "api/docgen/**"
+  - "api/docgen-openrpc/**"
+coverage:
+  status:
+    patch: off
+    project:
+      tools-and-tests:
+        target: auto
+        threshold: 1%
+        informational: true
+        paths:
+          - "testplans"
+          - "tools"
+          - "system"
+          - "snap"
+          - "lotuspond"
+          - "conformance"
+          - "scripts"
+          - "gen"
+          - "build"
+      markets: 
+        target: auto
+        threshold: 1%
+        informational: false        
+        paths: 
+          - "markets"
+          - "paychmgr"
+      miner: 
+        target: auto
+        threshold: 1.5%
+        informational: false       
+        paths: 
+          - "miner"
+          - "storage"
+      chain:
+        target: auto
+        threshold: 1%
+        informational: false
+        paths:
+          - "chain"
+      node:
+        target: auto
+        threshold: 1%
+        informational: false
+        paths: 
+          - "node"
+          - "blockstore"
+          - "metrics"
+          - "lib"
+          - "genesis"
+          - "gateway"
+          - "api"
+          - "journal"
+      cli: 
+        target: auto
+        threshold: 1%
+        informational: true
+        paths: 
+          - "cli"
+          - "cmd"

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -81,7 +81,7 @@ body:
     render: text
     description: |
       Please provide debug logs of the problem, remember you can get set log level control for:
-      * lotus: use `lotus log list` to get all log systems available and set level by `lotus log set-level`. An example can be found [here](https://lotus.filecoin.io/lotus/configure/defaults/#log-level-control).
+      * lotus: use `lotus log list` to get all log systems available and set level by `lotus log set-level`. An example can be found [here](https://docs.filecoin.io/get-started/lotus/configuration-and-advanced-usage/#log-level-control).
       * lotus-miner:`lotus-miner log list` to get all log systems available and set level by `lotus-miner log set-level
       If you don't provide detailed logs when you raise the issue it will almost certainly be the first request I make before furthur diagnosing the problem.
   validations:

.github/pull_request_template.md

@@ -1,23 +1,21 @@
 ## Related Issues
-<!-- Link issues that this PR might resolve/fix. If an issue doesn't exist, include a brief motivation for the change being made -->
+<!-- link all issues that this PR might resolve/fix. If an issue doesn't exist, include a brief motivation for the change being made.-->
 
 ## Proposed Changes
-<!-- A clear list of the changes being made -->
+<!-- provide a clear list of the changes being made-->
+
 
 ## Additional Info
-<!-- Callouts, links to documentation, and etc -->
+<!-- callouts, links to documentation, and etc-->
 
 ## Checklist
 
 Before you mark the PR ready for review, please make sure that:
-
-- [ ] Commits have a clear commit message.
-- [ ] PR title is in the form of of `<PR type>: <area>: <change being made>`
-  - example: ` fix: mempool: Introduce a cache for valid signatures`
-  - `PR type`: fix, feat, build, chore, ci, docs, perf, refactor, revert, style, test
-  - `area`, e.g. api, chain, state, market, mempool, multisig, networking, paych, proving, sealing, wallet, deps
-- [ ] New features have usage guidelines and / or documentation updates in
-  - [ ] [Lotus Documentation](https://lotus.filecoin.io)
-  - [ ] [Discussion Tutorials](https://github.com/filecoin-project/lotus/discussions/categories/tutorials)
-- [ ] Tests exist for new functionality or change in behavior
+- [ ] All commits have a clear commit message.
+- [ ] The PR title is in the form of of `<PR type>: <area>: <change being made>`
+    - example: ` fix: mempool: Introduce a cache for valid signatures`
+    - `PR type`: _fix_, _feat_, _INTERFACE BREAKING CHANGE_, _CONSENSUS BREAKING_, _build_, _chore_, _ci_, _docs_,_perf_, _refactor_, _revert_, _style_, _test_
+    - `area`: _api_, _chain_, _state_, _vm_, _data transfer_, _market_, _mempool_, _message_, _block production_, _multisig_, _networking_, _paychan_, _proving_, _sealing_, _wallet_, _deps_
+- [ ] This PR has tests for new functionality or change in behaviour
+- [ ] If new user-facing features are introduced, clear usage guidelines and / or documentation updates should be included in https://lotus.filecoin.io or [Discussion Tutorials.](https://github.com/filecoin-project/lotus/discussions/categories/tutorials)
 - [ ] CI is green

.github/workflows/codeql-analysis.yml

@@ -37,7 +37,7 @@ jobs:
 
     - uses: actions/setup-go@v1
       with:
-        go-version: '1.18.1'
+        go-version: '1.16.4'
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL

.github/workflows/testground-on-push.yml

@@ -21,7 +21,7 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: testground run
-        uses: testground/testground-github-action@v1
+        uses: coryschwartz/testground-github-action@v1.1
         with:
           backend_addr: ${{ matrix.backend_addr }}
           backend_proto: ${{ matrix.backend_proto }}

.gitignore

@@ -9,6 +9,7 @@
 /lotus-chainwatch
 /lotus-shed
 /lotus-sim
+/lotus-pond
 /lotus-townhall
 /lotus-fountain
 /lotus-stats
@@ -20,6 +21,8 @@
 /docgen-md
 /docgen-openrpc
 /bench.json
+/lotuspond/front/node_modules
+/lotuspond/front/build
 /cmd/lotus-townhall/townhall/node_modules
 /cmd/lotus-townhall/townhall/build
 /cmd/lotus-townhall/townhall/package-lock.json
@@ -45,8 +48,3 @@ bin/ipget
 bin/tmp/*
 .idea
 scratchpad
-
-build/builtin-actors/v*
-build/builtin-actors/*.car
-
-dist/

.golangci.yml

@@ -25,7 +25,7 @@ skip-dirs:
 
 issues:
   exclude:
-    - "by other packages, and that stutters; consider calling this"
+    - "func name will be used as test\\.Test.* by other packages, and that stutters; consider calling this"
     - "Potential file inclusion via variable"
     - "should have( a package)? comment"
     - "Error return value of `logging.SetLogLevel` is not checked"
@@ -37,12 +37,12 @@ issues:
     - "string .* has .* occurrences, make it a constant"
     - "a blank import should be only in a main or test package, or have a comment justifying it"
     - "package comment should be of the form"
-    - "Potential hardcoded credentials"
-    - "Use of weak random number generator"
-    - "xerrors.* is deprecated"
 
   exclude-use-default: false
   exclude-rules:
+    - path: lotuspond
+      linters:
+        - errcheck
 
     - path: node/modules/lp2p
       linters:
@@ -51,7 +51,7 @@ issues:
     - path: build/params_.*\.go
       linters:
         - golint
-
+          
     - path: api/apistruct/struct.go
       linters:
         - golint

.goreleaser.yaml

@@ -1,108 +0,0 @@
-project_name: lotus
-
-universal_binaries:
-  - id: lotus
-    replace: true
-    name_template: lotus
-  - id: lotus-miner
-    replace: true
-    name_template: lotus-miner
-  - id: lotus-worker
-    replace: true
-    name_template: lotus-worker
-
-builds:
-  - id: lotus
-    binary: lotus
-    builder: prebuilt
-    goos:
-      - darwin
-      - linux
-    goarch:
-      - amd64
-      - arm64
-    goamd64:
-      - v1
-    ignore:
-      - goos: linux
-        goarch: arm64
-    prebuilt:
-      path: /tmp/workspace/{{ .Os }}_{{ .Arch }}{{ with .Amd64 }}_{{ . }}{{ end }}/lotus
-  - id: lotus-miner
-    binary: lotus-miner
-    builder: prebuilt
-    goos:
-      - darwin
-      - linux
-    goarch:
-      - amd64
-      - arm64
-    goamd64:
-      - v1
-    ignore:
-      - goos: linux
-        goarch: arm64
-    prebuilt:
-      path: /tmp/workspace/{{ .Os }}_{{ .Arch }}{{ with .Amd64 }}_{{ . }}{{ end }}/lotus-miner
-  - id: lotus-worker
-    binary: lotus-worker
-    builder: prebuilt
-    goos:
-      - darwin
-      - linux
-    goarch:
-      - amd64
-      - arm64
-    goamd64:
-      - v1
-    ignore:
-      - goos: linux
-        goarch: arm64
-    prebuilt:
-      path: /tmp/workspace/{{ .Os }}_{{ .Arch }}{{ with .Amd64 }}_{{ . }}{{ end }}/lotus-worker
-
-archives:
-  - id: primary
-    format: tar.gz
-    wrap_in_directory: true
-    files:
-      # this is a dumb but required hack so it doesn't include the default files
-      # https://github.com/goreleaser/goreleaser/issues/602
-      - _n_o_n_e_*
-
-release:
-  github:
-    owner: filecoin-project
-    name: lotus
-  prerelease: auto
-  name_template: "v{{.Version}}"
-
-brews:
-  - tap:
-      owner: filecoin-project
-      name: homebrew-lotus
-      branch: master
-    ids:
-      - primary
-    install: |
-      bin.install "lotus"
-      bin.install "lotus-miner"
-      bin.install "lotus-worker"
-    test: |
-      system "#{bin}/lotus --version"
-      system "#{bin}/lotus-miner --version"
-      system "#{bin}/lotus-worker --version"
-    folder: Formula
-    homepage: "https://filecoin.io"
-    description: "A homebrew cask for installing filecoin-project/lotus on MacOS"
-    license: MIT
-    skip_upload: auto
-    dependencies:
-      - name: hwloc
-
-# produced manually so we can include cid checksums
-checksum:
-  disable: true
-
-snapshot:
-  name_template: "{{ .Tag }}"

AppImageBuilder.yml

@@ -68,4 +68,6 @@ AppDir:
       use_host_x: false
 AppImage:
   arch: x86_64
+  update-information: guess
+  sign-key: None
 

Dockerfile.lotus

@@ -1,45 +1,30 @@
-FROM golang:1.18.1-buster AS builder-deps
+FROM golang:1.16.4 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
 
+ARG RUST_VERSION=nightly
 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
+    PATH=/usr/local/cargo/bin:$PATH
 
-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 -; \
+RUN wget "https://static.rust-lang.org/rustup/dist/x86_64-unknown-linux-gnu/rustup-init"; \
     chmod +x rustup-init; \
-    ./rustup-init -y --no-modify-path --profile minimal --default-toolchain $RUST_VERSION --default-host ${rustArch}; \
+    ./rustup-init -y --no-modify-path --profile minimal --default-toolchain $RUST_VERSION; \
     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
 
 
@@ -67,14 +52,14 @@ 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/
+COPY --from=builder /lib/x86_64-linux-gnu/libdl.so.2         /lib/
+COPY --from=builder /lib/x86_64-linux-gnu/librt.so.1         /lib/
+COPY --from=builder /lib/x86_64-linux-gnu/libgcc_s.so.1      /lib/
+COPY --from=builder /lib/x86_64-linux-gnu/libutil.so.1       /lib/
+COPY --from=builder /usr/lib/x86_64-linux-gnu/libltdl.so.7   /lib/
+COPY --from=builder /usr/lib/x86_64-linux-gnu/libnuma.so.1   /lib/
+COPY --from=builder /usr/lib/x86_64-linux-gnu/libhwloc.so.5  /lib/
+COPY --from=builder /usr/lib/x86_64-linux-gnu/libOpenCL.so.1 /lib/
 
 RUN useradd -r -u 532 -U fc \
  && mkdir -p /etc/OpenCL/vendors \
@@ -268,4 +253,3 @@ EXPOSE 1234
 EXPOSE 2345
 EXPOSE 3456
 EXPOSE 1777
-

GO_VERSION_MIN

@@ -1 +0,0 @@
-1.18.1

Makefile

@@ -8,11 +8,9 @@ unexport GOFLAGS
 GOCC?=go
 
 GOVERSION:=$(shell $(GOCC) version | tr ' ' '\n' | grep go1 | sed 's/^go//' | awk -F. '{printf "%d%03d%03d", $$1, $$2, $$3}')
-GOVERSIONMIN:=$(shell cat GO_VERSION_MIN | awk -F. '{printf "%d%03d%03d", $$1, $$2, $$3}')
-
-ifeq ($(shell expr $(GOVERSION) \< $(GOVERSIONMIN)), 1)
+ifeq ($(shell expr $(GOVERSION) \< 1016000), 1)
 $(warning Your Golang version is go$(shell expr $(GOVERSION) / 1000000).$(shell expr $(GOVERSION) % 1000000 / 1000).$(shell expr $(GOVERSION) % 1000))
-$(error Update Golang to version to at least $(shell cat GO_VERSION_MIN))
+$(error Update Golang to version to at least 1.16.0)
 endif
 
 # git modules that need to be loaded
@@ -66,7 +64,7 @@ CLEAN+=build/.update-modules
 deps: $(BUILD_DEPS)
 .PHONY: deps
 
-build-devnets: build lotus-seed lotus-shed
+build-devnets: build lotus-seed lotus-shed lotus-wallet lotus-gateway
 .PHONY: build-devnets
 
 debug: GOFLAGS+=-tags=debug
@@ -135,18 +133,6 @@ install-worker:
 install-app:
 	install -C ./$(APP) /usr/local/bin/$(APP)
 
-uninstall: uninstall-daemon uninstall-miner uninstall-worker
-.PHONY: uninstall
-
-uninstall-daemon:
-	rm -f /usr/local/bin/lotus
-
-uninstall-miner:
-	rm -f /usr/local/bin/lotus-miner
-
-uninstall-worker:
-	rm -f /usr/local/bin/lotus-worker
-
 # TOOLS
 
 lotus-seed: $(BUILD_DEPS)
@@ -162,16 +148,28 @@ benchmarks:
 	@curl -X POST 'http://benchmark.kittyhawk.wtf/benchmark' -d '@bench.json' -u "${benchmark_http_cred}"
 .PHONY: benchmarks
 
+lotus-pond: 2k
+	$(GOCC) build -o lotus-pond ./lotuspond
+.PHONY: lotus-pond
+BINS+=lotus-pond
+
+lotus-pond-front:
+	(cd lotuspond/front && npm i && CI=false npm run build)
+.PHONY: lotus-pond-front
+
+lotus-pond-app: lotus-pond-front lotus-pond
+.PHONY: lotus-pond-app
+
 lotus-fountain:
 	rm -f lotus-fountain
-	$(GOCC) build $(GOFLAGS) -o lotus-fountain ./cmd/lotus-fountain
-	$(GOCC) run github.com/GeertJohan/go.rice/rice append --exec lotus-fountain -i ./cmd/lotus-fountain -i ./build
+	go build $(GOFLAGS) -o lotus-fountain ./cmd/lotus-fountain
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-fountain -i ./cmd/lotus-fountain -i ./build
 .PHONY: lotus-fountain
 BINS+=lotus-fountain
 
 lotus-bench:
 	rm -f lotus-bench
-	$(GOCC) build $(GOFLAGS) -o lotus-bench ./cmd/lotus-bench
+	$(GOCC) build -o lotus-bench ./cmd/lotus-bench
 .PHONY: lotus-bench
 BINS+=lotus-bench
 
@@ -195,7 +193,7 @@ BINS+=lotus-health
 
 lotus-wallet:
 	rm -f lotus-wallet
-	$(GOCC) build $(GOFLAGS) -o lotus-wallet ./cmd/lotus-wallet
+	$(GOCC) build -o lotus-wallet ./cmd/lotus-wallet
 .PHONY: lotus-wallet
 BINS+=lotus-wallet
 
@@ -289,20 +287,14 @@ type-gen: api-gen
 	$(GOCC) generate -x ./...
 	goimports -w api/
 
-actors-code-gen:
+method-gen: api-gen
+	(cd ./lotuspond/front/src/chain && $(GOCC) run ./methodgen.go)
+
+actors-gen:
 	$(GOCC) run ./gen/inline-gen . gen/inlinegen-data.json
 	$(GOCC) run ./chain/actors/agen
 	$(GOCC) fmt ./...
 
-actors-gen: actors-code-gen fiximports
-.PHONY: actors-gen
-
-bundle-gen:
-	$(GOCC) run ./gen/bundle
-	$(GOCC) fmt ./build/...
-.PHONY: bundle-gen
-
-
 api-gen:
 	$(GOCC) run ./gen/api
 	goimports -w api
@@ -321,7 +313,7 @@ appimage: lotus
 	cp ./lotus AppDir/usr/bin/
 	appimage-builder
 
-docsgen: docsgen-md docsgen-openrpc fiximports
+docsgen: docsgen-md docsgen-openrpc
 
 docsgen-md-bin: api-gen actors-gen
 	$(GOCC) build $(GOFLAGS) -o docgen-md ./api/docgen/cmd
@@ -338,7 +330,7 @@ docsgen-md-storage: docsgen-md-bin
 docsgen-md-worker: docsgen-md-bin
 	./docgen-md "api/api_worker.go" "Worker" "api" "./api" > documentation/en/api-v0-methods-worker.md
 
-docsgen-openrpc: docsgen-openrpc-full docsgen-openrpc-storage docsgen-openrpc-worker docsgen-openrpc-gateway
+docsgen-openrpc: docsgen-openrpc-full docsgen-openrpc-storage docsgen-openrpc-worker
 
 docsgen-openrpc-full: docsgen-openrpc-bin
 	./docgen-openrpc "api/api_full.go" "FullNode" "api" "./api" -gzip > build/openrpc/full.json.gz
@@ -346,15 +338,10 @@ docsgen-openrpc-storage: docsgen-openrpc-bin
 	./docgen-openrpc "api/api_storage.go" "StorageMiner" "api" "./api" -gzip > build/openrpc/miner.json.gz
 docsgen-openrpc-worker: docsgen-openrpc-bin
 	./docgen-openrpc "api/api_worker.go" "Worker" "api" "./api" -gzip > build/openrpc/worker.json.gz
-docsgen-openrpc-gateway: docsgen-openrpc-bin
-	./docgen-openrpc "api/api_gateway.go" "Gateway" "api" "./api" -gzip > build/openrpc/gateway.json.gz
 
 .PHONY: docsgen docsgen-md-bin docsgen-openrpc-bin
 
-fiximports:
-	./scripts/fiximports
-
-gen: actors-code-gen type-gen cfgdoc-gen docsgen api-gen circleci bundle-gen fiximports
+gen: actors-gen type-gen method-gen cfgdoc-gen docsgen api-gen circleci
 	@echo ">>> IF YOU'VE MODIFIED THE CLI OR CONFIG, REMEMBER TO ALSO MAKE docsgen-cli"
 .PHONY: gen
 

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="https://lotus.filecoin.io/" title="Filecoin Docs">
+  <a href="https://docs.filecoin.io/" title="Filecoin Docs">
     <img src="documentation/images/lotus_logo_h.png" alt="Project Lotus Logo" width="244" />
   </a>
 </p>
@@ -10,7 +10,7 @@
   <a href="https://circleci.com/gh/filecoin-project/lotus"><img src="https://circleci.com/gh/filecoin-project/lotus.svg?style=svg"></a>
   <a href="https://codecov.io/gh/filecoin-project/lotus"><img src="https://codecov.io/gh/filecoin-project/lotus/branch/master/graph/badge.svg"></a>
   <a href="https://goreportcard.com/report/github.com/filecoin-project/lotus"><img src="https://goreportcard.com/badge/github.com/filecoin-project/lotus" /></a>  
-  <a href=""><img src="https://img.shields.io/badge/golang-%3E%3D1.18.1-blue.svg" /></a>
+  <a href=""><img src="https://img.shields.io/badge/golang-%3E%3D1.16-blue.svg" /></a>
   <br>
 </p>
 
@@ -20,7 +20,7 @@ Lotus is an implementation of the Filecoin Distributed Storage Network. For more
 
 > Note: The default `master` branch is the dev branch, please use with caution. For the latest stable version, checkout the most recent [`Latest release`](https://github.com/filecoin-project/lotus/releases).
  
-For complete instructions on how to build, install and setup lotus, please visit [https://lotus.filecoin.io](https://lotus.filecoin.io/lotus/install/prerequisites/#supported-platforms). Basic build instructions can be found further down in this readme.
+For complete instructions on how to build, install and setup lotus, please visit [https://docs.filecoin.io/get-started/lotus](https://docs.filecoin.io/get-started/lotus/). Basic build instructions can be found further down in this readme.
 
 ## Reporting a Vulnerability
 
@@ -31,7 +31,7 @@ Please send an email to security@filecoin.org. See our [security policy](SECURIT
 These repos are independent and reusable modules, but are tightly integrated into Lotus to make up a fully featured Filecoin implementation:
 
 - [go-fil-markets](https://github.com/filecoin-project/go-fil-markets) which has its own [kanban work tracker available here](https://app.zenhub.com/workspaces/markets-shared-components-5daa144a7046a60001c6e253/board)
-- [builtin-actors](https://github.com/filecoin-project/builtin-actors)
+- [specs-actors](https://github.com/filecoin-project/specs-actors) which has its own [kanban work tracker available here](https://app.zenhub.com/workspaces/actors-5ee6f3aa87591f0016c05685/board)
 
 ## Contribute
 
@@ -64,17 +64,17 @@ sudo apt install mesa-opencl-icd ocl-icd-opencl-dev gcc git bzr jq pkg-config cu
 
 Fedora:
 ```
-sudo dnf -y install gcc make git bzr jq pkgconfig mesa-libOpenCL mesa-libOpenCL-devel opencl-headers ocl-icd ocl-icd-devel clang llvm wget hwloc hwloc-devel
+sudo dnf -y install gcc make git bzr jq pkgconfig mesa-libOpenCL mesa-libOpenCL-devel opencl-headers ocl-icd ocl-icd-devel clang llvm wget hwloc libhwloc-dev
 ```
 
-For other distributions you can find the required dependencies [here.](https://lotus.filecoin.io/lotus/install/prerequisites/#supported-platforms) For instructions specific to macOS, you can find them [here.](https://lotus.filecoin.io/lotus/install/macos/)
+For other distributions you can find the required dependencies [here.](https://docs.filecoin.io/get-started/lotus/installation/#system-specific) For instructions specific to macOS, you can find them [here.](https://docs.filecoin.io/get-started/lotus/installation/#macos)
 
 #### Go
 
-To build Lotus, you need a working installation of [Go 1.18.1 or higher](https://golang.org/dl/):
+To build Lotus, you need a working installation of [Go 1.16.4 or higher](https://golang.org/dl/):
 
 ```bash
-wget -c https://golang.org/dl/go1.18.1.linux-amd64.tar.gz -O - | sudo tar -xz -C /usr/local
+wget -c https://golang.org/dl/go1.16.4.linux-amd64.tar.gz -O - | sudo tar -xz -C /usr/local
 ```
 
 **TIP:**
@@ -101,7 +101,7 @@ Note: The default branch `master` is the dev branch where the latest new feature
 
 2. To join mainnet, checkout the [latest release](https://github.com/filecoin-project/lotus/releases).
 
-   If you are changing networks from a previous Lotus installation or there has been a network reset, read the [Switch networks guide](https://lotus.filecoin.io/lotus/manage/switch-networks/) before proceeding.
+   If you are changing networks from a previous Lotus installation or there has been a network reset, read the [Switch networks guide](https://docs.filecoin.io/get-started/lotus/switch-networks/) before proceeding.
 
    For networks other than mainnet, look up the current branch or tag/commit for the network you want to join in the [Filecoin networks dashboard](https://network.filecoin.io), then build Lotus for your specific network below.
 
@@ -113,8 +113,8 @@ Note: The default branch `master` is the dev branch where the latest new feature
 
    Currently, the latest code on the _master_ branch corresponds to mainnet.
 
-3. If you are in China, see "[Lotus: tips when running in China](https://lotus.filecoin.io/lotus/configure/nodes-in-china/)".
-4. This build instruction uses the prebuilt proofs binaries. If you want to build the proof binaries from source check the [complete instructions](https://lotus.filecoin.io/lotus/install/prerequisites/). Note, if you are building the proof binaries from source, [installing rustup](https://lotus.filecoin.io/lotus/install/linux/#rustup) is also needed.
+3. If you are in China, see "[Lotus: tips when running in China](https://docs.filecoin.io/get-started/lotus/tips-running-in-china/)".
+4. This build instruction uses the prebuilt proofs binaries. If you want to build the proof binaries from source check the [complete instructions](https://docs.filecoin.io/get-started/lotus/installation/#build-and-install-lotus). Note, if you are building the proof binaries from source, [installing rustup](https://docs.filecoin.io/get-started/lotus/installation/#rustup) is also needed.
 
 5. Build and install Lotus:
 
@@ -129,9 +129,9 @@ Note: The default branch `master` is the dev branch where the latest new feature
 
    This will put `lotus`, `lotus-miner` and `lotus-worker` in `/usr/local/bin`.
 
-   `lotus` will use the `$HOME/.lotus` folder by default for storage (configuration, chain data, wallets, etc). See [advanced options](https://lotus.filecoin.io/lotus/configure/defaults/#environment-variables) for information on how to customize the Lotus folder.
+   `lotus` will use the `$HOME/.lotus` folder by default for storage (configuration, chain data, wallets, etc). See [advanced options](https://docs.filecoin.io/get-started/lotus/configuration-and-advanced-usage/) for information on how to customize the Lotus folder.
 
-6. You should now have Lotus installed. You can now [start the Lotus daemon and sync the chain](https://lotus.filecoin.io/lotus/install/linux/#start-the-lotus-daemon-and-sync-the-chain).
+6. You should now have Lotus installed. You can now [start the Lotus daemon and sync the chain](https://docs.filecoin.io/get-started/lotus/installation/#start-the-lotus-daemon-and-sync-the-chain).
 
 ## License
 

api/api_common.go

@@ -3,14 +3,13 @@ package api
 import (
 	"context"
 	"fmt"
-	"time"
+
+	apitypes "github.com/filecoin-project/lotus/api/types"
+	"github.com/filecoin-project/lotus/journal/alerting"
 
 	"github.com/google/uuid"
 
 	"github.com/filecoin-project/go-jsonrpc/auth"
-
-	apitypes "github.com/filecoin-project/lotus/api/types"
-	"github.com/filecoin-project/lotus/journal/alerting"
 )
 
 //                       MODIFYING THE API INTERFACE
@@ -50,9 +49,6 @@ type Common interface {
 	// trigger graceful shutdown
 	Shutdown(context.Context) error //perm:admin
 
-	// StartTime returns node start time
-	StartTime(context.Context) (time.Time, error) //perm:read
-
 	// Session returns a random UUID of api provider session
 	Session(context.Context) (uuid.UUID, error) //perm:read
 

api/api_errors.go

@@ -1,42 +0,0 @@
-package api
-
-import (
-	"errors"
-	"reflect"
-
-	"github.com/filecoin-project/go-jsonrpc"
-)
-
-const (
-	EOutOfGas = iota + jsonrpc.FirstUserCode
-	EActorNotFound
-)
-
-type ErrOutOfGas struct{}
-
-func (e *ErrOutOfGas) Error() string {
-	return "call ran out of gas"
-}
-
-type ErrActorNotFound struct{}
-
-func (e *ErrActorNotFound) Error() string {
-	return "actor not found"
-}
-
-var RPCErrors = jsonrpc.NewErrors()
-
-func ErrorIsIn(err error, errorTypes []error) bool {
-	for _, etype := range errorTypes {
-		tmp := reflect.New(reflect.PointerTo(reflect.ValueOf(etype).Elem().Type())).Interface()
-		if errors.As(err, tmp) {
-			return true
-		}
-	}
-	return false
-}
-
-func init() {
-	RPCErrors.Register(EOutOfGas, new(*ErrOutOfGas))
-	RPCErrors.Register(EActorNotFound, new(*ErrActorNotFound))
-}

api/api_full.go

@@ -6,29 +6,25 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/google/uuid"
-	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/libp2p/go-libp2p-core/peer"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
-	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
-	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/builtin/v8/paych"
-	"github.com/filecoin-project/go-state-types/builtin/v9/market"
-	"github.com/filecoin-project/go-state-types/builtin/v9/miner"
-	verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/dline"
-	abinetwork "github.com/filecoin-project/go-state-types/network"
+
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
 
 	apitypes "github.com/filecoin-project/lotus/api/types"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	lminer "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
@@ -41,7 +37,6 @@ import (
 type ChainIO interface {
 	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
-	ChainPutObj(context.Context, blocks.Block) error
 }
 
 const LookbackNoLimit = abi.ChainEpoch(-1)
@@ -127,9 +122,6 @@ type FullNode interface {
 	// ChainHasObj checks if a given CID exists in the chain blockstore.
 	ChainHasObj(context.Context, cid.Cid) (bool, error) //perm:read
 
-	// ChainPutObj puts a given object into the block store
-	ChainPutObj(context.Context, blocks.Block) error //perm:admin
-
 	// ChainStatObj returns statistics about the graph referenced by 'obj'.
 	// If 'base' is also specified, then the returned stat will be a diff
 	// between the two objects.
@@ -171,10 +163,6 @@ type FullNode interface {
 	// If oldmsgskip is set, messages from before the requested roots are also not included.
 	ChainExport(ctx context.Context, nroots abi.ChainEpoch, oldmsgskip bool, tsk types.TipSetKey) (<-chan []byte, error) //perm:read
 
-	// ChainPrune prunes the stored chain state and garbage collects; only supported if you
-	// are using the splitstore
-	ChainPrune(ctx context.Context, opts PruneOpts) error //perm:admin
-
 	// ChainCheckBlockstore performs an (asynchronous) health check on the chain/state blockstore
 	// if supported by the underlying implementation.
 	ChainCheckBlockstore(context.Context) error //perm:admin
@@ -182,6 +170,14 @@ type FullNode interface {
 	// ChainBlockstoreInfo returns some basic information about the blockstore
 	ChainBlockstoreInfo(context.Context) (map[string]interface{}, error) //perm:read
 
+	// MethodGroup: Beacon
+	// The Beacon method group contains methods for interacting with the random beacon (DRAND)
+
+	// BeaconGetEntry returns the beacon entry for the given filecoin epoch. If
+	// the entry has not yet been produced, the call will block until the entry
+	// becomes available
+	BeaconGetEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) //perm:read
+
 	// GasEstimateFeeCap estimates gas fee cap
 	GasEstimateFeeCap(context.Context, *types.Message, int64, types.TipSetKey) (types.BigInt, error) //perm:read
 
@@ -364,7 +360,7 @@ type FullNode interface {
 	// ClientGetRetrievalUpdates returns status of updated retrieval deals
 	ClientGetRetrievalUpdates(ctx context.Context) (<-chan RetrievalInfo, error) //perm:write
 	// ClientQueryAsk returns a signed StorageAsk from the specified miner.
-	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*StorageAsk, error) //perm:read
+	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.StorageAsk, error) //perm:read
 	// ClientCalcCommP calculates the CommP and data size of the specified CID
 	ClientDealPieceCID(ctx context.Context, root cid.Cid) (DataCIDSize, error) //perm:read
 	// ClientCalcCommP calculates the CommP for a specified file
@@ -408,7 +404,7 @@ type FullNode interface {
 	StateCall(context.Context, *types.Message, types.TipSetKey) (*InvocResult, error) //perm:read
 	// StateReplay replays a given message, assuming it was included in a block in the specified tipset.
 	//
-	// If a tipset key is provided, and a replacing message is not found on chain,
+	// If a tipset key is provided, and a replacing message is found on chain,
 	// the method will return an error saying that the message wasn't found
 	//
 	// If no tipset key is provided, the appropriate tipset is looked up, and if
@@ -447,7 +443,7 @@ type FullNode interface {
 	// StateMinerPower returns the power of the indicated miner
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error) //perm:read
 	// StateMinerInfo returns info about the indicated miner
-	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (MinerInfo, error) //perm:read
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error) //perm:read
 	// StateMinerDeadlines returns all the proving deadlines for the given miner
 	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]Deadline, error) //perm:read
 	// StateMinerPartitions returns all partitions in the specified deadline
@@ -464,23 +460,18 @@ type FullNode interface {
 	StateMinerInitialPledgeCollateral(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error) //perm:read
 	// StateMinerAvailableBalance returns the portion of a miner's balance that can be withdrawn or spent
 	StateMinerAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error) //perm:read
-	// StateMinerSectorAllocated checks if a sector number is marked as allocated.
+	// StateMinerSectorAllocated checks if a sector is allocated
 	StateMinerSectorAllocated(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (bool, error) //perm:read
-	// StateSectorPreCommitInfo returns the PreCommit info for the specified miner's sector.
-	// Returns nil and no error if the sector isn't precommitted.
-	//
-	// Note that the sector number may be allocated while PreCommitInfo is nil. This means that either allocated sector
-	// numbers were compacted, and the sector number was marked as allocated in order to reduce size of the allocated
-	// sectors bitfield, or that the sector was precommitted, but the precommit has expired.
-	StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorPreCommitOnChainInfo, error) //perm:read
+	// StateSectorPreCommitInfo returns the PreCommit info for the specified miner's sector
+	StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) //perm:read
 	// StateSectorGetInfo returns the on-chain info for the specified miner's sector. Returns null in case the sector info isn't found
 	// NOTE: returned info.Expiration may not be accurate in some cases, use StateSectorExpiration to get accurate
 	// expiration epoch
 	StateSectorGetInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorOnChainInfo, error) //perm:read
 	// StateSectorExpiration returns epoch at which given sector will expire
-	StateSectorExpiration(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*lminer.SectorExpiration, error) //perm:read
+	StateSectorExpiration(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorExpiration, error) //perm:read
 	// StateSectorPartition finds deadline/partition with the specified sector
-	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*lminer.SectorLocation, error) //perm:read
+	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*miner.SectorLocation, error) //perm:read
 	// StateSearchMsg looks back up to limit epochs in the chain for a message, and returns its receipt and the tipset where it was executed
 	//
 	// NOTE: If a replacing message is found on chain, this method will return
@@ -526,35 +517,18 @@ type FullNode interface {
 	// StateMarketParticipants returns the Escrow and Locked balances of every participant in the Storage Market
 	StateMarketParticipants(context.Context, types.TipSetKey) (map[string]MarketBalance, error) //perm:read
 	// StateMarketDeals returns information about every deal in the Storage Market
-	StateMarketDeals(context.Context, types.TipSetKey) (map[string]*MarketDeal, error) //perm:read
+	StateMarketDeals(context.Context, types.TipSetKey) (map[string]MarketDeal, error) //perm:read
 	// StateMarketStorageDeal returns information about the indicated deal
 	StateMarketStorageDeal(context.Context, abi.DealID, types.TipSetKey) (*MarketDeal, error) //perm:read
-	// StateGetAllocationForPendingDeal returns the allocation for a given deal ID of a pending deal. Returns nil if
-	// pending allocation is not found.
-	StateGetAllocationForPendingDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*verifregtypes.Allocation, error) //perm:read
-	// StateGetAllocation returns the allocation for a given address and allocation ID.
-	StateGetAllocation(ctx context.Context, clientAddr address.Address, allocationId verifregtypes.AllocationId, tsk types.TipSetKey) (*verifregtypes.Allocation, error) //perm:read
-	// StateGetAllocations returns the all the allocations for a given client.
-	StateGetAllocations(ctx context.Context, clientAddr address.Address, tsk types.TipSetKey) (map[verifregtypes.AllocationId]verifregtypes.Allocation, error) //perm:read
-	// StateGetClaim returns the claim for a given address and claim ID.
-	StateGetClaim(ctx context.Context, providerAddr address.Address, claimId verifregtypes.ClaimId, tsk types.TipSetKey) (*verifregtypes.Claim, error) //perm:read
-	// StateGetClaims returns the all the claims for a given provider.
-	StateGetClaims(ctx context.Context, providerAddr address.Address, tsk types.TipSetKey) (map[verifregtypes.ClaimId]verifregtypes.Claim, error) //perm:read
-	// StateComputeDataCID computes DataCID from a set of on-chain deals
-	StateComputeDataCID(ctx context.Context, maddr address.Address, sectorType abi.RegisteredSealProof, deals []abi.DealID, tsk types.TipSetKey) (cid.Cid, error) //perm:read
 	// StateLookupID retrieves the ID address of the given address
 	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error) //perm:read
-	// StateAccountKey returns the public key address of the given ID address for secp and bls accounts
+	// StateAccountKey returns the public key address of the given ID address
 	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error) //perm:read
-	// StateLookupRobustAddress returns the public key address of the given ID address for non-account addresses (multisig, miners etc)
-	StateLookupRobustAddress(context.Context, address.Address, types.TipSetKey) (address.Address, error) //perm:read
 	// StateChangedActors returns all the actors whose states change between the two given state CIDs
 	// TODO: Should this take tipset keys instead?
 	StateChangedActors(context.Context, cid.Cid, cid.Cid) (map[string]types.Actor, error) //perm:read
 	// StateMinerSectorCount returns the number of sectors in a miner's sector set and proving set
 	StateMinerSectorCount(context.Context, address.Address, types.TipSetKey) (MinerSectors, error) //perm:read
-	// StateMinerAllocated returns a bitfield containing all sector numbers marked as allocated in miner state
-	StateMinerAllocated(context.Context, address.Address, types.TipSetKey) (*bitfield.BitField, error) //perm:read
 	// StateCompute is a flexible command that applies the given messages on the given tipset.
 	// The messages are run as though the VM were at the provided height.
 	//
@@ -596,7 +570,7 @@ type FullNode interface {
 	// Returns nil if there is no entry in the data cap table for the
 	// address.
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) //perm:read
-	// StateVerifiedRegistryRootKey returns the address of the Verified Registry's root key
+	// StateVerifiedClientStatus returns the address of the Verified Registry's root key
 	StateVerifiedRegistryRootKey(ctx context.Context, tsk types.TipSetKey) (address.Address, error) //perm:read
 	// StateDealProviderCollateralBounds returns the min and max collateral a storage provider
 	// can issue. It takes the deal size and verified status as parameters.
@@ -610,24 +584,12 @@ type FullNode interface {
 	StateVMCirculatingSupplyInternal(context.Context, types.TipSetKey) (CirculatingSupply, error) //perm:read
 	// StateNetworkVersion returns the network version at the given tipset
 	StateNetworkVersion(context.Context, types.TipSetKey) (apitypes.NetworkVersion, error) //perm:read
-	// StateActorCodeCIDs returns the CIDs of all the builtin actors for the given network version
-	StateActorCodeCIDs(context.Context, abinetwork.Version) (map[string]cid.Cid, error) //perm:read
-	// StateActorManifestCID returns the CID of the builtin actors manifest for the given network version
-	StateActorManifestCID(context.Context, abinetwork.Version) (cid.Cid, error) //perm:read
 
 	// StateGetRandomnessFromTickets is used to sample the chain for randomness.
 	StateGetRandomnessFromTickets(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) //perm:read
 	// StateGetRandomnessFromBeacon is used to sample the beacon for randomness.
 	StateGetRandomnessFromBeacon(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) //perm:read
 
-	// StateGetBeaconEntry returns the beacon entry for the given filecoin epoch. If
-	// the entry has not yet been produced, the call will block until the entry
-	// becomes available
-	StateGetBeaconEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) //perm:read
-
-	// StateGetNetworkParams return current network params
-	StateGetNetworkParams(ctx context.Context) (*NetworkParams, error) //perm:read
-
 	// MethodGroup: Msig
 	// The Msig methods are used to interact with multisig wallets on the
 	// filecoin network
@@ -764,15 +726,6 @@ type FullNode interface {
 	// LOTUS_BACKUP_BASE_PATH environment variable set to some path, and that
 	// the path specified when calling CreateBackup is within the base path
 	CreateBackup(ctx context.Context, fpath string) error //perm:admin
-
-	RaftState(ctx context.Context) (*RaftStateData, error) //perm:read
-	RaftLeader(ctx context.Context) (peer.ID, error)       //perm:read
-}
-
-type StorageAsk struct {
-	Response *storagemarket.StorageAsk
-
-	DealProtocols []string
 }
 
 type FileRef struct {
@@ -1016,12 +969,8 @@ type RetrievalOrder struct {
 	Client                  address.Address
 	Miner                   address.Address
 	MinerPeer               *retrievalmarket.RetrievalPeer
-
-	RemoteStore *RemoteStoreID `json:"RemoteStore,omitempty"`
 }
 
-type RemoteStoreID = uuid.UUID
-
 type InvocResult struct {
 	MsgCid         cid.Cid
 	Msg            *types.Message
@@ -1247,8 +1196,3 @@ type MsigTransaction struct {
 
 	Approved []address.Address
 }
-
-type PruneOpts struct {
-	MovingGC    bool
-	RetainState int64
-}

api/api_gateway.go

@@ -3,15 +3,14 @@ package api
 import (
 	"context"
 
-	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/builtin/v9/miner"
 	"github.com/filecoin-project/go-state-types/dline"
 
 	apitypes "github.com/filecoin-project/lotus/api/types"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
@@ -31,7 +30,6 @@ import (
 
 type Gateway interface {
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
-	ChainPutObj(context.Context, blocks.Block) error
 	ChainHead(ctx context.Context) (*types.TipSet, error)
 	ChainGetParentMessages(context.Context, cid.Cid) ([]Message, error)
 	ChainGetParentReceipts(context.Context, cid.Cid) ([]*types.MessageReceipt, error)
@@ -58,7 +56,7 @@ type Gateway interface {
 	StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 	StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (MarketBalance, error)
 	StateMarketStorageDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*MarketDeal, error)
-	StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (MinerInfo, error)
+	StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error)
 	StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error)
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
 	StateNetworkVersion(context.Context, types.TipSetKey) (apitypes.NetworkVersion, error)
@@ -68,5 +66,4 @@ type Gateway interface {
 	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64, limit abi.ChainEpoch, allowReplaced bool) (*MsgLookup, error)
 	WalletBalance(context.Context, address.Address) (types.BigInt, error)
 	Version(context.Context) (APIVersion, error)
-	Discover(context.Context) (apitypes.OpenRPCDocument, error)
 }

api/api_net.go

@@ -4,10 +4,10 @@ import (
 	"context"
 	"time"
 
-	"github.com/libp2p/go-libp2p/core/metrics"
-	"github.com/libp2p/go-libp2p/core/network"
-	"github.com/libp2p/go-libp2p/core/peer"
-	"github.com/libp2p/go-libp2p/core/protocol"
+	metrics "github.com/libp2p/go-libp2p-core/metrics"
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/libp2p/go-libp2p-core/protocol"
 )
 
 //                       MODIFYING THE API INTERFACE

api/api_storage.go

@@ -5,28 +5,28 @@ import (
 	"context"
 	"time"
 
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+
 	"github.com/google/uuid"
 	"github.com/ipfs/go-cid"
-	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/libp2p/go-libp2p-core/peer"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-bitfield"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
+	"github.com/filecoin-project/go-state-types/abi"
+	abinetwork "github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
+	"github.com/filecoin-project/specs-storage/storage"
+
 	"github.com/filecoin-project/go-fil-markets/piecestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
-	"github.com/filecoin-project/go-jsonrpc/auth"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/builtin/v9/market"
-	"github.com/filecoin-project/go-state-types/builtin/v9/miner"
-	abinetwork "github.com/filecoin-project/go-state-types/network"
 
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/storage/pipeline/sealiface"
-	"github.com/filecoin-project/lotus/storage/sealer/fsutil"
-	"github.com/filecoin-project/lotus/storage/sealer/storiface"
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	"github.com/filecoin-project/lotus/extern/storage-sealing/sealiface"
 )
 
 //                       MODIFYING THE API INTERFACE
@@ -50,22 +50,10 @@ type StorageMiner interface {
 	ActorSectorSize(context.Context, address.Address) (abi.SectorSize, error) //perm:read
 	ActorAddressConfig(ctx context.Context) (AddressConfig, error)            //perm:read
 
-	// WithdrawBalance allows to withdraw balance from miner actor to owner address
-	// Specify amount as "0" to withdraw full balance. This method returns a message CID
-	// and does not wait for message execution
-	ActorWithdrawBalance(ctx context.Context, amount abi.TokenAmount) (cid.Cid, error) //perm:admin
-
-	// BeneficiaryWithdrawBalance allows the beneficiary of a miner to withdraw balance from miner actor
-	// Specify amount as "0" to withdraw full balance. This method returns a message CID
-	// and does not wait for message execution
-	BeneficiaryWithdrawBalance(context.Context, abi.TokenAmount) (cid.Cid, error) //perm:admin
-
 	MiningBase(context.Context) (*types.TipSet, error) //perm:read
 
 	ComputeWindowPoSt(ctx context.Context, dlIdx uint64, tsk types.TipSetKey) ([]miner.SubmitWindowedPoStParams, error) //perm:admin
 
-	ComputeDataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (abi.PieceInfo, error) //perm:admin
-
 	// Temp api for testing
 	PledgeSector(context.Context) (abi.SectorID, error) //perm:write
 
@@ -75,9 +63,9 @@ type StorageMiner interface {
 	// Add piece to an open sector. If no sectors with enough space are open,
 	// either a new sector will be created, or this call will block until more
 	// sectors can be created.
-	SectorAddPieceToAny(ctx context.Context, size abi.UnpaddedPieceSize, r storiface.Data, d PieceDealInfo) (SectorOffset, error) //perm:admin
+	SectorAddPieceToAny(ctx context.Context, size abi.UnpaddedPieceSize, r storage.Data, d PieceDealInfo) (SectorOffset, error) //perm:admin
 
-	SectorsUnsealPiece(ctx context.Context, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd *cid.Cid) error //perm:admin
+	SectorsUnsealPiece(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd *cid.Cid) error //perm:admin
 
 	// List all staged sectors
 	SectorsList(context.Context) ([]abi.SectorNumber, error) //perm:read
@@ -130,90 +118,51 @@ type StorageMiner interface {
 	// SectorAbortUpgrade can be called on sectors that are in the process of being upgraded to abort it
 	SectorAbortUpgrade(context.Context, abi.SectorNumber) error //perm:admin
 
-	// SectorNumAssignerMeta returns sector number assigner metadata - reserved/allocated
-	SectorNumAssignerMeta(ctx context.Context) (NumAssignerMeta, error) //perm:read
-	// SectorNumReservations returns a list of sector number reservations
-	SectorNumReservations(ctx context.Context) (map[string]bitfield.BitField, error) //perm:read
-	// SectorNumReserve creates a new sector number reservation. Will fail if any other reservation has colliding
-	// numbers or name. Set force to true to override safety checks.
-	// Valid characters for name: a-z, A-Z, 0-9, _, -
-	SectorNumReserve(ctx context.Context, name string, sectors bitfield.BitField, force bool) error //perm:admin
-	// SectorNumReserveCount creates a new sector number reservation for `count` sector numbers.
-	// by default lotus will allocate lowest-available sector numbers to the reservation.
-	// For restrictions on `name` see SectorNumReserve
-	SectorNumReserveCount(ctx context.Context, name string, count uint64) (bitfield.BitField, error) //perm:admin
-	// SectorNumFree drops a sector reservation
-	SectorNumFree(ctx context.Context, name string) error //perm:admin
-
-	SectorReceive(ctx context.Context, meta RemoteSectorMeta) error //perm:admin
-
 	// WorkerConnect tells the node to connect to workers RPC
 	WorkerConnect(context.Context, string) error                              //perm:admin retry:true
 	WorkerStats(context.Context) (map[uuid.UUID]storiface.WorkerStats, error) //perm:admin
 	WorkerJobs(context.Context) (map[uuid.UUID][]storiface.WorkerJob, error)  //perm:admin
 
 	//storiface.WorkerReturn
-	ReturnDataCid(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err *storiface.CallError) error                                         //perm:admin retry:true
-	ReturnAddPiece(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err *storiface.CallError) error                                        //perm:admin retry:true
-	ReturnSealPreCommit1(ctx context.Context, callID storiface.CallID, p1o storiface.PreCommit1Out, err *storiface.CallError) error                       //perm:admin retry:true
-	ReturnSealPreCommit2(ctx context.Context, callID storiface.CallID, sealed storiface.SectorCids, err *storiface.CallError) error                       //perm:admin retry:true
-	ReturnSealCommit1(ctx context.Context, callID storiface.CallID, out storiface.Commit1Out, err *storiface.CallError) error                             //perm:admin retry:true
-	ReturnSealCommit2(ctx context.Context, callID storiface.CallID, proof storiface.Proof, err *storiface.CallError) error                                //perm:admin retry:true
-	ReturnFinalizeSector(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                                    //perm:admin retry:true
-	ReturnReplicaUpdate(ctx context.Context, callID storiface.CallID, out storiface.ReplicaUpdateOut, err *storiface.CallError) error                     //perm:admin retry:true
-	ReturnProveReplicaUpdate1(ctx context.Context, callID storiface.CallID, vanillaProofs storiface.ReplicaVanillaProofs, err *storiface.CallError) error //perm:admin retry:true
-	ReturnProveReplicaUpdate2(ctx context.Context, callID storiface.CallID, proof storiface.ReplicaUpdateProof, err *storiface.CallError) error           //perm:admin retry:true
-	ReturnGenerateSectorKeyFromData(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                         //perm:admin retry:true
-	ReturnFinalizeReplicaUpdate(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                             //perm:admin retry:true
-	ReturnReleaseUnsealed(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                                   //perm:admin retry:true
-	ReturnMoveStorage(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                                       //perm:admin retry:true
-	ReturnUnsealPiece(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                                       //perm:admin retry:true
-	ReturnReadPiece(ctx context.Context, callID storiface.CallID, ok bool, err *storiface.CallError) error                                                //perm:admin retry:true
-	ReturnDownloadSector(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                                    //perm:admin retry:true
-	ReturnFetch(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                                             //perm:admin retry:true
+	ReturnAddPiece(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err *storiface.CallError) error                                      //perm:admin retry:true
+	ReturnSealPreCommit1(ctx context.Context, callID storiface.CallID, p1o storage.PreCommit1Out, err *storiface.CallError) error                       //perm:admin retry:true
+	ReturnSealPreCommit2(ctx context.Context, callID storiface.CallID, sealed storage.SectorCids, err *storiface.CallError) error                       //perm:admin retry:true
+	ReturnSealCommit1(ctx context.Context, callID storiface.CallID, out storage.Commit1Out, err *storiface.CallError) error                             //perm:admin retry:true
+	ReturnSealCommit2(ctx context.Context, callID storiface.CallID, proof storage.Proof, err *storiface.CallError) error                                //perm:admin retry:true
+	ReturnFinalizeSector(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                                  //perm:admin retry:true
+	ReturnReplicaUpdate(ctx context.Context, callID storiface.CallID, out storage.ReplicaUpdateOut, err *storiface.CallError) error                     //perm:admin retry:true
+	ReturnProveReplicaUpdate1(ctx context.Context, callID storiface.CallID, vanillaProofs storage.ReplicaVanillaProofs, err *storiface.CallError) error //perm:admin retry:true
+	ReturnProveReplicaUpdate2(ctx context.Context, callID storiface.CallID, proof storage.ReplicaUpdateProof, err *storiface.CallError) error           //perm:admin retry:true
+	ReturnGenerateSectorKeyFromData(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                       //perm:admin retry:true
+	ReturnFinalizeReplicaUpdate(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                           //perm:admin retry:true
+	ReturnReleaseUnsealed(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                                 //perm:admin retry:true
+	ReturnMoveStorage(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                                     //perm:admin retry:true
+	ReturnUnsealPiece(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                                     //perm:admin retry:true
+	ReturnReadPiece(ctx context.Context, callID storiface.CallID, ok bool, err *storiface.CallError) error                                              //perm:admin retry:true
+	ReturnFetch(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                                                           //perm:admin retry:true
 
 	// SealingSchedDiag dumps internal sealing scheduler state
 	SealingSchedDiag(ctx context.Context, doSched bool) (interface{}, error) //perm:admin
 	SealingAbort(ctx context.Context, call storiface.CallID) error           //perm:admin
-	//SealingSchedRemove removes a request from sealing pipeline
-	SealingRemoveRequest(ctx context.Context, schedId uuid.UUID) error //perm:admin
 
-	// paths.SectorIndex
-	StorageAttach(context.Context, storiface.StorageInfo, fsutil.FsStat) error                                                         //perm:admin
-	StorageDetach(ctx context.Context, id storiface.ID, url string) error                                                              //perm:admin
-	StorageInfo(context.Context, storiface.ID) (storiface.StorageInfo, error)                                                          //perm:admin
-	StorageReportHealth(context.Context, storiface.ID, storiface.HealthReport) error                                                   //perm:admin
-	StorageDeclareSector(ctx context.Context, storageID storiface.ID, s abi.SectorID, ft storiface.SectorFileType, primary bool) error //perm:admin
-	StorageDropSector(ctx context.Context, storageID storiface.ID, s abi.SectorID, ft storiface.SectorFileType) error                  //perm:admin
-	// StorageFindSector returns list of paths where the specified sector files exist.
-	//
-	// If allowFetch is set, list of paths to which the sector can be fetched will also be returned.
-	// - Paths which have sector files locally (don't require fetching) will be listed first.
-	// - Paths which have sector files locally will not be filtered based on based on AllowTypes/DenyTypes.
-	// - Paths which require fetching will be filtered based on AllowTypes/DenyTypes. If multiple
-	//   file types are specified, each type will be considered individually, and a union of all paths
-	//   which can accommodate each file type will be returned.
+	// SectorIndex
+	StorageAttach(context.Context, storiface.StorageInfo, fsutil.FsStat) error                                                                                             //perm:admin
+	StorageInfo(context.Context, storiface.ID) (storiface.StorageInfo, error)                                                                                              //perm:admin
+	StorageReportHealth(context.Context, storiface.ID, storiface.HealthReport) error                                                                                       //perm:admin
+	StorageDeclareSector(ctx context.Context, storageID storiface.ID, s abi.SectorID, ft storiface.SectorFileType, primary bool) error                                     //perm:admin
+	StorageDropSector(ctx context.Context, storageID storiface.ID, s abi.SectorID, ft storiface.SectorFileType) error                                                      //perm:admin
 	StorageFindSector(ctx context.Context, sector abi.SectorID, ft storiface.SectorFileType, ssize abi.SectorSize, allowFetch bool) ([]storiface.SectorStorageInfo, error) //perm:admin
-	// StorageBestAlloc returns list of paths where sector files of the specified type can be allocated, ordered by preference.
-	// Paths with more weight and more % of free space are preferred.
-	// Note: This method doesn't filter paths based on AllowTypes/DenyTypes.
-	StorageBestAlloc(ctx context.Context, allocate storiface.SectorFileType, ssize abi.SectorSize, pathType storiface.PathType) ([]storiface.StorageInfo, error) //perm:admin
-	StorageLock(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) error                                   //perm:admin
-	StorageTryLock(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) (bool, error)                        //perm:admin
-	StorageList(ctx context.Context) (map[storiface.ID][]storiface.Decl, error)                                                                                  //perm:admin
-	StorageGetLocks(ctx context.Context) (storiface.SectorLocks, error)                                                                                          //perm:admin
+	StorageBestAlloc(ctx context.Context, allocate storiface.SectorFileType, ssize abi.SectorSize, pathType storiface.PathType) ([]storiface.StorageInfo, error)           //perm:admin
+	StorageLock(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) error                                             //perm:admin
+	StorageTryLock(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) (bool, error)                                  //perm:admin
+	StorageList(ctx context.Context) (map[storiface.ID][]storiface.Decl, error)                                                                                            //perm:admin
+	StorageGetLocks(ctx context.Context) (storiface.SectorLocks, error)                                                                                                    //perm:admin
 
 	StorageLocal(ctx context.Context) (map[storiface.ID]string, error)       //perm:admin
 	StorageStat(ctx context.Context, id storiface.ID) (fsutil.FsStat, error) //perm:admin
 
-	StorageAuthVerify(ctx context.Context, token string) ([]auth.Permission, error) //perm:read
-
-	StorageAddLocal(ctx context.Context, path string) error                              //perm:admin
-	StorageDetachLocal(ctx context.Context, path string) error                           //perm:admin
-	StorageRedeclareLocal(ctx context.Context, id *storiface.ID, dropMissing bool) error //perm:admin
-
 	MarketImportDealData(ctx context.Context, propcid cid.Cid, path string) error                                                                                                        //perm:write
-	MarketListDeals(ctx context.Context) ([]*MarketDeal, error)                                                                                                                          //perm:read
+	MarketListDeals(ctx context.Context) ([]MarketDeal, error)                                                                                                                           //perm:read
 	MarketListRetrievalDeals(ctx context.Context) ([]retrievalmarket.ProviderDealState, error)                                                                                           //perm:read
 	MarketGetDealUpdates(ctx context.Context) (<-chan storagemarket.MinerDeal, error)                                                                                                    //perm:read
 	MarketListIncompleteDeals(ctx context.Context) ([]storagemarket.MinerDeal, error)                                                                                                    //perm:read
@@ -275,9 +224,6 @@ type StorageMiner interface {
 	// DagstoreGC runs garbage collection on the DAG store.
 	DagstoreGC(ctx context.Context) ([]DagstoreShardResult, error) //perm:admin
 
-	// DagstoreRegisterShard registers a shard manually with dagstore with given pieceCID
-	DagstoreRegisterShard(ctx context.Context, key string) error //perm:admin
-
 	// IndexerAnnounceDeal informs indexer nodes that a new deal was received,
 	// so they can download its index
 	IndexerAnnounceDeal(ctx context.Context, proposalCid cid.Cid) error //perm:admin
@@ -293,7 +239,7 @@ type StorageMiner interface {
 	RuntimeSubsystems(ctx context.Context) (MinerSubsystems, error) //perm:read
 
 	DealsImportData(ctx context.Context, dealPropCid cid.Cid, file string) error //perm:admin
-	DealsList(ctx context.Context) ([]*MarketDeal, error)                        //perm:admin
+	DealsList(ctx context.Context) ([]MarketDeal, error)                         //perm:admin
 	DealsConsiderOnlineStorageDeals(context.Context) (bool, error)               //perm:admin
 	DealsSetConsiderOnlineStorageDeals(context.Context, bool) error              //perm:admin
 	DealsConsiderOnlineRetrievalDeals(context.Context) (bool, error)             //perm:admin
@@ -309,6 +255,8 @@ type StorageMiner interface {
 	DealsConsiderUnverifiedStorageDeals(context.Context) (bool, error)           //perm:admin
 	DealsSetConsiderUnverifiedStorageDeals(context.Context, bool) error          //perm:admin
 
+	StorageAddLocal(ctx context.Context, path string) error //perm:admin
+
 	PiecesListPieces(ctx context.Context) ([]cid.Cid, error)                                 //perm:read
 	PiecesListCidInfos(ctx context.Context) ([]cid.Cid, error)                               //perm:read
 	PiecesGetPieceInfo(ctx context.Context, pieceCid cid.Cid) (*piecestore.PieceInfo, error) //perm:read
@@ -320,14 +268,9 @@ type StorageMiner interface {
 	// the path specified when calling CreateBackup is within the base path
 	CreateBackup(ctx context.Context, fpath string) error //perm:admin
 
-	CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storiface.SectorRef) (map[abi.SectorNumber]string, error) //perm:admin
+	CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storage.SectorRef, expensive bool) (map[abi.SectorNumber]string, error) //perm:admin
 
 	ComputeProof(ctx context.Context, ssi []builtin.ExtendedSectorInfo, rand abi.PoStRandomness, poStEpoch abi.ChainEpoch, nv abinetwork.Version) ([]builtin.PoStProof, error) //perm:read
-
-	// RecoverFault can be used to declare recoveries manually. It sends messages
-	// to the miner actor with details of recovered sectors and returns the CID of messages. It honors the
-	// maxPartitionsPerRecoveryMessage from the config
-	RecoverFault(ctx context.Context, sectors []abi.SectorNumber) ([]cid.Cid, error) //perm:admin
 }
 
 var _ storiface.WorkerReturn = *new(StorageMiner)
@@ -498,119 +441,3 @@ type DagstoreInitializeAllEvent struct {
 	Total   int
 	Current int
 }
-
-type NumAssignerMeta struct {
-	Reserved  bitfield.BitField
-	Allocated bitfield.BitField
-
-	// ChainAllocated+Reserved+Allocated
-	InUse bitfield.BitField
-
-	Next abi.SectorNumber
-}
-
-type RemoteSectorMeta struct {
-	////////
-	// BASIC SECTOR INFORMATION
-
-	// State specifies the first state the sector will enter after being imported
-	// Must be one of the following states:
-	// * Packing
-	// * GetTicket
-	// * PreCommitting
-	// * SubmitCommit
-	// * Proving/Available
-	State SectorState
-
-	Sector abi.SectorID
-	Type   abi.RegisteredSealProof
-
-	////////
-	// SEALING METADATA
-	// (allows lotus to continue the sealing process)
-
-	// Required in Packing and later
-	Pieces []SectorPiece // todo better type?
-
-	// Required in PreCommitting and later
-	TicketValue   abi.SealRandomness
-	TicketEpoch   abi.ChainEpoch
-	PreCommit1Out storiface.PreCommit1Out // todo specify better
-
-	CommD *cid.Cid
-	CommR *cid.Cid // SectorKey
-
-	// Required in SubmitCommit and later
-	PreCommitInfo    *miner.SectorPreCommitInfo
-	PreCommitDeposit *big.Int
-	PreCommitMessage *cid.Cid
-	PreCommitTipSet  types.TipSetKey
-
-	SeedValue abi.InteractiveSealRandomness
-	SeedEpoch abi.ChainEpoch
-
-	CommitProof []byte
-
-	// Required in Proving/Available
-	CommitMessage *cid.Cid
-
-	// Optional sector metadata to import
-	Log []SectorLog
-
-	////////
-	// SECTOR DATA SOURCE
-
-	// Sector urls - lotus will use those for fetching files into local storage
-
-	// Required in all states
-	DataUnsealed *storiface.SectorLocation
-
-	// Required in PreCommitting and later
-	DataSealed *storiface.SectorLocation
-	DataCache  *storiface.SectorLocation
-
-	////////
-	// SEALING SERVICE HOOKS
-
-	// URL
-	// RemoteCommit1Endpoint is an URL of POST endpoint which lotus will call requesting Commit1 (seal_commit_phase1)
-	// request body will be json-serialized RemoteCommit1Params struct
-	RemoteCommit1Endpoint string
-
-	// RemoteCommit2Endpoint is an URL of POST endpoint which lotus will call requesting Commit2 (seal_commit_phase2)
-	// request body will be json-serialized RemoteCommit2Params struct
-	RemoteCommit2Endpoint string
-
-	// RemoteSealingDoneEndpoint is called after the sector exists the sealing pipeline
-	// request body will be json-serialized RemoteSealingDoneParams struct
-	RemoteSealingDoneEndpoint string
-}
-
-type RemoteCommit1Params struct {
-	Ticket, Seed []byte
-
-	Unsealed cid.Cid
-	Sealed   cid.Cid
-
-	ProofType abi.RegisteredSealProof
-}
-
-type RemoteCommit2Params struct {
-	Sector    abi.SectorID
-	ProofType abi.RegisteredSealProof
-
-	// todo spec better
-	Commit1Out storiface.Commit1Out
-}
-
-type RemoteSealingDoneParams struct {
-	// Successful is true if the sector has entered state considered as "successfully sealed"
-	Successful bool
-
-	// State is the state the sector has entered
-	// For example "Proving" / "Removing"
-	State string
-
-	// Optional commit message CID
-	CommitMessage *cid.Cid
-}

api/api_test.go

@@ -1,4 +1,4 @@
-// stm: #unit
+//stm: #unit
 package api
 
 import (
@@ -12,9 +12,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-jsonrpc"
 )
 
 func goCmd() string {
@@ -127,18 +124,3 @@ func TestPermTags(t *testing.T) {
 	_ = PermissionedStorMinerAPI(&StorageMinerStruct{})
 	_ = PermissionedWorkerAPI(&WorkerStruct{})
 }
-
-func TestRetryErrorIsInTrue(t *testing.T) {
-	errorsToRetry := []error{&jsonrpc.RPCConnectionError{}}
-	require.True(t, ErrorIsIn(&jsonrpc.RPCConnectionError{}, errorsToRetry))
-}
-
-func TestRetryErrorIsInFalse(t *testing.T) {
-	errorsToRetry := []error{&jsonrpc.RPCConnectionError{}}
-	require.False(t, ErrorIsIn(xerrors.Errorf("random error"), errorsToRetry))
-}
-
-func TestRetryWrappedErrorIsInTrue(t *testing.T) {
-	errorsToRetry := []error{&jsonrpc.RPCConnectionError{}}
-	require.True(t, ErrorIsIn(xerrors.Errorf("wrapped: %w", &jsonrpc.RPCConnectionError{}), errorsToRetry))
-}

api/api_worker.go

@@ -7,10 +7,11 @@ import (
 	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/proof"
+	"github.com/filecoin-project/specs-actors/v5/actors/runtime/proof"
 
-	"github.com/filecoin-project/lotus/storage/sealer/sealtasks"
-	"github.com/filecoin-project/lotus/storage/sealer/storiface"
+	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	"github.com/filecoin-project/specs-storage/storage"
 )
 
 //                       MODIFYING THE API INTERFACE
@@ -33,23 +34,21 @@ type Worker interface {
 	Info(context.Context) (storiface.WorkerInfo, error)                 //perm:admin
 
 	// storiface.WorkerCalls
-	DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (storiface.CallID, error)                                                                                        //perm:admin
-	AddPiece(ctx context.Context, sector storiface.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (storiface.CallID, error)                    //perm:admin
-	SealPreCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error)                                                             //perm:admin
-	SealPreCommit2(ctx context.Context, sector storiface.SectorRef, pc1o storiface.PreCommit1Out) (storiface.CallID, error)                                                                                  //perm:admin
-	SealCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storiface.SectorCids) (storiface.CallID, error) //perm:admin
-	SealCommit2(ctx context.Context, sector storiface.SectorRef, c1o storiface.Commit1Out) (storiface.CallID, error)                                                                                         //perm:admin
-	FinalizeSector(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) (storiface.CallID, error)                                                                                //perm:admin
-	FinalizeReplicaUpdate(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) (storiface.CallID, error)                                                                         //perm:admin
-	ReplicaUpdate(ctx context.Context, sector storiface.SectorRef, pieces []abi.PieceInfo) (storiface.CallID, error)                                                                                         //perm:admin
-	ProveReplicaUpdate1(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error)                                                                //perm:admin
-	ProveReplicaUpdate2(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storiface.ReplicaVanillaProofs) (storiface.CallID, error)                  //perm:admin
-	GenerateSectorKeyFromData(ctx context.Context, sector storiface.SectorRef, commD cid.Cid) (storiface.CallID, error)                                                                                      //perm:admin
-	ReleaseUnsealed(ctx context.Context, sector storiface.SectorRef, safeToFree []storiface.Range) (storiface.CallID, error)                                                                                 //perm:admin
-	MoveStorage(ctx context.Context, sector storiface.SectorRef, types storiface.SectorFileType) (storiface.CallID, error)                                                                                   //perm:admin
-	UnsealPiece(context.Context, storiface.SectorRef, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) (storiface.CallID, error)                                             //perm:admin
-	Fetch(context.Context, storiface.SectorRef, storiface.SectorFileType, storiface.PathType, storiface.AcquireMode) (storiface.CallID, error)                                                               //perm:admin
-	DownloadSectorData(ctx context.Context, sector storiface.SectorRef, finalized bool, src map[storiface.SectorFileType]storiface.SectorLocation) (storiface.CallID, error)                                 //perm:admin
+	AddPiece(ctx context.Context, sector storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error)                    //perm:admin
+	SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error)                                                           //perm:admin
+	SealPreCommit2(ctx context.Context, sector storage.SectorRef, pc1o storage.PreCommit1Out) (storiface.CallID, error)                                                                                  //perm:admin
+	SealCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storiface.CallID, error) //perm:admin
+	SealCommit2(ctx context.Context, sector storage.SectorRef, c1o storage.Commit1Out) (storiface.CallID, error)                                                                                         //perm:admin
+	FinalizeSector(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error)                                                                                //perm:admin
+	FinalizeReplicaUpdate(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error)                                                                         //perm:admin
+	ReplicaUpdate(ctx context.Context, sector storage.SectorRef, pieces []abi.PieceInfo) (storiface.CallID, error)                                                                                       //perm:admin
+	ProveReplicaUpdate1(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error)                                                              //perm:admin
+	ProveReplicaUpdate2(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storage.ReplicaVanillaProofs) (storiface.CallID, error)                  //perm:admin
+	GenerateSectorKeyFromData(ctx context.Context, sector storage.SectorRef, commD cid.Cid) (storiface.CallID, error)                                                                                    //perm:admin
+	ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) (storiface.CallID, error)                                                                                 //perm:admin
+	MoveStorage(ctx context.Context, sector storage.SectorRef, types storiface.SectorFileType) (storiface.CallID, error)                                                                                 //perm:admin
+	UnsealPiece(context.Context, storage.SectorRef, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) (storiface.CallID, error)                                           //perm:admin
+	Fetch(context.Context, storage.SectorRef, storiface.SectorFileType, storiface.PathType, storiface.AcquireMode) (storiface.CallID, error)                                                             //perm:admin
 
 	GenerateWinningPoSt(ctx context.Context, ppt abi.RegisteredPoStProof, mid abi.ActorID, sectors []storiface.PostSectorChallenge, randomness abi.PoStRandomness) ([]proof.PoStProof, error)                           //perm:admin
 	GenerateWindowPoSt(ctx context.Context, ppt abi.RegisteredPoStProof, mid abi.ActorID, sectors []storiface.PostSectorChallenge, partitionIdx int, randomness abi.PoStRandomness) (storiface.WindowPoStResult, error) //perm:admin
@@ -60,11 +59,7 @@ type Worker interface {
 	// Storage / Other
 	Remove(ctx context.Context, sector abi.SectorID) error //perm:admin
 
-	StorageLocal(ctx context.Context) (map[storiface.ID]string, error)                   //perm:admin
-	StorageAddLocal(ctx context.Context, path string) error                              //perm:admin
-	StorageDetachLocal(ctx context.Context, path string) error                           //perm:admin
-	StorageDetachAll(ctx context.Context) error                                          //perm:admin
-	StorageRedeclareLocal(ctx context.Context, id *storiface.ID, dropMissing bool) error //perm:admin
+	StorageAddLocal(ctx context.Context, path string) error //perm:admin
 
 	// SetEnabled marks the worker as enabled/disabled. Not that this setting
 	// may take a few seconds to propagate to task scheduler
@@ -81,10 +76,6 @@ type Worker interface {
 
 	// Like ProcessSession, but returns an error when worker is disabled
 	Session(context.Context) (uuid.UUID, error) //perm:admin
-
-	// Trigger shutdown
-	Shutdown(context.Context) error //perm:admin
-
 }
 
 var _ storiface.WorkerCalls = *new(Worker)

api/client/client.go

@@ -19,7 +19,7 @@ import (
 func NewCommonRPCV0(ctx context.Context, addr string, requestHeader http.Header) (api.CommonNet, jsonrpc.ClientCloser, error) {
 	var res v0api.CommonNetStruct
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		api.GetInternalStructs(&res), requestHeader, jsonrpc.WithErrors(api.RPCErrors))
+		api.GetInternalStructs(&res), requestHeader)
 
 	return &res, closer, err
 }
@@ -29,7 +29,7 @@ func NewFullNodeRPCV0(ctx context.Context, addr string, requestHeader http.Heade
 	var res v0api.FullNodeStruct
 
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		api.GetInternalStructs(&res), requestHeader, jsonrpc.WithErrors(api.RPCErrors))
+		api.GetInternalStructs(&res), requestHeader)
 
 	return &res, closer, err
 }
@@ -38,7 +38,7 @@ func NewFullNodeRPCV0(ctx context.Context, addr string, requestHeader http.Heade
 func NewFullNodeRPCV1(ctx context.Context, addr string, requestHeader http.Header) (api.FullNode, jsonrpc.ClientCloser, error) {
 	var res v1api.FullNodeStruct
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		api.GetInternalStructs(&res), requestHeader, jsonrpc.WithErrors(api.RPCErrors))
+		api.GetInternalStructs(&res), requestHeader)
 
 	return &res, closer, err
 }
@@ -72,7 +72,6 @@ func NewStorageMinerRPCV0(ctx context.Context, addr string, requestHeader http.H
 		api.GetInternalStructs(&res), requestHeader,
 		append([]jsonrpc.Option{
 			rpcenc.ReaderParamEncoder(pushUrl),
-			jsonrpc.WithErrors(api.RPCErrors),
 		}, opts...)...)
 
 	return &res, closer, err
@@ -91,7 +90,6 @@ func NewWorkerRPCV0(ctx context.Context, addr string, requestHeader http.Header)
 		rpcenc.ReaderParamEncoder(pushUrl),
 		jsonrpc.WithNoReconnect(),
 		jsonrpc.WithTimeout(30*time.Second),
-		jsonrpc.WithErrors(api.RPCErrors),
 	)
 
 	return &res, closer, err
@@ -103,7 +101,7 @@ func NewGatewayRPCV1(ctx context.Context, addr string, requestHeader http.Header
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		api.GetInternalStructs(&res),
 		requestHeader,
-		append(opts, jsonrpc.WithErrors(api.RPCErrors))...,
+		opts...,
 	)
 
 	return &res, closer, err
@@ -115,7 +113,7 @@ func NewGatewayRPCV0(ctx context.Context, addr string, requestHeader http.Header
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		api.GetInternalStructs(&res),
 		requestHeader,
-		append(opts, jsonrpc.WithErrors(api.RPCErrors))...,
+		opts...,
 	)
 
 	return &res, closer, err
@@ -126,7 +124,6 @@ func NewWalletRPCV0(ctx context.Context, addr string, requestHeader http.Header)
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		api.GetInternalStructs(&res),
 		requestHeader,
-		jsonrpc.WithErrors(api.RPCErrors),
 	)
 
 	return &res, closer, err

api/docgen-openrpc/cmd/docgen_openrpc.go

@@ -8,6 +8,7 @@ import (
 	"os"
 
 	"github.com/filecoin-project/lotus/api/docgen"
+
 	docgen_openrpc "github.com/filecoin-project/lotus/api/docgen-openrpc"
 )
 

api/docgen-openrpc/openrpc.go

@@ -8,11 +8,10 @@ import (
 
 	"github.com/alecthomas/jsonschema"
 	go_openrpc_reflect "github.com/etclabscore/go-openrpc-reflect"
-	"github.com/ipfs/go-cid"
-	meta_schema "github.com/open-rpc/meta-schema"
-
 	"github.com/filecoin-project/lotus/api/docgen"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/ipfs/go-cid"
+	meta_schema "github.com/open-rpc/meta-schema"
 )
 
 // schemaDictEntry represents a type association passed to the jsonschema reflector.

api/docgen/docgen.go

@@ -6,33 +6,31 @@ import (
 	"go/ast"
 	"go/parser"
 	"go/token"
-	"net/http"
 	"path/filepath"
 	"reflect"
 	"strings"
 	"time"
 	"unicode"
 
-	"github.com/google/uuid"
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-graphsync"
-	textselector "github.com/ipld/go-ipld-selector-text-lite"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"github.com/libp2p/go-libp2p/core/metrics"
-	"github.com/libp2p/go-libp2p/core/network"
-	"github.com/libp2p/go-libp2p/core/peer"
-	"github.com/libp2p/go-libp2p/core/protocol"
-	"github.com/multiformats/go-multiaddr"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
+	"github.com/google/uuid"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-graphsync"
+	"github.com/libp2p/go-libp2p-core/metrics"
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/libp2p/go-libp2p-core/protocol"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/multiformats/go-multiaddr"
+
 	datatransfer "github.com/filecoin-project/go-data-transfer"
-	"github.com/filecoin-project/go-fil-markets/filestore"
+	filestore "github.com/filecoin-project/go-fil-markets/filestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-jsonrpc/auth"
+	textselector "github.com/ipld/go-ipld-selector-text-lite"
+
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/exitcode"
 
@@ -41,11 +39,11 @@ import (
 	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/repo/imports"
-	sealing "github.com/filecoin-project/lotus/storage/pipeline"
-	"github.com/filecoin-project/lotus/storage/sealer/sealtasks"
-	"github.com/filecoin-project/lotus/storage/sealer/storiface"
 )
 
 var ExampleValues = map[reflect.Type]interface{}{
@@ -97,9 +95,6 @@ func init() {
 	apiSelExample := api.Selector("Links/21/Hash/Links/42/Hash")
 	clientEvent := retrievalmarket.ClientEventDealAccepted
 
-	block := blocks.Block(&blocks.BasicBlock{})
-	ExampleValues[reflect.TypeOf(&block).Elem()] = block
-
 	addExample(bitfield.NewFromSet([]uint64{5}))
 	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1_1)
 	addExample(abi.RegisteredPoStProof_StackedDrgWindow32GiBV1)
@@ -138,15 +133,7 @@ func init() {
 	addExample(&textSelExample)
 	addExample(&apiSelExample)
 	addExample(network.ReachabilityPublic)
-	addExample(build.TestNetworkVersion)
-	allocationId := verifreg.AllocationId(0)
-	addExample(allocationId)
-	addExample(&allocationId)
-	addExample(map[verifreg.AllocationId]verifreg.Allocation{})
-	claimId := verifreg.ClaimId(0)
-	addExample(claimId)
-	addExample(&claimId)
-	addExample(map[verifreg.ClaimId]verifreg.Claim{})
+	addExample(build.NewestNetworkVersion)
 	addExample(map[string]int{"name": 42})
 	addExample(map[string]time.Time{"name": time.Unix(1615243938, 0).UTC()})
 	addExample(&types.ExecutionTrace{
@@ -159,10 +146,6 @@ func init() {
 	addExample(map[string]api.MarketDeal{
 		"t026363": ExampleValue("init", reflect.TypeOf(api.MarketDeal{}), nil).(api.MarketDeal),
 	})
-	addExample(map[string]*api.MarketDeal{
-		"t026363": ExampleValue("init", reflect.TypeOf(&api.MarketDeal{}), nil).(*api.MarketDeal),
-	})
-
 	addExample(map[string]api.MarketBalance{
 		"t026363": ExampleValue("init", reflect.TypeOf(api.MarketBalance{}), nil).(api.MarketBalance),
 	})
@@ -205,7 +188,6 @@ func init() {
 	addExample(&si)
 	addExample(retrievalmarket.DealID(5))
 	addExample(abi.ActorID(1000))
-	addExample(map[string]cid.Cid{})
 	addExample(map[string][]api.SealedRef{
 		"98000": {
 			api.SealedRef{
@@ -282,8 +264,6 @@ func init() {
 			Read:   [storiface.FileTypes]uint{2, 3, 0},
 		},
 	})
-	storifaceid := storiface.ID("1399aa04-2625-44b1-bad4-bd07b59b22c4")
-	addExample(&storifaceid)
 
 	// worker specific
 	addExample(storiface.AcquireMove)
@@ -346,26 +326,7 @@ func init() {
 		Conns:           4,
 		FD:              5,
 	})
-	addExample(map[string]bitfield.BitField{
-		"": bitfield.NewFromSet([]uint64{5, 6, 7, 10}),
-	})
-	addExample(&api.RaftStateData{
-		NonceMap: make(map[address.Address]uint64),
-		MsgUuids: make(map[uuid.UUID]*types.SignedMessage),
-	})
 
-	addExample(http.Header{
-		"Authorization": []string{"Bearer ey.."},
-	})
-
-	addExample(map[storiface.SectorFileType]storiface.SectorLocation{
-		storiface.FTSealed: {
-			Local:   false,
-			URL:     "https://example.com/sealingservice/sectors/s-f0123-12345",
-			Headers: nil,
-		},
-	})
-	addExample(&uuid.UUID{})
 }
 
 func GetAPIType(name, pkg string) (i interface{}, t reflect.Type, permStruct []reflect.Type) {
@@ -389,10 +350,6 @@ func GetAPIType(name, pkg string) (i interface{}, t reflect.Type, permStruct []r
 			i = &api.WorkerStruct{}
 			t = reflect.TypeOf(new(struct{ api.Worker })).Elem()
 			permStruct = append(permStruct, reflect.TypeOf(api.WorkerStruct{}.Internal))
-		case "Gateway":
-			i = &api.GatewayStruct{}
-			t = reflect.TypeOf(new(struct{ api.Gateway })).Elem()
-			permStruct = append(permStruct, reflect.TypeOf(api.GatewayStruct{}.Internal))
 		default:
 			panic("unknown type")
 		}

api/mocks/mock_full.go

@@ -10,36 +10,33 @@ import (
 	reflect "reflect"
 	time "time"
 
-	gomock "github.com/golang/mock/gomock"
-	uuid "github.com/google/uuid"
-	blocks "github.com/ipfs/go-block-format"
-	cid "github.com/ipfs/go-cid"
-	metrics "github.com/libp2p/go-libp2p/core/metrics"
-	network0 "github.com/libp2p/go-libp2p/core/network"
-	peer "github.com/libp2p/go-libp2p/core/peer"
-	protocol "github.com/libp2p/go-libp2p/core/protocol"
-
 	address "github.com/filecoin-project/go-address"
 	bitfield "github.com/filecoin-project/go-bitfield"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	retrievalmarket "github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	storagemarket "github.com/filecoin-project/go-fil-markets/storagemarket"
 	auth "github.com/filecoin-project/go-jsonrpc/auth"
 	abi "github.com/filecoin-project/go-state-types/abi"
 	big "github.com/filecoin-project/go-state-types/big"
-	paych "github.com/filecoin-project/go-state-types/builtin/v8/paych"
-	miner "github.com/filecoin-project/go-state-types/builtin/v9/miner"
-	verifreg "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	crypto "github.com/filecoin-project/go-state-types/crypto"
 	dline "github.com/filecoin-project/go-state-types/dline"
 	network "github.com/filecoin-project/go-state-types/network"
-
 	api "github.com/filecoin-project/lotus/api"
 	apitypes "github.com/filecoin-project/lotus/api/types"
-	miner0 "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	miner "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	types "github.com/filecoin-project/lotus/chain/types"
 	alerting "github.com/filecoin-project/lotus/journal/alerting"
 	dtypes "github.com/filecoin-project/lotus/node/modules/dtypes"
 	imports "github.com/filecoin-project/lotus/node/repo/imports"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	paych "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	gomock "github.com/golang/mock/gomock"
+	uuid "github.com/google/uuid"
+	cid "github.com/ipfs/go-cid"
+	metrics "github.com/libp2p/go-libp2p-core/metrics"
+	network0 "github.com/libp2p/go-libp2p-core/network"
+	peer "github.com/libp2p/go-libp2p-core/peer"
+	protocol "github.com/libp2p/go-libp2p-core/protocol"
 )
 
 // MockFullNode is a mock of FullNode interface.
@@ -95,6 +92,21 @@ func (mr *MockFullNodeMockRecorder) AuthVerify(arg0, arg1 interface{}) *gomock.C
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthVerify", reflect.TypeOf((*MockFullNode)(nil).AuthVerify), arg0, arg1)
 }
 
+// BeaconGetEntry mocks base method.
+func (m *MockFullNode) BeaconGetEntry(arg0 context.Context, arg1 abi.ChainEpoch) (*types.BeaconEntry, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BeaconGetEntry", arg0, arg1)
+	ret0, _ := ret[0].(*types.BeaconEntry)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BeaconGetEntry indicates an expected call of BeaconGetEntry.
+func (mr *MockFullNodeMockRecorder) BeaconGetEntry(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeaconGetEntry", reflect.TypeOf((*MockFullNode)(nil).BeaconGetEntry), arg0, arg1)
+}
+
 // ChainBlockstoreInfo mocks base method.
 func (m *MockFullNode) ChainBlockstoreInfo(arg0 context.Context) (map[string]interface{}, error) {
 	m.ctrl.T.Helper()
@@ -378,34 +390,6 @@ func (mr *MockFullNodeMockRecorder) ChainNotify(arg0 interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainNotify", reflect.TypeOf((*MockFullNode)(nil).ChainNotify), arg0)
 }
 
-// ChainPrune mocks base method.
-func (m *MockFullNode) ChainPrune(arg0 context.Context, arg1 api.PruneOpts) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ChainPrune", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ChainPrune indicates an expected call of ChainPrune.
-func (mr *MockFullNodeMockRecorder) ChainPrune(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainPrune", reflect.TypeOf((*MockFullNode)(nil).ChainPrune), arg0, arg1)
-}
-
-// ChainPutObj mocks base method.
-func (m *MockFullNode) ChainPutObj(arg0 context.Context, arg1 blocks.Block) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ChainPutObj", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ChainPutObj indicates an expected call of ChainPutObj.
-func (mr *MockFullNodeMockRecorder) ChainPutObj(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainPutObj", reflect.TypeOf((*MockFullNode)(nil).ChainPutObj), arg0, arg1)
-}
-
 // ChainReadObj mocks base method.
 func (m *MockFullNode) ChainReadObj(arg0 context.Context, arg1 cid.Cid) ([]byte, error) {
 	m.ctrl.T.Helper()
@@ -762,10 +746,10 @@ func (mr *MockFullNodeMockRecorder) ClientMinerQueryOffer(arg0, arg1, arg2, arg3
 }
 
 // ClientQueryAsk mocks base method.
-func (m *MockFullNode) ClientQueryAsk(arg0 context.Context, arg1 peer.ID, arg2 address.Address) (*api.StorageAsk, error) {
+func (m *MockFullNode) ClientQueryAsk(arg0 context.Context, arg1 peer.ID, arg2 address.Address) (*storagemarket.StorageAsk, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ClientQueryAsk", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*api.StorageAsk)
+	ret0, _ := ret[0].(*storagemarket.StorageAsk)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2244,36 +2228,6 @@ func (mr *MockFullNodeMockRecorder) PaychVoucherSubmit(arg0, arg1, arg2, arg3, a
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaychVoucherSubmit", reflect.TypeOf((*MockFullNode)(nil).PaychVoucherSubmit), arg0, arg1, arg2, arg3, arg4)
 }
 
-// RaftLeader mocks base method.
-func (m *MockFullNode) RaftLeader(arg0 context.Context) (peer.ID, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RaftLeader", arg0)
-	ret0, _ := ret[0].(peer.ID)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RaftLeader indicates an expected call of RaftLeader.
-func (mr *MockFullNodeMockRecorder) RaftLeader(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RaftLeader", reflect.TypeOf((*MockFullNode)(nil).RaftLeader), arg0)
-}
-
-// RaftState mocks base method.
-func (m *MockFullNode) RaftState(arg0 context.Context) (*api.RaftStateData, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RaftState", arg0)
-	ret0, _ := ret[0].(*api.RaftStateData)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// RaftState indicates an expected call of RaftState.
-func (mr *MockFullNodeMockRecorder) RaftState(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RaftState", reflect.TypeOf((*MockFullNode)(nil).RaftState), arg0)
-}
-
 // Session mocks base method.
 func (m *MockFullNode) Session(arg0 context.Context) (uuid.UUID, error) {
 	m.ctrl.T.Helper()
@@ -2303,21 +2257,6 @@ func (mr *MockFullNodeMockRecorder) Shutdown(arg0 interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockFullNode)(nil).Shutdown), arg0)
 }
 
-// StartTime mocks base method.
-func (m *MockFullNode) StartTime(arg0 context.Context) (time.Time, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartTime", arg0)
-	ret0, _ := ret[0].(time.Time)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartTime indicates an expected call of StartTime.
-func (mr *MockFullNodeMockRecorder) StartTime(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTime", reflect.TypeOf((*MockFullNode)(nil).StartTime), arg0)
-}
-
 // StateAccountKey mocks base method.
 func (m *MockFullNode) StateAccountKey(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (address.Address, error) {
 	m.ctrl.T.Helper()
@@ -2333,36 +2272,6 @@ func (mr *MockFullNodeMockRecorder) StateAccountKey(arg0, arg1, arg2 interface{}
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateAccountKey", reflect.TypeOf((*MockFullNode)(nil).StateAccountKey), arg0, arg1, arg2)
 }
 
-// StateActorCodeCIDs mocks base method.
-func (m *MockFullNode) StateActorCodeCIDs(arg0 context.Context, arg1 network.Version) (map[string]cid.Cid, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateActorCodeCIDs", arg0, arg1)
-	ret0, _ := ret[0].(map[string]cid.Cid)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateActorCodeCIDs indicates an expected call of StateActorCodeCIDs.
-func (mr *MockFullNodeMockRecorder) StateActorCodeCIDs(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateActorCodeCIDs", reflect.TypeOf((*MockFullNode)(nil).StateActorCodeCIDs), arg0, arg1)
-}
-
-// StateActorManifestCID mocks base method.
-func (m *MockFullNode) StateActorManifestCID(arg0 context.Context, arg1 network.Version) (cid.Cid, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateActorManifestCID", arg0, arg1)
-	ret0, _ := ret[0].(cid.Cid)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateActorManifestCID indicates an expected call of StateActorManifestCID.
-func (mr *MockFullNodeMockRecorder) StateActorManifestCID(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateActorManifestCID", reflect.TypeOf((*MockFullNode)(nil).StateActorManifestCID), arg0, arg1)
-}
-
 // StateAllMinerFaults mocks base method.
 func (m *MockFullNode) StateAllMinerFaults(arg0 context.Context, arg1 abi.ChainEpoch, arg2 types.TipSetKey) ([]*api.Fault, error) {
 	m.ctrl.T.Helper()
@@ -2438,21 +2347,6 @@ func (mr *MockFullNodeMockRecorder) StateCompute(arg0, arg1, arg2, arg3 interfac
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateCompute", reflect.TypeOf((*MockFullNode)(nil).StateCompute), arg0, arg1, arg2, arg3)
 }
 
-// StateComputeDataCID mocks base method.
-func (m *MockFullNode) StateComputeDataCID(arg0 context.Context, arg1 address.Address, arg2 abi.RegisteredSealProof, arg3 []abi.DealID, arg4 types.TipSetKey) (cid.Cid, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateComputeDataCID", arg0, arg1, arg2, arg3, arg4)
-	ret0, _ := ret[0].(cid.Cid)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateComputeDataCID indicates an expected call of StateComputeDataCID.
-func (mr *MockFullNodeMockRecorder) StateComputeDataCID(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateComputeDataCID", reflect.TypeOf((*MockFullNode)(nil).StateComputeDataCID), arg0, arg1, arg2, arg3, arg4)
-}
-
 // StateDealProviderCollateralBounds mocks base method.
 func (m *MockFullNode) StateDealProviderCollateralBounds(arg0 context.Context, arg1 abi.PaddedPieceSize, arg2 bool, arg3 types.TipSetKey) (api.DealCollateralBounds, error) {
 	m.ctrl.T.Helper()
@@ -2513,111 +2407,6 @@ func (mr *MockFullNodeMockRecorder) StateGetActor(arg0, arg1, arg2 interface{})
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetActor", reflect.TypeOf((*MockFullNode)(nil).StateGetActor), arg0, arg1, arg2)
 }
 
-// StateGetAllocation mocks base method.
-func (m *MockFullNode) StateGetAllocation(arg0 context.Context, arg1 address.Address, arg2 verifreg.AllocationId, arg3 types.TipSetKey) (*verifreg.Allocation, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetAllocation", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*verifreg.Allocation)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetAllocation indicates an expected call of StateGetAllocation.
-func (mr *MockFullNodeMockRecorder) StateGetAllocation(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetAllocation", reflect.TypeOf((*MockFullNode)(nil).StateGetAllocation), arg0, arg1, arg2, arg3)
-}
-
-// StateGetAllocationForPendingDeal mocks base method.
-func (m *MockFullNode) StateGetAllocationForPendingDeal(arg0 context.Context, arg1 abi.DealID, arg2 types.TipSetKey) (*verifreg.Allocation, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetAllocationForPendingDeal", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*verifreg.Allocation)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetAllocationForPendingDeal indicates an expected call of StateGetAllocationForPendingDeal.
-func (mr *MockFullNodeMockRecorder) StateGetAllocationForPendingDeal(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetAllocationForPendingDeal", reflect.TypeOf((*MockFullNode)(nil).StateGetAllocationForPendingDeal), arg0, arg1, arg2)
-}
-
-// StateGetAllocations mocks base method.
-func (m *MockFullNode) StateGetAllocations(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (map[verifreg.AllocationId]verifreg.Allocation, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetAllocations", arg0, arg1, arg2)
-	ret0, _ := ret[0].(map[verifreg.AllocationId]verifreg.Allocation)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetAllocations indicates an expected call of StateGetAllocations.
-func (mr *MockFullNodeMockRecorder) StateGetAllocations(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetAllocations", reflect.TypeOf((*MockFullNode)(nil).StateGetAllocations), arg0, arg1, arg2)
-}
-
-// StateGetBeaconEntry mocks base method.
-func (m *MockFullNode) StateGetBeaconEntry(arg0 context.Context, arg1 abi.ChainEpoch) (*types.BeaconEntry, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetBeaconEntry", arg0, arg1)
-	ret0, _ := ret[0].(*types.BeaconEntry)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetBeaconEntry indicates an expected call of StateGetBeaconEntry.
-func (mr *MockFullNodeMockRecorder) StateGetBeaconEntry(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetBeaconEntry", reflect.TypeOf((*MockFullNode)(nil).StateGetBeaconEntry), arg0, arg1)
-}
-
-// StateGetClaim mocks base method.
-func (m *MockFullNode) StateGetClaim(arg0 context.Context, arg1 address.Address, arg2 verifreg.ClaimId, arg3 types.TipSetKey) (*verifreg.Claim, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetClaim", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*verifreg.Claim)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetClaim indicates an expected call of StateGetClaim.
-func (mr *MockFullNodeMockRecorder) StateGetClaim(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetClaim", reflect.TypeOf((*MockFullNode)(nil).StateGetClaim), arg0, arg1, arg2, arg3)
-}
-
-// StateGetClaims mocks base method.
-func (m *MockFullNode) StateGetClaims(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (map[verifreg.ClaimId]verifreg.Claim, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetClaims", arg0, arg1, arg2)
-	ret0, _ := ret[0].(map[verifreg.ClaimId]verifreg.Claim)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetClaims indicates an expected call of StateGetClaims.
-func (mr *MockFullNodeMockRecorder) StateGetClaims(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetClaims", reflect.TypeOf((*MockFullNode)(nil).StateGetClaims), arg0, arg1, arg2)
-}
-
-// StateGetNetworkParams mocks base method.
-func (m *MockFullNode) StateGetNetworkParams(arg0 context.Context) (*api.NetworkParams, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetNetworkParams", arg0)
-	ret0, _ := ret[0].(*api.NetworkParams)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetNetworkParams indicates an expected call of StateGetNetworkParams.
-func (mr *MockFullNodeMockRecorder) StateGetNetworkParams(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetNetworkParams", reflect.TypeOf((*MockFullNode)(nil).StateGetNetworkParams), arg0)
-}
-
 // StateGetRandomnessFromBeacon mocks base method.
 func (m *MockFullNode) StateGetRandomnessFromBeacon(arg0 context.Context, arg1 crypto.DomainSeparationTag, arg2 abi.ChainEpoch, arg3 []byte, arg4 types.TipSetKey) (abi.Randomness, error) {
 	m.ctrl.T.Helper()
@@ -2708,21 +2497,6 @@ func (mr *MockFullNodeMockRecorder) StateLookupID(arg0, arg1, arg2 interface{})
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateLookupID", reflect.TypeOf((*MockFullNode)(nil).StateLookupID), arg0, arg1, arg2)
 }
 
-// StateLookupRobustAddress mocks base method.
-func (m *MockFullNode) StateLookupRobustAddress(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (address.Address, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateLookupRobustAddress", arg0, arg1, arg2)
-	ret0, _ := ret[0].(address.Address)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateLookupRobustAddress indicates an expected call of StateLookupRobustAddress.
-func (mr *MockFullNodeMockRecorder) StateLookupRobustAddress(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateLookupRobustAddress", reflect.TypeOf((*MockFullNode)(nil).StateLookupRobustAddress), arg0, arg1, arg2)
-}
-
 // StateMarketBalance mocks base method.
 func (m *MockFullNode) StateMarketBalance(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (api.MarketBalance, error) {
 	m.ctrl.T.Helper()
@@ -2739,10 +2513,10 @@ func (mr *MockFullNodeMockRecorder) StateMarketBalance(arg0, arg1, arg2 interfac
 }
 
 // StateMarketDeals mocks base method.
-func (m *MockFullNode) StateMarketDeals(arg0 context.Context, arg1 types.TipSetKey) (map[string]*api.MarketDeal, error) {
+func (m *MockFullNode) StateMarketDeals(arg0 context.Context, arg1 types.TipSetKey) (map[string]api.MarketDeal, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateMarketDeals", arg0, arg1)
-	ret0, _ := ret[0].(map[string]*api.MarketDeal)
+	ret0, _ := ret[0].(map[string]api.MarketDeal)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2798,21 +2572,6 @@ func (mr *MockFullNodeMockRecorder) StateMinerActiveSectors(arg0, arg1, arg2 int
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateMinerActiveSectors", reflect.TypeOf((*MockFullNode)(nil).StateMinerActiveSectors), arg0, arg1, arg2)
 }
 
-// StateMinerAllocated mocks base method.
-func (m *MockFullNode) StateMinerAllocated(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (*bitfield.BitField, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateMinerAllocated", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*bitfield.BitField)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateMinerAllocated indicates an expected call of StateMinerAllocated.
-func (mr *MockFullNodeMockRecorder) StateMinerAllocated(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateMinerAllocated", reflect.TypeOf((*MockFullNode)(nil).StateMinerAllocated), arg0, arg1, arg2)
-}
-
 // StateMinerAvailableBalance mocks base method.
 func (m *MockFullNode) StateMinerAvailableBalance(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (big.Int, error) {
 	m.ctrl.T.Helper()
@@ -2859,10 +2618,10 @@ func (mr *MockFullNodeMockRecorder) StateMinerFaults(arg0, arg1, arg2 interface{
 }
 
 // StateMinerInfo mocks base method.
-func (m *MockFullNode) StateMinerInfo(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (api.MinerInfo, error) {
+func (m *MockFullNode) StateMinerInfo(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (miner.MinerInfo, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateMinerInfo", arg0, arg1, arg2)
-	ret0, _ := ret[0].(api.MinerInfo)
+	ret0, _ := ret[0].(miner.MinerInfo)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2874,7 +2633,7 @@ func (mr *MockFullNodeMockRecorder) StateMinerInfo(arg0, arg1, arg2 interface{})
 }
 
 // StateMinerInitialPledgeCollateral mocks base method.
-func (m *MockFullNode) StateMinerInitialPledgeCollateral(arg0 context.Context, arg1 address.Address, arg2 miner.SectorPreCommitInfo, arg3 types.TipSetKey) (big.Int, error) {
+func (m *MockFullNode) StateMinerInitialPledgeCollateral(arg0 context.Context, arg1 address.Address, arg2 miner0.SectorPreCommitInfo, arg3 types.TipSetKey) (big.Int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateMinerInitialPledgeCollateral", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(big.Int)
@@ -2919,7 +2678,7 @@ func (mr *MockFullNodeMockRecorder) StateMinerPower(arg0, arg1, arg2 interface{}
 }
 
 // StateMinerPreCommitDepositForPower mocks base method.
-func (m *MockFullNode) StateMinerPreCommitDepositForPower(arg0 context.Context, arg1 address.Address, arg2 miner.SectorPreCommitInfo, arg3 types.TipSetKey) (big.Int, error) {
+func (m *MockFullNode) StateMinerPreCommitDepositForPower(arg0 context.Context, arg1 address.Address, arg2 miner0.SectorPreCommitInfo, arg3 types.TipSetKey) (big.Int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateMinerPreCommitDepositForPower", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(big.Int)
@@ -3084,10 +2843,10 @@ func (mr *MockFullNodeMockRecorder) StateSearchMsg(arg0, arg1, arg2, arg3, arg4
 }
 
 // StateSectorExpiration mocks base method.
-func (m *MockFullNode) StateSectorExpiration(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner0.SectorExpiration, error) {
+func (m *MockFullNode) StateSectorExpiration(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner.SectorExpiration, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateSectorExpiration", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*miner0.SectorExpiration)
+	ret0, _ := ret[0].(*miner.SectorExpiration)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -3114,10 +2873,10 @@ func (mr *MockFullNodeMockRecorder) StateSectorGetInfo(arg0, arg1, arg2, arg3 in
 }
 
 // StateSectorPartition mocks base method.
-func (m *MockFullNode) StateSectorPartition(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner0.SectorLocation, error) {
+func (m *MockFullNode) StateSectorPartition(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner.SectorLocation, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateSectorPartition", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*miner0.SectorLocation)
+	ret0, _ := ret[0].(*miner.SectorLocation)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -3129,10 +2888,10 @@ func (mr *MockFullNodeMockRecorder) StateSectorPartition(arg0, arg1, arg2, arg3
 }
 
 // StateSectorPreCommitInfo mocks base method.
-func (m *MockFullNode) StateSectorPreCommitInfo(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner.SectorPreCommitOnChainInfo, error) {
+func (m *MockFullNode) StateSectorPreCommitInfo(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateSectorPreCommitInfo", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*miner.SectorPreCommitOnChainInfo)
+	ret0, _ := ret[0].(miner.SectorPreCommitOnChainInfo)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }

api/proxy_util_test.go

@@ -1,4 +1,4 @@
-// stm: #unit
+//stm: #unit
 package api
 
 import (

api/types.go

@@ -5,24 +5,22 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/google/uuid"
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-graphsync"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"github.com/libp2p/go-libp2p/core/network"
-	"github.com/libp2p/go-libp2p/core/peer"
-	ma "github.com/multiformats/go-multiaddr"
+	"github.com/libp2p/go-libp2p-core/network"
 
-	"github.com/filecoin-project/go-address"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/builtin/v9/miner"
-
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-graphsync"
+
+	"github.com/libp2p/go-libp2p-core/peer"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	ma "github.com/multiformats/go-multiaddr"
 )
 
+// TODO: check if this exists anywhere else
+
 type MultiaddrSlice []ma.Multiaddr
 
 func (m *MultiaddrSlice) UnmarshalJSON(raw []byte) (err error) {
@@ -55,13 +53,7 @@ type PubsubScore struct {
 }
 
 type MessageSendSpec struct {
-	MaxFee  abi.TokenAmount
-	MsgUuid uuid.UUID
-}
-
-type MpoolMessageWhole struct {
-	Msg  *types.Message
-	Spec *MessageSendSpec
+	MaxFee abi.TokenAmount
 }
 
 // GraphSyncDataTransfer provides diagnostics on a data transfer happening over graphsync
@@ -142,7 +134,13 @@ type NetStat struct {
 }
 
 type NetLimit struct {
+	Dynamic bool `json:",omitempty"`
+	// set if Dynamic is false
 	Memory int64 `json:",omitempty"`
+	// set if Dynamic is true
+	MemoryFraction float64 `json:",omitempty"`
+	MinMemory      int64   `json:",omitempty"`
+	MaxMemory      int64   `json:",omitempty"`
 
 	Streams, StreamsInbound, StreamsOutbound int
 	Conns, ConnsInbound, ConnsOutbound       int
@@ -254,10 +252,10 @@ type RestrievalRes struct {
 }
 
 // Selector specifies ipld selector string
-//   - if the string starts with '{', it's interpreted as json selector string
-//     see https://ipld.io/specs/selectors/ and https://ipld.io/specs/selectors/fixtures/selector-fixtures-1/
-//   - otherwise the string is interpreted as ipld-selector-text-lite (simple ipld path)
-//     see https://github.com/ipld/go-ipld-selector-text-lite
+// - if the string starts with '{', it's interpreted as json selector string
+//   see https://ipld.io/specs/selectors/ and https://ipld.io/specs/selectors/fixtures/selector-fixtures-1/
+// - otherwise the string is interpreted as ipld-selector-text-lite (simple ipld path)
+//   see https://github.com/ipld/go-ipld-selector-text-lite
 type Selector string
 
 type DagSpec struct {
@@ -288,112 +286,3 @@ type ExportRef struct {
 	FromLocalCAR string // if specified, get data from a local CARv2 file.
 	DealID       retrievalmarket.DealID
 }
-
-type MinerInfo struct {
-	Owner                      address.Address   // Must be an ID-address.
-	Worker                     address.Address   // Must be an ID-address.
-	NewWorker                  address.Address   // Must be an ID-address.
-	ControlAddresses           []address.Address // Must be an ID-addresses.
-	WorkerChangeEpoch          abi.ChainEpoch
-	PeerId                     *peer.ID
-	Multiaddrs                 []abi.Multiaddrs
-	WindowPoStProofType        abi.RegisteredPoStProof
-	SectorSize                 abi.SectorSize
-	WindowPoStPartitionSectors uint64
-	ConsensusFaultElapsed      abi.ChainEpoch
-	Beneficiary                address.Address
-	BeneficiaryTerm            *miner.BeneficiaryTerm
-	PendingBeneficiaryTerm     *miner.PendingBeneficiaryChange
-}
-
-type NetworkParams struct {
-	NetworkName             dtypes.NetworkName
-	BlockDelaySecs          uint64
-	ConsensusMinerMinPower  abi.StoragePower
-	SupportedProofTypes     []abi.RegisteredSealProof
-	PreCommitChallengeDelay abi.ChainEpoch
-	ForkUpgradeParams       ForkUpgradeParams
-}
-
-type ForkUpgradeParams struct {
-	UpgradeSmokeHeight         abi.ChainEpoch
-	UpgradeBreezeHeight        abi.ChainEpoch
-	UpgradeIgnitionHeight      abi.ChainEpoch
-	UpgradeLiftoffHeight       abi.ChainEpoch
-	UpgradeAssemblyHeight      abi.ChainEpoch
-	UpgradeRefuelHeight        abi.ChainEpoch
-	UpgradeTapeHeight          abi.ChainEpoch
-	UpgradeKumquatHeight       abi.ChainEpoch
-	UpgradePriceListOopsHeight abi.ChainEpoch
-	BreezeGasTampingDuration   abi.ChainEpoch
-	UpgradeCalicoHeight        abi.ChainEpoch
-	UpgradePersianHeight       abi.ChainEpoch
-	UpgradeOrangeHeight        abi.ChainEpoch
-	UpgradeClausHeight         abi.ChainEpoch
-	UpgradeTrustHeight         abi.ChainEpoch
-	UpgradeNorwegianHeight     abi.ChainEpoch
-	UpgradeTurboHeight         abi.ChainEpoch
-	UpgradeHyperdriveHeight    abi.ChainEpoch
-	UpgradeChocolateHeight     abi.ChainEpoch
-	UpgradeOhSnapHeight        abi.ChainEpoch
-	UpgradeSkyrHeight          abi.ChainEpoch
-	UpgradeSharkHeight         abi.ChainEpoch
-}
-
-type NonceMapType map[address.Address]uint64
-type MsgUuidMapType map[uuid.UUID]*types.SignedMessage
-
-type RaftStateData struct {
-	NonceMap NonceMapType
-	MsgUuids MsgUuidMapType
-}
-
-func (n *NonceMapType) MarshalJSON() ([]byte, error) {
-	marshalled := make(map[string]uint64)
-	for a, n := range *n {
-		marshalled[a.String()] = n
-	}
-	return json.Marshal(marshalled)
-}
-
-func (n *NonceMapType) UnmarshalJSON(b []byte) error {
-	unmarshalled := make(map[string]uint64)
-	err := json.Unmarshal(b, &unmarshalled)
-	if err != nil {
-		return err
-	}
-	*n = make(map[address.Address]uint64)
-	for saddr, nonce := range unmarshalled {
-		a, err := address.NewFromString(saddr)
-		if err != nil {
-			return err
-		}
-		(*n)[a] = nonce
-	}
-	return nil
-}
-
-func (m *MsgUuidMapType) MarshalJSON() ([]byte, error) {
-	marshalled := make(map[string]*types.SignedMessage)
-	for u, msg := range *m {
-		marshalled[u.String()] = msg
-	}
-	return json.Marshal(marshalled)
-}
-
-func (m *MsgUuidMapType) UnmarshalJSON(b []byte) error {
-	unmarshalled := make(map[string]*types.SignedMessage)
-	err := json.Unmarshal(b, &unmarshalled)
-	if err != nil {
-		return err
-	}
-	*m = make(map[uuid.UUID]*types.SignedMessage)
-	for suid, msg := range unmarshalled {
-		u, err := uuid.Parse(suid)
-		if err != nil {
-			return err
-		}
-		(*m)[u] = msg
-	}
-	return nil
-}

api/v0api/full.go

@@ -3,27 +3,22 @@ package v0api
 import (
 	"context"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	textselector "github.com/ipld/go-ipld-selector-text-lite"
-	"github.com/libp2p/go-libp2p/core/peer"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/builtin/v8/paych"
-	"github.com/filecoin-project/go-state-types/builtin/v9/miner"
-	verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/dline"
-	abinetwork "github.com/filecoin-project/go-state-types/network"
+	"github.com/ipfs/go-cid"
+	textselector "github.com/ipld/go-ipld-selector-text-lite"
+	"github.com/libp2p/go-libp2p-core/peer"
 
 	"github.com/filecoin-project/lotus/api"
 	apitypes "github.com/filecoin-project/lotus/api/types"
-	lminer "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/types"
 	marketevents "github.com/filecoin-project/lotus/markets/loggers"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
@@ -114,9 +109,6 @@ type FullNode interface {
 	// ChainDeleteObj deletes node referenced by the given CID
 	ChainDeleteObj(context.Context, cid.Cid) error //perm:admin
 
-	// ChainPutObj puts and object into the blockstore
-	ChainPutObj(context.Context, blocks.Block) error
-
 	// ChainHasObj checks if a given CID exists in the chain blockstore.
 	ChainHasObj(context.Context, cid.Cid) (bool, error) //perm:read
 
@@ -387,7 +379,7 @@ type FullNode interface {
 	StateCall(context.Context, *types.Message, types.TipSetKey) (*api.InvocResult, error) //perm:read
 	// StateReplay replays a given message, assuming it was included in a block in the specified tipset.
 	//
-	// If a tipset key is provided, and a replacing message is not found on chain,
+	// If a tipset key is provided, and a replacing message is found on chain,
 	// the method will return an error saying that the message wasn't found
 	//
 	// If no tipset key is provided, the appropriate tipset is looked up, and if
@@ -424,7 +416,7 @@ type FullNode interface {
 	// StateMinerPower returns the power of the indicated miner
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error) //perm:read
 	// StateMinerInfo returns info about the indicated miner
-	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (api.MinerInfo, error) //perm:read
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error) //perm:read
 	// StateMinerDeadlines returns all the proving deadlines for the given miner
 	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]api.Deadline, error) //perm:read
 	// StateMinerPartitions returns all partitions in the specified deadline
@@ -450,9 +442,9 @@ type FullNode interface {
 	// expiration epoch
 	StateSectorGetInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorOnChainInfo, error) //perm:read
 	// StateSectorExpiration returns epoch at which given sector will expire
-	StateSectorExpiration(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*lminer.SectorExpiration, error) //perm:read
+	StateSectorExpiration(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorExpiration, error) //perm:read
 	// StateSectorPartition finds deadline/partition with the specified sector
-	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*lminer.SectorLocation, error) //perm:read
+	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*miner.SectorLocation, error) //perm:read
 	// StateSearchMsg searches for a message in the chain, and returns its receipt and the tipset where it was executed
 	//
 	// NOTE: If a replacing message is found on chain, this method will return
@@ -529,19 +521,9 @@ type FullNode interface {
 	// StateMarketParticipants returns the Escrow and Locked balances of every participant in the Storage Market
 	StateMarketParticipants(context.Context, types.TipSetKey) (map[string]api.MarketBalance, error) //perm:read
 	// StateMarketDeals returns information about every deal in the Storage Market
-	StateMarketDeals(context.Context, types.TipSetKey) (map[string]*api.MarketDeal, error) //perm:read
+	StateMarketDeals(context.Context, types.TipSetKey) (map[string]api.MarketDeal, error) //perm:read
 	// StateMarketStorageDeal returns information about the indicated deal
 	StateMarketStorageDeal(context.Context, abi.DealID, types.TipSetKey) (*api.MarketDeal, error) //perm:read
-	// StateGetAllocationForPendingDeal returns the allocation for a given deal ID of a pending deal.
-	StateGetAllocationForPendingDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*verifregtypes.Allocation, error) //perm:read
-	// StateGetAllocation returns the allocation for a given address and allocation ID.
-	StateGetAllocation(ctx context.Context, clientAddr address.Address, allocationId verifregtypes.AllocationId, tsk types.TipSetKey) (*verifregtypes.Allocation, error) //perm:read
-	// StateGetAllocations returns the all the allocations for a given client.
-	StateGetAllocations(ctx context.Context, clientAddr address.Address, tsk types.TipSetKey) (map[verifregtypes.AllocationId]verifregtypes.Allocation, error) //perm:read
-	// StateGetClaim returns the claim for a given address and claim ID.
-	StateGetClaim(ctx context.Context, providerAddr address.Address, claimId verifregtypes.ClaimId, tsk types.TipSetKey) (*verifregtypes.Claim, error) //perm:read
-	// StateGetClaims returns the all the claims for a given provider.
-	StateGetClaims(ctx context.Context, providerAddr address.Address, tsk types.TipSetKey) (map[verifregtypes.ClaimId]verifregtypes.Claim, error) //perm:read
 	// StateLookupID retrieves the ID address of the given address
 	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error) //perm:read
 	// StateAccountKey returns the public key address of the given ID address
@@ -602,7 +584,7 @@ type FullNode interface {
 	// Returns nil if there is no entry in the data cap table for the
 	// address.
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) //perm:read
-	// StateVerifiedRegistryRootKey returns the address of the Verified Registry's root key
+	// StateVerifiedClientStatus returns the address of the Verified Registry's root key
 	StateVerifiedRegistryRootKey(ctx context.Context, tsk types.TipSetKey) (address.Address, error) //perm:read
 	// StateDealProviderCollateralBounds returns the min and max collateral a storage provider
 	// can issue. It takes the deal size and verified status as parameters.
@@ -616,19 +598,12 @@ type FullNode interface {
 	StateVMCirculatingSupplyInternal(context.Context, types.TipSetKey) (api.CirculatingSupply, error) //perm:read
 	// StateNetworkVersion returns the network version at the given tipset
 	StateNetworkVersion(context.Context, types.TipSetKey) (apitypes.NetworkVersion, error) //perm:read
-	// StateActorCodeCIDs returns the CIDs of all the builtin actors for the given network version
-	StateActorCodeCIDs(context.Context, abinetwork.Version) (map[string]cid.Cid, error) //perm:read
-	// StateActorManifestCID returns the CID of the builtin actors manifest for the given network version
-	StateActorManifestCID(context.Context, abinetwork.Version) (cid.Cid, error) //perm:read
 
 	// StateGetRandomnessFromTickets is used to sample the chain for randomness.
 	StateGetRandomnessFromTickets(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) //perm:read
 	// StateGetRandomnessFromBeacon is used to sample the beacon for randomness.
 	StateGetRandomnessFromBeacon(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) //perm:read
 
-	// StateGetNetworkParams return current network params
-	StateGetNetworkParams(ctx context.Context) (*api.NetworkParams, error) //perm:read
-
 	// MethodGroup: Msig
 	// The Msig methods are used to interact with multisig wallets on the
 	// filecoin network

api/v0api/gateway.go

@@ -3,16 +3,15 @@ package v0api
 import (
 	"context"
 
-	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/builtin/v9/miner"
 	"github.com/filecoin-project/go-state-types/dline"
 	abinetwork "github.com/filecoin-project/go-state-types/network"
 
 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
@@ -35,7 +34,6 @@ import (
 
 type Gateway interface {
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
-	ChainPutObj(context.Context, blocks.Block) error
 	ChainHead(ctx context.Context) (*types.TipSet, error)
 	ChainGetBlockMessages(context.Context, cid.Cid) (*api.BlockMessages, error)
 	ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Message, error)
@@ -56,7 +54,7 @@ type Gateway interface {
 	StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 	StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MarketBalance, error)
 	StateMarketStorageDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error)
-	StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (api.MinerInfo, error)
+	StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error)
 	StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error)
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error)
 	StateNetworkVersion(context.Context, types.TipSetKey) (abinetwork.Version, error)

api/v0api/permissioned.go

@@ -2,7 +2,6 @@ package v0api
 
 import (
 	"github.com/filecoin-project/go-jsonrpc/auth"
-
 	"github.com/filecoin-project/lotus/api"
 )
 

api/v0api/proxy_gen.go

@@ -5,31 +5,26 @@ package v0api
 import (
 	"context"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	"github.com/libp2p/go-libp2p/core/peer"
-	"golang.org/x/xerrors"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/builtin/v8/paych"
-	"github.com/filecoin-project/go-state-types/builtin/v9/miner"
-	verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/dline"
 	abinetwork "github.com/filecoin-project/go-state-types/network"
-
 	"github.com/filecoin-project/lotus/api"
 	apitypes "github.com/filecoin-project/lotus/api/types"
-	lminer "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/types"
 	marketevents "github.com/filecoin-project/lotus/markets/loggers"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/repo/imports"
+	"github.com/ipfs/go-cid"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"golang.org/x/xerrors"
 )
 
 var ErrNotSupported = xerrors.New("method not supported")
@@ -78,8 +73,6 @@ type FullNodeStruct struct {
 
 		ChainNotify func(p0 context.Context) (<-chan []*api.HeadChange, error) `perm:"read"`
 
-		ChainPutObj func(p0 context.Context, p1 blocks.Block) error ``
-
 		ChainReadObj func(p0 context.Context, p1 cid.Cid) ([]byte, error) `perm:"read"`
 
 		ChainSetHead func(p0 context.Context, p1 types.TipSetKey) error `perm:"admin"`
@@ -258,10 +251,6 @@ type FullNodeStruct struct {
 
 		StateAccountKey func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (address.Address, error) `perm:"read"`
 
-		StateActorCodeCIDs func(p0 context.Context, p1 abinetwork.Version) (map[string]cid.Cid, error) `perm:"read"`
-
-		StateActorManifestCID func(p0 context.Context, p1 abinetwork.Version) (cid.Cid, error) `perm:"read"`
-
 		StateAllMinerFaults func(p0 context.Context, p1 abi.ChainEpoch, p2 types.TipSetKey) ([]*api.Fault, error) `perm:"read"`
 
 		StateCall func(p0 context.Context, p1 *types.Message, p2 types.TipSetKey) (*api.InvocResult, error) `perm:"read"`
@@ -278,18 +267,6 @@ type FullNodeStruct struct {
 
 		StateGetActor func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*types.Actor, error) `perm:"read"`
 
-		StateGetAllocation func(p0 context.Context, p1 address.Address, p2 verifregtypes.AllocationId, p3 types.TipSetKey) (*verifregtypes.Allocation, error) `perm:"read"`
-
-		StateGetAllocationForPendingDeal func(p0 context.Context, p1 abi.DealID, p2 types.TipSetKey) (*verifregtypes.Allocation, error) `perm:"read"`
-
-		StateGetAllocations func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (map[verifregtypes.AllocationId]verifregtypes.Allocation, error) `perm:"read"`
-
-		StateGetClaim func(p0 context.Context, p1 address.Address, p2 verifregtypes.ClaimId, p3 types.TipSetKey) (*verifregtypes.Claim, error) `perm:"read"`
-
-		StateGetClaims func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (map[verifregtypes.ClaimId]verifregtypes.Claim, error) `perm:"read"`
-
-		StateGetNetworkParams func(p0 context.Context) (*api.NetworkParams, error) `perm:"read"`
-
 		StateGetRandomnessFromBeacon func(p0 context.Context, p1 crypto.DomainSeparationTag, p2 abi.ChainEpoch, p3 []byte, p4 types.TipSetKey) (abi.Randomness, error) `perm:"read"`
 
 		StateGetRandomnessFromTickets func(p0 context.Context, p1 crypto.DomainSeparationTag, p2 abi.ChainEpoch, p3 []byte, p4 types.TipSetKey) (abi.Randomness, error) `perm:"read"`
@@ -306,7 +283,7 @@ type FullNodeStruct struct {
 
 		StateMarketBalance func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (api.MarketBalance, error) `perm:"read"`
 
-		StateMarketDeals func(p0 context.Context, p1 types.TipSetKey) (map[string]*api.MarketDeal, error) `perm:"read"`
+		StateMarketDeals func(p0 context.Context, p1 types.TipSetKey) (map[string]api.MarketDeal, error) `perm:"read"`
 
 		StateMarketParticipants func(p0 context.Context, p1 types.TipSetKey) (map[string]api.MarketBalance, error) `perm:"read"`
 
@@ -320,7 +297,7 @@ type FullNodeStruct struct {
 
 		StateMinerFaults func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (bitfield.BitField, error) `perm:"read"`
 
-		StateMinerInfo func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (api.MinerInfo, error) `perm:"read"`
+		StateMinerInfo func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (miner.MinerInfo, error) `perm:"read"`
 
 		StateMinerInitialPledgeCollateral func(p0 context.Context, p1 address.Address, p2 miner.SectorPreCommitInfo, p3 types.TipSetKey) (types.BigInt, error) `perm:"read"`
 
@@ -352,11 +329,11 @@ type FullNodeStruct struct {
 
 		StateSearchMsgLimited func(p0 context.Context, p1 cid.Cid, p2 abi.ChainEpoch) (*api.MsgLookup, error) `perm:"read"`
 
-		StateSectorExpiration func(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*lminer.SectorExpiration, error) `perm:"read"`
+		StateSectorExpiration func(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*miner.SectorExpiration, error) `perm:"read"`
 
 		StateSectorGetInfo func(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*miner.SectorOnChainInfo, error) `perm:"read"`
 
-		StateSectorPartition func(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*lminer.SectorLocation, error) `perm:"read"`
+		StateSectorPartition func(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*miner.SectorLocation, error) `perm:"read"`
 
 		StateSectorPreCommitInfo func(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) `perm:"read"`
 
@@ -440,8 +417,6 @@ type GatewayStruct struct {
 
 		ChainNotify func(p0 context.Context) (<-chan []*api.HeadChange, error) ``
 
-		ChainPutObj func(p0 context.Context, p1 blocks.Block) error ``
-
 		ChainReadObj func(p0 context.Context, p1 cid.Cid) ([]byte, error) ``
 
 		GasEstimateMessageGas func(p0 context.Context, p1 *types.Message, p2 *api.MessageSendSpec, p3 types.TipSetKey) (*types.Message, error) ``
@@ -470,7 +445,7 @@ type GatewayStruct struct {
 
 		StateMarketStorageDeal func(p0 context.Context, p1 abi.DealID, p2 types.TipSetKey) (*api.MarketDeal, error) ``
 
-		StateMinerInfo func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (api.MinerInfo, error) ``
+		StateMinerInfo func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (miner.MinerInfo, error) ``
 
 		StateMinerPower func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*api.MinerPower, error) ``
 
@@ -704,17 +679,6 @@ func (s *FullNodeStub) ChainNotify(p0 context.Context) (<-chan []*api.HeadChange
 	return nil, ErrNotSupported
 }
 
-func (s *FullNodeStruct) ChainPutObj(p0 context.Context, p1 blocks.Block) error {
-	if s.Internal.ChainPutObj == nil {
-		return ErrNotSupported
-	}
-	return s.Internal.ChainPutObj(p0, p1)
-}
-
-func (s *FullNodeStub) ChainPutObj(p0 context.Context, p1 blocks.Block) error {
-	return ErrNotSupported
-}
-
 func (s *FullNodeStruct) ChainReadObj(p0 context.Context, p1 cid.Cid) ([]byte, error) {
 	if s.Internal.ChainReadObj == nil {
 		return *new([]byte), ErrNotSupported
@@ -1694,28 +1658,6 @@ func (s *FullNodeStub) StateAccountKey(p0 context.Context, p1 address.Address, p
 	return *new(address.Address), ErrNotSupported
 }
 
-func (s *FullNodeStruct) StateActorCodeCIDs(p0 context.Context, p1 abinetwork.Version) (map[string]cid.Cid, error) {
-	if s.Internal.StateActorCodeCIDs == nil {
-		return *new(map[string]cid.Cid), ErrNotSupported
-	}
-	return s.Internal.StateActorCodeCIDs(p0, p1)
-}
-
-func (s *FullNodeStub) StateActorCodeCIDs(p0 context.Context, p1 abinetwork.Version) (map[string]cid.Cid, error) {
-	return *new(map[string]cid.Cid), ErrNotSupported
-}
-
-func (s *FullNodeStruct) StateActorManifestCID(p0 context.Context, p1 abinetwork.Version) (cid.Cid, error) {
-	if s.Internal.StateActorManifestCID == nil {
-		return *new(cid.Cid), ErrNotSupported
-	}
-	return s.Internal.StateActorManifestCID(p0, p1)
-}
-
-func (s *FullNodeStub) StateActorManifestCID(p0 context.Context, p1 abinetwork.Version) (cid.Cid, error) {
-	return *new(cid.Cid), ErrNotSupported
-}
-
 func (s *FullNodeStruct) StateAllMinerFaults(p0 context.Context, p1 abi.ChainEpoch, p2 types.TipSetKey) ([]*api.Fault, error) {
 	if s.Internal.StateAllMinerFaults == nil {
 		return *new([]*api.Fault), ErrNotSupported
@@ -1804,72 +1746,6 @@ func (s *FullNodeStub) StateGetActor(p0 context.Context, p1 address.Address, p2
 	return nil, ErrNotSupported
 }
 
-func (s *FullNodeStruct) StateGetAllocation(p0 context.Context, p1 address.Address, p2 verifregtypes.AllocationId, p3 types.TipSetKey) (*verifregtypes.Allocation, error) {
-	if s.Internal.StateGetAllocation == nil {
-		return nil, ErrNotSupported
-	}
-	return s.Internal.StateGetAllocation(p0, p1, p2, p3)
-}
-
-func (s *FullNodeStub) StateGetAllocation(p0 context.Context, p1 address.Address, p2 verifregtypes.AllocationId, p3 types.TipSetKey) (*verifregtypes.Allocation, error) {
-	return nil, ErrNotSupported
-}
-
-func (s *FullNodeStruct) StateGetAllocationForPendingDeal(p0 context.Context, p1 abi.DealID, p2 types.TipSetKey) (*verifregtypes.Allocation, error) {
-	if s.Internal.StateGetAllocationForPendingDeal == nil {
-		return nil, ErrNotSupported
-	}
-	return s.Internal.StateGetAllocationForPendingDeal(p0, p1, p2)
-}
-
-func (s *FullNodeStub) StateGetAllocationForPendingDeal(p0 context.Context, p1 abi.DealID, p2 types.TipSetKey) (*verifregtypes.Allocation, error) {
-	return nil, ErrNotSupported
-}
-
-func (s *FullNodeStruct) StateGetAllocations(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (map[verifregtypes.AllocationId]verifregtypes.Allocation, error) {
-	if s.Internal.StateGetAllocations == nil {
-		return *new(map[verifregtypes.AllocationId]verifregtypes.Allocation), ErrNotSupported
-	}
-	return s.Internal.StateGetAllocations(p0, p1, p2)
-}
-
-func (s *FullNodeStub) StateGetAllocations(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (map[verifregtypes.AllocationId]verifregtypes.Allocation, error) {
-	return *new(map[verifregtypes.AllocationId]verifregtypes.Allocation), ErrNotSupported
-}
-
-func (s *FullNodeStruct) StateGetClaim(p0 context.Context, p1 address.Address, p2 verifregtypes.ClaimId, p3 types.TipSetKey) (*verifregtypes.Claim, error) {
-	if s.Internal.StateGetClaim == nil {
-		return nil, ErrNotSupported
-	}
-	return s.Internal.StateGetClaim(p0, p1, p2, p3)
-}
-
-func (s *FullNodeStub) StateGetClaim(p0 context.Context, p1 address.Address, p2 verifregtypes.ClaimId, p3 types.TipSetKey) (*verifregtypes.Claim, error) {
-	return nil, ErrNotSupported
-}
-
-func (s *FullNodeStruct) StateGetClaims(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (map[verifregtypes.ClaimId]verifregtypes.Claim, error) {
-	if s.Internal.StateGetClaims == nil {
-		return *new(map[verifregtypes.ClaimId]verifregtypes.Claim), ErrNotSupported
-	}
-	return s.Internal.StateGetClaims(p0, p1, p2)
-}
-
-func (s *FullNodeStub) StateGetClaims(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (map[verifregtypes.ClaimId]verifregtypes.Claim, error) {
-	return *new(map[verifregtypes.ClaimId]verifregtypes.Claim), ErrNotSupported
-}
-
-func (s *FullNodeStruct) StateGetNetworkParams(p0 context.Context) (*api.NetworkParams, error) {
-	if s.Internal.StateGetNetworkParams == nil {
-		return nil, ErrNotSupported
-	}
-	return s.Internal.StateGetNetworkParams(p0)
-}
-
-func (s *FullNodeStub) StateGetNetworkParams(p0 context.Context) (*api.NetworkParams, error) {
-	return nil, ErrNotSupported
-}
-
 func (s *FullNodeStruct) StateGetRandomnessFromBeacon(p0 context.Context, p1 crypto.DomainSeparationTag, p2 abi.ChainEpoch, p3 []byte, p4 types.TipSetKey) (abi.Randomness, error) {
 	if s.Internal.StateGetRandomnessFromBeacon == nil {
 		return *new(abi.Randomness), ErrNotSupported
@@ -1958,15 +1834,15 @@ func (s *FullNodeStub) StateMarketBalance(p0 context.Context, p1 address.Address
 	return *new(api.MarketBalance), ErrNotSupported
 }
 
-func (s *FullNodeStruct) StateMarketDeals(p0 context.Context, p1 types.TipSetKey) (map[string]*api.MarketDeal, error) {
+func (s *FullNodeStruct) StateMarketDeals(p0 context.Context, p1 types.TipSetKey) (map[string]api.MarketDeal, error) {
 	if s.Internal.StateMarketDeals == nil {
-		return *new(map[string]*api.MarketDeal), ErrNotSupported
+		return *new(map[string]api.MarketDeal), ErrNotSupported
 	}
 	return s.Internal.StateMarketDeals(p0, p1)
 }
 
-func (s *FullNodeStub) StateMarketDeals(p0 context.Context, p1 types.TipSetKey) (map[string]*api.MarketDeal, error) {
-	return *new(map[string]*api.MarketDeal), ErrNotSupported
+func (s *FullNodeStub) StateMarketDeals(p0 context.Context, p1 types.TipSetKey) (map[string]api.MarketDeal, error) {
+	return *new(map[string]api.MarketDeal), ErrNotSupported
 }
 
 func (s *FullNodeStruct) StateMarketParticipants(p0 context.Context, p1 types.TipSetKey) (map[string]api.MarketBalance, error) {
@@ -2035,15 +1911,15 @@ func (s *FullNodeStub) StateMinerFaults(p0 context.Context, p1 address.Address,
 	return *new(bitfield.BitField), ErrNotSupported
 }
 
-func (s *FullNodeStruct) StateMinerInfo(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (api.MinerInfo, error) {
+func (s *FullNodeStruct) StateMinerInfo(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (miner.MinerInfo, error) {
 	if s.Internal.StateMinerInfo == nil {
-		return *new(api.MinerInfo), ErrNotSupported
+		return *new(miner.MinerInfo), ErrNotSupported
 	}
 	return s.Internal.StateMinerInfo(p0, p1, p2)
 }
 
-func (s *FullNodeStub) StateMinerInfo(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (api.MinerInfo, error) {
-	return *new(api.MinerInfo), ErrNotSupported
+func (s *FullNodeStub) StateMinerInfo(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (miner.MinerInfo, error) {
+	return *new(miner.MinerInfo), ErrNotSupported
 }
 
 func (s *FullNodeStruct) StateMinerInitialPledgeCollateral(p0 context.Context, p1 address.Address, p2 miner.SectorPreCommitInfo, p3 types.TipSetKey) (types.BigInt, error) {
@@ -2211,14 +2087,14 @@ func (s *FullNodeStub) StateSearchMsgLimited(p0 context.Context, p1 cid.Cid, p2
 	return nil, ErrNotSupported
 }
 
-func (s *FullNodeStruct) StateSectorExpiration(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*lminer.SectorExpiration, error) {
+func (s *FullNodeStruct) StateSectorExpiration(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*miner.SectorExpiration, error) {
 	if s.Internal.StateSectorExpiration == nil {
 		return nil, ErrNotSupported
 	}
 	return s.Internal.StateSectorExpiration(p0, p1, p2, p3)
 }
 
-func (s *FullNodeStub) StateSectorExpiration(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*lminer.SectorExpiration, error) {
+func (s *FullNodeStub) StateSectorExpiration(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*miner.SectorExpiration, error) {
 	return nil, ErrNotSupported
 }
 
@@ -2233,14 +2109,14 @@ func (s *FullNodeStub) StateSectorGetInfo(p0 context.Context, p1 address.Address
 	return nil, ErrNotSupported
 }
 
-func (s *FullNodeStruct) StateSectorPartition(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*lminer.SectorLocation, error) {
+func (s *FullNodeStruct) StateSectorPartition(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*miner.SectorLocation, error) {
 	if s.Internal.StateSectorPartition == nil {
 		return nil, ErrNotSupported
 	}
 	return s.Internal.StateSectorPartition(p0, p1, p2, p3)
 }
 
-func (s *FullNodeStub) StateSectorPartition(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*lminer.SectorLocation, error) {
+func (s *FullNodeStub) StateSectorPartition(p0 context.Context, p1 address.Address, p2 abi.SectorNumber, p3 types.TipSetKey) (*miner.SectorLocation, error) {
 	return nil, ErrNotSupported
 }
 
@@ -2640,17 +2516,6 @@ func (s *GatewayStub) ChainNotify(p0 context.Context) (<-chan []*api.HeadChange,
 	return nil, ErrNotSupported
 }
 
-func (s *GatewayStruct) ChainPutObj(p0 context.Context, p1 blocks.Block) error {
-	if s.Internal.ChainPutObj == nil {
-		return ErrNotSupported
-	}
-	return s.Internal.ChainPutObj(p0, p1)
-}
-
-func (s *GatewayStub) ChainPutObj(p0 context.Context, p1 blocks.Block) error {
-	return ErrNotSupported
-}
-
 func (s *GatewayStruct) ChainReadObj(p0 context.Context, p1 cid.Cid) ([]byte, error) {
 	if s.Internal.ChainReadObj == nil {
 		return *new([]byte), ErrNotSupported
@@ -2805,15 +2670,15 @@ func (s *GatewayStub) StateMarketStorageDeal(p0 context.Context, p1 abi.DealID,
 	return nil, ErrNotSupported
 }
 
-func (s *GatewayStruct) StateMinerInfo(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (api.MinerInfo, error) {
+func (s *GatewayStruct) StateMinerInfo(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (miner.MinerInfo, error) {
 	if s.Internal.StateMinerInfo == nil {
-		return *new(api.MinerInfo), ErrNotSupported
+		return *new(miner.MinerInfo), ErrNotSupported
 	}
 	return s.Internal.StateMinerInfo(p0, p1, p2)
 }
 
-func (s *GatewayStub) StateMinerInfo(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (api.MinerInfo, error) {
-	return *new(api.MinerInfo), ErrNotSupported
+func (s *GatewayStub) StateMinerInfo(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (miner.MinerInfo, error) {
+	return *new(miner.MinerInfo), ErrNotSupported
 }
 
 func (s *GatewayStruct) StateMinerPower(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*api.MinerPower, error) {

api/v0api/v0mocks/mock_full.go

@@ -9,15 +9,6 @@ import (
 	reflect "reflect"
 	time "time"
 
-	gomock "github.com/golang/mock/gomock"
-	uuid "github.com/google/uuid"
-	blocks "github.com/ipfs/go-block-format"
-	cid "github.com/ipfs/go-cid"
-	metrics "github.com/libp2p/go-libp2p/core/metrics"
-	network0 "github.com/libp2p/go-libp2p/core/network"
-	peer "github.com/libp2p/go-libp2p/core/peer"
-	protocol "github.com/libp2p/go-libp2p/core/protocol"
-
 	address "github.com/filecoin-project/go-address"
 	bitfield "github.com/filecoin-project/go-bitfield"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
@@ -26,22 +17,27 @@ import (
 	auth "github.com/filecoin-project/go-jsonrpc/auth"
 	abi "github.com/filecoin-project/go-state-types/abi"
 	big "github.com/filecoin-project/go-state-types/big"
-	paych "github.com/filecoin-project/go-state-types/builtin/v8/paych"
-	miner "github.com/filecoin-project/go-state-types/builtin/v9/miner"
-	verifreg "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	crypto "github.com/filecoin-project/go-state-types/crypto"
 	dline "github.com/filecoin-project/go-state-types/dline"
 	network "github.com/filecoin-project/go-state-types/network"
-
 	api "github.com/filecoin-project/lotus/api"
 	apitypes "github.com/filecoin-project/lotus/api/types"
 	v0api "github.com/filecoin-project/lotus/api/v0api"
-	miner0 "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	miner "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	types "github.com/filecoin-project/lotus/chain/types"
 	alerting "github.com/filecoin-project/lotus/journal/alerting"
 	marketevents "github.com/filecoin-project/lotus/markets/loggers"
 	dtypes "github.com/filecoin-project/lotus/node/modules/dtypes"
 	imports "github.com/filecoin-project/lotus/node/repo/imports"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	paych "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	gomock "github.com/golang/mock/gomock"
+	uuid "github.com/google/uuid"
+	cid "github.com/ipfs/go-cid"
+	metrics "github.com/libp2p/go-libp2p-core/metrics"
+	network0 "github.com/libp2p/go-libp2p-core/network"
+	peer "github.com/libp2p/go-libp2p-core/peer"
+	protocol "github.com/libp2p/go-libp2p-core/protocol"
 )
 
 // MockFullNode is a mock of FullNode interface.
@@ -381,20 +377,6 @@ func (mr *MockFullNodeMockRecorder) ChainNotify(arg0 interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainNotify", reflect.TypeOf((*MockFullNode)(nil).ChainNotify), arg0)
 }
 
-// ChainPutObj mocks base method.
-func (m *MockFullNode) ChainPutObj(arg0 context.Context, arg1 blocks.Block) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ChainPutObj", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ChainPutObj indicates an expected call of ChainPutObj.
-func (mr *MockFullNodeMockRecorder) ChainPutObj(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainPutObj", reflect.TypeOf((*MockFullNode)(nil).ChainPutObj), arg0, arg1)
-}
-
 // ChainReadObj mocks base method.
 func (m *MockFullNode) ChainReadObj(arg0 context.Context, arg1 cid.Cid) ([]byte, error) {
 	m.ctrl.T.Helper()
@@ -2158,21 +2140,6 @@ func (mr *MockFullNodeMockRecorder) Shutdown(arg0 interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockFullNode)(nil).Shutdown), arg0)
 }
 
-// StartTime mocks base method.
-func (m *MockFullNode) StartTime(arg0 context.Context) (time.Time, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartTime", arg0)
-	ret0, _ := ret[0].(time.Time)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartTime indicates an expected call of StartTime.
-func (mr *MockFullNodeMockRecorder) StartTime(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTime", reflect.TypeOf((*MockFullNode)(nil).StartTime), arg0)
-}
-
 // StateAccountKey mocks base method.
 func (m *MockFullNode) StateAccountKey(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (address.Address, error) {
 	m.ctrl.T.Helper()
@@ -2188,36 +2155,6 @@ func (mr *MockFullNodeMockRecorder) StateAccountKey(arg0, arg1, arg2 interface{}
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateAccountKey", reflect.TypeOf((*MockFullNode)(nil).StateAccountKey), arg0, arg1, arg2)
 }
 
-// StateActorCodeCIDs mocks base method.
-func (m *MockFullNode) StateActorCodeCIDs(arg0 context.Context, arg1 network.Version) (map[string]cid.Cid, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateActorCodeCIDs", arg0, arg1)
-	ret0, _ := ret[0].(map[string]cid.Cid)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateActorCodeCIDs indicates an expected call of StateActorCodeCIDs.
-func (mr *MockFullNodeMockRecorder) StateActorCodeCIDs(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateActorCodeCIDs", reflect.TypeOf((*MockFullNode)(nil).StateActorCodeCIDs), arg0, arg1)
-}
-
-// StateActorManifestCID mocks base method.
-func (m *MockFullNode) StateActorManifestCID(arg0 context.Context, arg1 network.Version) (cid.Cid, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateActorManifestCID", arg0, arg1)
-	ret0, _ := ret[0].(cid.Cid)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateActorManifestCID indicates an expected call of StateActorManifestCID.
-func (mr *MockFullNodeMockRecorder) StateActorManifestCID(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateActorManifestCID", reflect.TypeOf((*MockFullNode)(nil).StateActorManifestCID), arg0, arg1)
-}
-
 // StateAllMinerFaults mocks base method.
 func (m *MockFullNode) StateAllMinerFaults(arg0 context.Context, arg1 abi.ChainEpoch, arg2 types.TipSetKey) ([]*api.Fault, error) {
 	m.ctrl.T.Helper()
@@ -2338,96 +2275,6 @@ func (mr *MockFullNodeMockRecorder) StateGetActor(arg0, arg1, arg2 interface{})
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetActor", reflect.TypeOf((*MockFullNode)(nil).StateGetActor), arg0, arg1, arg2)
 }
 
-// StateGetAllocation mocks base method.
-func (m *MockFullNode) StateGetAllocation(arg0 context.Context, arg1 address.Address, arg2 verifreg.AllocationId, arg3 types.TipSetKey) (*verifreg.Allocation, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetAllocation", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*verifreg.Allocation)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetAllocation indicates an expected call of StateGetAllocation.
-func (mr *MockFullNodeMockRecorder) StateGetAllocation(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetAllocation", reflect.TypeOf((*MockFullNode)(nil).StateGetAllocation), arg0, arg1, arg2, arg3)
-}
-
-// StateGetAllocationForPendingDeal mocks base method.
-func (m *MockFullNode) StateGetAllocationForPendingDeal(arg0 context.Context, arg1 abi.DealID, arg2 types.TipSetKey) (*verifreg.Allocation, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetAllocationForPendingDeal", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*verifreg.Allocation)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetAllocationForPendingDeal indicates an expected call of StateGetAllocationForPendingDeal.
-func (mr *MockFullNodeMockRecorder) StateGetAllocationForPendingDeal(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetAllocationForPendingDeal", reflect.TypeOf((*MockFullNode)(nil).StateGetAllocationForPendingDeal), arg0, arg1, arg2)
-}
-
-// StateGetAllocations mocks base method.
-func (m *MockFullNode) StateGetAllocations(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (map[verifreg.AllocationId]verifreg.Allocation, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetAllocations", arg0, arg1, arg2)
-	ret0, _ := ret[0].(map[verifreg.AllocationId]verifreg.Allocation)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetAllocations indicates an expected call of StateGetAllocations.
-func (mr *MockFullNodeMockRecorder) StateGetAllocations(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetAllocations", reflect.TypeOf((*MockFullNode)(nil).StateGetAllocations), arg0, arg1, arg2)
-}
-
-// StateGetClaim mocks base method.
-func (m *MockFullNode) StateGetClaim(arg0 context.Context, arg1 address.Address, arg2 verifreg.ClaimId, arg3 types.TipSetKey) (*verifreg.Claim, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetClaim", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*verifreg.Claim)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetClaim indicates an expected call of StateGetClaim.
-func (mr *MockFullNodeMockRecorder) StateGetClaim(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetClaim", reflect.TypeOf((*MockFullNode)(nil).StateGetClaim), arg0, arg1, arg2, arg3)
-}
-
-// StateGetClaims mocks base method.
-func (m *MockFullNode) StateGetClaims(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (map[verifreg.ClaimId]verifreg.Claim, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetClaims", arg0, arg1, arg2)
-	ret0, _ := ret[0].(map[verifreg.ClaimId]verifreg.Claim)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetClaims indicates an expected call of StateGetClaims.
-func (mr *MockFullNodeMockRecorder) StateGetClaims(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetClaims", reflect.TypeOf((*MockFullNode)(nil).StateGetClaims), arg0, arg1, arg2)
-}
-
-// StateGetNetworkParams mocks base method.
-func (m *MockFullNode) StateGetNetworkParams(arg0 context.Context) (*api.NetworkParams, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetNetworkParams", arg0)
-	ret0, _ := ret[0].(*api.NetworkParams)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetNetworkParams indicates an expected call of StateGetNetworkParams.
-func (mr *MockFullNodeMockRecorder) StateGetNetworkParams(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetNetworkParams", reflect.TypeOf((*MockFullNode)(nil).StateGetNetworkParams), arg0)
-}
-
 // StateGetRandomnessFromBeacon mocks base method.
 func (m *MockFullNode) StateGetRandomnessFromBeacon(arg0 context.Context, arg1 crypto.DomainSeparationTag, arg2 abi.ChainEpoch, arg3 []byte, arg4 types.TipSetKey) (abi.Randomness, error) {
 	m.ctrl.T.Helper()
@@ -2549,10 +2396,10 @@ func (mr *MockFullNodeMockRecorder) StateMarketBalance(arg0, arg1, arg2 interfac
 }
 
 // StateMarketDeals mocks base method.
-func (m *MockFullNode) StateMarketDeals(arg0 context.Context, arg1 types.TipSetKey) (map[string]*api.MarketDeal, error) {
+func (m *MockFullNode) StateMarketDeals(arg0 context.Context, arg1 types.TipSetKey) (map[string]api.MarketDeal, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateMarketDeals", arg0, arg1)
-	ret0, _ := ret[0].(map[string]*api.MarketDeal)
+	ret0, _ := ret[0].(map[string]api.MarketDeal)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2654,10 +2501,10 @@ func (mr *MockFullNodeMockRecorder) StateMinerFaults(arg0, arg1, arg2 interface{
 }
 
 // StateMinerInfo mocks base method.
-func (m *MockFullNode) StateMinerInfo(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (api.MinerInfo, error) {
+func (m *MockFullNode) StateMinerInfo(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (miner.MinerInfo, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateMinerInfo", arg0, arg1, arg2)
-	ret0, _ := ret[0].(api.MinerInfo)
+	ret0, _ := ret[0].(miner.MinerInfo)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2669,7 +2516,7 @@ func (mr *MockFullNodeMockRecorder) StateMinerInfo(arg0, arg1, arg2 interface{})
 }
 
 // StateMinerInitialPledgeCollateral mocks base method.
-func (m *MockFullNode) StateMinerInitialPledgeCollateral(arg0 context.Context, arg1 address.Address, arg2 miner.SectorPreCommitInfo, arg3 types.TipSetKey) (big.Int, error) {
+func (m *MockFullNode) StateMinerInitialPledgeCollateral(arg0 context.Context, arg1 address.Address, arg2 miner0.SectorPreCommitInfo, arg3 types.TipSetKey) (big.Int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateMinerInitialPledgeCollateral", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(big.Int)
@@ -2714,7 +2561,7 @@ func (mr *MockFullNodeMockRecorder) StateMinerPower(arg0, arg1, arg2 interface{}
 }
 
 // StateMinerPreCommitDepositForPower mocks base method.
-func (m *MockFullNode) StateMinerPreCommitDepositForPower(arg0 context.Context, arg1 address.Address, arg2 miner.SectorPreCommitInfo, arg3 types.TipSetKey) (big.Int, error) {
+func (m *MockFullNode) StateMinerPreCommitDepositForPower(arg0 context.Context, arg1 address.Address, arg2 miner0.SectorPreCommitInfo, arg3 types.TipSetKey) (big.Int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateMinerPreCommitDepositForPower", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(big.Int)
@@ -2894,10 +2741,10 @@ func (mr *MockFullNodeMockRecorder) StateSearchMsgLimited(arg0, arg1, arg2 inter
 }
 
 // StateSectorExpiration mocks base method.
-func (m *MockFullNode) StateSectorExpiration(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner0.SectorExpiration, error) {
+func (m *MockFullNode) StateSectorExpiration(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner.SectorExpiration, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateSectorExpiration", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*miner0.SectorExpiration)
+	ret0, _ := ret[0].(*miner.SectorExpiration)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2924,10 +2771,10 @@ func (mr *MockFullNodeMockRecorder) StateSectorGetInfo(arg0, arg1, arg2, arg3 in
 }
 
 // StateSectorPartition mocks base method.
-func (m *MockFullNode) StateSectorPartition(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner0.SectorLocation, error) {
+func (m *MockFullNode) StateSectorPartition(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner.SectorLocation, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateSectorPartition", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*miner0.SectorLocation)
+	ret0, _ := ret[0].(*miner.SectorLocation)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }

api/v0api/v1_wrapper.go

@@ -3,40 +3,27 @@ package v0api
 import (
 	"context"
 
-	"github.com/ipfs/go-cid"
-	"github.com/libp2p/go-libp2p/core/peer"
-	"golang.org/x/xerrors"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	marketevents "github.com/filecoin-project/lotus/markets/loggers"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
-	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/lotus/chain/types"
+	"golang.org/x/xerrors"
+
+	"github.com/ipfs/go-cid"
+
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/builtin/v9/miner"
-	"github.com/filecoin-project/go-state-types/crypto"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/v1api"
-	"github.com/filecoin-project/lotus/chain/types"
-	marketevents "github.com/filecoin-project/lotus/markets/loggers"
 )
 
 type WrapperV1Full struct {
 	v1api.FullNode
 }
 
-func (w *WrapperV1Full) StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, s abi.SectorNumber, tsk types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) {
-	pi, err := w.FullNode.StateSectorPreCommitInfo(ctx, maddr, s, tsk)
-	if err != nil {
-		return miner.SectorPreCommitOnChainInfo{}, err
-	}
-	if pi == nil {
-		return miner.SectorPreCommitOnChainInfo{}, xerrors.Errorf("precommit info does not exist")
-	}
-
-	return *pi, nil
-}
-
 func (w *WrapperV1Full) StateSearchMsg(ctx context.Context, msg cid.Cid) (*api.MsgLookup, error) {
 	return w.FullNode.StateSearchMsg(ctx, types.EmptyTSK, msg, api.LookbackNoLimit, true)
 }
@@ -354,16 +341,4 @@ func (w *WrapperV1Full) PaychGet(ctx context.Context, from, to address.Address,
 	return w.FullNode.PaychFund(ctx, from, to, amt)
 }
 
-func (w *WrapperV1Full) ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.StorageAsk, error) {
-	a, err := w.FullNode.ClientQueryAsk(ctx, p, miner)
-	if err != nil {
-		return nil, err
-	}
-	return a.Response, nil
-}
-
-func (w *WrapperV1Full) BeaconGetEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) {
-	return w.StateGetBeaconEntry(ctx, epoch)
-}
-
 var _ FullNode = &WrapperV1Full{}

api/v1api/latest.go

@@ -7,8 +7,6 @@ import (
 type FullNode = api.FullNode
 type FullNodeStruct = api.FullNodeStruct
 
-type RawFullNodeAPI FullNode
-
 func PermissionedFullAPI(a FullNode) FullNode {
 	return api.PermissionedFullAPI(a)
 }

api/version.go

@@ -3,7 +3,7 @@ package api
 import (
 	"fmt"
 
-	"golang.org/x/xerrors"
+	xerrors "golang.org/x/xerrors"
 )
 
 type Version uint32
@@ -55,7 +55,7 @@ func VersionForType(nodeType NodeType) (Version, error) {
 // semver versions of the rpc api exposed
 var (
 	FullAPIVersion0 = newVer(1, 5, 0)
-	FullAPIVersion1 = newVer(2, 3, 0)
+	FullAPIVersion1 = newVer(2, 2, 0)
 
 	MinerAPIVersion0  = newVer(1, 5, 0)
 	WorkerAPIVersion0 = newVer(1, 6, 0)

blockstore/api.go

@@ -11,7 +11,6 @@ import (
 type ChainIO interface {
 	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
-	ChainPutObj(context.Context, blocks.Block) error
 }
 
 type apiBlockstore struct {
@@ -50,18 +49,12 @@ func (a *apiBlockstore) GetSize(ctx context.Context, c cid.Cid) (int, error) {
 	return len(bb), nil
 }
 
-func (a *apiBlockstore) Put(ctx context.Context, block blocks.Block) error {
-	return a.api.ChainPutObj(ctx, block)
+func (a *apiBlockstore) Put(context.Context, blocks.Block) error {
+	return xerrors.New("not supported")
 }
 
-func (a *apiBlockstore) PutMany(ctx context.Context, blocks []blocks.Block) error {
-	for _, block := range blocks {
-		err := a.api.ChainPutObj(ctx, block)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
+func (a *apiBlockstore) PutMany(context.Context, []blocks.Block) error {
+	return xerrors.New("not supported")
 }
 
 func (a *apiBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {

blockstore/autobatch.go

@@ -5,10 +5,10 @@ import (
 	"sync"
 	"time"
 
+	"golang.org/x/xerrors"
+
 	block "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
-	"golang.org/x/xerrors"
 )
 
 // autolog is a logger for the autobatching blockstore. It is subscoped from the
@@ -176,27 +176,23 @@ func (bs *AutobatchBlockstore) Get(ctx context.Context, c cid.Cid) (block.Block,
 		return blk, nil
 	}
 
-	if !ipld.IsNotFound(err) {
+	if err != ErrNotFound {
 		return blk, err
 	}
 
 	bs.stateLock.Lock()
+	defer bs.stateLock.Unlock()
 	v, ok := bs.flushingBatch.blockMap[c]
 	if ok {
-		bs.stateLock.Unlock()
 		return v, nil
 	}
 
 	v, ok = bs.bufferedBatch.blockMap[c]
 	if ok {
-		bs.stateLock.Unlock()
 		return v, nil
 	}
-	bs.stateLock.Unlock()
 
-	// We have to check the backing store one more time because it may have been flushed by the
-	// time we were able to take the lock above.
-	return bs.backingBs.Get(ctx, c)
+	return bs.Get(ctx, c)
 }
 
 func (bs *AutobatchBlockstore) DeleteBlock(context.Context, cid.Cid) error {
@@ -218,7 +214,7 @@ func (bs *AutobatchBlockstore) Has(ctx context.Context, c cid.Cid) (bool, error)
 	if err == nil {
 		return true, nil
 	}
-	if ipld.IsNotFound(err) {
+	if err == ErrNotFound {
 		return false, nil
 	}
 

blockstore/autobatch_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"
 
-	ipld "github.com/ipfs/go-ipld-format"
 	"github.com/stretchr/testify/require"
 )
 
@@ -30,10 +29,6 @@ func TestAutobatchBlockstore(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, b2.RawData(), v2.RawData())
 
-	// Regression test for a deadlock.
-	_, err = ab.Get(ctx, b3.Cid())
-	require.True(t, ipld.IsNotFound(err))
-
 	require.NoError(t, ab.Flush(ctx))
 	require.NoError(t, ab.Shutdown(ctx))
 }

blockstore/badger/blockstore.go

@@ -13,14 +13,14 @@ import (
 	"github.com/dgraph-io/badger/v2"
 	"github.com/dgraph-io/badger/v2/options"
 	"github.com/dgraph-io/badger/v2/pb"
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
-	logger "github.com/ipfs/go-log/v2"
-	pool "github.com/libp2p/go-buffer-pool"
 	"github.com/multiformats/go-base32"
 	"go.uber.org/zap"
 
+	blocks "github.com/ipfs/go-block-format"
+	"github.com/ipfs/go-cid"
+	logger "github.com/ipfs/go-log/v2"
+	pool "github.com/libp2p/go-buffer-pool"
+
 	"github.com/filecoin-project/lotus/blockstore"
 )
 
@@ -544,7 +544,7 @@ func (b *Blockstore) View(ctx context.Context, cid cid.Cid, fn func([]byte) erro
 		case nil:
 			return item.Value(fn)
 		case badger.ErrKeyNotFound:
-			return ipld.ErrNotFound{Cid: cid}
+			return blockstore.ErrNotFound
 		default:
 			return fmt.Errorf("failed to view block from badger blockstore: %w", err)
 		}
@@ -584,7 +584,7 @@ func (b *Blockstore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
 // Get implements Blockstore.Get.
 func (b *Blockstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) {
 	if !cid.Defined() {
-		return nil, ipld.ErrNotFound{Cid: cid}
+		return nil, blockstore.ErrNotFound
 	}
 
 	if err := b.access(); err != nil {
@@ -607,7 +607,7 @@ func (b *Blockstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error)
 			val, err = item.ValueCopy(nil)
 			return err
 		case badger.ErrKeyNotFound:
-			return ipld.ErrNotFound{Cid: cid}
+			return blockstore.ErrNotFound
 		default:
 			return fmt.Errorf("failed to get block from badger blockstore: %w", err)
 		}
@@ -639,7 +639,7 @@ func (b *Blockstore) GetSize(ctx context.Context, cid cid.Cid) (int, error) {
 		case nil:
 			size = int(item.ValueSize())
 		case badger.ErrKeyNotFound:
-			return ipld.ErrNotFound{Cid: cid}
+			return blockstore.ErrNotFound
 		default:
 			return fmt.Errorf("failed to get block size from badger blockstore: %w", err)
 		}

blockstore/badger/blockstore_test.go

@@ -1,4 +1,4 @@
-// stm: #unit
+//stm: #unit
 package badgerbs
 
 import (
@@ -10,11 +10,12 @@ import (
 	"strings"
 	"testing"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/sync/errgroup"
 
+	blocks "github.com/ipfs/go-block-format"
+	cid "github.com/ipfs/go-cid"
+
 	"github.com/filecoin-project/lotus/blockstore"
 )
 

blockstore/badger/blockstore_test_suite.go

@@ -1,4 +1,4 @@
-// stm: #unit
+//stm: #unit
 package badgerbs
 
 import (
@@ -12,10 +12,10 @@ import (
 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
 	u "github.com/ipfs/go-ipfs-util"
-	ipld "github.com/ipfs/go-ipld-format"
-	"github.com/stretchr/testify/require"
 
 	"github.com/filecoin-project/lotus/blockstore"
+
+	"github.com/stretchr/testify/require"
 )
 
 // TODO: move this to go-ipfs-blockstore.
@@ -56,7 +56,7 @@ func (s *Suite) TestGetWhenKeyNotPresent(t *testing.T) {
 	c := cid.NewCidV0(u.Hash([]byte("stuff")))
 	bl, err := bs.Get(ctx, c)
 	require.Nil(t, bl)
-	require.Equal(t, ipld.ErrNotFound{Cid: c}, err)
+	require.Equal(t, blockstore.ErrNotFound, err)
 }
 
 func (s *Suite) TestGetWhenKeyIsNil(t *testing.T) {
@@ -69,7 +69,7 @@ func (s *Suite) TestGetWhenKeyIsNil(t *testing.T) {
 	}
 
 	_, err := bs.Get(ctx, cid.Undef)
-	require.Equal(t, ipld.ErrNotFound{Cid: cid.Undef}, err)
+	require.Equal(t, blockstore.ErrNotFound, err)
 }
 
 func (s *Suite) TestPutThenGetBlock(t *testing.T) {
@@ -164,9 +164,8 @@ func (s *Suite) TestPutThenGetSizeBlock(t *testing.T) {
 	require.NoError(t, err)
 	require.Zero(t, emptySize)
 
-	missingCid := missingBlock.Cid()
-	missingSize, err := bs.GetSize(ctx, missingCid)
-	require.Equal(t, ipld.ErrNotFound{Cid: missingCid}, err)
+	missingSize, err := bs.GetSize(ctx, missingBlock.Cid())
+	require.Equal(t, blockstore.ErrNotFound, err)
 	require.Equal(t, -1, missingSize)
 }
 

blockstore/blockstore.go

@@ -3,14 +3,17 @@ package blockstore
 import (
 	"context"
 
-	"github.com/ipfs/go-cid"
+	cid "github.com/ipfs/go-cid"
 	ds "github.com/ipfs/go-datastore"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	logging "github.com/ipfs/go-log/v2"
+
+	blockstore "github.com/ipfs/go-ipfs-blockstore"
 )
 
 var log = logging.Logger("blockstore")
 
+var ErrNotFound = blockstore.ErrNotFound
+
 // Blockstore is the blockstore interface used by Lotus. It is the union
 // of the basic go-ipfs blockstore, with other capabilities required by Lotus,
 // e.g. View or Sync.

blockstore/buffered.go

@@ -6,7 +6,6 @@ import (
 
 	block "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
 )
 
 // buflog is a logger for the buffered blockstore. It is subscoped from the
@@ -107,7 +106,7 @@ func (bs *BufferedBlockstore) DeleteMany(ctx context.Context, cids []cid.Cid) er
 
 func (bs *BufferedBlockstore) View(ctx context.Context, c cid.Cid, callback func([]byte) error) error {
 	// both stores are viewable.
-	if err := bs.write.View(ctx, c, callback); ipld.IsNotFound(err) {
+	if err := bs.write.View(ctx, c, callback); err == ErrNotFound {
 		// not found in write blockstore; fall through.
 	} else {
 		return err // propagate errors, or nil, i.e. found.
@@ -117,7 +116,7 @@ func (bs *BufferedBlockstore) View(ctx context.Context, c cid.Cid, callback func
 
 func (bs *BufferedBlockstore) Get(ctx context.Context, c cid.Cid) (block.Block, error) {
 	if out, err := bs.write.Get(ctx, c); err != nil {
-		if !ipld.IsNotFound(err) {
+		if err != ErrNotFound {
 			return nil, err
 		}
 	} else {
@@ -129,7 +128,7 @@ func (bs *BufferedBlockstore) Get(ctx context.Context, c cid.Cid) (block.Block,
 
 func (bs *BufferedBlockstore) GetSize(ctx context.Context, c cid.Cid) (int, error) {
 	s, err := bs.read.GetSize(ctx, c)
-	if ipld.IsNotFound(err) || s == 0 {
+	if err == ErrNotFound || s == 0 {
 		return bs.write.GetSize(ctx, c)
 	}
 

blockstore/cbor_gen.go

@@ -1,441 +0,0 @@
-// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
-
-package blockstore
-
-import (
-	"fmt"
-	"io"
-	"math"
-	"sort"
-
-	cid "github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	xerrors "golang.org/x/xerrors"
-)
-
-var _ = xerrors.Errorf
-var _ = cid.Undef
-var _ = math.E
-var _ = sort.Sort
-
-var lengthBufNetRpcReq = []byte{132}
-
-func (t *NetRpcReq) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-
-	cw := cbg.NewCborWriter(w)
-
-	if _, err := cw.Write(lengthBufNetRpcReq); err != nil {
-		return err
-	}
-
-	// t.Type (blockstore.NetRPCReqType) (uint8)
-	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Type)); err != nil {
-		return err
-	}
-
-	// t.ID (uint64) (uint64)
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ID)); err != nil {
-		return err
-	}
-
-	// t.Cid ([]cid.Cid) (slice)
-	if len(t.Cid) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Cid was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Cid))); err != nil {
-		return err
-	}
-	for _, v := range t.Cid {
-		if err := cbg.WriteCid(w, v); err != nil {
-			return xerrors.Errorf("failed writing cid field t.Cid: %w", err)
-		}
-	}
-
-	// t.Data ([][]uint8) (slice)
-	if len(t.Data) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Data was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Data))); err != nil {
-		return err
-	}
-	for _, v := range t.Data {
-		if len(v) > cbg.ByteArrayMaxLen {
-			return xerrors.Errorf("Byte array in field v was too long")
-		}
-
-		if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(v))); err != nil {
-			return err
-		}
-
-		if _, err := cw.Write(v[:]); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *NetRpcReq) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = NetRpcReq{}
-
-	cr := cbg.NewCborReader(r)
-
-	maj, extra, err := cr.ReadHeader()
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-	}()
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 4 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Type (blockstore.NetRPCReqType) (uint8)
-
-	maj, extra, err = cr.ReadHeader()
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint8 field")
-	}
-	if extra > math.MaxUint8 {
-		return fmt.Errorf("integer in input was too large for uint8 field")
-	}
-	t.Type = NetRPCReqType(extra)
-	// t.ID (uint64) (uint64)
-
-	{
-
-		maj, extra, err = cr.ReadHeader()
-		if err != nil {
-			return err
-		}
-		if maj != cbg.MajUnsignedInt {
-			return fmt.Errorf("wrong type for uint64 field")
-		}
-		t.ID = uint64(extra)
-
-	}
-	// t.Cid ([]cid.Cid) (slice)
-
-	maj, extra, err = cr.ReadHeader()
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Cid: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-
-	if extra > 0 {
-		t.Cid = make([]cid.Cid, extra)
-	}
-
-	for i := 0; i < int(extra); i++ {
-
-		c, err := cbg.ReadCid(cr)
-		if err != nil {
-			return xerrors.Errorf("reading cid field t.Cid failed: %w", err)
-		}
-		t.Cid[i] = c
-	}
-
-	// t.Data ([][]uint8) (slice)
-
-	maj, extra, err = cr.ReadHeader()
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Data: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-
-	if extra > 0 {
-		t.Data = make([][]uint8, extra)
-	}
-
-	for i := 0; i < int(extra); i++ {
-		{
-			var maj byte
-			var extra uint64
-			var err error
-
-			maj, extra, err = cr.ReadHeader()
-			if err != nil {
-				return err
-			}
-
-			if extra > cbg.ByteArrayMaxLen {
-				return fmt.Errorf("t.Data[i]: byte array too large (%d)", extra)
-			}
-			if maj != cbg.MajByteString {
-				return fmt.Errorf("expected byte array")
-			}
-
-			if extra > 0 {
-				t.Data[i] = make([]uint8, extra)
-			}
-
-			if _, err := io.ReadFull(cr, t.Data[i][:]); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-var lengthBufNetRpcResp = []byte{131}
-
-func (t *NetRpcResp) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-
-	cw := cbg.NewCborWriter(w)
-
-	if _, err := cw.Write(lengthBufNetRpcResp); err != nil {
-		return err
-	}
-
-	// t.Type (blockstore.NetRPCRespType) (uint8)
-	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Type)); err != nil {
-		return err
-	}
-
-	// t.ID (uint64) (uint64)
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ID)); err != nil {
-		return err
-	}
-
-	// t.Data ([]uint8) (slice)
-	if len(t.Data) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Data was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Data))); err != nil {
-		return err
-	}
-
-	if _, err := cw.Write(t.Data[:]); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *NetRpcResp) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = NetRpcResp{}
-
-	cr := cbg.NewCborReader(r)
-
-	maj, extra, err := cr.ReadHeader()
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-	}()
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Type (blockstore.NetRPCRespType) (uint8)
-
-	maj, extra, err = cr.ReadHeader()
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint8 field")
-	}
-	if extra > math.MaxUint8 {
-		return fmt.Errorf("integer in input was too large for uint8 field")
-	}
-	t.Type = NetRPCRespType(extra)
-	// t.ID (uint64) (uint64)
-
-	{
-
-		maj, extra, err = cr.ReadHeader()
-		if err != nil {
-			return err
-		}
-		if maj != cbg.MajUnsignedInt {
-			return fmt.Errorf("wrong type for uint64 field")
-		}
-		t.ID = uint64(extra)
-
-	}
-	// t.Data ([]uint8) (slice)
-
-	maj, extra, err = cr.ReadHeader()
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Data: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-
-	if extra > 0 {
-		t.Data = make([]uint8, extra)
-	}
-
-	if _, err := io.ReadFull(cr, t.Data[:]); err != nil {
-		return err
-	}
-	return nil
-}
-
-var lengthBufNetRpcErr = []byte{131}
-
-func (t *NetRpcErr) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-
-	cw := cbg.NewCborWriter(w)
-
-	if _, err := cw.Write(lengthBufNetRpcErr); err != nil {
-		return err
-	}
-
-	// t.Type (blockstore.NetRPCErrType) (uint8)
-	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Type)); err != nil {
-		return err
-	}
-
-	// t.Msg (string) (string)
-	if len(t.Msg) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.Msg was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Msg))); err != nil {
-		return err
-	}
-	if _, err := io.WriteString(w, string(t.Msg)); err != nil {
-		return err
-	}
-
-	// t.Cid (cid.Cid) (struct)
-
-	if t.Cid == nil {
-		if _, err := cw.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if err := cbg.WriteCid(cw, *t.Cid); err != nil {
-			return xerrors.Errorf("failed to write cid field t.Cid: %w", err)
-		}
-	}
-
-	return nil
-}
-
-func (t *NetRpcErr) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = NetRpcErr{}
-
-	cr := cbg.NewCborReader(r)
-
-	maj, extra, err := cr.ReadHeader()
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-	}()
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Type (blockstore.NetRPCErrType) (uint8)
-
-	maj, extra, err = cr.ReadHeader()
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint8 field")
-	}
-	if extra > math.MaxUint8 {
-		return fmt.Errorf("integer in input was too large for uint8 field")
-	}
-	t.Type = NetRPCErrType(extra)
-	// t.Msg (string) (string)
-
-	{
-		sval, err := cbg.ReadString(cr)
-		if err != nil {
-			return err
-		}
-
-		t.Msg = string(sval)
-	}
-	// t.Cid (cid.Cid) (struct)
-
-	{
-
-		b, err := cr.ReadByte()
-		if err != nil {
-			return err
-		}
-		if b != cbg.CborNull[0] {
-			if err := cr.UnreadByte(); err != nil {
-				return err
-			}
-
-			c, err := cbg.ReadCid(cr)
-			if err != nil {
-				return xerrors.Errorf("failed to read cid field t.Cid: %w", err)
-			}
-
-			t.Cid = &c
-		}
-
-	}
-	return nil
-}

blockstore/discard.go

@@ -5,7 +5,7 @@ import (
 	"io"
 
 	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
+	cid "github.com/ipfs/go-cid"
 )
 
 var _ Blockstore = (*discardstore)(nil)

blockstore/fallback.go

@@ -5,10 +5,10 @@ import (
 	"sync"
 	"time"
 
+	"golang.org/x/xerrors"
+
 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
-	"golang.org/x/xerrors"
 )
 
 // UnwrapFallbackStore takes a blockstore, and returns the underlying blockstore
@@ -56,7 +56,7 @@ func (fbs *FallbackStore) getFallback(c cid.Cid) (blocks.Block, error) {
 
 		if fbs.missFn == nil {
 			log.Errorw("fallbackstore: missFn not configured yet")
-			return nil, ipld.ErrNotFound{Cid: c}
+			return nil, ErrNotFound
 		}
 	}
 
@@ -79,10 +79,10 @@ func (fbs *FallbackStore) getFallback(c cid.Cid) (blocks.Block, error) {
 
 func (fbs *FallbackStore) Get(ctx context.Context, c cid.Cid) (blocks.Block, error) {
 	b, err := fbs.Blockstore.Get(ctx, c)
-	switch {
-	case err == nil:
+	switch err {
+	case nil:
 		return b, nil
-	case ipld.IsNotFound(err):
+	case ErrNotFound:
 		return fbs.getFallback(c)
 	default:
 		return b, err
@@ -91,10 +91,10 @@ func (fbs *FallbackStore) Get(ctx context.Context, c cid.Cid) (blocks.Block, err
 
 func (fbs *FallbackStore) GetSize(ctx context.Context, c cid.Cid) (int, error) {
 	sz, err := fbs.Blockstore.GetSize(ctx, c)
-	switch {
-	case err == nil:
+	switch err {
+	case nil:
 		return sz, nil
-	case ipld.IsNotFound(err):
+	case ErrNotFound:
 		b, err := fbs.getFallback(c)
 		if err != nil {
 			return 0, err

blockstore/idstore.go

@@ -4,10 +4,11 @@ import (
 	"context"
 	"io"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	mh "github.com/multiformats/go-multihash"
 	"golang.org/x/xerrors"
+
+	blocks "github.com/ipfs/go-block-format"
+	cid "github.com/ipfs/go-cid"
+	mh "github.com/multiformats/go-multihash"
 )
 
 var _ Blockstore = (*idstore)(nil)
@@ -102,14 +103,6 @@ func (b *idstore) Put(ctx context.Context, blk blocks.Block) error {
 	return b.bs.Put(ctx, blk)
 }
 
-func (b *idstore) ForEachKey(f func(cid.Cid) error) error {
-	iterBstore, ok := b.bs.(BlockstoreIterator)
-	if !ok {
-		return xerrors.Errorf("underlying blockstore (type %T) doesn't support fast iteration", b.bs)
-	}
-	return iterBstore.ForEachKey(f)
-}
-
 func (b *idstore) PutMany(ctx context.Context, blks []blocks.Block) error {
 	toPut := make([]blocks.Block, 0, len(blks))
 	for _, blk := range blks {

blockstore/ipfs.go

@@ -5,15 +5,17 @@ import (
 	"context"
 	"io/ioutil"
 
+	"golang.org/x/xerrors"
+
+	"github.com/multiformats/go-multiaddr"
+	"github.com/multiformats/go-multihash"
+
 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
 	httpapi "github.com/ipfs/go-ipfs-http-client"
 	iface "github.com/ipfs/interface-go-ipfs-core"
 	"github.com/ipfs/interface-go-ipfs-core/options"
 	"github.com/ipfs/interface-go-ipfs-core/path"
-	"github.com/multiformats/go-multiaddr"
-	"github.com/multiformats/go-multihash"
-	"golang.org/x/xerrors"
 )
 
 type IPFSBlockstore struct {
@@ -128,7 +130,7 @@ func (i *IPFSBlockstore) Put(ctx context.Context, block blocks.Block) error {
 
 	_, err = i.api.Block().Put(ctx, bytes.NewReader(block.RawData()),
 		options.Block.Hash(mhd.Code, mhd.Length),
-		options.Block.Format(multihash.Codes[block.Cid().Type()]))
+		options.Block.Format(cid.CodecToStr[block.Cid().Type()]))
 	return err
 }
 

blockstore/mem.go

@@ -5,7 +5,6 @@ import (
 
 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
 )
 
 // NewMemory returns a temporary memory-backed blockstore.
@@ -14,50 +13,46 @@ func NewMemory() MemBlockstore {
 }
 
 // MemBlockstore is a terminal blockstore that keeps blocks in memory.
-// To match behavior of badger blockstore we index by multihash only.
-type MemBlockstore map[string]blocks.Block
+type MemBlockstore map[cid.Cid]blocks.Block
 
 func (m MemBlockstore) DeleteBlock(ctx context.Context, k cid.Cid) error {
-	delete(m, string(k.Hash()))
+	delete(m, k)
 	return nil
 }
 
 func (m MemBlockstore) DeleteMany(ctx context.Context, ks []cid.Cid) error {
 	for _, k := range ks {
-		delete(m, string(k.Hash()))
+		delete(m, k)
 	}
 	return nil
 }
 
 func (m MemBlockstore) Has(ctx context.Context, k cid.Cid) (bool, error) {
-	_, ok := m[string(k.Hash())]
+	_, ok := m[k]
 	return ok, nil
 }
 
 func (m MemBlockstore) View(ctx context.Context, k cid.Cid, callback func([]byte) error) error {
-	b, ok := m[string(k.Hash())]
+	b, ok := m[k]
 	if !ok {
-		return ipld.ErrNotFound{Cid: k}
+		return ErrNotFound
 	}
 	return callback(b.RawData())
 }
 
 func (m MemBlockstore) Get(ctx context.Context, k cid.Cid) (blocks.Block, error) {
-	b, ok := m[string(k.Hash())]
+	b, ok := m[k]
 	if !ok {
-		return nil, ipld.ErrNotFound{Cid: k}
-	}
-	if b.Cid().Prefix().Codec != k.Prefix().Codec {
-		return blocks.NewBlockWithCid(b.RawData(), k)
+		return nil, ErrNotFound
 	}
 	return b, nil
 }
 
 // GetSize returns the CIDs mapped BlockSize
 func (m MemBlockstore) GetSize(ctx context.Context, k cid.Cid) (int, error) {
-	b, ok := m[string(k.Hash())]
+	b, ok := m[k]
 	if !ok {
-		return 0, ipld.ErrNotFound{Cid: k}
+		return 0, ErrNotFound
 	}
 	return len(b.RawData()), nil
 }
@@ -66,7 +61,7 @@ func (m MemBlockstore) GetSize(ctx context.Context, k cid.Cid) (int, error) {
 func (m MemBlockstore) Put(ctx context.Context, b blocks.Block) error {
 	// Convert to a basic block for safety, but try to reuse the existing
 	// block if it's already a basic block.
-	k := string(b.Cid().Hash())
+	k := b.Cid()
 	if _, ok := b.(*blocks.BasicBlock); !ok {
 		// If we already have the block, abort.
 		if _, ok := m[k]; ok {
@@ -75,7 +70,7 @@ func (m MemBlockstore) Put(ctx context.Context, b blocks.Block) error {
 		// the error is only for debugging.
 		b, _ = blocks.NewBlockWithCid(b.RawData(), b.Cid())
 	}
-	m[k] = b
+	m[b.Cid()] = b
 	return nil
 }
 
@@ -93,8 +88,8 @@ func (m MemBlockstore) PutMany(ctx context.Context, bs []blocks.Block) error {
 // the given context, closing the channel if it becomes Done.
 func (m MemBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
 	ch := make(chan cid.Cid, len(m))
-	for _, b := range m {
-		ch <- b.Cid()
+	for k := range m {
+		ch <- k
 	}
 	close(ch)
 	return ch, nil

blockstore/mem_test.go

@@ -1,45 +0,0 @@
-package blockstore
-
-import (
-	"context"
-	"testing"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	mh "github.com/multiformats/go-multihash"
-	"github.com/stretchr/testify/require"
-)
-
-func TestMemGetCodec(t *testing.T) {
-	ctx := context.Background()
-	bs := NewMemory()
-
-	cborArr := []byte{0x82, 1, 2}
-
-	h, err := mh.Sum(cborArr, mh.SHA2_256, -1)
-	require.NoError(t, err)
-
-	rawCid := cid.NewCidV1(cid.Raw, h)
-	rawBlk, err := blocks.NewBlockWithCid(cborArr, rawCid)
-	require.NoError(t, err)
-
-	err = bs.Put(ctx, rawBlk)
-	require.NoError(t, err)
-
-	cborCid := cid.NewCidV1(cid.DagCBOR, h)
-
-	cborBlk, err := bs.Get(ctx, cborCid)
-	require.NoError(t, err)
-
-	require.Equal(t, cborCid.Prefix(), cborBlk.Cid().Prefix())
-	require.EqualValues(t, cborArr, cborBlk.RawData())
-
-	// was allocated
-	require.NotEqual(t, cborBlk, rawBlk)
-
-	gotRawBlk, err := bs.Get(ctx, rawCid)
-	require.NoError(t, err)
-
-	// not allocated
-	require.Equal(t, rawBlk, gotRawBlk)
-}

blockstore/net.go

@@ -1,424 +0,0 @@
-package blockstore
-
-import (
-	"bytes"
-	"context"
-	"encoding/binary"
-	"fmt"
-	"sync"
-	"sync/atomic"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
-	"github.com/libp2p/go-msgio"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-)
-
-type NetRPCReqType byte
-
-const (
-	NRpcHas NetRPCReqType = iota
-	NRpcGet
-	NRpcGetSize
-	NRpcPut
-	NRpcDelete
-
-	// todo cancel req
-)
-
-type NetRPCRespType byte
-
-const (
-	NRpcOK NetRPCRespType = iota
-	NRpcErr
-	NRpcMore
-)
-
-type NetRPCErrType byte
-
-const (
-	NRpcErrGeneric NetRPCErrType = iota
-	NRpcErrNotFound
-)
-
-type NetRpcReq struct {
-	Type NetRPCReqType
-	ID   uint64
-
-	Cid  []cid.Cid // todo maxsize?
-	Data [][]byte  // todo maxsize?
-}
-
-type NetRpcResp struct {
-	Type NetRPCRespType
-	ID   uint64
-
-	// error or cids in allkeys
-	Data []byte // todo maxsize?
-
-	next <-chan NetRpcResp
-}
-
-type NetRpcErr struct {
-	Type NetRPCErrType
-
-	Msg string
-
-	// in case of NRpcErrNotFound
-	Cid *cid.Cid
-}
-
-type NetworkStore struct {
-	// note: writer is thread-safe
-	msgStream msgio.ReadWriteCloser
-
-	// atomic
-	reqCount uint64
-
-	respLk sync.Mutex
-
-	// respMap is nil after store closes
-	respMap map[uint64]chan<- NetRpcResp
-
-	closing chan struct{}
-	closed  chan struct{}
-
-	closeLk sync.Mutex
-	onClose []func()
-}
-
-func NewNetworkStore(mss msgio.ReadWriteCloser) *NetworkStore {
-	ns := &NetworkStore{
-		msgStream: mss,
-
-		respMap: map[uint64]chan<- NetRpcResp{},
-
-		closing: make(chan struct{}),
-		closed:  make(chan struct{}),
-	}
-
-	go ns.receive()
-
-	return ns
-}
-
-func (n *NetworkStore) shutdown(msg string) {
-	if err := n.msgStream.Close(); err != nil {
-		log.Errorw("closing netstore msg stream", "error", err)
-	}
-
-	nerr := NetRpcErr{
-		Type: NRpcErrGeneric,
-		Msg:  msg,
-		Cid:  nil,
-	}
-
-	var errb bytes.Buffer
-	if err := nerr.MarshalCBOR(&errb); err != nil {
-		log.Errorw("netstore shutdown: error marshaling error", "err", err)
-	}
-
-	n.respLk.Lock()
-	for id, resps := range n.respMap {
-		resps <- NetRpcResp{
-			Type: NRpcErr,
-			ID:   id,
-			Data: errb.Bytes(),
-		}
-	}
-
-	n.respMap = nil
-
-	n.respLk.Unlock()
-}
-
-func (n *NetworkStore) OnClose(cb func()) {
-	n.closeLk.Lock()
-	defer n.closeLk.Unlock()
-
-	select {
-	case <-n.closed:
-		cb()
-	default:
-		n.onClose = append(n.onClose, cb)
-	}
-}
-
-func (n *NetworkStore) receive() {
-	defer func() {
-		n.closeLk.Lock()
-		defer n.closeLk.Unlock()
-
-		close(n.closed)
-		if n.onClose != nil {
-			for _, f := range n.onClose {
-				f()
-			}
-		}
-	}()
-
-	for {
-		select {
-		case <-n.closing:
-			n.shutdown("netstore stopping")
-			return
-		default:
-		}
-
-		msg, err := n.msgStream.ReadMsg()
-		if err != nil {
-			n.shutdown(fmt.Sprintf("netstore ReadMsg: %s", err))
-			return
-		}
-
-		var resp NetRpcResp
-		if err := resp.UnmarshalCBOR(bytes.NewReader(msg)); err != nil {
-			n.shutdown(fmt.Sprintf("unmarshaling netstore response: %s", err))
-			return
-		}
-
-		n.msgStream.ReleaseMsg(msg)
-
-		n.respLk.Lock()
-		if ch, ok := n.respMap[resp.ID]; ok {
-			if resp.Type == NRpcMore {
-				nch := make(chan NetRpcResp, 1)
-				resp.next = nch
-				n.respMap[resp.ID] = nch
-			} else {
-				delete(n.respMap, resp.ID)
-			}
-
-			ch <- resp
-		}
-		n.respLk.Unlock()
-	}
-}
-
-func (n *NetworkStore) sendRpc(rt NetRPCReqType, cids []cid.Cid, data [][]byte) (uint64, <-chan NetRpcResp, error) {
-	rid := atomic.AddUint64(&n.reqCount, 1)
-
-	respCh := make(chan NetRpcResp, 1) // todo pool?
-
-	n.respLk.Lock()
-	if n.respMap == nil {
-		n.respLk.Unlock()
-		return 0, nil, xerrors.Errorf("netstore closed")
-	}
-	n.respMap[rid] = respCh
-	n.respLk.Unlock()
-
-	req := NetRpcReq{
-		Type: rt,
-		ID:   rid,
-		Cid:  cids,
-		Data: data,
-	}
-
-	var rbuf bytes.Buffer // todo buffer pool
-	if err := req.MarshalCBOR(&rbuf); err != nil {
-		n.respLk.Lock()
-		defer n.respLk.Unlock()
-
-		if n.respMap == nil {
-			return 0, nil, xerrors.Errorf("netstore closed")
-		}
-		delete(n.respMap, rid)
-
-		return 0, nil, err
-	}
-
-	if err := n.msgStream.WriteMsg(rbuf.Bytes()); err != nil {
-		n.respLk.Lock()
-		defer n.respLk.Unlock()
-
-		if n.respMap == nil {
-			return 0, nil, xerrors.Errorf("netstore closed")
-		}
-		delete(n.respMap, rid)
-
-		return 0, nil, err
-	}
-
-	return rid, respCh, nil
-}
-
-func (n *NetworkStore) waitResp(ctx context.Context, rch <-chan NetRpcResp, rid uint64) (NetRpcResp, error) {
-	select {
-	case resp := <-rch:
-		if resp.Type == NRpcErr {
-			var e NetRpcErr
-			if err := e.UnmarshalCBOR(bytes.NewReader(resp.Data)); err != nil {
-				return NetRpcResp{}, xerrors.Errorf("unmarshaling error data: %w", err)
-			}
-
-			var err error
-			switch e.Type {
-			case NRpcErrNotFound:
-				if e.Cid != nil {
-					err = ipld.ErrNotFound{
-						Cid: *e.Cid,
-					}
-				} else {
-					err = xerrors.Errorf("block not found, but cid was null")
-				}
-			case NRpcErrGeneric:
-				err = xerrors.Errorf("generic error")
-			default:
-				err = xerrors.Errorf("unknown error type")
-			}
-
-			return NetRpcResp{}, xerrors.Errorf("netstore error response: %s (%w)", e.Msg, err)
-		}
-
-		return resp, nil
-	case <-ctx.Done():
-		// todo send cancel req
-
-		n.respLk.Lock()
-		if n.respMap != nil {
-			delete(n.respMap, rid)
-		}
-		n.respLk.Unlock()
-
-		return NetRpcResp{}, ctx.Err()
-	}
-}
-
-func (n *NetworkStore) Has(ctx context.Context, c cid.Cid) (bool, error) {
-	req, rch, err := n.sendRpc(NRpcHas, []cid.Cid{c}, nil)
-	if err != nil {
-		return false, err
-	}
-
-	resp, err := n.waitResp(ctx, rch, req)
-	if err != nil {
-		return false, err
-	}
-
-	if len(resp.Data) != 1 {
-		return false, xerrors.Errorf("expected reposnse length to be 1 byte")
-	}
-	switch resp.Data[0] {
-	case cbg.CborBoolTrue[0]:
-		return true, nil
-	case cbg.CborBoolFalse[0]:
-		return false, nil
-	default:
-		return false, xerrors.Errorf("has: bad response: %x", resp.Data[0])
-	}
-}
-
-func (n *NetworkStore) Get(ctx context.Context, c cid.Cid) (blocks.Block, error) {
-	req, rch, err := n.sendRpc(NRpcGet, []cid.Cid{c}, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := n.waitResp(ctx, rch, req)
-	if err != nil {
-		return nil, err
-	}
-
-	return blocks.NewBlockWithCid(resp.Data, c)
-}
-
-func (n *NetworkStore) View(ctx context.Context, c cid.Cid, callback func([]byte) error) error {
-	req, rch, err := n.sendRpc(NRpcGet, []cid.Cid{c}, nil)
-	if err != nil {
-		return err
-	}
-
-	resp, err := n.waitResp(ctx, rch, req)
-	if err != nil {
-		return err
-	}
-
-	return callback(resp.Data) // todo return buf to pool
-}
-
-func (n *NetworkStore) GetSize(ctx context.Context, c cid.Cid) (int, error) {
-	req, rch, err := n.sendRpc(NRpcGetSize, []cid.Cid{c}, nil)
-	if err != nil {
-		return 0, err
-	}
-
-	resp, err := n.waitResp(ctx, rch, req)
-	if err != nil {
-		return 0, err
-	}
-
-	if len(resp.Data) != 4 {
-		return 0, xerrors.Errorf("expected getsize response to be 4 bytes, was %d", resp.Data)
-	}
-
-	return int(binary.LittleEndian.Uint32(resp.Data)), nil
-}
-
-func (n *NetworkStore) Put(ctx context.Context, block blocks.Block) error {
-	return n.PutMany(ctx, []blocks.Block{block})
-}
-
-func (n *NetworkStore) PutMany(ctx context.Context, blocks []blocks.Block) error {
-	// todo pool
-	cids := make([]cid.Cid, len(blocks))
-	blkDatas := make([][]byte, len(blocks))
-	for i, block := range blocks {
-		cids[i] = block.Cid()
-		blkDatas[i] = block.RawData()
-	}
-
-	req, rch, err := n.sendRpc(NRpcPut, cids, blkDatas)
-	if err != nil {
-		return err
-	}
-
-	_, err = n.waitResp(ctx, rch, req)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (n *NetworkStore) DeleteBlock(ctx context.Context, c cid.Cid) error {
-	return n.DeleteMany(ctx, []cid.Cid{c})
-}
-
-func (n *NetworkStore) DeleteMany(ctx context.Context, cids []cid.Cid) error {
-	req, rch, err := n.sendRpc(NRpcDelete, cids, nil)
-	if err != nil {
-		return err
-	}
-
-	_, err = n.waitResp(ctx, rch, req)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (n *NetworkStore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
-	return nil, xerrors.Errorf("not supported")
-}
-
-func (n *NetworkStore) HashOnRead(enabled bool) {
-	// todo
-	return
-}
-
-func (n *NetworkStore) Stop(ctx context.Context) error {
-	close(n.closing)
-
-	select {
-	case <-n.closed:
-		return nil
-	case <-ctx.Done():
-		return ctx.Err()
-	}
-}
-
-var _ Blockstore = &NetworkStore{}

blockstore/net_serve.go

@@ -1,237 +0,0 @@
-package blockstore
-
-import (
-	"bytes"
-	"context"
-	"encoding/binary"
-
-	block "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
-	"github.com/libp2p/go-msgio"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-)
-
-type NetworkStoreHandler struct {
-	msgStream msgio.ReadWriteCloser
-
-	bs Blockstore
-}
-
-// NOTE: This code isn't yet hardened to accept untrusted input. See TODOs here and in net.go
-func HandleNetBstoreStream(ctx context.Context, bs Blockstore, mss msgio.ReadWriteCloser) *NetworkStoreHandler {
-	ns := &NetworkStoreHandler{
-		msgStream: mss,
-		bs:        bs,
-	}
-
-	go ns.handle(ctx)
-
-	return ns
-}
-
-func (h *NetworkStoreHandler) handle(ctx context.Context) {
-	defer func() {
-		if err := h.msgStream.Close(); err != nil {
-			log.Errorw("error closing blockstore stream", "error", err)
-		}
-	}()
-
-	for {
-		var req NetRpcReq
-
-		ms, err := h.msgStream.ReadMsg()
-		if err != nil {
-			log.Warnw("bstore stream err", "error", err)
-			return
-		}
-
-		if err := req.UnmarshalCBOR(bytes.NewReader(ms)); err != nil {
-			return
-		}
-
-		h.msgStream.ReleaseMsg(ms)
-
-		switch req.Type {
-		case NRpcHas:
-			if len(req.Cid) != 1 {
-				if err := h.respondError(req.ID, xerrors.New("expected request for 1 cid"), cid.Undef); err != nil {
-					log.Warnw("writing error response", "error", err)
-					return
-				}
-				continue
-			}
-
-			res, err := h.bs.Has(ctx, req.Cid[0])
-			if err != nil {
-				if err := h.respondError(req.ID, err, req.Cid[0]); err != nil {
-					log.Warnw("writing error response", "error", err)
-					return
-				}
-				continue
-			}
-
-			var resData [1]byte
-			if res {
-				resData[0] = cbg.CborBoolTrue[0]
-			} else {
-				resData[0] = cbg.CborBoolFalse[0]
-			}
-
-			if err := h.respond(req.ID, NRpcOK, resData[:]); err != nil {
-				log.Warnw("writing response", "error", err)
-				return
-			}
-
-		case NRpcGet:
-			if len(req.Cid) != 1 {
-				if err := h.respondError(req.ID, xerrors.New("expected request for 1 cid"), cid.Undef); err != nil {
-					log.Warnw("writing error response", "error", err)
-					return
-				}
-				continue
-			}
-
-			err := h.bs.View(ctx, req.Cid[0], func(bdata []byte) error {
-				return h.respond(req.ID, NRpcOK, bdata)
-			})
-			if err != nil {
-				if err := h.respondError(req.ID, err, req.Cid[0]); err != nil {
-					log.Warnw("writing error response", "error", err)
-					return
-				}
-				continue
-			}
-
-		case NRpcGetSize:
-			if len(req.Cid) != 1 {
-				if err := h.respondError(req.ID, xerrors.New("expected request for 1 cid"), cid.Undef); err != nil {
-					log.Warnw("writing error response", "error", err)
-					return
-				}
-				continue
-			}
-
-			sz, err := h.bs.GetSize(ctx, req.Cid[0])
-			if err != nil {
-				if err := h.respondError(req.ID, err, req.Cid[0]); err != nil {
-					log.Warnw("writing error response", "error", err)
-					return
-				}
-				continue
-			}
-
-			var resData [4]byte
-			binary.LittleEndian.PutUint32(resData[:], uint32(sz))
-
-			if err := h.respond(req.ID, NRpcOK, resData[:]); err != nil {
-				log.Warnw("writing response", "error", err)
-				return
-			}
-
-		case NRpcPut:
-			blocks := make([]block.Block, len(req.Cid))
-
-			if len(req.Cid) != len(req.Data) {
-				if err := h.respondError(req.ID, xerrors.New("cid count didn't match data count"), cid.Undef); err != nil {
-					log.Warnw("writing error response", "error", err)
-				}
-				return
-			}
-
-			for i := range req.Cid {
-				blocks[i], err = block.NewBlockWithCid(req.Data[i], req.Cid[i])
-				if err != nil {
-					log.Warnw("make block", "error", err)
-					return
-				}
-			}
-
-			err := h.bs.PutMany(ctx, blocks)
-			if err != nil {
-				if err := h.respondError(req.ID, err, cid.Undef); err != nil {
-					log.Warnw("writing error response", "error", err)
-					return
-				}
-				continue
-			}
-
-			if err := h.respond(req.ID, NRpcOK, []byte{}); err != nil {
-				log.Warnw("writing response", "error", err)
-				return
-			}
-		case NRpcDelete:
-			err := h.bs.DeleteMany(ctx, req.Cid)
-			if err != nil {
-				if err := h.respondError(req.ID, err, cid.Undef); err != nil {
-					log.Warnw("writing error response", "error", err)
-					return
-				}
-				continue
-			}
-
-			if err := h.respond(req.ID, NRpcOK, []byte{}); err != nil {
-				log.Warnw("writing response", "error", err)
-				return
-			}
-		default:
-			if err := h.respondError(req.ID, xerrors.New("unsupported request type"), cid.Undef); err != nil {
-				log.Warnw("writing error response", "error", err)
-				return
-			}
-			continue
-		}
-	}
-}
-
-func (h *NetworkStoreHandler) respondError(req uint64, uerr error, c cid.Cid) error {
-	var resp NetRpcResp
-	resp.ID = req
-	resp.Type = NRpcErr
-
-	nerr := NetRpcErr{
-		Type: NRpcErrGeneric,
-		Msg:  uerr.Error(),
-	}
-	if ipld.IsNotFound(uerr) {
-		nerr.Type = NRpcErrNotFound
-		nerr.Cid = &c
-	}
-
-	var edata bytes.Buffer
-	if err := nerr.MarshalCBOR(&edata); err != nil {
-		return xerrors.Errorf("marshaling error data: %w", err)
-	}
-
-	resp.Data = edata.Bytes()
-
-	var msg bytes.Buffer
-	if err := resp.MarshalCBOR(&msg); err != nil {
-		return xerrors.Errorf("marshaling error response: %w", err)
-	}
-
-	if err := h.msgStream.WriteMsg(msg.Bytes()); err != nil {
-		return xerrors.Errorf("write error response: %w", err)
-	}
-
-	return nil
-}
-
-func (h *NetworkStoreHandler) respond(req uint64, rt NetRPCRespType, data []byte) error {
-	var resp NetRpcResp
-	resp.ID = req
-	resp.Type = rt
-	resp.Data = data
-
-	var msg bytes.Buffer
-	if err := resp.MarshalCBOR(&msg); err != nil {
-		return xerrors.Errorf("marshaling response: %w", err)
-	}
-
-	if err := h.msgStream.WriteMsg(msg.Bytes()); err != nil {
-		return xerrors.Errorf("write response: %w", err)
-	}
-
-	return nil
-}

blockstore/net_test.go

@@ -1,63 +0,0 @@
-package blockstore
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"testing"
-
-	block "github.com/ipfs/go-block-format"
-	ipld "github.com/ipfs/go-ipld-format"
-	"github.com/libp2p/go-msgio"
-	"github.com/stretchr/testify/require"
-)
-
-func TestNetBstore(t *testing.T) {
-	ctx := context.Background()
-
-	cr, sw := io.Pipe()
-	sr, cw := io.Pipe()
-
-	cm := msgio.Combine(msgio.NewWriter(cw), msgio.NewReader(cr))
-	sm := msgio.Combine(msgio.NewWriter(sw), msgio.NewReader(sr))
-
-	bbs := NewMemorySync()
-	_ = HandleNetBstoreStream(ctx, bbs, sm)
-
-	nbs := NewNetworkStore(cm)
-
-	tb1 := block.NewBlock([]byte("aoeu"))
-
-	h, err := nbs.Has(ctx, tb1.Cid())
-	require.NoError(t, err)
-	require.False(t, h)
-
-	err = nbs.Put(ctx, tb1)
-	require.NoError(t, err)
-
-	h, err = nbs.Has(ctx, tb1.Cid())
-	require.NoError(t, err)
-	require.True(t, h)
-
-	sz, err := nbs.GetSize(ctx, tb1.Cid())
-	require.NoError(t, err)
-	require.Equal(t, 4, sz)
-
-	err = nbs.DeleteBlock(ctx, tb1.Cid())
-	require.NoError(t, err)
-
-	h, err = nbs.Has(ctx, tb1.Cid())
-	require.NoError(t, err)
-	require.False(t, h)
-
-	_, err = nbs.Get(ctx, tb1.Cid())
-	fmt.Println(err)
-	require.True(t, ipld.IsNotFound(err))
-
-	err = nbs.Put(ctx, tb1)
-	require.NoError(t, err)
-
-	b, err := nbs.Get(ctx, tb1.Cid())
-	require.NoError(t, err)
-	require.Equal(t, "aoeu", string(b.RawData()))
-}

blockstore/net_ws.go

@@ -1,100 +0,0 @@
-package blockstore
-
-import (
-	"bytes"
-	"context"
-
-	"github.com/gorilla/websocket"
-	"github.com/libp2p/go-msgio"
-	"golang.org/x/xerrors"
-)
-
-type wsWrapper struct {
-	wc *websocket.Conn
-
-	nextMsg []byte
-}
-
-func (w *wsWrapper) Read(b []byte) (int, error) {
-	return 0, xerrors.New("read unsupported")
-}
-
-func (w *wsWrapper) ReadMsg() ([]byte, error) {
-	if w.nextMsg != nil {
-		nm := w.nextMsg
-		w.nextMsg = nil
-		return nm, nil
-	}
-
-	mt, r, err := w.wc.NextReader()
-	if err != nil {
-		return nil, err
-	}
-
-	switch mt {
-	case websocket.BinaryMessage, websocket.TextMessage:
-	default:
-		return nil, xerrors.Errorf("unexpected message type")
-	}
-
-	// todo pool
-	// todo limit sizes
-	var mbuf bytes.Buffer
-	if _, err := mbuf.ReadFrom(r); err != nil {
-		return nil, err
-	}
-
-	return mbuf.Bytes(), nil
-}
-
-func (w *wsWrapper) ReleaseMsg(bytes []byte) {
-	// todo use a pool
-}
-
-func (w *wsWrapper) NextMsgLen() (int, error) {
-	if w.nextMsg != nil {
-		return len(w.nextMsg), nil
-	}
-
-	mt, msg, err := w.wc.ReadMessage()
-	if err != nil {
-		return 0, err
-	}
-
-	switch mt {
-	case websocket.BinaryMessage, websocket.TextMessage:
-	default:
-		return 0, xerrors.Errorf("unexpected message type")
-	}
-
-	w.nextMsg = msg
-	return len(w.nextMsg), nil
-}
-
-func (w *wsWrapper) Write(bytes []byte) (int, error) {
-	return 0, xerrors.New("write unsupported")
-}
-
-func (w *wsWrapper) WriteMsg(bytes []byte) error {
-	return w.wc.WriteMessage(websocket.BinaryMessage, bytes)
-}
-
-func (w *wsWrapper) Close() error {
-	return w.wc.Close()
-}
-
-var _ msgio.ReadWriteCloser = &wsWrapper{}
-
-func wsConnToMio(wc *websocket.Conn) msgio.ReadWriteCloser {
-	return &wsWrapper{
-		wc: wc,
-	}
-}
-
-func HandleNetBstoreWS(ctx context.Context, bs Blockstore, wc *websocket.Conn) *NetworkStoreHandler {
-	return HandleNetBstoreStream(ctx, bs, wsConnToMio(wc))
-}
-
-func NewNetworkStoreWS(wc *websocket.Conn) *NetworkStore {
-	return NewNetworkStore(wsConnToMio(wc))
-}

blockstore/splitstore/checkpoint.go

@@ -5,9 +5,10 @@ import (
 	"io"
 	"os"
 
-	"github.com/ipfs/go-cid"
-	mh "github.com/multiformats/go-multihash"
 	"golang.org/x/xerrors"
+
+	cid "github.com/ipfs/go-cid"
+	mh "github.com/multiformats/go-multihash"
 )
 
 type Checkpoint struct {

blockstore/splitstore/coldset.go

@@ -5,8 +5,9 @@ import (
 	"io"
 	"os"
 
-	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
+
+	cid "github.com/ipfs/go-cid"
 )
 
 type ColdSetWriter struct {

blockstore/splitstore/debug.go

@@ -12,10 +12,11 @@ import (
 	"sync"
 	"time"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
 	"go.uber.org/multierr"
 	"golang.org/x/xerrors"
+
+	blocks "github.com/ipfs/go-block-format"
+	cid "github.com/ipfs/go-cid"
 )
 
 type debugLog struct {

blockstore/splitstore/markset.go

@@ -3,8 +3,9 @@ package splitstore
 import (
 	"errors"
 
-	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
+
+	cid "github.com/ipfs/go-cid"
 )
 
 var errMarkSetClosed = errors.New("markset closed")

blockstore/splitstore/markset_badger.go

@@ -6,11 +6,13 @@ import (
 	"runtime"
 	"sync"
 
+	"golang.org/x/xerrors"
+
 	"github.com/dgraph-io/badger/v2"
 	"github.com/dgraph-io/badger/v2/options"
-	"github.com/ipfs/go-cid"
 	"go.uber.org/zap"
-	"golang.org/x/xerrors"
+
+	cid "github.com/ipfs/go-cid"
 )
 
 type BadgerMarkSetEnv struct {

blockstore/splitstore/markset_map.go

@@ -7,8 +7,9 @@ import (
 	"path/filepath"
 	"sync"
 
-	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
+
+	cid "github.com/ipfs/go-cid"
 )
 
 type MapMarkSetEnv struct {

blockstore/splitstore/markset_test.go

@@ -1,10 +1,10 @@
-// stm: #unit
+//stm: #unit
 package splitstore
 
 import (
 	"testing"
 
-	"github.com/ipfs/go-cid"
+	cid "github.com/ipfs/go-cid"
 	"github.com/multiformats/go-multihash"
 )
 

blockstore/splitstore/splitstore.go

@@ -8,22 +8,22 @@ import (
 	"sync/atomic"
 	"time"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	dstore "github.com/ipfs/go-datastore"
-	ipld "github.com/ipfs/go-ipld-format"
-	logging "github.com/ipfs/go-log/v2"
-	"go.opencensus.io/stats"
 	"go.uber.org/multierr"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	blocks "github.com/ipfs/go-block-format"
+	cid "github.com/ipfs/go-cid"
+	dstore "github.com/ipfs/go-datastore"
+	logging "github.com/ipfs/go-log/v2"
 
+	"github.com/filecoin-project/go-state-types/abi"
 	bstore "github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/metrics"
+
+	"go.opencensus.io/stats"
 )
 
 var (
@@ -43,16 +43,8 @@ var (
 	// compactionIndexKey stores the compaction index (serial number)
 	compactionIndexKey = dstore.NewKey("/splitstore/compactionIndex")
 
-	// stores the prune index (serial number)
-	pruneIndexKey = dstore.NewKey("/splitstore/pruneIndex")
-
-	// stores the base epoch of last prune in the metadata store
-	pruneEpochKey = dstore.NewKey("/splitstore/pruneEpoch")
-
 	log = logging.Logger("splitstore")
 
-	errClosing = errors.New("splitstore is closing")
-
 	// set this to true if you are debugging the splitstore to enable debug logging
 	enableDebugLog = false
 	// set this to true if you want to track origin stack traces in the write log
@@ -62,16 +54,6 @@ var (
 	upgradeBoundary = build.Finality
 )
 
-type CompactType int
-
-const (
-	none CompactType = iota
-	warmup
-	hot
-	cold
-	check
-)
-
 func init() {
 	if os.Getenv("LOTUS_SPLITSTORE_DEBUG_LOG") == "1" {
 		enableDebugLog = true
@@ -98,10 +80,6 @@ type Config struct {
 	// and directly purges cold blocks.
 	DiscardColdBlocks bool
 
-	// UniversalColdBlocks indicates whether all blocks being garbage collected and purged
-	// from the hotstore should be written to the cold store
-	UniversalColdBlocks bool
-
 	// HotstoreMessageRetention indicates the hotstore retention policy for messages.
 	// It has the following semantics:
 	// - a value of 0 will only retain messages within the compaction boundary (4 finalities)
@@ -139,9 +117,8 @@ type hotstore interface {
 }
 
 type SplitStore struct {
-	compacting  int32       // flag for when compaction is in progress
-	compactType CompactType // compaction type, protected by compacting atomic, only meaningful when compacting == 1
-	closing     int32       // the splitstore is closing
+	compacting int32 // compaction/prune/warmup in progress
+	closing    int32 // the splitstore is closing
 
 	cfg  *Config
 	path string
@@ -149,7 +126,6 @@ type SplitStore struct {
 	mx          sync.Mutex
 	warmupEpoch abi.ChainEpoch // protected by mx
 	baseEpoch   abi.ChainEpoch // protected by compaction lock
-	pruneEpoch  abi.ChainEpoch // protected by compaction lock
 
 	headChangeMx sync.Mutex
 
@@ -164,7 +140,6 @@ type SplitStore struct {
 	markSetSize int64
 
 	compactionIndex int64
-	pruneIndex      int64
 
 	ctx    context.Context
 	cancel func()
@@ -252,13 +227,6 @@ func Open(path string, ds dstore.Datastore, hot, cold bstore.Blockstore, cfg *Co
 			return nil, xerrors.Errorf("error resuming compaction: %w", err)
 		}
 	}
-	if ss.pruneCheckpointExists() {
-		log.Info("found prune checkpoint; resuming prune")
-		if err := ss.completePrune(); err != nil {
-			markSetEnv.Close() //nolint:errcheck
-			return nil, xerrors.Errorf("error resuming prune: %w", err)
-		}
-	}
 
 	return ss, nil
 }
@@ -292,14 +260,8 @@ func (s *SplitStore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
 		if has {
 			return s.has(cid)
 		}
-		switch s.compactType {
-		case hot:
-			return s.cold.Has(ctx, cid)
-		case cold:
-			return s.hot.Has(ctx, cid)
-		default:
-			return false, xerrors.Errorf("invalid compaction type %d, only hot and cold allowed for critical section", s.compactType)
-		}
+
+		return s.cold.Has(ctx, cid)
 	}
 
 	has, err := s.hot.Has(ctx, cid)
@@ -314,11 +276,8 @@ func (s *SplitStore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
 	}
 
 	has, err = s.cold.Has(ctx, cid)
-	if has {
-		s.trackTxnRef(cid)
-		if bstore.IsHotView(ctx) {
-			s.reifyColdObject(cid)
-		}
+	if has && bstore.IsHotView(ctx) {
+		s.reifyColdObject(cid)
 	}
 
 	return has, err
@@ -348,31 +307,24 @@ func (s *SplitStore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error)
 		if has {
 			return s.get(cid)
 		}
-		switch s.compactType {
-		case hot:
-			return s.cold.Get(ctx, cid)
-		case cold:
-			return s.hot.Get(ctx, cid)
-		default:
-			return nil, xerrors.Errorf("invalid compaction type %d, only hot and cold allowed for critical section", s.compactType)
-		}
+
+		return s.cold.Get(ctx, cid)
 	}
 
 	blk, err := s.hot.Get(ctx, cid)
 
-	switch {
-	case err == nil:
+	switch err {
+	case nil:
 		s.trackTxnRef(cid)
 		return blk, nil
 
-	case ipld.IsNotFound(err):
+	case bstore.ErrNotFound:
 		if s.isWarm() {
 			s.debug.LogReadMiss(cid)
 		}
 
 		blk, err = s.cold.Get(ctx, cid)
 		if err == nil {
-			s.trackTxnRef(cid)
 			if bstore.IsHotView(ctx) {
 				s.reifyColdObject(cid)
 			}
@@ -409,31 +361,24 @@ func (s *SplitStore) GetSize(ctx context.Context, cid cid.Cid) (int, error) {
 		if has {
 			return s.getSize(cid)
 		}
-		switch s.compactType {
-		case hot:
-			return s.cold.GetSize(ctx, cid)
-		case cold:
-			return s.hot.GetSize(ctx, cid)
-		default:
-			return 0, xerrors.Errorf("invalid compaction type %d, only hot and cold allowed for critical section", s.compactType)
-		}
+
+		return s.cold.GetSize(ctx, cid)
 	}
 
 	size, err := s.hot.GetSize(ctx, cid)
 
-	switch {
-	case err == nil:
+	switch err {
+	case nil:
 		s.trackTxnRef(cid)
 		return size, nil
 
-	case ipld.IsNotFound(err):
+	case bstore.ErrNotFound:
 		if s.isWarm() {
 			s.debug.LogReadMiss(cid)
 		}
 
 		size, err = s.cold.GetSize(ctx, cid)
 		if err == nil {
-			s.trackTxnRef(cid)
 			if bstore.IsHotView(ctx) {
 				s.reifyColdObject(cid)
 			}
@@ -463,12 +408,12 @@ func (s *SplitStore) Put(ctx context.Context, blk blocks.Block) error {
 	s.debug.LogWrite(blk)
 
 	// critical section
-	if s.txnMarkSet != nil && s.compactType == hot { // puts only touch hot store
+	if s.txnMarkSet != nil {
 		s.markLiveRefs([]cid.Cid{blk.Cid()})
 		return nil
 	}
-	s.trackTxnRef(blk.Cid())
 
+	s.trackTxnRef(blk.Cid())
 	return nil
 }
 
@@ -514,12 +459,12 @@ func (s *SplitStore) PutMany(ctx context.Context, blks []blocks.Block) error {
 	s.debug.LogWriteMany(blks)
 
 	// critical section
-	if s.txnMarkSet != nil && s.compactType == hot { // puts only touch hot store
+	if s.txnMarkSet != nil {
 		s.markLiveRefs(batch)
 		return nil
 	}
-	s.trackTxnRefMany(batch)
 
+	s.trackTxnRefMany(batch)
 	return nil
 }
 
@@ -591,14 +536,8 @@ func (s *SplitStore) View(ctx context.Context, cid cid.Cid, cb func([]byte) erro
 		if has {
 			return s.view(cid, cb)
 		}
-		switch s.compactType {
-		case hot:
-			return s.cold.View(ctx, cid, cb)
-		case cold:
-			return s.hot.View(ctx, cid, cb)
-		default:
-			return xerrors.Errorf("invalid compaction type %d, only hot and cold allowed for critical section", s.compactType)
-		}
+
+		return s.cold.View(ctx, cid, cb)
 	}
 
 	// views are (optimistically) protected two-fold:
@@ -613,7 +552,8 @@ func (s *SplitStore) View(ctx context.Context, cid cid.Cid, cb func([]byte) erro
 	defer s.viewDone()
 
 	err := s.hot.View(ctx, cid, cb)
-	if ipld.IsNotFound(err) {
+	switch err {
+	case bstore.ErrNotFound:
 		if s.isWarm() {
 			s.debug.LogReadMiss(cid)
 		}
@@ -627,8 +567,10 @@ func (s *SplitStore) View(ctx context.Context, cid cid.Cid, cb func([]byte) erro
 			stats.Record(s.ctx, metrics.SplitstoreMiss.M(1))
 		}
 		return err
+
+	default:
+		return err
 	}
-	return err
 }
 
 func (s *SplitStore) isWarm() bool {
@@ -684,23 +626,6 @@ func (s *SplitStore) Start(chain ChainAccessor, us stmgr.UpgradeSchedule) error
 		return xerrors.Errorf("error loading base epoch: %w", err)
 	}
 
-	// load prune epoch from metadata ds
-	bs, err = s.ds.Get(s.ctx, pruneEpochKey)
-	switch err {
-	case nil:
-		s.pruneEpoch = bytesToEpoch(bs)
-	case dstore.ErrNotFound:
-		if curTs == nil {
-			//this can happen in some tests
-			break
-		}
-		if err := s.setPruneEpoch(curTs.Height()); err != nil {
-			return xerrors.Errorf("error saving prune epoch: %w", err)
-		}
-	default:
-		return xerrors.Errorf("error loading prune epoch: %w", err)
-	}
-
 	// load warmup epoch from metadata ds
 	bs, err = s.ds.Get(s.ctx, warmupEpochKey)
 	switch err {
@@ -800,8 +725,3 @@ func (s *SplitStore) setBaseEpoch(epoch abi.ChainEpoch) error {
 	s.baseEpoch = epoch
 	return s.ds.Put(s.ctx, baseEpochKey, epochToBytes(epoch))
 }
-
-func (s *SplitStore) setPruneEpoch(epoch abi.ChainEpoch) error {
-	s.pruneEpoch = epoch
-	return s.ds.Put(s.ctx, pruneEpochKey, epochToBytes(epoch))
-}

blockstore/splitstore/splitstore_check.go

@@ -8,9 +8,10 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 
+	cid "github.com/ipfs/go-cid"
+
 	bstore "github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/chain/types"
 )
@@ -25,7 +26,6 @@ func (s *SplitStore) Check() error {
 	if !atomic.CompareAndSwapInt32(&s.compacting, 0, 1) {
 		return xerrors.Errorf("can't acquire compaction lock; compacting operation in progress")
 	}
-	s.compactType = check
 
 	if s.compactionIndex == 0 {
 		atomic.StoreInt32(&s.compacting, 0)
@@ -125,7 +125,7 @@ func (s *SplitStore) doCheck(curTs *types.TipSet) error {
 			}
 
 			return nil
-		}, func(cid.Cid) error { return nil })
+		})
 
 	if err != nil {
 		err = xerrors.Errorf("error walking chain: %w", err)
@@ -147,8 +147,6 @@ func (s *SplitStore) Info() map[string]interface{} {
 	info["base epoch"] = s.baseEpoch
 	info["warmup epoch"] = s.warmupEpoch
 	info["compactions"] = s.compactionIndex
-	info["prunes"] = s.pruneIndex
-	info["compacting"] = s.compacting == 1
 
 	sizer, ok := s.hot.(bstore.BlockstoreSize)
 	if ok {

blockstore/splitstore/splitstore_compact.go

@@ -10,19 +10,20 @@ import (
 	"sync/atomic"
 	"time"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"go.opencensus.io/stats"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	blocks "github.com/ipfs/go-block-format"
+	cid "github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
 
+	"github.com/filecoin-project/go-state-types/abi"
+	bstore "github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/metrics"
+
+	"go.opencensus.io/stats"
 )
 
 var (
@@ -52,12 +53,6 @@ var (
 	// SyncWaitTime is the time delay from a tipset's min timestamp before we decide
 	// we have synced.
 	SyncWaitTime = 30 * time.Second
-
-	// This is a testing flag that should always be true when running a node. itests rely on the rough hack
-	// of starting genesis so far in the past that they exercise catchup mining to mine
-	// blocks quickly and so disabling syncgap checking is necessary to test compaction
-	// without a deep structural improvement of itests.
-	CheckSyncGap = true
 )
 
 var (
@@ -87,7 +82,7 @@ func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
 	//       this is guaranteed by the chainstore, and it is pervasive in all lotus
 	//       -- if that ever changes then all hell will break loose in general and
 	//       we will have a rance to protectTipSets here.
-	//      Regardless, we put a mutex in HeadChange just to be safe
+	//      Reagrdless, we put a mutex in HeadChange just to be safe
 
 	if !atomic.CompareAndSwapInt32(&s.compacting, 0, 1) {
 		// we are currently compacting -- protect the new tipset(s)
@@ -102,8 +97,7 @@ func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
 	}
 
 	timestamp := time.Unix(int64(curTs.MinTimestamp()), 0)
-
-	if CheckSyncGap && time.Since(timestamp) > SyncGapTime {
+	if time.Since(timestamp) > SyncGapTime {
 		// don't attempt compaction before we have caught up syncing
 		atomic.StoreInt32(&s.compacting, 0)
 		return nil
@@ -115,12 +109,9 @@ func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
 		return nil
 	}
 
-	// Prioritize hot store compaction over cold store prune
-
 	if epoch-s.baseEpoch > CompactionThreshold {
 		// it's time to compact -- prepare the transaction and go!
 		s.beginTxnProtect()
-		s.compactType = hot
 		go func() {
 			defer atomic.StoreInt32(&s.compacting, 0)
 			defer s.endTxnProtect()
@@ -132,7 +123,6 @@ func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
 
 			log.Infow("compaction done", "took", time.Since(start))
 		}()
-		// only prune if auto prune is enabled and after at least one compaction
 	} else {
 		// no compaction necessary
 		atomic.StoreInt32(&s.compacting, 0)
@@ -485,7 +475,6 @@ func (s *SplitStore) applyProtectors() error {
 // - At this point we are ready to begin purging:
 //   - We sort cold objects heaviest first, so as to never delete the consituents of a DAG before the DAG itself (which would leave dangling references)
 //   - We delete in small batches taking a lock; each batch is checked again for marks, from the concurrent transactional mark, so as to never delete anything live
-//
 // - We then end the transaction and compact/gc the hotstore.
 func (s *SplitStore) compact(curTs *types.TipSet) {
 	log.Info("waiting for active views to complete")
@@ -528,12 +517,6 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	defer markSet.Close() //nolint:errcheck
 	defer s.debug.Flush()
 
-	coldSet, err := s.markSetEnv.New("cold", s.markSetSize)
-	if err != nil {
-		return xerrors.Errorf("error creating cold mark set: %w", err)
-	}
-	defer coldSet.Close() //nolint:errcheck
-
 	if err := s.checkClosing(); err != nil {
 		return err
 	}
@@ -552,52 +535,24 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	startMark := time.Now()
 
 	count := new(int64)
+	err = s.walkChain(curTs, boundaryEpoch, inclMsgsEpoch, &noopVisitor{},
+		func(c cid.Cid) error {
+			if isUnitaryObject(c) {
+				return errStopWalk
+			}
 
-	coldCount := new(int64)
-	fCold := func(c cid.Cid) error {
-		// Writes to cold set optimized away in universal and discard mode
-		//
-		// Nothing gets written to cold store in discard mode so no cold objects to write
-		// Everything not marked hot gets written to cold store in universal mode so no need to track cold objects separately
-		if s.cfg.DiscardColdBlocks || s.cfg.UniversalColdBlocks {
+			visit, err := markSet.Visit(c)
+			if err != nil {
+				return xerrors.Errorf("error visiting object: %w", err)
+			}
+
+			if !visit {
+				return errStopWalk
+			}
+
+			atomic.AddInt64(count, 1)
 			return nil
-		}
-
-		if isUnitaryObject(c) {
-			return errStopWalk
-		}
-
-		visit, err := coldSet.Visit(c)
-		if err != nil {
-			return xerrors.Errorf("error visiting object: %w", err)
-		}
-
-		if !visit {
-			return errStopWalk
-		}
-
-		atomic.AddInt64(coldCount, 1)
-		return nil
-	}
-	fHot := func(c cid.Cid) error {
-		if isUnitaryObject(c) {
-			return errStopWalk
-		}
-
-		visit, err := markSet.Visit(c)
-		if err != nil {
-			return xerrors.Errorf("error visiting object: %w", err)
-		}
-
-		if !visit {
-			return errStopWalk
-		}
-
-		atomic.AddInt64(count, 1)
-		return nil
-	}
-
-	err = s.walkChain(curTs, boundaryEpoch, inclMsgsEpoch, &noopVisitor{}, fHot, fCold)
+		})
 
 	if err != nil {
 		return xerrors.Errorf("error marking: %w", err)
@@ -631,14 +586,9 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	}
 	defer coldw.Close() //nolint:errcheck
 
-	purgew, err := NewColdSetWriter(s.discardSetPath())
-	if err != nil {
-		return xerrors.Errorf("error creating deadset: %w", err)
-	}
-	defer purgew.Close() //nolint:errcheck
-
 	// some stats for logging
-	var hotCnt, coldCnt, purgeCnt int
+	var hotCnt, coldCnt int
+
 	err = s.hot.ForEachKey(func(c cid.Cid) error {
 		// was it marked?
 		mark, err := markSet.Has(c)
@@ -651,38 +601,19 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 			return nil
 		}
 
-		// it needs to be removed from hot store, mark it as candidate for purge
-		if err := purgew.Write(c); err != nil {
-			return xerrors.Errorf("error writing cid to purge set: %w", err)
-		}
-		purgeCnt++
-
-		coldMark, err := coldSet.Has(c)
-		if err != nil {
-			return xerrors.Errorf("error checking cold mark set for %s: %w", c, err)
-		}
-
-		// Discard mode: coldMark == false, s.cfg.UniversalColdBlocks == false, always return here, no writes to cold store
-		// Universal mode: coldMark == false, s.cfg.UniversalColdBlocks == true, never stop here, all writes to cold store
-		// Otherwise: s.cfg.UniversalColdBlocks == false, if !coldMark stop here and don't write to cold store, if coldMark continue and write to cold store
-		if !coldMark && !s.cfg.UniversalColdBlocks { // universal mode means mark everything as cold
-			return nil
-		}
-
-		// it's cold, mark as candidate for move
+		// it's cold, mark it as candidate for move
 		if err := coldw.Write(c); err != nil {
-			return xerrors.Errorf("error writing cid to cold set")
+			return xerrors.Errorf("error writing cid to coldstore: %w", err)
 		}
 		coldCnt++
 
 		return nil
 	})
+
 	if err != nil {
 		return xerrors.Errorf("error collecting cold objects: %w", err)
 	}
-	if err := purgew.Close(); err != nil {
-		return xerrors.Errorf("erroring closing purgeset: %w", err)
-	}
+
 	if err := coldw.Close(); err != nil {
 		return xerrors.Errorf("error closing coldset: %w", err)
 	}
@@ -731,12 +662,6 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 		}
 	}
 
-	purger, err := NewColdSetReader(s.discardSetPath())
-	if err != nil {
-		return xerrors.Errorf("error opening coldset: %w", err)
-	}
-	defer purger.Close() //nolint:errcheck
-
 	// 4. Purge cold objects with checkpointing for recovery.
 	// This is the critical section of compaction, whereby any cold object not in the markSet is
 	// considered already deleted.
@@ -768,7 +693,7 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	// 5. purge cold objects from the hotstore, taking protected references into account
 	log.Info("purging cold objects from the hotstore")
 	startPurge := time.Now()
-	err = s.purge(purger, checkpoint, markSet)
+	err = s.purge(coldr, checkpoint, markSet)
 	if err != nil {
 		return xerrors.Errorf("error purging cold objects: %w", err)
 	}
@@ -853,10 +778,6 @@ func (s *SplitStore) beginCriticalSection(markSet MarkSet) error {
 
 func (s *SplitStore) waitForSync() {
 	log.Info("waiting for sync")
-	if !CheckSyncGap {
-		log.Warnf("If you see this outside of test it is a serious splitstore issue")
-		return
-	}
 	startWait := time.Now()
 	defer func() {
 		log.Infow("waiting for sync done", "took", time.Since(startWait))
@@ -896,7 +817,7 @@ func (s *SplitStore) endCriticalSection() {
 }
 
 func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEpoch,
-	visitor ObjectVisitor, fHot, fCold func(cid.Cid) error) error {
+	visitor ObjectVisitor, f func(cid.Cid) error) error {
 	var walked ObjectVisitor
 	var mx sync.Mutex
 	// we copy the tipset first into a new slice, which allows us to reuse it in every epoch.
@@ -918,7 +839,7 @@ func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEp
 
 		atomic.AddInt64(walkCnt, 1)
 
-		if err := fHot(c); err != nil {
+		if err := f(c); err != nil {
 			return err
 		}
 
@@ -936,37 +857,27 @@ func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEp
 			if inclMsgs < inclState {
 				// we need to use walkObjectIncomplete here, as messages/receipts may be missing early on if we
 				// synced from snapshot and have a long HotStoreMessageRetentionPolicy.
-				if err := s.walkObjectIncomplete(hdr.Messages, visitor, fHot, stopWalk); err != nil {
+				if err := s.walkObjectIncomplete(hdr.Messages, visitor, f, stopWalk); err != nil {
 					return xerrors.Errorf("error walking messages (cid: %s): %w", hdr.Messages, err)
 				}
 
-				if err := s.walkObjectIncomplete(hdr.ParentMessageReceipts, visitor, fHot, stopWalk); err != nil {
+				if err := s.walkObjectIncomplete(hdr.ParentMessageReceipts, visitor, f, stopWalk); err != nil {
 					return xerrors.Errorf("error walking messages receipts (cid: %s): %w", hdr.ParentMessageReceipts, err)
 				}
 			} else {
-				if err := s.walkObject(hdr.Messages, visitor, fHot); err != nil {
+				if err := s.walkObject(hdr.Messages, visitor, f); err != nil {
 					return xerrors.Errorf("error walking messages (cid: %s): %w", hdr.Messages, err)
 				}
 
-				if err := s.walkObject(hdr.ParentMessageReceipts, visitor, fHot); err != nil {
+				if err := s.walkObject(hdr.ParentMessageReceipts, visitor, f); err != nil {
 					return xerrors.Errorf("error walking message receipts (cid: %s): %w", hdr.ParentMessageReceipts, err)
 				}
 			}
 		}
 
-		// messages and receipts outside of inclMsgs are included in the cold store
-		if hdr.Height < inclMsgs && hdr.Height > 0 {
-			if err := s.walkObjectIncomplete(hdr.Messages, visitor, fCold, stopWalk); err != nil {
-				return xerrors.Errorf("error walking messages (cid: %s): %w", hdr.Messages, err)
-			}
-			if err := s.walkObjectIncomplete(hdr.ParentMessageReceipts, visitor, fCold, stopWalk); err != nil {
-				return xerrors.Errorf("error walking messages receipts (cid: %s): %w", hdr.ParentMessageReceipts, err)
-			}
-		}
-
 		// state is only retained if within the inclState boundary, with the exception of genesis
 		if hdr.Height >= inclState || hdr.Height == 0 {
-			if err := s.walkObject(hdr.ParentStateRoot, visitor, fHot); err != nil {
+			if err := s.walkObject(hdr.ParentStateRoot, visitor, f); err != nil {
 				return xerrors.Errorf("error walking state root (cid: %s): %w", hdr.ParentStateRoot, err)
 			}
 			atomic.AddInt64(scanCnt, 1)
@@ -1154,10 +1065,13 @@ func (s *SplitStore) view(c cid.Cid, cb func([]byte) error) error {
 	}
 
 	err := s.hot.View(s.ctx, c, cb)
-	if ipld.IsNotFound(err) {
+	switch err {
+	case bstore.ErrNotFound:
 		return s.cold.View(s.ctx, c, cb)
+
+	default:
+		return err
 	}
-	return err
 }
 
 func (s *SplitStore) has(c cid.Cid) (bool, error) {
@@ -1176,10 +1090,10 @@ func (s *SplitStore) has(c cid.Cid) (bool, error) {
 
 func (s *SplitStore) get(c cid.Cid) (blocks.Block, error) {
 	blk, err := s.hot.Get(s.ctx, c)
-	switch {
-	case err == nil:
+	switch err {
+	case nil:
 		return blk, nil
-	case ipld.IsNotFound(err):
+	case bstore.ErrNotFound:
 		return s.cold.Get(s.ctx, c)
 	default:
 		return nil, err
@@ -1188,10 +1102,10 @@ func (s *SplitStore) get(c cid.Cid) (blocks.Block, error) {
 
 func (s *SplitStore) getSize(c cid.Cid) (int, error) {
 	sz, err := s.hot.GetSize(s.ctx, c)
-	switch {
-	case err == nil:
+	switch err {
+	case nil:
 		return sz, nil
-	case ipld.IsNotFound(err):
+	case bstore.ErrNotFound:
 		return s.cold.GetSize(s.ctx, c)
 	default:
 		return 0, err
@@ -1205,9 +1119,10 @@ func (s *SplitStore) moveColdBlocks(coldr *ColdSetReader) error {
 		if err := s.checkClosing(); err != nil {
 			return err
 		}
+
 		blk, err := s.hot.Get(s.ctx, c)
 		if err != nil {
-			if ipld.IsNotFound(err) {
+			if err == bstore.ErrNotFound {
 				log.Warnf("hotstore missing block %s", c)
 				return nil
 			}
@@ -1222,7 +1137,6 @@ func (s *SplitStore) moveColdBlocks(coldr *ColdSetReader) error {
 				return xerrors.Errorf("error putting batch to coldstore: %w", err)
 			}
 			batch = batch[:0]
-
 		}
 
 		return nil
@@ -1311,17 +1225,8 @@ func (s *SplitStore) purgeBatch(batch, deadCids []cid.Cid, checkpoint *Checkpoin
 		return 0, liveCnt, nil
 	}
 
-	switch s.compactType {
-	case hot:
-		if err := s.hot.DeleteMany(s.ctx, deadCids); err != nil {
-			return 0, liveCnt, xerrors.Errorf("error purging cold objects: %w", err)
-		}
-	case cold:
-		if err := s.cold.DeleteMany(s.ctx, deadCids); err != nil {
-			return 0, liveCnt, xerrors.Errorf("error purging dead objects: %w", err)
-		}
-	default:
-		return 0, liveCnt, xerrors.Errorf("invalid compaction type %d, only hot and cold allowed for critical section", s.compactType)
+	if err := s.hot.DeleteMany(s.ctx, deadCids); err != nil {
+		return 0, liveCnt, xerrors.Errorf("error purging cold objects: %w", err)
 	}
 
 	s.debug.LogDelete(deadCids)
@@ -1338,28 +1243,15 @@ func (s *SplitStore) coldSetPath() string {
 	return filepath.Join(s.path, "coldset")
 }
 
-func (s *SplitStore) discardSetPath() string {
-	return filepath.Join(s.path, "deadset")
-}
-
 func (s *SplitStore) checkpointPath() string {
 	return filepath.Join(s.path, "checkpoint")
 }
 
-func (s *SplitStore) pruneCheckpointPath() string {
-	return filepath.Join(s.path, "prune-checkpoint")
-}
-
 func (s *SplitStore) checkpointExists() bool {
 	_, err := os.Stat(s.checkpointPath())
 	return err == nil
 }
 
-func (s *SplitStore) pruneCheckpointExists() bool {
-	_, err := os.Stat(s.pruneCheckpointPath())
-	return err == nil
-}
-
 func (s *SplitStore) completeCompaction() error {
 	checkpoint, last, err := OpenCheckpoint(s.checkpointPath())
 	if err != nil {
@@ -1380,7 +1272,6 @@ func (s *SplitStore) completeCompaction() error {
 	defer markSet.Close() //nolint:errcheck
 
 	// PURGE
-	s.compactType = hot
 	log.Info("purging cold objects from the hotstore")
 	startPurge := time.Now()
 	err = s.completePurge(coldr, checkpoint, last, markSet)
@@ -1403,7 +1294,6 @@ func (s *SplitStore) completeCompaction() error {
 	if err := os.Remove(s.coldSetPath()); err != nil {
 		log.Warnf("error removing coldset: %s", err)
 	}
-	s.compactType = none
 
 	// Note: at this point we can start the splitstore; a compaction should run on
 	//       the first head change, which will trigger gc on the hotstore.

blockstore/splitstore/splitstore_expose.go

@@ -5,8 +5,7 @@ import (
 	"errors"
 
 	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
+	cid "github.com/ipfs/go-cid"
 
 	bstore "github.com/filecoin-project/lotus/blockstore"
 )
@@ -43,7 +42,6 @@ func (es *exposedSplitStore) Has(ctx context.Context, c cid.Cid) (bool, error) {
 }
 
 func (es *exposedSplitStore) Get(ctx context.Context, c cid.Cid) (blocks.Block, error) {
-
 	if isIdentiyCid(c) {
 		data, err := decodeIdentityCid(c)
 		if err != nil {
@@ -54,10 +52,12 @@ func (es *exposedSplitStore) Get(ctx context.Context, c cid.Cid) (blocks.Block,
 	}
 
 	blk, err := es.s.hot.Get(ctx, c)
-	if ipld.IsNotFound(err) {
+	switch err {
+	case bstore.ErrNotFound:
 		return es.s.cold.Get(ctx, c)
+	default:
+		return blk, err
 	}
-	return blk, err
 }
 
 func (es *exposedSplitStore) GetSize(ctx context.Context, c cid.Cid) (int, error) {
@@ -71,10 +71,12 @@ func (es *exposedSplitStore) GetSize(ctx context.Context, c cid.Cid) (int, error
 	}
 
 	size, err := es.s.hot.GetSize(ctx, c)
-	if ipld.IsNotFound(err) {
+	switch err {
+	case bstore.ErrNotFound:
 		return es.s.cold.GetSize(ctx, c)
+	default:
+		return size, err
 	}
-	return size, err
 }
 
 func (es *exposedSplitStore) Put(ctx context.Context, blk blocks.Block) error {
@@ -102,9 +104,11 @@ func (es *exposedSplitStore) View(ctx context.Context, c cid.Cid, f func([]byte)
 	}
 
 	err := es.s.hot.View(ctx, c, f)
-	if ipld.IsNotFound(err) {
+	switch err {
+	case bstore.ErrNotFound:
 		return es.s.cold.View(ctx, c, f)
-	}
 
-	return err
+	default:
+		return err
+	}
 }

blockstore/splitstore/splitstore_gc.go

@@ -27,7 +27,7 @@ func (s *SplitStore) gcBlockstore(b bstore.Blockstore, opts []bstore.BlockstoreG
 			return err
 		}
 
-		log.Infow("garbage collecting blockstore done", "took", time.Since(startGC))
+		log.Infow("garbage collecting hotstore done", "took", time.Since(startGC))
 		return nil
 	}
 

blockstore/splitstore/splitstore_prune.go

@@ -1,574 +0,0 @@
-package splitstore
-
-import (
-	"bytes"
-	"os"
-	"runtime"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	cid "github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"go.opencensus.io/stats"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/api"
-	bstore "github.com/filecoin-project/lotus/blockstore"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/metrics"
-)
-
-var (
-	// PruneOnline is a prune option that instructs PruneChain to use online gc for reclaiming space;
-	// there is no value associated with this option.
-	PruneOnlineGC = "splitstore.PruneOnlineGC"
-
-	// PruneMoving is a prune option that instructs PruneChain to use moving gc for reclaiming space;
-	// the value associated with this option is the path of the new coldstore.
-	PruneMovingGC = "splitstore.PruneMovingGC"
-
-	// PruneRetainState is a prune option that instructs PruneChain as to how many finalities worth
-	// of state to retain in the coldstore.
-	// The value is an integer:
-	// - if it is -1 then all state objects reachable from the chain will be retained in the coldstore.
-	//   this is useful for garbage collecting side-chains and other garbage in archival nodes.
-	//   This is the (safe) default.
-	// - if it is 0 then no state objects that are unreachable within the compaction boundary will
-	//   be retained in the coldstore.
-	// - if it is a positive integer, then it's the number of finalities past the compaction boundary
-	//   for which chain-reachable state objects are retained.
-	PruneRetainState = "splitstore.PruneRetainState"
-
-	// PruneThreshold is the number of epochs that need to have elapsed
-	// from the previously pruned epoch to trigger a new prune
-	PruneThreshold = 7 * build.Finality
-)
-
-// PruneChain instructs the SplitStore to prune chain state in the coldstore, according to the
-// options specified.
-func (s *SplitStore) PruneChain(opts api.PruneOpts) error {
-	retainState := opts.RetainState
-
-	var gcOpts []bstore.BlockstoreGCOption
-	if opts.MovingGC {
-		gcOpts = append(gcOpts, bstore.WithFullGC(true))
-	}
-	doGC := func() error { return s.gcBlockstore(s.cold, gcOpts) }
-
-	var retainStateP func(int64) bool
-	switch {
-	case retainState > 0:
-		retainStateP = func(depth int64) bool {
-			return depth <= int64(CompactionBoundary)+retainState*int64(build.Finality)
-		}
-	case retainState < 0:
-		retainStateP = func(_ int64) bool { return true }
-	default:
-		retainStateP = func(depth int64) bool {
-			return depth <= int64(CompactionBoundary)
-		}
-	}
-
-	if _, ok := s.cold.(bstore.BlockstoreIterator); !ok {
-		return xerrors.Errorf("coldstore does not support efficient iteration")
-	}
-
-	return s.pruneChain(retainStateP, doGC)
-}
-
-func (s *SplitStore) pruneChain(retainStateP func(int64) bool, doGC func() error) error {
-	// inhibit compaction while we are setting up
-	s.headChangeMx.Lock()
-	defer s.headChangeMx.Unlock()
-
-	// take the compaction lock; fail if there is a compaction in progress
-	if !atomic.CompareAndSwapInt32(&s.compacting, 0, 1) {
-		return xerrors.Errorf("compaction, prune or warmup in progress")
-	}
-
-	// check if we are actually closing first
-	if atomic.LoadInt32(&s.closing) == 1 {
-		atomic.StoreInt32(&s.compacting, 0)
-		return errClosing
-	}
-
-	// ensure that we have compacted at least once
-	if s.compactionIndex == 0 {
-		atomic.StoreInt32(&s.compacting, 0)
-		return xerrors.Errorf("splitstore has not compacted yet")
-	}
-
-	// get the current tipset
-	curTs := s.chain.GetHeaviestTipSet()
-
-	// begin the transaction and go
-	s.beginTxnProtect()
-	s.compactType = cold
-	go func() {
-		defer atomic.StoreInt32(&s.compacting, 0)
-		defer s.endTxnProtect()
-
-		log.Info("pruning splitstore")
-		start := time.Now()
-
-		s.prune(curTs, retainStateP, doGC)
-
-		log.Infow("prune done", "took", time.Since(start))
-	}()
-
-	return nil
-}
-
-func (s *SplitStore) prune(curTs *types.TipSet, retainStateP func(int64) bool, doGC func() error) {
-	log.Debug("waiting for active views to complete")
-	start := time.Now()
-	s.viewWait()
-	log.Debugw("waiting for active views done", "took", time.Since(start))
-
-	err := s.doPrune(curTs, retainStateP, doGC)
-	if err != nil {
-		log.Errorf("PRUNE ERROR: %s", err)
-	}
-}
-
-func (s *SplitStore) doPrune(curTs *types.TipSet, retainStateP func(int64) bool, doGC func() error) error {
-	currentEpoch := curTs.Height()
-	boundaryEpoch := currentEpoch - CompactionBoundary
-
-	log.Infow("running prune", "currentEpoch", currentEpoch, "pruneEpoch", s.pruneEpoch)
-
-	markSet, err := s.markSetEnv.New("live", s.markSetSize)
-	if err != nil {
-		return xerrors.Errorf("error creating mark set: %w", err)
-	}
-	defer markSet.Close() //nolint:errcheck
-	defer s.debug.Flush()
-
-	if err := s.checkClosing(); err != nil {
-		return err
-	}
-
-	// 0. track all protected references at beginning of compaction; anything added later should
-	//    be transactionally protected by the write
-	log.Info("protecting references with registered protectors")
-	err = s.applyProtectors()
-	if err != nil {
-		return err
-	}
-
-	// 1. mark reachable objects by walking the chain from the current epoch; we keep all messages
-	//    and chain headers; state and reciepts are retained only if it is within retention policy scope
-	log.Info("marking reachable objects")
-	startMark := time.Now()
-
-	count := new(int64)
-	err = s.walkChainDeep(curTs, retainStateP,
-		func(c cid.Cid) error {
-			if isUnitaryObject(c) {
-				return errStopWalk
-			}
-
-			mark, err := markSet.Has(c)
-			if err != nil {
-				return xerrors.Errorf("error checking markset: %w", err)
-			}
-
-			if mark {
-				return errStopWalk
-			}
-
-			atomic.AddInt64(count, 1)
-			return markSet.Mark(c)
-		})
-
-	if err != nil {
-		return xerrors.Errorf("error marking: %w", err)
-	}
-
-	log.Infow("marking done", "took", time.Since(startMark), "marked", count)
-
-	if err := s.checkClosing(); err != nil {
-		return err
-	}
-
-	// 1.1 protect transactional refs
-	err = s.protectTxnRefs(markSet)
-	if err != nil {
-		return xerrors.Errorf("error protecting transactional refs: %w", err)
-	}
-
-	if err := s.checkClosing(); err != nil {
-		return err
-	}
-
-	// 2. iterate through the coldstore to collect dead objects
-	log.Info("collecting dead objects")
-	startCollect := time.Now()
-
-	deadw, err := NewColdSetWriter(s.discardSetPath())
-	if err != nil {
-		return xerrors.Errorf("error creating coldset: %w", err)
-	}
-	defer deadw.Close() //nolint:errcheck
-
-	// some stats for logging
-	var liveCnt, deadCnt int
-
-	err = s.cold.(bstore.BlockstoreIterator).ForEachKey(func(c cid.Cid) error {
-		// was it marked?
-		mark, err := markSet.Has(c)
-		if err != nil {
-			return xerrors.Errorf("error checking mark set for %s: %w", c, err)
-		}
-
-		if mark {
-			liveCnt++
-			return nil
-		}
-
-		// Note: a possible optimization here is to also purge objects that are in the hotstore
-		//       but this needs special care not to purge genesis state, so we don't bother (yet)
-
-		// it's dead in the coldstore, mark it as candidate for purge
-
-		if err := deadw.Write(c); err != nil {
-			return xerrors.Errorf("error writing cid to coldstore: %w", err)
-		}
-		deadCnt++
-
-		return nil
-	})
-
-	if err != nil {
-		return xerrors.Errorf("error dead objects: %w", err)
-	}
-
-	if err := deadw.Close(); err != nil {
-		return xerrors.Errorf("error closing deadset: %w", err)
-	}
-
-	stats.Record(s.ctx, metrics.SplitstoreCompactionDead.M(int64(deadCnt)))
-
-	log.Infow("dead collection done", "took", time.Since(startCollect))
-	log.Infow("prune stats", "live", liveCnt, "dead", deadCnt)
-
-	if err := s.checkClosing(); err != nil {
-		return err
-	}
-
-	// now that we have collected dead objects, check for missing references from transactional i/o
-	// this is carried over from hot compaction for completeness
-	s.waitForMissingRefs(markSet)
-
-	if err := s.checkClosing(); err != nil {
-		return err
-	}
-
-	deadr, err := NewColdSetReader(s.discardSetPath())
-	if err != nil {
-		return xerrors.Errorf("error opening deadset: %w", err)
-	}
-	defer deadr.Close() //nolint:errcheck
-
-	// 3. Purge dead objects with checkpointing for recovery.
-	// This is the critical section of prune, whereby any dead object not in the markSet is
-	// considered already deleted.
-	// We delete dead objects in batches, holding the transaction lock, where we check the markSet
-	// again for new references created by the caller.
-	// After each batch we write a checkpoint to disk; if the process is interrupted before completion
-	// the process will continue from the checkpoint in the next recovery.
-	if err := s.beginCriticalSection(markSet); err != nil {
-		return xerrors.Errorf("error beginning critical section: %w", err)
-	}
-
-	if err := s.checkClosing(); err != nil {
-		return err
-	}
-
-	checkpoint, err := NewCheckpoint(s.pruneCheckpointPath())
-	if err != nil {
-		return xerrors.Errorf("error creating checkpoint: %w", err)
-	}
-	defer checkpoint.Close() //nolint:errcheck
-
-	log.Info("purging dead objects from the coldstore")
-	startPurge := time.Now()
-	err = s.purge(deadr, checkpoint, markSet)
-	if err != nil {
-		return xerrors.Errorf("error purging dead objects: %w", err)
-	}
-	log.Infow("purging dead objects from coldstore done", "took", time.Since(startPurge))
-
-	s.endCriticalSection()
-
-	if err := checkpoint.Close(); err != nil {
-		log.Warnf("error closing checkpoint: %s", err)
-	}
-	if err := os.Remove(s.pruneCheckpointPath()); err != nil {
-		log.Warnf("error removing checkpoint: %s", err)
-	}
-	if err := deadr.Close(); err != nil {
-		log.Warnf("error closing discard set: %s", err)
-	}
-	if err := os.Remove(s.discardSetPath()); err != nil {
-		log.Warnf("error removing discard set: %s", err)
-	}
-
-	// we are done; do some housekeeping
-	s.endTxnProtect()
-	err = doGC()
-	if err != nil {
-		log.Warnf("error garbage collecting cold store: %s", err)
-	}
-
-	if err := s.setPruneEpoch(boundaryEpoch); err != nil {
-		return xerrors.Errorf("error saving prune base epoch: %w", err)
-	}
-
-	s.pruneIndex++
-	err = s.ds.Put(s.ctx, pruneIndexKey, int64ToBytes(s.compactionIndex))
-	if err != nil {
-		return xerrors.Errorf("error saving compaction index: %w", err)
-	}
-
-	return nil
-}
-
-func (s *SplitStore) completePrune() error {
-	checkpoint, last, err := OpenCheckpoint(s.pruneCheckpointPath())
-	if err != nil {
-		return xerrors.Errorf("error opening checkpoint: %w", err)
-	}
-	defer checkpoint.Close() //nolint:errcheck
-
-	deadr, err := NewColdSetReader(s.discardSetPath())
-	if err != nil {
-		return xerrors.Errorf("error opening deadset: %w", err)
-	}
-	defer deadr.Close() //nolint:errcheck
-
-	markSet, err := s.markSetEnv.Recover("live")
-	if err != nil {
-		return xerrors.Errorf("error recovering markset: %w", err)
-	}
-	defer markSet.Close() //nolint:errcheck
-
-	// PURGE!
-	s.compactType = cold
-	log.Info("purging dead objects from the coldstore")
-	startPurge := time.Now()
-	err = s.completePurge(deadr, checkpoint, last, markSet)
-	if err != nil {
-		return xerrors.Errorf("error purgin dead objects: %w", err)
-	}
-	log.Infow("purging dead objects from the coldstore done", "took", time.Since(startPurge))
-
-	markSet.EndCriticalSection()
-	s.compactType = none
-
-	if err := checkpoint.Close(); err != nil {
-		log.Warnf("error closing checkpoint: %s", err)
-	}
-	if err := os.Remove(s.pruneCheckpointPath()); err != nil {
-		log.Warnf("error removing checkpoint: %s", err)
-	}
-	if err := deadr.Close(); err != nil {
-		log.Warnf("error closing deadset: %s", err)
-	}
-	if err := os.Remove(s.discardSetPath()); err != nil {
-		log.Warnf("error removing deadset: %s", err)
-	}
-
-	return nil
-}
-
-// like walkChain but peforms a deep walk, using parallel walking with walkObjectLax,
-// whereby all extant messages are retained and state roots are retained if they satisfy
-// the given predicate.
-// missing references are ignored, as we expect to have plenty for snapshot syncs.
-func (s *SplitStore) walkChainDeep(ts *types.TipSet, retainStateP func(int64) bool,
-	f func(cid.Cid) error) error {
-	visited := cid.NewSet()
-	toWalk := ts.Cids()
-	walkCnt := 0
-
-	workers := runtime.NumCPU() / 2
-	if workers < 2 {
-		workers = 2
-	}
-
-	var wg sync.WaitGroup
-	workch := make(chan cid.Cid, 16*workers)
-	errch := make(chan error, workers)
-
-	var once sync.Once
-	defer once.Do(func() { close(workch) })
-
-	push := func(c cid.Cid) error {
-		if !visited.Visit(c) {
-			return nil
-		}
-
-		select {
-		case workch <- c:
-			return nil
-		case err := <-errch:
-			return err
-		}
-	}
-
-	worker := func() {
-		defer wg.Done()
-		for c := range workch {
-			err := s.walkObjectLax(c, f)
-			if err != nil {
-				errch <- xerrors.Errorf("error walking object (cid: %s): %w", c, err)
-				return
-			}
-		}
-	}
-
-	for i := 0; i < workers; i++ {
-		wg.Add(1)
-		go worker()
-	}
-
-	baseEpoch := ts.Height()
-	minEpoch := baseEpoch // for progress report
-	log.Infof("walking at epoch %d", minEpoch)
-
-	walkBlock := func(c cid.Cid) error {
-		if !visited.Visit(c) {
-			return nil
-		}
-
-		walkCnt++
-
-		if err := f(c); err != nil {
-			return err
-		}
-
-		var hdr types.BlockHeader
-		err := s.view(c, func(data []byte) error {
-			return hdr.UnmarshalCBOR(bytes.NewBuffer(data))
-		})
-
-		if err != nil {
-			return xerrors.Errorf("error unmarshaling block header (cid: %s): %w", c, err)
-		}
-
-		if hdr.Height < minEpoch {
-			minEpoch = hdr.Height
-			if minEpoch%10_000 == 0 {
-				log.Infof("walking at epoch %d (walked: %d)", minEpoch, walkCnt)
-			}
-		}
-
-		depth := int64(baseEpoch - hdr.Height)
-		retainState := retainStateP(depth)
-
-		if hdr.Height > 0 {
-			if err := push(hdr.Messages); err != nil {
-				return err
-			}
-			if retainState {
-				if err := push(hdr.ParentMessageReceipts); err != nil {
-					return err
-				}
-			}
-		}
-
-		if retainState || hdr.Height == 0 {
-			if err := push(hdr.ParentStateRoot); err != nil {
-				return err
-			}
-		}
-
-		if hdr.Height > 0 {
-			toWalk = append(toWalk, hdr.Parents...)
-		}
-
-		return nil
-	}
-
-	for len(toWalk) > 0 {
-		// walking can take a while, so check this with every opportunity
-		if err := s.checkClosing(); err != nil {
-			return err
-		}
-
-		select {
-		case err := <-errch:
-			return err
-		default:
-		}
-
-		walking := toWalk
-		toWalk = nil
-		for _, c := range walking {
-			if err := walkBlock(c); err != nil {
-				return xerrors.Errorf("error walking block (cid: %s): %w", c, err)
-			}
-		}
-	}
-
-	once.Do(func() { close(workch) })
-	wg.Wait()
-	select {
-	case err := <-errch:
-		return err
-	default:
-	}
-
-	log.Infow("chain walk done", "walked", walkCnt)
-
-	return nil
-}
-
-// like walkObject but treats missing references laxly; faster version of walkObjectIncomplete
-// without an occurs check.
-func (s *SplitStore) walkObjectLax(c cid.Cid, f func(cid.Cid) error) error {
-	if err := f(c); err != nil {
-		if err == errStopWalk {
-			return nil
-		}
-
-		return err
-	}
-
-	if c.Prefix().Codec != cid.DagCBOR {
-		return nil
-	}
-
-	// check this before recursing
-	if err := s.checkClosing(); err != nil {
-		return err
-	}
-
-	var links []cid.Cid
-	err := s.view(c, func(data []byte) error {
-		return cbg.ScanForLinks(bytes.NewReader(data), func(c cid.Cid) {
-			links = append(links, c)
-		})
-	})
-
-	if err != nil {
-		if ipld.IsNotFound(err) { // not a problem for deep walks
-			return nil
-		}
-
-		return xerrors.Errorf("error scanning linked block (cid: %s): %w", c, err)
-	}
-
-	for _, c := range links {
-		err := s.walkObjectLax(c, f)
-		if err != nil {
-			return xerrors.Errorf("error walking link (cid: %s): %w", c, err)
-		}
-	}
-
-	return nil
-}

blockstore/splitstore/splitstore_reify.go

@@ -5,9 +5,10 @@ import (
 	"runtime"
 	"sync/atomic"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
+
+	blocks "github.com/ipfs/go-block-format"
+	cid "github.com/ipfs/go-cid"
 )
 
 var (
@@ -83,7 +84,7 @@ func (s *SplitStore) reifyWorker(workch chan cid.Cid) {
 }
 
 func (s *SplitStore) doReify(c cid.Cid) {
-	var toreify, toforget []cid.Cid
+	var toreify, totrack, toforget []cid.Cid
 
 	defer func() {
 		s.reifyMx.Lock()
@@ -92,6 +93,9 @@ func (s *SplitStore) doReify(c cid.Cid) {
 		for _, c := range toreify {
 			delete(s.reifyInProgress, c)
 		}
+		for _, c := range totrack {
+			delete(s.reifyInProgress, c)
+		}
 		for _, c := range toforget {
 			delete(s.reifyInProgress, c)
 		}
@@ -128,10 +132,19 @@ func (s *SplitStore) doReify(c cid.Cid) {
 				return xerrors.Errorf("error checking hotstore: %w", err)
 			}
 
-			// All reified blocks are tracked at reification start
 			if has {
-				toforget = append(toforget, c)
-				return errStopWalk
+				if s.txnMarkSet != nil {
+					hasMark, err := s.txnMarkSet.Has(c)
+					if err != nil {
+						log.Warnf("error checking markset: %s", err)
+					} else if hasMark {
+						toforget = append(toforget, c)
+						return errStopWalk
+					}
+				} else {
+					totrack = append(totrack, c)
+					return errStopWalk
+				}
 			}
 
 			toreify = append(toreify, c)
@@ -143,7 +156,7 @@ func (s *SplitStore) doReify(c cid.Cid) {
 		})
 
 	if err != nil {
-		if errors.Is(err, errReifyLimit) {
+		if xerrors.Is(err, errReifyLimit) {
 			log.Debug("reification aborted; reify limit reached")
 			return
 		}
@@ -178,4 +191,24 @@ func (s *SplitStore) doReify(c cid.Cid) {
 		}
 	}
 
+	if s.txnMarkSet != nil {
+		if len(toreify) > 0 {
+			if err := s.txnMarkSet.MarkMany(toreify); err != nil {
+				log.Warnf("error marking reified objects: %s", err)
+			}
+		}
+		if len(totrack) > 0 {
+			if err := s.txnMarkSet.MarkMany(totrack); err != nil {
+				log.Warnf("error marking tracked objects: %s", err)
+			}
+		}
+	} else {
+		// if txnActive is false these are noops
+		if len(toreify) > 0 {
+			s.trackTxnRefMany(toreify)
+		}
+		if len(totrack) > 0 {
+			s.trackTxnRefMany(totrack)
+		}
+	}
 }

blockstore/splitstore/splitstore_test.go

@@ -1,4 +1,4 @@
-// stm: #unit
+//stm: #unit
 package splitstore
 
 import (
@@ -11,20 +11,18 @@ import (
 	"testing"
 	"time"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-datastore"
-	dssync "github.com/ipfs/go-datastore/sync"
-	ipld "github.com/ipfs/go-ipld-format"
-	logging "github.com/ipfs/go-log/v2"
-	mh "github.com/multiformats/go-multihash"
-
 	"github.com/filecoin-project/go-state-types/abi"
-
 	"github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/types/mock"
+
+	blocks "github.com/ipfs/go-block-format"
+	cid "github.com/ipfs/go-cid"
+	datastore "github.com/ipfs/go-datastore"
+	dssync "github.com/ipfs/go-datastore/sync"
+	logging "github.com/ipfs/go-log/v2"
+	mh "github.com/multiformats/go-multihash"
 )
 
 func init() {
@@ -38,7 +36,6 @@ func init() {
 func testSplitStore(t *testing.T, cfg *Config) {
 	ctx := context.Background()
 	chain := &mockChain{t: t}
-	fmt.Printf("Config: %v\n", cfg)
 
 	// the myriads of stores
 	ds := dssync.MutexWrap(datastore.NewMapDatastore())
@@ -226,7 +223,7 @@ func TestSplitStoreCompaction(t *testing.T) {
 	//stm: @SPLITSTORE_SPLITSTORE_OPEN_001, @SPLITSTORE_SPLITSTORE_CLOSE_001
 	//stm: @SPLITSTORE_SPLITSTORE_PUT_001, @SPLITSTORE_SPLITSTORE_ADD_PROTECTOR_001
 	//stm: @SPLITSTORE_SPLITSTORE_CLOSE_001
-	testSplitStore(t, &Config{MarkSetType: "map", UniversalColdBlocks: true})
+	testSplitStore(t, &Config{MarkSetType: "map"})
 }
 
 func TestSplitStoreCompactionWithBadger(t *testing.T) {
@@ -238,7 +235,7 @@ func TestSplitStoreCompactionWithBadger(t *testing.T) {
 	t.Cleanup(func() {
 		badgerMarkSetBatchSize = bs
 	})
-	testSplitStore(t, &Config{MarkSetType: "badger", UniversalColdBlocks: true})
+	testSplitStore(t, &Config{MarkSetType: "badger"})
 }
 
 func TestSplitStoreSuppressCompactionNearUpgrade(t *testing.T) {
@@ -284,7 +281,7 @@ func TestSplitStoreSuppressCompactionNearUpgrade(t *testing.T) {
 	path := t.TempDir()
 
 	// open the splitstore
-	ss, err := Open(path, ds, hot, cold, &Config{MarkSetType: "map", UniversalColdBlocks: true})
+	ss, err := Open(path, ds, hot, cold, &Config{MarkSetType: "map"})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -423,7 +420,7 @@ func testSplitStoreReification(t *testing.T, f func(context.Context, blockstore.
 
 	path := t.TempDir()
 
-	ss, err := Open(path, ds, hot, cold, &Config{MarkSetType: "map", UniversalColdBlocks: true})
+	ss, err := Open(path, ds, hot, cold, &Config{MarkSetType: "map"})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -523,7 +520,7 @@ func testSplitStoreReificationLimit(t *testing.T, f func(context.Context, blocks
 
 	path := t.TempDir()
 
-	ss, err := Open(path, ds, hot, cold, &Config{MarkSetType: "map", UniversalColdBlocks: true})
+	ss, err := Open(path, ds, hot, cold, &Config{MarkSetType: "map"})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -699,7 +696,7 @@ func (b *mockStore) Get(_ context.Context, cid cid.Cid) (blocks.Block, error) {
 
 	blk, ok := b.set[b.keyOf(cid)]
 	if !ok {
-		return nil, ipld.ErrNotFound{Cid: cid}
+		return nil, blockstore.ErrNotFound
 	}
 	return blk, nil
 }

blockstore/splitstore/splitstore_util.go

@@ -3,10 +3,11 @@ package splitstore
 import (
 	"encoding/binary"
 
-	"github.com/ipfs/go-cid"
-	mh "github.com/multiformats/go-multihash"
 	"golang.org/x/xerrors"
 
+	cid "github.com/ipfs/go-cid"
+	mh "github.com/multiformats/go-multihash"
+
 	"github.com/filecoin-project/go-state-types/abi"
 )
 

blockstore/splitstore/splitstore_warmup.go

@@ -5,13 +5,13 @@ import (
 	"sync/atomic"
 	"time"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	blocks "github.com/ipfs/go-block-format"
+	cid "github.com/ipfs/go-cid"
 
+	"github.com/filecoin-project/go-state-types/abi"
+	bstore "github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 )
@@ -21,14 +21,14 @@ var (
 	WarmupBoundary = build.Finality
 )
 
-// warmup acquires the compaction lock and spawns a goroutine to warm up the hotstore;
+// warmup acuiqres the compaction lock and spawns a goroutine to warm up the hotstore;
 // this is necessary when we sync from a snapshot or when we enable the splitstore
 // on top of an existing blockstore (which becomes the coldstore).
 func (s *SplitStore) warmup(curTs *types.TipSet) error {
 	if !atomic.CompareAndSwapInt32(&s.compacting, 0, 1) {
 		return xerrors.Errorf("error locking compaction")
 	}
-	s.compactType = warmup
+
 	go func() {
 		defer atomic.StoreInt32(&s.compacting, 0)
 
@@ -88,7 +88,7 @@ func (s *SplitStore) doWarmup(curTs *types.TipSet) error {
 
 			blk, err := s.cold.Get(s.ctx, c)
 			if err != nil {
-				if ipld.IsNotFound(err) {
+				if err == bstore.ErrNotFound {
 					atomic.AddInt64(missing, 1)
 					return errStopWalk
 				}
@@ -110,7 +110,7 @@ func (s *SplitStore) doWarmup(curTs *types.TipSet) error {
 			mx.Unlock()
 
 			return nil
-		}, func(cid.Cid) error { return nil })
+		})
 
 	if err != nil {
 		return err

blockstore/splitstore/visitor.go

@@ -3,7 +3,7 @@ package splitstore
 import (
 	"sync"
 
-	"github.com/ipfs/go-cid"
+	cid "github.com/ipfs/go-cid"
 )
 
 // ObjectVisitor is an interface for deduplicating objects during walks

blockstore/timed.go

@@ -8,7 +8,6 @@ import (
 
 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
 	"github.com/raulk/clock"
 	"go.uber.org/multierr"
 )
@@ -113,7 +112,7 @@ func (t *TimedCacheBlockstore) View(ctx context.Context, k cid.Cid, callback fun
 	// calling an arbitrary callback while holding a lock.
 	t.mu.RLock()
 	block, err := t.active.Get(ctx, k)
-	if ipld.IsNotFound(err) {
+	if err == ErrNotFound {
 		block, err = t.inactive.Get(ctx, k)
 	}
 	t.mu.RUnlock()
@@ -128,7 +127,7 @@ func (t *TimedCacheBlockstore) Get(ctx context.Context, k cid.Cid) (blocks.Block
 	t.mu.RLock()
 	defer t.mu.RUnlock()
 	b, err := t.active.Get(ctx, k)
-	if ipld.IsNotFound(err) {
+	if err == ErrNotFound {
 		b, err = t.inactive.Get(ctx, k)
 	}
 	return b, err
@@ -138,7 +137,7 @@ func (t *TimedCacheBlockstore) GetSize(ctx context.Context, k cid.Cid) (int, err
 	t.mu.RLock()
 	defer t.mu.RUnlock()
 	size, err := t.active.GetSize(ctx, k)
-	if ipld.IsNotFound(err) {
+	if err == ErrNotFound {
 		size, err = t.inactive.GetSize(ctx, k)
 	}
 	return size, err
@@ -176,12 +175,11 @@ func (t *TimedCacheBlockstore) AllKeysChan(_ context.Context) (<-chan cid.Cid, e
 	defer t.mu.RUnlock()
 
 	ch := make(chan cid.Cid, len(t.active)+len(t.inactive))
-	for _, b := range t.active {
-		ch <- b.Cid()
+	for c := range t.active {
+		ch <- c
 	}
-	for _, b := range t.inactive {
-		c := b.Cid()
-		if _, ok := t.active[string(c.Hash())]; ok {
+	for c := range t.inactive {
+		if _, ok := t.active[c]; ok {
 			continue
 		}
 		ch <- c

blockstore/timed_test.go

@@ -1,4 +1,4 @@
-// stm: #unit
+//stm: #unit
 package blockstore
 
 import (
@@ -6,10 +6,11 @@ import (
 	"testing"
 	"time"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
 	"github.com/raulk/clock"
 	"github.com/stretchr/testify/require"
+
+	blocks "github.com/ipfs/go-block-format"
+	"github.com/ipfs/go-cid"
 )
 
 func TestTimedCacheBlockstoreSimple(t *testing.T) {

blockstore/union.go

@@ -5,16 +5,16 @@ import (
 
 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
 )
 
 type unionBlockstore []Blockstore
 
 // Union returns an unioned blockstore.
 //
-//   - Reads return from the first blockstore that has the value, querying in the
-//     supplied order.
-//   - Writes (puts and deletes) are broadcast to all stores.
+// * Reads return from the first blockstore that has the value, querying in the
+//   supplied order.
+// * Writes (puts and deltes) are broadcast to all stores.
+//
 func Union(stores ...Blockstore) Blockstore {
 	return unionBlockstore(stores)
 }
@@ -30,7 +30,7 @@ func (m unionBlockstore) Has(ctx context.Context, cid cid.Cid) (has bool, err er
 
 func (m unionBlockstore) Get(ctx context.Context, cid cid.Cid) (blk blocks.Block, err error) {
 	for _, bs := range m {
-		if blk, err = bs.Get(ctx, cid); err == nil || !ipld.IsNotFound(err) {
+		if blk, err = bs.Get(ctx, cid); err == nil || err != ErrNotFound {
 			break
 		}
 	}
@@ -39,7 +39,7 @@ func (m unionBlockstore) Get(ctx context.Context, cid cid.Cid) (blk blocks.Block
 
 func (m unionBlockstore) View(ctx context.Context, cid cid.Cid, callback func([]byte) error) (err error) {
 	for _, bs := range m {
-		if err = bs.View(ctx, cid, callback); err == nil || !ipld.IsNotFound(err) {
+		if err = bs.View(ctx, cid, callback); err == nil || err != ErrNotFound {
 			break
 		}
 	}
@@ -48,7 +48,7 @@ func (m unionBlockstore) View(ctx context.Context, cid cid.Cid, callback func([]
 
 func (m unionBlockstore) GetSize(ctx context.Context, cid cid.Cid) (size int, err error) {
 	for _, bs := range m {
-		if size, err = bs.GetSize(ctx, cid); err == nil || !ipld.IsNotFound(err) {
+		if size, err = bs.GetSize(ctx, cid); err == nil || err != ErrNotFound {
 			break
 		}
 	}

blockstore/union_test.go

@@ -1,4 +1,4 @@
-// stm: #unit
+//stm: #unit
 package blockstore
 
 import (
@@ -13,7 +13,6 @@ var (
 	b0 = blocks.NewBlock([]byte("abc"))
 	b1 = blocks.NewBlock([]byte("foo"))
 	b2 = blocks.NewBlock([]byte("bar"))
-	b3 = blocks.NewBlock([]byte("baz"))
 )
 
 func TestUnionBlockstore_Get(t *testing.T) {

build/actors/README.md

@@ -1,26 +0,0 @@
-# Bundles
-
-This directory includes the actors bundles for each release. Each actor bundle is a zstd compressed
-tarfile containing one bundle per network type. These tarfiles are subsequently embedded in the
-lotus binary.
-
-## Updating
-
-To update, run the `./pack.sh` script. For example, the following will pack the [builtin actors release](https://github.com/filecoin-project/builtin-actors/releases) `dev/20220602` into the `v8` tarfile.
-
-```bash
-./pack.sh v8 dev/20220602
-```
-
-This will:
-
-1. Download the actors bundles and pack them into the appropriate tarfile (`$VERSION.tar.zst`).
-2. Run `make bundle-gen` in the top-level directory to regenerate the bundle metadata file for _all_ network versions (all `*.tar.zst` files in this directory).
-
-## Overriding
-
-To build a bundle, but specify a different release/tag for a specific network, append `$network=$alternative_release` on the command line. For example:
-
-```bash
-./pack.sh v8 dev/20220602 mainnet=v8.0.0 calibrationnet=v8.0.0-rc.1
-```

build/actors/pack.sh

@@ -1,55 +0,0 @@
-#!/bin/bash
-
-NETWORKS=(devnet mainnet caterpillarnet butterflynet testing testing-fake-proofs calibrationnet)
-
-set -e
-
-if [[ $# -lt 2 ]]; then
-    echo "Usage: $0 VERSION RELEASE [NETWORK=RELEASE_OVERRIDE]..." >&2
-    echo "expected at least two arguments, an actors version (e.g., v8), an actors release, and any number of release overrides." >&2
-    exit 1
-fi
-
-VERSION="$1" # actors version
-RELEASE="$2" # actors release name
-RELEASE_OVERRIDES=("${@:3}")
-
-echo "Downloading bundles for actors version ${VERSION} release ${RELEASE}"
-echo "With release overrides ${RELEASE_OVERRIDES[*]}"
-
-TARGET_FILE="$(pwd)/${VERSION}.tar.zst"
-WORKDIR=$(mktemp -d -t "actor-bundles-${VERSION}.XXXXXXXXXX")
-trap 'rm -rf -- "$WORKDIR"' EXIT
-
-encode_release() {
-    jq -rn --arg release "$1" '$release | @uri'
-}
-
-pushd "${WORKDIR}"
-for network in "${NETWORKS[@]}"; do
-    release="$RELEASE"
-    # Ideally, we'd use an associative array (map). But that's not supported on macos.
-    for override in "${RELEASE_OVERRIDES[@]}"; do
-        if [[ "${network}" = "${override%%=*}" ]]; then
-            release="${override#*=}"
-            break
-        fi
-    done
-    encoded_release="$(encode_release "$release")"
-    echo "Downloading $release for network $network."
-    wget "https://github.com/filecoin-project/builtin-actors/releases/download/${encoded_release}/builtin-actors-${network}"{.car,.sha256}
-done
-
-echo "Checking the checksums..."
-
-sha256sum -c -- *.sha256
-
-echo "Packing..."
-
-rm -f -- "$TARGET_FILE"
-tar -cf "$TARGET_FILE" --use-compress-program "zstd -19" -- *.car
-popd
-
-echo "Generating metadata..."
-
-make -C ../../ bundle-gen

build/bootstrap.go

@@ -6,9 +6,9 @@ import (
 	"path"
 	"strings"
 
-	"github.com/libp2p/go-libp2p/core/peer"
-
 	"github.com/filecoin-project/lotus/lib/addrutil"
+
+	"github.com/libp2p/go-libp2p-core/peer"
 )
 
 //go:embed bootstrap

build/bootstrap/butterflynet.pi

@@ -1,2 +1,2 @@
-/dns4/bootstrap-0.butterfly.fildev.network/tcp/1347/p2p/12D3KooWKeDMuJbouvypr1nL2qRruhNVXzv4QiLsZRh6gnvLkc7p
-/dns4/bootstrap-1.butterfly.fildev.network/tcp/1347/p2p/12D3KooWSsACNHLGoJbPqeitNY7tom19Nxq8x5ag36eTwmgcAeLo
+/dns4/bootstrap-0.butterfly.fildev.network/tcp/1347/p2p/12D3KooWFHDtFx7CVTy4xoCDutVo1cScvSnQjDeaM8UzwVS1qwkh
+/dns4/bootstrap-1.butterfly.fildev.network/tcp/1347/p2p/12D3KooWKt8cwpkiumkT8x32c3YFxsPRwhV5J8hCYPn9mhUmcAXt

build/bootstrap/calibnet.pi

@@ -1,4 +1,4 @@
-/dns4/bootstrap-0.calibration.fildev.network/tcp/1347/p2p/12D3KooWCi2w8U4DDB9xqrejb5KYHaQv2iA2AJJ6uzG3iQxNLBMy
-/dns4/bootstrap-1.calibration.fildev.network/tcp/1347/p2p/12D3KooWDTayrBojBn9jWNNUih4nNQQBGJD7Zo3gQCKgBkUsS6dp
-/dns4/bootstrap-2.calibration.fildev.network/tcp/1347/p2p/12D3KooWNRxTHUn8bf7jz1KEUPMc2dMgGfa4f8ZJTsquVSn3vHCG
-/dns4/bootstrap-3.calibration.fildev.network/tcp/1347/p2p/12D3KooWFWUqE9jgXvcKHWieYs9nhyp6NF4ftwLGAHm4sCv73jjK
+/dns4/bootstrap-0.calibration.fildev.network/tcp/1347/p2p/12D3KooWJkikQQkxS58spo76BYzFt4fotaT5NpV2zngvrqm4u5ow
+/dns4/bootstrap-1.calibration.fildev.network/tcp/1347/p2p/12D3KooWLce5FDHR4EX4CrYavphA5xS3uDsX6aoowXh5tzDUxJav
+/dns4/bootstrap-2.calibration.fildev.network/tcp/1347/p2p/12D3KooWA9hFfQG9GjP6bHeuQQbMD3FDtZLdW1NayxKXUT26PQZu
+/dns4/bootstrap-3.calibration.fildev.network/tcp/1347/p2p/12D3KooWMHDi3LVTFG8Szqogt7RkNXvonbQYqSazxBx41A5aeuVz

build/bootstrap/interopnet.pi

@@ -1,2 +1,2 @@
-/dns4/bootstrap-0.interop.fildev.network/tcp/1347/p2p/12D3KooWDpppr8csCNvEPnD2Z83KTPdBTM7iJhL66qK8LK3bB5NU
-/dns4/bootstrap-1.interop.fildev.network/tcp/1347/p2p/12D3KooWR3K1sXWoDYcXWqDF26mFEM1o1g7e7fcVR3NYE7rn24Gs
+/dns4/bootstrap-0.interop.fildev.network/tcp/1347/p2p/12D3KooWPfaWdJjpPTQp5kSqsqvauJaM4cFz5NWja7qyjx7vVfjL
+/dns4/bootstrap-1.interop.fildev.network/tcp/1347/p2p/12D3KooWS5tjcL6s4hHZ1HVRTgGKaXpKkiHfbBSJdjbzgejgJpEh

build/bootstrap/mainnet.pi

@@ -13,4 +13,3 @@
 /dns4/node.glif.io/tcp/1235/p2p/12D3KooWBF8cpp65hp2u9LK5mh19x67ftAam84z9LsfaquTDSBpt
 /dns4/bootstrap-0.ipfsmain.cn/tcp/34721/p2p/12D3KooWQnwEGNqcM2nAcPtRR9rAX8Hrg4k9kJLCHoTR5chJfz6d
 /dns4/bootstrap-1.ipfsmain.cn/tcp/34723/p2p/12D3KooWMKxMkD5DMpSWsW7dBddKxKT7L2GgbNuckz9otxvkvByP
-/dns4/bootstarp-0.1475.io/tcp/61256/p2p/12D3KooWRzCVDwHUkgdK7eRgnoXbjDAELhxPErjHzbRLguSV1aRt

build/builtin_actors.go

@@ -1,265 +0,0 @@
-package build
-
-import (
-	"archive/tar"
-	"context"
-	"embed"
-	"fmt"
-	"io"
-	"os"
-	"path"
-	"sort"
-	"strconv"
-	"strings"
-
-	"github.com/DataDog/zstd"
-	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"github.com/ipld/go-car"
-	"golang.org/x/xerrors"
-
-	actorstypes "github.com/filecoin-project/go-state-types/actors"
-
-	"github.com/filecoin-project/lotus/blockstore"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-)
-
-//go:embed actors/*.tar.zst
-var embeddedBuiltinActorReleases embed.FS
-
-func init() {
-	if BundleOverrides == nil {
-		BundleOverrides = make(map[actorstypes.Version]string)
-	}
-	for _, av := range actors.Versions {
-		path := os.Getenv(fmt.Sprintf("LOTUS_BUILTIN_ACTORS_V%d_BUNDLE", av))
-		if path == "" {
-			continue
-		}
-		BundleOverrides[actorstypes.Version(av)] = path
-	}
-	if err := loadManifests(NetworkBundle); err != nil {
-		panic(err)
-	}
-}
-
-// UseNetworkBundle switches to a different network bundle, by name.
-func UseNetworkBundle(netw string) error {
-	if NetworkBundle == netw {
-		return nil
-	}
-	if err := loadManifests(netw); err != nil {
-		return err
-	}
-	NetworkBundle = netw
-	return nil
-}
-
-func loadManifests(netw string) error {
-	overridden := make(map[actorstypes.Version]struct{})
-	var newMetadata []*BuiltinActorsMetadata
-	// First, prefer overrides.
-	for av, path := range BundleOverrides {
-		root, actorCids, err := readBundleManifestFromFile(path)
-		if err != nil {
-			return err
-		}
-		newMetadata = append(newMetadata, &BuiltinActorsMetadata{
-			Network:     netw,
-			Version:     av,
-			ManifestCid: root,
-			Actors:      actorCids,
-		})
-		overridden[av] = struct{}{}
-	}
-
-	// Then load embedded bundle metadata.
-	for _, meta := range EmbeddedBuiltinActorsMetadata {
-		if meta.Network != netw {
-			continue
-		}
-		if _, ok := overridden[meta.Version]; ok {
-			continue
-		}
-		newMetadata = append(newMetadata, meta)
-	}
-
-	actors.ClearManifests()
-
-	for _, meta := range newMetadata {
-		actors.RegisterManifest(meta.Version, meta.ManifestCid, meta.Actors)
-	}
-
-	return nil
-}
-
-type BuiltinActorsMetadata struct {
-	Network     string
-	Version     actorstypes.Version
-	ManifestCid cid.Cid
-	Actors      map[string]cid.Cid
-}
-
-// ReadEmbeddedBuiltinActorsMetadata reads the metadata from the embedded built-in actor bundles.
-// There should be no need to call this method as the result is cached in the
-// `EmbeddedBuiltinActorsMetadata` variable on `make gen`.
-func ReadEmbeddedBuiltinActorsMetadata() ([]*BuiltinActorsMetadata, error) {
-	files, err := embeddedBuiltinActorReleases.ReadDir("actors")
-	if err != nil {
-		return nil, xerrors.Errorf("failed to read embedded bundle directory: %s", err)
-	}
-	var bundles []*BuiltinActorsMetadata
-	for _, dirent := range files {
-		name := dirent.Name()
-		b, err := readEmbeddedBuiltinActorsMetadata(name)
-		if err != nil {
-			return nil, err
-		}
-		bundles = append(bundles, b...)
-	}
-	// Sort by network, then by bundle.
-	sort.Slice(bundles, func(i, j int) bool {
-		if bundles[i].Network == bundles[j].Network {
-			return bundles[i].Version < bundles[j].Version
-		}
-		return bundles[i].Network < bundles[j].Network
-	})
-	return bundles, nil
-}
-
-func readEmbeddedBuiltinActorsMetadata(bundle string) ([]*BuiltinActorsMetadata, error) {
-	const (
-		archiveExt   = ".tar.zst"
-		bundleExt    = ".car"
-		bundlePrefix = "builtin-actors-"
-	)
-
-	if !strings.HasPrefix(bundle, "v") {
-		return nil, xerrors.Errorf("bundle bundle '%q' doesn't start with a 'v'", bundle)
-	}
-	if !strings.HasSuffix(bundle, archiveExt) {
-		return nil, xerrors.Errorf("bundle bundle '%q' doesn't end with '%s'", bundle, archiveExt)
-	}
-	version, err := strconv.ParseInt(bundle[1:len(bundle)-len(archiveExt)], 10, 0)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to parse actors version from bundle '%q': %s", bundle, err)
-	}
-	fi, err := embeddedBuiltinActorReleases.Open(fmt.Sprintf("actors/%s", bundle))
-	if err != nil {
-		return nil, err
-	}
-	defer fi.Close() //nolint
-
-	uncompressed := zstd.NewReader(fi)
-	defer uncompressed.Close() //nolint
-
-	var bundles []*BuiltinActorsMetadata
-
-	tarReader := tar.NewReader(uncompressed)
-	for {
-		header, err := tarReader.Next()
-		switch err {
-		case io.EOF:
-			return bundles, nil
-		case nil:
-		default:
-			return nil, err
-		}
-
-		// Read the network name from the bundle name.
-		name := path.Base(header.Name)
-		if !strings.HasSuffix(name, bundleExt) {
-			return nil, xerrors.Errorf("expected bundle to end with .car: %s", name)
-		}
-		if !strings.HasPrefix(name, bundlePrefix) {
-			return nil, xerrors.Errorf("expected bundle to end with .car: %s", name)
-		}
-		name = name[len(bundlePrefix) : len(name)-len(bundleExt)]
-
-		// Load the bundle.
-		root, actorCids, err := readBundleManifest(tarReader)
-		if err != nil {
-			return nil, xerrors.Errorf("error loading builtin actors bundle: %w", err)
-		}
-		bundles = append(bundles, &BuiltinActorsMetadata{
-			Network:     name,
-			Version:     actorstypes.Version(version),
-			ManifestCid: root,
-			Actors:      actorCids,
-		})
-	}
-}
-
-func readBundleManifestFromFile(path string) (cid.Cid, map[string]cid.Cid, error) {
-	fi, err := os.Open(path)
-	if err != nil {
-		return cid.Undef, nil, err
-	}
-	defer fi.Close() //nolint
-
-	return readBundleManifest(fi)
-}
-
-func readBundleManifest(r io.Reader) (cid.Cid, map[string]cid.Cid, error) {
-	// Load the bundle.
-	bs := blockstore.NewMemory()
-	hdr, err := car.LoadCar(context.Background(), bs, r)
-	if err != nil {
-		return cid.Undef, nil, xerrors.Errorf("error loading builtin actors bundle: %w", err)
-	}
-
-	if len(hdr.Roots) != 1 {
-		return cid.Undef, nil, xerrors.Errorf("expected one root when loading actors bundle, got %d", len(hdr.Roots))
-	}
-	root := hdr.Roots[0]
-	actorCids, err := actors.ReadManifest(context.Background(), adt.WrapStore(context.Background(), cbor.NewCborStore(bs)), root)
-	if err != nil {
-		return cid.Undef, nil, err
-	}
-
-	// Make sure we have all the actors.
-	for name, c := range actorCids {
-		if has, err := bs.Has(context.Background(), c); err != nil {
-			return cid.Undef, nil, xerrors.Errorf("got an error when checking that the bundle has the actor %q: %w", name, err)
-		} else if !has {
-			return cid.Undef, nil, xerrors.Errorf("actor %q missing from bundle", name)
-		}
-	}
-
-	return root, actorCids, nil
-}
-
-// GetEmbeddedBuiltinActorsBundle returns the builtin-actors bundle for the given actors version.
-func GetEmbeddedBuiltinActorsBundle(version actorstypes.Version) ([]byte, bool) {
-	fi, err := embeddedBuiltinActorReleases.Open(fmt.Sprintf("actors/v%d.tar.zst", version))
-	if err != nil {
-		return nil, false
-	}
-	defer fi.Close() //nolint
-
-	uncompressed := zstd.NewReader(fi)
-	defer uncompressed.Close() //nolint
-
-	tarReader := tar.NewReader(uncompressed)
-	targetFileName := fmt.Sprintf("builtin-actors-%s.car", NetworkBundle)
-	for {
-		header, err := tarReader.Next()
-		switch err {
-		case io.EOF:
-			return nil, false
-		case nil:
-		default:
-			panic(err)
-		}
-		if header.Name != targetFileName {
-			continue
-		}
-
-		car, err := io.ReadAll(tarReader)
-		if err != nil {
-			panic(err)
-		}
-		return car, true
-	}
-}

build/builtin_actors_gen.go

@@ -1,254 +0,0 @@
-// WARNING: This file has automatically been generated
-
-package build
-
-import (
-	"github.com/ipfs/go-cid"
-)
-
-var EmbeddedBuiltinActorsMetadata []*BuiltinActorsMetadata = []*BuiltinActorsMetadata{{
-	Network:     "butterflynet",
-	Version:     8,
-	ManifestCid: MustParseCid("bafy2bzacedvaarfyh6q3bk4dyzux46ednlace2ckxp5nbyn6mb3da2apqn6sk"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzaceavzeu4gqte7o33vr4htiaapiwpfq6p26tgdkqla2baqhmiqswfso"),
-		"cron":             MustParseCid("bafk2bzacech35onpqxep4yox36k7sr4mj4bch54s3i4b3yyaustrbo5xwfbfs"),
-		"init":             MustParseCid("bafk2bzaceahxin3sf5f6ude5j6we4yeqlg66s5qe4tu7lwp26jcg7yp2ns6hi"),
-		"multisig":         MustParseCid("bafk2bzacectfmzjtniypgl4whm42sws5aupihqgfikwsr7p5yoq3bmqaogldi"),
-		"paymentchannel":   MustParseCid("bafk2bzacecbwu54ce5mjgp2pqxyj6kpn2vlgiu5wv2lj2byjiegxnn3infd5i"),
-		"reward":           MustParseCid("bafk2bzacecskkbhe6c4ud5jt62wg4w7j7shj6xdwoyic74s5y6pgywxxvnw72"),
-		"storagemarket":    MustParseCid("bafk2bzacebycxcwwm7hwhuhpasaskil2kxaqb7tins7azdvvm72rorlciuysi"),
-		"storageminer":     MustParseCid("bafk2bzacecgx3etor5m6lahpmjdwqnryutqe6naiurfhgsju72rd4nqssutbg"),
-		"storagepower":     MustParseCid("bafk2bzaceayvy6xyp5cwtngm457c5hssvihidppgq3o7gy3dlmhgor3yzujoc"),
-		"system":           MustParseCid("bafk2bzacec6xctjxybp7r3kkhase56o6jsaiua7ure5ttu2xfuojt4jhlsoa6"),
-		"verifiedregistry": MustParseCid("bafk2bzacec2hcqlqcfacylfcrhhliwkisvh4y3adwt47xkf2gdvodwu6ccepc"),
-	},
-}, {
-	Network:     "butterflynet",
-	Version:     9,
-	ManifestCid: MustParseCid("bafy2bzacec35by4erhcdgcsgzp7yb3j57utydlxxfc73m3k5pep67ehvvyv6i"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzaceajsdln7v4chxqoukiw7lxw6aexg5qdsaex2hgelz2sbu24iblhzg"),
-		"cron":             MustParseCid("bafk2bzacecgrwmgnqhybn3l23uvwf2n2vrcfjrprfzgd44uxers2pgr5mhsue"),
-		"datacap":          MustParseCid("bafk2bzacebyier2ceh27acbrq2ccv4efvzotl6qntnlrxdsrik6i4tembz6qw"),
-		"init":             MustParseCid("bafk2bzaceberhto43wnf4pklkd4c7d36kzslngyzyms4op7shxuswv3dtvfxu"),
-		"multisig":         MustParseCid("bafk2bzaceaclpbrhoqdruvsuqqgknvy2k5dywzmjoehk4uarce3uvt3w2rewu"),
-		"paymentchannel":   MustParseCid("bafk2bzacedzp56g5cg73oilloak3kf7u667rdkd5pgnhe2cljmr3o7ykcrzuk"),
-		"reward":           MustParseCid("bafk2bzacebczbwfbbi6mvppbjcozatasjiaohvjjiqcy65ccuuyyw3xiixhk2"),
-		"storagemarket":    MustParseCid("bafk2bzaceawqexy6t2ybzh3jjwhbs7icbg5vqnedbbge4e4r4pfp7spkcadsu"),
-		"storageminer":     MustParseCid("bafk2bzacearemd7pn2jj26fdtqd4di27lfhpng3vp5chepm7qnmdzgiqr6wfi"),
-		"storagepower":     MustParseCid("bafk2bzaceddc7fiaxfobfegqaobf5xinjgmhsa5iu4yi6klvc3jmjimcdvgyg"),
-		"system":           MustParseCid("bafk2bzacedylltr57b2n6zpadh4i2c2kis4fzzvhao3kgvfaggrrbqyacew7q"),
-		"verifiedregistry": MustParseCid("bafk2bzacecjkesz766626ab4svnzpq3jfs26a75vfktlfaku5fjdao2eyiqyq"),
-	},
-}, {
-	Network:     "calibrationnet",
-	Version:     8,
-	ManifestCid: MustParseCid("bafy2bzacedrdn6z3z7xz7lx4wll3tlgktirhllzqxb766dxpaqp3ukxsjfsba"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzacecruossn66xqbeutqx5r4k2kjzgd43frmwd4qkw6haez44ubvvpxo"),
-		"cron":             MustParseCid("bafk2bzaceaxlezmclw5ugldhhtfgvn7yztux45scqik3ez4yhwiqhg5ssib44"),
-		"init":             MustParseCid("bafk2bzaceadyfilb22bcvzvnpzbg2lyg6npmperyq6es2brvzjdh5rmywc4ry"),
-		"multisig":         MustParseCid("bafk2bzacec66wmb4kohuzvuxsulhcgiwju7sqkldwfpmmgw7dbbwgm5l2574q"),
-		"paymentchannel":   MustParseCid("bafk2bzaceblot4pemhfgwb3lceellwrpgxaqkpselzbpqu32maffpopdunlha"),
-		"reward":           MustParseCid("bafk2bzaceayah37uvj7brl5no4gmvmqbmtndh5raywuts7h6tqbgbq2ge7dhu"),
-		"storagemarket":    MustParseCid("bafk2bzacebotg5coqnglzsdrqxtkqk2eq4krxt6zvds3i3vb2yejgxhexl2n6"),
-		"storageminer":     MustParseCid("bafk2bzacea6rabflc7kpwr6y4lzcqsnuahr4zblyq3rhzrrsfceeiw2lufrb4"),
-		"storagepower":     MustParseCid("bafk2bzacecpwr4mynn55bg5hrlns3osvg7sty3rca6zlai3vl52vbbjk7ulfa"),
-		"system":           MustParseCid("bafk2bzaceaqrkllksxv2jsfgjvmuewx5vbzrammw5mdscod6gkdr3ijih2q64"),
-		"verifiedregistry": MustParseCid("bafk2bzaceaihibfu625lbtzdp3tcftscshrmbgghgrc7kzqhxn4455pycpdkm"),
-	},
-}, {
-	Network:     "calibrationnet",
-	Version:     9,
-	ManifestCid: MustParseCid("bafy2bzacedbedgynklc4dgpyxippkxmba2mgtw7ecntoneclsvvl4klqwuyyy"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzaceavfgpiw6whqigmskk74z4blm22nwjfnzxb4unlqz2e4wg3c5ujpw"),
-		"cron":             MustParseCid("bafk2bzaceb7hxmudhvkizszbmmf2ur2qfnfxfkok3xmbrlifylx6huw4bb3s4"),
-		"datacap":          MustParseCid("bafk2bzaceanmwcfjfj65xy275rrfqqgoblnuqirdg6zwhc6qhbfhpphomvceu"),
-		"init":             MustParseCid("bafk2bzaceczqxpivlxifdo5ohr2rx5ny4uyvssm6tkf7am357xm47x472yxu2"),
-		"multisig":         MustParseCid("bafk2bzacec6gmi7ucukr3bk67akaxwngohw3lsg3obvdazhmfhdzflkszk3tg"),
-		"paymentchannel":   MustParseCid("bafk2bzacec4kg3bfjtssvv2b4wizlbdk3pdtrg5aknzgeb3a6rmksgurpynca"),
-		"reward":           MustParseCid("bafk2bzacebpptqhcw6mcwdj576dgpryapdd2zfexxvqzlh3aoc24mabwgmcss"),
-		"storagemarket":    MustParseCid("bafk2bzacebkfcnc27d3agm2bhzzbvvtbqahmvy2b2nf5xyj4aoxehow3bules"),
-		"storageminer":     MustParseCid("bafk2bzacebz4na3nq4gmumghegtkaofrv4nffiihd7sxntrryfneusqkuqodm"),
-		"storagepower":     MustParseCid("bafk2bzaceburxajojmywawjudovqvigmos4dlu4ifdikogumhso2ca2ccaleo"),
-		"system":           MustParseCid("bafk2bzaceaue3nzucbom3tcclgyaahy3iwvbqejsxrohiquakvvsjgbw3shac"),
-		"verifiedregistry": MustParseCid("bafk2bzacebh7dj6j7yi5vadh7lgqjtq42qi2uq4n6zy2g5vjeathacwn2tscu"),
-	},
-}, {
-	Network:     "caterpillarnet",
-	Version:     8,
-	ManifestCid: MustParseCid("bafy2bzacecsmunz6fzhg53276cixadn6ybhcnzkgbw3la5hf342tfxsdoet26"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzaced6yatl4y2nmqmx2h3btk3np6oelyw2yt57elsb2nfmm33fadzt2g"),
-		"cron":             MustParseCid("bafk2bzacebrujytq4u7g62jbz52gio5k2s6rhruty7nt4eqq7ygitzxuee5zi"),
-		"init":             MustParseCid("bafk2bzacedajw5ptnwfdidv6m4rvd4c2m7dve4lhfbawygl5idkalcxbiiudu"),
-		"multisig":         MustParseCid("bafk2bzaceb3kh5hjh6eebb5236xp7crn2owyyo7irap6sy4ns76uc7om6pxuy"),
-		"paymentchannel":   MustParseCid("bafk2bzacedl5am53e4mtxpzligcycxvmkolfkhfiuavww2dq3ukgaqwowj7vw"),
-		"reward":           MustParseCid("bafk2bzacecbswf242j43cymj3wh7nszawwlofv6z6z4qipb5d32hpxdhxywng"),
-		"storagemarket":    MustParseCid("bafk2bzaceca5ersmg3zxf2cztgktq33bmfjuiqjcjlktwj52xyrpujbdsqvek"),
-		"storageminer":     MustParseCid("bafk2bzacedg2fqaq5udfp3h6cxhywm27dgagxtselfgkyyyunqq362eaxpdm4"),
-		"storagepower":     MustParseCid("bafk2bzaceb3dm2i2q323e6iozo3r6pyded645vvlpf537kga2a3hu5x7abgl4"),
-		"system":           MustParseCid("bafk2bzacebu47th3xerlngqavlipb6cfu2utljkxxzgadc3totogto2tmx2jc"),
-		"verifiedregistry": MustParseCid("bafk2bzaceci3niq3rmbcmepgn27zvlgci6d5t4dvthx3pbmmx3wcu5elova6i"),
-	},
-}, {
-	Network:     "caterpillarnet",
-	Version:     9,
-	ManifestCid: MustParseCid("bafy2bzacedo6tmei6rzjaaddh2yffe5xgr6w4smnadofjhomc3saiv3ubplqe"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzacebb32htqlwcwiotyvtbeehfmluu2ubjnepo57gelelwitudrstwba"),
-		"cron":             MustParseCid("bafk2bzaceatvkww7soy4a6onu6xhe7pzkdzkqw46ywuu56yv3ncl76xpotzqu"),
-		"datacap":          MustParseCid("bafk2bzaced57nk7i7w6qmbosy4gd6atme6yppesdgjllou6nppbti5yw6glcg"),
-		"init":             MustParseCid("bafk2bzacedtoputbtz573ytg4yo5wbbg7fbhrzplux4uknxrb2jarifcuxxou"),
-		"multisig":         MustParseCid("bafk2bzacec22z3xz45mbwgtliwkj7ngc43bervnt557c6dqsg6aesatpd5isy"),
-		"paymentchannel":   MustParseCid("bafk2bzacedym7xnaxr2igfq72rttj2adqyqqfxk3j4qovp2bcwqk5paoe4t7e"),
-		"reward":           MustParseCid("bafk2bzacedemsmbmbtk5toprmm6jivjq3wkxumavc65vpvm6ngspgjfkth7z6"),
-		"storagemarket":    MustParseCid("bafk2bzacecb53mmklf4rbv263dvufqj3nsf7mi6zk2tjlgwmzbr633kw3ds3w"),
-		"storageminer":     MustParseCid("bafk2bzacea3wljpn2ixgnd4lovr6yckiwd652ytcrz5amgj47lg6drjhgggqa"),
-		"storagepower":     MustParseCid("bafk2bzaceakvohgvovpeldb6hjfg7readxo37a5h4qauis4nz6pte7mcll6c2"),
-		"system":           MustParseCid("bafk2bzacecisuqj2ln7ep72xaejvs2lrgh2logc7retxxpd3qvobymwyz7bxo"),
-		"verifiedregistry": MustParseCid("bafk2bzacebyjosiripwqyf56yhjfs5hg26mch7totsqth4rgpt5j32hqg6ric"),
-	},
-}, {
-	Network:     "devnet",
-	Version:     8,
-	ManifestCid: MustParseCid("bafy2bzacedq7tuibavyqxzkq4uybjj7ly22eu42mjkoehwn5d47xfunmtjm4k"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzacea4tlgnp7m6tlldpz3termlwxlnyq24nwd4zdzv4r6nsjuaktuuzc"),
-		"cron":             MustParseCid("bafk2bzacecgrlf3vg3mufwovddlbgclhpnpp3jftr46stssh3crd3pyljc37w"),
-		"init":             MustParseCid("bafk2bzacedarbnovmucppbjkcwsxopludrj5ttmtm7mzfqsugmxdnqevqso7o"),
-		"multisig":         MustParseCid("bafk2bzaced4gcxjwy6garxwfw6y5a2k4jewj4t5nzopjy4qwnimhjtnsgo3ss"),
-		"paymentchannel":   MustParseCid("bafk2bzaceb3isfguytt6cs4xecyoonbhhekmngfbap2msggbwyde7zch3a6w4"),
-		"reward":           MustParseCid("bafk2bzacedn3fkp27ys5dxn4pwqdq2atj2x6cyezxuekdorvjwi7zazirgvgy"),
-		"storagemarket":    MustParseCid("bafk2bzacecw57fpkqesfhi5g3nr4csy4oy7oc42wmwjuis6l7ijniolo4rt2k"),
-		"storageminer":     MustParseCid("bafk2bzacebze3elvppssc6v5457ukszzy6ndrg6xgaojfsqfbbtg3xfwo4rbs"),
-		"storagepower":     MustParseCid("bafk2bzaceb45l6zhgc34n6clz7xnvd7ek55bhw46q25umuje34t6kroix6hh6"),
-		"system":           MustParseCid("bafk2bzacecf7eta2stfd3cnuxzervd33imbvlaqq6b5tsho7pxmhifrybreru"),
-		"verifiedregistry": MustParseCid("bafk2bzaceaajgtglewgitshgdi2nzrvq7eihjtyqj5yiamesqun2hujl3xev2"),
-	},
-}, {
-	Network:     "devnet",
-	Version:     9,
-	ManifestCid: MustParseCid("bafy2bzacedozk3jh2j4nobqotkbofodq4chbrabioxbfrygpldgoxs3zwgggk"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzaced5llqnqqhypolyuogz3h2wjomugqkrhyhocvly3aoib4c5xiush6"),
-		"cron":             MustParseCid("bafk2bzaceahwdt32ji53mo5yz6imvztz3s3g2ra5uz3jdfa77j7hqcnq6r4l2"),
-		"datacap":          MustParseCid("bafk2bzaceabcxoy5iscdierasorjoj6xzqgnnb5pmrr7prkuibw4yggx3v2d2"),
-		"init":             MustParseCid("bafk2bzaceastwn42kqyztz7uzej7l4lemp5nakqqsfvksry7k75q5ombhprme"),
-		"multisig":         MustParseCid("bafk2bzacebeiygkjupkpfxcrsidci4bvn6afkvx4lsj3ut3ywhsj654pzfgk4"),
-		"paymentchannel":   MustParseCid("bafk2bzacedhsdoo4ww47rm44pizu5qqpho753cizzbbvnd5yz3nm3347su5cy"),
-		"reward":           MustParseCid("bafk2bzacebzqvisqe3iaodtxq7l2lgzwfkxznrnp676ddpllqcpvuae5i33le"),
-		"storagemarket":    MustParseCid("bafk2bzaceduauegz4nniegh667btjhg2anipwpxeb664s4ossq2ifvuqwqlso"),
-		"storageminer":     MustParseCid("bafk2bzacec23wjdmbm5pt6pqsbjb3w6j7vyrolijz2mysvp6clllfgpmhb6ge"),
-		"storagepower":     MustParseCid("bafk2bzacebnyywv46n2ghg62inllwpmnyuwtoz57fn5lpgpf436mahajg4qrg"),
-		"system":           MustParseCid("bafk2bzacebgafb6h2o2g5whrujc2uvsttrussyc5t56rvhrjqkqhzdu4jopwa"),
-		"verifiedregistry": MustParseCid("bafk2bzacednorhcy446agy7ecpmfms2u4aoa3mj2eqomffuoerbik5yavrxyi"),
-	},
-}, {
-	Network:     "mainnet",
-	Version:     8,
-	ManifestCid: MustParseCid("bafy2bzacebogjbpiemi7npzxchgcjjki3tfxon4ims55obfyfleqntteljsea"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzacedudbf7fc5va57t3tmo63snmt3en4iaidv4vo3qlyacbxaa6hlx6y"),
-		"cron":             MustParseCid("bafk2bzacecqb3eolfurehny6yp7tgmapib4ocazo5ilkopjce2c7wc2bcec62"),
-		"init":             MustParseCid("bafk2bzaceaipvjhoxmtofsnv3aj6gj5ida4afdrxa4ewku2hfipdlxpaektlw"),
-		"multisig":         MustParseCid("bafk2bzacebhldfjuy4o5v7amrhp5p2gzv2qo5275jut4adnbyp56fxkwy5fag"),
-		"paymentchannel":   MustParseCid("bafk2bzacebalad3f72wyk7qyilvfjijcwubdspytnyzlrhvn73254gqis44rq"),
-		"reward":           MustParseCid("bafk2bzacecwzzxlgjiavnc3545cqqil3cmq4hgpvfp2crguxy2pl5ybusfsbe"),
-		"storagemarket":    MustParseCid("bafk2bzacediohrxkp2fbsl4yj4jlupjdkgsiwqb4zuezvinhdo2j5hrxco62q"),
-		"storageminer":     MustParseCid("bafk2bzacecgnynvd3tene3bvqoknuspit56canij5bpra6wl4mrq2mxxwriyu"),
-		"storagepower":     MustParseCid("bafk2bzacebjvqva6ppvysn5xpmiqcdfelwbbcxmghx5ww6hr37cgred6dyrpm"),
-		"system":           MustParseCid("bafk2bzacedwq5uppsw7vp55zpj7jdieizirmldceehu6wvombw3ixq2tcq57w"),
-		"verifiedregistry": MustParseCid("bafk2bzaceb3zbkjz3auizmoln2unmxep7dyfcmsre64vnqfhdyh7rkqfoxlw4"),
-	},
-}, {
-	Network:     "mainnet",
-	Version:     9,
-	ManifestCid: MustParseCid("bafy2bzaceb6j6666h36xnhksu3ww4kxb6e25niayfgkdnifaqi6m6ooc66i6i"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzacect2p7urje3pylrrrjy3tngn6yaih4gtzauuatf2jllk3ksgfiw2y"),
-		"cron":             MustParseCid("bafk2bzacebcec3lffmos3nawm5cvwehssxeqwxixoyyfvejy7viszzsxzyu26"),
-		"datacap":          MustParseCid("bafk2bzacebb6uy2ys7tapekmtj7apnjg7oyj4ia5t7tlkvbmwtxwv74lb2pug"),
-		"init":             MustParseCid("bafk2bzacebtdq4zyuxk2fzbdkva6kc4mx75mkbfmldplfntayhbl5wkqou33i"),
-		"multisig":         MustParseCid("bafk2bzacec4va3nmugyqjqrs3lqyr2ij67jhjia5frvx7omnh2isha6abxzya"),
-		"paymentchannel":   MustParseCid("bafk2bzacebhdvjbjcgupklddfavzef4e4gnkt3xk3rbmgfmk7xhecszhfxeds"),
-		"reward":           MustParseCid("bafk2bzacebezgbbmcm2gbcqwisus5fjvpj7hhmu5ubd37phuku3hmkfulxm2o"),
-		"storagemarket":    MustParseCid("bafk2bzacec3j7p6gklk64stax5px3xxd7hdtejaepnd4nw7s2adihde6emkcu"),
-		"storageminer":     MustParseCid("bafk2bzacedyux5hlrildwutvvjdcsvjtwsoc5xnqdjl73ouiukgklekeuyfl4"),
-		"storagepower":     MustParseCid("bafk2bzacedsetphfajgne4qy3vdrpyd6ekcmtfs2zkjut4r34cvnuoqemdrtw"),
-		"system":           MustParseCid("bafk2bzaceagvlo2jtahj7dloshrmwfulrd6e2izqev32qm46eumf754weec6c"),
-		"verifiedregistry": MustParseCid("bafk2bzacecf3yodlyudzukumehbuabgqljyhjt5ifiv4vetcfohnvsxzynwga"),
-	},
-}, {
-	Network:     "testing",
-	Version:     8,
-	ManifestCid: MustParseCid("bafy2bzacedkjpqx27wgsvfxzuxfvixuxtbpt2y6yo6igcasez6gqiowron776"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzacebmfbtdj5vruje5auacrhhprcjdd6uclhukb7je7t2f6ozfcgqlu2"),
-		"cron":             MustParseCid("bafk2bzacea4gwsbeux7z4yxvpkxpco77iyxijoyqaoikofrxdewunwh3unjem"),
-		"init":             MustParseCid("bafk2bzacecqk6zlwein7tzy7yrrhtj4pzavrkofgpyxvvw5ktr3w4x4ml4lis"),
-		"multisig":         MustParseCid("bafk2bzacea5zp2g6ag5qfuro7zw6kyku2swxs57wjxncaaxbih5iqflqy4ghm"),
-		"paymentchannel":   MustParseCid("bafk2bzaced47dbtbygmfwnyfsp5iihzhhdmnkpuyc5nlnfgc4mkkvlsgvj2do"),
-		"reward":           MustParseCid("bafk2bzacecmcagk32pzdzfg7piobzqhlgla37x3g7jjzyndlz7mqdno2zulfi"),
-		"storagemarket":    MustParseCid("bafk2bzaceballmgd7puoixfwm65f5shi3kzreqdisowtsoufbvduwytydqotw"),
-		"storageminer":     MustParseCid("bafk2bzacebucngwdhxtod2gvv52adtdssafyg43znsoy4omtfkkqe2hbhvxeu"),
-		"storagepower":     MustParseCid("bafk2bzaceakxw5wx3rtqoarrdbzhmxkufg2kx7n34xotzxzacvvbe5iqggmsa"),
-		"system":           MustParseCid("bafk2bzaced6kjkbv7lrb2qwq5we2hqaxc6ztch5p52g27qtjy45zdemsk4b7m"),
-		"verifiedregistry": MustParseCid("bafk2bzacectzxvtoselhnzsair5nv6k5vokvegnht6z2lfee4p3xexo4kg4m6"),
-	},
-}, {
-	Network:     "testing",
-	Version:     9,
-	ManifestCid: MustParseCid("bafy2bzacecnnrmekqw2xvud46g3vo6x26cogh3ydgljqajlxqxzzbuxsjlwjm"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzaceaiebfiuu76zoywzltelio2zuvsavirka27ur6kspn7scvcl5cuiy"),
-		"cron":             MustParseCid("bafk2bzacecla36w3tbwap5jgdtooxsud25mdpc75kgtjs34mi4xhwygph2gki"),
-		"datacap":          MustParseCid("bafk2bzaced5h3ct6i7oqpyimkj3hwdywmux5tslu5vs2ywbzruqmxjtqczygs"),
-		"init":             MustParseCid("bafk2bzaceauxqpspnvui7dryuvfgzoogatbkbahp4ovaih734blwi4bassnlm"),
-		"multisig":         MustParseCid("bafk2bzaceddfagxfpsihjxq7yt4ditv2tcoou5w4hzbsapadlw3v44cxfcqpi"),
-		"paymentchannel":   MustParseCid("bafk2bzaced4nc4ofrbqevpwrt7fnf3beshi5ccrecq3zojt2sxgrkz7ebnbh4"),
-		"reward":           MustParseCid("bafk2bzacedxleepeg4ei3jnayzcfz6shi25rrvoyhr6fxmkdezq4owrazi7rq"),
-		"storagemarket":    MustParseCid("bafk2bzaceakqcjpppg3exrr7dru7jglvno2xyw4hsuebxay4lvrzvmwmv5kvu"),
-		"storageminer":     MustParseCid("bafk2bzacealfvphicwnysmmyyerseppyvydy2reisvbft46vdprp2lnfvlgqc"),
-		"storagepower":     MustParseCid("bafk2bzaceageil5b5mr5uwo6vqs4nnnmpiwe3fkjffzyngcicuu7gruuwapjm"),
-		"system":           MustParseCid("bafk2bzacedo4pu3iwx2gu72hinsstpiokhl5iicnb3rumzffsnhy7zhmnxhyy"),
-		"verifiedregistry": MustParseCid("bafk2bzaceatmqip2o3ausbntvdhj7yemu6hb3b5yqv6hm42gylbbmz7geocpm"),
-	},
-}, {
-	Network:     "testing-fake-proofs",
-	Version:     8,
-	ManifestCid: MustParseCid("bafy2bzacecd3lb5v6tzjylnhnrhexslssyaozy6hogzgpkhztoe76exbrgrug"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzacebmfbtdj5vruje5auacrhhprcjdd6uclhukb7je7t2f6ozfcgqlu2"),
-		"cron":             MustParseCid("bafk2bzacea4gwsbeux7z4yxvpkxpco77iyxijoyqaoikofrxdewunwh3unjem"),
-		"init":             MustParseCid("bafk2bzacebwkqd6e7gdphfzw2kdmbokdh2bly6fvzgfopxzy7quq4l67gmkks"),
-		"multisig":         MustParseCid("bafk2bzacea5zp2g6ag5qfuro7zw6kyku2swxs57wjxncaaxbih5iqflqy4ghm"),
-		"paymentchannel":   MustParseCid("bafk2bzaced47dbtbygmfwnyfsp5iihzhhdmnkpuyc5nlnfgc4mkkvlsgvj2do"),
-		"reward":           MustParseCid("bafk2bzacecmcagk32pzdzfg7piobzqhlgla37x3g7jjzyndlz7mqdno2zulfi"),
-		"storagemarket":    MustParseCid("bafk2bzacecxqgajcaednamgolc6wc3lzbjc6tz5alfrbwqez2y3c372vts6dg"),
-		"storageminer":     MustParseCid("bafk2bzaceaqwxllfycpq6decpsnkqjdeycpysh5acubonjae7u3wciydlkvki"),
-		"storagepower":     MustParseCid("bafk2bzaceddmeolsokbxgcr25cuf2skrobtmmoof3dmqfpcfp33lmw63oikvm"),
-		"system":           MustParseCid("bafk2bzaced6kjkbv7lrb2qwq5we2hqaxc6ztch5p52g27qtjy45zdemsk4b7m"),
-		"verifiedregistry": MustParseCid("bafk2bzacectzxvtoselhnzsair5nv6k5vokvegnht6z2lfee4p3xexo4kg4m6"),
-	},
-}, {
-	Network:     "testing-fake-proofs",
-	Version:     9,
-	ManifestCid: MustParseCid("bafy2bzacecql2gj2tri4fnbznmldue73qzt6zszvugw4exd64mwb52zrhv7k2"),
-	Actors: map[string]cid.Cid{
-		"account":          MustParseCid("bafk2bzaceaiebfiuu76zoywzltelio2zuvsavirka27ur6kspn7scvcl5cuiy"),
-		"cron":             MustParseCid("bafk2bzacecla36w3tbwap5jgdtooxsud25mdpc75kgtjs34mi4xhwygph2gki"),
-		"datacap":          MustParseCid("bafk2bzaced5h3ct6i7oqpyimkj3hwdywmux5tslu5vs2ywbzruqmxjtqczygs"),
-		"init":             MustParseCid("bafk2bzaceauxqpspnvui7dryuvfgzoogatbkbahp4ovaih734blwi4bassnlm"),
-		"multisig":         MustParseCid("bafk2bzaceddfagxfpsihjxq7yt4ditv2tcoou5w4hzbsapadlw3v44cxfcqpi"),
-		"paymentchannel":   MustParseCid("bafk2bzaced4nc4ofrbqevpwrt7fnf3beshi5ccrecq3zojt2sxgrkz7ebnbh4"),
-		"reward":           MustParseCid("bafk2bzacedxleepeg4ei3jnayzcfz6shi25rrvoyhr6fxmkdezq4owrazi7rq"),
-		"storagemarket":    MustParseCid("bafk2bzaceakqcjpppg3exrr7dru7jglvno2xyw4hsuebxay4lvrzvmwmv5kvu"),
-		"storageminer":     MustParseCid("bafk2bzaceab3cjrwwwfemyc5lw73w6tibpgxtx3wuzjhami6tvhcvetygdm7m"),
-		"storagepower":     MustParseCid("bafk2bzaceafemwhsy3e7ueqsrn3f7n53vdqkvfbig3hgbw7eohsefnfvgq7yc"),
-		"system":           MustParseCid("bafk2bzacedo4pu3iwx2gu72hinsstpiokhl5iicnb3rumzffsnhy7zhmnxhyy"),
-		"verifiedregistry": MustParseCid("bafk2bzaceatmqip2o3ausbntvdhj7yemu6hb3b5yqv6hm42gylbbmz7geocpm"),
-	},
-}}

build/builtin_actors_test.go

@@ -1,38 +0,0 @@
-package build_test
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	actorstypes "github.com/filecoin-project/go-state-types/actors"
-
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
-)
-
-// Test that the embedded metadata is correct.
-func TestEmbeddedMetadata(t *testing.T) {
-	metadata, err := build.ReadEmbeddedBuiltinActorsMetadata()
-	require.NoError(t, err)
-
-	require.Equal(t, metadata, build.EmbeddedBuiltinActorsMetadata)
-}
-
-// Test that we're registering the manifest correctly.
-func TestRegistration(t *testing.T) {
-	for _, av := range []actorstypes.Version{actorstypes.Version8, actorstypes.Version9} {
-		manifestCid, found := actors.GetManifest(av)
-		require.True(t, found)
-		require.True(t, manifestCid.Defined())
-
-		for _, key := range actors.GetBuiltinActorsKeys(av) {
-			actorCid, found := actors.GetActorCodeID(av, key)
-			require.True(t, found)
-			name, version, found := actors.GetActorMetaByCode(actorCid)
-			require.True(t, found)
-			require.Equal(t, av, version)
-			require.Equal(t, key, name)
-		}
-	}
-}

build/openrpc.go

@@ -52,11 +52,3 @@ func OpenRPCDiscoverJSON_Worker() apitypes.OpenRPCDocument {
 	}
 	return mustReadGzippedOpenRPCDocument(data)
 }
-
-func OpenRPCDiscoverJSON_Gateway() apitypes.OpenRPCDocument {
-	data, err := openrpcfs.ReadFile("openrpc/gateway.json.gz")
-	if err != nil {
-		panic(err)
-	}
-	return mustReadGzippedOpenRPCDocument(data)
-}