Merge pull request #5685 from filecoin-project/feat/v1-api

V1 API staging branch

.circleci/config.yml

@@ -438,7 +438,7 @@ jobs:
       - run: make deps
       - run: go install golang.org/x/tools/cmd/goimports
       - run: go install github.com/hannahhoward/cbor-gen-for
-      - run: go generate ./...
+      - run: make type-gen
       - run: git --no-pager diff
       - run: git --no-pager diff --quiet
 
@@ -447,6 +447,7 @@ jobs:
     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

Makefile

@@ -233,6 +233,13 @@ testground:
 .PHONY: testground
 BINS+=testground
 
+
+tvx:
+	rm -f tvx
+	go build -o tvx ./cmd/tvx
+.PHONY: tvx
+BINS+=tvx
+
 install-chainwatch: lotus-chainwatch
 	install -C ./lotus-chainwatch /usr/local/bin/lotus-chainwatch
 
@@ -318,43 +325,45 @@ dist-clean:
 	git submodule deinit --all -f
 .PHONY: dist-clean
 
-type-gen:
+type-gen: api-gen
 	go run ./gen/main.go
-	go generate ./...
+	go generate -x ./...
+	goimports -w api/
 
-method-gen:
+method-gen: api-gen
 	(cd ./lotuspond/front/src/chain && go run ./methodgen.go)
 
 api-gen:
-	go run ./gen/api > api/apistruct/struct.go
+	go run ./gen/api
-	goimports -w api/apistruct
+	goimports -w api
-	goimports -w api/apistruct
+	goimports -w api
 .PHONY: api-gen
 
 docsgen: docsgen-md docsgen-openrpc
 
-docsgen-md-bin:
+docsgen-md-bin: api-gen
 	go build $(GOFLAGS) -o docgen-md ./api/docgen/cmd
-docsgen-openrpc-bin:
+docsgen-openrpc-bin: api-gen
 	go build $(GOFLAGS) -o docgen-openrpc ./api/docgen-openrpc/cmd
 
 docsgen-md: docsgen-md-full docsgen-md-storage docsgen-md-worker
 
 docsgen-md-full: docsgen-md-bin
-	./docgen-md "api/api_full.go" "FullNode" > documentation/en/api-methods.md
+	./docgen-md "api/api_full.go" "FullNode" "api" "./api" > documentation/en/api-v1-unstable-methods.md
+	./docgen-md "api/v0api/full.go" "FullNode" "v0api" "./api/v0api" > documentation/en/api-v0-methods.md
 docsgen-md-storage: docsgen-md-bin
-	./docgen-md "api/api_storage.go" "StorageMiner" > documentation/en/api-methods-miner.md
+	./docgen-md "api/api_storage.go" "StorageMiner" "api" "./api" > documentation/en/api-v0-methods-miner.md
 docsgen-md-worker: docsgen-md-bin
-	./docgen-md "api/api_worker.go" "Worker" > documentation/en/api-methods-worker.md
+	./docgen-md "api/api_worker.go" "Worker" "api" "./api" > documentation/en/api-v0-methods-worker.md
 
 docsgen-openrpc: docsgen-openrpc-full docsgen-openrpc-storage docsgen-openrpc-worker
 
 docsgen-openrpc-full: docsgen-openrpc-bin
-	./docgen-openrpc "api/api_full.go" "FullNode" -gzip > build/openrpc/full.json.gz
+	./docgen-openrpc "api/api_full.go" "FullNode" "api" "./api" -gzip > build/openrpc/full.json.gz
 docsgen-openrpc-storage: docsgen-openrpc-bin
-	./docgen-openrpc "api/api_storage.go" "StorageMiner" -gzip > build/openrpc/miner.json.gz
+	./docgen-openrpc "api/api_storage.go" "StorageMiner" "api" "./api" -gzip > build/openrpc/miner.json.gz
 docsgen-openrpc-worker: docsgen-openrpc-bin
-	./docgen-openrpc "api/api_worker.go" "Worker" -gzip > build/openrpc/worker.json.gz
+	./docgen-openrpc "api/api_worker.go" "Worker" "api" "./api" -gzip > build/openrpc/worker.json.gz
 
 .PHONY: docsgen docsgen-md-bin docsgen-openrpc-bin
 

api/README.md

@@ -0,0 +1,14 @@
+## Lotus API
+
+This package contains all lotus API definitions. Interfaces defined here are
+exposed as JsonRPC 2.0 endpoints by lotus programs.
+
+### Versions
+
+| File             | Alias File        | Interface      | Exposed by         | Version | HTTP Endpoint | Status                       | Docs
+|------------------|-------------------|----------------|--------------------|---------|---------------|------------------------------|------
+| `api_common.go`  | `v0api/latest.go` | `Common`       | lotus; lotus-miner | v0      | `/rpc/v0`     | Latest, Stable               | [Methods](../documentation/en/api-v0-methods.md)
+| `api_full.go`    | `v1api/latest.go` | `FullNode`     | lotus              | v1      | `/rpc/v1`     | Latest, **Work in progress** | [Methods](../documentation/en/api-v1-unstable-methods.md)
+| `api_storage.go` | `v0api/latest.go` | `StorageMiner` | lotus-miner        | v0      | `/rpc/v0`     | Latest, Stable               | [Methods](../documentation/en/api-v0-methods-miner.md)
+| `api_worker.go`  | `v0api/latest.go` | `Worker`       | lotus-worker       | v0      | `/rpc/v0`     | Latest, Stable               | [Methods](../documentation/en/api-v0-methods-worker.md)
+| `v0api/full.go`  |                   | `FullNode`     | lotus              | v0      | `/rpc/v0`     | Stable                       | [Methods](../documentation/en/api-v0-methods.md)

api/api_full.go

@@ -39,6 +39,8 @@ type ChainIO interface {
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
 }
 
+const LookbackNoLimit = abi.ChainEpoch(-1)
+
 // FullNode API is a low-level interface to the Filecoin network full node
 type FullNode interface {
 	Common
@@ -430,7 +432,7 @@ type FullNode interface {
 	StateSectorExpiration(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorExpiration, error) //perm:read
 	// StateSectorPartition finds deadline/partition with the specified sector
 	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*miner.SectorLocation, error) //perm:read
-	// StateSearchMsg searches for a message in the chain, and returns its receipt and the tipset where it was executed
+	// StateSearchMsg looks back up to limit epochs in the chain for a message, and returns its receipt and the tipset where it was executed
 	//
 	// NOTE: If a replacing message is found on chain, this method will return
 	// a MsgLookup for the replacing message - the MsgLookup.Message will be a different
@@ -438,48 +440,16 @@ type FullNode interface {
 	// result of the execution of the replacing message.
 	//
 	// If the caller wants to ensure that exactly the requested message was executed,
-	// they MUST check that MsgLookup.Message is equal to the provided 'cid'.
+	// they must check that MsgLookup.Message is equal to the provided 'cid', or set the
-	// Without this check both the requested and original message may appear as
+	// `allowReplaced` parameter to false. Without this check, and with `allowReplaced`
+	// set to true, both the requested and original message may appear as
 	// successfully executed on-chain, which may look like a double-spend.
 	//
 	// A replacing message is a message with a different CID, any of Gas values, and
 	// different signature, but with all other parameters matching (source/destination,
 	// nonce, params, etc.)
-	StateSearchMsg(context.Context, cid.Cid) (*MsgLookup, error) //perm:read
+	StateSearchMsg(ctx context.Context, from types.TipSetKey, msg cid.Cid, limit abi.ChainEpoch, allowReplaced bool) (*MsgLookup, error) //perm:read
-	// StateSearchMsgLimited looks back up to limit epochs in the chain for a message, and returns its receipt and the tipset where it was executed
+	// StateWaitMsg looks back up to limit epochs in the chain for a message.
-	//
-	// NOTE: If a replacing message is found on chain, this method will return
-	// a MsgLookup for the replacing message - the MsgLookup.Message will be a different
-	// CID than the one provided in the 'cid' param, MsgLookup.Receipt will contain the
-	// result of the execution of the replacing message.
-	//
-	// If the caller wants to ensure that exactly the requested message was executed,
-	// they MUST check that MsgLookup.Message is equal to the provided 'cid'.
-	// Without this check both the requested and original message may appear as
-	// successfully executed on-chain, which may look like a double-spend.
-	//
-	// A replacing message is a message with a different CID, any of Gas values, and
-	// different signature, but with all other parameters matching (source/destination,
-	// nonce, params, etc.)
-	StateSearchMsgLimited(ctx context.Context, msg cid.Cid, limit abi.ChainEpoch) (*MsgLookup, error) //perm:read
-	// StateWaitMsg looks back in the chain for a message. If not found, it blocks until the
-	// message arrives on chain, and gets to the indicated confidence depth.
-	//
-	// NOTE: If a replacing message is found on chain, this method will return
-	// a MsgLookup for the replacing message - the MsgLookup.Message will be a different
-	// CID than the one provided in the 'cid' param, MsgLookup.Receipt will contain the
-	// result of the execution of the replacing message.
-	//
-	// If the caller wants to ensure that exactly the requested message was executed,
-	// they MUST check that MsgLookup.Message is equal to the provided 'cid'.
-	// Without this check both the requested and original message may appear as
-	// successfully executed on-chain, which may look like a double-spend.
-	//
-	// A replacing message is a message with a different CID, any of Gas values, and
-	// different signature, but with all other parameters matching (source/destination,
-	// nonce, params, etc.)
-	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64) (*MsgLookup, error) //perm:read
-	// StateWaitMsgLimited looks back up to limit epochs in the chain for a message.
 	// If not found, it blocks until the message arrives on chain, and gets to the
 	// indicated confidence depth.
 	//
@@ -489,14 +459,15 @@ type FullNode interface {
 	// result of the execution of the replacing message.
 	//
 	// If the caller wants to ensure that exactly the requested message was executed,
-	// they MUST check that MsgLookup.Message is equal to the provided 'cid'.
+	// they must check that MsgLookup.Message is equal to the provided 'cid', or set the
-	// Without this check both the requested and original message may appear as
+	// `allowReplaced` parameter to false. Without this check, and with `allowReplaced`
+	// set to true, both the requested and original message may appear as
 	// successfully executed on-chain, which may look like a double-spend.
 	//
 	// A replacing message is a message with a different CID, any of Gas values, and
 	// different signature, but with all other parameters matching (source/destination,
 	// nonce, params, etc.)
-	StateWaitMsgLimited(ctx context.Context, cid cid.Cid, confidence uint64, limit abi.ChainEpoch) (*MsgLookup, error) //perm:read
+	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64, limit abi.ChainEpoch, allowReplaced bool) (*MsgLookup, error) //perm:read
 	// StateListMiners returns the addresses of every miner that has claimed power in the Power Actor
 	StateListMiners(context.Context, types.TipSetKey) ([]address.Address, error) //perm:read
 	// StateListActors returns the addresses of every actor in the state
@@ -516,16 +487,6 @@ type FullNode interface {
 	// StateChangedActors returns all the actors whose states change between the two given state CIDs
 	// TODO: Should this take tipset keys instead?
 	StateChangedActors(context.Context, cid.Cid, cid.Cid) (map[string]types.Actor, error) //perm:read
-	// StateGetReceipt returns the message receipt for the given message or for a
-	// matching gas-repriced replacing message
-	//
-	// NOTE: If the requested message was replaced, this method will return the receipt
-	// for the replacing message - if the caller needs the receipt for exactly the
-	// requested message, use StateSearchMsg().Receipt, and check that MsgLookup.Message
-	// is matching the requested CID
-	//
-	// DEPRECATED: Use StateSearchMsg, this method won't be supported in v1 API
-	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error) //perm:read
 	// StateMinerSectorCount returns the number of sectors in a miner's sector set and proving set
 	StateMinerSectorCount(context.Context, address.Address, types.TipSetKey) (MinerSectors, error) //perm:read
 	// StateCompute is a flexible command that applies the given messages on the given tipset.

api/api_gateway.go

@@ -31,7 +31,6 @@ type Gateway interface {
 	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 	StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (DealCollateralBounds, error)
 	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
-	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
 	StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error)
 	StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 	StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (MarketBalance, error)
@@ -40,8 +39,8 @@ type Gateway interface {
 	StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error)
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
 	StateNetworkVersion(context.Context, types.TipSetKey) (apitypes.NetworkVersion, error)
-	StateSearchMsg(ctx context.Context, msg cid.Cid) (*MsgLookup, error)
 	StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error)
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
-	StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*MsgLookup, error)
+	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)
 }

api/api_test.go

@@ -113,3 +113,9 @@ func TestReturnTypes(t *testing.T) {
 	t.Run("miner", tst(new(StorageMiner)))
 	t.Run("worker", tst(new(Worker)))
 }
+
+func TestPermTags(t *testing.T) {
+	_ = PermissionedFullAPI(&FullNodeStruct{})
+	_ = PermissionedStorMinerAPI(&StorageMinerStruct{})
+	_ = PermissionedWorkerAPI(&WorkerStruct{})
+}

api/apistruct/struct_test.go

@@ -1,9 +0,0 @@
-package apistruct
-
-import "testing"
-
-func TestPermTags(t *testing.T) {
-	_ = PermissionedFullAPI(&FullNodeStruct{})
-	_ = PermissionedStorMinerAPI(&StorageMinerStruct{})
-	_ = PermissionedWorkerAPI(&WorkerStruct{})
-}

api/client/client.go

@@ -10,13 +10,14 @@ import (
 	"github.com/filecoin-project/go-jsonrpc"
 
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/apistruct"
+	"github.com/filecoin-project/lotus/api/v0api"
+	"github.com/filecoin-project/lotus/api/v1api"
 	"github.com/filecoin-project/lotus/lib/rpcenc"
 )
 
