feat: better failure messages when reading too much input

crates/core/executor/src/syscalls/hint.rs

@@ -10,10 +10,8 @@ impl Syscall for HintLenSyscall {
         _arg1: u32,
         _arg2: u32,
     ) -> Option<u32> {
-        panic_if_input_exhausted(ctx);
-
-        // Note: This cast could be truncating
-        ctx.rt.state.input_stream.front().map(|data| data.len() as u32)
+        // Note: This cast could be truncating on 64bit systems.
+        Some(ctx.rt.state.input_stream.front().map_or(u32::MAX, |data| data.len() as u32))
     }
 }
 

crates/zkvm/entrypoint/src/allocators/embedded.rs

@@ -32,11 +32,11 @@ pub fn init() {
 }
 
 pub fn used() -> usize {
-    critical_section::with(|cs| INNER_HEAP.used())
+    critical_section::with(|_cs| INNER_HEAP.used())
 }
 
 pub fn free() -> usize {
-    critical_section::with(|cs| INNER_HEAP.free())
+    critical_section::with(|_cs| INNER_HEAP.free())
 }
 
 struct EmbeddedAlloc;

crates/zkvm/entrypoint/src/lib.rs

@@ -49,6 +49,7 @@ pub struct ReadVecResult {
     pub ptr: *mut u8,
     pub len: usize,
     pub capacity: usize,
+    pub failed: bool,
 }
 
 /// Read a buffer from the input stream.
@@ -61,6 +62,9 @@ pub struct ReadVecResult {
 /// When the `embedded` feature is enabled, the buffer is read into the reserved input region.
 ///
 /// When there is no allocator selected, the program will fail to compile.
+///
+/// If the input stream is exhausted, the failed flag will be returned as true. In this case, the other outputs from the function are likely incorrect.
+/// is exhausted.
 #[no_mangle]
 pub extern "C" fn read_vec_raw() -> ReadVecResult {
     #[cfg(not(target_os = "zkvm"))]
@@ -70,6 +74,12 @@ pub extern "C" fn read_vec_raw() -> ReadVecResult {
     {
         // Get the length of the input buffer.
         let len = syscall_hint_len();
+
+        // If the length is u32::MAX, then the input stream is exhausted.
+        if len == usize::MAX {
+            return ReadVecResult { ptr: std::ptr::null_mut(), len: 0, capacity: 0, failed: true };
+        }
+
         // Round up to multiple of 4 for whole-word alignment.
         let capacity = (len + 3) / 4 * 4;
 
@@ -95,6 +105,7 @@ pub extern "C" fn read_vec_raw() -> ReadVecResult {
                     ptr: ptr as *mut u8,
                     len,
                     capacity,
+                    failed: false,
                 }
             } else if #[cfg(feature = "bump")] {
                 // Allocate a buffer of the required length that is 4 byte aligned.
@@ -113,6 +124,7 @@ pub extern "C" fn read_vec_raw() -> ReadVecResult {
                     ptr: ptr as *mut u8,
                     len,
                     capacity,
+                    failed: false,
                 }
             } else {
                 // An allocator must be selected.

crates/zkvm/lib/src/io.rs

@@ -38,11 +38,18 @@ impl Write for SyscallWriter {
 /// ```ignore
 /// let data: Vec<u8> = sp1_zkvm::io::read_vec();
 /// ```
+#[track_caller]
 pub fn read_vec() -> Vec<u8> {
-    let ReadVecResult { ptr, len, capacity } = unsafe { read_vec_raw() };
-    // 1. `ptr` was allocated using alloc
-    // 2. Assume that the allocator in the VM doesn't deallocate in the input space.
-    // 3. Size and length are correct from above. Length is <= capacity.
+    let ReadVecResult { ptr, len, capacity, failed } = unsafe { read_vec_raw() };
+
+    if failed {
+        panic!(
+            "Tried to read from the input stream, but it was empty @ {} \n
+            Was the correct data written into SP1Stdin?",
+            std::panic::Location::caller()
+        )
+    }
+
     unsafe { Vec::from_raw_parts(ptr, len, capacity) }
 }
 
@@ -60,8 +67,23 @@ pub fn read_vec() -> Vec<u8> {
 ///
 /// let data: MyStruct = sp1_zkvm::io::read();
 /// ```
+#[track_caller]
 pub fn read<T: DeserializeOwned>() -> T {
-    let vec = read_vec();
+    let ReadVecResult { ptr, len, capacity, failed } = unsafe { read_vec_raw() };
+
+    if failed {
+        panic!(
+            "Tried to read from the input stream, but it was empty @ {} \n
+            Was the correct data written into SP1Stdin?",
+            std::panic::Location::caller()
+        )
+    }
+
+    // 1. `ptr` was allocated using alloc
+    // 2. Assume that the allocator in the VM doesn't deallocate in the input space.
+    // 3. Size and length are correct from above. Length is <= capacity.
+    let vec = unsafe { Vec::from_raw_parts(ptr, len, capacity) };
+
     bincode::deserialize(&vec).expect("deserialization failed")
 }
 

crates/zkvm/lib/src/lib.rs

@@ -154,4 +154,5 @@ pub struct ReadVecResult {
     pub ptr: *mut u8,
     pub len: usize,
     pub capacity: usize,
+    pub failed: bool,
 }