wip

Author: GCdePaula

Cargo.lock

@@ -16,3 +16,6 @@ serde = { version = "1", features = ["derive"] }
 thiserror = "1"
 ssz = { package = "ethereum_ssz", version = "0.10" }
 ssz_derive = { package = "ethereum_ssz_derive", version = "0.10" }
+
+[build-dependencies]
+ruint = "1.17"

sequencer-core/Cargo.toml

@@ -0,0 +1,119 @@
+// (c) Cartesi and individual authors (see AUTHORS)
+// SPDX-License-Identifier: Apache-2.0 (see LICENSE)
+
+//! Build script that generates the precomputed fee table for log-space fee
+//! encoding with base 129/128.
+//!
+//! The table contains `(129/128)^(2^i)` for i in 0..15, represented as
+//! fixed-point values with 64 fractional bits stored in 4×u64 limbs
+//! (little-endian, same layout as `alloy_primitives::U256`).
+//!
+//! All arithmetic is exact integer math — no floats, no approximation.
+
+use std::env;
+use std::fs;
+use std::path::Path;
+
+use ruint::Uint;
+
+type U256 = Uint<256, 4>;
+type U512 = Uint<512, 8>;
+
+const FRAC_BITS: usize = 64;
+
+/// Truncate a U512 to U256 by taking the lower 4 limbs.
+/// Returns `None` if the upper 4 limbs are nonzero (value doesn't fit).
+fn try_narrow(wide: U512) -> Option<U256> {
+    let limbs = wide.into_limbs();
+    let upper_nonzero = limbs[4] != 0 || limbs[5] != 0 || limbs[6] != 0 || limbs[7] != 0;
+    if upper_nonzero {
+        return None;
+    }
+    Some(U256::from_limbs([limbs[0], limbs[1], limbs[2], limbs[3]]))
+}
+
+/// Fixed-point multiplication: floor((a × b) >> 64).
+fn fixed_mul(a: U256, b: U256) -> U256 {
+    let product: U512 = a.widening_mul(b);
+    let shifted = product >> FRAC_BITS;
+    try_narrow(shifted).expect("fixed_mul result overflows U256")
+}
+
+/// Compute the maximum safe exponent for the fixed-point representation.
+///
+/// Returns the largest n such that `(129/128)^n × 2^64` fits in U256, i.e.,
+/// the full fixed-point value does not overflow 256 bits.
+///
+/// Uses a greedy bit-by-bit approach from the most significant bit downward:
+/// tentatively set each bit and check if the result still fits.
+fn compute_max_exponent(table: &[U256; 15]) -> u16 {
+    let fixed_one = U256::from(1u64) << FRAC_BITS;
+    let mut result_exp: u16 = 0;
+    let mut result_val = fixed_one;
+
+    for i in (0..15).rev() {
+        let product: U512 = result_val.widening_mul(table[i]);
+        let shifted = product >> FRAC_BITS;
+        if let Some(narrowed) = try_narrow(shifted) {
+            result_exp |= 1 << i;
+            result_val = narrowed;
+        }
+    }
+
+    result_exp
+}
+
+fn main() {
+    let out_dir = env::var("OUT_DIR").expect("OUT_DIR not set");
+    let dest = Path::new(&out_dir).join("fee_table.rs");
+
+    // (129/128) in fixed-point: 129 × 2^64 / 128 = 129 × 2^57.
+    let base_fixed = U256::from(129u64) << 57;
+
+    // Build the table by repeated squaring.
+    let mut table = [U256::ZERO; 15];
+    table[0] = base_fixed; // (129/128)^1
+    for i in 1..15 {
+        table[i] = fixed_mul(table[i - 1], table[i - 1]);
+    }
+
+    let max_exp = compute_max_exponent(&table);
+
+    // Generate Rust source.
+    let mut code = String::new();
+    code.push_str("// Auto-generated by build.rs — do not edit.\n");
+    code.push_str("// Precomputed table for log-space fee encoding (base 129/128).\n");
+    code.push_str("// All values are exact integer computations, no floating-point.\n\n");
+    code.push_str("use alloy_primitives::U256;\n\n");
+
+    code.push_str(&format!(
+        "/// Maximum exponent whose fixed-point representation fits in U256.\n\
+         /// Computed at build time: the largest n where `(129/128)^n × 2^64 < 2^256`.\n\
+         pub const MAX_EXPONENT: u16 = {max_exp};\n\n"
+    ));
+
+    code.push_str(
+        "/// Precomputed table: `TABLE[i]` = `(129/128)^(2^i)` in fixed-point with 64\n\
+         /// fractional bits. 15 entries (bits 0..14) cover exponents 0..32767.\n\
+         /// In practice exponents are capped at [`MAX_EXPONENT`].\n\
+         ///\n\
+         /// Generated by `build.rs` using exact integer arithmetic.\n\
+         pub const TABLE: [U256; 15] = [\n",
+    );
+
+    for (i, entry) in table.iter().enumerate() {
+        let limbs = entry.into_limbs();
+        code.push_str(&format!(
+            "    // (129/128)^{}\n    U256::from_limbs([{:#018x}, {:#018x}, {:#018x}, {:#018x}]),\n",
+            1u32 << i,
+            limbs[0],
+            limbs[1],
+            limbs[2],
+            limbs[3]
+        ));
+    }
+    code.push_str("];\n");
+
+    fs::write(&dest, code).expect("failed to write fee_table.rs");
+    println!("cargo::rerun-if-changed=build.rs");
+}