-// NewCommonRPC creates a new http jsonrpc client.
+// NewCommonRPCV0 creates a new http jsonrpc client.
-func NewCommonRPC(ctx context.Context, addr string, requestHeader http.Header) (api.Common, jsonrpc.ClientCloser, error) {
+func NewCommonRPCV0(ctx context.Context, addr string, requestHeader http.Header) (api.Common, jsonrpc.ClientCloser, error) {
-	var res apistruct.CommonStruct
+	var res v0api.CommonStruct
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		[]interface{}{
 			&res.Internal,
@@ -27,9 +28,9 @@ func NewCommonRPC(ctx context.Context, addr string, requestHeader http.Header) (
 	return &res, closer, err
 }
 
-// NewFullNodeRPC creates a new http jsonrpc client.
+// NewFullNodeRPCV0 creates a new http jsonrpc client.
-func NewFullNodeRPC(ctx context.Context, addr string, requestHeader http.Header) (api.FullNode, jsonrpc.ClientCloser, error) {
+func NewFullNodeRPCV0(ctx context.Context, addr string, requestHeader http.Header) (v0api.FullNode, jsonrpc.ClientCloser, error) {
-	var res apistruct.FullNodeStruct
+	var res v0api.FullNodeStruct
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		[]interface{}{
 			&res.CommonStruct.Internal,
@@ -39,9 +40,21 @@ func NewFullNodeRPC(ctx context.Context, addr string, requestHeader http.Header)
 	return &res, closer, err
 }
 
-// NewStorageMinerRPC creates a new http jsonrpc client for miner
+// NewFullNodeRPCV1 creates a new http jsonrpc client.
-func NewStorageMinerRPC(ctx context.Context, addr string, requestHeader http.Header, opts ...jsonrpc.Option) (api.StorageMiner, jsonrpc.ClientCloser, error) {
+func NewFullNodeRPCV1(ctx context.Context, addr string, requestHeader http.Header) (api.FullNode, jsonrpc.ClientCloser, error) {
-	var res apistruct.StorageMinerStruct
+	var res v1api.FullNodeStruct
+	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
+		[]interface{}{
+			&res.CommonStruct.Internal,
+			&res.Internal,
+		}, requestHeader)
+
+	return &res, closer, err
+}
+
+// NewStorageMinerRPCV0 creates a new http jsonrpc client for miner
+func NewStorageMinerRPCV0(ctx context.Context, addr string, requestHeader http.Header, opts ...jsonrpc.Option) (v0api.StorageMiner, jsonrpc.ClientCloser, error) {
+	var res v0api.StorageMinerStruct
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		[]interface{}{
 			&res.CommonStruct.Internal,
@@ -54,7 +67,7 @@ func NewStorageMinerRPC(ctx context.Context, addr string, requestHeader http.Hea
 	return &res, closer, err
 }
 
-func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (api.Worker, jsonrpc.ClientCloser, error) {
+func NewWorkerRPCV0(ctx context.Context, addr string, requestHeader http.Header) (api.Worker, jsonrpc.ClientCloser, error) {
 	u, err := url.Parse(addr)
 	if err != nil {
 		return nil, nil, err
@@ -69,7 +82,7 @@ func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (
 
 	u.Path = path.Join(u.Path, "../streams/v0/push")
 
-	var res apistruct.WorkerStruct
+	var res api.WorkerStruct
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		[]interface{}{
 			&res.Internal,
@@ -83,9 +96,9 @@ func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (
 	return &res, closer, err
 }
 
-// NewGatewayRPC creates a new http jsonrpc client for a gateway node.
+// NewGatewayRPCV1 creates a new http jsonrpc client for a gateway node.
-func NewGatewayRPC(ctx context.Context, addr string, requestHeader http.Header, opts ...jsonrpc.Option) (api.Gateway, jsonrpc.ClientCloser, error) {
+func NewGatewayRPCV1(ctx context.Context, addr string, requestHeader http.Header, opts ...jsonrpc.Option) (api.Gateway, jsonrpc.ClientCloser, error) {
-	var res apistruct.GatewayStruct
+	var res api.GatewayStruct
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		[]interface{}{
 			&res.Internal,
@@ -97,8 +110,8 @@ func NewGatewayRPC(ctx context.Context, addr string, requestHeader http.Header,
 	return &res, closer, err
 }
 
-func NewWalletRPC(ctx context.Context, addr string, requestHeader http.Header) (api.Wallet, jsonrpc.ClientCloser, error) {
+func NewWalletRPCV0(ctx context.Context, addr string, requestHeader http.Header) (api.Wallet, jsonrpc.ClientCloser, error) {
-	var res apistruct.WalletStruct
+	var res api.WalletStruct
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		[]interface{}{
 			&res.Internal,

api/docgen-openrpc/cmd/docgen_openrpc.go

@@ -7,7 +7,8 @@ import (
 	"log"
 	"os"
 
-	"github.com/filecoin-project/lotus/api/apistruct"
+	"github.com/filecoin-project/lotus/api/docgen"
+
 	docgen_openrpc "github.com/filecoin-project/lotus/api/docgen-openrpc"
 )
 
@@ -29,16 +30,12 @@ Use:
 */
 
 func main() {
-	doc := docgen_openrpc.NewLotusOpenRPCDocument()
+	Comments, GroupDocs := docgen.ParseApiASTInfo(os.Args[1], os.Args[2], os.Args[3], os.Args[4])
 
-	switch os.Args[2] {
+	doc := docgen_openrpc.NewLotusOpenRPCDocument(Comments, GroupDocs)
-	case "FullNode":
+
-		doc.RegisterReceiverName("Filecoin", &apistruct.FullNodeStruct{})
+	i, _, _, _ := docgen.GetAPIType(os.Args[2], os.Args[3])
-	case "StorageMiner":
+	doc.RegisterReceiverName("Filecoin", i)
-		doc.RegisterReceiverName("Filecoin", &apistruct.StorageMinerStruct{})
-	case "Worker":
-		doc.RegisterReceiverName("Filecoin", &apistruct.WorkerStruct{})
-	}
 
 	out, err := doc.Discover()
 	if err != nil {
@@ -52,7 +49,7 @@ func main() {
 	// Could use flags package to handle this more cleanly, but that requires changes elsewhere
 	// the scope of which just isn't warranted by this one use case which will usually be run
 	// programmatically anyways.
-	if len(os.Args) > 3 && os.Args[3] == "-gzip" {
+	if len(os.Args) > 5 && os.Args[5] == "-gzip" {
 		jsonOut, err = json.Marshal(out)
 		if err != nil {
 			log.Fatalln(err)

api/docgen-openrpc/openrpc.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"go/ast"
 	"net"
-	"os"
 	"reflect"
 
 	"github.com/alecthomas/jsonschema"
@@ -15,16 +14,6 @@ import (
 	meta_schema "github.com/open-rpc/meta-schema"
 )
 
-// Comments holds API method comments collected by AST parsing.
-var Comments map[string]string
-
-// GroupDocs holds documentation for documentation groups.
-var GroupDocs map[string]string
-
-func init() {
-	Comments, GroupDocs = docgen.ParseApiASTInfo(os.Args[1], os.Args[2])
-}
-
 // schemaDictEntry represents a type association passed to the jsonschema reflector.
 type schemaDictEntry struct {
 	example interface{}
@@ -94,7 +83,7 @@ func OpenRPCSchemaTypeMapper(ty reflect.Type) *jsonschema.Type {
 }
 
 // NewLotusOpenRPCDocument defines application-specific documentation and configuration for its OpenRPC document.
-func NewLotusOpenRPCDocument() *go_openrpc_reflect.Document {
+func NewLotusOpenRPCDocument(Comments, GroupDocs map[string]string) *go_openrpc_reflect.Document {
 	d := &go_openrpc_reflect.Document{}
 
 	// Register "Meta" document fields.

api/docgen/cmd/docgen.go

@@ -4,39 +4,18 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
-	"reflect"
 	"sort"
 	"strings"
 
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/apistruct"
 	"github.com/filecoin-project/lotus/api/docgen"
 )
 
 func main() {
-	comments, groupComments := docgen.ParseApiASTInfo(os.Args[1], os.Args[2])
+	comments, groupComments := docgen.ParseApiASTInfo(os.Args[1], os.Args[2], os.Args[3], os.Args[4])
 
 	groups := make(map[string]*docgen.MethodGroup)
 
-	var t reflect.Type
+	_, t, permStruct, commonPermStruct := docgen.GetAPIType(os.Args[2], os.Args[3])
-	var permStruct, commonPermStruct reflect.Type
-
-	switch os.Args[2] {
-	case "FullNode":
-		t = reflect.TypeOf(new(struct{ api.FullNode })).Elem()
-		permStruct = reflect.TypeOf(apistruct.FullNodeStruct{}.Internal)
-		commonPermStruct = reflect.TypeOf(apistruct.CommonStruct{}.Internal)
-	case "StorageMiner":
-		t = reflect.TypeOf(new(struct{ api.StorageMiner })).Elem()
-		permStruct = reflect.TypeOf(apistruct.StorageMinerStruct{}.Internal)
-		commonPermStruct = reflect.TypeOf(apistruct.CommonStruct{}.Internal)
-	case "Worker":
-		t = reflect.TypeOf(new(struct{ api.Worker })).Elem()
-		permStruct = reflect.TypeOf(apistruct.WorkerStruct{}.Internal)
-		commonPermStruct = reflect.TypeOf(apistruct.WorkerStruct{}.Internal)
-	default:
-		panic("unknown type")
-	}
 
 	for i := 0; i < t.NumMethod(); i++ {
 		m := t.Method(i)

api/docgen/docgen.go

@@ -35,6 +35,7 @@ import (
 
 	"github.com/filecoin-project/lotus/api"
 	apitypes "github.com/filecoin-project/lotus/api/types"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
@@ -262,6 +263,42 @@ func init() {
 	)
 }
 
+func GetAPIType(name, pkg string) (i interface{}, t, permStruct, commonPermStruct reflect.Type) {
+	switch pkg {
+	case "api": // latest
+		switch name {
+		case "FullNode":
+			i = &api.FullNodeStruct{}
+			t = reflect.TypeOf(new(struct{ api.FullNode })).Elem()
+			permStruct = reflect.TypeOf(api.FullNodeStruct{}.Internal)
+			commonPermStruct = reflect.TypeOf(api.CommonStruct{}.Internal)
+		case "StorageMiner":
+			i = &api.StorageMinerStruct{}
+			t = reflect.TypeOf(new(struct{ api.StorageMiner })).Elem()
+			permStruct = reflect.TypeOf(api.StorageMinerStruct{}.Internal)
+			commonPermStruct = reflect.TypeOf(api.CommonStruct{}.Internal)
+		case "Worker":
+			i = &api.WorkerStruct{}
+			t = reflect.TypeOf(new(struct{ api.Worker })).Elem()
+			permStruct = reflect.TypeOf(api.WorkerStruct{}.Internal)
+			commonPermStruct = reflect.TypeOf(api.WorkerStruct{}.Internal)
+		default:
+			panic("unknown type")
+		}
+	case "v0api":
+		switch name {
+		case "FullNode":
+			i = v0api.FullNodeStruct{}
+			t = reflect.TypeOf(new(struct{ v0api.FullNode })).Elem()
+			permStruct = reflect.TypeOf(v0api.FullNodeStruct{}.Internal)
+			commonPermStruct = reflect.TypeOf(v0api.CommonStruct{}.Internal)
+		default:
+			panic("unknown type")
+		}
+	}
+	return
+}
+
 func ExampleValue(method string, t, parent reflect.Type) interface{} {
 	v, ok := ExampleValues[t]
 	if ok {
@@ -342,9 +379,9 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {
 
 const NoComment = "There are not yet any comments for this method."
 
-func ParseApiASTInfo(apiFile, iface string) (comments map[string]string, groupDocs map[string]string) { //nolint:golint
+func ParseApiASTInfo(apiFile, iface, pkg, dir string) (comments map[string]string, groupDocs map[string]string) { //nolint:golint
 	fset := token.NewFileSet()
-	apiDir, err := filepath.Abs("./api")
+	apiDir, err := filepath.Abs(dir)
 	if err != nil {
 		fmt.Println("./api filepath absolute error: ", err)
 		return
@@ -360,14 +397,14 @@ func ParseApiASTInfo(apiFile, iface string) (comments map[string]string, groupDo
 		return
 	}
 
-	ap := pkgs["api"]
+	ap := pkgs[pkg]
 
 	f := ap.Files[apiFile]
 
 	cmap := ast.NewCommentMap(fset, f, f.Comments)
 
 	v := &Visitor{iface, make(map[string]ast.Node)}
-	ast.Walk(v, pkgs["api"])
+	ast.Walk(v, ap)
 
 	comments = make(map[string]string)
 	groupDocs = make(map[string]string)

api/mocks/mock_full.go

@@ -6,6 +6,8 @@ package mocks
 
 import (
 	context "context"
+	reflect "reflect"
+
 	address "github.com/filecoin-project/go-address"
 	bitfield "github.com/filecoin-project/go-bitfield"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
@@ -33,7 +35,6 @@ import (
 	network0 "github.com/libp2p/go-libp2p-core/network"
 	peer "github.com/libp2p/go-libp2p-core/peer"
 	protocol "github.com/libp2p/go-libp2p-core/protocol"
-	reflect "reflect"
 )
 
 // MockFullNode is a mock of FullNode interface
@@ -2094,21 +2095,6 @@ func (mr *MockFullNodeMockRecorder) StateGetActor(arg0, arg1, arg2 interface{})
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetActor", reflect.TypeOf((*MockFullNode)(nil).StateGetActor), arg0, arg1, arg2)
 }
 
-// StateGetReceipt mocks base method
-func (m *MockFullNode) StateGetReceipt(arg0 context.Context, arg1 cid.Cid, arg2 types.TipSetKey) (*types.MessageReceipt, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateGetReceipt", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*types.MessageReceipt)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateGetReceipt indicates an expected call of StateGetReceipt
-func (mr *MockFullNodeMockRecorder) StateGetReceipt(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateGetReceipt", reflect.TypeOf((*MockFullNode)(nil).StateGetReceipt), arg0, arg1, arg2)
-}
-
 // StateListActors mocks base method
 func (m *MockFullNode) StateListActors(arg0 context.Context, arg1 types.TipSetKey) ([]address.Address, error) {
 	m.ctrl.T.Helper()
@@ -2500,33 +2486,18 @@ func (mr *MockFullNodeMockRecorder) StateReplay(arg0, arg1, arg2 interface{}) *g
 }
 
 // StateSearchMsg mocks base method
-func (m *MockFullNode) StateSearchMsg(arg0 context.Context, arg1 cid.Cid) (*api.MsgLookup, error) {
+func (m *MockFullNode) StateSearchMsg(arg0 context.Context, arg1 types.TipSetKey, arg2 cid.Cid, arg3 abi.ChainEpoch, arg4 bool) (*api.MsgLookup, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateSearchMsg", arg0, arg1)
+	ret := m.ctrl.Call(m, "StateSearchMsg", arg0, arg1, arg2, arg3, arg4)
 	ret0, _ := ret[0].(*api.MsgLookup)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // StateSearchMsg indicates an expected call of StateSearchMsg
-func (mr *MockFullNodeMockRecorder) StateSearchMsg(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockFullNodeMockRecorder) StateSearchMsg(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateSearchMsg", reflect.TypeOf((*MockFullNode)(nil).StateSearchMsg), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateSearchMsg", reflect.TypeOf((*MockFullNode)(nil).StateSearchMsg), arg0, arg1, arg2, arg3, arg4)
-}
-
-// StateSearchMsgLimited mocks base method
-func (m *MockFullNode) StateSearchMsgLimited(arg0 context.Context, arg1 cid.Cid, arg2 abi.ChainEpoch) (*api.MsgLookup, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateSearchMsgLimited", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*api.MsgLookup)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateSearchMsgLimited indicates an expected call of StateSearchMsgLimited
-func (mr *MockFullNodeMockRecorder) StateSearchMsgLimited(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateSearchMsgLimited", reflect.TypeOf((*MockFullNode)(nil).StateSearchMsgLimited), arg0, arg1, arg2)
 }
 
 // StateSectorExpiration mocks base method
@@ -2650,33 +2621,18 @@ func (mr *MockFullNodeMockRecorder) StateVerifierStatus(arg0, arg1, arg2 interfa
 }
 
 // StateWaitMsg mocks base method
-func (m *MockFullNode) StateWaitMsg(arg0 context.Context, arg1 cid.Cid, arg2 uint64) (*api.MsgLookup, error) {
+func (m *MockFullNode) StateWaitMsg(arg0 context.Context, arg1 cid.Cid, arg2 uint64, arg3 abi.ChainEpoch, arg4 bool) (*api.MsgLookup, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateWaitMsg", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "StateWaitMsg", arg0, arg1, arg2, arg3, arg4)
 	ret0, _ := ret[0].(*api.MsgLookup)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // StateWaitMsg indicates an expected call of StateWaitMsg
-func (mr *MockFullNodeMockRecorder) StateWaitMsg(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockFullNodeMockRecorder) StateWaitMsg(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateWaitMsg", reflect.TypeOf((*MockFullNode)(nil).StateWaitMsg), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateWaitMsg", reflect.TypeOf((*MockFullNode)(nil).StateWaitMsg), arg0, arg1, arg2, arg3, arg4)
-}
-
-// StateWaitMsgLimited mocks base method
-func (m *MockFullNode) StateWaitMsgLimited(arg0 context.Context, arg1 cid.Cid, arg2 uint64, arg3 abi.ChainEpoch) (*api.MsgLookup, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateWaitMsgLimited", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*api.MsgLookup)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// StateWaitMsgLimited indicates an expected call of StateWaitMsgLimited
-func (mr *MockFullNodeMockRecorder) StateWaitMsgLimited(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateWaitMsgLimited", reflect.TypeOf((*MockFullNode)(nil).StateWaitMsgLimited), arg0, arg1, arg2, arg3)
 }
 
 // SyncCheckBad mocks base method

api/permissioned.go

@@ -1,8 +1,7 @@
-package apistruct
+package api
 
 import (
 	"github.com/filecoin-project/go-jsonrpc/auth"
-	"github.com/filecoin-project/lotus/api"
 )
 
 const (
@@ -17,27 +16,27 @@ const (
 var AllPermissions = []auth.Permission{PermRead, PermWrite, PermSign, PermAdmin}
 var DefaultPerms = []auth.Permission{PermRead}
 
-func PermissionedStorMinerAPI(a api.StorageMiner) api.StorageMiner {
+func PermissionedStorMinerAPI(a StorageMiner) StorageMiner {
 	var out StorageMinerStruct
 	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
 	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.CommonStruct.Internal)
 	return &out
 }
 
-func PermissionedFullAPI(a api.FullNode) api.FullNode {
+func PermissionedFullAPI(a FullNode) FullNode {
 	var out FullNodeStruct
 	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
 	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.CommonStruct.Internal)
 	return &out
 }
 
-func PermissionedWorkerAPI(a api.Worker) api.Worker {
+func PermissionedWorkerAPI(a Worker) Worker {
 	var out WorkerStruct
 	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
 	return &out
 }
 
-func PermissionedWalletAPI(a api.Wallet) api.Wallet {
+func PermissionedWalletAPI(a Wallet) Wallet {
 	var out WalletStruct
 	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
 	return &out

api/test/paych.go

@@ -235,7 +235,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	res, err = paymentReceiver.StateWaitMsg(ctx, collectMsg, 3)
+	res, err = paymentReceiver.StateWaitMsg(ctx, collectMsg, 3, api.LookbackNoLimit, true)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -287,7 +287,7 @@ func waitForBlocks(ctx context.Context, t *testing.T, bm *BlockMiner, paymentRec
 			t.Fatal(err)
 		}
 
-		_, err = paymentReceiver.StateWaitMsg(ctx, m.Cid(), 1)
+		_, err = paymentReceiver.StateWaitMsg(ctx, m.Cid(), 1, api.LookbackNoLimit, true)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -299,7 +299,7 @@ func waitForMessage(ctx context.Context, t *testing.T, paymentCreator TestNode,
 	defer cancel()
 
 	fmt.Println("Waiting for", desc)
-	res, err := paymentCreator.StateWaitMsg(ctx, msgCid, 1)
+	res, err := paymentCreator.StateWaitMsg(ctx, msgCid, 1, api.LookbackNoLimit, true)
 	if err != nil {
 		fmt.Println("Error waiting for", desc, err)
 		t.Fatal(err)

api/test/test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/filecoin-project/lotus/api/v1api"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 
@@ -20,7 +21,7 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/lotus/api"
+	lapi "github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node"
@@ -36,14 +37,14 @@ func init() {
 }
 
 type TestNode struct {
-	api.FullNode
+	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
 }
 
 type TestStorageNode struct {
-	api.StorageMiner
+	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
@@ -155,7 +156,7 @@ var MineNext = miner.MineReq{
 }
 
 func (ts *testSuite) testVersion(t *testing.T) {
-	api.RunningNodeType = api.NodeFull
+	lapi.RunningNodeType = lapi.NodeFull
 
 	ctx := context.Background()
 	apis, _ := ts.makeNodes(t, OneFull, OneMiner)
@@ -196,7 +197,7 @@ func (ts *testSuite) testSearchMsg(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	res, err := api.StateWaitMsg(ctx, sm.Cid(), 1)
+	res, err := api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -204,7 +205,7 @@ func (ts *testSuite) testSearchMsg(t *testing.T) {
 		t.Fatal("did not successfully send message")
 	}
 
-	searchRes, err := api.StateSearchMsg(ctx, sm.Cid())
+	searchRes, err := api.StateSearchMsg(ctx, types.EmptyTSK, sm.Cid(), lapi.LookbackNoLimit, true)
 	if err != nil {
 		t.Fatal(err)
 	}

api/test/util.go

@@ -8,6 +8,7 @@ import (
 	"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"
 )
@@ -28,7 +29,7 @@ func SendFunds(ctx context.Context, t *testing.T, sender TestNode, addr address.
 	if err != nil {
 		t.Fatal(err)
 	}
-	res, err := sender.StateWaitMsg(ctx, sm.Cid(), 1)
+	res, err := sender.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
 	if err != nil {
 		t.Fatal(err)
 	}

api/test/window_post.go

@@ -766,7 +766,7 @@ func TestWindowPostDispute(t *testing.T, b APIBuilder, blocktime time.Duration)
 		require.NoError(t, err)
 
 		fmt.Println("waiting dispute")
-		rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence)
+		rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence, api.LookbackNoLimit, true)
 		require.NoError(t, err)
 		require.Zero(t, rec.Receipt.ExitCode, "dispute not accepted: %s", rec.Receipt.ExitCode.Error())
 	}
@@ -807,7 +807,7 @@ func TestWindowPostDispute(t *testing.T, b APIBuilder, blocktime time.Duration)
 		sm, err := client.MpoolPushMessage(ctx, msg, nil)
 		require.NoError(t, err)
 
-		rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence)
+		rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence, api.LookbackNoLimit, true)
 		require.NoError(t, err)
 		require.Zero(t, rec.Receipt.ExitCode, "recovery not accepted: %s", rec.Receipt.ExitCode.Error())
 	}
@@ -886,7 +886,7 @@ func submitBadProof(
 		return err
 	}
 
-	rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence)
+	rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence, api.LookbackNoLimit, true)
 	if err != nil {
 		return err
 	}

api/v0api/full.go

@@ -0,0 +1,684 @@
+package v0api
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-bitfield"
+	datatransfer "github.com/filecoin-project/go-data-transfer"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-multistore"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/dline"
+	"github.com/ipfs/go-cid"
+	"github.com/libp2p/go-libp2p-core/peer"
+
+	"github.com/filecoin-project/lotus/api"
+	apitypes "github.com/filecoin-project/lotus/api/types"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	"github.com/filecoin-project/lotus/chain/types"
+	marketevents "github.com/filecoin-project/lotus/markets/loggers"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+)
+
+//go:generate go run github.com/golang/mock/mockgen -destination=v0mocks/mock_full.go -package=v0mocks . FullNode
+
+// FullNode API is a low-level interface to the Filecoin network full node
+type FullNode interface {
+	Common
+
+	// MethodGroup: Chain
+	// The Chain method group contains methods for interacting with the
+	// blockchain, but that do not require any form of state computation.
+
+	// ChainNotify returns channel with chain head updates.
+	// First message is guaranteed to be of len == 1, and type == 'current'.
+	ChainNotify(context.Context) (<-chan []*api.HeadChange, error) //perm:read
+
+	// ChainHead returns the current head of the chain.
+	ChainHead(context.Context) (*types.TipSet, error) //perm:read
+
+	// ChainGetRandomnessFromTickets is used to sample the chain for randomness.
+	ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) //perm:read
+
+	// ChainGetRandomnessFromBeacon is used to sample the beacon for randomness.
+	ChainGetRandomnessFromBeacon(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) //perm:read
+
+	// ChainGetBlock returns the block specified by the given CID.
+	ChainGetBlock(context.Context, cid.Cid) (*types.BlockHeader, error) //perm:read
+	// ChainGetTipSet returns the tipset specified by the given TipSetKey.
+	ChainGetTipSet(context.Context, types.TipSetKey) (*types.TipSet, error) //perm:read
+
+	// ChainGetBlockMessages returns messages stored in the specified block.
+	//
+	// Note: If there are multiple blocks in a tipset, it's likely that some
+	// messages will be duplicated. It's also possible for blocks in a tipset to have
+	// different messages from the same sender at the same nonce. When that happens,
+	// only the first message (in a block with lowest ticket) will be considered
+	// for execution
+	//
+	// NOTE: THIS METHOD SHOULD ONLY BE USED FOR GETTING MESSAGES IN A SPECIFIC BLOCK
+	//
+	// DO NOT USE THIS METHOD TO GET MESSAGES INCLUDED IN A TIPSET
+	// Use ChainGetParentMessages, which will perform correct message deduplication
+	ChainGetBlockMessages(ctx context.Context, blockCid cid.Cid) (*api.BlockMessages, error) //perm:read
+
+	// ChainGetParentReceipts returns receipts for messages in parent tipset of
+	// the specified block. The receipts in the list returned is one-to-one with the
+	// messages returned by a call to ChainGetParentMessages with the same blockCid.
+	ChainGetParentReceipts(ctx context.Context, blockCid cid.Cid) ([]*types.MessageReceipt, error) //perm:read
+
+	// ChainGetParentMessages returns messages stored in parent tipset of the
+	// specified block.
+	ChainGetParentMessages(ctx context.Context, blockCid cid.Cid) ([]api.Message, error) //perm:read
+
+	// ChainGetTipSetByHeight looks back for a tipset at the specified epoch.
+	// If there are no blocks at the specified epoch, a tipset at an earlier epoch
+	// will be returned.
+	ChainGetTipSetByHeight(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error) //perm:read
+
+	// ChainReadObj reads ipld nodes referenced by the specified CID from chain
+	// blockstore and returns raw bytes.
+	ChainReadObj(context.Context, cid.Cid) ([]byte, error) //perm:read
+
+	// ChainDeleteObj deletes node referenced by the given CID
+	ChainDeleteObj(context.Context, cid.Cid) error //perm:admin
+
+	// ChainHasObj checks if a given CID exists in the chain blockstore.
+	ChainHasObj(context.Context, cid.Cid) (bool, error) //perm:read
+
+	// ChainStatObj returns statistics about the graph referenced by 'obj'.
+	// If 'base' is also specified, then the returned stat will be a diff
+	// between the two objects.
+	ChainStatObj(ctx context.Context, obj cid.Cid, base cid.Cid) (api.ObjStat, error) //perm:read
+
+	// ChainSetHead forcefully sets current chain head. Use with caution.
+	ChainSetHead(context.Context, types.TipSetKey) error //perm:admin
+
+	// ChainGetGenesis returns the genesis tipset.
+	ChainGetGenesis(context.Context) (*types.TipSet, error) //perm:read
+
+	// ChainTipSetWeight computes weight for the specified tipset.
+	ChainTipSetWeight(context.Context, types.TipSetKey) (types.BigInt, error) //perm:read
+	ChainGetNode(ctx context.Context, p string) (*api.IpldObject, error)      //perm:read
+
+	// ChainGetMessage reads a message referenced by the specified CID from the
+	// chain blockstore.
+	ChainGetMessage(context.Context, cid.Cid) (*types.Message, error) //perm:read
+
+	// ChainGetPath returns a set of revert/apply operations needed to get from
+	// one tipset to another, for example:
+	//```
+	//        to
+	//         ^
+	// from   tAA
+	//   ^     ^
+	// tBA    tAB
+	//  ^---*--^
+	//      ^
+	//     tRR
+	//```
+	// Would return `[revert(tBA), apply(tAB), apply(tAA)]`
+	ChainGetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*api.HeadChange, error) //perm:read
+
+	// ChainExport returns a stream of bytes with CAR dump of chain data.
+	// The exported chain data includes the header chain from the given tipset
+	// back to genesis, the entire genesis state, and the most recent 'nroots'
+	// state trees.
+	// If oldmsgskip is set, messages from before the requested roots are also not included.
+	ChainExport(ctx context.Context, nroots abi.ChainEpoch, oldmsgskip bool, tsk types.TipSetKey) (<-chan []byte, error) //perm:read
+
+	// MethodGroup: Beacon
+	// The Beacon method group contains methods for interacting with the random beacon (DRAND)
+
+	// BeaconGetEntry returns the beacon entry for the given filecoin epoch. If
+	// the entry has not yet been produced, the call will block until the entry
+	// becomes available
+	BeaconGetEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) //perm:read
+
+	// GasEstimateFeeCap estimates gas fee cap
+	GasEstimateFeeCap(context.Context, *types.Message, int64, types.TipSetKey) (types.BigInt, error) //perm:read
+
+	// GasEstimateGasLimit estimates gas used by the message and returns it.
+	// It fails if message fails to execute.
+	GasEstimateGasLimit(context.Context, *types.Message, types.TipSetKey) (int64, error) //perm:read
+
+	// GasEstimateGasPremium estimates what gas price should be used for a
+	// message to have high likelihood of inclusion in `nblocksincl` epochs.
+
+	GasEstimateGasPremium(_ context.Context, nblocksincl uint64,
+		sender address.Address, gaslimit int64, tsk types.TipSetKey) (types.BigInt, error) //perm:read
+
+	// GasEstimateMessageGas estimates gas values for unset message gas fields
+	GasEstimateMessageGas(context.Context, *types.Message, *api.MessageSendSpec, types.TipSetKey) (*types.Message, error) //perm:read
+
+	// MethodGroup: Sync
+	// The Sync method group contains methods for interacting with and
+	// observing the lotus sync service.
+
+	// SyncState returns the current status of the lotus sync system.
+	SyncState(context.Context) (*api.SyncState, error) //perm:read
+
+	// SyncSubmitBlock can be used to submit a newly created block to the.
+	// network through this node
+	SyncSubmitBlock(ctx context.Context, blk *types.BlockMsg) error //perm:write
+
+	// SyncIncomingBlocks returns a channel streaming incoming, potentially not
+	// yet synced block headers.
+	SyncIncomingBlocks(ctx context.Context) (<-chan *types.BlockHeader, error) //perm:read
+
+	// SyncCheckpoint marks a blocks as checkpointed, meaning that it won't ever fork away from it.
+	SyncCheckpoint(ctx context.Context, tsk types.TipSetKey) error //perm:admin
+
+	// SyncMarkBad marks a blocks as bad, meaning that it won't ever by synced.
+	// Use with extreme caution.
+	SyncMarkBad(ctx context.Context, bcid cid.Cid) error //perm:admin
+
+	// SyncUnmarkBad unmarks a blocks as bad, making it possible to be validated and synced again.
+	SyncUnmarkBad(ctx context.Context, bcid cid.Cid) error //perm:admin
+
+	// SyncUnmarkAllBad purges bad block cache, making it possible to sync to chains previously marked as bad
+	SyncUnmarkAllBad(ctx context.Context) error //perm:admin
+
+	// SyncCheckBad checks if a block was marked as bad, and if it was, returns
+	// the reason.
+	SyncCheckBad(ctx context.Context, bcid cid.Cid) (string, error) //perm:read
+
+	// SyncValidateTipset indicates whether the provided tipset is valid or not
+	SyncValidateTipset(ctx context.Context, tsk types.TipSetKey) (bool, error) //perm:read
+
+	// MethodGroup: Mpool
+	// The Mpool methods are for interacting with the message pool. The message pool
+	// manages all incoming and outgoing 'messages' going over the network.
+
+	// MpoolPending returns pending mempool messages.
+	MpoolPending(context.Context, types.TipSetKey) ([]*types.SignedMessage, error) //perm:read
+
+	// MpoolSelect returns a list of pending messages for inclusion in the next block
+	MpoolSelect(context.Context, types.TipSetKey, float64) ([]*types.SignedMessage, error) //perm:read
+
+	// MpoolPush pushes a signed message to mempool.
+	MpoolPush(context.Context, *types.SignedMessage) (cid.Cid, error) //perm:write
+
+	// MpoolPushUntrusted pushes a signed message to mempool from untrusted sources.
+	MpoolPushUntrusted(context.Context, *types.SignedMessage) (cid.Cid, error) //perm:write
+
+	// MpoolPushMessage atomically assigns a nonce, signs, and pushes a message
+	// to mempool.
+	// maxFee is only used when GasFeeCap/GasPremium fields aren't specified
+	//
+	// When maxFee is set to 0, MpoolPushMessage will guess appropriate fee
+	// based on current chain conditions
+	MpoolPushMessage(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec) (*types.SignedMessage, error) //perm:sign
+
+	// MpoolBatchPush batch pushes a signed message to mempool.
+	MpoolBatchPush(context.Context, []*types.SignedMessage) ([]cid.Cid, error) //perm:write
+
+	// MpoolBatchPushUntrusted batch pushes a signed message to mempool from untrusted sources.
+	MpoolBatchPushUntrusted(context.Context, []*types.SignedMessage) ([]cid.Cid, error) //perm:write
+
+	// MpoolBatchPushMessage batch pushes a unsigned message to mempool.
+	MpoolBatchPushMessage(context.Context, []*types.Message, *api.MessageSendSpec) ([]*types.SignedMessage, error) //perm:sign
+
+	// 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
+	MpoolSub(context.Context) (<-chan api.MpoolUpdate, error)       //perm:read
+
+	// MpoolClear clears pending messages from the mpool
+	MpoolClear(context.Context, bool) error //perm:write
+
+	// MpoolGetConfig returns (a copy of) the current mpool config
+	MpoolGetConfig(context.Context) (*types.MpoolConfig, error) //perm:read
+	// MpoolSetConfig sets the mpool config to (a copy of) the supplied config
+	MpoolSetConfig(context.Context, *types.MpoolConfig) error //perm:admin
+
+	// MethodGroup: Miner
+
+	MinerGetBaseInfo(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*api.MiningBaseInfo, error) //perm:read
+	MinerCreateBlock(context.Context, *api.BlockTemplate) (*types.BlockMsg, error)                                   //perm:write
+
+	// // UX ?
+
+	// MethodGroup: Wallet
+
+	// WalletNew creates a new address in the wallet with the given sigType.
+	// Available key types: bls, secp256k1, secp256k1-ledger
+	// Support for numerical types: 1 - secp256k1, 2 - BLS is deprecated
+	WalletNew(context.Context, types.KeyType) (address.Address, error) //perm:write
+	// WalletHas indicates whether the given address is in the wallet.
+	WalletHas(context.Context, address.Address) (bool, error) //perm:write
+	// WalletList lists all the addresses in the wallet.
+	WalletList(context.Context) ([]address.Address, error) //perm:write
+	// WalletBalance returns the balance of the given address at the current head of the chain.
+	WalletBalance(context.Context, address.Address) (types.BigInt, error) //perm:read
+	// WalletSign signs the given bytes using the given address.
+	WalletSign(context.Context, address.Address, []byte) (*crypto.Signature, error) //perm:sign
+	// WalletSignMessage signs the given message using the given address.
+	WalletSignMessage(context.Context, address.Address, *types.Message) (*types.SignedMessage, error) //perm:sign
+	// WalletVerify takes an address, a signature, and some bytes, and indicates whether the signature is valid.
+	// The address does not have to be in the wallet.
+	WalletVerify(context.Context, address.Address, []byte, *crypto.Signature) (bool, error) //perm:read
+	// WalletDefaultAddress returns the address marked as default in the wallet.
+	WalletDefaultAddress(context.Context) (address.Address, error) //perm:write
+	// WalletSetDefault marks the given address as as the default one.
+	WalletSetDefault(context.Context, address.Address) error //perm:write
+	// WalletExport returns the private key of an address in the wallet.
+	WalletExport(context.Context, address.Address) (*types.KeyInfo, error) //perm:admin
+	// WalletImport receives a KeyInfo, which includes a private key, and imports it into the wallet.
+	WalletImport(context.Context, *types.KeyInfo) (address.Address, error) //perm:admin
+	// WalletDelete deletes an address from the wallet.
+	WalletDelete(context.Context, address.Address) error //perm:admin
+	// WalletValidateAddress validates whether a given string can be decoded as a well-formed address
+	WalletValidateAddress(context.Context, string) (address.Address, error) //perm:read
+
+	// Other
+
+	// MethodGroup: Client
+	// The Client methods all have to do with interacting with the storage and
+	// retrieval markets as a client
+
+	// ClientImport imports file under the specified path into filestore.
+	ClientImport(ctx context.Context, ref api.FileRef) (*api.ImportRes, error) //perm:admin
+	// ClientRemoveImport removes file import
+	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
+	// 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.
+	ClientListDeals(ctx context.Context) ([]api.DealInfo, error) //perm:write
+	// ClientGetDealUpdates returns the status of updated deals
+	ClientGetDealUpdates(ctx context.Context) (<-chan api.DealInfo, error) //perm:write
+	// ClientGetDealStatus returns status given a code
+	ClientGetDealStatus(ctx context.Context, statusCode uint64) (string, error) //perm:read
+	// ClientHasLocal indicates whether a certain CID is locally stored.
+	ClientHasLocal(ctx context.Context, root cid.Cid) (bool, error) //perm:write
+	// ClientFindData identifies peers that have a certain file, and returns QueryOffers (one per peer).
+	ClientFindData(ctx context.Context, root cid.Cid, piece *cid.Cid) ([]api.QueryOffer, error) //perm:read
+	// ClientMinerQueryOffer returns a QueryOffer for the specific miner and file.
+	ClientMinerQueryOffer(ctx context.Context, miner address.Address, root cid.Cid, piece *cid.Cid) (api.QueryOffer, error) //perm:read
+	// ClientRetrieve initiates the retrieval of a file, as specified in the order.
+	ClientRetrieve(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) error //perm:admin
+	// ClientRetrieveWithEvents initiates the retrieval of a file, as specified in the order, and provides a channel
+	// 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.
+	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
+	// ClientCalcCommP calculates the CommP for a specified file
+	ClientCalcCommP(ctx context.Context, inpath string) (*api.CommPRet, error) //perm:write
+	// ClientGenCar generates a CAR file for the specified file.
+	ClientGenCar(ctx context.Context, ref api.FileRef, outpath string) error //perm:write
+	// ClientDealSize calculates real deal data size
+	ClientDealSize(ctx context.Context, root cid.Cid) (api.DataSize, error) //perm:read
+	// ClientListTransfers returns the status of all ongoing transfers of data
+	ClientListDataTransfers(ctx context.Context) ([]api.DataTransferChannel, error)        //perm:write
+	ClientDataTransferUpdates(ctx context.Context) (<-chan api.DataTransferChannel, error) //perm:write
+	// ClientRestartDataTransfer attempts to restart a data transfer with the given transfer ID and other peer
+	ClientRestartDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error //perm:write
+	// ClientCancelDataTransfer cancels a data transfer with the given transfer ID and other peer
+	ClientCancelDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error //perm:write
+	// ClientRetrieveTryRestartInsufficientFunds attempts to restart stalled retrievals on a given payment channel
+	// which are stuck due to insufficient funds
+	ClientRetrieveTryRestartInsufficientFunds(ctx context.Context, paymentChannel address.Address) error //perm:write
+
+	// ClientCancelRetrievalDeal cancels an ongoing retrieval deal based on DealID
+	ClientCancelRetrievalDeal(ctx context.Context, dealid retrievalmarket.DealID) error //perm:write
+
+	// ClientUnimport removes references to the specified file from filestore
+	//ClientUnimport(path string)
+
+	// ClientListImports lists imported files and their root CIDs
+	ClientListImports(ctx context.Context) ([]api.Import, error) //perm:write
+
+	//ClientListAsks() []Ask
+
+	// MethodGroup: State
+	// The State methods are used to query, inspect, and interact with chain state.
+	// Most methods take a TipSetKey as a parameter. The state looked up is the parent state of the tipset.
+	// A nil TipSetKey can be provided as a param, this will cause the heaviest tipset in the chain to be used.
+
+	// StateCall runs the given message and returns its result without any persisted changes.
+	//
+	// StateCall applies the message to the tipset's parent state. The
+	// message is not applied on-top-of the messages in the passed-in
+	// tipset.
+	StateCall(context.Context, *types.Message, types.TipSetKey) (*api.InvocResult, error) //perm:read
+	// StateReplay replays a given message, assuming it was included in a block in the specified tipset.
+	//
+	// If a tipset key is provided, and a replacing message is found on chain,
+	// the method will return an error saying that the message wasn't found
+	//
+	// If no tipset key is provided, the appropriate tipset is looked up, and if
+	// the message was gas-repriced, the on-chain message will be replayed - in
+	// that case the returned InvocResult.MsgCid will not match the Cid param
+	//
+	// If the caller wants to ensure that exactly the requested message was executed,
+	// they MUST check that InvocResult.MsgCid is equal to the provided Cid.
+	// Without this check both the requested and original message may appear as
+	// successfully executed on-chain, which may look like a double-spend.
+	//
+	// A replacing message is a message with a different CID, any of Gas values, and
+	// different signature, but with all other parameters matching (source/destination,
+	// nonce, params, etc.)
+	StateReplay(context.Context, types.TipSetKey, cid.Cid) (*api.InvocResult, error) //perm:read
+	// StateGetActor returns the indicated actor's nonce and balance.
+	StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) //perm:read
+	// StateReadState returns the indicated actor's state.
+	StateReadState(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*api.ActorState, error) //perm:read
+	// StateListMessages looks back and returns all messages with a matching to or from address, stopping at the given height.
+	StateListMessages(ctx context.Context, match *api.MessageMatch, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error) //perm:read
+	// StateDecodeParams attempts to decode the provided params, based on the recipient actor address and method number.
+	StateDecodeParams(ctx context.Context, toAddr address.Address, method abi.MethodNum, params []byte, tsk types.TipSetKey) (interface{}, error) //perm:read
+
+	// StateNetworkName returns the name of the network the node is synced to
+	StateNetworkName(context.Context) (dtypes.NetworkName, error) //perm:read
+	// StateMinerSectors returns info about the given miner's sectors. If the filter bitfield is nil, all sectors are included.
+	StateMinerSectors(context.Context, address.Address, *bitfield.BitField, types.TipSetKey) ([]*miner.SectorOnChainInfo, error) //perm:read
+	// StateMinerActiveSectors returns info about sectors that a given miner is actively proving.
+	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) ([]*miner.SectorOnChainInfo, error) //perm:read
+	// StateMinerProvingDeadline calculates the deadline at some epoch for a proving period
+	// and returns the deadline-related calculations.
+	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error) //perm:read
+	// StateMinerPower returns the power of the indicated miner
+	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error) //perm:read
+	// StateMinerInfo returns info about the indicated miner
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error) //perm:read
+	// StateMinerDeadlines returns all the proving deadlines for the given miner
+	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]api.Deadline, error) //perm:read
+	// StateMinerPartitions returns all partitions in the specified deadline
+	StateMinerPartitions(ctx context.Context, m address.Address, dlIdx uint64, tsk types.TipSetKey) ([]api.Partition, error) //perm:read
+	// StateMinerFaults returns a bitfield indicating the faulty sectors of the given miner
+	StateMinerFaults(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error) //perm:read
+	// StateAllMinerFaults returns all non-expired Faults that occur within lookback epochs of the given tipset
+	StateAllMinerFaults(ctx context.Context, lookback abi.ChainEpoch, ts types.TipSetKey) ([]*api.Fault, error) //perm:read
+	// StateMinerRecoveries returns a bitfield indicating the recovering sectors of the given miner
+	StateMinerRecoveries(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error) //perm:read
+	// StateMinerInitialPledgeCollateral returns the precommit deposit for the specified miner's sector
+	StateMinerPreCommitDepositForPower(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error) //perm:read
+	// StateMinerInitialPledgeCollateral returns the initial pledge collateral for the specified miner's sector
+	StateMinerInitialPledgeCollateral(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error) //perm:read
+	// StateMinerAvailableBalance returns the portion of a miner's balance that can be withdrawn or spent
+	StateMinerAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error) //perm:read
+	// StateMinerSectorAllocated checks if a sector is allocated
+	StateMinerSectorAllocated(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (bool, error) //perm:read
+	// StateSectorPreCommitInfo returns the PreCommit info for the specified miner's sector
+	StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) //perm:read
+	// StateSectorGetInfo returns the on-chain info for the specified miner's sector. Returns null in case the sector info isn't found
+	// NOTE: returned info.Expiration may not be accurate in some cases, use StateSectorExpiration to get accurate
+	// expiration epoch
+	StateSectorGetInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorOnChainInfo, error) //perm:read
+	// StateSectorExpiration returns epoch at which given sector will expire
+	StateSectorExpiration(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorExpiration, error) //perm:read
+	// StateSectorPartition finds deadline/partition with the specified sector
+	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*miner.SectorLocation, error) //perm:read
+	// StateSearchMsg searches for a message in the chain, and returns its receipt and the tipset where it was executed
+	//
+	// NOTE: If a replacing message is found on chain, this method will return
+	// a MsgLookup for the replacing message - the MsgLookup.Message will be a different
+	// CID than the one provided in the 'cid' param, MsgLookup.Receipt will contain the
+	// result of the execution of the replacing message.
+	//
+	// If the caller wants to ensure that exactly the requested message was executed,
+	// they MUST check that MsgLookup.Message is equal to the provided 'cid'.
+	// Without this check both the requested and original message may appear as
+	// successfully executed on-chain, which may look like a double-spend.
+	//
+	// A replacing message is a message with a different CID, any of Gas values, and
+	// different signature, but with all other parameters matching (source/destination,
+	// nonce, params, etc.)
+	StateSearchMsg(context.Context, cid.Cid) (*api.MsgLookup, error) //perm:read
+	// StateSearchMsgLimited looks back up to limit epochs in the chain for a message, and returns its receipt and the tipset where it was executed
+	//
+	// NOTE: If a replacing message is found on chain, this method will return
+	// a MsgLookup for the replacing message - the MsgLookup.Message will be a different
+	// CID than the one provided in the 'cid' param, MsgLookup.Receipt will contain the
+	// result of the execution of the replacing message.
+	//
+	// If the caller wants to ensure that exactly the requested message was executed,
+	// they MUST check that MsgLookup.Message is equal to the provided 'cid'.
+	// Without this check both the requested and original message may appear as
+	// successfully executed on-chain, which may look like a double-spend.
+	//
+	// A replacing message is a message with a different CID, any of Gas values, and
+	// different signature, but with all other parameters matching (source/destination,
+	// nonce, params, etc.)
+	StateSearchMsgLimited(ctx context.Context, msg cid.Cid, limit abi.ChainEpoch) (*api.MsgLookup, error) //perm:read
+	// StateWaitMsg looks back in the chain for a message. If not found, it blocks until the
+	// message arrives on chain, and gets to the indicated confidence depth.
+	//
+	// NOTE: If a replacing message is found on chain, this method will return
+	// a MsgLookup for the replacing message - the MsgLookup.Message will be a different
+	// CID than the one provided in the 'cid' param, MsgLookup.Receipt will contain the
+	// result of the execution of the replacing message.
+	//
+	// If the caller wants to ensure that exactly the requested message was executed,
+	// they MUST check that MsgLookup.Message is equal to the provided 'cid'.
+	// Without this check both the requested and original message may appear as
+	// successfully executed on-chain, which may look like a double-spend.
+	//
+	// A replacing message is a message with a different CID, any of Gas values, and
+	// different signature, but with all other parameters matching (source/destination,
+	// nonce, params, etc.)
+	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64) (*api.MsgLookup, error) //perm:read
+	// StateWaitMsgLimited looks back up to limit epochs in the chain for a message.
+	// If not found, it blocks until the message arrives on chain, and gets to the
+	// indicated confidence depth.
+	//
+	// NOTE: If a replacing message is found on chain, this method will return
+	// a MsgLookup for the replacing message - the MsgLookup.Message will be a different
+	// CID than the one provided in the 'cid' param, MsgLookup.Receipt will contain the
+	// result of the execution of the replacing message.
+	//
+	// If the caller wants to ensure that exactly the requested message was executed,
+	// they MUST check that MsgLookup.Message is equal to the provided 'cid'.
+	// Without this check both the requested and original message may appear as
+	// successfully executed on-chain, which may look like a double-spend.
+	//
+	// A replacing message is a message with a different CID, any of Gas values, and
+	// different signature, but with all other parameters matching (source/destination,
+	// nonce, params, etc.)
+	StateWaitMsgLimited(ctx context.Context, cid cid.Cid, confidence uint64, limit abi.ChainEpoch) (*api.MsgLookup, error) //perm:read
+	// StateListMiners returns the addresses of every miner that has claimed power in the Power Actor
+	StateListMiners(context.Context, types.TipSetKey) ([]address.Address, error) //perm:read
+	// StateListActors returns the addresses of every actor in the state
+	StateListActors(context.Context, types.TipSetKey) ([]address.Address, error) //perm:read
+	// StateMarketBalance looks up the Escrow and Locked balances of the given address in the Storage Market
+	StateMarketBalance(context.Context, address.Address, types.TipSetKey) (api.MarketBalance, error) //perm:read
+	// StateMarketParticipants returns the Escrow and Locked balances of every participant in the Storage Market
+	StateMarketParticipants(context.Context, types.TipSetKey) (map[string]api.MarketBalance, error) //perm:read
+	// StateMarketDeals returns information about every deal in the Storage Market
+	StateMarketDeals(context.Context, types.TipSetKey) (map[string]api.MarketDeal, error) //perm:read
+	// StateMarketStorageDeal returns information about the indicated deal
+	StateMarketStorageDeal(context.Context, abi.DealID, types.TipSetKey) (*api.MarketDeal, error) //perm:read
+	// StateLookupID retrieves the ID address of the given address
+	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error) //perm:read
+	// StateAccountKey returns the public key address of the given ID address
+	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error) //perm:read
+	// StateChangedActors returns all the actors whose states change between the two given state CIDs
+	// TODO: Should this take tipset keys instead?
+	StateChangedActors(context.Context, cid.Cid, cid.Cid) (map[string]types.Actor, error) //perm:read
+	// StateGetReceipt returns the message receipt for the given message or for a
+	// matching gas-repriced replacing message
+	//
+	// NOTE: If the requested message was replaced, this method will return the receipt
+	// for the replacing message - if the caller needs the receipt for exactly the
+	// requested message, use StateSearchMsg().Receipt, and check that MsgLookup.Message
+	// is matching the requested CID
+	//
+	// DEPRECATED: Use StateSearchMsg, this method won't be supported in v1 API
+	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error) //perm:read
+	// StateMinerSectorCount returns the number of sectors in a miner's sector set and proving set
+	StateMinerSectorCount(context.Context, address.Address, types.TipSetKey) (api.MinerSectors, error) //perm:read
+	// StateCompute is a flexible command that applies the given messages on the given tipset.
+	// The messages are run as though the VM were at the provided height.
+	//
+	// When called, StateCompute will:
+	// - Load the provided tipset, or use the current chain head if not provided
+	// - Compute the tipset state of the provided tipset on top of the parent state
+	//   - (note that this step runs before vmheight is applied to the execution)
+	//   - Execute state upgrade if any were scheduled at the epoch, or in null
+	//     blocks preceding the tipset
+	//   - Call the cron actor on null blocks preceding the tipset
+	//   - For each block in the tipset
+	//     - Apply messages in blocks in the specified
+	//     - Award block reward by calling the reward actor
+	//   - Call the cron actor for the current epoch
+	// - If the specified vmheight is higher than the current epoch, apply any
+	//   needed state upgrades to the state
+	// - Apply the specified messages to the state
+	//
+	// The vmheight parameter sets VM execution epoch, and can be used to simulate
+	// message execution in different network versions. If the specified vmheight
+	// epoch is higher than the epoch of the specified tipset, any state upgrades
+	// until the vmheight will be executed on the state before applying messages
+	// specified by the user.
+	//
+	// Note that the initial tipset state computation is not affected by the
+	// vmheight parameter - only the messages in the `apply` set are
+	//
+	// If the caller wants to simply compute the state, vmheight should be set to
+	// the epoch of the specified tipset.
+	//
+	// Messages in the `apply` parameter must have the correct nonces, and gas
+	// values set.
+	StateCompute(context.Context, abi.ChainEpoch, []*types.Message, types.TipSetKey) (*api.ComputeStateOutput, error) //perm:read
+	// StateVerifierStatus returns the data cap for the given address.
+	// Returns nil if there is no entry in the data cap table for the
+	// address.
+	StateVerifierStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) //perm:read
+	// StateVerifiedClientStatus returns the data cap for the given address.
+	// Returns nil if there is no entry in the data cap table for the
+	// address.
+	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) //perm:read
+	// StateVerifiedClientStatus returns the address of the Verified Registry's root key
+	StateVerifiedRegistryRootKey(ctx context.Context, tsk types.TipSetKey) (address.Address, error) //perm:read
+	// StateDealProviderCollateralBounds returns the min and max collateral a storage provider
+	// can issue. It takes the deal size and verified status as parameters.
+	StateDealProviderCollateralBounds(context.Context, abi.PaddedPieceSize, bool, types.TipSetKey) (api.DealCollateralBounds, error) //perm:read
+
+	// StateCirculatingSupply returns the exact circulating supply of Filecoin at the given tipset.
+	// This is not used anywhere in the protocol itself, and is only for external consumption.
+	StateCirculatingSupply(context.Context, types.TipSetKey) (abi.TokenAmount, error) //perm:read
+	// StateVMCirculatingSupplyInternal returns an approximation of the circulating supply of Filecoin at the given tipset.
+	// This is the value reported by the runtime interface to actors code.
+	StateVMCirculatingSupplyInternal(context.Context, types.TipSetKey) (api.CirculatingSupply, error) //perm:read
+	// StateNetworkVersion returns the network version at the given tipset
+	StateNetworkVersion(context.Context, types.TipSetKey) (apitypes.NetworkVersion, error) //perm:read
+
+	// MethodGroup: Msig
+	// The Msig methods are used to interact with multisig wallets on the
+	// filecoin network
+
+	// MsigGetAvailableBalance returns the portion of a multisig's balance that can be withdrawn or spent
+	MsigGetAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error) //perm:read
+	// MsigGetVestingSchedule returns the vesting details of a given multisig.
+	MsigGetVestingSchedule(context.Context, address.Address, types.TipSetKey) (api.MsigVesting, error) //perm:read
+	// MsigGetVested returns the amount of FIL that vested in a multisig in a certain period.
+	// It takes the following params: <multisig address>, <start epoch>, <end epoch>
+	MsigGetVested(context.Context, address.Address, types.TipSetKey, types.TipSetKey) (types.BigInt, error) //perm:read
+
+	//MsigGetPending returns pending transactions for the given multisig
+	//wallet. Once pending transactions are fully approved, they will no longer
+	//appear here.
+	MsigGetPending(context.Context, address.Address, types.TipSetKey) ([]*api.MsigTransaction, error) //perm:read
+
+	// MsigCreate creates a multisig wallet
+	// It takes the following params: <required number of senders>, <approving addresses>, <unlock duration>
+	//<initial balance>, <sender address of the create msg>, <gas price>
+	MsigCreate(context.Context, uint64, []address.Address, abi.ChainEpoch, types.BigInt, address.Address, types.BigInt) (cid.Cid, error) //perm:sign
+	// MsigPropose proposes a multisig message
+	// It takes the following params: <multisig address>, <recipient address>, <value to transfer>,
+	// <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
+
+	// 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
+
+	// MsigApproveTxnHash approves a previously-proposed multisig message, specified
+	// using both transaction ID and a hash of the parameters used in the
+	// 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>
+	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
+	// 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
+	// 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
+	// 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
+	// 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
+	// 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
+	// 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
+	// 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
+
+	// 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
+
+	// MarketAddBalance adds funds to the market actor
+	MarketAddBalance(ctx context.Context, wallet, addr address.Address, amt types.BigInt) (cid.Cid, error) //perm:sign
+	// MarketGetReserved gets the amount of funds that are currently reserved for the address
+	MarketGetReserved(ctx context.Context, addr address.Address) (types.BigInt, error) //perm:sign
+	// MarketReserveFunds reserves funds for a deal
+	MarketReserveFunds(ctx context.Context, wallet address.Address, addr address.Address, amt types.BigInt) (cid.Cid, error) //perm:sign
+	// MarketReleaseFunds releases funds reserved by MarketReserveFunds
+	MarketReleaseFunds(ctx context.Context, addr address.Address, amt types.BigInt) error //perm:sign
+	// MarketWithdraw withdraws unlocked funds from the market actor
+	MarketWithdraw(ctx context.Context, wallet, addr address.Address, amt types.BigInt) (cid.Cid, error) //perm:sign
+
+	// MethodGroup: Paych
+	// The Paych methods are for interacting with and managing payment channels
+
+	PaychGet(ctx context.Context, from, to address.Address, amt types.BigInt) (*api.ChannelInfo, error)                  //perm:sign
+	PaychGetWaitReady(context.Context, cid.Cid) (address.Address, error)                                                 //perm:sign
+	PaychAvailableFunds(ctx context.Context, ch address.Address) (*api.ChannelAvailableFunds, error)                     //perm:sign
+	PaychAvailableFundsByFromTo(ctx context.Context, from, to address.Address) (*api.ChannelAvailableFunds, error)       //perm:sign
+	PaychList(context.Context) ([]address.Address, error)                                                                //perm:read
+	PaychStatus(context.Context, address.Address) (*api.PaychStatus, error)                                              //perm:read
+	PaychSettle(context.Context, address.Address) (cid.Cid, error)                                                       //perm:sign
+	PaychCollect(context.Context, address.Address) (cid.Cid, error)                                                      //perm:sign
+	PaychAllocateLane(ctx context.Context, ch address.Address) (uint64, error)                                           //perm:sign
+	PaychNewPayment(ctx context.Context, from, to address.Address, vouchers []api.VoucherSpec) (*api.PaymentInfo, error) //perm:sign
+	PaychVoucherCheckValid(context.Context, address.Address, *paych.SignedVoucher) error                                 //perm:read
+	PaychVoucherCheckSpendable(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (bool, error)     //perm:read
+	PaychVoucherCreate(context.Context, address.Address, types.BigInt, uint64) (*api.VoucherCreateResult, error)         //perm:sign
+	PaychVoucherAdd(context.Context, address.Address, *paych.SignedVoucher, []byte, types.BigInt) (types.BigInt, error)  //perm:write
+	PaychVoucherList(context.Context, address.Address) ([]*paych.SignedVoucher, error)                                   //perm:write
+	PaychVoucherSubmit(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (cid.Cid, error)          //perm:sign
+
+	// CreateBackup creates node backup onder the specified file name. The
+	// method requires that the lotus daemon is running with the
+	// LOTUS_BACKUP_BASE_PATH environment variable set to some path, and that
+	// the path specified when calling CreateBackup is within the base path
+	CreateBackup(ctx context.Context, fpath string) error //perm:admin
+}

api/v0api/latest.go

@@ -0,0 +1,27 @@
+package v0api
+
+import (
+	"github.com/filecoin-project/lotus/api"
+)
+
+type Common = api.Common
+type CommonStruct = api.CommonStruct
+type CommonStub = api.CommonStub
+
+type Gateway = api.Gateway
+
+type StorageMiner = api.StorageMiner
+type StorageMinerStruct = api.StorageMinerStruct
+
+type Worker = api.Worker
+type WorkerStruct = api.WorkerStruct
+
+type Wallet = api.Wallet
+
+func PermissionedStorMinerAPI(a StorageMiner) StorageMiner {
+	return api.PermissionedStorMinerAPI(a)
+}
+
+func PermissionedWorkerAPI(a Worker) Worker {
+	return api.PermissionedWorkerAPI(a)
+}

api/v0api/permissioned.go

@@ -0,0 +1,13 @@
+package v0api
+
+import (
+	"github.com/filecoin-project/go-jsonrpc/auth"
+	"github.com/filecoin-project/lotus/api"
+)
+
+func PermissionedFullAPI(a FullNode) FullNode {
+	var out FullNodeStruct
+	auth.PermissionedProxy(api.AllPermissions, api.DefaultPerms, a, &out.Internal)
+	auth.PermissionedProxy(api.AllPermissions, api.DefaultPerms, a, &out.CommonStruct.Internal)
+	return &out
+}

api/v0api/v1_wrapper.go

@@ -0,0 +1,49 @@
+package v0api
+
+import (
+	"context"
+
+	"github.com/filecoin-project/lotus/chain/types"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v1api"
+)
+
+type WrapperV1Full struct {
+	v1api.FullNode
+}
+
+func (w *WrapperV1Full) StateSearchMsg(ctx context.Context, msg cid.Cid) (*api.MsgLookup, error) {
+	return w.FullNode.StateSearchMsg(ctx, types.EmptyTSK, msg, api.LookbackNoLimit, true)
+}
+
+func (w *WrapperV1Full) StateSearchMsgLimited(ctx context.Context, msg cid.Cid, limit abi.ChainEpoch) (*api.MsgLookup, error) {
+	return w.FullNode.StateSearchMsg(ctx, types.EmptyTSK, msg, limit, true)
+}
+
+func (w *WrapperV1Full) StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*api.MsgLookup, error) {
+	return w.FullNode.StateWaitMsg(ctx, msg, confidence, api.LookbackNoLimit, true)
+}
+
+func (w *WrapperV1Full) StateWaitMsgLimited(ctx context.Context, msg cid.Cid, confidence uint64, limit abi.ChainEpoch) (*api.MsgLookup, error) {
+	return w.FullNode.StateWaitMsg(ctx, msg, confidence, limit, true)
+}
+
+func (w *WrapperV1Full) StateGetReceipt(ctx context.Context, msg cid.Cid, from types.TipSetKey) (*types.MessageReceipt, error) {
+	ml, err := w.FullNode.StateSearchMsg(ctx, from, msg, api.LookbackNoLimit, true)
+	if err != nil {
+		return nil, err
+	}
+
+	if ml == nil {
+		return nil, nil
+	}
+
+	return &ml.Receipt, nil
+}
+
+var _ FullNode = &WrapperV1Full{}

api/v1api/latest.go

@@ -0,0 +1,12 @@
+package v1api
+
+import (
+	"github.com/filecoin-project/lotus/api"
+)
+
+type FullNode = api.FullNode
+type FullNodeStruct = api.FullNodeStruct
+
+func PermissionedFullAPI(a FullNode) FullNode {
+	return api.PermissionedFullAPI(a)
+}

api/wrap.go

@@ -0,0 +1,32 @@
+package api
+
+import (
+	"reflect"
+)
+
+// Wrap adapts partial api impl to another version
+// proxyT is the proxy type used as input in wrapperT
+// Usage: Wrap(new(v1api.FullNodeStruct), new(v0api.WrapperV1Full), eventsApi).(EventAPI)
+func Wrap(proxyT, wrapperT, impl interface{}) interface{} {
+	proxy := reflect.New(reflect.TypeOf(proxyT).Elem())
+	proxyMethods := proxy.Elem().FieldByName("Internal")
+	ri := reflect.ValueOf(impl)
+
+	for i := 0; i < ri.NumMethod(); i++ {
+		mt := ri.Type().Method(i)
+		if proxyMethods.FieldByName(mt.Name).Kind() == reflect.Invalid {
+			continue
+		}
+
+		fn := ri.Method(i)
+		of := proxyMethods.FieldByName(mt.Name)
+
+		proxyMethods.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()
+}

chain/events/events.go

@@ -33,19 +33,19 @@ type heightHandler struct {
 	revert RevertHandler
 }
 
-type eventAPI interface {
+type EventAPI interface {
 	ChainNotify(context.Context) (<-chan []*api.HeadChange, error)
 	ChainGetBlockMessages(context.Context, cid.Cid) (*api.BlockMessages, error)
 	ChainGetTipSetByHeight(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)
 	ChainHead(context.Context) (*types.TipSet, error)
-	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
+	StateSearchMsg(ctx context.Context, from types.TipSetKey, msg cid.Cid, limit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error)
 	ChainGetTipSet(context.Context, types.TipSetKey) (*types.TipSet, error)
 
 	StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) // optional / for CalledMsg
 }
 
 type Events struct {
-	api eventAPI
+	api EventAPI
 
 	tsc *tipSetCache
 	lk  sync.Mutex
@@ -59,7 +59,7 @@ type Events struct {
 	observers []TipSetObserver
 }
 
-func NewEventsWithConfidence(ctx context.Context, api eventAPI, gcConfidence abi.ChainEpoch) *Events {
+func NewEventsWithConfidence(ctx context.Context, api EventAPI, gcConfidence abi.ChainEpoch) *Events {
 	tsc := newTSCache(gcConfidence, api)
 
 	e := &Events{
@@ -93,7 +93,7 @@ func NewEventsWithConfidence(ctx context.Context, api eventAPI, gcConfidence abi
 	return e
 }
 
-func NewEvents(ctx context.Context, api eventAPI) *Events {
+func NewEvents(ctx context.Context, api EventAPI) *Events {
 	gcConfidence := 2 * build.ForkLengthThreshold
 	return NewEventsWithConfidence(ctx, api, gcConfidence)
 }

chain/events/events_called.go

@@ -5,6 +5,8 @@ import (
 	"math"
 	"sync"
 
+	"github.com/filecoin-project/lotus/chain/stmgr"
+
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
@@ -66,7 +68,7 @@ type queuedEvent struct {
 // Manages chain head change events, which may be forward (new tipset added to
 // chain) or backward (chain branch discarded in favour of heavier branch)
 type hcEvents struct {
-	cs           eventAPI
+	cs           EventAPI
 	tsc          *tipSetCache
 	ctx          context.Context
 	gcConfidence uint64
@@ -93,7 +95,7 @@ type hcEvents struct {
 	watcherEvents
 }
 
-func newHCEvents(ctx context.Context, cs eventAPI, tsc *tipSetCache, gcConfidence uint64) *hcEvents {
+func newHCEvents(ctx context.Context, cs EventAPI, tsc *tipSetCache, gcConfidence uint64) *hcEvents {
 	e := hcEvents{
 		ctx:          ctx,
 		cs:           cs,
@@ -353,14 +355,14 @@ type headChangeAPI interface {
 // watcherEvents watches for a state change
 type watcherEvents struct {
 	ctx   context.Context
-	cs    eventAPI
+	cs    EventAPI
 	hcAPI headChangeAPI
 
 	lk       sync.RWMutex
 	matchers map[triggerID]StateMatchFunc
 }
 
-func newWatcherEvents(ctx context.Context, hcAPI headChangeAPI, cs eventAPI) watcherEvents {
+func newWatcherEvents(ctx context.Context, hcAPI headChangeAPI, cs EventAPI) watcherEvents {
 	return watcherEvents{
 		ctx:      ctx,
 		cs:       cs,
@@ -455,14 +457,14 @@ func (we *watcherEvents) StateChanged(check CheckFunc, scHnd StateChangeHandler,
 // messageEvents watches for message calls to actors
 type messageEvents struct {
 	ctx   context.Context
-	cs    eventAPI
+	cs    EventAPI
 	hcAPI headChangeAPI
 
 	lk       sync.RWMutex
 	matchers map[triggerID]MsgMatchFunc
 }
 
-func newMessageEvents(ctx context.Context, hcAPI headChangeAPI, cs eventAPI) messageEvents {
+func newMessageEvents(ctx context.Context, hcAPI headChangeAPI, cs EventAPI) messageEvents {
 	return messageEvents{
 		ctx:      ctx,
 		cs:       cs,
@@ -583,12 +585,16 @@ func (me *messageEvents) Called(check CheckFunc, msgHnd MsgHandler, rev RevertHa
 			panic("expected msg")
 		}
 
-		rec, err := me.cs.StateGetReceipt(me.ctx, msg.Cid(), ts.Key())
+		ml, err := me.cs.StateSearchMsg(me.ctx, ts.Key(), msg.Cid(), stmgr.LookbackNoLimit, true)
 		if err != nil {
 			return false, err
 		}
 
-		return msgHnd(msg, rec, ts, height)
+		if ml == nil {
+			return msgHnd(msg, nil, ts, height)
+		}
+
+		return msgHnd(msg, &ml.Receipt, ts, height)
 	}
 
 	id, err := me.hcAPI.onHeadChanged(check, hnd, rev, confidence, timeout)

chain/events/events_test.go

@@ -54,7 +54,7 @@ func (fcs *fakeCS) ChainGetTipSet(ctx context.Context, key types.TipSetKey) (*ty
 	return fcs.tipsets[key], nil
 }
 
-func (fcs *fakeCS) StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error) {
+func (fcs *fakeCS) StateSearchMsg(ctx context.Context, from types.TipSetKey, msg cid.Cid, limit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error) {
 	return nil, nil
 }
 
@@ -229,7 +229,7 @@ func (fcs *fakeCS) notifDone() {
 	fcs.sync.Unlock()
 }
 
-var _ eventAPI = &fakeCS{}
+var _ EventAPI = &fakeCS{}
 
 func TestAt(t *testing.T) {
 	fcs := &fakeCS{

chain/events/utils.go

@@ -3,6 +3,8 @@ package events
 import (
 	"context"
 
+	"github.com/filecoin-project/lotus/chain/stmgr"
+
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/lotus/chain/types"
@@ -22,12 +24,16 @@ func (me *messageEvents) CheckMsg(ctx context.Context, smsg types.ChainMsg, hnd
 			return false, true, nil
 		}
 
-		rec, err := me.cs.StateGetReceipt(ctx, smsg.VMMessage().Cid(), ts.Key())
+		ml, err := me.cs.StateSearchMsg(me.ctx, ts.Key(), msg.Cid(), stmgr.LookbackNoLimit, true)
 		if err != nil {
 			return false, true, xerrors.Errorf("getting receipt in CheckMsg: %w", err)
 		}
 
-		more, err = hnd(msg, rec, ts, ts.Height())
+		if ml == nil {
+			more, err = hnd(msg, nil, ts, ts.Height())
+		} else {
+			more, err = hnd(msg, &ml.Receipt, ts, ts.Height())
+		}
 
 		return true, more, err
 	}

chain/market/fundmanager.go

@@ -36,7 +36,7 @@ type FundManagerAPI struct {
 type fundManagerAPI interface {
 	MpoolPushMessage(context.Context, *types.Message, *api.MessageSendSpec) (*types.SignedMessage, error)
 	StateMarketBalance(context.Context, address.Address, types.TipSetKey) (api.MarketBalance, error)
-	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64) (*api.MsgLookup, error)
+	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64, limit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error)
 }
 
 // FundManager keeps track of funds in a set of addresses
@@ -721,6 +721,6 @@ func (env *fundManagerEnvironment) WithdrawFunds(
 }
 
 func (env *fundManagerEnvironment) WaitMsg(ctx context.Context, c cid.Cid) error {
-	_, err := env.api.StateWaitMsg(ctx, c, build.MessageConfidence)
+	_, err := env.api.StateWaitMsg(ctx, c, build.MessageConfidence, api.LookbackNoLimit, true)
 	return err
 }

chain/market/fundmanager_test.go

@@ -793,7 +793,7 @@ func (mapi *mockFundManagerAPI) publish(addr address.Address, amt abi.TokenAmoun
 	mapi.escrow[addr] = escrow
 }
 
-func (mapi *mockFundManagerAPI) StateWaitMsg(ctx context.Context, c cid.Cid, confidence uint64) (*api.MsgLookup, error) {
+func (mapi *mockFundManagerAPI) StateWaitMsg(ctx context.Context, c cid.Cid, confidence uint64, limit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error) {
 	res := &api.MsgLookup{
 		Message: c,
 		Receipt: types.MessageReceipt{

chain/stmgr/stmgr.go

@@ -45,7 +45,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/vm"
 )
 
-const LookbackNoLimit = abi.ChainEpoch(-1)
+const LookbackNoLimit = api.LookbackNoLimit
 const ReceiptAmtBitwidth = 3
 
 var log = logging.Logger("statemgr")
@@ -564,24 +564,10 @@ func (sm *StateManager) LookupID(ctx context.Context, addr address.Address, ts *
 	return state.LookupID(addr)
 }
 
-func (sm *StateManager) GetReceipt(ctx context.Context, msg cid.Cid, ts *types.TipSet) (*types.MessageReceipt, error) {
-	m, err := sm.cs.GetCMessage(msg)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load message: %w", err)
-	}
-
-	_, r, _, err := sm.searchBackForMsg(ctx, ts, m, LookbackNoLimit)
-	if err != nil {
-		return nil, fmt.Errorf("failed to look back through chain for message: %w", err)
-	}
-
-	return r, nil
-}
-
 // WaitForMessage blocks until a message appears on chain. It looks backwards in the chain to see if this has already
 // happened, with an optional limit to how many epochs it will search. It guarantees that the message has been on
 // chain for at least confidence epochs without being reverted before returning.
-func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confidence uint64, lookbackLimit abi.ChainEpoch) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
+func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confidence uint64, lookbackLimit abi.ChainEpoch, allowReplaced bool) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
@@ -605,7 +591,7 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
 		return nil, nil, cid.Undef, fmt.Errorf("expected current head on SHC stream (got %s)", head[0].Type)
 	}
 
-	r, foundMsg, err := sm.tipsetExecutedMessage(head[0].Val, mcid, msg.VMMessage())
+	r, foundMsg, err := sm.tipsetExecutedMessage(head[0].Val, mcid, msg.VMMessage(), allowReplaced)
 	if err != nil {
 		return nil, nil, cid.Undef, err
 	}
@@ -619,7 +605,7 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
 	var backFm cid.Cid
 	backSearchWait := make(chan struct{})
 	go func() {
-		fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head[0].Val, msg, lookbackLimit)
+		fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head[0].Val, msg, lookbackLimit, allowReplaced)
 		if err != nil {
 			log.Warnf("failed to look back through chain for message: %v", err)
 			return
@@ -658,7 +644,7 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
 					if candidateTs != nil && val.Val.Height() >= candidateTs.Height()+abi.ChainEpoch(confidence) {
 						return candidateTs, candidateRcp, candidateFm, nil
 					}
-					r, foundMsg, err := sm.tipsetExecutedMessage(val.Val, mcid, msg.VMMessage())
+					r, foundMsg, err := sm.tipsetExecutedMessage(val.Val, mcid, msg.VMMessage(), allowReplaced)
 					if err != nil {
 						return nil, nil, cid.Undef, err
 					}
@@ -694,15 +680,13 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
 	}
 }
 
-func (sm *StateManager) SearchForMessage(ctx context.Context, mcid cid.Cid, lookbackLimit abi.ChainEpoch) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
+func (sm *StateManager) SearchForMessage(ctx context.Context, head *types.TipSet, mcid cid.Cid, lookbackLimit abi.ChainEpoch, allowReplaced bool) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
 	msg, err := sm.cs.GetCMessage(mcid)
 	if err != nil {
 		return nil, nil, cid.Undef, fmt.Errorf("failed to load message: %w", err)
 	}
 
-	head := sm.cs.GetHeaviestTipSet()
+	r, foundMsg, err := sm.tipsetExecutedMessage(head, mcid, msg.VMMessage(), allowReplaced)
-
-	r, foundMsg, err := sm.tipsetExecutedMessage(head, mcid, msg.VMMessage())
 	if err != nil {
 		return nil, nil, cid.Undef, err
 	}
@@ -711,7 +695,7 @@ func (sm *StateManager) SearchForMessage(ctx context.Context, mcid cid.Cid, look
 		return head, r, foundMsg, nil
 	}
 
-	fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head, msg, lookbackLimit)
+	fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head, msg, lookbackLimit, allowReplaced)
 
 	if err != nil {
 		log.Warnf("failed to look back through chain for message %s", mcid)
@@ -731,7 +715,7 @@ func (sm *StateManager) SearchForMessage(ctx context.Context, mcid cid.Cid, look
 // - 0 then no tipsets are searched
 // - 5 then five tipset are searched
 // - LookbackNoLimit then there is no limit
-func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet, m types.ChainMsg, limit abi.ChainEpoch) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
+func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet, m types.ChainMsg, limit abi.ChainEpoch, allowReplaced bool) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
 	limitHeight := from.Height() - limit
 	noLimit := limit == LookbackNoLimit
 
@@ -781,7 +765,7 @@ func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet
 
 		// check that between cur and parent tipset the nonce fell into range of our message
 		if actorNoExist || (curActor.Nonce > mNonce && act.Nonce <= mNonce) {
-			r, foundMsg, err := sm.tipsetExecutedMessage(cur, m.Cid(), m.VMMessage())
+			r, foundMsg, err := sm.tipsetExecutedMessage(cur, m.Cid(), m.VMMessage(), allowReplaced)
 			if err != nil {
 				return nil, nil, cid.Undef, xerrors.Errorf("checking for message execution during lookback: %w", err)
 			}
@@ -796,7 +780,7 @@ func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet
 	}
 }
 
-func (sm *StateManager) tipsetExecutedMessage(ts *types.TipSet, msg cid.Cid, vmm *types.Message) (*types.MessageReceipt, cid.Cid, error) {
+func (sm *StateManager) tipsetExecutedMessage(ts *types.TipSet, msg cid.Cid, vmm *types.Message, allowReplaced bool) (*types.MessageReceipt, cid.Cid, error) {
 	// The genesis block did not execute any messages
 	if ts.Height() == 0 {
 		return nil, cid.Undef, nil
@@ -819,7 +803,7 @@ func (sm *StateManager) tipsetExecutedMessage(ts *types.TipSet, msg cid.Cid, vmm
 
 		if m.VMMessage().From == vmm.From { // cheaper to just check origin first
 			if m.VMMessage().Nonce == vmm.Nonce {
-				if m.VMMessage().EqualCall(vmm) {
+				if allowReplaced && m.VMMessage().EqualCall(vmm) {
 					if m.Cid() != msg {
 						log.Warnw("found message with equal nonce and call params but different CID",
 							"wanted", msg, "found", m.Cid(), "nonce", vmm.Nonce, "from", vmm.From)

chain/sync_test.go

@@ -622,17 +622,17 @@ func TestDuplicateNonce(t *testing.T) {
 
 	var includedMsg cid.Cid
 	var skippedMsg cid.Cid
-	r0, err0 := tu.nds[0].StateGetReceipt(context.TODO(), msgs[0][0].Cid(), ts2.TipSet().Key())
+	r0, err0 := tu.nds[0].StateSearchMsg(context.TODO(), ts2.TipSet().Key(), msgs[0][0].Cid(), api.LookbackNoLimit, true)
-	r1, err1 := tu.nds[0].StateGetReceipt(context.TODO(), msgs[1][0].Cid(), ts2.TipSet().Key())
+	r1, err1 := tu.nds[0].StateSearchMsg(context.TODO(), ts2.TipSet().Key(), msgs[1][0].Cid(), api.LookbackNoLimit, true)
 
 	if err0 == nil {
 		require.Error(t, err1, "at least one of the StateGetReceipt calls should fail")
-		require.True(t, r0.ExitCode.IsSuccess())
+		require.True(t, r0.Receipt.ExitCode.IsSuccess())
 		includedMsg = msgs[0][0].Message.Cid()
 		skippedMsg = msgs[1][0].Message.Cid()
 	} else {
 		require.NoError(t, err1, "both the StateGetReceipt calls should not fail")
-		require.True(t, r1.ExitCode.IsSuccess())
+		require.True(t, r1.Receipt.ExitCode.IsSuccess())
 		includedMsg = msgs[1][0].Message.Cid()
 		skippedMsg = msgs[0][0].Message.Cid()
 	}

chain/wallet/remotewallet/remote.go

@@ -20,12 +20,12 @@ func SetupRemoteWallet(info string) func(mctx helpers.MetricsCtx, lc fx.Lifecycl
 	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle) (*RemoteWallet, error) {
 		ai := cliutil.ParseApiInfo(info)
 
-		url, err := ai.DialArgs()
+		url, err := ai.DialArgs("v0")
 		if err != nil {
 			return nil, err
 		}
 
-		wapi, closer, err := client.NewWalletRPC(mctx, url, ai.AuthHeader())
+		wapi, closer, err := client.NewWalletRPCV0(mctx, url, ai.AuthHeader())
 		if err != nil {
 			return nil, xerrors.Errorf("creating jsonrpc client: %w", err)
 		}

cli/auth.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/filecoin-project/go-jsonrpc/auth"
 
-	"github.com/filecoin-project/lotus/api/apistruct"
+	"github.com/filecoin-project/lotus/api"
 	cliutil "github.com/filecoin-project/lotus/cli/util"
 	"github.com/filecoin-project/lotus/node/repo"
 )
@@ -47,18 +47,18 @@ var AuthCreateAdminToken = &cli.Command{
 
 		perm := cctx.String("perm")
 		idx := 0
-		for i, p := range apistruct.AllPermissions {
+		for i, p := range api.AllPermissions {
 			if auth.Permission(perm) == p {
 				idx = i + 1
 			}
 		}
 
 		if idx == 0 {
-			return fmt.Errorf("--perm flag has to be one of: %s", apistruct.AllPermissions)
+			return fmt.Errorf("--perm flag has to be one of: %s", api.AllPermissions)
 		}
 
 		// slice on [:idx] so for example: 'sign' gives you [read, write, sign]
-		token, err := napi.AuthNew(ctx, apistruct.AllPermissions[:idx])
+		token, err := napi.AuthNew(ctx, api.AllPermissions[:idx])
 		if err != nil {
 			return err
 		}
@@ -95,18 +95,18 @@ var AuthApiInfoToken = &cli.Command{
 
 		perm := cctx.String("perm")
 		idx := 0
-		for i, p := range apistruct.AllPermissions {
+		for i, p := range api.AllPermissions {
 			if auth.Permission(perm) == p {
 				idx = i + 1
 			}
 		}
 
 		if idx == 0 {
-			return fmt.Errorf("--perm flag has to be one of: %s", apistruct.AllPermissions)
+			return fmt.Errorf("--perm flag has to be one of: %s", api.AllPermissions)
 		}
 
 		// slice on [:idx] so for example: 'sign' gives you [read, write, sign]
-		token, err := napi.AuthNew(ctx, apistruct.AllPermissions[:idx])
+		token, err := napi.AuthNew(ctx, api.AllPermissions[:idx])
 		if err != nil {
 			return err
 		}

cli/chain.go

@@ -32,6 +32,7 @@ import (
 	"golang.org/x/xerrors"
 
 	lapi "github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/stmgr"
@@ -806,7 +807,7 @@ var ChainGetCmd = &cli.Command{
 
 type apiIpldStore struct {
 	ctx context.Context
-	api lapi.FullNode
+	api v0api.FullNode
 }
 
 func (ht *apiIpldStore) Context() context.Context {
@@ -834,7 +835,7 @@ func (ht *apiIpldStore) Put(ctx context.Context, v interface{}) (cid.Cid, error)
 	panic("No mutations allowed")
 }
 
-func handleAmt(ctx context.Context, api lapi.FullNode, r cid.Cid) error {
+func handleAmt(ctx context.Context, api v0api.FullNode, r cid.Cid) error {
 	s := &apiIpldStore{ctx, api}
 	mp, err := adt.AsArray(s, r)
 	if err != nil {
@@ -847,7 +848,7 @@ func handleAmt(ctx context.Context, api lapi.FullNode, r cid.Cid) error {
 	})
 }
 
-func handleHamtEpoch(ctx context.Context, api lapi.FullNode, r cid.Cid) error {
+func handleHamtEpoch(ctx context.Context, api v0api.FullNode, r cid.Cid) error {
 	s := &apiIpldStore{ctx, api}
 	mp, err := adt.AsMap(s, r)
 	if err != nil {
@@ -865,7 +866,7 @@ func handleHamtEpoch(ctx context.Context, api lapi.FullNode, r cid.Cid) error {
 	})
 }
 
-func handleHamtAddress(ctx context.Context, api lapi.FullNode, r cid.Cid) error {
+func handleHamtAddress(ctx context.Context, api v0api.FullNode, r cid.Cid) error {
 	s := &apiIpldStore{ctx, api}
 	mp, err := adt.AsMap(s, r)
 	if err != nil {

cli/client.go

@@ -40,6 +40,7 @@ import (
 
 	"github.com/filecoin-project/lotus/api"
 	lapi "github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
@@ -1348,7 +1349,7 @@ type QueriedAsk struct {
 	Ping time.Duration
 }
 
-func GetAsks(ctx context.Context, api lapi.FullNode) ([]QueriedAsk, error) {
+func GetAsks(ctx context.Context, api v0api.FullNode) ([]QueriedAsk, error) {
 	isTTY := true
 	if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) == 0 {
 		isTTY = false
@@ -1655,7 +1656,7 @@ var clientListDeals = &cli.Command{
 	},
 }
 
-func dealFromDealInfo(ctx context.Context, full api.FullNode, head *types.TipSet, v api.DealInfo) deal {
+func dealFromDealInfo(ctx context.Context, full v0api.FullNode, head *types.TipSet, v api.DealInfo) deal {
 	if v.DealID == 0 {
 		return deal{
 			LocalDeal:        v,
@@ -1674,7 +1675,7 @@ func dealFromDealInfo(ctx context.Context, full api.FullNode, head *types.TipSet
 	}
 }
 
-func outputStorageDeals(ctx context.Context, out io.Writer, full lapi.FullNode, localDeals []lapi.DealInfo, verbose bool, color bool, showFailed bool) error {
+func outputStorageDeals(ctx context.Context, out io.Writer, full v0api.FullNode, localDeals []lapi.DealInfo, verbose bool, color bool, showFailed bool) error {
 	sort.Slice(localDeals, func(i, j int) bool {
 		return localDeals[i].CreationTime.Before(localDeals[j].CreationTime)
 	})
@@ -2293,7 +2294,7 @@ func ellipsis(s string, length int) string {
 	return s
 }
 
-func inspectDealCmd(ctx context.Context, api lapi.FullNode, proposalCid string, dealId int) error {
+func inspectDealCmd(ctx context.Context, api v0api.FullNode, proposalCid string, dealId int) error {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 

cli/cmd.go

@@ -50,6 +50,7 @@ var DaemonContext = cliutil.DaemonContext
 var ReqContext = cliutil.ReqContext
 
 var GetFullNodeAPI = cliutil.GetFullNodeAPI
+var GetFullNodeAPIV1 = cliutil.GetFullNodeAPIV1
 var GetGatewayAPI = cliutil.GetGatewayAPI
 
 var GetStorageMinerAPI = cliutil.GetStorageMinerAPI

cli/disputer.go

@@ -22,6 +22,7 @@ import (
 
 	logging "github.com/ipfs/go-log/v2"
 
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/urfave/cli/v2"
 )
@@ -356,7 +357,7 @@ var disputerStartCmd = &cli.Command{
 
 // for a given miner, index, and maxPostIndex, tries to dispute posts from 0...postsSnapshotted-1
 // returns a list of DisputeWindowedPoSt msgs that are expected to succeed if sent
-func makeDisputeWindowedPosts(ctx context.Context, api lapi.FullNode, dl minerDeadline, postsSnapshotted uint64, sender address.Address) ([]*types.Message, error) {
+func makeDisputeWindowedPosts(ctx context.Context, api v0api.FullNode, dl minerDeadline, postsSnapshotted uint64, sender address.Address) ([]*types.Message, error) {
 	disputes := make([]*types.Message, 0)
 
 	for i := uint64(0); i < postsSnapshotted; i++ {
@@ -388,7 +389,7 @@ func makeDisputeWindowedPosts(ctx context.Context, api lapi.FullNode, dl minerDe
 	return disputes, nil
 }
 
-func makeMinerDeadline(ctx context.Context, api lapi.FullNode, mAddr address.Address) (abi.ChainEpoch, *minerDeadline, error) {
+func makeMinerDeadline(ctx context.Context, api v0api.FullNode, mAddr address.Address) (abi.ChainEpoch, *minerDeadline, error) {
 	dl, err := api.StateMinerProvingDeadline(ctx, mAddr, types.EmptyTSK)
 	if err != nil {
 		return -1, nil, xerrors.Errorf("getting proving index list: %w", err)
@@ -400,7 +401,7 @@ func makeMinerDeadline(ctx context.Context, api lapi.FullNode, mAddr address.Add
 	}, nil
 }
 
-func getSender(ctx context.Context, api lapi.FullNode, fromStr string) (address.Address, error) {
+func getSender(ctx context.Context, api v0api.FullNode, fromStr string) (address.Address, error) {
 	if fromStr == "" {
 		return api.WalletDefaultAddress(ctx)
 	}

cli/services.go

@@ -11,7 +11,7 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-jsonrpc"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	types "github.com/filecoin-project/lotus/chain/types"
 	cid "github.com/ipfs/go-cid"
@@ -35,7 +35,7 @@ type ServicesAPI interface {
 }
 
 type ServicesImpl struct {
-	api    api.FullNode
+	api    v0api.FullNode
 	closer jsonrpc.ClientCloser
 }
 

cli/services_send_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/mocks"
+	mocks "github.com/filecoin-project/lotus/api/v0api/v0mocks"
 	types "github.com/filecoin-project/lotus/chain/types"
 	gomock "github.com/golang/mock/gomock"
 	cid "github.com/ipfs/go-cid"

cli/state.go

@@ -15,6 +15,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/filecoin-project/lotus/api/v0api"
+
 	"github.com/fatih/color"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 
@@ -178,7 +180,7 @@ func ParseTipSetString(ts string) ([]cid.Cid, error) {
 	return cids, nil
 }
 
-func LoadTipSet(ctx context.Context, cctx *cli.Context, api api.FullNode) (*types.TipSet, error) {
+func LoadTipSet(ctx context.Context, cctx *cli.Context, api v0api.FullNode) (*types.TipSet, error) {
 	tss := cctx.String("tipset")
 	if tss == "" {
 		return nil, nil
@@ -187,7 +189,7 @@ func LoadTipSet(ctx context.Context, cctx *cli.Context, api api.FullNode) (*type
 	return ParseTipSetRef(ctx, api, tss)
 }
 
-func ParseTipSetRef(ctx context.Context, api api.FullNode, tss string) (*types.TipSet, error) {
+func ParseTipSetRef(ctx context.Context, api v0api.FullNode, tss string) (*types.TipSet, error) {
 	if tss[0] == '@' {
 		if tss == "@head" {
 			return api.ChainHead(ctx)
@@ -574,7 +576,7 @@ var StateListMinersCmd = &cli.Command{
 	},
 }
 
-func getDealsCounts(ctx context.Context, lapi api.FullNode) (map[address.Address]int, error) {
+func getDealsCounts(ctx context.Context, lapi v0api.FullNode) (map[address.Address]int, error) {
 	allDeals, err := lapi.StateMarketDeals(ctx, types.EmptyTSK)
 	if err != nil {
 		return nil, err
@@ -1443,7 +1445,7 @@ var StateSearchMsgCmd = &cli.Command{
 	},
 }
 
-func printReceiptReturn(ctx context.Context, api api.FullNode, m *types.Message, r types.MessageReceipt) error {
+func printReceiptReturn(ctx context.Context, api v0api.FullNode, m *types.Message, r types.MessageReceipt) error {
 	if len(r.Return) == 0 {
 		return nil
 	}
@@ -1463,8 +1465,7 @@ func printReceiptReturn(ctx context.Context, api api.FullNode, m *types.Message,
 	return nil
 }
 
-func printMsg(ctx context.Context, api api.FullNode, msg cid.Cid, mw *lapi.MsgLookup, m *types.Message) error {
+func printMsg(ctx context.Context, api v0api.FullNode, msg cid.Cid, mw *lapi.MsgLookup, m *types.Message) error {
-
 	if mw == nil {
 		fmt.Println("message was not found on chain")
 		return nil

cli/sync.go

@@ -12,6 +12,7 @@ import (
 	"github.com/urfave/cli/v2"
 
 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/build"
 )
 
@@ -240,7 +241,7 @@ var SyncCheckpointCmd = &cli.Command{
 	},
 }
 
-func SyncWait(ctx context.Context, napi api.FullNode, watch bool) error {
+func SyncWait(ctx context.Context, napi v0api.FullNode, watch bool) error {
 	tick := time.Second / 4
 
 	lastLines := 0

cli/util.go

@@ -10,12 +10,12 @@ import (
 
 	"github.com/filecoin-project/go-state-types/abi"
 
-	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
-func parseTipSet(ctx context.Context, api api.FullNode, vals []string) (*types.TipSet, error) {
+func parseTipSet(ctx context.Context, api v0api.FullNode, vals []string) (*types.TipSet, error) {
 	var headers []*types.BlockHeader
 	for _, c := range vals {
 		blkc, err := cid.Decode(c)

cli/util/api.go

@@ -18,6 +18,8 @@ import (
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/client"
+	"github.com/filecoin-project/lotus/api/v0api"
+	"github.com/filecoin-project/lotus/api/v1api"
 	"github.com/filecoin-project/lotus/node/repo"
 )
 
@@ -133,13 +135,13 @@ func GetAPIInfo(ctx *cli.Context, t repo.RepoType) (APIInfo, error) {
 	}, nil
 }
 
-func GetRawAPI(ctx *cli.Context, t repo.RepoType) (string, http.Header, error) {
+func GetRawAPI(ctx *cli.Context, t repo.RepoType, version string) (string, http.Header, error) {
 	ainfo, err := GetAPIInfo(ctx, t)
 	if err != nil {
 		return "", nil, xerrors.Errorf("could not get API info: %w", err)
 	}
 
-	addr, err := ainfo.DialArgs()
+	addr, err := ainfo.DialArgs(version)
 	if err != nil {
 		return "", nil, xerrors.Errorf("could not get DialArgs: %w", err)
 	}
@@ -165,25 +167,38 @@ func GetAPI(ctx *cli.Context) (api.Common, jsonrpc.ClientCloser, error) {
 		return tn.(api.FullNode), func() {}, nil
 	}
 
-	addr, headers, err := GetRawAPI(ctx, t)
+	addr, headers, err := GetRawAPI(ctx, t, "v0")
 	if err != nil {
 		return nil, nil, err
 	}
 
-	return client.NewCommonRPC(ctx.Context, addr, headers)
+	return client.NewCommonRPCV0(ctx.Context, addr, headers)
 }
 
-func GetFullNodeAPI(ctx *cli.Context) (api.FullNode, jsonrpc.ClientCloser, error) {
+func GetFullNodeAPI(ctx *cli.Context) (v0api.FullNode, jsonrpc.ClientCloser, error) {
 	if tn, ok := ctx.App.Metadata["testnode-full"]; ok {
-		return tn.(api.FullNode), func() {}, nil
+		return &v0api.WrapperV1Full{FullNode: tn.(v1api.FullNode)}, func() {}, nil
 	}
 
-	addr, headers, err := GetRawAPI(ctx, repo.FullNode)
+	addr, headers, err := GetRawAPI(ctx, repo.FullNode, "v0")
 	if err != nil {
 		return nil, nil, err
 	}
 
-	return client.NewFullNodeRPC(ctx.Context, addr, headers)
+	return client.NewFullNodeRPCV0(ctx.Context, addr, headers)
+}
+
+func GetFullNodeAPIV1(ctx *cli.Context) (v1api.FullNode, jsonrpc.ClientCloser, error) {
+	if tn, ok := ctx.App.Metadata["testnode-full"]; ok {
+		return tn.(v1api.FullNode), func() {}, nil
+	}
+
+	addr, headers, err := GetRawAPI(ctx, repo.FullNode, "v1")
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return client.NewFullNodeRPCV1(ctx.Context, addr, headers)
 }
 
 type GetStorageMinerOptions struct {
@@ -206,7 +221,7 @@ func GetStorageMinerAPI(ctx *cli.Context, opts ...GetStorageMinerOption) (api.St
 		return tn.(api.StorageMiner), func() {}, nil
 	}
 
-	addr, headers, err := GetRawAPI(ctx, repo.StorageMiner)
+	addr, headers, err := GetRawAPI(ctx, repo.StorageMiner, "v0")
 	if err != nil {
 		return nil, nil, err
 	}
@@ -227,25 +242,25 @@ func GetStorageMinerAPI(ctx *cli.Context, opts ...GetStorageMinerOption) (api.St
 		addr = u.String()
 	}
 
-	return client.NewStorageMinerRPC(ctx.Context, addr, headers)
+	return client.NewStorageMinerRPCV0(ctx.Context, addr, headers)
 }
 
 func GetWorkerAPI(ctx *cli.Context) (api.Worker, jsonrpc.ClientCloser, error) {
-	addr, headers, err := GetRawAPI(ctx, repo.Worker)
+	addr, headers, err := GetRawAPI(ctx, repo.Worker, "v0")
 	if err != nil {
 		return nil, nil, err
 	}
 
-	return client.NewWorkerRPC(ctx.Context, addr, headers)
+	return client.NewWorkerRPCV0(ctx.Context, addr, headers)
 }
 
 func GetGatewayAPI(ctx *cli.Context) (api.Gateway, jsonrpc.ClientCloser, error) {
-	addr, headers, err := GetRawAPI(ctx, repo.FullNode)
+	addr, headers, err := GetRawAPI(ctx, repo.FullNode, "v0")
 	if err != nil {
 		return nil, nil, err
 	}
 
-	return client.NewGatewayRPC(ctx.Context, addr, headers)
+	return client.NewGatewayRPCV1(ctx.Context, addr, headers)
 }
 
 func DaemonContext(cctx *cli.Context) context.Context {

cli/util/apiinfo.go

@@ -36,7 +36,7 @@ func ParseApiInfo(s string) APIInfo {
 	}
 }
 
-func (a APIInfo) DialArgs() (string, error) {
+func (a APIInfo) DialArgs(version string) (string, error) {
 	ma, err := multiaddr.NewMultiaddr(a.Addr)
 	if err == nil {
 		_, addr, err := manet.DialArgs(ma)
@@ -44,14 +44,14 @@ func (a APIInfo) DialArgs() (string, error) {
 			return "", err
 		}
 
-		return "ws://" + addr + "/rpc/v0", nil
+		return "ws://" + addr + "/rpc/" + version, nil
 	}
 
 	_, err = url.Parse(a.Addr)
 	if err != nil {
 		return "", err
 	}
-	return a.Addr + "/rpc/v0", nil
+	return a.Addr + "/rpc/" + version, nil
 }
 
 func (a APIInfo) Host() (string, error) {

cmd/chain-noise/main.go

@@ -8,7 +8,7 @@ import (
 	"time"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
@@ -72,7 +72,7 @@ var runCmd = &cli.Command{
 	},
 }
 
-func sendSmallFundsTxs(ctx context.Context, api api.FullNode, from address.Address, rate, limit int) error {
+func sendSmallFundsTxs(ctx context.Context, api v0api.FullNode, from address.Address, rate, limit int) error {
 	var sendSet []address.Address
 	for i := 0; i < 20; i++ {
 		naddr, err := api.WalletNew(ctx, types.KTSecp256k1)

cmd/lotus-chainwatch/processor/miner.go

@@ -14,7 +14,7 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 
-	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/blockstore"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
@@ -1026,7 +1026,7 @@ func (p *Processor) storeMinersPower(miners []minerActorInfo) error {
 }
 
 // load the power actor state clam as an adt.Map at the tipset `ts`.
-func getPowerActorState(ctx context.Context, api api.FullNode, ts types.TipSetKey) (power.State, error) {
+func getPowerActorState(ctx context.Context, api v0api.FullNode, ts types.TipSetKey) (power.State, error) {
 	powerActor, err := api.StateGetActor(ctx, power.Address, ts)
 	if err != nil {
 		return nil, err

cmd/lotus-chainwatch/processor/processor.go

@@ -17,7 +17,7 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 
-	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/chain/types"
 	cw_util "github.com/filecoin-project/lotus/cmd/lotus-chainwatch/util"
 	"github.com/filecoin-project/lotus/lib/parmap"
@@ -28,7 +28,7 @@ var log = logging.Logger("processor")
 type Processor struct {
 	db *sql.DB
 
-	node     api.FullNode
+	node     v0api.FullNode
 	ctxStore *cw_util.APIIpldStore
 
 	genesisTs *types.TipSet
@@ -52,7 +52,7 @@ type actorInfo struct {
 	state string
 }
 
-func NewProcessor(ctx context.Context, db *sql.DB, node api.FullNode, batch int) *Processor {
+func NewProcessor(ctx context.Context, db *sql.DB, node v0api.FullNode, batch int) *Processor {
 	ctxStore := cw_util.NewAPIIpldStore(ctx, node)
 	return &Processor{
 		db:       db,

cmd/lotus-chainwatch/run.go

@@ -8,6 +8,8 @@ import (
 	"os"
 	"strings"
 
+	"github.com/filecoin-project/lotus/api/v0api"
+
 	_ "github.com/lib/pq"
 
 	"github.com/filecoin-project/go-jsonrpc"
@@ -15,7 +17,6 @@ import (
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/lotus/api"
 	lcli "github.com/filecoin-project/lotus/cli"
 	"github.com/filecoin-project/lotus/cmd/lotus-chainwatch/processor"
 	"github.com/filecoin-project/lotus/cmd/lotus-chainwatch/scheduler"
@@ -44,7 +45,7 @@ var runCmd = &cli.Command{
 			return err
 		}
 
-		var api api.FullNode
+		var api v0api.FullNode
 		var closer jsonrpc.ClientCloser
 		var err error
 		if tokenMaddr := cctx.String("api"); tokenMaddr != "" {

cmd/lotus-chainwatch/syncer/sync.go

@@ -13,7 +13,7 @@ import (
 	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log/v2"
 
-	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 )
@@ -26,10 +26,10 @@ type Syncer struct {
 	lookbackLimit uint64
 
 	headerLk sync.Mutex
-	node     api.FullNode
+	node     v0api.FullNode
 }
 
-func NewSyncer(db *sql.DB, node api.FullNode, lookbackLimit uint64) *Syncer {
+func NewSyncer(db *sql.DB, node v0api.FullNode, lookbackLimit uint64) *Syncer {
 	return &Syncer{
 		db:            db,
 		node:          node,

cmd/lotus-chainwatch/util/api.go

@@ -5,13 +5,13 @@ import (
 	"net/http"
 
 	"github.com/filecoin-project/go-jsonrpc"
-	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/client"
+	"github.com/filecoin-project/lotus/api/v0api"
 	ma "github.com/multiformats/go-multiaddr"
 	manet "github.com/multiformats/go-multiaddr/net"
 )
 
-func GetFullNodeAPIUsingCredentials(ctx context.Context, listenAddr, token string) (api.FullNode, jsonrpc.ClientCloser, error) {
+func GetFullNodeAPIUsingCredentials(ctx context.Context, listenAddr, token string) (v0api.FullNode, jsonrpc.ClientCloser, error) {
 	parsedAddr, err := ma.NewMultiaddr(listenAddr)
 	if err != nil {
 		return nil, nil, err
@@ -22,7 +22,7 @@ func GetFullNodeAPIUsingCredentials(ctx context.Context, listenAddr, token strin
 		return nil, nil, err
 	}
 
-	return client.NewFullNodeRPC(ctx, apiURI(addr), apiHeaders(token))
+	return client.NewFullNodeRPCV0(ctx, apiURI(addr), apiHeaders(token))
 }
 func apiURI(addr string) string {
 	return "ws://" + addr + "/rpc/v0"

cmd/lotus-chainwatch/util/contextStore.go

@@ -8,7 +8,7 @@ import (
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 
-	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 )
 
 // TODO extract this to a common location in lotus and reuse the code
@@ -16,10 +16,10 @@ import (
 // APIIpldStore is required for AMT and HAMT access.
 type APIIpldStore struct {
 	ctx context.Context
-	api api.FullNode
+	api v0api.FullNode
 }
 
-func NewAPIIpldStore(ctx context.Context, api api.FullNode) *APIIpldStore {
+func NewAPIIpldStore(ctx context.Context, api v0api.FullNode) *APIIpldStore {
 	return &APIIpldStore{
 		ctx: ctx,
 		api: api,

cmd/lotus-fountain/main.go

@@ -15,7 +15,7 @@ import (
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
@@ -143,7 +143,7 @@ func prepFundsHtml(box *rice.Box) http.HandlerFunc {
 
 type handler struct {
 	ctx context.Context
-	api api.FullNode
+	api v0api.FullNode
 
 	from           address.Address
 	sendPerRequest types.FIL

cmd/lotus-gateway/api.go

@@ -52,14 +52,13 @@ type gatewayDepsAPI interface {
 	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 	StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (api.DealCollateralBounds, error)
 	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
-	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
 	StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 	StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error)
 	StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MarketBalance, error)
 	StateMarketStorageDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error)
 	StateNetworkVersion(context.Context, types.TipSetKey) (network.Version, error)
-	StateSearchMsgLimited(ctx context.Context, msg cid.Cid, lookbackLimit abi.ChainEpoch) (*api.MsgLookup, error)
+	StateSearchMsg(ctx context.Context, from types.TipSetKey, msg cid.Cid, limit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error)
-	StateWaitMsgLimited(ctx context.Context, msg cid.Cid, confidence uint64, h abi.ChainEpoch) (*api.MsgLookup, error)
+	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64, limit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error)
 	StateReadState(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*api.ActorState, error)
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error)
 	StateMinerFaults(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)
@@ -74,6 +73,8 @@ type gatewayDepsAPI interface {
 	StateVMCirculatingSupplyInternal(context.Context, types.TipSetKey) (api.CirculatingSupply, error)
 }
 
+var _ gatewayDepsAPI = *new(api.FullNode) // gateway depends on latest
+
 type GatewayAPI struct {
 	api                    gatewayDepsAPI
 	lookbackCap            time.Duration
@@ -261,14 +262,6 @@ func (a *GatewayAPI) StateGetActor(ctx context.Context, actor address.Address, t
 	return a.api.StateGetActor(ctx, actor, tsk)
 }
 
-func (a *GatewayAPI) StateGetReceipt(ctx context.Context, c cid.Cid, tsk types.TipSetKey) (*types.MessageReceipt, error) {
-	if err := a.checkTipsetKey(ctx, tsk); err != nil {
-		return nil, err
-	}
-
-	return a.api.StateGetReceipt(ctx, c, tsk)
-}
-
 func (a *GatewayAPI) StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error) {
 	if err := a.checkTipsetKey(ctx, tsk); err != nil {
 		return nil, err
@@ -309,12 +302,29 @@ func (a *GatewayAPI) StateNetworkVersion(ctx context.Context, tsk types.TipSetKe
 	return a.api.StateNetworkVersion(ctx, tsk)
 }
 
-func (a *GatewayAPI) StateSearchMsg(ctx context.Context, msg cid.Cid) (*api.MsgLookup, error) {
+func (a *GatewayAPI) StateSearchMsg(ctx context.Context, from types.TipSetKey, msg cid.Cid, limit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error) {
-	return a.api.StateSearchMsgLimited(ctx, msg, a.stateWaitLookbackLimit)
+	if limit == api.LookbackNoLimit {
+		limit = a.stateWaitLookbackLimit
+	}
+	if a.stateWaitLookbackLimit != api.LookbackNoLimit && limit > a.stateWaitLookbackLimit {
+		limit = a.stateWaitLookbackLimit
+	}
+	if err := a.checkTipsetKey(ctx, from); err != nil {
+		return nil, err
+	}
+
+	return a.api.StateSearchMsg(ctx, from, msg, limit, allowReplaced)
 }
 
-func (a *GatewayAPI) StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*api.MsgLookup, error) {
+func (a *GatewayAPI) StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64, limit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error) {
-	return a.api.StateWaitMsgLimited(ctx, msg, confidence, a.stateWaitLookbackLimit)
+	if limit == api.LookbackNoLimit {
+		limit = a.stateWaitLookbackLimit
+	}
+	if a.stateWaitLookbackLimit != api.LookbackNoLimit && limit > a.stateWaitLookbackLimit {
+		limit = a.stateWaitLookbackLimit
+	}
+
+	return a.api.StateWaitMsg(ctx, msg, confidence, limit, allowReplaced)
 }
 
 func (a *GatewayAPI) StateReadState(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*api.ActorState, error) {

cmd/lotus-gateway/endtoend_test.go

@@ -24,6 +24,8 @@ import (
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/client"
 	"github.com/filecoin-project/lotus/api/test"
+	"github.com/filecoin-project/lotus/api/v0api"
+	"github.com/filecoin-project/lotus/api/v1api"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -103,7 +105,7 @@ func TestWalletMsig(t *testing.T) {
 	addProposal, err := lite.MsigCreate(ctx, 2, msigAddrs, abi.ChainEpoch(50), amt, liteWalletAddr, types.NewInt(0))
 	require.NoError(t, err)
 
-	res, err := lite.StateWaitMsg(ctx, addProposal, 1)
+	res, err := lite.StateWaitMsg(ctx, addProposal, 1, api.LookbackNoLimit, true)
 	require.NoError(t, err)
 	require.EqualValues(t, 0, res.Receipt.ExitCode)
 
@@ -123,7 +125,7 @@ func TestWalletMsig(t *testing.T) {
 	addProposal, err = lite.MsigAddPropose(ctx, msig, walletAddrs[0], walletAddrs[3], false)
 	require.NoError(t, err)
 
-	res, err = lite.StateWaitMsg(ctx, addProposal, 1)
+	res, err = lite.StateWaitMsg(ctx, addProposal, 1, api.LookbackNoLimit, true)
 	require.NoError(t, err)
 	require.EqualValues(t, 0, res.Receipt.ExitCode)
 
@@ -137,7 +139,7 @@ func TestWalletMsig(t *testing.T) {
 	approval1, err := lite.MsigAddApprove(ctx, msig, walletAddrs[1], txnID, walletAddrs[0], walletAddrs[3], false)
 	require.NoError(t, err)
 
-	res, err = lite.StateWaitMsg(ctx, approval1, 1)
+	res, err = lite.StateWaitMsg(ctx, approval1, 1, api.LookbackNoLimit, true)
 	require.NoError(t, err)
 	require.EqualValues(t, 0, res.Receipt.ExitCode)
 
@@ -245,12 +247,15 @@ func startNodes(
 
 				// Create a gateway server in front of the full node
 				gapiImpl := newGatewayAPI(fullNode, lookbackCap, stateWaitLookbackLimit)
-				_, addr, err := builder.CreateRPCServer(t, gapiImpl)
+				_, addr, err := builder.CreateRPCServer(t, map[string]interface{}{
+					"/rpc/v1": gapiImpl,
+					"/rpc/v0": api.Wrap(new(v1api.FullNodeStruct), new(v0api.WrapperV1Full), gapiImpl),
+				})
 				require.NoError(t, err)
 
 				// Create a gateway client API that connects to the gateway server
 				var gapi api.Gateway
-				gapi, closer, err = client.NewGatewayRPC(ctx, addr, nil)
+				gapi, closer, err = client.NewGatewayRPCV1(ctx, addr+"/rpc/v1", nil)
 				require.NoError(t, err)
 
 				// Provide the gateway API to dependency injection
@@ -299,7 +304,7 @@ func sendFunds(ctx context.Context, fromNode test.TestNode, fromAddr address.Add
 		return err
 	}
 
-	res, err := fromNode.StateWaitMsg(ctx, sm.Cid(), 1)
+	res, err := fromNode.StateWaitMsg(ctx, sm.Cid(), 1, api.LookbackNoLimit, true)
 	if err != nil {
 		return err
 	}

cmd/lotus-gateway/main.go

@@ -11,6 +11,9 @@ import (
 	promclient "github.com/prometheus/client_golang/prometheus"
 	"go.opencensus.io/tag"
 
+	lapi "github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
+	"github.com/filecoin-project/lotus/api/v1api"
 	"github.com/filecoin-project/lotus/build"
 	lcli "github.com/filecoin-project/lotus/cli"
 	"github.com/filecoin-project/lotus/lib/lotuslog"
@@ -82,7 +85,7 @@ var runCmd = &cli.Command{
 			log.Fatalf("Cannot register the view: %v", err)
 		}
 
-		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		api, closer, err := lcli.GetFullNodeAPIV1(cctx)
 		if err != nil {
 			return err
 		}
@@ -93,14 +96,21 @@ var runCmd = &cli.Command{
 
 		log.Info("Setting up API endpoint at " + address)
 
-		serverOptions := make([]jsonrpc.ServerOption, 0)
+		serveRpc := func(path string, hnd interface{}) {
-		if maxRequestSize := cctx.Int("api-max-req-size"); maxRequestSize != 0 {
+			serverOptions := make([]jsonrpc.ServerOption, 0)
-			serverOptions = append(serverOptions, jsonrpc.WithMaxRequestSize(int64(maxRequestSize)))
+			if maxRequestSize := cctx.Int("api-max-req-size"); maxRequestSize != 0 {
-		}
+				serverOptions = append(serverOptions, jsonrpc.WithMaxRequestSize(int64(maxRequestSize)))
-		rpcServer := jsonrpc.NewServer(serverOptions...)
+			}
-		rpcServer.Register("Filecoin", metrics.MetricedGatewayAPI(NewGatewayAPI(api)))
+			rpcServer := jsonrpc.NewServer(serverOptions...)
+			rpcServer.Register("Filecoin", hnd)
 
-		mux.Handle("/rpc/v0", rpcServer)
+			mux.Handle(path, rpcServer)
+		}
+
+		ma := metrics.MetricedGatewayAPI(NewGatewayAPI(api))
+
+		serveRpc("/rpc/v1", ma)
+		serveRpc("/rpc/v0", lapi.Wrap(new(v1api.FullNodeStruct), new(v0api.WrapperV1Full), ma))
 
 		registry := promclient.DefaultRegisterer.(*promclient.Registry)
 		exporter, err := prometheus.NewExporter(prometheus.Options{

cmd/lotus-health/main.go

@@ -8,13 +8,14 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/filecoin-project/lotus/api/v0api"
+
 	cid "github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/urfave/cli/v2"
 
 	"github.com/filecoin-project/go-jsonrpc"
 
-	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
@@ -180,7 +181,7 @@ func checkWindow(window CidWindow, t int) bool {
  * returns a slice of slices of Cids
  * len of slice <= `t` - threshold
  */
-func updateWindow(ctx context.Context, a api.FullNode, w CidWindow, t int, r int, to time.Duration) (CidWindow, error) {
+func updateWindow(ctx context.Context, a v0api.FullNode, w CidWindow, t int, r int, to time.Duration) (CidWindow, error) {
 	head, err := getHead(ctx, a, r, to)
 	if err != nil {
 		return nil, err
@@ -194,7 +195,7 @@ func updateWindow(ctx context.Context, a api.FullNode, w CidWindow, t int, r int
  * retries if API no available
  * returns tipset
  */
-func getHead(ctx context.Context, a api.FullNode, r int, t time.Duration) (*types.TipSet, error) {
+func getHead(ctx context.Context, a v0api.FullNode, r int, t time.Duration) (*types.TipSet, error) {
 	for i := 0; i < r; i++ {
 		head, err := a.ChainHead(ctx)
 		if err != nil && i == (r-1) {
@@ -226,7 +227,7 @@ func appendCIDsToWindow(w CidWindow, c []cid.Cid, t int) CidWindow {
 /*
  * wait for node to sync
  */
-func waitForSyncComplete(ctx context.Context, a api.FullNode, r int, t time.Duration) error {
+func waitForSyncComplete(ctx context.Context, a v0api.FullNode, r int, t time.Duration) error {
 	for {
 		select {
 		case <-ctx.Done():
@@ -248,7 +249,7 @@ func waitForSyncComplete(ctx context.Context, a api.FullNode, r int, t time.Dura
  * A thin wrapper around lotus cli GetFullNodeAPI
  * Adds retry logic
  */
-func getFullNodeAPI(ctx *cli.Context, r int, t time.Duration) (api.FullNode, jsonrpc.ClientCloser, error) {
+func getFullNodeAPI(ctx *cli.Context, r int, t time.Duration) (v0api.FullNode, jsonrpc.ClientCloser, error) {
 	for i := 0; i < r; i++ {
 		api, closer, err := lcli.GetFullNodeAPI(ctx)
 		if err != nil && i == (r-1) {

cmd/lotus-seal-worker/main.go

@@ -28,7 +28,6 @@ import (
 	"github.com/filecoin-project/go-statestore"
 
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/apistruct"
 	"github.com/filecoin-project/lotus/build"
 	lcli "github.com/filecoin-project/lotus/cli"
 	cliutil "github.com/filecoin-project/lotus/cli/util"
@@ -366,7 +365,7 @@ var runCmd = &cli.Command{
 
 		fh := &stores.FetchHandler{Local: localStore}
 		remoteHandler := func(w http.ResponseWriter, r *http.Request) {
-			if !auth.HasPerm(r.Context(), nil, apistruct.PermAdmin) {
+			if !auth.HasPerm(r.Context(), nil, api.PermAdmin) {
 				w.WriteHeader(401)
 				_ = json.NewEncoder(w).Encode(struct{ Error string }{"unauthorized: missing admin permission"})
 				return
@@ -394,7 +393,7 @@ var runCmd = &cli.Command{
 
 		readerHandler, readerServerOpt := rpcenc.ReaderParamDecoder()
 		rpcServer := jsonrpc.NewServer(readerServerOpt)
-		rpcServer.Register("Filecoin", apistruct.PermissionedWorkerAPI(metrics.MetricedWorkerAPI(workerApi)))
+		rpcServer.Register("Filecoin", api.PermissionedWorkerAPI(metrics.MetricedWorkerAPI(workerApi)))
 
 		mux.Handle("/rpc/v0", rpcServer)
 		mux.Handle("/rpc/streams/v0/push/{uuid}", readerHandler)

cmd/lotus-shed/consensus.go

@@ -113,12 +113,12 @@ var consensusCheckCmd = &cli.Command{
 				return err
 			}
 			ainfo := cliutil.APIInfo{Addr: apima.String()}
-			addr, err := ainfo.DialArgs()
+			addr, err := ainfo.DialArgs("v1")
 			if err != nil {
 				return err
 			}
 
-			api, closer, err := client.NewFullNodeRPC(cctx.Context, addr, nil)
+			api, closer, err := client.NewFullNodeRPCV1(cctx.Context, addr, nil)
 			if err != nil {
 				return err
 			}

cmd/lotus-shed/jwt.go

@@ -15,7 +15,8 @@ import (
 	"github.com/urfave/cli/v2"
 
 	"github.com/filecoin-project/go-jsonrpc/auth"
-	"github.com/filecoin-project/lotus/api/apistruct"
+
+	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/modules"
 )
@@ -98,19 +99,19 @@ var jwtTokenCmd = &cli.Command{
 		perms := []auth.Permission{}
 
 		if cctx.Bool("read") {
-			perms = append(perms, apistruct.PermRead)
+			perms = append(perms, api.PermRead)
 		}
 
 		if cctx.Bool("write") {
-			perms = append(perms, apistruct.PermWrite)
+			perms = append(perms, api.PermWrite)
 		}
 
 		if cctx.Bool("sign") {
-			perms = append(perms, apistruct.PermSign)
+			perms = append(perms, api.PermSign)
 		}
 
 		if cctx.Bool("admin") {
-			perms = append(perms, apistruct.PermAdmin)
+			perms = append(perms, api.PermAdmin)
 		}
 
 		p := modules.JwtPayload{
@@ -152,7 +153,7 @@ var jwtNewCmd = &cli.Command{
 		}
 
 		p := modules.JwtPayload{
-			Allow: apistruct.AllPermissions,
+			Allow: api.AllPermissions,
 		}
 
 		token, err := jwt.Sign(&p, jwt.NewHS256(keyInfo.PrivateKey))

cmd/lotus-shed/ledger.go

@@ -6,13 +6,14 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/filecoin-project/lotus/api/v0api"
+
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/urfave/cli/v2"
 	ledgerfil "github.com/whyrusleeping/ledger-filecoin-go"
 
-	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/types"
 	ledgerwallet "github.com/filecoin-project/lotus/chain/wallet/ledger"
 	lcli "github.com/filecoin-project/lotus/cli"
@@ -42,7 +43,7 @@ var ledgerListAddressesCmd = &cli.Command{
 		},
 	},
 	Action: func(cctx *cli.Context) error {
-		var api api.FullNode
+		var api v0api.FullNode
 		if cctx.Bool("print-balances") {
 			a, closer, err := lcli.GetFullNodeAPI(cctx)
 			if err != nil {

cmd/lotus-shed/rpc.go

@@ -28,6 +28,10 @@ var rpcCmd = &cli.Command{
 		&cli.BoolFlag{
 			Name: "miner",
 		},
+		&cli.StringFlag{
+			Name:  "version",
+			Value: "v0",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		rt := repo.FullNode
@@ -35,7 +39,7 @@ var rpcCmd = &cli.Command{
 			rt = repo.StorageMiner
 		}
 
-		addr, headers, err := lcli.GetRawAPI(cctx, rt)
+		addr, headers, err := lcli.GetRawAPI(cctx, rt, cctx.String("version"))
 		if err != nil {
 			return err
 		}

cmd/lotus-storage-miner/init.go

@@ -37,6 +37,8 @@ import (
 	power2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/power"
 
 	lapi "github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
+	"github.com/filecoin-project/lotus/api/v1api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
@@ -149,7 +151,7 @@ var initCmd = &cli.Command{
 
 		log.Info("Trying to connect to full node RPC")
 
-		api, closer, err := lcli.GetFullNodeAPI(cctx) // TODO: consider storing full node address in config
+		api, closer, err := lcli.GetFullNodeAPIV1(cctx) // TODO: consider storing full node address in config
 		if err != nil {
 			return err
 		}
@@ -158,7 +160,7 @@ var initCmd = &cli.Command{
 		log.Info("Checking full node sync status")
 
 		if !cctx.Bool("genesis-miner") && !cctx.Bool("nosync") {
-			if err := lcli.SyncWait(ctx, api, false); err != nil {
+			if err := lcli.SyncWait(ctx, &v0api.WrapperV1Full{FullNode: api}, false); err != nil {
 				return xerrors.Errorf("sync wait: %w", err)
 			}
 		}
@@ -269,7 +271,7 @@ var initCmd = &cli.Command{
 	},
 }
 
-func migratePreSealMeta(ctx context.Context, api lapi.FullNode, metadata string, maddr address.Address, mds dtypes.MetadataDS) error {
+func migratePreSealMeta(ctx context.Context, api v1api.FullNode, metadata string, maddr address.Address, mds dtypes.MetadataDS) error {
 	metadata, err := homedir.Expand(metadata)
 	if err != nil {
 		return xerrors.Errorf("expanding preseal dir: %w", err)
@@ -379,7 +381,7 @@ func migratePreSealMeta(ctx context.Context, api lapi.FullNode, metadata string,
 	return mds.Put(datastore.NewKey(modules.StorageCounterDSPrefix), buf[:size])
 }
 
-func findMarketDealID(ctx context.Context, api lapi.FullNode, deal market2.DealProposal) (abi.DealID, error) {
+func findMarketDealID(ctx context.Context, api v1api.FullNode, deal market2.DealProposal) (abi.DealID, error) {
 	// TODO: find a better way
 	//  (this is only used by genesis miners)
 
@@ -398,7 +400,7 @@ func findMarketDealID(ctx context.Context, api lapi.FullNode, deal market2.DealP
 	return 0, xerrors.New("deal not found")
 }
 
-func storageMinerInit(ctx context.Context, cctx *cli.Context, api lapi.FullNode, r repo.Repo, ssize abi.SectorSize, gasPrice types.BigInt) error {
+func storageMinerInit(ctx context.Context, cctx *cli.Context, api v1api.FullNode, r repo.Repo, ssize abi.SectorSize, gasPrice types.BigInt) error {
 	lr, err := r.Lock(repo.StorageMiner)
 	if err != nil {
 		return err
@@ -562,7 +564,7 @@ func makeHostKey(lr repo.LockedRepo) (crypto.PrivKey, error) {
 	return pk, nil
 }
 
-func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.Address, peerid peer.ID, gasPrice types.BigInt) error {
+func configureStorageMiner(ctx context.Context, api v1api.FullNode, addr address.Address, peerid peer.ID, gasPrice types.BigInt) error {
 	mi, err := api.StateMinerInfo(ctx, addr, types.EmptyTSK)
 	if err != nil {
 		return xerrors.Errorf("getWorkerAddr returned bad address: %w", err)
@@ -588,7 +590,7 @@ func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.
 	}
 
 	log.Info("Waiting for message: ", smsg.Cid())
-	ret, err := api.StateWaitMsg(ctx, smsg.Cid(), build.MessageConfidence)
+	ret, err := api.StateWaitMsg(ctx, smsg.Cid(), build.MessageConfidence, lapi.LookbackNoLimit, true)
 	if err != nil {
 		return err
 	}
@@ -600,7 +602,7 @@ func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.
 	return nil
 }
 
-func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID, gasPrice types.BigInt, cctx *cli.Context) (address.Address, error) {
+func createStorageMiner(ctx context.Context, api v1api.FullNode, peerid peer.ID, gasPrice types.BigInt, cctx *cli.Context) (address.Address, error) {
 	var err error
 	var owner address.Address
 	if cctx.String("owner") != "" {
@@ -642,7 +644,7 @@ func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID,
 		log.Infof("Initializing worker account %s, message: %s", worker, signed.Cid())
 		log.Infof("Waiting for confirmation")
 
-		mw, err := api.StateWaitMsg(ctx, signed.Cid(), build.MessageConfidence)
+		mw, err := api.StateWaitMsg(ctx, signed.Cid(), build.MessageConfidence, lapi.LookbackNoLimit, true)
 		if err != nil {
 			return address.Undef, xerrors.Errorf("waiting for worker init: %w", err)
 		}
@@ -700,7 +702,7 @@ func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID,
 	log.Infof("Pushed CreateMiner message: %s", signed.Cid())
 	log.Infof("Waiting for confirmation")
 
-	mw, err := api.StateWaitMsg(ctx, signed.Cid(), build.MessageConfidence)
+	mw, err := api.StateWaitMsg(ctx, signed.Cid(), build.MessageConfidence, lapi.LookbackNoLimit, true)
 	if err != nil {
 		return address.Undef, xerrors.Errorf("waiting for createMiner message: %w", err)
 	}

cmd/lotus-storage-miner/init_restore.go

@@ -6,6 +6,8 @@ import (
 	"io/ioutil"
 	"os"
 
+	"github.com/filecoin-project/lotus/api/v0api"
+
 	"github.com/docker/go-units"
 	"github.com/ipfs/go-datastore"
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -54,7 +56,7 @@ var initRestoreCmd = &cli.Command{
 
 		log.Info("Trying to connect to full node RPC")
 
-		api, closer, err := lcli.GetFullNodeAPI(cctx) // TODO: consider storing full node address in config
+		api, closer, err := lcli.GetFullNodeAPIV1(cctx) // TODO: consider storing full node address in config
 		if err != nil {
 			return err
 		}
@@ -74,7 +76,7 @@ var initRestoreCmd = &cli.Command{
 		}
 
 		if !cctx.Bool("nosync") {
-			if err := lcli.SyncWait(ctx, api, false); err != nil {
+			if err := lcli.SyncWait(ctx, &v0api.WrapperV1Full{FullNode: api}, false); err != nil {
 				return xerrors.Errorf("sync wait: %w", err)
 			}
 		}

cmd/lotus-storage-miner/run.go

@@ -9,6 +9,10 @@ import (
 	"os/signal"
 	"syscall"
 
+	"github.com/filecoin-project/lotus/api/v1api"
+
+	"github.com/filecoin-project/lotus/api/v0api"
+
 	mux "github.com/gorilla/mux"
 	"github.com/multiformats/go-multiaddr"
 	manet "github.com/multiformats/go-multiaddr/net"
@@ -22,7 +26,6 @@ import (
 	"github.com/filecoin-project/go-jsonrpc/auth"
 
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/apistruct"
 	"github.com/filecoin-project/lotus/build"
 	lcli "github.com/filecoin-project/lotus/cli"
 	"github.com/filecoin-project/lotus/lib/ulimit"
@@ -64,7 +67,7 @@ var runCmd = &cli.Command{
 			}
 		}
 
-		nodeApi, ncloser, err := lcli.GetFullNodeAPI(cctx)
+		nodeApi, ncloser, err := lcli.GetFullNodeAPIV1(cctx)
 		if err != nil {
 			return xerrors.Errorf("getting full node api: %w", err)
 		}
@@ -102,7 +105,7 @@ var runCmd = &cli.Command{
 		log.Info("Checking full node sync status")
 
 		if !cctx.Bool("nosync") {
-			if err := lcli.SyncWait(ctx, nodeApi, false); err != nil {
+			if err := lcli.SyncWait(ctx, &v0api.WrapperV1Full{FullNode: nodeApi}, false); err != nil {
 				return xerrors.Errorf("sync wait: %w", err)
 			}
 		}
@@ -134,7 +137,7 @@ var runCmd = &cli.Command{
 				node.Override(new(dtypes.APIEndpoint), func() (dtypes.APIEndpoint, error) {
 					return multiaddr.NewMultiaddr("/ip4/127.0.0.1/tcp/" + cctx.String("miner-api"))
 				})),
-			node.Override(new(api.FullNode), nodeApi),
+			node.Override(new(v1api.FullNode), nodeApi),
 		)
 		if err != nil {
 			return xerrors.Errorf("creating node: %w", err)
@@ -165,7 +168,7 @@ var runCmd = &cli.Command{
 		mux := mux.NewRouter()
 
 		rpcServer := jsonrpc.NewServer()
-		rpcServer.Register("Filecoin", apistruct.PermissionedStorMinerAPI(metrics.MetricedStorMinerAPI(minerapi)))
+		rpcServer.Register("Filecoin", api.PermissionedStorMinerAPI(metrics.MetricedStorMinerAPI(minerapi)))
 
 		mux.Handle("/rpc/v0", rpcServer)
 		mux.PathPrefix("/remote").HandlerFunc(minerapi.(*impl.StorageMinerAPI).ServeRemote)

cmd/lotus-storage-miner/storage.go

@@ -12,6 +12,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/filecoin-project/lotus/api/v0api"
+
 	"github.com/docker/go-units"
 	"github.com/fatih/color"
 	"github.com/google/uuid"
@@ -668,7 +670,7 @@ var storageCleanupCmd = &cli.Command{
 	},
 }
 
-func cleanupRemovedSectorData(ctx context.Context, api api.StorageMiner, napi api.FullNode) error {
+func cleanupRemovedSectorData(ctx context.Context, api api.StorageMiner, napi v0api.FullNode) error {
 	sectors, err := api.SectorsList(ctx)
 	if err != nil {
 		return err

cmd/lotus-wallet/interactive.go

@@ -20,6 +20,7 @@ import (
 	"github.com/filecoin-project/go-state-types/crypto"
 
 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
 	"github.com/filecoin-project/lotus/chain/stmgr"
@@ -30,8 +31,8 @@ import (
 type InteractiveWallet struct {
 	lk sync.Mutex
 
-	apiGetter func() (api.FullNode, jsonrpc.ClientCloser, error)
+	apiGetter func() (v0api.FullNode, jsonrpc.ClientCloser, error)
-	under     api.Wallet
+	under     v0api.Wallet
 }
 
 func (c *InteractiveWallet) WalletNew(ctx context.Context, typ types.KeyType) (address.Address, error) {

cmd/lotus-wallet/main.go

@@ -6,6 +6,8 @@ import (
 	"net/http"
 	"os"
 
+	"github.com/filecoin-project/lotus/api/v0api"
+
 	"github.com/gorilla/mux"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/urfave/cli/v2"
@@ -149,10 +151,10 @@ var runCmd = &cli.Command{
 		log.Info("Setting up API endpoint at " + address)
 
 		if cctx.Bool("interactive") {
-			var ag func() (api.FullNode, jsonrpc.ClientCloser, error)
+			var ag func() (v0api.FullNode, jsonrpc.ClientCloser, error)
 
 			if !cctx.Bool("offline") {
-				ag = func() (api.FullNode, jsonrpc.ClientCloser, error) {
+				ag = func() (v0api.FullNode, jsonrpc.ClientCloser, error) {
 					return lcli.GetFullNodeAPI(cctx)
 				}
 			}

cmd/lotus/rpc.go

@@ -22,7 +22,8 @@ import (
 	"github.com/filecoin-project/go-jsonrpc/auth"
 
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/apistruct"
+	"github.com/filecoin-project/lotus/api/v0api"
+	"github.com/filecoin-project/lotus/api/v1api"
 	"github.com/filecoin-project/lotus/metrics"
 	"github.com/filecoin-project/lotus/node"
 	"github.com/filecoin-project/lotus/node/impl"
@@ -30,21 +31,27 @@ import (
 
 var log = logging.Logger("main")
 
-func serveRPC(a api.FullNode, stop node.StopFunc, addr multiaddr.Multiaddr, shutdownCh <-chan struct{}, maxRequestSize int64) error {
+func serveRPC(a v1api.FullNode, stop node.StopFunc, addr multiaddr.Multiaddr, shutdownCh <-chan struct{}, maxRequestSize int64) error {
 	serverOptions := make([]jsonrpc.ServerOption, 0)
 	if maxRequestSize != 0 { // config set
 		serverOptions = append(serverOptions, jsonrpc.WithMaxRequestSize(maxRequestSize))
 	}
-	rpcServer := jsonrpc.NewServer(serverOptions...)
+	serveRpc := func(path string, hnd interface{}) {
-	rpcServer.Register("Filecoin", apistruct.PermissionedFullAPI(metrics.MetricedFullAPI(a)))
+		rpcServer := jsonrpc.NewServer(serverOptions...)
-	rpcServer.AliasMethod("rpc.discover", "Filecoin.Discover")
+		rpcServer.Register("Filecoin", hnd)
 
-	ah := &auth.Handler{
+		ah := &auth.Handler{
-		Verify: a.AuthVerify,
+			Verify: a.AuthVerify,
-		Next:   rpcServer.ServeHTTP,
+			Next:   rpcServer.ServeHTTP,
+		}
+
+		http.Handle(path, ah)
 	}
 
-	http.Handle("/rpc/v0", ah)
+	pma := api.PermissionedFullAPI(metrics.MetricedFullAPI(a))
+
+	serveRpc("/rpc/v1", pma)
+	serveRpc("/rpc/v0", &v0api.WrapperV1Full{FullNode: pma})
 
 	importAH := &auth.Handler{
 		Verify: a.AuthVerify,
@@ -109,7 +116,7 @@ func handleImport(a *impl.FullNodeAPI) func(w http.ResponseWriter, r *http.Reque
 			w.WriteHeader(404)
 			return
 		}
-		if !auth.HasPerm(r.Context(), nil, apistruct.PermWrite) {
+		if !auth.HasPerm(r.Context(), nil, api.PermWrite) {
 			w.WriteHeader(401)
 			_ = json.NewEncoder(w).Encode(struct{ Error string }{"unauthorized: missing write permission"})
 			return

cmd/tvx/extract_message.go

@@ -8,6 +8,8 @@ import (
 	"io"
 	"log"
 
+	"github.com/filecoin-project/lotus/api/v0api"
+
 	"github.com/fatih/color"
 	"github.com/filecoin-project/go-address"
 
@@ -318,7 +320,7 @@ func doExtractMessage(opts extractOpts) error {
 
 // resolveFromChain queries the chain for the provided message, using the block CID to
 // speed up the query, if provided
-func resolveFromChain(ctx context.Context, api api.FullNode, mcid cid.Cid, block string) (msg *types.Message, execTs *types.TipSet, incTs *types.TipSet, err error) {
+func resolveFromChain(ctx context.Context, api v0api.FullNode, mcid cid.Cid, block string) (msg *types.Message, execTs *types.TipSet, incTs *types.TipSet, err error) {
 	// Extract the full message.
 	msg, err = api.ChainGetMessage(ctx, mcid)
 	if err != nil {
@@ -373,7 +375,7 @@ func resolveFromChain(ctx context.Context, api api.FullNode, mcid cid.Cid, block
 // as the previous tipset. In the context of vector generation, the target
 // tipset is the one where a message was executed, and the previous tipset is
 // the one where the message was included.
-func fetchThisAndPrevTipset(ctx context.Context, api api.FullNode, target types.TipSetKey) (targetTs *types.TipSet, prevTs *types.TipSet, err error) {
+func fetchThisAndPrevTipset(ctx context.Context, api v0api.FullNode, target types.TipSetKey) (targetTs *types.TipSet, prevTs *types.TipSet, err error) {
 	// get the tipset on which this message was "executed" on.
 	// https://github.com/filecoin-project/lotus/issues/2847
 	targetTs, err = api.ChainGetTipSet(ctx, target)

cmd/tvx/main.go

@@ -9,13 +9,13 @@ import (
 	"github.com/filecoin-project/go-jsonrpc"
 	"github.com/urfave/cli/v2"
 
-	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	lcli "github.com/filecoin-project/lotus/cli"
 )
 
 // FullAPI is a JSON-RPC client targeting a full node. It's initialized in a
 // cli.BeforeFunc.
-var FullAPI api.FullNode
+var FullAPI v0api.FullNode
 
 // Closer is the closer for the JSON-RPC client, which must be called on
 // cli.AfterFunc.

cmd/tvx/state.go

@@ -6,6 +6,8 @@ import (
 	"io"
 	"log"
 
+	"github.com/filecoin-project/lotus/api/v0api"
+
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
@@ -13,7 +15,6 @@ import (
 	"github.com/ipld/go-car"
 	cbg "github.com/whyrusleeping/cbor-gen"
 
-	"github.com/filecoin-project/lotus/api"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -23,13 +24,13 @@ import (
 // StateSurgeon is an object used to fetch and manipulate state.
 type StateSurgeon struct {
 	ctx    context.Context
-	api    api.FullNode
+	api    v0api.FullNode
 	stores *Stores
 }
 
 // NewSurgeon returns a state surgeon, an object used to fetch and manipulate
 // state.
-func NewSurgeon(ctx context.Context, api api.FullNode, stores *Stores) *StateSurgeon {
+func NewSurgeon(ctx context.Context, api v0api.FullNode, stores *Stores) *StateSurgeon {
 	return &StateSurgeon{
 		ctx:    ctx,
 		api:    api,
@@ -85,7 +86,7 @@ func (sg *StateSurgeon) GetMaskedStateTree(previousRoot cid.Cid, retain []addres
 
 // GetAccessedActors identifies the actors that were accessed during the
 // execution of a message.
-func (sg *StateSurgeon) GetAccessedActors(ctx context.Context, a api.FullNode, mid cid.Cid) ([]address.Address, error) {
+func (sg *StateSurgeon) GetAccessedActors(ctx context.Context, a v0api.FullNode, mid cid.Cid) ([]address.Address, error) {
 	log.Printf("calculating accessed actors during execution of message: %s", mid)
 	msgInfo, err := a.StateSearchMsg(ctx, mid)
 	if err != nil {

cmd/tvx/stores.go

@@ -5,10 +5,11 @@ import (
 	"log"
 	"sync"
 
+	"github.com/filecoin-project/lotus/api/v0api"
+
 	"github.com/fatih/color"
 	dssync "github.com/ipfs/go-datastore/sync"
 
-	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/blockstore"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
@@ -40,7 +41,7 @@ type Stores struct {
 // NewProxyingStores is a set of Stores backed by a proxying Blockstore that
 // proxies Get requests for unknown CIDs to a Filecoin node, via the
 // ChainReadObj RPC.
-func NewProxyingStores(ctx context.Context, api api.FullNode) *Stores {
+func NewProxyingStores(ctx context.Context, api v0api.FullNode) *Stores {
 	ds := dssync.MutexWrap(ds.NewMapDatastore())
 	bs := &proxyingBlockstore{
 		ctx:        ctx,
@@ -85,7 +86,7 @@ type TracingBlockstore interface {
 // a Filecoin node via JSON-RPC.
 type proxyingBlockstore struct {
 	ctx context.Context
-	api api.FullNode
+	api v0api.FullNode
 
 	lk      sync.Mutex
 	tracing bool

conformance/rand_record.go

@@ -10,14 +10,14 @@ import (
 
 	"github.com/filecoin-project/test-vectors/schema"
 
-	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/v0api"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
 )
 
 type RecordingRand struct {
 	reporter Reporter
-	api      api.FullNode
+	api      v0api.FullNode
 
 	// once guards the loading of the head tipset.
 	// can be removed when https://github.com/filecoin-project/lotus/issues/4223
@@ -33,7 +33,7 @@ var _ vm.Rand = (*RecordingRand)(nil)
 // NewRecordingRand returns a vm.Rand implementation that proxies calls to a
 // full Lotus node via JSON-RPC, and records matching rules and responses so
 // they can later be embedded in test vectors.
-func NewRecordingRand(reporter Reporter, api api.FullNode) *RecordingRand {
+func NewRecordingRand(reporter Reporter, api v0api.FullNode) *RecordingRand {
 	return &RecordingRand{reporter: reporter, api: api}
 }
 

extern/storage-sealing/currentdealinfo.go

@@ -160,7 +160,7 @@ type CurrentDealInfoTskAPI interface {
 	ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Message, error)
 	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error)
 	StateMarketStorageDeal(context.Context, abi.DealID, types.TipSetKey) (*api.MarketDeal, error)
-	StateSearchMsg(context.Context, cid.Cid) (*api.MsgLookup, error)
+	StateSearchMsg(ctx context.Context, from types.TipSetKey, msg cid.Cid, limit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error)
 }
 
 type CurrentDealInfoAPIAdapter struct {
@@ -186,7 +186,7 @@ func (c *CurrentDealInfoAPIAdapter) StateMarketStorageDeal(ctx context.Context,
 }
 
 func (c *CurrentDealInfoAPIAdapter) StateSearchMsg(ctx context.Context, k cid.Cid) (*MsgLookup, error) {
-	wmsg, err := c.CurrentDealInfoTskAPI.StateSearchMsg(ctx, k)
+	wmsg, err := c.CurrentDealInfoTskAPI.StateSearchMsg(ctx, types.EmptyTSK, k, api.LookbackNoLimit, true)
 	if err != nil {
 		return nil, err
 	}

gen/api/proxygen.go

@@ -52,40 +52,47 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {
 
 	return v
 }
+
 func main() {
-	if err := runMain(); err != nil {
+	// latest (v1)
+	if err := generate("./api", "api", "api", "./api/proxy_gen.go"); err != nil {
+		fmt.Println("error: ", err)
+	}
+
+	// v0
+	if err := generate("./api/v0api", "v0api", "v0api", "./api/v0api/proxy_gen.go"); err != nil {
 		fmt.Println("error: ", err)
 	}
 }
 
-func typeName(e ast.Expr) (string, error) {
+func typeName(e ast.Expr, pkg string) (string, error) {
 	switch t := e.(type) {
 	case *ast.SelectorExpr:
 		return t.X.(*ast.Ident).Name + "." + t.Sel.Name, nil
 	case *ast.Ident:
 		pstr := t.Name
-		if !unicode.IsLower(rune(pstr[0])) {
+		if !unicode.IsLower(rune(pstr[0])) && pkg != "api" {
 			pstr = "api." + pstr // todo src pkg name
 		}
 		return pstr, nil
 	case *ast.ArrayType:
-		subt, err := typeName(t.Elt)
+		subt, err := typeName(t.Elt, pkg)
 		if err != nil {
 			return "", err
 		}
 		return "[]" + subt, nil
 	case *ast.StarExpr:
-		subt, err := typeName(t.X)
+		subt, err := typeName(t.X, pkg)
 		if err != nil {
 			return "", err
 		}
 		return "*" + subt, nil
 	case *ast.MapType:
-		k, err := typeName(t.Key)
+		k, err := typeName(t.Key, pkg)
 		if err != nil {
 			return "", err
 		}
-		v, err := typeName(t.Value)
+		v, err := typeName(t.Value, pkg)
 		if err != nil {
 			return "", err
 		}
@@ -101,7 +108,7 @@ func typeName(e ast.Expr) (string, error) {
 		}
 		return "interface{}", nil
 	case *ast.ChanType:
-		subt, err := typeName(t.Value)
+		subt, err := typeName(t.Value, pkg)
 		if err != nil {
 			return "", err
 		}
@@ -116,9 +123,13 @@ func typeName(e ast.Expr) (string, error) {
 	}
 }
 
-func runMain() error {
+func generate(path, pkg, outpkg, outfile string) error {
 	fset := token.NewFileSet()
-	apiDir, err := filepath.Abs("./api")
+	apiDir, err := filepath.Abs(path)
+	if err != nil {
+		return err
+	}
+	outfile, err = filepath.Abs(outfile)
 	if err != nil {
 		return err
 	}
@@ -127,16 +138,16 @@ func runMain() error {
 		return err
 	}
 
-	ap := pkgs["api"]
+	ap := pkgs[pkg]
 
 	v := &Visitor{make(map[string]map[string]*methodMeta), map[string][]string{}}
 	ast.Walk(v, ap)
 
 	type methodInfo struct {
-		Name                             string
+		Name                                     string
-		node                             ast.Node
+		node                                     ast.Node
-		Tags                             map[string][]string
+		Tags                                     map[string][]string
-		NamedParams, ParamNames, Results string
+		NamedParams, ParamNames, Results, DefRes string
 	}
 
 	type strinfo struct {
@@ -148,9 +159,11 @@ func runMain() error {
 	type meta struct {
 		Infos   map[string]*strinfo
 		Imports map[string]string
+		OutPkg  string
 	}
 
 	m := &meta{
+		OutPkg:  outpkg,
 		Infos:   map[string]*strinfo{},
 		Imports: map[string]string{},
 	}
@@ -165,6 +178,9 @@ func runMain() error {
 
 		for _, im := range f.Imports {
 			m.Imports[im.Path.Value] = im.Path.Value
+			if im.Name != nil {
+				m.Imports[im.Path.Value] = im.Name.Name + " " + m.Imports[im.Path.Value]
+			}
 		}
 
 		for ifname, methods := range v.Methods {
@@ -182,7 +198,7 @@ func runMain() error {
 				if _, ok := info.Methods[mname]; !ok {
 					var params, pnames []string
 					for _, param := range node.ftype.Params.List {
-						pstr, err := typeName(param.Type)
+						pstr, err := typeName(param.Type, outpkg)
 						if err != nil {
 							return err
 						}
@@ -199,15 +215,33 @@ func runMain() error {
 						}
 					}
 
-					var results []string
+					results := []string{}
 					for _, result := range node.ftype.Results.List {
-						rs, err := typeName(result.Type)
+						rs, err := typeName(result.Type, outpkg)
 						if err != nil {
 							return err
 						}
 						results = append(results, rs)
 					}
 
+					defRes := ""
+					if len(results) > 1 {
+						defRes = results[0]
+						switch {
+						case defRes[0] == '*' || defRes[0] == '<', defRes == "interface{}":
+							defRes = "nil"
+						case defRes == "bool":
+							defRes = "false"
+						case defRes == "string":
+							defRes = `""`
+						case defRes == "int", defRes == "int64", defRes == "uint64", defRes == "uint":
+							defRes = "0"
+						default:
+							defRes = "*new(" + defRes + ")"
+						}
+						defRes += ", "
+					}
+
 					info.Methods[mname] = &methodInfo{
 						Name:        mname,
 						node:        node.node,
@@ -215,6 +249,7 @@ func runMain() error {
 						NamedParams: strings.Join(params, ", "),
 						ParamNames:  strings.Join(pnames, ", "),
 						Results:     strings.Join(results, ", "),
+						DefRes:      defRes,
 					}
 				}
 
@@ -244,14 +279,17 @@ func runMain() error {
 	}
 	fmt.Println(string(jb))*/
 
-	w := os.Stdout
+	w, err := os.OpenFile(outfile, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
+	if err != nil {
+		return err
+	}
 
 	err = doTemplate(w, m, `// Code generated by github.com/filecoin-project/lotus/gen/api. DO NOT EDIT.
 
-package apistruct
+package {{.OutPkg}}
 
 import (
-{{range .Imports}}{{.}}
+{{range .Imports}}	{{.}}
 {{end}}
 )
 `)
@@ -271,6 +309,12 @@ type {{.Name}}Struct struct {
 {{end}}
 	}
 }
+
+type {{.Name}}Stub struct {
+{{range .Include}}
+	{{.}}Stub
+{{end}}
+}
 {{end}}
 
 {{range .Infos}}
@@ -279,10 +323,14 @@ type {{.Name}}Struct struct {
 func (s *{{$name}}Struct) {{.Name}}({{.NamedParams}}) ({{.Results}}) {
 	return s.Internal.{{.Name}}({{.ParamNames}})
 }
+
+func (s *{{$name}}Stub) {{.Name}}({{.NamedParams}}) ({{.Results}}) {
+	return {{.DefRes}}xerrors.New("method not supported")
+}
 {{end}}
 {{end}}
 
-{{range .Infos}}var _ api.{{.Name}} = new({{.Name}}Struct)
+{{range .Infos}}var _ {{.Name}} = new({{.Name}}Struct)
 {{end}}
 
 `)

markets/retrievaladapter/provider.go

@@ -4,10 +4,11 @@ import (
 	"context"
 	"io"
 
+	"github.com/filecoin-project/lotus/api/v1api"
+
 	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log/v2"
 
-	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/types"
 	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
@@ -26,12 +27,12 @@ var log = logging.Logger("retrievaladapter")
 type retrievalProviderNode struct {
 	miner  *storage.Miner
 	sealer sectorstorage.SectorManager
-	full   api.FullNode
+	full   v1api.FullNode
 }
 
 // NewRetrievalProviderNode returns a new node adapter for a retrieval provider that talks to the
 // Lotus Node
-func NewRetrievalProviderNode(miner *storage.Miner, sealer sectorstorage.SectorManager, full api.FullNode) retrievalmarket.RetrievalProviderNode {
+func NewRetrievalProviderNode(miner *storage.Miner, sealer sectorstorage.SectorManager, full v1api.FullNode) retrievalmarket.RetrievalProviderNode {
 	return &retrievalProviderNode{miner, sealer, full}
 }
 

markets/storageadapter/client.go

@@ -196,7 +196,7 @@ func (c *ClientNodeAdapter) ValidatePublishedDeal(ctx context.Context, deal stor
 	}
 
 	// TODO: timeout
-	ret, err := c.StateWaitMsg(ctx, *deal.PublishMessage, build.MessageConfidence)
+	ret, err := c.StateWaitMsg(ctx, *deal.PublishMessage, build.MessageConfidence, api.LookbackNoLimit, true)
 	if err != nil {
 		return 0, xerrors.Errorf("waiting for deal publish message: %w", err)
 	}
@@ -363,7 +363,7 @@ func (c *ClientNodeAdapter) GetChainHead(ctx context.Context) (shared.TipSetToke
 }
 
 func (c *ClientNodeAdapter) WaitForMessage(ctx context.Context, mcid cid.Cid, cb func(code exitcode.ExitCode, bytes []byte, finalCid cid.Cid, err error) error) error {
-	receipt, err := c.StateWaitMsg(ctx, mcid, build.MessageConfidence)
+	receipt, err := c.StateWaitMsg(ctx, mcid, build.MessageConfidence, api.LookbackNoLimit, true)
 	if err != nil {
 		return cb(0, nil, cid.Undef, err)
 	}

markets/storageadapter/provider.go

@@ -21,6 +21,7 @@ import (
 	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
 
 	"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/actors/builtin/market"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
@@ -42,7 +43,7 @@ var defaultMaxProviderCollateralMultiplier = uint64(2)
 var log = logging.Logger("storageadapter")
 
 type ProviderNodeAdapter struct {
-	api.FullNode
+	v1api.FullNode
 
 	// this goes away with the data transfer module
 	dag dtypes.StagingDAG
@@ -58,8 +59,8 @@ type ProviderNodeAdapter struct {
 	scMgr                       *SectorCommittedManager
 }
 
-func NewProviderNodeAdapter(fc *config.MinerFeeConfig, dc *config.DealmakingConfig) func(mctx helpers.MetricsCtx, lc fx.Lifecycle, dag dtypes.StagingDAG, secb *sectorblocks.SectorBlocks, full api.FullNode, dealPublisher *DealPublisher) storagemarket.StorageProviderNode {
+func NewProviderNodeAdapter(fc *config.MinerFeeConfig, dc *config.DealmakingConfig) func(mctx helpers.MetricsCtx, lc fx.Lifecycle, dag dtypes.StagingDAG, secb *sectorblocks.SectorBlocks, full v1api.FullNode, dealPublisher *DealPublisher) storagemarket.StorageProviderNode {
-	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, dag dtypes.StagingDAG, secb *sectorblocks.SectorBlocks, full api.FullNode, dealPublisher *DealPublisher) storagemarket.StorageProviderNode {
+	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, dag dtypes.StagingDAG, secb *sectorblocks.SectorBlocks, full v1api.FullNode, dealPublisher *DealPublisher) storagemarket.StorageProviderNode {
 		ctx := helpers.LifecycleCtx(mctx, lc)
 
 		ev := events.NewEvents(ctx, full)
@@ -290,7 +291,7 @@ func (n *ProviderNodeAdapter) GetChainHead(ctx context.Context) (shared.TipSetTo
 }
 
 func (n *ProviderNodeAdapter) WaitForMessage(ctx context.Context, mcid cid.Cid, cb func(code exitcode.ExitCode, bytes []byte, finalCid cid.Cid, err error) error) error {
-	receipt, err := n.StateWaitMsg(ctx, mcid, 2*build.MessageConfidence)
+	receipt, err := n.StateWaitMsg(ctx, mcid, 2*build.MessageConfidence, api.LookbackNoLimit, true)
 	if err != nil {
 		return cb(0, nil, cid.Undef, err)
 	}
@@ -299,7 +300,7 @@ func (n *ProviderNodeAdapter) WaitForMessage(ctx context.Context, mcid cid.Cid,
 
 func (n *ProviderNodeAdapter) WaitForPublishDeals(ctx context.Context, publishCid cid.Cid, proposal market2.DealProposal) (*storagemarket.PublishDealsWaitResult, error) {
 	// Wait for deal to be published (plus additional time for confidence)
-	receipt, err := n.StateWaitMsg(ctx, publishCid, 2*build.MessageConfidence)
+	receipt, err := n.StateWaitMsg(ctx, publishCid, 2*build.MessageConfidence, api.LookbackNoLimit, true)
 	if err != nil {
 		return nil, xerrors.Errorf("WaitForPublishDeals errored: %w", err)
 	}

metrics/proxy.go

@@ -7,37 +7,36 @@ import (
 	"go.opencensus.io/tag"
 
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/apistruct"
 )
 
 func MetricedStorMinerAPI(a api.StorageMiner) api.StorageMiner {
-	var out apistruct.StorageMinerStruct
+	var out api.StorageMinerStruct
 	proxy(a, &out.Internal)
 	proxy(a, &out.CommonStruct.Internal)
 	return &out
 }
 
 func MetricedFullAPI(a api.FullNode) api.FullNode {
-	var out apistruct.FullNodeStruct
+	var out api.FullNodeStruct
 	proxy(a, &out.Internal)
 	proxy(a, &out.CommonStruct.Internal)
 	return &out
 }
 
 func MetricedWorkerAPI(a api.Worker) api.Worker {
-	var out apistruct.WorkerStruct
+	var out api.WorkerStruct
 	proxy(a, &out.Internal)
 	return &out
 }
 
 func MetricedWalletAPI(a api.Wallet) api.Wallet {
-	var out apistruct.WalletStruct
+	var out api.WalletStruct
 	proxy(a, &out.Internal)
 	return &out
 }
 
 func MetricedGatewayAPI(a api.Gateway) api.Gateway {
-	var out apistruct.GatewayStruct
+	var out api.GatewayStruct
 	proxy(a, &out.Internal)
 	return &out
 }

miner/miner.go

@@ -9,6 +9,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/filecoin-project/lotus/api/v1api"
+
 	proof2 "github.com/filecoin-project/specs-actors/v2/actors/runtime/proof"
 
 	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
@@ -56,7 +58,7 @@ func randTimeOffset(width time.Duration) time.Duration {
 
 // NewMiner instantiates a miner with a concrete WinningPoStProver and a miner
 // address (which can be different from the worker's address).
-func NewMiner(api api.FullNode, epp gen.WinningPoStProver, addr address.Address, sf *slashfilter.SlashFilter, j journal.Journal) *Miner {
+func NewMiner(api v1api.FullNode, epp gen.WinningPoStProver, addr address.Address, sf *slashfilter.SlashFilter, j journal.Journal) *Miner {
 	arc, err := lru.NewARC(10000)
 	if err != nil {
 		panic(err)
@@ -100,7 +102,7 @@ func NewMiner(api api.FullNode, epp gen.WinningPoStProver, addr address.Address,
 //
 // Refer to the godocs on mineOne and mine methods for more detail.
 type Miner struct {
-	api api.FullNode
+	api v1api.FullNode
 
 	epp gen.WinningPoStProver
 

miner/testminer.go

@@ -8,7 +8,8 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/api"
+
+	"github.com/filecoin-project/lotus/api/v1api"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
 	"github.com/filecoin-project/lotus/journal"
@@ -19,8 +20,8 @@ type MineReq struct {
 	Done        func(bool, abi.ChainEpoch, error)
 }
 
-func NewTestMiner(nextCh <-chan MineReq, addr address.Address) func(api.FullNode, gen.WinningPoStProver) *Miner {
+func NewTestMiner(nextCh <-chan MineReq, addr address.Address) func(v1api.FullNode, gen.WinningPoStProver) *Miner {
-	return func(api api.FullNode, epp gen.WinningPoStProver) *Miner {
+	return func(api v1api.FullNode, epp gen.WinningPoStProver) *Miner {
 		arc, err := lru.NewARC(10000)
 		if err != nil {
 			panic(err)

node/impl/full/chain.go

@@ -51,6 +51,8 @@ type ChainModuleAPI interface {
 	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
 }
 
+var _ ChainModuleAPI = *new(api.FullNode)
+
 // ChainModule provides a default implementation of ChainModuleAPI.
 // It can be swapped out with another implementation through Dependency
 // Injection (for example with a thin RPC client).

node/impl/full/gas.go

@@ -31,6 +31,8 @@ type GasModuleAPI interface {
 	GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, tsk types.TipSetKey) (*types.Message, error)
 }
 
+var _ GasModuleAPI = *new(api.FullNode)
+
 // GasModule provides a default implementation of GasModuleAPI.
 // It can be swapped out with another implementation through Dependency
 // Injection (for example with a thin RPC client).

node/impl/full/mpool.go

@@ -20,6 +20,8 @@ type MpoolModuleAPI interface {
 	MpoolPush(ctx context.Context, smsg *types.SignedMessage) (cid.Cid, error)
 }
 
+var _ MpoolModuleAPI = *new(api.FullNode)
+
 // MpoolModule provides a default implementation of MpoolModuleAPI.
 // It can be swapped out with another implementation through Dependency
 // Injection (for example with a thin RPC client).

node/impl/full/state.go

@@ -44,7 +44,6 @@ type StateModuleAPI interface {
 	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 	StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (api.DealCollateralBounds, error)
 	StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error)
-	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
 	StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error)
 	StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 	StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MarketBalance, error)
@@ -53,12 +52,14 @@ type StateModuleAPI interface {
 	StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error)
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error)
 	StateNetworkVersion(ctx context.Context, key types.TipSetKey) (network.Version, error)
-	StateSearchMsg(ctx context.Context, msg cid.Cid) (*api.MsgLookup, error)
 	StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error)
 	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)
+	StateSearchMsg(ctx context.Context, from types.TipSetKey, msg cid.Cid, limit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error)
+	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64, limit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error)
 }
 
+var _ StateModuleAPI = *new(api.FullNode)
+
 // StateModule provides a default implementation of StateModuleAPI.
 // It can be swapped out with another implementation through Dependency
 // Injection (for example with a thin RPC client).
@@ -378,7 +379,7 @@ func (a *StateAPI) StateReplay(ctx context.Context, tsk types.TipSetKey, mc cid.
 	var ts *types.TipSet
 	var err error
 	if tsk == types.EmptyTSK {
-		mlkp, err := a.StateSearchMsg(ctx, mc)
+		mlkp, err := a.StateSearchMsg(ctx, types.EmptyTSK, mc, stmgr.LookbackNoLimit, true)
 		if err != nil {
 			return nil, xerrors.Errorf("searching for msg %s: %w", mc, err)
 		}
@@ -520,28 +521,22 @@ func (a *StateAPI) MinerCreateBlock(ctx context.Context, bt *api.BlockTemplate)
 	return &out, nil
 }
 
-func (m *StateModule) StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*api.MsgLookup, error) {
+func (m *StateModule) StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64, lookbackLimit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error) {
-	return stateWaitMsgLimited(ctx, m.StateManager, m.Chain, msg, confidence, stmgr.LookbackNoLimit)
+	ts, recpt, found, err := m.StateManager.WaitForMessage(ctx, msg, confidence, lookbackLimit, allowReplaced)
-}
-func (a *StateAPI) StateWaitMsgLimited(ctx context.Context, msg cid.Cid, confidence uint64, lookbackLimit abi.ChainEpoch) (*api.MsgLookup, error) {
-	return stateWaitMsgLimited(ctx, a.StateManager, a.Chain, msg, confidence, lookbackLimit)
-}
-func stateWaitMsgLimited(ctx context.Context, smgr *stmgr.StateManager, cstore *store.ChainStore, msg cid.Cid, confidence uint64, lookbackLimit abi.ChainEpoch) (*api.MsgLookup, error) {
-	ts, recpt, found, err := smgr.WaitForMessage(ctx, msg, confidence, lookbackLimit)
 	if err != nil {
 		return nil, err
 	}
 
 	var returndec interface{}
 	if recpt.ExitCode == 0 && len(recpt.Return) > 0 {
-		cmsg, err := cstore.GetCMessage(msg)
+		cmsg, err := m.Chain.GetCMessage(msg)
 		if err != nil {
 			return nil, xerrors.Errorf("failed to load message after successful receipt search: %w", err)
 		}
 
 		vmsg := cmsg.VMMessage()
 
-		t, err := stmgr.GetReturnType(ctx, smgr, vmsg.To, vmsg.Method, ts)
+		t, err := stmgr.GetReturnType(ctx, m.StateManager, vmsg.To, vmsg.Method, ts)
 		if err != nil {
 			return nil, xerrors.Errorf("failed to get return type: %w", err)
 		}
@@ -562,14 +557,13 @@ func stateWaitMsgLimited(ctx context.Context, smgr *stmgr.StateManager, cstore *
 	}, nil
 }
 
-func (m *StateModule) StateSearchMsg(ctx context.Context, msg cid.Cid) (*api.MsgLookup, error) {
+func (m *StateModule) StateSearchMsg(ctx context.Context, tsk types.TipSetKey, msg cid.Cid, lookbackLimit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error) {
-	return stateSearchMsgLimited(ctx, m.StateManager, msg, stmgr.LookbackNoLimit)
+	fromTs, err := m.Chain.GetTipSetFromKey(tsk)
-}
+	if err != nil {
-func (a *StateAPI) StateSearchMsgLimited(ctx context.Context, msg cid.Cid, lookbackLimit abi.ChainEpoch) (*api.MsgLookup, error) {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
-	return stateSearchMsgLimited(ctx, a.StateManager, msg, lookbackLimit)
+	}
-}
+
-func stateSearchMsgLimited(ctx context.Context, smgr *stmgr.StateManager, msg cid.Cid, lookbackLimit abi.ChainEpoch) (*api.MsgLookup, error) {
+	ts, recpt, found, err := m.StateManager.SearchForMessage(ctx, fromTs, msg, lookbackLimit, allowReplaced)
-	ts, recpt, found, err := smgr.SearchForMessage(ctx, msg, lookbackLimit)
 	if err != nil {
 		return nil, err
 	}
@@ -585,14 +579,6 @@ func stateSearchMsgLimited(ctx context.Context, smgr *stmgr.StateManager, msg ci
 	return nil, nil
 }
 
-func (m *StateModule) StateGetReceipt(ctx context.Context, msg cid.Cid, tsk types.TipSetKey) (*types.MessageReceipt, error) {
-	ts, err := m.Chain.GetTipSetFromKey(tsk)
-	if err != nil {
-		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
-	}
-	return m.StateManager.GetReceipt(ctx, msg, ts)
-}
-
 func (m *StateModule) StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error) {
 	ts, err := m.Chain.GetTipSetFromKey(tsk)
 	if err != nil {

node/impl/remoteworker.go

@@ -33,7 +33,7 @@ func connectRemoteWorker(ctx context.Context, fa api.Common, url string) (*remot
 	headers := http.Header{}
 	headers.Add("Authorization", "Bearer "+string(token))
 
-	wapi, closer, err := client.NewWorkerRPC(context.TODO(), url, headers)
+	wapi, closer, err := client.NewWorkerRPCV0(context.TODO(), url, headers)
 	if err != nil {
 		return nil, xerrors.Errorf("creating jsonrpc client: %w", err)
 	}

node/impl/storminer.go

@@ -34,7 +34,6 @@ import (
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/apistruct"
 	apitypes "github.com/filecoin-project/lotus/api/types"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/markets/storageadapter"
@@ -90,7 +89,7 @@ type StorageMinerAPI struct {
 }
 
 func (sm *StorageMinerAPI) ServeRemote(w http.ResponseWriter, r *http.Request) {
-	if !auth.HasPerm(r.Context(), nil, apistruct.PermAdmin) {
+	if !auth.HasPerm(r.Context(), nil, api.PermAdmin) {
 		w.WriteHeader(401)
 		_ = json.NewEncoder(w).Encode(struct{ Error string }{"unauthorized: missing write permission"})
 		return

node/modules/core.go

@@ -22,7 +22,7 @@ import (
 	"github.com/filecoin-project/go-jsonrpc/auth"
 	"github.com/filecoin-project/go-state-types/abi"
 
-	"github.com/filecoin-project/lotus/api/apistruct"
+	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/lib/addrutil"
@@ -163,7 +163,7 @@ func APISecret(keystore types.KeyStore, lr repo.LockedRepo) (*dtypes.APIAlg, err
 
 		// TODO: make this configurable
 		p := JwtPayload{
-			Allow: apistruct.AllPermissions,
+			Allow: api.AllPermissions,
 		}
 
 		cliToken, err := jwt.Sign(&p, jwt.NewHS256(key.PrivateKey))

node/modules/paych.go

@@ -32,6 +32,8 @@ type PaychAPI struct {
 	full.StateAPI
 }
 
+var _ paychmgr.PaychAPI = &PaychAPI{}
+
 // HandlePaychManager is called by dependency injection to set up hooks
 func HandlePaychManager(lc fx.Lifecycle, pm *paychmgr.Manager) {
 	lc.Append(fx.Hook{