codex-storage/codex-storage-proofs
1
0
Fork 0
mirror of https://github.com/codex-storage/codex-storage-proofs.git synced 2025-02-02 14:03:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

clippy & other lint stuff

Browse Source
This commit is contained in:
Dmitriy Ryajov 2023-03-27 20:19:05 -06:00
parent f2064b8925
commit 7c9db9486c
No known key found for this signature in database
GPG Key ID: DA8C680CE7C657A4
5 changed files with 55 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/circuit_tests/utils.rs
View File

@ -10,7 +10,7 @@ pub fn digest(input: &[U256], chunk_size: Option<usize>) -> U256 {
let range = (i * chunk_size)..std::cmp::min((i + 1) * chunk_size, input.len()); let range = (i * chunk_size)..std::cmp::min((i + 1) * chunk_size, input.len());
let mut chunk = input[range].to_vec(); let mut chunk = input[range].to_vec();
if chunk.len() < chunk_size { if chunk.len() < chunk_size {
chunk.resize(chunk_size as usize, uint!(0_U256)); chunk.resize(chunk_size, uint!(0_U256));
} }
concat.push(hash(chunk.as_slice())); concat.push(hash(chunk.as_slice()));
@ -20,7 +20,7 @@ pub fn digest(input: &[U256], chunk_size: Option<usize>) -> U256 {
return hash(concat.as_slice()); return hash(concat.as_slice());
} }
return concat[0]; concat[0]
} }
pub fn merkelize(leafs: &[U256]) -> U256 { pub fn merkelize(leafs: &[U256]) -> U256 {
@ -43,5 +43,5 @@ pub fn merkelize(leafs: &[U256]) -> U256 {
merkle = new_merkle; merkle = new_merkle;
} }
return merkle[0]; merkle[0]
} }

73
src/ffi.rs
View File

