Merge pull request #8 from kroma-network/fix/fix-types-of-function-ar…

…guments

fix: fix types of function arguments

examples/fibonacci/script/src/operator/mod.rs

@@ -4,13 +4,13 @@ pub mod utils;
 use crate::common;
 use crate::common::{
     memory_layouts::{SerializableDeferredLayout, SerializableRecursionLayout},
-    types::{CommitmentType, PublicValueStreamType, RecordType},
+    types::{CommitmentType, PublicValueStreamType},
 };
 use crate::ProveArgs;
 use p3_baby_bear::BabyBear;
 use sp1_core::air::{PublicValues, Word};
 use sp1_core::stark::{MachineProver, StarkGenericConfig};
-use sp1_core::{stark::ShardProof, utils::BabyBearPoseidon2};
+use sp1_core::utils::BabyBearPoseidon2;
 use sp1_prover::{SP1CoreProof, SP1ReduceProof};
 use std::borrow::Borrow;
 use steps::{
@@ -42,18 +42,28 @@ pub fn operator_split_into_checkpoints(
 
 pub fn operator_absorb_commits(
     args: &Vec<u8>,
-    commitments_vec: &[Vec<u8>],
-    records_vec: &[Vec<u8>],
+    commitments_vec: &[Vec<Vec<u8>>],
+    records_vec: &[Vec<Vec<u8>>],
     o_challenger_state: &mut Vec<u8>,
 ) {
     let args_obj = ProveArgs::from_slice(args.as_slice());
     let commitments_vec: Vec<Vec<CommitmentType>> = commitments_vec
         .iter()
-        .map(|commitments| bincode::deserialize(commitments).unwrap())
+        .map(|commitments| {
+            commitments
+                .iter()
+                .map(|commitment| bincode::deserialize(commitment.as_slice()).unwrap())
+                .collect()
+        })
         .collect();
-    let records_vec: Vec<Vec<RecordType>> = records_vec
+    let records_vec = records_vec
         .iter()
-        .map(|records| bincode::deserialize(records).unwrap())
+        .map(|records| {
+            records
+                .iter()
+                .map(|record| bincode::deserialize(record).unwrap())
+                .collect()
+        })
         .collect();
     tracing::info!(
         "collected commitments: {:?}",
@@ -69,15 +79,20 @@ pub fn operator_absorb_commits(
 
 pub fn operator_construct_sp1_core_proof(
     args: &Vec<u8>,
-    shard_proofs_vec: &[Vec<u8>],
+    shard_proofs_vec: &[Vec<Vec<u8>>],
     public_values_stream: &[u8],
     cycles: u64,
     o_proof: &mut Vec<u8>,
 ) {
     let args_obj = ProveArgs::from_slice(args.as_slice());
-    let shard_proofs_vec_obj: Vec<Vec<ShardProof<BabyBearPoseidon2>>> = shard_proofs_vec
+    let shard_proofs_vec_obj = shard_proofs_vec
         .iter()
-        .map(|shard_proofs| bincode::deserialize(shard_proofs).unwrap())
+        .map(|proofs| {
+            proofs
+                .iter()
+                .map(|proof| bincode::deserialize(proof).unwrap())
+                .collect()
+        })
         .collect();
     let public_values_stream_obj: PublicValueStreamType =
         bincode::deserialize(public_values_stream).unwrap();

examples/fibonacci/script/src/worker/mod.rs

@@ -5,7 +5,7 @@ use crate::common::memory_layouts::SerializableReduceLayout;
 use crate::{
     common::{
         memory_layouts::{SerializableDeferredLayout, SerializableRecursionLayout},
-        types::{LayoutType, RecordType},
+        types::LayoutType,
     },
     operator::utils::ChallengerState,
     ProveArgs,
@@ -23,8 +23,8 @@ pub fn worker_commit_checkpoint(
     checkpoint: &Vec<u8>,
     is_last_checkpoint: bool,
     public_values: &[u8],
-    o_commitments: &mut Vec<u8>,
-    o_records: &mut Vec<u8>,
+    o_commitments: &mut Vec<Vec<u8>>,
+    o_records: &mut Vec<Vec<u8>>,
 ) {
     let args_obj = ProveArgs::from_slice(args.as_slice());
     let execution_state: ExecutionState = bincode::deserialize(checkpoint.as_slice()).unwrap();
@@ -42,27 +42,38 @@ pub fn worker_commit_checkpoint(
     .unwrap();
     tracing::info!("{:?} commitments were generated", commitments.len());
 
-    *o_commitments = bincode::serialize(&commitments).unwrap();
-    *o_records = bincode::serialize(&records).unwrap();
+    *o_commitments = commitments
+        .iter()
+        .map(|commitment| bincode::serialize(commitment).unwrap())
+        .collect();
+    *o_records = records
+        .iter()
+        .map(|record| bincode::serialize(record).unwrap())
+        .collect();
 }
 
 pub fn worker_prove_checkpoint(
     args: &Vec<u8>,
     challenger_state: &Vec<u8>,
-    records: &[u8],
-    o_shard_proofs: &mut Vec<u8>,
+    records: &[Vec<u8>],
+    o_shard_proofs: &mut Vec<Vec<u8>>,
 ) {
     let args_obj = ProveArgs::from_slice(args.as_slice());
     let (client, _, _, _) = common::init_client(args_obj.clone());
     let challenger = ChallengerState::from_bytes(challenger_state.as_slice())
         .to_challenger(&client.prover.sp1_prover().core_prover.config().perm);
-    let records: Vec<RecordType> = bincode::deserialize(records).unwrap();
+    let records = records
+        .iter()
+        .map(|record| bincode::deserialize(record).unwrap())
+        .collect();
 
     let shard_proofs = worker_prove_checkpoint_impl(args_obj, challenger, records).unwrap();
     tracing::info!("{:?} shard proofs were generated", shard_proofs.len());
 
-    let result = bincode::serialize(&shard_proofs.as_slice()).unwrap();
-    *o_shard_proofs = result;
+    *o_shard_proofs = shard_proofs
+        .iter()
+        .map(|proof| bincode::serialize(proof).unwrap())
+        .collect();
 }
 
 pub fn worker_compress_proofs(