Add functionalities for main function inputs (#681)

* Fixes for the generation of entry code, fixes of hints parsing

* Add modifications to the runner

* Add fixes for the entrycode generation

* Refactor main CLI, offset the hints indexes by entry code size, load arguments and initial gas to the memory

* Add available gas and user args (#677)

* Add parsing logic for input user args

* Add flags for available gas, input user args, writing args to memory

* Fix unit tests for user arguments parsing

* Lint the PR

* Add user args to hint context

* Refactor the code

* Fix unconditional append of ExternalWriteArgsToMemory, bug fixes in integration tests

* Add fixes of the call size calculation and include ExternalWriteArgsToMemory hint when gas present

* Add layouts for integration tests

* Add error handling

* Fixes in entry code generation

* Address changes mentioned in a discussion

* Add comment regarding writing to memory in a hint for the future reference in the integration tests with args

* Changes in calculations of the initial PC offset, CALL opcode offset incremented by mainFuncOffset, writing user args to the AP in the hint

* Turn back VM config to private field

* Add error handling on assign of `userArgs` to the initial scope

* Lint project

* Bump go version from 1.20 -> 1.21 (#678)

* Bump go version from 1.20 -> 1.21

* Update golangci-lint

* Simplify the Makefile

* Correction in the makefile

* Fix the integration tests

* Fixes in the runner

* Fixes in the runner

* Fix the unit tests, uncomment pythonVm execution in integration tests, code cleanups

* Add writing tokens gas cost to memory

* Proper builtins initialization for cairo mode

* Address comments in the PR

* Fix bugs regarding dicts

* Remove prints

* Fixes of the last tests for the dicts

* Add dict_non_squashed dir to the integration tests

* Add checks for the matching args size, rename files, modify the integration tests pipeline

* Almost all pass

* Fix lint and unit tests

* Fix loading gas to the memory as an argument

* Fix run for tensor__small.cairo

* Bring back cairo0 integration tests

* Code refactoring, add comments

* Fix the CI

Author: MaksymMalicki

cmd/cli/main.go

@@ -12,7 +12,6 @@ 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"
 )
 
@@ -125,7 +124,7 @@ func main() {
 					if proofmode {
 						runnerMode = runner.ProofModeZero
 					}
-					return runVM(*program, proofmode, maxsteps, entrypointOffset, collectTrace, traceLocation, buildMemory, memoryLocation, layoutName, airPublicInputLocation, airPrivateInputLocation, hints, runnerMode, nil)
+					return runVM(*program, proofmode, maxsteps, entrypointOffset, collectTrace, traceLocation, buildMemory, memoryLocation, layoutName, airPublicInputLocation, airPrivateInputLocation, hints, runnerMode, nil, 0)
 				},
 			},
 			{
@@ -217,27 +216,19 @@ func main() {
 					if err != nil {
 						return fmt.Errorf("cannot load program: %w", err)
 					}
-					program, hints, err := runner.AssembleProgram(cairoProgram)
+					userArgs, err := starknet.ParseCairoProgramArgs(args)
+					if err != nil {
+						return fmt.Errorf("cannot parse args: %w", err)
+					}
+					program, hints, userArgs, err := runner.AssembleProgram(cairoProgram, userArgs, availableGas)
 					if err != nil {
 						return fmt.Errorf("cannot assemble program: %w", err)
 					}
 					runnerMode := runner.ExecutionModeCairo
 					if proofmode {
 						runnerMode = runner.ProofModeCairo
 					}
-					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)
+					return runVM(program, proofmode, maxsteps, entrypointOffset, collectTrace, traceLocation, buildMemory, memoryLocation, layoutName, airPublicInputLocation, airPrivateInputLocation, hints, runnerMode, userArgs, availableGas)
 				},
 			},
 		},
