Scroll dev 0807

core/src/cpu/trace.rs

@@ -711,12 +711,29 @@ impl CpuChip {
             }
 
             // Write the syscall nonce.
-            ecall_cols.syscall_nonce = F::from_canonical_u32(
-                nonce_lookup
-                    .get(&event.syscall_lookup_id)
-                    .copied()
-                    .unwrap_or_default(),
+            let syscall_nonce = nonce_lookup
+                .get(&event.syscall_lookup_id)
+                .copied()
+                .unwrap_or_default();
+            ecall_cols.syscall_nonce = F::from_canonical_u32(syscall_nonce);
+
+            // FIXME
+
+            if syscall_id == F::from_canonical_u32(SyscallCode::MEMCPY_32.syscall_id())
+                || syscall_id == F::from_canonical_u32(SyscallCode::MEMCPY_64.syscall_id())
+                || syscall_id == F::from_canonical_u32(SyscallCode::BN254_SCALAR_MAC.syscall_id())
+                || syscall_id == F::from_canonical_u32(SyscallCode::BN254_SCALAR_MUL.syscall_id())
+            {
+                ecall_cols.syscall_nonce = F::from_canonical_u32(0);
+            }
+
+            /*
+            log::info!(
+                "populate_ecall syscall_lookup_id {} syscall_nonce {} syscall_id {syscall_id:?}",
+                event.syscall_lookup_id,
+                syscall_nonce
             );
+            */
 
             is_halt = syscall_id == F::from_canonical_u32(SyscallCode::HALT.syscall_id());
 

core/src/lib.rs

@@ -37,4 +37,4 @@ use stark::StarkGenericConfig;
 /// This string should be updated whenever any step in verifying an SP1 proof changes, including
 /// core, recursion, and plonk-bn254. This string is used to download SP1 artifacts and the gnark
 /// docker image.
-pub const SP1_CIRCUIT_VERSION: &str = "v1.1.0";
+pub const SP1_CIRCUIT_VERSION: &str = "v1.1.0-scroll";

core/src/runtime/mod.rs

@@ -679,6 +679,10 @@ impl<'a> Runtime<'a> {
                 let value = (memory_read_value).to_le_bytes()[(addr % 4) as usize];
                 a = ((value as i8) as i32) as u32;
                 memory_store_value = Some(memory_read_value);
+                //println!(
+                //    "[clk: {}, pc: 0x{:x}] LB: {:?} <- {:x}",
+                //    self.state.global_clk, self.state.pc, rd, a
+                //);
                 self.rw(rd, a);
             }
             Opcode::LH => {
@@ -693,6 +697,10 @@ impl<'a> Runtime<'a> {
                 };
                 a = ((value as i16) as i32) as u32;
                 memory_store_value = Some(memory_read_value);
+                //println!(
+                //    "[clk: {}, pc: 0x{:x}] LH: {:?} <- {:x}",
+                //    self.state.global_clk, self.state.pc, rd, a
+                //);
                 self.rw(rd, a);
             }
             Opcode::LW => {
@@ -702,6 +710,10 @@ impl<'a> Runtime<'a> {
                 }
                 a = memory_read_value;
                 memory_store_value = Some(memory_read_value);
+                //println!(
+                //    "[clk: {}, pc: 0x{:x}] LW: {:?} <- {}",
+                //    self.state.global_clk, self.state.pc, rd, a
+                //);
                 self.rw(rd, a);
             }
             Opcode::LBU => {
@@ -737,6 +749,10 @@ impl<'a> Runtime<'a> {
                     _ => unreachable!(),
                 };
                 memory_store_value = Some(value);
+                //println!(
+                //    "[clk: {}, pc: 0x{:x}] SB 0x{:x} <- 0x{:x}",
+                //    self.state.global_clk, pc, addr, value
+                //);
                 self.mw_cpu(align(addr), value, MemoryAccessPosition::Memory);
             }
             Opcode::SH => {
@@ -750,6 +766,10 @@ impl<'a> Runtime<'a> {
                     _ => unreachable!(),
                 };
                 memory_store_value = Some(value);
+                //println!(
+                //    "[clk: {}, pc: 0x{:x}] SH 0x{:x} <- 0x{:x}",
+                //    self.state.global_clk, pc, addr, value
+                //);
                 self.mw_cpu(align(addr), value, MemoryAccessPosition::Memory);
             }
             Opcode::SW => {
@@ -759,6 +779,10 @@ impl<'a> Runtime<'a> {
                 }
                 let value = a;
                 memory_store_value = Some(value);
+                //println!(
+                //    "[clk: {}, pc: 0x{:x}] SW 0x{:x} <- 0x{:x}",
+                //    self.state.global_clk, pc, addr, value
+                //);
                 self.mw_cpu(align(addr), value, MemoryAccessPosition::Memory);
             }
 
@@ -842,9 +866,18 @@ impl<'a> Runtime<'a> {
                         .or_insert(1);
                 }
 
+                let global_clk = self.state.global_clk;
                 let syscall_impl = self.get_syscall(syscall).cloned();
                 let mut precompile_rt = SyscallContext::new(self);
                 precompile_rt.syscall_lookup_id = syscall_lookup_id;
+                log::trace!(
+                    "[clk: {}, pc: 0x{:x}] ecall syscall_id=0x{:x}, b: 0x{:x}, c: 0x{:x}",
+                    global_clk,
+                    pc,
+                    syscall_id,
+                    b,
+                    c,
+                );
                 let (precompile_next_pc, precompile_cycles, returned_exit_code) =
                     if let Some(syscall_impl) = syscall_impl {
                         // Executing a syscall optionally returns a value to write to the t0 register.
@@ -896,7 +929,20 @@ impl<'a> Runtime<'a> {
                     _ => (self.opts.split_opts.deferred_shift_threshold, 1),
                 };
                 let nonce = (((*syscall_count as usize) % threshold) * multiplier) as u32;
-                self.record.nonce_lookup.insert(syscall_lookup_id, nonce);
+                // FIXME
+                match syscall {
+                    SyscallCode::BN254_SCALAR_MAC
+                    | SyscallCode::BN254_SCALAR_MUL
+                    | SyscallCode::MEMCPY_32
+                    | SyscallCode::MEMCPY_64 => {}
+                    _ => {
+                        self.record.nonce_lookup.insert(syscall_lookup_id, nonce);
+                    }
+                }
+
+                //log::info!(
+                //    "execute_instruction {syscall:?} {syscall_count} {nonce} {syscall_lookup_id}"
+                //);
                 *syscall_count += 1;
             }
             Opcode::EBREAK => {

core/src/runtime/record.rs

@@ -17,12 +17,14 @@ use crate::cpu::CpuEvent;
 use crate::runtime::MemoryInitializeFinalizeEvent;
 use crate::runtime::MemoryRecordEnum;
 use crate::stark::MachineRecord;
+use crate::syscall::precompiles::bn254_scalar::Bn254FieldArithEvent;
 use crate::syscall::precompiles::edwards::EdDecompressEvent;
 use crate::syscall::precompiles::keccak256::KeccakPermuteEvent;
 use crate::syscall::precompiles::sha256::{ShaCompressEvent, ShaExtendEvent};
 use crate::syscall::precompiles::uint256::Uint256MulEvent;
 use crate::syscall::precompiles::ECDecompressEvent;
 use crate::syscall::precompiles::{ECAddEvent, ECDoubleEvent};
+use crate::syscall::MemCopyEvent;
 use crate::utils::SP1CoreOpts;
 
 /// A record of the execution of a program.
@@ -84,6 +86,9 @@ pub struct ExecutionRecord {
 
     pub bn254_double_events: Vec<ECDoubleEvent>,
 
+    pub bn254_scalar_mul_events: Vec<Bn254FieldArithEvent>,
+    pub bn254_scalar_mac_events: Vec<Bn254FieldArithEvent>,
+
     pub k256_decompress_events: Vec<ECDecompressEvent>,
 
     pub bls12381_add_events: Vec<ECAddEvent>,
@@ -98,6 +103,9 @@ pub struct ExecutionRecord {
 
     pub bls12381_decompress_events: Vec<ECDecompressEvent>,
 
+    pub memcpy32_events: Vec<MemCopyEvent>,
+    pub memcpy64_events: Vec<MemCopyEvent>,
+
     /// The public values.
     pub public_values: PublicValues<u32, u32>,
 
@@ -195,6 +203,19 @@ impl MachineRecord for ExecutionRecord {
             "bls12381_decompress_events".to_string(),
             self.bls12381_decompress_events.len(),
         );
+
+        stats.insert(
+            "bn254_scalar_mul_events".to_string(),
+            self.bn254_scalar_mul_events.len(),
+        );
+        stats.insert(
+            "bn254_scalar_mac_events".to_string(),
+            self.bn254_scalar_mac_events.len(),
+        );
+
+        stats.insert("memcpy32_events".to_string(), self.memcpy32_events.len());
+        stats.insert("memcpy64_events".to_string(), self.memcpy64_events.len());
+
         stats.insert(
             "memory_initialize_events".to_string(),
             self.memory_initialize_events.len(),
@@ -251,6 +272,12 @@ impl MachineRecord for ExecutionRecord {
             .append(&mut other.uint256_mul_events);
         self.bls12381_decompress_events
             .append(&mut other.bls12381_decompress_events);
+        self.bn254_scalar_mul_events
+            .append(&mut other.bn254_scalar_mul_events);
+        self.bn254_scalar_mac_events
+            .append(&mut other.bn254_scalar_mac_events);
+        self.memcpy32_events.append(&mut other.memcpy32_events);
+        self.memcpy64_events.append(&mut other.memcpy64_events);
 
         if self.byte_lookups.is_empty() {
             self.byte_lookups = std::mem::take(&mut other.byte_lookups);
@@ -278,6 +305,34 @@ impl MachineRecord for ExecutionRecord {
             self.nonce_lookup.insert(event.lookup_id, i as u32);
         });
 
+        /*
+                self.memcpy32_events
+                    .iter()
+                    .enumerate()
+                    .for_each(|(i, event)| {
+                        self.nonce_lookup.insert(event.lookup_id, i as u32);
+                    });
+
+                self.memcpy64_events
+                    .iter()
+                    .enumerate()
+                    .for_each(|(i, event)| {
+                        self.nonce_lookup.insert(event.lookup_id, i as u32);
+                    });
+
+                self.bn254_scalar_mul_events
+                    .iter()
+                    .enumerate()
+                    .for_each(|(i, event)| {
+                        self.nonce_lookup.insert(event.lookup_id, i as u32);
+                    });
+                self.bn254_scalar_mac_events
+                    .iter()
+                    .enumerate()
+                    .for_each(|(i, event)| {
+                        self.nonce_lookup.insert(event.lookup_id, i as u32);
+                    });
+        */
         self.bitwise_events
             .iter()
             .enumerate()
@@ -375,6 +430,10 @@ impl ExecutionRecord {
             secp256k1_double_events: std::mem::take(&mut self.secp256k1_double_events),
             bn254_add_events: std::mem::take(&mut self.bn254_add_events),
             bn254_double_events: std::mem::take(&mut self.bn254_double_events),
+            bn254_scalar_mul_events: std::mem::take(&mut self.bn254_scalar_mul_events),
+            bn254_scalar_mac_events: std::mem::take(&mut self.bn254_scalar_mac_events),
+            memcpy32_events: std::mem::take(&mut self.memcpy32_events),
+            memcpy64_events: std::mem::take(&mut self.memcpy64_events),
             bls12381_add_events: std::mem::take(&mut self.bls12381_add_events),
             bls12381_double_events: std::mem::take(&mut self.bls12381_double_events),
             sha_extend_events: std::mem::take(&mut self.sha_extend_events),
@@ -513,6 +572,34 @@ impl ExecutionRecord {
             opts.deferred_shift_threshold,
             last
         );
+        split_events!(
+            self,
+            memcpy32_events,
+            shards,
+            opts.deferred_shift_threshold,
+            last
+        );
+        split_events!(
+            self,
+            memcpy64_events,
+            shards,
+            opts.deferred_shift_threshold,
+            last
+        );
+        split_events!(
+            self,
+            bn254_scalar_mul_events,
+            shards,
+            opts.deferred_shift_threshold,
+            last
+        );
+        split_events!(
+            self,
+            bn254_scalar_mac_events,
+            shards,
+            opts.deferred_shift_threshold,
+            last
+        );
         split_events!(
             self,
             bls12381_decompress_events,

core/src/runtime/syscall.rs

@@ -4,8 +4,10 @@ use std::sync::Arc;
 
 use serde::{Deserialize, Serialize};
 use strum_macros::EnumIter;
+use typenum::{U16, U32, U64, U8};
 
 use crate::runtime::{Register, Runtime};
+use crate::syscall::precompiles::bn254_scalar::{Bn254ScalarMacChip, Bn254ScalarMulChip};
 use crate::syscall::precompiles::edwards::EdAddAssignChip;
 use crate::syscall::precompiles::edwards::EdDecompressChip;
 use crate::syscall::precompiles::keccak256::KeccakPermuteChip;
@@ -15,8 +17,9 @@ use crate::syscall::precompiles::weierstrass::WeierstrassAddAssignChip;
 use crate::syscall::precompiles::weierstrass::WeierstrassDecompressChip;
 use crate::syscall::precompiles::weierstrass::WeierstrassDoubleAssignChip;
 use crate::syscall::{
-    SyscallCommit, SyscallCommitDeferred, SyscallEnterUnconstrained, SyscallExitUnconstrained,
-    SyscallHalt, SyscallHintLen, SyscallHintRead, SyscallVerifySP1Proof, SyscallWrite,
+    MemCopyChip, SyscallCommit, SyscallCommitDeferred, SyscallEnterUnconstrained,
+    SyscallExitUnconstrained, SyscallHalt, SyscallHintLen, SyscallHintRead, SyscallVerifySP1Proof,
+    SyscallWrite,
 };
 use crate::utils::ec::edwards::ed25519::{Ed25519, Ed25519Parameters};
 use crate::utils::ec::weierstrass::bls12_381::Bls12381;
@@ -102,6 +105,18 @@ pub enum SyscallCode {
 
     /// Executes the `BLS12381_DOUBLE` precompile.
     BLS12381_DOUBLE = 0x00_00_01_1F,
+
+    /// Execute the `BN254_SCALAR_MUL` precompile.
+    BN254_SCALAR_MUL = 0x00_01_01_20,
+
+    /// Execute the `BN254_SCALAR_MAC` precompile.
+    BN254_SCALAR_MAC = 0x00_01_01_21,
+
+    /// Execute the `MEMCPY_32` precompile.
+    MEMCPY_32 = 0x00_00_01_30,
+
+    /// Execute the `MEMCPY_64` precompile.
+    MEMCPY_64 = 0x00_00_01_31,
 }
 
 impl SyscallCode {
@@ -131,6 +146,10 @@ impl SyscallCode {
             0x00_00_00_F1 => SyscallCode::HINT_READ,
             0x00_01_01_1D => SyscallCode::UINT256_MUL,
             0x00_00_01_1C => SyscallCode::BLS12381_DECOMPRESS,
+            0x00_01_01_20 => SyscallCode::BN254_SCALAR_MUL,
+            0x00_01_01_21 => SyscallCode::BN254_SCALAR_MAC,
+            0x00_00_01_30 => SyscallCode::MEMCPY_32,
+            0x00_00_01_31 => SyscallCode::MEMCPY_64,
             _ => panic!("invalid syscall number: {}", value),
         }
     }
@@ -338,6 +357,23 @@ pub fn default_syscall_map() -> HashMap<SyscallCode, Arc<dyn Syscall>> {
         Arc::new(WeierstrassDecompressChip::<Bls12381>::with_lexicographic_rule()),
     );
     syscall_map.insert(SyscallCode::UINT256_MUL, Arc::new(Uint256MulChip::new()));
+    syscall_map.insert(
+        SyscallCode::BN254_SCALAR_MUL,
+        Arc::new(Bn254ScalarMulChip::new()),
+    );
+    syscall_map.insert(
+        SyscallCode::BN254_SCALAR_MAC,
+        Arc::new(Bn254ScalarMacChip::new()),
+    );
+
+    syscall_map.insert(
+        SyscallCode::MEMCPY_32,
+        Arc::new(MemCopyChip::<U8, U32>::new()),
+    );
+    syscall_map.insert(
+        SyscallCode::MEMCPY_64,
+        Arc::new(MemCopyChip::<U16, U64>::new()),
+    );
 
     syscall_map
 }
@@ -428,6 +464,14 @@ mod tests {
                 SyscallCode::BLS12381_DECOMPRESS => {
                     assert_eq!(code as u32, sp1_zkvm::syscalls::BLS12381_DECOMPRESS)
                 }
+                SyscallCode::BN254_SCALAR_MUL => {
+                    assert_eq!(code as u32, sp1_zkvm::syscalls::BN254_SCALAR_MUL)
+                }
+                SyscallCode::BN254_SCALAR_MAC => {
+                    assert_eq!(code as u32, sp1_zkvm::syscalls::BN254_SCALAR_MAC)
+                }
+                SyscallCode::MEMCPY_32 => todo!(),
+                SyscallCode::MEMCPY_64 => todo!(),
             }
         }
     }