add simulateTransaction endpoint

api/jsonrpc/client.go

@@ -235,3 +235,30 @@ func Wait(ctx context.Context, interval time.Duration, check func(ctx context.Co
 	}
 	return ctx.Err()
 }
+
+func (cli *JSONRPCClient) SimulateActions(ctx context.Context, actions chain.Actions, actor codec.Address) ([]SimulateActionResult, error) {
+	args := &SimulatActionsArgs{
+		Actor: actor,
+	}
+
+	for _, action := range actions {
+		marshaledAction, err := chain.MarshalTyped(action)
+		if err != nil {
+			return nil, err
+		}
+		args.Actions = append(args.Actions, marshaledAction)
+	}
+
+	resp := new(SimulateActionsReply)
+	err := cli.requester.SendRequest(
+		ctx,
+		"simulateActions",
+		args,
+		resp,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return resp.ActionResults, nil
+}

api/jsonrpc/server.go

@@ -18,6 +18,7 @@ import (
 	"github.com/ava-labs/hypersdk/codec"
 	"github.com/ava-labs/hypersdk/consts"
 	"github.com/ava-labs/hypersdk/fees"
+	"github.com/ava-labs/hypersdk/state"
 	"github.com/ava-labs/hypersdk/state/tstate"
 )
 
@@ -230,3 +231,72 @@ func (j *JSONRPCServer) Execute(
 
 	return nil
 }
+
+type SimulatActionsArgs struct {
+	Actions []codec.Bytes `json:"actions"`
+	Actor   codec.Address `json:"actor"`
+}
+
+type SimulateActionResult struct {
+	Output    codec.Bytes `json:"output"`
+	StateKeys state.Keys  `json:"stateKeys"`
+}
+
+type SimulateActionsReply struct {
+	ActionResults []SimulateActionResult `json:"actionresults"`
+}
+
+func (j *JSONRPCServer) SimulateActions(
+	req *http.Request,
+	args *SimulatActionsArgs,
+	reply *SimulateActionsReply,
+) error {
+	ctx, span := j.vm.Tracer().Start(req.Context(), "JSONRPCServer.SimulateActions")
+	defer span.End()
+
+	actionRegistry := j.vm.ActionRegistry()
+	var actions chain.Actions
+	for _, actionBytes := range args.Actions {
+		actionsReader := codec.NewReader(actionBytes, len(actionBytes))
+		action, err := (*actionRegistry).Unmarshal(actionsReader)
+		if err != nil {
+			return err
+		}
+		if !actionsReader.Empty() {
+			return errors.New("tx has extra bytes")
+		}
+		actions = append(actions, action)
+	}
+	if len(actions) == 0 {
+		return errors.New("simulateAction expects at least a single action, none found")
+	}
+	currentState, err := j.vm.ImmutableState(ctx)
+	if err != nil {
+		return err
+	}
+
+	recorder := state.NewRecorder(currentState)
+
+	currentTime := time.Now().UnixMilli()
+	for _, action := range actions {
+		actionOutput, err := action.Execute(ctx, j.vm.Rules(currentTime), recorder, currentTime, args.Actor, ids.Empty)
+
+		var actionResult SimulateActionResult
+		if actionOutput == nil {
+			actionResult.Output = []byte{}
+		} else {
+			actionResult.Output, err = chain.MarshalTyped(actionOutput)
+			if err != nil {
+				return fmt.Errorf("failed to marshal output: %w", err)
+			}
+		}
+		if err != nil {
+			return err
+		}
+		actionResult.StateKeys = recorder.GetStateKeys()
+		reply.ActionResults = append(reply.ActionResults, actionResult)
+		// create another recorder to recored the next action.
+		recorder = state.NewRecorder(recorder)
+	}
+	return nil
+}

examples/vmwithcontracts/actions/call.go

@@ -21,7 +21,10 @@ import (
 
 var _ chain.Action = (*Call)(nil)
 
-const MaxCallDataSize = units.MiB
+const (
+	MaxCallDataSize    = units.MiB
+	MaxResultSizeLimit = units.MiB
+)
 
 type StateKeyPermission struct {
 	Key        string
@@ -68,7 +71,7 @@ func (t *Call) Execute(
 	actor codec.Address,
 	_ ids.ID,
 ) (codec.Typed, error) {
-	resutBytes, err := t.r.CallContract(ctx, &runtime.CallInfo{
+	callInfo := &runtime.CallInfo{
 		Contract:     t.ContractAddress,
 		Actor:        actor,
 		State:        &storage.ContractStateManager{Mutable: mu},
@@ -77,11 +80,13 @@ func (t *Call) Execute(
 		Timestamp:    uint64(timestamp),
 		Fuel:         t.Fuel,
 		Value:        t.Value,
-	})
+	}
+	resultBytes, err := t.r.CallContract(ctx, callInfo)
 	if err != nil {
 		return nil, err
 	}
-	return &Result{Value: resutBytes}, nil
+	consumedFuel := t.Fuel - callInfo.RemainingFuel()
+	return &Result{Value: resultBytes, ConsumedFuel: consumedFuel}, nil
 }
 
 func (t *Call) ComputeUnits(chain.Rules) uint64 {
@@ -134,9 +139,16 @@ func (*Call) ValidRange(chain.Rules) (int64, int64) {
 }
 
 type Result struct {
-	Value []byte `serialize:"true" json:"value"`
+	Value        []byte `serialize:"true" json:"value"`
+	ConsumedFuel uint64 `serialize:"true" json:"consumedfuel"`
 }
 
 func (*Result) GetTypeID() uint8 {
 	return mconsts.ResultOutputID
 }
+
+// Size is the number of bytes it takes to represent this [Action]. This is used to preallocate
+// memory during encoding and to charge bandwidth fees.
+func (r *Result) Size() int {
+	return consts.Uint64Len + consts.Uint32Len + len(r.Value)
+}

examples/vmwithcontracts/cmd/vmwithcontracts-cli/cmd/action.go

@@ -5,6 +5,8 @@ package cmd
 
 import (
 	"context"
+	"errors"
+	"fmt"
 	"os"
 
 	"github.com/near/borsh-go"
@@ -15,6 +17,7 @@ import (
 	"github.com/ava-labs/hypersdk/cli/prompt"
 	"github.com/ava-labs/hypersdk/codec"
 	"github.com/ava-labs/hypersdk/examples/vmwithcontracts/actions"
+	"github.com/ava-labs/hypersdk/examples/vmwithcontracts/vm"
 	"github.com/ava-labs/hypersdk/utils"
 )
 
@@ -141,18 +144,34 @@ var callCmd = &cobra.Command{
 			ContractAddress: contractAddress,
 			Value:           amount,
 			Function:        function,
+			Fuel:            uint64(1000000000),
 		}
 
-		specifiedStateKeysSet, fuel, err := bcli.Simulate(ctx, *action, priv.Address)
+		actionSimulationResults, err := cli.SimulateActions(ctx, chain.Actions{action}, priv.Address)
 		if err != nil {
 			return err
 		}
+		if len(actionSimulationResults) != 1 {
+			return fmt.Errorf("unexpected number of returned actions. One action expected, %d returned", len(actionSimulationResults))
+		}
+		actionSimulationResult := actionSimulationResults[0]
+
+		rtx := codec.NewReader(actionSimulationResult.Output, len(actionSimulationResult.Output))
+
+		simulationResultOutput, err := (*vm.OutputParser).Unmarshal(rtx)
+		if err != nil {
+			return err
+		}
+		simulationResult, ok := simulationResultOutput.(*actions.Result)
+		if !ok {
+			return errors.New("returned output from SimulateActions was not actions.Result")
+		}
 
-		action.SpecifiedStateKeys = make([]actions.StateKeyPermission, 0, len(specifiedStateKeysSet))
-		for key, value := range specifiedStateKeysSet {
+		action.SpecifiedStateKeys = make([]actions.StateKeyPermission, 0, len(actionSimulationResult.StateKeys))
+		for key, value := range actionSimulationResult.StateKeys {
 			action.SpecifiedStateKeys = append(action.SpecifiedStateKeys, actions.StateKeyPermission{Key: key, Permission: value})
 		}
-		action.Fuel = fuel
+		action.Fuel = simulationResult.ConsumedFuel
 
 		// Confirm action
 		cont, err := prompt.Continue()

examples/vmwithcontracts/vm/client.go

@@ -5,20 +5,17 @@ package vm
 
 import (
 	"context"
-	"encoding/hex"
 	"encoding/json"
 	"strings"
 	"time"
 
 	"github.com/ava-labs/hypersdk/api/jsonrpc"
 	"github.com/ava-labs/hypersdk/chain"
 	"github.com/ava-labs/hypersdk/codec"
-	"github.com/ava-labs/hypersdk/examples/vmwithcontracts/actions"
 	"github.com/ava-labs/hypersdk/examples/vmwithcontracts/consts"
 	"github.com/ava-labs/hypersdk/examples/vmwithcontracts/storage"
 	"github.com/ava-labs/hypersdk/genesis"
 	"github.com/ava-labs/hypersdk/requester"
-	"github.com/ava-labs/hypersdk/state"
 	"github.com/ava-labs/hypersdk/utils"
 )
 
@@ -137,26 +134,3 @@ func CreateParser(genesisBytes []byte) (chain.Parser, error) {
 	}
 	return NewParser(&genesis), nil
 }
-
-func (cli *JSONRPCClient) Simulate(ctx context.Context, callTx actions.Call, actor codec.Address) (state.Keys, uint64, error) {
-	resp := new(SimulateCallTxReply)
-	err := cli.requester.SendRequest(
-		ctx,
-		"simulateCallContractTx",
-		&SimulateCallTxArgs{CallTx: callTx, Actor: actor},
-		resp,
-	)
-	if err != nil {
-		return nil, 0, err
-	}
-	result := state.Keys{}
-	for _, entry := range resp.StateKeys {
-		hexBytes, err := hex.DecodeString(entry.HexKey)
-		if err != nil {
-			return nil, 0, err
-		}
-
-		result.Add(string(hexBytes), state.Permissions(entry.Permissions))
-	}
-	return result, resp.FuelConsumed, nil
-}