Plumb StateCall's flushAllBlocks and write into result

Author: rvagg

api/api_full.go

@@ -386,7 +386,7 @@ type FullNode interface {
 	// 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(ctx context.Context, p StateCallParams) (*InvocResult, error) //perm:read
+	StateCall(ctx context.Context, p jsonrpc.RawParams) (*InvocResult, error) //perm:read
 	// StateReplay replays a given message, assuming it was included in a block in the specified tipset.
 	//
 	// If a tipset key is provided, and a replacing message is not found on chain,
@@ -1271,12 +1271,7 @@ type InvocResult struct {
 	ExecutionTrace types.ExecutionTrace
 	Error          string
 	Duration       time.Duration
-	Blocks         *InvocBlocks `json:",omitempty"`
-}
-
-type InvocBlocks struct {
-	Root   cid.Cid
-	Blocks []Block
+	Blocks         []Block `json:",omitempty"`
 }
 
 type Block struct {
@@ -1482,20 +1477,55 @@ type EthTxReceipt struct {
 	Type              ethtypes.EthUint64   `json:"type"`
 }
 
+// StateCallParams is the parameters for the StateCall method.
 type StateCallParams struct {
 	Message       *types.Message  `json:"message"`
 	TipSetKey     types.TipSetKey `json:"tipsetKey"`
 	IncludeBlocks bool            `json:"includeBlocks,omitempty"`
 }
 
-func (e *StateCallParams) ToArg() jsonrpc.RawParams {
+// NewStateCallParams creates a new StateCallParams instance with the given message and tipset key.
+func NewStateCallParams(msg *types.Message, tsk types.TipSetKey) StateCallParams {
+	return StateCallParams{
+		Message:       msg,
+		TipSetKey:     tsk,
+		IncludeBlocks: false,
+	}
+}
+
+// StateCallParamsFromRaw converts raw jsonrpc parameters to StateCallParams.
+func StateCallParamsFromRaw(raw jsonrpc.RawParams) (StateCallParams, error) {
+	return jsonrpc.DecodeParams[StateCallParams](raw)
+}
+
+// ToRaw converts the StateCallParams to a jsonrpc.RawParams format for use with the StateCall
+// method.
+func (e StateCallParams) ToRaw() jsonrpc.RawParams {
+	if !e.IncludeBlocks {
+		// if we have 2 arguments, encode using the array format for backward compatibility with the
+		// old API, if a new client uses this to call an old server, it will be interpreted correctly
+		// as just 2 arguments
+		if b, err := json.Marshal([]any{e.Message, e.TipSetKey}); err == nil {
+			return jsonrpc.RawParams(b)
+		} // else fall through to the object format, maybe it'll work
+	}
+	// IncludeBlocks forces us to use the object format, so we can't be compatible with the old API
 	b, err := json.Marshal(e)
 	if err != nil {
 		return nil
 	}
 	return jsonrpc.RawParams(b)
 }
 
+// WithIncludeBlocks returns a new StateCallParams with IncludeBlocks set to true.
+func (e StateCallParams) WithIncludeBlocks() StateCallParams {
+	return StateCallParams{
+		Message:       e.Message,
+		TipSetKey:     e.TipSetKey,
+		IncludeBlocks: true,
+	}
+}
+
 func (e *StateCallParams) UnmarshalJSON(b []byte) error {
 	if len(b) == 0 {
 		return xerrors.New("empty input")
@@ -1509,11 +1539,8 @@ func (e *StateCallParams) UnmarshalJSON(b []byte) error {
 			return err
 		}
 		*e = StateCallParams(alias)
-		return nil
-	}
-
-	// If input is an array, expect exactly two elements: Message and TipSetKey
-	if b[0] == '[' {
+		// If input is an array, expect exactly two elements: Message and TipSetKey
+	} else if b[0] == '[' {
 		var params []json.RawMessage
 		if err := json.Unmarshal(b, &params); err != nil {
 			return err
@@ -1527,10 +1554,15 @@ func (e *StateCallParams) UnmarshalJSON(b []byte) error {
 		if err := json.Unmarshal(params[1], &e.TipSetKey); err != nil {
 			return xerrors.Errorf("failed to unmarshal tipset key: %w", err)
 		}
-		return nil
+	} else {
+		return xerrors.Errorf("unexpected JSON input: expected object or array, got %q", string(b[0]))
+	}
+
+	if e.Message == nil {
+		return xerrors.New("message required")
 	}
 
-	return xerrors.Errorf("unexpected JSON input: expected object or array, got %q", string(b[0]))
+	return nil
 }
 
 func (e *StateCallParams) MarshalJSON() ([]byte, error) {

api/api_gateway.go

@@ -64,7 +64,7 @@ type Gateway interface {
 	MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error)
 	MsigGetVestingSchedule(ctx context.Context, addr address.Address, tsk types.TipSetKey) (MsigVesting, error)
 	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-	StateCall(ctx context.Context, msg *types.Message, tsk types.TipSetKey) (*InvocResult, error)
+	StateCall(ctx context.Context, p jsonrpc.RawParams) (*InvocResult, error)
 	StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (DealCollateralBounds, error)
 	StateDecodeParams(ctx context.Context, toAddr address.Address, method abi.MethodNum, params []byte, tsk types.TipSetKey) (interface{}, error)
 	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)

api/mocks/mock_full.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
+	"github.com/filecoin-project/go-jsonrpc"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/builtin/v8/paych"
 	verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
@@ -308,7 +309,7 @@ type FullNode interface {
 	// 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
+	StateCall(context.Context, jsonrpc.RawParams) (*api.InvocResult, error) //perm:read
 	// StateReplay replays a given message, assuming it was included in a block in the specified tipset.
 	//
 	// If a tipset key is provided, and a replacing message is not found on chain,

api/proxy_gen.go

@@ -7,6 +7,7 @@ import (
 	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-jsonrpc"
 	"github.com/filecoin-project/go-state-types/abi"
 	verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
 	"github.com/filecoin-project/go-state-types/dline"
@@ -58,7 +59,7 @@ type Gateway interface {
 	MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error)
 	MsigGetPending(context.Context, address.Address, types.TipSetKey) ([]*api.MsigTransaction, error)
 	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-	StateCall(ctx context.Context, msg *types.Message, tsk types.TipSetKey) (*api.InvocResult, error)
+	StateCall(ctx context.Context, p jsonrpc.RawParams) (*api.InvocResult, error)
 	StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (api.DealCollateralBounds, error)
 	StateDecodeParams(ctx context.Context, toAddr address.Address, method abi.MethodNum, params []byte, tsk types.TipSetKey) (interface{}, error)
 	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)

api/v0api/full.go

@@ -1,7 +1,3 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/filecoin-project/lotus/api/v0api (interfaces: FullNode)
-
-// Package v0mocks is a generated GoMock package.
 package v0mocks
 
 import (
@@ -20,6 +16,7 @@ import (
 
 	address "github.com/filecoin-project/go-address"
 	bitfield "github.com/filecoin-project/go-bitfield"
+	"github.com/filecoin-project/go-jsonrpc"
 	auth "github.com/filecoin-project/go-jsonrpc/auth"
 	abi "github.com/filecoin-project/go-state-types/abi"
 	big "github.com/filecoin-project/go-state-types/big"
@@ -1831,9 +1828,9 @@ func (mr *MockFullNodeMockRecorder) StateAllMinerFaults(arg0, arg1, arg2 interfa
 }
 
 // StateCall mocks base method.
-func (m *MockFullNode) StateCall(arg0 context.Context, arg1 *types.Message, arg2 types.TipSetKey) (*api.InvocResult, error) {
+func (m *MockFullNode) StateCall(arg0 context.Context, arg1 jsonrpc.RawParams) (*api.InvocResult, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateCall", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "StateCall", arg0, arg1)
 	ret0, _ := ret[0].(*api.InvocResult)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1

api/v0api/gateway.go

@@ -0,0 +1,86 @@
+package blockstore
+
+import (
+	"context"
+	"sync"
+
+	block "github.com/ipfs/go-block-format"
+	"github.com/ipfs/go-cid"
+)
+
+// Accumulator is a type of blockstore that accumulates blocks in memory as they
+// are written. An Accumulator otherwise acts as a pass-through to the
+// underlying blockstore.
+//
+// Written blocks can be retrieved later using the GetBlocks method. This is
+// useful for testing and debugging purposes. Care should be taken when using
+// this feature for long-running applications where many blocks are written as
+// there is no automatic eviction mechanism. ClearBlocks can be used to
+// manually clear the accumulated blocks.
+type Accumulator struct {
+	Blockstore
+
+	cids []cid.Cid
+	lk   sync.Mutex
+}
+
+var (
+	_ Blockstore = (*Accumulator)(nil)
+	_ Viewer     = (*Accumulator)(nil)
+)
+
+// NewAccumulator creates a new Accumulator blockstore that wraps the given
+// Blockstore. The Accumulator will accumulate blocks in memory as they are
+// written. The blocks can be retrieved later using the GetBlocks method.
+func NewAccumulator(bs Blockstore) *Accumulator {
+	return &Accumulator{
+		Blockstore: bs,
+		cids:       make([]cid.Cid, 0),
+	}
+}
+
+func (acc *Accumulator) Put(ctx context.Context, b block.Block) error {
+	acc.lk.Lock()
+	acc.cids = append(acc.cids, b.Cid())
+	acc.lk.Unlock()
+	return acc.Blockstore.Put(ctx, b)
+}
+
+func (acc *Accumulator) PutMany(ctx context.Context, blks []block.Block) error {
+	acc.lk.Lock()
+	for _, b := range blks {
+		acc.cids = append(acc.cids, b.Cid())
+	}
+	acc.lk.Unlock()
+	return acc.Blockstore.PutMany(ctx, blks)
+}
+
+// GetBlocks returns the blocks that have been put into the accumulator.
+// It is safe to call this method concurrently with Put and PutMany.
+// The returned slice is the internal slice of blocks, and should be handled
+// with care if use of the blockstore is ongoing after this call.
+func (acc *Accumulator) GetBlocks(ctx context.Context) ([]block.Block, error) {
+	acc.lk.Lock()
+	defer acc.lk.Unlock()
+
+	blocks := make([]block.Block, len(acc.cids))
+	for i, c := range acc.cids {
+		b, err := acc.Blockstore.Get(ctx, c)
+		if err != nil {
+			return nil, err
+		}
+		blocks[i] = b
+	}
+	return blocks, nil
+}
+
+// ClearBlocks clears the blocks that have been accumulated in the
+// Accumulator. This is useful for testing and debugging purposes.
+// It is safe to call this method concurrently with Put and PutMany.
+// The blocks are not removed from the underlying blockstore.
+func (acc *Accumulator) ClearBlocks() {
+	acc.lk.Lock()
+	defer acc.lk.Unlock()
+
+	acc.cids = acc.cids[:0]
+}