@wiimdy/openfunderse-sdk 0.1.2 → 1.0.0

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Canonical weight scale for allocation claims (1e18).
+ * Every claim's `targetWeights` MUST sum to exactly this value.
+ * Example: 50/50 split = [500000000000000000n, 500000000000000000n]
+ */
+export declare const CLAIM_WEIGHT_SCALE = 1000000000000000000n;

package/dist/constants.js

@@ -0,0 +1,6 @@
+/**
+ * Canonical weight scale for allocation claims (1e18).
+ * Every claim's `targetWeights` MUST sum to exactly this value.
+ * Example: 50/50 split = [500000000000000000n, 500000000000000000n]
+ */
+export const CLAIM_WEIGHT_SCALE = 1000000000000000000n;

package/dist/hash.d.ts

@@ -4,8 +4,21 @@ export declare function intentHash(intent: TradeIntent): Hex;
 export declare function snapshotHash(epochId: bigint, orderedClaimHashes: Hex[]): Hex;
 export declare function canonicalOrderedClaimHashes(claimHashes: Hex[]): Hex[];
 export declare function snapshotHashFromUnordered(epochId: bigint, claimHashes: Hex[]): Hex;
-export declare const epochStateHash: typeof snapshotHash;
-export declare const epochStateHashFromUnordered: typeof snapshotHashFromUnordered;
+/**
+ * Deterministic Merkle root for strictly-sorted bytes32 leaves using commutative keccak256.
+ * - Leaves must be strictly sorted ascending with no duplicates.
+ * - If a layer has an odd number of nodes, the last node is duplicated.
+ */
+export declare function merkleRoot(orderedLeaves: Hex[]): Hex;
+export declare function merkleRootFromUnorderedLeaves(leaves: Hex[]): Hex;
+/**
+ * Epoch state hash used as the onchain/offchain snapshot root.
+ * Compatible with {SnapshotBook} + {IntentBook} snapshot gating.
+ */
+export declare function epochStateHash(epochId: bigint, orderedClaimHashes: Hex[]): Hex;
+export declare function epochStateHashFromUnordered(epochId: bigint, claimHashes: Hex[]): Hex;
+export declare function merkleProof(orderedLeaves: Hex[], leaf: Hex): Hex[];
+export declare function merkleProofFromUnorderedLeaves(leaves: Hex[], leaf: Hex): Hex[];
 export declare function reasonHash(reason: string): Hex;
 /**
  * Canonical allowlist hash for intent execution route.

package/dist/hash.js

@@ -59,8 +59,85 @@ export function snapshotHashFromUnordered(epochId, claimHashes) {
     const orderedClaimHashes = canonicalOrderedClaimHashes(claimHashes);
     return snapshotHash(epochId, orderedClaimHashes);
 }
-export const epochStateHash = snapshotHash;
-export const epochStateHashFromUnordered = snapshotHashFromUnordered;
+const MERKLE_NODE_PAIR = parseAbiParameters("bytes32 a, bytes32 b");
+const EPOCH_STATE_HASH_INPUT = parseAbiParameters("uint64 epochId,bytes32 merkleRoot");
+function merkleHashPair(a, b) {
+    const left = a.toLowerCase() < b.toLowerCase() ? a : b;
+    const right = left === a ? b : a;
+    return keccak256(encodeAbiParameters(MERKLE_NODE_PAIR, [left, right]));
+}
+/**
+ * Deterministic Merkle root for strictly-sorted bytes32 leaves using commutative keccak256.
+ * - Leaves must be strictly sorted ascending with no duplicates.
+ * - If a layer has an odd number of nodes, the last node is duplicated.
+ */
+export function merkleRoot(orderedLeaves) {
+    if (orderedLeaves.length === 0) {
+        throw new Error("leaves must not be empty");
+    }
+    assertStrictlySortedHex(orderedLeaves, "orderedLeaves");
+    let layer = [...orderedLeaves];
+    while (layer.length > 1) {
+        const next = [];
+        for (let i = 0; i < layer.length; i += 2) {
+            const left = layer[i];
+            const right = i + 1 < layer.length ? layer[i + 1] : layer[i];
+            next.push(merkleHashPair(left, right));
+        }
+        layer = next;
+    }
+    return layer[0];
+}
+export function merkleRootFromUnorderedLeaves(leaves) {
+    const ordered = uniqueSortedBytes32Hex(leaves);
+    return merkleRoot(ordered);
+}
+/**
+ * Epoch state hash used as the onchain/offchain snapshot root.
+ * Compatible with {SnapshotBook} + {IntentBook} snapshot gating.
+ */
+export function epochStateHash(epochId, orderedClaimHashes) {
+    assertUint64(epochId, "epochId");
+    const root = merkleRoot(orderedClaimHashes);
+    return keccak256(encodeAbiParameters(EPOCH_STATE_HASH_INPUT, [epochId, root]));
+}
+export function epochStateHashFromUnordered(epochId, claimHashes) {
+    assertUint64(epochId, "epochId");
+    const ordered = canonicalOrderedClaimHashes(claimHashes);
+    return epochStateHash(epochId, ordered);
+}
+export function merkleProof(orderedLeaves, leaf) {
+    assertStrictlySortedHex(orderedLeaves, "orderedLeaves");
+    if (orderedLeaves.length === 0) {
+        throw new Error("orderedLeaves must not be empty");
+    }
+    const normalizedLeaf = leaf.toLowerCase();
+    const index0 = orderedLeaves.findIndex((entry) => entry.toLowerCase() === normalizedLeaf);
+    if (index0 < 0) {
+        throw new Error("leaf not found in orderedLeaves");
+    }
+    const proof = [];
+    let index = index0;
+    let layer = [...orderedLeaves];
+    while (layer.length > 1) {
+        const siblingIndex = index ^ 1; // toggle last bit
+        const sibling = siblingIndex < layer.length ? layer[siblingIndex] : layer[index];
+        proof.push(sibling);
+        const next = [];
+        for (let i = 0; i < layer.length; i += 2) {
+            const left = layer[i];
+            const right = i + 1 < layer.length ? layer[i + 1] : layer[i];
+            next.push(merkleHashPair(left, right));
+        }
+        layer = next;
+        index = Math.floor(index / 2);
+    }
+    return proof;
+}
+export function merkleProofFromUnorderedLeaves(leaves, leaf) {
+    const ordered = uniqueSortedBytes32Hex(leaves);
+    return merkleProof(ordered, leaf);
+}
 export function reasonHash(reason) {
     return keccak256(toHex(reason.normalize("NFC").trim()));
 }

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./types.js";
 export * from "./nadfun-types.js";