@@ -264,9 +255,10 @@ func runVM(
 	hints map[uint64][]hinter.Hinter,
 	runnerMode runner.RunnerMode,
 	userArgs []starknet.CairoFuncArgs,
+	availableGas uint64,
 ) error {
 	fmt.Println("Running....")
-	runner, err := runner.NewRunner(&program, hints, runnerMode, collectTrace, maxsteps, layoutName, userArgs)
+	runner, err := runner.NewRunner(&program, hints, runnerMode, collectTrace, maxsteps, layoutName, userArgs, availableGas)
 	if err != nil {
 		return fmt.Errorf("cannot create runner: %w", err)
 	}

integration_tests/cairo_1_programs/with_input/array_input_sum.cairo renamed to integration_tests/cairo_1_programs/with_input/array_input_sum__small.cairo

@@ -66,7 +66,7 @@ func (f *Filter) filtered(testFile string) bool {
 	return false
 }
 
-func runAndTestFile(t *testing.T, path string, name string, benchmarkMap map[string][3]int, benchmark bool, errorExpected bool, zero bool) {
+func runAndTestFile(t *testing.T, path string, name string, benchmarkMap map[string][3]int, benchmark bool, errorExpected bool, zero bool, inputArgs string) {
 	t.Logf("testing: %s\n", path)
 	compiledOutput, err := compileCairoCode(path, zero)
 	if err != nil {
@@ -75,7 +75,7 @@ func runAndTestFile(t *testing.T, path string, name string, benchmarkMap map[str
 	}
 	layout := getLayoutFromFileName(path)
 
-	elapsedGo, traceFile, memoryFile, _, err := runVm(compiledOutput, layout, zero)
+	elapsedGo, traceFile, memoryFile, _, err := runVm(compiledOutput, layout, zero, inputArgs)
 	if errorExpected {
 		assert.Error(t, err, path)
 		writeToFile(path)
@@ -92,7 +92,7 @@ func runAndTestFile(t *testing.T, path string, name string, benchmarkMap map[str
 	if zero {
 		rustVmFilePath = compiledOutput
 	}
-	elapsedRs, rsTraceFile, rsMemoryFile, err := runRustVm(rustVmFilePath, layout, zero)
+	elapsedRs, rsTraceFile, rsMemoryFile, err := runRustVm(rustVmFilePath, layout, zero, inputArgs)
 	if errorExpected {
 		// we let the code go on so that we can check if the go vm also raises an error
 		assert.Error(t, err, path)
@@ -171,16 +171,28 @@ func TestCairoFiles(t *testing.T) {
 	if err != nil {
 		panic(fmt.Errorf("failed to open file: %w", err))
 	}
+
 	file.Close()
-	roots := []struct {
+	type TestCase struct {
 		path string
 		zero bool
-	}{
+	}
+	roots := []TestCase{
 		{"./cairo_zero_hint_tests/", true},
 		{"./cairo_zero_file_tests/", true},
 		{"./builtin_tests/", true},
 		// {"./cairo_1_programs/", false},
 		// {"./cairo_1_programs/dict_non_squashed", false},
+		// {"./cairo_1_programs/with_input", false},
+	}
+
+	// inputArgsMap is used to provide input arguments to the tests that require them. Whenever the args are needed for the new files, they can simply be added here.
+	inputArgsMap := map[string]string{
+		"cairo_1_programs/with_input/array_input_sum__small.cairo": "2 [111 222 333] 1 [444 555 666 777]",
+		"cairo_1_programs/with_input/array_length__small.cairo":    "[1 2 3 4 5 6] [7 8 9 10]",
+		"cairo_1_programs/with_input/branching.cairo":              "123",
+		"cairo_1_programs/with_input/dict_with_input__small.cairo": "[1 2 3 4]",
+		"cairo_1_programs/with_input/tensor__small.cairo":          "[1 4] [1 5]",
 	}
 
 	// filter is for debugging purposes
@@ -211,22 +223,19 @@ func TestCairoFiles(t *testing.T) {
 			if !filter.filtered(name) {
 				continue
 			}
-
+			inputArgs := inputArgsMap[path]
 			// we run tests concurrently if we don't need benchmarks
 			if !*zerobench {
 				sem <- struct{}{} // acquire a semaphore slot
 				wg.Add(1)
 
-				go func(path, name string, root struct {
-					path string
-					zero bool
-				}) {
+				go func(path, name string, root TestCase, inputArgs string) {
 					defer wg.Done()
 					defer func() { <-sem }() // release the semaphore slot when done
-					runAndTestFile(t, path, name, benchmarkMap, *zerobench, errorExpected, root.zero)
-				}(path, name, root)
+					runAndTestFile(t, path, name, benchmarkMap, *zerobench, errorExpected, root.zero, inputArgs)
+				}(path, name, root, inputArgs)
 			} else {
-				runAndTestFile(t, path, name, benchmarkMap, *zerobench, errorExpected, root.zero)
+				runAndTestFile(t, path, name, benchmarkMap, *zerobench, errorExpected, root.zero, inputArgs)
 			}
 		}
 	}
@@ -400,7 +409,7 @@ func runPythonVm(path, layout string) (time.Duration, string, string, error) {
 
 // given a path to a compiled cairo zero file, execute it using the
 // rust vm and return the trace and memory files location
-func runRustVm(path, layout string, zero bool) (time.Duration, string, string, error) {
+func runRustVm(path, layout string, zero bool, inputArgs string) (time.Duration, string, string, error) {
 	traceOutput := swapExtenstion(path, rsTraceSuffix)
 	memoryOutput := swapExtenstion(path, rsMemorySuffix)
 
@@ -418,9 +427,11 @@ func runRustVm(path, layout string, zero bool) (time.Duration, string, string, e
 		args = append(args, "--proof_mode")
 	}
 
-	binaryPath := "./../rust_vm_bin/cairo-lang/cairo1-run"
-	if zero {
-		binaryPath = "./../rust_vm_bin/cairo-vm-cli"
+	binaryPath := "./../rust_vm_bin/cairo-vm-cli"
+
+	if !zero {
+		args = append(args, "--args", inputArgs)
+		binaryPath = "./../rust_vm_bin/cairo-lang/cairo1-run"
 	}
 	cmd := exec.Command(binaryPath, args...)
 
@@ -441,7 +452,7 @@ func runRustVm(path, layout string, zero bool) (time.Duration, string, string, e
 
 // given a path to a compiled cairo zero file, execute
 // it using our vm
-func runVm(path, layout string, zero bool) (time.Duration, string, string, string, error) {
+func runVm(path, layout string, zero bool, inputArgs string) (time.Duration, string, string, string, error) {
 	traceOutput := swapExtenstion(path, traceSuffix)
 	memoryOutput := swapExtenstion(path, memorySuffix)
 
@@ -471,6 +482,8 @@ func runVm(path, layout string, zero bool) (time.Duration, string, string, strin
 			layout,
 			"--available_gas",
 			"9999999",
+			"--args",
+			inputArgs,
 		}
 	}
 	args = append(args, path)

integration_tests/cairo_1_programs/with_input/array_length.cairo renamed to integration_tests/cairo_1_programs/with_input/array_length__small.cairo

@@ -1937,30 +1937,75 @@ func (hint *ExternalWriteArgsToMemory) String() string {
 }
 
 func (hint *ExternalWriteArgsToMemory) Execute(vm *VM.VirtualMachine, ctx *hinter.HintRunnerContext) error {
-	userArgsVar, err := ctx.ScopeManager.GetVariableValue("userArgs")
+	userArgs, err := hinter.GetVariableAs[[]starknet.CairoFuncArgs](&ctx.ScopeManager, "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")
+	// The apOffset is the AP correction, which represents the memory slots taken up by the values created by the entry code instructions.
+	// It is calculated in the `getNewHintRunnerContext()` method.
+	apOffset, err := hinter.GetVariableAs[uint64](&ctx.ScopeManager, "apOffset")
+	if err != nil {
+		return fmt.Errorf("get ap offset: %v", err)
 	}
+	apOffset += vm.Context.Ap
 	for _, arg := range userArgs {
 		if arg.Single != nil {
 			mv := mem.MemoryValueFromFieldElement(arg.Single)
-			err := vm.Memory.Write(1, vm.Context.Ap, &mv)
+			err := vm.Memory.Write(1, apOffset, &mv)
 			if err != nil {
 				return fmt.Errorf("write single arg: %v", err)
 			}
+			apOffset++
 		} else if arg.Array != nil {
+			// The array is stored in memory as follows:
+			// Each array gets assigned a new segment (the pointer is stored in the arrayBase).
+			// arrayBase and arrayEnd pointers are written to the Execution Segment consecutively.
+			// Then, the array elements are written to the newly created array segment.
 			arrayBase := vm.Memory.AllocateEmptySegment()
 			mv := mem.MemoryValueFromMemoryAddress(&arrayBase)
-			err := vm.Memory.Write(1, vm.Context.Ap, &mv)
+			err := vm.Memory.Write(1, apOffset, &mv)
 			if err != nil {
 				return fmt.Errorf("write array base: %v", err)
 			}
-			// TODO: Implement array writing
+			apOffset++
+			arrayEnd := arrayBase
+			for _, val := range arg.Array {
+				mv := mem.MemoryValueFromFieldElement(&val)
+				err := vm.Memory.Write(arrayEnd.SegmentIndex, arrayEnd.Offset, &mv)
+				if err != nil {
+					return fmt.Errorf("write array element: %v", err)
+				}
+				arrayEnd.Offset += 1
+			}
+			mv = mem.MemoryValueFromMemoryAddress(&arrayEnd)
+			err = vm.Memory.Write(1, apOffset, &mv)
+			if err != nil {
+				return fmt.Errorf("write array end: %v", err)
+			}
+			apOffset++
 		}
 	}
 	return nil
 }
+
+type ExternalWriteGasToMemory struct{}
+
+func (hint *ExternalWriteGasToMemory) String() string {
+	return "ExternalWriteGasToMemory"
+}
+
+func (hint *ExternalWriteGasToMemory) Execute(vm *VM.VirtualMachine, ctx *hinter.HintRunnerContext) error {
+	// ExternalWriteGasToMemory is a separate hint, that writes the gas value to the memory.
+	// The gas value is written to the memory cell reserved by the instruction generated in entry code, which is dependent on the ordering of builtins list.
+	// Therefore the writing of the gas value to the memory is done in a separate hint.
+	gas, err := hinter.GetVariableAs[uint64](&ctx.ScopeManager, "gas")
+	if err != nil {
+		return fmt.Errorf("get gas: %v", err)
+	}
+	gasVal := mem.MemoryValueFromUint(gas)
+	err = vm.Memory.Write(1, vm.Context.Ap, &gasVal)
+	if err != nil {
+		return fmt.Errorf("write gas: %v", err)
+	}
+	return nil
+}

integration_tests/cairo_1_programs/with_input/dict_with_input.cairo renamed to integration_tests/cairo_1_programs/with_input/dict_with_input__small.cairo

@@ -4,7 +4,6 @@ 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"
 )
 
@@ -15,19 +14,14 @@ type HintRunner struct {
 	hints map[uint64][]h.Hinter
 }
 
-func NewHintRunner(hints map[uint64][]h.Hinter, userArgs []starknet.CairoFuncArgs) HintRunner {
-	context := *h.InitializeDefaultContext()
-	if userArgs != nil {
-		err := context.ScopeManager.AssignVariable("userArgs", userArgs)
-		// Error handling: this condition should never be true, since the context was initialized above
-		if err != nil {
-			panic(fmt.Errorf("assign userArgs: %v", err))
-		}
+func NewHintRunner(hints map[uint64][]h.Hinter, newHintRunnerContext *h.HintRunnerContext) HintRunner {
+	if newHintRunnerContext == nil {
+		newHintRunnerContext = h.InitializeDefaultContext()
 	}
 	return HintRunner{
 		// Context for certain hints that require it. Each manager is
 		// initialized only when required by the hint
-		context: context,
+		context: *newHintRunnerContext,
 		hints:   hints,
 	}
 }