Cairo0 hint pow

integration_tests/cairo_files/pow.cairo

@@ -0,0 +1,15 @@
+%builtins range_check
+
+from starkware.cairo.common.pow import pow
+
+func main{range_check_ptr: felt}() {
+    let (x) = pow(5, 3);
+    assert x = 125;
+    let (x) = pow(4, 3);
+    assert x = 64;
+    let (x) = pow(2, 10);
+    assert x = 1024;
+    let (y) = pow(x, 2);
+    assert x = 1048576;
+    return ();
+}

pkg/hintrunner/hinter/operand.go

@@ -231,12 +231,7 @@ func (v Immediate) ApplyApTracking(hint, ref zero.ApTracking) Reference {
 	return v
 }
 
-func GetConsecutiveValues(vm *VM.VirtualMachine, ref ResOperander, size int16) ([]mem.MemoryValue, error) {
-	addr, err := ref.GetAddress(vm)
-	if err != nil {
-		return nil, err
-	}
-
+func GetConsecutiveValues(vm *VM.VirtualMachine, addr mem.MemoryAddress, size int16) ([]mem.MemoryValue, error) {
 	values := make([]mem.MemoryValue, size)
 	for i := int16(0); i < size; i++ {
 		nAddr, err := addr.AddOffset(i)

pkg/hintrunner/zero/hint_reference_resolver.go

@@ -47,6 +47,18 @@ func (m *hintReferenceResolver) GetResOperander(name string) (hinter.ResOperande
 	return op, nil
 }
 
+func (m *hintReferenceResolver) GetCellRefer(name string) (hinter.CellRefer, error) {
+	ref, err := m.GetReference(name)
+	if err != nil {
+		return nil, err
+	}
+	op, ok := ref.(hinter.CellRefer)
+	if !ok {
+		return nil, fmt.Errorf("expected %s to be CellRefer (got %T)", name, ref)
+	}
+	return op, nil
+}
+
 // shortSymbolName turns a full symbol name like "a.b.c" into just "c".
 func shortSymbolName(name string) string {
 	i := strings.LastIndexByte(name, '.')

pkg/hintrunner/zero/hintcode.go

@@ -34,6 +34,9 @@ const (
 	splitIntAssertRange string = "assert ids.value == 0, 'split_int(): value is out of range.'"
 	splitIntCode        string = "memory[ids.output] = res = (int(ids.value) % PRIME) % ids.base\nassert res < ids.bound, f'split_int(): Limb {res} is out of range.'"
 
+	// pow hints
+	powCode string = "ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1"
+
 	unsignedDivRemCode string = "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.div)\nassert 0 < ids.div <= PRIME // range_check_builtin.bound, \\\n    f'div={hex(ids.div)} is out of the valid range.'\nids.q, ids.r = divmod(ids.value, ids.div)"
 
 	// split_felt() hints.

pkg/hintrunner/zero/zerohint.go

@@ -86,6 +86,8 @@ func GetHintFromCode(program *zero.ZeroProgram, rawHint zero.Hint, hintPC uint64
 		return createSplitIntAssertRangeHinter(resolver)
 	case splitIntCode:
 		return createSplitIntHinter(resolver)
+	case powCode:
+		return createPowHinter(resolver)
 	case uint256AddCode:
 		return createUint256AddHinter(resolver, false)
 	case uint256AddLowCode:

pkg/hintrunner/zero/zerohint_math.go

@@ -505,6 +505,59 @@ func createSplitIntHinter(resolver hintReferenceResolver) (hinter.Hinter, error)
 	return newSplitIntHint(output, value, base, bound), nil
 }
 
+func newPowHint(locs, prevLocs hinter.ResOperander) hinter.Hinter {
+	return &GenericZeroHinter{
+		Name: "Pow",
+		Op: func(vm *VM.VirtualMachine, _ *hinter.HintRunnerContext) error {
+			//> ids.locs.bit = (ids.prev_locs.exp % PRIME) & 1
+			/*> struct LoopLocals {
+				bit: felt,
+				temp0: felt,
+
+				res: felt,
+				base: felt,
+				exp: felt,
+			} */
+			const expStructOffset = 4
+			locsBitAddress, err := locs.GetAddress(vm)
+			if err != nil {
+				return err
+			}
+			prevLocsBitAddress, err := prevLocs.GetAddress(vm)
+			if err != nil {
+				return err
+			}
+			loopLocals, err := hinter.GetConsecutiveValues(vm, prevLocsBitAddress, expStructOffset+1)
+			if err != nil {
+				return err
+			}
+			prevLocsExp, err := loopLocals[expStructOffset].FieldElement()
+			if err != nil {
+				return err
+			}
+			var prevLocsExpBig big.Int
+			prevLocsExp.BigInt(&prevLocsExpBig)
+			locsBitBig := new(big.Int).And(&prevLocsExpBig, big.NewInt(1))
+			v := memory.MemoryValueFromFieldElement(new(fp.Element).SetBigInt(locsBitBig))
+			return vm.Memory.WriteToAddress(&locsBitAddress, &v)
+		},
+	}
+}
+
+func createPowHinter(resolver hintReferenceResolver) (hinter.Hinter, error) {
+	locs, err := resolver.GetCellRefer("locs")
+	if err != nil {
+		return nil, err
+	}
+	prev_locs, err := resolver.GetCellRefer("prev_locs")
+	if err != nil {
+		return nil, err
+	}
+	locsRes := hinter.Deref{Deref: locs}
+	prevLocsRes := hinter.Deref{Deref: prev_locs}
+	return newPowHint(locsRes, prevLocsRes), nil
+}
+
 func newSplitFeltHint(low, high, value hinter.ResOperander) hinter.Hinter {
 	return &GenericZeroHinter{
 		Name: "SplitFelt",
@@ -622,7 +675,6 @@ func newSqrtHint(root, value hinter.ResOperander) hinter.Hinter {
 }
 
 func createSqrtHinter(resolver hintReferenceResolver) (hinter.Hinter, error) {
-
 	root, err := resolver.GetResOperander("root")
 	if err != nil {
 		return nil, err
@@ -703,6 +755,5 @@ func createUnsignedDivRemHinter(resolver hintReferenceResolver) (hinter.Hinter,
 	if err != nil {
 		return nil, err
 	}
-
 	return newUnsignedDivRemHinter(value, div, q, r), nil
 }

pkg/hintrunner/zero/zerohint_math_test.go

@@ -555,7 +555,40 @@ func TestZeroHintMath(t *testing.T) {
 				errCheck: errorTextContains("outside of the range [0, 2**250)"),
 			},
 		},
-
+		"Pow": {
+			{
+				operanders: []*hintOperander{
+					{Name: "prev_locs.bit", Kind: apRelative, Value: feltInt64(0)},
+					{Name: "prev_locs.temp0", Kind: apRelative, Value: feltInt64(0)},
+					{Name: "prev_locs.res", Kind: apRelative, Value: feltInt64(0)},
+					{Name: "prev_locs.base", Kind: apRelative, Value: feltInt64(0)},
+					{Name: "prev_locs.exp", Kind: apRelative, Value: feltInt64(256)},
+					{Name: "locs.bit", Kind: uninitialized},
+				},
+				makeHinter: func(ctx *hintTestContext) hinter.Hinter {
+					return newPowHint(ctx.operanders["locs.bit"], ctx.operanders["prev_locs.bit"])
+				},
+				check: allVarValueEquals(map[string]*fp.Element{
+					"locs.bit": feltInt64(0),
+				}),
+			},
+			{
+				operanders: []*hintOperander{
+					{Name: "prev_locs.bit", Kind: apRelative, Value: feltInt64(0)},
+					{Name: "prev_locs.temp0", Kind: apRelative, Value: feltInt64(0)},
+					{Name: "prev_locs.res", Kind: apRelative, Value: feltInt64(0)},
+					{Name: "prev_locs.base", Kind: apRelative, Value: feltInt64(0)},
+					{Name: "prev_locs.exp", Kind: apRelative, Value: feltInt64(255)},
+					{Name: "locs.bit", Kind: uninitialized},
+				},
+				makeHinter: func(ctx *hintTestContext) hinter.Hinter {
+					return newPowHint(ctx.operanders["locs.bit"], ctx.operanders["prev_locs.bit"])
+				},
+				check: allVarValueEquals(map[string]*fp.Element{
+					"locs.bit": feltInt64(1),
+				}),
+			},
+		},
 		"SplitFelt": {
 			{
 				operanders: []*hintOperander{

pkg/hintrunner/zero/zerohint_uint256.go

@@ -13,7 +13,12 @@ import (
 )
 
 func GetUint256AsFelts(vm *VM.VirtualMachine, ref hinter.ResOperander) (*fp.Element, *fp.Element, error) {
-	values, err := hinter.GetConsecutiveValues(vm, ref, int16(2))
+	refAddr, err := ref.GetAddress(vm)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	values, err := hinter.GetConsecutiveValues(vm, refAddr, int16(2))
 	if err != nil {
 		return nil, nil, err
 	}