@psavelis/enterprise-blockchain 0.1.0 → 1.1.1

package/dist/p2mr/index.js

@@ -0,0 +1,59 @@
+/**
+ * @psavelis/enterprise-blockchain/p2mr
+ *
+ * BIP-360-inspired Pay-to-Merkle-Root quantum-safe outputs.
+ *
+ * P2MR eliminates the "harvest now, decrypt later" quantum threat by:
+ * 1. Storing ONLY a Merkle root on-chain (no public keys exposed)
+ * 2. Using post-quantum ML-DSA-65 signatures for spending
+ * 3. Revealing public keys only at spend time (minimizing exposure window)
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   createP2MROutput,
+ *   createSingleSigLeaf,
+ *   createTimelockLeaf,
+ *   buildSpendProof,
+ *   verifySpendProofStructure,
+ * } from "@psavelis/enterprise-blockchain/p2mr";
+ *
+ * // Create an output with two spending paths
+ * const { output, tree } = createP2MROutput({
+ *   leaves: [
+ *     createSingleSigLeaf(primaryKeyHash),   // Path 0: primary key
+ *     createTimelockLeaf(backupKeyHash, locktime), // Path 1: backup after locktime
+ *   ],
+ *   value: 1_000_000n,
+ * });
+ *
+ * // Store `output` on-chain (only merkleRoot exposed)
+ * // Keep `tree` off-chain for generating spend proofs
+ *
+ * // Later, spend via path 0:
+ * const proof = buildSpendProof({
+ *   outputId: output.outputId,
+ *   tree,
+ *   leafIndex: 0,
+ *   witness: {
+ *     publicKeys: [primaryKey],
+ *     signatures: [signature],
+ *   },
+ * });
+ *
+ * // Verify proof structure and Merkle path
+ * const result = verifySpendProofStructure(proof, output);
+ * console.log(result.valid); // true
+ * ```
+ *
+ * @packageDocumentation
+ */
+// ---------------------------------------------------------------------------
+// Merkle Tree
+// ---------------------------------------------------------------------------
+export { MerkleTree, canonicalJSON, hashScriptLeaf } from "./merkle-tree.js";
+export { validateScriptLeaf, createSingleSigLeaf, createTimelockLeaf, createMultisigLeaf, createHsmAttestedLeaf, } from "./script-leaf.js";
+export { createP2MROutput, P2MROutputStore } from "./p2mr-output.js";
+export { buildSpendProof, validateSpendProofStructure, verifyMerkleProof, verifySpendProofStructure, } from "./spend-proof.js";
+export { interpretScript, hashPublicKey, configureInterpreter, resetInterpreter, } from "./script-interpreter.js";
+export { MlDsaSignatureVerifier, Sha256Hasher, defaultSignatureVerifier, defaultHasher, } from "./adapters.js";