sequencer-core/build.rs

@@ -19,9 +19,20 @@
 //! The key trick: multiplying by 129/128 in integer math is `x + (x >> 7)`.
 //! Exponentiation uses a precomputed table of 15 entries with binary
 //! exponentiation (at most 15 fixed-point multiplications).
+//!
+//! The precomputed table and [`MAX_EXPONENT`] are generated at build time by
+//! `build.rs` using exact integer arithmetic (iterated fixed-point squaring).
+//! Any reimplementation (e.g. in C++) must use the same table values to
+//! guarantee bit-identical fee calculations. See `build.rs` for the algorithm.
 
 use alloy_primitives::U256;
 
+// Import the build-time generated constants: TABLE and MAX_EXPONENT.
+mod generated {
+    include!(concat!(env!("OUT_DIR"), "/fee_table.rs"));
+}
+use generated::{MAX_EXPONENT, TABLE};
+
 /// Fee base numerator.
 pub const FEE_BASE_NUM: u64 = 129;
 
@@ -37,46 +48,6 @@ const FIXED_ONE: U256 = U256::from_limbs([0, 1, 0, 0]);
 /// Type alias for the 512-bit intermediate used in fixed-point multiplication.
 type U512 = alloy_primitives::Uint<512, 8>;
 
-/// Maximum exponent that produces a result fitting in U256.
-/// `(129/128)^22801 ≈ 1.15 × 10⁷⁷ < 2²⁵⁶`.
-const MAX_EXPONENT: u16 = 22801;
-
-/// Precomputed table: `TABLE[i]` = `(129/128)^(2^i)` in fixed-point with 64
-/// fractional bits. 15 entries (bits 0..14) cover exponents 0..32767. In
-/// practice exponents are capped at [`MAX_EXPONENT`].
-const TABLE: [U256; 15] = [
-    // (129/128)^1
-    U256::from_limbs([0x0200000000000000, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^2
-    U256::from_limbs([0x0404000000000000, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^4
-    U256::from_limbs([0x0818201000000000, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^8
-    U256::from_limbs([0x1071C46707040100, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^16
-    U256::from_limbs([0x21F1F3E9E88A9FDE, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^32
-    U256::from_limbs([0x48642D6345D6B724, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^64
-    U256::from_limbs([0xA540DB81E090D217, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^128
-    U256::from_limbs([0xB52E6267A9C41385, 0x0000000000000002, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^256
-    U256::from_limbs([0x54F4292CC0341C1C, 0x0000000000000007, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^512
-    U256::from_limbs([0xC18B645664E97CB2, 0x0000000000000035, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^1024
-    U256::from_limbs([0xB60B04F629FAE140, 0x0000000000000B49, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^2048
-    U256::from_limbs([0x4629A786F160E3C4, 0x00000000007F6ADE, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^4096
-    U256::from_limbs([0x7A189A75BFA7286D, 0x00003F6B3526706C, 0x0000000000000000, 0x0000000000000000]),
-    // (129/128)^8192
-    U256::from_limbs([0xDE16922E6F29BFD7, 0x64804F18A8B89AD1, 0x000000000FB5F10E, 0x0000000000000000]),
-    // (129/128)^16384
-    U256::from_limbs([0xFAE86D02AC675940, 0xB9209769AD99BAC7, 0x770DC9A80163F037, 0x00F6D38E711D40BD]),
-];
-
 /// Convert a log-space fee exponent to a linear [`U256`] value.
 ///
 /// `fee_to_linear(n)` = `floor((129/128)^n)`.
@@ -100,9 +71,9 @@ fn fee_to_linear_fixed(log_fee: u16) -> U256 {
         "fee exponent {log_fee} exceeds MAX_EXPONENT ({MAX_EXPONENT})"
     );
     let mut result = FIXED_ONE; // 1.0 in fixed-point
-    for i in 0..15 {
+    for (i, entry) in TABLE.iter().enumerate() {
         if log_fee & (1 << i) != 0 {
-            result = fixed_mul(result, TABLE[i]);
+            result = fixed_mul(result, *entry);
         }
     }
     result
@@ -116,12 +87,20 @@ fn fee_to_linear_fixed(log_fee: u16) -> U256 {
 ///
 /// Uses binary search over `fee_to_linear` — 15 iterations, each doing at
 /// most 15 multiplies = 225 multiplies total. Fine for the rare inverse path.
-pub fn fee_from_linear(value: u64) -> u16 {
-    if value <= 1 {
+///
+/// Accepts [`U256`] for symmetry with [`fee_to_linear`], which returns [`U256`].
+pub fn fee_from_linear(value: U256) -> u16 {
+    if value <= U256::from(1u64) {
         return 0;
     }
+    // Values at or above the maximum representable fee saturate to MAX_EXPONENT.
+    // This also prevents overflow in the left-shift below (which requires the
+    // upper 64 bits of `value` to be zero).
+    if value >= fee_to_linear(MAX_EXPONENT) {
+        return MAX_EXPONENT;
+    }
     // Compare in fixed-point for full precision.
-    let target = U256::from(value) << FRAC_BITS;
+    let target = value << FRAC_BITS;
     // Binary search: find smallest n where fee_to_linear_fixed(n) >= target.
     let mut lo: u32 = 0;
     let mut hi: u32 = MAX_EXPONENT as u32 + 1;
@@ -237,11 +216,12 @@ mod tests {
     #[test]
     fn round_trip() {
         for original in [1u64, 10, 100, 1_000, 1_000_000, 1_000_000_000] {
-            let exp = fee_from_linear(original);
+            let original_u256 = U256::from(original);
+            let exp = fee_from_linear(original_u256);
             let recovered = fee_to_linear(exp);
             // Within ~1% of original (0.78% per step, rounding can add half a step).
-            let lo = U256::from(original) * U256::from(99u64) / U256::from(100u64);
-            let hi = U256::from(original) * U256::from(101u64) / U256::from(100u64);
+            let lo = original_u256 * U256::from(99u64) / U256::from(100u64);
+            let hi = original_u256 * U256::from(101u64) / U256::from(100u64);
             assert!(
                 recovered >= lo && recovered <= hi,
                 "round-trip failed for {original}: exp={exp}, recovered={recovered}"
@@ -275,7 +255,7 @@ mod tests {
 
     #[test]
     fn fee_from_linear_zero_and_one() {
-        assert_eq!(fee_from_linear(0), 0);
-        assert_eq!(fee_from_linear(1), 0);
+        assert_eq!(fee_from_linear(U256::ZERO), 0);
+        assert_eq!(fee_from_linear(U256::from(1u64)), 0);
     }
 }

sequencer-core/src/fee.rs

@@ -598,7 +598,7 @@ fn bootstrap_open_frame_with_deposits(db_path: &str, deposits: &[(Address, U256)
 
     let safe_input_count = deposits.len() as u64;
     let leading_range = SafeInputRange::new(0, safe_input_count);
-    // Default log_gas_price=0 → log_recommended_fee = 0+16+327+486 = 1060.
+    // Default log_gas_price=0 → log_recommended_fee = 0+20+419+621 = 1060.
     let head = storage
         .initialize_open_state(1, leading_range)
         .expect("initialize open state");