powdr: create prover bindings lib

Author: gballet

.gitignore

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

README.md

@@ -59,16 +59,28 @@ out for this space for annoucements on the same or reach out to us via our [comm
 
 ### Build instructions
 
-Zeam requires zig version 0.14.0 to build.
+
+#### Prerequisites
+
+ - Zeam requires zig version 0.14.0 to build.
+ - Zeam requires Rust 1.85+ to be able to build the rust connections to various zkvms
+
+#### Build
 
 In order to build the transition functions (one for each supported zkvm), as well as the whole client, type:
 
 ```
-> zig build
+> zig build -Doptimize=ReleaseFast
 ```
 
 at the root of the repository.
 
+#### Running the prover demo
+
+```
+> zig build -Doptimize=ReleaseFast run -- prove
+```
+
 ### Reporting Issues
 
 Open an [issue or a bug](https://github.com/blockblaz/zeam/issues/new) or else talk to us via our [community telegram group](https://t.me/zeamETH).

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 },
 };
 
@@ -52,13 +52,16 @@ pub fn build(b: *Builder) !void {
         .target = target,
         .optimize = optimize,
     });
+    zeam_state_transition.addImport("@zeam/types", zeam_types);
 
     // add state proving manager
     const zeam_state_proving_manager = b.addModule("@zeam/state-proving-manager", .{
         .root_source_file = b.path("pkgs/state-proving-manager/src/manager.zig"),
         .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,8 +96,33 @@ 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.addObjectFile(b.path(b.fmt("pkgs/state-transition-runtime/src/{s}/host/target/release/libzeam_prover_host_{s}.a", .{ zkvm_target.name, zkvm_target.name })));
+        }
+    }
+    cli_exe.linkLibC(); // for rust static libs to link
+    cli_exe.linkSystemLibrary("unwind"); // to be able to display rust backtraces
     b.installArtifact(cli_exe);
 
+    const run_prover = b.addRunArtifact(cli_exe);
+    const prover_step = b.step("run", "Run cli executable");
+    prover_step.dependOn(&run_prover.step);
+    if (b.args) |args| {
+        run_prover.addArgs(args);
+    }
+
     const tests = b.addTest(.{
         .root_source_file = b.path("pkgs/tests.zig"),
         .optimize = optimize,
@@ -169,15 +197,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 fn powdr_prove(serialized: [*]const u8, len: usize, output: [*]u8, output_len: usize, binary_path: [*]const u8, binary_path_length: usize) void;
+
+pub const zkvm_configs: []const ZKVMContext = &.{
+    .{ .program_path = "zig-out/bin/zeam-stf-powdr", .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, zkvm_configs[0].program_path.ptr, zkvm_configs[0].program_path.len);
     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;
 }