package/dist/p2mr/merkle-tree.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Merkle Tree for P2MR Script Trees
+ *
+ * Constructs a binary Merkle tree from an array of ScriptLeaf nodes.
+ * Provides proof generation and verification for spending P2MR outputs.
+ *
+ * Construction algorithm:
+ * 1. Each leaf = SHA-256(canonicalJSON(ScriptLeaf)) → 64-char hex string
+ * 2. Internal nodes = SHA-256(leftHex + rightHex) where + is string concatenation
+ *    (i.e., hashing the 128-char hex string, not raw 64 bytes)
+ * 3. Odd leaf count: duplicate last leaf for balanced tree
+ * 4. Root = final 32-byte hash (64 hex chars)
+ *
+ * NOTE: This implementation hashes hex-encoded strings, not raw bytes.
+ * For example, sha256hex("abc...def" + "012...345") hashes the 128-character
+ * hex string, producing deterministic results portable across platforms.
+ */
+import type { ScriptLeaf, MerkleProofNode } from "./types.js";
+/**
+ * Serialize an object to canonical JSON (sorted keys).
+ *
+ * This ensures deterministic hashing regardless of object property order.
+ * Required for Merkle tree construction to be reproducible.
+ */
+export declare function canonicalJSON(obj: unknown): string;
+/**
+ * Compute SHA-256 hash of a ScriptLeaf using canonical JSON.
+ */
+export declare function hashScriptLeaf(leaf: ScriptLeaf): string;
+/**
+ * A Merkle tree constructed from an array of ScriptLeaf spending conditions.
+ *
+ * Usage:
+ * ```typescript
+ * const tree = new MerkleTree([
+ *   { type: "ml-dsa-65-sig", publicKeyHashes: [hash1] },
+ *   { type: "multisig-ml-dsa", publicKeyHashes: [hash2, hash3], threshold: 2 },
+ *   { type: "timelock", publicKeyHashes: [hash4], locktime: futureTime },
+ * ]);
+ *
+ * const output: P2MROutput = {
+ *   outputId: randomUUID(),
+ *   merkleRoot: tree.root,
+ *   value: 1000000n,
+ *   createdAt: Date.now(),
+ * };
+ *
+ * // Later, to spend via leaf 0:
+ * const proof = tree.getProof(0);
+ * ```
+ */
+export declare class MerkleTree {
+    #private;
+    /**
+     * Construct a Merkle tree from an array of script leaves.
+     *
+     * @param leaves - Array of spending conditions. Must have at least 1 element.
+     * @throws Error if leaves array is empty.
+     */
+    constructor(leaves: ScriptLeaf[]);
+    /**
+     * The Merkle root hash.
+     * Format: 64 hex characters (32 bytes SHA-256).
+     */
+    get root(): string;
+    /**
+     * The original script leaves.
+     */
+    get leaves(): readonly ScriptLeaf[];
+    /**
+     * The leaf hashes (SHA-256 of canonical JSON).
+     */
+    get leafHashes(): readonly string[];
+    /**
+     * Number of leaves in the tree.
+     */
+    get leafCount(): number;
+    /**
+     * Generate a Merkle proof for a specific leaf.
+     *
+     * @param leafIndex - Zero-based index of the leaf.
+     * @returns Array of MerkleProofNode from leaf to root.
+     * @throws Error if leafIndex is out of bounds.
+     */
+    getProof(leafIndex: number): MerkleProofNode[];
+    /**
+     * Verify that a leaf hashes to the expected root via a proof.
+     *
+     * This is a static method so it can be used without the full tree.
+     *
+     * @param leaf - The script leaf to verify.
+     * @param proof - Merkle proof path.
+     * @param expectedRoot - Expected Merkle root.
+     * @returns true if the proof is valid.
+     */
+    static verify(leaf: ScriptLeaf, proof: MerkleProofNode[], expectedRoot: string): boolean;
+    /**
+     * Verify a leaf hash (already computed) against a proof.
+     *
+     * Useful when you have the hash but not the original leaf data.
+     *
+     * @param leafHash - SHA-256 hash of the leaf.
+     * @param proof - Merkle proof path.
+     * @param expectedRoot - Expected Merkle root.
+     * @returns true if the proof is valid.
+     */
+    static verifyHash(leafHash: string, proof: MerkleProofNode[], expectedRoot: string): boolean;
+}
+//# sourceMappingURL=merkle-tree.d.ts.map

package/dist/p2mr/merkle-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle-tree.d.ts","sourceRoot":"","sources":["../../src/p2mr/merkle-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAM9D;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAyBlD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAEvD;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,UAAU;;IAiBrB;;;;;OAKG;gBACS,MAAM,EAAE,UAAU,EAAE;IAUhC;;;OAGG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,SAAS,UAAU,EAAE,CAElC;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,SAAS,MAAM,EAAE,CAElC;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE;IAwC9C;;;;;;;;;OASG;IACH,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,eAAe,EAAE,EACxB,YAAY,EAAE,MAAM,GACnB,OAAO;IAYV;;;;;;;;;OASG;IACH,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,eAAe,EAAE,EACxB,YAAY,EAAE,MAAM,GACnB,OAAO;CA8CX"}

package/dist/p2mr/merkle-tree.js

