@tokenops/sdk 1.6.0 → 2.0.0-alpha.2

package/dist/chunk-IUKKNJ2R.cjs

@@ -0,0 +1,433 @@
+'use strict';
+
+var chunkPZZK3O3S_cjs = require('./chunk-PZZK3O3S.cjs');
+var chunkAREQJHKA_cjs = require('./chunk-AREQJHKA.cjs');
+var chunkJK4XMMKM_cjs = require('./chunk-JK4XMMKM.cjs');
+var chunk67OV5CX2_cjs = require('./chunk-67OV5CX2.cjs');
+var merkleTree = require('@openzeppelin/merkle-tree');
+var viem = require('viem');
+
+function leafOf(args) {
+  const inner = viem.keccak256(
+    viem.encodeAbiParameters(
+      [{ type: "address" }, { type: "address" }, { type: "bytes32" }],
+      [args.instance, args.account, args.handle]
+    )
+  );
+  return viem.keccak256(inner);
+}
+var HANDLE_PATTERN = /^0x[0-9a-fA-F]{64}$/;
+function assertLeaves(instance, leaves, method) {
+  if (!viem.isAddress(instance, { strict: false })) {
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+      method,
+      argument: "instance",
+      reason: "is not a 20-byte hex address",
+      value: instance
+    });
+  }
+  if (viem.isAddressEqual(instance, viem.zeroAddress)) {
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+      method,
+      argument: "instance",
+      reason: "is the zero address; leaves must be scoped to the airdrop instance"
+    });
+  }
+  if (leaves.length === 0) {
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+      method,
+      argument: "leaves",
+      reason: "a tree needs at least one leaf"
+    });
+  }
+  const seen = /* @__PURE__ */ new Map();
+  leaves.forEach((leaf, index) => {
+    if (!viem.isAddress(leaf.account, { strict: false })) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method,
+        argument: `leaves[${index}].account`,
+        reason: "is not a 20-byte hex address",
+        value: leaf.account
+      });
+    }
+    if (viem.isAddressEqual(leaf.account, viem.zeroAddress)) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method,
+        argument: `leaves[${index}].account`,
+        reason: "is the zero address; the contract rejects it with ZeroAccount"
+      });
+    }
+    if (!HANDLE_PATTERN.test(leaf.handle)) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method,
+        argument: `leaves[${index}].handle`,
+        reason: "is not a 32-byte hex handle; the tree would commit to a value no claim can reproduce",
+        value: leaf.handle
+      });
+    }
+    const key = leaf.account.toLowerCase();
+    const first = seen.get(key);
+    if (first !== void 0) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method,
+        argument: `leaves[${index}].account`,
+        reason: `appears twice (also at index ${first}); one root pays max, not sum, of an account's leaves \u2014 merge them into a single cumulative total`
+      });
+    }
+    seen.set(key, index);
+  });
+}
+function buildMerkleTree(args) {
+  return buildMerkleTreeInternal(args, "buildMerkleTree");
+}
+function buildMerkleTreeInternal({ instance, leaves }, method) {
+  assertLeaves(instance, leaves, method);
+  const airdrop = chunkJK4XMMKM_cjs.normaliseAddress(instance);
+  const accounts = leaves.map((leaf) => chunkJK4XMMKM_cjs.normaliseAddress(leaf.account));
+  const rows = accounts.map((account, i) => [airdrop, account, leaves[i].handle]);
+  const tree = merkleTree.StandardMerkleTree.of(rows, ["address", "address", "bytes32"]);
+  return {
+    root: tree.root,
+    // `getProof(i)` indexes the INPUT array, not the tree: `StandardMerkleTree` sorts
+    // leaves internally but keeps `values` in insertion order, so entry `i` always belongs
+    // to `leaves[i]`.
+    entries: leaves.map((leaf, i) => ({
+      ...leaf,
+      account: accounts[i],
+      merkleProof: tree.getProof(i)
+    }))
+  };
+}
+var MAX_UINT64 = (1n << 64n) - 1n;
+var MERKLE_BATCH_LIMIT = 2048 / 64;
+function validateCampaignRecipients(recipients) {
+  validateCampaignRecipientsInternal(recipients, "validateCampaignRecipients");
+}
+function validateCampaignRecipientsInternal(recipients, method) {
+  if (recipients.length === 0) {
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+      method,
+      argument: "recipients",
+      reason: "a campaign needs at least one recipient"
+    });
+  }
+  const seen = /* @__PURE__ */ new Map();
+  recipients.forEach((entry, index) => {
+    if (!viem.isAddress(entry.recipient, { strict: false })) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method,
+        argument: `recipients[${index}].recipient`,
+        reason: "is not a 20-byte hex address",
+        value: entry.recipient
+      });
+    }
+    if (viem.isAddressEqual(entry.recipient, viem.zeroAddress)) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method,
+        argument: `recipients[${index}].recipient`,
+        reason: "is the zero address, whose leaf can never be claimed"
+      });
+    }
+    if (entry.cumulativeTotal < 0n || entry.cumulativeTotal > MAX_UINT64) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method,
+        argument: `recipients[${index}].cumulativeTotal`,
+        // Deliberately no `value`: the total is confidential.
+        reason: "is outside uint64 range (0..2^64-1)"
+      });
+    }
+    const key = entry.recipient.toLowerCase();
+    const first = seen.get(key);
+    if (first !== void 0) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method,
+        argument: `recipients[${index}].recipient`,
+        reason: `appears twice (also at index ${first}); one root pays max, not sum, of a recipient's leaves \u2014 merge them into a single cumulative total`
+      });
+    }
+    seen.set(key, index);
+  });
+}
+async function encryptRoster({ instance, recipients, encryptor, submitter }, method) {
+  validateCampaignRecipientsInternal(recipients, method);
+  if (!viem.isAddress(instance, { strict: false })) {
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+      method,
+      argument: "instance",
+      reason: "is not a 20-byte hex address",
+      value: instance
+    });
+  }
+  if (viem.isAddressEqual(instance, viem.zeroAddress)) {
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+      method,
+      argument: "instance",
+      reason: "is the zero address; inputs must be bound to the airdrop instance"
+    });
+  }
+  const enc = chunkPZZK3O3S_cjs.resolveEncryptor(encryptor);
+  if (!enc) {
+    throw new chunk67OV5CX2_cjs.MissingEncryptorError(method, {
+      hint: "Pass an encryptor instance, or a lazy factory that returns one."
+    });
+  }
+  if (submitter !== void 0) {
+    if (!viem.isAddress(submitter, { strict: false })) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method,
+        argument: "submitter",
+        reason: "is not a 20-byte hex address",
+        value: submitter
+      });
+    }
+    if (viem.isAddressEqual(submitter, viem.zeroAddress)) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method,
+        argument: "submitter",
+        reason: "is the zero address; no proof can be bound to it, so no leaf would be claimable"
+      });
+    }
+  }
+  const airdrop = chunkJK4XMMKM_cjs.normaliseAddress(instance);
+  const accounts = recipients.map((r) => chunkJK4XMMKM_cjs.normaliseAddress(r.recipient));
+  if (submitter !== void 0) {
+    const boundTo = chunkJK4XMMKM_cjs.normaliseAddress(submitter);
+    const chunks = [];
+    for (let i = 0; i < recipients.length; i += MERKLE_BATCH_LIMIT) {
+      chunks.push(recipients.slice(i, i + MERKLE_BATCH_LIMIT));
+    }
+    const encryptedChunks = await Promise.all(
+      chunks.map(
+        (chunk) => chunkPZZK3O3S_cjs.encryptUint64Batch({
+          encryptor: enc,
+          contractAddress: airdrop,
+          userAddress: boundTo,
+          values: chunk.map((r) => r.cumulativeTotal)
+        })
+      )
+    );
+    return accounts.map((account, i) => {
+      const chunk = encryptedChunks[Math.floor(i / MERKLE_BATCH_LIMIT)];
+      return {
+        account,
+        boundTo,
+        handle: chunk.handles[i % MERKLE_BATCH_LIMIT],
+        inputProof: chunk.inputProof
+      };
+    });
+  }
+  const encrypted = await Promise.all(
+    recipients.map(
+      (r, i) => chunkPZZK3O3S_cjs.encryptUint64({
+        encryptor: enc,
+        contractAddress: airdrop,
+        userAddress: accounts[i],
+        value: r.cumulativeTotal
+      })
+    )
+  );
+  return accounts.map((account, i) => ({
+    account,
+    boundTo: account,
+    handle: encrypted[i].handle,
+    inputProof: encrypted[i].inputProof
+  }));
+}
+async function encryptCampaignAmounts(args) {
+  return encryptRoster(args, "encryptCampaignAmounts");
+}
+async function buildMerkleCampaign({
+  instance,
+  recipients,
+  encryptor,
+  submitter
+}) {
+  const leaves = await encryptRoster(
+    { instance, recipients, encryptor, submitter },
+    "buildMerkleCampaign"
+  );
+  return buildMerkleTreeInternal({ instance, leaves }, "buildMerkleCampaign");
+}
+async function planMerkleCampaign({
+  factory,
+  params,
+  mode,
+  creator,
+  userSalt,
+  recipients,
+  encryptor,
+  submitter
+}) {
+  validateCampaignRecipientsInternal(recipients, "planMerkleCampaign");
+  const initCodeHashBefore = await factory.getMerkleInitCodeHash({ params, mode });
+  const predictedAddress = await factory.predictMerkleAirdropAddress({
+    params,
+    mode,
+    deployer: creator,
+    userSalt
+  });
+  const campaign = await buildMerkleCampaign({
+    instance: predictedAddress,
+    recipients,
+    encryptor,
+    submitter
+  });
+  const initCodeHashAfter = await factory.getMerkleInitCodeHash({ params, mode });
+  chunkAREQJHKA_cjs.assertPredictionFresh({
+    variant: "merkle",
+    initCodeHashBefore,
+    initCodeHashAfter,
+    predictedAddress,
+    method: "planMerkleCampaign"
+  });
+  return { ...campaign, predictedAddress, initCodeHashBefore, initCodeHashAfter };
+}
+async function rotateMerkleRoot({
+  airdrop,
+  recipients,
+  encryptor,
+  submitter,
+  account
+}) {
+  const campaign = await buildMerkleCampaign({
+    instance: airdrop.address,
+    recipients,
+    encryptor,
+    submitter
+  });
+  const hash = await airdrop.setMerkleRoot({ newRoot: campaign.root, account });
+  return { ...campaign, hash };
+}
+var ASSIGNABLE_ROLES = [
+  { key: "pauser", role: "PAUSER_ROLE" },
+  { key: "windowAdmin", role: "WINDOW_ADMIN_ROLE" },
+  { key: "treasury", role: "TREASURY_ROLE" },
+  { key: "rescuer", role: "RESCUER_ROLE" },
+  { key: "disclosureAdmin", role: "DISCLOSURE_ADMIN_ROLE" },
+  { key: "upgrader", role: "UPGRADER_ROLE" },
+  { key: "merkleAdmin", role: "MERKLE_ADMIN_ROLE", variant: "merkle" },
+  { key: "signer", role: "SIGNER_ROLE", variant: "ecdsa" }
+];
+function planInstanceRoleSplit(args) {
+  const { assignment, caller, airdropType } = args;
+  if (assignment.feeCollector !== void 0) {
+    throw new chunkAREQJHKA_cjs.FeeCollectorSelfAdministeredError({ requestedGrantee: assignment.feeCollector });
+  }
+  const steps = [];
+  for (const { key, role, variant } of ASSIGNABLE_ROLES) {
+    const account = assignment[key];
+    if (account === void 0) continue;
+    if (variant !== void 0 && variant !== airdropType) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method: "planInstanceRoleSplit",
+        argument: `assignment.${key}`,
+        reason: `${role} only exists on ${variant} campaigns; this is a(n) ${airdropType} campaign`
+      });
+    }
+    steps.push({ kind: "grant", role, account });
+  }
+  if (assignment.admin !== void 0) {
+    if (viem.isAddressEqual(assignment.admin, viem.zeroAddress)) {
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+        method: "planInstanceRoleSplit",
+        argument: "assignment.admin",
+        reason: "granting DEFAULT_ADMIN_ROLE to the zero address is never valid"
+      });
+    }
+    steps.push({ kind: "grant", role: "DEFAULT_ADMIN_ROLE", account: assignment.admin });
+    steps.push({ kind: "revoke", role: "DEFAULT_ADMIN_ROLE", account: caller });
+  }
+  return steps;
+}
+function roleGetterAbiEntry(name) {
+  return {
+    inputs: [],
+    name,
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  };
+}
+var ROLE_GETTER_ABI = [
+  roleGetterAbiEntry("PAUSER_ROLE"),
+  roleGetterAbiEntry("WINDOW_ADMIN_ROLE"),
+  roleGetterAbiEntry("TREASURY_ROLE"),
+  roleGetterAbiEntry("RESCUER_ROLE"),
+  roleGetterAbiEntry("DISCLOSURE_ADMIN_ROLE"),
+  roleGetterAbiEntry("UPGRADER_ROLE"),
+  roleGetterAbiEntry("MERKLE_ADMIN_ROLE"),
+  roleGetterAbiEntry("SIGNER_ROLE")
+];
+var DEFAULT_ADMIN_ROLE_CONSTANT = `0x${"0".repeat(64)}`;
+async function resolveRoleConstant(airdrop, role) {
+  if (role === "DEFAULT_ADMIN_ROLE") return DEFAULT_ADMIN_ROLE_CONSTANT;
+  const result = await airdrop.publicClient.readContract({
+    address: airdrop.address,
+    abi: ROLE_GETTER_ABI,
+    functionName: role
+  });
+  return result;
+}
+function toOutcomeError(step, airdrop, error) {
+  if (chunk67OV5CX2_cjs.isTokenOpsSdkError(error)) return error;
+  return new chunk67OV5CX2_cjs.UnknownWriteFailureError({
+    method: `grantInstanceRoles.${step.kind}.${step.role}`,
+    contractAddress: airdrop.address,
+    cause: error
+  });
+}
+async function grantInstanceRoles(args) {
+  const { airdrop, assignment, revokeFromCreator = true } = args;
+  const wallet = airdrop.walletClient;
+  if (!wallet) {
+    throw new chunk67OV5CX2_cjs.MissingWalletClientError("grantInstanceRoles");
+  }
+  const callerAccount = wallet.account;
+  if (!callerAccount) {
+    throw new chunk67OV5CX2_cjs.MissingAccountError("grantInstanceRoles");
+  }
+  const caller = typeof callerAccount === "string" ? callerAccount : callerAccount.address;
+  const airdropType = await airdrop.airdropType() === 1 ? "merkle" : "ecdsa";
+  let steps = planInstanceRoleSplit({ assignment, caller, airdropType });
+  if (!revokeFromCreator) {
+    steps = steps.filter((step) => !(step.kind === "revoke" && step.role === "DEFAULT_ADMIN_ROLE"));
+  }
+  const outcomes = [];
+  for (const step of steps) {
+    try {
+      const role = await resolveRoleConstant(airdrop, step.role);
+      const hash = step.kind === "grant" ? await airdrop.grantRole({ role, holder: step.account, account: caller }) : await airdrop.revokeRole({ role, holder: step.account, account: caller });
+      const receipt = await airdrop.publicClient.waitForTransactionReceipt({ hash });
+      if (receipt.status !== "success") {
+        outcomes.push({
+          role: step.role,
+          account: step.account,
+          error: new chunk67OV5CX2_cjs.ContractRevertError({
+            method: `grantInstanceRoles.${step.kind}.${step.role}`,
+            contractAddress: airdrop.address,
+            message: `grantInstanceRoles.${step.kind}.${step.role}: transaction ${hash} was mined with a reverted status; the role change did not apply.`
+          })
+        });
+        continue;
+      }
+      outcomes.push({ role: step.role, account: step.account, hash });
+    } catch (error) {
+      outcomes.push({
+        role: step.role,
+        account: step.account,
+        error: toOutcomeError(step, airdrop, error)
+      });
+    }
+  }
+  return outcomes;
+}
+
+exports.buildMerkleCampaign = buildMerkleCampaign;
+exports.buildMerkleTree = buildMerkleTree;
+exports.encryptCampaignAmounts = encryptCampaignAmounts;
+exports.grantInstanceRoles = grantInstanceRoles;
+exports.leafOf = leafOf;
+exports.planInstanceRoleSplit = planInstanceRoleSplit;
+exports.planMerkleCampaign = planMerkleCampaign;
+exports.rotateMerkleRoot = rotateMerkleRoot;
+exports.validateCampaignRecipients = validateCampaignRecipients;

