Add available gas and user args

cmd/cli/main.go

@@ -12,6 +12,7 @@ import (
 	"github.com/NethermindEth/cairo-vm-go/pkg/parsers/starknet"
 	zero "github.com/NethermindEth/cairo-vm-go/pkg/parsers/zero"
 	"github.com/NethermindEth/cairo-vm-go/pkg/runner"
+	"github.com/consensys/gnark-crypto/ecc/stark-curve/fp"
 	"github.com/urfave/cli/v2"
 )
 
@@ -26,6 +27,8 @@ func main() {
 	var layoutName string
 	var airPublicInputLocation string
 	var airPrivateInputLocation string
+	var args string
+	var availableGas uint64
 	app := &cli.App{
 		Name:                 "cairo-vm",
 		Usage:                "A cairo virtual machine",
@@ -122,7 +125,7 @@ func main() {
 					if proofmode {
 						runnerMode = runner.ProofModeCairo0
 					}
-					return runVM(*program, proofmode, maxsteps, entrypointOffset, collectTrace, traceLocation, buildMemory, memoryLocation, layoutName, airPublicInputLocation, airPrivateInputLocation, hints, runnerMode)
+					return runVM(*program, proofmode, maxsteps, entrypointOffset, collectTrace, traceLocation, buildMemory, memoryLocation, layoutName, airPublicInputLocation, airPrivateInputLocation, hints, runnerMode, nil)
 				},
 			},
 			{
@@ -191,6 +194,18 @@ func main() {
 						Required:    false,
 						Destination: &airPrivateInputLocation,
 					},
+					&cli.StringFlag{
+						Name:        "args",
+						Usage:       "input arguments for the `main` function in the cairo progran",
+						Required:    false,
+						Destination: &args,
+					},
+					&cli.Uint64Flag{
+						Name:        "available_gas",
+						Usage:       "available gas for the VM execution",
+						Required:    false,
+						Destination: &availableGas,
+					},
 				},
 				Action: func(ctx *cli.Context) error {
 					pathToFile := ctx.Args().Get(0)
@@ -210,7 +225,19 @@ func main() {
 					if proofmode {
 						runnerMode = runner.ProofModeCairo1
 					}
-					return runVM(program, proofmode, maxsteps, entrypointOffset, collectTrace, traceLocation, buildMemory, memoryLocation, layoutName, airPublicInputLocation, airPrivateInputLocation, hints, runnerMode)
+					userArgs, err := starknet.ParseCairoProgramArgs(args)
+					if err != nil {
+						return fmt.Errorf("cannot parse args: %w", err)
+					}
+					if availableGas > 0 {
+						// The first argument is the available gas
+						availableGasArg := starknet.CairoFuncArgs{
+							Single: new(fp.Element).SetUint64(availableGas),
+							Array:  nil,
+						}
+						userArgs = append([]starknet.CairoFuncArgs{availableGasArg}, userArgs...)
+					}
+					return runVM(program, proofmode, maxsteps, entrypointOffset, collectTrace, traceLocation, buildMemory, memoryLocation, layoutName, airPublicInputLocation, airPrivateInputLocation, hints, runnerMode, userArgs)
 				},
 			},
 		},