@@ -0,0 +1,239 @@
+/**
+ * Merkle Tree for P2MR Script Trees
+ *
+ * Constructs a binary Merkle tree from an array of ScriptLeaf nodes.
+ * Provides proof generation and verification for spending P2MR outputs.
+ *
+ * Construction algorithm:
+ * 1. Each leaf = SHA-256(canonicalJSON(ScriptLeaf)) → 64-char hex string
+ * 2. Internal nodes = SHA-256(leftHex + rightHex) where + is string concatenation
+ *    (i.e., hashing the 128-char hex string, not raw 64 bytes)
+ * 3. Odd leaf count: duplicate last leaf for balanced tree
+ * 4. Root = final 32-byte hash (64 hex chars)
+ *
+ * NOTE: This implementation hashes hex-encoded strings, not raw bytes.
+ * For example, sha256hex("abc...def" + "012...345") hashes the 128-character
+ * hex string, producing deterministic results portable across platforms.
+ */
+import { sha256hex } from "../shared/crypto.js";
+// ---------------------------------------------------------------------------
+// Canonical JSON Serialization
+// ---------------------------------------------------------------------------
+/**
+ * Serialize an object to canonical JSON (sorted keys).
+ *
+ * This ensures deterministic hashing regardless of object property order.
+ * Required for Merkle tree construction to be reproducible.
+ */
+export function canonicalJSON(obj) {
+    if (obj === null || obj === undefined) {
+        return JSON.stringify(obj);
+    }
+    if (Array.isArray(obj)) {
+        return "[" + obj.map((item) => canonicalJSON(item)).join(",") + "]";
+    }
+    if (typeof obj === "object") {
+        const sorted = Object.keys(obj)
+            .sort()
+            .map((key) => {
+            const value = obj[key];
+            // Skip undefined values
+            if (value === undefined) {
+                return null;
+            }
+            return `${JSON.stringify(key)}:${canonicalJSON(value)}`;
+        })
+            .filter((item) => item !== null);
+        return "{" + sorted.join(",") + "}";
+    }
+    return JSON.stringify(obj);
+}
+/**
+ * Compute SHA-256 hash of a ScriptLeaf using canonical JSON.
+ */
+export function hashScriptLeaf(leaf) {
+    return sha256hex(canonicalJSON(leaf));
+}
+// ---------------------------------------------------------------------------
+// MerkleTree Class
+// ---------------------------------------------------------------------------
+/**
+ * A Merkle tree constructed from an array of ScriptLeaf spending conditions.
+ *
+ * Usage:
+ * ```typescript
+ * const tree = new MerkleTree([
+ *   { type: "ml-dsa-65-sig", publicKeyHashes: [hash1] },
+ *   { type: "multisig-ml-dsa", publicKeyHashes: [hash2, hash3], threshold: 2 },
+ *   { type: "timelock", publicKeyHashes: [hash4], locktime: futureTime },
+ * ]);
+ *
+ * const output: P2MROutput = {
+ *   outputId: randomUUID(),
+ *   merkleRoot: tree.root,
+ *   value: 1000000n,
+ *   createdAt: Date.now(),
+ * };
+ *
+ * // Later, to spend via leaf 0:
+ * const proof = tree.getProof(0);
+ * ```
+ */
+export class MerkleTree {
+    /**
+     * The original leaves (script conditions).
+     */
+    #leaves;
+    /**
+     * Leaf hashes (SHA-256 of canonical JSON).
+     */
+    #leafHashes;
+    /**
+     * All levels of the tree, from leaves (level 0) to root (last level).
+     * Each level is an array of hashes.
+     */
+    #levels;
+    /**
+     * Construct a Merkle tree from an array of script leaves.
+     *
+     * @param leaves - Array of spending conditions. Must have at least 1 element.
+     * @throws Error if leaves array is empty.
+     */
+    constructor(leaves) {
+        if (leaves.length === 0) {
+            throw new Error("MerkleTree requires at least one leaf");
+        }
+        this.#leaves = [...leaves];
+        this.#leafHashes = leaves.map(hashScriptLeaf);
+        this.#levels = this.#buildTree();
+    }
+    /**
+     * The Merkle root hash.
+     * Format: 64 hex characters (32 bytes SHA-256).
+     */
+    get root() {
+        return this.#levels[this.#levels.length - 1][0];
+    }
+    /**
+     * The original script leaves.
+     */
+    get leaves() {
+        return this.#leaves;
+    }
+    /**
+     * The leaf hashes (SHA-256 of canonical JSON).
+     */
+    get leafHashes() {
+        return this.#leafHashes;
+    }
+    /**
+     * Number of leaves in the tree.
+     */
+    get leafCount() {
+        return this.#leaves.length;
+    }
+    /**
+     * Generate a Merkle proof for a specific leaf.
+     *
+     * @param leafIndex - Zero-based index of the leaf.
+     * @returns Array of MerkleProofNode from leaf to root.
+     * @throws Error if leafIndex is out of bounds.
+     */
+    getProof(leafIndex) {
+        if (leafIndex < 0 || leafIndex >= this.#leaves.length) {
+            throw new Error(`Leaf index ${leafIndex} out of bounds [0, ${this.#leaves.length - 1}]`);
+        }
+        const proof = [];
+        let idx = leafIndex;
+        // Traverse from leaves up to (but not including) the root
+        for (let level = 0; level < this.#levels.length - 1; level++) {
+            const currentLevel = this.#levels[level];
+            const isLeftChild = idx % 2 === 0;
+            const siblingIdx = isLeftChild ? idx + 1 : idx - 1;
+            // When sibling doesn't exist (odd number at this level), the tree builder
+            // duplicates the last node to pair with itself. We must include this
+            // self-sibling in the proof for verification to work correctly.
+            if (siblingIdx < currentLevel.length) {
+                proof.push({
+                    hash: currentLevel[siblingIdx],
+                    position: isLeftChild ? "right" : "left",
+                });
+            }
+            else {
+                // Sibling is out of bounds - this node was duplicated as its own pair
+                // Include the self-hash as the sibling
+                proof.push({
+                    hash: currentLevel[idx],
+                    position: "right",
+                });
+            }
+            // Move to parent index
+            idx = Math.floor(idx / 2);
+        }
+        return proof;
+    }
+    /**
+     * Verify that a leaf hashes to the expected root via a proof.
+     *
+     * This is a static method so it can be used without the full tree.
+     *
+     * @param leaf - The script leaf to verify.
+     * @param proof - Merkle proof path.
+     * @param expectedRoot - Expected Merkle root.
+     * @returns true if the proof is valid.
+     */
+    static verify(leaf, proof, expectedRoot) {
+        let hash = hashScriptLeaf(leaf);
+        for (const node of proof) {
+            const combined = node.position === "left" ? node.hash + hash : hash + node.hash;
+            hash = sha256hex(combined);
+        }
+        return hash === expectedRoot;
+    }
+    /**
+     * Verify a leaf hash (already computed) against a proof.
+     *
+     * Useful when you have the hash but not the original leaf data.
+     *
+     * @param leafHash - SHA-256 hash of the leaf.
+     * @param proof - Merkle proof path.
+     * @param expectedRoot - Expected Merkle root.
+     * @returns true if the proof is valid.
+     */
+    static verifyHash(leafHash, proof, expectedRoot) {
+        let hash = leafHash;
+        for (const node of proof) {
+            const combined = node.position === "left" ? node.hash + hash : hash + node.hash;
+            hash = sha256hex(combined);
+        }
+        return hash === expectedRoot;
+    }
+    // ---------------------------------------------------------------------------
+    // Private Methods
+    // ---------------------------------------------------------------------------
+    /**
+     * Build the tree from leaf hashes up to the root.
+     */
+    #buildTree() {
+        const levels = [];
+        // Level 0: leaf hashes (possibly padded to even count)
+        let currentLevel = [...this.#leafHashes];
+        if (currentLevel.length % 2 === 1 && currentLevel.length > 1) {
+            // Duplicate last leaf for odd count
+            currentLevel.push(currentLevel[currentLevel.length - 1]);
+        }
+        levels.push(currentLevel);
+        // Build parent levels until we reach the root
+        while (currentLevel.length > 1) {
+            const parentLevel = [];
+            for (let i = 0; i < currentLevel.length; i += 2) {
+                const left = currentLevel[i];
+                const right = currentLevel[i + 1] ?? left; // Handle odd case
+                parentLevel.push(sha256hex(left + right));
+            }
+            levels.push(parentLevel);
+            currentLevel = parentLevel;
+        }
+        return levels;
+    }
+}

