refactor(inlines): InlineSpec requires InlineOp, implement on same struct

- InlineSpec: InlineOp supertrait — no separate spec structs
- Implement InlineSpec directly on InlineOp structs (Sha256Compression, etc.)
- Remove free functions from spec modules; callers use Struct::reference()
- Keep internal helpers (execute_keccak_f, g, round, etc.) as pub(crate)

Author: 0xAndoroid

jolt-inlines/bigint/src/multiplication/mod.rs

@@ -15,7 +15,5 @@ pub mod sequence_builder;
 #[cfg(feature = "host")]
 pub mod spec;
 
-#[cfg(all(test, feature = "host"))]
-pub mod test_utils;
 #[cfg(all(test, feature = "host"))]
 pub mod tests;

jolt-inlines/bigint/src/multiplication/sdk.rs

@@ -69,8 +69,11 @@ pub unsafe fn bigint256_mul_inline(_a: *const u64, _b: *const u64, _result: *mut
 /// - `result` must point to at least 64 bytes of writable memory
 #[cfg(feature = "host")]
 pub unsafe fn bigint256_mul_inline(a: *const u64, b: *const u64, result: *mut u64) {
+    use crate::multiplication::sequence_builder::BigintMul256;
+    use jolt_inlines_sdk::spec::InlineSpec;
+
     let a_array = *(a as *const [u64; INPUT_LIMBS]);
     let b_array = *(b as *const [u64; INPUT_LIMBS]);
-    let result_array = crate::multiplication::spec::bigint_mul(a_array, b_array);
+    let result_array = BigintMul256::reference(&(a_array, b_array));
     core::ptr::copy_nonoverlapping(result_array.as_ptr(), result, OUTPUT_LIMBS);
 }

jolt-inlines/bigint/src/multiplication/sequence_builder.rs

@@ -2,7 +2,7 @@ use core::array;
 
 use jolt_inlines_sdk::host::{
     instruction::{add::ADD, ld::LD, mul::MUL, mulhu::MULHU, sd::SD, sltu::SLTU},
-    Cpu, FormatInline, InlineOp, InstrAssembler, Instruction, VirtualRegisterGuard,
+    FormatInline, InlineOp, InstrAssembler, Instruction, VirtualRegisterGuard,
 };
 
 use super::{INPUT_LIMBS, OUTPUT_LIMBS};
@@ -155,6 +155,4 @@ impl InlineOp for BigintMul256 {
     fn build_sequence(asm: InstrAssembler, operands: FormatInline) -> Vec<Instruction> {
         BigIntMulSequenceBuilder::new(asm, operands).build()
     }
-
-    fn build_advice(_asm: InstrAssembler, _operands: FormatInline, _cpu: &mut Cpu) {}
 }

jolt-inlines/bigint/src/multiplication/spec.rs

@@ -1,49 +1,45 @@
+use super::sequence_builder::BigintMul256;
 use super::{INPUT_LIMBS, OUTPUT_LIMBS};
 use jolt_inlines_sdk::host::Xlen;
 use jolt_inlines_sdk::spec::{InlineMemoryLayout, InlineSpec, InlineTestHarness, INLINE};
 
-pub fn bigint_mul(lhs: [u64; INPUT_LIMBS], rhs: [u64; INPUT_LIMBS]) -> [u64; OUTPUT_LIMBS] {
-    let mut result = [0u64; OUTPUT_LIMBS];
+impl InlineSpec for BigintMul256 {
+    type Input = ([u64; INPUT_LIMBS], [u64; INPUT_LIMBS]);
+    type Output = [u64; OUTPUT_LIMBS];
+
+    fn reference(input: &Self::Input) -> Self::Output {
+        let (lhs, rhs) = input;
+        let mut result = [0u64; OUTPUT_LIMBS];
 
-    for (i, &lhs_limb) in lhs.iter().enumerate() {
-        for (j, &rhs_limb) in rhs.iter().enumerate() {
-            let product = (lhs_limb as u128) * (rhs_limb as u128);
-            let low = product as u64;
-            let high = (product >> 64) as u64;
+        for (i, &lhs_limb) in lhs.iter().enumerate() {
+            for (j, &rhs_limb) in rhs.iter().enumerate() {
+                let product = (lhs_limb as u128) * (rhs_limb as u128);
+                let low = product as u64;
+                let high = (product >> 64) as u64;
 
-            let result_position = i + j;
+                let result_position = i + j;
 
-            let (sum, carry1) = result[result_position].overflowing_add(low);
-            result[result_position] = sum;
+                let (sum, carry1) = result[result_position].overflowing_add(low);
+                result[result_position] = sum;
 
-            let mut carry = carry1 as u64;
-            if high != 0 || carry != 0 {
-                let (sum_with_hi, carry_hi) = result[result_position + 1].overflowing_add(high);
-                let (sum_with_carry, carry_carry) = sum_with_hi.overflowing_add(carry);
-                result[result_position + 1] = sum_with_carry;
-                carry = (carry_hi as u64) + (carry_carry as u64);
+                let mut carry = carry1 as u64;
+                if high != 0 || carry != 0 {
+                    let (sum_with_hi, carry_hi) = result[result_position + 1].overflowing_add(high);
+                    let (sum_with_carry, carry_carry) = sum_with_hi.overflowing_add(carry);
+                    result[result_position + 1] = sum_with_carry;
+                    carry = (carry_hi as u64) + (carry_carry as u64);
 
-                let mut carry_position = result_position + 2;
-                while carry != 0 && carry_position < OUTPUT_LIMBS {
-                    let (sum, c) = result[carry_position].overflowing_add(carry);
-                    result[carry_position] = sum;
-                    carry = c as u64;
-                    carry_position += 1;
+                    let mut carry_position = result_position + 2;
+                    while carry != 0 && carry_position < OUTPUT_LIMBS {
+                        let (sum, c) = result[carry_position].overflowing_add(carry);
+                        result[carry_position] = sum;
+                        carry = c as u64;
+                        carry_position += 1;
+                    }
                 }
             }
         }
-    }
-    result
-}
-
-pub struct BigintMul256Spec;
-
-impl InlineSpec for BigintMul256Spec {
-    type Input = ([u64; INPUT_LIMBS], [u64; INPUT_LIMBS]);
-    type Output = [u64; OUTPUT_LIMBS];
-
-    fn reference(input: &Self::Input) -> Self::Output {
-        bigint_mul(input.0, input.1)
+        result
     }
 
     fn create_harness() -> InlineTestHarness {

jolt-inlines/bigint/src/multiplication/test_utils.rs

@@ -4,36 +4,29 @@ use super::{INPUT_LIMBS, OUTPUT_LIMBS};
 
 mod bigint256_multiplication {
     use super::TestVectors;
-    use crate::test_utils::bigint_verify;
+    use crate::multiplication::sequence_builder::BigintMul256;
+    use jolt_inlines_sdk::spec;
 
     #[test]
     fn test_bigint256_mul_default() {
-        // Test with the default test vector
-        let (lhs, rhs, expected) = TestVectors::get_default_test();
-        bigint_verify::assert_exec_trace_equiv(&lhs, &rhs, &expected);
+        let (lhs, rhs, _expected) = TestVectors::get_default_test();
+        spec::verify::<BigintMul256>(&(lhs, rhs));
     }
 
     #[test]
     fn test_bigint256_mul_random() {
-        // Test with 100 random inputs
         for _ in 0..100 {
-            let (lhs, rhs, expected) = TestVectors::generate_random_test();
-            bigint_verify::assert_exec_trace_equiv(&lhs, &rhs, &expected);
+            let (lhs, rhs, _expected) = TestVectors::generate_random_test();
+            spec::verify::<BigintMul256>(&(lhs, rhs));
         }
     }
 
     #[test]
     fn test_bigint256_mul_edge_cases() {
-        println!("\n=== Testing BigInt256 multiplication edge cases ===");
-
         let edge_cases = TestVectors::get_edge_cases();
-
-        for (i, (lhs, rhs, expected, description)) in edge_cases.iter().enumerate() {
-            println!("\nEdge case #{}: {}", i + 1, description);
-            bigint_verify::assert_exec_trace_equiv(lhs, rhs, expected);
+        for (lhs, rhs, _expected, _description) in &edge_cases {
+            spec::verify::<BigintMul256>(&(*lhs, *rhs));
         }
-
-        println!("\n✅ All {} edge cases passed!\n", edge_cases.len());
     }
 }
 

jolt-inlines/bigint/src/multiplication/tests.rs

@@ -20,9 +20,6 @@ mod host;
 #[cfg(feature = "host")]
 pub use host::*;
 
-#[cfg(all(test, feature = "host"))]
-pub mod test_utils;
-
 /// Blake2b initialization vector (IV).
 pub const IV: [u64; 8] = [
     0x6a09e667f3bcc908,

jolt-inlines/blake2/src/lib.rs

@@ -401,18 +401,13 @@ pub(crate) unsafe fn blake2b_compress(state: *mut u64, message: *const u64) {
 /// - `message` must point to a valid array of 18 u64 values
 #[cfg(feature = "host")]
 pub(crate) unsafe fn blake2b_compress(state: *mut u64, message: *const u64) {
-    let state_slice = core::slice::from_raw_parts_mut(state, 8);
-    let message_slice = core::slice::from_raw_parts(message, 18);
-
-    // Convert to arrays for type safety
-    let state_array: &mut [u64; 8] = state_slice
-        .try_into()
-        .expect("State pointer must reference exactly 8 u64 values");
-    let message_array: [u64; 18] = message_slice
-        .try_into()
-        .expect("Message pointer must reference exactly 18 u64 values");
-
-    crate::spec::execute_blake2b_compression(state_array, &message_array);
+    use crate::sequence_builder::Blake2bCompression;
+    use jolt_inlines_sdk::spec::InlineSpec;
+
+    let state_array = *(state as *const [u64; 8]);
+    let message_array = *(message as *const [u64; 18]);
+    let result = Blake2bCompression::reference(&(state_array, message_array));
+    core::ptr::copy_nonoverlapping(result.as_ptr(), state, 8);
 }
 
 #[cfg(all(

jolt-inlines/blake2/src/sdk.rs

@@ -17,7 +17,7 @@ use jolt_inlines_sdk::host::{
         sub::SUB,
         virtual_xor_rot::{VirtualXORROT16, VirtualXORROT24, VirtualXORROT32, VirtualXORROT63},
     },
-    Cpu, FormatInline, InlineOp, InstrAssembler, InstrAssemblerExt, Instruction,
+    FormatInline, InlineOp, InstrAssembler, InstrAssemblerExt, Instruction,
     Value::{Imm, Reg},
     VirtualRegisterGuard,
 };
@@ -239,19 +239,14 @@ impl InlineOp for Blake2bCompression {
     fn build_sequence(asm: InstrAssembler, operands: FormatInline) -> Vec<Instruction> {
         Blake2SequenceBuilder::new(asm, operands).build()
     }
-
-    fn build_advice(_asm: InstrAssembler, _operands: FormatInline, _cpu: &mut Cpu) {}
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        test_utils::{create_blake2_harness, instruction, load_blake2_data, read_state},
-        IV,
-    };
+    use crate::IV;
+    use jolt_inlines_sdk::spec::InlineSpec;
 
     fn generate_default_input() -> ([u64; crate::MSG_BLOCK_LEN], u64) {
-        // Message block with "abc" in little-endian
         let mut message = [0u64; crate::MSG_BLOCK_LEN];
         message[0] = 0x0000000000636261u64;
         (message, 3)
@@ -294,13 +289,18 @@ mod tests {
         counter: u64,
         is_final: bool,
     ) -> [u64; crate::STATE_VECTOR_LEN] {
-        let mut harness = create_blake2_harness();
-        load_blake2_data(&mut harness, state, message, counter, is_final);
-        harness.execute_inline(instruction());
-        read_state(&mut harness)
+        let mut combined = [0u64; 18];
+        combined[..16].copy_from_slice(message);
+        combined[16] = counter;
+        combined[17] = is_final as u64;
+
+        let input = (*state, combined);
+        let mut harness = super::Blake2bCompression::create_harness();
+        super::Blake2bCompression::load(&mut harness, &input);
+        harness.execute_inline(super::Blake2bCompression::instruction());
+        super::Blake2bCompression::read(&mut harness)
     }
 
-    /// Helper function to test blake2b compression with given input
     fn verify_blake2b_compression(message_words: [u64; crate::MSG_BLOCK_LEN], message_len: u64) {
         let mut initial_state = IV;
         initial_state[0] ^= 0x01010000 ^ 64u64;
@@ -310,7 +310,7 @@ mod tests {
 
         assert_eq!(
             &expected_state, &trace_result,
-            "\n❌ BLAKE2b Trace Verification Failed!\n\
+            "\nBLAKE2b Trace Verification Failed!\n\
             Message: {message_words:016x?}"
         );
     }
@@ -323,7 +323,6 @@ mod tests {
 
     #[test]
     fn test_trace_result_with_random_inputs() {
-        // Test with multiple random inputs
         for _ in 0..10 {
             let input = generate_random_input();
             verify_blake2b_compression(input.0, input.1);