Cairo Zero Parser

Makefile

@@ -1,4 +1,4 @@
-.PHONY: build clean test help
+.PHONY: build clean test help format staticcheck pre-commit
 
 BINARY_DIR := bin
 BINARY_NAME := cairo-vm
@@ -30,3 +30,11 @@ clean:
 test:
 	@echo "Running tests..."
 	@go test ./...
+
+format:
+	@gofumpt -l -w .
+
+staticcheck:
+	@staticcheck ./...
+
+pre-commit: format staticcheck build test clean

cmd/cli/main.go

@@ -7,7 +7,7 @@ import (
 
 func main() {
 	if len(os.Args) < 2 {
-        fmt.Println("Usage: cairo-vm <path_to_file>")
+		fmt.Println("Usage: cairo-vm <path_to_file>")
 		os.Exit(1)
 	}
 

go.mod

@@ -17,6 +17,7 @@ require (
 require (
 	github.com/consensys/gnark-crypto v0.11.1
 	github.com/go-playground/validator/v10 v10.4.1
+	github.com/go-test/deep v1.1.0
 	github.com/stretchr/testify v1.8.4
 	golang.org/x/exp v0.0.0-20230811145659-89c5cff77bcb
 )

go.sum

@@ -13,6 +13,8 @@ github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD87
 github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
 github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE=
 github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
+github.com/go-test/deep v1.1.0 h1:WOcxcdHcvdgThNXjw0t76K42FXTU7HpNQWHpA2HHNlg=
+github.com/go-test/deep v1.1.0/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE=
 github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
 github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
 github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=

pkg/parsers/starknet/hint.go

@@ -44,7 +44,7 @@ const (
 	FieldSqrtName                   HintName = "FieldSqrt"
 	DebugPrintName                  HintName = "DebugPrint"
 	AllocConstantSizeName           HintName = "AllocConstantSize"
-	//Name Deprecated hints
+	// Name Deprecated hints
 	AssertCurrentAccessIndicesIsEmptyName HintName = "AssertCurrentAccessIndicesIsEmpty"
 	AssertAllAccessesUsedName             HintName = "AssertAllAccessesUsed"
 	AssertAllKeysUsedName                 HintName = "AssertAllKeysUsed"

pkg/parsers/starknet/program.go → pkg/parsers/starknet/starknet.go

@@ -131,23 +131,23 @@ func (hints *Hints) MarshalJSON() ([]byte, error) {
 	return json.Marshal(rawHints)
 }
 
-type Program struct {
+type StarknetProgram struct {
 	// Prime is fixed to be 0x800000000000011000000000000000000000000000000000000000000000001 and wont fit in a f.Felt
 	Bytecode        []f.Element      `json:"bytecode"`
 	CompilerVersion string           `json:"compiler_version"`
 	EntryPoints     EntryPointByType `json:"entry_points_by_type"`
 	Hints           []Hints          `json:"hints" validate:"required"`
 }
 
-func ProgramFromFile(pathToFile string) (*Program, error) {
+func StarknetProgramFromFile(pathToFile string) (*StarknetProgram, error) {
 	content, error := os.ReadFile(pathToFile)
 	if error != nil {
 		return nil, error
 	}
-	return ProgramFromJSON(content)
+	return StarknetProgramFromJSON(content)
 }
 
-func ProgramFromJSON(content json.RawMessage) (*Program, error) {
-	var program Program
-	return &program, json.Unmarshal(content, &program)
+func StarknetProgramFromJSON(content json.RawMessage) (*StarknetProgram, error) {
+	var starknet StarknetProgram
+	return &starknet, json.Unmarshal(content, &starknet)
 }

pkg/parsers/starknet/program_test.go → pkg/parsers/starknet/starknet_test.go

@@ -14,9 +14,9 @@ func TestCompilerVersionParsing(t *testing.T) {
           "compiler_version": "2.1.0"
        }
     `)
-	program, err := ProgramFromJSON(testData)
+	starknet, err := StarknetProgramFromJSON(testData)
 	require.NoError(t, err)
-	assert.Equal(t, "2.1.0", program.CompilerVersion)
+	assert.Equal(t, "2.1.0", starknet.CompilerVersion)
 }
 
 func TestByteCodeParsing(t *testing.T) {
@@ -30,11 +30,10 @@ func TestByteCodeParsing(t *testing.T) {
           ]
        }
     `)
-	program, err := ProgramFromJSON(testData)
+	starknet, err := StarknetProgramFromJSON(testData)
 	require.NoError(t, err)
-	assert.Len(t, program.Bytecode, 4)
-	assert.Equal(t, "482680017ffa8000", program.Bytecode[2].Text(16))
-
+	assert.Len(t, starknet.Bytecode, 4)
+	assert.Equal(t, "482680017ffa8000", starknet.Bytecode[2].Text(16))
 }
 
 func TestEmptyEntryPointTypeParsing(t *testing.T) {
@@ -47,14 +46,13 @@ func TestEmptyEntryPointTypeParsing(t *testing.T) {
           }       
       }
     `)
-	program, err := ProgramFromJSON(testData)
+	starknet, err := StarknetProgramFromJSON(testData)
 	require.NoError(t, err)
 
-	entryPoints := program.EntryPoints
+	entryPoints := starknet.EntryPoints
 	assert.Empty(t, entryPoints.External)
 	assert.Empty(t, entryPoints.L1Handler)
 	assert.Empty(t, entryPoints.Constructor)
-
 }
 
 func TestEntryPointInfoParsing(t *testing.T) {
@@ -83,10 +81,10 @@ func TestEntryPointInfoParsing(t *testing.T) {
           }       
       }
     `)
-	program, err := ProgramFromJSON(testData)
+	starknet, err := StarknetProgramFromJSON(testData)
 	require.NoError(t, err)
 
-	entryPoints := program.EntryPoints
+	entryPoints := starknet.EntryPoints
 	assert.Len(t, entryPoints.External, 1)
 
 	entryPointInfo := entryPoints.External[0]
@@ -135,18 +133,18 @@ func TestHintsParsing(t *testing.T) {
             ]
         }
     `)
-	program, err := ProgramFromJSON(testData)
+	starknet, err := StarknetProgramFromJSON(testData)
 	require.NoError(t, err)
 
-	hints := program.Hints
+	hints := starknet.Hints
 	assert.Len(t, hints, 5)
 
 	hint := hints[0].Hints[0]
 	assert.Equal(t, hint.Name, TestLessThanOrEqualName)
 	_, ok := hint.Args.(*TestLessThanOrEqual)
 	assert.True(t, ok)
 
-	assert.NoError(t, v.Struct(program))
+	assert.NoError(t, v.Struct(starknet))
 }
 
 func TestInvalidBuiltin(t *testing.T) {
@@ -167,7 +165,6 @@ func TestInvalidBuiltin(t *testing.T) {
           }       
       }
     `)
-	_, err := ProgramFromJSON(testData)
+	_, err := StarknetProgramFromJSON(testData)
 	assert.Error(t, err)
-
 }

pkg/parsers/zero/zero.go

@@ -0,0 +1,67 @@
+package zero
+
+import (
+	"encoding/json"
+	"os"
+)
+
+type ZeroProgram struct {
+	Attributes []string          `json:"attributes"`
+	Builtins   map[string]int64  `json:"builtins"`
+	Code       string            `json:"code"`
+	DebugInfo  DebugInfo         `json:"debug_info"`
+	Prime      string            `json:"prime"`
+	Version    string            `json:"version"`
+	Hints      map[string][]Hint `json:"hints"`
+}
+
+type DebugInfo struct {
+	InstructionOffsets []int64 `json:"instruction_offsets"`
+	SourceCode         string  `json:"source_code"`
+	SourcePath         string  `json:"source_path"`
+}
+
+type Hint struct {
+	AccessibleScopes []string         `json:"accessible_scopes"`
+	Code             string           `json:"code"`
+	FlowTrackingData FlowTrackingData `json:"flow_tracking_data"`
+}
+
+type FlowTrackingData struct {
+	ApTracking   ApTracking             `json:"ap_tracking"`
+	ReferenceIds map[string]interface{} `json:"reference_ids"`
+}
+
+type ApTracking struct {
+	Group  int `json:"group"`
+	Offset int `json:"offset"`
+}
+
+func (z ZeroProgram) MarshalToFile(filepath string) error {
+	// Marshal Output struct into JSON bytes
+	data, err := json.MarshalIndent(z, "", "    ")
+	if err != nil {
+		return err
+	}
+
+	// Write JSON bytes to file
+	err = os.WriteFile(filepath, data, 0644)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func ZeroProgramFromFile(filepath string) (zero *ZeroProgram, err error) {
+	content, err := os.ReadFile(filepath)
+	if err != nil {
+		return
+	}
+	return ZeroProgramFromJSON(content)
+}
+
+func ZeroProgramFromJSON(content json.RawMessage) (*ZeroProgram, error) {
+	var zero ZeroProgram
+	return &zero, json.Unmarshal(content, &zero)
+}

pkg/parsers/zero/zero_test.go

@@ -0,0 +1,105 @@
+package zero
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestZeroParse(t *testing.T) {
+	tests := []struct {
+		name     string
+		jsonData string
+		expected ZeroProgram
+	}{
+		{
+			name: "Attributes field",
+			jsonData: `
+				{
+					"attributes": ["attr1", "attr2"]
+				}`,
+			expected: ZeroProgram{
+				Attributes: []string{"attr1", "attr2"},
+			},
+		},
+		{
+			name: "Builtins field",
+			jsonData: `
+				{
+					"builtins": {"builtin1": 1, "builtin2": 2}
+				}`,
+			expected: ZeroProgram{
+				Builtins: map[string]int64{"builtin1": 1, "builtin2": 2},
+			},
+		},
+		{
+			name: "Code field",
+			jsonData: `
+				{
+					"code": "some code sample"
+				}`,
+			expected: ZeroProgram{
+				Code: "some code sample",
+			},
+		},
+		{
+			name: "Version field",
+			jsonData: `
+				{
+					"version": "0.12.2"
+				}`,
+			expected: ZeroProgram{
+				Version: "0.12.2",
+			},
+		},
+		{
+			name: "Prime field",
+			jsonData: `
+				{
+					"prime": "0x800000000000011000000000000000000000000000000000000000000000001"
+				}`,
+			expected: ZeroProgram{
+				Prime: "0x800000000000011000000000000000000000000000000000000000000000001",
+			},
+		},
+		{
+			name: "Hints field",
+			jsonData: `
+				{
+					"hints": {
+						"0": [
+							{
+								"accessible_scopes": [
+									"starkware.cairo.common.math",
+									"starkware.cairo.common.math.assert_not_equal"
+								],
+								"code": "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n    isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n    ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n    f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'"
+							}
+						]
+					}
+				}`,
+			expected: ZeroProgram{
+				Hints: map[string][]Hint{
+					"0": {{
+						AccessibleScopes: []string{"starkware.cairo.common.math", "starkware.cairo.common.math.assert_not_equal"},
+						Code:             "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n    isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n    ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n    f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'",
+					}},
+				},
+			},
+		},
+		// TODO: Add debug-info test case
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var z ZeroProgram
+			err := json.Unmarshal([]byte(tt.jsonData), &z)
+			if err != nil {
+				t.Errorf("Failed to unmarshal JSON: %s", err)
+			}
+
+			assert.Equal(t, tt.expected, z, "Field does not match")
+		})
+	}
+}

