sp1_core_machine/
io.rs

1use serde::{de::DeserializeOwned, Deserialize, Serialize};
2use sp1_core_executor::SP1RecursionProof;
3use sp1_hypercube::{MachineVerifyingKey, SP1PcsProofInner};
4use sp1_primitives::SP1GlobalContext;
5
6/// Standard input for the prover.
7#[derive(Debug, Clone, Serialize, Deserialize, Default)]
8pub struct SP1Stdin {
9    /// Input stored as a vec of vec of bytes. It's stored this way because the read syscall reads
10    /// a vec of bytes at a time.
11    pub buffer: Vec<Vec<u8>>,
12    pub ptr: usize,
13    pub proofs: Vec<(
14        SP1RecursionProof<SP1GlobalContext, SP1PcsProofInner>,
15        MachineVerifyingKey<SP1GlobalContext>,
16    )>,
17}
18
19impl SP1Stdin {
20    /// Create a new `SP1Stdin`.
21    pub const fn new() -> Self {
22        Self { buffer: Vec::new(), ptr: 0, proofs: Vec::new() }
23    }
24
25    /// Create a `SP1Stdin` from a slice of bytes.
26    pub fn from(data: &[u8]) -> Self {
27        Self { buffer: vec![data.to_vec()], ptr: 0, proofs: Vec::new() }
28    }
29
30    /// Read a value from the buffer.
31    pub fn read<T: DeserializeOwned>(&mut self) -> T {
32        let result: T =
33            bincode::deserialize(&self.buffer[self.ptr]).expect("failed to deserialize");
34        self.ptr += 1;
35        result
36    }
37
38    /// Read a slice of bytes from the buffer.
39    pub fn read_slice(&mut self, slice: &mut [u8]) {
40        slice.copy_from_slice(&self.buffer[self.ptr]);
41        self.ptr += 1;
42    }
43
44    /// Write a value to the buffer.
45    pub fn write<T: Serialize>(&mut self, data: &T) {
46        let mut tmp = Vec::new();
47        bincode::serialize_into(&mut tmp, data).expect("serialization failed");
48        self.buffer.push(tmp);
49    }
50
51    /// Write a slice of bytes to the buffer.
52    pub fn write_slice(&mut self, slice: &[u8]) {
53        self.buffer.push(slice.to_vec());
54    }
55
56    pub fn write_vec(&mut self, vec: Vec<u8>) {
57        self.buffer.push(vec);
58    }
59
60    pub fn write_proof(
61        &mut self,
62        proof: SP1RecursionProof<SP1GlobalContext, SP1PcsProofInner>,
63        vk: MachineVerifyingKey<SP1GlobalContext>,
64    ) {
65        self.proofs.push((proof, vk));
66    }
67}
68
69// pub mod proof_serde {
70//     use serde::{de::DeserializeOwned, Deserialize, Deserializer, Serialize};
71//     use sp1_hypercube::{MachineProof, StarkGenericConfig};
72
73//     pub fn serialize<S, SC: StarkGenericConfig + Serialize>(
74//         proof: &MachineProof<SC>,
75//         serializer: S,
76//     ) -> Result<S::Ok, S::Error>
77//     where
78//         S: serde::Serializer,
79//     {
80//         if serializer.is_human_readable() {
81//             let bytes = bincode::serialize(proof).unwrap();
82//             let hex_bytes = hex::encode(bytes);
83//             serializer.serialize_str(&hex_bytes)
84//         } else {
85//             proof.serialize(serializer)
86//         }
87//     }
88
89//     pub fn deserialize<'de, D, SC: StarkGenericConfig + DeserializeOwned>(
90//         deserializer: D,
91//     ) -> Result<MachineProof<SC>, D::Error>
92//     where
93//         D: Deserializer<'de>,
94//     {
95//         if deserializer.is_human_readable() {
96//             let hex_bytes = String::deserialize(deserializer).unwrap();
97//             let bytes = hex::decode(hex_bytes).unwrap();
98//             let proof = bincode::deserialize(&bytes).map_err(serde::de::Error::custom)?;
99//             Ok(proof)
100//         } else {
101//             MachineProof::<SC>::deserialize(deserializer)
102//         }
103//     }
104// }
sp1_core_machine/io.rs

sp1_core_machine/
io.rs
