New calibration network genesis

.circleci/config.yml

@@ -1,17 +1,15 @@
 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:
-      - image: circleci/golang:1.15.5
+      - image: circleci/golang:1.14.6
     resource_class: 2xlarge
   ubuntu:
     docker:
-      - image: ubuntu:20.04
+      - image: ubuntu:19.10
 
 commands:
   install-deps:
@@ -36,7 +34,7 @@ commands:
           condition: << parameters.linux >>
           steps:
             - run: sudo apt-get update
-            - run: sudo apt-get install ocl-icd-opencl-dev libhwloc-dev
+            - run: sudo apt-get install ocl-icd-opencl-dev
       - run: git submodule sync
       - run: git submodule update --init
   download-params:
@@ -130,9 +128,6 @@ jobs:
       winpost-test:
         type: string
         default: "0"
-      deadline-test:
-        type: string
-        default: "0"
       test-suite-name:
         type: string
         default: unit
@@ -166,7 +161,6 @@ jobs:
           name: go test
           environment:
             LOTUS_TEST_WINDOW_POST: << parameters.winpost-test >>
-            LOTUS_TEST_DEADLINE_TOGGLING: << parameters.deadline-test >>
             SKIP_CONFORMANCE: "1"
           command: |
             mkdir -p /tmp/test-reports/<< parameters.test-suite-name >>
@@ -194,24 +188,10 @@ jobs:
                 command: |
                   bash <(curl -s https://codecov.io/bash)
 
-  test-chain:
-    <<: *test
-  test-node:
-    <<: *test
-  test-storage:
-    <<: *test
-  test-cli:
-    <<: *test
   test-short:
     <<: *test
   test-window-post:
     <<: *test
-  test-window-post-dispute:
-    <<: *test
-  test-deadline-toggling:
-    <<: *test
-  test-terminate:
-    <<: *test
   test-conformance:
     description: |
       Run tests using a corpus of interoperable test vectors for Filecoin 
@@ -274,97 +254,24 @@ jobs:
           path: /tmp/test-reports
       - store_artifacts:
           path: /tmp/test-artifacts/conformance-coverage.html
-  build-ntwk-calibration:
-    description: |
-      Compile lotus binaries for the calibration network
-    parameters:
-      <<: *test-params
-    executor: << parameters.executor >>
-    steps:
-      - 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-ntwk-nerpa:
-    description: |
-      Compile lotus binaries for the nerpa network
-    parameters:
-      <<: *test-params
-    executor: << parameters.executor >>
-    steps:
-      - install-deps
-      - prepare
-      - run: make nerpanet
-      - run: mkdir linux-nerpanet && mv lotus lotus-miner lotus-worker linux-nerpanet
-      - persist_to_workspace:
-          root: "."
-          paths:
-            - linux-nerpanet
   build-lotus-soup:
     description: |
-      Compile `lotus-soup` Testground test plan
+      Compile `lotus-soup` Testground test plan using the current version of Lotus.
     parameters:
       <<: *test-params
     executor: << parameters.executor >>
     steps:
       - install-deps
       - prepare
+      - run: cd extern/oni && git submodule sync
+      - run: cd extern/oni && git submodule update --init
       - 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=../..
+          name: "replace lotus, filecoin-ffi, blst and fil-blst deps"
+          command: cd extern/oni/lotus-soup && go mod edit -replace github.com/filecoin-project/lotus=../../../ && go mod edit -replace github.com/filecoin-project/filecoin-ffi=../../filecoin-ffi && go mod edit -replace github.com/supranational/blst=../../fil-blst/blst && go mod edit -replace github.com/filecoin-project/fil-blst=../../fil-blst
       - 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 && ln -s $(pwd)/testplans/graphsync $HOME/testground/plans/graphsync
-      - 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
-      - run:
-          name: "trigger graphsync testplan on taas"
-          command: ~/testground-cli run composition -f $HOME/testground/plans/graphsync/_compositions/stress-k8s.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
+          command: pushd extern/oni/lotus-soup && go build -tags=testground .
 
 
   build-macos:
@@ -379,8 +286,8 @@ jobs:
       - run:
           name: Install go
           command: |
-            curl -O https://dl.google.com/go/go1.15.5.darwin-amd64.pkg && \
-            sudo installer -pkg go1.15.5.darwin-amd64.pkg -target /
+            curl -O https://dl.google.com/go/go1.14.2.darwin-amd64.pkg && \
+            sudo installer -pkg go1.14.2.darwin-amd64.pkg -target /
       - run:
           name: Install pkg-config
           command: HOMEBREW_NO_AUTO_UPDATE=1 brew install pkg-config
@@ -394,15 +301,6 @@ jobs:
           command: |
             curl --location https://github.com/stedolan/jq/releases/download/jq-1.6/jq-osx-amd64 --output /usr/local/bin/jq
             chmod +x /usr/local/bin/jq
-      - 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" }}
@@ -453,18 +351,8 @@ jobs:
     steps:
       - install-deps
       - prepare
-      - run: zcat build/openrpc/full.json.gz | jq > ../pre-openrpc-full
-      - run: zcat build/openrpc/miner.json.gz | jq > ../pre-openrpc-miner
-      - run: zcat build/openrpc/worker.json.gz | jq > ../pre-openrpc-worker
-      - run: make deps
       - run: make docsgen
-      - run: zcat build/openrpc/full.json.gz | jq > ../post-openrpc-full
-      - run: zcat build/openrpc/miner.json.gz | jq > ../post-openrpc-miner
-      - run: zcat build/openrpc/worker.json.gz | jq > ../post-openrpc-worker
       - run: git --no-pager diff
-      - run: diff ../pre-openrpc-full ../post-openrpc-full
-      - run: diff ../pre-openrpc-miner ../post-openrpc-miner
-      - run: diff ../pre-openrpc-worker ../post-openrpc-worker
       - run: git --no-pager diff --quiet
 
   lint: &lint
@@ -526,171 +414,6 @@ jobs:
           name: Publish release
           command: ./scripts/publish-release.sh
 
-  build-and-push-image:
-    description: build and push docker images to public AWS ECR registry
-    executor: aws-cli/default
-    parameters:
-      profile-name:
-        type: string
-        default: "default"
-        description: AWS profile name to be configured.
-
-      aws-access-key-id:
-        type: env_var_name
-        default: AWS_ACCESS_KEY_ID
-        description: >
-          AWS access key id for IAM role. Set this to the name of
-          the environment variable you will set to hold this
-          value, i.e. AWS_ACCESS_KEY.
-
-      aws-secret-access-key:
-        type: env_var_name
-        default: AWS_SECRET_ACCESS_KEY
-        description: >
-          AWS secret key for IAM role. Set this to the name of
-          the environment variable you will set to hold this
-          value, i.e. AWS_SECRET_ACCESS_KEY.
-
-      region:
-        type: env_var_name
-        default: AWS_REGION
-        description: >
-          Name of env var storing your AWS region information,
-          defaults to AWS_REGION
-
-      account-url:
-        type: env_var_name
-        default: AWS_ECR_ACCOUNT_URL
-        description: >
-          Env var storing Amazon ECR account URL that maps to an AWS account,
-          e.g. {awsAccountNum}.dkr.ecr.us-west-2.amazonaws.com
-          defaults to AWS_ECR_ACCOUNT_URL
-
-      dockerfile:
-        type: string
-        default: Dockerfile
-        description: Name of dockerfile to use. Defaults to Dockerfile.
-
-      path:
-        type: string
-        default: .
-        description: Path to the directory containing your Dockerfile and build context. Defaults to . (working directory).
-
-      extra-build-args:
-        type: string
-        default: ""
-        description: >
-          Extra flags to pass to docker build. For examples, see
-          https://docs.docker.com/engine/reference/commandline/build
-
-      repo:
-        type: string
-        description: Name of an Amazon ECR repository
-
-      tag:
-        type: string
-        default: "latest"
-        description: A comma-separated string containing docker image tags to build and push (default = latest)
-
-    steps:
-      - run:
-          name: Confirm that environment variables are set
-          command: |
-            if [ -z "$AWS_ACCESS_KEY_ID" ]; then
-              echo "No AWS_ACCESS_KEY_ID is set. Skipping build-and-push job ..."
-              circleci-agent step halt
-            fi
-
-      - aws-cli/setup:
-          profile-name: <<parameters.profile-name>>
-          aws-access-key-id: <<parameters.aws-access-key-id>>
-          aws-secret-access-key: <<parameters.aws-secret-access-key>>
-          aws-region: <<parameters.region>>
-
-      - run:
-          name: Log into Amazon ECR
-          command: |
-            aws ecr-public get-login-password --region $<<parameters.region>> --profile <<parameters.profile-name>> | docker login --username AWS --password-stdin $<<parameters.account-url>>
-
-      - checkout
-
-      - setup_remote_docker:
-          version: 19.03.13
-          docker_layer_caching: false
-
-      - run:
-          name: Build docker image
-          command: |
-            registry_id=$(echo $<<parameters.account-url>> | sed "s;\..*;;g")
-
-            docker_tag_args=""
-            IFS="," read -ra DOCKER_TAGS \<<< "<< parameters.tag >>"
-            for tag in "${DOCKER_TAGS[@]}"; do
-              docker_tag_args="$docker_tag_args -t $<<parameters.account-url>>/<<parameters.repo>>:$tag"
-            done
-
-            docker build \
-              <<#parameters.extra-build-args>><<parameters.extra-build-args>><</parameters.extra-build-args>> \
-              -f <<parameters.path>>/<<parameters.dockerfile>> \
-              $docker_tag_args \
-              <<parameters.path>>
-
-      - run:
-          name: Push image to Amazon ECR
-          command: |
-            IFS="," read -ra DOCKER_TAGS \<<< "<< parameters.tag >>"
-            for tag in "${DOCKER_TAGS[@]}"; do
-              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-nerpanet:
-    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-nerpanet -var lotus_network=nerpanet -var git_tag=$CIRCLE_TAG"
 
 workflows:
   version: 2.1
@@ -705,49 +428,17 @@ workflows:
       - test:
           codecov-upload: true
           test-suite-name: full
-      - test-chain:
-          codecov-upload: true
-          test-suite-name: chain
-          packages: "./chain/..."
-      - test-node:
-          codecov-upload: true
-          test-suite-name: node
-          packages: "./node/..."
-      - test-storage:
-          codecov-upload: true
-          test-suite-name: storage
-          packages: "./storage/... ./extern/..."
-      - test-cli:
-          codecov-upload: true
-          test-suite-name: cli
-          packages: "./cli/... ./cmd/... ./api/..."
       - test-window-post:
-          codecov-upload: true
           go-test-flags: "-run=TestWindowedPost"
           winpost-test: "1"
           test-suite-name: window-post
-      - test-window-post-dispute:
-          codecov-upload: true
-          go-test-flags: "-run=TestWindowPostDispute"
-          winpost-test: "1"
-          test-suite-name: window-post-dispute
-      - test-terminate:
-          codecov-upload: true
-          go-test-flags: "-run=TestTerminate"
-          winpost-test: "1"
-          test-suite-name: terminate
-      - test-deadline-toggling:
-          codecov-upload: true
-          go-test-flags: "-run=TestDeadlineToggling"
-          deadline-test: "1"
-          test-suite-name: deadline-toggling
       - test-short:
           go-test-flags: "--timeout 10m --short"
           test-suite-name: short
           filters:
             tags:
               only:
-                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+                - /^v\d+\.\d+\.\d+$/
       - test-conformance:
           test-suite-name: conformance
           packages: "./conformance"
@@ -756,11 +447,7 @@ workflows:
           test-suite-name: conformance-bleeding-edge
           packages: "./conformance"
           vectors-branch: master
-      - trigger-testplans:
-          filters:
-            branches:
-              only:
-                - master
+      - build-lotus-soup
       - build-debug
       - build-all:
           requires:
@@ -768,29 +455,7 @@ workflows:
           filters:
             tags:
               only:
-                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
-      - build-ntwk-calibration:
-          requires:
-            - test-short
-          filters:
-            tags:
-              only:
-                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
-      - build-ntwk-butterfly:
-          requires:
-            - test-short
-          filters:
-            tags:
-              only:
-                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
-      - build-ntwk-nerpa:
-          requires:
-            - test-short
-          filters:
-            tags:
-              only:
-                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
-      - build-lotus-soup
+                - /^v\d+\.\d+\.\d+$/
       - build-macos:
           requires:
             - test-short
@@ -800,7 +465,7 @@ workflows:
                 - /.*/
             tags:
               only:
-                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+                - /^v\d+\.\d+\.\d+$/
       - publish:
           requires:
             - build-all
@@ -811,49 +476,4 @@ workflows:
                 - /.*/
             tags:
               only:
-                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
-      - build-and-push-image:
-          dockerfile: Dockerfile.lotus
-          path: .
-          repo: lotus-dev
-          tag: '${CIRCLE_SHA1:0:8}'
-      - 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-packer-nerpanet:
-          requires:
-            - build-ntwk-nerpa
-          filters:
-            branches:
-              ignore:
-                - /.*/
-            tags:
-              only:
-                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+                - /^v\d+\.\d+\.\d+$/

.codecov.yml

@@ -1,19 +1,5 @@
 comment: off
 ignore:
-  - "**/cbor_gen.go"
-  - "api/test/**/*"
-  - "api/test/*"
-  - "gen/**/*"
-  - "gen/*"
-  - "cmd/lotus-shed/*"
-  - "cmd/tvx/*"
-  - "cmd/lotus-pcr/*"
-  - "cmd/tvx/*"
-  - "cmd/lotus-chainwatch/*"
-  - "cmd/lotus-health/*"
-  - "cmd/lotus-fountain/*"
-  - "cmd/lotus-townhall/*"
-  - "cmd/lotus-stats/*"
-  - "cmd/lotus-pcr/*"
+  - "cbor_gen.go"
 github_checks:
   annotations: false

.github/ISSUE_TEMPLATE/bug-report.md

@@ -1,33 +0,0 @@
----
-name: Bug Report
-about: Create a report to help us improve
-title: "[BUG] "
-labels: hint/needs-triaging, kind/bug
-assignees: ''
-
----
-
-> Note: For security-related bugs/issues, please follow the [security policy](https://github.com/filecoin-project/lotus/security/policy).
-
-**Describe the bug**
-A clear and concise description of what the bug is. 
-(If you are not sure what the bug is, try to figure it out via a [discussion](https://github.com/filecoin-project/lotus/discussions/new) first!
-
-**Version (run `lotus version`):**
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Run '...'
-2. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Logs**
-Provide daemon/miner/worker logs, and goroutines(if available) for troubleshooting.
- 
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,27 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Run '...'
+2. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Version (run `lotus version`):**
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/deal-making-issues.md

@@ -1,49 +0,0 @@
----
-name: Deal Making Issues
-about: Create a report for help with deal making failures.
-title: "[Deal Making Issue]"
-labels: hint/needs-triaging, area/markets
-assignees: ''
-
----
-
-> Note: For security-related bugs/issues, please follow the [security policy](https://github.com/filecoin-project/lotus/security/policy).
-
-Please provide all the information requested here to help us troubleshoot "deal making failed" issues.
-If the information requested is missing, we will probably have to just ask you to provide it anyway,
-before we can help debug.
-
-**Basic Information**
-Including information like, Are you the client or the miner? Is this a storage deal or a retrieval deal? Is it an offline deal?
-
-**Describe the problem**
-
-A brief description of the problem you encountered while trying to make a deal. 
-
-**Version**
-
-The output of `lotus --version`.
-
-**Setup**
-
-You miner(if applicable) and daemon setup, i.e: What hardware do you use, how much ram and etc.
-
-**To Reproduce**
- Steps to reproduce the behavior:
- 1. Run '...'
- 2. See error
-
-**Deal status**
-
-The output of `lotus client list-deals -v` and/or `lotus-miner storage-deals|retrieval-deals|data-transfers list [-v]` commands for the deal(s) in question.
-
-**Lotus daemon and miner logs**
-
-Please go through the logs of your daemon and miner(if applicable), and include screenshots of any error/warning-like messages you find.
-
-Alternatively please upload full log files and share a link here
-
-** Code modifications **
-
-If you have modified parts of lotus, please describe which areas were modified,
-and the scope of those modifications

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: "[Feature Request]"
-labels: hint/needs-triaging
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/mining-issues.md

@@ -1,35 +0,0 @@
----
-name: Mining Issues
-about: Create a report for help with mining failures.
-title: "[Mining Issue]"
-labels: hint/needs-triaging, area/mining
-assignees: ''
-
----
-
-> Note: For security-related bugs/issues, please follow the [security policy](https://github.com/filecoin-project/lotus/security/policy).
-
-Please provide all the information requested here to help us troubleshoot "mining/WinningPoSt failed" issues.
-If the information requested is missing, you may be asked you to provide it.
-
-**Describe the problem**
-A brief description of the problem you encountered while mining new blocks.
-
-**Version**
-
-The output of `lotus --version`.
-
-**Setup**
-
-You miner and daemon setup, including what hardware do you use, your environment variable settings, how do you run your miner and worker, do you use GPU and etc.
-
-**Lotus daemon and miner logs**
-
-Please go through the logs of your daemon and miner, and include screenshots of any error/warning-like messages you find, highlighting the one has "winning post" in it.
-
-Alternatively please upload full log files and share a link here
-
-** Code modifications **
-
-If you have modified parts of lotus, please describe which areas were modified,
-and the scope of those modifications

.github/ISSUE_TEMPLATE/proving-issues.md

@@ -1,46 +0,0 @@
----
-name: Proving Issues
-about: Create a report for help with proving failures.
-title: "[Proving Issue]"
-labels: area/proving, hint/needs-triaging
-assignees: ''
-
----
-
-> Note: For security-related bugs/issues, please follow the [security policy](https://github.com/filecoin-project/lotus/security/policy).
-
-Please provide all the information requested here to help us troubleshoot "proving/window PoSt failed" issues.
-If the information requested is missing, we will probably have to just ask you to provide it anyway,
-before we can help debug.
-
-**Describe the problem**
-A brief description of the problem you encountered while proving the storage.
-
-**Version**
-
-The output of `lotus --version`.
-
-**Setup**
-
-You miner and daemon setup, including what hardware do you use, your environment variable settings, how do you run your miner and worker, do you use GPU and etc.
-
-**Proving status**
-
-The output of `lotus-miner proving` info.
-
-**Lotus miner logs**
-
-Please go through the logs of your miner, and include screenshots of any error-like messages you find, highlighting the one has "window post" in it.
-
-Alternatively please upload full log files and share a link here
-
-**Lotus miner diagnostic info**
-
-Please collect the following diagnostic information, and share a link here
-
-* lotus-miner diagnostic info `lotus-miner info all > allinfo.txt`
-
-** Code modifications **
-
-If you have modified parts of lotus, please describe which areas were modified,
-and the scope of those modifications

.github/ISSUE_TEMPLATE/sealingfailed.md

@@ -1,32 +1,21 @@
 ---
 name: Sealing Issues
 about: Create a report for help with sealing (commit) failures.
-title: "[Sealing Issue]"
-labels: hint/needs-triaging, area/sealing
+title: ''
+labels: 'sealing'
 assignees: ''
 
 ---
 
-> Note: For security-related bugs/issues, please follow the [security policy](https://github.com/filecoin-project/lotus/security/policy).
-
 Please provide all the information requested here to help us troubleshoot "commit failed" issues.
 If the information requested is missing, we will probably have to just ask you to provide it anyway,
 before we can help debug.
 
 **Describe the problem**
-A brief description of the problem you encountered while sealing a sector.
 
-**Version**
+A brief description of the problem you encountered while proving (sealing) a sector.
 
-The output of `lotus --version`.
-
-**Setup**
-
-You miner and daemon setup, including what hardware do you use, your environment variable settings, how do you run your miner and worker, do you use GPU and etc.
-
-**Commands**
-
-Commands you ran.
+Including what commands you ran, and a description of your setup, is very helpful.
 
 **Sectors status**
 
@@ -48,3 +37,7 @@ Please collect the following diagnostic information, and share a link here
 
 If you have modified parts of lotus, please describe which areas were modified,
 and the scope of those modifications
+
+**Version**
+
+The output of `lotus --version`.

.gitignore

@@ -12,10 +12,6 @@
 /lotus-bench
 /lotus-gateway
 /lotus-pcr
-/lotus-wallet
-/lotus-keygen
-/docgen-md
-/docgen-openrpc
 /bench.json
 /lotuspond/front/node_modules
 /lotuspond/front/build

.gitmodules

@@ -1,9 +1,16 @@
 [submodule "extern/filecoin-ffi"]
 	path = extern/filecoin-ffi
 	url = https://github.com/filecoin-project/filecoin-ffi.git
+	branch = master
 [submodule "extern/serialization-vectors"]
 	path = extern/serialization-vectors
-	url = https://github.com/filecoin-project/serialization-vectors.git
+	url = https://github.com/filecoin-project/serialization-vectors
 [submodule "extern/test-vectors"]
 	path = extern/test-vectors
 	url = https://github.com/filecoin-project/test-vectors.git
+[submodule "extern/fil-blst"]
+	path = extern/fil-blst
+	url = https://github.com/filecoin-project/fil-blst.git
+[submodule "extern/oni"]
+	path = extern/oni
+	url = https://github.com/filecoin-project/oni

.golangci.yml

@@ -16,12 +16,6 @@ linters:
     - deadcode
     - scopelint
 
-# We don't want to skip builtin/
-skip-dirs-use-default: false
-skip-dirs:
-  - vendor$
-  - testdata$
-  - examples$
 
 issues:
   exclude:

Dockerfile.lotus

@@ -1,74 +0,0 @@
-FROM golang:1.15.6 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"
-
-ENV RUSTUP_HOME=/usr/local/rustup \
-    CARGO_HOME=/usr/local/cargo \
-    PATH=/usr/local/cargo/bin:$PATH
-
-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; \
-    rm rustup-init; \
-    chmod -R a+w $RUSTUP_HOME $CARGO_HOME; \
-    rustup --version; \
-    cargo --version; \
-    rustc --version;
-
-
-FROM builder-deps AS builder-local
-MAINTAINER Lotus Development Team
-
-COPY ./ /opt/filecoin
-WORKDIR /opt/filecoin
-RUN make clean deps
-
-
-FROM builder-local AS builder
-MAINTAINER Lotus Development Team
-
-WORKDIR /opt/filecoin
-
-ARG RUSTFLAGS=""
-ARG GOFLAGS=""
-
-RUN make deps lotus lotus-miner lotus-worker lotus-shed lotus-chainwatch lotus-stats
-
-
-FROM ubuntu:20.04 AS base
-MAINTAINER Lotus Development Team
-
-# Base resources
-COPY --from=builder /etc/ssl/certs                           /etc/ssl/certs
-COPY --from=builder /lib/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
-
-
-FROM base AS lotus
-MAINTAINER Lotus Development Team
-
-COPY --from=builder /opt/filecoin/lotus      /usr/local/bin/
-COPY --from=builder /opt/filecoin/lotus-shed /usr/local/bin/
-
-ENV FILECOIN_PARAMETER_CACHE /var/tmp/filecoin-proof-parameters
-ENV LOTUS_PATH /var/lib/lotus
-
-RUN mkdir /var/lib/lotus /var/tmp/filecoin-proof-parameters && chown fc /var/lib/lotus /var/tmp/filecoin-proof-parameters
-
-USER fc
-
-ENTRYPOINT ["/usr/local/bin/lotus"]
-
-CMD ["-help"]

Makefile

@@ -5,10 +5,10 @@ all: build
 
 unexport GOFLAGS
 
-GOVERSION:=$(shell go version | cut -d' ' -f 3 | sed 's/^go//' | awk -F. '{printf "%d%03d%03d", $$1, $$2, $$3}')
-ifeq ($(shell expr $(GOVERSION) \< 1015005), 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 1.15.5)
+GOVERSION:=$(shell go version | cut -d' ' -f 3 | cut -d. -f 2)
+ifeq ($(shell expr $(GOVERSION) \< 14), 1)
+$(warning Your Golang version is go 1.$(GOVERSION))
+$(error Update Golang to version $(shell grep '^go' go.mod))
 endif
 
 # git modules that need to be loaded
@@ -41,14 +41,8 @@ MODULES+=$(FFI_PATH)
 BUILD_DEPS+=build/.filecoin-install
 CLEAN+=build/.filecoin-install
 
-ffi-version-check:
-	@[[ "$$(awk '/const Version/{print $$5}' extern/filecoin-ffi/version.go)" -eq 2 ]] || (echo "FFI version mismatch, update submodules"; exit 1)
-BUILD_DEPS+=ffi-version-check
-
-.PHONY: ffi-version-check
-
-
 $(MODULES): build/.update-modules ;
+
 # dummy file that marks the last time modules were updated
 build/.update-modules:
 	git submodule update --init --recursive
@@ -63,23 +57,11 @@ CLEAN+=build/.update-modules
 deps: $(BUILD_DEPS)
 .PHONY: deps
 
-build-devnets: build lotus-seed lotus-shed lotus-wallet lotus-gateway
-.PHONY: build-devnets
-
 debug: GOFLAGS+=-tags=debug
-debug: build-devnets
+debug: lotus lotus-miner lotus-worker lotus-seed
 
 2k: GOFLAGS+=-tags=2k
-2k: build-devnets
-
-calibnet: GOFLAGS+=-tags=calibnet
-calibnet: build-devnets
-
-nerpanet: GOFLAGS+=-tags=nerpanet
-nerpanet: build-devnets
-
-butterflynet: GOFLAGS+=-tags=butterflynet
-butterflynet: build-devnets
+2k: lotus lotus-miner lotus-worker lotus-seed
 
 lotus: $(BUILD_DEPS)
 	rm -f lotus
@@ -151,30 +133,18 @@ benchmarks:
 
 lotus-pond: 2k
 	go build -o lotus-pond ./lotuspond
+	(cd lotuspond/front && npm i && CI=false npm run build)
 .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-townhall:
 	rm -f lotus-townhall
 	go build -o lotus-townhall ./cmd/lotus-townhall
+	(cd ./cmd/lotus-townhall/townhall && npm i && npm run build)
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-townhall -i ./cmd/lotus-townhall -i ./build
 .PHONY: lotus-townhall
 BINS+=lotus-townhall
 
-lotus-townhall-front:
-	(cd ./cmd/lotus-townhall/townhall && npm i && npm run build)
-.PHONY: lotus-townhall-front
-
-lotus-townhall-app: lotus-touch lotus-townhall-front
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-townhall -i ./cmd/lotus-townhall -i ./build
-.PHONY: lotus-townhall-app
-
 lotus-fountain:
 	rm -f lotus-fountain
 	go build -o lotus-fountain ./cmd/lotus-fountain
@@ -197,7 +167,7 @@ BINS+=lotus-bench
 
 lotus-stats:
 	rm -f lotus-stats
-	go build $(GOFLAGS) -o lotus-stats ./cmd/lotus-stats
+	go build -o lotus-stats ./cmd/lotus-stats
 	go run github.com/GeertJohan/go.rice/rice append --exec lotus-stats -i ./build
 .PHONY: lotus-stats
 BINS+=lotus-stats
@@ -216,18 +186,6 @@ lotus-health:
 .PHONY: lotus-health
 BINS+=lotus-health
 
-lotus-wallet:
-	rm -f lotus-wallet
-	go build -o lotus-wallet ./cmd/lotus-wallet
-.PHONY: lotus-wallet
-BINS+=lotus-wallet
-
-lotus-keygen:
-	rm -f lotus-keygen
-	go build -o lotus-keygen ./cmd/lotus-keygen
-.PHONY: lotus-keygen
-BINS+=lotus-keygen
-
 testground:
 	go build -tags testground -o /dev/null ./cmd/lotus
 .PHONY: testground
@@ -325,45 +283,10 @@ type-gen:
 method-gen:
 	(cd ./lotuspond/front/src/chain && go run ./methodgen.go)
 
-actors-gen:
-	go run ./chain/actors/agen
-	go fmt ./...
+gen: type-gen method-gen
 
-api-gen:
-	go run ./gen/api > api/apistruct/struct.go
-	goimports -w api/apistruct
-	goimports -w api/apistruct
-.PHONY: api-gen
-
-docsgen: docsgen-md docsgen-openrpc
-
-docsgen-md-bin: actors-gen
-	go build $(GOFLAGS) -o docgen-md ./api/docgen/cmd
-docsgen-openrpc-bin: actors-gen
-	go build $(GOFLAGS) -o docgen-openrpc ./api/docgen-openrpc/cmd
-
-docsgen-md: docsgen-md-full docsgen-md-storage docsgen-md-worker
-
-docsgen-md-full: docsgen-md-bin
-	./docgen-md "api/api_full.go" "FullNode" > documentation/en/api-methods.md
-docsgen-md-storage: docsgen-md-bin
-	./docgen-md "api/api_storage.go" "StorageMiner" > documentation/en/api-methods-miner.md
-docsgen-md-worker: docsgen-md-bin
-	./docgen-md "api/api_worker.go" "Worker" > documentation/en/api-methods-worker.md
-
-docsgen-openrpc: docsgen-openrpc-full docsgen-openrpc-storage docsgen-openrpc-worker
-
-docsgen-openrpc-full: docsgen-openrpc-bin
-	./docgen-openrpc "api/api_full.go" "FullNode" -gzip > build/openrpc/full.json.gz
-docsgen-openrpc-storage: docsgen-openrpc-bin
-	./docgen-openrpc "api/api_storage.go" "StorageMiner" -gzip > build/openrpc/miner.json.gz
-docsgen-openrpc-worker: docsgen-openrpc-bin
-	./docgen-openrpc "api/api_worker.go" "Worker" -gzip > build/openrpc/worker.json.gz
-
-.PHONY: docsgen docsgen-md-bin docsgen-openrpc-bin
-
-gen: actors-gen type-gen method-gen docsgen api-gen
-.PHONY: gen
+docsgen:
+	go run ./api/docgen > documentation/en/api-methods.md
 
 print-%:
 	@echo $*=$($*)

README.md

@@ -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.15.5-blue.svg" /></a>
+  <a href=""><img src="https://img.shields.io/badge/golang-%3E%3D1.14.7-blue.svg" /></a>
   <br>
 </p>
 
@@ -24,31 +24,24 @@ For instructions on how to build, install and setup lotus, please visit [https:/
 
 Please send an email to security@filecoin.org. See our [security policy](SECURITY.md) for more details.
 
-## Related packages
+## Development
 
-These repos are independent and reusable modules, but are tightly integrated into Lotus to make up a fully featured Filecoin implementation:
+The main branches under development at the moment are:
+* [`master`](https://github.com/filecoin-project/lotus): current testnet.
+* [`next`](https://github.com/filecoin-project/lotus/tree/next): working branch with chain-breaking changes.
+* [`ntwk-calibration`](https://github.com/filecoin-project/lotus/tree/ntwk-calibration): devnet running one of `next` commits.
 
+### Tracker
+
+All work is tracked via issues. An attempt at keeping an up-to-date view on remaining work towards Mainnet launch can be seen at the [lotus github project board](https://github.com/orgs/filecoin-project/projects/8). The issues labeled with `incentives` are there to identify the issues needed for Space Race launch.
+
+### Packages
+
+The lotus Filecoin implementation unfolds into the following packages:
+
+- [This repo](https://github.com/filecoin-project/lotus)
 - [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)
-- [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
-
-Lotus is a universally open project and welcomes contributions of all kinds: code, docs, and more. However, before making a contribution, we ask you to heed these recommendations:
-
-1. If the proposal entails a protocol change, please first submit a [Filecoin Improvement Proposal](https://github.com/filecoin-project/FIPs).
-2. If the change is complex and requires prior discussion, [open an issue](github.com/filecoin-project/lotus/issues) or a [discussion](https://github.com/filecoin-project/lotus/discussions) to request feedback before you start working on a pull request. This is to avoid disappointment and sunk costs, in case the change is not actually needed or accepted.
-3. Please refrain from submitting PRs to adapt existing code to subjective preferences. The changeset should contain functional or technical improvements/enhancements, bug fixes, new features, or some other clear material contribution. Simple stylistic changes are likely to be rejected in order to reduce code churn.
-
-When implementing a change:
-
-1. Adhere to the standard Go formatting guidelines, e.g. [Effective Go](https://golang.org/doc/effective_go.html). Run `go fmt`.
-2. Stick to the idioms and patterns used in the codebase. Familiar-looking code has a higher chance of being accepted than eerie code. Pay attention to commonly used variable and parameter names, avoidance of naked returns, error handling patterns, etc.
-3. Comments: follow the advice on the [Commentary](https://golang.org/doc/effective_go.html#commentary) section of Effective Go.
-4. Minimize code churn. Modify only what is strictly necessary. Well-encapsulated changesets will get a quicker response from maintainers.
-5. Lint your code with [`golangci-lint`](https://golangci-lint.run) (CI will reject your PR if unlinted).
-6. Add tests.
-7. Title the PR in a meaningful way and describe the rationale and the thought process in the PR description.
-8. Write clean, thoughtful, and detailed [commit messages](https://chris.beams.io/posts/git-commit/). This is even more important than the PR description, because commit messages are stored _inside_ the Git history. One good rule is: if you are happy posting the commit message as the PR description, then it's a good commit message.
+- [spec-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)
 
 ## License
 

SECURITY.md

@@ -2,11 +2,13 @@
 
 ## Reporting a Vulnerability
 
-For reporting security vulnerabilities/bugs, please consult our Security Policy and Responsible Disclosure Program information at https://github.com/filecoin-project/community/blob/master/SECURITY.md. Security vulnerabilities should be reported via our [Vulnerability Reporting channels](https://github.com/filecoin-project/community/blob/master/SECURITY.md#vulnerability-reporting) and will be eligible for a [Bug Bounty](https://security.filecoin.io/bug-bounty/).
+For *critical* bugs, please send an email to security@filecoin.org.
+
+The bug reporting process differs between bugs that are critical and may crash the network, and others that are unlikely to cause problems if malicious parties know about it. For non-critical bugs, please simply file a GitHub [issue](https://github.com/filecoin-project/lotus/issues/new?template=bug_report.md). 
 
 Please try to provide a clear description of any bugs reported, along with how to reproduce the bug if possible. More detailed bug reports (especially those with a PoC included) will help us move forward much faster. Additionally, please avoid reporting bugs that already have open issues. Take a moment to search the issue list of the related GitHub repositories before writing up a new report.
 
-Here are some examples of bugs we would consider to be security vulnerabilities:
+Here are some examples of bugs we would consider 'critical':
 
 * If you can spend from a `multisig` wallet you do not control the keys for.
 * If you can cause a miner to be slashed without them actually misbehaving.
@@ -16,8 +18,12 @@ Here are some examples of bugs we would consider to be security vulnerabilities:
 * If you can craft a message that causes a persistent fork in the network.
 * If you can cause the total amount of Filecoin in the network to no longer be 2 billion.
 
-This is not an exhaustive list, but should provide some idea of what we consider as a security vulnerability, . 
+This is not an exhaustive list, but should provide some idea of what we consider 'critical'.
 
-## Reporting a non security bug
+## Supported Versions
 
-For non-security bugs, please simply file a GitHub [issue](https://github.com/filecoin-project/lotus/issues/new?template=bug_report.md). 
+* TODO: This should be defined and set up by Mainnet launch.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| Testnet | :white_check_mark: |

api/api_common.go

@@ -4,86 +4,72 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/google/uuid"
-
 	"github.com/filecoin-project/go-jsonrpc/auth"
 	metrics "github.com/libp2p/go-libp2p-core/metrics"
 	"github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/peer"
 	protocol "github.com/libp2p/go-libp2p-core/protocol"
 
-	apitypes "github.com/filecoin-project/lotus/api/types"
+	"github.com/filecoin-project/lotus/build"
 )
 
 type Common interface {
 
 	// MethodGroup: Auth
 
-	AuthVerify(ctx context.Context, token string) ([]auth.Permission, error) //perm:read
-	AuthNew(ctx context.Context, perms []auth.Permission) ([]byte, error)    //perm:admin
+	AuthVerify(ctx context.Context, token string) ([]auth.Permission, error)
+	AuthNew(ctx context.Context, perms []auth.Permission) ([]byte, error)
 
 	// MethodGroup: Net
 
-	NetConnectedness(context.Context, peer.ID) (network.Connectedness, error) //perm:read
-	NetPeers(context.Context) ([]peer.AddrInfo, error)                        //perm:read
-	NetConnect(context.Context, peer.AddrInfo) error                          //perm:write
-	NetAddrsListen(context.Context) (peer.AddrInfo, error)                    //perm:read
-	NetDisconnect(context.Context, peer.ID) error                             //perm:write
-	NetFindPeer(context.Context, peer.ID) (peer.AddrInfo, error)              //perm:read
-	NetPubsubScores(context.Context) ([]PubsubScore, error)                   //perm:read
-	NetAutoNatStatus(context.Context) (NatInfo, error)                        //perm:read
-	NetAgentVersion(ctx context.Context, p peer.ID) (string, error)           //perm:read
-	NetPeerInfo(context.Context, peer.ID) (*ExtendedPeerInfo, error)          //perm:read
+	NetConnectedness(context.Context, peer.ID) (network.Connectedness, error)
+	NetPeers(context.Context) ([]peer.AddrInfo, error)
+	NetConnect(context.Context, peer.AddrInfo) error
+	NetAddrsListen(context.Context) (peer.AddrInfo, error)
+	NetDisconnect(context.Context, peer.ID) error
+	NetFindPeer(context.Context, peer.ID) (peer.AddrInfo, error)
+	NetPubsubScores(context.Context) ([]PubsubScore, error)
+	NetAutoNatStatus(context.Context) (NatInfo, error)
+	NetAgentVersion(ctx context.Context, p peer.ID) (string, error)
 
 	// NetBandwidthStats returns statistics about the nodes total bandwidth
 	// usage and current rate across all peers and protocols.
-	NetBandwidthStats(ctx context.Context) (metrics.Stats, error) //perm:read
+	NetBandwidthStats(ctx context.Context) (metrics.Stats, error)
 
 	// NetBandwidthStatsByPeer returns statistics about the nodes bandwidth
 	// usage and current rate per peer
-	NetBandwidthStatsByPeer(ctx context.Context) (map[string]metrics.Stats, error) //perm:read
+	NetBandwidthStatsByPeer(ctx context.Context) (map[string]metrics.Stats, error)
 
 	// NetBandwidthStatsByProtocol returns statistics about the nodes bandwidth
 	// usage and current rate per protocol
-	NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error) //perm:read
-
-	// ConnectionGater API
-	NetBlockAdd(ctx context.Context, acl NetBlockList) error    //perm:admin
-	NetBlockRemove(ctx context.Context, acl NetBlockList) error //perm:admin
-	NetBlockList(ctx context.Context) (NetBlockList, error)     //perm:read
+	NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error)
 
 	// MethodGroup: Common
 
-	// Discover returns an OpenRPC document describing an RPC API.
-	Discover(ctx context.Context) (apitypes.OpenRPCDocument, error) //perm:read
-
 	// ID returns peerID of libp2p node backing this API
-	ID(context.Context) (peer.ID, error) //perm:read
+	ID(context.Context) (peer.ID, error)
 
 	// Version provides information about API provider
-	Version(context.Context) (APIVersion, error) //perm:read
+	Version(context.Context) (Version, error)
 
-	LogList(context.Context) ([]string, error)         //perm:write
-	LogSetLevel(context.Context, string, string) error //perm:write
+	LogList(context.Context) ([]string, error)
+	LogSetLevel(context.Context, string, string) error
 
 	// trigger graceful shutdown
-	Shutdown(context.Context) error //perm:admin
+	Shutdown(context.Context) error
 
-	// Session returns a random UUID of api provider session
-	Session(context.Context) (uuid.UUID, error) //perm:read
-
-	Closing(context.Context) (<-chan struct{}, error) //perm:read
+	Closing(context.Context) (<-chan struct{}, error)
 }
 
-// APIVersion provides various build-time information
-type APIVersion struct {
+// Version provides various build-time information
+type Version struct {
 	Version string
 
 	// APIVersion is a binary encoded semver version of the remote implementing
 	// this api
 	//
 	// See APIVersion in build/version.go
-	APIVersion Version
+	APIVersion build.Version
 
 	// TODO: git commit / os / genesis cid?
 
@@ -91,7 +77,7 @@ type APIVersion struct {
 	BlockDelay uint64
 }
 
-func (v APIVersion) String() string {
+func (v Version) String() string {
 	return fmt.Sprintf("%s+api%s", v.Version, v.APIVersion.String())
 }
 

api/api_gateway.go

@@ -1,47 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"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/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"
-)
-
-type Gateway interface {
-	ChainHasObj(context.Context, cid.Cid) (bool, error)
-	ChainHead(ctx context.Context) (*types.TipSet, error)
-	ChainGetBlockMessages(context.Context, cid.Cid) (*BlockMessages, error)
-	ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Message, error)
-	ChainGetTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error)
-	ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error)
-	ChainNotify(context.Context) (<-chan []*HeadChange, error)
-	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
-	GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *MessageSendSpec, tsk types.TipSetKey) (*types.Message, error)
-	MpoolPush(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error)
-	MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error)
-	MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error)
-	MsigGetPending(context.Context, address.Address, types.TipSetKey) ([]*MsigTransaction, error)
-	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-	StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (DealCollateralBounds, error)
-	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
-	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
-	StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error)
-	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) (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)
-	StateSearchMsg(ctx context.Context, msg cid.Cid) (*MsgLookup, error)
-	StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error)
-	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
-	StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*MsgLookup, error)
-}

api/api_storage.go

@@ -5,186 +5,104 @@ import (
 	"context"
 	"time"
 
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-
-	"github.com/google/uuid"
 	"github.com/ipfs/go-cid"
-	"github.com/libp2p/go-libp2p-core/peer"
 
 	"github.com/filecoin-project/go-address"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"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-state-types/abi"
-	"github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
-	"github.com/filecoin-project/specs-storage/storage"
-
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
-	"github.com/filecoin-project/lotus/extern/storage-sealing/sealiface"
 )
 
 // StorageMiner is a low-level interface to the Filecoin network storage miner node
 type StorageMiner interface {
 	Common
 
-	ActorAddress(context.Context) (address.Address, error) //perm:read
+	ActorAddress(context.Context) (address.Address, error)
 
-	ActorSectorSize(context.Context, address.Address) (abi.SectorSize, error) //perm:read
-	ActorAddressConfig(ctx context.Context) (AddressConfig, error)            //perm:read
+	ActorSectorSize(context.Context, address.Address) (abi.SectorSize, error)
 
-	MiningBase(context.Context) (*types.TipSet, error) //perm:read
+	MiningBase(context.Context) (*types.TipSet, error)
 
 	// Temp api for testing
-	PledgeSector(context.Context) (abi.SectorID, error) //perm:write
+	PledgeSector(context.Context) error
 
 	// Get the status of a given sector by ID
-	SectorsStatus(ctx context.Context, sid abi.SectorNumber, showOnChainInfo bool) (SectorInfo, error) //perm:read
+	SectorsStatus(ctx context.Context, sid abi.SectorNumber, showOnChainInfo bool) (SectorInfo, error)
 
 	// List all staged sectors
-	SectorsList(context.Context) ([]abi.SectorNumber, error) //perm:read
+	SectorsList(context.Context) ([]abi.SectorNumber, error)
 
-	// Get summary info of sectors
-	SectorsSummary(ctx context.Context) (map[SectorState]int, error) //perm:read
-
-	// List sectors in particular states
-	SectorsListInStates(context.Context, []SectorState) ([]abi.SectorNumber, error) //perm:read
-
-	SectorsRefs(context.Context) (map[string][]SealedRef, error) //perm:read
+	SectorsRefs(context.Context) (map[string][]SealedRef, error)
 
 	// SectorStartSealing can be called on sectors in Empty or WaitDeals states
 	// to trigger sealing early
-	SectorStartSealing(context.Context, abi.SectorNumber) error //perm:write
+	SectorStartSealing(context.Context, abi.SectorNumber) error
 	// SectorSetSealDelay sets the time that a newly-created sector
 	// waits for more deals before it starts sealing
-	SectorSetSealDelay(context.Context, time.Duration) error //perm:write
+	SectorSetSealDelay(context.Context, time.Duration) error
 	// SectorGetSealDelay gets the time that a newly-created sector
 	// waits for more deals before it starts sealing
-	SectorGetSealDelay(context.Context) (time.Duration, error) //perm:read
+	SectorGetSealDelay(context.Context) (time.Duration, error)
 	// SectorSetExpectedSealDuration sets the expected time for a sector to seal
-	SectorSetExpectedSealDuration(context.Context, time.Duration) error //perm:write
+	SectorSetExpectedSealDuration(context.Context, time.Duration) error
 	// SectorGetExpectedSealDuration gets the expected time for a sector to seal
-	SectorGetExpectedSealDuration(context.Context) (time.Duration, error) //perm:read
-	SectorsUpdate(context.Context, abi.SectorNumber, SectorState) error   //perm:admin
-	// SectorRemove removes the sector from storage. It doesn't terminate it on-chain, which can
-	// be done with SectorTerminate. Removing and not terminating live sectors will cause additional penalties.
-	SectorRemove(context.Context, abi.SectorNumber) error //perm:admin
-	// SectorTerminate terminates the sector on-chain (adding it to a termination batch first), then
-	// automatically removes it from storage
-	SectorTerminate(context.Context, abi.SectorNumber) error //perm:admin
-	// SectorTerminateFlush immediately sends a terminate message with sectors batched for termination.
-	// Returns null if message wasn't sent
-	SectorTerminateFlush(ctx context.Context) (*cid.Cid, error) //perm:admin
-	// SectorTerminatePending returns a list of pending sector terminations to be sent in the next batch message
-	SectorTerminatePending(ctx context.Context) ([]abi.SectorID, error)  //perm:admin
-	SectorMarkForUpgrade(ctx context.Context, id abi.SectorNumber) error //perm:admin
-	// SectorPreCommitFlush immediately sends a PreCommit message with sectors batched for PreCommit.
-	// Returns null if message wasn't sent
-	SectorPreCommitFlush(ctx context.Context) ([]sealiface.PreCommitBatchRes, error) //perm:admin
-	// SectorPreCommitPending returns a list of pending PreCommit sectors to be sent in the next batch message
-	SectorPreCommitPending(ctx context.Context) ([]abi.SectorID, error) //perm:admin
-	// SectorCommitFlush immediately sends a Commit message with sectors aggregated for Commit.
-	// Returns null if message wasn't sent
-	SectorCommitFlush(ctx context.Context) ([]sealiface.CommitBatchRes, error) //perm:admin
-	// SectorCommitPending returns a list of pending Commit sectors to be sent in the next aggregate message
-	SectorCommitPending(ctx context.Context) ([]abi.SectorID, error) //perm:admin
+	SectorGetExpectedSealDuration(context.Context) (time.Duration, error)
+	SectorsUpdate(context.Context, abi.SectorNumber, SectorState) error
+	SectorRemove(context.Context, abi.SectorNumber) error
+	SectorMarkForUpgrade(ctx context.Context, id abi.SectorNumber) error
+
+	StorageList(ctx context.Context) (map[stores.ID][]stores.Decl, error)
+	StorageLocal(ctx context.Context) (map[stores.ID]string, error)
+	StorageStat(ctx context.Context, id stores.ID) (fsutil.FsStat, error)
 
 	// 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
-	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
-	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
+	WorkerConnect(context.Context, string) error
+	WorkerStats(context.Context) (map[uint64]storiface.WorkerStats, error)
+	WorkerJobs(context.Context) (map[uint64][]storiface.WorkerJob, error)
 
 	// 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
+	SealingSchedDiag(context.Context) (interface{}, error)
 
-	//stores.SectorIndex
-	StorageAttach(context.Context, stores.StorageInfo, fsutil.FsStat) error                                                                                             //perm:admin
-	StorageInfo(context.Context, stores.ID) (stores.StorageInfo, error)                                                                                                 //perm:admin
-	StorageReportHealth(context.Context, stores.ID, stores.HealthReport) error                                                                                          //perm:admin
-	StorageDeclareSector(ctx context.Context, storageID stores.ID, s abi.SectorID, ft storiface.SectorFileType, primary bool) error                                     //perm:admin
-	StorageDropSector(ctx context.Context, storageID stores.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) ([]stores.SectorStorageInfo, error) //perm:admin
-	StorageBestAlloc(ctx context.Context, allocate storiface.SectorFileType, ssize abi.SectorSize, pathType storiface.PathType) ([]stores.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
+	stores.SectorIndex
 
-	StorageList(ctx context.Context) (map[stores.ID][]stores.Decl, error) //perm:admin
-	StorageLocal(ctx context.Context) (map[stores.ID]string, error)       //perm:admin
-	StorageStat(ctx context.Context, id stores.ID) (fsutil.FsStat, error) //perm:admin
+	MarketImportDealData(ctx context.Context, propcid cid.Cid, path string) error
+	MarketListDeals(ctx context.Context) ([]MarketDeal, error)
+	MarketListRetrievalDeals(ctx context.Context) ([]retrievalmarket.ProviderDealState, error)
+	MarketGetDealUpdates(ctx context.Context) (<-chan storagemarket.MinerDeal, error)
+	MarketListIncompleteDeals(ctx context.Context) ([]storagemarket.MinerDeal, error)
+	MarketSetAsk(ctx context.Context, price types.BigInt, verifiedPrice types.BigInt, duration abi.ChainEpoch, minPieceSize abi.PaddedPieceSize, maxPieceSize abi.PaddedPieceSize) error
+	MarketGetAsk(ctx context.Context) (*storagemarket.SignedStorageAsk, error)
+	MarketSetRetrievalAsk(ctx context.Context, rask *retrievalmarket.Ask) error
+	MarketGetRetrievalAsk(ctx context.Context) (*retrievalmarket.Ask, error)
+	MarketListDataTransfers(ctx context.Context) ([]DataTransferChannel, error)
+	MarketDataTransferUpdates(ctx context.Context) (<-chan DataTransferChannel, error)
 
-	MarketImportDealData(ctx context.Context, propcid cid.Cid, path string) error                                                                                                        //perm:write
-	MarketListDeals(ctx context.Context) ([]MarketDeal, error)                                                                                                                           //perm:read
-	MarketListRetrievalDeals(ctx context.Context) ([]retrievalmarket.ProviderDealState, error)                                                                                           //perm:read
-	MarketGetDealUpdates(ctx context.Context) (<-chan storagemarket.MinerDeal, error)                                                                                                    //perm:read
-	MarketListIncompleteDeals(ctx context.Context) ([]storagemarket.MinerDeal, error)                                                                                                    //perm:read
-	MarketSetAsk(ctx context.Context, price types.BigInt, verifiedPrice types.BigInt, duration abi.ChainEpoch, minPieceSize abi.PaddedPieceSize, maxPieceSize abi.PaddedPieceSize) error //perm:admin
-	MarketGetAsk(ctx context.Context) (*storagemarket.SignedStorageAsk, error)                                                                                                           //perm:read
-	MarketSetRetrievalAsk(ctx context.Context, rask *retrievalmarket.Ask) error                                                                                                          //perm:admin
-	MarketGetRetrievalAsk(ctx context.Context) (*retrievalmarket.Ask, error)                                                                                                             //perm:read
-	MarketListDataTransfers(ctx context.Context) ([]DataTransferChannel, error)                                                                                                          //perm:write
-	MarketDataTransferUpdates(ctx context.Context) (<-chan DataTransferChannel, error)                                                                                                   //perm:write
-	// MarketRestartDataTransfer attempts to restart a data transfer with the given transfer ID and other peer
-	MarketRestartDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error //perm:write
-	// MarketCancelDataTransfer cancels a data transfer with the given transfer ID and other peer
-	MarketCancelDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error //perm:write
-	MarketPendingDeals(ctx context.Context) (PendingDealInfo, error)                                                             //perm:write
-	MarketPublishPendingDeals(ctx context.Context) error                                                                         //perm:admin
+	DealsImportData(ctx context.Context, dealPropCid cid.Cid, file string) error
+	DealsList(ctx context.Context) ([]MarketDeal, error)
+	DealsConsiderOnlineStorageDeals(context.Context) (bool, error)
+	DealsSetConsiderOnlineStorageDeals(context.Context, bool) error
+	DealsConsiderOnlineRetrievalDeals(context.Context) (bool, error)
+	DealsSetConsiderOnlineRetrievalDeals(context.Context, bool) error
+	DealsPieceCidBlocklist(context.Context) ([]cid.Cid, error)
+	DealsSetPieceCidBlocklist(context.Context, []cid.Cid) error
+	DealsConsiderOfflineStorageDeals(context.Context) (bool, error)
+	DealsSetConsiderOfflineStorageDeals(context.Context, bool) error
+	DealsConsiderOfflineRetrievalDeals(context.Context) (bool, error)
+	DealsSetConsiderOfflineRetrievalDeals(context.Context, bool) error
 
-	DealsImportData(ctx context.Context, dealPropCid cid.Cid, file string) 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
-	DealsSetConsiderOnlineRetrievalDeals(context.Context, bool) error            //perm:admin
-	DealsPieceCidBlocklist(context.Context) ([]cid.Cid, error)                   //perm:admin
-	DealsSetPieceCidBlocklist(context.Context, []cid.Cid) error                  //perm:admin
-	DealsConsiderOfflineStorageDeals(context.Context) (bool, error)              //perm:admin
-	DealsSetConsiderOfflineStorageDeals(context.Context, bool) error             //perm:admin
-	DealsConsiderOfflineRetrievalDeals(context.Context) (bool, error)            //perm:admin
-	DealsSetConsiderOfflineRetrievalDeals(context.Context, bool) error           //perm:admin
-	DealsConsiderVerifiedStorageDeals(context.Context) (bool, error)             //perm:admin
-	DealsSetConsiderVerifiedStorageDeals(context.Context, bool) error            //perm:admin
-	DealsConsiderUnverifiedStorageDeals(context.Context) (bool, error)           //perm:admin
-	DealsSetConsiderUnverifiedStorageDeals(context.Context, bool) error          //perm:admin
+	StorageAddLocal(ctx context.Context, path string) error
 
-	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
-	PiecesGetCIDInfo(ctx context.Context, payloadCid cid.Cid) (*piecestore.CIDInfo, error)   //perm:read
-
-	// CreateBackup creates node backup onder the specified file name. The
-	// method requires that the lotus-miner is running with the
-	// 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
-
-	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.SectorInfo, rand abi.PoStRandomness) ([]builtin.PoStProof, error) //perm:read
+	PiecesListPieces(ctx context.Context) ([]cid.Cid, error)
+	PiecesListCidInfos(ctx context.Context) ([]cid.Cid, error)
+	PiecesGetPieceInfo(ctx context.Context, pieceCid cid.Cid) (*piecestore.PieceInfo, error)
+	PiecesGetCIDInfo(ctx context.Context, payloadCid cid.Cid) (*piecestore.CIDInfo, error)
 }
 
-var _ storiface.WorkerReturn = *new(StorageMiner)
-var _ stores.SectorIndex = *new(StorageMiner)
-
 type SealRes struct {
 	Err   string
 	GoErr error `json:"-"`
@@ -262,30 +180,3 @@ func (st *SealSeed) Equals(ost *SealSeed) bool {
 }
 
 type SectorState string
-
-type AddrUse int
-
-const (
-	PreCommitAddr AddrUse = iota
-	CommitAddr
-	PoStAddr
-
-	TerminateSectorsAddr
-)
-
-type AddressConfig struct {
-	PreCommitControl []address.Address
-	CommitControl    []address.Address
-	TerminateControl []address.Address
-
-	DisableOwnerFallback  bool
-	DisableWorkerFallback bool
-}
-
-// PendingDealInfo has info about pending deals and when they are due to be
-// published
-type PendingDealInfo struct {
-	Deals              []market.ClientDealProposal
-	PublishPeriodStart time.Time
-	PublishPeriod      time.Duration
-}

api/api_test.go

@@ -37,18 +37,6 @@ func TestDoesntDependOnFFI(t *testing.T) {
 	}
 }
 
-func TestDoesntDependOnBuild(t *testing.T) {
-	deps, err := exec.Command(goCmd(), "list", "-deps", "github.com/filecoin-project/lotus/api").Output()
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, pkg := range strings.Fields(string(deps)) {
-		if pkg == "github.com/filecoin-project/build" {
-			t.Fatal("api depends on filecoin-ffi")
-		}
-	}
-}
-
 func TestReturnTypes(t *testing.T) {
 	errType := reflect.TypeOf(new(error)).Elem()
 	bareIface := reflect.TypeOf(new(interface{})).Elem()
@@ -111,5 +99,5 @@ func TestReturnTypes(t *testing.T) {
 	t.Run("common", tst(new(Common)))
 	t.Run("full", tst(new(FullNode)))
 	t.Run("miner", tst(new(StorageMiner)))
-	t.Run("worker", tst(new(Worker)))
+	t.Run("worker", tst(new(WorkerAPI)))
 }

api/api_wallet.go

@@ -1,47 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/crypto"
-
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type MsgType string
-
-const (
-	MTUnknown = "unknown"
-
-	// Signing message CID. MsgMeta.Extra contains raw cbor message bytes
-	MTChainMsg = "message"
-
-	// Signing a blockheader. signing raw cbor block bytes (MsgMeta.Extra is empty)
-	MTBlock = "block"
-
-	// Signing a deal proposal. signing raw cbor proposal bytes (MsgMeta.Extra is empty)
-	MTDealProposal = "dealproposal"
-
-	// TODO: Deals, Vouchers, VRF
-)
-
-type MsgMeta struct {
-	Type MsgType
-
-	// Additional data related to what is signed. Should be verifiable with the
-	// signed bytes (e.g. CID(Extra).Bytes() == toSign)
-	Extra []byte
-}
-
-type Wallet interface {
-	WalletNew(context.Context, types.KeyType) (address.Address, error)
-	WalletHas(context.Context, address.Address) (bool, error)
-	WalletList(context.Context) ([]address.Address, error)
-
-	WalletSign(ctx context.Context, signer address.Address, toSign []byte, meta MsgMeta) (*crypto.Signature, error)
-
-	WalletExport(context.Context, address.Address) (*types.KeyInfo, error)
-	WalletImport(context.Context, *types.KeyInfo) (address.Address, error)
-	WalletDelete(context.Context, address.Address) error
-}

api/api_worker.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"io"
 
-	"github.com/google/uuid"
 	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/go-state-types/abi"
@@ -12,52 +11,30 @@ import (
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
 	"github.com/filecoin-project/specs-storage/storage"
+
+	"github.com/filecoin-project/lotus/build"
 )
 
-type Worker interface {
-	Version(context.Context) (Version, error) //perm:admin
+type WorkerAPI interface {
+	Version(context.Context) (build.Version, error)
+	// TODO: Info() (name, ...) ?
 
-	// TaskType -> Weight
-	TaskTypes(context.Context) (map[sealtasks.TaskType]struct{}, error) //perm:admin
-	Paths(context.Context) ([]stores.StoragePath, error)                //perm:admin
-	Info(context.Context) (storiface.WorkerInfo, error)                 //perm:admin
+	TaskTypes(context.Context) (map[sealtasks.TaskType]struct{}, error) // TaskType -> Weight
+	Paths(context.Context) ([]stores.StoragePath, error)
+	Info(context.Context) (storiface.WorkerInfo, error)
 
-	// storiface.WorkerCalls
-	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
-	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
-	ReadPiece(context.Context, io.Writer, storage.SectorRef, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (storiface.CallID, error)                                                               //perm:admin
-	Fetch(context.Context, storage.SectorRef, storiface.SectorFileType, storiface.PathType, storiface.AcquireMode) (storiface.CallID, error)                                                             //perm:admin
+	AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error)
 
-	TaskDisable(ctx context.Context, tt sealtasks.TaskType) error //perm:admin
-	TaskEnable(ctx context.Context, tt sealtasks.TaskType) error  //perm:admin
+	storage.Sealer
 
-	// Storage / Other
-	Remove(ctx context.Context, sector abi.SectorID) error //perm:admin
+	MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error
 
-	StorageAddLocal(ctx context.Context, path string) error //perm:admin
+	UnsealPiece(context.Context, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) error
+	ReadPiece(context.Context, io.Writer, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (bool, error)
 
-	// SetEnabled marks the worker as enabled/disabled. Not that this setting
-	// may take a few seconds to propagate to task scheduler
-	SetEnabled(ctx context.Context, enabled bool) error //perm:admin
+	StorageAddLocal(ctx context.Context, path string) error
 
-	Enabled(ctx context.Context) (bool, error) //perm:admin
+	Fetch(context.Context, abi.SectorID, stores.SectorFileType, stores.PathType, stores.AcquireMode) error
 
-	// WaitQuiet blocks until there are no tasks running
-	WaitQuiet(ctx context.Context) error //perm:admin
-
-	// returns a random UUID of worker session, generated randomly when worker
-	// process starts
-	ProcessSession(context.Context) (uuid.UUID, error) //perm:admin
-
-	// Like ProcessSession, but returns an error when worker is disabled
-	Session(context.Context) (uuid.UUID, error) //perm:admin
+	Closing(context.Context) (<-chan struct{}, error)
 }
-
-var _ storiface.WorkerCalls = *new(Worker)

api/apibstore/apibstore.go

@@ -0,0 +1,68 @@
+package apibstore
+
+import (
+	"context"
+
+	blocks "github.com/ipfs/go-block-format"
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+type ChainIO interface {
+	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
+	ChainHasObj(context.Context, cid.Cid) (bool, error)
+}
+
+type apiBStore struct {
+	api ChainIO
+}
+
+func NewAPIBlockstore(cio ChainIO) blockstore.Blockstore {
+	return &apiBStore{
+		api: cio,
+	}
+}
+
+func (a *apiBStore) DeleteBlock(cid.Cid) error {
+	return xerrors.New("not supported")
+}
+
+func (a *apiBStore) Has(c cid.Cid) (bool, error) {
+	return a.api.ChainHasObj(context.TODO(), c)
+}
+
+func (a *apiBStore) Get(c cid.Cid) (blocks.Block, error) {
+	bb, err := a.api.ChainReadObj(context.TODO(), c)
+	if err != nil {
+		return nil, err
+	}
+	return blocks.NewBlockWithCid(bb, c)
+}
+
+func (a *apiBStore) GetSize(c cid.Cid) (int, error) {
+	bb, err := a.api.ChainReadObj(context.TODO(), c)
+	if err != nil {
+		return 0, err
+	}
+	return len(bb), nil
+}
+
+func (a *apiBStore) Put(blocks.Block) error {
+	return xerrors.New("not supported")
+}
+
+func (a *apiBStore) PutMany([]blocks.Block) error {
+	return xerrors.New("not supported")
+}
+
+func (a *apiBStore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
+	return nil, xerrors.New("not supported")
+}
+
+func (a *apiBStore) HashOnRead(enabled bool) {
+	return
+}
+
+var _ blockstore.Blockstore = &apiBStore{}

api/apistruct/permissioned.go

@@ -31,14 +31,8 @@ func PermissionedFullAPI(a api.FullNode) api.FullNode {
 	return &out
 }
 
-func PermissionedWorkerAPI(a api.Worker) api.Worker {
+func PermissionedWorkerAPI(a api.WorkerAPI) api.WorkerAPI {
 	var out WorkerStruct
 	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
 	return &out
 }
-
-func PermissionedWalletAPI(a api.Wallet) api.Wallet {
-	var out WalletStruct
-	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
-	return &out
-}

api/cbor_gen.go

@@ -5,18 +5,14 @@ package api
 import (
 	"fmt"
 	"io"
-	"sort"
 
 	abi "github.com/filecoin-project/go-state-types/abi"
 	paych "github.com/filecoin-project/specs-actors/actors/builtin/paych"
-	cid "github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
 )
 
 var _ = xerrors.Errorf
-var _ = cid.Undef
-var _ = sort.Sort
 
 func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
 	if t == nil {
@@ -175,8 +171,7 @@ func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error {
 			}
 
 		default:
-			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
 		}
 	}
 
@@ -324,8 +319,7 @@ func (t *SealedRef) UnmarshalCBOR(r io.Reader) error {
 			}
 
 		default:
-			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
 		}
 	}
 
@@ -433,8 +427,7 @@ func (t *SealedRefs) UnmarshalCBOR(r io.Reader) error {
 			}
 
 		default:
-			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
 		}
 	}
 
@@ -582,8 +575,7 @@ func (t *SealTicket) UnmarshalCBOR(r io.Reader) error {
 			}
 
 		default:
-			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
 		}
 	}
 
@@ -731,8 +723,7 @@ func (t *SealSeed) UnmarshalCBOR(r io.Reader) error {
 			}
 
 		default:
-			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
 		}
 	}
 

api/client/client.go

@@ -54,7 +54,7 @@ func NewStorageMinerRPC(ctx context.Context, addr string, requestHeader http.Hea
 	return &res, closer, err
 }
 
-func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (api.Worker, jsonrpc.ClientCloser, error) {
+func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (api.WorkerAPI, jsonrpc.ClientCloser, error) {
 	u, err := url.Parse(addr)
 	if err != nil {
 		return nil, nil, err
@@ -82,29 +82,3 @@ func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (
 
 	return &res, closer, err
 }
-
-// NewGatewayRPC creates a new http jsonrpc client for a gateway node.
-func NewGatewayRPC(ctx context.Context, addr string, requestHeader http.Header, opts ...jsonrpc.Option) (api.Gateway, jsonrpc.ClientCloser, error) {
-	var res apistruct.GatewayStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		[]interface{}{
-			&res.Internal,
-		},
-		requestHeader,
-		opts...,
-	)
-
-	return &res, closer, err
-}
-
-func NewWalletRPC(ctx context.Context, addr string, requestHeader http.Header) (api.Wallet, jsonrpc.ClientCloser, error) {
-	var res apistruct.WalletStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		[]interface{}{
-			&res.Internal,
-		},
-		requestHeader,
-	)
-
-	return &res, closer, err
-}

api/docgen-openrpc/cmd/docgen_openrpc.go

@@ -1,77 +0,0 @@
-package main
-
-import (
-	"compress/gzip"
-	"encoding/json"
-	"io"
-	"log"
-	"os"
-
-	"github.com/filecoin-project/lotus/api/apistruct"
-	docgen_openrpc "github.com/filecoin-project/lotus/api/docgen-openrpc"
-)
-
-/*
-main defines a small program that writes an OpenRPC document describing
-a Lotus API to stdout.
-
-If the first argument is "miner", the document will describe the StorageMiner API.
-If not (no, or any other args), the document will describe the Full API.
-
-Use:
-
-		go run ./api/openrpc/cmd ["api/api_full.go"|"api/api_storage.go"|"api/api_worker.go"] ["FullNode"|"StorageMiner"|"Worker"]
-
-	With gzip compression: a '-gzip' flag is made available as an optional third argument. Note that position matters.
-
-		go run ./api/openrpc/cmd ["api/api_full.go"|"api/api_storage.go"|"api/api_worker.go"] ["FullNode"|"StorageMiner"|"Worker"] -gzip
-
-*/
-
-func main() {
-	doc := docgen_openrpc.NewLotusOpenRPCDocument()
-
-	switch os.Args[2] {
-	case "FullNode":
-		doc.RegisterReceiverName("Filecoin", &apistruct.FullNodeStruct{})
-	case "StorageMiner":
-		doc.RegisterReceiverName("Filecoin", &apistruct.StorageMinerStruct{})
-	case "Worker":
-		doc.RegisterReceiverName("Filecoin", &apistruct.WorkerStruct{})
-	}
-
-	out, err := doc.Discover()
-	if err != nil {
-		log.Fatalln(err)
-	}
-
-	var jsonOut []byte
-	var writer io.WriteCloser
-
-	// Use os.Args to handle a somewhat hacky flag for the gzip option.
-	// Could use flags package to handle this more cleanly, but that requires changes elsewhere
-	// the scope of which just isn't warranted by this one use case which will usually be run
-	// programmatically anyways.
-	if len(os.Args) > 3 && os.Args[3] == "-gzip" {
-		jsonOut, err = json.Marshal(out)
-		if err != nil {
-			log.Fatalln(err)
-		}
-		writer = gzip.NewWriter(os.Stdout)
-	} else {
-		jsonOut, err = json.MarshalIndent(out, "", "    ")
-		if err != nil {
-			log.Fatalln(err)
-		}
-		writer = os.Stdout
-	}
-
-	_, err = writer.Write(jsonOut)
-	if err != nil {
-		log.Fatalln(err)
-	}
-	err = writer.Close()
-	if err != nil {
-		log.Fatalln(err)
-	}
-}

api/docgen-openrpc/openrpc.go

@@ -1,172 +0,0 @@
-package docgenopenrpc
-
-import (
-	"encoding/json"
-	"go/ast"
-	"net"
-	"os"
-	"reflect"
-
-	"github.com/alecthomas/jsonschema"
-	go_openrpc_reflect "github.com/etclabscore/go-openrpc-reflect"
-	"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"
-)
-
-// Comments holds API method comments collected by AST parsing.
-var Comments map[string]string
-
-// GroupDocs holds documentation for documentation groups.
-var GroupDocs map[string]string
-
-func init() {
-	Comments, GroupDocs = docgen.ParseApiASTInfo(os.Args[1], os.Args[2])
-}
-
-// schemaDictEntry represents a type association passed to the jsonschema reflector.
-type schemaDictEntry struct {
-	example interface{}
-	rawJson string
-}
-
-const integerD = `{
-          "title": "number",
-          "type": "number",
-          "description": "Number is a number"
-        }`
-
-const cidCidD = `{"title": "Content Identifier", "type": "string", "description": "Cid represents a self-describing content addressed identifier. It is formed by a Version, a Codec (which indicates a multicodec-packed content type) and a Multihash."}`
-
-func OpenRPCSchemaTypeMapper(ty reflect.Type) *jsonschema.Type {
-	unmarshalJSONToJSONSchemaType := func(input string) *jsonschema.Type {
-		var js jsonschema.Type
-		err := json.Unmarshal([]byte(input), &js)
-		if err != nil {
-			panic(err)
-		}
-		return &js
-	}
-
-	if ty.Kind() == reflect.Ptr {
-		ty = ty.Elem()
-	}
-
-	if ty == reflect.TypeOf((*interface{})(nil)).Elem() {
-		return &jsonschema.Type{Type: "object", AdditionalProperties: []byte("true")}
-	}
-
-	// Second, handle other types.
-	// Use a slice instead of a map because it preserves order, as a logic safeguard/fallback.
-	dict := []schemaDictEntry{
-		{cid.Cid{}, cidCidD},
-	}
-
-	for _, d := range dict {
-		if reflect.TypeOf(d.example) == ty {
-			tt := unmarshalJSONToJSONSchemaType(d.rawJson)
-
-			return tt
-		}
-	}
-
-	// Handle primitive types in case there are generic cases
-	// specific to our services.
-	switch ty.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		// Return all integer types as the hex representation integer schemea.
-		ret := unmarshalJSONToJSONSchemaType(integerD)
-		return ret
-	case reflect.Uintptr:
-		return &jsonschema.Type{Type: "number", Title: "uintptr-title"}
-	case reflect.Struct:
-	case reflect.Map:
-	case reflect.Slice, reflect.Array:
-	case reflect.Float32, reflect.Float64:
-	case reflect.Bool:
-	case reflect.String:
-	case reflect.Ptr, reflect.Interface:
-	default:
-	}
-
-	return nil
-}
-
-// NewLotusOpenRPCDocument defines application-specific documentation and configuration for its OpenRPC document.
-func NewLotusOpenRPCDocument() *go_openrpc_reflect.Document {
-	d := &go_openrpc_reflect.Document{}
-
-	// Register "Meta" document fields.
-	// These include getters for
-	// - Servers object
-	// - Info object
-	// - ExternalDocs object
-	//
-	// These objects represent server-specific data that cannot be
-	// reflected.
-	d.WithMeta(&go_openrpc_reflect.MetaT{
-		GetServersFn: func() func(listeners []net.Listener) (*meta_schema.Servers, error) {
-			return func(listeners []net.Listener) (*meta_schema.Servers, error) {
-				return nil, nil
-			}
-		},
-		GetInfoFn: func() (info *meta_schema.InfoObject) {
-			info = &meta_schema.InfoObject{}
-			title := "Lotus RPC API"
-			info.Title = (*meta_schema.InfoObjectProperties)(&title)
-
-			version := build.BuildVersion
-			info.Version = (*meta_schema.InfoObjectVersion)(&version)
-			return info
-		},
-		GetExternalDocsFn: func() (exdocs *meta_schema.ExternalDocumentationObject) {
-			return nil // FIXME
-		},
-	})
-
-	// Use a provided Ethereum default configuration as a base.
-	appReflector := &go_openrpc_reflect.EthereumReflectorT{}
-
-	// Install overrides for the json schema->type map fn used by the jsonschema reflect package.
-	appReflector.FnSchemaTypeMap = func() func(ty reflect.Type) *jsonschema.Type {
-		return OpenRPCSchemaTypeMapper
-	}
-
-	appReflector.FnIsMethodEligible = func(m reflect.Method) bool {
-		for i := 0; i < m.Func.Type().NumOut(); i++ {
-			if m.Func.Type().Out(i).Kind() == reflect.Chan {
-				return false
-			}
-		}
-		return go_openrpc_reflect.EthereumReflector.IsMethodEligible(m)
-	}
-	appReflector.FnGetMethodName = func(moduleName string, r reflect.Value, m reflect.Method, funcDecl *ast.FuncDecl) (string, error) {
-		if m.Name == "ID" {
-			return moduleName + "_ID", nil
-		}
-		if moduleName == "rpc" && m.Name == "Discover" {
-			return "rpc.discover", nil
-		}
-
-		return moduleName + "." + m.Name, nil
-	}
-
-	appReflector.FnGetMethodSummary = func(r reflect.Value, m reflect.Method, funcDecl *ast.FuncDecl) (string, error) {
-		if v, ok := Comments[m.Name]; ok {
-			return v, nil
-		}
-		return "", nil // noComment
-	}
-
-	appReflector.FnSchemaExamples = func(ty reflect.Type) (examples *meta_schema.Examples, err error) {
-		v := docgen.ExampleValue("unknown", ty, ty) // This isn't ideal, but seems to work well enough.
-		return &meta_schema.Examples{
-			meta_schema.AlwaysTrue(v),
-		}, nil
-	}
-
-	// Finally, register the configured reflector to the document.
-	d.WithReflector(appReflector)
-	return d
-}

api/docgen/cmd/docgen.go

@@ -1,137 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"reflect"
-	"sort"
-	"strings"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/apistruct"
-	"github.com/filecoin-project/lotus/api/docgen"
-)
-
-func main() {
-	comments, groupComments := docgen.ParseApiASTInfo(os.Args[1], os.Args[2])
-
-	groups := make(map[string]*docgen.MethodGroup)
-
-	var t reflect.Type
-	var permStruct, commonPermStruct reflect.Type
-
-	switch os.Args[2] {
-	case "FullNode":
-		t = reflect.TypeOf(new(struct{ api.FullNode })).Elem()
-		permStruct = reflect.TypeOf(apistruct.FullNodeStruct{}.Internal)
-		commonPermStruct = reflect.TypeOf(apistruct.CommonStruct{}.Internal)
-	case "StorageMiner":
-		t = reflect.TypeOf(new(struct{ api.StorageMiner })).Elem()
-		permStruct = reflect.TypeOf(apistruct.StorageMinerStruct{}.Internal)
-		commonPermStruct = reflect.TypeOf(apistruct.CommonStruct{}.Internal)
-	case "Worker":
-		t = reflect.TypeOf(new(struct{ api.Worker })).Elem()
-		permStruct = reflect.TypeOf(apistruct.WorkerStruct{}.Internal)
-		commonPermStruct = reflect.TypeOf(apistruct.WorkerStruct{}.Internal)
-	default:
-		panic("unknown type")
-	}
-
-	for i := 0; i < t.NumMethod(); i++ {
-		m := t.Method(i)
-
-		groupName := docgen.MethodGroupFromName(m.Name)
-
-		g, ok := groups[groupName]
-		if !ok {
-			g = new(docgen.MethodGroup)
-			g.Header = groupComments[groupName]
-			g.GroupName = groupName
-			groups[groupName] = g
-		}
-
-		var args []interface{}
-		ft := m.Func.Type()
-		for j := 2; j < ft.NumIn(); j++ {
-			inp := ft.In(j)
-			args = append(args, docgen.ExampleValue(m.Name, inp, nil))
-		}
-
-		v, err := json.MarshalIndent(args, "", "  ")
-		if err != nil {
-			panic(err)
-		}
-
-		outv := docgen.ExampleValue(m.Name, ft.Out(0), nil)
-
-		ov, err := json.MarshalIndent(outv, "", "  ")
-		if err != nil {
-			panic(err)
-		}
-
-		g.Methods = append(g.Methods, &docgen.Method{
-			Name:            m.Name,
-			Comment:         comments[m.Name],
-			InputExample:    string(v),
-			ResponseExample: string(ov),
-		})
-	}
-
-	var groupslice []*docgen.MethodGroup
-	for _, g := range groups {
-		groupslice = append(groupslice, g)
-	}
-
-	sort.Slice(groupslice, func(i, j int) bool {
-		return groupslice[i].GroupName < groupslice[j].GroupName
-	})
-
-	fmt.Printf("# Groups\n")
-
-	for _, g := range groupslice {
-		fmt.Printf("* [%s](#%s)\n", g.GroupName, g.GroupName)
-		for _, method := range g.Methods {
-			fmt.Printf("  * [%s](#%s)\n", method.Name, method.Name)
-		}
-	}
-
-	for _, g := range groupslice {
-		g := g
-		fmt.Printf("## %s\n", g.GroupName)
-		fmt.Printf("%s\n\n", g.Header)
-
-		sort.Slice(g.Methods, func(i, j int) bool {
-			return g.Methods[i].Name < g.Methods[j].Name
-		})
-
-		for _, m := range g.Methods {
-			fmt.Printf("### %s\n", m.Name)
-			fmt.Printf("%s\n\n", m.Comment)
-
-			meth, ok := permStruct.FieldByName(m.Name)
-			if !ok {
-				meth, ok = commonPermStruct.FieldByName(m.Name)
-				if !ok {
-					panic("no perms for method: " + m.Name)
-				}
-			}
-
-			perms := meth.Tag.Get("perm")
-
-			fmt.Printf("Perms: %s\n\n", perms)
-
-			if strings.Count(m.InputExample, "\n") > 0 {
-				fmt.Printf("Inputs:\n```json\n%s\n```\n\n", m.InputExample)
-			} else {
-				fmt.Printf("Inputs: `%s`\n\n", m.InputExample)
-			}
-
-			if strings.Count(m.ResponseExample, "\n") > 0 {
-				fmt.Printf("Response:\n```json\n%s\n```\n\n", m.ResponseExample)
-			} else {
-				fmt.Printf("Response: `%s`\n\n", m.ResponseExample)
-			}
-		}
-	}
-}

api/docgen/docgen.go

@@ -1,19 +1,17 @@
-package docgen
+package main
 
 import (
+	"encoding/json"
 	"fmt"
 	"go/ast"
 	"go/parser"
 	"go/token"
-	"path/filepath"
 	"reflect"
+	"sort"
 	"strings"
 	"time"
 	"unicode"
 
-	"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-filestore"
 	metrics "github.com/libp2p/go-libp2p-core/metrics"
@@ -23,8 +21,9 @@ import (
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/multiformats/go-multiaddr"
 
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-bitfield"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
-	filestore2 "github.com/filecoin-project/go-fil-markets/filestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-jsonrpc/auth"
 	"github.com/filecoin-project/go-multistore"
@@ -34,13 +33,9 @@ import (
 	"github.com/filecoin-project/go-state-types/exitcode"
 
 	"github.com/filecoin-project/lotus/api"
-	apitypes "github.com/filecoin-project/lotus/api/types"
+	"github.com/filecoin-project/lotus/api/apistruct"
 	"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/stores"
-	"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"
 )
 
@@ -87,14 +82,11 @@ func init() {
 	addExample(pid)
 	addExample(&pid)
 
-	multistoreIDExample := multistore.StoreID(50)
-
 	addExample(bitfield.NewFromSet([]uint64{5}))
-	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1_1)
+	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1)
 	addExample(abi.RegisteredPoStProof_StackedDrgWindow32GiBV1)
 	addExample(abi.ChainEpoch(10101))
 	addExample(crypto.SigTypeBLS)
-	addExample(types.KTBLS)
 	addExample(int64(9))
 	addExample(12.3)
 	addExample(123)
@@ -113,31 +105,28 @@ func init() {
 	addExample(network.Connected)
 	addExample(dtypes.NetworkName("lotus"))
 	addExample(api.SyncStateStage(1))
-	addExample(api.FullAPIVersion)
+	addExample(build.FullAPIVersion)
 	addExample(api.PCHInbound)
 	addExample(time.Minute)
 	addExample(datatransfer.TransferID(3))
 	addExample(datatransfer.Ongoing)
-	addExample(multistoreIDExample)
-	addExample(&multistoreIDExample)
+	addExample(multistore.StoreID(50))
 	addExample(retrievalmarket.ClientEventDealAccepted)
 	addExample(retrievalmarket.DealStatusNew)
 	addExample(network.ReachabilityPublic)
 	addExample(build.NewestNetworkVersion)
-	addExample(map[string]int{"name": 42})
-	addExample(map[string]time.Time{"name": time.Unix(1615243938, 0).UTC()})
 	addExample(&types.ExecutionTrace{
-		Msg:    ExampleValue("init", reflect.TypeOf(&types.Message{}), nil).(*types.Message),
-		MsgRct: ExampleValue("init", reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
+		Msg:    exampleValue(reflect.TypeOf(&types.Message{}), nil).(*types.Message),
+		MsgRct: exampleValue(reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
 	})
 	addExample(map[string]types.Actor{
-		"t01236": ExampleValue("init", reflect.TypeOf(types.Actor{}), nil).(types.Actor),
+		"t01236": exampleValue(reflect.TypeOf(types.Actor{}), nil).(types.Actor),
 	})
 	addExample(map[string]api.MarketDeal{
-		"t026363": ExampleValue("init", reflect.TypeOf(api.MarketDeal{}), nil).(api.MarketDeal),
+		"t026363": exampleValue(reflect.TypeOf(api.MarketDeal{}), nil).(api.MarketDeal),
 	})
 	addExample(map[string]api.MarketBalance{
-		"t026363": ExampleValue("init", reflect.TypeOf(api.MarketBalance{}), nil).(api.MarketBalance),
+		"t026363": exampleValue(reflect.TypeOf(api.MarketBalance{}), nil).(api.MarketBalance),
 	})
 	addExample(map[string]*pubsub.TopicScoreSnapshot{
 		"/blocks": {
@@ -172,97 +161,9 @@ func init() {
 	// because reflect.TypeOf(maddr) returns the concrete type...
 	ExampleValues[reflect.TypeOf(struct{ A multiaddr.Multiaddr }{}).Field(0).Type] = maddr
 
-	// miner specific
-	addExample(filestore2.Path(".lotusminer/fstmp123"))
-	si := multistore.StoreID(12)
-	addExample(&si)
-	addExample(retrievalmarket.DealID(5))
-	addExample(abi.ActorID(1000))
-	addExample(map[string][]api.SealedRef{
-		"98000": {
-			api.SealedRef{
-				SectorID: 100,
-				Offset:   10 << 20,
-				Size:     1 << 20,
-			},
-		},
-	})
-	addExample(api.SectorState(sealing.Proving))
-	addExample(stores.ID("76f1988b-ef30-4d7e-b3ec-9a627f4ba5a8"))
-	addExample(storiface.FTUnsealed)
-	addExample(storiface.PathSealing)
-	addExample(map[stores.ID][]stores.Decl{
-		"76f1988b-ef30-4d7e-b3ec-9a627f4ba5a8": {
-			{
-				SectorID:       abi.SectorID{Miner: 1000, Number: 100},
-				SectorFileType: storiface.FTSealed,
-			},
-		},
-	})
-	addExample(map[stores.ID]string{
-		"76f1988b-ef30-4d7e-b3ec-9a627f4ba5a8": "/data/path",
-	})
-	addExample(map[uuid.UUID][]storiface.WorkerJob{
-		uuid.MustParse("ef8d99a2-6865-4189-8ffa-9fef0f806eee"): {
-			{
-				ID: storiface.CallID{
-					Sector: abi.SectorID{Miner: 1000, Number: 100},
-					ID:     uuid.MustParse("76081ba0-61bd-45a5-bc08-af05f1c26e5d"),
-				},
-				Sector:   abi.SectorID{Miner: 1000, Number: 100},
-				Task:     sealtasks.TTPreCommit2,
-				RunWait:  0,
-				Start:    time.Unix(1605172927, 0).UTC(),
-				Hostname: "host",
-			},
-		},
-	})
-	addExample(map[uuid.UUID]storiface.WorkerStats{
-		uuid.MustParse("ef8d99a2-6865-4189-8ffa-9fef0f806eee"): {
-			Info: storiface.WorkerInfo{
-				Hostname: "host",
-				Resources: storiface.WorkerResources{
-					MemPhysical: 256 << 30,
-					MemSwap:     120 << 30,
-					MemReserved: 2 << 30,
-					CPUs:        64,
-					GPUs:        []string{"aGPU 1337"},
-				},
-			},
-			Enabled:    true,
-			MemUsedMin: 0,
-			MemUsedMax: 0,
-			GpuUsed:    false,
-			CpuUse:     0,
-		},
-	})
-	addExample(storiface.ErrorCode(0))
-	addExample(map[abi.SectorNumber]string{
-		123: "can't acquire read lock",
-	})
-	addExample(map[api.SectorState]int{
-		api.SectorState(sealing.Proving): 120,
-	})
-	addExample([]abi.SectorNumber{123, 124})
-
-	// worker specific
-	addExample(storiface.AcquireMove)
-	addExample(storiface.UnpaddedByteIndex(abi.PaddedPieceSize(1 << 20).Unpadded()))
-	addExample(map[sealtasks.TaskType]struct{}{
-		sealtasks.TTPreCommit2: {},
-	})
-	addExample(sealtasks.TTCommit2)
-	addExample(apitypes.OpenRPCDocument{
-		"openrpc": "1.2.6",
-		"info": map[string]interface{}{
-			"title":   "Lotus RPC API",
-			"version": "1.2.1/generated=2020-11-22T08:22:42-06:00",
-		},
-		"methods": []interface{}{}},
-	)
 }
 
-func ExampleValue(method string, t, parent reflect.Type) interface{} {
+func exampleValue(t, parent reflect.Type) interface{} {
 	v, ok := ExampleValues[t]
 	if ok {
 		return v
@@ -271,25 +172,25 @@ func ExampleValue(method string, t, parent reflect.Type) interface{} {
 	switch t.Kind() {
 	case reflect.Slice:
 		out := reflect.New(t).Elem()
-		reflect.Append(out, reflect.ValueOf(ExampleValue(method, t.Elem(), t)))
+		reflect.Append(out, reflect.ValueOf(exampleValue(t.Elem(), t)))
 		return out.Interface()
 	case reflect.Chan:
-		return ExampleValue(method, t.Elem(), nil)
+		return exampleValue(t.Elem(), nil)
 	case reflect.Struct:
-		es := exampleStruct(method, t, parent)
+		es := exampleStruct(t, parent)
 		v := reflect.ValueOf(es).Elem().Interface()
 		ExampleValues[t] = v
 		return v
 	case reflect.Array:
 		out := reflect.New(t).Elem()
 		for i := 0; i < t.Len(); i++ {
-			out.Index(i).Set(reflect.ValueOf(ExampleValue(method, t.Elem(), t)))
+			out.Index(i).Set(reflect.ValueOf(exampleValue(t.Elem(), t)))
 		}
 		return out.Interface()
 
 	case reflect.Ptr:
 		if t.Elem().Kind() == reflect.Struct {
-			es := exampleStruct(method, t.Elem(), t)
+			es := exampleStruct(t.Elem(), t)
 			//ExampleValues[t] = es
 			return es
 		}
@@ -297,10 +198,10 @@ func ExampleValue(method string, t, parent reflect.Type) interface{} {
 		return struct{}{}
 	}
 
-	panic(fmt.Sprintf("No example value for type: %s (method '%s')", t, method))
+	panic(fmt.Sprintf("No example value for type: %s", t))
 }
 
-func exampleStruct(method string, t, parent reflect.Type) interface{} {
+func exampleStruct(t, parent reflect.Type) interface{} {
 	ns := reflect.New(t)
 	for i := 0; i < t.NumField(); i++ {
 		f := t.Field(i)
@@ -308,7 +209,7 @@ func exampleStruct(method string, t, parent reflect.Type) interface{} {
 			continue
 		}
 		if strings.Title(f.Name) == f.Name {
-			ns.Elem().Field(i).Set(reflect.ValueOf(ExampleValue(method, f.Type, t)))
+			ns.Elem().Field(i).Set(reflect.ValueOf(exampleValue(f.Type, t)))
 		}
 	}
 
@@ -316,7 +217,6 @@ func exampleStruct(method string, t, parent reflect.Type) interface{} {
 }
 
 type Visitor struct {
-	Root    string
 	Methods map[string]ast.Node
 }
 
@@ -326,7 +226,7 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {
 		return v
 	}
 
-	if st.Name.Name != v.Root {
+	if st.Name.Name != "FullNode" {
 		return nil
 	}
 
@@ -340,43 +240,32 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {
 	return v
 }
 
-const NoComment = "There are not yet any comments for this method."
+const noComment = "There are not yet any comments for this method."
 
-func ParseApiASTInfo(apiFile, iface string) (comments map[string]string, groupDocs map[string]string) { //nolint:golint
+func parseApiASTInfo() (map[string]string, map[string]string) { //nolint:golint
 	fset := token.NewFileSet()
-	apiDir, err := filepath.Abs("./api")
-	if err != nil {
-		fmt.Println("./api filepath absolute error: ", err)
-		return
-	}
-	apiFile, err = filepath.Abs(apiFile)
-	if err != nil {
-		fmt.Println("filepath absolute error: ", err, "file:", apiFile)
-		return
-	}
-	pkgs, err := parser.ParseDir(fset, apiDir, nil, parser.AllErrors|parser.ParseComments)
+	pkgs, err := parser.ParseDir(fset, "./api", nil, parser.AllErrors|parser.ParseComments)
 	if err != nil {
 		fmt.Println("parse error: ", err)
-		return
 	}
 
 	ap := pkgs["api"]
 
-	f := ap.Files[apiFile]
+	f := ap.Files["api/api_full.go"]
 
 	cmap := ast.NewCommentMap(fset, f, f.Comments)
 
-	v := &Visitor{iface, make(map[string]ast.Node)}
+	v := &Visitor{make(map[string]ast.Node)}
 	ast.Walk(v, pkgs["api"])
 
-	comments = make(map[string]string)
-	groupDocs = make(map[string]string)
+	groupDocs := make(map[string]string)
+	out := make(map[string]string)
 	for mn, node := range v.Methods {
-		filteredComments := cmap.Filter(node).Comments()
-		if len(filteredComments) == 0 {
-			comments[mn] = NoComment
+		cs := cmap.Filter(node).Comments()
+		if len(cs) == 0 {
+			out[mn] = noComment
 		} else {
-			for _, c := range filteredComments {
+			for _, c := range cs {
 				if strings.HasPrefix(c.Text(), "MethodGroup:") {
 					parts := strings.Split(c.Text(), "\n")
 					groupName := strings.TrimSpace(parts[0][12:])
@@ -387,19 +276,15 @@ func ParseApiASTInfo(apiFile, iface string) (comments map[string]string, groupDo
 				}
 			}
 
-			l := len(filteredComments) - 1
-			if len(filteredComments) > 1 {
-				l = len(filteredComments) - 2
-			}
-			last := filteredComments[l].Text()
+			last := cs[len(cs)-1].Text()
 			if !strings.HasPrefix(last, "MethodGroup:") {
-				comments[mn] = last
+				out[mn] = last
 			} else {
-				comments[mn] = NoComment
+				out[mn] = noComment
 			}
 		}
 	}
-	return comments, groupDocs
+	return out, groupDocs
 }
 
 type MethodGroup struct {
@@ -415,7 +300,7 @@ type Method struct {
 	ResponseExample string
 }
 
-func MethodGroupFromName(mn string) string {
+func methodGroupFromName(mn string) string {
 	i := strings.IndexFunc(mn[1:], func(r rune) bool {
 		return unicode.IsUpper(r)
 	})
@@ -424,3 +309,112 @@ func MethodGroupFromName(mn string) string {
 	}
 	return mn[:i+1]
 }
+
+func main() {
+
+	comments, groupComments := parseApiASTInfo()
+
+	groups := make(map[string]*MethodGroup)
+
+	var api struct{ api.FullNode }
+	t := reflect.TypeOf(api)
+	for i := 0; i < t.NumMethod(); i++ {
+		m := t.Method(i)
+
+		groupName := methodGroupFromName(m.Name)
+
+		g, ok := groups[groupName]
+		if !ok {
+			g = new(MethodGroup)
+			g.Header = groupComments[groupName]
+			g.GroupName = groupName
+			groups[groupName] = g
+		}
+
+		var args []interface{}
+		ft := m.Func.Type()
+		for j := 2; j < ft.NumIn(); j++ {
+			inp := ft.In(j)
+			args = append(args, exampleValue(inp, nil))
+		}
+
+		v, err := json.MarshalIndent(args, "", "  ")
+		if err != nil {
+			panic(err)
+		}
+
+		outv := exampleValue(ft.Out(0), nil)
+
+		ov, err := json.MarshalIndent(outv, "", "  ")
+		if err != nil {
+			panic(err)
+		}
+
+		g.Methods = append(g.Methods, &Method{
+			Name:            m.Name,
+			Comment:         comments[m.Name],
+			InputExample:    string(v),
+			ResponseExample: string(ov),
+		})
+	}
+
+	var groupslice []*MethodGroup
+	for _, g := range groups {
+		groupslice = append(groupslice, g)
+	}
+
+	sort.Slice(groupslice, func(i, j int) bool {
+		return groupslice[i].GroupName < groupslice[j].GroupName
+	})
+
+	fmt.Printf("# Groups\n")
+
+	for _, g := range groupslice {
+		fmt.Printf("* [%s](#%s)\n", g.GroupName, g.GroupName)
+		for _, method := range g.Methods {
+			fmt.Printf("  * [%s](#%s)\n", method.Name, method.Name)
+		}
+	}
+
+	permStruct := reflect.TypeOf(apistruct.FullNodeStruct{}.Internal)
+	commonPermStruct := reflect.TypeOf(apistruct.CommonStruct{}.Internal)
+
+	for _, g := range groupslice {
+		g := g
+		fmt.Printf("## %s\n", g.GroupName)
+		fmt.Printf("%s\n\n", g.Header)
+
+		sort.Slice(g.Methods, func(i, j int) bool {
+			return g.Methods[i].Name < g.Methods[j].Name
+		})
+
+		for _, m := range g.Methods {
+			fmt.Printf("### %s\n", m.Name)
+			fmt.Printf("%s\n\n", m.Comment)
+
+			meth, ok := permStruct.FieldByName(m.Name)
+			if !ok {
+				meth, ok = commonPermStruct.FieldByName(m.Name)
+				if !ok {
+					panic("no perms for method: " + m.Name)
+				}
+			}
+
+			perms := meth.Tag.Get("perm")
+
+			fmt.Printf("Perms: %s\n\n", perms)
+
+			if strings.Count(m.InputExample, "\n") > 0 {
+				fmt.Printf("Inputs:\n```json\n%s\n```\n\n", m.InputExample)
+			} else {
+				fmt.Printf("Inputs: `%s`\n\n", m.InputExample)
+			}
+
+			if strings.Count(m.ResponseExample, "\n") > 0 {
+				fmt.Printf("Response:\n```json\n%s\n```\n\n", m.ResponseExample)
+			} else {
+				fmt.Printf("Response: `%s`\n\n", m.ResponseExample)
+			}
+		}
+	}
+}

api/test/blockminer.go

@@ -37,12 +37,7 @@ func (bm *BlockMiner) MineBlocks() {
 	go func() {
 		defer close(bm.done)
 		for atomic.LoadInt64(&bm.mine) == 1 {
-			select {
-			case <-bm.ctx.Done():
-				return
-			case <-time.After(bm.blocktime):
-			}
-
+			time.Sleep(bm.blocktime)
 			nulls := atomic.SwapInt64(&bm.nulls, 0)
 			if err := bm.miner.MineOne(bm.ctx, miner.MineReq{
 				InjectNulls: abi.ChainEpoch(nulls),

api/test/ccupgrade.go

@@ -3,6 +3,7 @@ package test
 import (
 	"context"
 	"fmt"
+	"os"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -16,22 +17,10 @@ import (
 )
 
 func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	for _, height := range []abi.ChainEpoch{
-		-1,   // before
-		162,  // while sealing
-		530,  // after upgrade deal
-		5000, // after
-	} {
-		height := height // make linters happy by copying
-		t.Run(fmt.Sprintf("upgrade-%d", height), func(t *testing.T) {
-			testCCUpgrade(t, b, blocktime, height)
-		})
-	}
-}
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 
-func testCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, upgradeHeight abi.ChainEpoch) {
 	ctx := context.Background()
-	n, sn := b(t, []FullNodeOpts{FullNodeWithLatestActorsAt(upgradeHeight)}, OneMiner)
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 
@@ -89,7 +78,7 @@ func testCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, upgradeH
 		t.Fatal(err)
 	}
 
-	MakeDeal(t, ctx, 6, client, miner, false, false, 0)
+	makeDeal(t, ctx, 6, client, miner, false, false)
 
 	// Validate upgrade
 

api/test/deadlines.go

@@ -1,350 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-bitfield"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/exitcode"
-	"github.com/filecoin-project/go-state-types/network"
-	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
-	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
-
-	"github.com/filecoin-project/lotus/blockstore"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/extern/sector-storage/mock"
-	"github.com/filecoin-project/lotus/node/impl"
-)
-
-// TestDeadlineToggling:
-// * spins up a v3 network (miner A)
-// * creates an inactive miner (miner B)
-// * creates another miner, pledges a sector, waits for power (miner C)
-//
-// * goes through v4 upgrade
-// * goes through PP
-// * creates minerD, minerE
-// * makes sure that miner B/D are inactive, A/C still are
-// * pledges sectors on miner B/D
-// * precommits a sector on minerE
-// * disables post on miner C
-// * goes through PP 0.5PP
-// * asserts that minerE is active
-// * goes through rest of PP (1.5)
-// * asserts that miner C loses power
-// * asserts that miner B/D is active and has power
-// * asserts that minerE is inactive
-// * disables post on miner B
-// * terminates sectors on miner D
-// * goes through another PP
-// * asserts that miner B loses power
-// * asserts that miner D loses power, is inactive
-func TestDeadlineToggling(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	var upgradeH abi.ChainEpoch = 4000
-	var provingPeriod abi.ChainEpoch = 2880
-
-	const sectorsC, sectorsD, sectersB = 10, 9, 8
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, sn := b(t, []FullNodeOpts{FullNodeWithV4ActorsAt(upgradeH)}, OneMiner)
-
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	minerA := sn[0]
-
-	{
-		addrinfo, err := client.NetAddrsListen(ctx)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if err := minerA.NetConnect(ctx, addrinfo); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	defaultFrom, err := client.WalletDefaultAddress(ctx)
-	require.NoError(t, err)
-
-	maddrA, err := minerA.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	build.Clock.Sleep(time.Second)
-
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for ctx.Err() == nil {
-			build.Clock.Sleep(blocktime)
-			if err := minerA.MineOne(ctx, MineNext); err != nil {
-				if ctx.Err() != nil {
-					// context was canceled, ignore the error.
-					return
-				}
-				t.Error(err)
-			}
-		}
-	}()
-	defer func() {
-		cancel()
-		<-done
-	}()
-
-	minerB := n[0].Stb(ctx, t, TestSpt, defaultFrom)
-	minerC := n[0].Stb(ctx, t, TestSpt, defaultFrom)
-
-	maddrB, err := minerB.ActorAddress(ctx)
-	require.NoError(t, err)
-	maddrC, err := minerC.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	ssz, err := minerC.ActorSectorSize(ctx, maddrC)
-	require.NoError(t, err)
-
-	// pledge sectors on C, go through a PP, check for power
-	{
-		pledgeSectors(t, ctx, minerC, sectorsC, 0, nil)
-
-		di, err := client.StateMinerProvingDeadline(ctx, maddrC, types.EmptyTSK)
-		require.NoError(t, err)
-
-		fmt.Printf("Running one proving period (miner C)\n")
-		fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod*2)
-
-		for {
-			head, err := client.ChainHead(ctx)
-			require.NoError(t, err)
-
-			if head.Height() > di.PeriodStart+provingPeriod*2 {
-				fmt.Printf("Now head.Height = %d\n", head.Height())
-				break
-			}
-			build.Clock.Sleep(blocktime)
-		}
-
-		expectedPower := types.NewInt(uint64(ssz) * sectorsC)
-
-		p, err := client.StateMinerPower(ctx, maddrC, types.EmptyTSK)
-		require.NoError(t, err)
-
-		// make sure it has gained power.
-		require.Equal(t, p.MinerPower.RawBytePower, expectedPower)
-	}
-
-	// go through upgrade + PP
-	for {
-		head, err := client.ChainHead(ctx)
-		require.NoError(t, err)
-
-		if head.Height() > upgradeH+provingPeriod {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	checkMiner := func(ma address.Address, power abi.StoragePower, active bool, tsk types.TipSetKey) {
-		p, err := client.StateMinerPower(ctx, ma, tsk)
-		require.NoError(t, err)
-
-		// make sure it has the expected power.
-		require.Equal(t, p.MinerPower.RawBytePower, power)
-
-		mact, err := client.StateGetActor(ctx, ma, tsk)
-		require.NoError(t, err)
-
-		mst, err := miner.Load(adt.WrapStore(ctx, cbor.NewCborStore(blockstore.NewAPIBlockstore(client))), mact)
-		require.NoError(t, err)
-
-		act, err := mst.DeadlineCronActive()
-		require.NoError(t, err)
-		require.Equal(t, active, act)
-	}
-
-	// check that just after the upgrade minerB was still active
-	{
-		uts, err := client.ChainGetTipSetByHeight(ctx, upgradeH+2, types.EmptyTSK)
-		require.NoError(t, err)
-		checkMiner(maddrB, types.NewInt(0), true, uts.Key())
-	}
-
-	nv, err := client.StateNetworkVersion(ctx, types.EmptyTSK)
-	require.NoError(t, err)
-	require.GreaterOrEqual(t, nv, network.Version12)
-
-	minerD := n[0].Stb(ctx, t, TestSpt, defaultFrom)
-	minerE := n[0].Stb(ctx, t, TestSpt, defaultFrom)
-
-	maddrD, err := minerD.ActorAddress(ctx)
-	require.NoError(t, err)
-	maddrE, err := minerE.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	// first round of miner checks
-	checkMiner(maddrA, types.NewInt(uint64(ssz)*GenesisPreseals), true, types.EmptyTSK)
-	checkMiner(maddrC, types.NewInt(uint64(ssz)*sectorsC), true, types.EmptyTSK)
-
-	checkMiner(maddrB, types.NewInt(0), false, types.EmptyTSK)
-	checkMiner(maddrD, types.NewInt(0), false, types.EmptyTSK)
-	checkMiner(maddrE, types.NewInt(0), false, types.EmptyTSK)
-
-	// pledge sectors on minerB/minerD, stop post on minerC
-	pledgeSectors(t, ctx, minerB, sectersB, 0, nil)
-	checkMiner(maddrB, types.NewInt(0), true, types.EmptyTSK)
-
-	pledgeSectors(t, ctx, minerD, sectorsD, 0, nil)
-	checkMiner(maddrD, types.NewInt(0), true, types.EmptyTSK)
-
-	minerC.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).Fail()
-
-	// precommit a sector on minerE
-	{
-		head, err := client.ChainHead(ctx)
-		require.NoError(t, err)
-
-		cr, err := cid.Parse("bagboea4b5abcatlxechwbp7kjpjguna6r6q7ejrhe6mdp3lf34pmswn27pkkiekz")
-		require.NoError(t, err)
-
-		params := &miner.SectorPreCommitInfo{
-			Expiration:   2880 * 300,
-			SectorNumber: 22,
-			SealProof:    TestSpt,
-
-			SealedCID:     cr,
-			SealRandEpoch: head.Height() - 200,
-		}
-
-		enc := new(bytes.Buffer)
-		require.NoError(t, params.MarshalCBOR(enc))
-
-		m, err := client.MpoolPushMessage(ctx, &types.Message{
-			To:     maddrE,
-			From:   defaultFrom,
-			Value:  types.FromFil(1),
-			Method: miner.Methods.PreCommitSector,
-			Params: enc.Bytes(),
-		}, nil)
-		require.NoError(t, err)
-
-		r, err := client.StateWaitMsg(ctx, m.Cid(), 2)
-		require.NoError(t, err)
-		require.Equal(t, exitcode.Ok, r.Receipt.ExitCode)
-	}
-
-	// go through 0.5 PP
-	for {
-		head, err := client.ChainHead(ctx)
-		require.NoError(t, err)
-
-		if head.Height() > upgradeH+provingPeriod+(provingPeriod/2) {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	checkMiner(maddrE, types.NewInt(0), true, types.EmptyTSK)
-
-	// go through rest of the PP
-	for {
-		head, err := client.ChainHead(ctx)
-		require.NoError(t, err)
-
-		if head.Height() > upgradeH+(provingPeriod*3) {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	// second round of miner checks
-	checkMiner(maddrA, types.NewInt(uint64(ssz)*GenesisPreseals), true, types.EmptyTSK)
-	checkMiner(maddrC, types.NewInt(0), true, types.EmptyTSK)
-	checkMiner(maddrB, types.NewInt(uint64(ssz)*sectersB), true, types.EmptyTSK)
-	checkMiner(maddrD, types.NewInt(uint64(ssz)*sectorsD), true, types.EmptyTSK)
-	checkMiner(maddrE, types.NewInt(0), false, types.EmptyTSK)
-
-	// disable post on minerB
-	minerB.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).Fail()
-
-	// terminate sectors on minerD
-	{
-		var terminationDeclarationParams []miner2.TerminationDeclaration
-		secs, err := minerD.SectorsList(ctx)
-		require.NoError(t, err)
-		require.Len(t, secs, sectorsD)
-
-		for _, sectorNum := range secs {
-			sectorbit := bitfield.New()
-			sectorbit.Set(uint64(sectorNum))
-
-			loca, err := client.StateSectorPartition(ctx, maddrD, sectorNum, types.EmptyTSK)
-			require.NoError(t, err)
-
-			para := miner2.TerminationDeclaration{
-				Deadline:  loca.Deadline,
-				Partition: loca.Partition,
-				Sectors:   sectorbit,
-			}
-
-			terminationDeclarationParams = append(terminationDeclarationParams, para)
-		}
-
-		terminateSectorParams := &miner2.TerminateSectorsParams{
-			Terminations: terminationDeclarationParams,
-		}
-
-		sp, aerr := actors.SerializeParams(terminateSectorParams)
-		require.NoError(t, aerr)
-
-		smsg, err := client.MpoolPushMessage(ctx, &types.Message{
-			From:   defaultFrom,
-			To:     maddrD,
-			Method: miner.Methods.TerminateSectors,
-
-			Value:  big.Zero(),
-			Params: sp,
-		}, nil)
-		require.NoError(t, err)
-
-		fmt.Println("sent termination message:", smsg.Cid())
-
-		r, err := client.StateWaitMsg(ctx, smsg.Cid(), 2)
-		require.NoError(t, err)
-		require.Equal(t, exitcode.Ok, r.Receipt.ExitCode)
-
-		checkMiner(maddrD, types.NewInt(0), true, r.TipSet)
-	}
-
-	// go through another PP
-	for {
-		head, err := client.ChainHead(ctx)
-		require.NoError(t, err)
-
-		if head.Height() > upgradeH+(provingPeriod*5) {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	// third round of miner checks
-	checkMiner(maddrA, types.NewInt(uint64(ssz)*GenesisPreseals), true, types.EmptyTSK)
-	checkMiner(maddrC, types.NewInt(0), true, types.EmptyTSK)
-	checkMiner(maddrB, types.NewInt(0), true, types.EmptyTSK)
-	checkMiner(maddrD, types.NewInt(0), false, types.EmptyTSK)
-}

api/test/deals.go

@@ -8,58 +8,131 @@ import (
 	"math/rand"
 	"os"
 	"path/filepath"
+	"sync/atomic"
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/ipfs/go-cid"
 	files "github.com/ipfs/go-ipfs-files"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/ipld/go-car"
-	"github.com/stretchr/testify/require"
 
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
-	"github.com/filecoin-project/lotus/chain/types"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
-	"github.com/filecoin-project/lotus/extern/storage-sealing/sealiface"
-	"github.com/filecoin-project/lotus/markets/storageadapter"
-	"github.com/filecoin-project/lotus/node"
-	"github.com/filecoin-project/lotus/node/impl"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
-	ipld "github.com/ipfs/go-ipld-format"
+	"github.com/filecoin-project/lotus/miner"
 	dag "github.com/ipfs/go-merkledag"
 	dstest "github.com/ipfs/go-merkledag/test"
 	unixfile "github.com/ipfs/go-unixfs/file"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/impl"
+	ipld "github.com/ipfs/go-ipld-format"
 )
 
-func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport, fastRet bool, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
-
-	MakeDeal(t, s.ctx, 6, s.client, s.miner, carExport, fastRet, startEpoch)
+var MineNext = miner.MineReq{
+	InjectNulls: 0,
+	Done:        func(bool, abi.ChainEpoch, error) {},
 }
 
-func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
-
-	MakeDeal(t, s.ctx, 6, s.client, s.miner, false, false, startEpoch)
-	MakeDeal(t, s.ctx, 7, s.client, s.miner, false, false, startEpoch)
+func init() {
+	logging.SetAllLoggers(logging.LevelInfo)
+	build.InsecurePoStValidation = true
 }
 
-func MakeDeal(t *testing.T, ctx context.Context, rseed int, client api.FullNode, miner TestStorageNode, carExport, fastRet bool, startEpoch abi.ChainEpoch) {
-	res, data, err := CreateClientFile(ctx, client, rseed)
+func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport, fastRet bool) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
+	ctx := context.Background()
+	n, sn := b(t, 1, OneMiner)
+	client := n[0].FullNode.(*impl.FullNodeAPI)
+	miner := sn[0]
+
+	addrinfo, err := client.NetAddrsListen(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if err := miner.NetConnect(ctx, addrinfo); err != nil {
+		t.Fatal(err)
+	}
+	time.Sleep(time.Second)
+
+	mine := int64(1)
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		for atomic.LoadInt64(&mine) == 1 {
+			time.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				t.Error(err)
+			}
+		}
+	}()
+
+	makeDeal(t, ctx, 6, client, miner, carExport, fastRet)
+
+	atomic.AddInt64(&mine, -1)
+	fmt.Println("shutting down mining")
+	<-done
+}
+
+func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
+	ctx := context.Background()
+	n, sn := b(t, 1, OneMiner)
+	client := n[0].FullNode.(*impl.FullNodeAPI)
+	miner := sn[0]
+
+	addrinfo, err := client.NetAddrsListen(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if err := miner.NetConnect(ctx, addrinfo); err != nil {
+		t.Fatal(err)
+	}
+	time.Sleep(time.Second)
+
+	mine := int64(1)
+	done := make(chan struct{})
+
+	go func() {
+		defer close(done)
+		for atomic.LoadInt64(&mine) == 1 {
+			time.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				t.Error(err)
+			}
+		}
+	}()
+
+	makeDeal(t, ctx, 6, client, miner, false, false)
+	makeDeal(t, ctx, 7, client, miner, false, false)
+
+	atomic.AddInt64(&mine, -1)
+	fmt.Println("shutting down mining")
+	<-done
+}
+
+func makeDeal(t *testing.T, ctx context.Context, rseed int, client *impl.FullNodeAPI, miner TestStorageNode, carExport, fastRet bool) {
+	data := make([]byte, 1600)
+	rand.New(rand.NewSource(int64(rseed))).Read(data)
+
+	r := bytes.NewReader(data)
+	fcid, err := client.ClientImportLocal(ctx, r)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	fcid := res.Root
 	fmt.Println("FILE CID: ", fcid)
 
-	deal := startDeal(t, ctx, miner, client, fcid, fastRet, startEpoch)
+	deal := startDeal(t, ctx, miner, client, fcid, fastRet)
 
 	// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
 	time.Sleep(time.Second)
@@ -72,220 +145,98 @@ func MakeDeal(t *testing.T, ctx context.Context, rseed int, client api.FullNode,
 	testRetrieval(t, ctx, client, fcid, &info.PieceCID, carExport, data)
 }
 
-func CreateClientFile(ctx context.Context, client api.FullNode, rseed int) (*api.ImportRes, []byte, error) {
-	data := make([]byte, 1600)
-	rand.New(rand.NewSource(int64(rseed))).Read(data)
+func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 
-	dir, err := ioutil.TempDir(os.TempDir(), "test-make-deal-")
-	if err != nil {
-		return nil, nil, err
-	}
-
-	path := filepath.Join(dir, "sourcefile.dat")
-	err = ioutil.WriteFile(path, data, 0644)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	res, err := client.ClientImport(ctx, api.FileRef{Path: path})
-	if err != nil {
-		return nil, nil, err
-	}
-	return res, data, nil
-}
-
-func TestPublishDealsBatching(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	publishPeriod := 10 * time.Second
-	maxDealsPerMsg := uint64(2)
-
-	// Set max deals per publish deals message to 2
-	minerDef := []StorageMiner{{
-		Full: 0,
-		Opts: node.Override(
-			new(*storageadapter.DealPublisher),
-			storageadapter.NewDealPublisher(nil, storageadapter.PublishMsgConfig{
-				Period:         publishPeriod,
-				MaxDealsPerMsg: maxDealsPerMsg,
-			})),
-		Preseal: PresealGenesis,
-	}}
-
-	// Create a connect client and miner node
-	n, sn := b(t, OneFull, minerDef)
+	ctx := context.Background()
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
-	s := connectAndStartMining(t, b, blocktime, client, miner)
-	defer s.blockMiner.Stop()
 
-	// Starts a deal and waits until it's published
-	runDealTillPublish := func(rseed int) {
-		res, _, err := CreateClientFile(s.ctx, s.client, rseed)
-		require.NoError(t, err)
+	addrinfo, err := client.NetAddrsListen(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
 
-		upds, err := client.ClientGetDealUpdates(s.ctx)
-		require.NoError(t, err)
+	if err := miner.NetConnect(ctx, addrinfo); err != nil {
+		t.Fatal(err)
+	}
+	time.Sleep(time.Second)
 
-		startDeal(t, s.ctx, s.miner, s.client, res.Root, false, startEpoch)
-
-		// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
-		time.Sleep(time.Second)
-
-		done := make(chan struct{})
-		go func() {
-			for upd := range upds {
-				if upd.DataRef.Root == res.Root && upd.State == storagemarket.StorageDealAwaitingPreCommit {
-					done <- struct{}{}
-				}
+	mine := int64(1)
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		for atomic.LoadInt64(&mine) == 1 {
+			time.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				t.Error(err)
 			}
-		}()
-		<-done
-	}
-
-	// Run three deals in parallel
-	done := make(chan struct{}, maxDealsPerMsg+1)
-	for rseed := 1; rseed <= 3; rseed++ {
-		rseed := rseed
-		go func() {
-			runDealTillPublish(rseed)
-			done <- struct{}{}
-		}()
-	}
-
-	// Wait for two of the deals to be published
-	for i := 0; i < int(maxDealsPerMsg); i++ {
-		<-done
-	}
-
-	// Expect a single PublishStorageDeals message that includes the first two deals
-	msgCids, err := s.client.StateListMessages(s.ctx, &api.MessageMatch{To: market.Address}, types.EmptyTSK, 1)
-	require.NoError(t, err)
-	count := 0
-	for _, msgCid := range msgCids {
-		msg, err := s.client.ChainGetMessage(s.ctx, msgCid)
-		require.NoError(t, err)
-
-		if msg.Method == market.Methods.PublishStorageDeals {
-			count++
-			var pubDealsParams market2.PublishStorageDealsParams
-			err = pubDealsParams.UnmarshalCBOR(bytes.NewReader(msg.Params))
-			require.NoError(t, err)
-			require.Len(t, pubDealsParams.Deals, int(maxDealsPerMsg))
 		}
-	}
-	require.Equal(t, 1, count)
-
-	// The third deal should be published once the publish period expires.
-	// Allow a little padding as it takes a moment for the state change to
-	// be noticed by the client.
-	padding := 10 * time.Second
-	select {
-	case <-time.After(publishPeriod + padding):
-		require.Fail(t, "Expected 3rd deal to be published once publish period elapsed")
-	case <-done: // Success
-	}
-}
-
-func TestBatchDealInput(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	publishPeriod := 10 * time.Second
-	maxDealsPerMsg := uint64(4)
-
-	// Set max deals per publish deals message to maxDealsPerMsg
-	minerDef := []StorageMiner{{
-		Full: 0,
-		Opts: node.Options(
-			node.Override(
-				new(*storageadapter.DealPublisher),
-				storageadapter.NewDealPublisher(nil, storageadapter.PublishMsgConfig{
-					Period:         publishPeriod,
-					MaxDealsPerMsg: maxDealsPerMsg,
-				})),
-			node.Override(new(dtypes.GetSealingConfigFunc), func() (dtypes.GetSealingConfigFunc, error) {
-				return func() (sealiface.Config, error) {
-					return sealiface.Config{
-						MaxWaitDealsSectors:       1,
-						MaxSealingSectors:         1,
-						MaxSealingSectorsForDeals: 2,
-						AlwaysKeepUnsealedCopy:    true,
-					}, nil
-				}, nil
-			}),
-		),
-		Preseal: PresealGenesis,
-	}}
-
-	// Create a connect client and miner node
-	n, sn := b(t, OneFull, minerDef)
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-	s := connectAndStartMining(t, b, blocktime, client, miner)
-	defer s.blockMiner.Stop()
-
-	// Starts a deal and waits until it's published
-	runDealTillSeal := func(rseed int) {
-		res, _, err := CreateClientFile(s.ctx, s.client, rseed)
-		require.NoError(t, err)
-
-		dc := startDeal(t, s.ctx, s.miner, s.client, res.Root, false, startEpoch)
-		waitDealSealed(t, s.ctx, s.miner, s.client, dc, false)
-	}
-
-	// Run maxDealsPerMsg+1 deals in parallel
-	done := make(chan struct{}, maxDealsPerMsg+1)
-	for rseed := 1; rseed <= int(maxDealsPerMsg+1); rseed++ {
-		rseed := rseed
-		go func() {
-			runDealTillSeal(rseed)
-			done <- struct{}{}
-		}()
-	}
-
-	// Wait for maxDealsPerMsg of the deals to be published
-	for i := 0; i < int(maxDealsPerMsg); i++ {
-		<-done
-	}
-
-	sl, err := sn[0].SectorsList(s.ctx)
-	require.NoError(t, err)
-	require.GreaterOrEqual(t, len(sl), 4)
-	require.LessOrEqual(t, len(sl), 5)
-}
-
-func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
+	}()
 
 	data := make([]byte, 1600)
 	rand.New(rand.NewSource(int64(8))).Read(data)
 
 	r := bytes.NewReader(data)
-	fcid, err := s.client.ClientImportLocal(s.ctx, r)
+	fcid, err := client.ClientImportLocal(ctx, r)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	fmt.Println("FILE CID: ", fcid)
 
-	deal := startDeal(t, s.ctx, s.miner, s.client, fcid, true, startEpoch)
+	deal := startDeal(t, ctx, miner, client, fcid, true)
 
-	waitDealPublished(t, s.ctx, s.miner, deal)
+	waitDealPublished(t, ctx, miner, deal)
 	fmt.Println("deal published, retrieving")
 	// Retrieval
-	info, err := s.client.ClientGetDealInfo(s.ctx, *deal)
+	info, err := client.ClientGetDealInfo(ctx, *deal)
 	require.NoError(t, err)
 
-	testRetrieval(t, s.ctx, s.client, fcid, &info.PieceCID, false, data)
+	testRetrieval(t, ctx, client, fcid, &info.PieceCID, false, data)
+	atomic.AddInt64(&mine, -1)
+	fmt.Println("shutting down mining")
+	<-done
 }
 
-func TestSecondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
+func TestSenondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
+	ctx := context.Background()
+	n, sn := b(t, 1, OneMiner)
+	client := n[0].FullNode.(*impl.FullNodeAPI)
+	miner := sn[0]
+
+	addrinfo, err := client.NetAddrsListen(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if err := miner.NetConnect(ctx, addrinfo); err != nil {
+		t.Fatal(err)
+	}
+	time.Sleep(time.Second)
+
+	mine := int64(1)
+	done := make(chan struct{})
+
+	go func() {
+		defer close(done)
+		for atomic.LoadInt64(&mine) == 1 {
+			time.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				t.Error(err)
+			}
+		}
+	}()
 
 	{
 		data1 := make([]byte, 800)
 		rand.New(rand.NewSource(int64(3))).Read(data1)
 		r := bytes.NewReader(data1)
 
-		fcid1, err := s.client.ClientImportLocal(s.ctx, r)
+		fcid1, err := client.ClientImportLocal(ctx, r)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -294,49 +245,38 @@ func TestSecondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration
 		rand.New(rand.NewSource(int64(9))).Read(data2)
 		r2 := bytes.NewReader(data2)
 
-		fcid2, err := s.client.ClientImportLocal(s.ctx, r2)
+		fcid2, err := client.ClientImportLocal(ctx, r2)
 		if err != nil {
 			t.Fatal(err)
 		}
 
-		deal1 := startDeal(t, s.ctx, s.miner, s.client, fcid1, true, 0)
+		deal1 := startDeal(t, ctx, miner, client, fcid1, true)
 
 		// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
 		time.Sleep(time.Second)
-		waitDealSealed(t, s.ctx, s.miner, s.client, deal1, true)
+		waitDealSealed(t, ctx, miner, client, deal1, true)
 
-		deal2 := startDeal(t, s.ctx, s.miner, s.client, fcid2, true, 0)
+		deal2 := startDeal(t, ctx, miner, client, fcid2, true)
 
 		time.Sleep(time.Second)
-		waitDealSealed(t, s.ctx, s.miner, s.client, deal2, false)
+		waitDealSealed(t, ctx, miner, client, deal2, false)
 
 		// Retrieval
-		info, err := s.client.ClientGetDealInfo(s.ctx, *deal2)
+		info, err := client.ClientGetDealInfo(ctx, *deal2)
 		require.NoError(t, err)
 
-		rf, _ := s.miner.SectorsRefs(s.ctx)
+		rf, _ := miner.SectorsRefs(ctx)
 		fmt.Printf("refs: %+v\n", rf)
 
-		testRetrieval(t, s.ctx, s.client, fcid2, &info.PieceCID, false, data2)
+		testRetrieval(t, ctx, client, fcid2, &info.PieceCID, false, data2)
 	}
+
+	atomic.AddInt64(&mine, -1)
+	fmt.Println("shutting down mining")
+	<-done
 }
 
-func TestZeroPricePerByteRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
-
-	// Set price-per-byte to zero
-	ask, err := s.miner.MarketGetRetrievalAsk(s.ctx)
-	require.NoError(t, err)
-
-	ask.PricePerByte = abi.NewTokenAmount(0)
-	err = s.miner.MarketSetRetrievalAsk(s.ctx, ask)
-	require.NoError(t, err)
-
-	MakeDeal(t, s.ctx, 6, s.client, s.miner, false, false, startEpoch)
-}
-
-func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client api.FullNode, fcid cid.Cid, fastRet bool, startEpoch abi.ChainEpoch) *cid.Cid {
+func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client *impl.FullNodeAPI, fcid cid.Cid, fastRet bool) *cid.Cid {
 	maddr, err := miner.ActorAddress(ctx)
 	if err != nil {
 		t.Fatal(err)
@@ -354,7 +294,6 @@ func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client
 		Wallet:            addr,
 		Miner:             maddr,
 		EpochPrice:        types.NewInt(1000000),
-		DealStartEpoch:    startEpoch,
 		MinBlocksDuration: uint64(build.MinDealDuration),
 		FastRetrieval:     fastRet,
 	})
@@ -364,7 +303,7 @@ func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client
 	return deal
 }
 
-func waitDealSealed(t *testing.T, ctx context.Context, miner TestStorageNode, client api.FullNode, deal *cid.Cid, noseal bool) {
+func waitDealSealed(t *testing.T, ctx context.Context, miner TestStorageNode, client *impl.FullNodeAPI, deal *cid.Cid, noseal bool) {
 loop:
 	for {
 		di, err := client.ClientGetDealInfo(ctx, *deal)
@@ -372,7 +311,7 @@ loop:
 			t.Fatal(err)
 		}
 		switch di.State {
-		case storagemarket.StorageDealAwaitingPreCommit, storagemarket.StorageDealSealing:
+		case storagemarket.StorageDealSealing:
 			if noseal {
 				return
 			}
@@ -412,7 +351,7 @@ func waitDealPublished(t *testing.T, ctx context.Context, miner TestStorageNode,
 					t.Fatal("deal failed")
 				case storagemarket.StorageDealError:
 					t.Fatal("deal errored", di.Message)
-				case storagemarket.StorageDealFinalizing, storagemarket.StorageDealAwaitingPreCommit, storagemarket.StorageDealSealing, storagemarket.StorageDealActive:
+				case storagemarket.StorageDealFinalizing, storagemarket.StorageDealSealing, storagemarket.StorageDealActive:
 					fmt.Println("COMPLETE", di)
 					return
 				}
@@ -435,11 +374,9 @@ func startSealingWaiting(t *testing.T, ctx context.Context, miner TestStorageNod
 			require.NoError(t, miner.SectorStartSealing(ctx, snum))
 		}
 	}
-
-	flushSealingBatches(t, ctx, miner)
 }
 
-func testRetrieval(t *testing.T, ctx context.Context, client api.FullNode, fcid cid.Cid, piece *cid.Cid, carExport bool, data []byte) {
+func testRetrieval(t *testing.T, ctx context.Context, client *impl.FullNodeAPI, fcid cid.Cid, piece *cid.Cid, carExport bool, data []byte) {
 	offers, err := client.ClientFindData(ctx, fcid, piece)
 	if err != nil {
 		t.Fatal(err)
@@ -465,12 +402,9 @@ func testRetrieval(t *testing.T, ctx context.Context, client api.FullNode, fcid
 		IsCAR: carExport,
 	}
 	updates, err := client.ClientRetrieveWithEvents(ctx, offers[0].Order(caddr), ref)
-	if err != nil {
-		t.Fatal(err)
-	}
 	for update := range updates {
 		if update.Err != "" {
-			t.Fatalf("retrieval failed: %s", update.Err)
+			t.Fatalf("%v", err)
 		}
 	}
 
@@ -517,40 +451,3 @@ func extractCarData(t *testing.T, ctx context.Context, rdata []byte, rpath strin
 	}
 	return rdata
 }
-
-type dealsScaffold struct {
-	ctx        context.Context
-	client     *impl.FullNodeAPI
-	miner      TestStorageNode
-	blockMiner *BlockMiner
-}
-
-func setupOneClientOneMiner(t *testing.T, b APIBuilder, blocktime time.Duration) *dealsScaffold {
-	n, sn := b(t, OneFull, OneMiner)
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-	return connectAndStartMining(t, b, blocktime, client, miner)
-}
-
-func connectAndStartMining(t *testing.T, b APIBuilder, blocktime time.Duration, client *impl.FullNodeAPI, miner TestStorageNode) *dealsScaffold {
-	ctx := context.Background()
-	addrinfo, err := client.NetAddrsListen(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := miner.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-	time.Sleep(time.Second)
-
-	blockMiner := NewBlockMiner(ctx, t, miner, blocktime)
-	blockMiner.MineBlocks()
-
-	return &dealsScaffold{
-		ctx:        ctx,
-		client:     client,
-		miner:      miner,
-		blockMiner: blockMiner,
-	}
-}

api/test/mining.go

@@ -5,19 +5,17 @@ import (
 	"context"
 	"fmt"
 	"math/rand"
+	"os"
 	"sync/atomic"
 	"testing"
 	"time"
 
 	logging "github.com/ipfs/go-log/v2"
 
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/stretchr/testify/require"
 
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node/impl"
 )
@@ -27,7 +25,7 @@ var log = logging.Logger("apitest")
 
 func (ts *testSuite) testMining(t *testing.T) {
 	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, OneFull, OneMiner)
+	apis, sn := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]
 
 	newHeads, err := api.ChainNotify(ctx)
@@ -56,16 +54,19 @@ func (ts *testSuite) testMiningReal(t *testing.T) {
 	}()
 
 	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, OneFull, OneMiner)
+	apis, sn := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]
 
 	newHeads, err := api.ChainNotify(ctx)
 	require.NoError(t, err)
-	at := (<-newHeads)[0].Val.Height()
+	initHead := (<-newHeads)[0]
+	if initHead.Val.Height() != 2 {
+		<-newHeads
+	}
 
 	h1, err := api.ChainHead(ctx)
 	require.NoError(t, err)
-	require.Equal(t, int64(at), int64(h1.Height()))
+	require.Equal(t, abi.ChainEpoch(2), h1.Height())
 
 	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
 	require.NoError(t, err)
@@ -74,23 +75,25 @@ func (ts *testSuite) testMiningReal(t *testing.T) {
 
 	h2, err := api.ChainHead(ctx)
 	require.NoError(t, err)
-	require.Greater(t, int64(h2.Height()), int64(h1.Height()))
+	require.Equal(t, abi.ChainEpoch(3), h2.Height())
 
 	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
 	require.NoError(t, err)
 
 	<-newHeads
 
-	h3, err := api.ChainHead(ctx)
+	h2, err = api.ChainHead(ctx)
 	require.NoError(t, err)
-	require.Greater(t, int64(h3.Height()), int64(h2.Height()))
+	require.Equal(t, abi.ChainEpoch(4), h2.Height())
 }
 
 func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExport bool) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
 	// test making a deal with a fresh miner, and see if it starts to mine
 
 	ctx := context.Background()
-	n, sn := b(t, OneFull, []StorageMiner{
+	n, sn := b(t, 1, []StorageMiner{
 		{Full: 0, Preseal: PresealGenesis},
 		{Full: 0, Preseal: 0}, // TODO: Add support for miners on non-first full node
 	})
@@ -189,7 +192,7 @@ func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExpo
 		}
 	}()
 
-	deal := startDeal(t, ctx, provider, client, fcid, false, 0)
+	deal := startDeal(t, ctx, provider, client, fcid, false)
 
 	// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
 	time.Sleep(time.Second)
@@ -202,39 +205,3 @@ func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExpo
 	fmt.Println("shutting down mining")
 	<-done
 }
-
-func (ts *testSuite) testNonGenesisMiner(t *testing.T) {
-	ctx := context.Background()
-	n, sn := ts.makeNodes(t, []FullNodeOpts{
-		FullNodeWithLatestActorsAt(-1),
-	}, []StorageMiner{
-		{Full: 0, Preseal: PresealGenesis},
-	})
-
-	full, ok := n[0].FullNode.(*impl.FullNodeAPI)
-	if !ok {
-		t.Skip("not testing with a full node")
-		return
-	}
-	genesisMiner := sn[0]
-
-	bm := NewBlockMiner(ctx, t, genesisMiner, 4*time.Millisecond)
-	bm.MineBlocks()
-	t.Cleanup(bm.Stop)
-
-	gaa, err := genesisMiner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	gmi, err := full.StateMinerInfo(ctx, gaa, types.EmptyTSK)
-	require.NoError(t, err)
-
-	testm := n[0].Stb(ctx, t, TestSpt, gmi.Owner)
-
-	ta, err := testm.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	tid, err := address.IDFromAddress(ta)
-	require.NoError(t, err)
-
-	require.Equal(t, uint64(1001), tid)
-}

api/test/paych.go

@@ -3,10 +3,14 @@ package test
 import (
 	"context"
 	"fmt"
+	"os"
 	"sync/atomic"
 	"testing"
 	"time"
 
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/ipfs/go-cid"
@@ -15,20 +19,21 @@ import (
 	cbor "github.com/ipfs/go-ipld-cbor"
 
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/blockstore"
+	"github.com/filecoin-project/lotus/api/apibstore"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/events"
 	"github.com/filecoin-project/lotus/chain/events/state"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/wallet"
 )
 
 func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
 	ctx := context.Background()
-	n, sn := b(t, TwoFull, OneMiner)
+	n, sn := b(t, 2, OneMiner)
 
 	paymentCreator := n[0]
 	paymentReceiver := n[1]
@@ -53,7 +58,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	bm.MineBlocks()
 
 	// send some funds to register the receiver
-	receiverAddr, err := paymentReceiver.WalletNew(ctx, types.KTSecp256k1)
+	receiverAddr, err := paymentReceiver.WalletNew(ctx, wallet.ActSigType("secp256k1"))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -66,7 +71,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal(err)
 	}
 
-	channelAmt := int64(7000)
+	channelAmt := int64(100000)
 	channelInfo, err := paymentCreator.PaychGet(ctx, createrAddr, receiverAddr, abi.NewTokenAmount(channelAmt))
 	if err != nil {
 		t.Fatal(err)
@@ -132,7 +137,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal("Unable to settle payment channel")
 	}
 
-	creatorStore := adt.WrapStore(ctx, cbor.NewCborStore(blockstore.NewAPIBlockstore(paymentCreator)))
+	creatorStore := adt.WrapStore(ctx, cbor.NewCborStore(apibstore.NewAPIBlockstore(paymentCreator)))
 
 	// wait for the receiver to submit their vouchers
 	ev := events.NewEvents(ctx, paymentCreator)
@@ -177,53 +182,8 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal("Timed out waiting for receiver to submit vouchers")
 	}
 
-	// Create a new voucher now that some vouchers have already been submitted
-	vouchRes, err := paymentCreator.PaychVoucherCreate(ctx, channel, abi.NewTokenAmount(1000), 3)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if vouchRes.Voucher == nil {
-		t.Fatal(fmt.Errorf("Not enough funds to create voucher: missing %d", vouchRes.Shortfall))
-	}
-	vdelta, err := paymentReceiver.PaychVoucherAdd(ctx, channel, vouchRes.Voucher, nil, abi.NewTokenAmount(1000))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !vdelta.Equals(abi.NewTokenAmount(1000)) {
-		t.Fatal("voucher didn't have the right amount")
-	}
-
-	// Create a new voucher whose value would exceed the channel balance
-	excessAmt := abi.NewTokenAmount(1000)
-	vouchRes, err = paymentCreator.PaychVoucherCreate(ctx, channel, excessAmt, 4)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if vouchRes.Voucher != nil {
-		t.Fatal("Expected not to be able to create voucher whose value would exceed channel balance")
-	}
-	if !vouchRes.Shortfall.Equals(excessAmt) {
-		t.Fatal(fmt.Errorf("Expected voucher shortfall of %d, got %d", excessAmt, vouchRes.Shortfall))
-	}
-
-	// Add a voucher whose value would exceed the channel balance
-	vouch := &paych.SignedVoucher{ChannelAddr: channel, Amount: excessAmt, Lane: 4, Nonce: 1}
-	vb, err := vouch.SigningBytes()
-	if err != nil {
-		t.Fatal(err)
-	}
-	sig, err := paymentCreator.WalletSign(ctx, createrAddr, vb)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vouch.Signature = sig
-	_, err = paymentReceiver.PaychVoucherAdd(ctx, channel, vouch, nil, abi.NewTokenAmount(1000))
-	if err == nil {
-		t.Fatal(fmt.Errorf("Expected shortfall error of %d", excessAmt))
-	}
-
 	// wait for the settlement period to pass before collecting
-	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, policy.PaychSettleDelay)
+	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, paych0.SettleDelay)
 
 	creatorPreCollectBalance, err := paymentCreator.WalletBalance(ctx, createrAddr)
 	if err != nil {
@@ -279,7 +239,7 @@ func waitForBlocks(ctx context.Context, t *testing.T, bm *BlockMiner, paymentRec
 
 		// Add a real block
 		m, err := paymentReceiver.MpoolPushMessage(ctx, &types.Message{
-			To:    builtin.BurntFundsActorAddr,
+			To:    builtin0.BurntFundsActorAddr,
 			From:  receiverAddr,
 			Value: types.NewInt(0),
 		}, nil)

api/test/pledge.go

@@ -1,389 +0,0 @@
-package test
-
-import (
-	"context"
-	"fmt"
-	"sort"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/network"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
-	bminer "github.com/filecoin-project/lotus/miner"
-	"github.com/filecoin-project/lotus/node"
-	"github.com/filecoin-project/lotus/node/impl"
-)
-
-func TestSDRUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, sn := b(t, []FullNodeOpts{FullNodeWithSDRAt(500, 1000)}, OneMiner)
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-
-	addrinfo, err := client.NetAddrsListen(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := miner.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-	build.Clock.Sleep(time.Second)
-
-	pledge := make(chan struct{})
-	mine := int64(1)
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		round := 0
-		for atomic.LoadInt64(&mine) != 0 {
-			build.Clock.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, abi.ChainEpoch, error) {
-
-			}}); err != nil {
-				t.Error(err)
-			}
-
-			// 3 sealing rounds: before, during after.
-			if round >= 3 {
-				continue
-			}
-
-			head, err := client.ChainHead(ctx)
-			assert.NoError(t, err)
-
-			// rounds happen every 100 blocks, with a 50 block offset.
-			if head.Height() >= abi.ChainEpoch(round*500+50) {
-				round++
-				pledge <- struct{}{}
-
-				ver, err := client.StateNetworkVersion(ctx, head.Key())
-				assert.NoError(t, err)
-				switch round {
-				case 1:
-					assert.Equal(t, network.Version6, ver)
-				case 2:
-					assert.Equal(t, network.Version7, ver)
-				case 3:
-					assert.Equal(t, network.Version8, ver)
-				}
-			}
-
-		}
-	}()
-
-	// before.
-	pledgeSectors(t, ctx, miner, 9, 0, pledge)
-
-	s, err := miner.SectorsList(ctx)
-	require.NoError(t, err)
-	sort.Slice(s, func(i, j int) bool {
-		return s[i] < s[j]
-	})
-
-	for i, id := range s {
-		info, err := miner.SectorsStatus(ctx, id, true)
-		require.NoError(t, err)
-		expectProof := abi.RegisteredSealProof_StackedDrg2KiBV1
-		if i >= 3 {
-			// after
-			expectProof = abi.RegisteredSealProof_StackedDrg2KiBV1_1
-		}
-		assert.Equal(t, expectProof, info.SealProof, "sector %d, id %d", i, id)
-	}
-
-	atomic.StoreInt64(&mine, 0)
-	<-done
-}
-
-func TestPledgeBatching(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, sn := b(t, []FullNodeOpts{FullNodeWithLatestActorsAt(-1)}, OneMiner)
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-
-	addrinfo, err := client.NetAddrsListen(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := miner.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-	build.Clock.Sleep(time.Second)
-
-	mine := int64(1)
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for atomic.LoadInt64(&mine) != 0 {
-			build.Clock.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, abi.ChainEpoch, error) {
-
-			}}); err != nil {
-				t.Error(err)
-			}
-		}
-	}()
-
-	for {
-		h, err := client.ChainHead(ctx)
-		require.NoError(t, err)
-		if h.Height() > 10 {
-			break
-		}
-	}
-
-	toCheck := startPledge(t, ctx, miner, nSectors, 0, nil)
-
-	for len(toCheck) > 0 {
-		states := map[api.SectorState]int{}
-
-		for n := range toCheck {
-			st, err := miner.SectorsStatus(ctx, n, false)
-			require.NoError(t, err)
-			states[st.State]++
-			if st.State == api.SectorState(sealing.Proving) {
-				delete(toCheck, n)
-			}
-			if strings.Contains(string(st.State), "Fail") {
-				t.Fatal("sector in a failed state", st.State)
-			}
-		}
-		if states[api.SectorState(sealing.SubmitPreCommitBatch)] == nSectors ||
-			(states[api.SectorState(sealing.SubmitPreCommitBatch)] > 0 && states[api.SectorState(sealing.PreCommit1)] == 0 && states[api.SectorState(sealing.PreCommit2)] == 0) {
-			pcb, err := miner.SectorPreCommitFlush(ctx)
-			require.NoError(t, err)
-			if pcb != nil {
-				fmt.Printf("PRECOMMIT BATCH: %+v\n", pcb)
-			}
-		}
-
-		if states[api.SectorState(sealing.SubmitCommitAggregate)] == nSectors ||
-			(states[api.SectorState(sealing.SubmitCommitAggregate)] > 0 && states[api.SectorState(sealing.WaitSeed)] == 0 && states[api.SectorState(sealing.Committing)] == 0) {
-			cb, err := miner.SectorCommitFlush(ctx)
-			require.NoError(t, err)
-			if cb != nil {
-				fmt.Printf("COMMIT BATCH: %+v\n", cb)
-			}
-		}
-
-		build.Clock.Sleep(100 * time.Millisecond)
-		fmt.Printf("WaitSeal: %d %+v\n", len(toCheck), states)
-	}
-
-	atomic.StoreInt64(&mine, 0)
-	<-done
-}
-
-func TestPledgeBeforeNv13(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, sn := b(t, []FullNodeOpts{
-		{
-			Opts: func(nodes []TestNode) node.Option {
-				return node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
-					Network:   network.Version9,
-					Height:    1,
-					Migration: stmgr.UpgradeActorsV2,
-				}, {
-					Network:   network.Version10,
-					Height:    2,
-					Migration: stmgr.UpgradeActorsV3,
-				}, {
-					Network:   network.Version12,
-					Height:    3,
-					Migration: stmgr.UpgradeActorsV4,
-				}, {
-					Network:   network.Version13,
-					Height:    1000000000,
-					Migration: stmgr.UpgradeActorsV5,
-				}})
-			},
-		},
-	}, OneMiner)
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-
-	addrinfo, err := client.NetAddrsListen(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := miner.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-	build.Clock.Sleep(time.Second)
-
-	mine := int64(1)
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for atomic.LoadInt64(&mine) != 0 {
-			build.Clock.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, abi.ChainEpoch, error) {
-
-			}}); err != nil {
-				t.Error(err)
-			}
-		}
-	}()
-
-	for {
-		h, err := client.ChainHead(ctx)
-		require.NoError(t, err)
-		if h.Height() > 10 {
-			break
-		}
-	}
-
-	toCheck := startPledge(t, ctx, miner, nSectors, 0, nil)
-
-	for len(toCheck) > 0 {
-		states := map[api.SectorState]int{}
-
-		for n := range toCheck {
-			st, err := miner.SectorsStatus(ctx, n, false)
-			require.NoError(t, err)
-			states[st.State]++
-			if st.State == api.SectorState(sealing.Proving) {
-				delete(toCheck, n)
-			}
-			if strings.Contains(string(st.State), "Fail") {
-				t.Fatal("sector in a failed state", st.State)
-			}
-		}
-
-		build.Clock.Sleep(100 * time.Millisecond)
-		fmt.Printf("WaitSeal: %d %+v\n", len(toCheck), states)
-	}
-
-	atomic.StoreInt64(&mine, 0)
-	<-done
-}
-
-func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, sn := b(t, OneFull, OneMiner)
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-
-	addrinfo, err := client.NetAddrsListen(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := miner.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-	build.Clock.Sleep(time.Second)
-
-	mine := int64(1)
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for atomic.LoadInt64(&mine) != 0 {
-			build.Clock.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, abi.ChainEpoch, error) {
-
-			}}); err != nil {
-				t.Error(err)
-			}
-		}
-	}()
-
-	pledgeSectors(t, ctx, miner, nSectors, 0, nil)
-
-	atomic.StoreInt64(&mine, 0)
-	<-done
-}
-
-func flushSealingBatches(t *testing.T, ctx context.Context, miner TestStorageNode) {
-	pcb, err := miner.SectorPreCommitFlush(ctx)
-	require.NoError(t, err)
-	if pcb != nil {
-		fmt.Printf("PRECOMMIT BATCH: %+v\n", pcb)
-	}
-
-	cb, err := miner.SectorCommitFlush(ctx)
-	require.NoError(t, err)
-	if cb != nil {
-		fmt.Printf("COMMIT BATCH: %+v\n", cb)
-	}
-}
-
-func startPledge(t *testing.T, ctx context.Context, miner TestStorageNode, n, existing int, blockNotif <-chan struct{}) map[abi.SectorNumber]struct{} {
-	for i := 0; i < n; i++ {
-		if i%3 == 0 && blockNotif != nil {
-			<-blockNotif
-			log.Errorf("WAIT")
-		}
-		log.Errorf("PLEDGING %d", i)
-		_, err := miner.PledgeSector(ctx)
-		require.NoError(t, err)
-	}
-
-	for {
-		s, err := miner.SectorsList(ctx) // Note - the test builder doesn't import genesis sectors into FSM
-		require.NoError(t, err)
-		fmt.Printf("Sectors: %d\n", len(s))
-		if len(s) >= n+existing {
-			break
-		}
-
-		build.Clock.Sleep(100 * time.Millisecond)
-	}
-
-	fmt.Printf("All sectors is fsm\n")
-
-	s, err := miner.SectorsList(ctx)
-	require.NoError(t, err)
-
-	toCheck := map[abi.SectorNumber]struct{}{}
-	for _, number := range s {
-		toCheck[number] = struct{}{}
-	}
-
-	return toCheck
-}
-
-func pledgeSectors(t *testing.T, ctx context.Context, miner TestStorageNode, n, existing int, blockNotif <-chan struct{}) {
-	toCheck := startPledge(t, ctx, miner, n, existing, blockNotif)
-
-	for len(toCheck) > 0 {
-		flushSealingBatches(t, ctx, miner)
-
-		states := map[api.SectorState]int{}
-		for n := range toCheck {
-			st, err := miner.SectorsStatus(ctx, n, false)
-			require.NoError(t, err)
-			states[st.State]++
-			if st.State == api.SectorState(sealing.Proving) {
-				delete(toCheck, n)
-			}
-			if strings.Contains(string(st.State), "Fail") {
-				t.Fatal("sector in a failed state", st.State)
-			}
-		}
-
-		build.Clock.Sleep(100 * time.Millisecond)
-		fmt.Printf("WaitSeal: %d %+v\n", len(toCheck), states)
-	}
-}

api/test/tape.go

@@ -1,101 +0,0 @@
-package test
-
-import (
-	"context"
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
-	"github.com/filecoin-project/lotus/node"
-	"github.com/filecoin-project/lotus/node/impl"
-	"github.com/stretchr/testify/require"
-)
-
-func TestTapeFix(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	// The "before" case is disabled, because we need the builder to mock 32 GiB sectors to accurately repro this case
-	// TODO: Make the mock sector size configurable and reenable this
-	//t.Run("before", func(t *testing.T) { testTapeFix(t, b, blocktime, false) })
-	t.Run("after", func(t *testing.T) { testTapeFix(t, b, blocktime, true) })
-}
-func testTapeFix(t *testing.T, b APIBuilder, blocktime time.Duration, after bool) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	upgradeSchedule := stmgr.UpgradeSchedule{{
-		Network:   build.ActorUpgradeNetworkVersion,
-		Height:    1,
-		Migration: stmgr.UpgradeActorsV2,
-	}}
-	if after {
-		upgradeSchedule = append(upgradeSchedule, stmgr.Upgrade{
-			Network: network.Version5,
-			Height:  2,
-		})
-	}
-
-	n, sn := b(t, []FullNodeOpts{{Opts: func(_ []TestNode) node.Option {
-		return node.Override(new(stmgr.UpgradeSchedule), upgradeSchedule)
-	}}}, OneMiner)
-
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-
-	addrinfo, err := client.NetAddrsListen(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := miner.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-	build.Clock.Sleep(time.Second)
-
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for ctx.Err() == nil {
-			build.Clock.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, MineNext); err != nil {
-				if ctx.Err() != nil {
-					// context was canceled, ignore the error.
-					return
-				}
-				t.Error(err)
-			}
-		}
-	}()
-	defer func() {
-		cancel()
-		<-done
-	}()
-
-	sid, err := miner.PledgeSector(ctx)
-	require.NoError(t, err)
-
-	fmt.Printf("All sectors is fsm\n")
-
-	// If before, we expect the precommit to fail
-	successState := api.SectorState(sealing.CommitFailed)
-	failureState := api.SectorState(sealing.Proving)
-	if after {
-		// otherwise, it should succeed.
-		successState, failureState = failureState, successState
-	}
-
-	for {
-		st, err := miner.SectorsStatus(ctx, sid.Number, false)
-		require.NoError(t, err)
-		if st.State == successState {
-			break
-		}
-		require.NotEqual(t, failureState, st.State)
-		build.Clock.Sleep(100 * time.Millisecond)
-		fmt.Println("WaitSeal")
-	}
-
-}

api/test/test.go

@@ -2,49 +2,23 @@ package test
 
 import (
 	"context"
-	"fmt"
-	"os"
-	"strings"
 	"testing"
-	"time"
 
-	logging "github.com/ipfs/go-log/v2"
 	"github.com/multiformats/go-multiaddr"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/network"
-
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/miner"
-	"github.com/filecoin-project/lotus/node"
 )
 
-func init() {
-	logging.SetAllLoggers(logging.LevelInfo)
-	err := os.Setenv("BELLMAN_NO_GPU", "1")
-	if err != nil {
-		panic(fmt.Sprintf("failed to set BELLMAN_NO_GPU env variable: %s", err))
-	}
-	build.InsecurePoStValidation = true
-}
-
-type StorageBuilder func(context.Context, *testing.T, abi.RegisteredSealProof, address.Address) TestStorageNode
-
 type TestNode struct {
 	api.FullNode
 	// ListenAddr is the address on which an API server is listening, if an
 	// API server is created for this Node
 	ListenAddr multiaddr.Multiaddr
-
-	Stb StorageBuilder
 }
 
 type TestStorageNode struct {
@@ -54,37 +28,23 @@ type TestStorageNode struct {
 	ListenAddr multiaddr.Multiaddr
 
 	MineOne func(context.Context, miner.MineReq) error
-	Stop    func(context.Context) error
 }
 
 var PresealGenesis = -1
 
 const GenesisPreseals = 2
 
-const TestSpt = abi.RegisteredSealProof_StackedDrg2KiBV1_1
-
-// Options for setting up a mock storage miner
 type StorageMiner struct {
 	Full    int
-	Opts    node.Option
 	Preseal int
 }
 
-type OptionGenerator func([]TestNode) node.Option
-
-// Options for setting up a mock full node
-type FullNodeOpts struct {
-	Lite bool            // run node in "lite" mode
-	Opts OptionGenerator // generate dependency injection options
-}
-
 // APIBuilder is a function which is invoked in test suite to provide
 // test nodes and networks
 //
-// fullOpts array defines options for each full node
 // storage array defines storage nodes, numbers in the array specify full node
 // index the storage node 'belongs' to
-type APIBuilder func(t *testing.T, full []FullNodeOpts, storage []StorageMiner) ([]TestNode, []TestStorageNode)
+type APIBuilder func(t *testing.T, nFull int, storage []StorageMiner) ([]TestNode, []TestStorageNode)
 type testSuite struct {
 	makeNodes APIBuilder
 }
@@ -100,172 +60,27 @@ func TestApis(t *testing.T, b APIBuilder) {
 	t.Run("testConnectTwo", ts.testConnectTwo)
 	t.Run("testMining", ts.testMining)
 	t.Run("testMiningReal", ts.testMiningReal)
-	t.Run("testSearchMsg", ts.testSearchMsg)
-	t.Run("testNonGenesisMiner", ts.testNonGenesisMiner)
-}
-
-func DefaultFullOpts(nFull int) []FullNodeOpts {
-	full := make([]FullNodeOpts, nFull)
-	for i := range full {
-		full[i] = FullNodeOpts{
-			Opts: func(nodes []TestNode) node.Option {
-				return node.Options()
-			},
-		}
-	}
-	return full
 }
 
 var OneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}
-var OneFull = DefaultFullOpts(1)
-var TwoFull = DefaultFullOpts(2)
-
-var FullNodeWithLatestActorsAt = func(upgradeHeight abi.ChainEpoch) FullNodeOpts {
-	if upgradeHeight == -1 {
-		// Attention: Update this when introducing new actor versions or your tests will be sad
-		upgradeHeight = 4
-	}
-
-	return FullNodeOpts{
-		Opts: func(nodes []TestNode) node.Option {
-			return node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
-				// prepare for upgrade.
-				Network:   network.Version9,
-				Height:    1,
-				Migration: stmgr.UpgradeActorsV2,
-			}, {
-				Network:   network.Version10,
-				Height:    2,
-				Migration: stmgr.UpgradeActorsV3,
-			}, {
-				Network:   network.Version12,
-				Height:    3,
-				Migration: stmgr.UpgradeActorsV4,
-			}, {
-				Network:   network.Version13,
-				Height:    upgradeHeight,
-				Migration: stmgr.UpgradeActorsV5,
-			}})
-		},
-	}
-}
-
-var FullNodeWithSDRAt = func(calico, persian abi.ChainEpoch) FullNodeOpts {
-	return FullNodeOpts{
-		Opts: func(nodes []TestNode) node.Option {
-			return node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
-				Network:   network.Version6,
-				Height:    1,
-				Migration: stmgr.UpgradeActorsV2,
-			}, {
-				Network:   network.Version7,
-				Height:    calico,
-				Migration: stmgr.UpgradeCalico,
-			}, {
-				Network: network.Version8,
-				Height:  persian,
-			}})
-		},
-	}
-}
-
-var FullNodeWithV4ActorsAt = func(upgradeHeight abi.ChainEpoch) FullNodeOpts {
-	if upgradeHeight == -1 {
-		upgradeHeight = 3
-	}
-
-	return FullNodeOpts{
-		Opts: func(nodes []TestNode) node.Option {
-			return node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
-				// prepare for upgrade.
-				Network:   network.Version9,
-				Height:    1,
-				Migration: stmgr.UpgradeActorsV2,
-			}, {
-				Network:   network.Version10,
-				Height:    2,
-				Migration: stmgr.UpgradeActorsV3,
-			}, {
-				Network:   network.Version12,
-				Height:    upgradeHeight,
-				Migration: stmgr.UpgradeActorsV4,
-			}})
-		},
-	}
-}
-
-var MineNext = miner.MineReq{
-	InjectNulls: 0,
-	Done:        func(bool, abi.ChainEpoch, error) {},
-}
 
 func (ts *testSuite) testVersion(t *testing.T) {
-	api.RunningNodeType = api.NodeFull
-	t.Cleanup(func() {
-		api.RunningNodeType = api.NodeUnknown
-	})
+	build.RunningNodeType = build.NodeFull
 
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, OneFull, OneMiner)
-	napi := apis[0]
-
-	v, err := napi.Version(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	versions := strings.Split(v.Version, "+")
-	if len(versions) <= 0 {
-		t.Fatal("empty version")
-	}
-	require.Equal(t, versions[0], build.BuildVersion)
-}
-
-func (ts *testSuite) testSearchMsg(t *testing.T) {
-	apis, miners := ts.makeNodes(t, OneFull, OneMiner)
-
+	apis, _ := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	senderAddr, err := api.WalletDefaultAddress(ctx)
+
+	v, err := api.Version(ctx)
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	msg := &types.Message{
-		From:  senderAddr,
-		To:    senderAddr,
-		Value: big.Zero(),
-	}
-	bm := NewBlockMiner(ctx, t, miners[0], 100*time.Millisecond)
-	bm.MineBlocks()
-	defer bm.Stop()
-
-	sm, err := api.MpoolPushMessage(ctx, msg, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	res, err := api.StateWaitMsg(ctx, sm.Cid(), 1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.Receipt.ExitCode != 0 {
-		t.Fatal("did not successfully send message")
-	}
-
-	searchRes, err := api.StateSearchMsg(ctx, sm.Cid())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if searchRes.TipSet != res.TipSet {
-		t.Fatalf("search ts: %s, different from wait ts: %s", searchRes.TipSet, res.TipSet)
-	}
-
+	require.Equal(t, v.Version, build.BuildVersion)
 }
 
 func (ts *testSuite) testID(t *testing.T) {
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, OneFull, OneMiner)
+	apis, _ := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]
 
 	id, err := api.ID(ctx)
@@ -277,7 +92,7 @@ func (ts *testSuite) testID(t *testing.T) {
 
 func (ts *testSuite) testConnectTwo(t *testing.T) {
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, TwoFull, OneMiner)
+	apis, _ := ts.makeNodes(t, 2, OneMiner)
 
 	p, err := apis[0].NetPeers(ctx)
 	if err != nil {

api/test/window_post.go

@@ -3,52 +3,36 @@ package test
 import (
 	"context"
 	"fmt"
+
+	"os"
+	"strings"
 	"testing"
 	"time"
 
-	"github.com/filecoin-project/go-state-types/big"
-
 	"github.com/stretchr/testify/require"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/go-state-types/dline"
 	"github.com/filecoin-project/lotus/extern/sector-storage/mock"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
-	proof3 "github.com/filecoin-project/specs-actors/v3/actors/runtime/proof"
-	"github.com/filecoin-project/specs-storage/storage"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
-	minerActor "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/types"
+	bminer "github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node/impl"
 )
 
-func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
-	for _, height := range []abi.ChainEpoch{
-		-1,   // before
-		162,  // while sealing
-		5000, // while proving
-	} {
-		height := height // copy to satisfy lints
-		t.Run(fmt.Sprintf("upgrade-%d", height), func(t *testing.T) {
-			testWindowPostUpgrade(t, b, blocktime, nSectors, height)
-		})
+func init() {
+	err := os.Setenv("BELLMAN_NO_GPU", "1")
+	if err != nil {
+		panic(fmt.Sprintf("failed to set BELLMAN_NO_GPU env variable: %s", err))
 	}
-
 }
 
-func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int,
-	upgradeHeight abi.ChainEpoch) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, sn := b(t, []FullNodeOpts{FullNodeWithLatestActorsAt(upgradeHeight)}, OneMiner)
-
+func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
+	ctx := context.Background()
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 
@@ -62,23 +46,99 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 	}
 	build.Clock.Sleep(time.Second)
 
+	mine := true
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
-		for ctx.Err() == nil {
+		for mine {
 			build.Clock.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, MineNext); err != nil {
-				if ctx.Err() != nil {
-					// context was canceled, ignore the error.
-					return
-				}
+			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, abi.ChainEpoch, error) {
+
+			}}); err != nil {
 				t.Error(err)
 			}
 		}
 	}()
-	defer func() {
-		cancel()
-		<-done
+
+	pledgeSectors(t, ctx, miner, nSectors, 0, nil)
+
+	mine = false
+	<-done
+}
+
+func pledgeSectors(t *testing.T, ctx context.Context, miner TestStorageNode, n, existing int, blockNotif <-chan struct{}) {
+	for i := 0; i < n; i++ {
+		err := miner.PledgeSector(ctx)
+		require.NoError(t, err)
+		if i%3 == 0 && blockNotif != nil {
+			<-blockNotif
+		}
+	}
+
+	for {
+		s, err := miner.SectorsList(ctx) // Note - the test builder doesn't import genesis sectors into FSM
+		require.NoError(t, err)
+		fmt.Printf("Sectors: %d\n", len(s))
+		if len(s) >= n+existing {
+			break
+		}
+
+		build.Clock.Sleep(100 * time.Millisecond)
+	}
+
+	fmt.Printf("All sectors is fsm\n")
+
+	s, err := miner.SectorsList(ctx)
+	require.NoError(t, err)
+
+	toCheck := map[abi.SectorNumber]struct{}{}
+	for _, number := range s {
+		toCheck[number] = struct{}{}
+	}
+
+	for len(toCheck) > 0 {
+		for n := range toCheck {
+			st, err := miner.SectorsStatus(ctx, n, false)
+			require.NoError(t, err)
+			if st.State == api.SectorState(sealing.Proving) {
+				delete(toCheck, n)
+			}
+			if strings.Contains(string(st.State), "Fail") {
+				t.Fatal("sector in a failed state", st.State)
+			}
+		}
+
+		build.Clock.Sleep(100 * time.Millisecond)
+		fmt.Printf("WaitSeal: %d\n", len(s))
+	}
+}
+
+func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
+	ctx := context.Background()
+	n, sn := b(t, 1, OneMiner)
+	client := n[0].FullNode.(*impl.FullNodeAPI)
+	miner := sn[0]
+
+	addrinfo, err := client.NetAddrsListen(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if err := miner.NetConnect(ctx, addrinfo); err != nil {
+		t.Fatal(err)
+	}
+	build.Clock.Sleep(time.Second)
+
+	mine := true
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		for mine {
+			build.Clock.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				t.Error(err)
+			}
+		}
 	}()
 
 	pledgeSectors(t, ctx, miner, nSectors, 0, nil)
@@ -99,7 +159,7 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)
 
-		if head.Height() > di.PeriodStart+di.WPoStProvingPeriod+2 {
+		if head.Height() > di.PeriodStart+(di.WPoStProvingPeriod)+2 {
 			fmt.Printf("Now head.Height = %d\n", head.Height())
 			break
 		}
@@ -130,17 +190,15 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 
 		// Drop the partition
 		err = secs.ForEach(func(sid uint64) error {
-			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(storage.SectorRef{
-				ID: abi.SectorID{
-					Miner:  abi.ActorID(mid),
-					Number: abi.SectorNumber(sid),
-				},
+			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(abi.SectorID{
+				Miner:  abi.ActorID(mid),
+				Number: abi.SectorNumber(sid),
 			}, true)
 		})
 		require.NoError(t, err)
 	}
 
-	var s storage.SectorRef
+	var s abi.SectorID
 
 	// Drop 1 sectors from deadline 3 partition 0
 	{
@@ -161,11 +219,9 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 		require.NoError(t, err)
 		fmt.Println("the sectors", all)
 
-		s = storage.SectorRef{
-			ID: abi.SectorID{
-				Miner:  abi.ActorID(mid),
-				Number: abi.SectorNumber(sn),
-			},
+		s = abi.SectorID{
+			Miner:  abi.ActorID(mid),
+			Number: abi.SectorNumber(sn),
 		}
 
 		err = miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkFailed(s, true)
@@ -233,11 +289,12 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 	pledgeSectors(t, ctx, miner, 1, nSectors, nil)
 
 	{
-		// Wait until proven.
-		di, err = client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
+		// wait a bit more
+
+		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)
 
-		waitUntil := di.PeriodStart + di.WPoStProvingPeriod + 2
+		waitUntil := head.Height() + 10
 		fmt.Printf("End for head.Height > %d\n", waitUntil)
 
 		for {
@@ -258,745 +315,7 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 
 	sectors = p.MinerPower.RawBytePower.Uint64() / uint64(ssz)
 	require.Equal(t, nSectors+GenesisPreseals-2+1, int(sectors)) // -2 not recovered sectors + 1 just pledged
-}
 
-func TestTerminate(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	nSectors := uint64(2)
-
-	n, sn := b(t, []FullNodeOpts{FullNodeWithLatestActorsAt(-1)}, []StorageMiner{{Full: 0, Preseal: int(nSectors)}})
-
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-
-	addrinfo, err := client.NetAddrsListen(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := miner.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-	build.Clock.Sleep(time.Second)
-
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for ctx.Err() == nil {
-			build.Clock.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, MineNext); err != nil {
-				if ctx.Err() != nil {
-					// context was canceled, ignore the error.
-					return
-				}
-				t.Error(err)
-			}
-		}
-	}()
-	defer func() {
-		cancel()
-		<-done
-	}()
-
-	maddr, err := miner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	ssz, err := miner.ActorSectorSize(ctx, maddr)
-	require.NoError(t, err)
-
-	p, err := client.StateMinerPower(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-	require.Equal(t, p.MinerPower, p.TotalPower)
-	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)*nSectors))
-
-	fmt.Printf("Seal a sector\n")
-
-	pledgeSectors(t, ctx, miner, 1, 0, nil)
-
-	fmt.Printf("wait for power\n")
-
-	{
-		// Wait until proven.
-		di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-		require.NoError(t, err)
-
-		waitUntil := di.PeriodStart + di.WPoStProvingPeriod + 2
-		fmt.Printf("End for head.Height > %d\n", waitUntil)
-
-		for {
-			head, err := client.ChainHead(ctx)
-			require.NoError(t, err)
-
-			if head.Height() > waitUntil {
-				fmt.Printf("Now head.Height = %d\n", head.Height())
-				break
-			}
-		}
-	}
-
-	nSectors++
-
-	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-	require.Equal(t, p.MinerPower, p.TotalPower)
-	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)*nSectors))
-
-	fmt.Println("Terminate a sector")
-
-	toTerminate := abi.SectorNumber(3)
-
-	err = miner.SectorTerminate(ctx, toTerminate)
-	require.NoError(t, err)
-
-	msgTriggerred := false
-loop:
-	for {
-		si, err := miner.SectorsStatus(ctx, toTerminate, false)
-		require.NoError(t, err)
-
-		fmt.Println("state: ", si.State, msgTriggerred)
-
-		switch sealing.SectorState(si.State) {
-		case sealing.Terminating:
-			if !msgTriggerred {
-				{
-					p, err := miner.SectorTerminatePending(ctx)
-					require.NoError(t, err)
-					require.Len(t, p, 1)
-					require.Equal(t, abi.SectorNumber(3), p[0].Number)
-				}
-
-				c, err := miner.SectorTerminateFlush(ctx)
-				require.NoError(t, err)
-				if c != nil {
-					msgTriggerred = true
-					fmt.Println("terminate message:", c)
-
-					{
-						p, err := miner.SectorTerminatePending(ctx)
-						require.NoError(t, err)
-						require.Len(t, p, 0)
-					}
-				}
-			}
-		case sealing.TerminateWait, sealing.TerminateFinality, sealing.Removed:
-			break loop
-		}
-
-		time.Sleep(100 * time.Millisecond)
-	}
-
-	// check power decreased
-	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-	require.Equal(t, p.MinerPower, p.TotalPower)
-	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)*(nSectors-1)))
-
-	// check in terminated set
-	{
-		parts, err := client.StateMinerPartitions(ctx, maddr, 1, types.EmptyTSK)
-		require.NoError(t, err)
-		require.Greater(t, len(parts), 0)
-
-		bflen := func(b bitfield.BitField) uint64 {
-			l, err := b.Count()
-			require.NoError(t, err)
-			return l
-		}
-
-		require.Equal(t, uint64(1), bflen(parts[0].AllSectors))
-		require.Equal(t, uint64(0), bflen(parts[0].LiveSectors))
-	}
-
-	di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-	for {
-		head, err := client.ChainHead(ctx)
-		require.NoError(t, err)
-
-		if head.Height() > di.PeriodStart+di.WPoStProvingPeriod+2 {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-	require.NoError(t, err)
-	fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod+2)
-
-	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	require.Equal(t, p.MinerPower, p.TotalPower)
-	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)*(nSectors-1)))
-}
-
-func TestWindowPostDispute(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// First, we configure two miners. After sealing, we're going to turn off the first miner so
-	// it doesn't submit proofs.
-	///
-	// Then we're going to manually submit bad proofs.
-	n, sn := b(t, []FullNodeOpts{
-		FullNodeWithV4ActorsAt(-1),
-	}, []StorageMiner{
-		{Full: 0, Preseal: PresealGenesis},
-		{Full: 0},
-	})
-
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	chainMiner := sn[0]
-	evilMiner := sn[1]
-
-	{
-		addrinfo, err := client.NetAddrsListen(ctx)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if err := chainMiner.NetConnect(ctx, addrinfo); err != nil {
-			t.Fatal(err)
-		}
-
-		if err := evilMiner.NetConnect(ctx, addrinfo); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	defaultFrom, err := client.WalletDefaultAddress(ctx)
-	require.NoError(t, err)
-
-	build.Clock.Sleep(time.Second)
-
-	// Mine with the _second_ node (the good one).
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for ctx.Err() == nil {
-			build.Clock.Sleep(blocktime)
-			if err := chainMiner.MineOne(ctx, MineNext); err != nil {
-				if ctx.Err() != nil {
-					// context was canceled, ignore the error.
-					return
-				}
-				t.Error(err)
-			}
-		}
-	}()
-	defer func() {
-		cancel()
-		<-done
-	}()
-
-	// Give the chain miner enough sectors to win every block.
-	pledgeSectors(t, ctx, chainMiner, 10, 0, nil)
-	// And the evil one 1 sector. No cookie for you.
-	pledgeSectors(t, ctx, evilMiner, 1, 0, nil)
-
-	// Let the evil miner's sectors gain power.
-	evilMinerAddr, err := evilMiner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	di, err := client.StateMinerProvingDeadline(ctx, evilMinerAddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	fmt.Printf("Running one proving period\n")
-	fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod*2)
-
-	for {
-		head, err := client.ChainHead(ctx)
-		require.NoError(t, err)
-
-		if head.Height() > di.PeriodStart+di.WPoStProvingPeriod*2 {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	p, err := client.StateMinerPower(ctx, evilMinerAddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	ssz, err := evilMiner.ActorSectorSize(ctx, evilMinerAddr)
-	require.NoError(t, err)
-
-	// make sure it has gained power.
-	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)))
-
-	evilSectors, err := evilMiner.SectorsList(ctx)
-	require.NoError(t, err)
-	evilSectorNo := evilSectors[0] // only one.
-	evilSectorLoc, err := client.StateSectorPartition(ctx, evilMinerAddr, evilSectorNo, types.EmptyTSK)
-	require.NoError(t, err)
-
-	fmt.Println("evil miner stopping")
-
-	// Now stop the evil miner, and start manually submitting bad proofs.
-	require.NoError(t, evilMiner.Stop(ctx))
-
-	fmt.Println("evil miner stopped")
-
-	// Wait until we need to prove our sector.
-	for {
-		di, err = client.StateMinerProvingDeadline(ctx, evilMinerAddr, types.EmptyTSK)
-		require.NoError(t, err)
-		if di.Index == evilSectorLoc.Deadline && di.CurrentEpoch-di.PeriodStart > 1 {
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	err = submitBadProof(ctx, client, evilMinerAddr, di, evilSectorLoc.Deadline, evilSectorLoc.Partition)
-	require.NoError(t, err, "evil proof not accepted")
-
-	// Wait until after the proving period.
-	for {
-		di, err = client.StateMinerProvingDeadline(ctx, evilMinerAddr, types.EmptyTSK)
-		require.NoError(t, err)
-		if di.Index != evilSectorLoc.Deadline {
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	fmt.Println("accepted evil proof")
-
-	// Make sure the evil node didn't lose any power.
-	p, err = client.StateMinerPower(ctx, evilMinerAddr, types.EmptyTSK)
-	require.NoError(t, err)
-	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)))
-
-	// OBJECTION! The good miner files a DISPUTE!!!!
-	{
-		params := &minerActor.DisputeWindowedPoStParams{
-			Deadline:  evilSectorLoc.Deadline,
-			PoStIndex: 0,
-		}
-
-		enc, aerr := actors.SerializeParams(params)
-		require.NoError(t, aerr)
-
-		msg := &types.Message{
-			To:     evilMinerAddr,
-			Method: minerActor.Methods.DisputeWindowedPoSt,
-			Params: enc,
-			Value:  types.NewInt(0),
-			From:   defaultFrom,
-		}
-		sm, err := client.MpoolPushMessage(ctx, msg, nil)
-		require.NoError(t, err)
-
-		fmt.Println("waiting dispute")
-		rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence)
-		require.NoError(t, err)
-		require.Zero(t, rec.Receipt.ExitCode, "dispute not accepted: %s", rec.Receipt.ExitCode.Error())
-	}
-
-	// Objection SUSTAINED!
-	// Make sure the evil node lost power.
-	p, err = client.StateMinerPower(ctx, evilMinerAddr, types.EmptyTSK)
-	require.NoError(t, err)
-	require.True(t, p.MinerPower.RawBytePower.IsZero())
-
-	// Now we begin the redemption arc.
-	require.True(t, p.MinerPower.RawBytePower.IsZero())
-
-	// First, recover the sector.
-
-	{
-		minerInfo, err := client.StateMinerInfo(ctx, evilMinerAddr, types.EmptyTSK)
-		require.NoError(t, err)
-
-		params := &minerActor.DeclareFaultsRecoveredParams{
-			Recoveries: []minerActor.RecoveryDeclaration{{
-				Deadline:  evilSectorLoc.Deadline,
-				Partition: evilSectorLoc.Partition,
-				Sectors:   bitfield.NewFromSet([]uint64{uint64(evilSectorNo)}),
-			}},
-		}
-
-		enc, aerr := actors.SerializeParams(params)
-		require.NoError(t, aerr)
-
-		msg := &types.Message{
-			To:     evilMinerAddr,
-			Method: minerActor.Methods.DeclareFaultsRecovered,
-			Params: enc,
-			Value:  types.FromFil(30), // repay debt.
-			From:   minerInfo.Owner,
-		}
-		sm, err := client.MpoolPushMessage(ctx, msg, nil)
-		require.NoError(t, err)
-
-		rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence)
-		require.NoError(t, err)
-		require.Zero(t, rec.Receipt.ExitCode, "recovery not accepted: %s", rec.Receipt.ExitCode.Error())
-	}
-
-	// Then wait for the deadline.
-	for {
-		di, err = client.StateMinerProvingDeadline(ctx, evilMinerAddr, types.EmptyTSK)
-		require.NoError(t, err)
-		if di.Index == evilSectorLoc.Deadline && di.CurrentEpoch-di.PeriodStart > 1 {
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	// Now try to be evil again
-	err = submitBadProof(ctx, client, evilMinerAddr, di, evilSectorLoc.Deadline, evilSectorLoc.Partition)
-	require.Error(t, err)
-	require.Contains(t, err.Error(), "message execution failed: exit 16, reason: window post failed: invalid PoSt")
-
-	// It didn't work because we're recovering.
-}
-
-func submitBadProof(
-	ctx context.Context,
-	client api.FullNode, maddr address.Address,
-	di *dline.Info, dlIdx, partIdx uint64,
-) error {
-	head, err := client.ChainHead(ctx)
-	if err != nil {
-		return err
-	}
-
-	from, err := client.WalletDefaultAddress(ctx)
-	if err != nil {
-		return err
-	}
-
-	minerInfo, err := client.StateMinerInfo(ctx, maddr, head.Key())
-	if err != nil {
-		return err
-	}
-
-	commEpoch := di.Open
-	commRand, err := client.ChainGetRandomnessFromTickets(
-		ctx, head.Key(), crypto.DomainSeparationTag_PoStChainCommit,
-		commEpoch, nil,
-	)
-	if err != nil {
-		return err
-	}
-	params := &minerActor.SubmitWindowedPoStParams{
-		ChainCommitEpoch: commEpoch,
-		ChainCommitRand:  commRand,
-		Deadline:         dlIdx,
-		Partitions:       []minerActor.PoStPartition{{Index: partIdx}},
-		Proofs: []proof3.PoStProof{{
-			PoStProof:  minerInfo.WindowPoStProofType,
-			ProofBytes: []byte("I'm soooo very evil."),
-		}},
-	}
-
-	enc, aerr := actors.SerializeParams(params)
-	if aerr != nil {
-		return aerr
-	}
-
-	msg := &types.Message{
-		To:     maddr,
-		Method: minerActor.Methods.SubmitWindowedPoSt,
-		Params: enc,
-		Value:  types.NewInt(0),
-		From:   from,
-	}
-	sm, err := client.MpoolPushMessage(ctx, msg, nil)
-	if err != nil {
-		return err
-	}
-
-	rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence)
-	if err != nil {
-		return err
-	}
-	if rec.Receipt.ExitCode.IsError() {
-		return rec.Receipt.ExitCode
-	}
-	return nil
-}
-
-func TestWindowPostDisputeFails(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, sn := b(t, []FullNodeOpts{FullNodeWithV4ActorsAt(-1)}, OneMiner)
-
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-
-	{
-		addrinfo, err := client.NetAddrsListen(ctx)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if err := miner.NetConnect(ctx, addrinfo); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	defaultFrom, err := client.WalletDefaultAddress(ctx)
-	require.NoError(t, err)
-
-	maddr, err := miner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	build.Clock.Sleep(time.Second)
-
-	// Mine with the _second_ node (the good one).
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for ctx.Err() == nil {
-			build.Clock.Sleep(blocktime)
-			if err := miner.MineOne(ctx, MineNext); err != nil {
-				if ctx.Err() != nil {
-					// context was canceled, ignore the error.
-					return
-				}
-				t.Error(err)
-			}
-		}
-	}()
-	defer func() {
-		cancel()
-		<-done
-	}()
-
-	pledgeSectors(t, ctx, miner, 10, 0, nil)
-
-	di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	fmt.Printf("Running one proving period\n")
-	fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod*2)
-
-	for {
-		head, err := client.ChainHead(ctx)
-		require.NoError(t, err)
-
-		if head.Height() > di.PeriodStart+di.WPoStProvingPeriod*2 {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	ssz, err := miner.ActorSectorSize(ctx, maddr)
-	require.NoError(t, err)
-	expectedPower := types.NewInt(uint64(ssz) * (GenesisPreseals + 10))
-
-	p, err := client.StateMinerPower(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	// make sure it has gained power.
-	require.Equal(t, p.MinerPower.RawBytePower, expectedPower)
-
-	// Wait until a proof has been submitted.
-	var targetDeadline uint64
-waitForProof:
-	for {
-		deadlines, err := client.StateMinerDeadlines(ctx, maddr, types.EmptyTSK)
-		require.NoError(t, err)
-		for dlIdx, dl := range deadlines {
-			nonEmpty, err := dl.PostSubmissions.IsEmpty()
-			require.NoError(t, err)
-			if nonEmpty {
-				targetDeadline = uint64(dlIdx)
-				break waitForProof
-			}
-		}
-
-		build.Clock.Sleep(blocktime)
-	}
-
-	for {
-		di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-		require.NoError(t, err)
-		// wait until the deadline finishes.
-		if di.Index == ((targetDeadline + 1) % di.WPoStPeriodDeadlines) {
-			break
-		}
-
-		build.Clock.Sleep(blocktime)
-	}
-
-	// Try to object to the proof. This should fail.
-	{
-		params := &minerActor.DisputeWindowedPoStParams{
-			Deadline:  targetDeadline,
-			PoStIndex: 0,
-		}
-
-		enc, aerr := actors.SerializeParams(params)
-		require.NoError(t, aerr)
-
-		msg := &types.Message{
-			To:     maddr,
-			Method: minerActor.Methods.DisputeWindowedPoSt,
-			Params: enc,
-			Value:  types.NewInt(0),
-			From:   defaultFrom,
-		}
-		_, err := client.MpoolPushMessage(ctx, msg, nil)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), "failed to dispute valid post (RetCode=16)")
-	}
-}
-
-func TestWindowPostBaseFeeNoBurn(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	och := build.UpgradeClausHeight
-	build.UpgradeClausHeight = 10
-	n, sn := b(t, DefaultFullOpts(1), OneMiner)
-
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-
-	{
-		addrinfo, err := client.NetAddrsListen(ctx)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if err := miner.NetConnect(ctx, addrinfo); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	maddr, err := miner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	mi, err := client.StateMinerInfo(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	build.Clock.Sleep(time.Second)
-
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for ctx.Err() == nil {
-			build.Clock.Sleep(blocktime)
-			if err := miner.MineOne(ctx, MineNext); err != nil {
-				if ctx.Err() != nil {
-					// context was canceled, ignore the error.
-					return
-				}
-				t.Error(err)
-			}
-		}
-	}()
-	defer func() {
-		cancel()
-		<-done
-	}()
-
-	pledgeSectors(t, ctx, miner, 10, 0, nil)
-	wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
-	require.NoError(t, err)
-	en := wact.Nonce
-
-	// wait for a new message to be sent from worker address, it will be a PoSt
-
-waitForProof:
-	for {
-		wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
-		require.NoError(t, err)
-		if wact.Nonce > en {
-			break waitForProof
-		}
-
-		build.Clock.Sleep(blocktime)
-	}
-
-	slm, err := client.StateListMessages(ctx, &api.MessageMatch{To: maddr}, types.EmptyTSK, 0)
-	require.NoError(t, err)
-
-	pmr, err := client.StateReplay(ctx, types.EmptyTSK, slm[0])
-	require.NoError(t, err)
-
-	require.Equal(t, pmr.GasCost.BaseFeeBurn, big.Zero())
-
-	build.UpgradeClausHeight = och
-}
-
-func TestWindowPostBaseFeeBurn(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, sn := b(t, []FullNodeOpts{FullNodeWithLatestActorsAt(-1)}, OneMiner)
-
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-
-	{
-		addrinfo, err := client.NetAddrsListen(ctx)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if err := miner.NetConnect(ctx, addrinfo); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	maddr, err := miner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	mi, err := client.StateMinerInfo(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	build.Clock.Sleep(time.Second)
-
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for ctx.Err() == nil {
-			build.Clock.Sleep(blocktime)
-			if err := miner.MineOne(ctx, MineNext); err != nil {
-				if ctx.Err() != nil {
-					// context was canceled, ignore the error.
-					return
-				}
-				t.Error(err)
-			}
-		}
-	}()
-	defer func() {
-		cancel()
-		<-done
-	}()
-
-	pledgeSectors(t, ctx, miner, 10, 0, nil)
-	wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
-	require.NoError(t, err)
-	en := wact.Nonce
-
-	// wait for a new message to be sent from worker address, it will be a PoSt
-
-waitForProof:
-	for {
-		wact, err := client.StateGetActor(ctx, mi.Worker, types.EmptyTSK)
-		require.NoError(t, err)
-		if wact.Nonce > en {
-			break waitForProof
-		}
-
-		build.Clock.Sleep(blocktime)
-	}
-
-	slm, err := client.StateListMessages(ctx, &api.MessageMatch{To: maddr}, types.EmptyTSK, 0)
-	require.NoError(t, err)
-
-	pmr, err := client.StateReplay(ctx, types.EmptyTSK, slm[0])
-	require.NoError(t, err)
-
-	require.NotEqual(t, pmr.GasCost.BaseFeeBurn, big.Zero())
+	mine = false
+	<-done
 }

api/types.go

@@ -3,10 +3,10 @@ package api
 import (
 	"encoding/json"
 	"fmt"
-	"time"
 
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/build"
 	"github.com/ipfs/go-cid"
 
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -51,6 +51,19 @@ type MessageSendSpec struct {
 	MaxFee abi.TokenAmount
 }
 
+var DefaultMessageSendSpec = MessageSendSpec{
+	// MaxFee of 0.1FIL
+	MaxFee: abi.NewTokenAmount(int64(build.FilecoinPrecision) / 10),
+}
+
+func (ms *MessageSendSpec) Get() MessageSendSpec {
+	if ms == nil {
+		return DefaultMessageSendSpec
+	}
+
+	return *ms
+}
+
 type DataTransferChannel struct {
 	TransferID  datatransfer.TransferID
 	Status      datatransfer.Status
@@ -61,7 +74,6 @@ type DataTransferChannel struct {
 	Message     string
 	OtherPeer   peer.ID
 	Transferred uint64
-	Stages      *datatransfer.ChannelStages
 }
 
 // NewDataTransferChannel constructs an API DataTransferChannel type from full channel state snapshot and a host id
@@ -95,24 +107,3 @@ func NewDataTransferChannel(hostID peer.ID, channelState datatransfer.ChannelSta
 	}
 	return channel
 }
-
-type NetBlockList struct {
-	Peers     []peer.ID
-	IPAddrs   []string
-	IPSubnets []string
-}
-
-type ExtendedPeerInfo struct {
-	ID          peer.ID
-	Agent       string
-	Addrs       []string
-	Protocols   []string
-	ConnMgrMeta *ConnMgrInfo
-}
-
-type ConnMgrInfo struct {
-	FirstSeen time.Time
-	Value     int
-	Tags      map[string]int
-	Conns     map[string]time.Time
-}

api/types/actors.go

@@ -1,5 +0,0 @@
-package apitypes
-
-import "github.com/filecoin-project/go-state-types/network"
-
-type NetworkVersion = network.Version

api/types/openrpc.go

@@ -1,3 +0,0 @@
-package apitypes
-
-type OpenRPCDocument map[string]interface{}

api/version.go

@@ -1,71 +0,0 @@
-package api
-
-import (
-	"fmt"
-
-	xerrors "golang.org/x/xerrors"
-)
-
-type Version uint32
-
-func newVer(major, minor, patch uint8) Version {
-	return Version(uint32(major)<<16 | uint32(minor)<<8 | uint32(patch))
-}
-
-// Ints returns (major, minor, patch) versions
-func (ve Version) Ints() (uint32, uint32, uint32) {
-	v := uint32(ve)
-	return (v & majorOnlyMask) >> 16, (v & minorOnlyMask) >> 8, v & patchOnlyMask
-}
-
-func (ve Version) String() string {
-	vmj, vmi, vp := ve.Ints()
-	return fmt.Sprintf("%d.%d.%d", vmj, vmi, vp)
-}
-
-func (ve Version) EqMajorMinor(v2 Version) bool {
-	return ve&minorMask == v2&minorMask
-}
-
-type NodeType int
-
-const (
-	NodeUnknown NodeType = iota
-
-	NodeFull
-	NodeMiner
-	NodeWorker
-)
-
-var RunningNodeType NodeType
-
-func VersionForType(nodeType NodeType) (Version, error) {
-	switch nodeType {
-	case NodeFull:
-		return FullAPIVersion, nil
-	case NodeMiner:
-		return MinerAPIVersion, nil
-	case NodeWorker:
-		return WorkerAPIVersion, nil
-	default:
-		return Version(0), xerrors.Errorf("unknown node type %d", nodeType)
-	}
-}
-
-// semver versions of the rpc api exposed
-var (
-	FullAPIVersion   = newVer(1, 2, 0)
-	MinerAPIVersion  = newVer(1, 0, 1)
-	WorkerAPIVersion = newVer(1, 0, 0)
-)
-
-//nolint:varcheck,deadcode
-const (
-	majorMask = 0xff0000
-	minorMask = 0xffff00
-	patchMask = 0xffffff
-
-	majorOnlyMask = 0xff0000
-	minorOnlyMask = 0x00ff00
-	patchOnlyMask = 0x0000ff
-)

blockstore/api.go

@@ -1,66 +0,0 @@
-package blockstore
-
-import (
-	"context"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-)
-
-type ChainIO interface {
-	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
-	ChainHasObj(context.Context, cid.Cid) (bool, error)
-}
-
-type apiBlockstore struct {
-	api ChainIO
-}
-
-// This blockstore is adapted in the constructor.
-var _ BasicBlockstore = (*apiBlockstore)(nil)
-
-func NewAPIBlockstore(cio ChainIO) Blockstore {
-	bs := &apiBlockstore{api: cio}
-	return Adapt(bs) // return an adapted blockstore.
-}
-
-func (a *apiBlockstore) DeleteBlock(cid.Cid) error {
-	return xerrors.New("not supported")
-}
-
-func (a *apiBlockstore) Has(c cid.Cid) (bool, error) {
-	return a.api.ChainHasObj(context.TODO(), c)
-}
-
-func (a *apiBlockstore) Get(c cid.Cid) (blocks.Block, error) {
-	bb, err := a.api.ChainReadObj(context.TODO(), c)
-	if err != nil {
-		return nil, err
-	}
-	return blocks.NewBlockWithCid(bb, c)
-}
-
-func (a *apiBlockstore) GetSize(c cid.Cid) (int, error) {
-	bb, err := a.api.ChainReadObj(context.TODO(), c)
-	if err != nil {
-		return 0, err
-	}
-	return len(bb), nil
-}
-
-func (a *apiBlockstore) Put(blocks.Block) error {
-	return xerrors.New("not supported")
-}
-
-func (a *apiBlockstore) PutMany([]blocks.Block) error {
-	return xerrors.New("not supported")
-}
-
-func (a *apiBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
-	return nil, xerrors.New("not supported")
-}
-
-func (a *apiBlockstore) HashOnRead(enabled bool) {
-	return
-}

blockstore/badger/blockstore.go

@@ -1,496 +0,0 @@
-package badgerbs
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"runtime"
-	"sync/atomic"
-
-	"github.com/dgraph-io/badger/v2"
-	"github.com/dgraph-io/badger/v2/options"
-	"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"
-)
-
-var (
-	// KeyPool is the buffer pool we use to compute storage keys.
-	KeyPool *pool.BufferPool = pool.GlobalPool
-)
-
-var (
-	// ErrBlockstoreClosed is returned from blockstore operations after
-	// the blockstore has been closed.
-	ErrBlockstoreClosed = fmt.Errorf("badger blockstore closed")
-
-	log = logger.Logger("badgerbs")
-)
-
-// aliases to mask badger dependencies.
-const (
-	// FileIO is equivalent to badger/options.FileIO.
-	FileIO = options.FileIO
-	// MemoryMap is equivalent to badger/options.MemoryMap.
-	MemoryMap = options.MemoryMap
-	// LoadToRAM is equivalent to badger/options.LoadToRAM.
-	LoadToRAM = options.LoadToRAM
-)
-
-// Options embeds the badger options themselves, and augments them with
-// blockstore-specific options.
-type Options struct {
-	badger.Options
-
-	// Prefix is an optional prefix to prepend to keys. Default: "".
-	Prefix string
-}
-
-func DefaultOptions(path string) Options {
-	return Options{
-		Options: badger.DefaultOptions(path),
-		Prefix:  "",
-	}
-}
-
-// badgerLogger is a local wrapper for go-log to make the interface
-// compatible with badger.Logger (namely, aliasing Warnf to Warningf)
-type badgerLogger struct {
-	*zap.SugaredLogger // skips 1 caller to get useful line info, skipping over badger.Options.
-
-	skip2 *zap.SugaredLogger // skips 2 callers, just like above + this logger.
-}
-
-// Warningf is required by the badger logger APIs.
-func (b *badgerLogger) Warningf(format string, args ...interface{}) {
-	b.skip2.Warnf(format, args...)
-}
-
-const (
-	stateOpen int64 = iota
-	stateClosing
-	stateClosed
-)
-
-// Blockstore is a badger-backed IPLD blockstore.
-//
-// NOTE: once Close() is called, methods will try their best to return
-// ErrBlockstoreClosed. This will guaranteed to happen for all subsequent
-// operation calls after Close() has returned, but it may not happen for
-// operations in progress. Those are likely to fail with a different error.
-type Blockstore struct {
-	// state is accessed atomically
-	state int64
-
-	DB *badger.DB
-
-	prefixing bool
-	prefix    []byte
-	prefixLen int
-}
-
-var _ blockstore.Blockstore = (*Blockstore)(nil)
-var _ blockstore.Viewer = (*Blockstore)(nil)
-var _ io.Closer = (*Blockstore)(nil)
-
-// Open creates a new badger-backed blockstore, with the supplied options.
-func Open(opts Options) (*Blockstore, error) {
-	opts.Logger = &badgerLogger{
-		SugaredLogger: log.Desugar().WithOptions(zap.AddCallerSkip(1)).Sugar(),
-		skip2:         log.Desugar().WithOptions(zap.AddCallerSkip(2)).Sugar(),
-	}
-
-	db, err := badger.Open(opts.Options)
-	if err != nil {
-		return nil, fmt.Errorf("failed to open badger blockstore: %w", err)
-	}
-
-	bs := &Blockstore{DB: db}
-	if p := opts.Prefix; p != "" {
-		bs.prefixing = true
-		bs.prefix = []byte(p)
-		bs.prefixLen = len(bs.prefix)
-	}
-
-	return bs, nil
-}
-
-// Close closes the store. If the store has already been closed, this noops and
-// returns an error, even if the first closure resulted in error.
-func (b *Blockstore) Close() error {
-	if !atomic.CompareAndSwapInt64(&b.state, stateOpen, stateClosing) {
-		return nil
-	}
-
-	defer atomic.StoreInt64(&b.state, stateClosed)
-	return b.DB.Close()
-}
-
-// CollectGarbage runs garbage collection on the value log
-func (b *Blockstore) CollectGarbage() error {
-	if atomic.LoadInt64(&b.state) != stateOpen {
-		return ErrBlockstoreClosed
-	}
-
-	var err error
-	for err == nil {
-		err = b.DB.RunValueLogGC(0.125)
-	}
-
-	if err == badger.ErrNoRewrite {
-		// not really an error in this case
-		return nil
-	}
-
-	return err
-}
-
-// Compact runs a synchronous compaction
-func (b *Blockstore) Compact() error {
-	if atomic.LoadInt64(&b.state) != stateOpen {
-		return ErrBlockstoreClosed
-	}
-
-	nworkers := runtime.NumCPU() / 2
-	if nworkers < 2 {
-		nworkers = 2
-	}
-
-	return b.DB.Flatten(nworkers)
-}
-
-// View implements blockstore.Viewer, which leverages zero-copy read-only
-// access to values.
-func (b *Blockstore) View(cid cid.Cid, fn func([]byte) error) error {
-	if atomic.LoadInt64(&b.state) != stateOpen {
-		return ErrBlockstoreClosed
-	}
-
-	k, pooled := b.PooledStorageKey(cid)
-	if pooled {
-		defer KeyPool.Put(k)
-	}
-
-	return b.DB.View(func(txn *badger.Txn) error {
-		switch item, err := txn.Get(k); err {
-		case nil:
-			return item.Value(fn)
-		case badger.ErrKeyNotFound:
-			return blockstore.ErrNotFound
-		default:
-			return fmt.Errorf("failed to view block from badger blockstore: %w", err)
-		}
-	})
-}
-
-// Has implements Blockstore.Has.
-func (b *Blockstore) Has(cid cid.Cid) (bool, error) {
-	if atomic.LoadInt64(&b.state) != stateOpen {
-		return false, ErrBlockstoreClosed
-	}
-
-	k, pooled := b.PooledStorageKey(cid)
-	if pooled {
-		defer KeyPool.Put(k)
-	}
-
-	err := b.DB.View(func(txn *badger.Txn) error {
-		_, err := txn.Get(k)
-		return err
-	})
-
-	switch err {
-	case badger.ErrKeyNotFound:
-		return false, nil
-	case nil:
-		return true, nil
-	default:
-		return false, fmt.Errorf("failed to check if block exists in badger blockstore: %w", err)
-	}
-}
-
-// Get implements Blockstore.Get.
-func (b *Blockstore) Get(cid cid.Cid) (blocks.Block, error) {
-	if !cid.Defined() {
-		return nil, blockstore.ErrNotFound
-	}
-
-	if atomic.LoadInt64(&b.state) != stateOpen {
-		return nil, ErrBlockstoreClosed
-	}
-
-	k, pooled := b.PooledStorageKey(cid)
-	if pooled {
-		defer KeyPool.Put(k)
-	}
-
-	var val []byte
-	err := b.DB.View(func(txn *badger.Txn) error {
-		switch item, err := txn.Get(k); err {
-		case nil:
-			val, err = item.ValueCopy(nil)
-			return err
-		case badger.ErrKeyNotFound:
-			return blockstore.ErrNotFound
-		default:
-			return fmt.Errorf("failed to get block from badger blockstore: %w", err)
-		}
-	})
-	if err != nil {
-		return nil, err
-	}
-	return blocks.NewBlockWithCid(val, cid)
-}
-
-// GetSize implements Blockstore.GetSize.
-func (b *Blockstore) GetSize(cid cid.Cid) (int, error) {
-	if atomic.LoadInt64(&b.state) != stateOpen {
-		return -1, ErrBlockstoreClosed
-	}
-
-	k, pooled := b.PooledStorageKey(cid)
-	if pooled {
-		defer KeyPool.Put(k)
-	}
-
-	var size int
-	err := b.DB.View(func(txn *badger.Txn) error {
-		switch item, err := txn.Get(k); err {
-		case nil:
-			size = int(item.ValueSize())
-		case badger.ErrKeyNotFound:
-			return blockstore.ErrNotFound
-		default:
-			return fmt.Errorf("failed to get block size from badger blockstore: %w", err)
-		}
-		return nil
-	})
-	if err != nil {
-		size = -1
-	}
-	return size, err
-}
-
-// Put implements Blockstore.Put.
-func (b *Blockstore) Put(block blocks.Block) error {
-	if atomic.LoadInt64(&b.state) != stateOpen {
-		return ErrBlockstoreClosed
-	}
-
-	k, pooled := b.PooledStorageKey(block.Cid())
-	if pooled {
-		defer KeyPool.Put(k)
-	}
-
-	err := b.DB.Update(func(txn *badger.Txn) error {
-		return txn.Set(k, block.RawData())
-	})
-	if err != nil {
-		err = fmt.Errorf("failed to put block in badger blockstore: %w", err)
-	}
-	return err
-}
-
-// PutMany implements Blockstore.PutMany.
-func (b *Blockstore) PutMany(blocks []blocks.Block) error {
-	if atomic.LoadInt64(&b.state) != stateOpen {
-		return ErrBlockstoreClosed
-	}
-
-	// toReturn tracks the byte slices to return to the pool, if we're using key
-	// prefixing. we can't return each slice to the pool after each Set, because
-	// badger holds on to the slice.
-	var toReturn [][]byte
-	if b.prefixing {
-		toReturn = make([][]byte, 0, len(blocks))
-		defer func() {
-			for _, b := range toReturn {
-				KeyPool.Put(b)
-			}
-		}()
-	}
-
-	batch := b.DB.NewWriteBatch()
-	defer batch.Cancel()
-
-	for _, block := range blocks {
-		k, pooled := b.PooledStorageKey(block.Cid())
-		if pooled {
-			toReturn = append(toReturn, k)
-		}
-		if err := batch.Set(k, block.RawData()); err != nil {
-			return err
-		}
-	}
-
-	err := batch.Flush()
-	if err != nil {
-		err = fmt.Errorf("failed to put blocks in badger blockstore: %w", err)
-	}
-	return err
-}
-
-// DeleteBlock implements Blockstore.DeleteBlock.
-func (b *Blockstore) DeleteBlock(cid cid.Cid) error {
-	if atomic.LoadInt64(&b.state) != stateOpen {
-		return ErrBlockstoreClosed
-	}
-
-	k, pooled := b.PooledStorageKey(cid)
-	if pooled {
-		defer KeyPool.Put(k)
-	}
-
-	return b.DB.Update(func(txn *badger.Txn) error {
-		return txn.Delete(k)
-	})
-}
-
-func (b *Blockstore) DeleteMany(cids []cid.Cid) error {
-	if atomic.LoadInt64(&b.state) != stateOpen {
-		return ErrBlockstoreClosed
-	}
-
-	// toReturn tracks the byte slices to return to the pool, if we're using key
-	// prefixing. we can't return each slice to the pool after each Set, because
-	// badger holds on to the slice.
-	var toReturn [][]byte
-	if b.prefixing {
-		toReturn = make([][]byte, 0, len(cids))
-		defer func() {
-			for _, b := range toReturn {
-				KeyPool.Put(b)
-			}
-		}()
-	}
-
-	batch := b.DB.NewWriteBatch()
-	defer batch.Cancel()
-
-	for _, cid := range cids {
-		k, pooled := b.PooledStorageKey(cid)
-		if pooled {
-			toReturn = append(toReturn, k)
-		}
-		if err := batch.Delete(k); err != nil {
-			return err
-		}
-	}
-
-	err := batch.Flush()
-	if err != nil {
-		err = fmt.Errorf("failed to delete blocks from badger blockstore: %w", err)
-	}
-	return err
-}
-
-// AllKeysChan implements Blockstore.AllKeysChan.
-func (b *Blockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
-	if atomic.LoadInt64(&b.state) != stateOpen {
-		return nil, ErrBlockstoreClosed
-	}
-
-	txn := b.DB.NewTransaction(false)
-	opts := badger.IteratorOptions{PrefetchSize: 100}
-	if b.prefixing {
-		opts.Prefix = b.prefix
-	}
-	iter := txn.NewIterator(opts)
-
-	ch := make(chan cid.Cid)
-	go func() {
-		defer close(ch)
-		defer iter.Close()
-
-		// NewCidV1 makes a copy of the multihash buffer, so we can reuse it to
-		// contain allocs.
-		var buf []byte
-		for iter.Rewind(); iter.Valid(); iter.Next() {
-			if ctx.Err() != nil {
-				return // context has fired.
-			}
-			if atomic.LoadInt64(&b.state) != stateOpen {
-				// open iterators will run even after the database is closed...
-				return // closing, yield.
-			}
-			k := iter.Item().Key()
-			if b.prefixing {
-				k = k[b.prefixLen:]
-			}
-
-			if reqlen := base32.RawStdEncoding.DecodedLen(len(k)); len(buf) < reqlen {
-				buf = make([]byte, reqlen)
-			}
-			if n, err := base32.RawStdEncoding.Decode(buf, k); err == nil {
-				select {
-				case ch <- cid.NewCidV1(cid.Raw, buf[:n]):
-				case <-ctx.Done():
-					return
-				}
-			} else {
-				log.Warnf("failed to decode key %s in badger AllKeysChan; err: %s", k, err)
-			}
-		}
-	}()
-
-	return ch, nil
-}
-
-// HashOnRead implements Blockstore.HashOnRead. It is not supported by this
-// blockstore.
-func (b *Blockstore) HashOnRead(_ bool) {
-	log.Warnf("called HashOnRead on badger blockstore; function not supported; ignoring")
-}
-
-// PooledStorageKey returns the storage key under which this CID is stored.
-//
-// The key is: prefix + base32_no_padding(cid.Hash)
-//
-// This method may return pooled byte slice, which MUST be returned to the
-// KeyPool if pooled=true, or a leak will occur.
-func (b *Blockstore) PooledStorageKey(cid cid.Cid) (key []byte, pooled bool) {
-	h := cid.Hash()
-	size := base32.RawStdEncoding.EncodedLen(len(h))
-	if !b.prefixing { // optimize for branch prediction.
-		k := pool.Get(size)
-		base32.RawStdEncoding.Encode(k, h)
-		return k, true // slicing upto length unnecessary; the pool has already done this.
-	}
-
-	size += b.prefixLen
-	k := pool.Get(size)
-	copy(k, b.prefix)
-	base32.RawStdEncoding.Encode(k[b.prefixLen:], h)
-	return k, true // slicing upto length unnecessary; the pool has already done this.
-}
-
-// Storage acts like PooledStorageKey, but attempts to write the storage key
-// into the provided slice. If the slice capacity is insufficient, it allocates
-// a new byte slice with enough capacity to accommodate the result. This method
-// returns the resulting slice.
-func (b *Blockstore) StorageKey(dst []byte, cid cid.Cid) []byte {
-	h := cid.Hash()
-	reqsize := base32.RawStdEncoding.EncodedLen(len(h)) + b.prefixLen
-	if reqsize > cap(dst) {
-		// passed slice is smaller than required size; create new.
-		dst = make([]byte, reqsize)
-	} else if reqsize > len(dst) {
-		// passed slice has enough capacity, but its length is
-		// restricted, expand.
-		dst = dst[:cap(dst)]
-	}
-
-	if b.prefixing { // optimize for branch prediction.
-		copy(dst, b.prefix)
-		base32.RawStdEncoding.Encode(dst[b.prefixLen:], h)
-	} else {
-		base32.RawStdEncoding.Encode(dst, h)
-	}
-	return dst[:reqsize]
-}

blockstore/badger/blockstore_test.go

@@ -1,91 +0,0 @@
-package badgerbs
-
-import (
-	"io/ioutil"
-	"os"
-	"testing"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/stretchr/testify/require"
-
-	"github.com/filecoin-project/lotus/blockstore"
-)
-
-func TestBadgerBlockstore(t *testing.T) {
-	(&Suite{
-		NewBlockstore:  newBlockstore(DefaultOptions),
-		OpenBlockstore: openBlockstore(DefaultOptions),
-	}).RunTests(t, "non_prefixed")
-
-	prefixed := func(path string) Options {
-		opts := DefaultOptions(path)
-		opts.Prefix = "/prefixed/"
-		return opts
-	}
-
-	(&Suite{
-		NewBlockstore:  newBlockstore(prefixed),
-		OpenBlockstore: openBlockstore(prefixed),
-	}).RunTests(t, "prefixed")
-}
-
-func TestStorageKey(t *testing.T) {
-	bs, _ := newBlockstore(DefaultOptions)(t)
-	bbs := bs.(*Blockstore)
-	defer bbs.Close() //nolint:errcheck
-
-	cid1 := blocks.NewBlock([]byte("some data")).Cid()
-	cid2 := blocks.NewBlock([]byte("more data")).Cid()
-	cid3 := blocks.NewBlock([]byte("a little more data")).Cid()
-	require.NotEqual(t, cid1, cid2) // sanity check
-	require.NotEqual(t, cid2, cid3) // sanity check
-
-	// nil slice; let StorageKey allocate for us.
-	k1 := bbs.StorageKey(nil, cid1)
-	require.Len(t, k1, 55)
-	require.True(t, cap(k1) == len(k1))
-
-	// k1's backing array is reused.
-	k2 := bbs.StorageKey(k1, cid2)
-	require.Len(t, k2, 55)
-	require.True(t, cap(k2) == len(k1))
-
-	// bring k2 to len=0, and verify that its backing array gets reused
-	// (i.e. k1 and k2 are overwritten)
-	k3 := bbs.StorageKey(k2[:0], cid3)
-	require.Len(t, k3, 55)
-	require.True(t, cap(k3) == len(k3))
-
-	// backing array of k1 and k2 has been modified, i.e. memory is shared.
-	require.Equal(t, k3, k1)
-	require.Equal(t, k3, k2)
-}
-
-func newBlockstore(optsSupplier func(path string) Options) func(tb testing.TB) (bs blockstore.BasicBlockstore, path string) {
-	return func(tb testing.TB) (bs blockstore.BasicBlockstore, path string) {
-		tb.Helper()
-
-		path, err := ioutil.TempDir("", "")
-		if err != nil {
-			tb.Fatal(err)
-		}
-
-		db, err := Open(optsSupplier(path))
-		if err != nil {
-			tb.Fatal(err)
-		}
-
-		tb.Cleanup(func() {
-			_ = os.RemoveAll(path)
-		})
-
-		return db, path
-	}
-}
-
-func openBlockstore(optsSupplier func(path string) Options) func(tb testing.TB, path string) (bs blockstore.BasicBlockstore, err error) {
-	return func(tb testing.TB, path string) (bs blockstore.BasicBlockstore, err error) {
-		tb.Helper()
-		return Open(optsSupplier(path))
-	}
-}

blockstore/badger/blockstore_test_suite.go

@@ -1,313 +0,0 @@
-package badgerbs
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"reflect"
-	"strings"
-	"testing"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	u "github.com/ipfs/go-ipfs-util"
-
-	"github.com/filecoin-project/lotus/blockstore"
-
-	"github.com/stretchr/testify/require"
-)
-
-// TODO: move this to go-ipfs-blockstore.
-type Suite struct {
-	NewBlockstore  func(tb testing.TB) (bs blockstore.BasicBlockstore, path string)
-	OpenBlockstore func(tb testing.TB, path string) (bs blockstore.BasicBlockstore, err error)
-}
-
-func (s *Suite) RunTests(t *testing.T, prefix string) {
-	v := reflect.TypeOf(s)
-	f := func(t *testing.T) {
-		for i := 0; i < v.NumMethod(); i++ {
-			if m := v.Method(i); strings.HasPrefix(m.Name, "Test") {
-				f := m.Func.Interface().(func(*Suite, *testing.T))
-				t.Run(m.Name, func(t *testing.T) {
-					f(s, t)
-				})
-			}
-		}
-	}
-
-	if prefix == "" {
-		f(t)
-	} else {
-		t.Run(prefix, f)
-	}
-}
-
-func (s *Suite) TestGetWhenKeyNotPresent(t *testing.T) {
-	bs, _ := s.NewBlockstore(t)
-	if c, ok := bs.(io.Closer); ok {
-		defer func() { require.NoError(t, c.Close()) }()
-	}
-
-	c := cid.NewCidV0(u.Hash([]byte("stuff")))
-	bl, err := bs.Get(c)
-	require.Nil(t, bl)
-	require.Equal(t, blockstore.ErrNotFound, err)
-}
-
-func (s *Suite) TestGetWhenKeyIsNil(t *testing.T) {
-	bs, _ := s.NewBlockstore(t)
-	if c, ok := bs.(io.Closer); ok {
-		defer func() { require.NoError(t, c.Close()) }()
-	}
-
-	_, err := bs.Get(cid.Undef)
-	require.Equal(t, blockstore.ErrNotFound, err)
-}
-
-func (s *Suite) TestPutThenGetBlock(t *testing.T) {
-	bs, _ := s.NewBlockstore(t)
-	if c, ok := bs.(io.Closer); ok {
-		defer func() { require.NoError(t, c.Close()) }()
-	}
-
-	orig := blocks.NewBlock([]byte("some data"))
-
-	err := bs.Put(orig)
-	require.NoError(t, err)
-
-	fetched, err := bs.Get(orig.Cid())
-	require.NoError(t, err)
-	require.Equal(t, orig.RawData(), fetched.RawData())
-}
-
-func (s *Suite) TestHas(t *testing.T) {
-	bs, _ := s.NewBlockstore(t)
-	if c, ok := bs.(io.Closer); ok {
-		defer func() { require.NoError(t, c.Close()) }()
-	}
-
-	orig := blocks.NewBlock([]byte("some data"))
-
-	err := bs.Put(orig)
-	require.NoError(t, err)
-
-	ok, err := bs.Has(orig.Cid())
-	require.NoError(t, err)
-	require.True(t, ok)
-
-	ok, err = bs.Has(blocks.NewBlock([]byte("another thing")).Cid())
-	require.NoError(t, err)
-	require.False(t, ok)
-}
-
-func (s *Suite) TestCidv0v1(t *testing.T) {
-	bs, _ := s.NewBlockstore(t)
-	if c, ok := bs.(io.Closer); ok {
-		defer func() { require.NoError(t, c.Close()) }()
-	}
-
-	orig := blocks.NewBlock([]byte("some data"))
-
-	err := bs.Put(orig)
-	require.NoError(t, err)
-
-	fetched, err := bs.Get(cid.NewCidV1(cid.DagProtobuf, orig.Cid().Hash()))
-	require.NoError(t, err)
-	require.Equal(t, orig.RawData(), fetched.RawData())
-}
-
-func (s *Suite) TestPutThenGetSizeBlock(t *testing.T) {
-	bs, _ := s.NewBlockstore(t)
-	if c, ok := bs.(io.Closer); ok {
-		defer func() { require.NoError(t, c.Close()) }()
-	}
-
-	block := blocks.NewBlock([]byte("some data"))
-	missingBlock := blocks.NewBlock([]byte("missingBlock"))
-	emptyBlock := blocks.NewBlock([]byte{})
-
-	err := bs.Put(block)
-	require.NoError(t, err)
-
-	blockSize, err := bs.GetSize(block.Cid())
-	require.NoError(t, err)
-	require.Len(t, block.RawData(), blockSize)
-
-	err = bs.Put(emptyBlock)
-	require.NoError(t, err)
-
-	emptySize, err := bs.GetSize(emptyBlock.Cid())
-	require.NoError(t, err)
-	require.Zero(t, emptySize)
-
-	missingSize, err := bs.GetSize(missingBlock.Cid())
-	require.Equal(t, blockstore.ErrNotFound, err)
-	require.Equal(t, -1, missingSize)
-}
-
-func (s *Suite) TestAllKeysSimple(t *testing.T) {
-	bs, _ := s.NewBlockstore(t)
-	if c, ok := bs.(io.Closer); ok {
-		defer func() { require.NoError(t, c.Close()) }()
-	}
-
-	keys := insertBlocks(t, bs, 100)
-
-	ctx := context.Background()
-	ch, err := bs.AllKeysChan(ctx)
-	require.NoError(t, err)
-	actual := collect(ch)
-
-	require.ElementsMatch(t, keys, actual)
-}
-
-func (s *Suite) TestAllKeysRespectsContext(t *testing.T) {
-	bs, _ := s.NewBlockstore(t)
-	if c, ok := bs.(io.Closer); ok {
-		defer func() { require.NoError(t, c.Close()) }()
-	}
-
-	_ = insertBlocks(t, bs, 100)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	ch, err := bs.AllKeysChan(ctx)
-	require.NoError(t, err)
-
-	// consume 2, then cancel context.
-	v, ok := <-ch
-	require.NotEqual(t, cid.Undef, v)
-	require.True(t, ok)
-
-	v, ok = <-ch
-	require.NotEqual(t, cid.Undef, v)
-	require.True(t, ok)
-
-	cancel()
-	// pull one value out to avoid race
-	_, _ = <-ch
-
-	v, ok = <-ch
-	require.Equal(t, cid.Undef, v)
-	require.False(t, ok)
-}
-
-func (s *Suite) TestDoubleClose(t *testing.T) {
-	bs, _ := s.NewBlockstore(t)
-	c, ok := bs.(io.Closer)
-	if !ok {
-		t.SkipNow()
-	}
-	require.NoError(t, c.Close())
-	require.NoError(t, c.Close())
-}
-
-func (s *Suite) TestReopenPutGet(t *testing.T) {
-	bs, path := s.NewBlockstore(t)
-	c, ok := bs.(io.Closer)
-	if !ok {
-		t.SkipNow()
-	}
-
-	orig := blocks.NewBlock([]byte("some data"))
-	err := bs.Put(orig)
-	require.NoError(t, err)
-
-	err = c.Close()
-	require.NoError(t, err)
-
-	bs, err = s.OpenBlockstore(t, path)
-	require.NoError(t, err)
-
-	fetched, err := bs.Get(orig.Cid())
-	require.NoError(t, err)
-	require.Equal(t, orig.RawData(), fetched.RawData())
-
-	err = bs.(io.Closer).Close()
-	require.NoError(t, err)
-}
-
-func (s *Suite) TestPutMany(t *testing.T) {
-	bs, _ := s.NewBlockstore(t)
-	if c, ok := bs.(io.Closer); ok {
-		defer func() { require.NoError(t, c.Close()) }()
-	}
-
-	blks := []blocks.Block{
-		blocks.NewBlock([]byte("foo1")),
-		blocks.NewBlock([]byte("foo2")),
-		blocks.NewBlock([]byte("foo3")),
-	}
-	err := bs.PutMany(blks)
-	require.NoError(t, err)
-
-	for _, blk := range blks {
-		fetched, err := bs.Get(blk.Cid())
-		require.NoError(t, err)
-		require.Equal(t, blk.RawData(), fetched.RawData())
-
-		ok, err := bs.Has(blk.Cid())
-		require.NoError(t, err)
-		require.True(t, ok)
-	}
-
-	ch, err := bs.AllKeysChan(context.Background())
-	require.NoError(t, err)
-
-	cids := collect(ch)
-	require.Len(t, cids, 3)
-}
-
-func (s *Suite) TestDelete(t *testing.T) {
-	bs, _ := s.NewBlockstore(t)
-	if c, ok := bs.(io.Closer); ok {
-		defer func() { require.NoError(t, c.Close()) }()
-	}
-
-	blks := []blocks.Block{
-		blocks.NewBlock([]byte("foo1")),
-		blocks.NewBlock([]byte("foo2")),
-		blocks.NewBlock([]byte("foo3")),
-	}
-	err := bs.PutMany(blks)
-	require.NoError(t, err)
-
-	err = bs.DeleteBlock(blks[1].Cid())
-	require.NoError(t, err)
-
-	ch, err := bs.AllKeysChan(context.Background())
-	require.NoError(t, err)
-
-	cids := collect(ch)
-	require.Len(t, cids, 2)
-	require.ElementsMatch(t, cids, []cid.Cid{
-		cid.NewCidV1(cid.Raw, blks[0].Cid().Hash()),
-		cid.NewCidV1(cid.Raw, blks[2].Cid().Hash()),
-	})
-
-	has, err := bs.Has(blks[1].Cid())
-	require.NoError(t, err)
-	require.False(t, has)
-
-}
-
-func insertBlocks(t *testing.T, bs blockstore.BasicBlockstore, count int) []cid.Cid {
-	keys := make([]cid.Cid, count)
-	for i := 0; i < count; i++ {
-		block := blocks.NewBlock([]byte(fmt.Sprintf("some data %d", i)))
-		err := bs.Put(block)
-		require.NoError(t, err)
-		// NewBlock assigns a CIDv0; we convert it to CIDv1 because that's what
-		// the store returns.
-		keys[i] = cid.NewCidV1(cid.Raw, block.Multihash())
-	}
-	return keys
-}
-
-func collect(ch <-chan cid.Cid) []cid.Cid {
-	var keys []cid.Cid
-	for k := range ch {
-		keys = append(keys, k)
-	}
-	return keys
-}

blockstore/blockstore.go

@@ -1,95 +0,0 @@
-package blockstore
-
-import (
-	cid "github.com/ipfs/go-cid"
-	ds "github.com/ipfs/go-datastore"
-	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.
-type Blockstore interface {
-	blockstore.Blockstore
-	blockstore.Viewer
-	BatchDeleter
-}
-
-// BasicBlockstore is an alias to the original IPFS Blockstore.
-type BasicBlockstore = blockstore.Blockstore
-
-type Viewer = blockstore.Viewer
-
-type BatchDeleter interface {
-	DeleteMany(cids []cid.Cid) error
-}
-
-// WrapIDStore wraps the underlying blockstore in an "identity" blockstore.
-// The ID store filters out all puts for blocks with CIDs using the "identity"
-// hash function. It also extracts inlined blocks from CIDs using the identity
-// hash function and returns them on get/has, ignoring the contents of the
-// blockstore.
-func WrapIDStore(bstore blockstore.Blockstore) Blockstore {
-	if is, ok := bstore.(*idstore); ok {
-		// already wrapped
-		return is
-	}
-
-	if bs, ok := bstore.(Blockstore); ok {
-		// we need to wrap our own because we don't want to neuter the DeleteMany method
-		// the underlying blockstore has implemented an (efficient) DeleteMany
-		return NewIDStore(bs)
-	}
-
-	// The underlying blockstore does not implement DeleteMany, so we need to shim it.
-	// This is less efficient as it'll iterate and perform single deletes.
-	return NewIDStore(Adapt(bstore))
-}
-
-// FromDatastore creates a new blockstore backed by the given datastore.
-func FromDatastore(dstore ds.Batching) Blockstore {
-	return WrapIDStore(blockstore.NewBlockstore(dstore))
-}
-
-type adaptedBlockstore struct {
-	blockstore.Blockstore
-}
-
-var _ Blockstore = (*adaptedBlockstore)(nil)
-
-func (a *adaptedBlockstore) View(cid cid.Cid, callback func([]byte) error) error {
-	blk, err := a.Get(cid)
-	if err != nil {
-		return err
-	}
-	return callback(blk.RawData())
-}
-
-func (a *adaptedBlockstore) DeleteMany(cids []cid.Cid) error {
-	for _, cid := range cids {
-		err := a.DeleteBlock(cid)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// Adapt adapts a standard blockstore to a Lotus blockstore by
-// enriching it with the extra methods that Lotus requires (e.g. View, Sync).
-//
-// View proxies over to Get and calls the callback with the value supplied by Get.
-// Sync noops.
-func Adapt(bs blockstore.Blockstore) Blockstore {
-	if ret, ok := bs.(Blockstore); ok {
-		return ret
-	}
-	return &adaptedBlockstore{bs}
-}

blockstore/buffered.go

@@ -1,174 +0,0 @@
-package blockstore
-
-import (
-	"context"
-	"os"
-
-	block "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-)
-
-// buflog is a logger for the buffered blockstore. It is subscoped from the
-// blockstore logger.
-var buflog = log.Named("buf")
-
-type BufferedBlockstore struct {
-	read  Blockstore
-	write Blockstore
-}
-
-func NewBuffered(base Blockstore) *BufferedBlockstore {
-	var buf Blockstore
-	if os.Getenv("LOTUS_DISABLE_VM_BUF") == "iknowitsabadidea" {
-		buflog.Warn("VM BLOCKSTORE BUFFERING IS DISABLED")
-		buf = base
-	} else {
-		buf = NewMemory()
-	}
-
-	bs := &BufferedBlockstore{
-		read:  base,
-		write: buf,
-	}
-	return bs
-}
-
-func NewTieredBstore(r Blockstore, w Blockstore) *BufferedBlockstore {
-	return &BufferedBlockstore{
-		read:  r,
-		write: w,
-	}
-}
-
-var (
-	_ Blockstore = (*BufferedBlockstore)(nil)
-	_ Viewer     = (*BufferedBlockstore)(nil)
-)
-
-func (bs *BufferedBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
-	a, err := bs.read.AllKeysChan(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	b, err := bs.write.AllKeysChan(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	out := make(chan cid.Cid)
-	go func() {
-		defer close(out)
-		for a != nil || b != nil {
-			select {
-			case val, ok := <-a:
-				if !ok {
-					a = nil
-				} else {
-					select {
-					case out <- val:
-					case <-ctx.Done():
-						return
-					}
-				}
-			case val, ok := <-b:
-				if !ok {
-					b = nil
-				} else {
-					select {
-					case out <- val:
-					case <-ctx.Done():
-						return
-					}
-				}
-			}
-		}
-	}()
-
-	return out, nil
-}
-
-func (bs *BufferedBlockstore) DeleteBlock(c cid.Cid) error {
-	if err := bs.read.DeleteBlock(c); err != nil {
-		return err
-	}
-
-	return bs.write.DeleteBlock(c)
-}
-
-func (bs *BufferedBlockstore) DeleteMany(cids []cid.Cid) error {
-	if err := bs.read.DeleteMany(cids); err != nil {
-		return err
-	}
-
-	return bs.write.DeleteMany(cids)
-}
-
-func (bs *BufferedBlockstore) View(c cid.Cid, callback func([]byte) error) error {
-	// both stores are viewable.
-	if err := bs.write.View(c, callback); err == ErrNotFound {
-		// not found in write blockstore; fall through.
-	} else {
-		return err // propagate errors, or nil, i.e. found.
-	}
-	return bs.read.View(c, callback)
-}
-
-func (bs *BufferedBlockstore) Get(c cid.Cid) (block.Block, error) {
-	if out, err := bs.write.Get(c); err != nil {
-		if err != ErrNotFound {
-			return nil, err
-		}
-	} else {
-		return out, nil
-	}
-
-	return bs.read.Get(c)
-}
-
-func (bs *BufferedBlockstore) GetSize(c cid.Cid) (int, error) {
-	s, err := bs.read.GetSize(c)
-	if err == ErrNotFound || s == 0 {
-		return bs.write.GetSize(c)
-	}
-
-	return s, err
-}
-
-func (bs *BufferedBlockstore) Put(blk block.Block) error {
-	has, err := bs.read.Has(blk.Cid()) // TODO: consider dropping this check
-	if err != nil {
-		return err
-	}
-
-	if has {
-		return nil
-	}
-
-	return bs.write.Put(blk)
-}
-
-func (bs *BufferedBlockstore) Has(c cid.Cid) (bool, error) {
-	has, err := bs.write.Has(c)
-	if err != nil {
-		return false, err
-	}
-	if has {
-		return true, nil
-	}
-
-	return bs.read.Has(c)
-}
-
-func (bs *BufferedBlockstore) HashOnRead(hor bool) {
-	bs.read.HashOnRead(hor)
-	bs.write.HashOnRead(hor)
-}
-
-func (bs *BufferedBlockstore) PutMany(blks []block.Block) error {
-	return bs.write.PutMany(blks)
-}
-
-func (bs *BufferedBlockstore) Read() Blockstore {
-	return bs.read
-}

blockstore/doc.go

@@ -1,9 +0,0 @@
-// Package blockstore and subpackages contain most of the blockstore
-// implementations used by Lotus.
-//
-// Blockstores not ultimately constructed out of the building blocks in this
-// package may not work properly.
-//
-// This package re-exports parts of the go-ipfs-blockstore package such that
-// no other package needs to import it directly, for ergonomics and traceability.
-package blockstore

blockstore/fallback.go

@@ -1,106 +0,0 @@
-package blockstore
-
-import (
-	"context"
-	"sync"
-	"time"
-
-	"golang.org/x/xerrors"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-)
-
-// UnwrapFallbackStore takes a blockstore, and returns the underlying blockstore
-// if it was a FallbackStore. Otherwise, it just returns the supplied store
-// unmodified.
-func UnwrapFallbackStore(bs Blockstore) (Blockstore, bool) {
-	if fbs, ok := bs.(*FallbackStore); ok {
-		return fbs.Blockstore, true
-	}
-	return bs, false
-}
-
-// FallbackStore is a read-through store that queries another (potentially
-// remote) source if the block is not found locally. If the block is found
-// during the fallback, it stores it in the local store.
-type FallbackStore struct {
-	Blockstore
-
-	lk sync.RWMutex
-	// missFn is the function that will be invoked on a local miss to pull the
-	// block from elsewhere.
-	missFn func(context.Context, cid.Cid) (blocks.Block, error)
-}
-
-var _ Blockstore = (*FallbackStore)(nil)
-
-func (fbs *FallbackStore) SetFallback(missFn func(context.Context, cid.Cid) (blocks.Block, error)) {
-	fbs.lk.Lock()
-	defer fbs.lk.Unlock()
-
-	fbs.missFn = missFn
-}
-
-func (fbs *FallbackStore) getFallback(c cid.Cid) (blocks.Block, error) {
-	log.Warnf("fallbackstore: block not found locally, fetching from the network; cid: %s", c)
-	fbs.lk.RLock()
-	defer fbs.lk.RUnlock()
-
-	if fbs.missFn == nil {
-		// FallbackStore wasn't configured yet (chainstore/bitswap aren't up yet)
-		// Wait for a bit and retry
-		fbs.lk.RUnlock()
-		time.Sleep(5 * time.Second)
-		fbs.lk.RLock()
-
-		if fbs.missFn == nil {
-			log.Errorw("fallbackstore: missFn not configured yet")
-			return nil, ErrNotFound
-		}
-	}
-
-	ctx, cancel := context.WithTimeout(context.TODO(), 120*time.Second)
-	defer cancel()
-
-	b, err := fbs.missFn(ctx, c)
-	if err != nil {
-		return nil, err
-	}
-
-	// chain bitswap puts blocks in temp blockstore which is cleaned up
-	// every few min (to drop any messages we fetched but don't want)
-	// in this case we want to keep this block around
-	if err := fbs.Put(b); err != nil {
-		return nil, xerrors.Errorf("persisting fallback-fetched block: %w", err)
-	}
-	return b, nil
-}
-
-func (fbs *FallbackStore) Get(c cid.Cid) (blocks.Block, error) {
-	b, err := fbs.Blockstore.Get(c)
-	switch err {
-	case nil:
-		return b, nil
-	case ErrNotFound:
-		return fbs.getFallback(c)
-	default:
-		return b, err
-	}
-}
-
-func (fbs *FallbackStore) GetSize(c cid.Cid) (int, error) {
-	sz, err := fbs.Blockstore.GetSize(c)
-	switch err {
-	case nil:
-		return sz, nil
-	case ErrNotFound:
-		b, err := fbs.getFallback(c)
-		if err != nil {
-			return 0, err
-		}
-		return len(b.RawData()), nil
-	default:
-		return sz, err
-	}
-}

blockstore/idstore.go

@@ -1,174 +0,0 @@
-package blockstore
-
-import (
-	"context"
-	"io"
-
-	"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)
-
-type idstore struct {
-	bs Blockstore
-}
-
-func NewIDStore(bs Blockstore) Blockstore {
-	return &idstore{bs: bs}
-}
-
-func decodeCid(cid cid.Cid) (inline bool, data []byte, err error) {
-	if cid.Prefix().MhType != mh.IDENTITY {
-		return false, nil, nil
-	}
-
-	dmh, err := mh.Decode(cid.Hash())
-	if err != nil {
-		return false, nil, err
-	}
-
-	if dmh.Code == mh.IDENTITY {
-		return true, dmh.Digest, nil
-	}
-
-	return false, nil, err
-}
-
-func (b *idstore) Has(cid cid.Cid) (bool, error) {
-	inline, _, err := decodeCid(cid)
-	if err != nil {
-		return false, xerrors.Errorf("error decoding Cid: %w", err)
-	}
-
-	if inline {
-		return true, nil
-	}
-
-	return b.bs.Has(cid)
-}
-
-func (b *idstore) Get(cid cid.Cid) (blocks.Block, error) {
-	inline, data, err := decodeCid(cid)
-	if err != nil {
-		return nil, xerrors.Errorf("error decoding Cid: %w", err)
-	}
-
-	if inline {
-		return blocks.NewBlockWithCid(data, cid)
-	}
-
-	return b.bs.Get(cid)
-}
-
-func (b *idstore) GetSize(cid cid.Cid) (int, error) {
-	inline, data, err := decodeCid(cid)
-	if err != nil {
-		return 0, xerrors.Errorf("error decoding Cid: %w", err)
-	}
-
-	if inline {
-		return len(data), err
-	}
-
-	return b.bs.GetSize(cid)
-}
-
-func (b *idstore) View(cid cid.Cid, cb func([]byte) error) error {
-	inline, data, err := decodeCid(cid)
-	if err != nil {
-		return xerrors.Errorf("error decoding Cid: %w", err)
-	}
-
-	if inline {
-		return cb(data)
-	}
-
-	return b.bs.View(cid, cb)
-}
-
-func (b *idstore) Put(blk blocks.Block) error {
-	inline, _, err := decodeCid(blk.Cid())
-	if err != nil {
-		return xerrors.Errorf("error decoding Cid: %w", err)
-	}
-
-	if inline {
-		return nil
-	}
-
-	return b.bs.Put(blk)
-}
-
-func (b *idstore) PutMany(blks []blocks.Block) error {
-	toPut := make([]blocks.Block, 0, len(blks))
-	for _, blk := range blks {
-		inline, _, err := decodeCid(blk.Cid())
-		if err != nil {
-			return xerrors.Errorf("error decoding Cid: %w", err)
-		}
-
-		if inline {
-			continue
-		}
-		toPut = append(toPut, blk)
-	}
-
-	if len(toPut) > 0 {
-		return b.bs.PutMany(toPut)
-	}
-
-	return nil
-}
-
-func (b *idstore) DeleteBlock(cid cid.Cid) error {
-	inline, _, err := decodeCid(cid)
-	if err != nil {
-		return xerrors.Errorf("error decoding Cid: %w", err)
-	}
-
-	if inline {
-		return nil
-	}
-
-	return b.bs.DeleteBlock(cid)
-}
-
-func (b *idstore) DeleteMany(cids []cid.Cid) error {
-	toDelete := make([]cid.Cid, 0, len(cids))
-	for _, cid := range cids {
-		inline, _, err := decodeCid(cid)
-		if err != nil {
-			return xerrors.Errorf("error decoding Cid: %w", err)
-		}
-
-		if inline {
-			continue
-		}
-		toDelete = append(toDelete, cid)
-	}
-
-	if len(toDelete) > 0 {
-		return b.bs.DeleteMany(toDelete)
-	}
-
-	return nil
-}
-
-func (b *idstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
-	return b.bs.AllKeysChan(ctx)
-}
-
-func (b *idstore) HashOnRead(enabled bool) {
-	b.bs.HashOnRead(enabled)
-}
-
-func (b *idstore) Close() error {
-	if c, ok := b.bs.(io.Closer); ok {
-		return c.Close()
-	}
-	return nil
-}

blockstore/mem.go

@@ -1,102 +0,0 @@
-package blockstore
-
-import (
-	"context"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-)
-
-// NewMemory returns a temporary memory-backed blockstore.
-func NewMemory() MemBlockstore {
-	return make(MemBlockstore)
-}
-
-// MemBlockstore is a terminal blockstore that keeps blocks in memory.
-type MemBlockstore map[cid.Cid]blocks.Block
-
-func (m MemBlockstore) DeleteBlock(k cid.Cid) error {
-	delete(m, k)
-	return nil
-}
-
-func (m MemBlockstore) DeleteMany(ks []cid.Cid) error {
-	for _, k := range ks {
-		delete(m, k)
-	}
-	return nil
-}
-
-func (m MemBlockstore) Has(k cid.Cid) (bool, error) {
-	_, ok := m[k]
-	return ok, nil
-}
-
-func (m MemBlockstore) View(k cid.Cid, callback func([]byte) error) error {
-	b, ok := m[k]
-	if !ok {
-		return ErrNotFound
-	}
-	return callback(b.RawData())
-}
-
-func (m MemBlockstore) Get(k cid.Cid) (blocks.Block, error) {
-	b, ok := m[k]
-	if !ok {
-		return nil, ErrNotFound
-	}
-	return b, nil
-}
-
-// GetSize returns the CIDs mapped BlockSize
-func (m MemBlockstore) GetSize(k cid.Cid) (int, error) {
-	b, ok := m[k]
-	if !ok {
-		return 0, ErrNotFound
-	}
-	return len(b.RawData()), nil
-}
-
-// Put puts a given block to the underlying datastore
-func (m MemBlockstore) Put(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 := b.Cid()
-	if _, ok := b.(*blocks.BasicBlock); !ok {
-		// If we already have the block, abort.
-		if _, ok := m[k]; ok {
-			return nil
-		}
-		// the error is only for debugging.
-		b, _ = blocks.NewBlockWithCid(b.RawData(), b.Cid())
-	}
-	m[b.Cid()] = b
-	return nil
-}
-
-// PutMany puts a slice of blocks at the same time using batching
-// capabilities of the underlying datastore whenever possible.
-func (m MemBlockstore) PutMany(bs []blocks.Block) error {
-	for _, b := range bs {
-		_ = m.Put(b) // can't fail
-	}
-	return nil
-}
-
-// AllKeysChan returns a channel from which
-// the CIDs in the Blockstore can be read. It should respect
-// 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 k := range m {
-		ch <- k
-	}
-	close(ch)
-	return ch, nil
-}
-
-// HashOnRead specifies if every read block should be
-// rehashed to make sure it matches its CID.
-func (m MemBlockstore) HashOnRead(enabled bool) {
-	// no-op
-}

blockstore/metrics.go

@@ -1,154 +0,0 @@
-package blockstore
-
-import (
-	"time"
-
-	"go.opencensus.io/stats"
-	"go.opencensus.io/stats/view"
-	"go.opencensus.io/tag"
-)
-
-//
-// Currently unused, but kept in repo in case we introduce one of the candidate
-// cache implementations (Freecache, Ristretto), both of which report these
-// metrics.
-//
-
-// CacheMetricsEmitInterval is the interval at which metrics are emitted onto
-// OpenCensus.
-var CacheMetricsEmitInterval = 5 * time.Second
-
-var (
-	CacheName, _ = tag.NewKey("cache_name")
-)
-
-// CacheMeasures groups all metrics emitted by the blockstore caches.
-var CacheMeasures = struct {
-	HitRatio       *stats.Float64Measure
-	Hits           *stats.Int64Measure
-	Misses         *stats.Int64Measure
-	Entries        *stats.Int64Measure
-	QueriesServed  *stats.Int64Measure
-	Adds           *stats.Int64Measure
-	Updates        *stats.Int64Measure
-	Evictions      *stats.Int64Measure
-	CostAdded      *stats.Int64Measure
-	CostEvicted    *stats.Int64Measure
-	SetsDropped    *stats.Int64Measure
-	SetsRejected   *stats.Int64Measure
-	QueriesDropped *stats.Int64Measure
-}{
-	HitRatio:       stats.Float64("blockstore/cache/hit_ratio", "Hit ratio of blockstore cache", stats.UnitDimensionless),
-	Hits:           stats.Int64("blockstore/cache/hits", "Total number of hits at blockstore cache", stats.UnitDimensionless),
-	Misses:         stats.Int64("blockstore/cache/misses", "Total number of misses at blockstore cache", stats.UnitDimensionless),
-	Entries:        stats.Int64("blockstore/cache/entry_count", "Total number of entries currently in the blockstore cache", stats.UnitDimensionless),
-	QueriesServed:  stats.Int64("blockstore/cache/queries_served", "Total number of queries served by the blockstore cache", stats.UnitDimensionless),
-	Adds:           stats.Int64("blockstore/cache/adds", "Total number of adds to blockstore cache", stats.UnitDimensionless),
-	Updates:        stats.Int64("blockstore/cache/updates", "Total number of updates in blockstore cache", stats.UnitDimensionless),
-	Evictions:      stats.Int64("blockstore/cache/evictions", "Total number of evictions from blockstore cache", stats.UnitDimensionless),
-	CostAdded:      stats.Int64("blockstore/cache/cost_added", "Total cost (byte size) of entries added into blockstore cache", stats.UnitBytes),
-	CostEvicted:    stats.Int64("blockstore/cache/cost_evicted", "Total cost (byte size) of entries evicted by blockstore cache", stats.UnitBytes),
-	SetsDropped:    stats.Int64("blockstore/cache/sets_dropped", "Total number of sets dropped by blockstore cache", stats.UnitDimensionless),
-	SetsRejected:   stats.Int64("blockstore/cache/sets_rejected", "Total number of sets rejected by blockstore cache", stats.UnitDimensionless),
-	QueriesDropped: stats.Int64("blockstore/cache/queries_dropped", "Total number of queries dropped by blockstore cache", stats.UnitDimensionless),
-}
-
-// CacheViews groups all cache-related default views.
-var CacheViews = struct {
-	HitRatio       *view.View
-	Hits           *view.View
-	Misses         *view.View
-	Entries        *view.View
-	QueriesServed  *view.View
-	Adds           *view.View
-	Updates        *view.View
-	Evictions      *view.View
-	CostAdded      *view.View
-	CostEvicted    *view.View
-	SetsDropped    *view.View
-	SetsRejected   *view.View
-	QueriesDropped *view.View
-}{
-	HitRatio: &view.View{
-		Measure:     CacheMeasures.HitRatio,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-	Hits: &view.View{
-		Measure:     CacheMeasures.Hits,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-	Misses: &view.View{
-		Measure:     CacheMeasures.Misses,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-	Entries: &view.View{
-		Measure:     CacheMeasures.Entries,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-	QueriesServed: &view.View{
-		Measure:     CacheMeasures.QueriesServed,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-	Adds: &view.View{
-		Measure:     CacheMeasures.Adds,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-	Updates: &view.View{
-		Measure:     CacheMeasures.Updates,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-	Evictions: &view.View{
-		Measure:     CacheMeasures.Evictions,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-	CostAdded: &view.View{
-		Measure:     CacheMeasures.CostAdded,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-	CostEvicted: &view.View{
-		Measure:     CacheMeasures.CostEvicted,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-	SetsDropped: &view.View{
-		Measure:     CacheMeasures.SetsDropped,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-	SetsRejected: &view.View{
-		Measure:     CacheMeasures.SetsRejected,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-	QueriesDropped: &view.View{
-		Measure:     CacheMeasures.QueriesDropped,
-		Aggregation: view.LastValue(),
-		TagKeys:     []tag.Key{CacheName},
-	},
-}
-
-// DefaultViews exports all default views for this package.
-var DefaultViews = []*view.View{
-	CacheViews.HitRatio,
-	CacheViews.Hits,
-	CacheViews.Misses,
-	CacheViews.Entries,
-	CacheViews.QueriesServed,
-	CacheViews.Adds,
-	CacheViews.Updates,
-	CacheViews.Evictions,
-	CacheViews.CostAdded,
-	CacheViews.CostEvicted,
-	CacheViews.SetsDropped,
-	CacheViews.SetsRejected,
-	CacheViews.QueriesDropped,
-}

blockstore/splitstore/markset.go

@@ -1,38 +0,0 @@
-package splitstore
-
-import (
-	"path/filepath"
-
-	"golang.org/x/xerrors"
-
-	cid "github.com/ipfs/go-cid"
-)
-
-// MarkSet is a utility to keep track of seen CID, and later query for them.
-//
-// * If the expected dataset is large, it can be backed by a datastore (e.g. bbolt).
-// * If a probabilistic result is acceptable, it can be backed by a bloom filter (default).
-type MarkSet interface {
-	Mark(cid.Cid) error
-	Has(cid.Cid) (bool, error)
-	Close() error
-}
-
-// markBytes is deliberately a non-nil empty byte slice for serialization.
-var markBytes = []byte{}
-
-type MarkSetEnv interface {
-	Create(name string, sizeHint int64) (MarkSet, error)
-	Close() error
-}
-
-func OpenMarkSetEnv(path string, mtype string) (MarkSetEnv, error) {
-	switch mtype {
-	case "", "bloom":
-		return NewBloomMarkSetEnv()
-	case "bolt":
-		return NewBoltMarkSetEnv(filepath.Join(path, "markset.bolt"))
-	default:
-		return nil, xerrors.Errorf("unknown mark set type %s", mtype)
-	}
-}

blockstore/splitstore/markset_bloom.go

@@ -1,77 +0,0 @@
-package splitstore
-
-import (
-	"crypto/rand"
-	"crypto/sha256"
-
-	"golang.org/x/xerrors"
-
-	bbloom "github.com/ipfs/bbloom"
-	cid "github.com/ipfs/go-cid"
-)
-
-const (
-	BloomFilterMinSize     = 10_000_000
-	BloomFilterProbability = 0.01
-)
-
-type BloomMarkSetEnv struct{}
-
-var _ MarkSetEnv = (*BloomMarkSetEnv)(nil)
-
-type BloomMarkSet struct {
-	salt []byte
-	bf   *bbloom.Bloom
-}
-
-var _ MarkSet = (*BloomMarkSet)(nil)
-
-func NewBloomMarkSetEnv() (*BloomMarkSetEnv, error) {
-	return &BloomMarkSetEnv{}, nil
-}
-
-func (e *BloomMarkSetEnv) Create(name string, sizeHint int64) (MarkSet, error) {
-	size := int64(BloomFilterMinSize)
-	for size < sizeHint {
-		size += BloomFilterMinSize
-	}
-
-	salt := make([]byte, 4)
-	_, err := rand.Read(salt)
-	if err != nil {
-		return nil, xerrors.Errorf("error reading salt: %w", err)
-	}
-
-	bf, err := bbloom.New(float64(size), BloomFilterProbability)
-	if err != nil {
-		return nil, xerrors.Errorf("error creating bloom filter: %w", err)
-	}
-
-	return &BloomMarkSet{salt: salt, bf: bf}, nil
-}
-
-func (e *BloomMarkSetEnv) Close() error {
-	return nil
-}
-
-func (s *BloomMarkSet) saltedKey(cid cid.Cid) []byte {
-	hash := cid.Hash()
-	key := make([]byte, len(s.salt)+len(hash))
-	n := copy(key, s.salt)
-	copy(key[n:], hash)
-	rehash := sha256.Sum256(key)
-	return rehash[:]
-}
-
-func (s *BloomMarkSet) Mark(cid cid.Cid) error {
-	s.bf.Add(s.saltedKey(cid))
-	return nil
-}
-
-func (s *BloomMarkSet) Has(cid cid.Cid) (bool, error) {
-	return s.bf.Has(s.saltedKey(cid)), nil
-}
-
-func (s *BloomMarkSet) Close() error {
-	return nil
-}

blockstore/splitstore/markset_bolt.go

@@ -1,81 +0,0 @@
-package splitstore
-
-import (
-	"time"
-
-	"golang.org/x/xerrors"
-
-	cid "github.com/ipfs/go-cid"
-	bolt "go.etcd.io/bbolt"
-)
-
-type BoltMarkSetEnv struct {
-	db *bolt.DB
-}
-
-var _ MarkSetEnv = (*BoltMarkSetEnv)(nil)
-
-type BoltMarkSet struct {
-	db       *bolt.DB
-	bucketId []byte
-}
-
-var _ MarkSet = (*BoltMarkSet)(nil)
-
-func NewBoltMarkSetEnv(path string) (*BoltMarkSetEnv, error) {
-	db, err := bolt.Open(path, 0644,
-		&bolt.Options{
-			Timeout: 1 * time.Second,
-			NoSync:  true,
-		})
-	if err != nil {
-		return nil, err
-	}
-
-	return &BoltMarkSetEnv{db: db}, nil
-}
-
-func (e *BoltMarkSetEnv) Create(name string, hint int64) (MarkSet, error) {
-	bucketId := []byte(name)
-	err := e.db.Update(func(tx *bolt.Tx) error {
-		_, err := tx.CreateBucketIfNotExists(bucketId)
-		if err != nil {
-			return xerrors.Errorf("error creating bolt db bucket %s: %w", name, err)
-		}
-		return nil
-	})
-
-	if err != nil {
-		return nil, err
-	}
-
-	return &BoltMarkSet{db: e.db, bucketId: bucketId}, nil
-}
-
-func (e *BoltMarkSetEnv) Close() error {
-	return e.db.Close()
-}
-
-func (s *BoltMarkSet) Mark(cid cid.Cid) error {
-	return s.db.Update(func(tx *bolt.Tx) error {
-		b := tx.Bucket(s.bucketId)
-		return b.Put(cid.Hash(), markBytes)
-	})
-}
-
-func (s *BoltMarkSet) Has(cid cid.Cid) (result bool, err error) {
-	err = s.db.View(func(tx *bolt.Tx) error {
-		b := tx.Bucket(s.bucketId)
-		v := b.Get(cid.Hash())
-		result = v != nil
-		return nil
-	})
-
-	return result, err
-}
-
-func (s *BoltMarkSet) Close() error {
-	return s.db.Update(func(tx *bolt.Tx) error {
-		return tx.DeleteBucket(s.bucketId)
-	})
-}

blockstore/splitstore/markset_test.go

@@ -1,138 +0,0 @@
-package splitstore
-
-import (
-	"io/ioutil"
-	"testing"
-
-	cid "github.com/ipfs/go-cid"
-	"github.com/multiformats/go-multihash"
-)
-
-func TestBoltMarkSet(t *testing.T) {
-	testMarkSet(t, "bolt")
-}
-
-func TestBloomMarkSet(t *testing.T) {
-	testMarkSet(t, "bloom")
-}
-
-func testMarkSet(t *testing.T, lsType string) {
-	t.Helper()
-
-	path, err := ioutil.TempDir("", "sweep-test.*")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	env, err := OpenMarkSetEnv(path, lsType)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer env.Close() //nolint:errcheck
-
-	hotSet, err := env.Create("hot", 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	coldSet, err := env.Create("cold", 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	makeCid := func(key string) cid.Cid {
-		h, err := multihash.Sum([]byte(key), multihash.SHA2_256, -1)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		return cid.NewCidV1(cid.Raw, h)
-	}
-
-	mustHave := func(s MarkSet, cid cid.Cid) {
-		has, err := s.Has(cid)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if !has {
-			t.Fatal("mark not found")
-		}
-	}
-
-	mustNotHave := func(s MarkSet, cid cid.Cid) {
-		has, err := s.Has(cid)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if has {
-			t.Fatal("unexpected mark")
-		}
-	}
-
-	k1 := makeCid("a")
-	k2 := makeCid("b")
-	k3 := makeCid("c")
-	k4 := makeCid("d")
-
-	hotSet.Mark(k1)  //nolint
-	hotSet.Mark(k2)  //nolint
-	coldSet.Mark(k3) //nolint
-
-	mustHave(hotSet, k1)
-	mustHave(hotSet, k2)
-	mustNotHave(hotSet, k3)
-	mustNotHave(hotSet, k4)
-
-	mustNotHave(coldSet, k1)
-	mustNotHave(coldSet, k2)
-	mustHave(coldSet, k3)
-	mustNotHave(coldSet, k4)
-
-	// close them and reopen to redo the dance
-
-	err = hotSet.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = coldSet.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	hotSet, err = env.Create("hot", 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	coldSet, err = env.Create("cold", 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	hotSet.Mark(k3)  //nolint
-	hotSet.Mark(k4)  //nolint
-	coldSet.Mark(k1) //nolint
-
-	mustNotHave(hotSet, k1)
-	mustNotHave(hotSet, k2)
-	mustHave(hotSet, k3)
-	mustHave(hotSet, k4)
-
-	mustHave(coldSet, k1)
-	mustNotHave(coldSet, k2)
-	mustNotHave(coldSet, k3)
-	mustNotHave(coldSet, k4)
-
-	err = hotSet.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = coldSet.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-}

blockstore/splitstore/splitstore_test.go

@@ -1,255 +0,0 @@
-package splitstore
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/blockstore"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/types/mock"
-
-	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"
-)
-
-func init() {
-	CompactionThreshold = 5
-	CompactionCold = 1
-	CompactionBoundary = 2
-	logging.SetLogLevel("splitstore", "DEBUG")
-}
-
-func testSplitStore(t *testing.T, cfg *Config) {
-	chain := &mockChain{}
-	// genesis
-	genBlock := mock.MkBlock(nil, 0, 0)
-	genTs := mock.TipSet(genBlock)
-	chain.push(genTs)
-
-	// the myriads of stores
-	ds := dssync.MutexWrap(datastore.NewMapDatastore())
-	hot := blockstore.NewMemorySync()
-	cold := blockstore.NewMemorySync()
-
-	// put the genesis block to cold store
-	blk, err := genBlock.ToStorageBlock()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = cold.Put(blk)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// open the splitstore
-	ss, err := Open("", ds, hot, cold, cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer ss.Close() //nolint
-
-	err = ss.Start(chain)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// make some tipsets, but not enough to cause compaction
-	mkBlock := func(curTs *types.TipSet, i int) *types.TipSet {
-		blk := mock.MkBlock(curTs, uint64(i), uint64(i))
-		sblk, err := blk.ToStorageBlock()
-		if err != nil {
-			t.Fatal(err)
-		}
-		err = ss.Put(sblk)
-		if err != nil {
-			t.Fatal(err)
-		}
-		ts := mock.TipSet(blk)
-		chain.push(ts)
-
-		return ts
-	}
-
-	mkGarbageBlock := func(curTs *types.TipSet, i int) {
-		blk := mock.MkBlock(curTs, uint64(i), uint64(i))
-		sblk, err := blk.ToStorageBlock()
-		if err != nil {
-			t.Fatal(err)
-		}
-		err = ss.Put(sblk)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	waitForCompaction := func() {
-		for atomic.LoadInt32(&ss.compacting) == 1 {
-			time.Sleep(100 * time.Millisecond)
-		}
-	}
-
-	curTs := genTs
-	for i := 1; i < 5; i++ {
-		curTs = mkBlock(curTs, i)
-		waitForCompaction()
-	}
-
-	mkGarbageBlock(genTs, 1)
-
-	// count objects in the cold and hot stores
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	countBlocks := func(bs blockstore.Blockstore) int {
-		count := 0
-		ch, err := bs.AllKeysChan(ctx)
-		if err != nil {
-			t.Fatal(err)
-		}
-		for range ch {
-			count++
-		}
-		return count
-	}
-
-	coldCnt := countBlocks(cold)
-	hotCnt := countBlocks(hot)
-
-	if coldCnt != 1 {
-		t.Errorf("expected %d blocks, but got %d", 1, coldCnt)
-	}
-
-	if hotCnt != 5 {
-		t.Errorf("expected %d blocks, but got %d", 5, hotCnt)
-	}
-
-	// trigger a compaction
-	for i := 5; i < 10; i++ {
-		curTs = mkBlock(curTs, i)
-		waitForCompaction()
-	}
-
-	coldCnt = countBlocks(cold)
-	hotCnt = countBlocks(hot)
-
-	if !cfg.EnableFullCompaction {
-		if coldCnt != 5 {
-			t.Errorf("expected %d cold blocks, but got %d", 5, coldCnt)
-		}
-
-		if hotCnt != 5 {
-			t.Errorf("expected %d hot blocks, but got %d", 5, hotCnt)
-		}
-	}
-
-	if cfg.EnableFullCompaction && !cfg.EnableGC {
-		if coldCnt != 3 {
-			t.Errorf("expected %d cold blocks, but got %d", 3, coldCnt)
-		}
-
-		if hotCnt != 7 {
-			t.Errorf("expected %d hot blocks, but got %d", 7, hotCnt)
-		}
-	}
-
-	if cfg.EnableFullCompaction && cfg.EnableGC {
-		if coldCnt != 2 {
-			t.Errorf("expected %d cold blocks, but got %d", 2, coldCnt)
-		}
-
-		if hotCnt != 7 {
-			t.Errorf("expected %d hot blocks, but got %d", 7, hotCnt)
-		}
-	}
-}
-
-func TestSplitStoreSimpleCompaction(t *testing.T) {
-	testSplitStore(t, &Config{TrackingStoreType: "mem"})
-}
-
-func TestSplitStoreFullCompactionWithoutGC(t *testing.T) {
-	testSplitStore(t, &Config{
-		TrackingStoreType:    "mem",
-		EnableFullCompaction: true,
-	})
-}
-
-func TestSplitStoreFullCompactionWithGC(t *testing.T) {
-	testSplitStore(t, &Config{
-		TrackingStoreType:    "mem",
-		EnableFullCompaction: true,
-		EnableGC:             true,
-	})
-}
-
-type mockChain struct {
-	sync.Mutex
-	tipsets  []*types.TipSet
-	listener func(revert []*types.TipSet, apply []*types.TipSet) error
-}
-
-func (c *mockChain) push(ts *types.TipSet) {
-	c.Lock()
-	c.tipsets = append(c.tipsets, ts)
-	c.Unlock()
-
-	if c.listener != nil {
-		err := c.listener(nil, []*types.TipSet{ts})
-		if err != nil {
-			log.Errorf("mockchain: error dispatching listener: %s", err)
-		}
-	}
-}
-
-func (c *mockChain) GetTipsetByHeight(_ context.Context, epoch abi.ChainEpoch, _ *types.TipSet, _ bool) (*types.TipSet, error) {
-	c.Lock()
-	defer c.Unlock()
-
-	iEpoch := int(epoch)
-	if iEpoch > len(c.tipsets) {
-		return nil, fmt.Errorf("bad epoch %d", epoch)
-	}
-
-	return c.tipsets[iEpoch-1], nil
-}
-
-func (c *mockChain) GetHeaviestTipSet() *types.TipSet {
-	c.Lock()
-	defer c.Unlock()
-
-	return c.tipsets[len(c.tipsets)-1]
-}
-
-func (c *mockChain) SubscribeHeadChanges(change func(revert []*types.TipSet, apply []*types.TipSet) error) {
-	c.listener = change
-}
-
-func (c *mockChain) WalkSnapshot(_ context.Context, ts *types.TipSet, epochs abi.ChainEpoch, _ bool, _ bool, f func(cid.Cid) error) error {
-	c.Lock()
-	defer c.Unlock()
-
-	start := int(ts.Height()) - 1
-	end := start - int(epochs)
-	if end < 0 {
-		end = -1
-	}
-	for i := start; i > end; i-- {
-		ts := c.tipsets[i]
-		for _, cid := range ts.Cids() {
-			err := f(cid)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}

blockstore/splitstore/tracking.go

@@ -1,109 +0,0 @@
-package splitstore
-
-import (
-	"path/filepath"
-	"sync"
-
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	cid "github.com/ipfs/go-cid"
-)
-
-// TrackingStore is a persistent store that tracks blocks that are added
-// to the hotstore, tracking the epoch at which they are written.
-type TrackingStore interface {
-	Put(cid.Cid, abi.ChainEpoch) error
-	PutBatch([]cid.Cid, abi.ChainEpoch) error
-	Get(cid.Cid) (abi.ChainEpoch, error)
-	Delete(cid.Cid) error
-	DeleteBatch([]cid.Cid) error
-	ForEach(func(cid.Cid, abi.ChainEpoch) error) error
-	Sync() error
-	Close() error
-}
-
-// OpenTrackingStore opens a tracking store of the specified type in the
-// specified path.
-func OpenTrackingStore(path string, ttype string) (TrackingStore, error) {
-	switch ttype {
-	case "", "bolt":
-		return OpenBoltTrackingStore(filepath.Join(path, "tracker.bolt"))
-	case "mem":
-		return NewMemTrackingStore(), nil
-	default:
-		return nil, xerrors.Errorf("unknown tracking store type %s", ttype)
-	}
-}
-
-// NewMemTrackingStore creates an in-memory tracking store.
-// This is only useful for test or situations where you don't want to open the
-// real tracking store (eg concurrent read only access on a node's datastore)
-func NewMemTrackingStore() *MemTrackingStore {
-	return &MemTrackingStore{tab: make(map[cid.Cid]abi.ChainEpoch)}
-}
-
-// MemTrackingStore is a simple in-memory tracking store
-type MemTrackingStore struct {
-	sync.Mutex
-	tab map[cid.Cid]abi.ChainEpoch
-}
-
-var _ TrackingStore = (*MemTrackingStore)(nil)
-
-func (s *MemTrackingStore) Put(cid cid.Cid, epoch abi.ChainEpoch) error {
-	s.Lock()
-	defer s.Unlock()
-	s.tab[cid] = epoch
-	return nil
-}
-
-func (s *MemTrackingStore) PutBatch(cids []cid.Cid, epoch abi.ChainEpoch) error {
-	s.Lock()
-	defer s.Unlock()
-	for _, cid := range cids {
-		s.tab[cid] = epoch
-	}
-	return nil
-}
-
-func (s *MemTrackingStore) Get(cid cid.Cid) (abi.ChainEpoch, error) {
-	s.Lock()
-	defer s.Unlock()
-	epoch, ok := s.tab[cid]
-	if ok {
-		return epoch, nil
-	}
-	return 0, xerrors.Errorf("missing tracking epoch for %s", cid)
-}
-
-func (s *MemTrackingStore) Delete(cid cid.Cid) error {
-	s.Lock()
-	defer s.Unlock()
-	delete(s.tab, cid)
-	return nil
-}
-
-func (s *MemTrackingStore) DeleteBatch(cids []cid.Cid) error {
-	s.Lock()
-	defer s.Unlock()
-	for _, cid := range cids {
-		delete(s.tab, cid)
-	}
-	return nil
-}
-
-func (s *MemTrackingStore) ForEach(f func(cid.Cid, abi.ChainEpoch) error) error {
-	s.Lock()
-	defer s.Unlock()
-	for cid, epoch := range s.tab {
-		err := f(cid, epoch)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (s *MemTrackingStore) Sync() error  { return nil }
-func (s *MemTrackingStore) Close() error { return nil }

blockstore/splitstore/tracking_bolt.go

@@ -1,120 +0,0 @@
-package splitstore
-
-import (
-	"time"
-
-	"golang.org/x/xerrors"
-
-	cid "github.com/ipfs/go-cid"
-	bolt "go.etcd.io/bbolt"
-
-	"github.com/filecoin-project/go-state-types/abi"
-)
-
-type BoltTrackingStore struct {
-	db       *bolt.DB
-	bucketId []byte
-}
-
-var _ TrackingStore = (*BoltTrackingStore)(nil)
-
-func OpenBoltTrackingStore(path string) (*BoltTrackingStore, error) {
-	opts := &bolt.Options{
-		Timeout: 1 * time.Second,
-		NoSync:  true,
-	}
-	db, err := bolt.Open(path, 0644, opts)
-	if err != nil {
-		return nil, err
-	}
-
-	bucketId := []byte("tracker")
-	err = db.Update(func(tx *bolt.Tx) error {
-		_, err := tx.CreateBucketIfNotExists(bucketId)
-		if err != nil {
-			return xerrors.Errorf("error creating bolt db bucket %s: %w", string(bucketId), err)
-		}
-		return nil
-	})
-
-	if err != nil {
-		_ = db.Close()
-		return nil, err
-	}
-
-	return &BoltTrackingStore{db: db, bucketId: bucketId}, nil
-}
-
-func (s *BoltTrackingStore) Put(cid cid.Cid, epoch abi.ChainEpoch) error {
-	val := epochToBytes(epoch)
-	return s.db.Batch(func(tx *bolt.Tx) error {
-		b := tx.Bucket(s.bucketId)
-		return b.Put(cid.Hash(), val)
-	})
-}
-
-func (s *BoltTrackingStore) PutBatch(cids []cid.Cid, epoch abi.ChainEpoch) error {
-	val := epochToBytes(epoch)
-	return s.db.Batch(func(tx *bolt.Tx) error {
-		b := tx.Bucket(s.bucketId)
-		for _, cid := range cids {
-			err := b.Put(cid.Hash(), val)
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-}
-
-func (s *BoltTrackingStore) Get(cid cid.Cid) (epoch abi.ChainEpoch, err error) {
-	err = s.db.View(func(tx *bolt.Tx) error {
-		b := tx.Bucket(s.bucketId)
-		val := b.Get(cid.Hash())
-		if val == nil {
-			return xerrors.Errorf("missing tracking epoch for %s", cid)
-		}
-		epoch = bytesToEpoch(val)
-		return nil
-	})
-	return epoch, err
-}
-
-func (s *BoltTrackingStore) Delete(cid cid.Cid) error {
-	return s.db.Batch(func(tx *bolt.Tx) error {
-		b := tx.Bucket(s.bucketId)
-		return b.Delete(cid.Hash())
-	})
-}
-
-func (s *BoltTrackingStore) DeleteBatch(cids []cid.Cid) error {
-	return s.db.Batch(func(tx *bolt.Tx) error {
-		b := tx.Bucket(s.bucketId)
-		for _, cid := range cids {
-			err := b.Delete(cid.Hash())
-			if err != nil {
-				return xerrors.Errorf("error deleting %s", cid)
-			}
-		}
-		return nil
-	})
-}
-
-func (s *BoltTrackingStore) ForEach(f func(cid.Cid, abi.ChainEpoch) error) error {
-	return s.db.View(func(tx *bolt.Tx) error {
-		b := tx.Bucket(s.bucketId)
-		return b.ForEach(func(k, v []byte) error {
-			cid := cid.NewCidV1(cid.Raw, k)
-			epoch := bytesToEpoch(v)
-			return f(cid, epoch)
-		})
-	})
-}
-
-func (s *BoltTrackingStore) Sync() error {
-	return s.db.Sync()
-}
-
-func (s *BoltTrackingStore) Close() error {
-	return s.db.Close()
-}

blockstore/splitstore/tracking_test.go

@@ -1,130 +0,0 @@
-package splitstore
-
-import (
-	"io/ioutil"
-	"testing"
-
-	cid "github.com/ipfs/go-cid"
-	"github.com/multiformats/go-multihash"
-
-	"github.com/filecoin-project/go-state-types/abi"
-)
-
-func TestBoltTrackingStore(t *testing.T) {
-	testTrackingStore(t, "bolt")
-}
-
-func testTrackingStore(t *testing.T, tsType string) {
-	t.Helper()
-
-	makeCid := func(key string) cid.Cid {
-		h, err := multihash.Sum([]byte(key), multihash.SHA2_256, -1)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		return cid.NewCidV1(cid.Raw, h)
-	}
-
-	mustHave := func(s TrackingStore, cid cid.Cid, epoch abi.ChainEpoch) {
-		val, err := s.Get(cid)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if val != epoch {
-			t.Fatal("epoch mismatch")
-		}
-	}
-
-	mustNotHave := func(s TrackingStore, cid cid.Cid) {
-		_, err := s.Get(cid)
-		if err == nil {
-			t.Fatal("expected error")
-		}
-	}
-
-	path, err := ioutil.TempDir("", "snoop-test.*")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	s, err := OpenTrackingStore(path, tsType)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	k1 := makeCid("a")
-	k2 := makeCid("b")
-	k3 := makeCid("c")
-	k4 := makeCid("d")
-
-	s.Put(k1, 1) //nolint
-	s.Put(k2, 2) //nolint
-	s.Put(k3, 3) //nolint
-	s.Put(k4, 4) //nolint
-
-	mustHave(s, k1, 1)
-	mustHave(s, k2, 2)
-	mustHave(s, k3, 3)
-	mustHave(s, k4, 4)
-
-	s.Delete(k1) // nolint
-	s.Delete(k2) // nolint
-
-	mustNotHave(s, k1)
-	mustNotHave(s, k2)
-	mustHave(s, k3, 3)
-	mustHave(s, k4, 4)
-
-	s.PutBatch([]cid.Cid{k1}, 1) //nolint
-	s.PutBatch([]cid.Cid{k2}, 2) //nolint
-
-	mustHave(s, k1, 1)
-	mustHave(s, k2, 2)
-	mustHave(s, k3, 3)
-	mustHave(s, k4, 4)
-
-	allKeys := map[string]struct{}{
-		k1.String(): {},
-		k2.String(): {},
-		k3.String(): {},
-		k4.String(): {},
-	}
-
-	err = s.ForEach(func(k cid.Cid, _ abi.ChainEpoch) error {
-		_, ok := allKeys[k.String()]
-		if !ok {
-			t.Fatal("unexpected key")
-		}
-
-		delete(allKeys, k.String())
-		return nil
-	})
-
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(allKeys) != 0 {
-		t.Fatal("not all keys were returned")
-	}
-
-	// no close and reopen and ensure the keys still exist
-	err = s.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	s, err = OpenTrackingStore(path, tsType)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	mustHave(s, k1, 1)
-	mustHave(s, k2, 2)
-	mustHave(s, k3, 3)
-	mustHave(s, k4, 4)
-
-	s.Close() //nolint:errcheck
-}

blockstore/sync.go

@@ -1,81 +0,0 @@
-package blockstore
-
-import (
-	"context"
-	"sync"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-)
-
-// NewMemorySync returns a thread-safe in-memory blockstore.
-func NewMemorySync() *SyncBlockstore {
-	return &SyncBlockstore{bs: make(MemBlockstore)}
-}
-
-// SyncBlockstore is a terminal blockstore that is a synchronized version
-// of MemBlockstore.
-type SyncBlockstore struct {
-	mu sync.RWMutex
-	bs MemBlockstore // specifically use a memStore to save indirection overhead.
-}
-
-func (m *SyncBlockstore) DeleteBlock(k cid.Cid) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	return m.bs.DeleteBlock(k)
-}
-
-func (m *SyncBlockstore) DeleteMany(ks []cid.Cid) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	return m.bs.DeleteMany(ks)
-}
-
-func (m *SyncBlockstore) Has(k cid.Cid) (bool, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.bs.Has(k)
-}
-
-func (m *SyncBlockstore) View(k cid.Cid, callback func([]byte) error) error {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	return m.bs.View(k, callback)
-}
-
-func (m *SyncBlockstore) Get(k cid.Cid) (blocks.Block, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.bs.Get(k)
-}
-
-func (m *SyncBlockstore) GetSize(k cid.Cid) (int, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.bs.GetSize(k)
-}
-
-func (m *SyncBlockstore) Put(b blocks.Block) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	return m.bs.Put(b)
-}
-
-func (m *SyncBlockstore) PutMany(bs []blocks.Block) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	return m.bs.PutMany(bs)
-}
-
-func (m *SyncBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	// this blockstore implementation doesn't do any async work.
-	return m.bs.AllKeysChan(ctx)
-}
-
-func (m *SyncBlockstore) HashOnRead(enabled bool) {
-	// noop
-}

blockstore/timed.go

@@ -1,185 +0,0 @@
-package blockstore
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	"github.com/raulk/clock"
-	"go.uber.org/multierr"
-)
-
-// TimedCacheBlockstore is a blockstore that keeps blocks for at least the
-// specified caching interval before discarding them. Garbage collection must
-// be started and stopped by calling Start/Stop.
-//
-// Under the covers, it's implemented with an active and an inactive blockstore
-// that are rotated every cache time interval. This means all blocks will be
-// stored at most 2x the cache interval.
-//
-// Create a new instance by calling the NewTimedCacheBlockstore constructor.
-type TimedCacheBlockstore struct {
-	mu               sync.RWMutex
-	active, inactive MemBlockstore
-	clock            clock.Clock
-	interval         time.Duration
-	closeCh          chan struct{}
-	doneRotatingCh   chan struct{}
-}
-
-func NewTimedCacheBlockstore(interval time.Duration) *TimedCacheBlockstore {
-	b := &TimedCacheBlockstore{
-		active:   NewMemory(),
-		inactive: NewMemory(),
-		interval: interval,
-		clock:    clock.New(),
-	}
-	return b
-}
-
-func (t *TimedCacheBlockstore) Start(_ context.Context) error {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	if t.closeCh != nil {
-		return fmt.Errorf("already started")
-	}
-	t.closeCh = make(chan struct{})
-	go func() {
-		ticker := t.clock.Ticker(t.interval)
-		defer ticker.Stop()
-		for {
-			select {
-			case <-ticker.C:
-				t.rotate()
-				if t.doneRotatingCh != nil {
-					t.doneRotatingCh <- struct{}{}
-				}
-			case <-t.closeCh:
-				return
-			}
-		}
-	}()
-	return nil
-}
-
-func (t *TimedCacheBlockstore) Stop(_ context.Context) error {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	if t.closeCh == nil {
-		return fmt.Errorf("not started")
-	}
-	select {
-	case <-t.closeCh:
-		// already closed
-	default:
-		close(t.closeCh)
-	}
-	return nil
-}
-
-func (t *TimedCacheBlockstore) rotate() {
-	newBs := NewMemory()
-
-	t.mu.Lock()
-	t.inactive, t.active = t.active, newBs
-	t.mu.Unlock()
-}
-
-func (t *TimedCacheBlockstore) Put(b blocks.Block) error {
-	// Don't check the inactive set here. We want to keep this block for at
-	// least one interval.
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	return t.active.Put(b)
-}
-
-func (t *TimedCacheBlockstore) PutMany(bs []blocks.Block) error {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	return t.active.PutMany(bs)
-}
-
-func (t *TimedCacheBlockstore) View(k cid.Cid, callback func([]byte) error) error {
-	// The underlying blockstore is always a "mem" blockstore so there's no difference,
-	// from a performance perspective, between view & get. So we call Get to avoid
-	// calling an arbitrary callback while holding a lock.
-	t.mu.RLock()
-	block, err := t.active.Get(k)
-	if err == ErrNotFound {
-		block, err = t.inactive.Get(k)
-	}
-	t.mu.RUnlock()
-
-	if err != nil {
-		return err
-	}
-	return callback(block.RawData())
-}
-
-func (t *TimedCacheBlockstore) Get(k cid.Cid) (blocks.Block, error) {
-	t.mu.RLock()
-	defer t.mu.RUnlock()
-	b, err := t.active.Get(k)
-	if err == ErrNotFound {
-		b, err = t.inactive.Get(k)
-	}
-	return b, err
-}
-
-func (t *TimedCacheBlockstore) GetSize(k cid.Cid) (int, error) {
-	t.mu.RLock()
-	defer t.mu.RUnlock()
-	size, err := t.active.GetSize(k)
-	if err == ErrNotFound {
-		size, err = t.inactive.GetSize(k)
-	}
-	return size, err
-}
-
-func (t *TimedCacheBlockstore) Has(k cid.Cid) (bool, error) {
-	t.mu.RLock()
-	defer t.mu.RUnlock()
-	if has, err := t.active.Has(k); err != nil {
-		return false, err
-	} else if has {
-		return true, nil
-	}
-	return t.inactive.Has(k)
-}
-
-func (t *TimedCacheBlockstore) HashOnRead(_ bool) {
-	// no-op
-}
-
-func (t *TimedCacheBlockstore) DeleteBlock(k cid.Cid) error {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	return multierr.Combine(t.active.DeleteBlock(k), t.inactive.DeleteBlock(k))
-}
-
-func (t *TimedCacheBlockstore) DeleteMany(ks []cid.Cid) error {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	return multierr.Combine(t.active.DeleteMany(ks), t.inactive.DeleteMany(ks))
-}
-
-func (t *TimedCacheBlockstore) AllKeysChan(_ context.Context) (<-chan cid.Cid, error) {
-	t.mu.RLock()
-	defer t.mu.RUnlock()
-
-	ch := make(chan cid.Cid, len(t.active)+len(t.inactive))
-	for c := range t.active {
-		ch <- c
-	}
-	for c := range t.inactive {
-		if _, ok := t.active[c]; ok {
-			continue
-		}
-		ch <- c
-	}
-	close(ch)
-	return ch, nil
-}

blockstore/timed_test.go

@@ -1,85 +0,0 @@
-package blockstore
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"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) {
-	tc := NewTimedCacheBlockstore(10 * time.Millisecond)
-	mClock := clock.NewMock()
-	mClock.Set(time.Now())
-	tc.clock = mClock
-	tc.doneRotatingCh = make(chan struct{})
-
-	_ = tc.Start(context.Background())
-	mClock.Add(1) // IDK why it is needed but it makes it work
-
-	defer func() {
-		_ = tc.Stop(context.Background())
-	}()
-
-	b1 := blocks.NewBlock([]byte("foo"))
-	require.NoError(t, tc.Put(b1))
-
-	b2 := blocks.NewBlock([]byte("bar"))
-	require.NoError(t, tc.Put(b2))
-
-	b3 := blocks.NewBlock([]byte("baz"))
-
-	b1out, err := tc.Get(b1.Cid())
-	require.NoError(t, err)
-	require.Equal(t, b1.RawData(), b1out.RawData())
-
-	has, err := tc.Has(b1.Cid())
-	require.NoError(t, err)
-	require.True(t, has)
-
-	mClock.Add(10 * time.Millisecond)
-	<-tc.doneRotatingCh
-
-	// We should still have everything.
-	has, err = tc.Has(b1.Cid())
-	require.NoError(t, err)
-	require.True(t, has)
-
-	has, err = tc.Has(b2.Cid())
-	require.NoError(t, err)
-	require.True(t, has)
-
-	// extend b2, add b3.
-	require.NoError(t, tc.Put(b2))
-	require.NoError(t, tc.Put(b3))
-
-	// all keys once.
-	allKeys, err := tc.AllKeysChan(context.Background())
-	var ks []cid.Cid
-	for k := range allKeys {
-		ks = append(ks, k)
-	}
-	require.NoError(t, err)
-	require.ElementsMatch(t, ks, []cid.Cid{b1.Cid(), b2.Cid(), b3.Cid()})
-
-	mClock.Add(10 * time.Millisecond)
-	<-tc.doneRotatingCh
-	// should still have b2, and b3, but not b1
-
-	has, err = tc.Has(b1.Cid())
-	require.NoError(t, err)
-	require.False(t, has)
-
-	has, err = tc.Has(b2.Cid())
-	require.NoError(t, err)
-	require.True(t, has)
-
-	has, err = tc.Has(b3.Cid())
-	require.NoError(t, err)
-	require.True(t, has)
-}

blockstore/union.go

@@ -1,119 +0,0 @@
-package blockstore
-
-import (
-	"context"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-)
-
-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 deltes) are broadcast to all stores.
-//
-func Union(stores ...Blockstore) Blockstore {
-	return unionBlockstore(stores)
-}
-
-func (m unionBlockstore) Has(cid cid.Cid) (has bool, err error) {
-	for _, bs := range m {
-		if has, err = bs.Has(cid); has || err != nil {
-			break
-		}
-	}
-	return has, err
-}
-
-func (m unionBlockstore) Get(cid cid.Cid) (blk blocks.Block, err error) {
-	for _, bs := range m {
-		if blk, err = bs.Get(cid); err == nil || err != ErrNotFound {
-			break
-		}
-	}
-	return blk, err
-}
-
-func (m unionBlockstore) View(cid cid.Cid, callback func([]byte) error) (err error) {
-	for _, bs := range m {
-		if err = bs.View(cid, callback); err == nil || err != ErrNotFound {
-			break
-		}
-	}
-	return err
-}
-
-func (m unionBlockstore) GetSize(cid cid.Cid) (size int, err error) {
-	for _, bs := range m {
-		if size, err = bs.GetSize(cid); err == nil || err != ErrNotFound {
-			break
-		}
-	}
-	return size, err
-}
-
-func (m unionBlockstore) Put(block blocks.Block) (err error) {
-	for _, bs := range m {
-		if err = bs.Put(block); err != nil {
-			break
-		}
-	}
-	return err
-}
-
-func (m unionBlockstore) PutMany(blks []blocks.Block) (err error) {
-	for _, bs := range m {
-		if err = bs.PutMany(blks); err != nil {
-			break
-		}
-	}
-	return err
-}
-
-func (m unionBlockstore) DeleteBlock(cid cid.Cid) (err error) {
-	for _, bs := range m {
-		if err = bs.DeleteBlock(cid); err != nil {
-			break
-		}
-	}
-	return err
-}
-
-func (m unionBlockstore) DeleteMany(cids []cid.Cid) (err error) {
-	for _, bs := range m {
-		if err = bs.DeleteMany(cids); err != nil {
-			break
-		}
-	}
-	return err
-}
-
-func (m unionBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
-	// this does not deduplicate; this interface needs to be revisited.
-	outCh := make(chan cid.Cid)
-
-	go func() {
-		defer close(outCh)
-
-		for _, bs := range m {
-			ch, err := bs.AllKeysChan(ctx)
-			if err != nil {
-				return
-			}
-			for cid := range ch {
-				outCh <- cid
-			}
-		}
-	}()
-
-	return outCh, nil
-}
-
-func (m unionBlockstore) HashOnRead(enabled bool) {
-	for _, bs := range m {
-		bs.HashOnRead(enabled)
-	}
-}

blockstore/union_test.go

@@ -1,102 +0,0 @@
-package blockstore
-
-import (
-	"context"
-	"testing"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/stretchr/testify/require"
-)
-
-var (
-	b0 = blocks.NewBlock([]byte("abc"))
-	b1 = blocks.NewBlock([]byte("foo"))
-	b2 = blocks.NewBlock([]byte("bar"))
-)
-
-func TestUnionBlockstore_Get(t *testing.T) {
-	m1 := NewMemory()
-	m2 := NewMemory()
-
-	_ = m1.Put(b1)
-	_ = m2.Put(b2)
-
-	u := Union(m1, m2)
-
-	v1, err := u.Get(b1.Cid())
-	require.NoError(t, err)
-	require.Equal(t, b1.RawData(), v1.RawData())
-
-	v2, err := u.Get(b2.Cid())
-	require.NoError(t, err)
-	require.Equal(t, b2.RawData(), v2.RawData())
-}
-
-func TestUnionBlockstore_Put_PutMany_Delete_AllKeysChan(t *testing.T) {
-	m1 := NewMemory()
-	m2 := NewMemory()
-
-	u := Union(m1, m2)
-
-	err := u.Put(b0)
-	require.NoError(t, err)
-
-	var has bool
-
-	// write was broadcasted to all stores.
-	has, _ = m1.Has(b0.Cid())
-	require.True(t, has)
-
-	has, _ = m2.Has(b0.Cid())
-	require.True(t, has)
-
-	has, _ = u.Has(b0.Cid())
-	require.True(t, has)
-
-	// put many.
-	err = u.PutMany([]blocks.Block{b1, b2})
-	require.NoError(t, err)
-
-	// write was broadcasted to all stores.
-	has, _ = m1.Has(b1.Cid())
-	require.True(t, has)
-
-	has, _ = m1.Has(b2.Cid())
-	require.True(t, has)
-
-	has, _ = m2.Has(b1.Cid())
-	require.True(t, has)
-
-	has, _ = m2.Has(b2.Cid())
-	require.True(t, has)
-
-	// also in the union store.
-	has, _ = u.Has(b1.Cid())
-	require.True(t, has)
-
-	has, _ = u.Has(b2.Cid())
-	require.True(t, has)
-
-	// deleted from all stores.
-	err = u.DeleteBlock(b1.Cid())
-	require.NoError(t, err)
-
-	has, _ = u.Has(b1.Cid())
-	require.False(t, has)
-
-	has, _ = m1.Has(b1.Cid())
-	require.False(t, has)
-
-	has, _ = m2.Has(b1.Cid())
-	require.False(t, has)
-
-	// check that AllKeysChan returns b0 and b2, twice (once per backing store)
-	ch, err := u.AllKeysChan(context.Background())
-	require.NoError(t, err)
-
-	var i int
-	for range ch {
-		i++
-	}
-	require.Equal(t, 4, i)
-}

build/bootstrap.go

@@ -2,9 +2,11 @@ package build
 
 import (
 	"context"
+	"os"
 	"strings"
 
 	"github.com/filecoin-project/lotus/lib/addrutil"
+	"golang.org/x/xerrors"
 
 	rice "github.com/GeertJohan/go.rice"
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -15,16 +17,24 @@ func BuiltinBootstrap() ([]peer.AddrInfo, error) {
 		return nil, nil
 	}
 
-	b := rice.MustFindBox("bootstrap")
+	var out []peer.AddrInfo
 
-	if BootstrappersFile != "" {
-		spi := b.MustString(BootstrappersFile)
-		if spi == "" {
-			return nil, nil
+	b := rice.MustFindBox("bootstrap")
+	err := b.Walk("", func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return xerrors.Errorf("failed to walk box: %w", err)
 		}
 
-		return addrutil.ParseAddresses(context.TODO(), strings.Split(strings.TrimSpace(spi), "\n"))
-	}
-
-	return nil, nil
+		if !strings.HasSuffix(path, ".pi") {
+			return nil
+		}
+		spi := b.MustString(path)
+		if spi == "" {
+			return nil
+		}
+		pi, err := addrutil.ParseAddresses(context.TODO(), strings.Split(strings.TrimSpace(spi), "\n"))
+		out = append(out, pi...)
+		return err
+	})
+	return out, err
 }

build/bootstrap/bootstrappers.pi

@@ -1,4 +1,4 @@
-/dns4/bootstrap-0.calibration.fildev.network/tcp/1347/p2p/12D3KooWRLZAseMo9h7fRD6ojn6YYDXHsBSavX5YmjBZ9ngtAEec
-/dns4/bootstrap-1.calibration.fildev.network/tcp/1347/p2p/12D3KooWJFtDXgZEQMEkjJPSrbfdvh2xfjVKrXeNFG1t8ioJXAzv
-/dns4/bootstrap-2.calibration.fildev.network/tcp/1347/p2p/12D3KooWP1uB9Lo7yCA3S17TD4Y5wStP5Nk7Vqh53m8GsFjkyujD
-/dns4/bootstrap-3.calibration.fildev.network/tcp/1347/p2p/12D3KooWLrPM4WPK1YRGPCUwndWcDX8GCYgms3DiuofUmxwvhMCn
+/dns4/bootstrap-0.calibration.fildev.network/tcp/1347/p2p/12D3KooWMEfi7K4zWWHP4dCf2iCeepUu9iNcVm6Xk8mTDq4E8rUi
+/dns4/bootstrap-1.calibration.fildev.network/tcp/1347/p2p/12D3KooWL4rBBKBRMr91Ej4b1WaSAaoHzPr2zBF9zJ4io8dDuHHT
+/dns4/bootstrap-2.calibration.fildev.network/tcp/1347/p2p/12D3KooWHTBk2eTBFf7F25Zdxue5iYzkwMRxN4sHApzTXq7siZ9g
+/dns4/bootstrap-3.calibration.fildev.network/tcp/1347/p2p/12D3KooWHRpygG9qTq2bP9SWVfgbD6KgbGxNZuEnpDjgRujJATV6

build/bootstrap/butterflynet.pi

@@ -1,2 +0,0 @@
-/dns4/bootstrap-0.butterfly.fildev.network/tcp/1347/p2p/12D3KooWRkaF18SR3E6qL6dkGrozT8QJUV5VbhE9E7BZtPmHqdWJ
-/dns4/bootstrap-1.butterfly.fildev.network/tcp/1347/p2p/12D3KooWJcJUc23WJjJHGSboGcU3t76z9Lb7CghrH2tiBiDCY4ux

build/bootstrap/mainnet.pi

@@ -1,15 +0,0 @@
-/dns4/bootstrap-0.mainnet.filops.net/tcp/1347/p2p/12D3KooWCVe8MmsEMes2FzgTpt9fXtmCY7wrq91GRiaC8PHSCCBj
-/dns4/bootstrap-1.mainnet.filops.net/tcp/1347/p2p/12D3KooWCwevHg1yLCvktf2nvLu7L9894mcrJR4MsBCcm4syShVc
-/dns4/bootstrap-2.mainnet.filops.net/tcp/1347/p2p/12D3KooWEWVwHGn2yR36gKLozmb4YjDJGerotAPGxmdWZx2nxMC4
-/dns4/bootstrap-3.mainnet.filops.net/tcp/1347/p2p/12D3KooWKhgq8c7NQ9iGjbyK7v7phXvG6492HQfiDaGHLHLQjk7R
-/dns4/bootstrap-4.mainnet.filops.net/tcp/1347/p2p/12D3KooWL6PsFNPhYftrJzGgF5U18hFoaVhfGk7xwzD8yVrHJ3Uc
-/dns4/bootstrap-5.mainnet.filops.net/tcp/1347/p2p/12D3KooWLFynvDQiUpXoHroV1YxKHhPJgysQGH2k3ZGwtWzR4dFH
-/dns4/bootstrap-6.mainnet.filops.net/tcp/1347/p2p/12D3KooWP5MwCiqdMETF9ub1P3MbCvQCcfconnYHbWg6sUJcDRQQ
-/dns4/bootstrap-7.mainnet.filops.net/tcp/1347/p2p/12D3KooWRs3aY1p3juFjPy8gPN95PEQChm2QKGUCAdcDCC4EBMKf
-/dns4/bootstrap-8.mainnet.filops.net/tcp/1347/p2p/12D3KooWScFR7385LTyR4zU1bYdzSiiAb5rnNABfVahPvVSzyTkR
-/dns4/lotus-bootstrap.ipfsforce.com/tcp/41778/p2p/12D3KooWGhufNmZHF3sv48aQeS13ng5XVJZ9E6qy2Ms4VzqeUsHk
-/dns4/bootstrap-0.starpool.in/tcp/12757/p2p/12D3KooWGHpBMeZbestVEWkfdnC9u7p6uFHXL1n7m1ZBqsEmiUzz
-/dns4/bootstrap-1.starpool.in/tcp/12757/p2p/12D3KooWQZrGH1PxSNZPum99M1zNvjNFM33d1AAu5DcvdHptuU7u
-/dns4/node.glif.io/tcp/1235/p2p/12D3KooWBF8cpp65hp2u9LK5mh19x67ftAam84z9LsfaquTDSBpt
-/dns4/bootstrap-0.ipfsmain.cn/tcp/34721/p2p/12D3KooWQnwEGNqcM2nAcPtRR9rAX8Hrg4k9kJLCHoTR5chJfz6d
-/dns4/bootstrap-1.ipfsmain.cn/tcp/34723/p2p/12D3KooWMKxMkD5DMpSWsW7dBddKxKT7L2GgbNuckz9otxvkvByP

build/bootstrap/nerpanet.pi

@@ -1,4 +0,0 @@
-/dns4/bootstrap-2.nerpa.interplanetary.dev/tcp/1347/p2p/12D3KooWQcL6ReWmR6ASWx4iT7EiAmxKDQpvgq1MKNTQZp5NPnWW
-/dns4/bootstrap-0.nerpa.interplanetary.dev/tcp/1347/p2p/12D3KooWGyJCwCm7EfupM15CFPXM4c7zRVHwwwjcuy9umaGeztMX
-/dns4/bootstrap-3.nerpa.interplanetary.dev/tcp/1347/p2p/12D3KooWNK9RmfksKXSCQj7ZwAM7L6roqbN4kwJteihq7yPvSgPs
-/dns4/bootstrap-1.nerpa.interplanetary.dev/tcp/1347/p2p/12D3KooWCWSaH6iUyXYspYxELjDfzToBsyVGVz3QvC7ysXv7wESo

build/drand.go

@@ -35,7 +35,6 @@ var DrandConfigs = map[DrandEnum]dtypes.DrandConfig{
 			"https://api.drand.sh",
 			"https://api2.drand.sh",
 			"https://api3.drand.sh",
-			"https://drand.cloudflare.com",
 		},
 		Relays: []string{
 			"/dnsaddr/api.drand.sh/",
@@ -69,6 +68,16 @@ var DrandConfigs = map[DrandEnum]dtypes.DrandConfig{
 		ChainInfoJSON: `{"public_key":"8cda589f88914aa728fd183f383980b35789ce81b274e5daee1f338b77d02566ef4d3fb0098af1f844f10f9c803c1827","period":25,"genesis_time":1595348225,"hash":"e73b7dc3c4f6a236378220c0dd6aa110eb16eed26c11259606e07ee122838d4f","groupHash":"567d4785122a5a3e75a9bc9911d7ea807dd85ff76b78dc4ff06b075712898607"}`,
 	},
 	DrandIncentinet: {
+		Servers: []string{
+			"https://pl-eu.incentinet.drand.sh",
+			"https://pl-us.incentinet.drand.sh",
+			"https://pl-sin.incentinet.drand.sh",
+		},
+		Relays: []string{
+			"/dnsaddr/pl-eu.incentinet.drand.sh/",
+			"/dnsaddr/pl-us.incentinet.drand.sh/",
+			"/dnsaddr/pl-sin.incentinet.drand.sh/",
+		},
 		ChainInfoJSON: `{"public_key":"8cad0c72c606ab27d36ee06de1d5b2db1faf92e447025ca37575ab3a8aac2eaae83192f846fc9e158bc738423753d000","period":30,"genesis_time":1595873820,"hash":"80c8b872c714f4c00fdd3daa465d5514049f457f01f85a4caf68cdcd394ba039","groupHash":"d9406aaed487f7af71851b4399448e311f2328923d454e971536c05398ce2d9b"}`,
 	},
 }

build/genesis.go

@@ -14,7 +14,7 @@ func MaybeGenesis() []byte {
 		log.Warnf("loading built-in genesis: %s", err)
 		return nil
 	}
-	genBytes, err := builtinGen.Bytes(GenesisFile)
+	genBytes, err := builtinGen.Bytes("devnet.car")
 	if err != nil {
 		log.Warnf("loading built-in genesis: %s", err)
 	}

build/isnearupgrade.go

@@ -1,9 +0,0 @@
-package build
-
-import (
-	"github.com/filecoin-project/go-state-types/abi"
-)
-
-func IsNearUpgrade(epoch, upgradeEpoch abi.ChainEpoch) bool {
-	return epoch > upgradeEpoch-Finality && epoch < upgradeEpoch+Finality
-}

build/openrpc.go

@@ -1,43 +0,0 @@
-package build
-
-import (
-	"bytes"
-	"compress/gzip"
-	"encoding/json"
-
-	rice "github.com/GeertJohan/go.rice"
-
-	apitypes "github.com/filecoin-project/lotus/api/types"
-)
-
-func mustReadGzippedOpenRPCDocument(data []byte) apitypes.OpenRPCDocument {
-	zr, err := gzip.NewReader(bytes.NewBuffer(data))
-	if err != nil {
-		log.Fatal(err)
-	}
-	m := apitypes.OpenRPCDocument{}
-	err = json.NewDecoder(zr).Decode(&m)
-	if err != nil {
-		log.Fatal(err)
-	}
-	err = zr.Close()
-	if err != nil {
-		log.Fatal(err)
-	}
-	return m
-}
-
-func OpenRPCDiscoverJSON_Full() apitypes.OpenRPCDocument {
-	data := rice.MustFindBox("openrpc").MustBytes("full.json.gz")
-	return mustReadGzippedOpenRPCDocument(data)
-}
-
-func OpenRPCDiscoverJSON_Miner() apitypes.OpenRPCDocument {
-	data := rice.MustFindBox("openrpc").MustBytes("miner.json.gz")
-	return mustReadGzippedOpenRPCDocument(data)
-}
-
-func OpenRPCDiscoverJSON_Worker() apitypes.OpenRPCDocument {
-	data := rice.MustFindBox("openrpc").MustBytes("worker.json.gz")
-	return mustReadGzippedOpenRPCDocument(data)
-}

build/openrpc_test.go

@@ -1,23 +0,0 @@
-package build
-
-import (
-	"testing"
-
-	apitypes "github.com/filecoin-project/lotus/api/types"
-)
-
-func TestOpenRPCDiscoverJSON_Version(t *testing.T) {
-	// openRPCDocVersion is the current OpenRPC version of the API docs.
-	openRPCDocVersion := "1.2.6"
-
-	for i, docFn := range []func() apitypes.OpenRPCDocument{
-		OpenRPCDiscoverJSON_Full,
-		OpenRPCDiscoverJSON_Miner,
-		OpenRPCDiscoverJSON_Worker,
-	} {
-		doc := docFn()
-		if got, ok := doc["openrpc"]; !ok || got != openRPCDocVersion {
-			t.Fatalf("case: %d, want: %s, got: %v, doc: %v", i, openRPCDocVersion, got, doc)
-		}
-	}
-}

build/parameters.go

@@ -5,7 +5,3 @@ import rice "github.com/GeertJohan/go.rice"
 func ParametersJSON() []byte {
 	return rice.MustFindBox("proof-params").MustBytes("parameters.json")
 }
-
-func SrsJSON() []byte {
-	return rice.MustFindBox("proof-params").MustBytes("srs-inner-product.json")
-}

build/params_2k.go

@@ -3,43 +3,18 @@
 package build
 
 import (
-	"os"
-	"strconv"
-
-	"github.com/ipfs/go-cid"
-
 	"github.com/filecoin-project/go-state-types/abi"
+
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 )
 
-const BootstrappersFile = ""
-const GenesisFile = ""
-
-var UpgradeBreezeHeight = abi.ChainEpoch(-1)
-
+const UpgradeBreezeHeight = -1
 const BreezeGasTampingDuration = 0
 
-var UpgradeSmokeHeight = abi.ChainEpoch(-1)
-var UpgradeIgnitionHeight = abi.ChainEpoch(-2)
-var UpgradeRefuelHeight = abi.ChainEpoch(-3)
-var UpgradeTapeHeight = abi.ChainEpoch(-4)
-
-var UpgradeAssemblyHeight = abi.ChainEpoch(5)
-var UpgradeLiftoffHeight = abi.ChainEpoch(-5)
-
-var UpgradeKumquatHeight = abi.ChainEpoch(6)
-var UpgradeCalicoHeight = abi.ChainEpoch(7)
-var UpgradePersianHeight = abi.ChainEpoch(8)
-var UpgradeOrangeHeight = abi.ChainEpoch(9)
-var UpgradeClausHeight = abi.ChainEpoch(10)
-
-var UpgradeTrustHeight = abi.ChainEpoch(11)
-
-var UpgradeNorwegianHeight = abi.ChainEpoch(12)
-
-var UpgradeTurboHeight = abi.ChainEpoch(13)
-
-var UpgradeHyperdriveHeight = abi.ChainEpoch(14)
+const UpgradeSmokeHeight = -1
+const UpgradeIgnitionHeight = -2
+const UpgradeLiftoffHeight = -3
+const UpgradeActorsV2Height = 10
 
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0: DrandMainnet,
@@ -49,38 +24,6 @@ func init() {
 	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
 	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
 	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
-	policy.SetPreCommitChallengeDelay(abi.ChainEpoch(10))
-
-	getUpgradeHeight := func(ev string, def abi.ChainEpoch) abi.ChainEpoch {
-		hs, found := os.LookupEnv(ev)
-		if found {
-			h, err := strconv.Atoi(hs)
-			if err != nil {
-				log.Panicf("failed to parse %s env var", ev)
-			}
-
-			return abi.ChainEpoch(h)
-		}
-
-		return def
-	}
-
-	UpgradeBreezeHeight = getUpgradeHeight("LOTUS_BREEZE_HEIGHT", UpgradeBreezeHeight)
-	UpgradeSmokeHeight = getUpgradeHeight("LOTUS_SMOKE_HEIGHT", UpgradeSmokeHeight)
-	UpgradeIgnitionHeight = getUpgradeHeight("LOTUS_IGNITION_HEIGHT", UpgradeIgnitionHeight)
-	UpgradeRefuelHeight = getUpgradeHeight("LOTUS_REFUEL_HEIGHT", UpgradeRefuelHeight)
-	UpgradeTapeHeight = getUpgradeHeight("LOTUS_TAPE_HEIGHT", UpgradeTapeHeight)
-	UpgradeAssemblyHeight = getUpgradeHeight("LOTUS_ACTORSV2_HEIGHT", UpgradeAssemblyHeight)
-	UpgradeLiftoffHeight = getUpgradeHeight("LOTUS_LIFTOFF_HEIGHT", UpgradeLiftoffHeight)
-	UpgradeKumquatHeight = getUpgradeHeight("LOTUS_KUMQUAT_HEIGHT", UpgradeKumquatHeight)
-	UpgradeCalicoHeight = getUpgradeHeight("LOTUS_CALICO_HEIGHT", UpgradeCalicoHeight)
-	UpgradePersianHeight = getUpgradeHeight("LOTUS_PERSIAN_HEIGHT", UpgradePersianHeight)
-	UpgradeOrangeHeight = getUpgradeHeight("LOTUS_ORANGE_HEIGHT", UpgradeOrangeHeight)
-	UpgradeClausHeight = getUpgradeHeight("LOTUS_CLAUS_HEIGHT", UpgradeClausHeight)
-	UpgradeTrustHeight = getUpgradeHeight("LOTUS_ACTORSV3_HEIGHT", UpgradeTrustHeight)
-	UpgradeNorwegianHeight = getUpgradeHeight("LOTUS_NORWEGIAN_HEIGHT", UpgradeNorwegianHeight)
-	UpgradeTurboHeight = getUpgradeHeight("LOTUS_ACTORSV4_HEIGHT", UpgradeTurboHeight)
-	UpgradeHyperdriveHeight = getUpgradeHeight("LOTUS_HYPERDRIVE_HEIGHT", UpgradeHyperdriveHeight)
 
 	BuildType |= Build2k
 }
@@ -97,7 +40,3 @@ const SlashablePowerDelay = 20
 
 // Epochs
 const InteractivePoRepConfidence = 6
-
-const BootstrapPeerThreshold = 1
-
-var WhitelistedBlock = cid.Undef

build/params_butterfly.go

@@ -1,58 +0,0 @@
-// +build butterflynet
-
-package build
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	"github.com/ipfs/go-cid"
-)
-
-var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0: DrandMainnet,
-}
-
-const BootstrappersFile = "butterflynet.pi"
-const GenesisFile = "butterflynet.car"
-
-const UpgradeBreezeHeight = -1
-const BreezeGasTampingDuration = 120
-const UpgradeSmokeHeight = -2
-const UpgradeIgnitionHeight = -3
-const UpgradeRefuelHeight = -4
-
-var UpgradeAssemblyHeight = abi.ChainEpoch(30)
-
-const UpgradeTapeHeight = 60
-const UpgradeLiftoffHeight = -5
-const UpgradeKumquatHeight = 90
-const UpgradeCalicoHeight = 120
-const UpgradePersianHeight = 150
-const UpgradeClausHeight = 180
-const UpgradeOrangeHeight = 210
-const UpgradeTrustHeight = 240
-const UpgradeNorwegianHeight = UpgradeTrustHeight + (builtin2.EpochsInHour * 12)
-const UpgradeTurboHeight = 8922
-const UpgradeHyperdriveHeight = 9999999
-
-func init() {
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2 << 30))
-	policy.SetSupportedProofTypes(
-		abi.RegisteredSealProof_StackedDrg512MiBV1,
-	)
-
-	SetAddressNetwork(address.Testnet)
-
-	Devnet = true
-}
-
-const BlockDelaySecs = uint64(builtin2.EpochDurationSeconds)
-
-const PropagationDelaySecs = uint64(6)
-
-// BootstrapPeerThreshold is the minimum number peers we need to track for a sync worker to start
-const BootstrapPeerThreshold = 2
-
-var WhitelistedBlock = cid.Undef

build/params_calibnet.go

@@ -1,72 +0,0 @@
-// +build calibnet
-
-package build
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	"github.com/ipfs/go-cid"
-)
-
-var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0: DrandMainnet,
-}
-
-const BootstrappersFile = "calibnet.pi"
-const GenesisFile = "calibnet.car"
-
-const UpgradeBreezeHeight = -1
-const BreezeGasTampingDuration = 120
-
-const UpgradeSmokeHeight = -2
-
-const UpgradeIgnitionHeight = -3
-const UpgradeRefuelHeight = -4
-
-var UpgradeAssemblyHeight = abi.ChainEpoch(30)
-
-const UpgradeTapeHeight = 60
-
-const UpgradeLiftoffHeight = -5
-
-const UpgradeKumquatHeight = 90
-
-const UpgradeCalicoHeight = 100
-const UpgradePersianHeight = UpgradeCalicoHeight + (builtin2.EpochsInHour * 1)
-
-const UpgradeClausHeight = 250
-
-const UpgradeOrangeHeight = 300
-
-const UpgradeTrustHeight = 600
-const UpgradeNorwegianHeight = 114000
-
-const UpgradeTurboHeight = 193789
-
-// 2021-06-11T14:30:00Z
-const UpgradeHyperdriveHeight = 321519
-
-func init() {
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(32 << 30))
-	policy.SetSupportedProofTypes(
-		abi.RegisteredSealProof_StackedDrg32GiBV1,
-		abi.RegisteredSealProof_StackedDrg64GiBV1,
-	)
-
-	SetAddressNetwork(address.Testnet)
-
-	Devnet = true
-
-	BuildType = BuildCalibnet
-}
-
-const BlockDelaySecs = uint64(builtin2.EpochDurationSeconds)
-
-const PropagationDelaySecs = uint64(6)
-
-// BootstrapPeerThreshold is the minimum number peers we need to track for a sync worker to start
-const BootstrapPeerThreshold = 4
-
-var WhitelistedBlock = cid.Undef

build/params_mainnet.go

@@ -1,92 +0,0 @@
-// +build !debug
-// +build !2k
-// +build !testground
-// +build !calibnet
-// +build !nerpanet
-// +build !butterflynet
-
-package build
-
-import (
-	"math"
-	"os"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-)
-
-var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0:                  DrandIncentinet,
-	UpgradeSmokeHeight: DrandMainnet,
-}
-
-const BootstrappersFile = "mainnet.pi"
-const GenesisFile = "mainnet.car"
-
-const UpgradeBreezeHeight = 41280
-
-const BreezeGasTampingDuration = 120
-
-const UpgradeSmokeHeight = 51000
-
-const UpgradeIgnitionHeight = 94000
-const UpgradeRefuelHeight = 130800
-
-const UpgradeAssemblyHeight = 138720
-
-const UpgradeTapeHeight = 140760
-
-// This signals our tentative epoch for mainnet launch. Can make it later, but not earlier.
-// Miners, clients, developers, custodians all need time to prepare.
-// We still have upgrades and state changes to do, but can happen after signaling timing here.
-const UpgradeLiftoffHeight = 148888
-
-const UpgradeKumquatHeight = 170000
-
-const UpgradeCalicoHeight = 265200
-const UpgradePersianHeight = UpgradeCalicoHeight + (builtin2.EpochsInHour * 60)
-
-const UpgradeOrangeHeight = 336458
-
-// 2020-12-22T02:00:00Z
-var UpgradeClausHeight = abi.ChainEpoch(343200)
-
-// 2021-03-04T00:00:30Z
-const UpgradeTrustHeight = 550321
-
-// 2021-04-12T22:00:00Z
-const UpgradeNorwegianHeight = 665280
-
-// 2021-04-29T06:00:00Z
-const UpgradeTurboHeight = 712320
-
-// ???
-var UpgradeHyperdriveHeight = abi.ChainEpoch(9999999)
-
-func init() {
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 40))
-
-	if os.Getenv("LOTUS_USE_TEST_ADDRESSES") != "1" {
-		SetAddressNetwork(address.Mainnet)
-	}
-
-	if os.Getenv("LOTUS_DISABLE_HYPERDRIVE") == "1" {
-		UpgradeHyperdriveHeight = math.MaxInt64
-	}
-
-	Devnet = false
-
-	BuildType = BuildMainnet
-}
-
-const BlockDelaySecs = uint64(builtin2.EpochDurationSeconds)
-
-const PropagationDelaySecs = uint64(6)
-
-// BootstrapPeerThreshold is the minimum number peers we need to track for a sync worker to start
-const BootstrapPeerThreshold = 4
-
-// we skip checks on message validity in this block to sidestep the zero-bls signature
-var WhitelistedBlock = MustParseCid("bafy2bzaceapyg2uyzk7vueh3xccxkuwbz3nxewjyguoxvhx77malc2lzn2ybi")

build/params_nerpanet.go

@@ -1,78 +0,0 @@
-// +build nerpanet
-
-package build
-
-import (
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
-	"github.com/ipfs/go-cid"
-
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-)
-
-var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0: DrandMainnet,
-}
-
-const BootstrappersFile = "nerpanet.pi"
-const GenesisFile = "nerpanet.car"
-
-const UpgradeBreezeHeight = -1
-const BreezeGasTampingDuration = 0
-
-const UpgradeSmokeHeight = -1
-
-const UpgradeIgnitionHeight = -2
-const UpgradeRefuelHeight = -3
-
-const UpgradeLiftoffHeight = -5
-
-const UpgradeAssemblyHeight = 30 // critical: the network can bootstrap from v1 only
-const UpgradeTapeHeight = 60
-
-const UpgradeKumquatHeight = 90
-
-const UpgradeCalicoHeight = 100
-const UpgradePersianHeight = UpgradeCalicoHeight + (builtin2.EpochsInHour * 1)
-
-const UpgradeClausHeight = 250
-
-const UpgradeOrangeHeight = 300
-
-const UpgradeTrustHeight = 600
-const UpgradeNorwegianHeight = 201000
-const UpgradeTurboHeight = 203000
-const UpgradeHyperdriveHeight = 999999999
-
-func init() {
-	// Minimum block production power is set to 4 TiB
-	// Rationale is to discourage small-scale miners from trying to take over the network
-	// One needs to invest in ~2.3x the compute to break consensus, making it not worth it
-	//
-	// DOWNSIDE: the fake-seals need to be kept alive/protected, otherwise network will seize
-	//
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(4 << 40))
-
-	policy.SetSupportedProofTypes(
-		abi.RegisteredSealProof_StackedDrg512MiBV1,
-		abi.RegisteredSealProof_StackedDrg32GiBV1,
-		abi.RegisteredSealProof_StackedDrg64GiBV1,
-	)
-
-	// Lower the most time-consuming parts of PoRep
-	policy.SetPreCommitChallengeDelay(10)
-
-	// TODO - make this a variable
-	//miner.WPoStChallengeLookback = abi.ChainEpoch(2)
-
-	Devnet = false
-}
-
-const BlockDelaySecs = uint64(builtin2.EpochDurationSeconds)
-
-const PropagationDelaySecs = uint64(6)
-
-// BootstrapPeerThreshold is the minimum number peers we need to track for a sync worker to start
-const BootstrapPeerThreshold = 4
-
-var WhitelistedBlock = cid.Undef

build/params_shared_funcs.go

@@ -1,14 +1,36 @@
 package build
 
 import (
+	"sort"
+
 	"github.com/filecoin-project/go-address"
-	"github.com/ipfs/go-cid"
 
 	"github.com/libp2p/go-libp2p-core/protocol"
 
+	"github.com/filecoin-project/go-state-types/abi"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 
+func DefaultSectorSize() abi.SectorSize {
+	szs := make([]abi.SectorSize, 0, len(miner0.SupportedProofTypes))
+	for spt := range miner0.SupportedProofTypes {
+		ss, err := spt.SectorSize()
+		if err != nil {
+			panic(err)
+		}
+
+		szs = append(szs, ss)
+	}
+
+	sort.Slice(szs, func(i, j int) bool {
+		return szs[i] < szs[j]
+	})
+
+	return szs[0]
+}
+
 // Core network constants
 
 func BlocksTopic(netName dtypes.NetworkName) string   { return "/fil/blocks/" + string(netName) }
@@ -17,24 +39,14 @@ func DhtProtocolName(netName dtypes.NetworkName) protocol.ID {
 	return protocol.ID("/fil/kad/" + string(netName))
 }
 
+func UseNewestNetwork() bool {
+	// TODO: Put these in a container we can iterate over
+	if UpgradeBreezeHeight <= 0 && UpgradeSmokeHeight <= 0 && UpgradeActorsV2Height <= 0 {
+		return true
+	}
+	return false
+}
+
 func SetAddressNetwork(n address.Network) {
 	address.CurrentNetwork = n
 }
-
-func MustParseAddress(addr string) address.Address {
-	ret, err := address.NewFromString(addr)
-	if err != nil {
-		panic(err)
-	}
-
-	return ret
-}
-
-func MustParseCid(c string) cid.Cid {
-	ret, err := cid.Decode(c)
-	if err != nil {
-		panic(err)
-	}
-
-	return ret
-}

build/params_shared_vals.go

@@ -7,12 +7,12 @@ import (
 	"os"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+
 	"github.com/filecoin-project/go-state-types/network"
 
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-
-	"github.com/filecoin-project/lotus/chain/actors/policy"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
 )
 
 // /////
@@ -25,14 +25,14 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network
 
 const AllowableClockDriftSecs = uint64(1)
-const NewestNetworkVersion = network.Version13
+const NewestNetworkVersion = network.Version4
 const ActorUpgradeNetworkVersion = network.Version4
 
 // Epochs
 const ForkLengthThreshold = Finality
 
 // Blocks (e)
-var BlocksPerEpoch = uint64(builtin2.ExpectedLeadersPerEpoch)
+var BlocksPerEpoch = uint64(builtin.ExpectedLeadersPerEpoch)
 
 // Epochs
 const Finality = policy.ChainFinality
@@ -56,14 +56,13 @@ const SealRandomnessLookback = policy.SealRandomnessLookback
 // Epochs
 const TicketRandomnessLookback = abi.ChainEpoch(1)
 
+const WinningPoStSectorSetLookback = abi.ChainEpoch(10)
+
 // /////
 // Address
 
 const AddressMainnetEnvVar = "_mainnet_"
 
-// the 'f' prefix doesn't matter
-var ZeroAddress = MustParseAddress("f3yaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaby2smx7a")
-
 // /////
 // Devnet settings
 
@@ -73,10 +72,8 @@ const FilBase = uint64(2_000_000_000)
 const FilAllocStorageMining = uint64(1_100_000_000)
 
 const FilecoinPrecision = uint64(1_000_000_000_000_000_000)
-const FilReserved = uint64(300_000_000)
 
 var InitialRewardBalance *big.Int
-var InitialFilReserved *big.Int
 
 // TODO: Move other important consts here
 
@@ -84,9 +81,6 @@ func init() {
 	InitialRewardBalance = big.NewInt(int64(FilAllocStorageMining))
 	InitialRewardBalance = InitialRewardBalance.Mul(InitialRewardBalance, big.NewInt(int64(FilecoinPrecision)))
 
-	InitialFilReserved = big.NewInt(int64(FilReserved))
-	InitialFilReserved = InitialFilReserved.Mul(InitialFilReserved, big.NewInt(int64(FilecoinPrecision)))
-
 	if os.Getenv("LOTUS_ADDRESS_TYPE") == AddressMainnetEnvVar {
 		SetAddressNetwork(address.Mainnet)
 	}
@@ -118,5 +112,5 @@ const PackingEfficiencyNum = 4
 const PackingEfficiencyDenom = 5
 
 // Actor consts
-// TODO: pieceSize unused from actors
-var MinDealDuration, MaxDealDuration = policy.DealDurationBounds(0)
+// TODO: Pull from actors when its made not private
+var MinDealDuration = abi.ChainEpoch(180 * builtin.EpochsInDay)

build/params_testground.go

@@ -12,9 +12,7 @@ import (
 
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/network"
-	"github.com/ipfs/go-cid"
-
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
 
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 )
@@ -23,14 +21,14 @@ var (
 	UnixfsChunkSize     = uint64(1 << 20)
 	UnixfsLinksPerLevel = 1024
 
-	BlocksPerEpoch        = uint64(builtin2.ExpectedLeadersPerEpoch)
+	BlocksPerEpoch        = uint64(builtin.ExpectedLeadersPerEpoch)
 	BlockMessageLimit     = 512
 	BlockGasLimit         = int64(100_000_000_000)
 	BlockGasTarget        = int64(BlockGasLimit / 2)
 	BaseFeeMaxChangeDenom = int64(8) // 12.5%
 	InitialBaseFee        = int64(100e6)
 	MinimumBaseFee        = int64(100)
-	BlockDelaySecs        = uint64(builtin2.EpochDurationSeconds)
+	BlockDelaySecs        = uint64(builtin.EpochDurationSeconds)
 	PropagationDelaySecs  = uint64(6)
 
 	AllowableClockDriftSecs = uint64(1)
@@ -52,11 +50,11 @@ var (
 
 	SealRandomnessLookback = policy.SealRandomnessLookback
 
-	TicketRandomnessLookback = abi.ChainEpoch(1)
+	TicketRandomnessLookback     = abi.ChainEpoch(1)
+	WinningPoStSectorSetLookback = abi.ChainEpoch(10)
 
 	FilBase               uint64 = 2_000_000_000
 	FilAllocStorageMining uint64 = 1_400_000_000
-	FilReserved           uint64 = 300_000_000
 
 	FilecoinPrecision uint64 = 1_000_000_000_000_000_000
 
@@ -65,16 +63,9 @@ var (
 		v = v.Mul(v, big.NewInt(int64(FilecoinPrecision)))
 		return v
 	}()
-
-	InitialFilReserved = func() *big.Int {
-		v := big.NewInt(int64(FilReserved))
-		v = v.Mul(v, big.NewInt(int64(FilecoinPrecision)))
-		return v
-	}()
-
 	// Actor consts
-	// TODO: pieceSize unused from actors
-	MinDealDuration, MaxDealDuration = policy.DealDurationBounds(0)
+	// TODO: Pull from actors when its made not private
+	MinDealDuration = abi.ChainEpoch(180 * builtin.EpochsInDay)
 
 	PackingEfficiencyNum   int64 = 4
 	PackingEfficiencyDenom int64 = 5
@@ -82,35 +73,17 @@ var (
 	UpgradeBreezeHeight      abi.ChainEpoch = -1
 	BreezeGasTampingDuration abi.ChainEpoch = 0
 
-	UpgradeSmokeHeight      abi.ChainEpoch = -1
-	UpgradeIgnitionHeight   abi.ChainEpoch = -2
-	UpgradeRefuelHeight     abi.ChainEpoch = -3
-	UpgradeTapeHeight       abi.ChainEpoch = -4
-	UpgradeAssemblyHeight   abi.ChainEpoch = 10
-	UpgradeLiftoffHeight    abi.ChainEpoch = -5
-	UpgradeKumquatHeight    abi.ChainEpoch = -6
-	UpgradeCalicoHeight     abi.ChainEpoch = -7
-	UpgradePersianHeight    abi.ChainEpoch = -8
-	UpgradeOrangeHeight     abi.ChainEpoch = -9
-	UpgradeClausHeight      abi.ChainEpoch = -10
-	UpgradeTrustHeight      abi.ChainEpoch = -11
-	UpgradeNorwegianHeight  abi.ChainEpoch = -12
-	UpgradeTurboHeight      abi.ChainEpoch = -13
-	UpgradeHyperdriveHeight abi.ChainEpoch = -13
+	UpgradeSmokeHeight    abi.ChainEpoch = -1
+	UpgradeIgnitionHeight abi.ChainEpoch = -2
+	UpgradeLiftoffHeight  abi.ChainEpoch = -3
+	UpgradeActorsV2Height abi.ChainEpoch = 10
 
 	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 		0: DrandMainnet,
 	}
 
-	NewestNetworkVersion       = network.Version11
+	NewestNetworkVersion       = network.Version4
 	ActorUpgradeNetworkVersion = network.Version4
 
-	Devnet      = true
-	ZeroAddress = MustParseAddress("f3yaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaby2smx7a")
-
-	WhitelistedBlock  = cid.Undef
-	BootstrappersFile = ""
-	GenesisFile       = ""
+	Devnet = true
 )
-
-const BootstrapPeerThreshold = 1

build/params_testnet.go

@@ -0,0 +1,44 @@
+// +build !debug
+// +build !2k
+// +build !testground
+
+package build
+
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+)
+
+var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+	0: DrandMainnet,
+}
+
+const UpgradeBreezeHeight = -1
+const BreezeGasTampingDuration = 120
+
+const UpgradeSmokeHeight = -2
+
+const UpgradeIgnitionHeight = -3
+
+const UpgradeActorsV2Height = 500
+
+// This signals our tentative epoch for mainnet launch. Can make it later, but not earlier.
+// Miners, clients, developers, custodians all need time to prepare.
+// We still have upgrades and state changes to do, but can happen after signaling timing here.
+const UpgradeLiftoffHeight = 148888
+
+func init() {
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 30))
+	policy.SetSupportedProofTypes(
+		abi.RegisteredSealProof_StackedDrg512MiBV1,
+		abi.RegisteredSealProof_StackedDrg32GiBV1,
+		abi.RegisteredSealProof_StackedDrg64GiBV1,
+	)
+	Devnet = false
+}
+
+const BlockDelaySecs = uint64(builtin0.EpochDurationSeconds)
+
+const PropagationDelaySecs = uint64(6)