@@ -236,9 +263,10 @@ func runVM(
 	airPrivateInputLocation string,
 	hints map[uint64][]hinter.Hinter,
 	runnerMode runner.RunnerMode,
+	userArgs []starknet.CairoFuncArgs,
 ) error {
 	fmt.Println("Running....")
-	runner, err := runner.NewRunner(&program, hints, runnerMode, collectTrace, maxsteps, layoutName)
+	runner, err := runner.NewRunner(&program, hints, runnerMode, collectTrace, maxsteps, layoutName, userArgs)
 	if err != nil {
 		return fmt.Errorf("cannot create runner: %w", err)
 	}

integration_tests/cairo_vm_test.go

@@ -459,16 +459,18 @@ func runVm(path, layout string, zero bool) (time.Duration, string, string, strin
 	}
 	args := []string{
 		cliCommand,
-		"--proofmode",
+		// "--proofmode",
 		"--tracefile",
 		traceOutput,
 		"--memoryfile",
 		memoryOutput,
 		"--layout",
 		layout,
-		path,
 	}
-
+	if !zero {
+		args = append(args, "--available_gas", "9999999")
+	}
+	args = append(args, path)
 	cmd := exec.Command(
 		"../bin/cairo-vm",
 		args...,

pkg/hintrunner/core/hint.go

@@ -1929,3 +1929,38 @@ func (hint *FieldSqrt) Execute(vm *VM.VirtualMachine, _ *hinter.HintRunnerContex
 
 	return vm.Memory.WriteToAddress(&sqrtAddr, &sqrtVal)
 }
+
+type ExternalWriteArgsToMemory struct{}
+
+func (hint *ExternalWriteArgsToMemory) String() string {
+	return "ExternalWriteToMemory"
+}
+
+func (hint *ExternalWriteArgsToMemory) Execute(vm *VM.VirtualMachine, ctx *hinter.HintRunnerContext) error {
+	userArgsVar, err := ctx.ScopeManager.GetVariableValue("userArgs")
+	if err != nil {
+		return fmt.Errorf("get user args: %v", err)
+	}
+	userArgs, ok := userArgsVar.([]starknet.CairoFuncArgs)
+	if !ok {
+		return fmt.Errorf("expected user args to be a list of CairoFuncArgs")
+	}
+	for _, arg := range userArgs {
+		if arg.Single != nil {
+			mv := mem.MemoryValueFromFieldElement(arg.Single)
+			err := vm.Memory.Write(1, vm.Context.Ap-uint64(len(userArgs)), &mv)
+			if err != nil {
+				return fmt.Errorf("write single arg: %v", err)
+			}
+		} else if arg.Array != nil {
+			arrayBase := vm.Memory.AllocateEmptySegment()
+			mv := mem.MemoryValueFromMemoryAddress(&arrayBase)
+			err := vm.Memory.Write(1, vm.Context.Ap, &mv)
+			if err != nil {
+				return fmt.Errorf("write array base: %v", err)
+			}
+			// TODO: Implement array writing
+		}
+	}
+	return nil
+}

pkg/hintrunner/hintrunner.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	h "github.com/NethermindEth/cairo-vm-go/pkg/hintrunner/hinter"
+	"github.com/NethermindEth/cairo-vm-go/pkg/parsers/starknet"
 	VM "github.com/NethermindEth/cairo-vm-go/pkg/vm"
 )
 
@@ -14,11 +15,19 @@ type HintRunner struct {
 	hints map[uint64][]h.Hinter
 }
 
-func NewHintRunner(hints map[uint64][]h.Hinter) HintRunner {
+func NewHintRunner(hints map[uint64][]h.Hinter, userArgs []starknet.CairoFuncArgs) HintRunner {
+	context := *h.InitializeDefaultContext()
+	if userArgs != nil {
+		context = *h.SetContextWithScope(
+			map[string]any{
+				"userArgs": userArgs,
+			},
+		)
+	}
 	return HintRunner{
 		// Context for certain hints that require it. Each manager is
 		// initialized only when required by the hint
-		context: *h.InitializeDefaultContext(),
+		context: context,
 		hints:   hints,
 	}
 }

pkg/hintrunner/hintrunner_test.go

@@ -20,7 +20,7 @@ func TestExistingHint(t *testing.T) {
 
 	hr := NewHintRunner(map[uint64][]hinter.Hinter{
 		10: {&allocHint},
-	})
+	}, nil)
 
 	vm.Context.Pc = memory.MemoryAddress{
 		SegmentIndex: 0,
@@ -44,7 +44,7 @@ func TestNoHint(t *testing.T) {
 
 	hr := NewHintRunner(map[uint64][]hinter.Hinter{
 		10: {&allocHint},
-	})
+	}, nil)
 
 	vm.Context.Pc = memory.MemoryAddress{
 		SegmentIndex: 0,

pkg/parsers/starknet/starknet.go

@@ -4,6 +4,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"regexp"
+	"strings"
 
 	"github.com/NethermindEth/cairo-vm-go/pkg/vm/builtins"
 	"github.com/consensys/gnark-crypto/ecc/stark-curve/fp"
@@ -95,3 +97,41 @@ func StarknetProgramFromJSON(content json.RawMessage) (*StarknetProgram, error)
 	var starknet StarknetProgram
 	return &starknet, json.Unmarshal(content, &starknet)
 }
+
+type CairoFuncArgs struct {
+	Single *fp.Element
+	Array  []fp.Element
+}
+
+func ParseCairoProgramArgs(input string) ([]CairoFuncArgs, error) {
+	re := regexp.MustCompile(`\[[^\]]*\]|\S+`)
+	tokens := re.FindAllString(input, -1)
+	var result []CairoFuncArgs
+	for _, token := range tokens {
+		if single, err := new(fp.Element).SetString(token); err == nil {
+			result = append(result, CairoFuncArgs{
+				Single: single,
+				Array:  nil,
+			})
+		} else if strings.HasPrefix(token, "[") && strings.HasSuffix(token, "]") {
+			arrayStr := strings.Trim(token, "[]")
+			arrayParts := strings.Fields(arrayStr)
+			var array []fp.Element
+			for _, part := range arrayParts {
+				single, err := new(fp.Element).SetString(part)
+				if err != nil {
+					return nil, fmt.Errorf("invalid felt value in array: %v", err)
+				}
+				array = append(array, *single)
+			}
+			result = append(result, CairoFuncArgs{
+				Single: nil,
+				Array:  array,
+			})
+		} else {
+			return nil, fmt.Errorf("invalid token: %s", token)
+		}
+	}
+
+	return result, nil
+}

pkg/parsers/starknet/starknet_test.go

@@ -3,6 +3,7 @@ package starknet
 import (
 	"testing"
 
+	"github.com/consensys/gnark-crypto/ecc/stark-curve/fp"
 	"github.com/go-playground/validator/v10"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -170,3 +171,95 @@ func TestInvalidBuiltin(t *testing.T) {
 	_, err := StarknetProgramFromJSON(testData)
 	assert.Error(t, err)
 }
+
+func TestParseStarknetProgramArgs(t *testing.T) {
+	testCases := []struct {
+		name     string
+		args     string
+		expected []CairoFuncArgs
+	}{
+		{
+			name: "single arg",
+			args: "1",
+			expected: []CairoFuncArgs{
+				{
+					Single: new(fp.Element).SetUint64(1),
+					Array:  nil,
+				},
+			},
+		},
+		{
+			name: "single array arg",
+			args: "[1 2 3 4]",
+			expected: []CairoFuncArgs{
+				{
+					Single: nil,
+					Array: []fp.Element{
+						*new(fp.Element).SetUint64(1),
+						*new(fp.Element).SetUint64(2),
+						*new(fp.Element).SetUint64(3),
+						*new(fp.Element).SetUint64(4),
+					},
+				},
+			},
+		},
+		{
+			name: "mixed args",
+			args: "1 [2 3 4] 5 [6 7 8] [1] 9 9 [12341341234 0]",
+			expected: []CairoFuncArgs{
+				{
+					Single: new(fp.Element).SetUint64(1),
+					Array:  nil,
+				},
+				{
+					Single: nil,
+					Array: []fp.Element{
+						*new(fp.Element).SetUint64(2),
+						*new(fp.Element).SetUint64(3),
+						*new(fp.Element).SetUint64(4),
+					},
+				},
+				{
+					Single: new(fp.Element).SetUint64(5),
+					Array:  nil,
+				},
+				{
+					Single: nil,
+					Array: []fp.Element{
+						*new(fp.Element).SetUint64(6),
+						*new(fp.Element).SetUint64(7),
+						*new(fp.Element).SetUint64(8),
+					},
+				},
+				{
+					Single: nil,
+					Array: []fp.Element{
+						*new(fp.Element).SetUint64(1),
+					},
+				},
+				{
+					Single: new(fp.Element).SetUint64(9),
+					Array:  nil,
+				},
+				{
+					Single: new(fp.Element).SetUint64(9),
+					Array:  nil,
+				},
+				{
+					Single: nil,
+					Array: []fp.Element{
+						*new(fp.Element).SetUint64(12341341234),
+						*new(fp.Element).SetUint64(0),
+					},
+				},
+			},
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			args, err := ParseCairoProgramArgs(testCase.args)
+			require.NoError(t, err)
+			assert.Equal(t, testCase.expected, args)
+		})
+	}
+}