+export * from "./constants.js";
 export * from "./canonical.js";
 export * from "./hash.js";
 export * from "./eip712.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from "./types.js";
 export * from "./nadfun-types.js";
+export * from "./constants.js";
 export * from "./canonical.js";
 export * from "./hash.js";
 export * from "./eip712.js";

package/dist/relayer-utils.js

@@ -1,6 +1,7 @@
 import { keccak256 } from "viem";
 import { canonicalAllocationClaim, canonicalIntent } from "./canonical.js";
-import { allocationClaimHash, intentExecutionAllowlistHash, intentHash, snapshotHashFromUnordered } from "./hash.js";
+import { CLAIM_WEIGHT_SCALE } from "./constants.js";
+import { allocationClaimHash, intentExecutionAllowlistHash, intentHash, epochStateHashFromUnordered } from "./hash.js";
 import { assertUint16, assertUint64 } from "./validate.js";
 function assertPositive(value, label) {
     if (value <= 0n) {
@@ -18,6 +19,12 @@ function assertWeightsSumPositive(weights) {
         throw new Error("targetWeights sum must be positive");
     }
 }
+function assertWeightsSumEqualsScale(weights) {
+    const sum = weights.reduce((acc, w) => acc + w, 0n);
+    if (sum !== CLAIM_WEIGHT_SCALE) {
+        throw new Error(`targetWeights sum must equal CLAIM_WEIGHT_SCALE (${CLAIM_WEIGHT_SCALE}), got ${sum}`);
+    }
+}
 export function buildCanonicalAllocationClaimRecord(input) {
     assertUint64(input.claim.epochId, "epochId");
     assertUint64(input.claim.horizonSec, "horizonSec");
@@ -35,6 +42,7 @@ export function buildCanonicalAllocationClaimRecord(input) {
         }
     });
     assertWeightsSumPositive(claim.targetWeights);
+    assertWeightsSumEqualsScale(claim.targetWeights);
     return {
         claim,
         claimHash: allocationClaimHash(claim)
@@ -78,7 +86,7 @@ export function buildEpochStateRecord(input) {
     if (input.claimHashes.length === 0) {
         throw new Error("claimHashes must not be empty");
     }
-    const hash = snapshotHashFromUnordered(input.epochId, input.claimHashes);
+    const hash = epochStateHashFromUnordered(input.epochId, input.claimHashes);
     return {
         epochId: input.epochId,
         epochStateHash: hash

package/dist/scope.d.ts

@@ -1,5 +1,5 @@
 import type { Hex, ProtocolScope } from "./types.js";
 export declare function canonicalScope(input: ProtocolScope): ProtocolScope;
-export declare function scopeKey(input: ProtocolScope): string;
+export declare function scopeKey(input: ProtocolScope): Hex;
 export declare function assertSameScope(expected: ProtocolScope, received: ProtocolScope): void;
 export declare function scopedSnapshotHash(scope: ProtocolScope, snapshotHash: Hex): Hex;

package/dist/scope.js

@@ -1,4 +1,5 @@
 import { encodeAbiParameters, keccak256, parseAbiParameters } from "viem";
+const SCOPE_KEY_INPUT = parseAbiParameters("string fundId,string roomId,uint64 epochId");
 function normalizeScopeText(value) {
     return value.normalize("NFC").trim();
 }
@@ -11,7 +12,7 @@ export function canonicalScope(input) {
 }
 export function scopeKey(input) {
     const v = canonicalScope(input);
-    return `${v.fundId}:${v.roomId}:${v.epochId.toString(10)}`;
+    return keccak256(encodeAbiParameters(SCOPE_KEY_INPUT, [v.fundId, v.roomId, v.epochId]));
 }
 export function assertSameScope(expected, received) {
     const left = scopeKey(expected);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wiimdy/openfunderse-sdk",
-  "version": "0.1.2",
+  "version": "1.0.0",
   "description": "Canonical hashing and EIP-712 helpers for Claw protocol components.",
   "license": "MIT",
   "type": "module",