fix lotus-sim build

.circleci/gen.go

@@ -0,0 +1,136 @@
+package main
+
+import (
+	"embed"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"text/template"
+)
+
+//go:generate go run ./gen.go ..
+
+//go:embed template.yml
+var templateFile embed.FS
+
+type (
+	dirs  = []string
+	suite = string
+)
+
+// groupedUnitTests maps suite names to top-level directories that should be
+// included in that suite. The program adds an implicit group "rest" that
+// includes all other top-level directories.
+var groupedUnitTests = map[suite]dirs{
+	"unit-node":    {"node"},
+	"unit-storage": {"storage", "extern"},
+	"unit-cli":     {"cli", "cmd", "api"},
+}
+
+func main() {
+	if len(os.Args) != 2 {
+		panic("expected path to repo as argument")
+	}
+
+	repo := os.Args[1]
+
+	tmpl := template.New("template.yml")
+	tmpl.Delims("[[", "]]")
+	tmpl.Funcs(template.FuncMap{
+		"stripSuffix": func(in string) string {
+			return strings.TrimSuffix(in, "_test.go")
+		},
+	})
+	tmpl = template.Must(tmpl.ParseFS(templateFile, "*"))
+
+	// list all itests.
+	itests, err := filepath.Glob(filepath.Join(repo, "./itests/*_test.go"))
+	if err != nil {
+		panic(err)
+	}
+
+	// strip the dir from all entries.
+	for i, f := range itests {
+		itests[i] = filepath.Base(f)
+	}
+
+	// calculate the exclusion set of unit test directories to exclude because
+	// they are already included in a grouped suite.
+	var excluded = map[string]struct{}{}
+	for _, ss := range groupedUnitTests {
+		for _, s := range ss {
+			e, err := filepath.Abs(filepath.Join(repo, s))
+			if err != nil {
+				panic(err)
+			}
+			excluded[e] = struct{}{}
+		}
+	}
+
+	// all unit tests top-level dirs that are not itests, nor included in other suites.
+	var rest = map[string]struct{}{}
+	err = filepath.Walk(repo, func(path string, f os.FileInfo, err error) error {
+		// include all tests that aren't in the itests directory.
+		if strings.Contains(path, "itests") {
+			return filepath.SkipDir
+		}
+		// exclude all tests included in other suites
+		if f.IsDir() {
+			if _, ok := excluded[path]; ok {
+				return filepath.SkipDir
+			}
+		}
+		if strings.HasSuffix(path, "_test.go") {
+			rel, err := filepath.Rel(repo, path)
+			if err != nil {
+				panic(err)
+			}
+			// take the first directory
+			rest[strings.Split(rel, string(os.PathSeparator))[0]] = struct{}{}
+		}
+		return err
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	// add other directories to a 'rest' suite.
+	for k := range rest {
+		groupedUnitTests["unit-rest"] = append(groupedUnitTests["unit-rest"], k)
+	}
+
+	// map iteration guarantees no order, so sort the array in-place.
+	sort.Strings(groupedUnitTests["unit-rest"])
+
+	// form the input data.
+	type data struct {
+		ItestFiles []string
+		UnitSuites map[string]string
+	}
+	in := data{
+		ItestFiles: itests,
+		UnitSuites: func() map[string]string {
+			ret := make(map[string]string)
+			for name, dirs := range groupedUnitTests {
+				for i, d := range dirs {
+					dirs[i] = fmt.Sprintf("./%s/...", d) // turn into package
+				}
+				ret[name] = strings.Join(dirs, " ")
+			}
+			return ret
+		}(),
+	}
+
+	out, err := os.Create("./config.yml")
+	if err != nil {
+		panic(err)
+	}
+	defer out.Close()
+
+	// execute the template.
+	if err := tmpl.Execute(out, in); err != nil {
+		panic(err)
+	}
+}

.circleci/template.yml

@@ -0,0 +1,953 @@
+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.16.4
+    resource_class: 2xlarge
+  ubuntu:
+    docker:
+      - image: ubuntu:20.04
+
+commands:
+  install-deps:
+    steps:
+      - go/install-ssh
+      - go/install: {package: git}
+  prepare:
+    parameters:
+      linux:
+        default: true
+        description: is a linux build environment?
+        type: boolean
+      darwin:
+        default: false
+        description: is a darwin build environment?
+        type: boolean
+    steps:
+      - checkout
+      - git_fetch_all_tags
+      - checkout
+      - when:
+          condition: << parameters.linux >>
+          steps:
+            - run: sudo apt-get update
+            - run: sudo apt-get install ocl-icd-opencl-dev libhwloc-dev
+      - run: git submodule sync
+      - run: git submodule update --init
+  download-params:
+    steps:
+      - restore_cache:
+          name: Restore parameters cache
+          keys:
+            - 'v26-2k-lotus-params'
+          paths:
+            - /var/tmp/filecoin-proof-parameters/
+      - run:  ./lotus fetch-params 2048
+      - save_cache:
+          name: Save parameters cache
+          key: 'v26-2k-lotus-params'
+          paths:
+            - /var/tmp/filecoin-proof-parameters/
+  install_ipfs:
+    steps:
+      - run: |
+          apt update
+          apt install -y wget
+          wget https://github.com/ipfs/go-ipfs/releases/download/v0.4.22/go-ipfs_v0.4.22_linux-amd64.tar.gz
+          wget https://github.com/ipfs/go-ipfs/releases/download/v0.4.22/go-ipfs_v0.4.22_linux-amd64.tar.gz.sha512
+          if [ "$(sha512sum go-ipfs_v0.4.22_linux-amd64.tar.gz)" != "$(cat go-ipfs_v0.4.22_linux-amd64.tar.gz.sha512)" ]
+          then
+            echo "ipfs failed checksum check"
+            exit 1
+          fi
+          tar -xf go-ipfs_v0.4.22_linux-amd64.tar.gz
+          mv go-ipfs/ipfs /usr/local/bin/ipfs
+          chmod +x /usr/local/bin/ipfs
+  git_fetch_all_tags:
+    steps:
+      - run:
+          name: fetch all tags
+          command: |
+            git fetch --all
+
+jobs:
+  mod-tidy-check:
+    executor: golang
+    steps:
+      - install-deps
+      - prepare
+      - go/mod-tidy-check
+
+  build-all:
+    executor: golang
+    steps:
+      - install-deps
+      - prepare
+      - run: sudo apt-get update
+      - run: sudo apt-get install npm
+      - run:
+          command: make buildall
+      - run:
+          name: check tag and version output match
+          command: ./scripts/version-check.sh ./lotus
+      - store_artifacts:
+          path: lotus
+      - store_artifacts:
+          path: lotus-miner
+      - store_artifacts:
+          path: lotus-worker
+      - run: mkdir linux && mv lotus lotus-miner lotus-worker linux/
+      - persist_to_workspace:
+          root: "."
+          paths:
+            - linux
+
+  build-debug:
+    executor: golang
+    steps:
+      - install-deps
+      - prepare
+      - run:
+          command: make debug
+
+  test:
+    description: |
+      Run tests with gotestsum.
+    parameters: &test-params
+      executor:
+        type: executor
+        default: golang
+      go-test-flags:
+        type: string
+        default: "-timeout 30m"
+        description: Flags passed to go test.
+      target:
+        type: string
+        default: "./..."
+        description: Import paths of packages to be tested.
+      proofs-log-test:
+        type: string
+        default: "0"
+      suite:
+        type: string
+        default: unit
+        description: Test suite name to report to CircleCI.
+      gotestsum-format:
+        type: string
+        default: standard-verbose
+        description: gotestsum format. https://github.com/gotestyourself/gotestsum#format
+      coverage:
+        type: string
+        default: -coverprofile=coverage.txt -coverpkg=github.com/filecoin-project/lotus/...
+        description: Coverage flag. Set to the empty string to disable.
+      codecov-upload:
+        type: boolean
+        default: true
+        description: |
+          Upload coverage report to https://codecov.io/. Requires the codecov API token to be
+          set as an environment variable for private projects.
+    executor: << parameters.executor >>
+    steps:
+      - install-deps
+      - prepare
+      - run:
+          command: make deps lotus
+          no_output_timeout: 30m
+      - download-params
+      - go/install-gotestsum:
+          gobin: $HOME/.local/bin
+          version: 0.5.2
+      - run:
+          name: go test
+          environment:
+            TEST_RUSTPROOFS_LOGS: << parameters.proofs-log-test >>
+            SKIP_CONFORMANCE: "1"
+          command: |
+            mkdir -p /tmp/test-reports/<< parameters.suite >>
+            mkdir -p /tmp/test-artifacts
+            gotestsum \
+              --format << parameters.gotestsum-format >> \
+              --junitfile /tmp/test-reports/<< parameters.suite >>/junit.xml \
+              --jsonfile /tmp/test-artifacts/<< parameters.suite >>.json \
+              -- \
+              << parameters.coverage >> \
+              << parameters.go-test-flags >> \
+              << parameters.target >>
+          no_output_timeout: 30m
+      - store_test_results:
+          path: /tmp/test-reports
+      - store_artifacts:
+          path: /tmp/test-artifacts/<< parameters.suite >>.json
+      - when:
+          condition: << parameters.codecov-upload >>
+          steps:
+            - go/install: {package: bash}
+            - go/install: {package: curl}
+            - run:
+                shell: /bin/bash -eo pipefail
+                command: |
+                  bash <(curl -s https://codecov.io/bash)
+
+  test-conformance:
+    description: |
+      Run tests using a corpus of interoperable test vectors for Filecoin 
+      implementations to test their correctness and compliance with the Filecoin
+      specifications.
+    parameters:
+      <<: *test-params
+      vectors-branch:
+        type: string
+        default: ""
+        description: |
+          Branch on github.com/filecoin-project/test-vectors to checkout and
+          test with. If empty (the default) the commit defined by the git
+          submodule is used.
+    executor: << parameters.executor >>
+    steps:
+      - install-deps
+      - prepare
+      - run:
+          command: make deps lotus
+          no_output_timeout: 30m
+      - download-params
+      - when:
+          condition:
+            not:
+              equal: [ "", << parameters.vectors-branch >> ]
+          steps:
+            - run:
+                name: checkout vectors branch
+                command: |
+                  cd extern/test-vectors
+                  git fetch
+                  git checkout origin/<< parameters.vectors-branch >>
+      - go/install-gotestsum:
+          gobin: $HOME/.local/bin
+          version: 0.5.2
+      - run:
+          name: install statediff globally
+          command: |
+            ## statediff is optional; we succeed even if compilation fails.
+            mkdir -p /tmp/statediff
+            git clone https://github.com/filecoin-project/statediff.git /tmp/statediff
+            cd /tmp/statediff
+            go install ./cmd/statediff || exit 0
+      - run:
+          name: go test
+          environment:
+            SKIP_CONFORMANCE: "0"
+          command: |
+            mkdir -p /tmp/test-reports
+            mkdir -p /tmp/test-artifacts
+            gotestsum \
+              --format pkgname-and-test-fails \
+              --junitfile /tmp/test-reports/junit.xml \
+              -- \
+              -v -coverpkg ./chain/vm/,github.com/filecoin-project/specs-actors/... -coverprofile=/tmp/conformance.out ./conformance/
+            go tool cover -html=/tmp/conformance.out -o /tmp/test-artifacts/conformance-coverage.html
+          no_output_timeout: 30m
+      - store_test_results:
+          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-lotus-soup:
+    description: |
+      Compile `lotus-soup` Testground test plan
+    parameters:
+      <<: *test-params
+    executor: << parameters.executor >>
+    steps:
+      - install-deps
+      - prepare
+      - run: cd extern/filecoin-ffi && make
+      - run:
+          name: "go get lotus@master"
+          command: cd testplans/lotus-soup && go mod edit -replace=github.com/filecoin-project/lotus=../.. && go mod tidy
+      - run:
+          name: "build lotus-soup testplan"
+          command: pushd testplans/lotus-soup && go build -tags=testground .
+  trigger-testplans:
+    description: |
+      Trigger `lotus-soup` test cases on TaaS
+    parameters:
+      <<: *test-params
+    executor: << parameters.executor >>
+    steps:
+      - install-deps
+      - prepare
+      - run:
+          name: "download testground"
+          command: wget https://gist.github.com/nonsense/5fbf3167cac79945f658771aed32fc44/raw/2e17eb0debf7ec6bdf027c1bdafc2c92dd97273b/testground-d3e9603 -O ~/testground-cli && chmod +x ~/testground-cli
+      - run:
+          name: "prepare .env.toml"
+          command: pushd testplans/lotus-soup && mkdir -p $HOME/testground && cp env-ci.toml $HOME/testground/.env.toml && echo 'endpoint="https://ci.testground.ipfs.team"' >> $HOME/testground/.env.toml && echo 'user="circleci"' >> $HOME/testground/.env.toml
+      - run:
+          name: "prepare testground home dir and link test plans"
+          command: mkdir -p $HOME/testground/plans && ln -s $(pwd)/testplans/lotus-soup $HOME/testground/plans/lotus-soup
+      - run:
+          name: "go get lotus@master"
+          command: cd testplans/lotus-soup && go get github.com/filecoin-project/lotus@master
+      - run:
+          name: "trigger deals baseline testplan on taas"
+          command: ~/testground-cli run composition -f $HOME/testground/plans/lotus-soup/_compositions/baseline-k8s-3-1.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
+      - run:
+          name: "trigger payment channel stress testplan on taas"
+          command: ~/testground-cli run composition -f $HOME/testground/plans/lotus-soup/_compositions/paych-stress-k8s.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
+
+  build-macos:
+    description: build darwin lotus binary
+    macos:
+      xcode: "12.5.0"
+    working_directory: ~/go/src/github.com/filecoin-project/lotus
+    steps:
+      - prepare:
+          linux: false
+          darwin: true
+      - run:
+          name: Install go
+          command: |
+            curl -O https://dl.google.com/go/go1.16.4.darwin-amd64.pkg && \
+            sudo installer -pkg go1.16.4.darwin-amd64.pkg -target /
+      - run:
+          name: Install pkg-config
+          command: HOMEBREW_NO_AUTO_UPDATE=1 brew install pkg-config
+      - run: go version
+      - run:
+          name: Install Rust
+          command: |
+            curl https://sh.rustup.rs -sSf | sh -s -- -y
+      - run:
+          name: Install hwloc
+          command: |
+            mkdir ~/hwloc
+            curl --location https://download.open-mpi.org/release/hwloc/v2.4/hwloc-2.4.1.tar.gz --output ~/hwloc/hwloc-2.4.1.tar.gz
+            cd ~/hwloc
+            tar -xvzpf hwloc-2.4.1.tar.gz
+            cd hwloc-2.4.1
+            ./configure && make && sudo make install
+      - restore_cache:
+          name: restore cargo cache
+          key: v3-go-deps-{{ arch }}-{{ checksum "~/go/src/github.com/filecoin-project/lotus/go.sum" }}
+      - install-deps
+      - run:
+          command: make build
+          no_output_timeout: 30m
+      - run:
+          name: check tag and version output match
+          command: ./scripts/version-check.sh ./lotus
+      - store_artifacts:
+          path: lotus
+      - store_artifacts:
+          path: lotus-miner
+      - store_artifacts:
+          path: lotus-worker
+      - run: mkdir darwin && mv lotus lotus-miner lotus-worker darwin/
+      - persist_to_workspace:
+          root: "."
+          paths:
+            - darwin
+      - save_cache:
+          name: save cargo cache
+          key: v3-go-deps-{{ arch }}-{{ checksum "~/go/src/github.com/filecoin-project/lotus/go.sum" }}
+          paths:
+            - "~/.rustup"
+            - "~/.cargo"
+
+  build-appimage:
+    machine:
+      image: ubuntu-2004:202111-02
+    steps:
+      - checkout
+      - attach_workspace:
+          at: "."
+      - run:
+          name: install appimage-builder
+          command: |
+            # appimage-builder requires /dev/snd to exist. It creates containers during the testing phase
+            # that pass sound devices from the host to the testing container. (hard coded!)
+            # https://github.com/AppImageCrafters/appimage-builder/blob/master/appimagebuilder/modules/test/execution_test.py#L54
+            # Circleci doesn't provide a working sound device; this is enough to fake it.
+            if [ ! -e /dev/snd ]
+            then
+              sudo mkdir /dev/snd
+              sudo mknod /dev/snd/ControlC0 c 1 2
+            fi
+
+            # docs: https://appimage-builder.readthedocs.io/en/latest/intro/install.html
+            sudo apt update
+            sudo apt install -y python3-pip python3-setuptools patchelf desktop-file-utils libgdk-pixbuf2.0-dev fakeroot strace
+            sudo curl -Lo /usr/local/bin/appimagetool https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage
+            sudo chmod +x /usr/local/bin/appimagetool
+            sudo pip3 install appimage-builder
+      - run:
+          name: install lotus dependencies
+          command: sudo apt install ocl-icd-opencl-dev libhwloc-dev
+      - run:
+          name: build appimage
+          command: |
+            sed -i "s/version: latest/version: ${CIRCLE_TAG:-latest}/" AppImageBuilder.yml
+            make appimage
+      - run:
+          name: prepare workspace
+          command: |
+            mkdir appimage
+            mv Lotus-*.AppImage appimage
+      - persist_to_workspace:
+          root: "."
+          paths:
+            - appimage
+
+
+  gofmt:
+    executor: golang
+    steps:
+      - install-deps
+      - prepare
+      - run:
+          command: "! go fmt ./... 2>&1 | read"
+
+  gen-check:
+    executor: golang
+    steps:
+      - install-deps
+      - prepare
+      - run: make deps
+      - run: go install golang.org/x/tools/cmd/goimports
+      - run: go install github.com/hannahhoward/cbor-gen-for
+      - run: make gen
+      - run: git --no-pager diff
+      - run: git --no-pager diff --quiet
+      - run: make docsgen-cli
+      - run: git --no-pager diff
+      - run: git --no-pager diff --quiet
+
+  docs-check:
+    executor: golang
+    steps:
+      - install-deps
+      - prepare
+      - run: go install golang.org/x/tools/cmd/goimports
+      - run: zcat build/openrpc/full.json.gz | jq > ../pre-openrpc-full
+      - 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
+    description: |
+      Run golangci-lint.
+    parameters:
+      executor:
+        type: executor
+        default: golang
+      golangci-lint-version:
+        type: string
+        default: 1.27.0
+      concurrency:
+        type: string
+        default: '2'
+        description: |
+          Concurrency used to run linters. Defaults to 2 because NumCPU is not
+          aware of container CPU limits.
+      args:
+        type: string
+        default: ''
+        description: |
+          Arguments to pass to golangci-lint
+    executor: << parameters.executor >>
+    steps:
+      - install-deps
+      - prepare
+      - run:
+          command: make deps
+          no_output_timeout: 30m
+      - go/install-golangci-lint:
+          gobin: $HOME/.local/bin
+          version: << parameters.golangci-lint-version >>
+      - run:
+          name: Lint
+          command: |
+            $HOME/.local/bin/golangci-lint run -v --timeout 2m \
+              --concurrency << parameters.concurrency >> << parameters.args >>
+  lint-all:
+    <<: *lint
+
+  publish:
+    description: publish binary artifacts
+    executor: ubuntu
+    steps:
+      - run:
+          name: Install git jq curl
+          command: apt update && apt install -y git jq curl
+      - checkout
+      - git_fetch_all_tags
+      - checkout
+      - install_ipfs
+      - attach_workspace:
+          at: "."
+      - run:
+          name: Create bundles
+          command: ./scripts/build-bundle.sh
+      - run:
+          name: Publish release
+          command: ./scripts/publish-release.sh
+
+  publish-snapcraft:
+    description: build and push snapcraft
+    machine:
+      image: ubuntu-2004:202104-01
+    resource_class: 2xlarge
+    parameters:
+      channel:
+        type: string
+        default: "edge"
+        description: snapcraft channel
+    steps:
+      - checkout
+      - run:
+          name: install snapcraft
+          command: sudo snap install snapcraft --classic
+      - run:
+          name: create snapcraft config file
+          command: |
+            mkdir -p ~/.config/snapcraft
+            echo "$SNAPCRAFT_LOGIN_FILE" | base64 -d > ~/.config/snapcraft/snapcraft.cfg
+      - run:
+          name: build snap
+          command: snapcraft --use-lxd
+      - run:
+          name: publish snap
+          command: snapcraft push *.snap --release << parameters.channel >>
+
+  build-and-push-image:
+    description: build and push docker images to public AWS ECR registry
+    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)
+
+      target:
+        type: string
+        default: "lotus-all-in-one"
+        description: Docker target to build
+
+    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>> \
+              --target <<parameters.target>> \
+              -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-snap:
+    description: build packer image with snap. mainnet only.
+    executor:
+      name: packer/default
+      packer-version: 1.6.6
+    steps:
+      - checkout
+      - attach_workspace:
+          at: "."
+      - packer/build:
+          template: tools/packer/lotus-snap.pkr.hcl
+  publish-dockerhub:
+    description: publish to dockerhub
+    machine:
+      image: ubuntu-2004:202010-01
+    parameters:
+      tag:
+        type: string
+        default: latest
+    steps:
+      - checkout
+      - run:
+          name: dockerhub login
+          command: echo $DOCKERHUB_PASSWORD | docker login --username $DOCKERHUB_USERNAME --password-stdin
+      - run:
+          name: docker build
+          command: |
+            docker build --target lotus -t filecoin/lotus:<< parameters.tag >> -f Dockerfile.lotus .
+            docker build --target lotus-all-in-one -t filecoin/lotus-all-in-one:<< parameters.tag >> -f Dockerfile.lotus .
+            if [["[[ ! -z $CIRCLE_SHA1 ]]"]]; then
+              docker build --target lotus -t filecoin/lotus:$CIRCLE_SHA1 -f Dockerfile.lotus .
+              docker build --target lotus-all-in-one -t filecoin/lotus-all-in-one:$CIRCLE_SHA1 -f Dockerfile.lotus .
+            fi
+            if [["[[ ! -z $CIRCLE_TAG ]]"]]; then
+              docker build --target lotus -t filecoin/lotus:$CIRCLE_TAG -f Dockerfile.lotus .
+              docker build --target lotus-all-in-one -t filecoin/lotus-all-in-one:$CIRCLE_TAG -f Dockerfile.lotus .
+            fi
+      - run:
+          name: docker push
+          command: |
+            docker push filecoin/lotus:<< parameters.tag >>
+            docker push filecoin/lotus-all-in-one:<< parameters.tag >>
+            if [["[[ ! -z $CIRCLE_SHA1 ]]"]]; then
+              docker push filecoin/lotus:$CIRCLE_SHA1
+              docker push filecoin/lotus-all-in-one:$CIRCLE_SHA1
+            fi
+            if [["[[ ! -z $CIRCLE_TAG ]]"]]; then
+              docker push filecoin/lotus:$CIRCLE_TAG
+              docker push filecoin/lotus-all-in-one:$CIRCLE_TAG
+            fi
+
+workflows:
+  version: 2.1
+  ci:
+    jobs:
+      - lint-all:
+          concurrency: "16"   # expend all docker 2xlarge CPUs.
+      - mod-tidy-check
+      - gofmt
+      - gen-check
+      - docs-check
+
+      [[- range $file := .ItestFiles -]]
+      [[ with $name := $file | stripSuffix ]]
+      - test:
+          name: test-itest-[[ $name ]]
+          suite: itest-[[ $name ]]
+          target: "./itests/[[ $file ]]"
+      [[ end ]]
+      [[- end -]]
+
+      [[range $suite, $pkgs := .UnitSuites]]
+      - test:
+          name: test-[[ $suite ]]
+          suite: utest-[[ $suite ]]
+          target: "[[ $pkgs ]]"
+      [[- end]]
+      - test:
+          go-test-flags: "-run=TestMulticoreSDR"
+          suite: multicore-sdr-check
+          target: "./extern/sector-storage/ffiwrapper"
+          proofs-log-test: "1"
+      - test-conformance:
+          suite: conformance
+          codecov-upload: false
+          target: "./conformance"
+      - test-conformance:
+          name: test-conformance-bleeding-edge
+          codecov-upload: false
+          suite: conformance-bleeding-edge
+          target: "./conformance"
+          vectors-branch: specs-actors-v7
+      - trigger-testplans:
+          filters:
+            branches:
+              only:
+                - master
+      - build-debug
+      - build-all:
+          filters:
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - build-ntwk-calibration:
+          filters:
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - build-ntwk-butterfly:
+          filters:
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - build-lotus-soup
+      - build-macos:
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - build-appimage:
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - publish:
+          requires:
+            - build-all
+            - build-macos
+            - build-appimage
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - build-and-push-image:
+          dockerfile: Dockerfile.lotus
+          path: .
+          repo: lotus-dev
+          tag: '${CIRCLE_SHA1:0:8}'
+          target: lotus-all-in-one
+      - build-and-push-image:
+          dockerfile: Dockerfile.lotus
+          path: .
+          repo: lotus-test
+          tag: '${CIRCLE_SHA1:0:8}'
+          target: lotus-test
+      - publish-packer-mainnet:
+          requires:
+            - build-all
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - publish-packer-calibrationnet:
+          requires:
+            - build-ntwk-calibration
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - publish-packer-butterflynet:
+          requires:
+            - build-ntwk-butterfly
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - publish-snapcraft:
+          name: publish-snapcraft-stable
+          channel: stable
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - publish-dockerhub:
+          name: publish-dockerhub
+          tag: stable
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+
+  nightly:
+    triggers:
+      - schedule:
+          cron: "0 0 * * *"
+          filters:
+            branches:
+              only:
+                - master
+    jobs:
+      - publish-snapcraft:
+          name: publish-snapcraft-nightly
+          channel: edge
+      - publish-dockerhub:
+          name: publish-dockerhub-nightly
+          tag: nightly
+  monthly:
+    triggers:
+      - schedule:
+          cron: "0 0 1 * *"
+          filters:
+            branches:
+              only:
+                - master
+    jobs:
+      - publish-packer-snap

.codecov.yml

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

.gitattributes

@@ -1,2 +0,0 @@
-chain/actors/builtin/*/v* linguist-generated=true
-chain/actors/builtin/*/message* linguist-generated=true

.github/CODEOWNERS

@@ -1,3 +1,6 @@
 # Reference
 # https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/creating-a-repository-on-github/about-code-owners
 
+# Global owners
+# Ensure maintainers team is a requested reviewer for non-draft PRs
+*                       @filecoin-project/lotus-maintainers

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -9,9 +9,15 @@ body:
     options:
       - label: This is **not** a security-related bug/issue. If it is, please follow please follow the [security policy](https://github.com/filecoin-project/lotus/security/policy).
         required: true
+      - label: This is **not** a question or a support request. If you have any lotus related questions, please ask in the [lotus forum](https://github.com/filecoin-project/lotus/discussions).
+        required: true
+      - label: This is **not** a new feature request. If it is, please file a [feature request](https://github.com/filecoin-project/lotus/issues/new?assignees=&labels=need%2Ftriage%2Ckind%2Ffeature&template=feature_request.yml) instead.
+        required: true
+      - label: This is **not** an enhancement request. If it is, please file a [improvement suggestion](https://github.com/filecoin-project/lotus/issues/new?assignees=&labels=need%2Ftriage%2Ckind%2Fenhancement&template=enhancement.yml) instead.
+        required: true
       - label: I **have** searched on the [issue tracker](https://github.com/filecoin-project/lotus/issues) and the [lotus forum](https://github.com/filecoin-project/lotus/discussions), and there is no existing related issue or discussion.
         required: true
-      - label: I am running the [`Latest release`](https://github.com/filecoin-project/lotus/releases), the most recent RC(release canadiate) for the upcoming release or the dev branch(master), or have an issue updating to any of these.
+      - label: I am running the [`Latest release`](https://github.com/filecoin-project/lotus/releases), or the most recent RC(release canadiate) for the upcoming release or the dev branch(master), or have an issue updating to any of these.
         required: true
       - label: I did not make any code changes to lotus.
         required: false
@@ -22,11 +28,19 @@ body:
     options:
       - label: lotus daemon - chain sync
         required: false
-      - label: lotus fvm/fevm - Lotus FVM and FEVM interactions
+      - label: lotus miner - mining and block production
         required: false
       - label: lotus miner/worker - sealing
         required: false
-      - label: lotus miner - proving(WindowPoSt/WinningPoSt)
+      - label: lotus miner - proving(WindowPoSt)
+        required: false
+      - label: lotus miner/market - storage deal
+        required: false
+      - label: lotus miner/market - retrieval deal
+        required: false
+      - label: lotus miner/market - data transfer
+        required: false
+      - label: lotus client
         required: false
       - label: lotus JSON-RPC API
         required: false
@@ -42,33 +56,22 @@ body:
     description: Enter the output of `lotus version` and `lotus-miner version` if applicable.
     placeholder: |
       e.g. 
-      Daemon:  1.19.0+mainnet+git.64059ca87+api1.5.0
-      Local: lotus-miner version 1.19.0+mainnet+git.64059ca87
+      Daemon:1.11.0-rc2+debug+git.0519cd371.dirty+api1.3.0 
+      Local: lotus version 1.11.0-rc2+debug+git.0519cd371.dirty
   validations:
     required: true
-- type: textarea
-  id: ReproSteps
-  attributes:
-    label: Repro Steps
-    description: "Steps to reproduce the behavior"
-    value: |
-      1. Run '...'
-      2. Do '...'
-      3. See error '...'
-      ...
-  validations:
-    required: false
 - type: textarea
   id: Description
   attributes:
     label: Describe the Bug
     description: |
       This is where you get to tell us what went wrong, when doing so, please try to provide a clear and concise description of the bug with all related information:
-      * What you were doing when you experienced the bug?
+      * What you were doding when you experienced the bug?
       * Any *error* messages you saw, *where* you saw them, and what you believe may have caused them (if you have any ideas).
       * What is the expected behaviour?
       * For sealing issues, include the output of `lotus-miner sectors status --log <sectorId>` for the failed sector(s).
       * For proving issues, include the output of `lotus-miner proving` info.
+      * For deal making issues, include the output of `lotus client list-deals -v` and/or `lotus-miner storage-deals|retrieval-deals|data-transfers list [-v]` commands for the deal(s) in question.
   validations:
     required: true
 - type: textarea
@@ -78,8 +81,20 @@ body:
     render: text
     description: |
       Please provide debug logs of the problem, remember you can get set log level control for:
-      * lotus: use `lotus log list` to get all log systems available and set level by `lotus log set-level`. An example can be found [here](https://lotus.filecoin.io/lotus/configure/defaults/#log-level-control).
+      * lotus: use `lotus log list` to get all log systems available and set level by `lotus log set-level`. An example can be found [here](https://docs.filecoin.io/get-started/lotus/configuration-and-advanced-usage/#log-level-control).
       * lotus-miner:`lotus-miner log list` to get all log systems available and set level by `lotus-miner log set-level
-      If you don't provide detailed logs when you raise the issue it will almost certainly be the first request we make before furthur diagnosing the problem.
+      If you don't provide detailed logs when you raise the issue it will almost certainly be the first request I make before furthur diagnosing the problem.
   validations:
-    required: true
+    required: true
+- type: textarea
+  id: RepoSteps
+  attributes:
+    label: Repo Steps
+    description: "Steps to reproduce the behavior"
+    value: |
+      1. Run '...'
+      2. Do '...'
+      3. See error '...'
+      ...
+  validations:
+    required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +0,0 @@
-blank_issues_enabled: true
-contact_links:
-  - name: Ask a question about Lotus or get support
-    url: https://github.com/filecoin-project/lotus/discussions/new/choose
-    about: Ask a question or request support for using Lotus
-  - name: Filecoin protocol feature or enhancement
-    url: https://github.com/filecoin-project/FIPs/discussions/new/choose
-    about: Write a discussion in the Filecoin Improvement Proposal repo

.github/ISSUE_TEMPLATE/enhancement.yml

@@ -7,7 +7,13 @@ body:
     label: Checklist
     description: Please check off the following boxes before continuing to create an improvement suggestion!
     options:
-      - label: I **have** a specific, actionable, and well motivated improvement to an existing lotus feature.
+      - label: This is **not** a new feature or an enhancement to the Filecoin protocol. If it is,  please open an [FIP issue](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0001.md).
+        required: true
+      - label: This is **not** a new feature request. If it is, please file a [feature request](https://github.com/filecoin-project/lotus/issues/new?assignees=&labels=need%2Ftriage%2Ckind%2Ffeature&template=feature_request.yml) instead.
+        required: true
+      - label: This is **not** brainstorming ideas. If you have an idea you'd like to discuss, please open a new discussion on [the lotus forum](https://github.com/filecoin-project/lotus/discussions/categories/ideas) and select the category as `Ideas`.
+        required: true
+      - label: I **have** a specific, actionable, and well motivated improvement to propose.
         required: true
 - type: checkboxes
   attributes:
@@ -16,11 +22,19 @@ body:
     options:
       - label: lotus daemon - chain sync
         required: false
-      - label: lotus fvm/fevm - Lotus FVM and FEVM interactions
+      - label: lotus miner - mining and block production
         required: false
       - label: lotus miner/worker - sealing
         required: false
-      - label: lotus miner - proving(WindowPoSt/WinningPoSt)
+      - label: lotus miner - proving(WindowPoSt)
+        required: false
+      - label: lotus miner/market - storage deal
+        required: false
+      - label: lotus miner/market - retrieval deal
+        required: false
+      - label: lotus miner/market - data transfer
+        required: false
+      - label: lotus client
         required: false
       - label: lotus JSON-RPC API
         required: false
@@ -31,17 +45,9 @@ body:
 - type: textarea
   id: request
   attributes:
-    label: Enhancement Suggestion
-    description: A clear and concise description of the suggested enhancement?
-    placeholder: Ex. Currently lotus... However it would be great if [enhancement] was implemented... With the ability to...
-  validations:
-    required: true
-- type: textarea
-  id: request
-  attributes:
-    label: Use-Case
-    description: How would this enhancement help you?
-    placeholder: Ex. With the [enhancement] node operators would be able to... For Storage Providers it would enable...
+    label: Improvement Suggestion
+    description: A clear and concise description of what the motivation or the current problem is and what is the suggested improvement?
+    placeholder: Ex. Currently lotus... However, as a storage provider, I'd like...
   validations:
     required: true
 

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -7,6 +7,8 @@ body:
     label: Checklist
     description: Please check off the following boxes before continuing to create a new feature request!
     options:
+      - label: This is **not** a new feature or an enhancement to the Filecoin protocol. If it is,  please open an [FIP issue](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0001.md).
+        required: true
       - label: This is **not** brainstorming ideas. If you have an idea you'd like to discuss, please open a new discussion on [the lotus forum](https://github.com/filecoin-project/lotus/discussions/categories/ideas) and select the category as `Ideas`.
         required: true
       - label: I **have** a specific, actionable, and well motivated feature request to propose.
@@ -18,11 +20,19 @@ body:
     options:
       - label: lotus daemon - chain sync
         required: false
-      - label: lotus fvm/fevm - Lotus FVM and FEVM interactions
+      - label: lotus miner - mining and block production
         required: false
       - label: lotus miner/worker - sealing
         required: false
-      - label: lotus miner - proving(WindowPoSt/WinningPoSt)
+      - label: lotus miner - proving(WindowPoSt)
+        required: false
+      - label: lotus miner/market - storage deal
+        required: false
+      - label: lotus miner/market - retrieval deal
+        required: false
+      - label: lotus miner/market - data transfer
+        required: false
+      - label: lotus client
         required: false
       - label: lotus JSON-RPC API
         required: false
@@ -46,7 +56,7 @@ body:
   validations:
     required: true
 - type: textarea
-  id: alternatives
+  id: alternates
   attributes:
     label: Describe alternatives you've considered
     description: A clear and concise description of any alternative solutions or features you've considered.
@@ -59,3 +69,4 @@ body:
     description: Add any other context, design docs or screenshots about the feature request here.
   validations:
     required: false
+

.github/ISSUE_TEMPLATE/service_developer_bug_report.yml

@@ -1,83 +0,0 @@
-name: "Bug Report - developer/service provider"
-description: "Bug report template about FEVM/FVM for developers/service providers"
-labels: [need/triage, kind/bug, area/fevm]
-body:
-- type: checkboxes
-  attributes:
-    label: Checklist
-    description: Please check off the following boxes before continuing to file a bug report!
-    options:
-      - label: This is **not** a security-related bug/issue. If it is, please follow please follow the [security policy](https://github.com/filecoin-project/lotus/security/policy).
-        required: true
-      - label: I **have** searched on the [issue tracker](https://github.com/filecoin-project/lotus/issues) and the [lotus forum](https://github.com/filecoin-project/lotus/discussions), and there is no existing related issue or discussion.
-        required: true
-      - label: I did not make any code changes to lotus.
-        required: false
-- type: checkboxes
-  attributes:
-    label: Lotus component
-    description: Please select the lotus component you are filing a bug for
-    options:
-      - label: lotus Ethereum RPC
-        required: false
-      - label: lotus FVM - Lotus FVM interactions
-        required: false
-      - label: FEVM tooling
-        required: false
-      - label:  Other
-        required: false
-- type: textarea
-  id: version
-  attributes:
-    label: Lotus Version
-    render: text
-    description: Enter the output of `lotus version` if applicable.
-    placeholder: |
-      e.g. 
-      Daemon:  1.19.0+mainnet+git.64059ca87+api1.5.0
-      Local: lotus-miner version 1.19.0+mainnet+git.64059ca87
-  validations:
-    required: true
-- type: textarea
-  id: repro
-  attributes:
-    label: Repro Steps
-    description: "Steps to reproduce the behavior"
-    value: |
-      1. Run '...'
-      2. Do '...'
-      3. See error '...'
-      ...
-  validations:
-    required: false
-- type: textarea
-  id: Description
-  attributes:
-    label: Describe the Bug
-    description: |
-      This is where you get to tell us what went wrong, when doing so, please try to provide a clear and concise description of the bug with all related information:
-      * What you were doing when you experienced the bug? What are you trying to build?
-      * Any *error* messages and logs you saw, *where* you saw them, and what you believe may have caused them (if you have any ideas).
-      * What is the expected behaviour? Links to the actual code?
-  validations:
-    required: true
-- type: textarea
-  id: toolingInfo
-  attributes:
-    label: Tooling
-    render: text
-    description: |
-      What kind of tooling are you using:
-      * Are you using ether.js, Alchemy, Hardhat, etc.
-  validations:
-    required: true
-- type: textarea
-  id: extraInfo
-  attributes:
-    label: Configuration Options
-    render: text
-    description: |
-      Please provide your updated FEVM related configuration options, or custome enviroment variables related to Lotus FEVM
-      * lotus: use `lotus config updated` to get your configuration options, and copy the [FEVM] section
-  validations:
-    required: true

.github/ISSUE_TEMPLATE/task.md

@@ -1,31 +0,0 @@
----
-name: New Task
-about: A larger yet well-scoped task
-title: '<title>'
-labels: Needs Triage
-assignees: ''
-
----
-
-## User Story
-<!-- Why? -->
-
-## Acceptance Criteria
-<!-- What? -->
-<!-- add description-->
-
-```[tasklist]
-### Deliverables
-
-```
-
-## Technical Breakdown
-```[tasklist]
-### Development
-
-```
-
-```[tasklist]
-### Testing
-
-```

.github/actions/install-go/action.yml

@@ -1,16 +0,0 @@
-name: Install Go
-description: Install Go for Filecoin Lotus
-
-runs:
-  using: composite
-  steps:
-    - uses: actions/setup-go@v5
-      with:
-        go-version: stable
-        cache: false
-    - id: go-mod
-      uses: ipdxco/unified-github-workflows/.github/actions/read-go-mod@main
-    - uses: actions/setup-go@v5
-      with:
-        go-version: ${{ fromJSON(steps.go-mod.outputs.json).Go }}.x
-        cache: false

.github/actions/install-system-dependencies/action.yml

@@ -1,21 +0,0 @@
-name: Install System Dependencies
-description: Install System dependencies for Filecoin Lotus
-
-runs:
-  using: composite
-  steps:
-    - if: runner.os == 'Linux'
-      run: |
-        # List processes to enable debugging in case /var/lib/apt/lists/ is locked 
-        ps aux
-        sudo apt-get update -y
-        sudo apt-get install -y ocl-icd-opencl-dev libhwloc-dev pkg-config
-      shell: bash
-    - if: runner.os == 'macOS'
-      env:
-        HOMEBREW_NO_AUTO_UPDATE: '1'
-      run: |
-        brew install hwloc pkg-config
-        echo "CPATH=$(brew --prefix)/include" | tee -a $GITHUB_ENV
-        echo "LIBRARY_PATH=$(brew --prefix)/lib" | tee -a $GITHUB_ENV
-      shell: bash

.github/actions/start-yugabytedb/action.yml

@@ -1,16 +0,0 @@
-name: Start YugabyteDB
-description: Install Yugabyte Database for Filecoin Lotus
-
-runs:
-  using: composite
-  steps:
-    - run: docker run --rm --name yugabyte -d -p 5433:5433 yugabytedb/yugabyte:2.18.0.0-b65 bin/yugabyted start --daemon=false
-      shell: bash
-    - run: |
-        while true; do
-          status=$(docker exec yugabyte bin/yugabyted status);
-          echo $status;
-          echo $status | grep Running && break;
-          sleep 1;
-        done
-      shell: bash

.github/labels.yml

@@ -0,0 +1,248 @@
+###
+### Special magic GitHub labels
+### https://help.github.com/en/github/building-a-strong-community/encouraging-helpful-contributions-to-your-project-with-labels
+#
+- name: "good first issue"
+  color: 7057ff
+  description: "Good for newcomers"
+- name: "help wanted"
+  color: 008672
+  description: "Extra attention is needed"
+
+###
+### Goals
+#
+- name: goal/incentives
+  color: ff004d
+  description: "Incentinet"
+
+###
+### Areas
+#
+- name: area/ux
+  color: 00A4E0
+  description: "Area: UX"
+- name: area/chain/vm
+  color: 00A4E2
+  description: "Area: Chain/VM"
+- name: area/chain/sync
+  color: 00A4E4
+  description: "Area: Chain/Sync"
+- name: area/chain/misc
+  color: 00A4E6
+  description: "Area: Chain/Misc"
+- name: area/markets
+  color: 00A4E8
+  description: "Area: Markets"  
+- name: area/sealing/fsm
+  color: 0bb1ed
+  description: "Area: Sealing/FSM"
+- name: area/sealing/storage
+  color: 0EB4F0
+  description: "Area: Sealing/Storage"
+- name: area/proving
+  color: 0EB4F0
+  description: "Area: Proving"
+- name: area/mining
+  color: 10B6F2
+  description: "Area: Mining"
+- name: area/client/storage
+  color: 13B9F5
+  description: "Area: Client/Storage"
+- name: area/client/retrieval
+  color: 15BBF7
+  description: "Area: Client/Retrieval"
+- name: area/wallet
+  color: 15BBF7
+  description: "Area: Wallet"
+- name: area/payment-channel
+  color: ff6767
+  description: "Area: Payment Channel"
+- name: area/multisig
+  color: fff0ff
+  description: "Area: Multisig"
+- name: area/networking
+  color: 273f8a
+  description: "Area: Networking"
+
+###
+### Kinds
+#
+- name: kind/bug
+  color: c92712
+  description: "Kind: Bug"
+- name: kind/chore
+  color: fcf0b5
+  description: "Kind: Chore"
+- name: kind/feature
+  color: FFF3B8
+  description: "Kind: Feature"
+- name: kind/improvement
+  color: FFF5BA
+  description: "Kind: Improvement"
+- name: kind/test
+  color: FFF8BD
+  description: "Kind: Test"
+- name: kind/question
+  color: FFFDC2
+  description: "Kind: Question"
+- name: kind/enhancement
+  color: FFFFC5
+  description: "Kind: Enhancement"
+- name: kind/discussion
+  color: FFFFC7
+  description: "Kind: Discussion"
+
+###
+### Difficulties
+#
+- name: dif/trivial
+  color: b2b7ff
+  description: "Can be confidently tackled by newcomers, who are widely unfamiliar with lotus"
+- name: dif/easy
+  color: 7886d7
+  description: "An existing lotus user should be able to pick this up"
+- name: dif/medium
+  color: 6574cd
+  description: "Prior development experience with lotus is likely helpful"
+- name: dif/hard
+  color: 5661b3
+  description: "Suggests that having worked on the specific component affected by this issue is important"
+- name: dif/expert
+  color: 2f365f
+  description: "Requires extensive knowledge of the history, implications, ramifications of the issue"
+
+###
+### Efforts
+#
+- name: effort/minutes
+  color: e8fffe
+  description: "Effort: Minutes"
+- name: effort/hours
+  color: a0f0ed
+  description: "Effort: Hours"
+- name: effort/day
+  color: 64d5ca
+  description: "Effort: One Day"
+- name: effort/days
+  color: 4dc0b5
+  description: "Effort: Multiple Days"
+- name: effort/week
+  color: 38a89d
+  description: "Effort: One Week"
+- name: effort/weeks
+  color: 20504f
+  description: "Effort: Multiple Weeks"
+
+###
+### Impacts
+#
+- name: impact/regression
+  color: f1f5f8
+  description: "Impact: Regression"
+- name: impact/api-breakage
+  color: ECF0F3
+  description: "Impact: API Breakage"
+- name: impact/quality
+  color: E7EBEE
+  description: "Impact: Quality"
+- name: impact/dx
+  color: E2E6E9
+  description: "Impact: Developer Experience"
+- name: impact/test-flakiness
+  color: DDE1E4
+  description: "Impact: Test Flakiness"
+- name: impact/consensus
+  color: b20014
+  description: "Impact: Consensus"
+
+###
+### Topics
+#
+- name: topic/interoperability
+  color: bf0f73
+  description: "Topic: Interoperability"
+- name: topic/specs
+  color: CC1C80
+  description: "Topic: Specs"
+- name: topic/docs
+  color: D9298D
+  description: "Topic: Documentation"
+- name: topic/architecture
+  color: E53599
+  description: "Topic: Architecture"
+
+###
+### Priorities
+###
+- name: P0
+  color: dd362a
+  description: "P0: Critical Blocker"
+- name: P1
+  color: ce8048
+  description: "P1: Must be resolved"
+- name: P2
+  color: dbd81a
+  description: "P2: Should be resolved"
+- name: P3
+  color: 9fea8f
+  description: "P3: Might get resolved"
+
+###
+### Hints
+#
+#- name: hint/good-first-issue
+#  color: 7057ff
+#  description: "Hint: Good First Issue"
+#- name: hint/help-wanted
+#  color: 008672
+#  description: "Hint: Help Wanted"
+- name: hint/needs-decision
+  color: 33B9A5
+  description: "Hint: Needs Decision"
+- name: hint/needs-triage
+  color: 1AA08C
+  description: "Hint: Needs Triage"
+- name: hint/needs-analysis
+  color: 26AC98
+  description: "Hint: Needs Analysis"
+- name: hint/needs-author-input
+  color: 33B9A5
+  description: "Hint: Needs Author Input"
+- name: hint/needs-team-input
+  color: 40C6B2
+  description: "Hint: Needs Team Input"
+- name: hint/needs-community-input
+  color: 4DD3BF
+  description: "Hint: Needs Community Input"
+- name: hint/needs-review
+  color: 5AE0CC
+  description: "Hint: Needs Review"
+
+###
+### Statuses
+#
+- name: status/done
+  color: edb3a6
+  description: "Status: Done"
+- name: status/deferred
+  color: E0A699
+  description: "Status: Deferred"
+- name: status/in-progress
+  color: D49A8D
+  description: "Status: In Progress"
+- name: status/blocked
+  color: C78D80
+  description: "Status: Blocked"
+- name: status/inactive
+  color: BA8073
+  description: "Status: Inactive"
+- name: status/waiting
+  color: AD7366
+  description: "Status: Waiting"
+- name: status/rotten
+  color: 7A4033
+  description: "Status: Rotten"
+- name: status/discarded
+  color: 6D3326
+  description: "Status: Discarded / Won't fix"

.github/pull_request_template.md

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

.github/workflows/build.yml

@@ -1,31 +0,0 @@
-name: Build
-
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-      - release/*
-  workflow_dispatch:
-
-defaults:
-  run:
-    shell: bash
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
-permissions: {}
-
-jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: 'recursive'
-      - uses: ./.github/actions/install-system-dependencies
-      - uses: ./.github/actions/install-go
-      - run: make deps lotus

.github/workflows/builtin-actor-tests.yml

@@ -1,22 +0,0 @@
-name: Built-in Actors
-
-on:
-  push:
-    paths:
-      - build/actors
-      - build/builtin_actors_gen.go
-    branches:
-      - release/*
-
-permissions: {}
-
-jobs:
-  release:
-    name: Release Tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
-        with:
-          go-version: 1.21
-      - run: go test -tags=release ./build

.github/workflows/check.yml

@@ -1,82 +0,0 @@
-name: Check
-
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-      - release/*
-  workflow_dispatch:
-
-defaults:
-  run:
-    shell: bash
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
-permissions: {}
-
-jobs:
-  check-docsgen:
-    name: Check (docs-check)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: 'recursive'
-      - uses: ./.github/actions/install-system-dependencies
-      - uses: ./.github/actions/install-go
-      - run: go install golang.org/x/tools/cmd/goimports
-      - run: make deps
-      - run: make docsgen
-      - run: git diff --exit-code
-  check-gen:
-    name: Check (gen-check)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: 'recursive'
-      - uses: ./.github/actions/install-system-dependencies
-      - uses: ./.github/actions/install-go
-      - run: make deps lotus
-      - run: go install golang.org/x/tools/cmd/goimports
-      - run: go install github.com/hannahhoward/cbor-gen-for
-      - run: make gen
-      - run: git diff --exit-code
-      - run: make docsgen-cli
-      - run: git diff --exit-code
-  check-lint:
-    name: Check (lint-all)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: 'recursive'
-      - uses: ./.github/actions/install-system-dependencies
-      - uses: ./.github/actions/install-go
-      - run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
-      - run: make deps
-      - run: golangci-lint run -v --timeout 10m --concurrency 4
-  check-fmt:
-    name: Check (gofmt)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: 'recursive'
-      - uses: ./.github/actions/install-go
-      - run: go fmt ./...
-      - run: git diff --exit-code
-  check-mod-tidy:
-    name: Check (mod-tidy-check)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: 'recursive'
-      - uses: ./.github/actions/install-go
-      - run: go mod tidy -v
-      - run: git diff --exit-code

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,69 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    - uses: actions/setup-go@v1
+      with:
+        go-version: '1.16.4'
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.github/workflows/docker.yml

@@ -1,94 +0,0 @@
-name: Docker
-
-on:
-  push:
-    branches:
-      - master
-      - release/*
-    tags:
-      - v*
-  schedule:
-    - cron: '0 0 * * *'
-  workflow_dispatch:
-
-defaults:
-  run:
-    shell: bash
-
-permissions: {}
-
-jobs:
-  docker:
-    name: Docker (${{ matrix.image }} / ${{ matrix.network }}) [publish=${{ github.ref == 'refs/heads/master' || startsWith(github.ref, 'refs/tags/') }}]
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        image:
-          - lotus-all-in-one
-        network:
-          - mainnet
-          - butterflynet
-          - calibnet
-          - debug
-        include:
-          - image: lotus
-            network: mainnet
-    env:
-      PUBLISH: ${{ github.ref == 'refs/heads/master' || startsWith(github.ref, 'refs/tags/') }}
-    steps:
-      - id: channel
-        env:
-          IS_MASTER: ${{ github.ref == 'refs/heads/master' }}
-          IS_TAG: ${{ startsWith(github.ref, 'refs/tags/') }}
-          IS_RC: ${{ endsWith(github.ref, '-rc') }}
-          IS_SCHEDULED: ${{ github.event_name == 'schedule' }}
-        run: |
-          channel=''
-          if [[ "$IS_MASTER" == 'true' ]]; then
-            if [[ "$IS_SCHEDULED" == 'true' ]]; then
-              channel=nightly
-            else
-              channel=master
-            fi
-          elif [[ "$IS_TAG" == 'true' ]]; then
-            if [[ "$IS_RC" == 'true' ]]; then
-              channel=candidate
-            else
-              channel=stable
-            fi
-          fi
-          echo "channel=$channel" | tee -a $GITHUB_ENV
-      - uses: actions/checkout@v4
-        with:
-          submodules: 'recursive'
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: filecoin/${{ matrix.image }}
-          tags: |
-            type=schedule
-            type=raw,enable=${{ github.event_name != 'schedule' && steps.channel.outputs.channel != '' }},value=${{ steps.channel.outputs.channel }}
-            type=ref,event=tag
-            type=sha,prefix=
-          flavor: |
-            latest=false
-            suffix=${{ matrix.network != 'mainnet' && format('-{0}', matrix.network) || '' }}
-      - if: env.PUBLISH == 'true'
-        name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ vars.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Build and push if channel is set (channel=${{ steps.channel.outputs.channel }})
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: ${{ env.PUBLISH == 'true' }}
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          build-args: |
-            ${{ matrix.network != 'mainnet' && format('GOFLAGS=-tags={0}', matrix.network) || ''}}

.github/workflows/label-syncer.yml

@@ -0,0 +1,17 @@
+
+name: Label syncer
+on:
+  push:
+    paths:
+      - '.github/labels.yml'
+    branches:
+      - master
+jobs:
+  build:
+    name: Sync labels
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@1.0.0
+      - uses: micnncim/action-label-syncer@v1.0.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release.yml

@@ -1,105 +0,0 @@
-name: Release
-
-on:
-  push:
-    branches:
-      - ci/*
-      - release/*
-    tags:
-      - v*
-  workflow_dispatch:
-
-defaults:
-  run:
-    shell: bash
-
-permissions: {}
-
-jobs:
-  build:
-    name: Build (${{ matrix.os }}/${{ matrix.arch }})
-    runs-on: ${{ matrix.runner }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - runner: ubuntu-latest
-            os: Linux
-            arch: X64
-          - runner: macos-13
-            os: macOS
-            arch: X64
-          - runner: macos-14
-            os: macOS
-            arch: ARM64
-    steps:
-      - env:
-          OS: ${{ matrix.os }}
-          ARCH: ${{ matrix.arch }}
-        run: |
-          if [[ "$OS" != "$RUNNER_OS" || "$ARCH" != "$RUNNER_ARCH" ]]; then
-            echo "::error title=Unexpected Runner::Expected $OS/$ARCH, got $RUNNER_OS/$RUNNER_ARCH"
-            exit 1
-          fi
-      - uses: actions/checkout@v4
-        with:
-          submodules: 'recursive'
-      - uses: ./.github/actions/install-system-dependencies
-      - uses: ./.github/actions/install-go
-      - env:
-          GITHUB_TOKEN: ${{ github.token }}
-        run: make deps lotus lotus-miner lotus-worker
-      - if: runner.os == 'macOS'
-        run: otool -hv lotus
-      - run: ./scripts/version-check.sh ./lotus
-      - uses: actions/upload-artifact@v4
-        with:
-          name: lotus-${{ matrix.os }}-${{ matrix.arch }}
-          path: |
-            lotus
-            lotus-miner
-            lotus-worker
-  release:
-    name: Release [publish=${{ startsWith(github.ref, 'refs/tags/') }}]
-    permissions:
-      # This enables the job to create and/or update GitHub releases
-      contents: write
-    runs-on: ubuntu-latest
-    needs: [build]
-    env:
-      PUBLISH: ${{ startsWith(github.ref, 'refs/tags/') }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: 'recursive'
-          fetch-depth: 0
-      - uses: actions/download-artifact@v4
-        with:
-          name: lotus-Linux-X64
-          path: linux_amd64_v1
-      - uses: actions/download-artifact@v4
-        with:
-          name: lotus-macOS-X64
-          path: darwin_amd64_v1
-      - uses: actions/download-artifact@v4
-        with:
-          name: lotus-macOS-ARM64
-          path: darwin_arm64
-      - uses: ./.github/actions/install-go
-      - uses: ipfs/download-ipfs-distribution-action@v1
-        with:
-          name: kubo
-          version: v0.16.0
-      - uses: goreleaser/goreleaser-action@7ec5c2b0c6cdda6e8bbb49444bc797dd33d74dd8 # v5.0.0
-        with:
-          distribution: goreleaser-pro
-          version: latest
-          args: release --clean --debug ${{ env.PUBLISH == 'false' && '--snapshot' || '' }}
-        env:
-          GITHUB_TOKEN: ${{ env.PUBLISH == 'true' && github.token || '' }}
-          GORELEASER_KEY: ${{ env.PUBLISH == 'true' && secrets.GORELEASER_KEY || '' }}
-      - run: ./scripts/generate-checksums.sh
-      - if: env.PUBLISH == 'true'
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-        run: ./scripts/publish-checksums.sh

.github/workflows/sorted-pr-checks.yml

@@ -1,32 +0,0 @@
-name: Comment with sorted PR checks
-
-on:
-  workflow_dispatch:
-    inputs:
-      pull_number:
-        description: 'Pull request number'
-        required: true
-  workflow_run:
-    workflows:
-      - Build
-      - Check
-      - CodeQL
-      - Test
-    types:
-      - requested
-      - completed
-
-permissions:
-  pull-requests: write
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.inputs.pull_number || github.event.workflow_run.pull_requests[0].number || 'unknown' }}
-  cancel-in-progress: true
-
-jobs:
-  comment:
-    if: github.event.inputs.pull_number || github.event.workflow_run.pull_requests[0]
-    uses: ipdxco/sorted-pr-checks/.github/workflows/comment.yml@v1
-    with:
-      pull_number: ${{ github.event.inputs.pull_number || github.event.workflow_run.pull_requests[0].number }}
-      template: unsuccessful_only

.github/workflows/stale.yml

@@ -4,18 +4,18 @@ on:
   schedule:
   - cron: '0 12 * * *'
 
-permissions: {}
-
 jobs:
   stale:
+
+    runs-on: ubuntu-latest
     permissions:
       issues: write
       pull-requests: write
-    runs-on: ubuntu-latest
+
     steps:
-    - uses: actions/stale@v9
+    - uses: actions/stale@v3
       with:
-        repo-token: ${{ github.token }}
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
         stale-issue-message: 'Oops, seems like we needed more information for this issue, please comment with more details or this issue will be closed in 24 hours.'
         close-issue-message: 'This issue was closed because it is missing author input.'
         stale-pr-message: 'Thank you for submitting the PR and contributing to lotus! Lotus maintainers need more of your input before merging it, please address the suggested changes or reply to the comments or this PR will be closed in 48 hours. You are always more than welcome to reopen the PR later as well!'
@@ -29,3 +29,5 @@ jobs:
         days-before-pr-close: 2
         remove-stale-when-updated: true
         enable-statistics: true
+
+

.github/workflows/sync-master-main.yaml

@@ -1,19 +1,13 @@
 name: sync-master-main
-
 on:
   push:
     branches:
       - master
-
-permissions: {}
-
 jobs:
   sync:
-    permissions:
-      contents: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
       - name: update remote branch main
         run: |
           # overrides the remote branch (origin:github) `main`

.github/workflows/test.yml

@@ -1,306 +0,0 @@
-name: Test
-
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-      - release/*
-  workflow_dispatch:
-
-defaults:
-  run:
-    shell: bash
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
-permissions: {}
-
-jobs:
-  discover:
-    name: Discover Test Groups
-    runs-on: ubuntu-latest
-    outputs:
-      groups: ${{ steps.test.outputs.groups }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: 'recursive'
-      - id: test
-        env:
-          # Unit test groups other than unit-rest
-          utests: |
-            [
-              {"name": "unit-cli", "packages": ["./cli/...", "./cmd/...", "./api/..."]},
-              {"name": "unit-storage", "packages": ["./storage/...", "./extern/..."]},
-              {"name": "unit-node", "packages": ["./node/..."]}
-            ]
-          # Other tests that require special configuration
-          otests: |
-            [
-              {
-                "name": "multicore-sdr",
-                "packages": ["./storage/sealer/ffiwrapper"],
-                "go_test_flags": "-run=TestMulticoreSDR",
-                "test_rustproofs_logs": "1"
-              }, {
-                "name": "conformance",
-                "packages": ["./conformance"],
-                "go_test_flags": "-run=TestConformance",
-                "skip_conformance": "0"
-              }
-            ]
-          # Mapping from test group names to custom runner labels
-          # The jobs default to running on the default hosted runners (4 CPU, 16 RAM).
-          # We use self-hosted xlarge (4 CPU, 8 RAM; and large - 2 CPU, 4 RAM) runners
-          #   to extend the available runner capacity (60 default hosted runners).
-          # We use self-hosted 4xlarge (16 CPU, 32 RAM; and 2xlarge - 8 CPU, 16 RAM) self-hosted
-          #   to support resource intensive jobs.
-          runners: |
-            {
-              "itest-deals_concurrent": ["self-hosted", "linux", "x64", "4xlarge"],
-              "itest-sector_pledge": ["self-hosted", "linux", "x64", "4xlarge"],
-              "itest-worker": ["self-hosted", "linux", "x64", "4xlarge"],
-
-              "itest-gateway": ["self-hosted", "linux", "x64", "2xlarge"],
-              "itest-sector_import_full": ["self-hosted", "linux", "x64", "2xlarge"],
-              "itest-sector_import_simple": ["self-hosted", "linux", "x64", "2xlarge"],
-              "itest-wdpost": ["self-hosted", "linux", "x64", "2xlarge"],
-              "unit-storage": ["self-hosted", "linux", "x64", "2xlarge"],
-
-              "itest-batch_deal": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-cli": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-deals_512mb": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-deals_anycid": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-deals_invalid_utf8_label": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-deals_max_staging_deals": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-deals_partial_retrieval": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-deals_publish": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-deals_remote_retrieval": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-decode_params": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-dup_mpool_messages": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-eth_account_abstraction": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-eth_api": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-eth_balance": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-eth_bytecode": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-eth_config": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-eth_conformance": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-eth_deploy": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-eth_fee_history": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-eth_transactions": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-fevm_address": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-fevm_events": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-gas_estimation": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-get_messages_in_ts": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-lite_migration": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-lookup_robust_address": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-mempool": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-mpool_msg_uuid": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-mpool_push_with_uuid": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-msgindex": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-multisig": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-net": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-nonce": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-path_detach_redeclare": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-pending_deal_allocation": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-remove_verifreg_datacap": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-sector_miner_collateral": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-sector_numassign": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-self_sent_txn": ["self-hosted", "linux", "x64", "xlarge"],
-              "itest-verifreg": ["self-hosted", "linux", "x64", "xlarge"],
-              "multicore-sdr": ["self-hosted", "linux", "x64", "xlarge"],
-              "unit-node": ["self-hosted", "linux", "x64", "xlarge"]
-            }
-          # A list of test groups that require YugabyteDB to be running
-          yugabytedb: |
-            ["itest-harmonydb", "itest-harmonytask", "itest-curio"]
-          # A list of test groups that require Proof Parameters to be fetched
-          parameters: |
-            [
-              "conformance",
-              "itest-api",
-              "itest-deals_offline",
-              "itest-deals_padding",
-              "itest-deals_partial_retrieval_dm-level",
-              "itest-deals_pricing",
-              "itest-deals",
-              "itest-direct_data_onboard_verified",
-              "itest-direct_data_onboard",
-              "itest-net",
-              "itest-path_detach_redeclare",
-              "itest-path_type_filters",
-              "itest-sealing_resources",
-              "itest-sector_finalize_early",
-              "itest-sector_import_full",
-              "itest-sector_import_simple",
-              "itest-sector_pledge",
-              "itest-sector_unseal",
-              "itest-wdpost_no_miner_storage",
-              "itest-wdpost_worker_config",
-              "itest-wdpost",
-              "itest-worker_upgrade",
-              "itest-worker",
-              "multicore-sdr",
-              "unit-cli",
-              "unit-storage"
-            ]
-        run: |
-          # Create a list of integration test groups
-          itests="$(
-            find ./itests -name "*_test.go" | \
-              jq -R '{
-                "name": "itest-\(. | split("/") | .[2] | sub("_test.go$";""))",
-                "packages": [.]
-              }' | jq -s
-            )"
-
-          # Create a list of packages that are covered by the integration and unit tests
-          packages="$(jq -n --argjson utests "$utests" '$utests | map(.packages) | flatten | . + ["./itests/..."]')"
-
-          # Create a new group for the unit tests that are not yet covered
-          rest="$(
-            find . -name "*_test.go" | cut -d/ -f2 | sort | uniq | \
-              jq -R '"./\(.)/..."' | \
-              jq -s --argjson p "$packages" '{"name": "unit-rest", "packages": (. - $p)}'
-          )"
-
-          # Combine the groups for integration tests, unit tests, the new unit-rest group, and the other tests
-          groups="$(jq -n --argjson i "$itests" --argjson u "$utests" --argjson r "$rest" --argjson o "$otests" '$i + $u + [$r] + $o')"
-
-          # Apply custom runner labels to the groups
-          groups="$(jq -n --argjson g "$groups" --argjson r "$runners" '$g | map(. + {"runner": (.name as $n | $r | .[$n]) })')"
-
-          # Apply the needs_yugabytedb flag to the groups
-          groups="$(jq -n --argjson g "$groups" --argjson y "$yugabytedb" '$g | map(. + {"needs_yugabytedb": ([.name] | inside($y)) })')"
-
-          # Apply the needs_parameters flag to the groups
-          groups="$(jq -n --argjson g "$groups" --argjson p "$parameters" '$g | map(. + {"needs_parameters": ([.name] | inside($p)) })')"
-
-          # Output the groups
-          echo "groups=$groups"
-          echo "groups=$(jq -nc --argjson g "$groups" '$g')" >> $GITHUB_OUTPUT
-  cache:
-    name: Cache Dependencies
-    runs-on: ubuntu-latest
-    outputs:
-      fetch_params_key: ${{ steps.fetch_params.outputs.key }}
-      fetch_params_path: ${{ steps.fetch_params.outputs.path }}
-      make_deps_key: ${{ steps.make_deps.outputs.key }}
-      make_deps_path: ${{ steps.make_deps.outputs.path }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: 'recursive'
-      - id: fetch_params
-        env:
-          CACHE_KEY: fetch-params-${{ hashFiles('./extern/filecoin-ffi/parameters.json') }}
-          CACHE_PATH: |
-            /var/tmp/filecoin-proof-parameters/
-        run: |
-          echo -e "key=$CACHE_KEY" | tee -a $GITHUB_OUTPUT
-          echo -e "path<<EOF\n$CACHE_PATH\nEOF" | tee -a $GITHUB_OUTPUT
-      - id: make_deps
-        env:
-          CACHE_KEY: ${{ runner.os }}-${{ runner.arch }}-make-deps-${{ hashFiles('./extern/filecoin-ffi/install-filcrypto') }}-${{ hashFiles('./extern/filecoin-ffi/rust/rustc-target-features-optimized.json') }}
-          CACHE_PATH: |
-            ./extern/filecoin-ffi/filcrypto.h
-            ./extern/filecoin-ffi/libfilcrypto.a
-            ./extern/filecoin-ffi/filcrypto.pc
-        run: |
-          echo -e "key=$CACHE_KEY" | tee -a $GITHUB_OUTPUT
-          echo -e "path<<EOF\n$CACHE_PATH\nEOF" | tee -a $GITHUB_OUTPUT
-      - id: restore_fetch_params
-        uses: actions/cache/restore@v4
-        with:
-          key: ${{ steps.fetch_params.outputs.key }}
-          path: ${{ steps.fetch_params.outputs.path }}
-          lookup-only: true
-      - id: restore_make_deps
-        uses: actions/cache/restore@v4
-        with:
-          key: ${{ steps.make_deps.outputs.key }}
-          path: ${{ steps.make_deps.outputs.path }}
-          lookup-only: true
-      - if: steps.restore_fetch_params.outputs.cache-hit != 'true'
-        uses: ./.github/actions/install-system-dependencies
-      - if: steps.restore_fetch_params.outputs.cache-hit != 'true'
-        uses: ./.github/actions/install-go
-      - if: steps.restore_fetch_params.outputs.cache-hit != 'true' || steps.restore_make_deps.outputs.cache-hit != 'true'
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-        run: make deps
-      - if: steps.restore_fetch_params.outputs.cache-hit != 'true'
-        run: make lotus
-      - if: steps.restore_fetch_params.outputs.cache-hit != 'true'
-        run: ./lotus fetch-params 2048
-      - if: steps.restore_fetch_params.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v4
-        with:
-          key: ${{ steps.fetch_params.outputs.key }}
-          path: ${{ steps.fetch_params.outputs.path }}
-      - if: steps.restore_make_deps.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v4
-        with:
-          key: ${{ steps.make_deps.outputs.key }}
-          path: ${{ steps.make_deps.outputs.path }}
-  test:
-    needs: [discover, cache]
-    name: Test (${{ matrix.name }})
-    runs-on: ${{ github.repository == 'filecoin-project/lotus' && matrix.runner || 'ubuntu-latest' }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include: ${{ fromJson(needs.discover.outputs.groups) }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: 'recursive'
-      - uses: ./.github/actions/install-system-dependencies
-      - uses: ./.github/actions/install-go
-      - run: go install gotest.tools/gotestsum@latest
-      - name: Restore cached make deps outputs
-        uses: actions/cache/restore@v4
-        with:
-          key: ${{ needs.cache.outputs.make_deps_key }}
-          path: ${{ needs.cache.outputs.make_deps_path }}
-          fail-on-cache-miss: true
-      - if: ${{ matrix.needs_parameters }}
-        name: Restore cached fetch params outputs
-        uses: actions/cache/restore@v4
-        with:
-          key: ${{ needs.cache.outputs.fetch_params_key }}
-          path: ${{ needs.cache.outputs.fetch_params_path }}
-          fail-on-cache-miss: true
-      - if: ${{ matrix.needs_yugabytedb }}
-        uses: ./.github/actions/start-yugabytedb
-        timeout-minutes: 3
-      # TODO: Install statediff (used to be used for conformance)
-      - id: reports
-        run: mktemp -d | xargs -0 -I{} echo "path={}" | tee -a $GITHUB_OUTPUT
-      # TODO: Track coverage (used to be tracked for conformance)
-      - env:
-          NAME: ${{ matrix.name }}
-          LOTUS_SRC_DIR: ${{ github.workspace }}
-          LOTUS_HARMONYDB_HOSTS: 127.0.0.1
-          REPORTS_PATH: ${{ steps.reports.outputs.path }}
-          SKIP_CONFORMANCE: ${{ matrix.skip_conformance || '1' }}
-          TEST_RUSTPROOFS_LOGS: ${{ matrix.test_rustproofs_logs || '0' }}
-          FORMAT: ${{ matrix.format || 'standard-verbose' }}
-          PACKAGES: ${{ join(matrix.packages, ' ') }}
-        run: |
-          gotestsum \
-            --format "$FORMAT" \
-            --junitfile "$REPORTS_PATH/$NAME.xml" \
-            --jsonfile "$REPORTS_PATH/$NAME.json" \
-            --packages="$PACKAGES" \
-            -- ${{ matrix.go_test_flags || '' }}
-      - if: success() || failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ matrix.name }}
-          path: |
-            ${{ steps.reports.outputs.path }}/${{ matrix.name }}.xml
-            ${{ steps.reports.outputs.path }}/${{ matrix.name }}.json
-        continue-on-error: true

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

@@ -0,0 +1,29 @@
+---
+name: Testground PR Checker
+
+on: [push]
+
+jobs:
+  testground:
+    runs-on: ubuntu-latest
+    name: ${{ matrix.composition_file }}
+    strategy:
+      matrix:
+        include:
+          - backend_addr: ci.testground.ipfs.team
+            backend_proto: https
+            plan_directory: testplans/lotus-soup
+            composition_file: testplans/lotus-soup/_compositions/baseline-k8s-3-1.toml
+          - backend_addr: ci.testground.ipfs.team
+            backend_proto: https
+            plan_directory: testplans/lotus-soup
+            composition_file: testplans/lotus-soup/_compositions/paych-stress-k8s.toml
+    steps:
+      - uses: actions/checkout@v2
+      - name: testground run
+        uses: coryschwartz/testground-github-action@v1.1
+        with:
+          backend_addr: ${{ matrix.backend_addr }}
+          backend_proto: ${{ matrix.backend_proto }}
+          plan_directory: ${{ matrix.plan_directory }}
+          composition_file: ${{ matrix.composition_file }}

.gitignore

@@ -1,3 +1,6 @@
+/AppDir
+/appimage-builder-cache
+*.AppImage
 /lotus
 /lotus-miner
 /lotus-worker
@@ -6,8 +9,7 @@
 /lotus-chainwatch
 /lotus-shed
 /lotus-sim
-/curio
-/sptool
+/lotus-pond
 /lotus-townhall
 /lotus-fountain
 /lotus-stats
@@ -19,6 +21,8 @@
 /docgen-md
 /docgen-openrpc
 /bench.json
+/lotuspond/front/node_modules
+/lotuspond/front/build
 /cmd/lotus-townhall/townhall/node_modules
 /cmd/lotus-townhall/townhall/build
 /cmd/lotus-townhall/townhall/package-lock.json
@@ -37,25 +41,10 @@ build/paramfetch.sh
 /darwin
 /linux
 *.snap
-devgen.car
-localnet.json
-/*.ndjson
 
 *-fuzz.zip
 /chain/types/work_msg/
 bin/ipget
 bin/tmp/*
 .idea
-.vscode
 scratchpad
-
-build/builtin-actors/v*
-build/builtin-actors/*.car
-
-dist/
-
-
-# The following files are checked into git and result
-# in dirty git state if removed from the docker context
-!extern/filecoin-ffi/rust/filecoin.pc
-!extern/test-vectors

.golangci.yml

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

.goreleaser.yaml

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

AppDir/usr/share/icons/icon.svg

@@ -0,0 +1 @@
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0" y="0" viewBox="0 0 127 127" xml:space="preserve" enable-background="new 0 0 127 127"><style type="text/css">.st0{fill:#00d2d6}.st1{fill:#fff}</style><g><path class="st0" d="M63.5,127C28.5,127.1-0.2,98.4,0,63.2C0.2,28.3,28.6-0.2,63.9,0c34.8,0.2,63.3,28.7,63.1,64 C126.7,98.7,98.5,127.1,63.5,127z M71.4,57.6c5.5,0.8,11,1.5,16.5,2.3c0.5-1.7,0.9-3.1,1.3-4.7c-5.7-0.8-11.2-1.7-17.1-2.5 c2-7,3.7-13.7,5.8-20.2c0.7-2.2,2.3-4.2,3.9-5.9c2.1-2.2,5-1.7,6.8,0.7c0.7,1,1.4,2.1,2.3,2.9c1.1,1.1,2.8,1.6,4,0.6 c0.8-0.7,0.7-2.4,0.8-3.6c0-0.5-0.6-1.1-1-1.6c-2-2.3-4.7-3.1-7.5-3.2c-6.3-0.3-10.9,3-14.5,7.8c-3.5,4.8-5.1,10.5-6.8,16.2 c-0.5,1.6-0.9,3.3-1.4,5.1c-6.2-0.9-12.1-1.7-18.2-2.6c-0.2,1.6-0.4,3.2-0.6,4.8c6,0.9,11.8,1.8,17.8,2.7c-0.8,3.4-1.5,6.5-2.3,9.7 c-5.8-0.8-11.4-1.6-17-2.4c-0.2,1.8-0.4,3.2-0.6,4.8c5.6,0.9,11,1.7,16.5,2.5c0,0.6,0.1,1,0,1.3c-1.7,7.4-3.4,14.8-5.3,22.2 c-0.9,3.5-2.4,6.9-5.3,9.3c-2.4,2-5,1.7-6.8-0.8c-0.8-1.1-1.5-2.5-2.6-3.3c-0.8-0.6-2.5-0.9-3.1-0.5c-0.9,0.7-1.5,2.2-1.4,3.3 c0.1,1,1,2.2,1.9,2.8c3,2.3,6.5,2.6,10,1.9c5.9-1.2,10.1-4.9,12.7-10.1c2-4.1,3.6-8.5,5-12.9c1.3-4,2.2-8,3.3-12.2 c5.8,0.8,11.5,1.7,17.3,2.5c0.5-1.7,0.9-3.2,1.4-4.8c-6.1-0.9-11.9-1.7-17.7-2.6C70.1,64,70.7,60.9,71.4,57.6z"/><path class="st1" d="M71.4,57.6c-0.7,3.3-1.3,6.4-2,9.8c5.9,0.9,11.7,1.7,17.7,2.6c-0.5,1.6-0.9,3.1-1.4,4.8 c-5.8-0.8-11.5-1.7-17.3-2.5c-1.1,4.2-2,8.3-3.3,12.2c-1.4,4.4-3,8.7-5,12.9c-2.6,5.2-6.8,8.9-12.7,10.1c-3.5,0.7-7,0.4-10-1.9 c-0.9-0.7-1.8-1.8-1.9-2.8c-0.1-1.1,0.5-2.7,1.4-3.3c0.6-0.5,2.3-0.1,3.1,0.5c1.1,0.8,1.8,2.1,2.6,3.3c1.8,2.5,4.4,2.9,6.8,0.8 c2.9-2.5,4.4-5.8,5.3-9.3c1.9-7.3,3.6-14.8,5.3-22.2c0.1-0.3,0-0.7,0-1.3c-5.4-0.8-10.8-1.7-16.5-2.5c0.2-1.6,0.4-3,0.6-4.8 c5.6,0.8,11.1,1.6,17,2.4c0.8-3.2,1.5-6.4,2.3-9.7c-6-0.9-11.7-1.8-17.8-2.7c0.2-1.6,0.4-3.2,0.6-4.8c6.1,0.9,12,1.7,18.2,2.6 c0.5-1.8,0.9-3.5,1.4-5.1c1.7-5.6,3.2-11.3,6.8-16.2c3.6-4.9,8.1-8.1,14.5-7.8c2.8,0.1,5.5,0.9,7.5,3.2c0.4,0.5,1,1.1,1,1.6 c-0.1,1.2,0,2.9-0.8,3.6c-1.1,1.1-2.8,0.5-4-0.6c-0.9-0.9-1.6-1.9-2.3-2.9c-1.8-2.4-4.7-2.9-6.8-0.7c-1.6,1.7-3.2,3.7-3.9,5.9 C75.7,39.4,74,46,72,53c5.9,0.9,11.4,1.7,17.1,2.5c-0.5,1.6-0.9,3.1-1.3,4.7C82.3,59.1,76.9,58.3,71.4,57.6z"/></g></svg>

AppImageBuilder.yml

@@ -0,0 +1,73 @@
+version: 1
+AppDir:
+  path: ./AppDir
+  app_info:
+    id: io.filecoin.lotus
+    name: Lotus
+    icon: icon
+    version: latest
+    exec: usr/bin/lotus
+    exec_args: $@
+  apt:
+    arch: amd64
+    allow_unauthenticated: true
+    sources:
+    - sourceline: deb http://archive.ubuntu.com/ubuntu/ focal main restricted
+    - sourceline: deb http://archive.ubuntu.com/ubuntu/ focal-updates main restricted
+    - sourceline: deb http://archive.ubuntu.com/ubuntu/ focal universe
+    - sourceline: deb http://archive.ubuntu.com/ubuntu/ focal-updates universe
+    - sourceline: deb http://archive.ubuntu.com/ubuntu/ focal multiverse
+    - sourceline: deb http://archive.ubuntu.com/ubuntu/ focal-updates multiverse
+    - sourceline: deb http://archive.ubuntu.com/ubuntu/ focal-backports main restricted
+        universe multiverse
+    - sourceline: deb http://security.ubuntu.com/ubuntu focal-security main restricted
+    - sourceline: deb http://security.ubuntu.com/ubuntu focal-security universe
+    - sourceline: deb http://security.ubuntu.com/ubuntu focal-security multiverse
+    - sourceline: deb https://cli-assets.heroku.com/apt ./
+    - sourceline: deb http://ppa.launchpad.net/openjdk-r/ppa/ubuntu focal main
+    - sourceline: deb http://ppa.launchpad.net/git-core/ppa/ubuntu focal main
+    - sourceline: deb http://archive.canonical.com/ubuntu focal partner
+    include:
+    - ocl-icd-libopencl1
+    - libhwloc15
+    exclude: []
+  files:
+    include:
+    - /usr/lib/x86_64-linux-gnu/libgcc_s.so.1
+    - /usr/lib/x86_64-linux-gnu/libpthread-2.31.so
+    - /usr/lib/x86_64-linux-gnu/libm-2.31.so
+    - /usr/lib/x86_64-linux-gnu/libdl-2.31.so
+    - /usr/lib/x86_64-linux-gnu/libc-2.31.so
+    - /usr/lib/x86_64-linux-gnu/libudev.so.1.6.17
+    exclude:
+    - usr/share/man
+    - usr/share/doc/*/README.*
+    - usr/share/doc/*/changelog.*
+    - usr/share/doc/*/NEWS.*
+    - usr/share/doc/*/TODO.*
+  test:
+    fedora:
+      image: appimagecrafters/tests-env:fedora-30
+      command: ./AppRun
+      use_host_x: false
+    debian:
+      image: appimagecrafters/tests-env:debian-stable
+      command: ./AppRun
+      use_host_x: false
+    arch:
+      image: appimagecrafters/tests-env:archlinux-latest
+      command: ./AppRun
+      use_host_x: false
+    centos:
+      image: appimagecrafters/tests-env:centos-7
+      command: ./AppRun
+      use_host_x: false
+    ubuntu:
+      image: appimagecrafters/tests-env:ubuntu-xenial
+      command: ./AppRun
+      use_host_x: false
+AppImage:
+  arch: x86_64
+  update-information: guess
+  sign-key: None
+

Dockerfile

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

Dockerfile.lotus

@@ -0,0 +1,255 @@
+FROM golang:1.16.4 AS builder-deps
+MAINTAINER Lotus Development Team
+
+RUN apt-get update && apt-get install -y ca-certificates build-essential clang ocl-icd-opencl-dev ocl-icd-libopencl1 jq libhwloc-dev
+
+ARG RUST_VERSION=nightly
+ENV XDG_CACHE_HOME="/tmp"
+
+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-test
+MAINTAINER Lotus Development Team
+
+WORKDIR /opt/filecoin
+
+RUN make debug
+
+
+FROM builder-local AS builder
+MAINTAINER Lotus Development Team
+
+WORKDIR /opt/filecoin
+
+ARG RUSTFLAGS=""
+ARG GOFLAGS=""
+
+RUN make lotus lotus-miner lotus-worker lotus-shed lotus-wallet lotus-gateway lotus-stats
+
+
+FROM ubuntu:20.04 AS base
+MAINTAINER Lotus Development Team
+
+# Base resources
+COPY --from=builder /etc/ssl/certs                           /etc/ssl/certs
+COPY --from=builder /lib/x86_64-linux-gnu/libdl.so.2         /lib/
+COPY --from=builder /lib/x86_64-linux-gnu/librt.so.1         /lib/
+COPY --from=builder /lib/x86_64-linux-gnu/libgcc_s.so.1      /lib/
+COPY --from=builder /lib/x86_64-linux-gnu/libutil.so.1       /lib/
+COPY --from=builder /usr/lib/x86_64-linux-gnu/libltdl.so.7   /lib/
+COPY --from=builder /usr/lib/x86_64-linux-gnu/libnuma.so.1   /lib/
+COPY --from=builder /usr/lib/x86_64-linux-gnu/libhwloc.so.5  /lib/
+COPY --from=builder /usr/lib/x86_64-linux-gnu/libOpenCL.so.1 /lib/
+
+RUN useradd -r -u 532 -U fc \
+ && mkdir -p /etc/OpenCL/vendors \
+ && echo "libnvidia-opencl.so.1" > /etc/OpenCL/vendors/nvidia.icd
+
+###
+FROM base AS lotus
+MAINTAINER Lotus Development Team
+
+COPY --from=builder /opt/filecoin/lotus /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-shed /usr/local/bin/
+COPY scripts/docker-lotus-entrypoint.sh /
+
+ENV FILECOIN_PARAMETER_CACHE /var/tmp/filecoin-proof-parameters
+ENV LOTUS_PATH /var/lib/lotus
+ENV DOCKER_LOTUS_IMPORT_SNAPSHOT https://fil-chain-snapshots-fallback.s3.amazonaws.com/mainnet/minimal_finality_stateroots_latest.car
+ENV DOCKER_LOTUS_IMPORT_WALLET ""
+
+RUN mkdir /var/lib/lotus /var/tmp/filecoin-proof-parameters
+RUN chown fc: /var/lib/lotus /var/tmp/filecoin-proof-parameters
+
+VOLUME /var/lib/lotus
+VOLUME /var/tmp/filecoin-proof-parameters
+
+USER fc
+
+EXPOSE 1234
+
+ENTRYPOINT ["/docker-lotus-entrypoint.sh"]
+
+CMD ["-help"]
+
+###
+FROM base AS lotus-wallet
+MAINTAINER Lotus Development Team
+
+COPY --from=builder /opt/filecoin/lotus-wallet /usr/local/bin/
+
+ENV WALLET_PATH /var/lib/lotus-wallet
+
+RUN mkdir /var/lib/lotus-wallet
+RUN chown fc: /var/lib/lotus-wallet
+
+VOLUME /var/lib/lotus-wallet
+
+USER fc
+
+EXPOSE 1777
+
+ENTRYPOINT ["/usr/local/bin/lotus-wallet"]
+
+CMD ["-help"]
+
+###
+FROM base AS lotus-gateway
+MAINTAINER Lotus Development Team
+
+COPY --from=builder /opt/filecoin/lotus-gateway /usr/local/bin/
+
+USER fc
+
+EXPOSE 1234
+
+ENTRYPOINT ["/usr/local/bin/lotus-gateway"]
+
+CMD ["-help"]
+
+
+###
+FROM base AS lotus-miner
+MAINTAINER Lotus Development Team
+
+COPY --from=builder /opt/filecoin/lotus-miner /usr/local/bin/
+COPY scripts/docker-lotus-miner-entrypoint.sh /
+
+ENV FILECOIN_PARAMETER_CACHE /var/tmp/filecoin-proof-parameters
+ENV LOTUS_MINER_PATH /var/lib/lotus-miner
+
+RUN mkdir /var/lib/lotus-miner /var/tmp/filecoin-proof-parameters
+RUN chown fc: /var/lib/lotus-miner /var/tmp/filecoin-proof-parameters
+
+VOLUME /var/lib/lotus-miner
+VOLUME /var/tmp/filecoin-proof-parameters
+
+USER fc
+
+EXPOSE 2345
+
+ENTRYPOINT ["/docker-lotus-miner-entrypoint.sh"]
+
+CMD ["-help"]
+
+
+###
+FROM base AS lotus-worker
+MAINTAINER Lotus Development Team
+
+COPY --from=builder /opt/filecoin/lotus-worker /usr/local/bin/
+
+ENV FILECOIN_PARAMETER_CACHE /var/tmp/filecoin-proof-parameters
+ENV LOTUS_WORKER_PATH /var/lib/lotus-worker
+
+RUN mkdir /var/lib/lotus-worker
+RUN chown fc: /var/lib/lotus-worker
+
+VOLUME /var/lib/lotus-worker
+
+USER fc
+
+EXPOSE 3456
+
+ENTRYPOINT ["/usr/local/bin/lotus-worker"]
+
+CMD ["-help"]
+
+
+###
+from base as lotus-all-in-one
+
+ENV FILECOIN_PARAMETER_CACHE /var/tmp/filecoin-proof-parameters
+ENV LOTUS_MINER_PATH /var/lib/lotus-miner
+ENV LOTUS_PATH /var/lib/lotus
+ENV LOTUS_WORKER_PATH /var/lib/lotus-worker
+ENV WALLET_PATH /var/lib/lotus-wallet
+ENV DOCKER_LOTUS_IMPORT_SNAPSHOT https://fil-chain-snapshots-fallback.s3.amazonaws.com/mainnet/minimal_finality_stateroots_latest.car
+
+COPY --from=builder /opt/filecoin/lotus      /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-shed /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-wallet /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-gateway /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-miner /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-worker /usr/local/bin/
+COPY --from=builder /opt/filecoin/lotus-stats /usr/local/bin/
+
+RUN mkdir /var/tmp/filecoin-proof-parameters
+RUN mkdir /var/lib/lotus
+RUN mkdir /var/lib/lotus-miner
+RUN mkdir /var/lib/lotus-worker
+RUN mkdir /var/lib/lotus-wallet
+RUN chown fc: /var/tmp/filecoin-proof-parameters
+RUN chown fc: /var/lib/lotus
+RUN chown fc: /var/lib/lotus-miner
+RUN chown fc: /var/lib/lotus-worker
+RUN chown fc: /var/lib/lotus-wallet
+
+
+VOLUME /var/tmp/filecoin-proof-parameters
+VOLUME /var/lib/lotus
+VOLUME /var/lib/lotus-miner
+VOLUME /var/lib/lotus-worker
+VOLUME /var/lib/lotus-wallet
+
+EXPOSE 1234
+EXPOSE 2345
+EXPOSE 3456
+EXPOSE 1777
+
+###
+from base as lotus-test
+
+ENV FILECOIN_PARAMETER_CACHE /var/tmp/filecoin-proof-parameters
+ENV LOTUS_MINER_PATH /var/lib/lotus-miner
+ENV LOTUS_PATH /var/lib/lotus
+ENV LOTUS_WORKER_PATH /var/lib/lotus-worker
+ENV WALLET_PATH /var/lib/lotus-wallet
+
+COPY --from=builder-test /opt/filecoin/lotus      /usr/local/bin/
+COPY --from=builder-test /opt/filecoin/lotus-miner /usr/local/bin/
+COPY --from=builder-test /opt/filecoin/lotus-worker /usr/local/bin/
+COPY --from=builder-test /opt/filecoin/lotus-seed /usr/local/bin/
+
+RUN mkdir /var/tmp/filecoin-proof-parameters
+RUN mkdir /var/lib/lotus
+RUN mkdir /var/lib/lotus-miner
+RUN mkdir /var/lib/lotus-worker
+RUN mkdir /var/lib/lotus-wallet
+RUN chown fc: /var/tmp/filecoin-proof-parameters
+RUN chown fc: /var/lib/lotus
+RUN chown fc: /var/lib/lotus-miner
+RUN chown fc: /var/lib/lotus-worker
+RUN chown fc: /var/lib/lotus-wallet
+
+
+VOLUME /var/tmp/filecoin-proof-parameters
+VOLUME /var/lib/lotus
+VOLUME /var/lib/lotus-miner
+VOLUME /var/lib/lotus-worker
+VOLUME /var/lib/lotus-wallet
+
+EXPOSE 1234
+EXPOSE 2345
+EXPOSE 3456
+EXPOSE 1777

GO_VERSION_MIN

@@ -1 +0,0 @@
-1.21.7

LOTUS_RELEASE_FLOW.md

@@ -73,7 +73,7 @@ All releases under an odd minor version number indicate **feature releases**. Th
 
 Feature releases include new development and bug fixes. They are not mandatory, but still highly recommended, **as they may contain critical security fixes**. Note that some of these releases may be very small patch releases that include critical hotfixes.  There is no way to distinguish between a bug fix release and a feature release on the "feature" version. Both cases will use the "patch" version number.
 
-We aim to ship a new feature release of the Lotus software from our development (master) branch every 3 weeks, so users can expect a regular cadence of Lotus feature releases. Note that mandatory releases for network upgrades may disrupt this schedule. For more, see the [Release Cycle section](#release-cycle).
+We aim to ship a new feature release of the Lotus software from our development (master) branch every 3 weeks, so users can expect a regular cadence of Lotus feature releases. Note that mandatory releases for network upgrades may disrupt this schedule. For more, see the Release Cycle section (TODO: Link).
 
 ### Examples Scenarios
 

Makefile

@@ -8,11 +8,9 @@ unexport GOFLAGS
 GOCC?=go
 
 GOVERSION:=$(shell $(GOCC) version | tr ' ' '\n' | grep go1 | sed 's/^go//' | awk -F. '{printf "%d%03d%03d", $$1, $$2, $$3}')
-GOVERSIONMIN:=$(shell cat GO_VERSION_MIN | awk -F. '{printf "%d%03d%03d", $$1, $$2, $$3}')
-
-ifeq ($(shell expr $(GOVERSION) \< $(GOVERSIONMIN)), 1)
+ifeq ($(shell expr $(GOVERSION) \< 1016000), 1)
 $(warning Your Golang version is go$(shell expr $(GOVERSION) / 1000000).$(shell expr $(GOVERSION) % 1000000 / 1000).$(shell expr $(GOVERSION) % 1000))
-$(error Update Golang to version to at least $(shell cat GO_VERSION_MIN))
+$(error Update Golang to version to at least 1.16.0)
 endif
 
 # git modules that need to be loaded
@@ -66,7 +64,7 @@ CLEAN+=build/.update-modules
 deps: $(BUILD_DEPS)
 .PHONY: deps
 
-build-devnets: build lotus-seed lotus-shed curio sptool
+build-devnets: build lotus-seed lotus-shed lotus-wallet lotus-gateway
 .PHONY: build-devnets
 
 debug: GOFLAGS+=-tags=debug
@@ -97,21 +95,6 @@ lotus-miner: $(BUILD_DEPS)
 .PHONY: lotus-miner
 BINS+=lotus-miner
 
-curio: $(BUILD_DEPS)
-	rm -f curio
-	$(GOCC) build $(GOFLAGS) -o curio ./cmd/curio
-.PHONY: curio
-BINS+=curio
-
-cu2k: GOFLAGS+=-tags=2k
-cu2k: curio
-
-sptool: $(BUILD_DEPS)
-	rm -f sptool
-	$(GOCC) build $(GOFLAGS) -o sptool ./cmd/sptool
-.PHONY: sptool
-BINS+=sptool
-
 lotus-worker: $(BUILD_DEPS)
 	rm -f lotus-worker
 	$(GOCC) build $(GOFLAGS) -o lotus-worker ./cmd/lotus-worker
@@ -130,13 +113,13 @@ lotus-gateway: $(BUILD_DEPS)
 .PHONY: lotus-gateway
 BINS+=lotus-gateway
 
-build: lotus lotus-miner lotus-worker curio sptool
+build: lotus lotus-miner lotus-worker
 	@[[ $$(type -P "lotus") ]] && echo "Caution: you have \
 an existing lotus binary in your PATH. This may cause problems if you don't run 'sudo make install'" || true
 
 .PHONY: build
 
-install: install-daemon install-miner install-worker install-curio install-sptool
+install: install-daemon install-miner install-worker
 
 install-daemon:
 	install -C ./lotus /usr/local/bin/lotus
@@ -144,36 +127,12 @@ install-daemon:
 install-miner:
 	install -C ./lotus-miner /usr/local/bin/lotus-miner
 
-install-curio:
-	install -C ./curio /usr/local/bin/curio
-
-install-sptool:
-	install -C ./sptool /usr/local/bin/sptool
-
 install-worker:
 	install -C ./lotus-worker /usr/local/bin/lotus-worker
 
 install-app:
 	install -C ./$(APP) /usr/local/bin/$(APP)
 
-uninstall: uninstall-daemon uninstall-miner uninstall-worker
-.PHONY: uninstall
-
-uninstall-daemon:
-	rm -f /usr/local/bin/lotus
-
-uninstall-miner:
-	rm -f /usr/local/bin/lotus-miner
-
-uninstall-curio:
-	rm -f /usr/local/bin/curio
-
-uninstall-sptool:
-	rm -f /usr/local/bin/sptool
-
-uninstall-worker:
-	rm -f /usr/local/bin/lotus-worker
-
 # TOOLS
 
 lotus-seed: $(BUILD_DEPS)
@@ -189,16 +148,28 @@ benchmarks:
 	@curl -X POST 'http://benchmark.kittyhawk.wtf/benchmark' -d '@bench.json' -u "${benchmark_http_cred}"
 .PHONY: benchmarks
 
+lotus-pond: 2k
+	$(GOCC) build -o lotus-pond ./lotuspond
+.PHONY: lotus-pond
+BINS+=lotus-pond
+
+lotus-pond-front:
+	(cd lotuspond/front && npm i && CI=false npm run build)
+.PHONY: lotus-pond-front
+
+lotus-pond-app: lotus-pond-front lotus-pond
+.PHONY: lotus-pond-app
+
 lotus-fountain:
 	rm -f lotus-fountain
-	$(GOCC) build $(GOFLAGS) -o lotus-fountain ./cmd/lotus-fountain
-	$(GOCC) run github.com/GeertJohan/go.rice/rice append --exec lotus-fountain -i ./cmd/lotus-fountain -i ./build
+	go build $(GOFLAGS) -o lotus-fountain ./cmd/lotus-fountain
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-fountain -i ./cmd/lotus-fountain -i ./build
 .PHONY: lotus-fountain
 BINS+=lotus-fountain
 
 lotus-bench:
 	rm -f lotus-bench
-	$(GOCC) build $(GOFLAGS) -o lotus-bench ./cmd/lotus-bench
+	$(GOCC) build -o lotus-bench ./cmd/lotus-bench
 .PHONY: lotus-bench
 BINS+=lotus-bench
 
@@ -220,9 +191,9 @@ lotus-health:
 .PHONY: lotus-health
 BINS+=lotus-health
 
-lotus-wallet: $(BUILD_DEPS)
+lotus-wallet:
 	rm -f lotus-wallet
-	$(GOCC) build $(GOFLAGS) -o lotus-wallet ./cmd/lotus-wallet
+	$(GOCC) build -o lotus-wallet ./cmd/lotus-wallet
 .PHONY: lotus-wallet
 BINS+=lotus-wallet
 
@@ -258,9 +229,7 @@ install-daemon-service: install-daemon
 	install -C -m 0644 ./scripts/lotus-daemon.service /etc/systemd/system/lotus-daemon.service
 	systemctl daemon-reload
 	@echo
-	@echo "lotus-daemon service installed."
-	@echo "To start the service, run: 'sudo systemctl start lotus-daemon'"
-	@echo "To enable the service on startup, run: 'sudo systemctl enable lotus-daemon'"
+	@echo "lotus-daemon service installed. Don't forget to run 'sudo systemctl start lotus-daemon' to start it and 'sudo systemctl enable lotus-daemon' for it to be enabled on startup."
 
 install-miner-service: install-miner install-daemon-service
 	mkdir -p /etc/systemd/system
@@ -268,17 +237,7 @@ install-miner-service: install-miner install-daemon-service
 	install -C -m 0644 ./scripts/lotus-miner.service /etc/systemd/system/lotus-miner.service
 	systemctl daemon-reload
 	@echo
-	@echo "lotus-miner service installed."
-	@echo "To start the service, run: 'sudo systemctl start lotus-miner'"
-	@echo "To enable the service on startup, run: 'sudo systemctl enable lotus-miner'"
-
-install-curio-service: install-curio install-sptool install-daemon-service
-	mkdir -p /etc/systemd/system
-	mkdir -p /var/log/lotus
-	install -C -m 0644 ./scripts/curio.service /etc/systemd/system/curio.service
-	systemctl daemon-reload
-	@echo
-	@echo "Curio service installed. Don't forget to run 'sudo systemctl start curio' to start it and 'sudo systemctl enable curio' for it to be enabled on startup."
+	@echo "lotus-miner service installed. Don't forget to run 'sudo systemctl start lotus-miner' to start it and 'sudo systemctl enable lotus-miner' for it to be enabled on startup."
 
 install-main-services: install-miner-service
 
@@ -298,12 +257,6 @@ clean-miner-service:
 	rm -f /etc/systemd/system/lotus-miner.service
 	systemctl daemon-reload
 
-clean-curio-service:
-	-systemctl stop curio
-	-systemctl disable curio
-	rm -f /etc/systemd/system/curio.service
-	systemctl daemon-reload
-
 clean-main-services: clean-daemon-service
 
 clean-all-services: clean-main-services
@@ -319,10 +272,6 @@ install-completions:
 	install -C ./scripts/bash-completion/lotus /usr/share/bash-completion/completions/lotus
 	install -C ./scripts/zsh-completion/lotus /usr/local/share/zsh/site-functions/_lotus
 
-unittests:
-	@$(GOCC) test $(shell go list ./... | grep -v /lotus/itests)
-.PHONY: unittests
-
 clean:
 	rm -rf $(CLEAN) $(BINS)
 	-$(MAKE) -C $(FFI_PATH) clean
@@ -338,21 +287,14 @@ type-gen: api-gen
 	$(GOCC) generate -x ./...
 	goimports -w api/
 
-actors-code-gen:
+method-gen: api-gen
+	(cd ./lotuspond/front/src/chain && $(GOCC) run ./methodgen.go)
+
+actors-gen:
 	$(GOCC) run ./gen/inline-gen . gen/inlinegen-data.json
 	$(GOCC) run ./chain/actors/agen
 	$(GOCC) fmt ./...
 
-actors-gen: actors-code-gen
-	$(GOCC) run ./scripts/fiximports
-.PHONY: actors-gen
-
-bundle-gen:
-	$(GOCC) run ./gen/bundle $(VERSION) $(RELEASE) $(RELEASE_OVERRIDES)
-	$(GOCC) fmt ./build/...
-.PHONY: bundle-gen
-
-
 api-gen:
 	$(GOCC) run ./gen/api
 	goimports -w api
@@ -371,14 +313,14 @@ appimage: lotus
 	cp ./lotus AppDir/usr/bin/
 	appimage-builder
 
-docsgen: docsgen-md docsgen-openrpc fiximports
+docsgen: docsgen-md docsgen-openrpc
 
 docsgen-md-bin: api-gen actors-gen
 	$(GOCC) build $(GOFLAGS) -o docgen-md ./api/docgen/cmd
 docsgen-openrpc-bin: api-gen actors-gen
 	$(GOCC) build $(GOFLAGS) -o docgen-openrpc ./api/docgen-openrpc/cmd
 
-docsgen-md: docsgen-md-full docsgen-md-storage docsgen-md-worker docsgen-md-curio
+docsgen-md: docsgen-md-full docsgen-md-storage docsgen-md-worker
 
 docsgen-md-full: docsgen-md-bin
 	./docgen-md "api/api_full.go" "FullNode" "api" "./api" > documentation/en/api-v1-unstable-methods.md
@@ -387,73 +329,37 @@ docsgen-md-storage: docsgen-md-bin
 	./docgen-md "api/api_storage.go" "StorageMiner" "api" "./api" > documentation/en/api-v0-methods-miner.md
 docsgen-md-worker: docsgen-md-bin
 	./docgen-md "api/api_worker.go" "Worker" "api" "./api" > documentation/en/api-v0-methods-worker.md
-docsgen-md-curio: docsgen-md-bin
-	./docgen-md "api/api_curio.go" "Curio" "api" "./api" > documentation/en/api-v0-methods-curio.md
 
-docsgen-openrpc: docsgen-openrpc-full docsgen-openrpc-storage docsgen-openrpc-worker docsgen-openrpc-gateway
+docsgen-openrpc: docsgen-openrpc-full docsgen-openrpc-storage docsgen-openrpc-worker
 
 docsgen-openrpc-full: docsgen-openrpc-bin
-	./docgen-openrpc "api/api_full.go" "FullNode" "api" "./api" > build/openrpc/full.json
+	./docgen-openrpc "api/api_full.go" "FullNode" "api" "./api" -gzip > build/openrpc/full.json.gz
 docsgen-openrpc-storage: docsgen-openrpc-bin
-	./docgen-openrpc "api/api_storage.go" "StorageMiner" "api" "./api" > build/openrpc/miner.json
+	./docgen-openrpc "api/api_storage.go" "StorageMiner" "api" "./api" -gzip > build/openrpc/miner.json.gz
 docsgen-openrpc-worker: docsgen-openrpc-bin
-	./docgen-openrpc "api/api_worker.go" "Worker" "api" "./api" > build/openrpc/worker.json
-docsgen-openrpc-gateway: docsgen-openrpc-bin
-	./docgen-openrpc "api/api_gateway.go" "Gateway" "api" "./api" > build/openrpc/gateway.json
+	./docgen-openrpc "api/api_worker.go" "Worker" "api" "./api" -gzip > build/openrpc/worker.json.gz
 
 .PHONY: docsgen docsgen-md-bin docsgen-openrpc-bin
 
-fiximports:
-	$(GOCC) run ./scripts/fiximports
-
-gen: actors-code-gen type-gen cfgdoc-gen docsgen api-gen
-	$(GOCC) run ./scripts/fiximports
-	@echo ">>> IF YOU'VE MODIFIED THE CLI OR CONFIG, REMEMBER TO ALSO RUN 'make docsgen-cli'"
+gen: actors-gen type-gen method-gen cfgdoc-gen docsgen api-gen circleci
+	@echo ">>> IF YOU'VE MODIFIED THE CLI OR CONFIG, REMEMBER TO ALSO MAKE docsgen-cli"
 .PHONY: gen
 
 jen: gen
 
-snap: lotus lotus-miner lotus-worker curio sptool
+snap: lotus lotus-miner lotus-worker
 	snapcraft
 	# snapcraft upload ./lotus_*.snap
 
 # separate from gen because it needs binaries
-docsgen-cli: lotus lotus-miner lotus-worker curio sptool
-	python3 ./scripts/generate-lotus-cli.py
+docsgen-cli: lotus lotus-miner lotus-worker
+	python ./scripts/generate-lotus-cli.py
 	./lotus config default > documentation/en/default-lotus-config.toml
 	./lotus-miner config default > documentation/en/default-lotus-miner-config.toml
-	./curio config default > documentation/en/default-curio-config.toml
 .PHONY: docsgen-cli
 
 print-%:
 	@echo $*=$($*)
 
-### Curio devnet images
-curio_docker_user?=curio
-curio_base_image=$(curio_docker_user)/curio-all-in-one:latest-debug
-ffi_from_source?=0
-
-curio-devnet: lotus lotus-miner lotus-shed lotus-seed curio sptool
-.PHONY: curio-devnet
-
-curio_docker_build_cmd=docker build --build-arg CURIO_TEST_IMAGE=$(curio_base_image) \
-	--build-arg FFI_BUILD_FROM_SOURCE=$(ffi_from_source) $(docker_args)
-
-docker/curio-all-in-one:
-	$(curio_docker_build_cmd) -f Dockerfile.curio --target curio-all-in-one \
-		-t $(curio_base_image) --build-arg GOFLAGS=-tags=debug .
-.PHONY: docker/curio-all-in-one
-
-docker/%:
-	cd curiosrc/docker/$* && DOCKER_BUILDKIT=1 $(curio_docker_build_cmd) -t $(curio_docker_user)/$*-dev:dev \
-		--build-arg BUILD_VERSION=dev .
-
-docker/curio-devnet: $(lotus_build_cmd) \
-	docker/curio-all-in-one docker/lotus docker/lotus-miner docker/curio docker/yugabyte
-.PHONY: docker/curio-devnet
-
-curio-devnet/up:
-	rm -rf ./curiosrc/docker/data && docker compose -f ./curiosrc/docker/docker-compose.yaml up -d
-
-curio-devnet/down:
-	docker compose -f ./curiosrc/docker/docker-compose.yaml down --rmi=local && sleep 2 && rm -rf ./curiosrc/docker/data
+circleci:
+	go generate -x ./.circleci

README.md

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

api/api_common.go

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

api/api_curio.go

@@ -1,34 +0,0 @@
-package api
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	"github.com/filecoin-project/lotus/storage/sealer/fsutil"
-	"github.com/filecoin-project/lotus/storage/sealer/storiface"
-)
-
-type Curio interface {
-	Version(context.Context) (Version, error) //perm:admin
-
-	AllocatePieceToSector(ctx context.Context, maddr address.Address, piece PieceDealInfo, rawSize int64, source url.URL, header http.Header) (SectorOffset, error) //perm:write
-
-	StorageInit(ctx context.Context, path string, opts storiface.LocalStorageMeta) error                                                                                   //perm:admin
-	StorageAddLocal(ctx context.Context, path string) error                                                                                                                //perm:admin
-	StorageDetachLocal(ctx context.Context, path string) error                                                                                                             //perm:admin
-	StorageList(ctx context.Context) (map[storiface.ID][]storiface.Decl, error)                                                                                            //perm:admin
-	StorageLocal(ctx context.Context) (map[storiface.ID]string, error)                                                                                                     //perm:admin
-	StorageStat(ctx context.Context, id storiface.ID) (fsutil.FsStat, error)                                                                                               //perm:admin
-	StorageInfo(context.Context, storiface.ID) (storiface.StorageInfo, error)                                                                                              //perm:admin
-	StorageFindSector(ctx context.Context, sector abi.SectorID, ft storiface.SectorFileType, ssize abi.SectorSize, allowFetch bool) ([]storiface.SectorStorageInfo, error) //perm:admin
-
-	LogList(ctx context.Context) ([]string, error)                  //perm:read
-	LogSetLevel(ctx context.Context, subsystem, level string) error //perm:admin
-
-	// Trigger shutdown
-	Shutdown(context.Context) error //perm:admin
-}

api/api_errors.go

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

api/api_full.go

@@ -6,33 +6,27 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/google/uuid"
-	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/libp2p/go-libp2p-core/peer"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
-	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
-	"github.com/filecoin-project/go-fil-markets/storagemarket"
-	"github.com/filecoin-project/go-jsonrpc"
+	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/builtin/v8/paych"
-	verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/dline"
-	abinetwork "github.com/filecoin-project/go-state-types/network"
+
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
 
 	apitypes "github.com/filecoin-project/lotus/api/types"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/verifreg"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/types/ethtypes"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/repo/imports"
 )
@@ -43,7 +37,6 @@ import (
 type ChainIO interface {
 	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
-	ChainPutObj(context.Context, blocks.Block) error
 }
 
 const LookbackNoLimit = abi.ChainEpoch(-1)
@@ -129,9 +122,6 @@ type FullNode interface {
 	// ChainHasObj checks if a given CID exists in the chain blockstore.
 	ChainHasObj(context.Context, cid.Cid) (bool, error) //perm:read
 
-	// ChainPutObj puts a given object into the block store
-	ChainPutObj(context.Context, blocks.Block) error //perm:admin
-
 	// ChainStatObj returns statistics about the graph referenced by 'obj'.
 	// If 'base' is also specified, then the returned stat will be a diff
 	// between the two objects.
@@ -153,7 +143,7 @@ type FullNode interface {
 
 	// ChainGetPath returns a set of revert/apply operations needed to get from
 	// one tipset to another, for example:
-	// ```
+	//```
 	//        to
 	//         ^
 	// from   tAA
@@ -162,7 +152,7 @@ type FullNode interface {
 	//  ^---*--^
 	//      ^
 	//     tRR
-	// ```
+	//```
 	// Would return `[revert(tBA), apply(tAB), apply(tAA)]`
 	ChainGetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*HeadChange, error) //perm:read
 
@@ -173,24 +163,6 @@ type FullNode interface {
 	// If oldmsgskip is set, messages from before the requested roots are also not included.
 	ChainExport(ctx context.Context, nroots abi.ChainEpoch, oldmsgskip bool, tsk types.TipSetKey) (<-chan []byte, error) //perm:read
 
-	// ChainExportRangeInternal triggers the export of a chain
-	// CAR-snapshot directly to disk. It is similar to ChainExport,
-	// except, depending on options, the snapshot can include receipts,
-	// messages and stateroots for the length between the specified head
-	// and tail, thus producing "archival-grade" snapshots that include
-	// all the on-chain data.  The header chain is included back to
-	// genesis and these snapshots can be used to initialize Filecoin
-	// nodes.
-	ChainExportRangeInternal(ctx context.Context, head, tail types.TipSetKey, cfg ChainExportConfig) error //perm:admin
-
-	// ChainPrune forces compaction on cold store and garbage collects; only supported if you
-	// are using the splitstore
-	ChainPrune(ctx context.Context, opts PruneOpts) error //perm:admin
-
-	// ChainHotGC does online (badger) GC on the hot store; only supported if you are using
-	// the splitstore
-	ChainHotGC(ctx context.Context, opts HotGCOpts) error //perm:admin
-
 	// ChainCheckBlockstore performs an (asynchronous) health check on the chain/state blockstore
 	// if supported by the underlying implementation.
 	ChainCheckBlockstore(context.Context) error //perm:admin
@@ -198,8 +170,13 @@ type FullNode interface {
 	// ChainBlockstoreInfo returns some basic information about the blockstore
 	ChainBlockstoreInfo(context.Context) (map[string]interface{}, error) //perm:read
 
-	// ChainGetEvents returns the events under an event AMT root CID.
-	ChainGetEvents(context.Context, cid.Cid) ([]types.Event, error) //perm:read
+	// MethodGroup: Beacon
+	// The Beacon method group contains methods for interacting with the random beacon (DRAND)
+
+	// BeaconGetEntry returns the beacon entry for the given filecoin epoch. If
+	// the entry has not yet been produced, the call will block until the entry
+	// becomes available
+	BeaconGetEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) //perm:read
 
 	// GasEstimateFeeCap estimates gas fee cap
 	GasEstimateFeeCap(context.Context, *types.Message, int64, types.TipSetKey) (types.BigInt, error) //perm:read
@@ -297,10 +274,8 @@ type FullNode interface {
 	MpoolGetNonce(context.Context, address.Address) (uint64, error) //perm:read
 	MpoolSub(context.Context) (<-chan MpoolUpdate, error)           //perm:read
 
-	// MpoolClear clears pending messages from the mpool.
-	// If clearLocal is true, ALL messages will be cleared.
-	// If clearLocal is false, local messages will be protected, all others will be cleared.
-	MpoolClear(ctx context.Context, clearLocal bool) error //perm:write
+	// MpoolClear clears pending messages from the mpool
+	MpoolClear(context.Context, bool) error //perm:write
 
 	// MpoolGetConfig returns (a copy of) the current mpool config
 	MpoolGetConfig(context.Context) (*types.MpoolConfig, error) //perm:read
@@ -335,7 +310,7 @@ type FullNode interface {
 	WalletVerify(context.Context, address.Address, []byte, *crypto.Signature) (bool, error) //perm:read
 	// WalletDefaultAddress returns the address marked as default in the wallet.
 	WalletDefaultAddress(context.Context) (address.Address, error) //perm:write
-	// WalletSetDefault marks the given address as the default one.
+	// WalletSetDefault marks the given address as as the default one.
 	WalletSetDefault(context.Context, address.Address) error //perm:write
 	// WalletExport returns the private key of an address in the wallet.
 	WalletExport(context.Context, address.Address) (*types.KeyInfo, error) //perm:admin
@@ -385,7 +360,7 @@ type FullNode interface {
 	// ClientGetRetrievalUpdates returns status of updated retrieval deals
 	ClientGetRetrievalUpdates(ctx context.Context) (<-chan RetrievalInfo, error) //perm:write
 	// ClientQueryAsk returns a signed StorageAsk from the specified miner.
-	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*StorageAsk, error) //perm:read
+	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.StorageAsk, error) //perm:read
 	// ClientCalcCommP calculates the CommP and data size of the specified CID
 	ClientDealPieceCID(ctx context.Context, root cid.Cid) (DataCIDSize, error) //perm:read
 	// ClientCalcCommP calculates the CommP for a specified file
@@ -409,12 +384,12 @@ type FullNode interface {
 	ClientCancelRetrievalDeal(ctx context.Context, dealid retrievalmarket.DealID) error //perm:write
 
 	// ClientUnimport removes references to the specified file from filestore
-	// ClientUnimport(path string)
+	//ClientUnimport(path string)
 
 	// ClientListImports lists imported files and their root CIDs
 	ClientListImports(ctx context.Context) ([]Import, error) //perm:write
 
-	// ClientListAsks() []Ask
+	//ClientListAsks() []Ask
 
 	// MethodGroup: State
 	// The State methods are used to query, inspect, and interact with chain state.
@@ -429,7 +404,7 @@ type FullNode interface {
 	StateCall(context.Context, *types.Message, types.TipSetKey) (*InvocResult, error) //perm:read
 	// StateReplay replays a given message, assuming it was included in a block in the specified tipset.
 	//
-	// If a tipset key is provided, and a replacing message is not found on chain,
+	// If a tipset key is provided, and a replacing message is found on chain,
 	// the method will return an error saying that the message wasn't found
 	//
 	// If no tipset key is provided, the appropriate tipset is looked up, and if
@@ -468,7 +443,7 @@ type FullNode interface {
 	// StateMinerPower returns the power of the indicated miner
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error) //perm:read
 	// StateMinerInfo returns info about the indicated miner
-	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (MinerInfo, error) //perm:read
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error) //perm:read
 	// StateMinerDeadlines returns all the proving deadlines for the given miner
 	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]Deadline, error) //perm:read
 	// StateMinerPartitions returns all partitions in the specified deadline
@@ -485,15 +460,10 @@ type FullNode interface {
 	StateMinerInitialPledgeCollateral(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error) //perm:read
 	// StateMinerAvailableBalance returns the portion of a miner's balance that can be withdrawn or spent
 	StateMinerAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error) //perm:read
-	// StateMinerSectorAllocated checks if a sector number is marked as allocated.
+	// StateMinerSectorAllocated checks if a sector is allocated
 	StateMinerSectorAllocated(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (bool, error) //perm:read
-	// StateSectorPreCommitInfo returns the PreCommit info for the specified miner's sector.
-	// Returns nil and no error if the sector isn't precommitted.
-	//
-	// Note that the sector number may be allocated while PreCommitInfo is nil. This means that either allocated sector
-	// numbers were compacted, and the sector number was marked as allocated in order to reduce size of the allocated
-	// sectors bitfield, or that the sector was precommitted, but the precommit has expired.
-	StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorPreCommitOnChainInfo, error) //perm:read
+	// StateSectorPreCommitInfo returns the PreCommit info for the specified miner's sector
+	StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) //perm:read
 	// StateSectorGetInfo returns the on-chain info for the specified miner's sector. Returns null in case the sector info isn't found
 	// NOTE: returned info.Expiration may not be accurate in some cases, use StateSectorExpiration to get accurate
 	// expiration epoch
@@ -547,41 +517,18 @@ type FullNode interface {
 	// StateMarketParticipants returns the Escrow and Locked balances of every participant in the Storage Market
 	StateMarketParticipants(context.Context, types.TipSetKey) (map[string]MarketBalance, error) //perm:read
 	// StateMarketDeals returns information about every deal in the Storage Market
-	StateMarketDeals(context.Context, types.TipSetKey) (map[string]*MarketDeal, error) //perm:read
+	StateMarketDeals(context.Context, types.TipSetKey) (map[string]MarketDeal, error) //perm:read
 	// StateMarketStorageDeal returns information about the indicated deal
 	StateMarketStorageDeal(context.Context, abi.DealID, types.TipSetKey) (*MarketDeal, error) //perm:read
-	// StateGetAllocationForPendingDeal returns the allocation for a given deal ID of a pending deal. Returns nil if
-	// pending allocation is not found.
-	StateGetAllocationForPendingDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*verifregtypes.Allocation, error) //perm:read
-	// StateGetAllocationIdForPendingDeal is like StateGetAllocationForPendingDeal except it returns the allocation ID
-	StateGetAllocationIdForPendingDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (verifreg.AllocationId, error) //perm:read
-	// StateGetAllocation returns the allocation for a given address and allocation ID.
-	StateGetAllocation(ctx context.Context, clientAddr address.Address, allocationId verifregtypes.AllocationId, tsk types.TipSetKey) (*verifregtypes.Allocation, error) //perm:read
-	// StateGetAllocations returns the all the allocations for a given client.
-	StateGetAllocations(ctx context.Context, clientAddr address.Address, tsk types.TipSetKey) (map[verifregtypes.AllocationId]verifregtypes.Allocation, error) //perm:read
-	// StateGetAllAllocations returns the all the allocations available in verified registry actor.
-	StateGetAllAllocations(ctx context.Context, tsk types.TipSetKey) (map[verifregtypes.AllocationId]verifregtypes.Allocation, error) //perm:read
-	// StateGetClaim returns the claim for a given address and claim ID.
-	StateGetClaim(ctx context.Context, providerAddr address.Address, claimId verifregtypes.ClaimId, tsk types.TipSetKey) (*verifregtypes.Claim, error) //perm:read
-	// StateGetClaims returns the all the claims for a given provider.
-	StateGetClaims(ctx context.Context, providerAddr address.Address, tsk types.TipSetKey) (map[verifregtypes.ClaimId]verifregtypes.Claim, error) //perm:read
-	// StateGetAllClaims returns the all the claims available in verified registry actor.
-	StateGetAllClaims(ctx context.Context, tsk types.TipSetKey) (map[verifregtypes.ClaimId]verifregtypes.Claim, error) //perm:read
-	// StateComputeDataCID computes DataCID from a set of on-chain deals
-	StateComputeDataCID(ctx context.Context, maddr address.Address, sectorType abi.RegisteredSealProof, deals []abi.DealID, tsk types.TipSetKey) (cid.Cid, error) //perm:read
 	// StateLookupID retrieves the ID address of the given address
 	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error) //perm:read
-	// StateAccountKey returns the public key address of the given ID address for secp and bls accounts
+	// StateAccountKey returns the public key address of the given ID address
 	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error) //perm:read
-	// StateLookupRobustAddress returns the public key address of the given ID address for non-account addresses (multisig, miners etc)
-	StateLookupRobustAddress(context.Context, address.Address, types.TipSetKey) (address.Address, error) //perm:read
 	// StateChangedActors returns all the actors whose states change between the two given state CIDs
 	// TODO: Should this take tipset keys instead?
 	StateChangedActors(context.Context, cid.Cid, cid.Cid) (map[string]types.Actor, error) //perm:read
 	// StateMinerSectorCount returns the number of sectors in a miner's sector set and proving set
 	StateMinerSectorCount(context.Context, address.Address, types.TipSetKey) (MinerSectors, error) //perm:read
-	// StateMinerAllocated returns a bitfield containing all sector numbers marked as allocated in miner state
-	StateMinerAllocated(context.Context, address.Address, types.TipSetKey) (*bitfield.BitField, error) //perm:read
 	// StateCompute is a flexible command that applies the given messages on the given tipset.
 	// The messages are run as though the VM were at the provided height.
 	//
@@ -623,7 +570,7 @@ type FullNode interface {
 	// Returns nil if there is no entry in the data cap table for the
 	// address.
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) //perm:read
-	// StateVerifiedRegistryRootKey returns the address of the Verified Registry's root key
+	// StateVerifiedClientStatus returns the address of the Verified Registry's root key
 	StateVerifiedRegistryRootKey(ctx context.Context, tsk types.TipSetKey) (address.Address, error) //perm:read
 	// StateDealProviderCollateralBounds returns the min and max collateral a storage provider
 	// can issue. It takes the deal size and verified status as parameters.
@@ -637,29 +584,12 @@ type FullNode interface {
 	StateVMCirculatingSupplyInternal(context.Context, types.TipSetKey) (CirculatingSupply, error) //perm:read
 	// StateNetworkVersion returns the network version at the given tipset
 	StateNetworkVersion(context.Context, types.TipSetKey) (apitypes.NetworkVersion, error) //perm:read
-	// StateActorCodeCIDs returns the CIDs of all the builtin actors for the given network version
-	StateActorCodeCIDs(context.Context, abinetwork.Version) (map[string]cid.Cid, error) //perm:read
-	// StateActorManifestCID returns the CID of the builtin actors manifest for the given network version
-	StateActorManifestCID(context.Context, abinetwork.Version) (cid.Cid, error) //perm:read
 
 	// StateGetRandomnessFromTickets is used to sample the chain for randomness.
 	StateGetRandomnessFromTickets(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) //perm:read
 	// StateGetRandomnessFromBeacon is used to sample the beacon for randomness.
 	StateGetRandomnessFromBeacon(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) //perm:read
 
-	// StateGetRandomnessDigestFromTickets. is used to sample the chain for randomness.
-	StateGetRandomnessDigestFromTickets(ctx context.Context, randEpoch abi.ChainEpoch, tsk types.TipSetKey) (abi.Randomness, error) //perm:read
-	// StateGetRandomnessDigestFromBeacon is used to sample the beacon for randomness.
-	StateGetRandomnessDigestFromBeacon(ctx context.Context, randEpoch abi.ChainEpoch, tsk types.TipSetKey) (abi.Randomness, error) //perm:read
-
-	// StateGetBeaconEntry returns the beacon entry for the given filecoin epoch. If
-	// the entry has not yet been produced, the call will block until the entry
-	// becomes available
-	StateGetBeaconEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) //perm:read
-
-	// StateGetNetworkParams return current network params
-	StateGetNetworkParams(ctx context.Context) (*NetworkParams, error) //perm:read
-
 	// MethodGroup: Msig
 	// The Msig methods are used to interact with multisig wallets on the
 	// filecoin network
@@ -672,14 +602,14 @@ type FullNode interface {
 	// It takes the following params: <multisig address>, <start epoch>, <end epoch>
 	MsigGetVested(context.Context, address.Address, types.TipSetKey, types.TipSetKey) (types.BigInt, error) //perm:read
 
-	// MsigGetPending returns pending transactions for the given multisig
-	// wallet. Once pending transactions are fully approved, they will no longer
-	// appear here.
+	//MsigGetPending returns pending transactions for the given multisig
+	//wallet. Once pending transactions are fully approved, they will no longer
+	//appear here.
 	MsigGetPending(context.Context, address.Address, types.TipSetKey) ([]*MsigTransaction, error) //perm:read
 
 	// MsigCreate creates a multisig wallet
 	// It takes the following params: <required number of senders>, <approving addresses>, <unlock duration>
-	// <initial balance>, <sender address of the create msg>, <gas price>
+	//<initial balance>, <sender address of the create msg>, <gas price>
 	MsigCreate(context.Context, uint64, []address.Address, abi.ChainEpoch, types.BigInt, address.Address, types.BigInt) (*MessagePrototype, error) //perm:sign
 
 	// MsigPropose proposes a multisig message
@@ -791,157 +721,11 @@ type FullNode interface {
 
 	NodeStatus(ctx context.Context, inclChainStatus bool) (NodeStatus, error) //perm:read
 
-	// MethodGroup: Eth
-	// These methods are used for Ethereum-compatible JSON-RPC calls
-	//
-	// EthAccounts will always return [] since we don't expect Lotus to manage private keys
-	EthAccounts(ctx context.Context) ([]ethtypes.EthAddress, error) //perm:read
-	// EthAddressToFilecoinAddress converts an EthAddress into an f410 Filecoin Address
-	EthAddressToFilecoinAddress(ctx context.Context, ethAddress ethtypes.EthAddress) (address.Address, error) //perm:read
-	// FilecoinAddressToEthAddress converts an f410 or f0 Filecoin Address to an EthAddress
-	FilecoinAddressToEthAddress(ctx context.Context, filecoinAddress address.Address) (ethtypes.EthAddress, error) //perm:read
-	// EthBlockNumber returns the height of the latest (heaviest) TipSet
-	EthBlockNumber(ctx context.Context) (ethtypes.EthUint64, error) //perm:read
-	// EthGetBlockTransactionCountByNumber returns the number of messages in the TipSet
-	EthGetBlockTransactionCountByNumber(ctx context.Context, blkNum ethtypes.EthUint64) (ethtypes.EthUint64, error) //perm:read
-	// EthGetBlockTransactionCountByHash returns the number of messages in the TipSet
-	EthGetBlockTransactionCountByHash(ctx context.Context, blkHash ethtypes.EthHash) (ethtypes.EthUint64, error) //perm:read
-
-	EthGetBlockByHash(ctx context.Context, blkHash ethtypes.EthHash, fullTxInfo bool) (ethtypes.EthBlock, error)                                //perm:read
-	EthGetBlockByNumber(ctx context.Context, blkNum string, fullTxInfo bool) (ethtypes.EthBlock, error)                                         //perm:read
-	EthGetTransactionByHash(ctx context.Context, txHash *ethtypes.EthHash) (*ethtypes.EthTx, error)                                             //perm:read
-	EthGetTransactionByHashLimited(ctx context.Context, txHash *ethtypes.EthHash, limit abi.ChainEpoch) (*ethtypes.EthTx, error)                //perm:read
-	EthGetTransactionHashByCid(ctx context.Context, cid cid.Cid) (*ethtypes.EthHash, error)                                                     //perm:read
-	EthGetMessageCidByTransactionHash(ctx context.Context, txHash *ethtypes.EthHash) (*cid.Cid, error)                                          //perm:read
-	EthGetTransactionCount(ctx context.Context, sender ethtypes.EthAddress, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthUint64, error) //perm:read
-	EthGetTransactionReceipt(ctx context.Context, txHash ethtypes.EthHash) (*EthTxReceipt, error)                                               //perm:read
-	EthGetTransactionReceiptLimited(ctx context.Context, txHash ethtypes.EthHash, limit abi.ChainEpoch) (*EthTxReceipt, error)                  //perm:read
-	EthGetTransactionByBlockHashAndIndex(ctx context.Context, blkHash ethtypes.EthHash, txIndex ethtypes.EthUint64) (ethtypes.EthTx, error)     //perm:read
-	EthGetTransactionByBlockNumberAndIndex(ctx context.Context, blkNum ethtypes.EthUint64, txIndex ethtypes.EthUint64) (ethtypes.EthTx, error)  //perm:read
-
-	EthGetCode(ctx context.Context, address ethtypes.EthAddress, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBytes, error)                                  //perm:read
-	EthGetStorageAt(ctx context.Context, address ethtypes.EthAddress, position ethtypes.EthBytes, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBytes, error) //perm:read
-	EthGetBalance(ctx context.Context, address ethtypes.EthAddress, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBigInt, error)                              //perm:read
-	EthChainId(ctx context.Context) (ethtypes.EthUint64, error)                                                                                                      //perm:read
-	EthSyncing(ctx context.Context) (ethtypes.EthSyncingResult, error)                                                                                               //perm:read
-	NetVersion(ctx context.Context) (string, error)                                                                                                                  //perm:read
-	NetListening(ctx context.Context) (bool, error)                                                                                                                  //perm:read
-	EthProtocolVersion(ctx context.Context) (ethtypes.EthUint64, error)                                                                                              //perm:read
-	EthGasPrice(ctx context.Context) (ethtypes.EthBigInt, error)                                                                                                     //perm:read
-	EthFeeHistory(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthFeeHistory, error)                                                                          //perm:read
-
-	EthMaxPriorityFeePerGas(ctx context.Context) (ethtypes.EthBigInt, error)                                             //perm:read
-	EthEstimateGas(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthUint64, error)                                 //perm:read
-	EthCall(ctx context.Context, tx ethtypes.EthCall, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBytes, error) //perm:read
-
-	EthSendRawTransaction(ctx context.Context, rawTx ethtypes.EthBytes) (ethtypes.EthHash, error) //perm:read
-
-	// Returns event logs matching given filter spec.
-	EthGetLogs(ctx context.Context, filter *ethtypes.EthFilterSpec) (*ethtypes.EthFilterResult, error) //perm:read
-
-	// Polling method for a filter, returns event logs which occurred since last poll.
-	// (requires write perm since timestamp of last filter execution will be written)
-	EthGetFilterChanges(ctx context.Context, id ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) //perm:read
-
-	// Returns event logs matching filter with given id.
-	// (requires write perm since timestamp of last filter execution will be written)
-	EthGetFilterLogs(ctx context.Context, id ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error) //perm:read
-
-	// Installs a persistent filter based on given filter spec.
-	EthNewFilter(ctx context.Context, filter *ethtypes.EthFilterSpec) (ethtypes.EthFilterID, error) //perm:read
-
-	// Installs a persistent filter to notify when a new block arrives.
-	EthNewBlockFilter(ctx context.Context) (ethtypes.EthFilterID, error) //perm:read
-
-	// Installs a persistent filter to notify when new messages arrive in the message pool.
-	EthNewPendingTransactionFilter(ctx context.Context) (ethtypes.EthFilterID, error) //perm:read
-
-	// Uninstalls a filter with given id.
-	EthUninstallFilter(ctx context.Context, id ethtypes.EthFilterID) (bool, error) //perm:read
-
-	// Subscribe to different event types using websockets
-	// eventTypes is one or more of:
-	//  - newHeads: notify when new blocks arrive.
-	//  - pendingTransactions: notify when new messages arrive in the message pool.
-	//  - logs: notify new event logs that match a criteria
-	// params contains additional parameters used with the log event type
-	// The client will receive a stream of EthSubscriptionResponse values until EthUnsubscribe is called.
-	EthSubscribe(ctx context.Context, params jsonrpc.RawParams) (ethtypes.EthSubscriptionID, error) //perm:read
-
-	// Unsubscribe from a websocket subscription
-	EthUnsubscribe(ctx context.Context, id ethtypes.EthSubscriptionID) (bool, error) //perm:read
-
-	// Returns the client version
-	Web3ClientVersion(ctx context.Context) (string, error) //perm:read
-
-	// TraceAPI related methods
-
-	// Returns an OpenEthereum-compatible trace of the given block (implementing `trace_block`),
-	// translating Filecoin semantics into Ethereum semantics and tracing both EVM and FVM calls.
-	//
-	// Features:
-	//
-	// - FVM actor create events, calls, etc. show up as if they were EVM smart contract events.
-	// - Native FVM call inputs are ABI-encoded (Solidity ABI) as if they were calls to a
-	//   `handle_filecoin_method(uint64 method, uint64 codec, bytes params)` function
-	//   (where `codec` is the IPLD codec of `params`).
-	// - Native FVM call outputs (return values) are ABI-encoded as `(uint32 exit_code, uint64
-	//   codec, bytes output)` where `codec` is the IPLD codec of `output`.
-	//
-	// Limitations (for now):
-	//
-	// 1. Block rewards are not included in the trace.
-	// 2. SELFDESTRUCT operations are not included in the trace.
-	// 3. EVM smart contract "create" events always specify `0xfe` as the "code" for newly created EVM smart contracts.
-	EthTraceBlock(ctx context.Context, blkNum string) ([]*ethtypes.EthTraceBlock, error) //perm:read
-
-	// Replays all transactions in a block returning the requested traces for each transaction
-	EthTraceReplayBlockTransactions(ctx context.Context, blkNum string, traceTypes []string) ([]*ethtypes.EthTraceReplayBlockTransaction, error) //perm:read
-
 	// CreateBackup creates node backup onder the specified file name. The
 	// method requires that the lotus daemon 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
-
-	// Actor events
-
-	// GetActorEventsRaw returns all user-programmed and built-in actor events that match the given
-	// filter.
-	// This is a request/response API.
-	// Results available from this API may be limited by the MaxFilterResults and MaxFilterHeightRange
-	// configuration options and also the amount of historical data available in the node.
-	//
-	// This is an EXPERIMENTAL API and may be subject to change.
-	GetActorEventsRaw(ctx context.Context, filter *types.ActorEventFilter) ([]*types.ActorEvent, error) //perm:read
-
-	// SubscribeActorEventsRaw returns a long-lived stream of all user-programmed and built-in actor
-	// events that match the given filter.
-	// Events that match the given filter are written to the stream in real-time as they are emitted
-	// from the FVM.
-	// The response stream is closed when the client disconnects, when a ToHeight is specified and is
-	// reached, or if there is an error while writing an event to the stream.
-	// This API also allows clients to read all historical events matching the given filter before any
-	// real-time events are written to the response stream if the filter specifies an earlier
-	// FromHeight.
-	// Results available from this API may be limited by the MaxFilterResults and MaxFilterHeightRange
-	// configuration options and also the amount of historical data available in the node.
-	//
-	// Note: this API is only available via websocket connections.
-	// This is an EXPERIMENTAL API and may be subject to change.
-	SubscribeActorEventsRaw(ctx context.Context, filter *types.ActorEventFilter) (<-chan *types.ActorEvent, error) //perm:read
-}
-
-// reverse interface to the client, called after EthSubscribe
-type EthSubscriber interface {
-	// note: the parameter is ethtypes.EthSubscriptionResponse serialized as json object
-	EthSubscription(ctx context.Context, r jsonrpc.RawParams) error // rpc_method:eth_subscription notify:true
-}
-
-type StorageAsk struct {
-	Response *storagemarket.StorageAsk
-
-	DealProtocols []string
 }
 
 type FileRef struct {
@@ -1165,47 +949,9 @@ type MarketBalance struct {
 	Locked big.Int
 }
 
-type MarketDealState struct {
-	SectorStartEpoch abi.ChainEpoch // -1 if not yet included in proven sector
-	LastUpdatedEpoch abi.ChainEpoch // -1 if deal state never updated
-	SlashEpoch       abi.ChainEpoch // -1 if deal never slashed
-}
-
-func MakeDealState(mds market.DealState) MarketDealState {
-	return MarketDealState{
-		SectorStartEpoch: mds.SectorStartEpoch(),
-		LastUpdatedEpoch: mds.LastUpdatedEpoch(),
-		SlashEpoch:       mds.SlashEpoch(),
-	}
-}
-
-type mstate struct {
-	s MarketDealState
-}
-
-func (m mstate) SectorStartEpoch() abi.ChainEpoch {
-	return m.s.SectorStartEpoch
-}
-
-func (m mstate) LastUpdatedEpoch() abi.ChainEpoch {
-	return m.s.LastUpdatedEpoch
-}
-
-func (m mstate) SlashEpoch() abi.ChainEpoch {
-	return m.s.SlashEpoch
-}
-
-func (m mstate) Equals(o market.DealState) bool {
-	return market.DealStatesEqual(m, o)
-}
-
-func (m MarketDealState) Iface() market.DealState {
-	return mstate{m}
-}
-
 type MarketDeal struct {
 	Proposal market.DealProposal
-	State    MarketDealState
+	State    market.DealState
 }
 
 type RetrievalOrder struct {
@@ -1223,12 +969,8 @@ type RetrievalOrder struct {
 	Client                  address.Address
 	Miner                   address.Address
 	MinerPeer               *retrievalmarket.RetrievalPeer
-
-	RemoteStore *RemoteStoreID `json:"RemoteStore,omitempty"`
 }
 
-type RemoteStoreID = uuid.UUID
-
 type InvocResult struct {
 	MsgCid         cid.Cid
 	Msg            *types.Message
@@ -1454,32 +1196,3 @@ type MsigTransaction struct {
 
 	Approved []address.Address
 }
-
-type PruneOpts struct {
-	MovingGC    bool
-	RetainState int64
-}
-
-type HotGCOpts struct {
-	Threshold float64
-	Periodic  bool
-	Moving    bool
-}
-
-type EthTxReceipt struct {
-	TransactionHash   ethtypes.EthHash     `json:"transactionHash"`
-	TransactionIndex  ethtypes.EthUint64   `json:"transactionIndex"`
-	BlockHash         ethtypes.EthHash     `json:"blockHash"`
-	BlockNumber       ethtypes.EthUint64   `json:"blockNumber"`
-	From              ethtypes.EthAddress  `json:"from"`
-	To                *ethtypes.EthAddress `json:"to"`
-	StateRoot         ethtypes.EthHash     `json:"root"`
-	Status            ethtypes.EthUint64   `json:"status"`
-	ContractAddress   *ethtypes.EthAddress `json:"contractAddress"`
-	CumulativeGasUsed ethtypes.EthUint64   `json:"cumulativeGasUsed"`
-	GasUsed           ethtypes.EthUint64   `json:"gasUsed"`
-	EffectiveGasPrice ethtypes.EthBigInt   `json:"effectiveGasPrice"`
-	LogsBloom         ethtypes.EthBytes    `json:"logsBloom"`
-	Logs              []ethtypes.EthLog    `json:"logs"`
-	Type              ethtypes.EthUint64   `json:"type"`
-}

api/api_gateway.go

@@ -3,20 +3,15 @@ package api
 import (
 	"context"
 
-	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-jsonrpc"
 	"github.com/filecoin-project/go-state-types/abi"
-	verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	"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"
-	"github.com/filecoin-project/lotus/chain/types/ethtypes"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 
 //                       MODIFYING THE API INTERFACE
@@ -27,21 +22,14 @@ import (
 // When adding / changing methods in this file:
 // * Do the change here
 // * Adjust implementation in `node/impl/`
-// * Run `make clean && make deps && make gen` - this will:
+// * Run `make gen` - this will:
 //  * Generate proxy structs
 //  * Generate mocks
 //  * Generate markdown docs
 //  * Generate openrpc blobs
 
 type Gateway interface {
-	MpoolPending(context.Context, types.TipSetKey) ([]*types.SignedMessage, error)
-	ChainGetBlock(context.Context, cid.Cid) (*types.BlockHeader, error)
-	MinerGetBaseInfo(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*MiningBaseInfo, error)
-	StateMinerSectorCount(context.Context, address.Address, types.TipSetKey) (MinerSectors, error)
-	GasEstimateGasPremium(context.Context, uint64, address.Address, int64, types.TipSetKey) (types.BigInt, error)
-	StateReplay(context.Context, types.TipSetKey, cid.Cid) (*InvocResult, error)
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
-	ChainPutObj(context.Context, blocks.Block) error
 	ChainHead(ctx context.Context) (*types.TipSet, error)
 	ChainGetParentMessages(context.Context, cid.Cid) ([]Message, error)
 	ChainGetParentReceipts(context.Context, cid.Cid) ([]*types.MessageReceipt, error)
@@ -55,85 +43,27 @@ type Gateway interface {
 	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
 	ChainGetGenesis(context.Context) (*types.TipSet, error)
 	GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *MessageSendSpec, tsk types.TipSetKey) (*types.Message, error)
-	MpoolGetNonce(ctx context.Context, addr address.Address) (uint64, error)
 	MpoolPush(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error)
 	MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error)
 	MsigGetPending(context.Context, address.Address, types.TipSetKey) ([]*MsigTransaction, error)
 	MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error)
 	MsigGetVestingSchedule(ctx context.Context, addr address.Address, tsk types.TipSetKey) (MsigVesting, error)
 	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-	StateCall(ctx context.Context, msg *types.Message, tsk types.TipSetKey) (*InvocResult, error)
 	StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (DealCollateralBounds, error)
-	StateDecodeParams(ctx context.Context, toAddr address.Address, method abi.MethodNum, params []byte, tsk types.TipSetKey) (interface{}, error)
 	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
-	StateGetAllocationForPendingDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*verifregtypes.Allocation, error)
-	StateGetAllocation(ctx context.Context, clientAddr address.Address, allocationId verifregtypes.AllocationId, tsk types.TipSetKey) (*verifregtypes.Allocation, error)
-	StateGetAllocations(ctx context.Context, clientAddr address.Address, tsk types.TipSetKey) (map[verifregtypes.AllocationId]verifregtypes.Allocation, error)
-	StateGetClaim(ctx context.Context, providerAddr address.Address, claimId verifregtypes.ClaimId, tsk types.TipSetKey) (*verifregtypes.Claim, error)
-	StateGetClaims(ctx context.Context, providerAddr address.Address, tsk types.TipSetKey) (map[verifregtypes.ClaimId]verifregtypes.Claim, error)
-	StateReadState(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*ActorState, error)
+	StateReadState(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*ActorState, error) //perm:read
 	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) (MinerInfo, error)
-	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]Deadline, 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)
-	StateNetworkName(context.Context) (dtypes.NetworkName, error)
 	StateNetworkVersion(context.Context, types.TipSetKey) (apitypes.NetworkVersion, error)
 	StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error)
-	StateVerifierStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 	StateSearchMsg(ctx context.Context, from types.TipSetKey, msg cid.Cid, limit abi.ChainEpoch, allowReplaced bool) (*MsgLookup, error)
 	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64, limit abi.ChainEpoch, allowReplaced bool) (*MsgLookup, error)
 	WalletBalance(context.Context, address.Address) (types.BigInt, error)
 	Version(context.Context) (APIVersion, error)
-	Discover(context.Context) (apitypes.OpenRPCDocument, error)
-
-	EthAddressToFilecoinAddress(ctx context.Context, ethAddress ethtypes.EthAddress) (address.Address, error)
-	FilecoinAddressToEthAddress(ctx context.Context, filecoinAddress address.Address) (ethtypes.EthAddress, error)
-	EthAccounts(ctx context.Context) ([]ethtypes.EthAddress, error)
-	EthBlockNumber(ctx context.Context) (ethtypes.EthUint64, error)
-	EthGetBlockTransactionCountByNumber(ctx context.Context, blkNum ethtypes.EthUint64) (ethtypes.EthUint64, error)
-	EthGetBlockTransactionCountByHash(ctx context.Context, blkHash ethtypes.EthHash) (ethtypes.EthUint64, error)
-	EthGetBlockByHash(ctx context.Context, blkHash ethtypes.EthHash, fullTxInfo bool) (ethtypes.EthBlock, error)
-	EthGetBlockByNumber(ctx context.Context, blkNum string, fullTxInfo bool) (ethtypes.EthBlock, error)
-	EthGetTransactionByHash(ctx context.Context, txHash *ethtypes.EthHash) (*ethtypes.EthTx, error)
-	EthGetTransactionByHashLimited(ctx context.Context, txHash *ethtypes.EthHash, limit abi.ChainEpoch) (*ethtypes.EthTx, error)
-	EthGetTransactionHashByCid(ctx context.Context, cid cid.Cid) (*ethtypes.EthHash, error)
-	EthGetMessageCidByTransactionHash(ctx context.Context, txHash *ethtypes.EthHash) (*cid.Cid, error)
-	EthGetTransactionCount(ctx context.Context, sender ethtypes.EthAddress, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthUint64, error)
-	EthGetTransactionReceipt(ctx context.Context, txHash ethtypes.EthHash) (*EthTxReceipt, error)
-	EthGetTransactionReceiptLimited(ctx context.Context, txHash ethtypes.EthHash, limit abi.ChainEpoch) (*EthTxReceipt, error)
-	EthGetCode(ctx context.Context, address ethtypes.EthAddress, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBytes, error)
-	EthGetStorageAt(ctx context.Context, address ethtypes.EthAddress, position ethtypes.EthBytes, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBytes, error)
-	EthGetBalance(ctx context.Context, address ethtypes.EthAddress, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBigInt, error)
-	EthChainId(ctx context.Context) (ethtypes.EthUint64, error)
-	EthSyncing(ctx context.Context) (ethtypes.EthSyncingResult, error)
-	NetVersion(ctx context.Context) (string, error)
-	NetListening(ctx context.Context) (bool, error)
-	EthProtocolVersion(ctx context.Context) (ethtypes.EthUint64, error)
-	EthGasPrice(ctx context.Context) (ethtypes.EthBigInt, error)
-	EthFeeHistory(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthFeeHistory, error)
-	EthMaxPriorityFeePerGas(ctx context.Context) (ethtypes.EthBigInt, error)
-	EthEstimateGas(ctx context.Context, p jsonrpc.RawParams) (ethtypes.EthUint64, error)
-	EthCall(ctx context.Context, tx ethtypes.EthCall, blkParam ethtypes.EthBlockNumberOrHash) (ethtypes.EthBytes, error)
-	EthSendRawTransaction(ctx context.Context, rawTx ethtypes.EthBytes) (ethtypes.EthHash, error)
-	EthGetLogs(ctx context.Context, filter *ethtypes.EthFilterSpec) (*ethtypes.EthFilterResult, error)
-	EthGetFilterChanges(ctx context.Context, id ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error)
-	EthGetFilterLogs(ctx context.Context, id ethtypes.EthFilterID) (*ethtypes.EthFilterResult, error)
-	EthNewFilter(ctx context.Context, filter *ethtypes.EthFilterSpec) (ethtypes.EthFilterID, error)
-	EthNewBlockFilter(ctx context.Context) (ethtypes.EthFilterID, error)
-	EthNewPendingTransactionFilter(ctx context.Context) (ethtypes.EthFilterID, error)
-	EthUninstallFilter(ctx context.Context, id ethtypes.EthFilterID) (bool, error)
-	EthSubscribe(ctx context.Context, params jsonrpc.RawParams) (ethtypes.EthSubscriptionID, error)
-	EthUnsubscribe(ctx context.Context, id ethtypes.EthSubscriptionID) (bool, error)
-	Web3ClientVersion(ctx context.Context) (string, error)
-	EthTraceBlock(ctx context.Context, blkNum string) ([]*ethtypes.EthTraceBlock, error)
-	EthTraceReplayBlockTransactions(ctx context.Context, blkNum string, traceTypes []string) ([]*ethtypes.EthTraceReplayBlockTransaction, error)
-
-	GetActorEventsRaw(ctx context.Context, filter *types.ActorEventFilter) ([]*types.ActorEvent, error)
-	SubscribeActorEventsRaw(ctx context.Context, filter *types.ActorEventFilter) (<-chan *types.ActorEvent, error)
-	ChainGetEvents(context.Context, cid.Cid) ([]types.Event, error)
 }

api/api_net.go

@@ -4,10 +4,10 @@ import (
 	"context"
 	"time"
 
-	"github.com/libp2p/go-libp2p/core/metrics"
-	"github.com/libp2p/go-libp2p/core/network"
-	"github.com/libp2p/go-libp2p/core/peer"
-	"github.com/libp2p/go-libp2p/core/protocol"
+	metrics "github.com/libp2p/go-libp2p-core/metrics"
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/libp2p/go-libp2p-core/protocol"
 )
 
 //                       MODIFYING THE API INTERFACE
@@ -73,5 +73,5 @@ type CommonNet interface {
 
 type NatInfo struct {
 	Reachability network.Reachability
-	PublicAddrs  []string
+	PublicAddr   string
 }

api/api_storage.go

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

api/api_test.go

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

api/api_worker.go

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

api/client/client.go

@@ -15,21 +15,11 @@ import (
 	"github.com/filecoin-project/lotus/lib/rpcenc"
 )
 
-// NewCurioRpc creates a new http jsonrpc client.
-func NewCurioRpc(ctx context.Context, addr string, requestHeader http.Header) (api.Curio, jsonrpc.ClientCloser, error) {
-	var res v1api.CurioStruct
-
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		api.GetInternalStructs(&res), requestHeader, jsonrpc.WithErrors(api.RPCErrors))
-
-	return &res, closer, err
-}
-
 // NewCommonRPCV0 creates a new http jsonrpc client.
 func NewCommonRPCV0(ctx context.Context, addr string, requestHeader http.Header) (api.CommonNet, jsonrpc.ClientCloser, error) {
 	var res v0api.CommonNetStruct
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		api.GetInternalStructs(&res), requestHeader, jsonrpc.WithErrors(api.RPCErrors))
+		api.GetInternalStructs(&res), requestHeader)
 
 	return &res, closer, err
 }
@@ -39,16 +29,16 @@ func NewFullNodeRPCV0(ctx context.Context, addr string, requestHeader http.Heade
 	var res v0api.FullNodeStruct
 
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		api.GetInternalStructs(&res), requestHeader, jsonrpc.WithErrors(api.RPCErrors))
+		api.GetInternalStructs(&res), requestHeader)
 
 	return &res, closer, err
 }
 
 // NewFullNodeRPCV1 creates a new http jsonrpc client.
-func NewFullNodeRPCV1(ctx context.Context, addr string, requestHeader http.Header, opts ...jsonrpc.Option) (api.FullNode, jsonrpc.ClientCloser, error) {
+func NewFullNodeRPCV1(ctx context.Context, addr string, requestHeader http.Header) (api.FullNode, jsonrpc.ClientCloser, error) {
 	var res v1api.FullNodeStruct
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		api.GetInternalStructs(&res), requestHeader, append([]jsonrpc.Option{jsonrpc.WithErrors(api.RPCErrors)}, opts...)...)
+		api.GetInternalStructs(&res), requestHeader)
 
 	return &res, closer, err
 }
@@ -82,7 +72,6 @@ func NewStorageMinerRPCV0(ctx context.Context, addr string, requestHeader http.H
 		api.GetInternalStructs(&res), requestHeader,
 		append([]jsonrpc.Option{
 			rpcenc.ReaderParamEncoder(pushUrl),
-			jsonrpc.WithErrors(api.RPCErrors),
 		}, opts...)...)
 
 	return &res, closer, err
@@ -101,7 +90,6 @@ func NewWorkerRPCV0(ctx context.Context, addr string, requestHeader http.Header)
 		rpcenc.ReaderParamEncoder(pushUrl),
 		jsonrpc.WithNoReconnect(),
 		jsonrpc.WithTimeout(30*time.Second),
-		jsonrpc.WithErrors(api.RPCErrors),
 	)
 
 	return &res, closer, err
@@ -113,7 +101,7 @@ func NewGatewayRPCV1(ctx context.Context, addr string, requestHeader http.Header
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		api.GetInternalStructs(&res),
 		requestHeader,
-		append(opts, jsonrpc.WithErrors(api.RPCErrors))...,
+		opts...,
 	)
 
 	return &res, closer, err
@@ -125,7 +113,7 @@ func NewGatewayRPCV0(ctx context.Context, addr string, requestHeader http.Header
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		api.GetInternalStructs(&res),
 		requestHeader,
-		append(opts, jsonrpc.WithErrors(api.RPCErrors))...,
+		opts...,
 	)
 
 	return &res, closer, err
@@ -136,7 +124,6 @@ func NewWalletRPCV0(ctx context.Context, addr string, requestHeader http.Header)
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		api.GetInternalStructs(&res),
 		requestHeader,
-		jsonrpc.WithErrors(api.RPCErrors),
 	)
 
 	return &res, closer, err

