add simulateTransaction endpoint

api/jsonrpc/client.go

@@ -5,6 +5,7 @@ package jsonrpc
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"strings"
 	"time"
@@ -235,3 +236,55 @@ func Wait(ctx context.Context, interval time.Duration, check func(ctx context.Co
 	}
 	return ctx.Err()
 }
+
+type SimulatedActionResponse struct {
+	Output []byte
+	Error  error
+}
+
+type SimulateTransactionResponse struct {
+	SimulatedActions []SimulatedActionResponse
+	ReadKeys         []string
+	WriteKeys        []string
+	AllocateKeys     []string
+	BlockHeight      uint64
+}
+
+func (cli *JSONRPCClient) SimulateTransaction(ctx context.Context, txn []byte) (*SimulateTransactionResponse, error) {
+	args := &SimulateTransactionArgs{
+		Tx: txn,
+	}
+
+	resp := new(SimulateTransactionReply)
+	err := cli.requester.SendRequest(
+		ctx,
+		"simulateTransaction",
+		args,
+		resp,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if resp.Error != "" {
+		return nil, fmt.Errorf("failed to execute action: %s", resp.Error)
+	}
+
+	// copy the response from resp into the model SimulateTransactionResponse
+	output := SimulateTransactionResponse{
+		ReadKeys:     resp.ReadKeys,
+		WriteKeys:    resp.WriteKeys,
+		AllocateKeys: resp.AllocateKeys,
+		BlockHeight:  resp.BlockHeight,
+	}
+	for _, action := range resp.SimulatedActions {
+		entry := SimulatedActionResponse{
+			Output: action.Output,
+		}
+		if action.Error != nil {
+			entry.Error = errors.New(*action.Error)
+		}
+		output.SimulatedActions = append(output.SimulatedActions, entry)
+	}
+
+	return &output, 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"
 )
 
@@ -235,3 +236,96 @@ func (j *JSONRPCServer) Execute(
 
 	return nil
 }
+
+type SimulateTransactionArgs struct {
+	Tx []byte `json:"tx"`
+}
+
+type SimulatedAction struct {
+	Output []byte  `json:"output_b64"`
+	Error  *string `json:"error"`
+}
+
+type SimulateTransactionReply struct {
+	SimulatedActions []SimulatedAction `json:"simulatedActions"`
+	ReadKeys         []string          `json:"readKeys"`
+	WriteKeys        []string          `json:"writeKeys"`
+	AllocateKeys     []string          `json:"allocKeys"`
+	BlockHeight      uint64            `json:"blockheight"`
+	Error            string            `json:"error"`
+}
+
+type SimulationEnabledRules struct {
+	chain.Rules
+}
+
+func (SimulationEnabledRules) GetTransactionExecutionMode() chain.TransactionExecutionMode {
+	return chain.SimulatedTransactionExecution
+}
+
+func (j *JSONRPCServer) SimulateTransaction(
+	req *http.Request,
+	args *SimulateTransactionArgs,
+	reply *SimulateTransactionReply,
+) error {
+	ctx, span := j.vm.Tracer().Start(req.Context(), "JSONRPCServer.SimulateTransaction")
+	defer span.End()
+
+	if reply == nil {
+		return errors.New("SimulateTransaction was called with a nil reply object")
+	}
+
+	actionRegistry, authRegistry := j.vm.ActionRegistry(), j.vm.AuthRegistry()
+	rtx := codec.NewReader(args.Tx, consts.NetworkSizeLimit) // will likely be much smaller than this
+	tx, err := chain.UnmarshalTx(rtx, actionRegistry, authRegistry)
+	if err != nil {
+		return fmt.Errorf("%w: unable to unmarshal on public service", err)
+	}
+	if !rtx.Empty() {
+		return errors.New("tx has extra bytes")
+	}
+	actor := tx.Auth.Actor()
+
+	currentState, err := j.vm.ImmutableState(ctx)
+	if err != nil {
+		return err
+	}
+	reply.BlockHeight = j.vm.LastAcceptedBlock().Hght
+	recorder := state.NewRecorder(currentState)
+	simulationEnabledRules := SimulationEnabledRules{j.vm.Rules(tx.Base.Timestamp)}
+	for actionIdx, action := range tx.Actions {
+		actionOutput, err := action.Execute(ctx, simulationEnabledRules, recorder, tx.Base.Timestamp, actor, chain.CreateActionID(tx.ID(), uint8(actionIdx)))
+
+		var simAction SimulatedAction
+		if actionOutput == nil {
+			simAction.Output = []byte{}
+		} else {
+			simAction.Output, err = chain.MarshalTyped(actionOutput)
+			if err != nil {
+				return fmt.Errorf("failed to marshal output: %w", err)
+			}
+		}
+		if err != nil {
+			errString := err.Error()
+			simAction.Error = &errString
+		}
+
+		reply.SimulatedActions = append(reply.SimulatedActions, simAction)
+
+		if err != nil {
+			break
+		}
+	}
+	for key, perm := range recorder.GetStateKeys() {
+		if perm.Has(state.Read) {
+			reply.ReadKeys = append(reply.ReadKeys, key)
+		}
+		if perm.Has(state.Write) {
+			reply.WriteKeys = append(reply.WriteKeys, key)
+		}
+		if perm.Has(state.Allocate) {
+			reply.AllocateKeys = append(reply.AllocateKeys, key)
+		}
+	}
+	return nil
+}

chain/dependencies.go

@@ -25,6 +25,13 @@ type (
 	ActionRegistry *codec.TypeParser[Action]
 	OutputRegistry *codec.TypeParser[codec.Typed]
 	AuthRegistry   *codec.TypeParser[Auth]
+
+	TransactionExecutionMode int
+)
+
+const (
+	OnchainTransactionExecution TransactionExecutionMode = iota
+	SimulatedTransactionExecution
 )
 
 type Parser interface {
@@ -152,6 +159,8 @@ type Rules interface {
 	GetStorageValueWriteUnits() uint64 // per chunk
 
 	FetchCustom(string) (any, bool)
+
+	GetTransactionExecutionMode() TransactionExecutionMode // either OnchainTransactionExecution or SimulatedTransactionExecution
 }
 
 type MetadataManager interface {
@@ -229,8 +238,8 @@ type Action interface {
 	// Execute actually runs the [Action]. Any state changes that the [Action] performs should
 	// be done here.
 	//
-	// If any keys are touched during [Execute] that are not specified in [StateKeys], the transaction
-	// will revert and the max fee will be charged.
+	// If any keys are touched during [Execute] while running in [OnchainTransactionExecution] mode that
+	// are not specified in [StateKeys], the transaction will revert and the max fee will be charged.
 	//
 	// If [Execute] returns an error, execution will halt and any state changes will revert.
 	Execute(

examples/vmwithcontracts/actions/call.go

@@ -12,11 +12,11 @@ import (
 	"github.com/ava-labs/hypersdk/chain"
 	"github.com/ava-labs/hypersdk/codec"
 	"github.com/ava-labs/hypersdk/consts"
-	"github.com/ava-labs/hypersdk/examples/vmwithcontracts/storage"
 	"github.com/ava-labs/hypersdk/state"
 	"github.com/ava-labs/hypersdk/x/contracts/runtime"
 
 	mconsts "github.com/ava-labs/hypersdk/examples/vmwithcontracts/consts"
+	mstorage "github.com/ava-labs/hypersdk/examples/vmwithcontracts/storage"
 )
 
 var _ chain.Action = (*Call)(nil)
@@ -62,16 +62,23 @@ func (t *Call) StateKeys(_ codec.Address) state.Keys {
 
 func (t *Call) Execute(
 	ctx context.Context,
-	_ chain.Rules,
+	r chain.Rules,
 	mu state.Mutable,
 	timestamp int64,
 	actor codec.Address,
 	_ ids.ID,
 ) (codec.Typed, error) {
+	var limitStateKeys map[string]state.Permissions
+	if r.GetTransactionExecutionMode() == chain.OnchainTransactionExecution {
+		limitStateKeys = make(map[string]state.Permissions, len(t.SpecifiedStateKeys))
+		for _, statekey := range t.SpecifiedStateKeys {
+			limitStateKeys[statekey.Key] = statekey.Permission
+		}
+	}
 	resutBytes, err := t.r.CallContract(ctx, &runtime.CallInfo{
 		Contract:     t.ContractAddress,
 		Actor:        actor,
-		State:        &storage.ContractStateManager{Mutable: mu},
+		State:        mstorage.NewContractStateManager(mu, limitStateKeys),
 		FunctionName: t.Function,
 		Params:       t.CallData,
 		Timestamp:    uint64(timestamp),

examples/vmwithcontracts/storage/programs.go

@@ -17,6 +17,8 @@ import (
 	"github.com/ava-labs/hypersdk/x/contracts/runtime"
 )
 
+var ErrUnpermissionedKeyAccessed = errors.New("unpermissioned key accessed")
+
 // [accountStatePrefix] + [account]
 func accountStateKey(account codec.Address) (k []byte) {
 	k = make([]byte, 2+codec.AddressLen)
@@ -60,6 +62,14 @@ var _ runtime.StateManager = (*ContractStateManager)(nil)
 
 type ContractStateManager struct {
 	state.Mutable
+	limitStateKeys map[string]state.Permissions
+}
+
+func NewContractStateManager(mu state.Mutable, limitStateKeys map[string]state.Permissions) *ContractStateManager {
+	return &ContractStateManager{
+		Mutable:        mu,
+		limitStateKeys: limitStateKeys,
+	}
 }
 
 func (p *ContractStateManager) GetBalance(ctx context.Context, address codec.Address) (uint64, error) {
@@ -81,6 +91,9 @@ func (p *ContractStateManager) GetContractState(address codec.Address) state.Mut
 
 func (p *ContractStateManager) GetAccountContract(ctx context.Context, account codec.Address) (runtime.ContractID, error) {
 	key, _ := keys.Encode(AccountContractKey(account), 36)
+	if perm, has := p.limitStateKeys[string(key)]; has && !perm.Has(state.Read) {
+		return ids.Empty[:], ErrUnpermissionedKeyAccessed
+	}
 	result, err := p.GetValue(ctx, key)
 	if err != nil {
 		return ids.Empty[:], err
@@ -89,12 +102,18 @@ func (p *ContractStateManager) GetAccountContract(ctx context.Context, account c
 }
 
 func (p *ContractStateManager) GetContractBytes(ctx context.Context, contractID runtime.ContractID) ([]byte, error) {
+	if perm, has := p.limitStateKeys[string(contractID)]; has && !perm.Has(state.Read) {
+		return ids.Empty[:], ErrUnpermissionedKeyAccessed
+	}
 	return p.GetValue(ctx, contractID)
 }
 
 func (p *ContractStateManager) NewAccountWithContract(ctx context.Context, contractID runtime.ContractID, accountCreationData []byte) (codec.Address, error) {
 	newAddress := GetAddressForDeploy(0, accountCreationData)
 	key, _ := keys.Encode(AccountContractKey(newAddress), 36)
+	if perm, has := p.limitStateKeys[string(contractID)]; has && !perm.Has(state.Read) {
+		return codec.EmptyAddress, ErrUnpermissionedKeyAccessed
+	}
 	_, err := p.GetValue(ctx, key)
 	if err != nil && !errors.Is(err, database.ErrNotFound) {
 		return codec.EmptyAddress, err
@@ -107,6 +126,9 @@ func (p *ContractStateManager) NewAccountWithContract(ctx context.Context, contr
 
 func (p *ContractStateManager) SetAccountContract(ctx context.Context, account codec.Address, contractID runtime.ContractID) error {
 	key, _ := keys.Encode(AccountContractKey(account), 36)
+	if perm, has := p.limitStateKeys[string(key)]; has && !perm.Has(state.Write) && !perm.Has(state.Allocate) {
+		return ErrUnpermissionedKeyAccessed
+	}
 	return p.Insert(ctx, key, contractID)
 }
 

examples/vmwithcontracts/vm/server.go

@@ -101,7 +101,7 @@ func (j *JSONRPCServer) simulate(ctx context.Context, t actions.Call, actor code
 	if err != nil {
 		return nil, 0, err
 	}
-	recorder := storage.NewRecorder(currentState)
+	recorder := state.NewRecorder(currentState)
 	startFuel := uint64(1000000000)
 	callInfo := &runtime.CallInfo{
 		Contract:     t.ContractAddress,

genesis/rules.go

@@ -152,6 +152,10 @@ func (*Rules) FetchCustom(string) (any, bool) {
 	return nil, false
 }
 
+func (*Rules) GetTransactionExecutionMode() chain.TransactionExecutionMode {
+	return chain.OnchainTransactionExecution
+}
+
 type ImmutableRuleFactory struct {
 	Rules chain.Rules
 }

examples/vmwithcontracts/storage/recorder.go → state/recorder.go

@@ -1,26 +1,24 @@
 // Copyright (C) 2024, Ava Labs, Inc. All rights reserved.
 // See the file LICENSE for licensing terms.
 
-package storage
+package state
 
 import (
 	"context"
 	"errors"
 
 	"github.com/ava-labs/avalanchego/database"
 	"github.com/ava-labs/avalanchego/utils/set"
-
-	"github.com/ava-labs/hypersdk/state"
 )
 
 type Recorder struct {
-	State         state.Immutable
+	State         Immutable
 	changedValues map[string][]byte
 	ReadState     set.Set[string]
 	WriteState    set.Set[string]
 }
 
-func NewRecorder(db state.Immutable) *Recorder {
+func NewRecorder(db Immutable) *Recorder {
 	return &Recorder{State: db, changedValues: map[string][]byte{}}
 }
 
@@ -50,10 +48,10 @@ func (r *Recorder) GetValue(ctx context.Context, key []byte) (value []byte, err
 	return r.State.GetValue(ctx, key)
 }
 
-func (r *Recorder) GetStateKeys() state.Keys {
-	result := state.Keys{}
+func (r *Recorder) GetStateKeys() Keys {
+	result := Keys{}
 	for key := range r.ReadState {
-		result.Add(key, state.Read)
+		result.Add(key, Read)
 	}
 	for key := range r.WriteState {
 		if _, err := r.State.GetValue(context.Background(), []byte(key)); err != nil && errors.Is(err, database.ErrNotFound) {
@@ -62,9 +60,9 @@ func (r *Recorder) GetStateKeys() state.Keys {
 				continue
 			}
 			// wasn't found so needs to be allocated
-			result.Add(key, state.Allocate)
+			result.Add(key, Allocate)
 		}
-		result.Add(key, state.Write)
+		result.Add(key, Write)
 	}
 	return result
 }