package/dist/{chunk-VR3FREBX.cjs → chunk-JK4XMMKM.cjs}

@@ -1,17 +1,17 @@
 'use strict';
 
-var chunk2RNW4MIJ_cjs = require('./chunk-2RNW4MIJ.cjs');
+var chunk67OV5CX2_cjs = require('./chunk-67OV5CX2.cjs');
 var viem = require('viem');
 
 function normaliseAddress(input) {
   if (typeof input !== "string") {
-    throw new chunk2RNW4MIJ_cjs.TokenOpsValidationError("normaliseAddress: input is not a string", {
+    throw new chunk67OV5CX2_cjs.TokenOpsValidationError("normaliseAddress: input is not a string", {
       method: "normaliseAddress",
       args: { input: typeof input }
     });
   }
   if (!viem.isAddress(input, { strict: false })) {
-    throw new chunk2RNW4MIJ_cjs.TokenOpsValidationError(
+    throw new chunk67OV5CX2_cjs.TokenOpsValidationError(
       `normaliseAddress: '${input}' is not a valid 0x-prefixed 20-byte hex address`,
       {
         method: "normaliseAddress",

package/dist/{chunk-4ZCXK4VI.cjs → chunk-KFRDLKMA.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
 var chunkFWHYQZ5E_cjs = require('./chunk-FWHYQZ5E.cjs');
-var chunkVR3FREBX_cjs = require('./chunk-VR3FREBX.cjs');
-var chunk2RNW4MIJ_cjs = require('./chunk-2RNW4MIJ.cjs');
+var chunkJK4XMMKM_cjs = require('./chunk-JK4XMMKM.cjs');
+var chunk67OV5CX2_cjs = require('./chunk-67OV5CX2.cjs');
 var chunkVJKZWYYJ_cjs = require('./chunk-VJKZWYYJ.cjs');
 
 // src/fhe/operators.ts
@@ -21,19 +21,19 @@ var ERC7984_SET_OPERATOR_ABI = [
 var ERC7984_OPERATOR_MAX_DEADLINE = (1n << 48n) - 1n;
 async function setOperator(args) {
   const { publicClient, walletClient, account, waitForReceipt = true, telemetry } = args;
-  const token = chunkVR3FREBX_cjs.normaliseAddress(args.token);
-  const spender = chunkVR3FREBX_cjs.normaliseAddress(args.spender);
+  const token = chunkJK4XMMKM_cjs.normaliseAddress(args.token);
+  const spender = chunkJK4XMMKM_cjs.normaliseAddress(args.spender);
   const deadline = args.deadline ?? ERC7984_OPERATOR_MAX_DEADLINE;
   return chunkVJKZWYYJ_cjs.withTelemetry(telemetry, "fhe.setOperator", async () => {
     const fromAccount = account ?? walletClient.account;
     if (!fromAccount) {
-      throw new chunk2RNW4MIJ_cjs.TokenOpsContractError(
+      throw new chunk67OV5CX2_cjs.TokenOpsContractError(
         "setOperator: no account available \u2014 pass `account` explicitly or attach an account to the walletClient",
         { contract: "ERC7984", call: "setOperator" }
       );
     }
     if (deadline < 0n || deadline > ERC7984_OPERATOR_MAX_DEADLINE) {
-      throw new chunk2RNW4MIJ_cjs.TokenOpsContractError(
+      throw new chunk67OV5CX2_cjs.TokenOpsContractError(
         `setOperator: deadline ${deadline} out of uint48 range [0, ${ERC7984_OPERATOR_MAX_DEADLINE}]`,
         { contract: "ERC7984", call: "setOperator", deadline: deadline.toString() }
       );
@@ -54,7 +54,7 @@ async function setOperator(args) {
         chain: walletClient.chain
       });
     } catch (err) {
-      throw new chunk2RNW4MIJ_cjs.TokenOpsContractError(
+      throw new chunk67OV5CX2_cjs.TokenOpsContractError(
         `setOperator: writeContract failed (token=${token}, spender=${spender})`,
         {
           contract: "ERC7984",
@@ -69,7 +69,7 @@ async function setOperator(args) {
       try {
         await publicClient.waitForTransactionReceipt({ hash });
       } catch (err) {
-        throw new chunk2RNW4MIJ_cjs.TokenOpsContractError(`setOperator: receipt wait failed (tx=${hash})`, {
+        throw new chunk67OV5CX2_cjs.TokenOpsContractError(`setOperator: receipt wait failed (tx=${hash})`, {
           contract: "ERC7984",
           call: "setOperator",
           tx: hash,
@@ -96,9 +96,9 @@ async function revokeOperator(args) {
   });
 }
 async function isOperator(args) {
-  const token = chunkVR3FREBX_cjs.normaliseAddress(args.token);
-  const holder = chunkVR3FREBX_cjs.normaliseAddress(args.holder);
-  const spender = chunkVR3FREBX_cjs.normaliseAddress(args.spender);
+  const token = chunkJK4XMMKM_cjs.normaliseAddress(args.token);
+  const holder = chunkJK4XMMKM_cjs.normaliseAddress(args.holder);
+  const spender = chunkJK4XMMKM_cjs.normaliseAddress(args.spender);
   return chunkVJKZWYYJ_cjs.withTelemetry(args.telemetry, "fhe.isOperator", async () => {
     try {
       return await args.publicClient.readContract({
@@ -108,7 +108,7 @@ async function isOperator(args) {
         args: [holder, spender]
       });
     } catch (err) {
-      throw new chunk2RNW4MIJ_cjs.TokenOpsContractError(
+      throw new chunk67OV5CX2_cjs.TokenOpsContractError(
         `isOperator: readContract failed (token=${token}, holder=${holder}, spender=${spender})`,
         { contract: "ERC7984", call: "isOperator", token, holder, spender, cause: err }
       );
@@ -118,14 +118,14 @@ async function isOperator(args) {
 async function ensureOperator(args) {
   return chunkVJKZWYYJ_cjs.withTelemetry(args.telemetry, "fhe.ensureOperator", async () => {
     if (args.deadline <= 0n || args.deadline > ERC7984_OPERATOR_MAX_DEADLINE) {
-      throw new chunk2RNW4MIJ_cjs.TokenOpsContractError(
+      throw new chunk67OV5CX2_cjs.TokenOpsContractError(
         `ensureOperator: deadline ${args.deadline} out of range (0, ${ERC7984_OPERATOR_MAX_DEADLINE}]`,
         { contract: "ERC7984", call: "ensureOperator", deadline: args.deadline.toString() }
       );
     }
     const fromAccount = args.account ?? args.walletClient.account;
     if (!fromAccount) {
-      throw new chunk2RNW4MIJ_cjs.TokenOpsContractError(
+      throw new chunk67OV5CX2_cjs.TokenOpsContractError(
         "ensureOperator: no account available \u2014 pass `account` explicitly or attach an account to the walletClient",
         { contract: "ERC7984", call: "ensureOperator" }
       );

package/dist/chunk-KWFFIJYX.js

@@ -0,0 +1,11 @@
+// src/core/brands.ts
+var asEncryptedHandle = (h) => h;
+var asExternalInputProof = (h) => h;
+var asTxHash = (h) => h;
+var asVestingId = (h) => h;
+var asAirdropId = (h) => h;
+var asDisperseId = (h) => h;
+var asRole = (h) => h;
+var asSignature = (h) => h;
+
+export { asAirdropId, asDisperseId, asEncryptedHandle, asExternalInputProof, asRole, asSignature, asTxHash, asVestingId };

package/dist/{chunk-7G7UOQV4.cjs → chunk-MM5BV5CS.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunkEUKPOXWR_cjs = require('./chunk-EUKPOXWR.cjs');
+var chunkUHHMVBLU_cjs = require('./chunk-UHHMVBLU.cjs');
 
 // src/fhe-vesting/advanced/factory-advanced.ts
-var ConfidentialVestingFactoryAdvancedClient = class extends chunkEUKPOXWR_cjs.ConfidentialVestingFactoryClient {
+var ConfidentialVestingFactoryAdvancedClient = class extends chunkUHHMVBLU_cjs.ConfidentialVestingFactoryClient {
   /**
    * Compute the deterministic CREATE2 clone address as the factory would have
    * computed it at `args.blockNumber`.
@@ -20,7 +20,7 @@ var ConfidentialVestingFactoryAdvancedClient = class extends chunkEUKPOXWR_cjs.C
     if (hasOptions) {
       return this.publicClient.readContract({
         address: this.address,
-        abi: chunkEUKPOXWR_cjs.confidentialVestingFactoryAbi,
+        abi: chunkUHHMVBLU_cjs.confidentialVestingFactoryAbi,
         functionName: "predictManagerAddressWithOptions",
         args: [
           args.token,
@@ -34,7 +34,7 @@ var ConfidentialVestingFactoryAdvancedClient = class extends chunkEUKPOXWR_cjs.C
     }
     return this.publicClient.readContract({
       address: this.address,
-      abi: chunkEUKPOXWR_cjs.confidentialVestingFactoryAbi,
+      abi: chunkUHHMVBLU_cjs.confidentialVestingFactoryAbi,
       functionName: "predictManagerAddress",
       args: [args.token, args.userSalt, args.deployer],
       blockNumber: args.blockNumber