feat: implement compact multi proofs and bindings for createMultiProof (#200)

This pr implements 
- multicompact proofs and uses
[this](https://github.com/ChainSafe/ssz/blob/master/packages/persistent-merkle-tree/src/proof/multi.ts)
as a reference
- fixes a bug in `sszValueToNapiValue` to handle u64 types by using
`createBigintUint64` instead of `createInt64`

---------

Co-authored-by: Cayman <caymannava@gmail.com>

Author: guha-rahul

bindings/napi/BeaconStateView.zig

@@ -767,7 +767,79 @@ pub fn BeaconStateView_getSingleProof(env: napi.Env, cb: napi.CallbackInfo(1)) !
     return result;
 }
 
-// pub fn BeaconStateView_createMultiProof
+/// Create a compact multi-proof from a descriptor.
+/// Arguments:
+/// - arg 0: descriptor (Uint8Array)
+/// Returns: {type: string, leaves: Uint8Array[], descriptor: Uint8Array}
+pub fn BeaconStateView_createMultiProof(env: napi.Env, cb: napi.CallbackInfo(1)) !napi.Value {
+    const persistent_merkle_tree = @import("persistent_merkle_tree");
+    const cached_state = try env.unwrap(CachedBeaconState, cb.this());
+
+    const descriptor_info = try cb.arg(0).getTypedarrayInfo();
+    if (descriptor_info.array_type != .uint8) {
+        try env.throwTypeError("Expected descriptor to be a Uint8Array");
+        return env.getNull();
+    }
+    const descriptor = descriptor_info.data;
+
+    // Get the root node from the state
+    try cached_state.state.commit();
+    const root_node = switch (cached_state.state.*) {
+        inline else => |*state| state.base_view.data.root,
+    };
+
+    // Create proof input for compact multi-proof
+    const proof_input = persistent_merkle_tree.proof.ProofInput{
+        .compactMulti = .{ .descriptor = descriptor },
+    };
+
+    var proof = persistent_merkle_tree.proof.createProof(
+        allocator,
+        &pool.pool,
+        root_node,
+        proof_input,
+    ) catch {
+        try env.throwError("STATE_ERROR", "Failed to create proof");
+        return env.getNull();
+    };
+    defer proof.deinit(allocator);
+
+    // Create result object matching Proof interface
+    const result = try env.createObject();
+
+    // Add type field
+    const proof_type_str = switch (proof) {
+        inline else => |_, tag| @tagName(tag),
+    };
+    try result.setNamedProperty("type", try env.createStringUtf8(proof_type_str));
+
+    // Extract data based on proof type
+    switch (proof) {
+        .compactMulti => |compact| {
+            // Create leaves array
+            const leaves_array = try env.createArray();
+            for (compact.leaves, 0..) |leaf, i| {
+                var leaf_bytes: [*]u8 = undefined;
+                const leaf_buf = try env.createArrayBuffer(32, &leaf_bytes);
+                @memcpy(leaf_bytes[0..32], &leaf);
+                try leaves_array.setElement(@intCast(i), try env.createTypedarray(.uint8, 32, leaf_buf, 0));
+            }
+            try result.setNamedProperty("leaves", leaves_array);
+
+            // Create descriptor Uint8Array
+            var descriptor_bytes: [*]u8 = undefined;
+            const descriptor_buf = try env.createArrayBuffer(compact.descriptor.len, &descriptor_bytes);
+            @memcpy(descriptor_bytes[0..compact.descriptor.len], compact.descriptor);
+            try result.setNamedProperty("descriptor", try env.createTypedarray(.uint8, compact.descriptor.len, descriptor_buf, 0));
+        },
+        else => {
+            try env.throwError("STATE_ERROR", "Unexpected proof type");
+            return env.getNull();
+        },
+    }
+
+    return result;
+}
 
 pub fn BeaconStateView_computeUnrealizedCheckpoints(env: napi.Env, cb: napi.CallbackInfo(0)) !napi.Value {
     const cached_state = try env.unwrap(CachedBeaconState, cb.this());
@@ -995,7 +1067,7 @@ pub fn register(env: napi.Env, exports: napi.Value) !void {
             method(0, BeaconStateView_getFinalizedRootProof),
             // method(1, BeaconStateView_getSyncCommitteesWitness),
             method(1, BeaconStateView_getSingleProof),
-            // method(1, BeaconStateView_createMultiProof),
+            method(1, BeaconStateView_createMultiProof),
 
             method(0, BeaconStateView_computeUnrealizedCheckpoints),
 

bindings/src/index.ts

@@ -53,6 +53,12 @@ interface ProcessSlotsOpts {
   transferCache?: boolean;
 }
 
+interface CompactMultiProof {
+  type: "compactMulti";
+  leaves: Uint8Array[];
+  descriptor: Uint8Array;
+}
+
 interface ProposerRewards {
   attestations: bigint;
   syncAggregate: bigint;
@@ -104,6 +110,7 @@ type VoluntaryExitValidity =
   | "pending_withdrawals"
   | "invalid_signature";
 
+
 declare class BeaconStateView {
   static createFromBytes(fork: string, bytes: Uint8Array): BeaconStateView;
 
@@ -196,6 +203,7 @@ declare class BeaconStateView {
   serializedValidatorsSize(): number;
   serializeValidatorsToBytes(output: Uint8Array, offset: number): number;
   hashTreeRoot(): Uint8Array;
+  createMultiProof(descriptor: Uint8Array): CompactMultiProof;
 
   // stateTransition(signedBlockBytes: Uint8Array): BeaconStateView;
   processSlots(slot: number, options?: ProcessSlotsOpts): BeaconStateView;

bindings/test/demo.ts

@@ -107,6 +107,7 @@ printDuration("proposerLookahead", () => state.proposerLookahead);
 printDuration("getSingleProof(169)", () => state.getSingleProof(169));
 printDuration("isValidVoluntaryExit", () => state.isValidVoluntaryExit(new Uint8Array(112), false));
 printDuration("getVoluntaryExitValidity", () => state.getVoluntaryExitValidity(new Uint8Array(112), false));
+printDuration("createMultiProof(descriptor for gindex 42)", () => state.createMultiProof(Uint8Array.from([0x25, 0xe0])));
 printDuration("getFinalizedRootProof()", () => state.getFinalizedRootProof());
 printDuration("isExecutionStateType", () => state.isExecutionStateType);
 printDuration("getEffectiveBalanceIncrementsZeroInactive()", () => state.getEffectiveBalanceIncrementsZeroInactive());