From 35085fbe647b64787a94e0d0ede355a69ae5081b Mon Sep 17 00:00:00 2001 From: Artem Storozhuk Date: Mon, 23 Sep 2024 16:51:21 +0300 Subject: [PATCH] feat: Introduce Add3 operation --- core/src/operations/add3.rs | 134 ++++++++++++++++++ core/src/operations/mod.rs | 2 + core/src/syscall/precompiles/blake2s/air.rs | 94 +++++------- .../syscall/precompiles/blake2s/columns.rs | 9 +- .../syscall/precompiles/blake2s/execute.rs | 2 +- core/src/syscall/precompiles/blake2s/mod.rs | 12 +- core/src/syscall/precompiles/blake2s/trace.rs | 77 ++-------- tests/blake2s-round/Cargo.lock | 2 +- tests/blake2s-round/Cargo.toml | 2 +- .../elf/riscv32im-succinct-zkvm-elf | Bin 22700 -> 22700 bytes tests/blake2s-round/src/main.rs | 2 +- 11 files changed, 190 insertions(+), 146 deletions(-) create mode 100644 core/src/operations/add3.rs diff --git a/core/src/operations/add3.rs b/core/src/operations/add3.rs new file mode 100644 index 000000000..0366f79ae --- /dev/null +++ b/core/src/operations/add3.rs @@ -0,0 +1,134 @@ +use p3_air::AirBuilder; +use p3_field::{AbstractField, Field}; +use sphinx_derive::AlignedBorrow; + +use crate::air::Word; +use crate::air::WordAirBuilder; +use crate::air::WORD_SIZE; +use crate::bytes::event::ByteRecord; + +/// A set of columns needed to compute the add of three words. +#[derive(AlignedBorrow, Default, Debug, Clone, Copy)] +#[repr(C)] +pub struct Add3Operation { + /// The result of `a + b + c`. + pub value: Word, + + /// Indicates if the carry for the `i`th digit is 0. + pub is_carry_0: Word, + + /// Indicates if the carry for the `i`th digit is 1. + pub is_carry_1: Word, + + /// Indicates if the carry for the `i`th digit is 2. The carry when adding 3 words is at most 2. + pub is_carry_2: Word, + + /// The carry for the `i`th digit. + pub carry: Word, +} + +impl Add3Operation { + pub fn populate( + &mut self, + record: &mut impl ByteRecord, + shard: u32, + channel: u32, + a_u32: u32, + b_u32: u32, + c_u32: u32, + ) -> u32 { + let expected = a_u32.wrapping_add(b_u32).wrapping_add(c_u32); + + self.value = Word::from(expected); + let a = a_u32.to_le_bytes(); + let b = b_u32.to_le_bytes(); + let c = c_u32.to_le_bytes(); + + let base = 256; + let mut carry = [0u8, 0u8, 0u8, 0u8]; + for i in 0..WORD_SIZE { + let mut res = u32::from(a[i]) + u32::from(b[i]) + u32::from(c[i]); + if i > 0 { + res += u32::from(carry[i - 1]); + } + carry[i] = (res / base) as u8; + self.is_carry_0[i] = F::from_bool(carry[i] == 0); + self.is_carry_1[i] = F::from_bool(carry[i] == 1); + self.is_carry_2[i] = F::from_bool(carry[i] == 2); + self.carry[i] = F::from_canonical_u8(carry[i]); + debug_assert!(carry[i] <= 2); + debug_assert_eq!(self.value[i], F::from_canonical_u32(res % base)); + } + + // Range check. + { + record.add_u8_range_checks(shard, channel, &a); + record.add_u8_range_checks(shard, channel, &b); + record.add_u8_range_checks(shard, channel, &c); + record.add_u8_range_checks(shard, channel, &expected.to_le_bytes()); + } + expected + } + + pub fn eval>( + builder: &mut AB, + a: Word, + b: Word, + c: Word, + shard: AB::Var, + channel: impl Into + Copy, + is_real: AB::Var, + cols: Add3Operation, + ) { + // Range check each byte. + { + builder.slice_range_check_u8(&a.0, shard, channel, is_real); + builder.slice_range_check_u8(&b.0, shard, channel, is_real); + builder.slice_range_check_u8(&c.0, shard, channel, is_real); + builder.slice_range_check_u8(&cols.value.0, shard, channel, is_real); + } + + builder.assert_bool(is_real); + let mut builder_is_real = builder.when(is_real); + + // Each value in is_carry_{0,1,2,3} is 0 or 1, and exactly one of them is 1 per digit. + { + for i in 0..WORD_SIZE { + builder_is_real.assert_bool(cols.is_carry_0[i]); + builder_is_real.assert_bool(cols.is_carry_1[i]); + builder_is_real.assert_bool(cols.is_carry_2[i]); + builder_is_real.assert_eq( + cols.is_carry_0[i] + cols.is_carry_1[i] + cols.is_carry_2[i], + AB::Expr::one(), + ); + } + } + + // Calculates carry from is_carry_{0,1,2}. + { + let one = AB::Expr::one(); + let two = AB::F::from_canonical_u32(2); + + for i in 0..WORD_SIZE { + builder_is_real.assert_eq( + cols.carry[i], + cols.is_carry_1[i] * one.clone() + cols.is_carry_2[i] * two, + ); + } + } + + // Compare the sum and summands by looking at carry. + { + let base = AB::F::from_canonical_u32(256); + // For each limb, assert that difference between the carried result and the non-carried + // result is the product of carry and base. + for i in 0..WORD_SIZE { + let mut overflow = a[i] + b[i] + c[i] - cols.value[i]; + if i > 0 { + overflow += cols.carry[i - 1].into(); + } + builder_is_real.assert_eq(cols.carry[i] * base, overflow.clone()); + } + } + } +} diff --git a/core/src/operations/mod.rs b/core/src/operations/mod.rs index e3fbcc78b..52a17847d 100644 --- a/core/src/operations/mod.rs +++ b/core/src/operations/mod.rs @@ -5,6 +5,7 @@ //! the constraints. mod add; +mod add3; mod add4; mod add5; mod and; @@ -21,6 +22,7 @@ mod or; mod xor; pub use add::*; +pub use add3::*; pub use add4::*; pub use add5::*; pub use and::*; diff --git a/core/src/syscall/precompiles/blake2s/air.rs b/core/src/syscall/precompiles/blake2s/air.rs index d70f0d6f2..d054431dc 100644 --- a/core/src/syscall/precompiles/blake2s/air.rs +++ b/core/src/syscall/precompiles/blake2s/air.rs @@ -1,5 +1,5 @@ use crate::memory::MemoryCols; -use crate::operations::{Add4Operation, FixedRotateRightOperation, XorOperation}; +use crate::operations::{Add3Operation, AddOperation, FixedRotateRightOperation, XorOperation}; use crate::runtime::SyscallCode; use crate::stark::SphinxAirBuilder; use crate::syscall::precompiles::blake2s::columns::Blake2sRoundCols; @@ -55,18 +55,6 @@ where ); } - // Eval extra-zeroes - for i in 16..24usize { - builder.eval_memory_access( - local.shard, - local.channel, - local.clk, - local.b_ptr + AB::F::from_canonical_u32((i as u32) * 4), - &local.b[i], - local.is_real, - ); - } - let v1_shuffle_lookup = [1, 2, 3, 0]; let v2_shuffle_lookup = [2, 3, 0, 1]; let v3_shuffle_lookup = [3, 0, 1, 2]; @@ -75,23 +63,22 @@ where // 1x // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); - Add4Operation::::eval( + Add3Operation::::eval( builder, *local.a[i].prev_value(), // v0 *local.a[i + 4].prev_value(), // v1 *local.b[i].value(), // m1 - *local.b[i + 20].value(), // zero1 local.shard, local.channel, local.is_real, - local.add[i], + local.add3[i], ); // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); XorOperation::::eval( builder, *local.a[i + 12].prev_value(), - local.add[i].value, + local.add3[i].value, local.xor[i], local.shard, &local.channel, @@ -108,23 +95,21 @@ where ); // v[2] = v[2].wrapping_add(v[3]); - Add4Operation::::eval( + AddOperation::::eval( builder, *local.a[i + 8].prev_value(), // v2 local.rotate_right[i].value, // v3 from previous operation - *local.b[i + 16].value(), // zero1 - *local.b[i + 20].value(), // zero2 + local.add2[i], local.shard, local.channel, - local.is_real, - local.add[i + 4], + local.is_real.into(), ); // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); XorOperation::::eval( builder, *local.a[i + 4].prev_value(), - local.add[i + 4].value, + local.add2[i].value, local.xor[i + 4], local.shard, &local.channel, @@ -143,23 +128,22 @@ where // 2x // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); - Add4Operation::::eval( + Add3Operation::::eval( builder, - local.add[i].value, // v0 after 1x + local.add3[i].value, // v0 after 1x local.rotate_right[i + 4].value, // v1 after 1x *local.b[i + 4].value(), // m2 - *local.b[i + 16].value(), // zero1 local.shard, local.channel, local.is_real, - local.add[i + 8], + local.add3[i + 4], ); // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); XorOperation::::eval( builder, local.rotate_right[i].value, // v3 after 1x - local.add[i + 8].value, // v0 after 1x + local.add3[i + 4].value, // v0 after 1x local.xor[i + 8], local.shard, &local.channel, @@ -176,23 +160,21 @@ where ); // v[2] = v[2].wrapping_add(v[3]); - Add4Operation::::eval( + AddOperation::::eval( builder, - local.add[i + 4].value, // v2 after 1x + local.add2[i].value, // v2 after 1x local.rotate_right[i + 8].value, // v3 after previous operation - *local.b[i + 16].value(), // zero1 - *local.b[i + 20].value(), // zero2 + local.add2[i + 4], local.shard, local.channel, - local.is_real, - local.add[i + 12], + local.is_real.into(), ); // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); XorOperation::::eval( builder, local.rotate_right[i + 4].value, // v1 after 1x - local.add[i + 12].value, // v2 after previous operation + local.add2[i + 4].value, // v2 after previous operation local.xor[i + 12], local.shard, &local.channel, @@ -215,23 +197,22 @@ where // 3x // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); - Add4Operation::::eval( + Add3Operation::::eval( builder, - local.add[i + 8].value, // v0 after 2x + local.add3[i + 4].value, // v0 after 2x local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x *local.b[i + 8].value(), // m3 - *local.b[i + 16].value(), // zero1 local.shard, local.channel, local.is_real, - local.add[i + 16], + local.add3[i + 8], ); // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); XorOperation::::eval( builder, local.rotate_right[v3_shuffle_lookup[i] + 8].value, // v3 after 2x - local.add[i + 16].value, // v0 after previous operation + local.add3[i + 8].value, // v0 after previous operation local.xor[i + 16], local.shard, &local.channel, @@ -248,23 +229,21 @@ where ); // v[2] = v[2].wrapping_add(v[3]); - Add4Operation::::eval( + AddOperation::::eval( builder, - local.add[v2_shuffle_lookup[i] + 12].value, // v2 after 2x + local.add2[v2_shuffle_lookup[i] + 4].value, // v2 after 2x local.rotate_right[i + 16].value, // v3 after previous operation - *local.b[i + 16].value(), // zero1 - *local.b[i + 20].value(), // zero2 + local.add2[i + 8], local.shard, local.channel, - local.is_real, - local.add[i + 20], + local.is_real.into(), ); // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); XorOperation::::eval( builder, local.rotate_right[v1_shuffle_lookup[i] + 12].value, // v1 after 2x - local.add[i + 20].value, // v2 after previous operation + local.add2[i + 8].value, // v2 after previous operation local.xor[i + 20], local.shard, &local.channel, @@ -282,23 +261,22 @@ where // 4x // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); - Add4Operation::::eval( + Add3Operation::::eval( builder, - local.add[i + 16].value, // v0 after 3x + local.add3[i + 8].value, // v0 after 3x local.rotate_right[i + 20].value, // v1 after 3x *local.b[i + 12].value(), // m4 - *local.b[i + 16].value(), // zero1 local.shard, local.channel, local.is_real, - local.add[i + 24], + local.add3[i + 12], ); // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); XorOperation::::eval( builder, local.rotate_right[i + 16].value, // v3 after 3x - local.add[i + 24].value, // v0 after previous operation + local.add3[i + 12].value, // v0 after previous operation local.xor[i + 24], local.shard, &local.channel, @@ -315,23 +293,21 @@ where ); // v[2] = v[2].wrapping_add(v[3]); - Add4Operation::::eval( + AddOperation::::eval( builder, - local.add[i + 20].value, // v2 after 3x + local.add2[i + 8].value, // v2 after 3x local.rotate_right[i + 24].value, // v3 after previous operation - *local.b[i + 16].value(), // zero1 - *local.b[i + 20].value(), // zero2 + local.add2[i + 12], local.shard, local.channel, - local.is_real, - local.add[i + 28], + local.is_real.into(), ); // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); XorOperation::::eval( builder, local.rotate_right[i + 20].value, // v1 after 3x - local.add[i + 28].value, // v2 after previous operation + local.add2[i + 12].value, // v2 after previous operation local.xor[i + 28], local.shard, &local.channel, diff --git a/core/src/syscall/precompiles/blake2s/columns.rs b/core/src/syscall/precompiles/blake2s/columns.rs index a684fd9f0..1d17a2108 100644 --- a/core/src/syscall/precompiles/blake2s/columns.rs +++ b/core/src/syscall/precompiles/blake2s/columns.rs @@ -1,5 +1,5 @@ use crate::memory::{MemoryReadCols, MemoryWriteCols}; -use crate::operations::{Add4Operation, FixedRotateRightOperation, XorOperation}; +use crate::operations::{Add3Operation, AddOperation, FixedRotateRightOperation, XorOperation}; use sphinx_derive::AlignedBorrow; #[derive(Debug, Clone, AlignedBorrow)] @@ -27,13 +27,12 @@ pub struct Blake2sRoundCols { /// m1[0] || m1[1] || m1[2] || m1[3] || /// m2[0] || m2[1] || m2[2] || m2[3] || /// m3[0] || m3[1] || m3[2] || m3[3] || - /// 0 || 0 || 0 || 0 || - /// 0 || 0 || 0 || 0 || /// pub a: [MemoryWriteCols; 16], - pub b: [MemoryReadCols; 24], + pub b: [MemoryReadCols; 16], - pub add: [Add4Operation; 32], + pub add3: [Add3Operation; 16], + pub add2: [AddOperation; 16], pub xor: [XorOperation; 32], pub rotate_right: [FixedRotateRightOperation; 32], } diff --git a/core/src/syscall/precompiles/blake2s/execute.rs b/core/src/syscall/precompiles/blake2s/execute.rs index c4e7b5d0d..6a568a1a5 100644 --- a/core/src/syscall/precompiles/blake2s/execute.rs +++ b/core/src/syscall/precompiles/blake2s/execute.rs @@ -16,7 +16,7 @@ impl Syscall for Blake2sRoundChip { let mut a = ctx.slice_unsafe(a_ptr, 16); let mut a_clone = a.clone(); - let (b_reads, b) = ctx.mr_slice(b_ptr, 24); + let (b_reads, b) = ctx.mr_slice(b_ptr, 16); // 1x (m0, R1, R2) // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m1) diff --git a/core/src/syscall/precompiles/blake2s/mod.rs b/core/src/syscall/precompiles/blake2s/mod.rs index db178b42f..ca52c776d 100644 --- a/core/src/syscall/precompiles/blake2s/mod.rs +++ b/core/src/syscall/precompiles/blake2s/mod.rs @@ -145,10 +145,7 @@ fn round(v: &mut [[u32; 4]], m: [u32; 16], s: [usize; 16]) { pub fn blake2s_round(v: &mut [u32], m: &[u32]) { assert_eq!(v.len(), 16); - assert_eq!(m.len(), 24); - for item in m[16..24].iter() { - assert_eq!(*item, 0u32); - } + assert_eq!(m.len(), 16); let r1 = 16; let r2 = 12; @@ -186,7 +183,7 @@ mod tests { use crate::Program; use rand::Rng; - fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 16], b: [u32; 24]) -> Program { + fn risc_v_program(a_ptr: u32, b_ptr: u32, a: [u32; 16], b: [u32; 16]) -> Program { let mut instructions = vec![]; // memory write a for (index, word) in a.into_iter().enumerate() { @@ -240,10 +237,7 @@ mod tests { let a = rand::thread_rng().gen::<[u32; 16]>(); let mut a_clone = a; - let mut b = rand::thread_rng().gen::<[u32; 24]>(); - for item in b[0..24].iter_mut() { - *item = 0; - } + let b = rand::thread_rng().gen::<[u32; 16]>(); blake2s_round(&mut a_clone, &b); diff --git a/core/src/syscall/precompiles/blake2s/trace.rs b/core/src/syscall/precompiles/blake2s/trace.rs index d710f0fd8..8159d8c73 100644 --- a/core/src/syscall/precompiles/blake2s/trace.rs +++ b/core/src/syscall/precompiles/blake2s/trace.rs @@ -56,12 +56,6 @@ impl MachineAir for Blake2sRoundChip { cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events); } - // populate extra-zeroes - // TODO: replace Add4 with Add3 operation and avoid this - for i in 16..24usize { - cols.b[i].populate(event.channel, event.b_reads[i], &mut new_byte_lookup_events); - } - let mut v0_outer = [0u32; 4]; let mut v1_outer = [0u32; 4]; let mut v2_outer = [0u32; 4]; @@ -74,13 +68,9 @@ impl MachineAir for Blake2sRoundChip { let v2 = event.a_reads_writes[i + 8].prev_value; let v3 = event.a_reads_writes[i + 12].prev_value; let m1 = event.b_reads[i].value; - let zero1 = event.b_reads[i + 16].value; - let zero2 = event.b_reads[i + 20].value; - assert_eq!(zero1, 0); - assert_eq!(zero2, 0); // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); - let v0_new = cols.add[i].populate(output, shard, event.channel, v0, v1, m1, zero1); + let v0_new = cols.add3[i].populate(output, shard, event.channel, v0, v1, m1); // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); let temp = cols.xor[i].populate(output, shard, event.channel, v3, v0_new); @@ -88,15 +78,7 @@ impl MachineAir for Blake2sRoundChip { cols.rotate_right[i].populate(output, shard, event.channel, temp, R_1 as usize); // v[2] = v[2].wrapping_add(v[3]); - let v2_new = cols.add[i + 4].populate( - output, - shard, - event.channel, - v2, - v3_new, - zero1, - zero2, - ); + let v2_new = cols.add2[i].populate(output, shard, event.channel, v2, v3_new); // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); let temp = cols.xor[i + 4].populate(output, shard, event.channel, v1, v2_new); @@ -121,12 +103,9 @@ impl MachineAir for Blake2sRoundChip { let v2 = v2_outer[i]; let v3 = v3_outer[i]; let m2 = event.b_reads[i + 4].value; - let zero1 = event.b_reads[i + 16].value; - let zero2 = event.b_reads[i + 20].value; // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2) - let v0_new = - cols.add[i + 8].populate(output, shard, event.channel, v0, v1, m2, zero1); + let v0_new = cols.add3[i + 4].populate(output, shard, event.channel, v0, v1, m2); // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3) let temp = cols.xor[i + 8].populate(output, shard, event.channel, v3, v0_new); @@ -139,15 +118,7 @@ impl MachineAir for Blake2sRoundChip { ); // v[2] = v[2].wrapping_add(v[3]); - let v2_new = cols.add[i + 4 + 8].populate( - output, - shard, - event.channel, - v2, - v3_new, - zero1, - zero2, - ); + let v2_new = cols.add2[i + 4].populate(output, shard, event.channel, v2, v3_new); // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4) let temp = cols.xor[i + 4 + 8].populate(output, shard, event.channel, v1, v2_new); @@ -191,15 +162,9 @@ impl MachineAir for Blake2sRoundChip { let v2 = v2_outer[i]; let v3 = v3_outer[i]; let m3 = event.b_reads[i + 8].value; - let zero1 = event.b_reads[i + 16].value; - let zero2 = event.b_reads[i + 20].value; - assert_eq!(zero1, 0); - assert_eq!(zero2, 0); // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); - let v0_new = - cols.add[i + 16].populate(output, shard, event.channel, v0, v1, m3, zero1); - assert_eq!(v0 + v1 + m3 + zero1, v0_new); + let v0_new = cols.add3[i + 8].populate(output, shard, event.channel, v0, v1, m3); // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); let temp = cols.xor[i + 16].populate(output, shard, event.channel, v3, v0_new); @@ -210,19 +175,9 @@ impl MachineAir for Blake2sRoundChip { temp, R_1 as usize, ); - assert_eq!((v3 ^ v0_new).rotate_right(R_1), v3_new); // v[2] = v[2].wrapping_add(v[3]); - let v2_new = cols.add[i + 16 + 4].populate( - output, - shard, - event.channel, - v2, - v3_new, - zero1, - zero2, - ); - assert_eq!(v2 + v3_new + zero1 + zero2, v2_new); + let v2_new = cols.add2[i + 8].populate(output, shard, event.channel, v2, v3_new); // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); let temp = cols.xor[i + 16 + 4].populate(output, shard, event.channel, v1, v2_new); @@ -233,7 +188,6 @@ impl MachineAir for Blake2sRoundChip { temp, R_2 as usize, ); - assert_eq!((v1 ^ v2_new).rotate_right(R_2), v1_new); v0_outer[i] = v0_new; v1_outer[i] = v1_new; @@ -248,15 +202,9 @@ impl MachineAir for Blake2sRoundChip { let v2 = v2_outer[i]; let v3 = v3_outer[i]; let m4 = event.b_reads[i + 12].value; - let zero1 = event.b_reads[i + 16].value; - let zero2 = event.b_reads[i + 20].value; - assert_eq!(zero1, 0); - assert_eq!(zero2, 0); // v[0] = v[0].wrapping_add(v[1]).wrapping_add(m.from_le()); (m2) - let v0_new = - cols.add[i + 16 + 8].populate(output, shard, event.channel, v0, v1, m4, zero1); - assert_eq!(v0 + v1 + m4 + zero1, v0_new); + let v0_new = cols.add3[i + 12].populate(output, shard, event.channel, v0, v1, m4); // v[3] = (v[3] ^ v[0]).rotate_right_const(rd); (R3) let temp = cols.xor[i + 16 + 8].populate(output, shard, event.channel, v3, v0_new); @@ -267,18 +215,9 @@ impl MachineAir for Blake2sRoundChip { temp, R_3 as usize, ); - assert_eq!((v3 ^ v0_new).rotate_right(R_3), v3_new); // v[2] = v[2].wrapping_add(v[3]); - let v2_new = cols.add[i + 16 + 4 + 8].populate( - output, - shard, - event.channel, - v2, - v3_new, - zero1, - zero2, - ); + let v2_new = cols.add2[i + 12].populate(output, shard, event.channel, v2, v3_new); // v[1] = (v[1] ^ v[2]).rotate_right_const(rb); (R4) let temp = diff --git a/tests/blake2s-round/Cargo.lock b/tests/blake2s-round/Cargo.lock index 7efd0650c..e2a3cc14e 100644 --- a/tests/blake2s-round/Cargo.lock +++ b/tests/blake2s-round/Cargo.lock @@ -42,7 +42,7 @@ dependencies = [ ] [[package]] -name = "blake2s-quarter_round-2x-test" +name = "blake2s-round-test" version = "0.1.0" dependencies = [ "sphinx-zkvm", diff --git a/tests/blake2s-round/Cargo.toml b/tests/blake2s-round/Cargo.toml index 188c60950..98d23e472 100644 --- a/tests/blake2s-round/Cargo.toml +++ b/tests/blake2s-round/Cargo.toml @@ -1,6 +1,6 @@ [workspace] [package] -name = "blake2s-quarter_round-2x-test" +name = "blake2s-round-test" version = "0.1.0" edition = "2021" diff --git a/tests/blake2s-round/elf/riscv32im-succinct-zkvm-elf b/tests/blake2s-round/elf/riscv32im-succinct-zkvm-elf index d20fc7e4394539b95ec58368a5f2c68ef66e49f8..fef04f7e418a7cf1d0be9ce6d562ef6bd302e8f0 100755 GIT binary patch delta 36 scmZ3pk#WsN#tq86tlyQ@1UV*a@J?rBnS6j(nUzDBk&$!r3*IAM0Mzsf!vFvP delta 36 scmZ3pk#WsN#tq86tY4MY1i2<_@J?rBn|y#*nUzbJk&%1z3*IAM0M#rC$p8QV diff --git a/tests/blake2s-round/src/main.rs b/tests/blake2s-round/src/main.rs index c67c53605..1fec17136 100644 --- a/tests/blake2s-round/src/main.rs +++ b/tests/blake2s-round/src/main.rs @@ -9,7 +9,7 @@ pub fn main() { 0x5be0cd19, 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0xe07c2654, 0x5be0cd19 ]; - let b: [u32; 24] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + let b: [u32; 16] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; syscall_blake2s_round(a.as_mut_ptr(), b.as_ptr()); }