api/docgen-openrpc/cmd/docgen_openrpc.go

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

api/docgen-openrpc/openrpc.go

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

api/docgen/docgen.go

@@ -6,33 +6,31 @@ import (
 	"go/ast"
 	"go/parser"
 	"go/token"
-	"net/http"
 	"path/filepath"
 	"reflect"
 	"strings"
 	"time"
 	"unicode"
 
-	"github.com/google/uuid"
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-graphsync"
-	textselector "github.com/ipld/go-ipld-selector-text-lite"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"github.com/libp2p/go-libp2p/core/metrics"
-	"github.com/libp2p/go-libp2p/core/network"
-	"github.com/libp2p/go-libp2p/core/peer"
-	"github.com/libp2p/go-libp2p/core/protocol"
-	"github.com/multiformats/go-multiaddr"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
-	"github.com/filecoin-project/go-fil-markets/filestore"
+	"github.com/google/uuid"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-graphsync"
+	"github.com/libp2p/go-libp2p-core/metrics"
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/libp2p/go-libp2p-core/protocol"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/multiformats/go-multiaddr"
+
+	datatransfer "github.com/filecoin-project/go-data-transfer"
+	filestore "github.com/filecoin-project/go-fil-markets/filestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-jsonrpc/auth"
+	textselector "github.com/ipld/go-ipld-selector-text-lite"
+
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/exitcode"
 
@@ -40,14 +38,12 @@ import (
 	apitypes "github.com/filecoin-project/lotus/api/types"
 	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/types/ethtypes"
+	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/repo/imports"
-	sealing "github.com/filecoin-project/lotus/storage/pipeline"
-	"github.com/filecoin-project/lotus/storage/sealer/sealtasks"
-	"github.com/filecoin-project/lotus/storage/sealer/storiface"
 )
 
 var ExampleValues = map[reflect.Type]interface{}{
@@ -70,7 +66,6 @@ func init() {
 	}
 
 	ExampleValues[reflect.TypeOf(c)] = c
-	ExampleValues[reflect.TypeOf(&c)] = &c
 
 	c2, err := cid.Decode("bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve")
 	if err != nil {
@@ -87,7 +82,6 @@ func init() {
 	}
 
 	ExampleValues[reflect.TypeOf(addr)] = addr
-	ExampleValues[reflect.TypeOf(&addr)] = &addr
 
 	pid, err := peer.Decode("12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf")
 	if err != nil {
@@ -101,9 +95,6 @@ func init() {
 	apiSelExample := api.Selector("Links/21/Hash/Links/42/Hash")
 	clientEvent := retrievalmarket.ClientEventDealAccepted
 
-	block := blocks.Block(&blocks.BasicBlock{})
-	ExampleValues[reflect.TypeOf(&block).Elem()] = block
-
 	addExample(bitfield.NewFromSet([]uint64{5}))
 	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1_1)
 	addExample(abi.RegisteredPoStProof_StackedDrgWindow32GiBV1)
@@ -142,33 +133,19 @@ func init() {
 	addExample(&textSelExample)
 	addExample(&apiSelExample)
 	addExample(network.ReachabilityPublic)
-	addExample(build.TestNetworkVersion)
-	allocationId := verifreg.AllocationId(0)
-	addExample(allocationId)
-	addExample(&allocationId)
-	addExample(miner.SectorOnChainInfoFlags(0))
-	addExample(map[verifreg.AllocationId]verifreg.Allocation{})
-	claimId := verifreg.ClaimId(0)
-	addExample(claimId)
-	addExample(&claimId)
-	addExample(map[verifreg.ClaimId]verifreg.Claim{})
+	addExample(build.NewestNetworkVersion)
 	addExample(map[string]int{"name": 42})
 	addExample(map[string]time.Time{"name": time.Unix(1615243938, 0).UTC()})
-	addExample(abi.ActorID(1000))
+	addExample(&types.ExecutionTrace{
+		Msg:    ExampleValue("init", reflect.TypeOf(&types.Message{}), nil).(*types.Message),
+		MsgRct: ExampleValue("init", reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
+	})
 	addExample(map[string]types.Actor{
 		"t01236": ExampleValue("init", reflect.TypeOf(types.Actor{}), nil).(types.Actor),
 	})
-	addExample(&types.ExecutionTrace{
-		Msg:    ExampleValue("init", reflect.TypeOf(types.MessageTrace{}), nil).(types.MessageTrace),
-		MsgRct: ExampleValue("init", reflect.TypeOf(types.ReturnTrace{}), nil).(types.ReturnTrace),
-	})
 	addExample(map[string]api.MarketDeal{
 		"t026363": ExampleValue("init", reflect.TypeOf(api.MarketDeal{}), nil).(api.MarketDeal),
 	})
-	addExample(map[string]*api.MarketDeal{
-		"t026363": ExampleValue("init", reflect.TypeOf(&api.MarketDeal{}), nil).(*api.MarketDeal),
-	})
-
 	addExample(map[string]api.MarketBalance{
 		"t026363": ExampleValue("init", reflect.TypeOf(api.MarketBalance{}), nil).(api.MarketBalance),
 	})
@@ -210,7 +187,7 @@ func init() {
 	si := uint64(12)
 	addExample(&si)
 	addExample(retrievalmarket.DealID(5))
-	addExample(map[string]cid.Cid{})
+	addExample(abi.ActorID(1000))
 	addExample(map[string][]api.SealedRef{
 		"98000": {
 			api.SealedRef{
@@ -287,8 +264,6 @@ func init() {
 			Read:   [storiface.FileTypes]uint{2, 3, 0},
 		},
 	})
-	storifaceid := storiface.ID("1399aa04-2625-44b1-bad4-bd07b59b22c4")
-	addExample(&storifaceid)
 
 	// worker specific
 	addExample(storiface.AcquireMove)
@@ -303,8 +278,7 @@ func init() {
 			"title":   "Lotus RPC API",
 			"version": "1.2.1/generated=2020-11-22T08:22:42-06:00",
 		},
-		"methods": []interface{}{},
-	},
+		"methods": []interface{}{}},
 	)
 
 	addExample(api.CheckStatusCode(0))
@@ -341,8 +315,7 @@ func init() {
 			NumConnsInbound:    3,
 			NumConnsOutbound:   4,
 			NumFD:              5,
-		},
-	})
+		}})
 	addExample(api.NetLimit{
 		Memory:          123,
 		StreamsInbound:  1,
@@ -354,85 +327,10 @@ func init() {
 		FD:              5,
 	})
 
-	addExample(map[string]bitfield.BitField{
-		"": bitfield.NewFromSet([]uint64{5, 6, 7, 10}),
-	})
-
-	addExample(http.Header{
-		"Authorization": []string{"Bearer ey.."},
-	})
-
-	addExample(map[storiface.SectorFileType]storiface.SectorLocation{
-		storiface.FTSealed: {
-			Local:   false,
-			URL:     "https://example.com/sealingservice/sectors/s-f0123-12345",
-			Headers: nil,
-		},
-	})
-
-	ethint := ethtypes.EthUint64(5)
-	addExample(ethint)
-	addExample(&ethint)
-
-	ethaddr, _ := ethtypes.ParseEthAddress("0x5CbEeCF99d3fDB3f25E309Cc264f240bb0664031")
-	addExample(ethaddr)
-	addExample(&ethaddr)
-
-	ethhash, _ := ethtypes.EthHashFromCid(c)
-	addExample(ethhash)
-	addExample(&ethhash)
-
-	ethFeeHistoryReward := [][]ethtypes.EthBigInt{}
-	addExample(&ethFeeHistoryReward)
-
-	addExample(&uuid.UUID{})
-
-	filterid := ethtypes.EthFilterID(ethhash)
-	addExample(filterid)
-	addExample(&filterid)
-
-	subid := ethtypes.EthSubscriptionID(ethhash)
-	addExample(subid)
-	addExample(&subid)
-
-	pstring := func(s string) *string { return &s }
-	addExample(&ethtypes.EthFilterSpec{
-		FromBlock: pstring("2301220"),
-		Address:   []ethtypes.EthAddress{ethaddr},
-	})
-
-	percent := types.Percent(123)
-	addExample(percent)
-	addExample(&percent)
-
-	addExample(&miner.PieceActivationManifest{
-		CID:                   c,
-		Size:                  2032,
-		VerifiedAllocationKey: nil,
-		Notify:                nil,
-	})
-
-	addExample(&types.ActorEventBlock{
-		Codec: 0x51,
-		Value: []byte("ddata"),
-	})
-
-	addExample(&types.ActorEventFilter{
-		Addresses: []address.Address{addr},
-		Fields: map[string][]types.ActorEventBlock{
-			"abc": {
-				{
-					Codec: 0x51,
-					Value: []byte("ddata"),
-				},
-			},
-		},
-		FromHeight: epochPtr(1010),
-		ToHeight:   epochPtr(1020),
-	})
 }
 
 func GetAPIType(name, pkg string) (i interface{}, t reflect.Type, permStruct []reflect.Type) {
+
 	switch pkg {
 	case "api": // latest
 		switch name {
@@ -452,14 +350,6 @@ func GetAPIType(name, pkg string) (i interface{}, t reflect.Type, permStruct []r
 			i = &api.WorkerStruct{}
 			t = reflect.TypeOf(new(struct{ api.Worker })).Elem()
 			permStruct = append(permStruct, reflect.TypeOf(api.WorkerStruct{}.Internal))
-		case "Gateway":
-			i = &api.GatewayStruct{}
-			t = reflect.TypeOf(new(struct{ api.Gateway })).Elem()
-			permStruct = append(permStruct, reflect.TypeOf(api.GatewayStruct{}.Internal))
-		case "Curio":
-			i = &api.CurioStruct{}
-			t = reflect.TypeOf(new(struct{ api.Curio })).Elem()
-			permStruct = append(permStruct, reflect.TypeOf(api.CurioStruct{}.Internal))
 		default:
 			panic("unknown type")
 		}
@@ -506,11 +396,8 @@ func ExampleValue(method string, t, parent reflect.Type) interface{} {
 	case reflect.Ptr:
 		if t.Elem().Kind() == reflect.Struct {
 			es := exampleStruct(method, t.Elem(), t)
-			ExampleValues[t] = es
+			//ExampleValues[t] = es
 			return es
-		} else if t.Elem().Kind() == reflect.String {
-			str := "string value"
-			return &str
 		}
 	case reflect.Interface:
 		return struct{}{}
@@ -526,8 +413,7 @@ func exampleStruct(method string, t, parent reflect.Type) interface{} {
 		if f.Type == parent {
 			continue
 		}
-
-		if f.IsExported() {
+		if strings.Title(f.Name) == f.Name {
 			ns.Elem().Field(i).Set(reflect.ValueOf(ExampleValue(method, f.Type, t)))
 		}
 	}
@@ -535,11 +421,6 @@ func exampleStruct(method string, t, parent reflect.Type) interface{} {
 	return ns.Interface()
 }
 
-func epochPtr(ei int64) *abi.ChainEpoch {
-	ep := abi.ChainEpoch(ei)
-	return &ep
-}
-
 type Visitor struct {
 	Root    string
 	Methods map[string]ast.Node

api/eth_aliases.go

@@ -1,50 +0,0 @@
-package api
-
-import apitypes "github.com/filecoin-project/lotus/api/types"
-
-func CreateEthRPCAliases(as apitypes.Aliaser) {
-	// TODO: maybe use reflect to automatically register all the eth aliases
-	as.AliasMethod("eth_accounts", "Filecoin.EthAccounts")
-	as.AliasMethod("eth_blockNumber", "Filecoin.EthBlockNumber")
-	as.AliasMethod("eth_getBlockTransactionCountByNumber", "Filecoin.EthGetBlockTransactionCountByNumber")
-	as.AliasMethod("eth_getBlockTransactionCountByHash", "Filecoin.EthGetBlockTransactionCountByHash")
-
-	as.AliasMethod("eth_getBlockByHash", "Filecoin.EthGetBlockByHash")
-	as.AliasMethod("eth_getBlockByNumber", "Filecoin.EthGetBlockByNumber")
-	as.AliasMethod("eth_getTransactionByHash", "Filecoin.EthGetTransactionByHash")
-	as.AliasMethod("eth_getTransactionCount", "Filecoin.EthGetTransactionCount")
-	as.AliasMethod("eth_getTransactionReceipt", "Filecoin.EthGetTransactionReceipt")
-	as.AliasMethod("eth_getTransactionByBlockHashAndIndex", "Filecoin.EthGetTransactionByBlockHashAndIndex")
-	as.AliasMethod("eth_getTransactionByBlockNumberAndIndex", "Filecoin.EthGetTransactionByBlockNumberAndIndex")
-
-	as.AliasMethod("eth_getCode", "Filecoin.EthGetCode")
-	as.AliasMethod("eth_getStorageAt", "Filecoin.EthGetStorageAt")
-	as.AliasMethod("eth_getBalance", "Filecoin.EthGetBalance")
-	as.AliasMethod("eth_chainId", "Filecoin.EthChainId")
-	as.AliasMethod("eth_syncing", "Filecoin.EthSyncing")
-	as.AliasMethod("eth_feeHistory", "Filecoin.EthFeeHistory")
-	as.AliasMethod("eth_protocolVersion", "Filecoin.EthProtocolVersion")
-	as.AliasMethod("eth_maxPriorityFeePerGas", "Filecoin.EthMaxPriorityFeePerGas")
-	as.AliasMethod("eth_gasPrice", "Filecoin.EthGasPrice")
-	as.AliasMethod("eth_sendRawTransaction", "Filecoin.EthSendRawTransaction")
-	as.AliasMethod("eth_estimateGas", "Filecoin.EthEstimateGas")
-	as.AliasMethod("eth_call", "Filecoin.EthCall")
-
-	as.AliasMethod("eth_getLogs", "Filecoin.EthGetLogs")
-	as.AliasMethod("eth_getFilterChanges", "Filecoin.EthGetFilterChanges")
-	as.AliasMethod("eth_getFilterLogs", "Filecoin.EthGetFilterLogs")
-	as.AliasMethod("eth_newFilter", "Filecoin.EthNewFilter")
-	as.AliasMethod("eth_newBlockFilter", "Filecoin.EthNewBlockFilter")
-	as.AliasMethod("eth_newPendingTransactionFilter", "Filecoin.EthNewPendingTransactionFilter")
-	as.AliasMethod("eth_uninstallFilter", "Filecoin.EthUninstallFilter")
-	as.AliasMethod("eth_subscribe", "Filecoin.EthSubscribe")
-	as.AliasMethod("eth_unsubscribe", "Filecoin.EthUnsubscribe")
-
-	as.AliasMethod("trace_block", "Filecoin.EthTraceBlock")
-	as.AliasMethod("trace_replayBlockTransactions", "Filecoin.EthTraceReplayBlockTransactions")
-
-	as.AliasMethod("net_version", "Filecoin.NetVersion")
-	as.AliasMethod("net_listening", "Filecoin.NetListening")
-
-	as.AliasMethod("web3_clientVersion", "Filecoin.Web3ClientVersion")
-}

api/permissioned.go

@@ -41,12 +41,6 @@ func PermissionedWorkerAPI(a Worker) Worker {
 	return &out
 }
 
-func PermissionedAPI[T, P any](a T) *P {
-	var out P
-	permissionedProxies(a, &out)
-	return &out
-}
-
 func PermissionedWalletAPI(a Wallet) Wallet {
 	var out WalletStruct
 	permissionedProxies(a, &out)

api/proxy_util_test.go

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

api/types.go

@@ -5,26 +5,22 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/google/uuid"
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-graphsync"
-	"github.com/ipld/go-ipld-prime"
-	"github.com/ipld/go-ipld-prime/codec/dagjson"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"github.com/libp2p/go-libp2p/core/network"
-	"github.com/libp2p/go-libp2p/core/peer"
-	ma "github.com/multiformats/go-multiaddr"
+	"github.com/libp2p/go-libp2p-core/network"
 
-	"github.com/filecoin-project/go-address"
-	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
+	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-state-types/abi"
-
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-graphsync"
+
+	"github.com/libp2p/go-libp2p-core/peer"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	ma "github.com/multiformats/go-multiaddr"
 )
 
+// TODO: check if this exists anywhere else
+
 type MultiaddrSlice []ma.Multiaddr
 
 func (m *MultiaddrSlice) UnmarshalJSON(raw []byte) (err error) {
@@ -56,17 +52,8 @@ type PubsubScore struct {
 	Score *pubsub.PeerScoreSnapshot
 }
 
-// MessageSendSpec contains optional fields which modify message sending behavior
 type MessageSendSpec struct {
-	// MaxFee specifies a cap on network fees related to this message
 	MaxFee abi.TokenAmount
-
-	// MsgUuid specifies a unique message identifier which can be used on node (or node cluster)
-	// level to prevent double-sends of messages even when nonce generation is not handled by sender
-	MsgUuid uuid.UUID
-
-	// MaximizeFeeCap makes message FeeCap be based entirely on MaxFee
-	MaximizeFeeCap bool
 }
 
 // GraphSyncDataTransfer provides diagnostics on a data transfer happening over graphsync
@@ -115,12 +102,16 @@ func NewDataTransferChannel(hostID peer.ID, channelState datatransfer.ChannelSta
 		IsSender:   channelState.Sender() == hostID,
 		Message:    channelState.Message(),
 	}
-	voucher := channelState.Voucher()
-	voucherJSON, err := ipld.Encode(voucher.Voucher, dagjson.Encode)
-	if err != nil {
-		channel.Voucher = fmt.Errorf("Voucher Serialization: %w", err).Error()
+	stringer, ok := channelState.Voucher().(fmt.Stringer)
+	if ok {
+		channel.Voucher = stringer.String()
 	} else {
-		channel.Voucher = string(voucherJSON)
+		voucherJSON, err := json.Marshal(channelState.Voucher())
+		if err != nil {
+			channel.Voucher = fmt.Errorf("Voucher Serialization: %w", err).Error()
+		} else {
+			channel.Voucher = string(voucherJSON)
+		}
 	}
 	if channel.IsSender {
 		channel.IsInitiator = !channelState.IsPull()
@@ -143,7 +134,13 @@ type NetStat struct {
 }
 
 type NetLimit struct {
+	Dynamic bool `json:",omitempty"`
+	// set if Dynamic is false
 	Memory int64 `json:",omitempty"`
+	// set if Dynamic is true
+	MemoryFraction float64 `json:",omitempty"`
+	MinMemory      int64   `json:",omitempty"`
+	MaxMemory      int64   `json:",omitempty"`
 
 	Streams, StreamsInbound, StreamsOutbound int
 	Conns, ConnsInbound, ConnsOutbound       int
@@ -255,10 +252,10 @@ type RestrievalRes struct {
 }
 
 // Selector specifies ipld selector string
-//   - if the string starts with '{', it's interpreted as json selector string
-//     see https://ipld.io/specs/selectors/ and https://ipld.io/specs/selectors/fixtures/selector-fixtures-1/
-//   - otherwise the string is interpreted as ipld-selector-text-lite (simple ipld path)
-//     see https://github.com/ipld/go-ipld-selector-text-lite
+// - if the string starts with '{', it's interpreted as json selector string
+//   see https://ipld.io/specs/selectors/ and https://ipld.io/specs/selectors/fixtures/selector-fixtures-1/
+// - otherwise the string is interpreted as ipld-selector-text-lite (simple ipld path)
+//   see https://github.com/ipld/go-ipld-selector-text-lite
 type Selector string
 
 type DagSpec struct {
@@ -289,70 +286,3 @@ type ExportRef struct {
 	FromLocalCAR string // if specified, get data from a local CARv2 file.
 	DealID       retrievalmarket.DealID
 }
-
-type MinerInfo struct {
-	Owner                      address.Address   // Must be an ID-address.
-	Worker                     address.Address   // Must be an ID-address.
-	NewWorker                  address.Address   // Must be an ID-address.
-	ControlAddresses           []address.Address // Must be an ID-addresses.
-	WorkerChangeEpoch          abi.ChainEpoch
-	PeerId                     *peer.ID
-	Multiaddrs                 []abi.Multiaddrs
-	WindowPoStProofType        abi.RegisteredPoStProof
-	SectorSize                 abi.SectorSize
-	WindowPoStPartitionSectors uint64
-	ConsensusFaultElapsed      abi.ChainEpoch
-	PendingOwnerAddress        *address.Address
-	Beneficiary                address.Address
-	BeneficiaryTerm            *miner.BeneficiaryTerm
-	PendingBeneficiaryTerm     *miner.PendingBeneficiaryChange
-}
-
-type NetworkParams struct {
-	NetworkName             dtypes.NetworkName
-	BlockDelaySecs          uint64
-	ConsensusMinerMinPower  abi.StoragePower
-	SupportedProofTypes     []abi.RegisteredSealProof
-	PreCommitChallengeDelay abi.ChainEpoch
-	ForkUpgradeParams       ForkUpgradeParams
-	Eip155ChainID           int
-}
-
-type ForkUpgradeParams struct {
-	UpgradeSmokeHeight       abi.ChainEpoch
-	UpgradeBreezeHeight      abi.ChainEpoch
-	UpgradeIgnitionHeight    abi.ChainEpoch
-	UpgradeLiftoffHeight     abi.ChainEpoch
-	UpgradeAssemblyHeight    abi.ChainEpoch
-	UpgradeRefuelHeight      abi.ChainEpoch
-	UpgradeTapeHeight        abi.ChainEpoch
-	UpgradeKumquatHeight     abi.ChainEpoch
-	BreezeGasTampingDuration abi.ChainEpoch
-	UpgradeCalicoHeight      abi.ChainEpoch
-	UpgradePersianHeight     abi.ChainEpoch
-	UpgradeOrangeHeight      abi.ChainEpoch
-	UpgradeClausHeight       abi.ChainEpoch
-	UpgradeTrustHeight       abi.ChainEpoch
-	UpgradeNorwegianHeight   abi.ChainEpoch
-	UpgradeTurboHeight       abi.ChainEpoch
-	UpgradeHyperdriveHeight  abi.ChainEpoch
-	UpgradeChocolateHeight   abi.ChainEpoch
-	UpgradeOhSnapHeight      abi.ChainEpoch
-	UpgradeSkyrHeight        abi.ChainEpoch
-	UpgradeSharkHeight       abi.ChainEpoch
-	UpgradeHyggeHeight       abi.ChainEpoch
-	UpgradeLightningHeight   abi.ChainEpoch
-	UpgradeThunderHeight     abi.ChainEpoch
-	UpgradeWatermelonHeight  abi.ChainEpoch
-	UpgradeDragonHeight      abi.ChainEpoch
-	UpgradePhoenixHeight     abi.ChainEpoch
-}
-
-// ChainExportConfig holds configuration for chain ranged exports.
-type ChainExportConfig struct {
-	WriteBufferSize   int
-	NumWorkers        int
-	IncludeMessages   bool
-	IncludeReceipts   bool
-	IncludeStateRoots bool
-}

api/types/rpc.go

@@ -1,5 +0,0 @@
-package apitypes
-
-type Aliaser interface {
-	AliasMethod(alias, original string)
-}

api/v0api/full.go

@@ -3,26 +3,22 @@ package v0api
 import (
 	"context"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	textselector "github.com/ipld/go-ipld-selector-text-lite"
-	"github.com/libp2p/go-libp2p/core/peer"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
+	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/builtin/v8/paych"
-	verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/dline"
-	abinetwork "github.com/filecoin-project/go-state-types/network"
+	"github.com/ipfs/go-cid"
+	textselector "github.com/ipld/go-ipld-selector-text-lite"
+	"github.com/libp2p/go-libp2p-core/peer"
 
 	"github.com/filecoin-project/lotus/api"
 	apitypes "github.com/filecoin-project/lotus/api/types"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/types"
 	marketevents "github.com/filecoin-project/lotus/markets/loggers"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
@@ -113,9 +109,6 @@ type FullNode interface {
 	// ChainDeleteObj deletes node referenced by the given CID
 	ChainDeleteObj(context.Context, cid.Cid) error //perm:admin
 
-	// ChainPutObj puts and object into the blockstore
-	ChainPutObj(context.Context, blocks.Block) error
-
 	// ChainHasObj checks if a given CID exists in the chain blockstore.
 	ChainHasObj(context.Context, cid.Cid) (bool, error) //perm:read
 
@@ -140,7 +133,7 @@ type FullNode interface {
 
 	// ChainGetPath returns a set of revert/apply operations needed to get from
 	// one tipset to another, for example:
-	// ```
+	//```
 	//        to
 	//         ^
 	// from   tAA
@@ -149,7 +142,7 @@ type FullNode interface {
 	//  ^---*--^
 	//      ^
 	//     tRR
-	// ```
+	//```
 	// Would return `[revert(tBA), apply(tAB), apply(tAA)]`
 	ChainGetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*api.HeadChange, error) //perm:read
 
@@ -293,7 +286,7 @@ type FullNode interface {
 	WalletVerify(context.Context, address.Address, []byte, *crypto.Signature) (bool, error) //perm:read
 	// WalletDefaultAddress returns the address marked as default in the wallet.
 	WalletDefaultAddress(context.Context) (address.Address, error) //perm:write
-	// WalletSetDefault marks the given address as the default one.
+	// WalletSetDefault marks the given address as as the default one.
 	WalletSetDefault(context.Context, address.Address) error //perm:write
 	// WalletExport returns the private key of an address in the wallet.
 	WalletExport(context.Context, address.Address) (*types.KeyInfo, error) //perm:admin
@@ -366,12 +359,12 @@ type FullNode interface {
 	ClientCancelRetrievalDeal(ctx context.Context, dealid retrievalmarket.DealID) error //perm:write
 
 	// ClientUnimport removes references to the specified file from filestore
-	// ClientUnimport(path string)
+	//ClientUnimport(path string)
 
 	// ClientListImports lists imported files and their root CIDs
 	ClientListImports(ctx context.Context) ([]api.Import, error) //perm:write
 
-	// ClientListAsks() []Ask
+	//ClientListAsks() []Ask
 
 	// MethodGroup: State
 	// The State methods are used to query, inspect, and interact with chain state.
@@ -386,7 +379,7 @@ type FullNode interface {
 	StateCall(context.Context, *types.Message, types.TipSetKey) (*api.InvocResult, error) //perm:read
 	// StateReplay replays a given message, assuming it was included in a block in the specified tipset.
 	//
-	// If a tipset key is provided, and a replacing message is not found on chain,
+	// If a tipset key is provided, and a replacing message is found on chain,
 	// the method will return an error saying that the message wasn't found
 	//
 	// If no tipset key is provided, the appropriate tipset is looked up, and if
@@ -423,7 +416,7 @@ type FullNode interface {
 	// StateMinerPower returns the power of the indicated miner
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error) //perm:read
 	// StateMinerInfo returns info about the indicated miner
-	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (api.MinerInfo, error) //perm:read
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error) //perm:read
 	// StateMinerDeadlines returns all the proving deadlines for the given miner
 	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]api.Deadline, error) //perm:read
 	// StateMinerPartitions returns all partitions in the specified deadline
@@ -528,23 +521,9 @@ type FullNode interface {
 	// StateMarketParticipants returns the Escrow and Locked balances of every participant in the Storage Market
 	StateMarketParticipants(context.Context, types.TipSetKey) (map[string]api.MarketBalance, error) //perm:read
 	// StateMarketDeals returns information about every deal in the Storage Market
-	StateMarketDeals(context.Context, types.TipSetKey) (map[string]*api.MarketDeal, error) //perm:read
+	StateMarketDeals(context.Context, types.TipSetKey) (map[string]api.MarketDeal, error) //perm:read
 	// StateMarketStorageDeal returns information about the indicated deal
 	StateMarketStorageDeal(context.Context, abi.DealID, types.TipSetKey) (*api.MarketDeal, error) //perm:read
-	// StateGetAllocationForPendingDeal returns the allocation for a given deal ID of a pending deal.
-	StateGetAllocationForPendingDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*verifregtypes.Allocation, error) //perm:read
-	// StateGetAllocation returns the allocation for a given address and allocation ID.
-	StateGetAllocation(ctx context.Context, clientAddr address.Address, allocationId verifregtypes.AllocationId, tsk types.TipSetKey) (*verifregtypes.Allocation, error) //perm:read
-	// StateGetAllocations returns the all the allocations for a given client.
-	StateGetAllocations(ctx context.Context, clientAddr address.Address, tsk types.TipSetKey) (map[verifregtypes.AllocationId]verifregtypes.Allocation, error) //perm:read
-	// StateGetAllAllocations returns the all the allocations available in verified registry actor.
-	StateGetAllAllocations(ctx context.Context, tsk types.TipSetKey) (map[verifregtypes.AllocationId]verifregtypes.Allocation, error) //perm:read
-	// StateGetClaim returns the claim for a given address and claim ID.
-	StateGetClaim(ctx context.Context, providerAddr address.Address, claimId verifregtypes.ClaimId, tsk types.TipSetKey) (*verifregtypes.Claim, error) //perm:read
-	// StateGetClaims returns the all the claims for a given provider.
-	StateGetClaims(ctx context.Context, providerAddr address.Address, tsk types.TipSetKey) (map[verifregtypes.ClaimId]verifregtypes.Claim, error) //perm:read
-	// StateGetAllClaims returns the all the claims available in verified registry actor.
-	StateGetAllClaims(ctx context.Context, tsk types.TipSetKey) (map[verifregtypes.ClaimId]verifregtypes.Claim, error) //perm:read
 	// StateLookupID retrieves the ID address of the given address
 	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error) //perm:read
 	// StateAccountKey returns the public key address of the given ID address
@@ -605,7 +584,7 @@ type FullNode interface {
 	// Returns nil if there is no entry in the data cap table for the
 	// address.
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) //perm:read
-	// StateVerifiedRegistryRootKey returns the address of the Verified Registry's root key
+	// StateVerifiedClientStatus returns the address of the Verified Registry's root key
 	StateVerifiedRegistryRootKey(ctx context.Context, tsk types.TipSetKey) (address.Address, error) //perm:read
 	// StateDealProviderCollateralBounds returns the min and max collateral a storage provider
 	// can issue. It takes the deal size and verified status as parameters.
@@ -619,19 +598,12 @@ type FullNode interface {
 	StateVMCirculatingSupplyInternal(context.Context, types.TipSetKey) (api.CirculatingSupply, error) //perm:read
 	// StateNetworkVersion returns the network version at the given tipset
 	StateNetworkVersion(context.Context, types.TipSetKey) (apitypes.NetworkVersion, error) //perm:read
-	// StateActorCodeCIDs returns the CIDs of all the builtin actors for the given network version
-	StateActorCodeCIDs(context.Context, abinetwork.Version) (map[string]cid.Cid, error) //perm:read
-	// StateActorManifestCID returns the CID of the builtin actors manifest for the given network version
-	StateActorManifestCID(context.Context, abinetwork.Version) (cid.Cid, error) //perm:read
 
 	// StateGetRandomnessFromTickets is used to sample the chain for randomness.
 	StateGetRandomnessFromTickets(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) //perm:read
 	// StateGetRandomnessFromBeacon is used to sample the beacon for randomness.
 	StateGetRandomnessFromBeacon(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte, tsk types.TipSetKey) (abi.Randomness, error) //perm:read
 
-	// StateGetNetworkParams return current network params
-	StateGetNetworkParams(ctx context.Context) (*api.NetworkParams, error) //perm:read
-
 	// MethodGroup: Msig
 	// The Msig methods are used to interact with multisig wallets on the
 	// filecoin network
@@ -644,14 +616,14 @@ type FullNode interface {
 	// It takes the following params: <multisig address>, <start epoch>, <end epoch>
 	MsigGetVested(context.Context, address.Address, types.TipSetKey, types.TipSetKey) (types.BigInt, error) //perm:read
 
-	// MsigGetPending returns pending transactions for the given multisig
-	// wallet. Once pending transactions are fully approved, they will no longer
-	// appear here.
+	//MsigGetPending returns pending transactions for the given multisig
+	//wallet. Once pending transactions are fully approved, they will no longer
+	//appear here.
 	MsigGetPending(context.Context, address.Address, types.TipSetKey) ([]*api.MsigTransaction, error) //perm:read
 
 	// MsigCreate creates a multisig wallet
 	// It takes the following params: <required number of senders>, <approving addresses>, <unlock duration>
-	// <initial balance>, <sender address of the create msg>, <gas price>
+	//<initial balance>, <sender address of the create msg>, <gas price>
 	MsigCreate(context.Context, uint64, []address.Address, abi.ChainEpoch, types.BigInt, address.Address, types.BigInt) (cid.Cid, error) //perm:sign
 	// MsigPropose proposes a multisig message
 	// It takes the following params: <multisig address>, <recipient address>, <value to transfer>,

api/v0api/gateway.go

@@ -3,19 +3,16 @@ package v0api
 import (
 	"context"
 
-	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	"github.com/filecoin-project/go-state-types/dline"
 	abinetwork "github.com/filecoin-project/go-state-types/network"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 
 //                       MODIFYING THE API INTERFACE
@@ -36,14 +33,7 @@ import (
 //  * Generate openrpc blobs
 
 type Gateway interface {
-	MpoolPending(context.Context, types.TipSetKey) ([]*types.SignedMessage, error)
-	ChainGetBlock(context.Context, cid.Cid) (*types.BlockHeader, error)
-	MinerGetBaseInfo(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*api.MiningBaseInfo, error)
-	StateMinerSectorCount(context.Context, address.Address, types.TipSetKey) (api.MinerSectors, error)
-	GasEstimateGasPremium(context.Context, uint64, address.Address, int64, types.TipSetKey) (types.BigInt, error)
-	StateReplay(context.Context, types.TipSetKey, cid.Cid) (*api.InvocResult, error)
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
-	ChainPutObj(context.Context, blocks.Block) error
 	ChainHead(ctx context.Context) (*types.TipSet, error)
 	ChainGetBlockMessages(context.Context, cid.Cid) (*api.BlockMessages, error)
 	ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Message, error)
@@ -52,30 +42,21 @@ type Gateway interface {
 	ChainNotify(context.Context) (<-chan []*api.HeadChange, error)
 	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
 	GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, tsk types.TipSetKey) (*types.Message, error)
-	MpoolGetNonce(ctx context.Context, addr address.Address) (uint64, 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) ([]*api.MsigTransaction, error)
 	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-	StateCall(ctx context.Context, msg *types.Message, tsk types.TipSetKey) (*api.InvocResult, error)
 	StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (api.DealCollateralBounds, error)
-	StateDecodeParams(ctx context.Context, toAddr address.Address, method abi.MethodNum, params []byte, tsk types.TipSetKey) (interface{}, error)
 	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
-	StateGetAllocationForPendingDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*verifregtypes.Allocation, error)
-	StateGetAllocation(ctx context.Context, clientAddr address.Address, allocationId verifregtypes.AllocationId, tsk types.TipSetKey) (*verifregtypes.Allocation, error)
-	StateGetAllocations(ctx context.Context, clientAddr address.Address, tsk types.TipSetKey) (map[verifregtypes.AllocationId]verifregtypes.Allocation, error)
-	StateGetClaim(ctx context.Context, providerAddr address.Address, claimId verifregtypes.ClaimId, tsk types.TipSetKey) (*verifregtypes.Claim, error)
-	StateGetClaims(ctx context.Context, providerAddr address.Address, tsk types.TipSetKey) (map[verifregtypes.ClaimId]verifregtypes.Claim, 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) (api.MarketBalance, error)
 	StateMarketStorageDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error)
-	StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (api.MinerInfo, error)
+	StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error)
 	StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error)
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error)
-	StateNetworkName(context.Context) (dtypes.NetworkName, error)
 	StateNetworkVersion(context.Context, types.TipSetKey) (abinetwork.Version, error)
 	StateSearchMsg(ctx context.Context, msg cid.Cid) (*api.MsgLookup, error)
 	StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error)

api/v0api/permissioned.go

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

api/v0api/v0mocks/mock_full.go

@@ -9,40 +9,35 @@ import (
 	reflect "reflect"
 	time "time"
 
-	gomock "github.com/golang/mock/gomock"
-	uuid "github.com/google/uuid"
-	blocks "github.com/ipfs/go-block-format"
-	cid "github.com/ipfs/go-cid"
-	metrics "github.com/libp2p/go-libp2p/core/metrics"
-	network0 "github.com/libp2p/go-libp2p/core/network"
-	peer "github.com/libp2p/go-libp2p/core/peer"
-	protocol "github.com/libp2p/go-libp2p/core/protocol"
-
 	address "github.com/filecoin-project/go-address"
 	bitfield "github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer/v2"
+	datatransfer "github.com/filecoin-project/go-data-transfer"
 	retrievalmarket "github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	storagemarket "github.com/filecoin-project/go-fil-markets/storagemarket"
 	auth "github.com/filecoin-project/go-jsonrpc/auth"
 	abi "github.com/filecoin-project/go-state-types/abi"
 	big "github.com/filecoin-project/go-state-types/big"
-	miner "github.com/filecoin-project/go-state-types/builtin/v13/miner"
-	paych "github.com/filecoin-project/go-state-types/builtin/v8/paych"
-	miner0 "github.com/filecoin-project/go-state-types/builtin/v9/miner"
-	verifreg "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	crypto "github.com/filecoin-project/go-state-types/crypto"
 	dline "github.com/filecoin-project/go-state-types/dline"
 	network "github.com/filecoin-project/go-state-types/network"
-
 	api "github.com/filecoin-project/lotus/api"
 	apitypes "github.com/filecoin-project/lotus/api/types"
 	v0api "github.com/filecoin-project/lotus/api/v0api"
-	miner1 "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	miner "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	types "github.com/filecoin-project/lotus/chain/types"
 	alerting "github.com/filecoin-project/lotus/journal/alerting"
 	marketevents "github.com/filecoin-project/lotus/markets/loggers"
 	dtypes "github.com/filecoin-project/lotus/node/modules/dtypes"
 	imports "github.com/filecoin-project/lotus/node/repo/imports"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	paych "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	gomock "github.com/golang/mock/gomock"
+	uuid "github.com/google/uuid"
+	cid "github.com/ipfs/go-cid"
+	metrics "github.com/libp2p/go-libp2p-core/metrics"
+	network0 "github.com/libp2p/go-libp2p-core/network"
+	peer "github.com/libp2p/go-libp2p-core/peer"
+	protocol "github.com/libp2p/go-libp2p-core/protocol"
 )
 
 // MockFullNode is a mock of FullNode interface.
@@ -382,20 +377,6 @@ func (mr *MockFullNodeMockRecorder) ChainNotify(arg0 interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainNotify", reflect.TypeOf((*MockFullNode)(nil).ChainNotify), arg0)
 }
 
-// ChainPutObj mocks base method.
-func (m *MockFullNode) ChainPutObj(arg0 context.Context, arg1 blocks.Block) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ChainPutObj", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ChainPutObj indicates an expected call of ChainPutObj.
-func (mr *MockFullNodeMockRecorder) ChainPutObj(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChainPutObj", reflect.TypeOf((*MockFullNode)(nil).ChainPutObj), arg0, arg1)
-}
-
 // ChainReadObj mocks base method.
 func (m *MockFullNode) ChainReadObj(arg0 context.Context, arg1 cid.Cid) ([]byte, error) {
 	m.ctrl.T.Helper()
@@ -2159,21 +2140,6 @@ func (mr *MockFullNodeMockRecorder) Shutdown(arg0 interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockFullNode)(nil).Shutdown), arg0)
 }
 
-// StartTime mocks base method.
-func (m *MockFullNode) StartTime(arg0 context.Context) (time.Time, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StartTime", arg0)
-	ret0, _ := ret[0].(time.Time)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StartTime indicates an expected call of StartTime.
-func (mr *MockFullNodeMockRecorder) StartTime(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartTime", reflect.TypeOf((*MockFullNode)(nil).StartTime), arg0)
-}
-
 // StateAccountKey mocks base method.
 func (m *MockFullNode) StateAccountKey(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (address.Address, error) {
 	m.ctrl.T.Helper()
@@ -2189,36 +2155,6 @@ func (mr *MockFullNodeMockRecorder) StateAccountKey(arg0, arg1, arg2 interface{}
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateAccountKey", reflect.TypeOf((*MockFullNode)(nil).StateAccountKey), arg0, arg1, arg2)
 }
 
-// StateActorCodeCIDs mocks base method.
-func (m *MockFullNode) StateActorCodeCIDs(arg0 context.Context, arg1 network.Version) (map[string]cid.Cid, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateActorCodeCIDs", arg0, arg1)
-	ret0, _ := ret[0].(map[string]cid.Cid)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateActorCodeCIDs indicates an expected call of StateActorCodeCIDs.
-func (mr *MockFullNodeMockRecorder) StateActorCodeCIDs(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateActorCodeCIDs", reflect.TypeOf((*MockFullNode)(nil).StateActorCodeCIDs), arg0, arg1)
-}
-
-// StateActorManifestCID mocks base method.
-func (m *MockFullNode) StateActorManifestCID(arg0 context.Context, arg1 network.Version) (cid.Cid, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateActorManifestCID", arg0, arg1)
-	ret0, _ := ret[0].(cid.Cid)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateActorManifestCID indicates an expected call of StateActorManifestCID.
-func (mr *MockFullNodeMockRecorder) StateActorManifestCID(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateActorManifestCID", reflect.TypeOf((*MockFullNode)(nil).StateActorManifestCID), arg0, arg1)
-}
-
 // StateAllMinerFaults mocks base method.
 func (m *MockFullNode) StateAllMinerFaults(arg0 context.Context, arg1 abi.ChainEpoch, arg2 types.TipSetKey) ([]*api.Fault, error) {
 	m.ctrl.T.Helper()
@@ -2250,10 +2186,10 @@ func (mr *MockFullNodeMockRecorder) StateCall(arg0, arg1, arg2 interface{}) *gom
 }
 
 // StateChangedActors mocks base method.
-func (m *MockFullNode) StateChangedActors(arg0 context.Context, arg1, arg2 cid.Cid) (map[string]types.ActorV5, error) {
+func (m *MockFullNode) StateChangedActors(arg0 context.Context, arg1, arg2 cid.Cid) (map[string]types.Actor, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateChangedActors", arg0, arg1, arg2)
-	ret0, _ := ret[0].(map[string]types.ActorV5)
+	ret0, _ := ret[0].(map[string]types.Actor)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2325,10 +2261,10 @@ func (mr *MockFullNodeMockRecorder) StateDecodeParams(arg0, arg1, arg2, arg3, ar
 }
 
 // StateGetActor mocks base method.
-func (m *MockFullNode) StateGetActor(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (*types.ActorV5, error) {
+func (m *MockFullNode) StateGetActor(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (*types.Actor, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateGetActor", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*types.ActorV5)
+	ret0, _ := ret[0].(*types.Actor)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2339,126 +2275,6 @@ func (mr *MockFullNodeMockRecorder) StateGetActor(arg0, arg1, arg2 interface{})
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetActor", reflect.TypeOf((*MockFullNode)(nil).StateGetActor), arg0, arg1, arg2)
 }
 
-// StateGetAllAllocations mocks base method.
-func (m *MockFullNode) StateGetAllAllocations(arg0 context.Context, arg1 types.TipSetKey) (map[verifreg.AllocationId]verifreg.Allocation, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetAllAllocations", arg0, arg1)
-	ret0, _ := ret[0].(map[verifreg.AllocationId]verifreg.Allocation)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetAllAllocations indicates an expected call of StateGetAllAllocations.
-func (mr *MockFullNodeMockRecorder) StateGetAllAllocations(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetAllAllocations", reflect.TypeOf((*MockFullNode)(nil).StateGetAllAllocations), arg0, arg1)
-}
-
-// StateGetAllClaims mocks base method.
-func (m *MockFullNode) StateGetAllClaims(arg0 context.Context, arg1 types.TipSetKey) (map[verifreg.ClaimId]verifreg.Claim, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetAllClaims", arg0, arg1)
-	ret0, _ := ret[0].(map[verifreg.ClaimId]verifreg.Claim)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetAllClaims indicates an expected call of StateGetAllClaims.
-func (mr *MockFullNodeMockRecorder) StateGetAllClaims(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetAllClaims", reflect.TypeOf((*MockFullNode)(nil).StateGetAllClaims), arg0, arg1)
-}
-
-// StateGetAllocation mocks base method.
-func (m *MockFullNode) StateGetAllocation(arg0 context.Context, arg1 address.Address, arg2 verifreg.AllocationId, arg3 types.TipSetKey) (*verifreg.Allocation, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetAllocation", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*verifreg.Allocation)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetAllocation indicates an expected call of StateGetAllocation.
-func (mr *MockFullNodeMockRecorder) StateGetAllocation(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetAllocation", reflect.TypeOf((*MockFullNode)(nil).StateGetAllocation), arg0, arg1, arg2, arg3)
-}
-
-// StateGetAllocationForPendingDeal mocks base method.
-func (m *MockFullNode) StateGetAllocationForPendingDeal(arg0 context.Context, arg1 abi.DealID, arg2 types.TipSetKey) (*verifreg.Allocation, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetAllocationForPendingDeal", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*verifreg.Allocation)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetAllocationForPendingDeal indicates an expected call of StateGetAllocationForPendingDeal.
-func (mr *MockFullNodeMockRecorder) StateGetAllocationForPendingDeal(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetAllocationForPendingDeal", reflect.TypeOf((*MockFullNode)(nil).StateGetAllocationForPendingDeal), arg0, arg1, arg2)
-}
-
-// StateGetAllocations mocks base method.
-func (m *MockFullNode) StateGetAllocations(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (map[verifreg.AllocationId]verifreg.Allocation, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetAllocations", arg0, arg1, arg2)
-	ret0, _ := ret[0].(map[verifreg.AllocationId]verifreg.Allocation)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetAllocations indicates an expected call of StateGetAllocations.
-func (mr *MockFullNodeMockRecorder) StateGetAllocations(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetAllocations", reflect.TypeOf((*MockFullNode)(nil).StateGetAllocations), arg0, arg1, arg2)
-}
-
-// StateGetClaim mocks base method.
-func (m *MockFullNode) StateGetClaim(arg0 context.Context, arg1 address.Address, arg2 verifreg.ClaimId, arg3 types.TipSetKey) (*verifreg.Claim, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetClaim", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*verifreg.Claim)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetClaim indicates an expected call of StateGetClaim.
-func (mr *MockFullNodeMockRecorder) StateGetClaim(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetClaim", reflect.TypeOf((*MockFullNode)(nil).StateGetClaim), arg0, arg1, arg2, arg3)
-}
-
-// StateGetClaims mocks base method.
-func (m *MockFullNode) StateGetClaims(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (map[verifreg.ClaimId]verifreg.Claim, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetClaims", arg0, arg1, arg2)
-	ret0, _ := ret[0].(map[verifreg.ClaimId]verifreg.Claim)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetClaims indicates an expected call of StateGetClaims.
-func (mr *MockFullNodeMockRecorder) StateGetClaims(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetClaims", reflect.TypeOf((*MockFullNode)(nil).StateGetClaims), arg0, arg1, arg2)
-}
-
-// StateGetNetworkParams mocks base method.
-func (m *MockFullNode) StateGetNetworkParams(arg0 context.Context) (*api.NetworkParams, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetNetworkParams", arg0)
-	ret0, _ := ret[0].(*api.NetworkParams)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetNetworkParams indicates an expected call of StateGetNetworkParams.
-func (mr *MockFullNodeMockRecorder) StateGetNetworkParams(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetNetworkParams", reflect.TypeOf((*MockFullNode)(nil).StateGetNetworkParams), arg0)
-}
-
 // StateGetRandomnessFromBeacon mocks base method.
 func (m *MockFullNode) StateGetRandomnessFromBeacon(arg0 context.Context, arg1 crypto.DomainSeparationTag, arg2 abi.ChainEpoch, arg3 []byte, arg4 types.TipSetKey) (abi.Randomness, error) {
 	m.ctrl.T.Helper()
@@ -2580,10 +2396,10 @@ func (mr *MockFullNodeMockRecorder) StateMarketBalance(arg0, arg1, arg2 interfac
 }
 
 // StateMarketDeals mocks base method.
-func (m *MockFullNode) StateMarketDeals(arg0 context.Context, arg1 types.TipSetKey) (map[string]*api.MarketDeal, error) {
+func (m *MockFullNode) StateMarketDeals(arg0 context.Context, arg1 types.TipSetKey) (map[string]api.MarketDeal, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateMarketDeals", arg0, arg1)
-	ret0, _ := ret[0].(map[string]*api.MarketDeal)
+	ret0, _ := ret[0].(map[string]api.MarketDeal)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2685,10 +2501,10 @@ func (mr *MockFullNodeMockRecorder) StateMinerFaults(arg0, arg1, arg2 interface{
 }
 
 // StateMinerInfo mocks base method.
-func (m *MockFullNode) StateMinerInfo(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (api.MinerInfo, error) {
+func (m *MockFullNode) StateMinerInfo(arg0 context.Context, arg1 address.Address, arg2 types.TipSetKey) (miner.MinerInfo, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateMinerInfo", arg0, arg1, arg2)
-	ret0, _ := ret[0].(api.MinerInfo)
+	ret0, _ := ret[0].(miner.MinerInfo)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2925,10 +2741,10 @@ func (mr *MockFullNodeMockRecorder) StateSearchMsgLimited(arg0, arg1, arg2 inter
 }
 
 // StateSectorExpiration mocks base method.
-func (m *MockFullNode) StateSectorExpiration(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner1.SectorExpiration, error) {
+func (m *MockFullNode) StateSectorExpiration(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner.SectorExpiration, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateSectorExpiration", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*miner1.SectorExpiration)
+	ret0, _ := ret[0].(*miner.SectorExpiration)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2955,10 +2771,10 @@ func (mr *MockFullNodeMockRecorder) StateSectorGetInfo(arg0, arg1, arg2, arg3 in
 }
 
 // StateSectorPartition mocks base method.
-func (m *MockFullNode) StateSectorPartition(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner1.SectorLocation, error) {
+func (m *MockFullNode) StateSectorPartition(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (*miner.SectorLocation, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateSectorPartition", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*miner1.SectorLocation)
+	ret0, _ := ret[0].(*miner.SectorLocation)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -2970,10 +2786,10 @@ func (mr *MockFullNodeMockRecorder) StateSectorPartition(arg0, arg1, arg2, arg3
 }
 
 // StateSectorPreCommitInfo mocks base method.
-func (m *MockFullNode) StateSectorPreCommitInfo(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (miner0.SectorPreCommitOnChainInfo, error) {
+func (m *MockFullNode) StateSectorPreCommitInfo(arg0 context.Context, arg1 address.Address, arg2 abi.SectorNumber, arg3 types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StateSectorPreCommitInfo", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(miner0.SectorPreCommitOnChainInfo)
+	ret0, _ := ret[0].(miner.SectorPreCommitOnChainInfo)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }

api/v0api/v1_wrapper.go

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

api/v1api/latest.go

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

api/version.go

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

blockstore/api.go

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

blockstore/autobatch.go

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

blockstore/autobatch_test.go

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

blockstore/badger/blockstore.go

@@ -13,14 +13,13 @@ import (
 	"github.com/dgraph-io/badger/v2"
 	"github.com/dgraph-io/badger/v2/options"
 	"github.com/dgraph-io/badger/v2/pb"
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
-	logger "github.com/ipfs/go-log/v2"
-	pool "github.com/libp2p/go-buffer-pool"
 	"github.com/multiformats/go-base32"
 	"go.uber.org/zap"
-	"golang.org/x/xerrors"
+
+	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"
 )
@@ -45,8 +44,7 @@ const (
 	// MemoryMap is equivalent to badger/options.MemoryMap.
 	MemoryMap = options.MemoryMap
 	// LoadToRAM is equivalent to badger/options.LoadToRAM.
-	LoadToRAM          = options.LoadToRAM
-	defaultGCThreshold = 0.125
+	LoadToRAM = options.LoadToRAM
 )
 
 // Options embeds the badger options themselves, and augments them with
@@ -396,9 +394,6 @@ func (b *Blockstore) doCopy(from, to *badger.DB) error {
 	if workers < 2 {
 		workers = 2
 	}
-	if workers > 8 {
-		workers = 8
-	}
 
 	stream := from.NewStream()
 	stream.NumGo = workers
@@ -444,7 +439,7 @@ func (b *Blockstore) deleteDB(path string) {
 	}
 }
 
-func (b *Blockstore) onlineGC(ctx context.Context, threshold float64, checkFreq time.Duration, check func() error) error {
+func (b *Blockstore) onlineGC() error {
 	b.lockDB()
 	defer b.unlockDB()
 
@@ -453,26 +448,14 @@ func (b *Blockstore) onlineGC(ctx context.Context, threshold float64, checkFreq
 	if nworkers < 2 {
 		nworkers = 2
 	}
-	if nworkers > 7 { // max out at 1 goroutine per badger level
-		nworkers = 7
-	}
 
 	err := b.db.Flatten(nworkers)
 	if err != nil {
 		return err
 	}
-	checkTick := time.NewTimer(checkFreq)
-	defer checkTick.Stop()
+
 	for err == nil {
-		select {
-		case <-ctx.Done():
-			err = ctx.Err()
-		case <-checkTick.C:
-			err = check()
-			checkTick.Reset(checkFreq)
-		default:
-			err = b.db.RunValueLogGC(threshold)
-		}
+		err = b.db.RunValueLogGC(0.125)
 	}
 
 	if err == badger.ErrNoRewrite {
@@ -485,7 +468,7 @@ func (b *Blockstore) onlineGC(ctx context.Context, threshold float64, checkFreq
 
 // CollectGarbage compacts and runs garbage collection on the value log;
 // implements the BlockstoreGC trait
-func (b *Blockstore) CollectGarbage(ctx context.Context, opts ...blockstore.BlockstoreGCOption) error {
+func (b *Blockstore) CollectGarbage(opts ...blockstore.BlockstoreGCOption) error {
 	if err := b.access(); err != nil {
 		return err
 	}
@@ -502,58 +485,8 @@ func (b *Blockstore) CollectGarbage(ctx context.Context, opts ...blockstore.Bloc
 	if options.FullGC {
 		return b.movingGC()
 	}
-	threshold := options.Threshold
-	if threshold == 0 {
-		threshold = defaultGCThreshold
-	}
-	checkFreq := options.CheckFreq
-	if checkFreq < 30*time.Second { // disallow checking more frequently than block time
-		checkFreq = 30 * time.Second
-	}
-	check := options.Check
-	if check == nil {
-		check = func() error {
-			return nil
-		}
-	}
-	return b.onlineGC(ctx, threshold, checkFreq, check)
-}
 
-// GCOnce runs garbage collection on the value log;
-// implements BlockstoreGCOnce trait
-func (b *Blockstore) GCOnce(ctx context.Context, opts ...blockstore.BlockstoreGCOption) error {
-	if err := b.access(); err != nil {
-		return err
-	}
-	defer b.viewers.Done()
-
-	var options blockstore.BlockstoreGCOptions
-	for _, opt := range opts {
-		err := opt(&options)
-		if err != nil {
-			return err
-		}
-	}
-	if options.FullGC {
-		return xerrors.Errorf("FullGC option specified for GCOnce but full GC is non incremental")
-	}
-
-	threshold := options.Threshold
-	if threshold == 0 {
-		threshold = defaultGCThreshold
-	}
-
-	b.lockDB()
-	defer b.unlockDB()
-
-	// Note no compaction needed before single GC as we will hit at most one vlog anyway
-	err := b.db.RunValueLogGC(threshold)
-	if err == badger.ErrNoRewrite {
-		// not really an error in this case, it signals the end of GC
-		return nil
-	}
-
-	return err
+	return b.onlineGC()
 }
 
 // Size returns the aggregate size of the blockstore
@@ -611,25 +544,13 @@ func (b *Blockstore) View(ctx context.Context, cid cid.Cid, fn func([]byte) erro
 		case nil:
 			return item.Value(fn)
 		case badger.ErrKeyNotFound:
-			return ipld.ErrNotFound{Cid: cid}
+			return blockstore.ErrNotFound
 		default:
 			return fmt.Errorf("failed to view block from badger blockstore: %w", err)
 		}
 	})
 }
 
-func (b *Blockstore) Flush(context.Context) error {
-	if err := b.access(); err != nil {
-		return err
-	}
-	defer b.viewers.Done()
-
-	b.lockDB()
-	defer b.unlockDB()
-
-	return b.db.Sync()
-}
-
 // Has implements Blockstore.Has.
 func (b *Blockstore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
 	if err := b.access(); err != nil {
@@ -663,7 +584,7 @@ func (b *Blockstore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
 // Get implements Blockstore.Get.
 func (b *Blockstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) {
 	if !cid.Defined() {
-		return nil, ipld.ErrNotFound{Cid: cid}
+		return nil, blockstore.ErrNotFound
 	}
 
 	if err := b.access(); err != nil {
@@ -686,7 +607,7 @@ func (b *Blockstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error)
 			val, err = item.ValueCopy(nil)
 			return err
 		case badger.ErrKeyNotFound:
-			return ipld.ErrNotFound{Cid: cid}
+			return blockstore.ErrNotFound
 		default:
 			return fmt.Errorf("failed to get block from badger blockstore: %w", err)
 		}
@@ -718,7 +639,7 @@ func (b *Blockstore) GetSize(ctx context.Context, cid cid.Cid) (int, error) {
 		case nil:
 			size = int(item.ValueSize())
 		case badger.ErrKeyNotFound:
-			return ipld.ErrNotFound{Cid: cid}
+			return blockstore.ErrNotFound
 		default:
 			return fmt.Errorf("failed to get block size from badger blockstore: %w", err)
 		}
@@ -746,20 +667,6 @@ func (b *Blockstore) Put(ctx context.Context, block blocks.Block) error {
 	}
 
 	put := func(db *badger.DB) error {
-		// Check if we have it before writing it.
-		switch err := db.View(func(txn *badger.Txn) error {
-			_, err := txn.Get(k)
-			return err
-		}); err {
-		case badger.ErrKeyNotFound:
-		case nil:
-			// Already exists, skip the put.
-			return nil
-		default:
-			return err
-		}
-
-		// Then write it.
 		err := db.Update(func(txn *badger.Txn) error {
 			return txn.Set(k, block.RawData())
 		})
@@ -815,33 +722,12 @@ func (b *Blockstore) PutMany(ctx context.Context, blocks []blocks.Block) error {
 		keys = append(keys, k)
 	}
 
-	err := b.db.View(func(txn *badger.Txn) error {
-		for i, k := range keys {
-			switch _, err := txn.Get(k); err {
-			case badger.ErrKeyNotFound:
-			case nil:
-				keys[i] = nil
-			default:
-				// Something is actually wrong
-				return err
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-
 	put := func(db *badger.DB) error {
 		batch := db.NewWriteBatch()
 		defer batch.Cancel()
 
 		for i, block := range blocks {
 			k := keys[i]
-			if k == nil {
-				// skipped because we already have it.
-				continue
-			}
 			if err := batch.Set(k, block.RawData()); err != nil {
 				return err
 			}

blockstore/badger/blockstore_test.go

@@ -1,4 +1,4 @@
-// stm: #unit
+//stm: #unit
 package badgerbs
 
 import (
@@ -10,11 +10,12 @@ import (
 	"strings"
 	"testing"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/sync/errgroup"
 
+	blocks "github.com/ipfs/go-block-format"
+	cid "github.com/ipfs/go-cid"
+
 	"github.com/filecoin-project/lotus/blockstore"
 )
 
@@ -145,7 +146,7 @@ func testMove(t *testing.T, optsF func(string) Options) {
 		return nil
 	})
 	g.Go(func() error {
-		return db.CollectGarbage(ctx, blockstore.WithFullGC(true))
+		return db.CollectGarbage(blockstore.WithFullGC(true))
 	})
 
 	err = g.Wait()
@@ -230,7 +231,7 @@ func testMove(t *testing.T, optsF func(string) Options) {
 	checkPath()
 
 	// now do another FullGC to test the double move and following of symlinks
-	if err := db.CollectGarbage(ctx, blockstore.WithFullGC(true)); err != nil {
+	if err := db.CollectGarbage(blockstore.WithFullGC(true)); err != nil {
 		t.Fatal(err)
 	}
 

blockstore/badger/blockstore_test_suite.go

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

blockstore/blockstore.go

@@ -2,16 +2,18 @@ package blockstore
 
 import (
 	"context"
-	"time"
 
-	blockstore "github.com/ipfs/boxo/blockstore"
-	"github.com/ipfs/go-cid"
+	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.
@@ -19,7 +21,6 @@ type Blockstore interface {
 	blockstore.Blockstore
 	blockstore.Viewer
 	BatchDeleter
-	Flusher
 }
 
 // BasicBlockstore is an alias to the original IPFS Blockstore.
@@ -27,10 +28,6 @@ type BasicBlockstore = blockstore.Blockstore
 
 type Viewer = blockstore.Viewer
 
-type Flusher interface {
-	Flush(context.Context) error
-}
-
 type BatchDeleter interface {
 	DeleteMany(ctx context.Context, cids []cid.Cid) error
 }
@@ -42,12 +39,7 @@ type BlockstoreIterator interface {
 
 // BlockstoreGC is a trait for blockstores that support online garbage collection
 type BlockstoreGC interface {
-	CollectGarbage(ctx context.Context, options ...BlockstoreGCOption) error
-}
-
-// BlockstoreGCOnce is a trait for a blockstore that supports incremental online garbage collection
-type BlockstoreGCOnce interface {
-	GCOnce(ctx context.Context, options ...BlockstoreGCOption) error
+	CollectGarbage(options ...BlockstoreGCOption) error
 }
 
 // BlockstoreGCOption is a functional interface for controlling blockstore GC options
@@ -56,12 +48,6 @@ type BlockstoreGCOption = func(*BlockstoreGCOptions) error
 // BlockstoreGCOptions is a struct with GC options
 type BlockstoreGCOptions struct {
 	FullGC bool
-	// fraction of garbage in badger vlog before its worth processing in online GC
-	Threshold float64
-	// how often to call the check function
-	CheckFreq time.Duration
-	// function to call periodically to pause or early terminate GC
-	Check func() error
 }
 
 func WithFullGC(fullgc bool) BlockstoreGCOption {
@@ -71,27 +57,6 @@ func WithFullGC(fullgc bool) BlockstoreGCOption {
 	}
 }
 
-func WithThreshold(threshold float64) BlockstoreGCOption {
-	return func(opts *BlockstoreGCOptions) error {
-		opts.Threshold = threshold
-		return nil
-	}
-}
-
-func WithCheckFreq(f time.Duration) BlockstoreGCOption {
-	return func(opts *BlockstoreGCOptions) error {
-		opts.CheckFreq = f
-		return nil
-	}
-}
-
-func WithCheck(check func() error) BlockstoreGCOption {
-	return func(opts *BlockstoreGCOptions) error {
-		opts.Check = check
-		return nil
-	}
-}
-
 // BlockstoreSize is a trait for on-disk blockstores that can report their size
 type BlockstoreSize interface {
 	Size() (int64, error)
@@ -130,13 +95,6 @@ type adaptedBlockstore struct {
 
 var _ Blockstore = (*adaptedBlockstore)(nil)
 
-func (a *adaptedBlockstore) Flush(ctx context.Context) error {
-	if flusher, canFlush := a.Blockstore.(Flusher); canFlush {
-		return flusher.Flush(ctx)
-	}
-	return nil
-}
-
 func (a *adaptedBlockstore) View(ctx context.Context, cid cid.Cid, callback func([]byte) error) error {
 	blk, err := a.Get(ctx, cid)
 	if err != nil {

blockstore/buffered.go

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

blockstore/cached.go

@@ -1,113 +0,0 @@
-package blockstore
-
-import (
-	"context"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-)
-
-// BlockstoreCache is a cache for blocks, compatible with lru.Cache; Must be safe for concurrent access
-type BlockstoreCache interface {
-	Remove(mhString MhString) bool
-	Contains(mhString MhString) bool
-	Get(mhString MhString) (blocks.Block, bool)
-	Add(mhString MhString, block blocks.Block) (evicted bool)
-}
-
-type ReadCachedBlockstore struct {
-	top   Blockstore
-	cache BlockstoreCache
-}
-
-type MhString string
-
-func NewReadCachedBlockstore(top Blockstore, cache BlockstoreCache) *ReadCachedBlockstore {
-	return &ReadCachedBlockstore{
-		top:   top,
-		cache: cache,
-	}
-}
-
-func (c *ReadCachedBlockstore) DeleteBlock(ctx context.Context, cid cid.Cid) error {
-	c.cache.Remove(MhString(cid.Hash()))
-	return c.top.DeleteBlock(ctx, cid)
-}
-
-func (c *ReadCachedBlockstore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
-	if c.cache.Contains(MhString(cid.Hash())) {
-		return true, nil
-	}
-
-	return c.top.Has(ctx, cid)
-}
-
-func (c *ReadCachedBlockstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) {
-	if out, ok := c.cache.Get(MhString(cid.Hash())); ok {
-		return out, nil
-	}
-
-	out, err := c.top.Get(ctx, cid)
-	if err != nil {
-		return nil, err
-	}
-
-	c.cache.Add(MhString(cid.Hash()), out)
-	return out, nil
-}
-
-func (c *ReadCachedBlockstore) GetSize(ctx context.Context, cid cid.Cid) (int, error) {
-	if b, ok := c.cache.Get(MhString(cid.Hash())); ok {
-		return len(b.RawData()), nil
-	}
-
-	return c.top.GetSize(ctx, cid)
-}
-
-func (c *ReadCachedBlockstore) Put(ctx context.Context, block blocks.Block) error {
-	c.cache.Add(MhString(block.Cid().Hash()), block)
-	return c.top.Put(ctx, block)
-}
-
-func (c *ReadCachedBlockstore) PutMany(ctx context.Context, blocks []blocks.Block) error {
-	for _, b := range blocks {
-		c.cache.Add(MhString(b.Cid().Hash()), b)
-	}
-
-	return c.top.PutMany(ctx, blocks)
-}
-
-func (c *ReadCachedBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
-	return c.top.AllKeysChan(ctx)
-}
-
-func (c *ReadCachedBlockstore) HashOnRead(enabled bool) {
-	c.top.HashOnRead(enabled)
-}
-
-func (c *ReadCachedBlockstore) View(ctx context.Context, cid cid.Cid, callback func([]byte) error) error {
-	return c.top.View(ctx, cid, func(bb []byte) error {
-		blk, err := blocks.NewBlockWithCid(bb, cid)
-		if err != nil {
-			return err
-		}
-
-		c.cache.Add(MhString(cid.Hash()), blk)
-
-		return callback(bb)
-	})
-}
-
-func (c *ReadCachedBlockstore) DeleteMany(ctx context.Context, cids []cid.Cid) error {
-	for _, ci := range cids {
-		c.cache.Remove(MhString(ci.Hash()))
-	}
-
-	return c.top.DeleteMany(ctx, cids)
-}
-
-func (c *ReadCachedBlockstore) Flush(ctx context.Context) error {
-	return c.top.Flush(ctx)
-}
-
-var _ Blockstore = (*ReadCachedBlockstore)(nil)

blockstore/cbor_gen.go

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

blockstore/discard.go

@@ -5,7 +5,7 @@ import (
 	"io"
 
 	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
+	cid "github.com/ipfs/go-cid"
 )
 
 var _ Blockstore = (*discardstore)(nil)
@@ -38,10 +38,6 @@ func (b *discardstore) View(ctx context.Context, cid cid.Cid, f func([]byte) err
 	return b.bs.View(ctx, cid, f)
 }
 
-func (b *discardstore) Flush(ctx context.Context) error {
-	return nil
-}
-
 func (b *discardstore) Put(ctx context.Context, blk blocks.Block) error {
 	return nil
 }

blockstore/fallback.go

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

blockstore/idstore.go

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

blockstore/ipfs.go

@@ -0,0 +1,155 @@
+package blockstore
+
+import (
+	"bytes"
+	"context"
+	"io/ioutil"
+
+	"golang.org/x/xerrors"
+
+	"github.com/multiformats/go-multiaddr"
+	"github.com/multiformats/go-multihash"
+
+	blocks "github.com/ipfs/go-block-format"
+	"github.com/ipfs/go-cid"
+	httpapi "github.com/ipfs/go-ipfs-http-client"
+	iface "github.com/ipfs/interface-go-ipfs-core"
+	"github.com/ipfs/interface-go-ipfs-core/options"
+	"github.com/ipfs/interface-go-ipfs-core/path"
+)
+
+type IPFSBlockstore struct {
+	ctx             context.Context
+	api, offlineAPI iface.CoreAPI
+}
+
+var _ BasicBlockstore = (*IPFSBlockstore)(nil)
+
+func NewLocalIPFSBlockstore(ctx context.Context, onlineMode bool) (Blockstore, error) {
+	localApi, err := httpapi.NewLocalApi()
+	if err != nil {
+		return nil, xerrors.Errorf("getting local ipfs api: %w", err)
+	}
+	api, err := localApi.WithOptions(options.Api.Offline(!onlineMode))
+	if err != nil {
+		return nil, xerrors.Errorf("setting offline mode: %s", err)
+	}
+
+	offlineAPI := api
+	if onlineMode {
+		offlineAPI, err = localApi.WithOptions(options.Api.Offline(true))
+		if err != nil {
+			return nil, xerrors.Errorf("applying offline mode: %s", err)
+		}
+	}
+
+	bs := &IPFSBlockstore{
+		ctx:        ctx,
+		api:        api,
+		offlineAPI: offlineAPI,
+	}
+
+	return Adapt(bs), nil
+}
+
+func NewRemoteIPFSBlockstore(ctx context.Context, maddr multiaddr.Multiaddr, onlineMode bool) (Blockstore, error) {
+	httpApi, err := httpapi.NewApi(maddr)
+	if err != nil {
+		return nil, xerrors.Errorf("setting remote ipfs api: %w", err)
+	}
+	api, err := httpApi.WithOptions(options.Api.Offline(!onlineMode))
+	if err != nil {
+		return nil, xerrors.Errorf("applying offline mode: %s", err)
+	}
+
+	offlineAPI := api
+	if onlineMode {
+		offlineAPI, err = httpApi.WithOptions(options.Api.Offline(true))
+		if err != nil {
+			return nil, xerrors.Errorf("applying offline mode: %s", err)
+		}
+	}
+
+	bs := &IPFSBlockstore{
+		ctx:        ctx,
+		api:        api,
+		offlineAPI: offlineAPI,
+	}
+
+	return Adapt(bs), nil
+}
+
+func (i *IPFSBlockstore) DeleteBlock(ctx context.Context, cid cid.Cid) error {
+	return xerrors.Errorf("not supported")
+}
+
+func (i *IPFSBlockstore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
+	_, err := i.offlineAPI.Block().Stat(ctx, path.IpldPath(cid))
+	if err != nil {
+		// The underlying client is running in Offline mode.
+		// Stat() will fail with an err if the block isn't in the
+		// blockstore. If that's the case, return false without
+		// an error since that's the original intention of this method.
+		if err.Error() == "blockservice: key not found" {
+			return false, nil
+		}
+		return false, xerrors.Errorf("getting ipfs block: %w", err)
+	}
+
+	return true, nil
+}
+
+func (i *IPFSBlockstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) {
+	rd, err := i.api.Block().Get(ctx, path.IpldPath(cid))
+	if err != nil {
+		return nil, xerrors.Errorf("getting ipfs block: %w", err)
+	}
+
+	data, err := ioutil.ReadAll(rd)
+	if err != nil {
+		return nil, err
+	}
+
+	return blocks.NewBlockWithCid(data, cid)
+}
+
+func (i *IPFSBlockstore) GetSize(ctx context.Context, cid cid.Cid) (int, error) {
+	st, err := i.api.Block().Stat(ctx, path.IpldPath(cid))
+	if err != nil {
+		return 0, xerrors.Errorf("getting ipfs block: %w", err)
+	}
+
+	return st.Size(), nil
+}
+
+func (i *IPFSBlockstore) Put(ctx context.Context, block blocks.Block) error {
+	mhd, err := multihash.Decode(block.Cid().Hash())
+	if err != nil {
+		return err
+	}
+
+	_, err = i.api.Block().Put(ctx, bytes.NewReader(block.RawData()),
+		options.Block.Hash(mhd.Code, mhd.Length),
+		options.Block.Format(cid.CodecToStr[block.Cid().Type()]))
+	return err
+}
+
+func (i *IPFSBlockstore) PutMany(ctx context.Context, blocks []blocks.Block) error {
+	// TODO: could be done in parallel
+
+	for _, block := range blocks {
+		if err := i.Put(ctx, block); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (i *IPFSBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
+	return nil, xerrors.Errorf("not supported")
+}
+
+func (i *IPFSBlockstore) HashOnRead(enabled bool) {
+	return // TODO: We could technically support this, but..
+}

blockstore/mem.go

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

blockstore/mem_test.go

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

blockstore/net.go

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

blockstore/net_serve.go

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

blockstore/net_test.go

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

blockstore/net_ws.go

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

blockstore/splitstore/checkpoint.go

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

blockstore/splitstore/coldset.go

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

blockstore/splitstore/debug.go

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

blockstore/splitstore/markset.go

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

blockstore/splitstore/markset_badger.go

@@ -6,13 +6,13 @@ import (
 	"runtime"
 	"sync"
 
-	"github.com/dgraph-io/badger/v2"
-	"github.com/dgraph-io/badger/v2/options"
-	"github.com/ipfs/go-cid"
-	"go.uber.org/zap"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/lotus/system"
+	"github.com/dgraph-io/badger/v2"
+	"github.com/dgraph-io/badger/v2/options"
+	"go.uber.org/zap"
+
+	cid "github.com/ipfs/go-cid"
 )
 
 type BadgerMarkSetEnv struct {
@@ -351,7 +351,7 @@ func (s *BadgerMarkSet) write(seqno int) (err error) {
 	persist := s.persist
 	s.mx.RUnlock()
 
-	if persist && !system.BadgerFsyncDisable { // WARNING: disabling sync makes recovery from crash during critical section unsound
+	if persist {
 		return s.db.Sync()
 	}
 

blockstore/splitstore/markset_map.go

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

blockstore/splitstore/markset_test.go

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

blockstore/splitstore/splitstore.go

@@ -8,22 +8,22 @@ import (
 	"sync/atomic"
 	"time"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	dstore "github.com/ipfs/go-datastore"
-	ipld "github.com/ipfs/go-ipld-format"
-	logging "github.com/ipfs/go-log/v2"
-	"go.opencensus.io/stats"
 	"go.uber.org/multierr"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	blocks "github.com/ipfs/go-block-format"
+	cid "github.com/ipfs/go-cid"
+	dstore "github.com/ipfs/go-datastore"
+	logging "github.com/ipfs/go-log/v2"
 
+	"github.com/filecoin-project/go-state-types/abi"
 	bstore "github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/metrics"
+
+	"go.opencensus.io/stats"
 )
 
 var (
@@ -43,16 +43,8 @@ var (
 	// compactionIndexKey stores the compaction index (serial number)
 	compactionIndexKey = dstore.NewKey("/splitstore/compactionIndex")
 
-	// stores the prune index (serial number)
-	pruneIndexKey = dstore.NewKey("/splitstore/pruneIndex")
-
-	// stores the base epoch of last prune in the metadata store
-	pruneEpochKey = dstore.NewKey("/splitstore/pruneEpoch")
-
 	log = logging.Logger("splitstore")
 
-	errClosing = errors.New("splitstore is closing")
-
 	// set this to true if you are debugging the splitstore to enable debug logging
 	enableDebugLog = false
 	// set this to true if you want to track origin stack traces in the write log
@@ -62,16 +54,6 @@ var (
 	upgradeBoundary = build.Finality
 )
 
-type CompactType int
-
-const (
-	none CompactType = iota
-	warmup
-	hot
-	cold
-	check
-)
-
 func init() {
 	if os.Getenv("LOTUS_SPLITSTORE_DEBUG_LOG") == "1" {
 		enableDebugLog = true
@@ -98,10 +80,6 @@ type Config struct {
 	// and directly purges cold blocks.
 	DiscardColdBlocks bool
 
-	// UniversalColdBlocks indicates whether all blocks being garbage collected and purged
-	// from the hotstore should be written to the cold store
-	UniversalColdBlocks bool
-
 	// HotstoreMessageRetention indicates the hotstore retention policy for messages.
 	// It has the following semantics:
 	// - a value of 0 will only retain messages within the compaction boundary (4 finalities)
@@ -115,23 +93,6 @@ type Config struct {
 	// A positive value is the number of compactions before a full GC is performed;
 	// a value of 1 will perform full GC in every compaction.
 	HotStoreFullGCFrequency uint64
-
-	// HotstoreMaxSpaceTarget suggests the max allowed space the hotstore can take.
-	// This is not a hard limit, it is possible for the hotstore to exceed the target
-	// for example if state grows massively between compactions. The splitstore
-	// will make a best effort to avoid overflowing the target and in practice should
-	// never overflow.  This field is used when doing GC at the end of a compaction to
-	// adaptively choose moving GC
-	HotstoreMaxSpaceTarget uint64
-
-	// Moving GC will be triggered when total moving size exceeds
-	// HotstoreMaxSpaceTarget - HotstoreMaxSpaceThreshold
-	HotstoreMaxSpaceThreshold uint64
-
-	// Safety buffer to prevent moving GC from overflowing disk.
-	// Moving GC will not occur when total moving size exceeds
-	// HotstoreMaxSpaceTarget - HotstoreMaxSpaceSafetyBuffer
-	HotstoreMaxSpaceSafetyBuffer uint64
 }
 
 // ChainAccessor allows the Splitstore to access the chain. It will most likely
@@ -156,17 +117,15 @@ type hotstore interface {
 }
 
 type SplitStore struct {
-	compacting  int32       // flag for when compaction is in progress
-	compactType CompactType // compaction type, protected by compacting atomic, only meaningful when compacting == 1
-	closing     int32       // the splitstore is closing
+	compacting int32 // compaction/prune/warmup in progress
+	closing    int32 // the splitstore is closing
 
 	cfg  *Config
 	path string
 
 	mx          sync.Mutex
-	warmupEpoch atomic.Int64
+	warmupEpoch abi.ChainEpoch // protected by mx
 	baseEpoch   abi.ChainEpoch // protected by compaction lock
-	pruneEpoch  abi.ChainEpoch // protected by compaction lock
 
 	headChangeMx sync.Mutex
 
@@ -181,16 +140,10 @@ type SplitStore struct {
 	markSetSize int64
 
 	compactionIndex int64
-	pruneIndex      int64
 
 	ctx    context.Context
 	cancel func()
 
-	outOfSync         int32 // for fast checking
-	chainSyncMx       sync.Mutex
-	chainSyncCond     sync.Cond
-	chainSyncFinished bool // protected by chainSyncMx
-
 	debug *debugLog
 
 	// transactional protection for concurrent read/writes during compaction
@@ -217,17 +170,6 @@ type SplitStore struct {
 
 	// registered protectors
 	protectors []func(func(cid.Cid) error) error
-
-	// dag sizes measured during latest compaction
-	// logged and used for GC strategy
-
-	// protected by compaction lock
-	szWalk          int64
-	szProtectedTxns int64
-	szKeys          int64 // approximate, not counting keys protected when entering critical section
-
-	// protected by txnLk
-	szMarkedLiveRefs int64
 }
 
 var _ bstore.Blockstore = (*SplitStore)(nil)
@@ -265,7 +207,6 @@ func Open(path string, ds dstore.Datastore, hot, cold bstore.Blockstore, cfg *Co
 
 	ss.txnViewsCond.L = &ss.txnViewsMx
 	ss.txnSyncCond.L = &ss.txnSyncMx
-	ss.chainSyncCond.L = &ss.chainSyncMx
 	ss.ctx, ss.cancel = context.WithCancel(context.Background())
 
 	ss.reifyCond.L = &ss.reifyMx
@@ -286,13 +227,6 @@ func Open(path string, ds dstore.Datastore, hot, cold bstore.Blockstore, cfg *Co
 			return nil, xerrors.Errorf("error resuming compaction: %w", err)
 		}
 	}
-	if ss.pruneCheckpointExists() {
-		log.Info("found prune checkpoint; resuming prune")
-		if err := ss.completePrune(); err != nil {
-			markSetEnv.Close() //nolint:errcheck
-			return nil, xerrors.Errorf("error resuming prune: %w", err)
-		}
-	}
 
 	return ss, nil
 }
@@ -326,14 +260,8 @@ func (s *SplitStore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
 		if has {
 			return s.has(cid)
 		}
-		switch s.compactType {
-		case hot:
-			return s.cold.Has(ctx, cid)
-		case cold:
-			return s.hot.Has(ctx, cid)
-		default:
-			return false, xerrors.Errorf("invalid compaction type %d, only hot and cold allowed for critical section", s.compactType)
-		}
+
+		return s.cold.Has(ctx, cid)
 	}
 
 	has, err := s.hot.Has(ctx, cid)
@@ -348,11 +276,8 @@ func (s *SplitStore) Has(ctx context.Context, cid cid.Cid) (bool, error) {
 	}
 
 	has, err = s.cold.Has(ctx, cid)
-	if has {
-		s.trackTxnRef(cid)
-		if bstore.IsHotView(ctx) {
-			s.reifyColdObject(cid)
-		}
+	if has && bstore.IsHotView(ctx) {
+		s.reifyColdObject(cid)
 	}
 
 	return has, err
@@ -382,31 +307,24 @@ func (s *SplitStore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error)
 		if has {
 			return s.get(cid)
 		}
-		switch s.compactType {
-		case hot:
-			return s.cold.Get(ctx, cid)
-		case cold:
-			return s.hot.Get(ctx, cid)
-		default:
-			return nil, xerrors.Errorf("invalid compaction type %d, only hot and cold allowed for critical section", s.compactType)
-		}
+
+		return s.cold.Get(ctx, cid)
 	}
 
 	blk, err := s.hot.Get(ctx, cid)
 
-	switch {
-	case err == nil:
+	switch err {
+	case nil:
 		s.trackTxnRef(cid)
 		return blk, nil
 
-	case ipld.IsNotFound(err):
+	case bstore.ErrNotFound:
 		if s.isWarm() {
 			s.debug.LogReadMiss(cid)
 		}
 
 		blk, err = s.cold.Get(ctx, cid)
 		if err == nil {
-			s.trackTxnRef(cid)
 			if bstore.IsHotView(ctx) {
 				s.reifyColdObject(cid)
 			}
@@ -443,31 +361,24 @@ func (s *SplitStore) GetSize(ctx context.Context, cid cid.Cid) (int, error) {
 		if has {
 			return s.getSize(cid)
 		}
-		switch s.compactType {
-		case hot:
-			return s.cold.GetSize(ctx, cid)
-		case cold:
-			return s.hot.GetSize(ctx, cid)
-		default:
-			return 0, xerrors.Errorf("invalid compaction type %d, only hot and cold allowed for critical section", s.compactType)
-		}
+
+		return s.cold.GetSize(ctx, cid)
 	}
 
 	size, err := s.hot.GetSize(ctx, cid)
 
-	switch {
-	case err == nil:
+	switch err {
+	case nil:
 		s.trackTxnRef(cid)
 		return size, nil
 
-	case ipld.IsNotFound(err):
+	case bstore.ErrNotFound:
 		if s.isWarm() {
 			s.debug.LogReadMiss(cid)
 		}
 
 		size, err = s.cold.GetSize(ctx, cid)
 		if err == nil {
-			s.trackTxnRef(cid)
 			if bstore.IsHotView(ctx) {
 				s.reifyColdObject(cid)
 			}
@@ -481,23 +392,6 @@ func (s *SplitStore) GetSize(ctx context.Context, cid cid.Cid) (int, error) {
 	}
 }
 
-func (s *SplitStore) Flush(ctx context.Context) error {
-	s.txnLk.RLock()
-	defer s.txnLk.RUnlock()
-
-	if err := s.cold.Flush(ctx); err != nil {
-		return err
-	}
-	if err := s.hot.Flush(ctx); err != nil {
-		return err
-	}
-	if err := s.ds.Sync(ctx, dstore.Key{}); err != nil {
-		return err
-	}
-
-	return nil
-}
-
 func (s *SplitStore) Put(ctx context.Context, blk blocks.Block) error {
 	if isIdentiyCid(blk.Cid()) {
 		return nil
@@ -514,12 +408,12 @@ func (s *SplitStore) Put(ctx context.Context, blk blocks.Block) error {
 	s.debug.LogWrite(blk)
 
 	// critical section
-	if s.txnMarkSet != nil && s.compactType == hot { // puts only touch hot store
+	if s.txnMarkSet != nil {
 		s.markLiveRefs([]cid.Cid{blk.Cid()})
 		return nil
 	}
-	s.trackTxnRef(blk.Cid())
 
+	s.trackTxnRef(blk.Cid())
 	return nil
 }
 
@@ -565,12 +459,12 @@ func (s *SplitStore) PutMany(ctx context.Context, blks []blocks.Block) error {
 	s.debug.LogWriteMany(blks)
 
 	// critical section
-	if s.txnMarkSet != nil && s.compactType == hot { // puts only touch hot store
+	if s.txnMarkSet != nil {
 		s.markLiveRefs(batch)
 		return nil
 	}
-	s.trackTxnRefMany(batch)
 
+	s.trackTxnRefMany(batch)
 	return nil
 }
 
@@ -642,14 +536,8 @@ func (s *SplitStore) View(ctx context.Context, cid cid.Cid, cb func([]byte) erro
 		if has {
 			return s.view(cid, cb)
 		}
-		switch s.compactType {
-		case hot:
-			return s.cold.View(ctx, cid, cb)
-		case cold:
-			return s.hot.View(ctx, cid, cb)
-		default:
-			return xerrors.Errorf("invalid compaction type %d, only hot and cold allowed for critical section", s.compactType)
-		}
+
+		return s.cold.View(ctx, cid, cb)
 	}
 
 	// views are (optimistically) protected two-fold:
@@ -664,7 +552,8 @@ func (s *SplitStore) View(ctx context.Context, cid cid.Cid, cb func([]byte) erro
 	defer s.viewDone()
 
 	err := s.hot.View(ctx, cid, cb)
-	if ipld.IsNotFound(err) {
+	switch err {
+	case bstore.ErrNotFound:
 		if s.isWarm() {
 			s.debug.LogReadMiss(cid)
 		}
@@ -678,12 +567,16 @@ func (s *SplitStore) View(ctx context.Context, cid cid.Cid, cb func([]byte) erro
 			stats.Record(s.ctx, metrics.SplitstoreMiss.M(1))
 		}
 		return err
+
+	default:
+		return err
 	}
-	return err
 }
 
 func (s *SplitStore) isWarm() bool {
-	return s.warmupEpoch.Load() > 0
+	s.mx.Lock()
+	defer s.mx.Unlock()
+	return s.warmupEpoch > 0
 }
 
 // State tracking
@@ -733,28 +626,11 @@ func (s *SplitStore) Start(chain ChainAccessor, us stmgr.UpgradeSchedule) error
 		return xerrors.Errorf("error loading base epoch: %w", err)
 	}
 
-	// load prune epoch from metadata ds
-	bs, err = s.ds.Get(s.ctx, pruneEpochKey)
-	switch err {
-	case nil:
-		s.pruneEpoch = bytesToEpoch(bs)
-	case dstore.ErrNotFound:
-		if curTs == nil {
-			//this can happen in some tests
-			break
-		}
-		if err := s.setPruneEpoch(curTs.Height()); err != nil {
-			return xerrors.Errorf("error saving prune epoch: %w", err)
-		}
-	default:
-		return xerrors.Errorf("error loading prune epoch: %w", err)
-	}
-
 	// load warmup epoch from metadata ds
 	bs, err = s.ds.Get(s.ctx, warmupEpochKey)
 	switch err {
 	case nil:
-		s.warmupEpoch.Store(bytesToInt64(bs))
+		s.warmupEpoch = bytesToEpoch(bs)
 
 	case dstore.ErrNotFound:
 		warmup = true
@@ -788,7 +664,7 @@ func (s *SplitStore) Start(chain ChainAccessor, us stmgr.UpgradeSchedule) error
 		return xerrors.Errorf("error loading compaction index: %w", err)
 	}
 
-	log.Infow("starting splitstore", "baseEpoch", s.baseEpoch, "warmupEpoch", s.warmupEpoch.Load())
+	log.Infow("starting splitstore", "baseEpoch", s.baseEpoch, "warmupEpoch", s.warmupEpoch)
 
 	if warmup {
 		err = s.warmup(curTs)
@@ -825,11 +701,6 @@ func (s *SplitStore) Close() error {
 		s.txnSyncCond.Broadcast()
 		s.txnSyncMx.Unlock()
 
-		s.chainSyncMx.Lock()
-		s.chainSyncFinished = true
-		s.chainSyncCond.Broadcast()
-		s.chainSyncMx.Unlock()
-
 		log.Warn("close with ongoing compaction in progress; waiting for it to finish...")
 		for atomic.LoadInt32(&s.compacting) == 1 {
 			time.Sleep(time.Second)
@@ -854,8 +725,3 @@ func (s *SplitStore) setBaseEpoch(epoch abi.ChainEpoch) error {
 	s.baseEpoch = epoch
 	return s.ds.Put(s.ctx, baseEpochKey, epochToBytes(epoch))
 }
-
-func (s *SplitStore) setPruneEpoch(epoch abi.ChainEpoch) error {
-	s.pruneEpoch = epoch
-	return s.ds.Put(s.ctx, pruneEpochKey, epochToBytes(epoch))
-}

blockstore/splitstore/splitstore_check.go

@@ -8,9 +8,10 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 
+	cid "github.com/ipfs/go-cid"
+
 	bstore "github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/chain/types"
 )
@@ -25,7 +26,6 @@ func (s *SplitStore) Check() error {
 	if !atomic.CompareAndSwapInt32(&s.compacting, 0, 1) {
 		return xerrors.Errorf("can't acquire compaction lock; compacting operation in progress")
 	}
-	s.compactType = check
 
 	if s.compactionIndex == 0 {
 		atomic.StoreInt32(&s.compacting, 0)
@@ -95,7 +95,7 @@ func (s *SplitStore) doCheck(curTs *types.TipSet) error {
 	}
 	defer visitor.Close() //nolint
 
-	size := s.walkChain(curTs, boundaryEpoch, boundaryEpoch, visitor,
+	err = s.walkChain(curTs, boundaryEpoch, boundaryEpoch, visitor,
 		func(c cid.Cid) error {
 			if isUnitaryObject(c) {
 				return errStopWalk
@@ -125,7 +125,7 @@ func (s *SplitStore) doCheck(curTs *types.TipSet) error {
 			}
 
 			return nil
-		}, func(cid.Cid) error { return nil })
+		})
 
 	if err != nil {
 		err = xerrors.Errorf("error walking chain: %w", err)
@@ -133,7 +133,7 @@ func (s *SplitStore) doCheck(curTs *types.TipSet) error {
 		return err
 	}
 
-	log.Infow("check done", "cold", *coldCnt, "missing", *missingCnt, "walk size", size)
+	log.Infow("check done", "cold", *coldCnt, "missing", *missingCnt)
 	write("--")
 	write("cold: %d missing: %d", *coldCnt, *missingCnt)
 	write("DONE")
@@ -145,10 +145,8 @@ func (s *SplitStore) doCheck(curTs *types.TipSet) error {
 func (s *SplitStore) Info() map[string]interface{} {
 	info := make(map[string]interface{})
 	info["base epoch"] = s.baseEpoch
-	info["warmup epoch"] = s.warmupEpoch.Load()
+	info["warmup epoch"] = s.warmupEpoch
 	info["compactions"] = s.compactionIndex
-	info["prunes"] = s.pruneIndex
-	info["compacting"] = s.compacting == 1
 
 	sizer, ok := s.hot.(bstore.BlockstoreSize)
 	if ok {

blockstore/splitstore/splitstore_compact.go

@@ -10,19 +10,20 @@ import (
 	"sync/atomic"
 	"time"
 
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"go.opencensus.io/stats"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	blocks "github.com/ipfs/go-block-format"
+	cid "github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
 
+	"github.com/filecoin-project/go-state-types/abi"
+	bstore "github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/metrics"
+
+	"go.opencensus.io/stats"
 )
 
 var (
@@ -52,12 +53,6 @@ var (
 	// SyncWaitTime is the time delay from a tipset's min timestamp before we decide
 	// we have synced.
 	SyncWaitTime = 30 * time.Second
-
-	// This is a testing flag that should always be true when running a node. itests rely on the rough hack
-	// of starting genesis so far in the past that they exercise catchup mining to mine
-	// blocks quickly and so disabling syncgap checking is necessary to test compaction
-	// without a deep structural improvement of itests.
-	CheckSyncGap = true
 )
 
 var (
@@ -66,9 +61,7 @@ var (
 )
 
 const (
-	batchSize              = 16384
-	cidKeySize             = 128
-	purgeWorkSliceDuration = time.Second
+	batchSize = 16384
 )
 
 func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
@@ -89,38 +82,10 @@ func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
 	//       this is guaranteed by the chainstore, and it is pervasive in all lotus
 	//       -- if that ever changes then all hell will break loose in general and
 	//       we will have a rance to protectTipSets here.
-	//      Regardless, we put a mutex in HeadChange just to be safe
+	//      Reagrdless, we put a mutex in HeadChange just to be safe
 
 	if !atomic.CompareAndSwapInt32(&s.compacting, 0, 1) {
-		// we are currently compacting
-		// 1. Signal sync condition to yield compaction when out of sync and resume when in sync
-		timestamp := time.Unix(int64(curTs.MinTimestamp()), 0)
-		if CheckSyncGap && time.Since(timestamp) > SyncGapTime {
-			/* Chain out of sync */
-			if atomic.CompareAndSwapInt32(&s.outOfSync, 0, 1) {
-				// transition from in sync to out of sync
-				s.chainSyncMx.Lock()
-				s.chainSyncFinished = false
-				s.chainSyncMx.Unlock()
-			}
-			// already out of sync, no signaling necessary
-
-		}
-		// TODO: ok to use hysteresis with no transitions between 30s and 1m?
-		if time.Since(timestamp) < SyncWaitTime {
-			/* Chain in sync */
-			if atomic.CompareAndSwapInt32(&s.outOfSync, 0, 0) {
-				// already in sync, no signaling necessary
-			} else {
-				// transition from out of sync to in sync
-				s.chainSyncMx.Lock()
-				s.chainSyncFinished = true
-				s.chainSyncCond.Broadcast()
-				s.chainSyncMx.Unlock()
-			}
-
-		}
-		// 2. protect the new tipset(s)
+		// we are currently compacting -- protect the new tipset(s)
 		s.protectTipSets(apply)
 		return nil
 	}
@@ -132,8 +97,7 @@ func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
 	}
 
 	timestamp := time.Unix(int64(curTs.MinTimestamp()), 0)
-
-	if CheckSyncGap && time.Since(timestamp) > SyncGapTime {
+	if time.Since(timestamp) > SyncGapTime {
 		// don't attempt compaction before we have caught up syncing
 		atomic.StoreInt32(&s.compacting, 0)
 		return nil
@@ -148,7 +112,6 @@ func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
 	if epoch-s.baseEpoch > CompactionThreshold {
 		// it's time to compact -- prepare the transaction and go!
 		s.beginTxnProtect()
-		s.compactType = hot
 		go func() {
 			defer atomic.StoreInt32(&s.compacting, 0)
 			defer s.endTxnProtect()
@@ -160,7 +123,6 @@ func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
 
 			log.Infow("compaction done", "took", time.Since(start))
 		}()
-		// only prune if auto prune is enabled and after at least one compaction
 	} else {
 		// no compaction necessary
 		atomic.StoreInt32(&s.compacting, 0)
@@ -204,8 +166,6 @@ func (s *SplitStore) protectTipSets(apply []*types.TipSet) {
 		timestamp := time.Unix(int64(curTs.MinTimestamp()), 0)
 		doSync := time.Since(timestamp) < SyncWaitTime
 		go func() {
-			// we are holding the txnLk while marking
-			// so critical section cannot delete
 			if doSync {
 				defer func() {
 					s.txnSyncMx.Lock()
@@ -229,11 +189,9 @@ func (s *SplitStore) markLiveRefs(cids []cid.Cid) {
 	log.Debugf("marking %d live refs", len(cids))
 	startMark := time.Now()
 
-	szMarked := new(int64)
-
 	count := new(int32)
 	visitor := newConcurrentVisitor()
-	walkObject := func(c cid.Cid) (int64, error) {
+	walkObject := func(c cid.Cid) error {
 		return s.walkObjectIncomplete(c, visitor,
 			func(c cid.Cid) error {
 				if isUnitaryObject(c) {
@@ -260,12 +218,10 @@ func (s *SplitStore) markLiveRefs(cids []cid.Cid) {
 
 	// optimize the common case of single put
 	if len(cids) == 1 {
-		sz, err := walkObject(cids[0])
-		if err != nil {
+		if err := walkObject(cids[0]); err != nil {
 			log.Errorf("error marking tipset refs: %s", err)
 		}
 		log.Debugw("marking live refs done", "took", time.Since(startMark), "marked", *count)
-		atomic.AddInt64(szMarked, sz)
 		return
 	}
 
@@ -277,11 +233,9 @@ func (s *SplitStore) markLiveRefs(cids []cid.Cid) {
 
 	worker := func() error {
 		for c := range workch {
-			sz, err := walkObject(c)
-			if err != nil {
+			if err := walkObject(c); err != nil {
 				return err
 			}
-			atomic.AddInt64(szMarked, sz)
 		}
 
 		return nil
@@ -304,8 +258,7 @@ func (s *SplitStore) markLiveRefs(cids []cid.Cid) {
 		log.Errorf("error marking tipset refs: %s", err)
 	}
 
-	log.Debugw("marking live refs done", "took", time.Since(startMark), "marked", *count, "size marked", *szMarked)
-	s.szMarkedLiveRefs += atomic.LoadInt64(szMarked)
+	log.Debugw("marking live refs done", "took", time.Since(startMark), "marked", *count)
 }
 
 // transactionally protect a view
@@ -398,7 +351,6 @@ func (s *SplitStore) protectTxnRefs(markSet MarkSet) error {
 
 		log.Infow("protecting transactional references", "refs", len(txnRefs))
 		count := 0
-		sz := new(int64)
 		workch := make(chan cid.Cid, len(txnRefs))
 		startProtect := time.Now()
 
@@ -431,11 +383,10 @@ func (s *SplitStore) protectTxnRefs(markSet MarkSet) error {
 
 		worker := func() error {
 			for c := range workch {
-				szTxn, err := s.doTxnProtect(c, markSet)
+				err := s.doTxnProtect(c, markSet)
 				if err != nil {
 					return xerrors.Errorf("error protecting transactional references to %s: %w", c, err)
 				}
-				atomic.AddInt64(sz, szTxn)
 			}
 			return nil
 		}
@@ -448,16 +399,16 @@ func (s *SplitStore) protectTxnRefs(markSet MarkSet) error {
 		if err := g.Wait(); err != nil {
 			return err
 		}
-		s.szProtectedTxns += atomic.LoadInt64(sz)
-		log.Infow("protecting transactional refs done", "took", time.Since(startProtect), "protected", count, "protected size", sz)
+
+		log.Infow("protecting transactional refs done", "took", time.Since(startProtect), "protected", count)
 	}
 }
 
 // transactionally protect a reference by walking the object and marking.
 // concurrent markings are short circuited by checking the markset.
-func (s *SplitStore) doTxnProtect(root cid.Cid, markSet MarkSet) (int64, error) {
+func (s *SplitStore) doTxnProtect(root cid.Cid, markSet MarkSet) error {
 	if err := s.checkClosing(); err != nil {
-		return 0, err
+		return err
 	}
 
 	// Note: cold objects are deleted heaviest first, so the consituents of an object
@@ -481,7 +432,7 @@ func (s *SplitStore) doTxnProtect(root cid.Cid, markSet MarkSet) (int64, error)
 		},
 		func(c cid.Cid) error {
 			if s.txnMissing != nil {
-				log.Debugf("missing object reference %s in %s", c, root)
+				log.Warnf("missing object reference %s in %s", c, root)
 				s.txnRefsMx.Lock()
 				s.txnMissing[c] = struct{}{}
 				s.txnRefsMx.Unlock()
@@ -524,7 +475,6 @@ func (s *SplitStore) applyProtectors() error {
 // - At this point we are ready to begin purging:
 //   - We sort cold objects heaviest first, so as to never delete the consituents of a DAG before the DAG itself (which would leave dangling references)
 //   - We delete in small batches taking a lock; each batch is checked again for marks, from the concurrent transactional mark, so as to never delete anything live
-//
 // - We then end the transaction and compact/gc the hotstore.
 func (s *SplitStore) compact(curTs *types.TipSet) {
 	log.Info("waiting for active views to complete")
@@ -548,7 +498,6 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 		// might be potentially inconsistent; abort compaction and notify the user to intervene.
 		return xerrors.Errorf("checkpoint exists; aborting compaction")
 	}
-	s.clearSizeMeasurements()
 
 	currentEpoch := curTs.Height()
 	boundaryEpoch := currentEpoch - CompactionBoundary
@@ -568,13 +517,7 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	defer markSet.Close() //nolint:errcheck
 	defer s.debug.Flush()
 
-	coldSet, err := s.markSetEnv.New("cold", s.markSetSize)
-	if err != nil {
-		return xerrors.Errorf("error creating cold mark set: %w", err)
-	}
-	defer coldSet.Close() //nolint:errcheck
-
-	if err := s.checkYield(); err != nil {
+	if err := s.checkClosing(); err != nil {
 		return err
 	}
 
@@ -592,52 +535,25 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	startMark := time.Now()
 
 	count := new(int64)
+	err = s.walkChain(curTs, boundaryEpoch, inclMsgsEpoch, &noopVisitor{},
+		func(c cid.Cid) error {
+			if isUnitaryObject(c) {
+				return errStopWalk
+			}
 
-	coldCount := new(int64)
-	fCold := func(c cid.Cid) error {
-		// Writes to cold set optimized away in universal and discard mode
-		//
-		// Nothing gets written to cold store in discard mode so no cold objects to write
-		// Everything not marked hot gets written to cold store in universal mode so no need to track cold objects separately
-		if s.cfg.DiscardColdBlocks || s.cfg.UniversalColdBlocks {
+			visit, err := markSet.Visit(c)
+			if err != nil {
+				return xerrors.Errorf("error visiting object: %w", err)
+			}
+
+			if !visit {
+				return errStopWalk
+			}
+
+			atomic.AddInt64(count, 1)
 			return nil
-		}
+		})
 
-		if isUnitaryObject(c) {
-			return errStopWalk
-		}
-
-		visit, err := coldSet.Visit(c)
-		if err != nil {
-			return xerrors.Errorf("error visiting object: %w", err)
-		}
-
-		if !visit {
-			return errStopWalk
-		}
-
-		atomic.AddInt64(coldCount, 1)
-		return nil
-	}
-	fHot := func(c cid.Cid) error {
-		if isUnitaryObject(c) {
-			return errStopWalk
-		}
-
-		visit, err := markSet.Visit(c)
-		if err != nil {
-			return xerrors.Errorf("error visiting object: %w", err)
-		}
-
-		if !visit {
-			return errStopWalk
-		}
-
-		atomic.AddInt64(count, 1)
-		return nil
-	}
-
-	err = s.walkChain(curTs, boundaryEpoch, inclMsgsEpoch, &noopVisitor{}, fHot, fCold)
 	if err != nil {
 		return xerrors.Errorf("error marking: %w", err)
 	}
@@ -646,7 +562,7 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 
 	log.Infow("marking done", "took", time.Since(startMark), "marked", *count)
 
-	if err := s.checkYield(); err != nil {
+	if err := s.checkClosing(); err != nil {
 		return err
 	}
 
@@ -656,7 +572,7 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 		return xerrors.Errorf("error protecting transactional refs: %w", err)
 	}
 
-	if err := s.checkYield(); err != nil {
+	if err := s.checkClosing(); err != nil {
 		return err
 	}
 
@@ -670,14 +586,9 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	}
 	defer coldw.Close() //nolint:errcheck
 
-	purgew, err := NewColdSetWriter(s.discardSetPath())
-	if err != nil {
-		return xerrors.Errorf("error creating deadset: %w", err)
-	}
-	defer purgew.Close() //nolint:errcheck
-
 	// some stats for logging
-	var hotCnt, coldCnt, purgeCnt int64
+	var hotCnt, coldCnt int
+
 	err = s.hot.ForEachKey(func(c cid.Cid) error {
 		// was it marked?
 		mark, err := markSet.Has(c)
@@ -690,50 +601,30 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 			return nil
 		}
 
-		// it needs to be removed from hot store, mark it as candidate for purge
-		if err := purgew.Write(c); err != nil {
-			return xerrors.Errorf("error writing cid to purge set: %w", err)
-		}
-		purgeCnt++
-
-		coldMark, err := coldSet.Has(c)
-		if err != nil {
-			return xerrors.Errorf("error checking cold mark set for %s: %w", c, err)
-		}
-
-		// Discard mode: coldMark == false, s.cfg.UniversalColdBlocks == false, always return here, no writes to cold store
-		// Universal mode: coldMark == false, s.cfg.UniversalColdBlocks == true, never stop here, all writes to cold store
-		// Otherwise: s.cfg.UniversalColdBlocks == false, if !coldMark stop here and don't write to cold store, if coldMark continue and write to cold store
-		if !coldMark && !s.cfg.UniversalColdBlocks { // universal mode means mark everything as cold
-			return nil
-		}
-
-		// it's cold, mark as candidate for move
+		// it's cold, mark it as candidate for move
 		if err := coldw.Write(c); err != nil {
-			return xerrors.Errorf("error writing cid to cold set")
+			return xerrors.Errorf("error writing cid to coldstore: %w", err)
 		}
 		coldCnt++
 
 		return nil
 	})
+
 	if err != nil {
 		return xerrors.Errorf("error collecting cold objects: %w", err)
 	}
-	if err := purgew.Close(); err != nil {
-		return xerrors.Errorf("erroring closing purgeset: %w", err)
-	}
+
 	if err := coldw.Close(); err != nil {
 		return xerrors.Errorf("error closing coldset: %w", err)
 	}
 
 	log.Infow("cold collection done", "took", time.Since(startCollect))
 
-	log.Infow("compaction stats", "hot", hotCnt, "cold", coldCnt, "purge", purgeCnt)
-	s.szKeys = hotCnt * cidKeySize
-	stats.Record(s.ctx, metrics.SplitstoreCompactionHot.M(hotCnt))
-	stats.Record(s.ctx, metrics.SplitstoreCompactionCold.M(coldCnt))
+	log.Infow("compaction stats", "hot", hotCnt, "cold", coldCnt)
+	stats.Record(s.ctx, metrics.SplitstoreCompactionHot.M(int64(hotCnt)))
+	stats.Record(s.ctx, metrics.SplitstoreCompactionCold.M(int64(coldCnt)))
 
-	if err := s.checkYield(); err != nil {
+	if err := s.checkClosing(); err != nil {
 		return err
 	}
 
@@ -742,7 +633,7 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	// possibly delete objects we didn't have when we were collecting cold objects)
 	s.waitForMissingRefs(markSet)
 
-	if err := s.checkYield(); err != nil {
+	if err := s.checkClosing(); err != nil {
 		return err
 	}
 
@@ -762,7 +653,7 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 		}
 		log.Infow("moving done", "took", time.Since(startMove))
 
-		if err := s.checkYield(); err != nil {
+		if err := s.checkClosing(); err != nil {
 			return err
 		}
 
@@ -771,12 +662,6 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 		}
 	}
 
-	purger, err := NewColdSetReader(s.discardSetPath())
-	if err != nil {
-		return xerrors.Errorf("error opening coldset: %w", err)
-	}
-	defer purger.Close() //nolint:errcheck
-
 	// 4. Purge cold objects with checkpointing for recovery.
 	// This is the critical section of compaction, whereby any cold object not in the markSet is
 	// considered already deleted.
@@ -793,7 +678,7 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	}
 
 	// wait for the head to catch up so that the current tipset is marked
-	s.waitForTxnSync()
+	s.waitForSync()
 
 	if err := s.checkClosing(); err != nil {
 		return err
@@ -808,13 +693,13 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	// 5. purge cold objects from the hotstore, taking protected references into account
 	log.Info("purging cold objects from the hotstore")
 	startPurge := time.Now()
-	err = s.purge(purger, checkpoint, markSet)
+	err = s.purge(coldr, checkpoint, markSet)
 	if err != nil {
 		return xerrors.Errorf("error purging cold objects: %w", err)
 	}
 	log.Infow("purging cold objects from hotstore done", "took", time.Since(startPurge))
+
 	s.endCriticalSection()
-	log.Infow("critical section done", "total protected size", s.szProtectedTxns, "total marked live size", s.szMarkedLiveRefs)
 
 	if err := checkpoint.Close(); err != nil {
 		log.Warnf("error closing checkpoint: %s", err)
@@ -828,13 +713,10 @@ func (s *SplitStore) doCompact(curTs *types.TipSet) error {
 	if err := os.Remove(s.coldSetPath()); err != nil {
 		log.Warnf("error removing coldset: %s", err)
 	}
-	if err := os.Remove(s.discardSetPath()); err != nil {
-		log.Warnf("error removing discardset: %s", err)
-	}
 
 	// we are done; do some housekeeping
 	s.endTxnProtect()
-	s.gcHotAfterCompaction()
+	s.gcHotstore()
 
 	err = s.setBaseEpoch(boundaryEpoch)
 	if err != nil {
@@ -894,12 +776,8 @@ func (s *SplitStore) beginCriticalSection(markSet MarkSet) error {
 	return nil
 }
 
-func (s *SplitStore) waitForTxnSync() {
+func (s *SplitStore) waitForSync() {
 	log.Info("waiting for sync")
-	if !CheckSyncGap {
-		log.Warnf("If you see this outside of test it is a serious splitstore issue")
-		return
-	}
 	startWait := time.Now()
 	defer func() {
 		log.Infow("waiting for sync done", "took", time.Since(startWait))
@@ -913,25 +791,6 @@ func (s *SplitStore) waitForTxnSync() {
 	}
 }
 
-// Block compaction operations if chain sync has fallen behind
-func (s *SplitStore) waitForSync() {
-	if atomic.LoadInt32(&s.outOfSync) == 0 {
-		return
-	}
-	s.chainSyncMx.Lock()
-	defer s.chainSyncMx.Unlock()
-
-	for !s.chainSyncFinished {
-		s.chainSyncCond.Wait()
-	}
-}
-
-// Combined sync and closing check
-func (s *SplitStore) checkYield() error {
-	s.waitForSync()
-	return s.checkClosing()
-}
-
 func (s *SplitStore) endTxnProtect() {
 	s.txnLk.Lock()
 	defer s.txnLk.Unlock()
@@ -958,7 +817,7 @@ func (s *SplitStore) endCriticalSection() {
 }
 
 func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEpoch,
-	visitor ObjectVisitor, fHot, fCold func(cid.Cid) error) error {
+	visitor ObjectVisitor, f func(cid.Cid) error) error {
 	var walked ObjectVisitor
 	var mx sync.Mutex
 	// we copy the tipset first into a new slice, which allows us to reuse it in every epoch.
@@ -966,11 +825,6 @@ func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEp
 	copy(toWalk, ts.Cids())
 	walkCnt := new(int64)
 	scanCnt := new(int64)
-	szWalk := new(int64)
-
-	tsRef := func(blkCids []cid.Cid) (cid.Cid, error) {
-		return types.NewTipSetKey(blkCids...).Cid()
-	}
 
 	stopWalk := func(_ cid.Cid) error { return errStopWalk }
 
@@ -985,7 +839,7 @@ func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEp
 
 		atomic.AddInt64(walkCnt, 1)
 
-		if err := fHot(c); err != nil {
+		if err := f(c); err != nil {
 			return err
 		}
 
@@ -993,73 +847,39 @@ func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEp
 		err = s.view(c, func(data []byte) error {
 			return hdr.UnmarshalCBOR(bytes.NewBuffer(data))
 		})
+
 		if err != nil {
 			return xerrors.Errorf("error unmarshaling block header (cid: %s): %w", c, err)
 		}
 
-		// tipset CID references are retained
-		pRef, err := tsRef(hdr.Parents)
-		if err != nil {
-			return xerrors.Errorf("error computing cid reference to parent tipset")
-		}
-		sz, err := s.walkObjectIncomplete(pRef, visitor, fHot, stopWalk)
-		if err != nil {
-			return xerrors.Errorf("error walking parent tipset cid reference")
-		}
-		atomic.AddInt64(szWalk, sz)
-
 		// message are retained if within the inclMsgs boundary
 		if hdr.Height >= inclMsgs && hdr.Height > 0 {
 			if inclMsgs < inclState {
 				// we need to use walkObjectIncomplete here, as messages/receipts may be missing early on if we
 				// synced from snapshot and have a long HotStoreMessageRetentionPolicy.
-				sz, err := s.walkObjectIncomplete(hdr.Messages, visitor, fHot, stopWalk)
-				if err != nil {
+				if err := s.walkObjectIncomplete(hdr.Messages, visitor, f, stopWalk); err != nil {
 					return xerrors.Errorf("error walking messages (cid: %s): %w", hdr.Messages, err)
 				}
-				atomic.AddInt64(szWalk, sz)
 
-				sz, err = s.walkObjectIncomplete(hdr.ParentMessageReceipts, visitor, fHot, stopWalk)
-				if err != nil {
+				if err := s.walkObjectIncomplete(hdr.ParentMessageReceipts, visitor, f, stopWalk); err != nil {
 					return xerrors.Errorf("error walking messages receipts (cid: %s): %w", hdr.ParentMessageReceipts, err)
 				}
-				atomic.AddInt64(szWalk, sz)
 			} else {
-				sz, err = s.walkObject(hdr.Messages, visitor, fHot)
-				if err != nil {
+				if err := s.walkObject(hdr.Messages, visitor, f); err != nil {
 					return xerrors.Errorf("error walking messages (cid: %s): %w", hdr.Messages, err)
 				}
-				atomic.AddInt64(szWalk, sz)
 
-				sz, err := s.walkObjectIncomplete(hdr.ParentMessageReceipts, visitor, fHot, stopWalk)
-				if err != nil {
+				if err := s.walkObject(hdr.ParentMessageReceipts, visitor, f); err != nil {
 					return xerrors.Errorf("error walking message receipts (cid: %s): %w", hdr.ParentMessageReceipts, err)
 				}
-				atomic.AddInt64(szWalk, sz)
 			}
 		}
 
-		// messages and receipts outside of inclMsgs are included in the cold store
-		if hdr.Height < inclMsgs && hdr.Height > 0 {
-			sz, err := s.walkObjectIncomplete(hdr.Messages, visitor, fCold, stopWalk)
-			if err != nil {
-				return xerrors.Errorf("error walking messages (cid: %s): %w", hdr.Messages, err)
-			}
-			atomic.AddInt64(szWalk, sz)
-			sz, err = s.walkObjectIncomplete(hdr.ParentMessageReceipts, visitor, fCold, stopWalk)
-			if err != nil {
-				return xerrors.Errorf("error walking messages receipts (cid: %s): %w", hdr.ParentMessageReceipts, err)
-			}
-			atomic.AddInt64(szWalk, sz)
-		}
-
 		// state is only retained if within the inclState boundary, with the exception of genesis
 		if hdr.Height >= inclState || hdr.Height == 0 {
-			sz, err := s.walkObject(hdr.ParentStateRoot, visitor, fHot)
-			if err != nil {
+			if err := s.walkObject(hdr.ParentStateRoot, visitor, f); err != nil {
 				return xerrors.Errorf("error walking state root (cid: %s): %w", hdr.ParentStateRoot, err)
 			}
-			atomic.AddInt64(szWalk, sz)
 			atomic.AddInt64(scanCnt, 1)
 		}
 
@@ -1072,20 +892,9 @@ func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEp
 		return nil
 	}
 
-	// retain ref to chain head
-	hRef, err := tsRef(ts.Cids())
-	if err != nil {
-		return xerrors.Errorf("error computing cid reference to parent tipset")
-	}
-	sz, err := s.walkObjectIncomplete(hRef, visitor, fHot, stopWalk)
-	if err != nil {
-		return xerrors.Errorf("error walking parent tipset cid reference")
-	}
-	atomic.AddInt64(szWalk, sz)
-
 	for len(toWalk) > 0 {
 		// walking can take a while, so check this with every opportunity
-		if err := s.checkYield(); err != nil {
+		if err := s.checkClosing(); err != nil {
 			return err
 		}
 
@@ -1115,143 +924,133 @@ func (s *SplitStore) walkChain(ts *types.TipSet, inclState, inclMsgs abi.ChainEp
 					if err := walkBlock(c); err != nil {
 						return xerrors.Errorf("error walking block (cid: %s): %w", c, err)
 					}
-
-					if err := s.checkYield(); err != nil {
-						return xerrors.Errorf("check yield: %w", err)
-					}
 				}
 				return nil
 			})
 		}
 
 		if err := g.Wait(); err != nil {
-			return xerrors.Errorf("walkBlock workers errored: %w", err)
+			return err
 		}
 	}
 
-	log.Infow("chain walk done", "walked", *walkCnt, "scanned", *scanCnt, "walk size", szWalk)
-	s.szWalk = atomic.LoadInt64(szWalk)
+	log.Infow("chain walk done", "walked", *walkCnt, "scanned", *scanCnt)
+
 	return nil
 }
 
-func (s *SplitStore) walkObject(c cid.Cid, visitor ObjectVisitor, f func(cid.Cid) error) (int64, error) {
-	var sz int64
+func (s *SplitStore) walkObject(c cid.Cid, visitor ObjectVisitor, f func(cid.Cid) error) error {
 	visit, err := visitor.Visit(c)
 	if err != nil {
-		return 0, xerrors.Errorf("error visiting object: %w", err)
+		return xerrors.Errorf("error visiting object: %w", err)
 	}
 
 	if !visit {
-		return sz, nil
+		return nil
 	}
 
 	if err := f(c); err != nil {
 		if err == errStopWalk {
-			return sz, nil
+			return nil
 		}
 
-		return 0, err
+		return err
 	}
 
 	if c.Prefix().Codec != cid.DagCBOR {
-		return sz, nil
+		return nil
 	}
 
 	// check this before recursing
 	if err := s.checkClosing(); err != nil {
-		return 0, xerrors.Errorf("check closing: %w", err)
+		return err
 	}
 
 	var links []cid.Cid
 	err = s.view(c, func(data []byte) error {
-		sz += int64(len(data))
 		return cbg.ScanForLinks(bytes.NewReader(data), func(c cid.Cid) {
 			links = append(links, c)
 		})
 	})
 
 	if err != nil {
-		return 0, xerrors.Errorf("error scanning linked block (cid: %s): %w", c, err)
+		return xerrors.Errorf("error scanning linked block (cid: %s): %w", c, err)
 	}
 
 	for _, c := range links {
-		szLink, err := s.walkObject(c, visitor, f)
+		err := s.walkObject(c, visitor, f)
 		if err != nil {
-			return 0, xerrors.Errorf("error walking link (cid: %s): %w", c, err)
+			return xerrors.Errorf("error walking link (cid: %s): %w", c, err)
 		}
-		sz += szLink
 	}
 
-	return sz, nil
+	return nil
 }
 
 // like walkObject, but the object may be potentially incomplete (references missing)
-func (s *SplitStore) walkObjectIncomplete(c cid.Cid, visitor ObjectVisitor, f, missing func(cid.Cid) error) (int64, error) {
-	var sz int64
+func (s *SplitStore) walkObjectIncomplete(c cid.Cid, visitor ObjectVisitor, f, missing func(cid.Cid) error) error {
 	visit, err := visitor.Visit(c)
 	if err != nil {
-		return 0, xerrors.Errorf("error visiting object: %w", err)
+		return xerrors.Errorf("error visiting object: %w", err)
 	}
 
 	if !visit {
-		return sz, nil
+		return nil
 	}
 
 	// occurs check -- only for DAGs
 	if c.Prefix().Codec == cid.DagCBOR {
 		has, err := s.has(c)
 		if err != nil {
-			return 0, xerrors.Errorf("error occur checking %s: %w", c, err)
+			return xerrors.Errorf("error occur checking %s: %w", c, err)
 		}
 
 		if !has {
 			err = missing(c)
 			if err == errStopWalk {
-				return sz, nil
+				return nil
 			}
 
-			return 0, err
+			return err
 		}
 	}
 
 	if err := f(c); err != nil {
 		if err == errStopWalk {
-			return sz, nil
+			return nil
 		}
 
-		return 0, err
+		return err
 	}
 
 	if c.Prefix().Codec != cid.DagCBOR {
-		return sz, nil
+		return nil
 	}
 
 	// check this before recursing
 	if err := s.checkClosing(); err != nil {
-		return sz, xerrors.Errorf("check closing: %w", err)
+		return err
 	}
 
 	var links []cid.Cid
 	err = s.view(c, func(data []byte) error {
-		sz += int64(len(data))
 		return cbg.ScanForLinks(bytes.NewReader(data), func(c cid.Cid) {
 			links = append(links, c)
 		})
 	})
 
 	if err != nil {
-		return 0, xerrors.Errorf("error scanning linked block (cid: %s): %w", c, err)
+		return xerrors.Errorf("error scanning linked block (cid: %s): %w", c, err)
 	}
 
 	for _, c := range links {
-		szLink, err := s.walkObjectIncomplete(c, visitor, f, missing)
+		err := s.walkObjectIncomplete(c, visitor, f, missing)
 		if err != nil {
-			return 0, xerrors.Errorf("error walking link (cid: %s): %w", c, err)
+			return xerrors.Errorf("error walking link (cid: %s): %w", c, err)
 		}
-		sz += szLink
 	}
 
-	return sz, nil
+	return nil
 }
 
 // internal version used during compaction and related operations
@@ -1266,10 +1065,13 @@ func (s *SplitStore) view(c cid.Cid, cb func([]byte) error) error {
 	}
 
 	err := s.hot.View(s.ctx, c, cb)
-	if ipld.IsNotFound(err) {
+	switch err {
+	case bstore.ErrNotFound:
 		return s.cold.View(s.ctx, c, cb)
+
+	default:
+		return err
 	}
-	return err
 }
 
 func (s *SplitStore) has(c cid.Cid) (bool, error) {
@@ -1288,10 +1090,10 @@ func (s *SplitStore) has(c cid.Cid) (bool, error) {
 
 func (s *SplitStore) get(c cid.Cid) (blocks.Block, error) {
 	blk, err := s.hot.Get(s.ctx, c)
-	switch {
-	case err == nil:
+	switch err {
+	case nil:
 		return blk, nil
-	case ipld.IsNotFound(err):
+	case bstore.ErrNotFound:
 		return s.cold.Get(s.ctx, c)
 	default:
 		return nil, err
@@ -1300,10 +1102,10 @@ func (s *SplitStore) get(c cid.Cid) (blocks.Block, error) {
 
 func (s *SplitStore) getSize(c cid.Cid) (int, error) {
 	sz, err := s.hot.GetSize(s.ctx, c)
-	switch {
-	case err == nil:
+	switch err {
+	case nil:
 		return sz, nil
-	case ipld.IsNotFound(err):
+	case bstore.ErrNotFound:
 		return s.cold.GetSize(s.ctx, c)
 	default:
 		return 0, err
@@ -1314,12 +1116,13 @@ func (s *SplitStore) moveColdBlocks(coldr *ColdSetReader) error {
 	batch := make([]blocks.Block, 0, batchSize)
 
 	err := coldr.ForEach(func(c cid.Cid) error {
-		if err := s.checkYield(); err != nil {
+		if err := s.checkClosing(); err != nil {
 			return err
 		}
+
 		blk, err := s.hot.Get(s.ctx, c)
 		if err != nil {
-			if ipld.IsNotFound(err) {
+			if err == bstore.ErrNotFound {
 				log.Warnf("hotstore missing block %s", c)
 				return nil
 			}
@@ -1334,7 +1137,6 @@ func (s *SplitStore) moveColdBlocks(coldr *ColdSetReader) error {
 				return xerrors.Errorf("error putting batch to coldstore: %w", err)
 			}
 			batch = batch[:0]
-
 		}
 
 		return nil
@@ -1373,21 +1175,9 @@ func (s *SplitStore) purge(coldr *ColdSetReader, checkpoint *Checkpoint, markSet
 		return err
 	}
 
-	now := time.Now()
-
 	err := coldr.ForEach(func(c cid.Cid) error {
 		batch = append(batch, c)
 		if len(batch) == batchSize {
-			// add some time slicing to the purge as this a very disk I/O heavy operation that
-			// requires write access to txnLk that may starve other operations that require
-			// access to the blockstore.
-			elapsed := time.Since(now)
-			if elapsed > purgeWorkSliceDuration {
-				// work 1 slice, sleep 4 slices, or 20% utilization
-				time.Sleep(4 * elapsed)
-				now = time.Now()
-			}
-
 			return deleteBatch()
 		}
 
@@ -1435,17 +1225,8 @@ func (s *SplitStore) purgeBatch(batch, deadCids []cid.Cid, checkpoint *Checkpoin
 		return 0, liveCnt, nil
 	}
 
-	switch s.compactType {
-	case hot:
-		if err := s.hot.DeleteMany(s.ctx, deadCids); err != nil {
-			return 0, liveCnt, xerrors.Errorf("error purging cold objects: %w", err)
-		}
-	case cold:
-		if err := s.cold.DeleteMany(s.ctx, deadCids); err != nil {
-			return 0, liveCnt, xerrors.Errorf("error purging dead objects: %w", err)
-		}
-	default:
-		return 0, liveCnt, xerrors.Errorf("invalid compaction type %d, only hot and cold allowed for critical section", s.compactType)
+	if err := s.hot.DeleteMany(s.ctx, deadCids); err != nil {
+		return 0, liveCnt, xerrors.Errorf("error purging cold objects: %w", err)
 	}
 
 	s.debug.LogDelete(deadCids)
@@ -1462,28 +1243,15 @@ func (s *SplitStore) coldSetPath() string {
 	return filepath.Join(s.path, "coldset")
 }
 
-func (s *SplitStore) discardSetPath() string {
-	return filepath.Join(s.path, "deadset")
-}
-
 func (s *SplitStore) checkpointPath() string {
 	return filepath.Join(s.path, "checkpoint")
 }
 
-func (s *SplitStore) pruneCheckpointPath() string {
-	return filepath.Join(s.path, "prune-checkpoint")
-}
-
 func (s *SplitStore) checkpointExists() bool {
 	_, err := os.Stat(s.checkpointPath())
 	return err == nil
 }
 
-func (s *SplitStore) pruneCheckpointExists() bool {
-	_, err := os.Stat(s.pruneCheckpointPath())
-	return err == nil
-}
-
 func (s *SplitStore) completeCompaction() error {
 	checkpoint, last, err := OpenCheckpoint(s.checkpointPath())
 	if err != nil {
@@ -1504,7 +1272,6 @@ func (s *SplitStore) completeCompaction() error {
 	defer markSet.Close() //nolint:errcheck
 
 	// PURGE
-	s.compactType = hot
 	log.Info("purging cold objects from the hotstore")
 	startPurge := time.Now()
 	err = s.completePurge(coldr, checkpoint, last, markSet)
@@ -1527,11 +1294,9 @@ func (s *SplitStore) completeCompaction() error {
 	if err := os.Remove(s.coldSetPath()); err != nil {
 		log.Warnf("error removing coldset: %s", err)
 	}
-	s.compactType = none
 
-	// Note: at this point we can start the splitstore; base epoch is not
-	//       incremented here so a compaction should run on the first head
-	//       change, which will trigger gc on the hotstore.
+	// Note: at this point we can start the splitstore; a compaction should run on
+	//       the first head change, which will trigger gc on the hotstore.
 	//       We don't mind the second (back-to-back) compaction as the head will
 	//       have advanced during marking and coldset accumulation.
 	return nil
@@ -1589,13 +1354,6 @@ func (s *SplitStore) completePurge(coldr *ColdSetReader, checkpoint *Checkpoint,
 	return nil
 }
 
-func (s *SplitStore) clearSizeMeasurements() {
-	s.szKeys = 0
-	s.szMarkedLiveRefs = 0
-	s.szProtectedTxns = 0
-	s.szWalk = 0
-}
-
 // I really don't like having this code, but we seem to have some occasional DAG references with
 // missing constituents. During testing in mainnet *some* of these references *sometimes* appeared
 // after a little bit.
@@ -1636,7 +1394,7 @@ func (s *SplitStore) waitForMissingRefs(markSet MarkSet) {
 		missing = make(map[cid.Cid]struct{})
 
 		for c := range towalk {
-			_, err := s.walkObjectIncomplete(c, visitor,
+			err := s.walkObjectIncomplete(c, visitor,
 				func(c cid.Cid) error {
 					if isUnitaryObject(c) {
 						return errStopWalk