setup pow

evm/src/cpu/kernel/asm/curve/bn254/curve_arithmetic/tate_pairing.asm

@@ -1,7 +1,7 @@
 /// def tate(P : [Fp; 2], Q: [Fp2; 2]) -> Fp12:
 ///     out = miller_loop(P, Q)
 ///
-///     inv = inverse_fp12(out)
+///     inv = inv_fp12(out)
 ///     out = frob_fp12_6(out)
 ///     out = mul_fp12(out, inv)
 ///
@@ -27,7 +27,7 @@ global post_mllr:
     // stack:            100, tate_inv, out, retdest
     DUP3 
     // stack:       out, 100, tate_inv, out, retdest
-    %jump(inverse_fp12)
+    %jump(inv_fp12)
 tate_inv:
     // stack:                           out, retdest  {100: inv}
     PUSH tate_mul1

evm/src/cpu/kernel/asm/curve/bn254/field_arithmetic/inverse.asm

@@ -22,13 +22,13 @@
 %endmacro
 
 
-global test_inverse_fp12:
+global test_inv_fp12:
     // stack:                        ptr, f, ptr, inv, retdest
     %store_fp12
     // stack:                                ptr, inv, retdest
-    %jump(inverse_fp12)
+    %jump(inv_fp12)
 
-global inverse_fp12:
+global inv_fp12:
     // stack:                 ptr, inv, retdest
     DUP1  %load_fp12
     // stack:              f, ptr, inv, retdest

evm/src/cpu/kernel/asm/curve/bn254/field_arithmetic/power.asm

@@ -1,4 +1,4 @@
-global test_power:
+global test_pow:
     // stack: ptr, f, ptr, out, ret_stack, out
     %store_fp12
     // stack:         ptr, out, ret_stack, out
@@ -39,7 +39,7 @@ power_return:
     // stack:                                out, retdest  {200: y0, 212: y1, 224: y2}
     PUSH power_return_1  PUSH 236  PUSH 200
     // stack:      200, 236, power_return_1, out, retdest  {200: y0, 212: y1, 224: y2}
-    %jump(inverse_fp12)
+    %jump(inv_fp12)
 power_return_1:
     // stack:                                out, retdest  {236: y0, 212: y1, 224: y2}
     PUSH power_return_2  PUSH 248  PUSH 224

evm/src/cpu/kernel/tests/bn254_field.rs

@@ -722,7 +722,7 @@ fn make_inv_stack(f: Fp12) -> Vec<U256> {
 fn test_inv_fp12() -> Result<()> {
     let f: Fp12 = gen_fp12();
 
-    let test_inv = KERNEL.global_labels["test_inverse_fp12"];
+    let test_inv = KERNEL.global_labels["test_inv_fp12"];
     let stack = make_inv_stack(f);
 
     let output: Vec<U256> = run_interpreter(test_inv, stack)?.stack().to_vec();
@@ -732,7 +732,7 @@ fn test_inv_fp12() -> Result<()> {
     Ok(())
 }
 
-fn make_power_stack(f: Fp12) -> Vec<U256> {
+fn make_pow_stack(f: Fp12) -> Vec<U256> {
     let ptr = U256::from(300);
     let out = U256::from(400);
     let f: Vec<U256> = f.into_iter().flatten().flatten().collect();
@@ -744,3 +744,26 @@ fn make_power_stack(f: Fp12) -> Vec<U256> {
     input.reverse();
     input
 }
+
+fn make_pow_expected(f: Fp12) -> Vec<U256> {
+    fast_exp(f)
+        .into_iter()
+        .flatten()
+        .flatten()
+        .rev()
+        .collect()
+}
+
+fn test_pow_fp12() -> Result<()> {
+    let f: Fp12 = gen_fp12();
+
+    let test_pow = KERNEL.global_labels["test_pow"];
+    let stack = make_pow_stack(f);
+
+    let output: Vec<U256> = run_interpreter(test_pow, stack)?.stack().to_vec();
+    let expected: Vec<U256> = make_pow_expected(f);
+
+    assert_eq!(output, expected);
+
+    Ok(())
+}