powdr: create prover bindings lib

Author: gballet

.gitignore

@@ -3,3 +3,4 @@ main*
 zig-cache/
 .zig-cache/
 zig-out/
+target

build.zig

@@ -8,7 +8,7 @@ const zkvmTarget = struct {
 };
 
 const zkvm_targets: []const zkvmTarget = &.{
-    .{ .name = "powdr", .set_pie = true },
+    .{ .name = "powdr", .set_pie = true, .build_glue = true },
     .{ .name = "ceno", .set_pie = false },
 };
 
@@ -59,6 +59,8 @@ pub fn build(b: *Builder) !void {
         .target = target,
         .optimize = optimize,
     });
+    zeam_state_proving_manager.addImport("@zeam/types", zeam_types);
+    zeam_state_proving_manager.addImport("ssz", ssz);
 
     const st_lib = b.addStaticLibrary(.{
         .name = "zeam-state-transition",
@@ -93,6 +95,23 @@ pub fn build(b: *Builder) !void {
     cli_exe.root_module.addImport("@zeam/state-proving-manager", zeam_state_proving_manager);
     cli_exe.root_module.addImport("@zeam/node", zeam_beam_node);
     cli_exe.root_module.addImport("@zeam/params", zeam_params);
+    for (zkvm_targets) |zkvm_target| {
+        if (zkvm_target.build_glue) {
+            const zkvm_host_cmd = b.addSystemCommand(&.{
+                "cargo",
+                "+nightly",
+                "-C",
+                b.fmt("pkgs/state-transition-runtime/src/{s}/host", .{zkvm_target.name}),
+                "-Z",
+                "unstable-options",
+                "build",
+                "--release",
+            });
+            cli_exe.step.dependOn(&zkvm_host_cmd.step);
+            cli_exe.addLibraryPath(b.path(b.fmt("pkgs/state-transition-runtime/src/{s}/host/target/release/", .{zkvm_target.name})));
+            cli_exe.linkSystemLibrary("zeam_prover_host_powdr");
+        }
+    }
     b.installArtifact(cli_exe);
 
     const tests = b.addTest(.{
@@ -169,15 +188,5 @@ fn build_zkvm_targets(b: *Builder) !void {
         }
         exe.setLinkerScript(b.path(b.fmt("pkgs/state-transition-runtime/src/{s}/{s}.ld", .{ zkvm_target.name, zkvm_target.name })));
         b.installArtifact(exe);
-
-        // build the library connecting to the zkvm
-        if (zkvm_target.build_glue) {
-            _ = b.addSystemCommand(&.{
-                "cargo",
-                "-C",
-                b.fmt("pkgs/state-transition-runtime/src/{s}/host", .{zkvm_target.name}),
-                "build",
-            });
-        }
     }
 }

pkgs/cli/src/main.zig

@@ -4,11 +4,12 @@ const simargs = @import("simargs");
 const types = @import("@zeam/types");
 const nodeLib = @import("@zeam/node");
 const Clock = nodeLib.Clock;
+const stateProvingManager = @import("@zeam/state-proving-manager");
 
 const ZeamArgs = struct {
     genesis: ?u64,
 
-    __commands__: union(enum) { clock: struct {} },
+    __commands__: union(enum) { clock: struct {}, prove: struct {} },
 
     pub const __messages__ = .{
         .genesis = "genesis time",
@@ -28,5 +29,33 @@ pub fn main() !void {
 
             try clock.run();
         },
+        .prove => {
+            const state = types.BeamState{
+                .genesis_time = 0,
+                .slot = 0,
+                .latest_block_header = .{
+                    .slot = 0,
+                    .proposer_index = 0,
+                    .parent_root = [_]u8{0} ** 32,
+                    .state_root = [_]u8{0} ** 32,
+                    .body_root = [_]u8{0} ** 32,
+                },
+            };
+            const block = types.SignedBeamBlock{
+                .message = .{
+                    .slot = 0,
+                    .proposer_index = 0,
+                    .parent_root = [_]u8{0} ** 32,
+                    .state_root = [_]u8{0} ** 32,
+                    .body = .{},
+                },
+                .signature = [_]u8{0} ** 48,
+            };
+            const options = stateProvingManager.StateTransitionOpts{
+                .zk_vm = stateProvingManager.zkvm_configs[0],
+            };
+
+            _ = try stateProvingManager.execute_transition(state, block, options);
+        },
     }
 }

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

@@ -1,15 +1,43 @@
-const types = @import("types")
-const state_transition = @import("state-transition")
+const std = @import("std");
+const ssz = @import("ssz");
+const types = @import("@zeam/types");
+const allocator = std.heap.page_allocator;
 
+pub const ZKVMContext = struct {
+    program_path: []const u8,
+    output_dir: []const u8,
+    backend: ?[]const u8 = null,
+};
 
-const StateTransitionOpts = struct{
-    zk_vm: ZKVM_TYPES,
-}
+extern "C" fn powdr_prove(serialized: [*]const u8, len: usize, output: [*]u8, output_len: usize) void;
+
+pub const zkvm_configs: []const ZKVMContext = &.{
+    .{ .program_path = "dist/zeam-stf-powdr.asm", .output_dir = "out", .backend = "plonky3" },
+};
+
+pub const StateTransitionOpts = struct {
+    zk_vm: ZKVMContext,
+};
 
-pub fn execute_transition(state: types.BeamState, block: types.SignedBeamBlock, opts: StateTransitionOpts) types.BeamSTFProof {
+pub fn execute_transition(state: types.BeamState, block: types.SignedBeamBlock, opts: StateTransitionOpts) !types.BeamSTFProof {
+    _ = opts;
+
+    var serialized = std.ArrayList(u8).init(allocator);
+    defer serialized.deinit();
+    const prover_input = types.BeamSTFProverInput{
+        .state = state,
+        .block = block,
+    };
+    try ssz.serialize(types.BeamSTFProverInput, prover_input, &serialized);
+
+    var output: [256]u8 = undefined;
+    powdr_prove(serialized.items.ptr, serialized.items.len, @ptrCast(&output), 256);
     return types.BeamSTFProof{};
 }
 
-pub fn verify_transition(stf_proof: types.BeamSTFProof, state_root: types.Bytes32, block_root: types.Bytes32, opts: StateTransitionOpts) !void{
-
+pub fn verify_transition(stf_proof: types.BeamSTFProof, state_root: types.Bytes32, block_root: types.Bytes32, opts: StateTransitionOpts) !void {
+    _ = stf_proof;
+    _ = state_root;
+    _ = block_root;
+    _ = opts;
 }