fix risc0 input decoding and reactivate powdr

Signed-off-by: Guillaume Ballet <3272758+gballet@users.noreply.github.com>

Author: gballet

build.zig

@@ -10,7 +10,7 @@ const zkvmTarget = struct {
 
 const zkvm_targets: []const zkvmTarget = &.{
     .{ .name = "powdr", .set_pie = true, .build_glue = true },
-    .{ .name = "ceno", .set_pie = false },
+    // .{ .name = "ceno", .set_pie = false },
     .{ .name = "risc0", .build_glue = true },
 };
 

pkgs/state-proving-manager/src/manager.zig

@@ -39,6 +39,7 @@ pub fn prove_transition(state: types.BeamState, block: types.SignedBeamBlock, op
     const output_len = switch (opts) {
         .powdr => |powdrcfg| powdr_prove(serialized.items.ptr, serialized.items.len, @ptrCast(&output), 256, powdrcfg.program_path.ptr, powdrcfg.program_path.len, powdrcfg.output_dir.ptr, powdrcfg.output_dir.len),
         .risc0 => |risc0cfg| risc0_prove(serialized.items.ptr, serialized.items.len, risc0cfg.program_path.ptr, risc0cfg.program_path.len, output.ptr, output.len),
+        // else => @panic("prover isn't enabled"),
     };
     std.debug.print("proof len={}\n", .{output_len});
     const proof = types.BeamSTFProof{

pkgs/state-transition-runtime/src/main.zig

@@ -5,14 +5,10 @@ const ssz = @import("ssz");
 const types = @import("@zeam/types");
 const state_transition = @import("@zeam/state-transition");
 
+// TODO(gballet) move to zkvm module as each zkvm has a
+// different allocated space.
 var fixed_mem = [_]u8{0} ** (128 * 1024 * 1024);
 
-const __powdr_prover_data_start: [*]const u8 = @ptrFromInt(0x10000000);
-// this is hardcoded for now, because the compiler seems unable to see
-// linker script symbols.
-// extern const _powdr_prover_data_start: [*]const u8;
-// extern const __powdr_prover_data_end: [*]const u8;
-
 // implements risv5 runtime that runs in zkvm on provided inputs and witnesses to execute
 // and prove the state transition as imported from `pkgs/state-transition`
 export fn main() noreturn {
@@ -24,16 +20,11 @@ export fn main() noreturn {
     const allocator = fixed_allocator.allocator();
 
     // Get input from memory and deserialize it
-    // TODO(gballet) move that to powdr-specific code when
-    // another zkvm is being used that uses a different way
-    // of passing data to guests.
-    const total_input_len = std.mem.bytesToValue(u32, __powdr_prover_data_start[2048..2052]);
-    const total_input: []const u8 = __powdr_prover_data_start[2052 .. 2052 + total_input_len];
-    const input_len = std.mem.bytesAsValue(u32, total_input[0..4]);
-    const input = total_input[4 .. 4 + input_len.*];
     // TODO(gballet) figure out why printing this string is necessary.
     // It might be worth commenting it once the powdr rebase has been
     // completed.
+    const input = zkvm.get_input(allocator);
+    defer zkvm.free_input(allocator);
     var input_dump: [2048]u8 = undefined;
     _ = std.fmt.bufPrint(input_dump[0..], "serialized input={any} len={}\n", .{ input[0..], input_len.* }) catch @panic("error allocating string to dump serialized input");
     // Uncomment when debugging

pkgs/state-transition-runtime/src/powdr/lib.zig

@@ -92,3 +92,18 @@ pub fn halt(_: u32) noreturn {
     );
     while (true) {}
 }
+
+const __powdr_prover_data_start: [*]const u8 = @ptrFromInt(0x10000000);
+// this is hardcoded for now, because the compiler seems unable to see
+// linker script symbols.
+// extern const _powdr_prover_data_start: [*]const u8;
+// extern const __powdr_prover_data_end: [*]const u8;
+
+pub fn get_input(_: std.mem.Allocator) []const u8 {
+    const total_input_len = std.mem.bytesToValue(u32, __powdr_prover_data_start[2048..2052]);
+    const total_input: []const u8 = __powdr_prover_data_start[2052 .. 2052 + total_input_len];
+    const input_len = std.mem.bytesAsValue(u32, total_input[0..4]);
+    return total_input[4 .. 4 + input_len.*];
+}
+
+pub fn free_input(_: std.mem.Allocator, _: []const u8) void {}

pkgs/state-transition-runtime/src/risc0/io.zig

@@ -24,26 +24,43 @@ fn sys_write(fd: u32, data: []const u8) void {
     );
 }
 
-fn sys_read(fd: u32, comptime nrequested: usize, buffer: []u8) void {
+fn sys_read(fd: u32, nrequested: usize, buffer: []u8, nread: *u32, last: *u32) void {
     const main_words = nrequested / 4;
 
     const syscall_name: [:0]const u8 = "risc0_zkvm_platform::syscall::nr::SYS_READ";
+    var a0: u32 = undefined;
+    var a1: u32 = undefined;
     asm volatile (
         \\ ecall
-        :
+        : [a0] "={a0}" (a0),
+          [a1] "={a1}" (a1),
         : [syscallNumber] "{t0}" (syscalls.software),
-          [from_host] "{a0}" (buffer),
+          [from_host] "{a0}" (buffer.ptr),
           [from_host_words] "{a1}" (main_words),
           [syscall_name] "{a2}" (syscall_name.ptr),
           [file_descriptor] "{a3}" (fd),
           [main_requested] "{a4}" (nrequested),
         : "memory"
     );
+
+    nread.* = a0;
+    last.* = a1;
 }
 
-pub fn read_slice(_: u32, data: []u32) void {
-    var as_u8: []u8 = @ptrCast(data);
-    read_slice(.stdin, as_u8[0..]);
+pub fn read_slice(fd: u32, data: []u8) void {
+    var count: u32 = 0;
+    // TODO unaligned read if needed for starting point
+    while (count < data.len) {
+        const chunk_len = @min(data.len, 1024 * 4);
+        var nread: u32 = undefined;
+        var last: u32 = 0;
+        sys_read(fd, chunk_len, data[count..], &nread, &last);
+        if (nread == 0) print_str("read 0\n");
+        if (last == 0) print_str("last 0\n");
+        if (nread < chunk_len) break;
+        count += nread;
+    }
+    // TODO unaligned read at the end if need be
 }
 
 pub fn write_slice(fd: u32, data: []const u8) void {

pkgs/state-transition-runtime/src/risc0/lib.zig

@@ -18,3 +18,13 @@ fn sys_halt(out_state: *const [8]u32, status: u32) noreturn {
     );
     unreachable;
 }
+
+pub fn get_input(allocator: std.mem.Allocator) []const u8 {
+    var input: []u8 = allocator.alloc(u8, 256) catch @panic("could not allocate space for the input slice");
+    io.read_slice(0, input[0..]);
+    return input;
+}
+
+pub fn free_input(allocator: std.mem.Allocator, input: []const u8) void {
+    allocator.free(input);
+}

pkgs/state-transition/src/transition.zig

@@ -88,6 +88,7 @@ pub fn verify_signatures(signedBlock: types.SignedBeamBlock) !void {
 pub fn apply_transition(allocator: Allocator, state: *types.BeamState, signedBlock: types.SignedBeamBlock) !void {
     const block = signedBlock.message;
     if (block.slot <= state.slot) {
+        log("slots are invalid for block {any}: {} >= {}\n", .{ block, block.slot, state.slot }) catch @panic("error printing block and state slots");
         return StateTransitionError.InvalidPreState;
     }