Merge pull request #6831 from filecoin-project/feat/v1.11.0

Feat/v1.11.0

.circleci/config.yml

@@ -7,7 +7,7 @@ orbs:
 executors:
   golang:
     docker:
-      - image: circleci/golang:1.15.5
+      - image: circleci/golang:1.16.4
     resource_class: 2xlarge
   ubuntu:
     docker:
@@ -112,7 +112,7 @@ jobs:
       - run:
           command: make debug
 
-  test: &test
+  test:
     description: |
       Run tests with gotestsum.
     parameters: &test-params
@@ -123,23 +123,20 @@ jobs:
         type: string
         default: "-timeout 30m"
         description: Flags passed to go test.
-      packages:
+      target:
         type: string
         default: "./..."
         description: Import paths of packages to be tested.
-      winpost-test:
+      proofs-log-test:
         type: string
         default: "0"
-      deadline-test:
-        type: string
-        default: "0"
-      test-suite-name:
+      suite:
         type: string
         default: unit
         description: Test suite name to report to CircleCI.
       gotestsum-format:
         type: string
-        default: pkgname-and-test-fails
+        default: standard-verbose
         description: gotestsum format. https://github.com/gotestyourself/gotestsum#format
       coverage:
         type: string
@@ -147,7 +144,7 @@ jobs:
         description: Coverage flag. Set to the empty string to disable.
       codecov-upload:
         type: boolean
-        default: false
+        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.
@@ -165,25 +162,24 @@ jobs:
       - run:
           name: go test
           environment:
-            LOTUS_TEST_WINDOW_POST: << parameters.winpost-test >>
-            LOTUS_TEST_DEADLINE_TOGGLING: << parameters.deadline-test >>
+            TEST_RUSTPROOFS_LOGS: << parameters.proofs-log-test >>
             SKIP_CONFORMANCE: "1"
           command: |
-            mkdir -p /tmp/test-reports/<< parameters.test-suite-name >>
+            mkdir -p /tmp/test-reports/<< parameters.suite >>
             mkdir -p /tmp/test-artifacts
             gotestsum \
               --format << parameters.gotestsum-format >> \
-              --junitfile /tmp/test-reports/<< parameters.test-suite-name >>/junit.xml \
-              --jsonfile /tmp/test-artifacts/<< parameters.test-suite-name >>.json \
+              --junitfile /tmp/test-reports/<< parameters.suite >>/junit.xml \
+              --jsonfile /tmp/test-artifacts/<< parameters.suite >>.json \
               -- \
               << parameters.coverage >> \
               << parameters.go-test-flags >> \
-              << parameters.packages >>
+              << parameters.target >>
           no_output_timeout: 30m
       - store_test_results:
           path: /tmp/test-reports
       - store_artifacts:
-          path: /tmp/test-artifacts/<< parameters.test-suite-name >>.json
+          path: /tmp/test-artifacts/<< parameters.suite >>.json
       - when:
           condition: << parameters.codecov-upload >>
           steps:
@@ -194,24 +190,6 @@ jobs:
                 command: |
                   bash <(curl -s https://codecov.io/bash)
 
-  test-chain:
-    <<: *test
-  test-node:
-    <<: *test
-  test-storage:
-    <<: *test
-  test-cli:
-    <<: *test
-  test-short:
-    <<: *test
-  test-window-post:
-    <<: *test
-  test-window-post-dispute:
-    <<: *test
-  test-deadline-toggling:
-    <<: *test
-  test-terminate:
-    <<: *test
   test-conformance:
     description: |
       Run tests using a corpus of interoperable test vectors for Filecoin 
@@ -331,7 +309,7 @@ jobs:
       - 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=../..
+          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 .
@@ -379,8 +357,8 @@ jobs:
       - run:
           name: Install go
           command: |
-            curl -O https://dl.google.com/go/go1.15.5.darwin-amd64.pkg && \
-            sudo installer -pkg go1.15.5.darwin-amd64.pkg -target /
+            curl -O https://dl.google.com/go/go1.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
@@ -428,6 +406,41 @@ jobs:
             - "~/.rustup"
             - "~/.cargo"
 
+  build-appimage:
+    machine:
+      image: ubuntu-2004:202104-01
+    steps:
+      - checkout
+      - attach_workspace:
+          at: "."
+      - run:
+          name: install appimage-builder
+          command: |
+            # 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:
@@ -436,7 +449,7 @@ jobs:
       - run:
           command: "! go fmt ./... 2>&1 | read"
 
-  cbor-gen-check:
+  gen-check:
     executor: golang
     steps:
       - install-deps
@@ -444,7 +457,10 @@ jobs:
       - run: make deps
       - run: go install golang.org/x/tools/cmd/goimports
       - run: go install github.com/hannahhoward/cbor-gen-for
-      - run: make type-gen
+      - 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
 
@@ -527,6 +543,33 @@ jobs:
           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
@@ -701,61 +744,153 @@ workflows:
           concurrency: "16"   # expend all docker 2xlarge CPUs.
       - mod-tidy-check
       - gofmt
-      - cbor-gen-check
+      - gen-check
       - docs-check
       - test:
-          codecov-upload: true
-          test-suite-name: full
-      - test-chain:
-          codecov-upload: true
-          test-suite-name: chain
-          packages: "./chain/..."
-      - test-node:
-          codecov-upload: true
-          test-suite-name: node
-          packages: "./node/..."
-      - test-storage:
-          codecov-upload: true
-          test-suite-name: storage
-          packages: "./storage/... ./extern/..."
-      - test-cli:
-          codecov-upload: true
-          test-suite-name: cli
-          packages: "./cli/... ./cmd/... ./api/..."
-      - test-window-post:
-          codecov-upload: true
-          go-test-flags: "-run=TestWindowedPost"
-          winpost-test: "1"
-          test-suite-name: window-post
-      - test-window-post-dispute:
-          codecov-upload: true
-          go-test-flags: "-run=TestWindowPostDispute"
-          winpost-test: "1"
-          test-suite-name: window-post-dispute
-      - test-terminate:
-          codecov-upload: true
-          go-test-flags: "-run=TestTerminate"
-          winpost-test: "1"
-          test-suite-name: terminate
-      - test-deadline-toggling:
-          codecov-upload: true
-          go-test-flags: "-run=TestDeadlineToggling"
-          deadline-test: "1"
-          test-suite-name: deadline-toggling
-      - test-short:
-          go-test-flags: "--timeout 10m --short"
-          test-suite-name: short
-          filters:
-            tags:
-              only:
-                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+          name: test-itest-api
+          suite: itest-api
+          target: "./itests/api_test.go"
+      
+      - test:
+          name: test-itest-batch_deal
+          suite: itest-batch_deal
+          target: "./itests/batch_deal_test.go"
+      
+      - test:
+          name: test-itest-ccupgrade
+          suite: itest-ccupgrade
+          target: "./itests/ccupgrade_test.go"
+      
+      - test:
+          name: test-itest-cli
+          suite: itest-cli
+          target: "./itests/cli_test.go"
+      
+      - test:
+          name: test-itest-deadlines
+          suite: itest-deadlines
+          target: "./itests/deadlines_test.go"
+      
+      - test:
+          name: test-itest-deals_concurrent
+          suite: itest-deals_concurrent
+          target: "./itests/deals_concurrent_test.go"
+      
+      - test:
+          name: test-itest-deals_offline
+          suite: itest-deals_offline
+          target: "./itests/deals_offline_test.go"
+      
+      - test:
+          name: test-itest-deals_power
+          suite: itest-deals_power
+          target: "./itests/deals_power_test.go"
+      
+      - test:
+          name: test-itest-deals_pricing
+          suite: itest-deals_pricing
+          target: "./itests/deals_pricing_test.go"
+      
+      - test:
+          name: test-itest-deals_publish
+          suite: itest-deals_publish
+          target: "./itests/deals_publish_test.go"
+      
+      - test:
+          name: test-itest-deals
+          suite: itest-deals
+          target: "./itests/deals_test.go"
+      
+      - test:
+          name: test-itest-gateway
+          suite: itest-gateway
+          target: "./itests/gateway_test.go"
+      
+      - test:
+          name: test-itest-multisig
+          suite: itest-multisig
+          target: "./itests/multisig_test.go"
+      
+      - test:
+          name: test-itest-paych_api
+          suite: itest-paych_api
+          target: "./itests/paych_api_test.go"
+      
+      - test:
+          name: test-itest-paych_cli
+          suite: itest-paych_cli
+          target: "./itests/paych_cli_test.go"
+      
+      - test:
+          name: test-itest-sdr_upgrade
+          suite: itest-sdr_upgrade
+          target: "./itests/sdr_upgrade_test.go"
+      
+      - test:
+          name: test-itest-sector_finalize_early
+          suite: itest-sector_finalize_early
+          target: "./itests/sector_finalize_early_test.go"
+      
+      - test:
+          name: test-itest-sector_pledge
+          suite: itest-sector_pledge
+          target: "./itests/sector_pledge_test.go"
+      
+      - test:
+          name: test-itest-sector_terminate
+          suite: itest-sector_terminate
+          target: "./itests/sector_terminate_test.go"
+      
+      - test:
+          name: test-itest-tape
+          suite: itest-tape
+          target: "./itests/tape_test.go"
+      
+      - test:
+          name: test-itest-verifreg
+          suite: itest-verifreg
+          target: "./itests/verifreg_test.go"
+      
+      - test:
+          name: test-itest-wdpost_dispute
+          suite: itest-wdpost_dispute
+          target: "./itests/wdpost_dispute_test.go"
+      
+      - test:
+          name: test-itest-wdpost
+          suite: itest-wdpost
+          target: "./itests/wdpost_test.go"
+      
+      - test:
+          name: test-unit-cli
+          suite: utest-unit-cli
+          target: "./cli/... ./cmd/... ./api/..."
+      - test:
+          name: test-unit-node
+          suite: utest-unit-node
+          target: "./node/..."
+      - test:
+          name: test-unit-rest
+          suite: utest-unit-rest
+          target: "./api/... ./blockstore/... ./build/... ./chain/... ./cli/... ./cmd/... ./conformance/... ./extern/... ./gateway/... ./journal/... ./lib/... ./markets/... ./node/... ./paychmgr/... ./storage/... ./tools/..."
+      - test:
+          name: test-unit-storage
+          suite: utest-unit-storage
+          target: "./storage/... ./extern/..."
+      - test:
+          go-test-flags: "-run=TestMulticoreSDR"
+          suite: multicore-sdr-check
+          target: "./extern/sector-storage/ffiwrapper"
+          proofs-log-test: "1"
       - test-conformance:
-          test-suite-name: conformance
-          packages: "./conformance"
+          suite: conformance
+          codecov-upload: false
+          target: "./conformance"
       - test-conformance:
           name: test-conformance-bleeding-edge
-          test-suite-name: conformance-bleeding-edge
-          packages: "./conformance"
+          codecov-upload: false
+          suite: conformance-bleeding-edge
+          target: "./conformance"
           vectors-branch: master
       - trigger-testplans:
           filters:
@@ -764,37 +899,35 @@ workflows:
                 - master
       - build-debug
       - build-all:
-          requires:
-            - test-short
           filters:
             tags:
               only:
                 - /^v\d+\.\d+\.\d+(-rc\d+)?$/
       - build-ntwk-calibration:
-          requires:
-            - test-short
           filters:
             tags:
               only:
                 - /^v\d+\.\d+\.\d+(-rc\d+)?$/
       - build-ntwk-butterfly:
-          requires:
-            - test-short
           filters:
             tags:
               only:
                 - /^v\d+\.\d+\.\d+(-rc\d+)?$/
       - build-ntwk-nerpa:
-          requires:
-            - test-short
           filters:
             tags:
               only:
                 - /^v\d+\.\d+\.\d+(-rc\d+)?$/
       - build-lotus-soup
       - build-macos:
-          requires:
-            - test-short
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - build-appimage:
           filters:
             branches:
               ignore:
@@ -806,6 +939,7 @@ workflows:
           requires:
             - build-all
             - build-macos
+            - build-appimage
           filters:
             branches:
               ignore:
@@ -858,3 +992,26 @@ workflows:
             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+)?$/
+
+  nightly:
+    triggers:
+      - schedule:
+          cron: "0 0 * * *"
+          filters:
+            branches:
+              only:
+                - master
+    jobs:
+      - publish-snapcraft:
+          name: publish-snapcraft-nightly
+          channel: edge

.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,902 @@
+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:
+            - 'v25-2k-lotus-params'
+          paths:
+            - /var/tmp/filecoin-proof-parameters/
+      - run:  ./lotus fetch-params 2048
+      - save_cache:
+          name: Save parameters cache
+          key: 'v25-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
+      - 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-ntwk-nerpa:
+    description: |
+      Compile lotus binaries for the nerpa network
+    parameters:
+      <<: *test-params
+    executor: << parameters.executor >>
+    steps:
+      - install-deps
+      - prepare
+      - run: make nerpanet
+      - run: mkdir linux-nerpanet && mv lotus lotus-miner lotus-worker linux-nerpanet
+      - persist_to_workspace:
+          root: "."
+          paths:
+            - linux-nerpanet
+  build-lotus-soup:
+    description: |
+      Compile `lotus-soup` Testground test plan
+    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 && ln -s $(pwd)/testplans/graphsync $HOME/testground/plans/graphsync
+      - run:
+          name: "go get lotus@master"
+          command: cd testplans/lotus-soup && go get github.com/filecoin-project/lotus@master
+      - run:
+          name: "trigger deals baseline testplan on taas"
+          command: ~/testground-cli run composition -f $HOME/testground/plans/lotus-soup/_compositions/baseline-k8s-3-1.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
+      - run:
+          name: "trigger payment channel stress testplan on taas"
+          command: ~/testground-cli run composition -f $HOME/testground/plans/lotus-soup/_compositions/paych-stress-k8s.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
+      - run:
+          name: "trigger graphsync testplan on taas"
+          command: ~/testground-cli run composition -f $HOME/testground/plans/graphsync/_compositions/stress-k8s.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
+
+
+  build-macos:
+    description: build darwin lotus binary
+    macos:
+      xcode: "10.0.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 jq
+          command: |
+            curl --location https://github.com/stedolan/jq/releases/download/jq-1.6/jq-osx-amd64 --output /usr/local/bin/jq
+            chmod +x /usr/local/bin/jq
+      - run:
+          name: Install hwloc
+          command: |
+            mkdir ~/hwloc
+            curl --location https://download.open-mpi.org/release/hwloc/v2.4/hwloc-2.4.1.tar.gz --output ~/hwloc/hwloc-2.4.1.tar.gz
+            cd ~/hwloc
+            tar -xvzpf hwloc-2.4.1.tar.gz
+            cd hwloc-2.4.1
+            ./configure && make && sudo make install
+      - restore_cache:
+          name: restore cargo cache
+          key: v3-go-deps-{{ arch }}-{{ checksum "~/go/src/github.com/filecoin-project/lotus/go.sum" }}
+      - install-deps
+      - run:
+          command: make build
+          no_output_timeout: 30m
+      - 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:202104-01
+    steps:
+      - checkout
+      - attach_workspace:
+          at: "."
+      - run:
+          name: install appimage-builder
+          command: |
+            # 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)
+
+    steps:
+      - run:
+          name: Confirm that environment variables are set
+          command: |
+            if [ -z "$AWS_ACCESS_KEY_ID" ]; then
+              echo "No AWS_ACCESS_KEY_ID is set. Skipping build-and-push job ..."
+              circleci-agent step halt
+            fi
+
+      - aws-cli/setup:
+          profile-name: <<parameters.profile-name>>
+          aws-access-key-id: <<parameters.aws-access-key-id>>
+          aws-secret-access-key: <<parameters.aws-secret-access-key>>
+          aws-region: <<parameters.region>>
+
+      - run:
+          name: Log into Amazon ECR
+          command: |
+            aws ecr-public get-login-password --region $<<parameters.region>> --profile <<parameters.profile-name>> | docker login --username AWS --password-stdin $<<parameters.account-url>>
+
+      - checkout
+
+      - setup_remote_docker:
+          version: 19.03.13
+          docker_layer_caching: false
+
+      - run:
+          name: Build docker image
+          command: |
+            registry_id=$(echo $<<parameters.account-url>> | sed "s;\..*;;g")
+
+            docker_tag_args=""
+            IFS="," read -ra DOCKER_TAGS \<<< "<< parameters.tag >>"
+            for tag in "${DOCKER_TAGS[@]}"; do
+              docker_tag_args="$docker_tag_args -t $<<parameters.account-url>>/<<parameters.repo>>:$tag"
+            done
+
+            docker build \
+              <<#parameters.extra-build-args>><<parameters.extra-build-args>><</parameters.extra-build-args>> \
+              -f <<parameters.path>>/<<parameters.dockerfile>> \
+              $docker_tag_args \
+              <<parameters.path>>
+
+      - run:
+          name: Push image to Amazon ECR
+          command: |
+            IFS="," read -ra DOCKER_TAGS \<<< "<< parameters.tag >>"
+            for tag in "${DOCKER_TAGS[@]}"; do
+              docker push $<<parameters.account-url>>/<<parameters.repo>>:${tag}
+            done
+
+  publish-packer-mainnet:
+    description: build and push AWS IAM and DigitalOcean droplet.
+    executor:
+      name: packer/default
+      packer-version: 1.6.6
+    steps:
+      - checkout
+      - attach_workspace:
+          at: "."
+      - packer/build:
+          template: tools/packer/lotus.pkr.hcl
+          args: "-var ci_workspace_bins=./linux -var lotus_network=mainnet -var git_tag=$CIRCLE_TAG"
+  publish-packer-calibrationnet:
+    description: build and push AWS IAM and DigitalOcean droplet.
+    executor:
+      name: packer/default
+      packer-version: 1.6.6
+    steps:
+      - checkout
+      - attach_workspace:
+          at: "."
+      - packer/build:
+          template: tools/packer/lotus.pkr.hcl
+          args: "-var ci_workspace_bins=./linux-calibrationnet -var lotus_network=calibrationnet -var git_tag=$CIRCLE_TAG"
+  publish-packer-butterflynet:
+    description: build and push AWS IAM and DigitalOcean droplet.
+    executor:
+      name: packer/default
+      packer-version: 1.6.6
+    steps:
+      - checkout
+      - attach_workspace:
+          at: "."
+      - packer/build:
+          template: tools/packer/lotus.pkr.hcl
+          args: "-var ci_workspace_bins=./linux-butterflynet -var lotus_network=butterflynet -var git_tag=$CIRCLE_TAG"
+  publish-packer-nerpanet:
+    description: build and push AWS IAM and DigitalOcean droplet.
+    executor:
+      name: packer/default
+      packer-version: 1.6.6
+    steps:
+      - checkout
+      - attach_workspace:
+          at: "."
+      - packer/build:
+          template: tools/packer/lotus.pkr.hcl
+          args: "-var ci_workspace_bins=./linux-nerpanet -var lotus_network=nerpanet -var git_tag=$CIRCLE_TAG"
+
+workflows:
+  version: 2.1
+  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: master
+      - 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-ntwk-nerpa:
+          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}'
+      - publish-packer-mainnet:
+          requires:
+            - build-all
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - publish-packer-calibrationnet:
+          requires:
+            - build-ntwk-calibration
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - publish-packer-butterflynet:
+          requires:
+            - build-ntwk-butterfly
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - publish-packer-nerpanet:
+          requires:
+            - build-ntwk-nerpa
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+(-rc\d+)?$/
+      - publish-snapcraft:
+          name: publish-snapcraft-stable
+          channel: 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

.github/CODEOWNERS

@@ -1,16 +0,0 @@
-## filecoin-project/lotus CODEOWNERS
-## Refer to https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners.
-##
-## These users or groups will be automatically assigned as reviewers every time
-## a PR is submitted that modifies code in the specified locations.
-##
-## The Lotus repo configuration requires that at least ONE codeowner approves
-## the PR before merging.
-
-### Global owners.
-*                       @magik6k @arajasek
-
-### Conformance testing.
-conformance/            @ZenGround0
-extern/test-vectors     @ZenGround0
-cmd/tvx                 @ZenGround0

.github/workflows/codeql-analysis.yml

@@ -35,6 +35,10 @@ jobs:
     - 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

.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
@@ -5,6 +8,7 @@
 /lotus-health
 /lotus-chainwatch
 /lotus-shed
+/lotus-sim
 /lotus-pond
 /lotus-townhall
 /lotus-fountain

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: true
+    debian:
+      image: appimagecrafters/tests-env:debian-stable
+      command: ./AppRun
+      use_host_x: true
+    arch:
+      image: appimagecrafters/tests-env:archlinux-latest
+      command: ./AppRun
+      use_host_x: true
+    centos:
+      image: appimagecrafters/tests-env:centos-7
+      command: ./AppRun
+      use_host_x: true
+    ubuntu:
+      image: appimagecrafters/tests-env:ubuntu-xenial
+      command: ./AppRun
+      use_host_x: true
+AppImage:
+  arch: x86_64
+  update-information: guess
+  sign-key: None
+

CHANGELOG.md

@@ -1,5 +1,399 @@
 # Lotus changelog
 
+# 1.11.0 / 2021-07-22
+
+This is a **highly recommended** release of Lotus that have many bug fixes, improvements and new features. 
+
+## Highlights
+- Miner SimultaneousTransfers config ([filecoin-project/lotus#6612](https://github.com/filecoin-project/lotus/pull/6612))
+  - Set `SimultaneousTransfers` in lotus miner config to configure the maximum number of parallel online data transfers, including both storage and retrieval deals.
+- Dynamic Retrieval pricing ([filecoin-project/lotus#6175](https://github.com/filecoin-project/lotus/pull/6175))
+  - Customize your retrieval ask price, see a quick tutorial [here](https://github.com/filecoin-project/lotus/discussions/6780).
+- Robust message management  ([filecoin-project/lotus#5822](https://github.com/filecoin-project/lotus/pull/5822))
+  - run `lotus mpool manage and follow the instructions!
+  - Demo available at https://www.youtube.com/watch?v=QDocpLQjZgQ.
+- Add utils to use multisigs as miner owners ([filecoin-project/lotus#6490](https://github.com/filecoin-project/lotus/pull/6490))
+  
+## More New Features
+-  feat: implement lotus-sim ([filecoin-project/lotus#6406](https://github.com/filecoin-project/lotus/pull/6406))
+- implement a command to export a car ([filecoin-project/lotus#6405](https://github.com/filecoin-project/lotus/pull/6405))
+- Add a command to get the fees of a deal ([filecoin-project/lotus#5307](https://github.com/filecoin-project/lotus/pull/5307))
+  - run `lotus-shed market get-deal-fees`
+- Add a command to list retrievals ([filecoin-project/lotus#6337](https://github.com/filecoin-project/lotus/pull/6337))
+  - run `lotus client list-retrievals`
+- lotus-gateway: add check command ([filecoin-project/lotus#6373](https://github.com/filecoin-project/lotus/pull/6373))
+- lotus-wallet: JWT Support ([filecoin-project/lotus#6360](https://github.com/filecoin-project/lotus/pull/6360))
+- Allow starting networks from arbitrary actor versions ([filecoin-project/lotus#6305](https://github.com/filecoin-project/lotus/pull/6305))
+- oh, snap! ([filecoin-project/lotus#6202](https://github.com/filecoin-project/lotus/pull/6202))
+- Add a shed util to count 64 GiB miner stats ([filecoin-project/lotus#6290](https://github.com/filecoin-project/lotus/pull/6290))
+- Introduce stateless offline dealflow, bypassing the FSM/deallists ([filecoin-project/lotus#5961](https://github.com/filecoin-project/lotus/pull/5961))
+- Transplant some useful commands to lotus-shed actor ([filecoin-project/lotus#5913](https://github.com/filecoin-project/lotus/pull/5913))
+  - run `lotus-shed actor`
+- actor wrapper codegen ([filecoin-project/lotus#6108](https://github.com/filecoin-project/lotus/pull/6108))
+- Add a shed util to count miners by post type ([filecoin-project/lotus#6169](https://github.com/filecoin-project/lotus/pull/6169))  
+- shed: command to list duplicate messages in tipsets (steb) ([filecoin-project/lotus#5847](https://github.com/filecoin-project/lotus/pull/5847))
+- feat: allow checkpointing to forks ([filecoin-project/lotus#6107](https://github.com/filecoin-project/lotus/pull/6107))
+- Add a CLI tool for miner proving deadline ([filecoin-project/lotus#6132](https://github.com/filecoin-project/lotus/pull/6132))   
+  - run `lotus state miner-proving-deadline` 
+
+
+## Bug Fixes
+- Fix wallet error messages ([filecoin-project/lotus#6594](https://github.com/filecoin-project/lotus/pull/6594))
+- Fix CircleCI gen ([filecoin-project/lotus#6589](https://github.com/filecoin-project/lotus/pull/6589))
+- Make query-ask CLI more graceful ([filecoin-project/lotus#6590](https://github.com/filecoin-project/lotus/pull/6590))
+- scale up sector expiration to avoid sector expire in batch-pre-commit waitting ([filecoin-project/lotus#6566](https://github.com/filecoin-project/lotus/pull/6566))
+-  Fix an error in msigLockCancel ([filecoin-project/lotus#6582](https://github.com/filecoin-project/lotus/pull/6582)
+- fix circleci being out of sync. ([filecoin-project/lotus#6573](https://github.com/filecoin-project/lotus/pull/6573))  
+- Fix helptext for ask price([filecoin-project/lotus#6560](https://github.com/filecoin-project/lotus/pull/6560))
+- fix commit finalize failed ([filecoin-project/lotus#6521](https://github.com/filecoin-project/lotus/pull/6521))
+- Fix soup ([filecoin-project/lotus#6501](https://github.com/filecoin-project/lotus/pull/6501))
+- fix: pick the correct partitions-per-post limit ([filecoin-project/lotus#6502](https://github.com/filecoin-project/lotus/pull/6502))
+- sealing: Fix restartSectors race ([filecoin-project/lotus#6495](https://github.com/filecoin-project/lotus/pull/6495))
+- Fix: correct the change of message size limit ([filecoin-project/lotus#6430](https://github.com/filecoin-project/lotus/pull/6430))
+- Fix logging of stringified CIDs double-encoded in hex ([filecoin-project/lotus#6413](https://github.com/filecoin-project/lotus/pull/6413))
+- Fix success handling in Retreival ([filecoin-project/lotus#5921](https://github.com/filecoin-project/lotus/pull/5921))
+- storagefsm: Fix batch deal packing behavior ([filecoin-project/lotus#6041](https://github.com/filecoin-project/lotus/pull/6041))
+- events: Fix handling of multiple matched events per epoch ([filecoin-project/lotus#6355](https://github.com/filecoin-project/lotus/pull/6355))
+- Fix logging around mineOne ([filecoin-project/lotus#6310](https://github.com/filecoin-project/lotus/pull/6310))
+- Fix shell completions ([filecoin-project/lotus#6316](https://github.com/filecoin-project/lotus/pull/6316))
+- Allow 8MB sectors in devnet ([filecoin-project/lotus#6312](https://github.com/filecoin-project/lotus/pull/6312))
+- fix ticket expired ([filecoin-project/lotus#6304](https://github.com/filecoin-project/lotus/pull/6304))
+- Revert "chore: update go-libp2p" ([filecoin-project/lotus#6306](https://github.com/filecoin-project/lotus/pull/6306))
+- fix: wait-api should use GetAPI to acquire binary specific API ([filecoin-project/lotus#6246](https://github.com/filecoin-project/lotus/pull/6246))
+- fix(ci): Updates to lotus CI build process ([filecoin-project/lotus#6256](https://github.com/filecoin-project/lotus/pull/6256))
+- fix: use a consistent tipset in commands ([filecoin-project/lotus#6142](https://github.com/filecoin-project/lotus/pull/6142))
+- go mod tidy for lotus-soup testplans ([filecoin-project/lotus#6124](https://github.com/filecoin-project/lotus/pull/6124))
+- fix testground payment channel tests: use 1 miner ([filecoin-project/lotus#6126](https://github.com/filecoin-project/lotus/pull/6126))
+- fix: use the parent state when listing actors ([filecoin-project/lotus#6143](https://github.com/filecoin-project/lotus/pull/6143))
+- Speed up StateListMessages in some cases ([filecoin-project/lotus#6007](https://github.com/filecoin-project/lotus/pull/6007))
+- fix(splitstore): fix a panic on revert-only head changes ([filecoin-project/lotus#6133](https://github.com/filecoin-project/lotus/pull/6133))
+- drand: fix beacon cache ([filecoin-project/lotus#6164](https://github.com/filecoin-project/lotus/pull/6164))
+ 
+## Improvements
+- gateway: Add support for Version method ([filecoin-project/lotus#6618](https://github.com/filecoin-project/lotus/pull/6618))
+- revamped integration test kit (aka. Operation Sparks Joy) ([filecoin-project/lotus#6329](https://github.com/filecoin-project/lotus/pull/6329))
+- move with changed name ([filecoin-project/lotus#6587](https://github.com/filecoin-project/lotus/pull/6587))
+- dynamic circleci config for streamlining test execution ([filecoin-project/lotus#6561](https://github.com/filecoin-project/lotus/pull/6561))
+- extern/storage: add ability to ignore worker resources when scheduling. ([filecoin-project/lotus#6542](https://github.com/filecoin-project/lotus/pull/6542))
+- Adjust various CLI display ratios to arbitrary precision ([filecoin-project/lotus#6309](https://github.com/filecoin-project/lotus/pull/6309))
+- Test multicore SDR support ([filecoin-project/lotus#6479](https://github.com/filecoin-project/lotus/pull/6479))
+- Unit tests for sector batchers ([filecoin-project/lotus#6432](https://github.com/filecoin-project/lotus/pull/6432))
+- Update chain list with correct help instructions ([filecoin-project/lotus#6465](https://github.com/filecoin-project/lotus/pull/6465))
+- clean failed sectors in batch commit ([filecoin-project/lotus#6451](https://github.com/filecoin-project/lotus/pull/6451))
+- itests/kit: add guard to ensure imports from tests only. ([filecoin-project/lotus#6445](https://github.com/filecoin-project/lotus/pull/6445))
+- consolidate integration tests into `itests` package; create test kit; cleanup ([filecoin-project/lotus#6311](https://github.com/filecoin-project/lotus/pull/6311))
+- Fee config for sector batching ([filecoin-project/lotus#6420](https://github.com/filecoin-project/lotus/pull/6420))
+- UX: lotus state power CLI should fail if called with a not-miner ([filecoin-project/lotus#6425](https://github.com/filecoin-project/lotus/pull/6425))
+- Increase message size limit ([filecoin-project/lotus#6419](https://github.com/filecoin-project/lotus/pull/6419))
+- polish(stmgr): define ExecMonitor for message application callback ([filecoin-project/lotus#6389](https://github.com/filecoin-project/lotus/pull/6389))
+- upgrade testground action version ([filecoin-project/lotus#6403](https://github.com/filecoin-project/lotus/pull/6403))
+- Bypass task scheduler for reading unsealed pieces ([filecoin-project/lotus#6280](https://github.com/filecoin-project/lotus/pull/6280))
+- testplans: lotus-soup: use default WPoStChallengeWindow ([filecoin-project/lotus#6400](https://github.com/filecoin-project/lotus/pull/6400))
+- Integration tests for offline deals ([filecoin-project/lotus#6081](https://github.com/filecoin-project/lotus/pull/6081))
+- Fix some flaky tests ([filecoin-project/lotus#6397](https://github.com/filecoin-project/lotus/pull/6397))
+- build appimage in CI ([filecoin-project/lotus#6384](https://github.com/filecoin-project/lotus/pull/6384))
+- Generate AppImage ([filecoin-project/lotus#6208](https://github.com/filecoin-project/lotus/pull/6208))
+- Add test for AddVerifiedClient ([filecoin-project/lotus#6317](https://github.com/filecoin-project/lotus/pull/6317))
+- Typo fix in error message: "pubusb" -> "pubsub" ([filecoin-project/lotus#6365](https://github.com/filecoin-project/lotus/pull/6365))
+- Improve the cli state call command  ([filecoin-project/lotus#6226](https://github.com/filecoin-project/lotus/pull/6226))
+- Upscale mineOne message to a WARN on unexpected ineligibility ([filecoin-project/lotus#6358](https://github.com/filecoin-project/lotus/pull/6358))
+- Remove few useless variable assignments ([filecoin-project/lotus#6359](https://github.com/filecoin-project/lotus/pull/6359))
+- Reduce noise from 'peer has different genesis' messages ([filecoin-project/lotus#6357](https://github.com/filecoin-project/lotus/pull/6357))
+- Get current seal proof when necessary ([filecoin-project/lotus#6339](https://github.com/filecoin-project/lotus/pull/6339))
+- Remove log line when tracing is not configured ([filecoin-project/lotus#6334](https://github.com/filecoin-project/lotus/pull/6334))
+- separate tracing environment variables ([filecoin-project/lotus#6323](https://github.com/filecoin-project/lotus/pull/6323))
+- feat: log dispute rate ([filecoin-project/lotus#6322](https://github.com/filecoin-project/lotus/pull/6322))
+- Move verifreg shed utils to CLI ([filecoin-project/lotus#6135](https://github.com/filecoin-project/lotus/pull/6135))  
+- consider storiface.PathStorage when calculating storage requirements ([filecoin-project/lotus#6233](https://github.com/filecoin-project/lotus/pull/6233))
+- `storage` module: add go docs and minor code quality refactors ([filecoin-project/lotus#6259](https://github.com/filecoin-project/lotus/pull/6259))
+- Increase data transfer timeouts ([filecoin-project/lotus#6300](https://github.com/filecoin-project/lotus/pull/6300))
+- gateway: spin off from cmd to package ([filecoin-project/lotus#6294](https://github.com/filecoin-project/lotus/pull/6294))
+- Return total power when GetPowerRaw doesn't find miner claim ([filecoin-project/lotus#4938](https://github.com/filecoin-project/lotus/pull/4938))
+- add flags to control gateway lookback parameters ([filecoin-project/lotus#6247](https://github.com/filecoin-project/lotus/pull/6247))
+- chore(ci): Enable build on RC tags ([filecoin-project/lotus#6238](https://github.com/filecoin-project/lotus/pull/6238))
+- cron-wc ([filecoin-project/lotus#6178](https://github.com/filecoin-project/lotus/pull/6178))
+- Allow creation of state tree v3s ([filecoin-project/lotus#6167](https://github.com/filecoin-project/lotus/pull/6167))
+- mpool: Cleanup pre-nv12 selection logic ([filecoin-project/lotus#6148](https://github.com/filecoin-project/lotus/pull/6148))
+- attempt to do better padding on pieces being written into sectors ([filecoin-project/lotus#5988](https://github.com/filecoin-project/lotus/pull/5988))
+- remove duplicate ask and calculate ping before lock ([filecoin-project/lotus#5968](https://github.com/filecoin-project/lotus/pull/5968))
+- flaky tests improvement: separate TestBatchDealInput from TestAPIDealFlow ([filecoin-project/lotus#6141](https://github.com/filecoin-project/lotus/pull/6141))
+- Testground checks on push ([filecoin-project/lotus#5887](https://github.com/filecoin-project/lotus/pull/5887))
+- Use EmptyTSK where appropriate ([filecoin-project/lotus#6134](https://github.com/filecoin-project/lotus/pull/6134))
+- upgrade `lotus-soup` testplans and reduce deals concurrency to a single miner ([filecoin-project/lotus#6122](https://github.com/filecoin-project/lotus/pull/6122)
+  
+## Dependency Updates
+- downgrade libp2p/go-libp2p-yamux to v0.5.1. ([filecoin-project/lotus#6605](https://github.com/filecoin-project/lotus/pull/6605))
+- Update libp2p to 0.14.2 ([filecoin-project/lotus#6404](https://github.com/filecoin-project/lotus/pull/6404))
+- update to markets-v1.4.0 ([filecoin-project/lotus#6369](https://github.com/filecoin-project/lotus/pull/6369))
+- Use new actor tags ([filecoin-project/lotus#6291](https://github.com/filecoin-project/lotus/pull/6291))
+- chore: update go-libp2p ([filecoin-project/lotus#6231](https://github.com/filecoin-project/lotus/pull/6231))
+- Update ffi to proofs v7 ([filecoin-project/lotus#6150](https://github.com/filecoin-project/lotus/pull/6150))
+  
+## Others
+- Initial draft: basic build instructions on Readme ([filecoin-project/lotus#6498](https://github.com/filecoin-project/lotus/pull/6498))
+- Remove rc changelog, compile the new changelog for final release only ([filecoin-project/lotus#6444](https://github.com/filecoin-project/lotus/pull/6444))
+- updated configuration comments for docs ([filecoin-project/lotus#6440](https://github.com/filecoin-project/lotus/pull/6440))
+- Set ntwk v13 HyperDrive Calibration upgrade epoch ([filecoin-project/lotus#6441](https://github.com/filecoin-project/lotus/pull/6441))
+- build snapcraft ([filecoin-project/lotus#6388](https://github.com/filecoin-project/lotus/pull/6388))
+- Fix the doc errors of the sealing config funcs ([filecoin-project/lotus#6399](https://github.com/filecoin-project/lotus/pull/6399))
+- Add doc on gas balancing ([filecoin-project/lotus#6392](https://github.com/filecoin-project/lotus/pull/6392))
+- Add interop network ([filecoin-project/lotus#6387](https://github.com/filecoin-project/lotus/pull/6387))
+- Network version 13 (v1.11) ([filecoin-project/lotus#6342](https://github.com/filecoin-project/lotus/pull/6342))
+- Add a warning to the release issue template ([filecoin-project/lotus#6374](https://github.com/filecoin-project/lotus/pull/6374))
+- Update RELEASE_ISSUE_TEMPLATE.md ([filecoin-project/lotus#6236](https://github.com/filecoin-project/lotus/pull/6236))
+- Delete CODEOWNERS ([filecoin-project/lotus#6289](https://github.com/filecoin-project/lotus/pull/6289))
+- Feat/nerpa v4 ([filecoin-project/lotus#6248](https://github.com/filecoin-project/lotus/pull/6248))
+- Introduce a release issue template ([filecoin-project/lotus#5826](https://github.com/filecoin-project/lotus/pull/5826))
+- This is a 1:1 forward-port of PR#6183 from 1.9.x to master ([filecoin-project/lotus#6196](https://github.com/filecoin-project/lotus/pull/6196))
+- Update cli gen ([filecoin-project/lotus#6155](https://github.com/filecoin-project/lotus/pull/6155))
+- Generate CLI docs ([filecoin-project/lotus#6145](https://github.com/filecoin-project/lotus/pull/6145))  
+  
+## Contributors
+
+| Contributor | Commits | Lines ± | Files Changed |
+|-------------|---------|---------|---------------|
+| @raulk | 118 | +11972/-10860 | 472 |
+| @magik6k | 65 | +10824/-4158 | 353 |
+| @aarshkshah1992 | 59 | +8057/-3355 | 224 |
+| @arajasek | 41 | +8786/-1691 | 331 |
+| @Stebalien | 106 | +7653/-2718 | 273 |
+| dirkmc | 11 | +2580/-1371 | 77 |
+| @dirkmc | 39 | +1865/-1194 | 79 |
+| @Kubuxu | 19 | +1973/-485 | 81 |
+| @vyzo | 4 | +1748/-330 | 50 |
+| @aarshkshah1992 | 5 | +1462/-213 | 27 |
+| @coryschwartz | 35 | +568/-206 | 59 |
+| @chadwick2143 | 3 | +739/-1 | 4 |
+| @ribasushi | 21 | +487/-164 | 36 |
+| @hannahhoward | 5 | +544/-5 | 19 |
+| @jennijuju | 9 | +241/-174 | 19 |
+| @frrist | 1 | +137/-88 | 7 |
+| @travisperson | 3 | +175/-6 | 7 |
+| @wadeAlexC | 1 | +48/-129 | 1 |
+| @whyrusleeping | 8 | +161/-13 | 11 |
+| lotus | 1 | +114/-46 | 1 |
+| @nonsense | 8 | +107/-53 | 20 |
+| @rjan90 | 4 | +115/-33 | 4 |
+| @ZenGround0 | 3 | +114/-1 | 4 |
+| @Aloxaf | 1 | +43/-61 | 7 |
+| @yaohcn | 4 | +89/-9 | 5 |
+| @mitchellsoo | 1 | +51/-0 | 1 |
+| @placer14 | 3 | +28/-18 | 4 |
+| @jennijuju | 6 | +9/-14 | 6 |
+| @Frank | 2 | +11/-10 | 2 |
+| @wangchao | 3 | +5/-4 | 4 |
+| @Steve Loeppky | 1 | +7/-1 | 1 |
+| @Lion | 1 | +4/-2 | 1 |
+| @Mimir | 1 | +2/-2 | 1 |
+| @raulk | 1 | +1/-1 | 1 |
+| @Jack Yao | 1 | +1/-1 | 1 |
+| @IPFSUnion | 1 | +1/-1 | 1 |
+
+# 1.10.1 / 2021-07-05
+
+This is an optional but **highly recommended** release of Lotus for lotus miners that has many bug fixes and improvements based on the feedback we got from the community since HyperDrive.
+
+## New Features
+- commit batch: AggregateAboveBaseFee config #6650
+  - `AggregateAboveBaseFee` is added to miner sealing configuration for setting the network base fee to start aggregating proofs. When the network base fee is lower than this value, the prove commits will be submitted individually via `ProveCommitSector`. According to the [Batch Incentive Alignment](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0013.md#batch-incentive-alignment) introduced in FIP-0013, we recommend miners to set this value to 0.15 nanoFIL(which is the default value) to avoid unexpected aggregation fee in burn and enjoy the most benefits of aggregation!
+    
+## Bug Fixes
+- storage: Fix FinalizeSector with sectors in storage paths #6652
+- Fix tiny error in check-client-datacap #6664  
+- Fix: precommit_batch method used the wrong cfg.PreCommitBatchWait #6658
+- to optimize the batchwait #6636
+- fix getTicket: sector precommitted but expired case #6635
+- handleSubmitCommitAggregate() exception handling #6595
+- remove precommit check in handleCommitFailed #6634
+- ensure agg fee is adequate
+- fix: miner balance is not enough, so that ProveCommitAggregate msg exec failed #6623
+- commit batch: Initialize the FailedSectors map #6647
+
+Contributors
+
+| Contributor | Commits | Lines ± | Files Changed |
+|-------------|---------|---------|---------------|
+| @magik6k| 7 | +151/-56 | 21 |
+| @llifezou | 4 | +59/-20 | 4 |
+| @johnli-helloworld | 2 | +45/-14 | 4 |
+| @wangchao | 1 | +1/-27 | 1 |
+| Jerry | 2 | +9/-4 | 2 |
+| @zhoutian527 | 1 | +2/-2 | 1 |
+| @ribasushi| 1 | +1/-1 | 1 |
+
+||||||| 764fa9dae
+=======
+# 1.10.1 / 2021-07-05
+
+This is an optional but **highly recommended** release of Lotus for lotus miners that has many bug fixes and improvements based on the feedback we got from the community since HyperDrive.
+
+## New Features
+- commit batch: AggregateAboveBaseFee config #6650
+  - `AggregateAboveBaseFee` is added to miner sealing configuration for setting the network base fee to start aggregating proofs. When the network base fee is lower than this value, the prove commits will be submitted individually via `ProveCommitSector`. According to the [Batch Incentive Alignment](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0013.md#batch-incentive-alignment) introduced in FIP-0013, we recommend miners to set this value to 0.15 nanoFIL(which is the default value) to avoid unexpected aggregation fee in burn and enjoy the most benefits of aggregation!
+    
+## Bug Fixes
+- storage: Fix FinalizeSector with sectors in storage paths #6652
+- Fix tiny error in check-client-datacap #6664  
+- Fix: precommit_batch method used the wrong cfg.PreCommitBatchWait #6658
+- to optimize the batchwait #6636
+- fix getTicket: sector precommitted but expired case #6635
+- handleSubmitCommitAggregate() exception handling #6595
+- remove precommit check in handleCommitFailed #6634
+- ensure agg fee is adequate
+- fix: miner balance is not enough, so that ProveCommitAggregate msg exec failed #6623
+- commit batch: Initialize the FailedSectors map #6647
+
+Contributors
+
+| Contributor | Commits | Lines ± | Files Changed |
+|-------------|---------|---------|---------------|
+| @magik6k| 7 | +151/-56 | 21 |
+| @llifezou | 4 | +59/-20 | 4 |
+| @johnli-helloworld | 2 | +45/-14 | 4 |
+| @wangchao | 1 | +1/-27 | 1 |
+| Jerry | 2 | +9/-4 | 2 |
+| @zhoutian527 | 1 | +2/-2 | 1 |
+| @ribasushi| 1 | +1/-1 | 1 |
+
+
+>>>>>>> releases
+# 1.10.0 / 2021-06-23
+
+This is a mandatory release of Lotus that introduces Filecoin network v13, codenamed the HyperDrive upgrade. The
+Filecoin mainnet will upgrade, which is epoch 892800, on 2021-06-30T22:00:00Z. The network upgrade introduces the
+following FIPs:
+
+- [FIP-0008](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0008.md): Add miner batched sector pre-commit method
+- [FIP-0011](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0011.md): Remove reward auction from reporting consensus faults
+- [FIP-0012](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0012.md): DataCap Top up for FIL+ Client Addresses
+- [FIP-0013](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0013.md): Add ProveCommitSectorAggregated method to reduce on-chain congestion
+- [FIP-0015](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0015.md): Revert FIP-0009(Exempt Window PoSts from BaseFee burn)
+
+Note that this release is built on top of Lotus v1.9.0. Enterprising users can use the `master` branch of Lotus to get the latest functionality, including all changes in this release candidate.
+
+## Proof batching and aggregation
+
+FIPs [0008](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0008.md) and [0013](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0013.md) combine to allow for a significant increase in the rate of onboarding storage on the Filecoin network. This aims to lead to more useful data being stored on the network, reduced network congestion, and lower network base fee.
+
+**Check out the documentation [here](https://docs.filecoin.io/mine/lotus/miner-configuration/#precommitsectorsbatch) for details on the new Lotus miner sealing config options, [here](https://docs.filecoin.io/mine/lotus/miner-configuration/#fees-section) for fee config options, and explanations of the new features.**
+
+Note:
+  - We recommend to keep `PreCommitSectorsBatch` as 1.
+  - We recommend miners to set `PreCommitBatchWait` lower than 30 hours.
+  - We recommend miners to set a longer `CommitBatchSlack` and  `PreCommitBatchSlack` to prevent message failures
+    due to expirations.
+
+### Projected state tree growth
+
+In order to validate the Hyperdrive changes, we wrote a simulation to seal as many sectors as quickly as possible, assuming the same number and mix of 32GiB and 64GiB miners as the current network.
+
+Given these assumptions:
+
+- We'd expect a network storage growth rate of around 530PiB per day. 😳 🎉 🥳 😅
+- We'd expect network bandwidth dedicated to `SubmitWindowedPoSt` to grow by about 0.02% per day.
+- We'd expect the [state-tree](https://spec.filecoin.io/#section-systems.filecoin_vm.state_tree) (and therefore [snapshot](https://docs.filecoin.io/get-started/lotus/chain/#lightweight-snapshot)) size to grow by 1.16GiB per day.
+   - Nearly all of the state-tree growth is expected to come from new sector metadata.
+- We'd expect the daily lotus datastore growth rate to increase by about 10-15% (from current ~21GiB/day).
+   - Most "growth" of the lotus datastore is due to "churn", historical data that's no longer referenced by the latest state-tree.
+
+### Future improvements
+
+Various Lotus improvements are planned moving forward to mitigate the effects of the growing state tree size. The primary improvement is the [Lotus splitstore](https://github.com/filecoin-project/lotus/discussions/5788), which will soon be enabled by default. The feature allows for [online garbage collection](https://github.com/filecoin-project/lotus/issues/6577) for nodes that do not seek to maintain full chain and state history, thus eliminating the need for users to delete their datastores and sync from snapshots.
+
+Other improvements including better compressed snapshots, faster pre-migrations, and improved chain exports are in the roadmap.
+
+## WindowPost base fee burn
+
+Included in the HyperDrive upgrade is [FIP-0015](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0015.md) which eliminates the special-case gas treatment of `SubmitWindowedPoSt` messages that was introduced in [FIP-0009](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0009.md). Although `SubmitWindowedPoSt` messages will be relatively cheap, thanks to the introduction of optimistic acceptance of these proofs in [FIP-0010](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0010.md), storage providers should pay attention to their `MaxWindowPoStGasFee` config option: too low and PoSts may not land on chain; too high and they may cost an exorbitant amount!
+
+## Changelog
+
+### New Features
+
+- Implement FIP-0015 ([filecoin-project/lotus#6361](https://github.com/filecoin-project/lotus/pull/6361))
+- Integrate FIP0013 and FIP0008 ([filecoin-project/lotus#6235](https://github.com/filecoin-project/lotus/pull/6235))
+  - [Configuration docs and cli examples](https://docs.filecoin.io/mine/lotus/miner-configuration/#precommitsectorsbatch)
+  - [cli docs](https://github.com/filecoin-project/lotus/blob/master/documentation/en/cli-lotus-miner.md#lotus-miner-sectors-batching)
+  - Introduce gas prices for aggregate verifications ([filecoin-project/lotus#6347](https://github.com/filecoin-project/lotus/pull/6347))
+- Introduce v5 actors ([filecoin-project/lotus#6195](https://github.com/filecoin-project/lotus/pull/6195))
+- Robustify commit batcher ([filecoin-project/lotus#6367](https://github.com/filecoin-project/lotus/pull/6367))
+- Always flush when timer goes off ([filecoin-project/lotus#6563](https://github.com/filecoin-project/lotus/pull/6563))
+- Update default fees for aggregates ([filecoin-project/lotus#6548](https://github.com/filecoin-project/lotus/pull/6548))
+- sealing: Early finalization option ([filecoin-project/lotus#6452](https://github.com/filecoin-project/lotus/pull/6452))
+  - `./lotus-miner/config.toml/[Sealing.FinalizeEarly]`: default to false. Enable if you want to FinalizeSector before commiting
+- Add filplus utils to CLI ([filecoin-project/lotus#6351](https://github.com/filecoin-project/lotus/pull/6351))
+  - cli doc can be found [here](https://github.com/filecoin-project/lotus/blob/master/documentation/en/cli-lotus.md#lotus-filplus)
+- Add miner-side MaxDealStartDelay config ([filecoin-project/lotus#6576](https://github.com/filecoin-project/lotus/pull/6576))
+
+
+### Bug Fixes
+- chainstore: Don't take heaviestLk with backlogged reorgCh ([filecoin-project/lotus#6526](https://github.com/filecoin-project/lotus/pull/6526))
+- Backport #6041 - storagefsm: Fix batch deal packing behavior  ([filecoin-project/lotus#6519](https://github.com/filecoin-project/lotus/pull/6519))
+- backport: pick the correct partitions-per-post limit ([filecoin-project/lotus#6503](https://github.com/filecoin-project/lotus/pull/6503))
+- failed sectors should be added into res correctly ([filecoin-project/lotus#6472](https://github.com/filecoin-project/lotus/pull/6472))
+- sealing: Fix restartSectors race ([filecoin-project/lotus#6491](https://github.com/filecoin-project/lotus/pull/6491))
+- Fund miners with the aggregate fee when ProveCommitting ([filecoin-project/lotus#6428](https://github.com/filecoin-project/lotus/pull/6428))
+- Commit and Precommit batcher cannot share a getSectorDeadline method ([filecoin-project/lotus#6416](https://github.com/filecoin-project/lotus/pull/6416))
+- Fix supported proof type manipulations for v5 actors ([filecoin-project/lotus#6366](https://github.com/filecoin-project/lotus/pull/6366))
+- events: Fix handling of multiple matched events per epoch ([filecoin-project/lotus#6362](https://github.com/filecoin-project/lotus/pull/6362))
+- Fix randomness fetching around null blocks ([filecoin-project/lotus#6240](https://github.com/filecoin-project/lotus/pull/6240))
+
+### Improvements
+- Appimage v1.10.0 rc3 ([filecoin-project/lotus#6492](https://github.com/filecoin-project/lotus/pull/6492))
+- Expand on Drand change testing ([filecoin-project/lotus#6500](https://github.com/filecoin-project/lotus/pull/6500))
+- Backport Fix logging around mineOne ([filecoin-project/lotus#6499](https://github.com/filecoin-project/lotus/pull/6499))
+- mpool: Add more metrics ([filecoin-project/lotus#6453](https://github.com/filecoin-project/lotus/pull/6453))
+- Merge backported PRs into v1.10 release branch ([filecoin-project/lotus#6436](https://github.com/filecoin-project/lotus/pull/6436))
+- Fix tests ([filecoin-project/lotus#6371](https://github.com/filecoin-project/lotus/pull/6371))
+- Extend the default deal start epoch delay ([filecoin-project/lotus#6350](https://github.com/filecoin-project/lotus/pull/6350))
+- sealing: Wire up context to batchers ([filecoin-project/lotus#6497](https://github.com/filecoin-project/lotus/pull/6497))
+- Improve address resolution for messages ([filecoin-project/lotus#6364](https://github.com/filecoin-project/lotus/pull/6364))
+
+### Dependency Updates
+- Proofs v8.0.2 ([filecoin-project/lotus#6524](https://github.com/filecoin-project/lotus/pull/6524))
+- Update to fixed Bellperson ([filecoin-project/lotus#6480](https://github.com/filecoin-project/lotus/pull/6480))
+- Update to go-praamfetch with fslocks ([filecoin-project/lotus#6473](https://github.com/filecoin-project/lotus/pull/6473))
+- Update ffi with fixed multicore sdr support ([filecoin-project/lotus#6471](https://github.com/filecoin-project/lotus/pull/6471))
+- github.com/filecoin-project/go-paramfetch (v0.0.2-0.20200701152213-3e0f0afdc261 -> v0.0.2-0.20210614165157-25a6c7769498)
+- github.com/filecoin-project/specs-actors/v5 (v5.0.0-20210512015452-4fe3889fff57 -> v5.0.0)
+- github.com/filecoin-project/go-hamt-ipld/v3 (v3.0.1 -> v3.1.0)
+- github.com/ipfs/go-log/v2 (v2.1.2-0.20200626104915-0016c0b4b3e4 -> v2.1.3)
+- github.com/filecoin-project/go-amt-ipld/v3 (v3.0.0 -> v3.1.0)
+
+### Network Version v13 HyperDrive Upgrade
+- Set HyperDrive upgrade epoch ([filecoin-project/lotus#6565](https://github.com/filecoin-project/lotus/pull/6565))
+- version bump to lotus v1.10.0-rc6 ([filecoin-project/lotus#6529](https://github.com/filecoin-project/lotus/pull/6529))
+- Upgrade epochs for calibration reset ([filecoin-project/lotus#6528](https://github.com/filecoin-project/lotus/pull/6528))
+- Lotus version 1.10.0-rc5 ([filecoin-project/lotus#6504](https://github.com/filecoin-project/lotus/pull/6504))
+- Merge releases into v1.10 release ([filecoin-project/lotus#6494](https://github.com/filecoin-project/lotus/pull/6494))
+- update lotus to v1.10.0-rc3 ([filecoin-project/lotus#6481](https://github.com/filecoin-project/lotus/pull/6481))
+- updated configuration comments for docs
+- Lotus version 1.10.0-rc2 ([filecoin-project/lotus#6443](https://github.com/filecoin-project/lotus/pull/6443))
+- Set ntwk v13 HyperDrive Calibration upgrade epoch ([filecoin-project/lotus#6442](https://github.com/filecoin-project/lotus/pull/6442))
+
+
+## Contributors
+
+💙Thank you to all the contributors!
+
+| Contributor        | Commits | Lines ±     | Files Changed |
+|--------------------|---------|-------------|---------------|
+| @magik6k    | 81      | +9606/-1536 | 361           |
+| @arajasek  | 41      | +6543/-679  | 189           |
+| @ZenGround0         | 11      | +4074/-727  | 110           |
+| @anorth                | 10      | +2035/-1177 | 55            |
+| @iand           | 1       | +779/-12    | 5             |
+| @frrist             | 2       | +722/-6     | 6             |
+| @Stebalien       | 6       | +368/-24    | 15            |
+| @jennijuju      | 11      | +204/-111   | 19            |
+| @vyzo               | 6       | +155/-66    | 13            |
+| @coryschwartz      | 10      | +171/-27    | 14            |
+| @Kubuxu    | 4       | +177/-13    | 7             |
+| @ribasushi    | 4       | +65/-42     | 5             |
+| @travisperson      | 2       | +11/-11     | 4             |
+| @kirk-baird | 1       | +1/-5       | 1             |
+| @wangchao           | 2       | +3/-2       | 2             |
+
 
 # 1.9.0 / 2021-05-17
 
@@ -71,143 +465,6 @@ This is an optional Lotus release that introduces various improvements to the se
 - fix health report (https://github.com/filecoin-project/lotus/pull/6011)
 - fix(ci): Use recent ubuntu LTS release; Update release params ((https://github.com/filecoin-project/lotus/pull/6011))
 
-# 1.9.0-rc4 / 2021-05-13
-
-This is an optional Lotus release that introduces various improvements to the sealing, mining, and deal-making processes.
-
-## Highlights
-
-- OpenRPC Support (https://github.com/filecoin-project/lotus/pull/5843)
-- Take latency into account when making interactive deals (https://github.com/filecoin-project/lotus/pull/5876)
-- Update go-commp-utils for >10x faster client commp calculation (https://github.com/filecoin-project/lotus/pull/5892)
-- add `lotus client cancel-retrieval` cmd to lotus CLI (https://github.com/filecoin-project/lotus/pull/5871)
-- add `inspect-deal` command to `lotus client` (https://github.com/filecoin-project/lotus/pull/5833)
-- Local retrieval support (https://github.com/filecoin-project/lotus/pull/5917)
-- go-fil-markets v1.1.9 -> v1.2.5
-  - For a detailed changelog see https://github.com/filecoin-project/go-fil-markets/blob/master/CHANGELOG.md
-- rust-fil-proofs v5.4.1 -> v7.0.1
-  - For a detailed changelog see https://github.com/filecoin-project/rust-fil-proofs/blob/master/CHANGELOG.md
-
-## Changes
-- storagefsm: Apply global events even in broken states (https://github.com/filecoin-project/lotus/pull/5962)
-- Default the AlwaysKeepUnsealedCopy flag to true (https://github.com/filecoin-project/lotus/pull/5743)
-- splitstore: compact hotstore prior to garbage collection (https://github.com/filecoin-project/lotus/pull/5778)
-- ipfs-force bootstrapper update (https://github.com/filecoin-project/lotus/pull/5799)
-- better logging when unsealing fails (https://github.com/filecoin-project/lotus/pull/5851)
-- perf: add cache for gas permium estimation (https://github.com/filecoin-project/lotus/pull/5709)
-- backupds: Compact log on restart (https://github.com/filecoin-project/lotus/pull/5875)
-- backupds: Improve truncated log handling (https://github.com/filecoin-project/lotus/pull/5891)
-- State CLI improvements (State CLI improvements)
-- API proxy struct codegen (https://github.com/filecoin-project/lotus/pull/5854)
-- move DI stuff for paychmgr into modules (https://github.com/filecoin-project/lotus/pull/5791)
-- Implement Event observer and Settings for 3rd party dep injection (https://github.com/filecoin-project/lotus/pull/5693)
-- Export developer and network commands for consumption by derivatives of Lotus (https://github.com/filecoin-project/lotus/pull/5864)
-- mock sealer: Simulate randomness sideeffects (https://github.com/filecoin-project/lotus/pull/5805)
-- localstorage: Demote reservation stat error to debug (https://github.com/filecoin-project/lotus/pull/5976)
-- shed command to unpack miner info dumps (https://github.com/filecoin-project/lotus/pull/5800)
-- Add two utils to Lotus-shed (https://github.com/filecoin-project/lotus/pull/5867)
-- add shed election estimate command  (https://github.com/filecoin-project/lotus/pull/5092)
-- Add --actor flag in lotus-shed sectors terminate (https://github.com/filecoin-project/lotus/pull/5819)
-- Move lotus mpool clear to lotus-shed (https://github.com/filecoin-project/lotus/pull/5900)
-- Centralize everything on ipfs/go-log/v2 (https://github.com/filecoin-project/lotus/pull/5974)
-- expose NextID from nice market actor interface (https://github.com/filecoin-project/lotus/pull/5850)
-- add available options for perm on error (https://github.com/filecoin-project/lotus/pull/5814)
-- API docs clarification: Document StateSearchMsg replaced message behavior (https://github.com/filecoin-project/lotus/pull/5838)
-- api: Document StateReplay replaced message behavior (https://github.com/filecoin-project/lotus/pull/5840)
-- add godocs to miner objects (https://github.com/filecoin-project/lotus/pull/2184)
-- Add description to the client deal CLI command (https://github.com/filecoin-project/lotus/pull/5999)
-- lint: don't skip builtin (https://github.com/filecoin-project/lotus/pull/5881)
-- use deal duration from actors (https://github.com/filecoin-project/lotus/pull/5270)
-- remote calc winningpost proof (https://github.com/filecoin-project/lotus/pull/5884)
-- packer: other network images (https://github.com/filecoin-project/lotus/pull/5930)
-- Convert the chainstore lock to RW (https://github.com/filecoin-project/lotus/pull/5971)
-- Remove CachedBlockstore (https://github.com/filecoin-project/lotus/pull/5972)
-- remove messagepool CapGasFee duplicate code (https://github.com/filecoin-project/lotus/pull/5992)
-- Add a mining-heartbeat INFO line at every epoch (https://github.com/filecoin-project/lotus/pull/6183)
-- chore(ci): Enable build on RC tags (https://github.com/filecoin-project/lotus/pull/6245)
-- Upgrade nerpa to actor v4 and bump the version to rc4 (https://github.com/filecoin-project/lotus/pull/6249)
-## Fixes
-- return buffers after canceling badger operation (https://github.com/filecoin-project/lotus/pull/5796)
-- avoid holding a lock while calling the View callback (https://github.com/filecoin-project/lotus/pull/5792)
-- storagefsm: Trigger input processing when below limits (https://github.com/filecoin-project/lotus/pull/5801)
-- After importing a previously deleted key, be able to delete it again (https://github.com/filecoin-project/lotus/pull/4653)
-- fix StateManager.Replay on reward actor (https://github.com/filecoin-project/lotus/pull/5804)
-- make sure atomic 64bit fields are 64bit aligned (https://github.com/filecoin-project/lotus/pull/5794)
-- Import secp sigs in paych tests (https://github.com/filecoin-project/lotus/pull/5879)
-- fix ci build-macos (https://github.com/filecoin-project/lotus/pull/5934)
-- Fix creation of remainder account when it's not a multisig (https://github.com/filecoin-project/lotus/pull/5807)
-- Fix fallback chainstore (https://github.com/filecoin-project/lotus/pull/6003)
-- fix 4857: show help for set-addrs (https://github.com/filecoin-project/lotus/pull/5943)
-- fix health report (https://github.com/filecoin-project/lotus/pull/6011)
-
-
-# 1.9.0-rc2 / 2021-04-30
-
-This is an optional Lotus release that introduces various improvements to the sealing, mining, and deal-making processes.
-
-## Highlights
-
-- OpenRPC Support (https://github.com/filecoin-project/lotus/pull/5843)
-- Take latency into account when making interactive deals (https://github.com/filecoin-project/lotus/pull/5876)
-- Update go-commp-utils for >10x faster client commp calculation (https://github.com/filecoin-project/lotus/pull/5892)
-- add `lotus client cancel-retrieval` cmd to lotus CLI (https://github.com/filecoin-project/lotus/pull/5871)
-- add `inspect-deal` command to `lotus client` (https://github.com/filecoin-project/lotus/pull/5833)
-- Local retrieval support (https://github.com/filecoin-project/lotus/pull/5917)
-- go-fil-markets v1.1.9 -> v1.2.5
-  - For a detailed changelog see https://github.com/filecoin-project/go-fil-markets/blob/master/CHANGELOG.md
-- rust-fil-proofs v5.4.1 -> v7
-  - For a detailed changelog see https://github.com/filecoin-project/rust-fil-proofs/blob/master/CHANGELOG.md
-
-## Changes
-- storagefsm: Apply global events even in broken states (https://github.com/filecoin-project/lotus/pull/5962)
-- Default the AlwaysKeepUnsealedCopy flag to true (https://github.com/filecoin-project/lotus/pull/5743)
-- splitstore: compact hotstore prior to garbage collection (https://github.com/filecoin-project/lotus/pull/5778)
-- ipfs-force bootstrapper update (https://github.com/filecoin-project/lotus/pull/5799)
-- better logging when unsealing fails (https://github.com/filecoin-project/lotus/pull/5851)
-- perf: add cache for gas permium estimation (https://github.com/filecoin-project/lotus/pull/5709)
-- backupds: Compact log on restart (https://github.com/filecoin-project/lotus/pull/5875)
-- backupds: Improve truncated log handling (https://github.com/filecoin-project/lotus/pull/5891)
-- State CLI improvements (State CLI improvements)
-- API proxy struct codegen (https://github.com/filecoin-project/lotus/pull/5854)
-- move DI stuff for paychmgr into modules (https://github.com/filecoin-project/lotus/pull/5791)
-- Implement Event observer and Settings for 3rd party dep injection (https://github.com/filecoin-project/lotus/pull/5693)
-- Export developer and network commands for consumption by derivatives of Lotus (https://github.com/filecoin-project/lotus/pull/5864)
-- mock sealer: Simulate randomness sideeffects (https://github.com/filecoin-project/lotus/pull/5805)
-- localstorage: Demote reservation stat error to debug (https://github.com/filecoin-project/lotus/pull/5976)
-- shed command to unpack miner info dumps (https://github.com/filecoin-project/lotus/pull/5800)
-- Add two utils to Lotus-shed (https://github.com/filecoin-project/lotus/pull/5867)
-- add shed election estimate command  (https://github.com/filecoin-project/lotus/pull/5092)
-- Add --actor flag in lotus-shed sectors terminate (https://github.com/filecoin-project/lotus/pull/5819)
-- Move lotus mpool clear to lotus-shed (https://github.com/filecoin-project/lotus/pull/5900)
-- Centralize everything on ipfs/go-log/v2 (https://github.com/filecoin-project/lotus/pull/5974)
-- expose NextID from nice market actor interface (https://github.com/filecoin-project/lotus/pull/5850)
-- add available options for perm on error (https://github.com/filecoin-project/lotus/pull/5814)
-- API docs clarification: Document StateSearchMsg replaced message behavior (https://github.com/filecoin-project/lotus/pull/5838)
-- api: Document StateReplay replaced message behavior (https://github.com/filecoin-project/lotus/pull/5840)
-- add godocs to miner objects (https://github.com/filecoin-project/lotus/pull/2184)
-- Add description to the client deal CLI command (https://github.com/filecoin-project/lotus/pull/5999)
-- lint: don't skip builtin (https://github.com/filecoin-project/lotus/pull/5881)
-- use deal duration from actors (https://github.com/filecoin-project/lotus/pull/5270)
-- remote calc winningpost proof (https://github.com/filecoin-project/lotus/pull/5884)
-- packer: other network images (https://github.com/filecoin-project/lotus/pull/5930)
-- Convert the chainstore lock to RW (https://github.com/filecoin-project/lotus/pull/5971)
-- Remove CachedBlockstore (https://github.com/filecoin-project/lotus/pull/5972)
-- remove messagepool CapGasFee duplicate code (https://github.com/filecoin-project/lotus/pull/5992)
-
-## Fixes
-- return buffers after canceling badger operation (https://github.com/filecoin-project/lotus/pull/5796)
-- avoid holding a lock while calling the View callback (https://github.com/filecoin-project/lotus/pull/5792)
-- storagefsm: Trigger input processing when below limits (https://github.com/filecoin-project/lotus/pull/5801)
-- After importing a previously deleted key, be able to delete it again (https://github.com/filecoin-project/lotus/pull/4653)
-- fix StateManager.Replay on reward actor (https://github.com/filecoin-project/lotus/pull/5804)
-- make sure atomic 64bit fields are 64bit aligned (https://github.com/filecoin-project/lotus/pull/5794)
-- Import secp sigs in paych tests (https://github.com/filecoin-project/lotus/pull/5879)
-- fix ci build-macos (https://github.com/filecoin-project/lotus/pull/5934)
-- Fix creation of remainder account when it's not a multisig (https://github.com/filecoin-project/lotus/pull/5807)
-- Fix fallback chainstore (https://github.com/filecoin-project/lotus/pull/6003)
-- fix 4857: show help for set-addrs (https://github.com/filecoin-project/lotus/pull/5943)
-- fix health report (https://github.com/filecoin-project/lotus/pull/6011)
-
 # 1.8.0 / 2021-04-05
 
 This is a mandatory release of Lotus that upgrades the network to version 12, which introduces various performance improvements to the cron processing of the power actor. The network will upgrade at height 712320, which is 2021-04-29T06:00:00Z.
@@ -228,7 +485,7 @@ This release also expands the `lotus-miner sectors extend` CLI, with a new optio
 
 - The `expiration-cutoff` flag can be passed to skip sectors whose expiration is past a certain point from the current head. It defaults to infinity (no cutoff), but if, say, 28800 was specified, then only sectors expiring in the next 10 days would be extended (2880 epochs in 1 day).
 
-## Changes 
+## Changes
 
 - Util for miners to extend all v1 sectors (https://github.com/filecoin-project/lotus/pull/5924)
 - Upgrade the butterfly network (https://github.com/filecoin-project/lotus/pull/5929)
@@ -239,7 +496,7 @@ This release also expands the `lotus-miner sectors extend` CLI, with a new optio
 
 This is a patch release of Lotus that introduces small fixes to the Storage FSM.
 
-## Changes 
+## Changes
 
 - storagefsm: Fix double unlock with ready WaitDeals sectors (https://github.com/filecoin-project/lotus/pull/5783)
 - backupds: Allow larger values in write log (https://github.com/filecoin-project/lotus/pull/5776)
@@ -255,7 +512,7 @@ This is an hotfix release of Lotus that fixes a critical bug introduced in v1.5.
 
 # 1.5.1 / 2021-03-10
 
-This is an optional release of Lotus that introduces an important fix to the WindowPoSt computation process. The change is to wait for some confidence before drawing beacon randomness for the proof. Without this, invalid proofs might be generated as the result of a null tipset. 
+This is an optional release of Lotus that introduces an important fix to the WindowPoSt computation process. The change is to wait for some confidence before drawing beacon randomness for the proof. Without this, invalid proofs might be generated as the result of a null tipset.
 
 ## Splitstore
 
@@ -348,7 +605,7 @@ FIP-0010 introduces the ability to dispute bad Window PoSts. Node operators are
 ## Changes
 
 - [#5341](https://github.com/filecoin-project/lotus/pull/5341)  Add a  `LOTUS_DISABLE_V3_ACTOR_MIGRATION` envvar
-    - Setting this envvar to 1 disables the v3 actor migration, should only be used in the event of a failed migration
+  - Setting this envvar to 1 disables the v3 actor migration, should only be used in the event of a failed migration
 
 # 1.4.2 / 2021-02-17
 
@@ -356,14 +613,14 @@ This is a large, and highly recommended, optional release with new features and
 
 - [FIP-0007 h/amt-v3](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0007.md) which improves the performance of the Filecoin HAMT and AMT.
 - [FIP-0010 off-chain Window PoSt Verification](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0010.md) which reduces the gas consumption of `SubmitWindowedPoSt` messages significantly by optimistically accepting Window PoSt proofs without verification, and allowing them to be disputed later by off-chain verifiers.
- 
+
 Note that this release does NOT set an upgrade epoch for v3 actors to take effect. That will be done in the upcoming 1.5.0 release.
- 
- ## New Features
- 
- - [#5341](https://github.com/filecoin-project/lotus/pull/5341)  Added sector termination API and CLI 
-     - Run `lotus-miner sectors terminate`
-- [#5342](https://github.com/filecoin-project/lotus/pull/5342) Added CLI for using a multisig wallet as miner's owner address 
+
+## New Features
+
+- [#5341](https://github.com/filecoin-project/lotus/pull/5341)  Added sector termination API and CLI
+  - Run `lotus-miner sectors terminate`
+- [#5342](https://github.com/filecoin-project/lotus/pull/5342) Added CLI for using a multisig wallet as miner's owner address
   - See how to set it up [here](https://github.com/filecoin-project/lotus/pull/5342#issue-554009129)
 - [#5363](https://github.com/filecoin-project/lotus/pull/5363), [#5418](https://github.com/filecoin-project/lotus/pull/), [#5476](https://github.com/filecoin-project/lotus/pull/5476), [#5459](https://github.com/filecoin-project/lotus/pull/5459) Integrated [spec-actor v3](https://github.com/filecoin-pro5418ject/specs-actors/releases/tag/v3.0.0)
   - [#5472](https://github.com/filecoin-project/lotus/pull/5472) Generate actor v3 methods for pond
@@ -374,7 +631,7 @@ Note that this release does NOT set an upgrade epoch for v3 actors to take effec
   - [#5411](https://github.com/filecoin-project/lotus/pull/5411) Handle batch `PublishStorageDeals` message in sealing recovery
   - [#5505](https://github.com/filecoin-project/lotus/pull/5505) Exclude expired deals from batching in `PublishStorageDeals` messages
   - Added `PublishMsgPeriod` and `MaxDealsPerPublishMsg` to miner `Dealmaking` [configuration](https://docs.filecoin.io/mine/lotus/miner-configuration/#dealmaking-section). See how they work [here](https://docs.filecoin.io/mine/lotus/miner-configuration/#publishing-several-deals-in-one-message).
-  - [#5538](https://github.com/filecoin-project/lotus/pull/5538), [#5549](https://github.com/filecoin-project/lotus/pull/5549) Added a command to list pending deals and force publish messages. 
+  - [#5538](https://github.com/filecoin-project/lotus/pull/5538), [#5549](https://github.com/filecoin-project/lotus/pull/5549) Added a command to list pending deals and force publish messages.
     - Run `lotus-miner market pending-publish`
   - [#5428](https://github.com/filecoin-project/lotus/pull/5428) Moved waiting for `PublishStorageDeals` messages' receipt from markets to lotus
 - [#5510](https://github.com/filecoin-project/lotus/pull/5510) Added `nerpanet` build option
@@ -384,32 +641,32 @@ Note that this release does NOT set an upgrade epoch for v3 actors to take effec
 - [#5219](https://github.com/filecoin-project/lotus/pull/5219) Added interactive mode for lotus-wallet
 - [5529](https://github.com/filecoin-project/lotus/pull/5529) Added support for minder nodes in `lotus-shed rpc` util
 
- ## Bug Fixes
- 
- - [#5210](https://github.com/filecoin-project/lotus/pull/5210) Miner should not dial client on restart
- - [#5403](https://github.com/filecoin-project/lotus/pull/5403) When estimating GasLimit only apply prior messages up to the nonce
- - [#5410](https://github.com/filecoin-project/lotus/pull/510) Fix the calibnet build option
- - [#5492](https://github.com/filecoin-project/lotus/pull/5492) Fixed `has` for ipfsbstore for non-existing blocks
- - [#5361](https://github.com/filecoin-project/lotus/pull/5361) Fixed retrieval hangs when using `IpfsOnlineMode=true`
- - [#5493](https://github.com/filecoin-project/lotus/pull/5493) Fixed retrieval failure when price-per-byte is zero
- - [#5506](https://github.com/filecoin-project/lotus/pull/5506) Fixed contexts in the storage adpater
- - [#5515](https://github.com/filecoin-project/lotus/pull/5515) Properly wire up `StateReadState` on gateway API
- - [#5582](https://github.com/filecoin-project/lotus/pull/5582) Fixed error logging format strings
- - [#5614](https://github.com/filecoin-project/lotus/pull/5614) Fixed websocket reconnecting handling
+## Bug Fixes
+
+- [#5210](https://github.com/filecoin-project/lotus/pull/5210) Miner should not dial client on restart
+- [#5403](https://github.com/filecoin-project/lotus/pull/5403) When estimating GasLimit only apply prior messages up to the nonce
+- [#5410](https://github.com/filecoin-project/lotus/pull/510) Fix the calibnet build option
+- [#5492](https://github.com/filecoin-project/lotus/pull/5492) Fixed `has` for ipfsbstore for non-existing blocks
+- [#5361](https://github.com/filecoin-project/lotus/pull/5361) Fixed retrieval hangs when using `IpfsOnlineMode=true`
+- [#5493](https://github.com/filecoin-project/lotus/pull/5493) Fixed retrieval failure when price-per-byte is zero
+- [#5506](https://github.com/filecoin-project/lotus/pull/5506) Fixed contexts in the storage adpater
+- [#5515](https://github.com/filecoin-project/lotus/pull/5515) Properly wire up `StateReadState` on gateway API
+- [#5582](https://github.com/filecoin-project/lotus/pull/5582) Fixed error logging format strings
+- [#5614](https://github.com/filecoin-project/lotus/pull/5614) Fixed websocket reconnecting handling
 
 
- ## Improvements
- 
- - [#5389](https://github.com/filecoin-project/lotus/pull/5389) Show verified indicator for `./lotus-miner storage-deals list`  
+## Improvements
+
+- [#5389](https://github.com/filecoin-project/lotus/pull/5389) Show verified indicator for `./lotus-miner storage-deals list`
 - [#5229](https://github.com/filecoin-project/lotus/pull/5220) Show power for verified deals in `./lotus-miner setocr list`
 - [#5407](https://github.com/filecoin-project/lotus/pull/5407) Added explicit check of the miner address protocol
- - [#5399](https://github.com/filecoin-project/lotus/pull/5399) watchdog: increase heapprof capture threshold to 90%
- - [#5398](https://github.com/filecoin-project/lotus/pull/5398) storageadapter: Look at precommits on-chain since deal publish msg
- - [#5470](https://github.com/filecoin-project/lotus/pull/5470) Added `--no-timing` option for `./lotus state compute-state --html`
+- [#5399](https://github.com/filecoin-project/lotus/pull/5399) watchdog: increase heapprof capture threshold to 90%
+- [#5398](https://github.com/filecoin-project/lotus/pull/5398) storageadapter: Look at precommits on-chain since deal publish msg
+- [#5470](https://github.com/filecoin-project/lotus/pull/5470) Added `--no-timing` option for `./lotus state compute-state --html`
 - [#5417](https://github.com/filecoin-project/lotus/pull/5417) Storage Manager: Always unseal full sectors
 - [#5393](https://github.com/filecoin-project/lotus/pull/5393) Switched to [filecoin-ffi bls api ](https://github.com/filecoin-project/filecoin-ffi/pull/159)for bls signatures
-- [#5380](https://github.com/filecoin-project/lotus/pull/5210) Refactor deals API tests 
-- [#5397](https://github.com/filecoin-project/lotus/pull/5397) Fixed a flake in the sync manager edge case test 
+- [#5380](https://github.com/filecoin-project/lotus/pull/5210) Refactor deals API tests
+- [#5397](https://github.com/filecoin-project/lotus/pull/5397) Fixed a flake in the sync manager edge case test
 - [#5406](https://github.com/filecoin-project/lotus/pull/5406) Added a test to ensure a correct window post cannot be disputed
 - [#5294](https://github.com/filecoin-project/lotus/pull/5394) Added jobs to build Lotus docker image and push it to AWS ECR
 - [#5387](https://github.com/filecoin-project/lotus/pull/5387) Added network info(mainnet|calibnet) in version
@@ -418,7 +675,7 @@ Note that this release does NOT set an upgrade epoch for v3 actors to take effec
 - [#5047](https://github.com/filecoin-project/lotus/pull/5047) Improved the UX for `./lotus-shed bitfield enc`
 - [#5282](https://github.com/filecoin-project/lotus/pull/5282) Snake a context through the chian blockstore creation
 - [#5350](https://github.com/filecoin-project/lotus/pull/5350) Avoid using `mp.cfg` directrly to prevent race condition
-- [#5449](https://github.com/filecoin-project/lotus/pull/5449) Documented the block-header better 
+- [#5449](https://github.com/filecoin-project/lotus/pull/5449) Documented the block-header better
 - [#5404](https://github.com/filecoin-project/lotus/pull/5404) Added retrying proofs if an incorrect one is generated
 - [#4545](https://github.com/filecoin-project/lotus/pull/4545) Made state tipset usage consistent in the API
 - [#5540](https://github.com/filecoin-project/lotus/pull/5540) Removed unnecessary database reads in validation check
@@ -435,14 +692,14 @@ Note that this release does NOT set an upgrade epoch for v3 actors to take effec
 - [#5592](https://github.com/filecoin-project/lotus/pull/5592) Verify FFI version before building
 
 ## Dependency Updates
- - [#5296](https://github.com/filecoin-project/lotus/pull/5396) Upgraded to [raulk/go-watchdog@v1.0.1](https://github.com/raulk/go-watchdog/releases/tag/v1.0.1)
- - [#5450](https://github.com/filecoin-project/lotus/pull/5450) Dependency updates
- - [#5425](https://github.com/filecoin-project/lotus/pull/5425) Fixed stale imports in testplans/lotus-soup
- - [#5535](https://github.com/filecoin-project/lotus/pull/5535) Updated to [go-fil-markets@v1.1.7](https://github.com/filecoin-project/go-fil-markets/releases/tag/v1.1.7)
- - [#5616](https://github.com/filecoin-project/lotus/pull/5600) Updated to [filecoin-ffi@b6e0b35fb49ed0fe](https://github.com/filecoin-project/filecoin-ffi/releases/tag/b6e0b35fb49ed0fe)
- - [#5599](https://github.com/filecoin-project/lotus/pull/5599) Updated to [go-bitfield@v0.2.4](https://github.com/filecoin-project/go-bitfield/releases/tag/v0.2.4)
- - [#5614](https://github.com/filecoin-project/lotus/pull/5614), , [#5621](https://github.com/filecoin-project/lotus/pull/5621) Updated to [go-jsonrpc@v0.1.3](https://github.com/filecoin-project/go-jsonrpc/releases/tag/v0.1.3)
- - [#5459](https://github.com/filecoin-project/lotus/pull/5459) Updated to [spec-actors@v3.0.1](https://github.com/filecoin-project/specs-actors/releases/tag/v3.0.1)
+- [#5296](https://github.com/filecoin-project/lotus/pull/5396) Upgraded to [raulk/go-watchdog@v1.0.1](https://github.com/raulk/go-watchdog/releases/tag/v1.0.1)
+- [#5450](https://github.com/filecoin-project/lotus/pull/5450) Dependency updates
+- [#5425](https://github.com/filecoin-project/lotus/pull/5425) Fixed stale imports in testplans/lotus-soup
+- [#5535](https://github.com/filecoin-project/lotus/pull/5535) Updated to [go-fil-markets@v1.1.7](https://github.com/filecoin-project/go-fil-markets/releases/tag/v1.1.7)
+- [#5616](https://github.com/filecoin-project/lotus/pull/5600) Updated to [filecoin-ffi@b6e0b35fb49ed0fe](https://github.com/filecoin-project/filecoin-ffi/releases/tag/b6e0b35fb49ed0fe)
+- [#5599](https://github.com/filecoin-project/lotus/pull/5599) Updated to [go-bitfield@v0.2.4](https://github.com/filecoin-project/go-bitfield/releases/tag/v0.2.4)
+- [#5614](https://github.com/filecoin-project/lotus/pull/5614), , [#5621](https://github.com/filecoin-project/lotus/pull/5621) Updated to [go-jsonrpc@v0.1.3](https://github.com/filecoin-project/go-jsonrpc/releases/tag/v0.1.3)
+- [#5459](https://github.com/filecoin-project/lotus/pull/5459) Updated to [spec-actors@v3.0.1](https://github.com/filecoin-project/specs-actors/releases/tag/v3.0.1)
 
 
 ## Network Version v10 Upgrade
@@ -450,7 +707,7 @@ Note that this release does NOT set an upgrade epoch for v3 actors to take effec
 - [#5603](https://github.com/filecoin-project/lotus/pull/5603) Set nerpanet's upgrade epochs up to v3 actors
 - [#5471](https://github.com/filecoin-project/lotus/pull/5471), [#5456](https://github.com/filecoin-project/lotus/pull/5456) Set calibration net actor v3 migration epochs for testing
 - [#5434](https://github.com/filecoin-project/lotus/pull/5434) Implemented pre-migration framework
-- [#5476](https://github.com/filecoin-project/lotus/pull/5477) Tune migration 
+- [#5476](https://github.com/filecoin-project/lotus/pull/5477) Tune migration
 
 # 1.4.1 / 2021-01-20
 
@@ -649,9 +906,9 @@ This is an optional Lotus release that introduces various improvements to the mi
 - Error out deals that are not activated by proposed deal start epoch (https://github.com/filecoin-project/lotus/pull/5061)
 
 # 1.2.1 / 2020-11-20
-          
+
 This is a very small release of Lotus that fixes an issue users are experiencing when importing snapshots. There is no need to upgrade unless you experience an issue with creating a new datastore directory in the Lotus repo.
-          
+
 ## Changes
 
 - fix blockstore directory not created automatically (https://github.com/filecoin-project/lotus/pull/4922)
@@ -671,7 +928,7 @@ The changes that break consensus are:
 - Correction of the VM circulating supply calculation (https://github.com/filecoin-project/lotus/pull/4862)
 - Retuning gas costs (https://github.com/filecoin-project/lotus/pull/4830)
 - Avoid sending messages to the zero BLS address (https://github.com/filecoin-project/lotus/pull/4888)
-                                     
+
 ## Other Changes
 
 - delayed pubsub subscribe for messages topic (https://github.com/filecoin-project/lotus/pull/3646)
@@ -828,7 +1085,7 @@ This is an optional release of Lotus that upgrades Lotus dependencies, and inclu
 
 This is a patch release of Lotus that builds on the fixes involving worker keys that was introduced in v1.1.1. Miners and node operators should update to this release as soon as possible in order to ensure their blocks are propagated and validated.
 
-## Changes 
+## Changes
 
 - Handle worker key changes correctly in runtime (https://github.com/filecoin-project/lotus/pull/4579)
 
@@ -1071,7 +1328,7 @@ This consensus-breaking release of Lotus upgrades the actors version to v2.0.0.
 - Fix pond (https://github.com/filecoin-project/lotus/pull/4203)
 - allow manual setting of noncefix fee cap (https://github.com/filecoin-project/lotus/pull/4205)
 - implement command to get execution traces of any message (https://github.com/filecoin-project/lotus/pull/4200)
-- conformance: minor driver refactors (https://github.com/filecoin-project/lotus/pull/4211) 
+- conformance: minor driver refactors (https://github.com/filecoin-project/lotus/pull/4211)
 - lotus-pcr: ignore all other messages (https://github.com/filecoin-project/lotus/pull/4218)
 - lotus-pcr: zero refund (https://github.com/filecoin-project/lotus/pull/4229)
 
@@ -1098,7 +1355,7 @@ We are grateful for every contribution!
 
 This optional release of Lotus introduces a new version of markets which switches to CBOR-map encodings, and allows datastore migrations. The release also introduces several improvements to the mining process, a few performance optimizations, and a battery of UX additions and enhancements.
 
-## Changes 
+## Changes
 
 #### Dependencies
 
@@ -1169,7 +1426,7 @@ This consensus-breaking release of Lotus introduces an upgrade to the network. T
 
 This release also updates go-fil-markets to fix an incompatibility issue between v0.7.2 and earlier versions.
 
-## Changes 
+## Changes
 
 #### Dependencies
 
@@ -1258,7 +1515,7 @@ This optional release of Lotus introduces some critical fixes to the window PoSt
 
 ## Changes
 
-#### Some notable improvements: 
+#### Some notable improvements:
 
 - Correctly construct params for `SubmitWindowedPoSt` messages (https://github.com/filecoin-project/lotus/pull/3909)
 - Skip sectors correctly for Window PoSt (https://github.com/filecoin-project/lotus/pull/3839)
@@ -1294,7 +1551,7 @@ This consensus-breaking release of Lotus is designed to test a network upgrade o
 - Drand upgrade (https://github.com/filecoin-project/lotus/pull/3670)
 - Multisig API additions (https://github.com/filecoin-project/lotus/pull/3590)
 
-#### Storage Miner 
+#### Storage Miner
 
 - Increase the number of times precommit2 is attempted before moving back to precommit1 (https://github.com/filecoin-project/lotus/pull/3720)
 
@@ -1337,7 +1594,7 @@ This release introduces some critical fixes to message selection and gas estimat
 
 ## Changes
 
-#### Messagepool 
+#### Messagepool
 
 - Warn when optimal selection fails to pack a block and we fall back to random selection (https://github.com/filecoin-project/lotus/pull/3708)
 - Add basic command for printing gas performance of messages in the mpool (https://github.com/filecoin-project/lotus/pull/3701)
@@ -1407,7 +1664,7 @@ This release also introduces many improvements to Lotus! Among them are a new ve
 - Add additional info about gas premium (https://github.com/filecoin-project/lotus/pull/3578)
 - Fix GasPremium capping logic  (https://github.com/filecoin-project/lotus/pull/3552)
 
-#### Payment channels 
+#### Payment channels
 
 - Get available funds by address or by from/to (https://github.com/filecoin-project/lotus/pull/3547)
 - Create `lotus paych status` command (https://github.com/filecoin-project/lotus/pull/3523)
@@ -1457,7 +1714,7 @@ This patch includes a crucial fix to the message pool selection logic, strongly
 
 This patch includes a hotfix to the `GasEstimateFeeCap` method, capping the estimated fee to a reasonable level by default.
 
-## Changes 
+## Changes
 
 - Added target height to sync wait (https://github.com/filecoin-project/lotus/pull/3502)
 - Disable codecov annotations (https://github.com/filecoin-project/lotus/pull/3514)
@@ -1487,7 +1744,7 @@ This patch includes some bugfixes to the sector sealing process, and updates go-
 
 # 0.5.7 / 2020-08-31
 
-This patch release includes some bugfixes and enhancements to the sector lifecycle and message pool logic. 
+This patch release includes some bugfixes and enhancements to the sector lifecycle and message pool logic.
 
 ## Changes
 
@@ -1507,7 +1764,7 @@ Hotfix release that fixes a panic in the sealing scheduler (https://github.com/f
 # 0.5.5
 
 This patch release introduces a large number of improvements to the sealing process.
-It also updates go-fil-markets to 
+It also updates go-fil-markets to
 [version 0.5.8](https://github.com/filecoin-project/go-fil-markets/releases/tag/v0.5.8),
 and go-libp2p-pubsub to [v0.3.5](https://github.com/libp2p/go-libp2p-pubsub/releases/tag/v0.3.5).
 
@@ -1520,16 +1777,16 @@ and go-libp2p-pubsub to [v0.3.5](https://github.com/libp2p/go-libp2p-pubsub/rele
 
 - The following improvements were introduced in https://github.com/filecoin-project/lotus/pull/3350.
 
-    - Allow `lotus-miner sectors remove` to remove a sector in any state.
-    - Create a separate state in the storage FSM dedicated to submitting the Commit message.
-    - Recovery for when the Deal IDs of deals in a sector get changed in a reorg.
-    - Auto-retry sending Precommit and Commit messages if they run out of gas
-    - Auto-retry sector remove tasks when they fail
-    - Compact worker windows, and allow their tasks to be executed in any order
+  - Allow `lotus-miner sectors remove` to remove a sector in any state.
+  - Create a separate state in the storage FSM dedicated to submitting the Commit message.
+  - Recovery for when the Deal IDs of deals in a sector get changed in a reorg.
+  - Auto-retry sending Precommit and Commit messages if they run out of gas
+  - Auto-retry sector remove tasks when they fail
+  - Compact worker windows, and allow their tasks to be executed in any order
 
 - Don't simply skip PoSt for bad sectors (https://github.com/filecoin-project/lotus/pull/3323)
 
-#### Message Pool 
+#### Message Pool
 
 - Spam Protection: Track required funds for pending messages (https://github.com/filecoin-project/lotus/pull/3313)
 
@@ -1554,7 +1811,7 @@ A patch release, containing a few nice bugfixes and improvements:
 
 # 0.5.3
 
-Yet another hotfix release. 
+Yet another hotfix release.
 A lesson for readers, having people who have been awake for 12+ hours review
 your hotfix PR is not a good idea. Find someone who has enough slept recently
 enough to give you good code review, otherwise you'll end up quickly bumping
@@ -1573,9 +1830,9 @@ This is a hotfix release.
 
 # 0.5.1 / 2020-08-24
 
-The Space Race release! 
+The Space Race release!
 This release contains the genesis car file and bootstrap peers for the space
-race network. 
+race network.
 
 Additionally, we included two small fixes to genesis creation:
 - Randomize ticket value in genesis generation
@@ -1593,9 +1850,9 @@ Among the highlights included in this release are:
 
 - Gas changes: We implemented EIP-1559 and introduced real gas values.
 - Deal-making: We now support "Committed Capacity" sectors, "fast-retrieval" deals,
-and the packing of multiple deals into a single sector.
+  and the packing of multiple deals into a single sector.
 - Renamed features: We renamed some of the binaries, environment variables, and default
-paths associated with a Lotus node.
+  paths associated with a Lotus node.
 
 ### Gas changes
 
@@ -1603,19 +1860,19 @@ We made some significant changes to the mechanics of gas in this release.
 
 #### Network fee
 
-We implemented something similar to 
+We implemented something similar to
 [Ethereum's EIP-1559](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md).
 The `Message` structure had three changes:
 - The `GasPrice` field has been removed
 - A new `GasFeeCap` field has been added, which controls the maximum cost
-the sender incurs for the message
+  the sender incurs for the message
 - A new `GasPremium` field has been added, which controls the reward a miner
-earns for including the message
+  earns for including the message
 
-A sender will never be charged more than `GasFeeCap * GasLimit`. 
+A sender will never be charged more than `GasFeeCap * GasLimit`.
 A miner will typically earn `GasPremium * GasLimit` as a reward.
 
-The `Blockheader` structure has one new field, called `ParentBaseFee`. 
+The `Blockheader` structure has one new field, called `ParentBaseFee`.
 Informally speaking,the `ParentBaseFee`
 is increased when blocks are densely packed with messages, and decreased otherwise.
 

Dockerfile.lotus

@@ -1,4 +1,4 @@
-FROM golang:1.15.6 AS builder-deps
+FROM golang:1.16.4 AS builder-deps
 MAINTAINER Lotus Development Team
 
 RUN apt-get update && apt-get install -y ca-certificates build-essential clang ocl-icd-opencl-dev ocl-icd-libopencl1 jq libhwloc-dev

Makefile

@@ -6,9 +6,9 @@ all: build
 unexport GOFLAGS
 
 GOVERSION:=$(shell go version | cut -d' ' -f 3 | sed 's/^go//' | awk -F. '{printf "%d%03d%03d", $$1, $$2, $$3}')
-ifeq ($(shell expr $(GOVERSION) \< 1015005), 1)
+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 1.15.5)
+$(error Update Golang to version to at least 1.16.0)
 endif
 
 # git modules that need to be loaded
@@ -42,12 +42,11 @@ BUILD_DEPS+=build/.filecoin-install
 CLEAN+=build/.filecoin-install
 
 ffi-version-check:
-	@[[ "$$(awk '/const Version/{print $$5}' extern/filecoin-ffi/version.go)" -eq 2 ]] || (echo "FFI version mismatch, update submodules"; exit 1)
+	@[[ "$$(awk '/const Version/{print $$5}' extern/filecoin-ffi/version.go)" -eq 3 ]] || (echo "FFI version mismatch, update submodules"; exit 1)
 BUILD_DEPS+=ffi-version-check
 
 .PHONY: ffi-version-check
 
-
 $(MODULES): build/.update-modules ;
 # dummy file that marks the last time modules were updated
 build/.update-modules:
@@ -81,10 +80,12 @@ nerpanet: build-devnets
 butterflynet: GOFLAGS+=-tags=butterflynet
 butterflynet: build-devnets
 
+interopnet: GOFLAGS+=-tags=interopnet
+interopnet: build-devnets
+
 lotus: $(BUILD_DEPS)
 	rm -f lotus
 	go build $(GOFLAGS) -o lotus ./cmd/lotus
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus -i ./build
 
 .PHONY: lotus
 BINS+=lotus
@@ -92,21 +93,18 @@ BINS+=lotus
 lotus-miner: $(BUILD_DEPS)
 	rm -f lotus-miner
 	go build $(GOFLAGS) -o lotus-miner ./cmd/lotus-storage-miner
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-miner -i ./build
 .PHONY: lotus-miner
 BINS+=lotus-miner
 
 lotus-worker: $(BUILD_DEPS)
 	rm -f lotus-worker
 	go build $(GOFLAGS) -o lotus-worker ./cmd/lotus-seal-worker
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-worker -i ./build
 .PHONY: lotus-worker
 BINS+=lotus-worker
 
 lotus-shed: $(BUILD_DEPS)
 	rm -f lotus-shed
 	go build $(GOFLAGS) -o lotus-shed ./cmd/lotus-shed
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-shed -i ./build
 .PHONY: lotus-shed
 BINS+=lotus-shed
 
@@ -138,7 +136,6 @@ install-worker:
 lotus-seed: $(BUILD_DEPS)
 	rm -f lotus-seed
 	go build $(GOFLAGS) -o lotus-seed ./cmd/lotus-seed
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-seed -i ./build
 
 .PHONY: lotus-seed
 BINS+=lotus-seed
@@ -172,13 +169,11 @@ lotus-townhall-front:
 .PHONY: lotus-townhall-front
 
 lotus-townhall-app: lotus-touch lotus-townhall-front
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-townhall -i ./cmd/lotus-townhall -i ./build
 .PHONY: lotus-townhall-app
 
 lotus-fountain:
 	rm -f lotus-fountain
 	go build -o lotus-fountain ./cmd/lotus-fountain
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-fountain -i ./cmd/lotus-fountain -i ./build
 .PHONY: lotus-fountain
 BINS+=lotus-fountain
 
@@ -191,28 +186,24 @@ BINS+=lotus-chainwatch
 lotus-bench:
 	rm -f lotus-bench
 	go build -o lotus-bench ./cmd/lotus-bench
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-bench -i ./build
 .PHONY: lotus-bench
 BINS+=lotus-bench
 
 lotus-stats:
 	rm -f lotus-stats
 	go build $(GOFLAGS) -o lotus-stats ./cmd/lotus-stats
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-stats -i ./build
 .PHONY: lotus-stats
 BINS+=lotus-stats
 
 lotus-pcr:
 	rm -f lotus-pcr
 	go build $(GOFLAGS) -o lotus-pcr ./cmd/lotus-pcr
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-pcr -i ./build
 .PHONY: lotus-pcr
 BINS+=lotus-pcr
 
 lotus-health:
 	rm -f lotus-health
 	go build -o lotus-health ./cmd/lotus-health
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-health -i ./build
 .PHONY: lotus-health
 BINS+=lotus-health
 
@@ -243,6 +234,12 @@ BINS+=tvx
 install-chainwatch: lotus-chainwatch
 	install -C ./lotus-chainwatch /usr/local/bin/lotus-chainwatch
 
+lotus-sim: $(BUILD_DEPS)
+	rm -f lotus-sim
+	go build $(GOFLAGS) -o lotus-sim ./cmd/lotus-sim
+.PHONY: lotus-sim
+BINS+=lotus-sim
+
 # SYSTEMD
 
 install-daemon-service: install-daemon
@@ -303,17 +300,10 @@ clean-services: clean-all-services
 
 buildall: $(BINS)
 
-completions:
-	./scripts/make-completions.sh lotus
-	./scripts/make-completions.sh lotus-miner
-.PHONY: completions
-
 install-completions:
 	mkdir -p /usr/share/bash-completion/completions /usr/local/share/zsh/site-functions/
 	install -C ./scripts/bash-completion/lotus /usr/share/bash-completion/completions/lotus
-	install -C ./scripts/bash-completion/lotus-miner /usr/share/bash-completion/completions/lotus-miner
 	install -C ./scripts/zsh-completion/lotus /usr/local/share/zsh/site-functions/_lotus
-	install -C ./scripts/zsh-completion/lotus-miner /usr/local/share/zsh/site-functions/_lotus-miner
 
 clean:
 	rm -rf $(CLEAN) $(BINS)
@@ -333,17 +323,30 @@ type-gen: api-gen
 method-gen: api-gen
 	(cd ./lotuspond/front/src/chain && go run ./methodgen.go)
 
+actors-gen:
+	go run ./chain/actors/agen
+	go fmt ./...
+
 api-gen:
 	go run ./gen/api
 	goimports -w api
 	goimports -w api
 .PHONY: api-gen
 
+appimage: lotus
+	rm -rf appimage-builder-cache || true
+	rm AppDir/io.filecoin.lotus.desktop || true
+	rm AppDir/icon.svg || true
+	rm Appdir/AppRun || true
+	mkdir -p AppDir/usr/bin
+	cp ./lotus AppDir/usr/bin/
+	appimage-builder
+
 docsgen: docsgen-md docsgen-openrpc
 
-docsgen-md-bin: api-gen
+docsgen-md-bin: api-gen actors-gen
 	go build $(GOFLAGS) -o docgen-md ./api/docgen/cmd
-docsgen-openrpc-bin: api-gen
+docsgen-openrpc-bin: api-gen actors-gen
 	go build $(GOFLAGS) -o docgen-openrpc ./api/docgen-openrpc/cmd
 
 docsgen-md: docsgen-md-full docsgen-md-storage docsgen-md-worker
@@ -367,8 +370,21 @@ docsgen-openrpc-worker: docsgen-openrpc-bin
 
 .PHONY: docsgen docsgen-md-bin docsgen-openrpc-bin
 
-gen: type-gen method-gen docsgen api-gen
+gen: actors-gen type-gen method-gen docsgen api-gen circleci
+	@echo ">>> IF YOU'VE MODIFIED THE CLI, REMEMBER TO ALSO MAKE docsgen-cli"
 .PHONY: gen
 
+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
+	python ./scripts/generate-lotus-cli.py
+.PHONY: docsgen-cli
+
 print-%:
 	@echo $*=$($*)
+
+circleci:
+	go generate -x ./.circleci

README.md

@@ -10,7 +10,7 @@
   <a href="https://circleci.com/gh/filecoin-project/lotus"><img src="https://circleci.com/gh/filecoin-project/lotus.svg?style=svg"></a>
   <a href="https://codecov.io/gh/filecoin-project/lotus"><img src="https://codecov.io/gh/filecoin-project/lotus/branch/master/graph/badge.svg"></a>
   <a href="https://goreportcard.com/report/github.com/filecoin-project/lotus"><img src="https://goreportcard.com/badge/github.com/filecoin-project/lotus" /></a>  
-  <a href=""><img src="https://img.shields.io/badge/golang-%3E%3D1.15.5-blue.svg" /></a>
+  <a href=""><img src="https://img.shields.io/badge/golang-%3E%3D1.16-blue.svg" /></a>
   <br>
 </p>
 
@@ -18,7 +18,7 @@ Lotus is an implementation of the Filecoin Distributed Storage Network. For more
 
 ## Building & Documentation
 
-For 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/).
+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
 
@@ -50,6 +50,88 @@ When implementing a change:
 7. Title the PR in a meaningful way and describe the rationale and the thought process in the PR description.
 8. Write clean, thoughtful, and detailed [commit messages](https://chris.beams.io/posts/git-commit/). This is even more important than the PR description, because commit messages are stored _inside_ the Git history. One good rule is: if you are happy posting the commit message as the PR description, then it's a good commit message.
 
+## Basic Build Instructions
+**System-specific Software Dependencies**:
+
+Building Lotus requires some system dependencies, usually provided by your distribution.
+
+Ubuntu/Debian:
+```
+sudo apt install mesa-opencl-icd ocl-icd-opencl-dev gcc git bzr jq pkg-config curl clang build-essential hwloc libhwloc-dev wget -y && sudo apt upgrade -y
+```
+
+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 libhwloc-dev
+```
+
+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.16.4 or higher](https://golang.org/dl/):
+
+```bash
+wget -c https://golang.org/dl/go1.16.4.linux-amd64.tar.gz -O - | sudo tar -xz -C /usr/local
+```
+
+**TIP:**
+You'll need to add `/usr/local/go/bin` to your path. For most Linux distributions you can run something like:
+
+```shell
+echo "export PATH=$PATH:/usr/local/go/bin" >> ~/.bashrc && source ~/.bashrc
+```
+
+See the [official Golang installation instructions](https://golang.org/doc/install) if you get stuck.
+
+### Build and install Lotus
+
+Once all the dependencies are installed, you can build and install the Lotus suite (`lotus`, `lotus-miner`, and `lotus-worker`).
+
+1. Clone the repository:
+
+   ```sh
+   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://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.
+
+   ```sh
+   git checkout <tag_or_branch>
+   # For example:
+   git checkout <vX.X.X> # tag for a release
+   ```
+
+   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://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:
+
+   ```sh
+   make clean all #mainnet
+
+   # Or to join a testnet or devnet:
+   make clean calibnet # Calibration with min 32GiB sectors
+   make clean nerpanet # Nerpa with min 512MiB sectors
+
+   sudo make install
+   ```
+
+   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://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://docs.filecoin.io/get-started/lotus/installation/#start-the-lotus-daemon-and-sync-the-chain).
+
 ## License
 
 Dual-licensed under [MIT](https://github.com/filecoin-project/lotus/blob/master/LICENSE-MIT) + [Apache 2.0](https://github.com/filecoin-project/lotus/blob/master/LICENSE-APACHE)

api/api_full.go

@@ -252,6 +252,13 @@ type FullNode interface {
 	// MpoolBatchPushMessage batch pushes a unsigned message to mempool.
 	MpoolBatchPushMessage(context.Context, []*types.Message, *MessageSendSpec) ([]*types.SignedMessage, error) //perm:sign
 
+	// MpoolCheckMessages performs logical checks on a batch of messages
+	MpoolCheckMessages(context.Context, []*MessagePrototype) ([][]MessageCheckStatus, error) //perm:read
+	// MpoolCheckPendingMessages performs logical checks for all pending messages from a given address
+	MpoolCheckPendingMessages(context.Context, address.Address) ([][]MessageCheckStatus, error) //perm:read
+	// MpoolCheckReplaceMessages performs logical checks on pending messages with replacement
+	MpoolCheckReplaceMessages(context.Context, []*types.Message) ([][]MessageCheckStatus, error) //perm:read
+
 	// MpoolGetNonce gets next nonce for the specified sender.
 	// Note that this method may not be atomic. Use MpoolPushMessage instead.
 	MpoolGetNonce(context.Context, address.Address) (uint64, error) //perm:read
@@ -316,6 +323,8 @@ type FullNode interface {
 	ClientRemoveImport(ctx context.Context, importID multistore.StoreID) error //perm:admin
 	// ClientStartDeal proposes a deal with a miner.
 	ClientStartDeal(ctx context.Context, params *StartDealParams) (*cid.Cid, error) //perm:admin
+	// ClientStatelessDeal fire-and-forget-proposes an offline deal to a miner without subsequent tracking.
+	ClientStatelessDeal(ctx context.Context, params *StartDealParams) (*cid.Cid, error) //perm:write
 	// ClientGetDealInfo returns the latest information about a given deal.
 	ClientGetDealInfo(context.Context, cid.Cid) (*DealInfo, error) //perm:read
 	// ClientListDeals returns information about the deals made by the local client.
@@ -335,6 +344,10 @@ type FullNode interface {
 	// ClientRetrieveWithEvents initiates the retrieval of a file, as specified in the order, and provides a channel
 	// of status updates.
 	ClientRetrieveWithEvents(ctx context.Context, order RetrievalOrder, ref *FileRef) (<-chan marketevents.RetrievalEvent, error) //perm:admin
+	// ClientListRetrievals returns information about retrievals made by the local client
+	ClientListRetrievals(ctx context.Context) ([]RetrievalInfo, error) //perm:write
+	// 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) (*storagemarket.StorageAsk, error) //perm:read
 	// ClientCalcCommP calculates the CommP and data size of the specified CID
@@ -579,15 +592,16 @@ type FullNode interface {
 	// 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>
-	MsigCreate(context.Context, uint64, []address.Address, abi.ChainEpoch, types.BigInt, address.Address, types.BigInt) (cid.Cid, error) //perm:sign
+	MsigCreate(context.Context, uint64, []address.Address, abi.ChainEpoch, types.BigInt, address.Address, types.BigInt) (*MessagePrototype, error) //perm:sign
+
 	// MsigPropose proposes a multisig message
 	// It takes the following params: <multisig address>, <recipient address>, <value to transfer>,
 	// <sender address of the propose msg>, <method to call in the proposed message>, <params to include in the proposed message>
-	MsigPropose(context.Context, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error) //perm:sign
+	MsigPropose(context.Context, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (*MessagePrototype, error) //perm:sign
 
 	// MsigApprove approves a previously-proposed multisig message by transaction ID
 	// It takes the following params: <multisig address>, <proposed transaction ID> <signer address>
-	MsigApprove(context.Context, address.Address, uint64, address.Address) (cid.Cid, error) //perm:sign
+	MsigApprove(context.Context, address.Address, uint64, address.Address) (*MessagePrototype, error) //perm:sign
 
 	// MsigApproveTxnHash approves a previously-proposed multisig message, specified
 	// using both transaction ID and a hash of the parameters used in the
@@ -595,43 +609,49 @@ type FullNode interface {
 	// exactly the transaction you think you are.
 	// It takes the following params: <multisig address>, <proposed message ID>, <proposer address>, <recipient address>, <value to transfer>,
 	// <sender address of the approve msg>, <method to call in the proposed message>, <params to include in the proposed message>
-	MsigApproveTxnHash(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error) //perm:sign
+	MsigApproveTxnHash(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (*MessagePrototype, error) //perm:sign
 
 	// MsigCancel cancels a previously-proposed multisig message
 	// It takes the following params: <multisig address>, <proposed transaction ID>, <recipient address>, <value to transfer>,
 	// <sender address of the cancel msg>, <method to call in the proposed message>, <params to include in the proposed message>
-	MsigCancel(context.Context, address.Address, uint64, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error) //perm:sign
+	MsigCancel(context.Context, address.Address, uint64, address.Address, types.BigInt, address.Address, uint64, []byte) (*MessagePrototype, error) //perm:sign
+
 	// MsigAddPropose proposes adding a signer in the multisig
 	// It takes the following params: <multisig address>, <sender address of the propose msg>,
 	// <new signer>, <whether the number of required signers should be increased>
-	MsigAddPropose(context.Context, address.Address, address.Address, address.Address, bool) (cid.Cid, error) //perm:sign
+	MsigAddPropose(context.Context, address.Address, address.Address, address.Address, bool) (*MessagePrototype, error) //perm:sign
+
 	// MsigAddApprove approves a previously proposed AddSigner message
 	// It takes the following params: <multisig address>, <sender address of the approve msg>, <proposed message ID>,
 	// <proposer address>, <new signer>, <whether the number of required signers should be increased>
-	MsigAddApprove(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, bool) (cid.Cid, error) //perm:sign
+	MsigAddApprove(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, bool) (*MessagePrototype, error) //perm:sign
+
 	// MsigAddCancel cancels a previously proposed AddSigner message
 	// It takes the following params: <multisig address>, <sender address of the cancel msg>, <proposed message ID>,
 	// <new signer>, <whether the number of required signers should be increased>
-	MsigAddCancel(context.Context, address.Address, address.Address, uint64, address.Address, bool) (cid.Cid, error) //perm:sign
+	MsigAddCancel(context.Context, address.Address, address.Address, uint64, address.Address, bool) (*MessagePrototype, error) //perm:sign
+
 	// MsigSwapPropose proposes swapping 2 signers in the multisig
 	// It takes the following params: <multisig address>, <sender address of the propose msg>,
 	// <old signer>, <new signer>
-	MsigSwapPropose(context.Context, address.Address, address.Address, address.Address, address.Address) (cid.Cid, error) //perm:sign
+	MsigSwapPropose(context.Context, address.Address, address.Address, address.Address, address.Address) (*MessagePrototype, error) //perm:sign
+
 	// MsigSwapApprove approves a previously proposed SwapSigner
 	// It takes the following params: <multisig address>, <sender address of the approve msg>, <proposed message ID>,
 	// <proposer address>, <old signer>, <new signer>
-	MsigSwapApprove(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, address.Address) (cid.Cid, error) //perm:sign
+	MsigSwapApprove(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, address.Address) (*MessagePrototype, error) //perm:sign
+
 	// MsigSwapCancel cancels a previously proposed SwapSigner message
 	// It takes the following params: <multisig address>, <sender address of the cancel msg>, <proposed message ID>,
 	// <old signer>, <new signer>
-	MsigSwapCancel(context.Context, address.Address, address.Address, uint64, address.Address, address.Address) (cid.Cid, error) //perm:sign
+	MsigSwapCancel(context.Context, address.Address, address.Address, uint64, address.Address, address.Address) (*MessagePrototype, error) //perm:sign
 
 	// MsigRemoveSigner proposes the removal of a signer from the multisig.
 	// It accepts the multisig to make the change on, the proposer address to
 	// send the message from, the address to be removed, and a boolean
 	// indicating whether or not the signing threshold should be lowered by one
 	// along with the address removal.
-	MsigRemoveSigner(ctx context.Context, msig address.Address, proposer address.Address, toRemove address.Address, decrease bool) (cid.Cid, error) //perm:sign
+	MsigRemoveSigner(ctx context.Context, msig address.Address, proposer address.Address, toRemove address.Address, decrease bool) (*MessagePrototype, error) //perm:sign
 
 	// MarketAddBalance adds funds to the market actor
 	MarketAddBalance(ctx context.Context, wallet, addr address.Address, amt types.BigInt) (cid.Cid, error) //perm:sign
@@ -664,6 +684,11 @@ type FullNode interface {
 	PaychVoucherList(context.Context, address.Address) ([]*paych.SignedVoucher, error)                                  //perm:write
 	PaychVoucherSubmit(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (cid.Cid, error)         //perm:sign
 
+	// MethodGroup: Node
+	// These methods are general node management and status commands
+
+	NodeStatus(ctx context.Context, inclChainStatus bool) (NodeStatus, 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

api/api_gateway.go

@@ -58,4 +58,5 @@ type Gateway interface {
 	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)
 }

api/api_storage.go

@@ -24,6 +24,7 @@ import (
 	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	"github.com/filecoin-project/lotus/extern/storage-sealing/sealiface"
 )
 
 //                       MODIFYING THE API INTERFACE
@@ -91,6 +92,16 @@ type StorageMiner interface {
 	// SectorTerminatePending returns a list of pending sector terminations to be sent in the next batch message
 	SectorTerminatePending(ctx context.Context) ([]abi.SectorID, error)  //perm:admin
 	SectorMarkForUpgrade(ctx context.Context, id abi.SectorNumber) error //perm:admin
+	// SectorPreCommitFlush immediately sends a PreCommit message with sectors batched for PreCommit.
+	// Returns null if message wasn't sent
+	SectorPreCommitFlush(ctx context.Context) ([]sealiface.PreCommitBatchRes, error) //perm:admin
+	// SectorPreCommitPending returns a list of pending PreCommit sectors to be sent in the next batch message
+	SectorPreCommitPending(ctx context.Context) ([]abi.SectorID, error) //perm:admin
+	// SectorCommitFlush immediately sends a Commit message with sectors aggregated for Commit.
+	// Returns null if message wasn't sent
+	SectorCommitFlush(ctx context.Context) ([]sealiface.CommitBatchRes, error) //perm:admin
+	// SectorCommitPending returns a list of pending Commit sectors to be sent in the next aggregate message
+	SectorCommitPending(ctx context.Context) ([]abi.SectorID, error) //perm:admin
 
 	// WorkerConnect tells the node to connect to workers RPC
 	WorkerConnect(context.Context, string) error                              //perm:admin retry:true

api/api_wallet.go

@@ -35,13 +35,13 @@ type MsgMeta struct {
 }
 
 type Wallet interface {
-	WalletNew(context.Context, types.KeyType) (address.Address, error)
-	WalletHas(context.Context, address.Address) (bool, error)
-	WalletList(context.Context) ([]address.Address, error)
+	WalletNew(context.Context, types.KeyType) (address.Address, error) //perm:admin
+	WalletHas(context.Context, address.Address) (bool, error)          //perm:admin
+	WalletList(context.Context) ([]address.Address, error)             //perm:admin
 
-	WalletSign(ctx context.Context, signer address.Address, toSign []byte, meta MsgMeta) (*crypto.Signature, error)
+	WalletSign(ctx context.Context, signer address.Address, toSign []byte, meta MsgMeta) (*crypto.Signature, error) //perm:admin
 
-	WalletExport(context.Context, address.Address) (*types.KeyInfo, error)
-	WalletImport(context.Context, *types.KeyInfo) (address.Address, error)
-	WalletDelete(context.Context, address.Address) error
+	WalletExport(context.Context, address.Address) (*types.KeyInfo, error) //perm:admin
+	WalletImport(context.Context, *types.KeyInfo) (address.Address, error) //perm:admin
+	WalletDelete(context.Context, address.Address) error                   //perm:admin
 }

api/api_worker.go

@@ -2,7 +2,6 @@ package api
 
 import (
 	"context"
-	"io"
 
 	"github.com/google/uuid"
 	"github.com/ipfs/go-cid"
@@ -43,7 +42,6 @@ type Worker interface {
 	ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) (storiface.CallID, error)                                                                                 //perm:admin
 	MoveStorage(ctx context.Context, sector storage.SectorRef, types storiface.SectorFileType) (storiface.CallID, error)                                                                                 //perm:admin
 	UnsealPiece(context.Context, storage.SectorRef, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) (storiface.CallID, error)                                           //perm:admin
-	ReadPiece(context.Context, io.Writer, storage.SectorRef, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (storiface.CallID, error)                                                               //perm:admin
 	Fetch(context.Context, storage.SectorRef, storiface.SectorFileType, storiface.PathType, storiface.AcquireMode) (storiface.CallID, error)                                                             //perm:admin
 
 	TaskDisable(ctx context.Context, tt sealtasks.TaskType) error //perm:admin

api/checkstatuscode_string.go

@@ -0,0 +1,35 @@
+// Code generated by "stringer -type=CheckStatusCode -trimprefix=CheckStatus"; DO NOT EDIT.
+
+package api
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[CheckStatusMessageSerialize-1]
+	_ = x[CheckStatusMessageSize-2]
+	_ = x[CheckStatusMessageValidity-3]
+	_ = x[CheckStatusMessageMinGas-4]
+	_ = x[CheckStatusMessageMinBaseFee-5]
+	_ = x[CheckStatusMessageBaseFee-6]
+	_ = x[CheckStatusMessageBaseFeeLowerBound-7]
+	_ = x[CheckStatusMessageBaseFeeUpperBound-8]
+	_ = x[CheckStatusMessageGetStateNonce-9]
+	_ = x[CheckStatusMessageNonce-10]
+	_ = x[CheckStatusMessageGetStateBalance-11]
+	_ = x[CheckStatusMessageBalance-12]
+}
+
+const _CheckStatusCode_name = "MessageSerializeMessageSizeMessageValidityMessageMinGasMessageMinBaseFeeMessageBaseFeeMessageBaseFeeLowerBoundMessageBaseFeeUpperBoundMessageGetStateNonceMessageNonceMessageGetStateBalanceMessageBalance"
+
+var _CheckStatusCode_index = [...]uint8{0, 16, 27, 42, 55, 72, 86, 110, 134, 154, 166, 188, 202}
+
+func (i CheckStatusCode) String() string {
+	i -= 1
+	if i < 0 || i >= CheckStatusCode(len(_CheckStatusCode_index)-1) {
+		return "CheckStatusCode(" + strconv.FormatInt(int64(i+1), 10) + ")"
+	}
+	return _CheckStatusCode_name[_CheckStatusCode_index[i]:_CheckStatusCode_index[i+1]]
+}

api/docgen/docgen.go

@@ -261,6 +261,9 @@ func init() {
 		},
 		"methods": []interface{}{}},
 	)
+
+	addExample(api.CheckStatusCode(0))
+	addExample(map[string]interface{}{"abc": 123})
 }
 
 func GetAPIType(name, pkg string) (i interface{}, t, permStruct, commonPermStruct reflect.Type) {

api/proxy_gen.go

@@ -4,7 +4,6 @@ package api
 
 import (
 	"context"
-	"io"
 	"time"
 
 	"github.com/filecoin-project/go-address"
@@ -27,6 +26,7 @@ import (
 	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	"github.com/filecoin-project/lotus/extern/storage-sealing/sealiface"
 	marketevents "github.com/filecoin-project/lotus/markets/loggers"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/specs-storage/storage"
@@ -179,6 +179,8 @@ type FullNodeStruct struct {
 
 		ClientGetDealUpdates func(p0 context.Context) (<-chan DealInfo, error) `perm:"write"`
 
+		ClientGetRetrievalUpdates func(p0 context.Context) (<-chan RetrievalInfo, error) `perm:"write"`
+
 		ClientHasLocal func(p0 context.Context, p1 cid.Cid) (bool, error) `perm:"write"`
 
 		ClientImport func(p0 context.Context, p1 FileRef) (*ImportRes, error) `perm:"admin"`
@@ -189,6 +191,8 @@ type FullNodeStruct struct {
 
 		ClientListImports func(p0 context.Context) ([]Import, error) `perm:"write"`
 
+		ClientListRetrievals func(p0 context.Context) ([]RetrievalInfo, error) `perm:"write"`
+
 		ClientMinerQueryOffer func(p0 context.Context, p1 address.Address, p2 cid.Cid, p3 *cid.Cid) (QueryOffer, error) `perm:"read"`
 
 		ClientQueryAsk func(p0 context.Context, p1 peer.ID, p2 address.Address) (*storagemarket.StorageAsk, error) `perm:"read"`
@@ -205,6 +209,8 @@ type FullNodeStruct struct {
 
 		ClientStartDeal func(p0 context.Context, p1 *StartDealParams) (*cid.Cid, error) `perm:"admin"`
 
+		ClientStatelessDeal func(p0 context.Context, p1 *StartDealParams) (*cid.Cid, error) `perm:"write"`
+
 		CreateBackup func(p0 context.Context, p1 string) error `perm:"admin"`
 
 		GasEstimateFeeCap func(p0 context.Context, p1 *types.Message, p2 int64, p3 types.TipSetKey) (types.BigInt, error) `perm:"read"`
@@ -235,6 +241,12 @@ type FullNodeStruct struct {
 
 		MpoolBatchPushUntrusted func(p0 context.Context, p1 []*types.SignedMessage) ([]cid.Cid, error) `perm:"write"`
 
+		MpoolCheckMessages func(p0 context.Context, p1 []*MessagePrototype) ([][]MessageCheckStatus, error) `perm:"read"`
+
+		MpoolCheckPendingMessages func(p0 context.Context, p1 address.Address) ([][]MessageCheckStatus, error) `perm:"read"`
+
+		MpoolCheckReplaceMessages func(p0 context.Context, p1 []*types.Message) ([][]MessageCheckStatus, error) `perm:"read"`
+
 		MpoolClear func(p0 context.Context, p1 bool) error `perm:"write"`
 
 		MpoolGetConfig func(p0 context.Context) (*types.MpoolConfig, error) `perm:"read"`
@@ -255,19 +267,19 @@ type FullNodeStruct struct {
 
 		MpoolSub func(p0 context.Context) (<-chan MpoolUpdate, error) `perm:"read"`
 
-		MsigAddApprove func(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address, p6 bool) (cid.Cid, error) `perm:"sign"`
+		MsigAddApprove func(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address, p6 bool) (*MessagePrototype, error) `perm:"sign"`
 
-		MsigAddCancel func(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 bool) (cid.Cid, error) `perm:"sign"`
+		MsigAddCancel func(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 bool) (*MessagePrototype, error) `perm:"sign"`
 
-		MsigAddPropose func(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 bool) (cid.Cid, error) `perm:"sign"`
+		MsigAddPropose func(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 bool) (*MessagePrototype, error) `perm:"sign"`
 
-		MsigApprove func(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address) (cid.Cid, error) `perm:"sign"`
+		MsigApprove func(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address) (*MessagePrototype, error) `perm:"sign"`
 
-		MsigApproveTxnHash func(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address, p4 address.Address, p5 types.BigInt, p6 address.Address, p7 uint64, p8 []byte) (cid.Cid, error) `perm:"sign"`
+		MsigApproveTxnHash func(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address, p4 address.Address, p5 types.BigInt, p6 address.Address, p7 uint64, p8 []byte) (*MessagePrototype, error) `perm:"sign"`
 
-		MsigCancel func(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address, p4 types.BigInt, p5 address.Address, p6 uint64, p7 []byte) (cid.Cid, error) `perm:"sign"`
+		MsigCancel func(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address, p4 types.BigInt, p5 address.Address, p6 uint64, p7 []byte) (*MessagePrototype, error) `perm:"sign"`
 
-		MsigCreate func(p0 context.Context, p1 uint64, p2 []address.Address, p3 abi.ChainEpoch, p4 types.BigInt, p5 address.Address, p6 types.BigInt) (cid.Cid, error) `perm:"sign"`
+		MsigCreate func(p0 context.Context, p1 uint64, p2 []address.Address, p3 abi.ChainEpoch, p4 types.BigInt, p5 address.Address, p6 types.BigInt) (*MessagePrototype, error) `perm:"sign"`
 
 		MsigGetAvailableBalance func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (types.BigInt, error) `perm:"read"`
 
@@ -277,15 +289,17 @@ type FullNodeStruct struct {
 
 		MsigGetVestingSchedule func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (MsigVesting, error) `perm:"read"`
 
-		MsigPropose func(p0 context.Context, p1 address.Address, p2 address.Address, p3 types.BigInt, p4 address.Address, p5 uint64, p6 []byte) (cid.Cid, error) `perm:"sign"`
+		MsigPropose func(p0 context.Context, p1 address.Address, p2 address.Address, p3 types.BigInt, p4 address.Address, p5 uint64, p6 []byte) (*MessagePrototype, error) `perm:"sign"`
 
-		MsigRemoveSigner func(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 bool) (cid.Cid, error) `perm:"sign"`
+		MsigRemoveSigner func(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 bool) (*MessagePrototype, error) `perm:"sign"`
 
-		MsigSwapApprove func(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address, p6 address.Address) (cid.Cid, error) `perm:"sign"`
+		MsigSwapApprove func(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address, p6 address.Address) (*MessagePrototype, error) `perm:"sign"`
 
-		MsigSwapCancel func(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address) (cid.Cid, error) `perm:"sign"`
+		MsigSwapCancel func(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address) (*MessagePrototype, error) `perm:"sign"`
 
-		MsigSwapPropose func(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 address.Address) (cid.Cid, error) `perm:"sign"`
+		MsigSwapPropose func(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 address.Address) (*MessagePrototype, error) `perm:"sign"`
+
+		NodeStatus func(p0 context.Context, p1 bool) (NodeStatus, error) `perm:"read"`
 
 		PaychAllocateLane func(p0 context.Context, p1 address.Address) (uint64, error) `perm:"sign"`
 
@@ -517,6 +531,8 @@ type GatewayStruct struct {
 
 		StateWaitMsg func(p0 context.Context, p1 cid.Cid, p2 uint64, p3 abi.ChainEpoch, p4 bool) (*MsgLookup, error) ``
 
+		Version func(p0 context.Context) (APIVersion, error) ``
+
 		WalletBalance func(p0 context.Context, p1 address.Address) (types.BigInt, error) ``
 	}
 }
@@ -649,12 +665,20 @@ type StorageMinerStruct struct {
 
 		SealingSchedDiag func(p0 context.Context, p1 bool) (interface{}, error) `perm:"admin"`
 
+		SectorCommitFlush func(p0 context.Context) ([]sealiface.CommitBatchRes, error) `perm:"admin"`
+
+		SectorCommitPending func(p0 context.Context) ([]abi.SectorID, error) `perm:"admin"`
+
 		SectorGetExpectedSealDuration func(p0 context.Context) (time.Duration, error) `perm:"read"`
 
 		SectorGetSealDelay func(p0 context.Context) (time.Duration, error) `perm:"read"`
 
 		SectorMarkForUpgrade func(p0 context.Context, p1 abi.SectorNumber) error `perm:"admin"`
 
+		SectorPreCommitFlush func(p0 context.Context) ([]sealiface.PreCommitBatchRes, error) `perm:"admin"`
+
+		SectorPreCommitPending func(p0 context.Context) ([]abi.SectorID, error) `perm:"admin"`
+
 		SectorRemove func(p0 context.Context, p1 abi.SectorNumber) error `perm:"admin"`
 
 		SectorSetExpectedSealDuration func(p0 context.Context, p1 time.Duration) error `perm:"write"`
@@ -721,19 +745,19 @@ type StorageMinerStub struct {
 
 type WalletStruct struct {
 	Internal struct {
-		WalletDelete func(p0 context.Context, p1 address.Address) error ``
+		WalletDelete func(p0 context.Context, p1 address.Address) error `perm:"admin"`
 
-		WalletExport func(p0 context.Context, p1 address.Address) (*types.KeyInfo, error) ``
+		WalletExport func(p0 context.Context, p1 address.Address) (*types.KeyInfo, error) `perm:"admin"`
 
-		WalletHas func(p0 context.Context, p1 address.Address) (bool, error) ``
+		WalletHas func(p0 context.Context, p1 address.Address) (bool, error) `perm:"admin"`
 
-		WalletImport func(p0 context.Context, p1 *types.KeyInfo) (address.Address, error) ``
+		WalletImport func(p0 context.Context, p1 *types.KeyInfo) (address.Address, error) `perm:"admin"`
 
-		WalletList func(p0 context.Context) ([]address.Address, error) ``
+		WalletList func(p0 context.Context) ([]address.Address, error) `perm:"admin"`
 
-		WalletNew func(p0 context.Context, p1 types.KeyType) (address.Address, error) ``
+		WalletNew func(p0 context.Context, p1 types.KeyType) (address.Address, error) `perm:"admin"`
 
-		WalletSign func(p0 context.Context, p1 address.Address, p2 []byte, p3 MsgMeta) (*crypto.Signature, error) ``
+		WalletSign func(p0 context.Context, p1 address.Address, p2 []byte, p3 MsgMeta) (*crypto.Signature, error) `perm:"admin"`
 	}
 }
 
@@ -758,8 +782,6 @@ type WorkerStruct struct {
 
 		ProcessSession func(p0 context.Context) (uuid.UUID, error) `perm:"admin"`
 
-		ReadPiece func(p0 context.Context, p1 io.Writer, p2 storage.SectorRef, p3 storiface.UnpaddedByteIndex, p4 abi.UnpaddedPieceSize) (storiface.CallID, error) `perm:"admin"`
-
 		ReleaseUnsealed func(p0 context.Context, p1 storage.SectorRef, p2 []storage.Range) (storiface.CallID, error) `perm:"admin"`
 
 		Remove func(p0 context.Context, p1 abi.SectorID) error `perm:"admin"`
@@ -1283,6 +1305,14 @@ func (s *FullNodeStub) ClientGetDealUpdates(p0 context.Context) (<-chan DealInfo
 	return nil, xerrors.New("method not supported")
 }
 
+func (s *FullNodeStruct) ClientGetRetrievalUpdates(p0 context.Context) (<-chan RetrievalInfo, error) {
+	return s.Internal.ClientGetRetrievalUpdates(p0)
+}
+
+func (s *FullNodeStub) ClientGetRetrievalUpdates(p0 context.Context) (<-chan RetrievalInfo, error) {
+	return nil, xerrors.New("method not supported")
+}
+
 func (s *FullNodeStruct) ClientHasLocal(p0 context.Context, p1 cid.Cid) (bool, error) {
 	return s.Internal.ClientHasLocal(p0, p1)
 }
@@ -1323,6 +1353,14 @@ func (s *FullNodeStub) ClientListImports(p0 context.Context) ([]Import, error) {
 	return *new([]Import), xerrors.New("method not supported")
 }
 
+func (s *FullNodeStruct) ClientListRetrievals(p0 context.Context) ([]RetrievalInfo, error) {
+	return s.Internal.ClientListRetrievals(p0)
+}
+
+func (s *FullNodeStub) ClientListRetrievals(p0 context.Context) ([]RetrievalInfo, error) {
+	return *new([]RetrievalInfo), xerrors.New("method not supported")
+}
+
 func (s *FullNodeStruct) ClientMinerQueryOffer(p0 context.Context, p1 address.Address, p2 cid.Cid, p3 *cid.Cid) (QueryOffer, error) {
 	return s.Internal.ClientMinerQueryOffer(p0, p1, p2, p3)
 }
@@ -1387,6 +1425,14 @@ func (s *FullNodeStub) ClientStartDeal(p0 context.Context, p1 *StartDealParams)
 	return nil, xerrors.New("method not supported")
 }
 
+func (s *FullNodeStruct) ClientStatelessDeal(p0 context.Context, p1 *StartDealParams) (*cid.Cid, error) {
+	return s.Internal.ClientStatelessDeal(p0, p1)
+}
+
+func (s *FullNodeStub) ClientStatelessDeal(p0 context.Context, p1 *StartDealParams) (*cid.Cid, error) {
+	return nil, xerrors.New("method not supported")
+}
+
 func (s *FullNodeStruct) CreateBackup(p0 context.Context, p1 string) error {
 	return s.Internal.CreateBackup(p0, p1)
 }
@@ -1507,6 +1553,30 @@ func (s *FullNodeStub) MpoolBatchPushUntrusted(p0 context.Context, p1 []*types.S
 	return *new([]cid.Cid), xerrors.New("method not supported")
 }
 
+func (s *FullNodeStruct) MpoolCheckMessages(p0 context.Context, p1 []*MessagePrototype) ([][]MessageCheckStatus, error) {
+	return s.Internal.MpoolCheckMessages(p0, p1)
+}
+
+func (s *FullNodeStub) MpoolCheckMessages(p0 context.Context, p1 []*MessagePrototype) ([][]MessageCheckStatus, error) {
+	return *new([][]MessageCheckStatus), xerrors.New("method not supported")
+}
+
+func (s *FullNodeStruct) MpoolCheckPendingMessages(p0 context.Context, p1 address.Address) ([][]MessageCheckStatus, error) {
+	return s.Internal.MpoolCheckPendingMessages(p0, p1)
+}
+
+func (s *FullNodeStub) MpoolCheckPendingMessages(p0 context.Context, p1 address.Address) ([][]MessageCheckStatus, error) {
+	return *new([][]MessageCheckStatus), xerrors.New("method not supported")
+}
+
+func (s *FullNodeStruct) MpoolCheckReplaceMessages(p0 context.Context, p1 []*types.Message) ([][]MessageCheckStatus, error) {
+	return s.Internal.MpoolCheckReplaceMessages(p0, p1)
+}
+
+func (s *FullNodeStub) MpoolCheckReplaceMessages(p0 context.Context, p1 []*types.Message) ([][]MessageCheckStatus, error) {
+	return *new([][]MessageCheckStatus), xerrors.New("method not supported")
+}
+
 func (s *FullNodeStruct) MpoolClear(p0 context.Context, p1 bool) error {
 	return s.Internal.MpoolClear(p0, p1)
 }
@@ -1587,60 +1657,60 @@ func (s *FullNodeStub) MpoolSub(p0 context.Context) (<-chan MpoolUpdate, error)
 	return nil, xerrors.New("method not supported")
 }
 
-func (s *FullNodeStruct) MsigAddApprove(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address, p6 bool) (cid.Cid, error) {
+func (s *FullNodeStruct) MsigAddApprove(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address, p6 bool) (*MessagePrototype, error) {
 	return s.Internal.MsigAddApprove(p0, p1, p2, p3, p4, p5, p6)
 }
 
-func (s *FullNodeStub) MsigAddApprove(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address, p6 bool) (cid.Cid, error) {
-	return *new(cid.Cid), xerrors.New("method not supported")
+func (s *FullNodeStub) MsigAddApprove(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address, p6 bool) (*MessagePrototype, error) {
+	return nil, xerrors.New("method not supported")
 }
 
-func (s *FullNodeStruct) MsigAddCancel(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 bool) (cid.Cid, error) {
+func (s *FullNodeStruct) MsigAddCancel(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 bool) (*MessagePrototype, error) {
 	return s.Internal.MsigAddCancel(p0, p1, p2, p3, p4, p5)
 }
 
-func (s *FullNodeStub) MsigAddCancel(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 bool) (cid.Cid, error) {
-	return *new(cid.Cid), xerrors.New("method not supported")
+func (s *FullNodeStub) MsigAddCancel(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 bool) (*MessagePrototype, error) {
+	return nil, xerrors.New("method not supported")
 }
 
-func (s *FullNodeStruct) MsigAddPropose(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 bool) (cid.Cid, error) {
+func (s *FullNodeStruct) MsigAddPropose(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 bool) (*MessagePrototype, error) {
 	return s.Internal.MsigAddPropose(p0, p1, p2, p3, p4)
 }
 
-func (s *FullNodeStub) MsigAddPropose(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 bool) (cid.Cid, error) {
-	return *new(cid.Cid), xerrors.New("method not supported")
+func (s *FullNodeStub) MsigAddPropose(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 bool) (*MessagePrototype, error) {
+	return nil, xerrors.New("method not supported")
 }
 
-func (s *FullNodeStruct) MsigApprove(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address) (cid.Cid, error) {
+func (s *FullNodeStruct) MsigApprove(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address) (*MessagePrototype, error) {
 	return s.Internal.MsigApprove(p0, p1, p2, p3)
 }
 
-func (s *FullNodeStub) MsigApprove(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address) (cid.Cid, error) {
-	return *new(cid.Cid), xerrors.New("method not supported")
+func (s *FullNodeStub) MsigApprove(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address) (*MessagePrototype, error) {
+	return nil, xerrors.New("method not supported")
 }
 
-func (s *FullNodeStruct) MsigApproveTxnHash(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address, p4 address.Address, p5 types.BigInt, p6 address.Address, p7 uint64, p8 []byte) (cid.Cid, error) {
+func (s *FullNodeStruct) MsigApproveTxnHash(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address, p4 address.Address, p5 types.BigInt, p6 address.Address, p7 uint64, p8 []byte) (*MessagePrototype, error) {
 	return s.Internal.MsigApproveTxnHash(p0, p1, p2, p3, p4, p5, p6, p7, p8)
 }
 
-func (s *FullNodeStub) MsigApproveTxnHash(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address, p4 address.Address, p5 types.BigInt, p6 address.Address, p7 uint64, p8 []byte) (cid.Cid, error) {
-	return *new(cid.Cid), xerrors.New("method not supported")
+func (s *FullNodeStub) MsigApproveTxnHash(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address, p4 address.Address, p5 types.BigInt, p6 address.Address, p7 uint64, p8 []byte) (*MessagePrototype, error) {
+	return nil, xerrors.New("method not supported")
 }
 
-func (s *FullNodeStruct) MsigCancel(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address, p4 types.BigInt, p5 address.Address, p6 uint64, p7 []byte) (cid.Cid, error) {
+func (s *FullNodeStruct) MsigCancel(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address, p4 types.BigInt, p5 address.Address, p6 uint64, p7 []byte) (*MessagePrototype, error) {
 	return s.Internal.MsigCancel(p0, p1, p2, p3, p4, p5, p6, p7)
 }
 
-func (s *FullNodeStub) MsigCancel(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address, p4 types.BigInt, p5 address.Address, p6 uint64, p7 []byte) (cid.Cid, error) {
-	return *new(cid.Cid), xerrors.New("method not supported")
+func (s *FullNodeStub) MsigCancel(p0 context.Context, p1 address.Address, p2 uint64, p3 address.Address, p4 types.BigInt, p5 address.Address, p6 uint64, p7 []byte) (*MessagePrototype, error) {
+	return nil, xerrors.New("method not supported")
 }
 
-func (s *FullNodeStruct) MsigCreate(p0 context.Context, p1 uint64, p2 []address.Address, p3 abi.ChainEpoch, p4 types.BigInt, p5 address.Address, p6 types.BigInt) (cid.Cid, error) {
+func (s *FullNodeStruct) MsigCreate(p0 context.Context, p1 uint64, p2 []address.Address, p3 abi.ChainEpoch, p4 types.BigInt, p5 address.Address, p6 types.BigInt) (*MessagePrototype, error) {
 	return s.Internal.MsigCreate(p0, p1, p2, p3, p4, p5, p6)
 }
 
-func (s *FullNodeStub) MsigCreate(p0 context.Context, p1 uint64, p2 []address.Address, p3 abi.ChainEpoch, p4 types.BigInt, p5 address.Address, p6 types.BigInt) (cid.Cid, error) {
-	return *new(cid.Cid), xerrors.New("method not supported")
+func (s *FullNodeStub) MsigCreate(p0 context.Context, p1 uint64, p2 []address.Address, p3 abi.ChainEpoch, p4 types.BigInt, p5 address.Address, p6 types.BigInt) (*MessagePrototype, error) {
+	return nil, xerrors.New("method not supported")
 }
 
 func (s *FullNodeStruct) MsigGetAvailableBalance(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (types.BigInt, error) {
@@ -1675,44 +1745,52 @@ func (s *FullNodeStub) MsigGetVestingSchedule(p0 context.Context, p1 address.Add
 	return *new(MsigVesting), xerrors.New("method not supported")
 }
 
-func (s *FullNodeStruct) MsigPropose(p0 context.Context, p1 address.Address, p2 address.Address, p3 types.BigInt, p4 address.Address, p5 uint64, p6 []byte) (cid.Cid, error) {
+func (s *FullNodeStruct) MsigPropose(p0 context.Context, p1 address.Address, p2 address.Address, p3 types.BigInt, p4 address.Address, p5 uint64, p6 []byte) (*MessagePrototype, error) {
 	return s.Internal.MsigPropose(p0, p1, p2, p3, p4, p5, p6)
 }
 
-func (s *FullNodeStub) MsigPropose(p0 context.Context, p1 address.Address, p2 address.Address, p3 types.BigInt, p4 address.Address, p5 uint64, p6 []byte) (cid.Cid, error) {
-	return *new(cid.Cid), xerrors.New("method not supported")
+func (s *FullNodeStub) MsigPropose(p0 context.Context, p1 address.Address, p2 address.Address, p3 types.BigInt, p4 address.Address, p5 uint64, p6 []byte) (*MessagePrototype, error) {
+	return nil, xerrors.New("method not supported")
 }
 
-func (s *FullNodeStruct) MsigRemoveSigner(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 bool) (cid.Cid, error) {
+func (s *FullNodeStruct) MsigRemoveSigner(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 bool) (*MessagePrototype, error) {
 	return s.Internal.MsigRemoveSigner(p0, p1, p2, p3, p4)
 }
 
-func (s *FullNodeStub) MsigRemoveSigner(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 bool) (cid.Cid, error) {
-	return *new(cid.Cid), xerrors.New("method not supported")
+func (s *FullNodeStub) MsigRemoveSigner(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 bool) (*MessagePrototype, error) {
+	return nil, xerrors.New("method not supported")
 }
 
-func (s *FullNodeStruct) MsigSwapApprove(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address, p6 address.Address) (cid.Cid, error) {
+func (s *FullNodeStruct) MsigSwapApprove(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address, p6 address.Address) (*MessagePrototype, error) {
 	return s.Internal.MsigSwapApprove(p0, p1, p2, p3, p4, p5, p6)
 }
 
-func (s *FullNodeStub) MsigSwapApprove(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address, p6 address.Address) (cid.Cid, error) {
-	return *new(cid.Cid), xerrors.New("method not supported")
+func (s *FullNodeStub) MsigSwapApprove(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address, p6 address.Address) (*MessagePrototype, error) {
+	return nil, xerrors.New("method not supported")
 }
 
-func (s *FullNodeStruct) MsigSwapCancel(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address) (cid.Cid, error) {
+func (s *FullNodeStruct) MsigSwapCancel(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address) (*MessagePrototype, error) {
 	return s.Internal.MsigSwapCancel(p0, p1, p2, p3, p4, p5)
 }
 
-func (s *FullNodeStub) MsigSwapCancel(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address) (cid.Cid, error) {
-	return *new(cid.Cid), xerrors.New("method not supported")
+func (s *FullNodeStub) MsigSwapCancel(p0 context.Context, p1 address.Address, p2 address.Address, p3 uint64, p4 address.Address, p5 address.Address) (*MessagePrototype, error) {
+	return nil, xerrors.New("method not supported")
 }
 
-func (s *FullNodeStruct) MsigSwapPropose(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 address.Address) (cid.Cid, error) {
+func (s *FullNodeStruct) MsigSwapPropose(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 address.Address) (*MessagePrototype, error) {
 	return s.Internal.MsigSwapPropose(p0, p1, p2, p3, p4)
 }
 
-func (s *FullNodeStub) MsigSwapPropose(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 address.Address) (cid.Cid, error) {
-	return *new(cid.Cid), xerrors.New("method not supported")
+func (s *FullNodeStub) MsigSwapPropose(p0 context.Context, p1 address.Address, p2 address.Address, p3 address.Address, p4 address.Address) (*MessagePrototype, error) {
+	return nil, xerrors.New("method not supported")
+}
+
+func (s *FullNodeStruct) NodeStatus(p0 context.Context, p1 bool) (NodeStatus, error) {
+	return s.Internal.NodeStatus(p0, p1)
+}
+
+func (s *FullNodeStub) NodeStatus(p0 context.Context, p1 bool) (NodeStatus, error) {
+	return *new(NodeStatus), xerrors.New("method not supported")
 }
 
 func (s *FullNodeStruct) PaychAllocateLane(p0 context.Context, p1 address.Address) (uint64, error) {
@@ -2603,6 +2681,14 @@ func (s *GatewayStub) StateWaitMsg(p0 context.Context, p1 cid.Cid, p2 uint64, p3
 	return nil, xerrors.New("method not supported")
 }
 
+func (s *GatewayStruct) Version(p0 context.Context) (APIVersion, error) {
+	return s.Internal.Version(p0)
+}
+
+func (s *GatewayStub) Version(p0 context.Context) (APIVersion, error) {
+	return *new(APIVersion), xerrors.New("method not supported")
+}
+
 func (s *GatewayStruct) WalletBalance(p0 context.Context, p1 address.Address) (types.BigInt, error) {
 	return s.Internal.WalletBalance(p0, p1)
 }
@@ -3067,6 +3153,22 @@ func (s *StorageMinerStub) SealingSchedDiag(p0 context.Context, p1 bool) (interf
 	return nil, xerrors.New("method not supported")
 }
 
+func (s *StorageMinerStruct) SectorCommitFlush(p0 context.Context) ([]sealiface.CommitBatchRes, error) {
+	return s.Internal.SectorCommitFlush(p0)
+}
+
+func (s *StorageMinerStub) SectorCommitFlush(p0 context.Context) ([]sealiface.CommitBatchRes, error) {
+	return *new([]sealiface.CommitBatchRes), xerrors.New("method not supported")
+}
+
+func (s *StorageMinerStruct) SectorCommitPending(p0 context.Context) ([]abi.SectorID, error) {
+	return s.Internal.SectorCommitPending(p0)
+}
+
+func (s *StorageMinerStub) SectorCommitPending(p0 context.Context) ([]abi.SectorID, error) {
+	return *new([]abi.SectorID), xerrors.New("method not supported")
+}
+
 func (s *StorageMinerStruct) SectorGetExpectedSealDuration(p0 context.Context) (time.Duration, error) {
 	return s.Internal.SectorGetExpectedSealDuration(p0)
 }
@@ -3091,6 +3193,22 @@ func (s *StorageMinerStub) SectorMarkForUpgrade(p0 context.Context, p1 abi.Secto
 	return xerrors.New("method not supported")
 }
 
+func (s *StorageMinerStruct) SectorPreCommitFlush(p0 context.Context) ([]sealiface.PreCommitBatchRes, error) {
+	return s.Internal.SectorPreCommitFlush(p0)
+}
+
+func (s *StorageMinerStub) SectorPreCommitFlush(p0 context.Context) ([]sealiface.PreCommitBatchRes, error) {
+	return *new([]sealiface.PreCommitBatchRes), xerrors.New("method not supported")
+}
+
+func (s *StorageMinerStruct) SectorPreCommitPending(p0 context.Context) ([]abi.SectorID, error) {
+	return s.Internal.SectorPreCommitPending(p0)
+}
+
+func (s *StorageMinerStub) SectorPreCommitPending(p0 context.Context) ([]abi.SectorID, error) {
+	return *new([]abi.SectorID), xerrors.New("method not supported")
+}
+
 func (s *StorageMinerStruct) SectorRemove(p0 context.Context, p1 abi.SectorNumber) error {
 	return s.Internal.SectorRemove(p0, p1)
 }
@@ -3443,14 +3561,6 @@ func (s *WorkerStub) ProcessSession(p0 context.Context) (uuid.UUID, error) {
 	return *new(uuid.UUID), xerrors.New("method not supported")
 }
 
-func (s *WorkerStruct) ReadPiece(p0 context.Context, p1 io.Writer, p2 storage.SectorRef, p3 storiface.UnpaddedByteIndex, p4 abi.UnpaddedPieceSize) (storiface.CallID, error) {
-	return s.Internal.ReadPiece(p0, p1, p2, p3, p4)
-}
-
-func (s *WorkerStub) ReadPiece(p0 context.Context, p1 io.Writer, p2 storage.SectorRef, p3 storiface.UnpaddedByteIndex, p4 abi.UnpaddedPieceSize) (storiface.CallID, error) {
-	return *new(storiface.CallID), xerrors.New("method not supported")
-}
-
 func (s *WorkerStruct) ReleaseUnsealed(p0 context.Context, p1 storage.SectorRef, p2 []storage.Range) (storiface.CallID, error) {
 	return s.Internal.ReleaseUnsealed(p0, p1, p2)
 }

api/test/blockminer.go

@@ -1,61 +0,0 @@
-package test
-
-import (
-	"context"
-	"fmt"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/miner"
-)
-
-type BlockMiner struct {
-	ctx       context.Context
-	t         *testing.T
-	miner     TestStorageNode
-	blocktime time.Duration
-	mine      int64
-	nulls     int64
-	done      chan struct{}
-}
-
-func NewBlockMiner(ctx context.Context, t *testing.T, miner TestStorageNode, blocktime time.Duration) *BlockMiner {
-	return &BlockMiner{
-		ctx:       ctx,
-		t:         t,
-		miner:     miner,
-		blocktime: blocktime,
-		mine:      int64(1),
-		done:      make(chan struct{}),
-	}
-}
-
-func (bm *BlockMiner) MineBlocks() {
-	time.Sleep(time.Second)
-	go func() {
-		defer close(bm.done)
-		for atomic.LoadInt64(&bm.mine) == 1 {
-			select {
-			case <-bm.ctx.Done():
-				return
-			case <-time.After(bm.blocktime):
-			}
-
-			nulls := atomic.SwapInt64(&bm.nulls, 0)
-			if err := bm.miner.MineOne(bm.ctx, miner.MineReq{
-				InjectNulls: abi.ChainEpoch(nulls),
-				Done:        func(bool, abi.ChainEpoch, error) {},
-			}); err != nil {
-				bm.t.Error(err)
-			}
-		}
-	}()
-}
-
-func (bm *BlockMiner) Stop() {
-	atomic.AddInt64(&bm.mine, -1)
-	fmt.Println("shutting down mining")
-	<-bm.done
-}

api/test/deals.go

@@ -1,554 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"io/ioutil"
-	"math/rand"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/ipfs/go-cid"
-	files "github.com/ipfs/go-ipfs-files"
-	"github.com/ipld/go-car"
-	"github.com/stretchr/testify/require"
-
-	"github.com/filecoin-project/go-fil-markets/storagemarket"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
-	"github.com/filecoin-project/lotus/chain/types"
-	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
-	"github.com/filecoin-project/lotus/extern/storage-sealing/sealiface"
-	"github.com/filecoin-project/lotus/markets/storageadapter"
-	"github.com/filecoin-project/lotus/node"
-	"github.com/filecoin-project/lotus/node/impl"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
-	ipld "github.com/ipfs/go-ipld-format"
-	dag "github.com/ipfs/go-merkledag"
-	dstest "github.com/ipfs/go-merkledag/test"
-	unixfile "github.com/ipfs/go-unixfs/file"
-)
-
-func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport, fastRet bool, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
-
-	MakeDeal(t, s.ctx, 6, s.client, s.miner, carExport, fastRet, startEpoch)
-}
-
-func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
-
-	MakeDeal(t, s.ctx, 6, s.client, s.miner, false, false, startEpoch)
-	MakeDeal(t, s.ctx, 7, s.client, s.miner, false, false, startEpoch)
-}
-
-func MakeDeal(t *testing.T, ctx context.Context, rseed int, client api.FullNode, miner TestStorageNode, carExport, fastRet bool, startEpoch abi.ChainEpoch) {
-	res, data, err := CreateClientFile(ctx, client, rseed)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	fcid := res.Root
-	fmt.Println("FILE CID: ", fcid)
-
-	deal := startDeal(t, ctx, miner, client, fcid, fastRet, startEpoch)
-
-	// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
-	time.Sleep(time.Second)
-	waitDealSealed(t, ctx, miner, client, deal, false)
-
-	// Retrieval
-	info, err := client.ClientGetDealInfo(ctx, *deal)
-	require.NoError(t, err)
-
-	testRetrieval(t, ctx, client, fcid, &info.PieceCID, carExport, data)
-}
-
-func CreateClientFile(ctx context.Context, client api.FullNode, rseed int) (*api.ImportRes, []byte, error) {
-	data := make([]byte, 1600)
-	rand.New(rand.NewSource(int64(rseed))).Read(data)
-
-	dir, err := ioutil.TempDir(os.TempDir(), "test-make-deal-")
-	if err != nil {
-		return nil, nil, err
-	}
-
-	path := filepath.Join(dir, "sourcefile.dat")
-	err = ioutil.WriteFile(path, data, 0644)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	res, err := client.ClientImport(ctx, api.FileRef{Path: path})
-	if err != nil {
-		return nil, nil, err
-	}
-	return res, data, nil
-}
-
-func TestPublishDealsBatching(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	publishPeriod := 10 * time.Second
-	maxDealsPerMsg := uint64(2)
-
-	// Set max deals per publish deals message to 2
-	minerDef := []StorageMiner{{
-		Full: 0,
-		Opts: node.Override(
-			new(*storageadapter.DealPublisher),
-			storageadapter.NewDealPublisher(nil, storageadapter.PublishMsgConfig{
-				Period:         publishPeriod,
-				MaxDealsPerMsg: maxDealsPerMsg,
-			})),
-		Preseal: PresealGenesis,
-	}}
-
-	// Create a connect client and miner node
-	n, sn := b(t, OneFull, minerDef)
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-	s := connectAndStartMining(t, b, blocktime, client, miner)
-	defer s.blockMiner.Stop()
-
-	// Starts a deal and waits until it's published
-	runDealTillPublish := func(rseed int) {
-		res, _, err := CreateClientFile(s.ctx, s.client, rseed)
-		require.NoError(t, err)
-
-		upds, err := client.ClientGetDealUpdates(s.ctx)
-		require.NoError(t, err)
-
-		startDeal(t, s.ctx, s.miner, s.client, res.Root, false, startEpoch)
-
-		// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
-		time.Sleep(time.Second)
-
-		done := make(chan struct{})
-		go func() {
-			for upd := range upds {
-				if upd.DataRef.Root == res.Root && upd.State == storagemarket.StorageDealAwaitingPreCommit {
-					done <- struct{}{}
-				}
-			}
-		}()
-		<-done
-	}
-
-	// Run three deals in parallel
-	done := make(chan struct{}, maxDealsPerMsg+1)
-	for rseed := 1; rseed <= 3; rseed++ {
-		rseed := rseed
-		go func() {
-			runDealTillPublish(rseed)
-			done <- struct{}{}
-		}()
-	}
-
-	// Wait for two of the deals to be published
-	for i := 0; i < int(maxDealsPerMsg); i++ {
-		<-done
-	}
-
-	// Expect a single PublishStorageDeals message that includes the first two deals
-	msgCids, err := s.client.StateListMessages(s.ctx, &api.MessageMatch{To: market.Address}, types.EmptyTSK, 1)
-	require.NoError(t, err)
-	count := 0
-	for _, msgCid := range msgCids {
-		msg, err := s.client.ChainGetMessage(s.ctx, msgCid)
-		require.NoError(t, err)
-
-		if msg.Method == market.Methods.PublishStorageDeals {
-			count++
-			var pubDealsParams market2.PublishStorageDealsParams
-			err = pubDealsParams.UnmarshalCBOR(bytes.NewReader(msg.Params))
-			require.NoError(t, err)
-			require.Len(t, pubDealsParams.Deals, int(maxDealsPerMsg))
-		}
-	}
-	require.Equal(t, 1, count)
-
-	// The third deal should be published once the publish period expires.
-	// Allow a little padding as it takes a moment for the state change to
-	// be noticed by the client.
-	padding := 10 * time.Second
-	select {
-	case <-time.After(publishPeriod + padding):
-		require.Fail(t, "Expected 3rd deal to be published once publish period elapsed")
-	case <-done: // Success
-	}
-}
-
-func TestBatchDealInput(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	publishPeriod := 10 * time.Second
-	maxDealsPerMsg := uint64(4)
-
-	// Set max deals per publish deals message to maxDealsPerMsg
-	minerDef := []StorageMiner{{
-		Full: 0,
-		Opts: node.Options(
-			node.Override(
-				new(*storageadapter.DealPublisher),
-				storageadapter.NewDealPublisher(nil, storageadapter.PublishMsgConfig{
-					Period:         publishPeriod,
-					MaxDealsPerMsg: maxDealsPerMsg,
-				})),
-			node.Override(new(dtypes.GetSealingConfigFunc), func() (dtypes.GetSealingConfigFunc, error) {
-				return func() (sealiface.Config, error) {
-					return sealiface.Config{
-						MaxWaitDealsSectors:       1,
-						MaxSealingSectors:         1,
-						MaxSealingSectorsForDeals: 2,
-						AlwaysKeepUnsealedCopy:    true,
-					}, nil
-				}, nil
-			}),
-		),
-		Preseal: PresealGenesis,
-	}}
-
-	// Create a connect client and miner node
-	n, sn := b(t, OneFull, minerDef)
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-	s := connectAndStartMining(t, b, blocktime, client, miner)
-	defer s.blockMiner.Stop()
-
-	// Starts a deal and waits until it's published
-	runDealTillSeal := func(rseed int) {
-		res, _, err := CreateClientFile(s.ctx, s.client, rseed)
-		require.NoError(t, err)
-
-		dc := startDeal(t, s.ctx, s.miner, s.client, res.Root, false, startEpoch)
-		waitDealSealed(t, s.ctx, s.miner, s.client, dc, false)
-	}
-
-	// Run maxDealsPerMsg+1 deals in parallel
-	done := make(chan struct{}, maxDealsPerMsg+1)
-	for rseed := 1; rseed <= int(maxDealsPerMsg+1); rseed++ {
-		rseed := rseed
-		go func() {
-			runDealTillSeal(rseed)
-			done <- struct{}{}
-		}()
-	}
-
-	// Wait for maxDealsPerMsg of the deals to be published
-	for i := 0; i < int(maxDealsPerMsg); i++ {
-		<-done
-	}
-
-	sl, err := sn[0].SectorsList(s.ctx)
-	require.NoError(t, err)
-	require.GreaterOrEqual(t, len(sl), 4)
-	require.LessOrEqual(t, len(sl), 5)
-}
-
-func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
-
-	data := make([]byte, 1600)
-	rand.New(rand.NewSource(int64(8))).Read(data)
-
-	r := bytes.NewReader(data)
-	fcid, err := s.client.ClientImportLocal(s.ctx, r)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	fmt.Println("FILE CID: ", fcid)
-
-	deal := startDeal(t, s.ctx, s.miner, s.client, fcid, true, startEpoch)
-
-	waitDealPublished(t, s.ctx, s.miner, deal)
-	fmt.Println("deal published, retrieving")
-	// Retrieval
-	info, err := s.client.ClientGetDealInfo(s.ctx, *deal)
-	require.NoError(t, err)
-
-	testRetrieval(t, s.ctx, s.client, fcid, &info.PieceCID, false, data)
-}
-
-func TestSecondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
-
-	{
-		data1 := make([]byte, 800)
-		rand.New(rand.NewSource(int64(3))).Read(data1)
-		r := bytes.NewReader(data1)
-
-		fcid1, err := s.client.ClientImportLocal(s.ctx, r)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		data2 := make([]byte, 800)
-		rand.New(rand.NewSource(int64(9))).Read(data2)
-		r2 := bytes.NewReader(data2)
-
-		fcid2, err := s.client.ClientImportLocal(s.ctx, r2)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		deal1 := startDeal(t, s.ctx, s.miner, s.client, fcid1, true, 0)
-
-		// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
-		time.Sleep(time.Second)
-		waitDealSealed(t, s.ctx, s.miner, s.client, deal1, true)
-
-		deal2 := startDeal(t, s.ctx, s.miner, s.client, fcid2, true, 0)
-
-		time.Sleep(time.Second)
-		waitDealSealed(t, s.ctx, s.miner, s.client, deal2, false)
-
-		// Retrieval
-		info, err := s.client.ClientGetDealInfo(s.ctx, *deal2)
-		require.NoError(t, err)
-
-		rf, _ := s.miner.SectorsRefs(s.ctx)
-		fmt.Printf("refs: %+v\n", rf)
-
-		testRetrieval(t, s.ctx, s.client, fcid2, &info.PieceCID, false, data2)
-	}
-}
-
-func TestZeroPricePerByteRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
-
-	// Set price-per-byte to zero
-	ask, err := s.miner.MarketGetRetrievalAsk(s.ctx)
-	require.NoError(t, err)
-
-	ask.PricePerByte = abi.NewTokenAmount(0)
-	err = s.miner.MarketSetRetrievalAsk(s.ctx, ask)
-	require.NoError(t, err)
-
-	MakeDeal(t, s.ctx, 6, s.client, s.miner, false, false, startEpoch)
-}
-
-func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client api.FullNode, fcid cid.Cid, fastRet bool, startEpoch abi.ChainEpoch) *cid.Cid {
-	maddr, err := miner.ActorAddress(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	addr, err := client.WalletDefaultAddress(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	deal, err := client.ClientStartDeal(ctx, &api.StartDealParams{
-		Data: &storagemarket.DataRef{
-			TransferType: storagemarket.TTGraphsync,
-			Root:         fcid,
-		},
-		Wallet:            addr,
-		Miner:             maddr,
-		EpochPrice:        types.NewInt(1000000),
-		DealStartEpoch:    startEpoch,
-		MinBlocksDuration: uint64(build.MinDealDuration),
-		FastRetrieval:     fastRet,
-	})
-	if err != nil {
-		t.Fatalf("%+v", err)
-	}
-	return deal
-}
-
-func waitDealSealed(t *testing.T, ctx context.Context, miner TestStorageNode, client api.FullNode, deal *cid.Cid, noseal bool) {
-loop:
-	for {
-		di, err := client.ClientGetDealInfo(ctx, *deal)
-		if err != nil {
-			t.Fatal(err)
-		}
-		switch di.State {
-		case storagemarket.StorageDealAwaitingPreCommit, storagemarket.StorageDealSealing:
-			if noseal {
-				return
-			}
-			startSealingWaiting(t, ctx, miner)
-		case storagemarket.StorageDealProposalRejected:
-			t.Fatal("deal rejected")
-		case storagemarket.StorageDealFailing:
-			t.Fatal("deal failed")
-		case storagemarket.StorageDealError:
-			t.Fatal("deal errored", di.Message)
-		case storagemarket.StorageDealActive:
-			fmt.Println("COMPLETE", di)
-			break loop
-		}
-		fmt.Println("Deal state: ", storagemarket.DealStates[di.State])
-		time.Sleep(time.Second / 2)
-	}
-}
-
-func waitDealPublished(t *testing.T, ctx context.Context, miner TestStorageNode, deal *cid.Cid) {
-	subCtx, cancel := context.WithCancel(ctx)
-	defer cancel()
-	updates, err := miner.MarketGetDealUpdates(subCtx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for {
-		select {
-		case <-ctx.Done():
-			t.Fatal("context timeout")
-		case di := <-updates:
-			if deal.Equals(di.ProposalCid) {
-				switch di.State {
-				case storagemarket.StorageDealProposalRejected:
-					t.Fatal("deal rejected")
-				case storagemarket.StorageDealFailing:
-					t.Fatal("deal failed")
-				case storagemarket.StorageDealError:
-					t.Fatal("deal errored", di.Message)
-				case storagemarket.StorageDealFinalizing, storagemarket.StorageDealAwaitingPreCommit, storagemarket.StorageDealSealing, storagemarket.StorageDealActive:
-					fmt.Println("COMPLETE", di)
-					return
-				}
-				fmt.Println("Deal state: ", storagemarket.DealStates[di.State])
-			}
-		}
-	}
-}
-
-func startSealingWaiting(t *testing.T, ctx context.Context, miner TestStorageNode) {
-	snums, err := miner.SectorsList(ctx)
-	require.NoError(t, err)
-
-	for _, snum := range snums {
-		si, err := miner.SectorsStatus(ctx, snum, false)
-		require.NoError(t, err)
-
-		t.Logf("Sector state: %s", si.State)
-		if si.State == api.SectorState(sealing.WaitDeals) {
-			require.NoError(t, miner.SectorStartSealing(ctx, snum))
-		}
-	}
-}
-
-func testRetrieval(t *testing.T, ctx context.Context, client api.FullNode, fcid cid.Cid, piece *cid.Cid, carExport bool, data []byte) {
-	offers, err := client.ClientFindData(ctx, fcid, piece)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(offers) < 1 {
-		t.Fatal("no offers")
-	}
-
-	rpath, err := ioutil.TempDir("", "lotus-retrieve-test-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(rpath) //nolint:errcheck
-
-	caddr, err := client.WalletDefaultAddress(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ref := &api.FileRef{
-		Path:  filepath.Join(rpath, "ret"),
-		IsCAR: carExport,
-	}
-	updates, err := client.ClientRetrieveWithEvents(ctx, offers[0].Order(caddr), ref)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for update := range updates {
-		if update.Err != "" {
-			t.Fatalf("retrieval failed: %s", update.Err)
-		}
-	}
-
-	rdata, err := ioutil.ReadFile(filepath.Join(rpath, "ret"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if carExport {
-		rdata = extractCarData(t, ctx, rdata, rpath)
-	}
-
-	if !bytes.Equal(rdata, data) {
-		t.Fatal("wrong data retrieved")
-	}
-}
-
-func extractCarData(t *testing.T, ctx context.Context, rdata []byte, rpath string) []byte {
-	bserv := dstest.Bserv()
-	ch, err := car.LoadCar(bserv.Blockstore(), bytes.NewReader(rdata))
-	if err != nil {
-		t.Fatal(err)
-	}
-	b, err := bserv.GetBlock(ctx, ch.Roots[0])
-	if err != nil {
-		t.Fatal(err)
-	}
-	nd, err := ipld.Decode(b)
-	if err != nil {
-		t.Fatal(err)
-	}
-	dserv := dag.NewDAGService(bserv)
-	fil, err := unixfile.NewUnixfsFile(ctx, dserv, nd)
-	if err != nil {
-		t.Fatal(err)
-	}
-	outPath := filepath.Join(rpath, "retLoadedCAR")
-	if err := files.WriteTo(fil, outPath); err != nil {
-		t.Fatal(err)
-	}
-	rdata, err = ioutil.ReadFile(outPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return rdata
-}
-
-type dealsScaffold struct {
-	ctx        context.Context
-	client     *impl.FullNodeAPI
-	miner      TestStorageNode
-	blockMiner *BlockMiner
-}
-
-func setupOneClientOneMiner(t *testing.T, b APIBuilder, blocktime time.Duration) *dealsScaffold {
-	n, sn := b(t, OneFull, OneMiner)
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-	return connectAndStartMining(t, b, blocktime, client, miner)
-}
-
-func connectAndStartMining(t *testing.T, b APIBuilder, blocktime time.Duration, client *impl.FullNodeAPI, miner TestStorageNode) *dealsScaffold {
-	ctx := context.Background()
-	addrinfo, err := client.NetAddrsListen(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := miner.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-	time.Sleep(time.Second)
-
-	blockMiner := NewBlockMiner(ctx, t, miner, blocktime)
-	blockMiner.MineBlocks()
-
-	return &dealsScaffold{
-		ctx:        ctx,
-		client:     client,
-		miner:      miner,
-		blockMiner: blockMiner,
-	}
-}

api/test/mining.go

@@ -1,240 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"math/rand"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	logging "github.com/ipfs/go-log/v2"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/miner"
-	"github.com/filecoin-project/lotus/node/impl"
-)
-
-//nolint:deadcode,varcheck
-var log = logging.Logger("apitest")
-
-func (ts *testSuite) testMining(t *testing.T) {
-	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, OneFull, OneMiner)
-	api := apis[0]
-
-	newHeads, err := api.ChainNotify(ctx)
-	require.NoError(t, err)
-	initHead := (<-newHeads)[0]
-	baseHeight := initHead.Val.Height()
-
-	h1, err := api.ChainHead(ctx)
-	require.NoError(t, err)
-	require.Equal(t, int64(h1.Height()), int64(baseHeight))
-
-	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
-	require.NoError(t, err)
-
-	<-newHeads
-
-	h2, err := api.ChainHead(ctx)
-	require.NoError(t, err)
-	require.Greater(t, int64(h2.Height()), int64(h1.Height()))
-}
-
-func (ts *testSuite) testMiningReal(t *testing.T) {
-	build.InsecurePoStValidation = false
-	defer func() {
-		build.InsecurePoStValidation = true
-	}()
-
-	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, OneFull, OneMiner)
-	api := apis[0]
-
-	newHeads, err := api.ChainNotify(ctx)
-	require.NoError(t, err)
-	at := (<-newHeads)[0].Val.Height()
-
-	h1, err := api.ChainHead(ctx)
-	require.NoError(t, err)
-	require.Equal(t, int64(at), int64(h1.Height()))
-
-	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
-	require.NoError(t, err)
-
-	<-newHeads
-
-	h2, err := api.ChainHead(ctx)
-	require.NoError(t, err)
-	require.Greater(t, int64(h2.Height()), int64(h1.Height()))
-
-	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
-	require.NoError(t, err)
-
-	<-newHeads
-
-	h3, err := api.ChainHead(ctx)
-	require.NoError(t, err)
-	require.Greater(t, int64(h3.Height()), int64(h2.Height()))
-}
-
-func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExport bool) {
-	// test making a deal with a fresh miner, and see if it starts to mine
-
-	ctx := context.Background()
-	n, sn := b(t, OneFull, []StorageMiner{
-		{Full: 0, Preseal: PresealGenesis},
-		{Full: 0, Preseal: 0}, // TODO: Add support for miners on non-first full node
-	})
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	provider := sn[1]
-	genesisMiner := sn[0]
-
-	addrinfo, err := client.NetAddrsListen(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := provider.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := genesisMiner.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-
-	time.Sleep(time.Second)
-
-	data := make([]byte, 600)
-	rand.New(rand.NewSource(5)).Read(data)
-
-	r := bytes.NewReader(data)
-	fcid, err := client.ClientImportLocal(ctx, r)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	fmt.Println("FILE CID: ", fcid)
-
-	var mine int32 = 1
-	done := make(chan struct{})
-	minedTwo := make(chan struct{})
-
-	m2addr, err := sn[1].ActorAddress(context.TODO())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	go func() {
-		defer close(done)
-
-		complChan := minedTwo
-		for atomic.LoadInt32(&mine) != 0 {
-			wait := make(chan int)
-			mdone := func(mined bool, _ abi.ChainEpoch, err error) {
-				n := 0
-				if mined {
-					n = 1
-				}
-				wait <- n
-			}
-
-			if err := sn[0].MineOne(ctx, miner.MineReq{Done: mdone}); err != nil {
-				t.Error(err)
-			}
-
-			if err := sn[1].MineOne(ctx, miner.MineReq{Done: mdone}); err != nil {
-				t.Error(err)
-			}
-
-			expect := <-wait
-			expect += <-wait
-
-			time.Sleep(blocktime)
-			if expect == 0 {
-				// null block
-				continue
-			}
-
-			var nodeOneMined bool
-			for _, node := range sn {
-				mb, err := node.MiningBase(ctx)
-				if err != nil {
-					t.Error(err)
-					return
-				}
-
-				for _, b := range mb.Blocks() {
-					if b.Miner == m2addr {
-						nodeOneMined = true
-						break
-					}
-				}
-
-			}
-
-			if nodeOneMined && complChan != nil {
-				close(complChan)
-				complChan = nil
-			}
-
-		}
-	}()
-
-	deal := startDeal(t, ctx, provider, client, fcid, false, 0)
-
-	// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
-	time.Sleep(time.Second)
-
-	waitDealSealed(t, ctx, provider, client, deal, false)
-
-	<-minedTwo
-
-	atomic.StoreInt32(&mine, 0)
-	fmt.Println("shutting down mining")
-	<-done
-}
-
-func (ts *testSuite) testNonGenesisMiner(t *testing.T) {
-	ctx := context.Background()
-	n, sn := ts.makeNodes(t, []FullNodeOpts{
-		FullNodeWithActorsV4At(-1),
-	}, []StorageMiner{
-		{Full: 0, Preseal: PresealGenesis},
-	})
-
-	full, ok := n[0].FullNode.(*impl.FullNodeAPI)
-	if !ok {
-		t.Skip("not testing with a full node")
-		return
-	}
-	genesisMiner := sn[0]
-
-	bm := NewBlockMiner(ctx, t, genesisMiner, 4*time.Millisecond)
-	bm.MineBlocks()
-	t.Cleanup(bm.Stop)
-
-	gaa, err := genesisMiner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	gmi, err := full.StateMinerInfo(ctx, gaa, types.EmptyTSK)
-	require.NoError(t, err)
-
-	testm := n[0].Stb(ctx, t, TestSpt, gmi.Owner)
-
-	ta, err := testm.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	tid, err := address.IDFromAddress(ta)
-	require.NoError(t, err)
-
-	require.Equal(t, uint64(1001), tid)
-}

api/test/test.go

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

api/test/util.go

@@ -1,87 +0,0 @@
-package test
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/filecoin-project/go-state-types/abi"
-
-	"github.com/filecoin-project/go-address"
-	lapi "github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/miner"
-)
-
-func SendFunds(ctx context.Context, t *testing.T, sender TestNode, addr address.Address, amount abi.TokenAmount) {
-	senderAddr, err := sender.WalletDefaultAddress(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	msg := &types.Message{
-		From:  senderAddr,
-		To:    addr,
-		Value: amount,
-	}
-
-	sm, err := sender.MpoolPushMessage(ctx, msg, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	res, err := sender.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.Receipt.ExitCode != 0 {
-		t.Fatal("did not successfully send money")
-	}
-}
-
-func MineUntilBlock(ctx context.Context, t *testing.T, fn TestNode, sn TestStorageNode, cb func(abi.ChainEpoch)) {
-	for i := 0; i < 1000; i++ {
-		var success bool
-		var err error
-		var epoch abi.ChainEpoch
-		wait := make(chan struct{})
-		mineErr := sn.MineOne(ctx, miner.MineReq{
-			Done: func(win bool, ep abi.ChainEpoch, e error) {
-				success = win
-				err = e
-				epoch = ep
-				wait <- struct{}{}
-			},
-		})
-		if mineErr != nil {
-			t.Fatal(mineErr)
-		}
-		<-wait
-		if err != nil {
-			t.Fatal(err)
-		}
-		if success {
-			// Wait until it shows up on the given full nodes ChainHead
-			nloops := 50
-			for i := 0; i < nloops; i++ {
-				ts, err := fn.ChainHead(ctx)
-				if err != nil {
-					t.Fatal(err)
-				}
-				if ts.Height() == epoch {
-					break
-				}
-				if i == nloops-1 {
-					t.Fatal("block never managed to sync to node")
-				}
-				time.Sleep(time.Millisecond * 10)
-			}
-
-			if cb != nil {
-				cb(epoch)
-			}
-			return
-		}
-		t.Log("did not mine block, trying again", i)
-	}
-	t.Fatal("failed to mine 1000 times in a row...")
-}

api/types.go

@@ -5,6 +5,9 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/lotus/chain/types"
+
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
@@ -116,3 +119,79 @@ type ConnMgrInfo struct {
 	Tags      map[string]int
 	Conns     map[string]time.Time
 }
+
+type NodeStatus struct {
+	SyncStatus  NodeSyncStatus
+	PeerStatus  NodePeerStatus
+	ChainStatus NodeChainStatus
+}
+
+type NodeSyncStatus struct {
+	Epoch  uint64
+	Behind uint64
+}
+
+type NodePeerStatus struct {
+	PeersToPublishMsgs   int
+	PeersToPublishBlocks int
+}
+
+type NodeChainStatus struct {
+	BlocksPerTipsetLast100      float64
+	BlocksPerTipsetLastFinality float64
+}
+
+type CheckStatusCode int
+
+//go:generate go run golang.org/x/tools/cmd/stringer -type=CheckStatusCode -trimprefix=CheckStatus
+const (
+	_ CheckStatusCode = iota
+	// Message Checks
+	CheckStatusMessageSerialize
+	CheckStatusMessageSize
+	CheckStatusMessageValidity
+	CheckStatusMessageMinGas
+	CheckStatusMessageMinBaseFee
+	CheckStatusMessageBaseFee
+	CheckStatusMessageBaseFeeLowerBound
+	CheckStatusMessageBaseFeeUpperBound
+	CheckStatusMessageGetStateNonce
+	CheckStatusMessageNonce
+	CheckStatusMessageGetStateBalance
+	CheckStatusMessageBalance
+)
+
+type CheckStatus struct {
+	Code CheckStatusCode
+	OK   bool
+	Err  string
+	Hint map[string]interface{}
+}
+
+type MessageCheckStatus struct {
+	Cid cid.Cid
+	CheckStatus
+}
+
+type MessagePrototype struct {
+	Message    types.Message
+	ValidNonce bool
+}
+
+type RetrievalInfo struct {
+	PayloadCID   cid.Cid
+	ID           retrievalmarket.DealID
+	PieceCID     *cid.Cid
+	PricePerByte abi.TokenAmount
+	UnsealPrice  abi.TokenAmount
+
+	Status        retrievalmarket.DealStatus
+	Message       string // more information about deal state, particularly errors
+	Provider      peer.ID
+	BytesReceived uint64
+	BytesPaidFor  uint64
+	TotalPaid     abi.TokenAmount
+
+	TransferChannelID *datatransfer.ChannelID
+	DataTransfer      *DataTransferChannel
+}

api/v0api/full.go

@@ -304,6 +304,8 @@ type FullNode interface {
 	ClientRemoveImport(ctx context.Context, importID multistore.StoreID) error //perm:admin
 	// ClientStartDeal proposes a deal with a miner.
 	ClientStartDeal(ctx context.Context, params *api.StartDealParams) (*cid.Cid, error) //perm:admin
+	// ClientStatelessDeal fire-and-forget-proposes an offline deal to a miner without subsequent tracking.
+	ClientStatelessDeal(ctx context.Context, params *api.StartDealParams) (*cid.Cid, error) //perm:write
 	// ClientGetDealInfo returns the latest information about a given deal.
 	ClientGetDealInfo(context.Context, cid.Cid) (*api.DealInfo, error) //perm:read
 	// ClientListDeals returns information about the deals made by the local client.
@@ -324,6 +326,10 @@ type FullNode interface {
 	// of status updates.
 	ClientRetrieveWithEvents(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) (<-chan marketevents.RetrievalEvent, error) //perm:admin
 	// ClientQueryAsk returns a signed StorageAsk from the specified miner.
+	// ClientListRetrievals returns information about retrievals made by the local client
+	ClientListRetrievals(ctx context.Context) ([]api.RetrievalInfo, error) //perm:write
+	// ClientGetRetrievalUpdates returns status of updated retrieval deals
+	ClientGetRetrievalUpdates(ctx context.Context) (<-chan api.RetrievalInfo, error)                         //perm:write
 	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) (api.DataCIDSize, error) //perm:read
@@ -623,7 +629,7 @@ type FullNode interface {
 	// proposal. This method of approval can be used to ensure you only approve
 	// exactly the transaction you think you are.
 	// It takes the following params: <multisig address>, <proposed message ID>, <proposer address>, <recipient address>, <value to transfer>,
-	// <sender address of the approve msg>, <method to call in the proposed message>, <params to include in the proposed message>
+	// <sender address of the approve msg>, <method to call in the approved message>, <params to include in the proposed message>
 	MsigApproveTxnHash(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error) //perm:sign
 
 	// MsigCancel cancels a previously-proposed multisig message

api/v0api/gateway.go

@@ -63,6 +63,7 @@ type Gateway interface {
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 	StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*api.MsgLookup, error)
 	WalletBalance(context.Context, address.Address) (types.BigInt, error)
+	Version(context.Context) (api.APIVersion, error)
 }
 
 var _ Gateway = *new(FullNode)

api/v0api/proxy_gen.go

@@ -97,6 +97,8 @@ type FullNodeStruct struct {
 
 		ClientGetDealUpdates func(p0 context.Context) (<-chan api.DealInfo, error) `perm:"write"`
 
+		ClientGetRetrievalUpdates func(p0 context.Context) (<-chan api.RetrievalInfo, error) `perm:"write"`
+
 		ClientHasLocal func(p0 context.Context, p1 cid.Cid) (bool, error) `perm:"write"`
 
 		ClientImport func(p0 context.Context, p1 api.FileRef) (*api.ImportRes, error) `perm:"admin"`
@@ -107,6 +109,8 @@ type FullNodeStruct struct {
 
 		ClientListImports func(p0 context.Context) ([]api.Import, error) `perm:"write"`
 
+		ClientListRetrievals func(p0 context.Context) ([]api.RetrievalInfo, error) `perm:"write"`
+
 		ClientMinerQueryOffer func(p0 context.Context, p1 address.Address, p2 cid.Cid, p3 *cid.Cid) (api.QueryOffer, error) `perm:"read"`
 
 		ClientQueryAsk func(p0 context.Context, p1 peer.ID, p2 address.Address) (*storagemarket.StorageAsk, error) `perm:"read"`
@@ -123,6 +127,8 @@ type FullNodeStruct struct {
 
 		ClientStartDeal func(p0 context.Context, p1 *api.StartDealParams) (*cid.Cid, error) `perm:"admin"`
 
+		ClientStatelessDeal func(p0 context.Context, p1 *api.StartDealParams) (*cid.Cid, error) `perm:"write"`
+
 		CreateBackup func(p0 context.Context, p1 string) error `perm:"admin"`
 
 		GasEstimateFeeCap func(p0 context.Context, p1 *types.Message, p2 int64, p3 types.TipSetKey) (types.BigInt, error) `perm:"read"`
@@ -443,6 +449,8 @@ type GatewayStruct struct {
 
 		StateWaitMsg func(p0 context.Context, p1 cid.Cid, p2 uint64) (*api.MsgLookup, error) ``
 
+		Version func(p0 context.Context) (api.APIVersion, error) ``
+
 		WalletBalance func(p0 context.Context, p1 address.Address) (types.BigInt, error) ``
 	}
 }
@@ -714,6 +722,14 @@ func (s *FullNodeStub) ClientGetDealUpdates(p0 context.Context) (<-chan api.Deal
 	return nil, xerrors.New("method not supported")
 }
 
+func (s *FullNodeStruct) ClientGetRetrievalUpdates(p0 context.Context) (<-chan api.RetrievalInfo, error) {
+	return s.Internal.ClientGetRetrievalUpdates(p0)
+}
+
+func (s *FullNodeStub) ClientGetRetrievalUpdates(p0 context.Context) (<-chan api.RetrievalInfo, error) {
+	return nil, xerrors.New("method not supported")
+}
+
 func (s *FullNodeStruct) ClientHasLocal(p0 context.Context, p1 cid.Cid) (bool, error) {
 	return s.Internal.ClientHasLocal(p0, p1)
 }
@@ -754,6 +770,14 @@ func (s *FullNodeStub) ClientListImports(p0 context.Context) ([]api.Import, erro
 	return *new([]api.Import), xerrors.New("method not supported")
 }
 
+func (s *FullNodeStruct) ClientListRetrievals(p0 context.Context) ([]api.RetrievalInfo, error) {
+	return s.Internal.ClientListRetrievals(p0)
+}
+
+func (s *FullNodeStub) ClientListRetrievals(p0 context.Context) ([]api.RetrievalInfo, error) {
+	return *new([]api.RetrievalInfo), xerrors.New("method not supported")
+}
+
 func (s *FullNodeStruct) ClientMinerQueryOffer(p0 context.Context, p1 address.Address, p2 cid.Cid, p3 *cid.Cid) (api.QueryOffer, error) {
 	return s.Internal.ClientMinerQueryOffer(p0, p1, p2, p3)
 }
@@ -818,6 +842,14 @@ func (s *FullNodeStub) ClientStartDeal(p0 context.Context, p1 *api.StartDealPara
 	return nil, xerrors.New("method not supported")
 }
 
+func (s *FullNodeStruct) ClientStatelessDeal(p0 context.Context, p1 *api.StartDealParams) (*cid.Cid, error) {
+	return s.Internal.ClientStatelessDeal(p0, p1)
+}
+
+func (s *FullNodeStub) ClientStatelessDeal(p0 context.Context, p1 *api.StartDealParams) (*cid.Cid, error) {
+	return nil, xerrors.New("method not supported")
+}
+
 func (s *FullNodeStruct) CreateBackup(p0 context.Context, p1 string) error {
 	return s.Internal.CreateBackup(p0, p1)
 }
@@ -2066,6 +2098,14 @@ func (s *GatewayStub) StateWaitMsg(p0 context.Context, p1 cid.Cid, p2 uint64) (*
 	return nil, xerrors.New("method not supported")
 }
 
+func (s *GatewayStruct) Version(p0 context.Context) (api.APIVersion, error) {
+	return s.Internal.Version(p0)
+}
+
+func (s *GatewayStub) Version(p0 context.Context) (api.APIVersion, error) {
+	return *new(api.APIVersion), xerrors.New("method not supported")
+}
+
 func (s *GatewayStruct) WalletBalance(p0 context.Context, p1 address.Address) (types.BigInt, error) {
 	return s.Internal.WalletBalance(p0, p1)
 }

api/v0api/v1_wrapper.go

@@ -3,7 +3,9 @@ package v0api
 import (
 	"context"
 
+	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/chain/types"
+	"golang.org/x/xerrors"
 
 	"github.com/ipfs/go-cid"
 
@@ -57,4 +59,129 @@ func (w *WrapperV1Full) Version(ctx context.Context) (api.APIVersion, error) {
 	return ver, nil
 }
 
+func (w *WrapperV1Full) executePrototype(ctx context.Context, p *api.MessagePrototype) (cid.Cid, error) {
+	sm, err := w.FullNode.MpoolPushMessage(ctx, &p.Message, nil)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("pushing message: %w", err)
+	}
+
+	return sm.Cid(), nil
+}
+func (w *WrapperV1Full) MsigCreate(ctx context.Context, req uint64, addrs []address.Address, duration abi.ChainEpoch, val types.BigInt, src address.Address, gp types.BigInt) (cid.Cid, error) {
+
+	p, err := w.FullNode.MsigCreate(ctx, req, addrs, duration, val, src, gp)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("creating prototype: %w", err)
+	}
+
+	return w.executePrototype(ctx, p)
+}
+
+func (w *WrapperV1Full) MsigPropose(ctx context.Context, msig address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+
+	p, err := w.FullNode.MsigPropose(ctx, msig, to, amt, src, method, params)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("creating prototype: %w", err)
+	}
+
+	return w.executePrototype(ctx, p)
+}
+func (w *WrapperV1Full) MsigApprove(ctx context.Context, msig address.Address, txID uint64, src address.Address) (cid.Cid, error) {
+
+	p, err := w.FullNode.MsigApprove(ctx, msig, txID, src)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("creating prototype: %w", err)
+	}
+
+	return w.executePrototype(ctx, p)
+}
+
+func (w *WrapperV1Full) MsigApproveTxnHash(ctx context.Context, msig address.Address, txID uint64, proposer address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+	p, err := w.FullNode.MsigApproveTxnHash(ctx, msig, txID, proposer, to, amt, src, method, params)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("creating prototype: %w", err)
+	}
+
+	return w.executePrototype(ctx, p)
+}
+
+func (w *WrapperV1Full) MsigCancel(ctx context.Context, msig address.Address, txID uint64, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+	p, err := w.FullNode.MsigCancel(ctx, msig, txID, to, amt, src, method, params)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("creating prototype: %w", err)
+	}
+
+	return w.executePrototype(ctx, p)
+}
+
+func (w *WrapperV1Full) MsigAddPropose(ctx context.Context, msig address.Address, src address.Address, newAdd address.Address, inc bool) (cid.Cid, error) {
+
+	p, err := w.FullNode.MsigAddPropose(ctx, msig, src, newAdd, inc)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("creating prototype: %w", err)
+	}
+
+	return w.executePrototype(ctx, p)
+}
+
+func (w *WrapperV1Full) MsigAddApprove(ctx context.Context, msig address.Address, src address.Address, txID uint64, proposer address.Address, newAdd address.Address, inc bool) (cid.Cid, error) {
+
+	p, err := w.FullNode.MsigAddApprove(ctx, msig, src, txID, proposer, newAdd, inc)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("creating prototype: %w", err)
+	}
+
+	return w.executePrototype(ctx, p)
+}
+
+func (w *WrapperV1Full) MsigAddCancel(ctx context.Context, msig address.Address, src address.Address, txID uint64, newAdd address.Address, inc bool) (cid.Cid, error) {
+
+	p, err := w.FullNode.MsigAddCancel(ctx, msig, src, txID, newAdd, inc)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("creating prototype: %w", err)
+	}
+
+	return w.executePrototype(ctx, p)
+}
+
+func (w *WrapperV1Full) MsigSwapPropose(ctx context.Context, msig address.Address, src address.Address, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+
+	p, err := w.FullNode.MsigSwapPropose(ctx, msig, src, oldAdd, newAdd)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("creating prototype: %w", err)
+	}
+
+	return w.executePrototype(ctx, p)
+}
+
+func (w *WrapperV1Full) MsigSwapApprove(ctx context.Context, msig address.Address, src address.Address, txID uint64, proposer address.Address, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+
+	p, err := w.FullNode.MsigSwapApprove(ctx, msig, src, txID, proposer, oldAdd, newAdd)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("creating prototype: %w", err)
+	}
+
+	return w.executePrototype(ctx, p)
+}
+
+func (w *WrapperV1Full) MsigSwapCancel(ctx context.Context, msig address.Address, src address.Address, txID uint64, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+
+	p, err := w.FullNode.MsigSwapCancel(ctx, msig, src, txID, oldAdd, newAdd)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("creating prototype: %w", err)
+	}
+
+	return w.executePrototype(ctx, p)
+}
+
+func (w *WrapperV1Full) MsigRemoveSigner(ctx context.Context, msig address.Address, proposer address.Address, toRemove address.Address, decrease bool) (cid.Cid, error) {
+
+	p, err := w.FullNode.MsigRemoveSigner(ctx, msig, proposer, toRemove, decrease)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("creating prototype: %w", err)
+	}
+
+	return w.executePrototype(ctx, p)
+}
+
 var _ FullNode = &WrapperV1Full{}

api/version.go

@@ -57,8 +57,8 @@ var (
 	FullAPIVersion0 = newVer(1, 3, 0)
 	FullAPIVersion1 = newVer(2, 1, 0)
 
-	MinerAPIVersion0  = newVer(1, 0, 1)
-	WorkerAPIVersion0 = newVer(1, 0, 0)
+	MinerAPIVersion0  = newVer(1, 1, 0)
+	WorkerAPIVersion0 = newVer(1, 1, 0)
 )
 
 //nolint:varcheck,deadcode

api/wrap.go

@@ -26,6 +26,27 @@ func Wrap(proxyT, wrapperT, impl interface{}) interface{} {
 		}))
 	}
 
+	for i := 0; i < proxy.Elem().NumField(); i++ {
+		if proxy.Elem().Type().Field(i).Name == "Internal" {
+			continue
+		}
+
+		subProxy := proxy.Elem().Field(i).FieldByName("Internal")
+		for i := 0; i < ri.NumMethod(); i++ {
+			mt := ri.Type().Method(i)
+			if subProxy.FieldByName(mt.Name).Kind() == reflect.Invalid {
+				continue
+			}
+
+			fn := ri.Method(i)
+			of := subProxy.FieldByName(mt.Name)
+
+			subProxy.FieldByName(mt.Name).Set(reflect.MakeFunc(of.Type(), func(args []reflect.Value) (results []reflect.Value) {
+				return fn.Call(args)
+			}))
+		}
+	}
+
 	wp := reflect.New(reflect.TypeOf(wrapperT).Elem())
 	wp.Elem().Field(0).Set(proxy)
 	return wp.Interface()

blockstore/splitstore/splitstore.go

@@ -406,6 +406,11 @@ func (s *SplitStore) Close() error {
 }
 
 func (s *SplitStore) HeadChange(_, apply []*types.TipSet) error {
+	// Revert only.
+	if len(apply) == 0 {
+		return nil
+	}
+
 	s.mx.Lock()
 	curTs := apply[len(apply)-1]
 	epoch := curTs.Height()

blockstore/splitstore/splitstore_test.go

@@ -27,7 +27,7 @@ func init() {
 }
 
 func testSplitStore(t *testing.T, cfg *Config) {
-	chain := &mockChain{}
+	chain := &mockChain{t: t}
 	// genesis
 	genBlock := mock.MkBlock(nil, 0, 0)
 	genTs := mock.TipSet(genBlock)
@@ -169,6 +169,9 @@ func testSplitStore(t *testing.T, cfg *Config) {
 			t.Errorf("expected %d hot blocks, but got %d", 7, hotCnt)
 		}
 	}
+
+	// Make sure we can revert without panicking.
+	chain.revert(2)
 }
 
 func TestSplitStoreSimpleCompaction(t *testing.T) {
@@ -191,6 +194,8 @@ func TestSplitStoreFullCompactionWithGC(t *testing.T) {
 }
 
 type mockChain struct {
+	t testing.TB
+
 	sync.Mutex
 	tipsets  []*types.TipSet
 	listener func(revert []*types.TipSet, apply []*types.TipSet) error
@@ -204,7 +209,26 @@ func (c *mockChain) push(ts *types.TipSet) {
 	if c.listener != nil {
 		err := c.listener(nil, []*types.TipSet{ts})
 		if err != nil {
-			log.Errorf("mockchain: error dispatching listener: %s", err)
+			c.t.Errorf("mockchain: error dispatching listener: %s", err)
+		}
+	}
+}
+
+func (c *mockChain) revert(count int) {
+	c.Lock()
+	revert := make([]*types.TipSet, count)
+	if count > len(c.tipsets) {
+		c.Unlock()
+		c.t.Fatalf("not enough tipsets to revert")
+	}
+	copy(revert, c.tipsets[len(c.tipsets)-count:])
+	c.tipsets = c.tipsets[:len(c.tipsets)-count]
+	c.Unlock()
+
+	if c.listener != nil {
+		err := c.listener(revert, nil)
+		if err != nil {
+			c.t.Errorf("mockchain: error dispatching listener: %s", err)
 		}
 	}
 }

build/bootstrap.go

@@ -2,28 +2,32 @@ package build
 
 import (
 	"context"
+	"embed"
+	"path"
 	"strings"
 
 	"github.com/filecoin-project/lotus/lib/addrutil"
 
-	rice "github.com/GeertJohan/go.rice"
 	"github.com/libp2p/go-libp2p-core/peer"
 )
 
+//go:embed bootstrap
+var bootstrapfs embed.FS
+
 func BuiltinBootstrap() ([]peer.AddrInfo, error) {
 	if DisableBuiltinAssets {
 		return nil, nil
 	}
-
-	b := rice.MustFindBox("bootstrap")
-
 	if BootstrappersFile != "" {
-		spi := b.MustString(BootstrappersFile)
-		if spi == "" {
+		spi, err := bootstrapfs.ReadFile(path.Join("bootstrap", BootstrappersFile))
+		if err != nil {
+			return nil, err
+		}
+		if len(spi) == 0 {
 			return nil, nil
 		}
 
-		return addrutil.ParseAddresses(context.TODO(), strings.Split(strings.TrimSpace(spi), "\n"))
+		return addrutil.ParseAddresses(context.TODO(), strings.Split(strings.TrimSpace(string(spi)), "\n"))
 	}
 
 	return nil, nil

build/bootstrap/butterflynet.pi

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

build/bootstrap/calibnet.pi

@@ -1,4 +1,4 @@
-/dns4/bootstrap-0.calibration.fildev.network/tcp/1347/p2p/12D3KooWRLZAseMo9h7fRD6ojn6YYDXHsBSavX5YmjBZ9ngtAEec
-/dns4/bootstrap-1.calibration.fildev.network/tcp/1347/p2p/12D3KooWJFtDXgZEQMEkjJPSrbfdvh2xfjVKrXeNFG1t8ioJXAzv
-/dns4/bootstrap-2.calibration.fildev.network/tcp/1347/p2p/12D3KooWP1uB9Lo7yCA3S17TD4Y5wStP5Nk7Vqh53m8GsFjkyujD
-/dns4/bootstrap-3.calibration.fildev.network/tcp/1347/p2p/12D3KooWLrPM4WPK1YRGPCUwndWcDX8GCYgms3DiuofUmxwvhMCn
+/dns4/bootstrap-0.calibration.fildev.network/tcp/1347/p2p/12D3KooWJkikQQkxS58spo76BYzFt4fotaT5NpV2zngvrqm4u5ow
+/dns4/bootstrap-1.calibration.fildev.network/tcp/1347/p2p/12D3KooWLce5FDHR4EX4CrYavphA5xS3uDsX6aoowXh5tzDUxJav
+/dns4/bootstrap-2.calibration.fildev.network/tcp/1347/p2p/12D3KooWA9hFfQG9GjP6bHeuQQbMD3FDtZLdW1NayxKXUT26PQZu
+/dns4/bootstrap-3.calibration.fildev.network/tcp/1347/p2p/12D3KooWMHDi3LVTFG8Szqogt7RkNXvonbQYqSazxBx41A5aeuVz

build/bootstrap/interopnet.pi

@@ -0,0 +1,2 @@
+/dns4/bootstrap-0.interop.fildev.network/tcp/1347/p2p/12D3KooWN86wA54r3v9M8bBYbc1vK9W1ehHDxVGPRaoeUYuXF8R7
+/dns4/bootstrap-1.interop.fildev.network/tcp/1347/p2p/12D3KooWNZ41kev8mtBZgWe43qam1VX9pJyf87jnaisQP2urZZ2M

build/genesis.go

@@ -1,23 +1,23 @@
 package build
 
 import (
-	rice "github.com/GeertJohan/go.rice"
+	"embed"
+	"path"
+
 	logging "github.com/ipfs/go-log/v2"
 )
 
 // moved from now-defunct build/paramfetch.go
 var log = logging.Logger("build")
 
+//go:embed genesis
+var genesisfs embed.FS
+
 func MaybeGenesis() []byte {
-	builtinGen, err := rice.FindBox("genesis")
+	genBytes, err := genesisfs.ReadFile(path.Join("genesis", GenesisFile))
 	if err != nil {
 		log.Warnf("loading built-in genesis: %s", err)
 		return nil
 	}
-	genBytes, err := builtinGen.Bytes(GenesisFile)
-	if err != nil {
-		log.Warnf("loading built-in genesis: %s", err)
-	}
-
 	return genBytes
 }

build/openrpc.go

@@ -3,13 +3,15 @@ package build
 import (
 	"bytes"
 	"compress/gzip"
+	"embed"
 	"encoding/json"
 
-	rice "github.com/GeertJohan/go.rice"
-
 	apitypes "github.com/filecoin-project/lotus/api/types"
 )
 
+//go:embed openrpc
+var openrpcfs embed.FS
+
 func mustReadGzippedOpenRPCDocument(data []byte) apitypes.OpenRPCDocument {
 	zr, err := gzip.NewReader(bytes.NewBuffer(data))
 	if err != nil {
@@ -28,16 +30,25 @@ func mustReadGzippedOpenRPCDocument(data []byte) apitypes.OpenRPCDocument {
 }
 
 func OpenRPCDiscoverJSON_Full() apitypes.OpenRPCDocument {
-	data := rice.MustFindBox("openrpc").MustBytes("full.json.gz")
+	data, err := openrpcfs.ReadFile("openrpc/full.json.gz")
+	if err != nil {
+		panic(err)
+	}
 	return mustReadGzippedOpenRPCDocument(data)
 }
 
 func OpenRPCDiscoverJSON_Miner() apitypes.OpenRPCDocument {
-	data := rice.MustFindBox("openrpc").MustBytes("miner.json.gz")
+	data, err := openrpcfs.ReadFile("openrpc/miner.json.gz")
+	if err != nil {
+		panic(err)
+	}
 	return mustReadGzippedOpenRPCDocument(data)
 }
 
 func OpenRPCDiscoverJSON_Worker() apitypes.OpenRPCDocument {
-	data := rice.MustFindBox("openrpc").MustBytes("worker.json.gz")
+	data, err := openrpcfs.ReadFile("openrpc/worker.json.gz")
+	if err != nil {
+		panic(err)
+	}
 	return mustReadGzippedOpenRPCDocument(data)
 }

build/parameters.go

@@ -1,7 +1,19 @@
 package build
 
-import rice "github.com/GeertJohan/go.rice"
+import (
+	_ "embed"
+)
+
+//go:embed proof-params/parameters.json
+var params []byte
+
+//go:embed proof-params/srs-inner-product.json
+var srs []byte
 
 func ParametersJSON() []byte {
-	return rice.MustFindBox("proof-params").MustBytes("parameters.json")
+	return params
+}
+
+func SrsJSON() []byte {
+	return srs
 }

build/params_2k.go

@@ -24,27 +24,29 @@ var UpgradeIgnitionHeight = abi.ChainEpoch(-2)
 var UpgradeRefuelHeight = abi.ChainEpoch(-3)
 var UpgradeTapeHeight = abi.ChainEpoch(-4)
 
-var UpgradeActorsV2Height = abi.ChainEpoch(10)
-var UpgradeLiftoffHeight = abi.ChainEpoch(-5)
+var UpgradeAssemblyHeight = abi.ChainEpoch(-5)
+var UpgradeLiftoffHeight = abi.ChainEpoch(-6)
 
-var UpgradeKumquatHeight = abi.ChainEpoch(15)
-var UpgradeCalicoHeight = abi.ChainEpoch(20)
-var UpgradePersianHeight = abi.ChainEpoch(25)
-var UpgradeOrangeHeight = abi.ChainEpoch(27)
-var UpgradeClausHeight = abi.ChainEpoch(30)
+var UpgradeKumquatHeight = abi.ChainEpoch(-7)
+var UpgradeCalicoHeight = abi.ChainEpoch(-8)
+var UpgradePersianHeight = abi.ChainEpoch(-9)
+var UpgradeOrangeHeight = abi.ChainEpoch(-10)
+var UpgradeClausHeight = abi.ChainEpoch(-11)
 
-var UpgradeActorsV3Height = abi.ChainEpoch(35)
+var UpgradeTrustHeight = abi.ChainEpoch(-12)
 
-var UpgradeNorwegianHeight = abi.ChainEpoch(40)
+var UpgradeNorwegianHeight = abi.ChainEpoch(-13)
 
-var UpgradeActorsV4Height = abi.ChainEpoch(45)
+var UpgradeTurboHeight = abi.ChainEpoch(-14)
+
+var UpgradeHyperdriveHeight = abi.ChainEpoch(-15)
 
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0: DrandMainnet,
 }
 
 func init() {
-	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1, abi.RegisteredSealProof_StackedDrg8MiBV1)
 	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
 	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
 	policy.SetPreCommitChallengeDelay(abi.ChainEpoch(10))
@@ -68,16 +70,17 @@ func init() {
 	UpgradeIgnitionHeight = getUpgradeHeight("LOTUS_IGNITION_HEIGHT", UpgradeIgnitionHeight)
 	UpgradeRefuelHeight = getUpgradeHeight("LOTUS_REFUEL_HEIGHT", UpgradeRefuelHeight)
 	UpgradeTapeHeight = getUpgradeHeight("LOTUS_TAPE_HEIGHT", UpgradeTapeHeight)
-	UpgradeActorsV2Height = getUpgradeHeight("LOTUS_ACTORSV2_HEIGHT", UpgradeActorsV2Height)
+	UpgradeAssemblyHeight = getUpgradeHeight("LOTUS_ACTORSV2_HEIGHT", UpgradeAssemblyHeight)
 	UpgradeLiftoffHeight = getUpgradeHeight("LOTUS_LIFTOFF_HEIGHT", UpgradeLiftoffHeight)
 	UpgradeKumquatHeight = getUpgradeHeight("LOTUS_KUMQUAT_HEIGHT", UpgradeKumquatHeight)
 	UpgradeCalicoHeight = getUpgradeHeight("LOTUS_CALICO_HEIGHT", UpgradeCalicoHeight)
 	UpgradePersianHeight = getUpgradeHeight("LOTUS_PERSIAN_HEIGHT", UpgradePersianHeight)
 	UpgradeOrangeHeight = getUpgradeHeight("LOTUS_ORANGE_HEIGHT", UpgradeOrangeHeight)
 	UpgradeClausHeight = getUpgradeHeight("LOTUS_CLAUS_HEIGHT", UpgradeClausHeight)
-	UpgradeActorsV3Height = getUpgradeHeight("LOTUS_ACTORSV3_HEIGHT", UpgradeActorsV3Height)
+	UpgradeTrustHeight = getUpgradeHeight("LOTUS_ACTORSV3_HEIGHT", UpgradeTrustHeight)
 	UpgradeNorwegianHeight = getUpgradeHeight("LOTUS_NORWEGIAN_HEIGHT", UpgradeNorwegianHeight)
-	UpgradeActorsV4Height = getUpgradeHeight("LOTUS_ACTORSV4_HEIGHT", UpgradeActorsV4Height)
+	UpgradeTurboHeight = getUpgradeHeight("LOTUS_ACTORSV4_HEIGHT", UpgradeTurboHeight)
+	UpgradeHyperdriveHeight = getUpgradeHeight("LOTUS_HYPERDRIVE_HEIGHT", UpgradeHyperdriveHeight)
 
 	BuildType |= Build2k
 }

build/params_butterfly.go

@@ -23,7 +23,7 @@ const UpgradeSmokeHeight = -2
 const UpgradeIgnitionHeight = -3
 const UpgradeRefuelHeight = -4
 
-var UpgradeActorsV2Height = abi.ChainEpoch(30)
+var UpgradeAssemblyHeight = abi.ChainEpoch(30)
 
 const UpgradeTapeHeight = 60
 const UpgradeLiftoffHeight = -5
@@ -32,9 +32,10 @@ const UpgradeCalicoHeight = 120
 const UpgradePersianHeight = 150
 const UpgradeClausHeight = 180
 const UpgradeOrangeHeight = 210
-const UpgradeActorsV3Height = 240
-const UpgradeNorwegianHeight = UpgradeActorsV3Height + (builtin2.EpochsInHour * 12)
-const UpgradeActorsV4Height = 8922
+const UpgradeTrustHeight = 240
+const UpgradeNorwegianHeight = UpgradeTrustHeight + (builtin2.EpochsInHour * 12)
+const UpgradeTurboHeight = 8922
+const UpgradeHyperdriveHeight = 9999999
 
 func init() {
 	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2 << 30))

build/params_calibnet.go

@@ -25,7 +25,7 @@ const UpgradeSmokeHeight = -2
 const UpgradeIgnitionHeight = -3
 const UpgradeRefuelHeight = -4
 
-var UpgradeActorsV2Height = abi.ChainEpoch(30)
+var UpgradeAssemblyHeight = abi.ChainEpoch(30)
 
 const UpgradeTapeHeight = 60
 
@@ -33,17 +33,20 @@ const UpgradeLiftoffHeight = -5
 
 const UpgradeKumquatHeight = 90
 
-const UpgradeCalicoHeight = 100
+const UpgradeCalicoHeight = 120
 const UpgradePersianHeight = UpgradeCalicoHeight + (builtin2.EpochsInHour * 1)
 
-const UpgradeClausHeight = 250
+const UpgradeClausHeight = 270
 
 const UpgradeOrangeHeight = 300
 
-const UpgradeActorsV3Height = 600
-const UpgradeNorwegianHeight = 114000
+const UpgradeTrustHeight = 330
 
-const UpgradeActorsV4Height = 193789
+const UpgradeNorwegianHeight = 360
+
+const UpgradeTurboHeight = 390
+
+const UpgradeHyperdriveHeight = 420
 
 func init() {
 	policy.SetConsensusMinerMinPower(abi.NewStoragePower(32 << 30))

build/params_interop.go

@@ -0,0 +1,104 @@
+// +build interopnet
+
+package build
+
+import (
+	"os"
+	"strconv"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+)
+
+const BootstrappersFile = "interopnet.pi"
+const GenesisFile = "interopnet.car"
+
+var UpgradeBreezeHeight = abi.ChainEpoch(-1)
+
+const BreezeGasTampingDuration = 0
+
+var UpgradeSmokeHeight = abi.ChainEpoch(-1)
+var UpgradeIgnitionHeight = abi.ChainEpoch(-2)
+var UpgradeRefuelHeight = abi.ChainEpoch(-3)
+var UpgradeTapeHeight = abi.ChainEpoch(-4)
+
+var UpgradeAssemblyHeight = abi.ChainEpoch(-5)
+var UpgradeLiftoffHeight = abi.ChainEpoch(-6)
+
+var UpgradeKumquatHeight = abi.ChainEpoch(-7)
+var UpgradeCalicoHeight = abi.ChainEpoch(-8)
+var UpgradePersianHeight = abi.ChainEpoch(-9)
+var UpgradeOrangeHeight = abi.ChainEpoch(-10)
+var UpgradeClausHeight = abi.ChainEpoch(-11)
+
+var UpgradeTrustHeight = abi.ChainEpoch(-12)
+
+var UpgradeNorwegianHeight = abi.ChainEpoch(-13)
+
+var UpgradeTurboHeight = abi.ChainEpoch(-14)
+
+var UpgradeHyperdriveHeight = abi.ChainEpoch(-15)
+
+var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+	0: DrandMainnet,
+}
+
+func init() {
+	policy.SetSupportedProofTypes(
+		abi.RegisteredSealProof_StackedDrg2KiBV1,
+		abi.RegisteredSealProof_StackedDrg8MiBV1,
+		abi.RegisteredSealProof_StackedDrg512MiBV1,
+	)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
+	policy.SetPreCommitChallengeDelay(abi.ChainEpoch(10))
+
+	getUpgradeHeight := func(ev string, def abi.ChainEpoch) abi.ChainEpoch {
+		hs, found := os.LookupEnv(ev)
+		if found {
+			h, err := strconv.Atoi(hs)
+			if err != nil {
+				log.Panicf("failed to parse %s env var", ev)
+			}
+
+			return abi.ChainEpoch(h)
+		}
+
+		return def
+	}
+
+	UpgradeBreezeHeight = getUpgradeHeight("LOTUS_BREEZE_HEIGHT", UpgradeBreezeHeight)
+	UpgradeSmokeHeight = getUpgradeHeight("LOTUS_SMOKE_HEIGHT", UpgradeSmokeHeight)
+	UpgradeIgnitionHeight = getUpgradeHeight("LOTUS_IGNITION_HEIGHT", UpgradeIgnitionHeight)
+	UpgradeRefuelHeight = getUpgradeHeight("LOTUS_REFUEL_HEIGHT", UpgradeRefuelHeight)
+	UpgradeTapeHeight = getUpgradeHeight("LOTUS_TAPE_HEIGHT", UpgradeTapeHeight)
+	UpgradeAssemblyHeight = getUpgradeHeight("LOTUS_ACTORSV2_HEIGHT", UpgradeAssemblyHeight)
+	UpgradeLiftoffHeight = getUpgradeHeight("LOTUS_LIFTOFF_HEIGHT", UpgradeLiftoffHeight)
+	UpgradeKumquatHeight = getUpgradeHeight("LOTUS_KUMQUAT_HEIGHT", UpgradeKumquatHeight)
+	UpgradeCalicoHeight = getUpgradeHeight("LOTUS_CALICO_HEIGHT", UpgradeCalicoHeight)
+	UpgradePersianHeight = getUpgradeHeight("LOTUS_PERSIAN_HEIGHT", UpgradePersianHeight)
+	UpgradeOrangeHeight = getUpgradeHeight("LOTUS_ORANGE_HEIGHT", UpgradeOrangeHeight)
+	UpgradeClausHeight = getUpgradeHeight("LOTUS_CLAUS_HEIGHT", UpgradeClausHeight)
+	UpgradeTrustHeight = getUpgradeHeight("LOTUS_ACTORSV3_HEIGHT", UpgradeTrustHeight)
+	UpgradeNorwegianHeight = getUpgradeHeight("LOTUS_NORWEGIAN_HEIGHT", UpgradeNorwegianHeight)
+	UpgradeTurboHeight = getUpgradeHeight("LOTUS_ACTORSV4_HEIGHT", UpgradeTurboHeight)
+	UpgradeHyperdriveHeight = getUpgradeHeight("LOTUS_HYPERDRIVE_HEIGHT", UpgradeHyperdriveHeight)
+
+	BuildType |= BuildInteropnet
+	SetAddressNetwork(address.Testnet)
+	Devnet = true
+}
+
+const BlockDelaySecs = uint64(builtin2.EpochDurationSeconds)
+
+const PropagationDelaySecs = uint64(6)
+
+// BootstrapPeerThreshold is the minimum number peers we need to track for a sync worker to start
+const BootstrapPeerThreshold = 2
+
+var WhitelistedBlock = cid.Undef

build/params_mainnet.go

@@ -4,6 +4,7 @@
 // +build !calibnet
 // +build !nerpanet
 // +build !butterflynet
+// +build !interopnet
 
 package build
 
@@ -13,7 +14,6 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
 
@@ -34,7 +34,7 @@ const UpgradeSmokeHeight = 51000
 const UpgradeIgnitionHeight = 94000
 const UpgradeRefuelHeight = 130800
 
-const UpgradeActorsV2Height = 138720
+const UpgradeAssemblyHeight = 138720
 
 const UpgradeTapeHeight = 140760
 
@@ -51,30 +51,27 @@ const UpgradePersianHeight = UpgradeCalicoHeight + (builtin2.EpochsInHour * 60)
 const UpgradeOrangeHeight = 336458
 
 // 2020-12-22T02:00:00Z
-const UpgradeClausHeight = 343200
+var UpgradeClausHeight = abi.ChainEpoch(343200)
 
 // 2021-03-04T00:00:30Z
-var UpgradeActorsV3Height = abi.ChainEpoch(550321)
+const UpgradeTrustHeight = 550321
 
 // 2021-04-12T22:00:00Z
 const UpgradeNorwegianHeight = 665280
 
 // 2021-04-29T06:00:00Z
-var UpgradeActorsV4Height = abi.ChainEpoch(712320)
+const UpgradeTurboHeight = 712320
+
+// 2021-06-30T22:00:00Z
+var UpgradeHyperdriveHeight = abi.ChainEpoch(892800)
 
 func init() {
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 40))
-
 	if os.Getenv("LOTUS_USE_TEST_ADDRESSES") != "1" {
 		SetAddressNetwork(address.Mainnet)
 	}
 
-	if os.Getenv("LOTUS_DISABLE_V3_ACTOR_MIGRATION") == "1" {
-		UpgradeActorsV3Height = math.MaxInt64
-	}
-
-	if os.Getenv("LOTUS_DISABLE_V4_ACTOR_MIGRATION") == "1" {
-		UpgradeActorsV4Height = math.MaxInt64
+	if os.Getenv("LOTUS_DISABLE_HYPERDRIVE") == "1" {
+		UpgradeHyperdriveHeight = math.MaxInt64
 	}
 
 	Devnet = false

build/params_nerpanet.go

@@ -27,7 +27,7 @@ const UpgradeRefuelHeight = -3
 
 const UpgradeLiftoffHeight = -5
 
-const UpgradeActorsV2Height = 30 // critical: the network can bootstrap from v1 only
+const UpgradeAssemblyHeight = 30 // critical: the network can bootstrap from v1 only
 const UpgradeTapeHeight = 60
 
 const UpgradeKumquatHeight = 90
@@ -39,9 +39,10 @@ const UpgradeClausHeight = 250
 
 const UpgradeOrangeHeight = 300
 
-const UpgradeActorsV3Height = 600
+const UpgradeTrustHeight = 600
 const UpgradeNorwegianHeight = 201000
-const UpgradeActorsV4Height = 203000
+const UpgradeTurboHeight = 203000
+const UpgradeHyperdriveHeight = 999999999
 
 func init() {
 	// Minimum block production power is set to 4 TiB

build/params_shared_vals.go

@@ -25,7 +25,7 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network
 
 const AllowableClockDriftSecs = uint64(1)
-const NewestNetworkVersion = network.Version11
+const NewestNetworkVersion = network.Version13
 const ActorUpgradeNetworkVersion = network.Version4
 
 // Epochs

build/params_testground.go

@@ -82,20 +82,21 @@ var (
 	UpgradeBreezeHeight      abi.ChainEpoch = -1
 	BreezeGasTampingDuration abi.ChainEpoch = 0
 
-	UpgradeSmokeHeight     abi.ChainEpoch = -1
-	UpgradeIgnitionHeight  abi.ChainEpoch = -2
-	UpgradeRefuelHeight    abi.ChainEpoch = -3
-	UpgradeTapeHeight      abi.ChainEpoch = -4
-	UpgradeActorsV2Height  abi.ChainEpoch = 10
-	UpgradeLiftoffHeight   abi.ChainEpoch = -5
-	UpgradeKumquatHeight   abi.ChainEpoch = -6
-	UpgradeCalicoHeight    abi.ChainEpoch = -7
-	UpgradePersianHeight   abi.ChainEpoch = -8
-	UpgradeOrangeHeight    abi.ChainEpoch = -9
-	UpgradeClausHeight     abi.ChainEpoch = -10
-	UpgradeActorsV3Height  abi.ChainEpoch = -11
-	UpgradeNorwegianHeight abi.ChainEpoch = -12
-	UpgradeActorsV4Height  abi.ChainEpoch = -13
+	UpgradeSmokeHeight      abi.ChainEpoch = -1
+	UpgradeIgnitionHeight   abi.ChainEpoch = -2
+	UpgradeRefuelHeight     abi.ChainEpoch = -3
+	UpgradeTapeHeight       abi.ChainEpoch = -4
+	UpgradeAssemblyHeight   abi.ChainEpoch = 10
+	UpgradeLiftoffHeight    abi.ChainEpoch = -5
+	UpgradeKumquatHeight    abi.ChainEpoch = -6
+	UpgradeCalicoHeight     abi.ChainEpoch = -7
+	UpgradePersianHeight    abi.ChainEpoch = -8
+	UpgradeOrangeHeight     abi.ChainEpoch = -9
+	UpgradeClausHeight      abi.ChainEpoch = -10
+	UpgradeTrustHeight      abi.ChainEpoch = -11
+	UpgradeNorwegianHeight  abi.ChainEpoch = -12
+	UpgradeTurboHeight      abi.ChainEpoch = -13
+	UpgradeHyperdriveHeight abi.ChainEpoch = -13
 
 	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 		0: DrandMainnet,

build/proof-params/srs-inner-product.json

@@ -0,0 +1,7 @@
+{
+  "v28-fil-inner-product-v1.srs": {
+    "cid": "Qmdq44DjcQnFfU3PJcdX7J49GCqcUYszr1TxMbHtAkvQ3g",
+    "digest": "ae20310138f5ba81451d723f858e3797",
+    "sector_size": 0
+  }
+}

build/tools.go

@@ -6,4 +6,5 @@ import (
 	_ "github.com/GeertJohan/go.rice/rice"
 	_ "github.com/golang/mock/mockgen"
 	_ "github.com/whyrusleeping/bencher"
+	_ "golang.org/x/tools/cmd/stringer"
 )

build/version.go

@@ -1,14 +1,17 @@
 package build
 
+import "os"
+
 var CurrentCommit string
 var BuildType int
 
 const (
-	BuildDefault  = 0
-	BuildMainnet  = 0x1
-	Build2k       = 0x2
-	BuildDebug    = 0x3
-	BuildCalibnet = 0x4
+	BuildDefault    = 0
+	BuildMainnet    = 0x1
+	Build2k         = 0x2
+	BuildDebug      = 0x3
+	BuildCalibnet   = 0x4
+	BuildInteropnet = 0x5
 )
 
 func buildType() string {
@@ -23,14 +26,20 @@ func buildType() string {
 		return "+debug"
 	case BuildCalibnet:
 		return "+calibnet"
+	case BuildInteropnet:
+		return "+interopnet"
 	default:
 		return "+huh?"
 	}
 }
 
 // BuildVersion is the local build version, set by build system
-const BuildVersion = "1.9.0"
+const BuildVersion = "1.11.0"
 
 func UserVersion() string {
+	if os.Getenv("LOTUS_VERSION_IGNORE_COMMIT") == "1" {
+		return BuildVersion
+	}
+
 	return BuildVersion + buildType() + CurrentCommit
 }

chain/actors/agen/main.go

@@ -0,0 +1,224 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strconv"
+	"text/template"
+
+	lotusactors "github.com/filecoin-project/lotus/chain/actors"
+
+	"golang.org/x/xerrors"
+)
+
+var actors = map[string][]int{
+	"account":  lotusactors.Versions,
+	"cron":     lotusactors.Versions,
+	"init":     lotusactors.Versions,
+	"market":   lotusactors.Versions,
+	"miner":    lotusactors.Versions,
+	"multisig": lotusactors.Versions,
+	"paych":    lotusactors.Versions,
+	"power":    lotusactors.Versions,
+	"system":   lotusactors.Versions,
+	"reward":   lotusactors.Versions,
+	"verifreg": lotusactors.Versions,
+}
+
+func main() {
+	if err := generateAdapters(); err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	if err := generatePolicy("chain/actors/policy/policy.go"); err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	if err := generateBuiltin("chain/actors/builtin/builtin.go"); err != nil {
+		fmt.Println(err)
+		return
+	}
+}
+
+func generateAdapters() error {
+	for act, versions := range actors {
+		actDir := filepath.Join("chain/actors/builtin", act)
+
+		if err := generateState(actDir); err != nil {
+			return err
+		}
+
+		if err := generateMessages(actDir); err != nil {
+			return err
+		}
+
+		{
+			af, err := ioutil.ReadFile(filepath.Join(actDir, "actor.go.template"))
+			if err != nil {
+				return xerrors.Errorf("loading actor template: %w", err)
+			}
+
+			tpl := template.Must(template.New("").Funcs(template.FuncMap{
+				"import": func(v int) string { return getVersionImports()[v] },
+			}).Parse(string(af)))
+
+			var b bytes.Buffer
+
+			err = tpl.Execute(&b, map[string]interface{}{
+				"versions":      versions,
+				"latestVersion": lotusactors.LatestVersion,
+			})
+			if err != nil {
+				return err
+			}
+
+			if err := ioutil.WriteFile(filepath.Join(actDir, fmt.Sprintf("%s.go", act)), b.Bytes(), 0666); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func generateState(actDir string) error {
+	af, err := ioutil.ReadFile(filepath.Join(actDir, "state.go.template"))
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil // skip
+		}
+
+		return xerrors.Errorf("loading state adapter template: %w", err)
+	}
+
+	for _, version := range lotusactors.Versions {
+		tpl := template.Must(template.New("").Funcs(template.FuncMap{}).Parse(string(af)))
+
+		var b bytes.Buffer
+
+		err := tpl.Execute(&b, map[string]interface{}{
+			"v":      version,
+			"import": getVersionImports()[version],
+		})
+		if err != nil {
+			return err
+		}
+
+		if err := ioutil.WriteFile(filepath.Join(actDir, fmt.Sprintf("v%d.go", version)), b.Bytes(), 0666); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func generateMessages(actDir string) error {
+	af, err := ioutil.ReadFile(filepath.Join(actDir, "message.go.template"))
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil // skip
+		}
+
+		return xerrors.Errorf("loading message adapter template: %w", err)
+	}
+
+	for _, version := range lotusactors.Versions {
+		tpl := template.Must(template.New("").Funcs(template.FuncMap{}).Parse(string(af)))
+
+		var b bytes.Buffer
+
+		err := tpl.Execute(&b, map[string]interface{}{
+			"v":      version,
+			"import": getVersionImports()[version],
+		})
+		if err != nil {
+			return err
+		}
+
+		if err := ioutil.WriteFile(filepath.Join(actDir, fmt.Sprintf("message%d.go", version)), b.Bytes(), 0666); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func generatePolicy(policyPath string) error {
+
+	pf, err := ioutil.ReadFile(policyPath + ".template")
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil // skip
+		}
+
+		return xerrors.Errorf("loading policy template file: %w", err)
+	}
+
+	tpl := template.Must(template.New("").Funcs(template.FuncMap{
+		"import": func(v int) string { return getVersionImports()[v] },
+	}).Parse(string(pf)))
+	var b bytes.Buffer
+
+	err = tpl.Execute(&b, map[string]interface{}{
+		"versions":      lotusactors.Versions,
+		"latestVersion": lotusactors.LatestVersion,
+	})
+	if err != nil {
+		return err
+	}
+
+	if err := ioutil.WriteFile(policyPath, b.Bytes(), 0666); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func generateBuiltin(builtinPath string) error {
+
+	bf, err := ioutil.ReadFile(builtinPath + ".template")
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil // skip
+		}
+
+		return xerrors.Errorf("loading builtin template file: %w", err)
+	}
+
+	tpl := template.Must(template.New("").Funcs(template.FuncMap{
+		"import": func(v int) string { return getVersionImports()[v] },
+	}).Parse(string(bf)))
+	var b bytes.Buffer
+
+	err = tpl.Execute(&b, map[string]interface{}{
+		"versions":      lotusactors.Versions,
+		"latestVersion": lotusactors.LatestVersion,
+	})
+	if err != nil {
+		return err
+	}
+
+	if err := ioutil.WriteFile(builtinPath, b.Bytes(), 0666); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func getVersionImports() map[int]string {
+	versionImports := make(map[int]string, lotusactors.LatestVersion)
+	for _, v := range lotusactors.Versions {
+		if v == 0 {
+			versionImports[v] = "/"
+		} else {
+			versionImports[v] = "/v" + strconv.Itoa(v) + "/"
+		}
+	}
+
+	return versionImports
+}

chain/actors/builtin/account/account.go

@@ -1,6 +1,7 @@
 package account
 
 import (
+	"github.com/filecoin-project/lotus/chain/actors"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
@@ -12,44 +13,111 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+
 	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+
+	builtin5 "github.com/filecoin-project/specs-actors/v5/actors/builtin"
 )
 
 func init() {
+
 	builtin.RegisterActorState(builtin0.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
+
 	builtin.RegisterActorState(builtin2.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
+
 	builtin.RegisterActorState(builtin3.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+
 	builtin.RegisterActorState(builtin4.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load4(store, root)
 	})
+
+	builtin.RegisterActorState(builtin5.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load5(store, root)
+	})
 }
 
 var Methods = builtin4.MethodsAccount
 
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
+
 	case builtin0.AccountActorCodeID:
 		return load0(store, act.Head)
+
 	case builtin2.AccountActorCodeID:
 		return load2(store, act.Head)
+
 	case builtin3.AccountActorCodeID:
 		return load3(store, act.Head)
+
 	case builtin4.AccountActorCodeID:
 		return load4(store, act.Head)
+
+	case builtin5.AccountActorCodeID:
+		return load5(store, act.Head)
+
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
+func MakeState(store adt.Store, av actors.Version, addr address.Address) (State, error) {
+	switch av {
+
+	case actors.Version0:
+		return make0(store, addr)
+
+	case actors.Version2:
+		return make2(store, addr)
+
+	case actors.Version3:
+		return make3(store, addr)
+
+	case actors.Version4:
+		return make4(store, addr)
+
+	case actors.Version5:
+		return make5(store, addr)
+
+	}
+	return nil, xerrors.Errorf("unknown actor version %d", av)
+}
+
+func GetActorCodeID(av actors.Version) (cid.Cid, error) {
+	switch av {
+
+	case actors.Version0:
+		return builtin0.AccountActorCodeID, nil
+
+	case actors.Version2:
+		return builtin2.AccountActorCodeID, nil
+
+	case actors.Version3:
+		return builtin3.AccountActorCodeID, nil
+
+	case actors.Version4:
+		return builtin4.AccountActorCodeID, nil
+
+	case actors.Version5:
+		return builtin5.AccountActorCodeID, nil
+
+	}
+
+	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
+}
+
 type State interface {
 	cbor.Marshaler
 
 	PubkeyAddress() (address.Address, error)
+	GetState() interface{}
 }

chain/actors/builtin/account/actor.go.template

@@ -0,0 +1,64 @@
+package account
+
+import (
+	"github.com/filecoin-project/lotus/chain/actors"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/types"
+{{range .versions}}
+	builtin{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/builtin"
+{{end}}
+)
+
+func init() {
+{{range .versions}}
+	builtin.RegisterActorState(builtin{{.}}.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load{{.}}(store, root)
+	})
+{{end}}}
+
+var Methods = builtin4.MethodsAccount
+
+func Load(store adt.Store, act *types.Actor) (State, error) {
+	switch act.Code {
+{{range .versions}}
+	case builtin{{.}}.AccountActorCodeID:
+		return load{{.}}(store, act.Head)
+{{end}}
+	}
+	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
+}
+
+func MakeState(store adt.Store, av actors.Version, addr address.Address) (State, error) {
+	switch av {
+{{range .versions}}
+	case actors.Version{{.}}:
+		return make{{.}}(store, addr)
+{{end}}
+}
+	return nil, xerrors.Errorf("unknown actor version %d", av)
+}
+
+func GetActorCodeID(av actors.Version) (cid.Cid, error) {
+	switch av {
+{{range .versions}}
+	case actors.Version{{.}}:
+		return builtin{{.}}.AccountActorCodeID, nil
+{{end}}
+	}
+
+	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
+}
+
+type State interface {
+	cbor.Marshaler
+
+	PubkeyAddress() (address.Address, error)
+	GetState() interface{}
+}

chain/actors/builtin/account/state.go.template

@@ -0,0 +1,40 @@
+package account
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
+	account{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/builtin/account"
+)
+
+var _ State = (*state{{.v}})(nil)
+
+func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
+	out := state{{.v}}{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+func make{{.v}}(store adt.Store, addr address.Address) (State, error) {
+	out := state{{.v}}{store: store}
+	out.State = account{{.v}}.State{Address:addr}
+	return &out, nil
+}
+
+type state{{.v}} struct {
+	account{{.v}}.State
+	store adt.Store
+}
+
+func (s *state{{.v}}) PubkeyAddress() (address.Address, error) {
+	return s.Address, nil
+}
+
+func (s *state{{.v}}) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/account/v0.go

@@ -20,6 +20,12 @@ func load0(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
+func make0(store adt.Store, addr address.Address) (State, error) {
+	out := state0{store: store}
+	out.State = account0.State{Address: addr}
+	return &out, nil
+}
+
 type state0 struct {
 	account0.State
 	store adt.Store
@@ -28,3 +34,7 @@ type state0 struct {
 func (s *state0) PubkeyAddress() (address.Address, error) {
 	return s.Address, nil
 }
+
+func (s *state0) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/account/v2.go

@@ -20,6 +20,12 @@ func load2(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
+func make2(store adt.Store, addr address.Address) (State, error) {
+	out := state2{store: store}
+	out.State = account2.State{Address: addr}
+	return &out, nil
+}
+
 type state2 struct {
 	account2.State
 	store adt.Store
@@ -28,3 +34,7 @@ type state2 struct {
 func (s *state2) PubkeyAddress() (address.Address, error) {
 	return s.Address, nil
 }
+
+func (s *state2) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/account/v3.go

@@ -20,6 +20,12 @@ func load3(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
+func make3(store adt.Store, addr address.Address) (State, error) {
+	out := state3{store: store}
+	out.State = account3.State{Address: addr}
+	return &out, nil
+}
+
 type state3 struct {
 	account3.State
 	store adt.Store
@@ -28,3 +34,7 @@ type state3 struct {
 func (s *state3) PubkeyAddress() (address.Address, error) {
 	return s.Address, nil
 }
+
+func (s *state3) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/account/v4.go

@@ -20,6 +20,12 @@ func load4(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
+func make4(store adt.Store, addr address.Address) (State, error) {
+	out := state4{store: store}
+	out.State = account4.State{Address: addr}
+	return &out, nil
+}
+
 type state4 struct {
 	account4.State
 	store adt.Store
@@ -28,3 +34,7 @@ type state4 struct {
 func (s *state4) PubkeyAddress() (address.Address, error) {
 	return s.Address, nil
 }
+
+func (s *state4) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/account/v5.go

@@ -0,0 +1,40 @@
+package account
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
+	account5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/account"
+)
+
+var _ State = (*state5)(nil)
+
+func load5(store adt.Store, root cid.Cid) (State, error) {
+	out := state5{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+func make5(store adt.Store, addr address.Address) (State, error) {
+	out := state5{store: store}
+	out.State = account5.State{Address: addr}
+	return &out, nil
+}
+
+type state5 struct {
+	account5.State
+	store adt.Store
+}
+
+func (s *state5) PubkeyAddress() (address.Address, error) {
+	return s.Address, nil
+}
+
+func (s *state5) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/builtin.go

@@ -6,9 +6,19 @@ import (
 	"golang.org/x/xerrors"
 
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
+
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+	smoothing2 "github.com/filecoin-project/specs-actors/v2/actors/util/smoothing"
+
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	smoothing3 "github.com/filecoin-project/specs-actors/v3/actors/util/smoothing"
+
 	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+	smoothing4 "github.com/filecoin-project/specs-actors/v4/actors/util/smoothing"
+
+	builtin5 "github.com/filecoin-project/specs-actors/v5/actors/builtin"
+	smoothing5 "github.com/filecoin-project/specs-actors/v5/actors/util/smoothing"
 
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
@@ -16,62 +26,70 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/types"
 
-	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
-	smoothing2 "github.com/filecoin-project/specs-actors/v2/actors/util/smoothing"
-	smoothing3 "github.com/filecoin-project/specs-actors/v3/actors/util/smoothing"
-	smoothing4 "github.com/filecoin-project/specs-actors/v4/actors/util/smoothing"
-
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
+	miner5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/miner"
+	proof5 "github.com/filecoin-project/specs-actors/v5/actors/runtime/proof"
 )
 
-var SystemActorAddr = builtin0.SystemActorAddr
-var BurntFundsActorAddr = builtin0.BurntFundsActorAddr
-var CronActorAddr = builtin0.CronActorAddr
+var SystemActorAddr = builtin5.SystemActorAddr
+var BurntFundsActorAddr = builtin5.BurntFundsActorAddr
+var CronActorAddr = builtin5.CronActorAddr
 var SaftAddress = makeAddress("t0122")
 var ReserveAddress = makeAddress("t090")
 var RootVerifierAddress = makeAddress("t080")
 
 var (
-	ExpectedLeadersPerEpoch = builtin0.ExpectedLeadersPerEpoch
+	ExpectedLeadersPerEpoch = builtin5.ExpectedLeadersPerEpoch
 )
 
 const (
-	EpochDurationSeconds = builtin0.EpochDurationSeconds
-	EpochsInDay          = builtin0.EpochsInDay
-	SecondsInDay         = builtin0.SecondsInDay
+	EpochDurationSeconds = builtin5.EpochDurationSeconds
+	EpochsInDay          = builtin5.EpochsInDay
+	SecondsInDay         = builtin5.SecondsInDay
 )
 
 const (
-	MethodSend        = builtin4.MethodSend
-	MethodConstructor = builtin4.MethodConstructor
+	MethodSend        = builtin5.MethodSend
+	MethodConstructor = builtin5.MethodConstructor
 )
 
-// These are all just type aliases across actor versions 0, 2, & 3. In the future, that might change
+// These are all just type aliases across actor versions. In the future, that might change
 // and we might need to do something fancier.
-type SectorInfo = proof0.SectorInfo
-type PoStProof = proof0.PoStProof
+type SectorInfo = proof5.SectorInfo
+type PoStProof = proof5.PoStProof
 type FilterEstimate = smoothing0.FilterEstimate
 
-func FromV0FilterEstimate(v0 smoothing0.FilterEstimate) FilterEstimate {
-	return (FilterEstimate)(v0) //nolint:unconvert
+func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight, verifiedWeight abi.DealWeight) abi.StoragePower {
+	return miner5.QAPowerForWeight(size, duration, dealWeight, verifiedWeight)
 }
 
-// Doesn't change between actors v0, v2, and v3.
-func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight, verifiedWeight abi.DealWeight) abi.StoragePower {
-	return miner0.QAPowerForWeight(size, duration, dealWeight, verifiedWeight)
+func FromV0FilterEstimate(v0 smoothing0.FilterEstimate) FilterEstimate {
+
+	return (FilterEstimate)(v0) //nolint:unconvert
+
 }
 
 func FromV2FilterEstimate(v2 smoothing2.FilterEstimate) FilterEstimate {
+
 	return (FilterEstimate)(v2)
+
 }
 
 func FromV3FilterEstimate(v3 smoothing3.FilterEstimate) FilterEstimate {
+
 	return (FilterEstimate)(v3)
+
 }
 
 func FromV4FilterEstimate(v4 smoothing4.FilterEstimate) FilterEstimate {
+
 	return (FilterEstimate)(v4)
+
+}
+
+func FromV5FilterEstimate(v5 smoothing5.FilterEstimate) FilterEstimate {
+
+	return (FilterEstimate)(v5)
+
 }
 
 type ActorStateLoader func(store adt.Store, root cid.Cid) (cbor.Marshaler, error)
@@ -92,52 +110,150 @@ func Load(store adt.Store, act *types.Actor) (cbor.Marshaler, error) {
 
 func ActorNameByCode(c cid.Cid) string {
 	switch {
+
 	case builtin0.IsBuiltinActor(c):
 		return builtin0.ActorNameByCode(c)
+
 	case builtin2.IsBuiltinActor(c):
 		return builtin2.ActorNameByCode(c)
+
 	case builtin3.IsBuiltinActor(c):
 		return builtin3.ActorNameByCode(c)
+
 	case builtin4.IsBuiltinActor(c):
 		return builtin4.ActorNameByCode(c)
+
+	case builtin5.IsBuiltinActor(c):
+		return builtin5.ActorNameByCode(c)
+
 	default:
 		return "<unknown>"
 	}
 }
 
 func IsBuiltinActor(c cid.Cid) bool {
-	return builtin0.IsBuiltinActor(c) ||
-		builtin2.IsBuiltinActor(c) ||
-		builtin3.IsBuiltinActor(c) ||
-		builtin4.IsBuiltinActor(c)
+
+	if builtin0.IsBuiltinActor(c) {
+		return true
+	}
+
+	if builtin2.IsBuiltinActor(c) {
+		return true
+	}
+
+	if builtin3.IsBuiltinActor(c) {
+		return true
+	}
+
+	if builtin4.IsBuiltinActor(c) {
+		return true
+	}
+
+	if builtin5.IsBuiltinActor(c) {
+		return true
+	}
+
+	return false
 }
 
 func IsAccountActor(c cid.Cid) bool {
-	return c == builtin0.AccountActorCodeID ||
-		c == builtin2.AccountActorCodeID ||
-		c == builtin3.AccountActorCodeID ||
-		c == builtin4.AccountActorCodeID
+
+	if c == builtin0.AccountActorCodeID {
+		return true
+	}
+
+	if c == builtin2.AccountActorCodeID {
+		return true
+	}
+
+	if c == builtin3.AccountActorCodeID {
+		return true
+	}
+
+	if c == builtin4.AccountActorCodeID {
+		return true
+	}
+
+	if c == builtin5.AccountActorCodeID {
+		return true
+	}
+
+	return false
 }
 
 func IsStorageMinerActor(c cid.Cid) bool {
-	return c == builtin0.StorageMinerActorCodeID ||
-		c == builtin2.StorageMinerActorCodeID ||
-		c == builtin3.StorageMinerActorCodeID ||
-		c == builtin4.StorageMinerActorCodeID
+
+	if c == builtin0.StorageMinerActorCodeID {
+		return true
+	}
+
+	if c == builtin2.StorageMinerActorCodeID {
+		return true
+	}
+
+	if c == builtin3.StorageMinerActorCodeID {
+		return true
+	}
+
+	if c == builtin4.StorageMinerActorCodeID {
+		return true
+	}
+
+	if c == builtin5.StorageMinerActorCodeID {
+		return true
+	}
+
+	return false
 }
 
 func IsMultisigActor(c cid.Cid) bool {
-	return c == builtin0.MultisigActorCodeID ||
-		c == builtin2.MultisigActorCodeID ||
-		c == builtin3.MultisigActorCodeID ||
-		c == builtin4.MultisigActorCodeID
+
+	if c == builtin0.MultisigActorCodeID {
+		return true
+	}
+
+	if c == builtin2.MultisigActorCodeID {
+		return true
+	}
+
+	if c == builtin3.MultisigActorCodeID {
+		return true
+	}
+
+	if c == builtin4.MultisigActorCodeID {
+		return true
+	}
+
+	if c == builtin5.MultisigActorCodeID {
+		return true
+	}
+
+	return false
 }
 
 func IsPaymentChannelActor(c cid.Cid) bool {
-	return c == builtin0.PaymentChannelActorCodeID ||
-		c == builtin2.PaymentChannelActorCodeID ||
-		c == builtin3.PaymentChannelActorCodeID ||
-		c == builtin4.PaymentChannelActorCodeID
+
+	if c == builtin0.PaymentChannelActorCodeID {
+		return true
+	}
+
+	if c == builtin2.PaymentChannelActorCodeID {
+		return true
+	}
+
+	if c == builtin3.PaymentChannelActorCodeID {
+		return true
+	}
+
+	if c == builtin4.PaymentChannelActorCodeID {
+		return true
+	}
+
+	if c == builtin5.PaymentChannelActorCodeID {
+		return true
+	}
+
+	return false
 }
 
 func makeAddress(addr string) address.Address {

chain/actors/builtin/builtin.go.template

@@ -0,0 +1,144 @@
+package builtin
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	{{range .versions}}
+		builtin{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/builtin"
+		smoothing{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/util/smoothing"
+	{{end}}
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/cbor"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+
+	miner{{.latestVersion}} "github.com/filecoin-project/specs-actors{{import .latestVersion}}actors/builtin/miner"
+	proof{{.latestVersion}} "github.com/filecoin-project/specs-actors{{import .latestVersion}}actors/runtime/proof"
+)
+
+var SystemActorAddr = builtin{{.latestVersion}}.SystemActorAddr
+var BurntFundsActorAddr = builtin{{.latestVersion}}.BurntFundsActorAddr
+var CronActorAddr = builtin{{.latestVersion}}.CronActorAddr
+var SaftAddress = makeAddress("t0122")
+var ReserveAddress = makeAddress("t090")
+var RootVerifierAddress = makeAddress("t080")
+
+var (
+	ExpectedLeadersPerEpoch = builtin{{.latestVersion}}.ExpectedLeadersPerEpoch
+)
+
+const (
+	EpochDurationSeconds = builtin{{.latestVersion}}.EpochDurationSeconds
+	EpochsInDay          = builtin{{.latestVersion}}.EpochsInDay
+	SecondsInDay         = builtin{{.latestVersion}}.SecondsInDay
+)
+
+const (
+	MethodSend        = builtin{{.latestVersion}}.MethodSend
+	MethodConstructor = builtin{{.latestVersion}}.MethodConstructor
+)
+
+// These are all just type aliases across actor versions. In the future, that might change
+// and we might need to do something fancier.
+type SectorInfo = proof{{.latestVersion}}.SectorInfo
+type PoStProof = proof{{.latestVersion}}.PoStProof
+type FilterEstimate = smoothing0.FilterEstimate
+
+func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight, verifiedWeight abi.DealWeight) abi.StoragePower {
+	return miner{{.latestVersion}}.QAPowerForWeight(size, duration, dealWeight, verifiedWeight)
+}
+
+{{range .versions}}
+	func FromV{{.}}FilterEstimate(v{{.}} smoothing{{.}}.FilterEstimate) FilterEstimate {
+	{{if (eq . 0)}}
+		return (FilterEstimate)(v{{.}}) //nolint:unconvert
+	{{else}}
+		return (FilterEstimate)(v{{.}})
+	{{end}}
+	}
+{{end}}
+
+type ActorStateLoader func(store adt.Store, root cid.Cid) (cbor.Marshaler, error)
+
+var ActorStateLoaders = make(map[cid.Cid]ActorStateLoader)
+
+func RegisterActorState(code cid.Cid, loader ActorStateLoader) {
+	ActorStateLoaders[code] = loader
+}
+
+func Load(store adt.Store, act *types.Actor) (cbor.Marshaler, error) {
+	loader, found := ActorStateLoaders[act.Code]
+	if !found {
+		return nil, xerrors.Errorf("unknown actor code %s", act.Code)
+	}
+	return loader(store, act.Head)
+}
+
+func ActorNameByCode(c cid.Cid) string {
+	switch {
+		{{range .versions}}
+			case builtin{{.}}.IsBuiltinActor(c):
+			return builtin{{.}}.ActorNameByCode(c)
+		{{end}}
+	default:
+		return "<unknown>"
+	}
+}
+
+func IsBuiltinActor(c cid.Cid) bool {
+	{{range .versions}}
+		if builtin{{.}}.IsBuiltinActor(c) {
+			return true
+		}
+	{{end}}
+	return false
+}
+
+func IsAccountActor(c cid.Cid) bool {
+	{{range .versions}}
+		if c == builtin{{.}}.AccountActorCodeID {
+			return true
+		}
+	{{end}}
+	return false
+}
+
+func IsStorageMinerActor(c cid.Cid) bool {
+	{{range .versions}}
+		if c == builtin{{.}}.StorageMinerActorCodeID {
+			return true
+		}
+	{{end}}
+	return false
+}
+
+func IsMultisigActor(c cid.Cid) bool {
+	{{range .versions}}
+		if c == builtin{{.}}.MultisigActorCodeID {
+			return true
+		}
+	{{end}}
+	return false
+}
+
+func IsPaymentChannelActor(c cid.Cid) bool {
+	{{range .versions}}
+		if c == builtin{{.}}.PaymentChannelActorCodeID {
+			return true
+		}
+	{{end}}
+	return false
+}
+
+func makeAddress(addr string) address.Address {
+	ret, err := address.NewFromString(addr)
+	if err != nil {
+		panic(err)
+	}
+
+	return ret
+}

chain/actors/builtin/cron/actor.go.template

@@ -0,0 +1,42 @@
+package cron
+
+import (
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"golang.org/x/xerrors"
+	"github.com/ipfs/go-cid"
+{{range .versions}}
+	builtin{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/builtin"
+{{end}}
+)
+
+func MakeState(store adt.Store, av actors.Version) (State, error) {
+	switch av {
+{{range .versions}}
+	case actors.Version{{.}}:
+		return make{{.}}(store)
+{{end}}
+}
+	return nil, xerrors.Errorf("unknown actor version %d", av)
+}
+
+func GetActorCodeID(av actors.Version) (cid.Cid, error) {
+	switch av {
+{{range .versions}}
+	case actors.Version{{.}}:
+		return builtin{{.}}.CronActorCodeID, nil
+{{end}}
+	}
+
+	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
+}
+
+var (
+	Address = builtin{{.latestVersion}}.CronActorAddr
+	Methods = builtin{{.latestVersion}}.MethodsCron
+)
+
+
+type State interface {
+	GetState() interface{}
+}

chain/actors/builtin/cron/cron.go

@@ -1,10 +1,72 @@
 package cron
 
 import (
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+
+	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+
 	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+
+	builtin5 "github.com/filecoin-project/specs-actors/v5/actors/builtin"
 )
 
+func MakeState(store adt.Store, av actors.Version) (State, error) {
+	switch av {
+
+	case actors.Version0:
+		return make0(store)
+
+	case actors.Version2:
+		return make2(store)
+
+	case actors.Version3:
+		return make3(store)
+
+	case actors.Version4:
+		return make4(store)
+
+	case actors.Version5:
+		return make5(store)
+
+	}
+	return nil, xerrors.Errorf("unknown actor version %d", av)
+}
+
+func GetActorCodeID(av actors.Version) (cid.Cid, error) {
+	switch av {
+
+	case actors.Version0:
+		return builtin0.CronActorCodeID, nil
+
+	case actors.Version2:
+		return builtin2.CronActorCodeID, nil
+
+	case actors.Version3:
+		return builtin3.CronActorCodeID, nil
+
+	case actors.Version4:
+		return builtin4.CronActorCodeID, nil
+
+	case actors.Version5:
+		return builtin5.CronActorCodeID, nil
+
+	}
+
+	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
+}
+
 var (
-	Address = builtin4.CronActorAddr
-	Methods = builtin4.MethodsCron
+	Address = builtin5.CronActorAddr
+	Methods = builtin5.MethodsCron
 )
+
+type State interface {
+	GetState() interface{}
+}

chain/actors/builtin/cron/state.go.template

@@ -0,0 +1,35 @@
+package cron
+
+import (
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
+	cron{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/builtin/cron"
+)
+
+var _ State = (*state{{.v}})(nil)
+
+func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
+	out := state{{.v}}{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+func make{{.v}}(store adt.Store) (State, error) {
+	out := state{{.v}}{store: store}
+	out.State = *cron{{.v}}.ConstructState(cron{{.v}}.BuiltInEntries())
+	return &out, nil
+}
+
+type state{{.v}} struct {
+	cron{{.v}}.State
+	store adt.Store
+}
+
+func (s *state{{.v}}) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/cron/v0.go

@@ -0,0 +1,35 @@
+package cron
+
+import (
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
+	cron0 "github.com/filecoin-project/specs-actors/actors/builtin/cron"
+)
+
+var _ State = (*state0)(nil)
+
+func load0(store adt.Store, root cid.Cid) (State, error) {
+	out := state0{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+func make0(store adt.Store) (State, error) {
+	out := state0{store: store}
+	out.State = *cron0.ConstructState(cron0.BuiltInEntries())
+	return &out, nil
+}
+
+type state0 struct {
+	cron0.State
+	store adt.Store
+}
+
+func (s *state0) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/cron/v2.go

@@ -0,0 +1,35 @@
+package cron
+
+import (
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
+	cron2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/cron"
+)
+
+var _ State = (*state2)(nil)
+
+func load2(store adt.Store, root cid.Cid) (State, error) {
+	out := state2{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+func make2(store adt.Store) (State, error) {
+	out := state2{store: store}
+	out.State = *cron2.ConstructState(cron2.BuiltInEntries())
+	return &out, nil
+}
+
+type state2 struct {
+	cron2.State
+	store adt.Store
+}
+
+func (s *state2) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/cron/v3.go

@@ -0,0 +1,35 @@
+package cron
+
+import (
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
+	cron3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/cron"
+)
+
+var _ State = (*state3)(nil)
+
+func load3(store adt.Store, root cid.Cid) (State, error) {
+	out := state3{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+func make3(store adt.Store) (State, error) {
+	out := state3{store: store}
+	out.State = *cron3.ConstructState(cron3.BuiltInEntries())
+	return &out, nil
+}
+
+type state3 struct {
+	cron3.State
+	store adt.Store
+}
+
+func (s *state3) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/cron/v4.go

@@ -0,0 +1,35 @@
+package cron
+
+import (
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
+	cron4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/cron"
+)
+
+var _ State = (*state4)(nil)
+
+func load4(store adt.Store, root cid.Cid) (State, error) {
+	out := state4{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+func make4(store adt.Store) (State, error) {
+	out := state4{store: store}
+	out.State = *cron4.ConstructState(cron4.BuiltInEntries())
+	return &out, nil
+}
+
+type state4 struct {
+	cron4.State
+	store adt.Store
+}
+
+func (s *state4) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/cron/v5.go

@@ -0,0 +1,35 @@
+package cron
+
+import (
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
+	cron5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/cron"
+)
+
+var _ State = (*state5)(nil)
+
+func load5(store adt.Store, root cid.Cid) (State, error) {
+	out := state5{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+func make5(store adt.Store) (State, error) {
+	out := state5{store: store}
+	out.State = *cron5.ConstructState(cron5.BuiltInEntries())
+	return &out, nil
+}
+
+type state5 struct {
+	cron5.State
+	store adt.Store
+}
+
+func (s *state5) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/init/actor.go.template

@@ -0,0 +1,89 @@
+package init
+
+import (
+	"github.com/filecoin-project/lotus/chain/actors"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+{{range .versions}}
+	builtin{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/builtin"
+{{end}}
+)
+
+func init() {
+{{range .versions}}
+	builtin.RegisterActorState(builtin{{.}}.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load{{.}}(store, root)
+	})
+{{end}}}
+
+var (
+	Address = builtin{{.latestVersion}}.InitActorAddr
+	Methods = builtin{{.latestVersion}}.MethodsInit
+)
+
+func Load(store adt.Store, act *types.Actor) (State, error) {
+	switch act.Code {
+{{range .versions}}
+	case builtin{{.}}.InitActorCodeID:
+		return load{{.}}(store, act.Head)
+{{end}}
+	}
+	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
+}
+
+func MakeState(store adt.Store, av actors.Version, networkName string) (State, error) {
+	switch av {
+{{range .versions}}
+	case actors.Version{{.}}:
+		return make{{.}}(store, networkName)
+{{end}}
+}
+	return nil, xerrors.Errorf("unknown actor version %d", av)
+}
+
+func GetActorCodeID(av actors.Version) (cid.Cid, error) {
+	switch av {
+{{range .versions}}
+	case actors.Version{{.}}:
+		return builtin{{.}}.InitActorCodeID, nil
+{{end}}
+	}
+
+	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
+}
+
+type State interface {
+	cbor.Marshaler
+
+	ResolveAddress(address address.Address) (address.Address, bool, error)
+	MapAddressToNewID(address address.Address) (address.Address, error)
+	NetworkName() (dtypes.NetworkName, error)
+
+	ForEachActor(func(id abi.ActorID, address address.Address) error) error
+
+	// Remove exists to support tooling that manipulates state for testing.
+	// It should not be used in production code, as init actor entries are
+	// immutable.
+	Remove(addrs ...address.Address) error
+
+	// Sets the network's name. This should only be used on upgrade/fork.
+	SetNetworkName(name string) error
+
+	// Sets the next ID for the init actor. This should only be used for testing.
+	SetNextID(id abi.ActorID) error
+
+	// Sets the address map for the init actor. This should only be used for testing.
+	SetAddressMap(mcid cid.Cid) error
+
+	AddressMap() (adt.Map, error)
+	GetState() interface{}
+}

chain/actors/builtin/init/diff.go

@@ -11,12 +11,12 @@ import (
 )
 
 func DiffAddressMap(pre, cur State) (*AddressMapChanges, error) {
-	prem, err := pre.addressMap()
+	prem, err := pre.AddressMap()
 	if err != nil {
 		return nil, err
 	}
 
-	curm, err := cur.addressMap()
+	curm, err := cur.AddressMap()
 	if err != nil {
 		return nil, err
 	}

chain/actors/builtin/init/init.go

@@ -1,6 +1,7 @@
 package init
 
 import (
+	"github.com/filecoin-project/lotus/chain/actors"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
@@ -14,45 +15,111 @@ import (
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+
 	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+
+	builtin5 "github.com/filecoin-project/specs-actors/v5/actors/builtin"
 )
 
 func init() {
+
 	builtin.RegisterActorState(builtin0.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
+
 	builtin.RegisterActorState(builtin2.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
+
 	builtin.RegisterActorState(builtin3.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+
 	builtin.RegisterActorState(builtin4.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load4(store, root)
 	})
+
+	builtin.RegisterActorState(builtin5.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load5(store, root)
+	})
 }
 
 var (
-	Address = builtin4.InitActorAddr
-	Methods = builtin4.MethodsInit
+	Address = builtin5.InitActorAddr
+	Methods = builtin5.MethodsInit
 )
 
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
+
 	case builtin0.InitActorCodeID:
 		return load0(store, act.Head)
+
 	case builtin2.InitActorCodeID:
 		return load2(store, act.Head)
+
 	case builtin3.InitActorCodeID:
 		return load3(store, act.Head)
+
 	case builtin4.InitActorCodeID:
 		return load4(store, act.Head)
+
+	case builtin5.InitActorCodeID:
+		return load5(store, act.Head)
+
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
+func MakeState(store adt.Store, av actors.Version, networkName string) (State, error) {
+	switch av {
+
+	case actors.Version0:
+		return make0(store, networkName)
+
+	case actors.Version2:
+		return make2(store, networkName)
+
+	case actors.Version3:
+		return make3(store, networkName)
+
+	case actors.Version4:
+		return make4(store, networkName)
+
+	case actors.Version5:
+		return make5(store, networkName)
+
+	}
+	return nil, xerrors.Errorf("unknown actor version %d", av)
+}
+
+func GetActorCodeID(av actors.Version) (cid.Cid, error) {
+	switch av {
+
+	case actors.Version0:
+		return builtin0.InitActorCodeID, nil
+
+	case actors.Version2:
+		return builtin2.InitActorCodeID, nil
+
+	case actors.Version3:
+		return builtin3.InitActorCodeID, nil
+
+	case actors.Version4:
+		return builtin4.InitActorCodeID, nil
+
+	case actors.Version5:
+		return builtin5.InitActorCodeID, nil
+
+	}
+
+	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
+}
+
 type State interface {
 	cbor.Marshaler
 
@@ -70,5 +137,12 @@ type State interface {
 	// Sets the network's name. This should only be used on upgrade/fork.
 	SetNetworkName(name string) error
 
-	addressMap() (adt.Map, error)
+	// Sets the next ID for the init actor. This should only be used for testing.
+	SetNextID(id abi.ActorID) error
+
+	// Sets the address map for the init actor. This should only be used for testing.
+	SetAddressMap(mcid cid.Cid) error
+
+	AddressMap() (adt.Map, error)
+	GetState() interface{}
 }

chain/actors/builtin/init/state.go.template

@@ -0,0 +1,123 @@
+package init
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+
+{{if (ge .v 3)}}
+	builtin{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/builtin"
+{{end}}
+
+	init{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/builtin/init"
+	adt{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/util/adt"
+)
+
+var _ State = (*state{{.v}})(nil)
+
+func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
+	out := state{{.v}}{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+func make{{.v}}(store adt.Store, networkName string) (State, error) {
+	out := state{{.v}}{store: store}
+	{{if (le .v 2)}}
+		mr, err := adt{{.v}}.MakeEmptyMap(store).Root()
+		if err != nil {
+			return nil, err
+		}
+
+		out.State = *init{{.v}}.ConstructState(mr, networkName)
+	{{else}}
+		s, err := init{{.v}}.ConstructState(store, networkName)
+		if err != nil {
+			return nil, err
+		}
+
+		out.State = *s
+	{{end}}
+	return &out, nil
+}
+
+type state{{.v}} struct {
+	init{{.v}}.State
+	store adt.Store
+}
+
+func (s *state{{.v}}) ResolveAddress(address address.Address) (address.Address, bool, error) {
+	return s.State.ResolveAddress(s.store, address)
+}
+
+func (s *state{{.v}}) MapAddressToNewID(address address.Address) (address.Address, error) {
+	return s.State.MapAddressToNewID(s.store, address)
+}
+
+func (s *state{{.v}}) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error {
+	addrs, err := adt{{.v}}.AsMap(s.store, s.State.AddressMap{{if (ge .v 3)}}, builtin{{.v}}.DefaultHamtBitwidth{{end}})
+	if err != nil {
+		return err
+	}
+	var actorID cbg.CborInt
+	return addrs.ForEach(&actorID, func(key string) error {
+		addr, err := address.NewFromBytes([]byte(key))
+		if err != nil {
+			return err
+		}
+		return cb(abi.ActorID(actorID), addr)
+	})
+}
+
+func (s *state{{.v}}) NetworkName() (dtypes.NetworkName, error) {
+	return dtypes.NetworkName(s.State.NetworkName), nil
+}
+
+func (s *state{{.v}}) SetNetworkName(name string) error {
+	s.State.NetworkName = name
+	return nil
+}
+
+func (s *state{{.v}}) SetNextID(id abi.ActorID) error {
+	s.State.NextID = id
+	return nil
+}
+
+func (s *state{{.v}}) Remove(addrs ...address.Address) (err error) {
+	m, err := adt{{.v}}.AsMap(s.store, s.State.AddressMap{{if (ge .v 3)}}, builtin{{.v}}.DefaultHamtBitwidth{{end}})
+	if err != nil {
+		return err
+	}
+	for _, addr := range addrs {
+		if err = m.Delete(abi.AddrKey(addr)); err != nil {
+			return xerrors.Errorf("failed to delete entry for address: %s; err: %w", addr, err)
+		}
+	}
+	amr, err := m.Root()
+	if err != nil {
+		return xerrors.Errorf("failed to get address map root: %w", err)
+	}
+	s.State.AddressMap = amr
+	return nil
+}
+
+func (s *state{{.v}}) SetAddressMap(mcid cid.Cid) error {
+	s.State.AddressMap = mcid
+	return nil
+}
+
+func (s *state{{.v}}) AddressMap() (adt.Map, error) {
+	return adt{{.v}}.AsMap(s.store, s.State.AddressMap{{if (ge .v 3)}}, builtin{{.v}}.DefaultHamtBitwidth{{end}})
+}
+
+func (s *state{{.v}}) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/init/v0.go

@@ -25,6 +25,19 @@ func load0(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
+func make0(store adt.Store, networkName string) (State, error) {
+	out := state0{store: store}
+
+	mr, err := adt0.MakeEmptyMap(store).Root()
+	if err != nil {
+		return nil, err
+	}
+
+	out.State = *init0.ConstructState(mr, networkName)
+
+	return &out, nil
+}
+
 type state0 struct {
 	init0.State
 	store adt.Store
@@ -62,6 +75,11 @@ func (s *state0) SetNetworkName(name string) error {
 	return nil
 }
 
+func (s *state0) SetNextID(id abi.ActorID) error {
+	s.State.NextID = id
+	return nil
+}
+
 func (s *state0) Remove(addrs ...address.Address) (err error) {
 	m, err := adt0.AsMap(s.store, s.State.AddressMap)
 	if err != nil {
@@ -80,6 +98,15 @@ func (s *state0) Remove(addrs ...address.Address) (err error) {
 	return nil
 }
 
-func (s *state0) addressMap() (adt.Map, error) {
-	return adt0.AsMap(s.store, s.AddressMap)
+func (s *state0) SetAddressMap(mcid cid.Cid) error {
+	s.State.AddressMap = mcid
+	return nil
+}
+
+func (s *state0) AddressMap() (adt.Map, error) {
+	return adt0.AsMap(s.store, s.State.AddressMap)
+}
+
+func (s *state0) GetState() interface{} {
+	return &s.State
 }

chain/actors/builtin/init/v2.go

@@ -25,6 +25,19 @@ func load2(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
+func make2(store adt.Store, networkName string) (State, error) {
+	out := state2{store: store}
+
+	mr, err := adt2.MakeEmptyMap(store).Root()
+	if err != nil {
+		return nil, err
+	}
+
+	out.State = *init2.ConstructState(mr, networkName)
+
+	return &out, nil
+}
+
 type state2 struct {
 	init2.State
 	store adt.Store
@@ -62,6 +75,11 @@ func (s *state2) SetNetworkName(name string) error {
 	return nil
 }
 
+func (s *state2) SetNextID(id abi.ActorID) error {
+	s.State.NextID = id
+	return nil
+}
+
 func (s *state2) Remove(addrs ...address.Address) (err error) {
 	m, err := adt2.AsMap(s.store, s.State.AddressMap)
 	if err != nil {
@@ -80,6 +98,15 @@ func (s *state2) Remove(addrs ...address.Address) (err error) {
 	return nil
 }
 
-func (s *state2) addressMap() (adt.Map, error) {
-	return adt2.AsMap(s.store, s.AddressMap)
+func (s *state2) SetAddressMap(mcid cid.Cid) error {
+	s.State.AddressMap = mcid
+	return nil
+}
+
+func (s *state2) AddressMap() (adt.Map, error) {
+	return adt2.AsMap(s.store, s.State.AddressMap)
+}
+
+func (s *state2) GetState() interface{} {
+	return &s.State
 }

chain/actors/builtin/init/v3.go

@@ -3,7 +3,6 @@ package init
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
@@ -11,6 +10,8 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 
+	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+
 	init3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/init"
 	adt3 "github.com/filecoin-project/specs-actors/v3/actors/util/adt"
 )
@@ -26,6 +27,19 @@ func load3(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
+func make3(store adt.Store, networkName string) (State, error) {
+	out := state3{store: store}
+
+	s, err := init3.ConstructState(store, networkName)
+	if err != nil {
+		return nil, err
+	}
+
+	out.State = *s
+
+	return &out, nil
+}
+
 type state3 struct {
 	init3.State
 	store adt.Store
@@ -63,6 +77,11 @@ func (s *state3) SetNetworkName(name string) error {
 	return nil
 }
 
+func (s *state3) SetNextID(id abi.ActorID) error {
+	s.State.NextID = id
+	return nil
+}
+
 func (s *state3) Remove(addrs ...address.Address) (err error) {
 	m, err := adt3.AsMap(s.store, s.State.AddressMap, builtin3.DefaultHamtBitwidth)
 	if err != nil {
@@ -81,6 +100,15 @@ func (s *state3) Remove(addrs ...address.Address) (err error) {
 	return nil
 }
 
-func (s *state3) addressMap() (adt.Map, error) {
-	return adt3.AsMap(s.store, s.AddressMap, builtin3.DefaultHamtBitwidth)
+func (s *state3) SetAddressMap(mcid cid.Cid) error {
+	s.State.AddressMap = mcid
+	return nil
+}
+
+func (s *state3) AddressMap() (adt.Map, error) {
+	return adt3.AsMap(s.store, s.State.AddressMap, builtin3.DefaultHamtBitwidth)
+}
+
+func (s *state3) GetState() interface{} {
+	return &s.State
 }

chain/actors/builtin/init/v4.go

@@ -3,7 +3,6 @@ package init
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
@@ -11,6 +10,8 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+
 	init4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/init"
 	adt4 "github.com/filecoin-project/specs-actors/v4/actors/util/adt"
 )
@@ -26,6 +27,19 @@ func load4(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
+func make4(store adt.Store, networkName string) (State, error) {
+	out := state4{store: store}
+
+	s, err := init4.ConstructState(store, networkName)
+	if err != nil {
+		return nil, err
+	}
+
+	out.State = *s
+
+	return &out, nil
+}
+
 type state4 struct {
 	init4.State
 	store adt.Store
@@ -63,6 +77,11 @@ func (s *state4) SetNetworkName(name string) error {
 	return nil
 }
 
+func (s *state4) SetNextID(id abi.ActorID) error {
+	s.State.NextID = id
+	return nil
+}
+
 func (s *state4) Remove(addrs ...address.Address) (err error) {
 	m, err := adt4.AsMap(s.store, s.State.AddressMap, builtin4.DefaultHamtBitwidth)
 	if err != nil {
@@ -81,6 +100,15 @@ func (s *state4) Remove(addrs ...address.Address) (err error) {
 	return nil
 }
 
-func (s *state4) addressMap() (adt.Map, error) {
-	return adt4.AsMap(s.store, s.AddressMap, builtin4.DefaultHamtBitwidth)
+func (s *state4) SetAddressMap(mcid cid.Cid) error {
+	s.State.AddressMap = mcid
+	return nil
+}
+
+func (s *state4) AddressMap() (adt.Map, error) {
+	return adt4.AsMap(s.store, s.State.AddressMap, builtin4.DefaultHamtBitwidth)
+}
+
+func (s *state4) GetState() interface{} {
+	return &s.State
 }

chain/actors/builtin/init/v5.go

@@ -0,0 +1,114 @@
+package init
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+
+	builtin5 "github.com/filecoin-project/specs-actors/v5/actors/builtin"
+
+	init5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/init"
+	adt5 "github.com/filecoin-project/specs-actors/v5/actors/util/adt"
+)
+
+var _ State = (*state5)(nil)
+
+func load5(store adt.Store, root cid.Cid) (State, error) {
+	out := state5{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+func make5(store adt.Store, networkName string) (State, error) {
+	out := state5{store: store}
+
+	s, err := init5.ConstructState(store, networkName)
+	if err != nil {
+		return nil, err
+	}
+
+	out.State = *s
+
+	return &out, nil
+}
+
+type state5 struct {
+	init5.State
+	store adt.Store
+}
+
+func (s *state5) ResolveAddress(address address.Address) (address.Address, bool, error) {
+	return s.State.ResolveAddress(s.store, address)
+}
+
+func (s *state5) MapAddressToNewID(address address.Address) (address.Address, error) {
+	return s.State.MapAddressToNewID(s.store, address)
+}
+
+func (s *state5) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error {
+	addrs, err := adt5.AsMap(s.store, s.State.AddressMap, builtin5.DefaultHamtBitwidth)
+	if err != nil {
+		return err
+	}
+	var actorID cbg.CborInt
+	return addrs.ForEach(&actorID, func(key string) error {
+		addr, err := address.NewFromBytes([]byte(key))
+		if err != nil {
+			return err
+		}
+		return cb(abi.ActorID(actorID), addr)
+	})
+}
+
+func (s *state5) NetworkName() (dtypes.NetworkName, error) {
+	return dtypes.NetworkName(s.State.NetworkName), nil
+}
+
+func (s *state5) SetNetworkName(name string) error {
+	s.State.NetworkName = name
+	return nil
+}
+
+func (s *state5) SetNextID(id abi.ActorID) error {
+	s.State.NextID = id
+	return nil
+}
+
+func (s *state5) Remove(addrs ...address.Address) (err error) {
+	m, err := adt5.AsMap(s.store, s.State.AddressMap, builtin5.DefaultHamtBitwidth)
+	if err != nil {
+		return err
+	}
+	for _, addr := range addrs {
+		if err = m.Delete(abi.AddrKey(addr)); err != nil {
+			return xerrors.Errorf("failed to delete entry for address: %s; err: %w", addr, err)
+		}
+	}
+	amr, err := m.Root()
+	if err != nil {
+		return xerrors.Errorf("failed to get address map root: %w", err)
+	}
+	s.State.AddressMap = amr
+	return nil
+}
+
+func (s *state5) SetAddressMap(mcid cid.Cid) error {
+	s.State.AddressMap = mcid
+	return nil
+}
+
+func (s *state5) AddressMap() (adt.Map, error) {
+	return adt5.AsMap(s.store, s.State.AddressMap, builtin5.DefaultHamtBitwidth)
+}
+
+func (s *state5) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/market/actor.go.template

@@ -0,0 +1,182 @@
+package market
+
+import (
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+{{range .versions}}
+	builtin{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/builtin"
+{{end}}
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func init() {
+{{range .versions}}
+	builtin.RegisterActorState(builtin{{.}}.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load{{.}}(store, root)
+	})
+{{end}}}
+
+var (
+	Address = builtin{{.latestVersion}}.StorageMarketActorAddr
+	Methods = builtin{{.latestVersion}}.MethodsMarket
+)
+
+func Load(store adt.Store, act *types.Actor) (State, error) {
+	switch act.Code {
+{{range .versions}}
+	case builtin{{.}}.StorageMarketActorCodeID:
+		return load{{.}}(store, act.Head)
+{{end}}
+	}
+	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
+}
+
+func MakeState(store adt.Store, av actors.Version) (State, error) {
+	switch av {
+{{range .versions}}
+	case actors.Version{{.}}:
+		return make{{.}}(store)
+{{end}}
+}
+	return nil, xerrors.Errorf("unknown actor version %d", av)
+}
+
+func GetActorCodeID(av actors.Version) (cid.Cid, error) {
+	switch av {
+{{range .versions}}
+	case actors.Version{{.}}:
+		return builtin{{.}}.StorageMarketActorCodeID, nil
+{{end}}
+	}
+
+	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
+}
+
+type State interface {
+	cbor.Marshaler
+	BalancesChanged(State) (bool, error)
+	EscrowTable() (BalanceTable, error)
+	LockedTable() (BalanceTable, error)
+	TotalLocked() (abi.TokenAmount, error)
+	StatesChanged(State) (bool, error)
+	States() (DealStates, error)
+	ProposalsChanged(State) (bool, error)
+	Proposals() (DealProposals, error)
+	VerifyDealsForActivation(
+		minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
+	) (weight, verifiedWeight abi.DealWeight, err error)
+	NextID() (abi.DealID, error)
+	GetState() interface{}
+}
+
+type BalanceTable interface {
+	ForEach(cb func(address.Address, abi.TokenAmount) error) error
+	Get(key address.Address) (abi.TokenAmount, error)
+}
+
+type DealStates interface {
+	ForEach(cb func(id abi.DealID, ds DealState) error) error
+	Get(id abi.DealID) (*DealState, bool, error)
+
+	array() adt.Array
+	decode(*cbg.Deferred) (*DealState, error)
+}
+
+type DealProposals interface {
+	ForEach(cb func(id abi.DealID, dp DealProposal) error) error
+	Get(id abi.DealID) (*DealProposal, bool, error)
+
+	array() adt.Array
+	decode(*cbg.Deferred) (*DealProposal, error)
+}
+
+type PublishStorageDealsParams = market0.PublishStorageDealsParams
+type PublishStorageDealsReturn = market0.PublishStorageDealsReturn
+type VerifyDealsForActivationParams = market0.VerifyDealsForActivationParams
+type WithdrawBalanceParams = market0.WithdrawBalanceParams
+
+type ClientDealProposal = market0.ClientDealProposal
+
+type DealState 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
+}
+
+type DealProposal struct {
+	PieceCID			 cid.Cid
+	PieceSize			 abi.PaddedPieceSize
+	VerifiedDeal		 bool
+	Client				 address.Address
+	Provider			 address.Address
+	Label				 string
+	StartEpoch			 abi.ChainEpoch
+	EndEpoch			 abi.ChainEpoch
+	StoragePricePerEpoch abi.TokenAmount
+	ProviderCollateral	 abi.TokenAmount
+	ClientCollateral	 abi.TokenAmount
+}
+
+type DealStateChanges struct {
+	Added	 []DealIDState
+	Modified []DealStateChange
+	Removed	 []DealIDState
+}
+
+type DealIDState struct {
+	ID	 abi.DealID
+	Deal DealState
+}
+
+// DealStateChange is a change in deal state from -> to
+type DealStateChange struct {
+	ID	 abi.DealID
+	From *DealState
+	To	 *DealState
+}
+
+type DealProposalChanges struct {
+	Added	[]ProposalIDState
+	Removed []ProposalIDState
+}
+
+type ProposalIDState struct {
+	ID		 abi.DealID
+	Proposal DealProposal
+}
+
+func EmptyDealState() *DealState {
+	return &DealState{
+		SectorStartEpoch: -1,
+		SlashEpoch:		  -1,
+		LastUpdatedEpoch: -1,
+	}
+}
+
+// returns the earned fees and pending fees for a given deal
+func (deal DealProposal) GetDealFees(height abi.ChainEpoch) (abi.TokenAmount, abi.TokenAmount) {
+	   tf := big.Mul(deal.StoragePricePerEpoch, big.NewInt(int64(deal.EndEpoch-deal.StartEpoch)))
+
+	   ef := big.Mul(deal.StoragePricePerEpoch, big.NewInt(int64(height-deal.StartEpoch)))
+	   if ef.LessThan(big.Zero()) {
+			   ef = big.Zero()
+	   }
+
+	   if ef.GreaterThan(tf) {
+			   ef = tf
+	   }
+
+	   return ef, big.Sub(tf, ef)
+}

chain/actors/builtin/market/market.go

@@ -5,55 +5,124 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/cbor"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+
 	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 
+	builtin5 "github.com/filecoin-project/specs-actors/v5/actors/builtin"
+
+	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
 func init() {
+
 	builtin.RegisterActorState(builtin0.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
+
 	builtin.RegisterActorState(builtin2.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
+
 	builtin.RegisterActorState(builtin3.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+
 	builtin.RegisterActorState(builtin4.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load4(store, root)
 	})
+
+	builtin.RegisterActorState(builtin5.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load5(store, root)
+	})
 }
 
 var (
-	Address = builtin4.StorageMarketActorAddr
-	Methods = builtin4.MethodsMarket
+	Address = builtin5.StorageMarketActorAddr
+	Methods = builtin5.MethodsMarket
 )
 
-func Load(store adt.Store, act *types.Actor) (st State, err error) {
+func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
+
 	case builtin0.StorageMarketActorCodeID:
 		return load0(store, act.Head)
+
 	case builtin2.StorageMarketActorCodeID:
 		return load2(store, act.Head)
+
 	case builtin3.StorageMarketActorCodeID:
 		return load3(store, act.Head)
+
 	case builtin4.StorageMarketActorCodeID:
 		return load4(store, act.Head)
+
+	case builtin5.StorageMarketActorCodeID:
+		return load5(store, act.Head)
+
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
+func MakeState(store adt.Store, av actors.Version) (State, error) {
+	switch av {
+
+	case actors.Version0:
+		return make0(store)
+
+	case actors.Version2:
+		return make2(store)
+
+	case actors.Version3:
+		return make3(store)
+
+	case actors.Version4:
+		return make4(store)
+
+	case actors.Version5:
+		return make5(store)
+
+	}
+	return nil, xerrors.Errorf("unknown actor version %d", av)
+}
+
+func GetActorCodeID(av actors.Version) (cid.Cid, error) {
+	switch av {
+
+	case actors.Version0:
+		return builtin0.StorageMarketActorCodeID, nil
+
+	case actors.Version2:
+		return builtin2.StorageMarketActorCodeID, nil
+
+	case actors.Version3:
+		return builtin3.StorageMarketActorCodeID, nil
+
+	case actors.Version4:
+		return builtin4.StorageMarketActorCodeID, nil
+
+	case actors.Version5:
+		return builtin5.StorageMarketActorCodeID, nil
+
+	}
+
+	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
+}
+
 type State interface {
 	cbor.Marshaler
 	BalancesChanged(State) (bool, error)
@@ -68,6 +137,7 @@ type State interface {
 		minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
 	) (weight, verifiedWeight abi.DealWeight, err error)
 	NextID() (abi.DealID, error)
+	GetState() interface{}
 }
 
 type BalanceTable interface {
@@ -153,3 +223,19 @@ func EmptyDealState() *DealState {
 		LastUpdatedEpoch: -1,
 	}
 }
+
+// returns the earned fees and pending fees for a given deal
+func (deal DealProposal) GetDealFees(height abi.ChainEpoch) (abi.TokenAmount, abi.TokenAmount) {
+	tf := big.Mul(deal.StoragePricePerEpoch, big.NewInt(int64(deal.EndEpoch-deal.StartEpoch)))
+
+	ef := big.Mul(deal.StoragePricePerEpoch, big.NewInt(int64(height-deal.StartEpoch)))
+	if ef.LessThan(big.Zero()) {
+		ef = big.Zero()
+	}
+
+	if ef.GreaterThan(tf) {
+		ef = tf
+	}
+
+	return ef, big.Sub(tf, ef)
+}

chain/actors/builtin/market/state.go.template

@@ -0,0 +1,238 @@
+package market
+
+import (
+	"bytes"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+
+	market{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/builtin/market"
+	adt{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/util/adt"
+)
+
+var _ State = (*state{{.v}})(nil)
+
+func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
+	out := state{{.v}}{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+func make{{.v}}(store adt.Store) (State, error) {
+	out := state{{.v}}{store: store}
+	{{if (le .v 2)}}
+		ea, err := adt{{.v}}.MakeEmptyArray(store).Root()
+		if err != nil {
+			return nil, err
+		}
+
+		em, err := adt{{.v}}.MakeEmptyMap(store).Root()
+		if err != nil {
+			return nil, err
+		}
+
+		out.State = *market{{.v}}.ConstructState(ea, em, em)
+	{{else}}
+		s, err := market{{.v}}.ConstructState(store)
+		if err != nil {
+			return nil, err
+		}
+
+		out.State = *s
+	{{end}}
+	return &out, nil
+}
+
+type state{{.v}} struct {
+	market{{.v}}.State
+	store adt.Store
+}
+
+func (s *state{{.v}}) TotalLocked() (abi.TokenAmount, error) {
+	fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
+	fml = types.BigAdd(fml, s.TotalClientStorageFee)
+	return fml, nil
+}
+
+func (s *state{{.v}}) BalancesChanged(otherState State) (bool, error) {
+	otherState{{.v}}, ok := otherState.(*state{{.v}})
+	if !ok {
+		// there's no way to compare different versions of the state, so let's
+		// just say that means the state of balances has changed
+		return true, nil
+	}
+	return !s.State.EscrowTable.Equals(otherState{{.v}}.State.EscrowTable) || !s.State.LockedTable.Equals(otherState{{.v}}.State.LockedTable), nil
+}
+
+func (s *state{{.v}}) StatesChanged(otherState State) (bool, error) {
+	otherState{{.v}}, ok := otherState.(*state{{.v}})
+	if !ok {
+		// there's no way to compare different versions of the state, so let's
+		// just say that means the state of balances has changed
+		return true, nil
+	}
+	return !s.State.States.Equals(otherState{{.v}}.State.States), nil
+}
+
+func (s *state{{.v}}) States() (DealStates, error) {
+	stateArray, err := adt{{.v}}.AsArray(s.store, s.State.States{{if (ge .v 3)}}, market{{.v}}.StatesAmtBitwidth{{end}})
+	if err != nil {
+		return nil, err
+	}
+	return &dealStates{{.v}}{stateArray}, nil
+}
+
+func (s *state{{.v}}) ProposalsChanged(otherState State) (bool, error) {
+	otherState{{.v}}, ok := otherState.(*state{{.v}})
+	if !ok {
+		// there's no way to compare different versions of the state, so let's
+		// just say that means the state of balances has changed
+		return true, nil
+	}
+	return !s.State.Proposals.Equals(otherState{{.v}}.State.Proposals), nil
+}
+
+func (s *state{{.v}}) Proposals() (DealProposals, error) {
+	proposalArray, err := adt{{.v}}.AsArray(s.store, s.State.Proposals{{if (ge .v 3)}}, market{{.v}}.ProposalsAmtBitwidth{{end}})
+	if err != nil {
+		return nil, err
+	}
+	return &dealProposals{{.v}}{proposalArray}, nil
+}
+
+func (s *state{{.v}}) EscrowTable() (BalanceTable, error) {
+	bt, err := adt{{.v}}.AsBalanceTable(s.store, s.State.EscrowTable)
+	if err != nil {
+		return nil, err
+	}
+	return &balanceTable{{.v}}{bt}, nil
+}
+
+func (s *state{{.v}}) LockedTable() (BalanceTable, error) {
+	bt, err := adt{{.v}}.AsBalanceTable(s.store, s.State.LockedTable)
+	if err != nil {
+		return nil, err
+	}
+	return &balanceTable{{.v}}{bt}, nil
+}
+
+func (s *state{{.v}}) VerifyDealsForActivation(
+	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
+) (weight, verifiedWeight abi.DealWeight, err error) {
+	w, vw{{if (ge .v 2)}}, _{{end}}, err := market{{.v}}.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
+	return w, vw, err
+}
+
+func (s *state{{.v}}) NextID() (abi.DealID, error) {
+	return s.State.NextID, nil
+}
+
+type balanceTable{{.v}} struct {
+	*adt{{.v}}.BalanceTable
+}
+
+func (bt *balanceTable{{.v}}) ForEach(cb func(address.Address, abi.TokenAmount) error) error {
+	asMap := (*adt{{.v}}.Map)(bt.BalanceTable)
+	var ta abi.TokenAmount
+	return asMap.ForEach(&ta, func(key string) error {
+		a, err := address.NewFromBytes([]byte(key))
+		if err != nil {
+			return err
+		}
+		return cb(a, ta)
+	})
+}
+
+type dealStates{{.v}} struct {
+	adt.Array
+}
+
+func (s *dealStates{{.v}}) Get(dealID abi.DealID) (*DealState, bool, error) {
+	var deal{{.v}} market{{.v}}.DealState
+	found, err := s.Array.Get(uint64(dealID), &deal{{.v}})
+	if err != nil {
+		return nil, false, err
+	}
+	if !found {
+		return nil, false, nil
+	}
+	deal := fromV{{.v}}DealState(deal{{.v}})
+	return &deal, true, nil
+}
+
+func (s *dealStates{{.v}}) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
+	var ds{{.v}} market{{.v}}.DealState
+	return s.Array.ForEach(&ds{{.v}}, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV{{.v}}DealState(ds{{.v}}))
+	})
+}
+
+func (s *dealStates{{.v}}) decode(val *cbg.Deferred) (*DealState, error) {
+	var ds{{.v}} market{{.v}}.DealState
+	if err := ds{{.v}}.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return nil, err
+	}
+	ds := fromV{{.v}}DealState(ds{{.v}})
+	return &ds, nil
+}
+
+func (s *dealStates{{.v}}) array() adt.Array {
+	return s.Array
+}
+
+func fromV{{.v}}DealState(v{{.v}} market{{.v}}.DealState) DealState {
+	return (DealState)(v{{.v}})
+}
+
+type dealProposals{{.v}} struct {
+	adt.Array
+}
+
+func (s *dealProposals{{.v}}) Get(dealID abi.DealID) (*DealProposal, bool, error) {
+	var proposal{{.v}} market{{.v}}.DealProposal
+	found, err := s.Array.Get(uint64(dealID), &proposal{{.v}})
+	if err != nil {
+		return nil, false, err
+	}
+	if !found {
+		return nil, false, nil
+	}
+	proposal := fromV{{.v}}DealProposal(proposal{{.v}})
+	return &proposal, true, nil
+}
+
+func (s *dealProposals{{.v}}) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
+	var dp{{.v}} market{{.v}}.DealProposal
+	return s.Array.ForEach(&dp{{.v}}, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV{{.v}}DealProposal(dp{{.v}}))
+	})
+}
+
+func (s *dealProposals{{.v}}) decode(val *cbg.Deferred) (*DealProposal, error) {
+	var dp{{.v}} market{{.v}}.DealProposal
+	if err := dp{{.v}}.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return nil, err
+	}
+	dp := fromV{{.v}}DealProposal(dp{{.v}})
+	return &dp, nil
+}
+
+func (s *dealProposals{{.v}}) array() adt.Array {
+	return s.Array
+}
+
+func fromV{{.v}}DealProposal(v{{.v}} market{{.v}}.DealProposal) DealProposal {
+	return (DealProposal)(v{{.v}})
+}
+
+func (s *state{{.v}}) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/market/v0.go

@@ -26,6 +26,24 @@ func load0(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
+func make0(store adt.Store) (State, error) {
+	out := state0{store: store}
+
+	ea, err := adt0.MakeEmptyArray(store).Root()
+	if err != nil {
+		return nil, err
+	}
+
+	em, err := adt0.MakeEmptyMap(store).Root()
+	if err != nil {
+		return nil, err
+	}
+
+	out.State = *market0.ConstructState(ea, em, em)
+
+	return &out, nil
+}
+
 type state0 struct {
 	market0.State
 	store adt.Store
@@ -102,7 +120,8 @@ func (s *state0) LockedTable() (BalanceTable, error) {
 func (s *state0) VerifyDealsForActivation(
 	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
 ) (weight, verifiedWeight abi.DealWeight, err error) {
-	return market0.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
+	w, vw, err := market0.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
+	return w, vw, err
 }
 
 func (s *state0) NextID() (abi.DealID, error) {
@@ -206,3 +225,7 @@ func (s *dealProposals0) array() adt.Array {
 func fromV0DealProposal(v0 market0.DealProposal) DealProposal {
 	return (DealProposal)(v0)
 }
+
+func (s *state0) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/market/v2.go

@@ -26,6 +26,24 @@ func load2(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
+func make2(store adt.Store) (State, error) {
+	out := state2{store: store}
+
+	ea, err := adt2.MakeEmptyArray(store).Root()
+	if err != nil {
+		return nil, err
+	}
+
+	em, err := adt2.MakeEmptyMap(store).Root()
+	if err != nil {
+		return nil, err
+	}
+
+	out.State = *market2.ConstructState(ea, em, em)
+
+	return &out, nil
+}
+
 type state2 struct {
 	market2.State
 	store adt.Store
@@ -144,18 +162,18 @@ func (s *dealStates2) Get(dealID abi.DealID) (*DealState, bool, error) {
 }
 
 func (s *dealStates2) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
-	var ds1 market2.DealState
-	return s.Array.ForEach(&ds1, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV2DealState(ds1))
+	var ds2 market2.DealState
+	return s.Array.ForEach(&ds2, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV2DealState(ds2))
 	})
 }
 
 func (s *dealStates2) decode(val *cbg.Deferred) (*DealState, error) {
-	var ds1 market2.DealState
-	if err := ds1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+	var ds2 market2.DealState
+	if err := ds2.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
-	ds := fromV2DealState(ds1)
+	ds := fromV2DealState(ds2)
 	return &ds, nil
 }
 
@@ -163,8 +181,8 @@ func (s *dealStates2) array() adt.Array {
 	return s.Array
 }
 
-func fromV2DealState(v1 market2.DealState) DealState {
-	return (DealState)(v1)
+func fromV2DealState(v2 market2.DealState) DealState {
+	return (DealState)(v2)
 }
 
 type dealProposals2 struct {
@@ -185,18 +203,18 @@ func (s *dealProposals2) Get(dealID abi.DealID) (*DealProposal, bool, error) {
 }
 
 func (s *dealProposals2) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
-	var dp1 market2.DealProposal
-	return s.Array.ForEach(&dp1, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV2DealProposal(dp1))
+	var dp2 market2.DealProposal
+	return s.Array.ForEach(&dp2, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV2DealProposal(dp2))
 	})
 }
 
 func (s *dealProposals2) decode(val *cbg.Deferred) (*DealProposal, error) {
-	var dp1 market2.DealProposal
-	if err := dp1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+	var dp2 market2.DealProposal
+	if err := dp2.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
-	dp := fromV2DealProposal(dp1)
+	dp := fromV2DealProposal(dp2)
 	return &dp, nil
 }
 
@@ -204,6 +222,10 @@ func (s *dealProposals2) array() adt.Array {
 	return s.Array
 }
 
-func fromV2DealProposal(v1 market2.DealProposal) DealProposal {
-	return (DealProposal)(v1)
+func fromV2DealProposal(v2 market2.DealProposal) DealProposal {
+	return (DealProposal)(v2)
+}
+
+func (s *state2) GetState() interface{} {
+	return &s.State
 }

chain/actors/builtin/market/v3.go

@@ -26,6 +26,19 @@ func load3(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
+func make3(store adt.Store) (State, error) {
+	out := state3{store: store}
+
+	s, err := market3.ConstructState(store)
+	if err != nil {
+		return nil, err
+	}
+
+	out.State = *s
+
+	return &out, nil
+}
+
 type state3 struct {
 	market3.State
 	store adt.Store
@@ -38,23 +51,23 @@ func (s *state3) TotalLocked() (abi.TokenAmount, error) {
 }
 
 func (s *state3) BalancesChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state3)
+	otherState3, ok := otherState.(*state3)
 	if !ok {
 		// there's no way to compare different versions of the state, so let's
 		// just say that means the state of balances has changed
 		return true, nil
 	}
-	return !s.State.EscrowTable.Equals(otherState2.State.EscrowTable) || !s.State.LockedTable.Equals(otherState2.State.LockedTable), nil
+	return !s.State.EscrowTable.Equals(otherState3.State.EscrowTable) || !s.State.LockedTable.Equals(otherState3.State.LockedTable), nil
 }
 
 func (s *state3) StatesChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state3)
+	otherState3, ok := otherState.(*state3)
 	if !ok {
 		// there's no way to compare different versions of the state, so let's
 		// just say that means the state of balances has changed
 		return true, nil
 	}
-	return !s.State.States.Equals(otherState2.State.States), nil
+	return !s.State.States.Equals(otherState3.State.States), nil
 }
 
 func (s *state3) States() (DealStates, error) {
@@ -66,13 +79,13 @@ func (s *state3) States() (DealStates, error) {
 }
 
 func (s *state3) ProposalsChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state3)
+	otherState3, ok := otherState.(*state3)
 	if !ok {
 		// there's no way to compare different versions of the state, so let's
 		// just say that means the state of balances has changed
 		return true, nil
 	}
-	return !s.State.Proposals.Equals(otherState2.State.Proposals), nil
+	return !s.State.Proposals.Equals(otherState3.State.Proposals), nil
 }
 
 func (s *state3) Proposals() (DealProposals, error) {
@@ -131,31 +144,31 @@ type dealStates3 struct {
 }
 
 func (s *dealStates3) Get(dealID abi.DealID) (*DealState, bool, error) {
-	var deal2 market3.DealState
-	found, err := s.Array.Get(uint64(dealID), &deal2)
+	var deal3 market3.DealState
+	found, err := s.Array.Get(uint64(dealID), &deal3)
 	if err != nil {
 		return nil, false, err
 	}
 	if !found {
 		return nil, false, nil
 	}
-	deal := fromV3DealState(deal2)
+	deal := fromV3DealState(deal3)
 	return &deal, true, nil
 }
 
 func (s *dealStates3) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
-	var ds1 market3.DealState
-	return s.Array.ForEach(&ds1, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV3DealState(ds1))
+	var ds3 market3.DealState
+	return s.Array.ForEach(&ds3, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV3DealState(ds3))
 	})
 }
 
 func (s *dealStates3) decode(val *cbg.Deferred) (*DealState, error) {
-	var ds1 market3.DealState
-	if err := ds1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+	var ds3 market3.DealState
+	if err := ds3.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
-	ds := fromV3DealState(ds1)
+	ds := fromV3DealState(ds3)
 	return &ds, nil
 }
 
@@ -163,8 +176,8 @@ func (s *dealStates3) array() adt.Array {
 	return s.Array
 }
 
-func fromV3DealState(v1 market3.DealState) DealState {
-	return (DealState)(v1)
+func fromV3DealState(v3 market3.DealState) DealState {
+	return (DealState)(v3)
 }
 
 type dealProposals3 struct {
@@ -172,31 +185,31 @@ type dealProposals3 struct {
 }
 
 func (s *dealProposals3) Get(dealID abi.DealID) (*DealProposal, bool, error) {
-	var proposal2 market3.DealProposal
-	found, err := s.Array.Get(uint64(dealID), &proposal2)
+	var proposal3 market3.DealProposal
+	found, err := s.Array.Get(uint64(dealID), &proposal3)
 	if err != nil {
 		return nil, false, err
 	}
 	if !found {
 		return nil, false, nil
 	}
-	proposal := fromV3DealProposal(proposal2)
+	proposal := fromV3DealProposal(proposal3)
 	return &proposal, true, nil
 }
 
 func (s *dealProposals3) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
-	var dp1 market3.DealProposal
-	return s.Array.ForEach(&dp1, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV3DealProposal(dp1))
+	var dp3 market3.DealProposal
+	return s.Array.ForEach(&dp3, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV3DealProposal(dp3))
 	})
 }
 
 func (s *dealProposals3) decode(val *cbg.Deferred) (*DealProposal, error) {
-	var dp1 market3.DealProposal
-	if err := dp1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+	var dp3 market3.DealProposal
+	if err := dp3.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
-	dp := fromV3DealProposal(dp1)
+	dp := fromV3DealProposal(dp3)
 	return &dp, nil
 }
 
@@ -204,6 +217,10 @@ func (s *dealProposals3) array() adt.Array {
 	return s.Array
 }
 
-func fromV3DealProposal(v1 market3.DealProposal) DealProposal {
-	return (DealProposal)(v1)
+func fromV3DealProposal(v3 market3.DealProposal) DealProposal {
+	return (DealProposal)(v3)
+}
+
+func (s *state3) GetState() interface{} {
+	return &s.State
 }

chain/actors/builtin/market/v4.go

@@ -26,6 +26,19 @@ func load4(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
+func make4(store adt.Store) (State, error) {
+	out := state4{store: store}
+
+	s, err := market4.ConstructState(store)
+	if err != nil {
+		return nil, err
+	}
+
+	out.State = *s
+
+	return &out, nil
+}
+
 type state4 struct {
 	market4.State
 	store adt.Store
@@ -38,23 +51,23 @@ func (s *state4) TotalLocked() (abi.TokenAmount, error) {
 }
 
 func (s *state4) BalancesChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state4)
+	otherState4, ok := otherState.(*state4)
 	if !ok {
 		// there's no way to compare different versions of the state, so let's
 		// just say that means the state of balances has changed
 		return true, nil
 	}
-	return !s.State.EscrowTable.Equals(otherState2.State.EscrowTable) || !s.State.LockedTable.Equals(otherState2.State.LockedTable), nil
+	return !s.State.EscrowTable.Equals(otherState4.State.EscrowTable) || !s.State.LockedTable.Equals(otherState4.State.LockedTable), nil
 }
 
 func (s *state4) StatesChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state4)
+	otherState4, ok := otherState.(*state4)
 	if !ok {
 		// there's no way to compare different versions of the state, so let's
 		// just say that means the state of balances has changed
 		return true, nil
 	}
-	return !s.State.States.Equals(otherState2.State.States), nil
+	return !s.State.States.Equals(otherState4.State.States), nil
 }
 
 func (s *state4) States() (DealStates, error) {
@@ -66,13 +79,13 @@ func (s *state4) States() (DealStates, error) {
 }
 
 func (s *state4) ProposalsChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state4)
+	otherState4, ok := otherState.(*state4)
 	if !ok {
 		// there's no way to compare different versions of the state, so let's
 		// just say that means the state of balances has changed
 		return true, nil
 	}
-	return !s.State.Proposals.Equals(otherState2.State.Proposals), nil
+	return !s.State.Proposals.Equals(otherState4.State.Proposals), nil
 }
 
 func (s *state4) Proposals() (DealProposals, error) {
@@ -131,31 +144,31 @@ type dealStates4 struct {
 }
 
 func (s *dealStates4) Get(dealID abi.DealID) (*DealState, bool, error) {
-	var deal2 market4.DealState
-	found, err := s.Array.Get(uint64(dealID), &deal2)
+	var deal4 market4.DealState
+	found, err := s.Array.Get(uint64(dealID), &deal4)
 	if err != nil {
 		return nil, false, err
 	}
 	if !found {
 		return nil, false, nil
 	}
-	deal := fromV4DealState(deal2)
+	deal := fromV4DealState(deal4)
 	return &deal, true, nil
 }
 
 func (s *dealStates4) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
-	var ds1 market4.DealState
-	return s.Array.ForEach(&ds1, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV4DealState(ds1))
+	var ds4 market4.DealState
+	return s.Array.ForEach(&ds4, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV4DealState(ds4))
 	})
 }
 
 func (s *dealStates4) decode(val *cbg.Deferred) (*DealState, error) {
-	var ds1 market4.DealState
-	if err := ds1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+	var ds4 market4.DealState
+	if err := ds4.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
-	ds := fromV4DealState(ds1)
+	ds := fromV4DealState(ds4)
 	return &ds, nil
 }
 
@@ -172,31 +185,31 @@ type dealProposals4 struct {
 }
 
 func (s *dealProposals4) Get(dealID abi.DealID) (*DealProposal, bool, error) {
-	var proposal2 market4.DealProposal
-	found, err := s.Array.Get(uint64(dealID), &proposal2)
+	var proposal4 market4.DealProposal
+	found, err := s.Array.Get(uint64(dealID), &proposal4)
 	if err != nil {
 		return nil, false, err
 	}
 	if !found {
 		return nil, false, nil
 	}
-	proposal := fromV4DealProposal(proposal2)
+	proposal := fromV4DealProposal(proposal4)
 	return &proposal, true, nil
 }
 
 func (s *dealProposals4) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
-	var dp1 market4.DealProposal
-	return s.Array.ForEach(&dp1, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV4DealProposal(dp1))
+	var dp4 market4.DealProposal
+	return s.Array.ForEach(&dp4, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV4DealProposal(dp4))
 	})
 }
 
 func (s *dealProposals4) decode(val *cbg.Deferred) (*DealProposal, error) {
-	var dp1 market4.DealProposal
-	if err := dp1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+	var dp4 market4.DealProposal
+	if err := dp4.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
-	dp := fromV4DealProposal(dp1)
+	dp := fromV4DealProposal(dp4)
 	return &dp, nil
 }
 
@@ -207,3 +220,7 @@ func (s *dealProposals4) array() adt.Array {
 func fromV4DealProposal(v4 market4.DealProposal) DealProposal {
 	return (DealProposal)(v4)
 }
+
+func (s *state4) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/market/v5.go

@@ -0,0 +1,226 @@
+package market
+
+import (
+	"bytes"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+
+	market5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/market"
+	adt5 "github.com/filecoin-project/specs-actors/v5/actors/util/adt"
+)
+
+var _ State = (*state5)(nil)
+
+func load5(store adt.Store, root cid.Cid) (State, error) {
+	out := state5{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+func make5(store adt.Store) (State, error) {
+	out := state5{store: store}
+
+	s, err := market5.ConstructState(store)
+	if err != nil {
+		return nil, err
+	}
+
+	out.State = *s
+
+	return &out, nil
+}
+
+type state5 struct {
+	market5.State
+	store adt.Store
+}
+
+func (s *state5) TotalLocked() (abi.TokenAmount, error) {
+	fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
+	fml = types.BigAdd(fml, s.TotalClientStorageFee)
+	return fml, nil
+}
+
+func (s *state5) BalancesChanged(otherState State) (bool, error) {
+	otherState5, ok := otherState.(*state5)
+	if !ok {
+		// there's no way to compare different versions of the state, so let's
+		// just say that means the state of balances has changed
+		return true, nil
+	}
+	return !s.State.EscrowTable.Equals(otherState5.State.EscrowTable) || !s.State.LockedTable.Equals(otherState5.State.LockedTable), nil
+}
+
+func (s *state5) StatesChanged(otherState State) (bool, error) {
+	otherState5, ok := otherState.(*state5)
+	if !ok {
+		// there's no way to compare different versions of the state, so let's
+		// just say that means the state of balances has changed
+		return true, nil
+	}
+	return !s.State.States.Equals(otherState5.State.States), nil
+}
+
+func (s *state5) States() (DealStates, error) {
+	stateArray, err := adt5.AsArray(s.store, s.State.States, market5.StatesAmtBitwidth)
+	if err != nil {
+		return nil, err
+	}
+	return &dealStates5{stateArray}, nil
+}
+
+func (s *state5) ProposalsChanged(otherState State) (bool, error) {
+	otherState5, ok := otherState.(*state5)
+	if !ok {
+		// there's no way to compare different versions of the state, so let's
+		// just say that means the state of balances has changed
+		return true, nil
+	}
+	return !s.State.Proposals.Equals(otherState5.State.Proposals), nil
+}
+
+func (s *state5) Proposals() (DealProposals, error) {
+	proposalArray, err := adt5.AsArray(s.store, s.State.Proposals, market5.ProposalsAmtBitwidth)
+	if err != nil {
+		return nil, err
+	}
+	return &dealProposals5{proposalArray}, nil
+}
+
+func (s *state5) EscrowTable() (BalanceTable, error) {
+	bt, err := adt5.AsBalanceTable(s.store, s.State.EscrowTable)
+	if err != nil {
+		return nil, err
+	}
+	return &balanceTable5{bt}, nil
+}
+
+func (s *state5) LockedTable() (BalanceTable, error) {
+	bt, err := adt5.AsBalanceTable(s.store, s.State.LockedTable)
+	if err != nil {
+		return nil, err
+	}
+	return &balanceTable5{bt}, nil
+}
+
+func (s *state5) VerifyDealsForActivation(
+	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
+) (weight, verifiedWeight abi.DealWeight, err error) {
+	w, vw, _, err := market5.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
+	return w, vw, err
+}
+
+func (s *state5) NextID() (abi.DealID, error) {
+	return s.State.NextID, nil
+}
+
+type balanceTable5 struct {
+	*adt5.BalanceTable
+}
+
+func (bt *balanceTable5) ForEach(cb func(address.Address, abi.TokenAmount) error) error {
+	asMap := (*adt5.Map)(bt.BalanceTable)
+	var ta abi.TokenAmount
+	return asMap.ForEach(&ta, func(key string) error {
+		a, err := address.NewFromBytes([]byte(key))
+		if err != nil {
+			return err
+		}
+		return cb(a, ta)
+	})
+}
+
+type dealStates5 struct {
+	adt.Array
+}
+
+func (s *dealStates5) Get(dealID abi.DealID) (*DealState, bool, error) {
+	var deal5 market5.DealState
+	found, err := s.Array.Get(uint64(dealID), &deal5)
+	if err != nil {
+		return nil, false, err
+	}
+	if !found {
+		return nil, false, nil
+	}
+	deal := fromV5DealState(deal5)
+	return &deal, true, nil
+}
+
+func (s *dealStates5) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
+	var ds5 market5.DealState
+	return s.Array.ForEach(&ds5, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV5DealState(ds5))
+	})
+}
+
+func (s *dealStates5) decode(val *cbg.Deferred) (*DealState, error) {
+	var ds5 market5.DealState
+	if err := ds5.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return nil, err
+	}
+	ds := fromV5DealState(ds5)
+	return &ds, nil
+}
+
+func (s *dealStates5) array() adt.Array {
+	return s.Array
+}
+
+func fromV5DealState(v5 market5.DealState) DealState {
+	return (DealState)(v5)
+}
+
+type dealProposals5 struct {
+	adt.Array
+}
+
+func (s *dealProposals5) Get(dealID abi.DealID) (*DealProposal, bool, error) {
+	var proposal5 market5.DealProposal
+	found, err := s.Array.Get(uint64(dealID), &proposal5)
+	if err != nil {
+		return nil, false, err
+	}
+	if !found {
+		return nil, false, nil
+	}
+	proposal := fromV5DealProposal(proposal5)
+	return &proposal, true, nil
+}
+
+func (s *dealProposals5) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
+	var dp5 market5.DealProposal
+	return s.Array.ForEach(&dp5, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV5DealProposal(dp5))
+	})
+}
+
+func (s *dealProposals5) decode(val *cbg.Deferred) (*DealProposal, error) {
+	var dp5 market5.DealProposal
+	if err := dp5.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return nil, err
+	}
+	dp := fromV5DealProposal(dp5)
+	return &dp, nil
+}
+
+func (s *dealProposals5) array() adt.Array {
+	return s.Array
+}
+
+func fromV5DealProposal(v5 market5.DealProposal) DealProposal {
+	return (DealProposal)(v5)
+}
+
+func (s *state5) GetState() interface{} {
+	return &s.State
+}

chain/actors/builtin/miner/actor.go.template

@@ -0,0 +1,304 @@
+package miner
+
+import (
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/ipfs/go-cid"
+	"github.com/libp2p/go-libp2p-core/peer"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-bitfield"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/filecoin-project/go-state-types/dline"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/types"
+
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
+	miner3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/miner"
+	miner5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/miner"
+{{range .versions}}
+	builtin{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/builtin"
+{{end}}
+)
+
+func init() {
+{{range .versions}}
+	builtin.RegisterActorState(builtin{{.}}.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load{{.}}(store, root)
+	})
+{{end}}
+}
+
+var Methods = builtin{{.latestVersion}}.MethodsMiner
+
+// Unchanged between v0, v2, v3, and v4 actors
+var WPoStProvingPeriod = miner0.WPoStProvingPeriod
+var WPoStPeriodDeadlines = miner0.WPoStPeriodDeadlines
+var WPoStChallengeWindow = miner0.WPoStChallengeWindow
+var WPoStChallengeLookback = miner0.WPoStChallengeLookback
+var FaultDeclarationCutoff = miner0.FaultDeclarationCutoff
+
+const MinSectorExpiration = miner0.MinSectorExpiration
+
+// Not used / checked in v0
+// TODO: Abstract over network versions
+var DeclarationsMax = miner2.DeclarationsMax
+var AddressedSectorsMax = miner2.AddressedSectorsMax
+
+func Load(store adt.Store, act *types.Actor) (State, error) {
+	switch act.Code {
+{{range .versions}}
+	case builtin{{.}}.StorageMinerActorCodeID:
+		return load{{.}}(store, act.Head)
+{{end}}
+}
+	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
+}
+
+func MakeState(store adt.Store, av actors.Version) (State, error) {
+	switch av {
+{{range .versions}}
+	case actors.Version{{.}}:
+		return make{{.}}(store)
+{{end}}
+}
+	return nil, xerrors.Errorf("unknown actor version %d", av)
+}
+
+func GetActorCodeID(av actors.Version) (cid.Cid, error) {
+	switch av {
+{{range .versions}}
+	case actors.Version{{.}}:
+		return builtin{{.}}.StorageMinerActorCodeID, nil
+{{end}}
+	}
+
+	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
+}
+
+type State interface {
+	cbor.Marshaler
+
+	// Total available balance to spend.
+	AvailableBalance(abi.TokenAmount) (abi.TokenAmount, error)
+	// Funds that will vest by the given epoch.
+	VestedFunds(abi.ChainEpoch) (abi.TokenAmount, error)
+	// Funds locked for various reasons.
+	LockedFunds() (LockedFunds, error)
+	FeeDebt() (abi.TokenAmount, error)
+
+	GetSector(abi.SectorNumber) (*SectorOnChainInfo, error)
+	FindSector(abi.SectorNumber) (*SectorLocation, error)
+	GetSectorExpiration(abi.SectorNumber) (*SectorExpiration, error)
+	GetPrecommittedSector(abi.SectorNumber) (*SectorPreCommitOnChainInfo, error)
+	ForEachPrecommittedSector(func(SectorPreCommitOnChainInfo) error) error
+	LoadSectors(sectorNos *bitfield.BitField) ([]*SectorOnChainInfo, error)
+	NumLiveSectors() (uint64, error)
+	IsAllocated(abi.SectorNumber) (bool, error)
+        // UnallocatedSectorNumbers returns up to count unallocated sector numbers (or less than
+        // count if there aren't enough).
+	UnallocatedSectorNumbers(count int) ([]abi.SectorNumber, error)
+
+	// Note that ProvingPeriodStart is deprecated and will be renamed / removed in a future version of actors
+	GetProvingPeriodStart() (abi.ChainEpoch, error)
+	// Testing only
+	EraseAllUnproven() error
+
+	LoadDeadline(idx uint64) (Deadline, error)
+	ForEachDeadline(cb func(idx uint64, dl Deadline) error) error
+	NumDeadlines() (uint64, error)
+	DeadlinesChanged(State) (bool, error)
+
+	Info() (MinerInfo, error)
+	MinerInfoChanged(State) (bool, error)
+
+	DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error)
+	DeadlineCronActive() (bool, error)
+
+	// Diff helpers. Used by Diff* functions internally.
+	sectors() (adt.Array, error)
+	decodeSectorOnChainInfo(*cbg.Deferred) (SectorOnChainInfo, error)
+	precommits() (adt.Map, error)
+	decodeSectorPreCommitOnChainInfo(*cbg.Deferred) (SectorPreCommitOnChainInfo, error)
+	GetState() interface{}
+}
+
+type Deadline interface {
+	LoadPartition(idx uint64) (Partition, error)
+	ForEachPartition(cb func(idx uint64, part Partition) error) error
+	PartitionsPoSted() (bitfield.BitField, error)
+
+	PartitionsChanged(Deadline) (bool, error)
+	DisputableProofCount() (uint64, error)
+}
+
+type Partition interface {
+	AllSectors() (bitfield.BitField, error)
+	FaultySectors() (bitfield.BitField, error)
+	RecoveringSectors() (bitfield.BitField, error)
+	LiveSectors() (bitfield.BitField, error)
+	ActiveSectors() (bitfield.BitField, error)
+}
+
+type SectorOnChainInfo struct {
+	SectorNumber          abi.SectorNumber
+	SealProof             abi.RegisteredSealProof
+	SealedCID             cid.Cid
+	DealIDs               []abi.DealID
+	Activation            abi.ChainEpoch
+	Expiration            abi.ChainEpoch
+	DealWeight            abi.DealWeight
+	VerifiedDealWeight    abi.DealWeight
+	InitialPledge         abi.TokenAmount
+	ExpectedDayReward     abi.TokenAmount
+	ExpectedStoragePledge abi.TokenAmount
+}
+
+type SectorPreCommitInfo = miner0.SectorPreCommitInfo
+
+type SectorPreCommitOnChainInfo struct {
+	Info               SectorPreCommitInfo
+	PreCommitDeposit   abi.TokenAmount
+	PreCommitEpoch     abi.ChainEpoch
+	DealWeight         abi.DealWeight
+	VerifiedDealWeight abi.DealWeight
+}
+
+type PoStPartition = miner0.PoStPartition
+type RecoveryDeclaration = miner0.RecoveryDeclaration
+type FaultDeclaration = miner0.FaultDeclaration
+
+// Params
+type DeclareFaultsParams = miner0.DeclareFaultsParams
+type DeclareFaultsRecoveredParams = miner0.DeclareFaultsRecoveredParams
+type SubmitWindowedPoStParams = miner0.SubmitWindowedPoStParams
+type ProveCommitSectorParams = miner0.ProveCommitSectorParams
+type DisputeWindowedPoStParams = miner3.DisputeWindowedPoStParams
+type ProveCommitAggregateParams = miner5.ProveCommitAggregateParams
+
+func PreferredSealProofTypeFromWindowPoStType(nver network.Version, proof abi.RegisteredPoStProof) (abi.RegisteredSealProof, error) {
+	// We added support for the new proofs in network version 7, and removed support for the old
+	// ones in network version 8.
+	if nver < network.Version7 {
+		switch proof {
+		case abi.RegisteredPoStProof_StackedDrgWindow2KiBV1:
+			return abi.RegisteredSealProof_StackedDrg2KiBV1, nil
+		case abi.RegisteredPoStProof_StackedDrgWindow8MiBV1:
+			return abi.RegisteredSealProof_StackedDrg8MiBV1, nil
+		case abi.RegisteredPoStProof_StackedDrgWindow512MiBV1:
+			return abi.RegisteredSealProof_StackedDrg512MiBV1, nil
+		case abi.RegisteredPoStProof_StackedDrgWindow32GiBV1:
+			return abi.RegisteredSealProof_StackedDrg32GiBV1, nil
+		case abi.RegisteredPoStProof_StackedDrgWindow64GiBV1:
+			return abi.RegisteredSealProof_StackedDrg64GiBV1, nil
+		default:
+			return -1, xerrors.Errorf("unrecognized window post type: %d", proof)
+		}
+	}
+
+	switch proof {
+	case abi.RegisteredPoStProof_StackedDrgWindow2KiBV1:
+		return abi.RegisteredSealProof_StackedDrg2KiBV1_1, nil
+	case abi.RegisteredPoStProof_StackedDrgWindow8MiBV1:
+		return abi.RegisteredSealProof_StackedDrg8MiBV1_1, nil
+	case abi.RegisteredPoStProof_StackedDrgWindow512MiBV1:
+		return abi.RegisteredSealProof_StackedDrg512MiBV1_1, nil
+	case abi.RegisteredPoStProof_StackedDrgWindow32GiBV1:
+		return abi.RegisteredSealProof_StackedDrg32GiBV1_1, nil
+	case abi.RegisteredPoStProof_StackedDrgWindow64GiBV1:
+		return abi.RegisteredSealProof_StackedDrg64GiBV1_1, nil
+	default:
+		return -1, xerrors.Errorf("unrecognized window post type: %d", proof)
+	}
+}
+
+func WinningPoStProofTypeFromWindowPoStProofType(nver network.Version, proof abi.RegisteredPoStProof) (abi.RegisteredPoStProof, error) {
+	switch proof {
+	case abi.RegisteredPoStProof_StackedDrgWindow2KiBV1:
+		return abi.RegisteredPoStProof_StackedDrgWinning2KiBV1, nil
+	case abi.RegisteredPoStProof_StackedDrgWindow8MiBV1:
+		return abi.RegisteredPoStProof_StackedDrgWinning8MiBV1, nil
+	case abi.RegisteredPoStProof_StackedDrgWindow512MiBV1:
+		return abi.RegisteredPoStProof_StackedDrgWinning512MiBV1, nil
+	case abi.RegisteredPoStProof_StackedDrgWindow32GiBV1:
+		return abi.RegisteredPoStProof_StackedDrgWinning32GiBV1, nil
+	case abi.RegisteredPoStProof_StackedDrgWindow64GiBV1:
+		return abi.RegisteredPoStProof_StackedDrgWinning64GiBV1, nil
+	default:
+		return -1, xerrors.Errorf("unknown proof type %d", proof)
+	}
+}
+
+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
+}
+
+func (mi MinerInfo) IsController(addr address.Address) bool {
+	if addr == mi.Owner || addr == mi.Worker {
+		return true
+	}
+
+	for _, ca := range mi.ControlAddresses {
+		if addr == ca {
+			return true
+		}
+	}
+
+	return false
+}
+
+type SectorExpiration struct {
+	OnTime abi.ChainEpoch
+
+	// non-zero if sector is faulty, epoch at which it will be permanently
+	// removed if it doesn't recover
+	Early abi.ChainEpoch
+}
+
+type SectorLocation struct {
+	Deadline  uint64
+	Partition uint64
+}
+
+type SectorChanges struct {
+	Added    []SectorOnChainInfo
+	Extended []SectorExtensions
+	Removed  []SectorOnChainInfo
+}
+
+type SectorExtensions struct {
+	From SectorOnChainInfo
+	To   SectorOnChainInfo
+}
+
+type PreCommitChanges struct {
+	Added   []SectorPreCommitOnChainInfo
+	Removed []SectorPreCommitOnChainInfo
+}
+
+type LockedFunds struct {
+	VestingFunds             abi.TokenAmount
+	InitialPledgeRequirement abi.TokenAmount
+	PreCommitDeposits        abi.TokenAmount
+}
+
+func (lf LockedFunds) TotalLockedFunds() abi.TokenAmount {
+	return big.Add(lf.VestingFunds, big.Add(lf.InitialPledgeRequirement, lf.PreCommitDeposits))
+}

chain/actors/builtin/miner/miner.go

@@ -3,6 +3,7 @@ package miner
 import (
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/ipfs/go-cid"
 	"github.com/libp2p/go-libp2p-core/peer"
 	cbg "github.com/whyrusleeping/cbor-gen"
@@ -18,31 +19,47 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
 	miner3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/miner"
+	miner5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/miner"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+
+	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+
 	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+
+	builtin5 "github.com/filecoin-project/specs-actors/v5/actors/builtin"
 )
 
 func init() {
+
 	builtin.RegisterActorState(builtin0.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
+
 	builtin.RegisterActorState(builtin2.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
+
 	builtin.RegisterActorState(builtin3.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+
 	builtin.RegisterActorState(builtin4.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load4(store, root)
 	})
+
+	builtin.RegisterActorState(builtin5.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load5(store, root)
+	})
+
 }
 
-var Methods = builtin4.MethodsMiner
+var Methods = builtin5.MethodsMiner
 
 // Unchanged between v0, v2, v3, and v4 actors
 var WPoStProvingPeriod = miner0.WPoStProvingPeriod
@@ -58,20 +75,73 @@ const MinSectorExpiration = miner0.MinSectorExpiration
 var DeclarationsMax = miner2.DeclarationsMax
 var AddressedSectorsMax = miner2.AddressedSectorsMax
 
-func Load(store adt.Store, act *types.Actor) (st State, err error) {
+func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
+
 	case builtin0.StorageMinerActorCodeID:
 		return load0(store, act.Head)
+
 	case builtin2.StorageMinerActorCodeID:
 		return load2(store, act.Head)
+
 	case builtin3.StorageMinerActorCodeID:
 		return load3(store, act.Head)
+
 	case builtin4.StorageMinerActorCodeID:
 		return load4(store, act.Head)
+
+	case builtin5.StorageMinerActorCodeID:
+		return load5(store, act.Head)
+
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
+func MakeState(store adt.Store, av actors.Version) (State, error) {
+	switch av {
+
+	case actors.Version0:
+		return make0(store)
+
+	case actors.Version2:
+		return make2(store)
+
+	case actors.Version3:
+		return make3(store)
+
+	case actors.Version4:
+		return make4(store)
+
+	case actors.Version5:
+		return make5(store)
+
+	}
+	return nil, xerrors.Errorf("unknown actor version %d", av)
+}
+
+func GetActorCodeID(av actors.Version) (cid.Cid, error) {
+	switch av {
+
+	case actors.Version0:
+		return builtin0.StorageMinerActorCodeID, nil
+
+	case actors.Version2:
+		return builtin2.StorageMinerActorCodeID, nil
+
+	case actors.Version3:
+		return builtin3.StorageMinerActorCodeID, nil
+
+	case actors.Version4:
+		return builtin4.StorageMinerActorCodeID, nil
+
+	case actors.Version5:
+		return builtin5.StorageMinerActorCodeID, nil
+
+	}
+
+	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
+}
+
 type State interface {
 	cbor.Marshaler
 
@@ -87,9 +157,18 @@ type State interface {
 	FindSector(abi.SectorNumber) (*SectorLocation, error)
 	GetSectorExpiration(abi.SectorNumber) (*SectorExpiration, error)
 	GetPrecommittedSector(abi.SectorNumber) (*SectorPreCommitOnChainInfo, error)
+	ForEachPrecommittedSector(func(SectorPreCommitOnChainInfo) error) error
 	LoadSectors(sectorNos *bitfield.BitField) ([]*SectorOnChainInfo, error)
 	NumLiveSectors() (uint64, error)
 	IsAllocated(abi.SectorNumber) (bool, error)
+	// UnallocatedSectorNumbers returns up to count unallocated sector numbers (or less than
+	// count if there aren't enough).
+	UnallocatedSectorNumbers(count int) ([]abi.SectorNumber, error)
+
+	// Note that ProvingPeriodStart is deprecated and will be renamed / removed in a future version of actors
+	GetProvingPeriodStart() (abi.ChainEpoch, error)
+	// Testing only
+	EraseAllUnproven() error
 
 	LoadDeadline(idx uint64) (Deadline, error)
 	ForEachDeadline(cb func(idx uint64, dl Deadline) error) error
@@ -107,6 +186,7 @@ type State interface {
 	decodeSectorOnChainInfo(*cbg.Deferred) (SectorOnChainInfo, error)
 	precommits() (adt.Map, error)
 	decodeSectorPreCommitOnChainInfo(*cbg.Deferred) (SectorPreCommitOnChainInfo, error)
+	GetState() interface{}
 }
 
 type Deadline interface {
@@ -160,6 +240,7 @@ type DeclareFaultsRecoveredParams = miner0.DeclareFaultsRecoveredParams
 type SubmitWindowedPoStParams = miner0.SubmitWindowedPoStParams
 type ProveCommitSectorParams = miner0.ProveCommitSectorParams
 type DisputeWindowedPoStParams = miner3.DisputeWindowedPoStParams
+type ProveCommitAggregateParams = miner5.ProveCommitAggregateParams
 
 func PreferredSealProofTypeFromWindowPoStType(nver network.Version, proof abi.RegisteredPoStProof) (abi.RegisteredSealProof, error) {
 	// We added support for the new proofs in network version 7, and removed support for the old