modexp big integers arithmetics

docs/src/SUMMARY.md

@@ -13,4 +13,5 @@
     - [Optimizations](ecpairing/optimizations.md)
 - [ModExp]()
     - [Specification](modexp/spec.md)
+    - [API Docs](modexp/api.md)
     - [Optimizations](modexp/optimizations.md)

docs/src/modexp/api.md

@@ -0,0 +1,27 @@
+# API Docs
+
+## Big Unsigned Integers Arithmetic
+
+### `bigUIntAdd`
+
+### `bigUIntSubWithBorrow`
+
+### `bigUIntMul`
+
+### `bigUIntBitOr`
+
+```
++------------+-----------------------+-------------------------------+-------------------------------+-------------------------------+-----------------+-----------------+--------------------------------------+
+| Iteration  |       currentOffset   |           lhsCurrentPtr       |           rhsCurrentPtr       |           resCurrentPtr       | lhsCurrentValue | rhsCurrentValue |           resCurrentValue            |
++------------+-----------------------+-------------------------------+-------------------------------+-------------------------------+-----------------+-----------------+--------------------------------------+
+| 0          | +0x00                 | lhsPtr + 0x00                 | rhsPtr + 0x00                 | resPtr + 0x00                 | lhs[0]          | rhs[0]          | or(lhs[0], rhs[0])                   |
+| 1          | +0x20                 | lhsPtr + 0x20                 | rhsPtr + 0x20                 | resPtr + 0x20                 | lhs[1]          | rhs[1]          | or(lhs[1], rhs[1])                   |
+| 2          | +0x40                 | lhsPtr + 0x40                 | rhsPtr + 0x40                 | resPtr + 0x40                 | lhs[2]          | rhs[2]          | or(lhs[2], rhs[2])                   |
+|            |                       |                               |                               |                               |                 |                 |                                      |
+| ...        | ...                   | ...                           | ...                           | ...                           | ...             | ...             | ...                                  |
+|            |                       |                               |                               |                               |                 |                 |                                      |
+| nLimbs - 1 | +(0x20 * (nLimbs - 1) | lhsPtr + (0x20 * (nLimbs - 1) | rhsPtr + (0x20 * (nLimbs - 1) | resPtr + (0x20 * (nLimbs - 1) | lhs[nLimbs - 1] | rhs[nLimbs - 1] | or(lhs[nLimbs - 1], rhs[nLimbs - 1]) |
++------------+-----------------------+-------------------------------+-------------------------------+-------------------------------+-----------------+-----------------+--------------------------------------+
+```
+
+### `bigUIntCondSelect`

scripts/modexp_reference.py

@@ -0,0 +1,22 @@
+#! /usr/bin/python3
+def modular_pow(base, exponent, modulus):
+    if modulus == 1:
+        return 0
+
+    result = 1
+    base %= modulus
+
+    while exponent > 0:
+        print(f"Exponent: {hex(exponent)}, result: {hex(result)}, base: {hex(base)}")
+        if exponent % 2 == 1:
+            result = (result * base) % modulus
+        exponent >>= 1
+        base = (base * base) % modulus
+
+    return result
+
+# Example usage:
+base = 390298093899999943928098409885853890809480289080848908498808490890809858888590
+exponent = 328010176336108753607932954472681594880
+modulus = 328083392909999939299399093209090192209
+result = modular_pow(base, exponent, modulus)

tests/build.rs

@@ -0,0 +1,33 @@
+use std::fs::OpenOptions;
+use std::io::Write;
+
+fn main() {
+    let directory = "gas_reports";
+    if !std::path::Path::new(directory).exists() {
+        std::fs::create_dir(directory).unwrap();
+    }
+
+    let precompiles_report_list: Vec<String> = vec![
+        "modexp".to_string(),
+        "ecadd".to_string(),
+        "ecmul".to_string(),
+        "ecpairing".to_string(),
+        "p256verify".to_string(),
+        "secp256k1verify".to_string(),
+    ];
+    precompiles_report_list
+        .into_iter()
+        .for_each(|mut precompile_name| {
+            let file_path = format!("{}/{}_report.md", directory, precompile_name);
+            precompile_name.push_str("_report.md");
+            let mut file = OpenOptions::new()
+                .create(true)
+                .write(true)
+                .truncate(true)
+                .open(file_path)
+                .unwrap();
+
+            writeln!(file, "| Test case | Gas used |").unwrap();
+            writeln!(file, "| --------- | -------- |").unwrap();
+        });
+}

tests/tests/p256verify_tests.rs

@@ -1,7 +1,6 @@
 use zksync_web3_rs::types::{Address, Bytes, H160};
-
 mod test_utils;
-use test_utils::{era_call, parse_call_result};
+use test_utils::{era_call, parse_call_result, write_p256verify_gas_result};
 
 pub const P256VERIFTY_PRECOMPILE_ADDRESS: Address = H160([
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -27,7 +26,8 @@ async fn p256verify_valid_signature_one() {
     )
     .await
     .unwrap();
-    let (era_output, _) = parse_call_result(&era_response);
+    let (era_output, gas_used) = parse_call_result(&era_response);
+    write_p256verify_gas_result(gas_used);
     assert_eq!(era_output, Bytes::from(RESPONSE_VALID))
 }
 
@@ -40,7 +40,8 @@ async fn p256verify_valid_signature_two() {
     )
     .await
     .unwrap();
-    let (era_output, _) = parse_call_result(&era_response);
+    let (era_output, gas_used) = parse_call_result(&era_response);
+    write_p256verify_gas_result(gas_used);
     assert_eq!(era_output, Bytes::from(RESPONSE_VALID))
 }
 