package/dist/p2mr/p2mr-output.d.ts

@@ -0,0 +1,142 @@
+/**
+ * P2MR Output Management
+ *
+ * Provides factory functions and storage patterns for P2MR outputs.
+ * Outputs are created by committing to a Merkle root and tracked
+ * in an output store for spending.
+ */
+import type { Store } from "../shared/store.js";
+import type { P2MROutput, ScriptLeaf } from "./types.js";
+import { MerkleTree } from "./merkle-tree.js";
+/** Alias for the P2MR output store type (outputId -> P2MROutput). */
+type P2MRStore = Store<string, P2MROutput>;
+/**
+ * Options for creating a P2MR output.
+ */
+export interface CreateP2MROutputOptions {
+    /**
+     * Spending conditions for the output.
+     * These are hashed into a Merkle tree; only the root is stored on-chain.
+     */
+    leaves: ScriptLeaf[];
+    /**
+     * Value locked in the output.
+     */
+    value: bigint;
+    /**
+     * Optional output ID. If not provided, a UUID is generated.
+     */
+    outputId?: string;
+    /**
+     * Optional creation timestamp. Defaults to current time.
+     */
+    createdAt?: number;
+    /**
+     * Optional metadata hash (SHA-256 of off-chain data).
+     */
+    metadataHash?: string;
+}
+/**
+ * Result of creating a P2MR output.
+ *
+ * Returns both the output (for on-chain storage) and the Merkle tree
+ * (for generating spend proofs later).
+ */
+export interface CreateP2MROutputResult {
+    /**
+     * The P2MR output to store on-chain.
+     */
+    output: P2MROutput;
+    /**
+     * The Merkle tree constructed from the spending conditions.
+     * Keep this off-chain for generating spend proofs.
+     */
+    tree: MerkleTree;
+}
+/**
+ * Create a P2MR output from spending conditions.
+ *
+ * The output stores only the Merkle root; the actual spending conditions
+ * (script leaves) are kept off-chain by the creator. This prevents
+ * quantum adversaries from harvesting public keys from unspent outputs.
+ *
+ * @param options - Output creation options.
+ * @returns The P2MR output and its Merkle tree.
+ * @throws Error if leaves array is empty or value is negative.
+ *
+ * @example
+ * ```typescript
+ * import { createP2MROutput, createSingleSigLeaf, createTimelockLeaf } from "@enterprise-blockchain/p2mr";
+ *
+ * const primaryKey = "a1b2c3..."; // SHA-256 hash of ML-DSA-65 public key
+ * const backupKey = "d4e5f6...";
+ *
+ * const { output, tree } = createP2MROutput({
+ *   leaves: [
+ *     createSingleSigLeaf(primaryKey),           // Spend path 0: primary key
+ *     createTimelockLeaf(backupKey, futureTime), // Spend path 1: backup after 1 year
+ *   ],
+ *   value: 1_000_000n,
+ * });
+ *
+ * // Store `output` on-chain (only merkleRoot exposed)
+ * // Keep `tree` off-chain for generating spend proofs
+ * ```
+ */
+export declare function createP2MROutput(options: CreateP2MROutputOptions): CreateP2MROutputResult;
+/**
+ * A store for P2MR outputs indexed by outputId.
+ *
+ * Provides methods for tracking unspent outputs (UTXOs).
+ */
+export declare class P2MROutputStore {
+    #private;
+    /**
+     * Create a new P2MR output store.
+     *
+     * @param store - Optional backing store. Defaults to in-memory.
+     */
+    constructor(store?: P2MRStore);
+    /**
+     * Add an output to the store.
+     *
+     * @param output - The P2MR output to store.
+     * @throws Error if output with same ID already exists.
+     */
+    add(output: P2MROutput): void;
+    /**
+     * Get an output by ID.
+     *
+     * @param outputId - The output ID.
+     * @returns The output, or undefined if not found.
+     */
+    get(outputId: string): P2MROutput | undefined;
+    /**
+     * Check if an output is unspent.
+     *
+     * @param outputId - The output ID.
+     * @returns true if the output exists and has not been spent.
+     */
+    isUnspent(outputId: string): boolean;
+    /**
+     * Mark an output as spent.
+     *
+     * @param outputId - The output ID.
+     * @throws Error if output does not exist or is already spent.
+     */
+    markSpent(outputId: string): void;
+    /**
+     * Get all unspent outputs.
+     *
+     * @returns Array of unspent P2MR outputs.
+     */
+    getUnspent(): P2MROutput[];
+    /**
+     * Get total value of all unspent outputs.
+     *
+     * @returns Sum of all unspent output values.
+     */
+    getUnspentBalance(): bigint;
+}
+export {};
+//# sourceMappingURL=p2mr-output.d.ts.map

package/dist/p2mr/p2mr-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"p2mr-output.d.ts","sourceRoot":"","sources":["../../src/p2mr/p2mr-output.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,qEAAqE;AACrE,KAAK,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAM3C;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,MAAM,EAAE,UAAU,EAAE,CAAC;IAErB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,MAAM,EAAE,UAAU,CAAC;IAEnB;;;OAGG;IACH,IAAI,EAAE,UAAU,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,uBAAuB,GAC/B,sBAAsB,CAyBxB;AAMD;;;;GAIG;AACH,qBAAa,eAAe;;IAI1B;;;;OAIG;gBACS,KAAK,CAAC,EAAE,SAAS;IAK7B;;;;;OAKG;IACH,GAAG,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAQ7B;;;;;OAKG;IACH,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAI7C;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAQpC;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAWjC;;;;OAIG;IACH,UAAU,IAAI,UAAU,EAAE;IAK1B;;;;OAIG;IACH,iBAAiB,IAAI,MAAM;CAI5B"}