From 08a2f391c3b50c16424b0324c8eb290fd369fab4 Mon Sep 17 00:00:00 2001 From: Harikrishnan Shaji Date: Tue, 16 Jul 2024 15:36:59 +0530 Subject: [PATCH] Fix some integration test bugs (#516) * Run all builtin tests as integration tests * Fix bitwise infer value bug * Allow checking for failures * Update blake test * Fix checkUsedCells bug * Update blake test * Fix error handling * Fix error handling * Fix unidentified hints bug * Fix minor bug * Refactor to use NondetElementsOverX --- integration_tests/BenchMarks.txt | 96 ++++++++++----------- pkg/hintrunner/zero/hintcode.go | 4 +- pkg/hintrunner/zero/zerohint.go | 6 +- pkg/hintrunner/zero/zerohint_keccak.go | 8 +- pkg/hintrunner/zero/zerohint_others.go | 71 ++++----------- pkg/hintrunner/zero/zerohint_others_test.go | 44 +++------- 6 files changed, 89 insertions(+), 140 deletions(-) diff --git a/integration_tests/BenchMarks.txt b/integration_tests/BenchMarks.txt index 87da4f035..72e95b1cc 100644 --- a/integration_tests/BenchMarks.txt +++ b/integration_tests/BenchMarks.txt @@ -1,99 +1,99 @@ =========================================================================================================================== | File | PythonVM (ms) | GoVM (ms) | =========================================================================================================================== -| is_quad_residue.small.cairo | 815 | 122 | +| uint256_mul_div_mod.small.cairo | 975 | 112 | --------------------------------------------------------------------------------------------------------------------------- -| memset.cairo | 723 | 107 | +| poseidon_test.starknet_with_keccak.cairo| 1330 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| pow.small.cairo | 810 | 109 | +| assert_not_zero.cairo | 749 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| search_sorted_lower.small.cairo | 849 | 107 | +| pow.small.cairo | 728 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| bitwise_builtin_test.starknet_with_keccak.cairo| 1312 | 108 | +| simple.cairo | 632 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| dict.cairo | 840 | 106 | +| is_quad_residue.small.cairo | 903 | 125 | --------------------------------------------------------------------------------------------------------------------------- -| hintrefs.cairo | 1029 | 109 | +| split_int.small.cairo | 894 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_sqrt.small.cairo | 929 | 109 | +| set_add.small.cairo | 855 | 112 | --------------------------------------------------------------------------------------------------------------------------- -| assert_250_bits.small.cairo | 843 | 109 | +| split64.small.cairo | 829 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| assert_not_equal.cairo | 923 | 182 | +| usort.small.cairo | 767 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| div_mod_n.small.cairo | 889 | 113 | +| assert_250_bits.small.cairo | 1111 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| ec.small.cairo | 4754 | 158 | +| blake.starknet_with_keccak.cairo | 47198 | 472 | --------------------------------------------------------------------------------------------------------------------------- -| import_secp256R1P.small.cairo | 705 | 103 | +| memcpy.cairo | 745 | 224 | --------------------------------------------------------------------------------------------------------------------------- -| usort.small.cairo | 916 | 106 | +| split_felt.small.cairo | 861 | 110 | --------------------------------------------------------------------------------------------------------------------------- -| verify_ecdsa_signature.small.cairo | 747 | 104 | +| unsafe_keccak_finalize.small.cairo | 694 | 109 | --------------------------------------------------------------------------------------------------------------------------- -| cmp.small.cairo | 913 | 110 | +| unsigned_div_rem.small.cairo | 839 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| signed_div_rem.small.cairo | 1000 | 115 | +| ecdsa_test.starknet_with_keccak.cairo | 1616 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| poseidon_test.starknet_with_keccak.cairo| 1318 | 108 | +| dict.cairo | 697 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| assert_not_zero.cairo | 1052 | 104 | +| hintrefs.cairo | 774 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| blake.starknet_with_keccak.cairo | 47471 | 512 | +| uint256_signedNN.small.cairo | 764 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| set_add.small.cairo | 707 | 107 | +| uint256_sqrt.small.cairo | 966 | 109 | --------------------------------------------------------------------------------------------------------------------------- -| split64.small.cairo | 804 | 106 | +| factorial.cairo | 1341 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| sqrt.small.cairo | 853 | 106 | +| cmp.small.cairo | 924 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| verify_zero.small.cairo | 738 | 105 | +| uint256_add.small.cairo | 892 | 109 | --------------------------------------------------------------------------------------------------------------------------- -| simple.cairo | 600 | 103 | +| reduce_v1.small.cairo | 823 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| dict_squash.small.cairo | 1005 | 115 | +| search_sorted_lower.small.cairo | 833 | 122 | --------------------------------------------------------------------------------------------------------------------------- -| memcpy.cairo | 627 | 103 | +| signed_div_rem.small.cairo | 731 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| split_felt.small.cairo | 1041 | 106 | +| unsafe_keccak.small.cairo | 745 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_add.small.cairo | 722 | 105 | +| verify_ecdsa_signature.small.cairo | 761 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| factorial.cairo | 1047 | 106 | +| verify_zero.small.cairo | 733 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| pedersen_test.small.cairo | 639 | 103 | +| dict_squash.small.cairo | 801 | 110 | --------------------------------------------------------------------------------------------------------------------------- -| is_zero.small.cairo | 872 | 107 | +| get_point_from_x.small.cairo | 884 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| random_ec.cairo | 763 | 108 | +| pedersen_test.small.cairo | 699 | 103 | --------------------------------------------------------------------------------------------------------------------------- -| split_int.small.cairo | 793 | 106 | +| bitwise_builtin_test.starknet_with_keccak.cairo| 1343 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_signedNN.small.cairo | 767 | 105 | +| ecop.starknet_with_keccak.cairo | 1423 | 111 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_unsigned_div_rem.small.cairo | 883 | 108 | +| fib.cairo | 648 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| unsafe_keccak.small.cairo | 740 | 104 | +| alloc.cairo | 957 | 1056 | --------------------------------------------------------------------------------------------------------------------------- -| unsigned_div_rem.small.cairo | 826 | 106 | +| is_positive.small.cairo | 802 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| alloc.cairo | 737 | 620 | +| ec.small.cairo | 4492 | 157 | --------------------------------------------------------------------------------------------------------------------------- -| find_element.small.cairo | 813 | 105 | +| find_element.small.cairo | 1706 | 127 | --------------------------------------------------------------------------------------------------------------------------- -| get_point_from_x.small.cairo | 1039 | 135 | +| import_secp256R1P.small.cairo | 627 | 108 | --------------------------------------------------------------------------------------------------------------------------- -| is_positive.small.cairo | 784 | 105 | +| is_zero.small.cairo | 872 | 112 | --------------------------------------------------------------------------------------------------------------------------- -| reduce_v1.small.cairo | 860 | 108 | +| memset.cairo | 898 | 104 | --------------------------------------------------------------------------------------------------------------------------- -| uint256_mul_div_mod.small.cairo | 977 | 110 | +| sqrt.small.cairo | 807 | 105 | --------------------------------------------------------------------------------------------------------------------------- -| unsafe_keccak_finalize.small.cairo | 662 | 104 | +| assert_not_equal.cairo | 694 | 107 | --------------------------------------------------------------------------------------------------------------------------- -| fib.cairo | 641 | 103 | +| div_mod_n.small.cairo | 869 | 106 | --------------------------------------------------------------------------------------------------------------------------- -| ecdsa_test.starknet_with_keccak.cairo | 1506 | 108 | +| uint256_unsigned_div_rem.small.cairo | 897 | 109 | --------------------------------------------------------------------------------------------------------------------------- -| keccak_test.starknet_with_keccak.cairo| 1369 | 110 | +| keccak_test.starknet_with_keccak.cairo| 1297 | 109 | =========================================================================================================================== diff --git a/pkg/hintrunner/zero/hintcode.go b/pkg/hintrunner/zero/hintcode.go index d09037598..de35f9e07 100644 --- a/pkg/hintrunner/zero/hintcode.go +++ b/pkg/hintrunner/zero/hintcode.go @@ -159,8 +159,8 @@ ids.multiplicities = segments.gen_arg([len(positions_dict[k]) for k in output])` vmEnterScopeCode string = "vm_enter_scope()" vmExitScopeCode string = "vm_exit_scope()" findElementCode string = "array_ptr = ids.array_ptr\nelm_size = ids.elm_size\nassert isinstance(elm_size, int) and elm_size > 0, \\\n f'Invalid value for elm_size. Got: {elm_size}.'\nkey = ids.key\n\nif '__find_element_index' in globals():\n ids.index = __find_element_index\n found_key = memory[array_ptr + elm_size * __find_element_index]\n assert found_key == key, \\\n f'Invalid index found in __find_element_index. index: {__find_element_index}, ' \\\n f'expected key {key}, found key: {found_key}.'\n # Delete __find_element_index to make sure it's not used for the next calls.\n del __find_element_index\nelse:\n n_elms = ids.n_elms\n assert isinstance(n_elms, int) and n_elms >= 0, \\\n f'Invalid value for n_elms. Got: {n_elms}.'\n if '__find_element_max_size' in globals():\n assert n_elms <= __find_element_max_size, \\\n f'find_element() can only be used with n_elms<={__find_element_max_size}. ' \\\n f'Got: n_elms={n_elms}.'\n\n for i in range(n_elms):\n if memory[array_ptr + elm_size * i] == key:\n ids.index = i\n break\n else:\n raise ValueError(f'Key {key} was not found.')" - nondetElementsOverTWoCode string = "memory[ap] = to_felt_or_relocatable(ids.n >= 2)" - nondetElementsOverTenCode string = "memory[ap] = to_felt_or_relocatable(ids.n >= 10)" + nondetElementsOverTwoCode string = "memory[ap] = to_felt_or_relocatable(ids.elements_end - ids.elements >= 2)" + nondetElementsOverTenCode string = "memory[ap] = to_felt_or_relocatable(ids.elements_end - ids.elements >= 10)" setAddCode string = "assert ids.elm_size > 0\nassert ids.set_ptr <= ids.set_end_ptr\nelm_list = memory.get_range(ids.elm_ptr, ids.elm_size)\nfor i in range(0, ids.set_end_ptr - ids.set_ptr, ids.elm_size):\n if memory.get_range(ids.set_ptr + i, ids.elm_size) == elm_list:\n ids.index = i // ids.elm_size\n ids.is_elm_in_set = 1\n break\nelse:\n ids.is_elm_in_set = 0" searchSortedLowerCode string = `array_ptr = ids.array_ptr elm_size = ids.elm_size diff --git a/pkg/hintrunner/zero/zerohint.go b/pkg/hintrunner/zero/zerohint.go index d1f18d5eb..11f42f240 100644 --- a/pkg/hintrunner/zero/zerohint.go +++ b/pkg/hintrunner/zero/zerohint.go @@ -260,10 +260,10 @@ func GetHintFromCode(program *zero.ZeroProgram, rawHint zero.Hint, hintPC uint64 return createTestAssignHinter(resolver) case findElementCode: return createFindElementHinter(resolver) - case nondetElementsOverTWoCode: - return createNondetElementsOverTWoHinter(resolver) + case nondetElementsOverTwoCode: + return createNondetElementsOverXHinter(resolver, 2) case nondetElementsOverTenCode: - return createNondetElementsOverTenHinter(resolver) + return createNondetElementsOverXHinter(resolver, 10) default: return nil, fmt.Errorf("not identified hint") } diff --git a/pkg/hintrunner/zero/zerohint_keccak.go b/pkg/hintrunner/zero/zerohint_keccak.go index e9021b377..0e235edcd 100644 --- a/pkg/hintrunner/zero/zerohint_keccak.go +++ b/pkg/hintrunner/zero/zerohint_keccak.go @@ -390,17 +390,17 @@ func newKeccakWriteArgsHint(inputs, low, high hinter.ResOperander) hinter.Hinter func createKeccakWriteArgsHinter(resolver hintReferenceResolver) (hinter.Hinter, error) { inputs, err := resolver.GetResOperander("inputs") - if inputs != nil { + if err != nil { return nil, err } low, err := resolver.GetResOperander("low") - if low != nil { + if err != nil { return nil, err } high, err := resolver.GetResOperander("high") - if high != nil { + if err != nil { return nil, err } @@ -521,7 +521,7 @@ func newBlockPermutationHint(keccakPtr hinter.ResOperander) hinter.Hinter { func createBlockPermutationHinter(resolver hintReferenceResolver) (hinter.Hinter, error) { keccakPtr, err := resolver.GetResOperander("keccak_ptr") - if keccakPtr != nil { + if err != nil { return nil, err } diff --git a/pkg/hintrunner/zero/zerohint_others.go b/pkg/hintrunner/zero/zerohint_others.go index d47bab113..ef4c055f4 100644 --- a/pkg/hintrunner/zero/zerohint_others.go +++ b/pkg/hintrunner/zero/zerohint_others.go @@ -608,71 +608,34 @@ func createSearchSortedLowerHinter(resolver hintReferenceResolver) (hinter.Hinte return newSearchSortedLowerHint(arrayPtr, elmSize, nElms, key, index), nil } -// NondetElementsOverTWo hint compares the offset difference between two memory address and +// NondetElementsOverX hint compares the offset difference between two memory address and // writes 1 or 0 at `ap` memory address, depending on whether the difference is greater or -// equal to 2 or not +// equal to x or not // -// `newNondetElementsOverTWoHint` takes 2 operanders as arguments +// `newNondetElementsOverXHint` takes 3 arguments // - `elementsEnd` represents the address in memory right after the last element of the array // - `elements` represents the address in memory of the first element of the array -func newNondetElementsOverTWoHint(n hinter.ResOperander) hinter.Hinter { +// - `x` represents the offset difference used to decide the result +func newNondetElementsOverXHint(elementsEnd, elements hinter.ResOperander, x uint64) hinter.Hinter { return &GenericZeroHinter{ - Name: "NondetElementsOverTWo", + Name: "NondetElementsOverX", Op: func(vm *VM.VirtualMachine, ctx *hinter.HintRunnerContext) error { - //> python hint in cairo file: "ids.elements_end - ids.elements >= 2" - //> python hint in whitelist: "memory[ap] = to_felt_or_relocatable(ids.elements_end - ids.elements >= 2)" - //> compiled file hint: "memory[ap] = to_felt_or_relocatable(ids.n >= 2)" + //> python hint in cairo file: "ids.elements_end - ids.elements >= x" + //> python hint in whitelist: "memory[ap] = to_felt_or_relocatable(ids.elements_end - ids.elements >= x)" - n, err := hinter.ResolveAsUint64(vm, n) + elementsEndAddr, err := hinter.ResolveAsAddress(vm, elementsEnd) if err != nil { return err } - - apAddr := vm.Context.AddressAp() - var resultMv memory.MemoryValue - if n >= uint64(2) { - resultMv = memory.MemoryValueFromFieldElement(&utils.FeltOne) - } else { - resultMv = memory.MemoryValueFromFieldElement(&utils.FeltZero) - } - - return vm.Memory.WriteToAddress(&apAddr, &resultMv) - }, - } -} - -func createNondetElementsOverTWoHinter(resolver hintReferenceResolver) (hinter.Hinter, error) { - n, err := resolver.GetResOperander("n") - if err != nil { - return nil, err - } - - return newNondetElementsOverTWoHint(n), nil -} - -// NondetElementsOverTen hint compares the offset difference between two memory address and -// writes 1 or 0 at `ap` memory address, depending on whether the difference is greater or -// esual to 10 or not -// -// `newNondetElementsOverTenHint` takes 2 operanders as arguments -// - `elementsEnd` represents the address in memory right after the last element of the array -// - `elements` represents the address in memory of the first element of the array -func newNondetElementsOverTenHint(n hinter.ResOperander) hinter.Hinter { - return &GenericZeroHinter{ - Name: "NondetElementsOverTen", - Op: func(vm *VM.VirtualMachine, ctx *hinter.HintRunnerContext) error { - //> python hint in cairo file: "ids.elements_end - ids.elements >= 10" - //> python hint in whitelist: "memory[ap] = to_felt_or_relocatable(ids.elements_end - ids.elements >= 10)" - //> compiled file hint: "memory[ap] = to_felt_or_relocatable(ids.n >= 10)" - - n, err := hinter.ResolveAsUint64(vm, n) + elementsAddr, err := hinter.ResolveAsAddress(vm, elements) if err != nil { return err } apAddr := vm.Context.AddressAp() var resultMv memory.MemoryValue - if n >= uint64(10) { + offsetDiff := elementsEndAddr.Offset - elementsAddr.Offset + if offsetDiff >= x { resultMv = memory.MemoryValueFromFieldElement(&utils.FeltOne) } else { resultMv = memory.MemoryValueFromFieldElement(&utils.FeltZero) @@ -683,11 +646,15 @@ func newNondetElementsOverTenHint(n hinter.ResOperander) hinter.Hinter { } } -func createNondetElementsOverTenHinter(resolver hintReferenceResolver) (hinter.Hinter, error) { - n, err := resolver.GetResOperander("n") +func createNondetElementsOverXHinter(resolver hintReferenceResolver, x uint64) (hinter.Hinter, error) { + elementsEnd, err := resolver.GetResOperander("elements_end") + if err != nil { + return nil, err + } + elements, err := resolver.GetResOperander("elements") if err != nil { return nil, err } - return newNondetElementsOverTenHint(n), nil + return newNondetElementsOverXHint(elementsEnd, elements, x), nil } diff --git a/pkg/hintrunner/zero/zerohint_others_test.go b/pkg/hintrunner/zero/zerohint_others_test.go index 729d65551..18f7d3368 100644 --- a/pkg/hintrunner/zero/zerohint_others_test.go +++ b/pkg/hintrunner/zero/zerohint_others_test.go @@ -531,53 +531,35 @@ func TestZeroHintOthers(t *testing.T) { }), }, }, - "NondetElementsOverTwo": { + "NondetElementsOverX": { { operanders: []*hintOperander{ - {Name: "n", Kind: apRelative, Value: feltUint64(1)}, + {Name: "elements_end", Kind: apRelative, Value: addr(6)}, + {Name: "elements", Kind: apRelative, Value: addr(4)}, }, makeHinter: func(ctx *hintTestContext) hinter.Hinter { - return newNondetElementsOverTWoHint( - ctx.operanders["n"], - ) - }, - check: apValueEquals(feltUint64(0)), - }, - { - operanders: []*hintOperander{ - {Name: "n", Kind: apRelative, Value: feltUint64(2)}, - }, - makeHinter: func(ctx *hintTestContext) hinter.Hinter { - return newNondetElementsOverTWoHint( - ctx.operanders["n"], + return newNondetElementsOverXHint( + ctx.operanders["elements_end"], + ctx.operanders["elements"], + 2, ) }, check: apValueEquals(feltUint64(1)), }, - }, - "NondetElementsOverTen": { { operanders: []*hintOperander{ - {Name: "n", Kind: apRelative, Value: feltUint64(9)}, + {Name: "elements_end", Kind: apRelative, Value: addr(11)}, + {Name: "elements", Kind: apRelative, Value: addr(2)}, }, makeHinter: func(ctx *hintTestContext) hinter.Hinter { - return newNondetElementsOverTenHint( - ctx.operanders["n"], + return newNondetElementsOverXHint( + ctx.operanders["elements_end"], + ctx.operanders["elements"], + 10, ) }, check: apValueEquals(feltUint64(0)), }, - { - operanders: []*hintOperander{ - {Name: "n", Kind: apRelative, Value: feltUint64(10)}, - }, - makeHinter: func(ctx *hintTestContext) hinter.Hinter { - return newNondetElementsOverTenHint( - ctx.operanders["n"], - ) - }, - check: apValueEquals(feltUint64(1)), - }, }, }) }