@ -32,13 +32,16 @@ impl ProofCtx {
} }
} }
/// # Safety
///
/// Construct a StorageProofs object
#[no_mangle] #[no_mangle]
pub extern "C" fn init( pub unsafe extern "C" fn init(
r1cs: *const &Buffer, r1cs: *const &Buffer,
wasm: *const &Buffer, wasm: *const &Buffer,
zkey: *const &Buffer, zkey: *const &Buffer,
) -> *mut StorageProofs { ) -> *mut StorageProofs {
let r1cs = unsafe { let r1cs = {
if r1cs.is_null() { if r1cs.is_null() {
return std::ptr::null_mut(); return std::ptr::null_mut();
} }
@ -47,8 +50,8 @@ pub extern "C" fn init(
str::from_utf8(slice).unwrap().to_string() str::from_utf8(slice).unwrap().to_string()
}; };
let wasm = unsafe { let wasm = {
if wasm == std::ptr::null() { if wasm.is_null() {
return std::ptr::null_mut(); return std::ptr::null_mut();
} }
@ -56,7 +59,7 @@ pub extern "C" fn init(
str::from_utf8(slice).unwrap().to_string() str::from_utf8(slice).unwrap().to_string()
}; };
let zkey = unsafe { let zkey = {
if !zkey.is_null() { if !zkey.is_null() {
let slice = std::slice::from_raw_parts((*zkey).data, (*zkey).len); let slice = std::slice::from_raw_parts((*zkey).data, (*zkey).len);
Some(str::from_utf8(slice).unwrap().to_string()) Some(str::from_utf8(slice).unwrap().to_string())
@ -68,8 +71,12 @@ pub extern "C" fn init(
Box::into_raw(Box::new(StorageProofs::new(wasm, r1cs, zkey))) Box::into_raw(Box::new(StorageProofs::new(wasm, r1cs, zkey)))
} }
/// # Safety
///
/// Use after constructing a StorageProofs object
#[no_mangle] #[no_mangle]
pub extern "C" fn prove( pub unsafe extern "C" fn prove(
prover_ptr: *mut StorageProofs, prover_ptr: *mut StorageProofs,
chunks: *const Buffer, chunks: *const Buffer,
siblings: *const Buffer, siblings: *const Buffer,
@ -80,7 +87,7 @@ pub extern "C" fn prove(
root: *const Buffer, root: *const Buffer,
salt: *const Buffer, salt: *const Buffer,
) -> *mut ProofCtx { ) -> *mut ProofCtx {
let chunks = unsafe { let chunks = {
let slice = std::slice::from_raw_parts((*chunks).data, (*chunks).len); let slice = std::slice::from_raw_parts((*chunks).data, (*chunks).len);
slice slice
.chunks(U256::BYTES) .chunks(U256::BYTES)
@ -88,7 +95,7 @@ pub extern "C" fn prove(
.collect::<Vec<U256>>() .collect::<Vec<U256>>()
}; };
let siblings = unsafe { let siblings = {
let slice = std::slice::from_raw_parts((*siblings).data, (*siblings).len); let slice = std::slice::from_raw_parts((*siblings).data, (*siblings).len);
slice slice
.chunks(U256::BYTES) .chunks(U256::BYTES)
@ -96,7 +103,7 @@ pub extern "C" fn prove(
.collect::<Vec<U256>>() .collect::<Vec<U256>>()
}; };
let hashes = unsafe { let hashes = {
let slice = std::slice::from_raw_parts((*hashes).data, (*hashes).len); let slice = std::slice::from_raw_parts((*hashes).data, (*hashes).len);
slice slice
.chunks(U256::BYTES) .chunks(U256::BYTES)
@ -104,27 +111,24 @@ pub extern "C" fn prove(
.collect::<Vec<U256>>() .collect::<Vec<U256>>()
}; };
let path = unsafe { let path = {
let slice = std::slice::from_raw_parts(path, path_len); let slice = std::slice::from_raw_parts(path, path_len);
slice.to_vec() slice.to_vec()
}; };
let pubkey = unsafe { let pubkey =
U256::try_from_le_slice(std::slice::from_raw_parts((*pubkey).data, (*pubkey).len)).unwrap() U256::try_from_le_slice(std::slice::from_raw_parts((*pubkey).data, (*pubkey).len)).unwrap();
};
let root = unsafe { let root =
U256::try_from_le_slice(std::slice::from_raw_parts((*root).data, (*root).len)).unwrap() U256::try_from_le_slice(std::slice::from_raw_parts((*root).data, (*root).len)).unwrap();
};
let salt = unsafe { let salt =
U256::try_from_le_slice(std::slice::from_raw_parts((*salt).data, (*salt).len)).unwrap() U256::try_from_le_slice(std::slice::from_raw_parts((*salt).data, (*salt).len)).unwrap();
};
let proof_bytes = &mut Vec::new(); let proof_bytes = &mut Vec::new();
let public_inputs_bytes = &mut Vec::new(); let public_inputs_bytes = &mut Vec::new();
let mut _prover = unsafe { &mut *prover_ptr }; let mut _prover = &mut *prover_ptr;
_prover _prover
.prove( .prove(
chunks.as_slice(), chunks.as_slice(),
@ -142,22 +146,25 @@ pub extern "C" fn prove(
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn verify( /// # Safety
///
/// Should be called on a valid proof and public inputs previously generated by prove
pub unsafe extern "C" fn verify(
prover_ptr: *mut StorageProofs, prover_ptr: *mut StorageProofs,
proof: *const Buffer, proof: *const Buffer,
public_inputs: *const Buffer, public_inputs: *const Buffer,
) -> bool { ) -> bool {
let proof = unsafe { std::slice::from_raw_parts((*proof).data, (*proof).len) }; let proof = std::slice::from_raw_parts((*proof).data, (*proof).len);
let public_inputs = std::slice::from_raw_parts((*public_inputs).data, (*public_inputs).len);
let public_inputs = let mut _prover = &mut *prover_ptr;
unsafe { std::slice::from_raw_parts((*public_inputs).data, (*public_inputs).len) };
let mut _prover = unsafe { &mut *prover_ptr };
_prover.verify(proof, public_inputs).is_ok() _prover.verify(proof, public_inputs).is_ok()
} }
/// # Safety
///
/// Use on a valid pointer to StorageProofs or panics
#[no_mangle] #[no_mangle]
pub extern "C" fn free_prover(prover: *mut StorageProofs) { pub unsafe extern "C" fn free_prover(prover: *mut StorageProofs) {
if prover.is_null() { if prover.is_null() {
return; return;
} }
@ -165,17 +172,21 @@ pub extern "C" fn free_prover(prover: *mut StorageProofs) {
unsafe { drop(Box::from_raw(prover)) } unsafe { drop(Box::from_raw(prover)) }
} }
pub extern "C" fn free_proof_ctx(ctx: *mut ProofCtx) { /// # Safety
///
/// Use on a valid pointer to ProofCtx or panics
#[no_mangle]
pub unsafe extern "C" fn free_proof_ctx(ctx: *mut ProofCtx) {
if ctx.is_null() { if ctx.is_null() {
return; return;
} }
unsafe { drop(Box::from_raw(ctx)) } drop(Box::from_raw(ctx))
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use ark_std::rand::{rngs::ThreadRng, distributions::Alphanumeric, Rng}; use ark_std::rand::{distributions::Alphanumeric, rngs::ThreadRng, Rng};
use ruint::aliases::U256; use ruint::aliases::U256;
use crate::{ use crate::{

16
src/poseidon/constants.rs
View File

@ -34,12 +34,8 @@ pub static C_CONST: Lazy<Vec<Vec<Fr>>> = Lazy::new(|| {
}) })
.collect::<Result<Vec<Fr>, _>>() .collect::<Result<Vec<Fr>, _>>()
.unwrap() .unwrap()
.try_into()
.unwrap()
}) })
.collect::<Vec<Vec<Fr>>>() .collect::<Vec<Vec<Fr>>>()
.try_into()
.unwrap()
}); });
pub static S_CONST: Lazy<Vec<Vec<Fr>>> = Lazy::new(|| { pub static S_CONST: Lazy<Vec<Vec<Fr>>> = Lazy::new(|| {
@ -62,12 +58,8 @@ pub static S_CONST: Lazy<Vec<Vec<Fr>>> = Lazy::new(|| {
}) })
.collect::<Result<Vec<Fr>, _>>() .collect::<Result<Vec<Fr>, _>>()
.unwrap() .unwrap()
.try_into()
.unwrap()
}) })
.collect::<Vec<Vec<Fr>>>() .collect::<Vec<Vec<Fr>>>()
.try_into()
.unwrap()
}); });
pub static M_CONST: Lazy<Vec<Vec<Vec<Fr>>>> = Lazy::new(|| { pub static M_CONST: Lazy<Vec<Vec<Vec<Fr>>>> = Lazy::new(|| {
@ -94,14 +86,10 @@ pub static M_CONST: Lazy<Vec<Vec<Vec<Fr>>>> = Lazy::new(|| {
}) })
.collect::<Result<Vec<Fr>, _>>() .collect::<Result<Vec<Fr>, _>>()
.unwrap() .unwrap()
.try_into()
.unwrap()
}) })
.collect() .collect()
}) })
.collect::<Vec<Vec<Vec<Fr>>>>() .collect::<Vec<Vec<Vec<Fr>>>>()
.try_into()
.unwrap()
}); });
pub static P_CONST: Lazy<Vec<Vec<Vec<Fr>>>> = Lazy::new(|| { pub static P_CONST: Lazy<Vec<Vec<Vec<Fr>>>> = Lazy::new(|| {
@ -128,12 +116,8 @@ pub static P_CONST: Lazy<Vec<Vec<Vec<Fr>>>> = Lazy::new(|| {
}) })
.collect::<Result<Vec<Fr>, _>>() .collect::<Result<Vec<Fr>, _>>()
.unwrap() .unwrap()
.try_into()
.unwrap()
}) })
.collect() .collect()
}) })
.collect::<Vec<Vec<Vec<Fr>>>>() .collect::<Vec<Vec<Vec<Fr>>>>()
.try_into()
.unwrap()
}); });