pkg/vm/memory/memory_value.go

@@ -151,11 +151,13 @@ func EmptyMemoryValueAsFelt() *MemoryValue {
 		felt: new(f.Element),
 	}
 }
+
 func EmptyMemoryValueAsAddress() *MemoryValue {
 	return &MemoryValue{
 		address: new(MemoryAddress),
 	}
 }
+
 func EmptyMemoryValueAs(address bool) *MemoryValue {
 	if address {
 		return EmptyMemoryValueAsAddress()

pkg/vm/memory/memory_value_test.go

@@ -1,9 +1,10 @@
 package memory
 
 import (
-	"github.com/stretchr/testify/require"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
 	f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp"
 	"github.com/stretchr/testify/assert"
 )
@@ -60,7 +61,6 @@ func TestFeltPlusMemoryAddress(t *testing.T) {
 
 	assert.Equal(t, memVal, res)
 	assert.Equal(t, *expected, *res)
-
 }
 
 func TestMemoryAddressPlusMemoryAddress(t *testing.T) {

pkg/vm/vm.go

@@ -3,9 +3,10 @@ package vm
 import (
 	"fmt"
 
+	f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp"
+
 	safemath "github.com/NethermindEth/cairo-vm-go/pkg/safemath"
 	mem "github.com/NethermindEth/cairo-vm-go/pkg/vm/memory"
-	f "github.com/consensys/gnark-crypto/ecc/stark-curve/fp"
 )
 
 const (