@@ -53,7 +54,8 @@ async fn p256verify_invalid_signature() {
     )
     .await
     .unwrap();
-    let (era_output, _) = parse_call_result(&era_response);
+    let (era_output, gas_used) = parse_call_result(&era_response);
+    write_p256verify_gas_result(gas_used);
     assert_eq!(era_output, Bytes::from(RESPONSE_INVALID))
 }
 
@@ -82,6 +84,7 @@ async fn p256verify_invalid_s() {
     .err()
     .unwrap()
     .to_string();
+
     assert_eq!(era_response, EXECUTION_REVERTED)
 }
 
@@ -96,6 +99,7 @@ async fn p256verify_public_key_inf() {
     .err()
     .unwrap()
     .to_string();
+
     assert_eq!(era_response, EXECUTION_REVERTED)
 }
 
@@ -110,6 +114,7 @@ async fn p256verify_public_key_x_not_in_field() {
     .err()
     .unwrap()
     .to_string();
+
     assert_eq!(era_response, EXECUTION_REVERTED)
 }
 
@@ -124,6 +129,7 @@ async fn p256verify_public_key_y_not_in_field() {
     .err()
     .unwrap()
     .to_string();
+
     assert_eq!(era_response, EXECUTION_REVERTED)
 }
 
@@ -138,5 +144,6 @@ async fn p256verify_public_key_not_in_curve() {
     .err()
     .unwrap()
     .to_string();
+
     assert_eq!(era_response, EXECUTION_REVERTED)
 }

tests/tests/secp256k1verify_tests.rs

@@ -1,15 +1,13 @@
 use zksync_web3_rs::types::{Address, Bytes, H160};
 
+mod test_utils;
+use test_utils::{era_call, parse_call_result, write_secp256k1verify_gas_result};
+
 pub const SECP256K1VERIFTY_PRECOMPILE_ADDRESS: Address = H160([
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x20,
 ]);
 
-mod test_utils;
-use test_utils::era_call;
-
-use crate::test_utils::parse_call_result;
-
 const RESPONSE_VALID: [u8; 32] = [
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
 ];
@@ -29,7 +27,8 @@ async fn secp256k1verify_valid_signature_one() {
     )
     .await
     .unwrap();
-    let (era_output, _) = parse_call_result(&era_response);
+    let (era_output, gas_used) = parse_call_result(&era_response);
+    write_secp256k1verify_gas_result(gas_used);
     assert_eq!(era_output, Bytes::from(RESPONSE_VALID))
 }
 
@@ -42,7 +41,8 @@ async fn secp256k1verify_valid_signature_two() {
     )
     .await
     .unwrap();
-    let (era_output, _) = parse_call_result(&era_response);
+    let (era_output, gas_used) = parse_call_result(&era_response);
+    write_secp256k1verify_gas_result(gas_used);
     assert_eq!(era_output, Bytes::from(RESPONSE_VALID))
 }
 
@@ -55,7 +55,8 @@ async fn secp256k1verify_invalid_signature() {
     )
     .await
     .unwrap();
-    let (era_output, _) = parse_call_result(&era_response);
+    let (era_output, gas_used) = parse_call_result(&era_response);
+    write_secp256k1verify_gas_result(gas_used);
     assert_eq!(era_output, Bytes::from(RESPONSE_INVALID))
 }
 

tests/tests/test_utils.rs

@@ -1,4 +1,4 @@
-use std::env;
+use std::{env, fs::OpenOptions, io::Write};
 use zksync_web3_rs::{
     providers::{Http, Middleware, Provider, ProviderError},
     types::{transaction::eip2718::TypedTransaction, Address, Bytes, Eip1559TransactionRequest},
@@ -21,6 +21,48 @@ pub fn parse_call_result(bytes: &[u8]) -> (Bytes, u32) {
     (output.into(), gas_used)
 }
 
+fn write_line_to_report(used_gas: u32, report_to_write: &str) {
+    let mut file = OpenOptions::new()
+        .append(true)
+        .open(report_to_write)
+        .unwrap();
+
+    let curr_thread = std::thread::current();
+    let test_name = curr_thread.name().unwrap();
+
+    writeln!(file, "| {test_name}  | {used_gas} |").unwrap();
+}
+
+#[allow(dead_code)]
+pub fn write_modexp_gas_result(used_gas: u32) {
+    write_line_to_report(used_gas, "gas_reports/modexp_report.md");
+}
+
+#[allow(dead_code)]
+pub fn write_ecadd_gas_result(used_gas: u32) {
+    write_line_to_report(used_gas, "gas_reports/ecadd_report.md");
+}
+
+#[allow(dead_code)]
+pub fn write_ecmul_gas_result(used_gas: u32) {
+    write_line_to_report(used_gas, "gas_reports/ecmul_report.md");
+}
+
+#[allow(dead_code)]
+pub fn write_ecpairing_gas_result(used_gas: u32) {
+    write_line_to_report(used_gas, "gas_reports/ecpairing_report.md");
+}
+
+#[allow(dead_code)]
+pub fn write_p256verify_gas_result(used_gas: u32) {
+    write_line_to_report(used_gas, "gas_reports/p256verify_report.md");
+}
+
+#[allow(dead_code)]
+pub fn write_secp256k1verify_gas_result(used_gas: u32) {
+    write_line_to_report(used_gas, "gas_reports/secp256k1verify_report.md");
+}
+
 pub fn eth_provider() -> Provider<Http> {
     let url: String =
         env::var("ZKSYNC_WEB3_RS_L1_PROVIDER_URL").unwrap_or(DEFAULT_L1_PROVIDER_URL.to_owned());