@intentlayer/sdk 0.1.0

package/dist/chunk-GRBEB2EV.mjs

@@ -0,0 +1,1112 @@
+import {
+  __esm
+} from "./chunk-XP4I75K7.mjs";
+
+// src/constraints.ts
+import { keccak256, encodePacked, decodeAbiParameters } from "viem";
+function toBigEndianUint128(value) {
+  if (value >= 1n << 128n) {
+    throw new Error("Value exceeds uint128 maximum");
+  }
+  const shifted = value << 128n;
+  const hex = shifted.toString(16).padStart(64, "0");
+  const high16Bytes = hex.slice(0, 32);
+  return `0x${high16Bytes}`;
+}
+function toBigEndianUint48(value) {
+  if (value >= 281474976710656) {
+    throw new Error("Value exceeds uint48 maximum");
+  }
+  const shifted = BigInt(value) << 208n;
+  const hex = shifted.toString(16).padStart(64, "0");
+  const high6Bytes = hex.slice(0, 12);
+  return `0x${high6Bytes}`;
+}
+function toBigEndianUint32(value) {
+  if (value >= 4294967296) {
+    throw new Error("Value exceeds uint32 maximum");
+  }
+  const shifted = BigInt(value) << 224n;
+  const hex = shifted.toString(16).padStart(64, "0");
+  const high4Bytes = hex.slice(0, 8);
+  return `0x${high4Bytes}`;
+}
+function toBigEndianInt16(value) {
+  if (value < -32768 || value > 32767) {
+    throw new Error("Value exceeds int16 range");
+  }
+  const unsignedValue = value < 0 ? 65536 + value : value;
+  const shifted = BigInt(unsignedValue) << 240n;
+  const hex = shifted.toString(16).padStart(64, "0");
+  const high2Bytes = hex.slice(0, 4);
+  return `0x${high2Bytes}`;
+}
+function toBigEndianUint16(value) {
+  if (value >= 65536) {
+    throw new Error("Value exceeds uint16 maximum");
+  }
+  const shifted = BigInt(value) << 240n;
+  const hex = shifted.toString(16).padStart(64, "0");
+  const high2Bytes = hex.slice(0, 4);
+  return `0x${high2Bytes}`;
+}
+function createConstraintBuilder() {
+  return new CompoundLeafBuilder();
+}
+function getLeafAndProofForRecipient(policy, recipient, asset) {
+  const assetKey = asset || "0x0000000000000000000000000000000000000000";
+  const key = `${recipient.toLowerCase()}-${assetKey.toLowerCase()}`;
+  const proof = policy.leafProofs[key];
+  return proof || null;
+}
+function isRecipientAllowed(policy, recipient, asset) {
+  const assetKey = asset || "0x0000000000000000000000000000000000000000";
+  const key = `${recipient.toLowerCase()}-${assetKey.toLowerCase()}`;
+  return key in policy.leafProofs;
+}
+function buildConstraintCalldata(wallet, asset, recipient, amount) {
+  if (amount >= 1n << 128n) {
+    throw new Error("Amount exceeds uint128 maximum");
+  }
+  return encodePacked(
+    ["address", "address", "address", "uint128"],
+    [wallet, asset, recipient, amount]
+  );
+}
+function buildConstraintCalldataFromIntent(intent, wallet) {
+  return buildConstraintCalldata(
+    wallet,
+    intent.asset,
+    intent.recipient,
+    intent.amount
+  );
+}
+function extractConstraintDataFromOperations(operationsBundle, owner) {
+  try {
+    const operations = decodeAbiParameters(
+      [{
+        type: "tuple[]",
+        components: [
+          { type: "uint8", name: "opType" },
+          { type: "address", name: "target" },
+          { type: "uint256", name: "value" },
+          { type: "bytes", name: "data" }
+        ]
+      }],
+      operationsBundle
+    )[0];
+    const transferOp = operations.find((op) => op.opType === 2);
+    if (!transferOp) {
+      return null;
+    }
+    const [recipient, amount] = decodeAbiParameters(
+      [{ type: "address" }, { type: "uint256" }],
+      transferOp.data
+    );
+    const token = transferOp.target;
+    const constraintCalldata = buildConstraintCalldataFromIntent(
+      { asset: token, recipient, amount },
+      owner
+    );
+    return {
+      constraintCalldata,
+      token,
+      recipient,
+      amount
+    };
+  } catch (error) {
+    console.error("Failed to extract constraint data from operations:", error);
+    return null;
+  }
+}
+var DOMAIN_PREFIX2, TAG_COMPOUND_EMPLOYEE2, COMPOUND_LEAF_VERSION, FLAG_RECIPIENT, FLAG_CAP, FLAG_DEADLINE, FLAG_ASSET, FLAG_BUCKET, FLAG_PERIOD, FLAG_VENDOR_GROUP, DOMAIN_V3, VERSION_V3, TAG_COMPOUND_V3, FLAG_TARGET, FLAG_SELECTOR_LIST, FLAG_NO_BRIDGE, FLAG_OPS_HASH, PERIOD_NONE2, PERIOD_DAILY2, PERIOD_WEEKLY2, PERIOD_MONTH302, PERIOD_CUSTOM2, CompoundLeafBuilder, CompoundLeafV3Builder;
+var init_constraints = __esm({
+  "src/constraints.ts"() {
+    "use strict";
+    DOMAIN_PREFIX2 = keccak256("IEL_CONSTRAINT_LEAF_V1").slice(0, 10);
+    TAG_COMPOUND_EMPLOYEE2 = 16;
+    COMPOUND_LEAF_VERSION = 1;
+    FLAG_RECIPIENT = 1;
+    FLAG_CAP = 2;
+    FLAG_DEADLINE = 4;
+    FLAG_ASSET = 8;
+    FLAG_BUCKET = 16;
+    FLAG_PERIOD = 32;
+    FLAG_VENDOR_GROUP = 64;
+    DOMAIN_V3 = "0x49454C33";
+    VERSION_V3 = 3;
+    TAG_COMPOUND_V3 = 32;
+    FLAG_TARGET = 2048;
+    FLAG_SELECTOR_LIST = 4096;
+    FLAG_NO_BRIDGE = 8192;
+    FLAG_OPS_HASH = 16384;
+    PERIOD_NONE2 = 0;
+    PERIOD_DAILY2 = 1;
+    PERIOD_WEEKLY2 = 2;
+    PERIOD_MONTH302 = 3;
+    PERIOD_CUSTOM2 = 4;
+    CompoundLeafBuilder = class {
+      /**
+       * Build compound constraint leaf with TLV encoding
+       * 
+       * Format: [4B domain_prefix][1B tag][1B version][1B flags][conditional_fields...]
+       * Matches foundry test _buildCompoundLeaf exactly
+       */
+      buildCompoundLeaf(constraints) {
+        let flags = 0;
+        if (constraints.allowedAsset) {
+          if (!constraints.allowedAsset.match(/^0x[a-fA-F0-9]{40}$/)) {
+            throw new Error(`Invalid asset address: ${constraints.allowedAsset}`);
+          }
+          flags |= FLAG_ASSET;
+        }
+        if (constraints.allowedRecipient) {
+          if (!constraints.allowedRecipient.match(/^0x[a-fA-F0-9]{40}$/)) {
+            throw new Error(`Invalid recipient address: ${constraints.allowedRecipient}`);
+          }
+          flags |= FLAG_RECIPIENT;
+        }
+        if (constraints.maxAmount !== void 0) {
+          if (constraints.maxAmount <= 0n) {
+            throw new Error("Amount must be positive");
+          }
+          if (constraints.maxAmount >= 1n << 128n) {
+            throw new Error("Amount exceeds uint128 maximum");
+          }
+          flags |= FLAG_CAP;
+        }
+        if (constraints.deadline !== void 0) {
+          const currentTimestamp = Math.floor(Date.now() / 1e3);
+          if (constraints.deadline <= currentTimestamp) {
+            throw new Error("Deadline must be in the future");
+          }
+          const maxUint48 = 2n ** 48n - 1n;
+          if (BigInt(constraints.deadline) >= maxUint48) {
+            throw new Error("Deadline exceeds uint48 maximum");
+          }
+          flags |= FLAG_DEADLINE;
+        }
+        if (constraints.bucketId) {
+          if (!constraints.bucketId.match(/^0x[a-fA-F0-9]{64}$/)) {
+            throw new Error(`Invalid bucketId format: ${constraints.bucketId}`);
+          }
+          flags |= FLAG_BUCKET;
+        }
+        if (constraints.periodCode !== void 0) {
+          console.log("\u{1F50D} SDK DEBUG: Period constraint validation triggered");
+          console.log("\u{1F50D} SDK DEBUG: periodCode:", constraints.periodCode);
+          console.log("\u{1F50D} SDK DEBUG: FLAG_PERIOD value:", FLAG_PERIOD);
+          if (constraints.periodCode < 0 || constraints.periodCode > 4) {
+            throw new Error(`Invalid period code: ${constraints.periodCode}`);
+          }
+          flags |= FLAG_PERIOD;
+          console.log("\u{1F50D} SDK DEBUG: flags after adding FLAG_PERIOD:", flags);
+          if (constraints.offsetMinutes !== void 0) {
+            if (constraints.offsetMinutes < -720 || constraints.offsetMinutes > 840) {
+              throw new Error(`Invalid UTC offset: ${constraints.offsetMinutes} (must be -720 to +840)`);
+            }
+          }
+          if (constraints.periodCode === PERIOD_CUSTOM2 && !constraints.customSeconds) {
+            throw new Error("Custom period requires customSeconds");
+          }
+        }
+        if (constraints.vendorGroupId) {
+          if (!constraints.vendorGroupId.match(/^0x[a-fA-F0-9]{64}$/)) {
+            throw new Error(`Invalid vendorGroupId format: ${constraints.vendorGroupId}`);
+          }
+          flags |= FLAG_VENDOR_GROUP;
+        }
+        let leaf = encodePacked(
+          ["bytes4", "uint8", "uint8", "uint8"],
+          [DOMAIN_PREFIX2, TAG_COMPOUND_EMPLOYEE2, COMPOUND_LEAF_VERSION, flags]
+        );
+        if (flags & FLAG_ASSET) {
+          leaf = encodePacked(
+            ["bytes", "address"],
+            [leaf, constraints.allowedAsset]
+          );
+        }
+        if (flags & FLAG_RECIPIENT) {
+          leaf = encodePacked(
+            ["bytes", "address"],
+            [leaf, constraints.allowedRecipient]
+          );
+        }
+        if (flags & FLAG_CAP) {
+          const capBigEndian = toBigEndianUint128(constraints.maxAmount);
+          leaf = encodePacked(
+            ["bytes", "bytes"],
+            [leaf, capBigEndian]
+          );
+        }
+        if (flags & FLAG_DEADLINE) {
+          const deadlineBigEndian = toBigEndianUint48(constraints.deadline);
+          leaf = encodePacked(
+            ["bytes", "bytes"],
+            [leaf, deadlineBigEndian]
+          );
+        }
+        if (flags & FLAG_BUCKET) {
+          leaf = encodePacked(
+            ["bytes", "bytes32"],
+            [leaf, constraints.bucketId]
+          );
+        }
+        if (flags & FLAG_PERIOD) {
+          leaf = encodePacked(
+            ["bytes", "uint8"],
+            [leaf, constraints.periodCode]
+          );
+          const offset = constraints.offsetMinutes ?? 0;
+          const offsetBigEndian = toBigEndianInt16(offset);
+          leaf = encodePacked(
+            ["bytes", "bytes"],
+            [leaf, offsetBigEndian]
+          );
+          if (constraints.periodCode === PERIOD_CUSTOM2) {
+            const customSecondsBigEndian = toBigEndianUint32(constraints.customSeconds);
+            leaf = encodePacked(
+              ["bytes", "bytes"],
+              [leaf, customSecondsBigEndian]
+            );
+          }
+        }
+        if (flags & FLAG_VENDOR_GROUP) {
+          leaf = encodePacked(
+            ["bytes", "bytes32"],
+            [leaf, constraints.vendorGroupId]
+          );
+        }
+        return {
+          flags,
+          asset: constraints.allowedAsset,
+          recipient: constraints.allowedRecipient,
+          cap: constraints.maxAmount,
+          deadline: constraints.deadline,
+          bucketId: constraints.bucketId,
+          periodCode: constraints.periodCode,
+          offsetMinutes: constraints.offsetMinutes,
+          customSeconds: constraints.customSeconds,
+          vendorGroupId: constraints.vendorGroupId,
+          encoded: leaf
+        };
+      }
+      /**
+       * Create compound constraint policy
+       * 
+       * High-level helper that builds compound leaf and returns everything needed
+       * for policy registration. Handles both single and multiple recipients.
+       */
+      createConstrainedPolicy(walletAddress, constraints) {
+        if (constraints.allowedRecipients && constraints.allowedRecipients.length > 1) {
+          throw new Error("Use createMultiRecipientPolicy() for multiple recipients");
+        }
+        const recipient = constraints.allowedRecipients?.[0] || constraints.allowedRecipient;
+        const normalizedConstraints = {
+          allowedAsset: constraints.allowedAsset,
+          allowedRecipient: recipient,
+          maxAmount: constraints.maxAmount,
+          deadline: constraints.deadline,
+          bucketId: constraints.bucketId,
+          // Week 1 additions
+          periodCode: constraints.periodCode,
+          offsetMinutes: constraints.offsetMinutes,
+          customSeconds: constraints.customSeconds,
+          vendorGroupId: constraints.vendorGroupId
+        };
+        const hasConstraints = normalizedConstraints.allowedAsset || normalizedConstraints.allowedRecipient || normalizedConstraints.maxAmount !== void 0 || normalizedConstraints.deadline !== void 0 || normalizedConstraints.bucketId || normalizedConstraints.periodCode !== void 0 || normalizedConstraints.vendorGroupId;
+        if (!hasConstraints) {
+          return {
+            policyId: keccak256(walletAddress),
+            merkleRoot: "0x0000000000000000000000000000000000000000000000000000000000000000",
+            leafAndProof: "0x",
+            // Empty bytes for no constraints
+            policyRootVersion: 1,
+            // Compound leaf version
+            leaf: {
+              flags: 0,
+              encoded: "0x"
+            }
+          };
+        }
+        const leaf = this.buildCompoundLeaf(normalizedConstraints);
+        const merkleRoot = keccak256(leaf.encoded);
+        return {
+          policyId: keccak256(walletAddress),
+          merkleRoot,
+          leafAndProof: leaf.encoded,
+          // Single leaf, no separate proof needed
+          policyRootVersion: 1,
+          // Compound leaf version
+          leaf
+        };
+      }
+      /**
+       * Build asset-only constraint (common case)
+       */
+      buildAssetConstraint(asset) {
+        return this.buildCompoundLeaf({ allowedAsset: asset });
+      }
+      /**
+       * Build recipient-only constraint (common case)
+       */
+      buildRecipientConstraint(recipient) {
+        return this.buildCompoundLeaf({ allowedRecipient: recipient });
+      }
+      /**
+       * Build cap-only constraint (common case)
+       */
+      buildCapConstraint(maxAmount) {
+        return this.buildCompoundLeaf({ maxAmount });
+      }
+      /**
+       * Build asset + recipient constraint (common case)
+       */
+      buildAssetRecipientConstraint(asset, recipient) {
+        return this.buildCompoundLeaf({
+          allowedAsset: asset,
+          allowedRecipient: recipient
+        });
+      }
+      /**
+       * Build recipient + cap constraint (common case)
+       */
+      buildRecipientCapConstraint(recipient, maxAmount) {
+        return this.buildCompoundLeaf({
+          allowedRecipient: recipient,
+          maxAmount
+        });
+      }
+      /**
+       * Build full constraint with all fields (common case)
+       */
+      buildFullConstraint(asset, recipient, maxAmount, deadline, bucketId) {
+        return this.buildCompoundLeaf({
+          allowedAsset: asset,
+          allowedRecipient: recipient,
+          maxAmount,
+          deadline,
+          bucketId
+        });
+      }
+      /**
+       * Create compound leaf with proper validation (alternative to buildCompoundLeaf)
+       * 
+       * Provides a cleaner interface for creating individual compound leaves
+       */
+      createCompoundLeaf(constraints) {
+        if (!constraints.asset && !constraints.recipient && constraints.maxAmount === void 0 && constraints.deadline === void 0 && !constraints.bucketId) {
+          throw new Error("At least one constraint must be specified");
+        }
+        const policyConstraints = {
+          allowedAsset: constraints.asset,
+          allowedRecipient: constraints.recipient,
+          maxAmount: constraints.maxAmount,
+          deadline: constraints.deadline,
+          bucketId: constraints.bucketId
+        };
+        return this.buildCompoundLeaf(policyConstraints);
+      }
+      /**
+       * Build period constraint
+       */
+      buildPeriodConstraint(periodCode, offsetMinutes = 0, customSeconds) {
+        return this.buildCompoundLeaf({
+          periodCode,
+          offsetMinutes,
+          customSeconds
+        });
+      }
+      /**
+       * Build vendor group constraint
+       */
+      buildVendorGroupConstraint(vendorGroupId) {
+        return this.buildCompoundLeaf({ vendorGroupId });
+      }
+      /**
+       * Build period + cap constraint (common pattern)
+       */
+      buildPeriodCapConstraint(periodCode, maxAmount, offsetMinutes = 0) {
+        return this.buildCompoundLeaf({
+          periodCode,
+          offsetMinutes,
+          maxAmount
+        });
+      }
+      /**
+       * Build vendor group + cap + period constraint (enterprise pattern)
+       */
+      buildVendorGroupCapPeriodConstraint(vendorGroupId, maxAmount, periodCode, offsetMinutes = 0) {
+        return this.buildCompoundLeaf({
+          vendorGroupId,
+          maxAmount,
+          periodCode,
+          offsetMinutes
+        });
+      }
+      /**
+       * Generate vendor group ID from string (helper)
+       */
+      static generateVendorGroupId(name) {
+        return keccak256(encodePacked(["string"], [`VENDOR_GROUP_${name}`]));
+      }
+      /**
+       * Create multi-recipient policy with Merkle tree
+       * 
+       * This creates a policy that supports multiple recipients by building a Merkle tree
+       * where each leaf represents one recipient constraint.
+       * 
+       * Supports two call patterns:
+       * 1. Same constraints for all recipients: createMultiRecipientPolicy(wallet, PolicyConstraints)
+       * 2. Different constraints per recipient: createMultiRecipientPolicy(wallet, RecipientConstraint[])
+       */
+      createMultiRecipientPolicy(walletAddress, constraintsOrRecipients) {
+        let recipients;
+        let leaves;
+        if (Array.isArray(constraintsOrRecipients)) {
+          if (constraintsOrRecipients.length === 0) {
+            throw new Error("At least one recipient must be specified for multi-recipient policy");
+          }
+          const recipientAssetSet = /* @__PURE__ */ new Set();
+          for (const item of constraintsOrRecipients) {
+            const key = `${item.recipient.toLowerCase()}-${item.asset || "none"}`;
+            if (recipientAssetSet.has(key)) {
+              throw new Error(`Duplicate recipient-asset combination: ${item.recipient} with asset ${item.asset || "none"}`);
+            }
+            recipientAssetSet.add(key);
+          }
+          recipients = constraintsOrRecipients.map((item) => item.recipient);
+          leaves = constraintsOrRecipients.map((item) => {
+            const leafConstraints = {
+              allowedRecipient: item.recipient,
+              maxAmount: item.maxAmount,
+              deadline: item.deadline,
+              allowedAsset: item.asset
+            };
+            return this.buildCompoundLeaf(leafConstraints);
+          });
+        } else {
+          const constraints = constraintsOrRecipients;
+          recipients = constraints.allowedRecipients || (constraints.allowedRecipient ? [constraints.allowedRecipient] : []);
+          if (recipients.length === 0) {
+            throw new Error("At least one recipient must be specified for multi-recipient policy");
+          }
+          leaves = recipients.map((recipient) => {
+            const leafConstraints = {
+              allowedAsset: constraints.allowedAsset,
+              allowedRecipient: recipient,
+              maxAmount: constraints.maxAmount,
+              deadline: constraints.deadline,
+              bucketId: constraints.bucketId
+            };
+            return this.buildCompoundLeaf(leafConstraints);
+          });
+        }
+        const { merkleRoot, leafProofs } = this.buildMerkleTree(leaves, recipients);
+        return {
+          policyId: keccak256(walletAddress),
+          merkleRoot,
+          leaves,
+          leafProofs,
+          policyRootVersion: 1
+        };
+      }
+      /**
+       * Build Merkle tree from compound leaves
+       * 
+       * Uses sorted pair hashing to match ConstraintLib.sol implementation
+       */
+      buildMerkleTree(leaves, recipients) {
+        if (leaves.length === 0) {
+          throw new Error("Cannot build Merkle tree with no leaves");
+        }
+        if (leaves.length === 1) {
+          const recipient = recipients?.[0] || leaves[0].recipient;
+          if (!recipient) {
+            throw new Error("Recipient must be specified for single leaf tree");
+          }
+          const asset = leaves[0].asset ? leaves[0].asset.toLowerCase() : "*";
+          const key = `${recipient.toLowerCase()}-${asset}`;
+          return {
+            merkleRoot: keccak256(leaves[0].encoded),
+            leafProofs: {
+              [key]: leaves[0].encoded
+              // No proof needed for single leaf
+            }
+          };
+        }
+        const leafHashes = leaves.map((leaf, index) => ({
+          hash: keccak256(leaf.encoded),
+          encoded: leaf.encoded,
+          originalIndex: index
+        }));
+        leafHashes.sort((a, b) => a.hash.localeCompare(b.hash));
+        const tree = [leafHashes.map((lh) => lh.hash)];
+        while (tree[tree.length - 1].length > 1) {
+          const currentLevel = tree[tree.length - 1];
+          const nextLevel = [];
+          for (let i = 0; i < currentLevel.length; i += 2) {
+            const left = currentLevel[i];
+            const right = i + 1 < currentLevel.length ? currentLevel[i + 1] : left;
+            const hash = left <= right ? keccak256(encodePacked(["bytes32", "bytes32"], [left, right])) : keccak256(encodePacked(["bytes32", "bytes32"], [right, left]));
+            nextLevel.push(hash);
+          }
+          tree.push(nextLevel);
+        }
+        const merkleRoot = tree[tree.length - 1][0];
+        const leafProofs = {};
+        for (let sortedIndex = 0; sortedIndex < leafHashes.length; sortedIndex++) {
+          const leafHash = leafHashes[sortedIndex];
+          const originalIndex = leafHash.originalIndex;
+          const proof = this.generateMerkleProof(tree, sortedIndex);
+          const leafAndProof = encodePacked(
+            ["bytes", "bytes"],
+            [leafHash.encoded, proof]
+          );
+          const recipient = recipients?.[originalIndex] || leaves[originalIndex].recipient;
+          if (!recipient) {
+            throw new Error(`Recipient must be specified for leaf ${originalIndex}`);
+          }
+          const asset = leaves[originalIndex].asset ? leaves[originalIndex].asset.toLowerCase() : "*";
+          const key = `${recipient.toLowerCase()}-${asset}`;
+          leafProofs[key] = leafAndProof;
+        }
+        return {
+          merkleRoot,
+          leafProofs,
+          tree: { root: merkleRoot, leaves: leafHashes }
+        };
+      }
+      /**
+       * Generate Merkle proof for a leaf at given index
+       */
+      generateMerkleProof(tree, leafIndex) {
+        let proof = "0x";
+        let currentIndex = leafIndex;
+        for (let level = 0; level < tree.length - 1; level++) {
+          const currentLevel = tree[level];
+          const isRightNode = currentIndex % 2 === 1;
+          let siblingIndex;
+          if (isRightNode) {
+            siblingIndex = currentIndex - 1;
+          } else {
+            siblingIndex = currentIndex + 1;
+            if (siblingIndex >= currentLevel.length) {
+              siblingIndex = currentIndex;
+            }
+          }
+          const sibling = currentLevel[siblingIndex];
+          proof = encodePacked(["bytes", "bytes32"], [proof, sibling]);
+          currentIndex = Math.floor(currentIndex / 2);
+        }
+        return proof;
+      }
+      /**
+       * Generate proof for a leaf at specific index (alternative interface)
+       */
+      generateProof(tree, leafIndex) {
+        const hashes = tree.leaves.map((l) => keccak256(l.encoded));
+        const treeStructure = [hashes];
+        while (treeStructure[treeStructure.length - 1].length > 1) {
+          const currentLevel = treeStructure[treeStructure.length - 1];
+          const nextLevel = [];
+          for (let i = 0; i < currentLevel.length; i += 2) {
+            const left = currentLevel[i];
+            const right = i + 1 < currentLevel.length ? currentLevel[i + 1] : left;
+            const hash = left <= right ? keccak256(encodePacked(["bytes32", "bytes32"], [left, right])) : keccak256(encodePacked(["bytes32", "bytes32"], [right, left]));
+            nextLevel.push(hash);
+          }
+          treeStructure.push(nextLevel);
+        }
+        const proof = [];
+        let currentIndex = leafIndex;
+        for (let level = 0; level < treeStructure.length - 1; level++) {
+          const currentLevel = treeStructure[level];
+          const isRightNode = currentIndex % 2 === 1;
+          let siblingIndex;
+          if (isRightNode) {
+            siblingIndex = currentIndex - 1;
+          } else {
+            siblingIndex = currentIndex + 1;
+            if (siblingIndex >= currentLevel.length) {
+              siblingIndex = currentIndex;
+            }
+          }
+          proof.push(currentLevel[siblingIndex]);
+          currentIndex = Math.floor(currentIndex / 2);
+        }
+        return proof;
+      }
+      /**
+       * Verify a Merkle proof
+       */
+      verifyProof(root, leafData, proof) {
+        let computedHash = keccak256(leafData);
+        for (const sibling of proof) {
+          computedHash = computedHash <= sibling ? keccak256(encodePacked(["bytes32", "bytes32"], [computedHash, sibling])) : keccak256(encodePacked(["bytes32", "bytes32"], [sibling, computedHash]));
+        }
+        return computedHash === root;
+      }
+      /**
+       * Build vendor group with period budget constraint (common pattern)
+       * 
+       * Creates a vendor group with shared period budget across authorized members.
+       * 
+       * @param vendorGroupId Vendor group identifier
+       * @param maxAmount Shared budget amount for the period
+       * @param periodCode Period type (PERIOD_DAILY, PERIOD_WEEKLY, etc.)
+       * @param offsetMinutes UTC timezone offset (default: 0)
+       * @returns Compound leaf with vendor + period constraints
+       */
+      buildVendorGroupPeriodConstraint(vendorGroupId, maxAmount, periodCode, offsetMinutes = 0) {
+        return this.buildCompoundLeaf({
+          vendorGroupId,
+          maxAmount,
+          periodCode,
+          offsetMinutes
+        });
+      }
+    };
+    CompoundLeafV3Builder = class {
+      /**
+       * Build V3 compound constraint leaf with venue controls
+       * 
+       * Format: [4B domain_v3][1B tag][1B version][2B flags][conditional_fields...]
+       */
+      buildVenueConstraintLeaf(constraints) {
+        let flags = 0;
+        const parts = [];
+        parts.push(DOMAIN_V3);
+        parts.push(encodePacked(["uint8"], [TAG_COMPOUND_V3]));
+        parts.push(encodePacked(["uint8"], [VERSION_V3]));
+        if (constraints.allowedTarget) {
+          if (!constraints.allowedTarget.match(/^0x[a-fA-F0-9]{40}$/)) {
+            throw new Error(`Invalid target address: ${constraints.allowedTarget}`);
+          }
+          flags |= FLAG_TARGET;
+        }
+        if (constraints.allowedSelectors && constraints.allowedSelectors.length > 0) {
+          if (constraints.allowedSelectors.length > 8) {
+            throw new Error("Too many selectors (max 8)");
+          }
+          for (const selector of constraints.allowedSelectors) {
+            if (!selector.match(/^0x[a-fA-F0-9]{8}$/)) {
+              throw new Error(`Invalid selector format: ${selector}`);
+            }
+          }
+          flags |= FLAG_SELECTOR_LIST;
+        }
+        if (constraints.bridgeBlocked) {
+          flags |= FLAG_NO_BRIDGE;
+        }
+        parts.push(toBigEndianUint16(flags));
+        if (flags & FLAG_TARGET) {
+          parts.push(constraints.allowedTarget);
+        }
+        if (flags & FLAG_SELECTOR_LIST) {
+          parts.push(encodePacked(["uint8"], [constraints.allowedSelectors.length]));
+          for (const selector of constraints.allowedSelectors) {
+            parts.push(selector);
+          }
+        }
+        const encoded = encodePacked(
+          parts.map(() => "bytes"),
+          parts
+        );
+        return {
+          flags,
+          venueConstraints: {
+            allowedTarget: constraints.allowedTarget,
+            allowedSelectors: constraints.allowedSelectors,
+            bridgeBlocked: constraints.bridgeBlocked
+          },
+          asset: constraints.allowedAsset,
+          recipient: constraints.allowedRecipient,
+          cap: constraints.maxAmount,
+          deadline: constraints.deadline,
+          bucketId: constraints.bucketId,
+          periodCode: constraints.periodCode,
+          offsetMinutes: constraints.offsetMinutes,
+          customSeconds: constraints.customSeconds,
+          vendorGroupId: constraints.vendorGroupId,
+          encoded
+        };
+      }
+      /**
+       * Create a simple V3 policy with venue controls
+       */
+      createVenueConstrainedPolicy(walletAddress, constraints) {
+        const leaf = this.buildVenueConstraintLeaf(constraints);
+        const merkleRoot = keccak256(leaf.encoded);
+        const leafAndProof = leaf.encoded;
+        const recipient = constraints.allowedRecipient || "0x0000000000000000000000000000000000000000";
+        const recipientKey = recipient.toLowerCase();
+        const policy = {
+          policyId: keccak256(encodePacked(["string"], [`V3_VENUE_POLICY_${Date.now()}_${Math.random()}`])),
+          merkleRoot,
+          leaves: [leaf],
+          leafProofs: {
+            [recipientKey]: leafAndProof
+          },
+          policyRootVersion: 1
+        };
+        return Object.assign(policy, {
+          getLeafAndProofForRecipient: (targetRecipient) => {
+            if (targetRecipient) {
+              const key = targetRecipient.toLowerCase();
+              return policy.leafProofs[key] || leafAndProof;
+            }
+            return leafAndProof;
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/constraints/agentConstraintBuilder.ts
+import { keccak256 as keccak2562, parseEther } from "viem";
+
+// src/policy/types.ts
+var V2_FLAG_RECIPIENT = 1;
+var V2_FLAG_CAP = 2;
+var V2_FLAG_DEADLINE = 4;
+var V2_FLAG_ASSET = 8;
+var V2_FLAG_BUCKET = 16;
+var V2_FLAG_PERIOD = 32;
+var V2_FLAG_VENDOR_GROUP = 64;
+var PERIOD_NONE = 0;
+var PERIOD_DAILY = 1;
+var PERIOD_WEEKLY = 2;
+var PERIOD_MONTH30 = 3;
+var PERIOD_CUSTOM = 4;
+var GLOBAL_FLAG_NO_BRIDGE = 1n << 0n;
+var GLOBAL_FLAG_POST_CONDITIONS = 1n << 1n;
+var GLOBAL_FLAG_FX_SAFETY = 1n << 2n;
+var GLOBAL_FLAG_SOLVER_ENVELOPE = 1n << 3n;
+
+// src/policy/v2LeafBuilder.ts
+var DOMAIN_PREFIX = "0x1a13d438";
+var TAG_COMPOUND_EMPLOYEE = 16;
+var VERSION = 1;
+function toBigEndianHex(value, byteLength) {
+  const hex = BigInt(value).toString(16).padStart(byteLength * 2, "0");
+  if (hex.length > byteLength * 2) {
+    throw new Error(`Value ${value} exceeds ${byteLength} bytes`);
+  }
+  return hex;
+}
+function validateAddress(address, fieldName) {
+  if (!address.startsWith("0x") || address.length !== 42) {
+    throw new Error(`${fieldName} must be a valid 20-byte address, got: ${address}`);
+  }
+}
+function validateBytes32(value, fieldName) {
+  if (!value.startsWith("0x") || value.length !== 66) {
+    throw new Error(`${fieldName} must be a valid 32-byte hex, got length ${value.length}`);
+  }
+}
+function buildV2CompoundLeaf(params) {
+  const chunks = [];
+  chunks.push(DOMAIN_PREFIX.slice(2));
+  chunks.push(TAG_COMPOUND_EMPLOYEE.toString(16).padStart(2, "0"));
+  chunks.push(VERSION.toString(16).padStart(2, "0"));
+  if (params.flags < 0 || params.flags > 255) {
+    throw new Error(`Flags must be 0-255, got: ${params.flags}`);
+  }
+  chunks.push(params.flags.toString(16).padStart(2, "0"));
+  if (params.flags & V2_FLAG_ASSET) {
+    if (!params.asset) {
+      throw new Error("asset is required when FLAG_ASSET is set");
+    }
+    validateAddress(params.asset, "asset");
+    chunks.push(params.asset.slice(2).toLowerCase());
+  }
+  if (params.flags & V2_FLAG_RECIPIENT) {
+    if (!params.allowedRecipient) {
+      throw new Error("allowedRecipient is required when FLAG_RECIPIENT is set");
+    }
+    validateAddress(params.allowedRecipient, "allowedRecipient");
+    chunks.push(params.allowedRecipient.slice(2).toLowerCase());
+  }
+  if (params.flags & V2_FLAG_CAP) {
+    if (params.cap === void 0) {
+      throw new Error("cap is required when FLAG_CAP is set");
+    }
+    const maxUint128 = (1n << 128n) - 1n;
+    if (params.cap < 0n || params.cap > maxUint128) {
+      throw new Error(`cap must be 0 to ${maxUint128}, got: ${params.cap}`);
+    }
+    chunks.push(toBigEndianHex(params.cap, 16));
+  }
+  if (params.flags & V2_FLAG_DEADLINE) {
+    if (params.deadline === void 0) {
+      throw new Error("deadline is required when FLAG_DEADLINE is set");
+    }
+    const maxUint48 = (1n << 48n) - 1n;
+    if (BigInt(params.deadline) < 0n || BigInt(params.deadline) > maxUint48) {
+      throw new Error(`deadline must be 0 to ${maxUint48}, got: ${params.deadline}`);
+    }
+    chunks.push(toBigEndianHex(params.deadline, 6));
+  }
+  if (params.flags & V2_FLAG_BUCKET) {
+    if (!params.bucketId) {
+      throw new Error("bucketId is required when FLAG_BUCKET is set");
+    }
+    validateBytes32(params.bucketId, "bucketId");
+    chunks.push(params.bucketId.slice(2).toLowerCase());
+  }
+  if (params.flags & V2_FLAG_PERIOD) {
+    if (params.periodCode === void 0) {
+      throw new Error("periodCode is required when FLAG_PERIOD is set");
+    }
+    if (params.periodCode < 0 || params.periodCode > 255) {
+      throw new Error(`periodCode must be 0-255, got: ${params.periodCode}`);
+    }
+    chunks.push(params.periodCode.toString(16).padStart(2, "0"));
+    const offsetMinutes = params.offsetMinutes ?? 0;
+    if (offsetMinutes < -32768 || offsetMinutes > 32767) {
+      throw new Error(`offsetMinutes must be -32768 to 32767, got: ${offsetMinutes}`);
+    }
+    const unsignedOffset = offsetMinutes < 0 ? 65536 + offsetMinutes : offsetMinutes;
+    chunks.push(unsignedOffset.toString(16).padStart(4, "0"));
+    if (params.periodCode === PERIOD_CUSTOM) {
+      if (params.customSeconds === void 0) {
+        throw new Error("customSeconds is required when periodCode is PERIOD_CUSTOM");
+      }
+      const maxUint32 = 4294967295;
+      if (params.customSeconds < 0 || params.customSeconds > maxUint32) {
+        throw new Error(`customSeconds must be 0 to ${maxUint32}, got: ${params.customSeconds}`);
+      }
+      chunks.push(params.customSeconds.toString(16).padStart(8, "0"));
+    }
+  }
+  if (params.flags & V2_FLAG_VENDOR_GROUP) {
+    if (!params.vendorGroupId) {
+      throw new Error("vendorGroupId is required when FLAG_VENDOR_GROUP is set");
+    }
+    validateBytes32(params.vendorGroupId, "vendorGroupId");
+    chunks.push(params.vendorGroupId.slice(2).toLowerCase());
+  }
+  return `0x${chunks.join("")}`;
+}
+function v2ConstraintsToLeafParams(params) {
+  let flags = 0;
+  if (params.allowedRecipient) {
+    flags |= V2_FLAG_RECIPIENT;
+  }
+  if (params.cap !== void 0) {
+    flags |= V2_FLAG_CAP;
+  }
+  if (params.deadline !== void 0) {
+    flags |= V2_FLAG_DEADLINE;
+  }
+  if (params.asset) {
+    flags |= V2_FLAG_ASSET;
+  }
+  if (params.periodType && params.periodType !== "none") {
+    flags |= V2_FLAG_PERIOD;
+  }
+  if (params.vendorGroupId) {
+    flags |= V2_FLAG_VENDOR_GROUP;
+  }
+  let periodCode;
+  if (params.periodType) {
+    switch (params.periodType) {
+      case "none":
+        periodCode = 0;
+        break;
+      case "daily":
+        periodCode = 1;
+        break;
+      case "weekly":
+        periodCode = 2;
+        break;
+      case "monthly":
+        periodCode = 3;
+        break;
+      case "custom":
+        periodCode = 4;
+        break;
+    }
+  }
+  return {
+    flags,
+    allowedRecipient: params.allowedRecipient,
+    cap: params.cap,
+    deadline: params.deadline,
+    asset: params.asset,
+    periodCode,
+    offsetMinutes: params.utcOffsetMinutes,
+    customSeconds: params.customPeriodSeconds,
+    vendorGroupId: params.vendorGroupId
+  };
+}
+function buildV2LeafFromConstraints(params) {
+  const leafParams = v2ConstraintsToLeafParams(params);
+  return buildV2CompoundLeaf(leafParams);
+}
+
+// src/constraints/agentConstraintBuilder.ts
+init_constraints();
+function buildV2ConstraintsFromAgent(constraints) {
+  if (constraints.allowedRecipients && constraints.allowedRecipients.length > 1) {
+    return buildMultiRecipientV2Constraints(constraints);
+  }
+  const v2Params = {};
+  if (constraints.allowedRecipients && constraints.allowedRecipients.length === 1) {
+    v2Params.allowedRecipient = constraints.allowedRecipients[0];
+  }
+  if (constraints.maxDailyUsd) {
+    v2Params.cap = parseEther(String(constraints.maxDailyUsd));
+    v2Params.periodType = "daily";
+  } else if (constraints.maxPerTxUsd) {
+    v2Params.cap = parseEther(String(constraints.maxPerTxUsd));
+  }
+  if (constraints.deadline) {
+    v2Params.deadline = constraints.deadline;
+  }
+  if (constraints.allowedAssets && constraints.allowedAssets.length > 0) {
+    v2Params.asset = constraints.allowedAssets[0];
+  }
+  if (constraints.vendorGroupId !== void 0) {
+    v2Params.vendorGroupId = bigintToBytes32(constraints.vendorGroupId);
+  }
+  const leaf = buildV2LeafFromConstraints(v2Params);
+  const root = keccak2562(leaf);
+  let recipientLeaves;
+  if (constraints.allowedRecipients && constraints.allowedRecipients.length === 1) {
+    const recipient = constraints.allowedRecipients[0].toLowerCase();
+    const asset = constraints.allowedAssets?.[0] ? constraints.allowedAssets[0].toLowerCase() : "*";
+    const key = `${recipient}-${asset}`;
+    recipientLeaves = { [key]: leaf };
+  }
+  return { leaf, root, recipientLeaves };
+}
+function buildMultiRecipientV2Constraints(constraints) {
+  const recipients = constraints.allowedRecipients;
+  const builder = new CompoundLeafBuilder();
+  const cap = constraints.maxDailyUsd ? parseEther(String(constraints.maxDailyUsd)) : constraints.maxPerTxUsd ? parseEther(String(constraints.maxPerTxUsd)) : void 0;
+  const dummyWallet = "0x0000000000000000000000000000000000000001";
+  const assets = constraints.allowedAssets;
+  const hasMultipleAssets = assets && assets.length > 1;
+  let multiPolicy;
+  if (hasMultipleAssets) {
+    const recipientAssetCombinations = [];
+    for (const recipient of recipients) {
+      for (const asset of assets) {
+        recipientAssetCombinations.push({
+          recipient,
+          asset,
+          maxAmount: cap,
+          deadline: constraints.deadline
+        });
+      }
+    }
+    multiPolicy = builder.createMultiRecipientPolicy(dummyWallet, recipientAssetCombinations);
+  } else {
+    const asset = assets?.[0];
+    multiPolicy = builder.createMultiRecipientPolicy(dummyWallet, {
+      allowedRecipients: recipients,
+      allowedAsset: asset,
+      maxAmount: cap,
+      deadline: constraints.deadline,
+      periodCode: constraints.maxDailyUsd ? PERIOD_DAILY2 : void 0
+    });
+  }
+  const defaultAsset = assets?.[0] ? assets[0].toLowerCase() : "*";
+  const defaultKey = `${recipients[0].toLowerCase()}-${defaultAsset}`;
+  const defaultLeafAndProof = multiPolicy.leafProofs[defaultKey];
+  if (!defaultLeafAndProof) {
+    throw new Error(`Failed to get default leaf+proof for multi-recipient policy`);
+  }
+  return {
+    leaf: defaultLeafAndProof,
+    // This is actually leafAndProof (leaf + merkle proof)
+    root: multiPolicy.merkleRoot,
+    recipientLeaves: multiPolicy.leafProofs
+    // Map of recipient-asset -> leafAndProof
+  };
+}
+function constraintsToV2Params(constraints, recipient) {
+  const params = {};
+  if (recipient) {
+    params.allowedRecipient = recipient;
+  } else if (constraints.allowedRecipients && constraints.allowedRecipients.length === 1) {
+    params.allowedRecipient = constraints.allowedRecipients[0];
+  }
+  if (constraints.maxDailyUsd) {
+    params.cap = parseEther(String(constraints.maxDailyUsd));
+    params.periodType = "daily";
+  } else if (constraints.maxPerTxUsd) {
+    params.cap = parseEther(String(constraints.maxPerTxUsd));
+  }
+  if (constraints.deadline) {
+    params.deadline = constraints.deadline;
+  }
+  if (constraints.allowedAssets && constraints.allowedAssets.length > 0) {
+    params.asset = constraints.allowedAssets[0];
+  }
+  if (constraints.vendorGroupId !== void 0) {
+    params.vendorGroupId = bigintToBytes32(constraints.vendorGroupId);
+  }
+  return params;
+}
+function bigintToBytes32(value) {
+  return `0x${value.toString(16).padStart(64, "0")}`;
+}
+
+export {
+  FLAG_RECIPIENT,
+  FLAG_CAP,
+  FLAG_DEADLINE,
+  FLAG_ASSET,
+  FLAG_BUCKET,
+  FLAG_PERIOD,
+  FLAG_VENDOR_GROUP,
+  DOMAIN_V3,
+  VERSION_V3,
+  TAG_COMPOUND_V3,
+  FLAG_TARGET,
+  FLAG_SELECTOR_LIST,
+  FLAG_NO_BRIDGE,
+  FLAG_OPS_HASH,
+  PERIOD_NONE2 as PERIOD_NONE,
+  PERIOD_DAILY2 as PERIOD_DAILY,
+  PERIOD_WEEKLY2 as PERIOD_WEEKLY,
+  PERIOD_MONTH302 as PERIOD_MONTH30,
+  PERIOD_CUSTOM2 as PERIOD_CUSTOM,
+  CompoundLeafBuilder,
+  createConstraintBuilder,
+  getLeafAndProofForRecipient,
+  isRecipientAllowed,
+  buildConstraintCalldata,
+  buildConstraintCalldataFromIntent,
+  extractConstraintDataFromOperations,
+  CompoundLeafV3Builder,
+  init_constraints,
+  V2_FLAG_RECIPIENT,
+  V2_FLAG_CAP,
+  V2_FLAG_DEADLINE,
+  V2_FLAG_ASSET,
+  V2_FLAG_BUCKET,
+  V2_FLAG_PERIOD,
+  V2_FLAG_VENDOR_GROUP,
+  PERIOD_NONE as PERIOD_NONE2,
+  PERIOD_DAILY as PERIOD_DAILY2,
+  PERIOD_WEEKLY as PERIOD_WEEKLY2,
+  PERIOD_MONTH30 as PERIOD_MONTH302,
+  PERIOD_CUSTOM as PERIOD_CUSTOM2,
+  GLOBAL_FLAG_NO_BRIDGE,
+  GLOBAL_FLAG_POST_CONDITIONS,
+  GLOBAL_FLAG_FX_SAFETY,
+  GLOBAL_FLAG_SOLVER_ENVELOPE,
+  DOMAIN_PREFIX,
+  TAG_COMPOUND_EMPLOYEE,
+  VERSION,
+  buildV2CompoundLeaf,
+  v2ConstraintsToLeafParams,
+  buildV2LeafFromConstraints,
+  buildV2ConstraintsFromAgent,
+  constraintsToV2Params
+};