18
src/poseidon/mod.rs
View File

@ -16,7 +16,7 @@ const N_ROUNDS_P: [i32; 16] = [
// Panics if `input` is not a valid field element. // Panics if `input` is not a valid field element.
#[must_use] #[must_use]
pub fn hash(inputs: &[U256]) -> U256 { pub fn hash(inputs: &[U256]) -> U256 {
assert!(inputs.len() > 0); assert!(!inputs.is_empty());
assert!(inputs.len() <= N_ROUNDS_P.len()); assert!(inputs.len() <= N_ROUNDS_P.len());
let t = inputs.len() + 1; let t = inputs.len() + 1;
@ -35,7 +35,7 @@ pub fn hash(inputs: &[U256]) -> U256 {
for r in 0..(n_rounds_f / 2 - 1) { for r in 0..(n_rounds_f / 2 - 1) {
state = state state = state
.iter() .iter()
.map(|a| a.pow(&[5])) .map(|a| a.pow([5]))
.enumerate() .enumerate()
.map(|(i, a)| a + c[(r + 1) * t + i]) .map(|(i, a)| a + c[(r + 1) * t + i])
.collect(); .collect();
@ -57,7 +57,7 @@ pub fn hash(inputs: &[U256]) -> U256 {
state = state state = state
.iter() .iter()
.map(|a| a.pow(&[5])) .map(|a| a.pow([5]))
.enumerate() .enumerate()
.map(|(i, a)| a + c[(n_rounds_f / 2 - 1 + 1) * t + i]) .map(|(i, a)| a + c[(n_rounds_f / 2 - 1 + 1) * t + i])
.collect(); .collect();
@ -76,9 +76,9 @@ pub fn hash(inputs: &[U256]) -> U256 {
}) })
.collect(); .collect();
for r in 0..n_rounds_p as usize { for r in 0..n_rounds_p {
state[0] = state[0].pow(&[5]); state[0] = state[0].pow([5]);
state[0] = state[0] + c[(n_rounds_f / 2 + 1) * t + r]; state[0] += c[(n_rounds_f / 2 + 1) * t + r];
let s0 = state let s0 = state
.iter() .iter()
@ -94,10 +94,10 @@ pub fn hash(inputs: &[U256]) -> U256 {
state[0] = s0; state[0] = s0;
} }
for r in 0..(n_rounds_f / 2 - 1) as usize { for r in 0..(n_rounds_f / 2 - 1) {
state = state state = state
.iter() .iter()
.map(|a| a.pow(&[5])) .map(|a| a.pow([5]))
.enumerate() .enumerate()
.map(|(i, a)| a + c[(n_rounds_f / 2 + 1) * t + n_rounds_p + r * t + i]) .map(|(i, a)| a + c[(n_rounds_f / 2 + 1) * t + n_rounds_p + r * t + i])
.collect(); .collect();
@ -117,7 +117,7 @@ pub fn hash(inputs: &[U256]) -> U256 {
.collect(); .collect();
} }
state = state.iter().map(|a| a.pow(&[5])).collect(); state = state.iter().map(|a| a.pow([5])).collect();
state = state state = state
.iter() .iter()
.enumerate() .enumerate()

2
src/storage_proofs.rs
View File

@ -92,7 +92,7 @@ impl StorageProofs {
let proof = Proof::<Bn254>::deserialize(proof_bytes).map_err(|e| e.to_string())?; let proof = Proof::<Bn254>::deserialize(proof_bytes).map_err(|e| e.to_string())?;
let vk = prepare_verifying_key(&self.params.vk); let vk = prepare_verifying_key(&self.params.vk);
verify_proof(&vk, &proof, &inputs.as_slice()).map_err(|e| e.to_string())?; verify_proof(&vk, &proof, inputs.as_slice()).map_err(|e| e.to_string())?;
Ok(()) Ok(())
} }