@tokenops/sdk 1.6.0 → 2.0.0-alpha.1

package/dist/{chunk-BD4LZBVF.cjs → chunk-3QHNYEQD.cjs}

@@ -1,6 +1,7 @@
 'use strict';
 
-var chunk2RNW4MIJ_cjs = require('./chunk-2RNW4MIJ.cjs');
+var chunk66IHPTOK_cjs = require('./chunk-66IHPTOK.cjs');
+var chunk67OV5CX2_cjs = require('./chunk-67OV5CX2.cjs');
 var viem = require('viem');
 
 // src/fhe/scale-ratio.ts
@@ -16,7 +17,7 @@ function scaleRatio({
   width = "uint128"
 }) {
   if (denominator <= 0n) {
-    throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
       method: "scaleRatio",
       argument: "denominator",
       reason: `must be > 0, got ${denominator}`,
@@ -24,7 +25,7 @@ function scaleRatio({
     });
   }
   if (numerator < 0n) {
-    throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
       method: "scaleRatio",
       argument: "numerator",
       reason: `must be >= 0, got ${numerator}`,
@@ -32,7 +33,7 @@ function scaleRatio({
     });
   }
   if (minDenominator <= 0n) {
-    throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
       method: "scaleRatio",
       argument: "minDenominator",
       reason: `must be > 0, got ${minDenominator}`,
@@ -52,7 +53,7 @@ function scaleRatio({
 function assertWithinWidth(value, width, label) {
   const max = width === "uint64" ? MAX_UINT64 : MAX_UINT128;
   if (value > max) {
-    throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
       method: "scaleRatio",
       argument: label,
       reason: `exceeds ${width} range`,
@@ -79,7 +80,7 @@ var share = {
     const n = toIntegerBigInt(numerator, "share.fraction", "numerator");
     const m = toIntegerBigInt(denominator, "share.fraction", "denominator");
     if (m <= 0n || m > MAX_FRACTION_DENOMINATOR) {
-      throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
         method: "share.fraction",
         argument: "denominator",
         reason: `must be in 1..${MAX_FRACTION_DENOMINATOR}, got ${m}`,
@@ -87,7 +88,7 @@ var share = {
       });
     }
     if (n < 0n || n > m) {
-      throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
         method: "share.fraction",
         argument: "numerator",
         reason: `must be in 0..${m} (denominator), got ${n}`,
@@ -112,7 +113,7 @@ var share = {
   basisPoints(bps) {
     const value = toIntegerBigInt(bps, "share.basisPoints", "bps");
     if (value < 0n || value > BASIS_POINT_SCALE) {
-      throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
+      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
         method: "share.basisPoints",
         argument: "bps",
         reason: `must be in 0..${BASIS_POINT_SCALE}, got ${value}`,
@@ -125,7 +126,7 @@ var share = {
 function toIntegerBigInt(value, method, argument) {
   if (typeof value === "bigint") return value;
   if (!Number.isInteger(value)) {
-    throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
       method,
       argument,
       reason: `must be an integer, got ${value}`,
@@ -141,7 +142,7 @@ function resolveEncryptor(source) {
 var MAX_UINT642 = (1n << 64n) - 1n;
 function assertUint64(value, label) {
   if (value < 0n || value > MAX_UINT642) {
-    throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
       method: "encryptUint64",
       argument: label,
       reason: `does not fit in uint64 (0..2^64-1)`,
@@ -162,7 +163,7 @@ async function encryptUint64({
     userAddress
   });
   if (handles.length !== 1) {
-    throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
       method: "encryptUint64",
       argument: "handles",
       reason: `expected 1 handle, got ${handles.length}`,
@@ -170,8 +171,8 @@ async function encryptUint64({
     });
   }
   return {
-    handle: chunk2RNW4MIJ_cjs.asEncryptedHandle(viem.bytesToHex(handles[0])),
-    inputProof: chunk2RNW4MIJ_cjs.asExternalInputProof(viem.bytesToHex(inputProof))
+    handle: chunk66IHPTOK_cjs.asEncryptedHandle(viem.bytesToHex(handles[0])),
+    inputProof: chunk66IHPTOK_cjs.asExternalInputProof(viem.bytesToHex(inputProof))
   };
 }
 async function encryptUint64Batch({
@@ -181,7 +182,7 @@ async function encryptUint64Batch({
   values
 }) {
   if (values.length === 0) {
-    throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
       method: "encryptUint64Batch",
       argument: "values",
       reason: "must be non-empty"
@@ -194,7 +195,7 @@ async function encryptUint64Batch({
     userAddress
   });
   if (handles.length !== values.length) {
-    throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
+    throw new chunk67OV5CX2_cjs.InvalidArgumentError({
       method: "encryptUint64Batch",
       argument: "handles",
       reason: `expected ${values.length} handles, got ${handles.length}`,
@@ -202,8 +203,8 @@ async function encryptUint64Batch({
     });
   }
   return {
-    handles: handles.map((h) => chunk2RNW4MIJ_cjs.asEncryptedHandle(viem.bytesToHex(h))),
-    inputProof: chunk2RNW4MIJ_cjs.asExternalInputProof(viem.bytesToHex(inputProof))
+    handles: handles.map((h) => chunk66IHPTOK_cjs.asEncryptedHandle(viem.bytesToHex(h))),
+    inputProof: chunk66IHPTOK_cjs.asExternalInputProof(viem.bytesToHex(inputProof))
   };
 }
 

package/dist/chunk-456VDDA3.js

@@ -0,0 +1,370 @@
+import { resolveEncryptor, encryptUint64 } from './chunk-GKKDAW44.js';
+import { assertPredictionFresh, FeeCollectorSelfAdministeredError } from './chunk-O5676ZWY.js';
+import { normaliseAddress } from './chunk-ZA673I3O.js';
+import { InvalidArgumentError, MissingWalletClientError, MissingAccountError, ContractRevertError, MissingEncryptorError, isTokenOpsSdkError, UnknownWriteFailureError } from './chunk-QBJ7O2B4.js';
+import { StandardMerkleTree } from '@openzeppelin/merkle-tree';
+import { keccak256, encodeAbiParameters, isAddress, isAddressEqual, zeroAddress } from 'viem';
+
+function leafOf(args) {
+  const inner = keccak256(
+    encodeAbiParameters(
+      [{ type: "address" }, { type: "address" }, { type: "bytes32" }],
+      [args.instance, args.recipient, args.handle]
+    )
+  );
+  return keccak256(inner);
+}
+var HANDLE_PATTERN = /^0x[0-9a-fA-F]{64}$/;
+function assertLeaves(instance, leaves, method) {
+  if (!isAddress(instance, { strict: false })) {
+    throw new InvalidArgumentError({
+      method,
+      argument: "instance",
+      reason: "is not a 20-byte hex address",
+      value: instance
+    });
+  }
+  if (isAddressEqual(instance, zeroAddress)) {
+    throw new InvalidArgumentError({
+      method,
+      argument: "instance",
+      reason: "is the zero address; leaves must be scoped to the airdrop instance"
+    });
+  }
+  if (leaves.length === 0) {
+    throw new InvalidArgumentError({
+      method,
+      argument: "leaves",
+      reason: "a tree needs at least one leaf"
+    });
+  }
+  const seen = /* @__PURE__ */ new Map();
+  leaves.forEach((leaf, index) => {
+    if (!isAddress(leaf.recipient, { strict: false })) {
+      throw new InvalidArgumentError({
+        method,
+        argument: `leaves[${index}].recipient`,
+        reason: "is not a 20-byte hex address",
+        value: leaf.recipient
+      });
+    }
+    if (isAddressEqual(leaf.recipient, zeroAddress)) {
+      throw new InvalidArgumentError({
+        method,
+        argument: `leaves[${index}].recipient`,
+        reason: "is the zero address, whose leaf can never be claimed"
+      });
+    }
+    if (!HANDLE_PATTERN.test(leaf.handle)) {
+      throw new 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.recipient.toLowerCase();
+    const first = seen.get(key);
+    if (first !== void 0) {
+      throw new InvalidArgumentError({
+        method,
+        argument: `leaves[${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);
+  });
+}
+function buildMerkleTree(args) {
+  return buildMerkleTreeInternal(args, "buildMerkleTree");
+}
+function buildMerkleTreeInternal({ instance, leaves }, method) {
+  assertLeaves(instance, leaves, method);
+  const airdrop = normaliseAddress(instance);
+  const accounts = leaves.map((leaf) => normaliseAddress(leaf.recipient));
+  const rows = accounts.map((account, i) => [airdrop, account, leaves[i].handle]);
+  const tree = 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,
+      recipient: accounts[i],
+      merkleProof: tree.getProof(i)
+    }))
+  };
+}
+var MAX_UINT64 = (1n << 64n) - 1n;
+function validateCampaignRecipients(recipients) {
+  validateCampaignRecipientsInternal(recipients, "validateCampaignRecipients");
+}
+function validateCampaignRecipientsInternal(recipients, method) {
+  if (recipients.length === 0) {
+    throw new InvalidArgumentError({
+      method,
+      argument: "recipients",
+      reason: "a campaign needs at least one recipient"
+    });
+  }
+  const seen = /* @__PURE__ */ new Map();
+  recipients.forEach((entry, index) => {
+    if (!isAddress(entry.recipient, { strict: false })) {
+      throw new InvalidArgumentError({
+        method,
+        argument: `recipients[${index}].recipient`,
+        reason: "is not a 20-byte hex address",
+        value: entry.recipient
+      });
+    }
+    if (isAddressEqual(entry.recipient, zeroAddress)) {
+      throw new 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 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 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 }, method) {
+  validateCampaignRecipientsInternal(recipients, method);
+  if (!isAddress(instance, { strict: false })) {
+    throw new InvalidArgumentError({
+      method,
+      argument: "instance",
+      reason: "is not a 20-byte hex address",
+      value: instance
+    });
+  }
+  if (isAddressEqual(instance, zeroAddress)) {
+    throw new InvalidArgumentError({
+      method,
+      argument: "instance",
+      reason: "is the zero address; inputs must be bound to the airdrop instance"
+    });
+  }
+  const enc = resolveEncryptor(encryptor);
+  if (!enc) {
+    throw new MissingEncryptorError(method, {
+      hint: "Pass an encryptor instance, or a lazy factory that returns one."
+    });
+  }
+  const airdrop = normaliseAddress(instance);
+  const accounts = recipients.map((r) => normaliseAddress(r.recipient));
+  const encrypted = await Promise.all(
+    recipients.map(
+      (r, i) => encryptUint64({
+        encryptor: enc,
+        contractAddress: airdrop,
+        userAddress: accounts[i],
+        value: r.cumulativeTotal
+      })
+    )
+  );
+  return accounts.map((recipient, i) => ({
+    recipient,
+    handle: encrypted[i].handle,
+    inputProof: encrypted[i].inputProof
+  }));
+}
+async function encryptCampaignAmounts(args) {
+  return encryptRoster(args, "encryptCampaignAmounts");
+}
+async function buildMerkleCampaign({
+  instance,
+  recipients,
+  encryptor
+}) {
+  const leaves = await encryptRoster({ instance, recipients, encryptor }, "buildMerkleCampaign");
+  return buildMerkleTreeInternal({ instance, leaves }, "buildMerkleCampaign");
+}
+async function planMerkleCampaign({
+  factory,
+  params,
+  mode,
+  creator,
+  userSalt,
+  recipients,
+  encryptor
+}) {
+  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
+  });
+  const initCodeHashAfter = await factory.getMerkleInitCodeHash({ params, mode });
+  assertPredictionFresh({
+    variant: "merkle",
+    initCodeHashBefore,
+    initCodeHashAfter,
+    predictedAddress,
+    method: "planMerkleCampaign"
+  });
+  return { ...campaign, predictedAddress, initCodeHashBefore, initCodeHashAfter };
+}
+async function rotateMerkleRoot({
+  airdrop,
+  recipients,
+  encryptor,
+  account
+}) {
+  const campaign = await buildMerkleCampaign({
+    instance: airdrop.address,
+    recipients,
+    encryptor
+  });
+  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 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 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 (isAddressEqual(assignment.admin, zeroAddress)) {
+      throw new 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 (isTokenOpsSdkError(error)) return error;
+  return new 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 MissingWalletClientError("grantInstanceRoles");
+  }
+  const callerAccount = wallet.account;
+  if (!callerAccount) {
+    throw new 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 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;
+}
+
+export { buildMerkleCampaign, buildMerkleTree, encryptCampaignAmounts, grantInstanceRoles, leafOf, planInstanceRoleSplit, planMerkleCampaign, rotateMerkleRoot, validateCampaignRecipients };

package/dist/{chunk-6WSNS3UV.js → chunk-4RAAATVY.js}

@@ -1,8 +1,6 @@
-import { TokenOpsSdkError, ContractRevertError, InvalidArgumentError, OperatorNotApprovedError, InvalidSignatureError, FheHandleNotAllowedError, TransferFailedError, FeatureDisabledError, BatchTooLargeError, InsufficientBalanceError, InsufficientFeeError, ReentrancyError, AlreadyInitializedError, AccessDeniedError, PausedError, UnknownWriteFailureError, WalletRejectedError, WalletChainMismatchError, InsufficientGasFundsError, NetworkError } from './chunk-DRSPMIZ7.js';
+import { TokenOpsSdkError, ContractRevertError, InvalidArgumentError, OperatorNotApprovedError, InvalidSignatureError, FheHandleNotAllowedError, TransferFailedError, FeatureDisabledError, BatchTooLargeError, InsufficientBalanceError, InsufficientFeeError, ReentrancyError, AlreadyInitializedError, AccessDeniedError, PausedError, UnknownWriteFailureError, WalletRejectedError, WalletChainMismatchError, InsufficientGasFundsError, NetworkError } from './chunk-QBJ7O2B4.js';
 import { decodeErrorResult, BaseError, ContractFunctionRevertedError, UserRejectedRequestError, TransactionRejectedRpcError, ChainMismatchError, InsufficientFundsError, HttpRequestError, TimeoutError } from 'viem';
 
-// src/core/version.ts
-var SDK_VERSION = "1.0.0";
 var ERC7984_ERRORS_ABI = [
   {
     type: "error",
@@ -378,4 +376,4 @@ function coerceRevertHex(value) {
   return void 0;
 }
 
-export { SDK_VERSION, isContractRevert, mapContractRevert };
+export { isContractRevert, mapContractRevert };

package/dist/{chunk-4KJ66YRH.js → chunk-4TSDNZQ3.js}

@@ -1,6 +1,6 @@
 import { erc7984OperatorAbi } from './chunk-7VELUOMI.js';
-import { normaliseAddress } from './chunk-46T67CE2.js';
-import { TokenOpsContractError } from './chunk-DRSPMIZ7.js';
+import { normaliseAddress } from './chunk-ZA673I3O.js';
+import { TokenOpsContractError } from './chunk-QBJ7O2B4.js';
 import { withTelemetry } from './chunk-Q2GP5UDC.js';
 
 // src/fhe/operators.ts

package/dist/{chunk-WUXUWTFW.cjs → chunk-5576FRT3.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunk2RNW4MIJ_cjs = require('./chunk-2RNW4MIJ.cjs');
+var chunk67OV5CX2_cjs = require('./chunk-67OV5CX2.cjs');
 var chains = require('viem/chains');
 
 var DEPLOYED_ADDRESSES = {
@@ -10,10 +10,22 @@ var DEPLOYED_ADDRESSES = {
       // mainnet omitted — not deployed.
     }
   },
+  // Airdrop v2 (tokenops-fhe-airdrop-v2 @ 8e5b144). The four contracts deploy
+  // together in one scripted run, so a chain either has all of them or none —
+  // which is what `chainsWithDeployment` assumes.
   fheAirdrop: {
-    confidentialAirdropFactory: {
-      [chains.sepolia.id]: "0xbE6A3B78B36684fFee48De77d47Bc3393F5Acd4c"
-      // mainnet omitted — not deployed.
+    airdropFactory: {
+      [chains.sepolia.id]: "0x383083B6f13a0ee513596A6750B511c5E482d2d1"
+      // mainnet omitted — ZamaConfig-gated, not deployed.
+    },
+    ecdsaImplementation: {
+      [chains.sepolia.id]: "0xefE40570C1837210f8E4Ae938635e11bd1ae788E"
+    },
+    merkleImplementation: {
+      [chains.sepolia.id]: "0x9f3156546744F3ceE98Dc44bed817d98A8b8ae74"
+    },
+    complianceManagerImplementation: {
+      [chains.sepolia.id]: "0x6adA841250C048364d1d3027958C662Dd4E62136"
     }
   },
   fheDisperse: {
@@ -50,7 +62,7 @@ function requireDeployedAddress(product, contract, chainId) {
   const contractEntry = productEntry[contract];
   const entry = contractEntry?.[chainId];
   if (entry) return entry;
-  throw new chunk2RNW4MIJ_cjs.DeploymentAddressUnavailableError({
+  throw new chunk67OV5CX2_cjs.DeploymentAddressUnavailableError({
     reason: entry === null ? "registry-not-deployed" : "registry-unknown-chain",
     product: String(product),
     contract: String(contract),
@@ -64,10 +76,19 @@ function requireFheVestingFactoryAddress(chainId) {
   return requireDeployedAddress("fheVesting", "confidentialVestingFactory", chainId);
 }
 function getFheAirdropFactoryAddress(chainId) {
-  return getDeployedAddress("fheAirdrop", "confidentialAirdropFactory", chainId);
+  return getDeployedAddress("fheAirdrop", "airdropFactory", chainId);
 }
 function requireFheAirdropFactoryAddress(chainId) {
-  return requireDeployedAddress("fheAirdrop", "confidentialAirdropFactory", chainId);
+  return requireDeployedAddress("fheAirdrop", "airdropFactory", chainId);
+}
+function getFheAirdropEcdsaImplementationAddress(chainId) {
+  return getDeployedAddress("fheAirdrop", "ecdsaImplementation", chainId);
+}
+function getFheAirdropMerkleImplementationAddress(chainId) {
+  return getDeployedAddress("fheAirdrop", "merkleImplementation", chainId);
+}
+function getFheAirdropComplianceImplementationAddress(chainId) {
+  return getDeployedAddress("fheAirdrop", "complianceManagerImplementation", chainId);
 }
 function getFheDisperseSingletonAddress(chainId) {
   return getDeployedAddress("fheDisperse", "disperseConfidentialSingleton", chainId);
@@ -115,7 +136,10 @@ exports.chainsWithDeployment = chainsWithDeployment;
 exports.chainsWithKnownRegistryEntry = chainsWithKnownRegistryEntry;
 exports.getConfidentialTestTokenAddress = getConfidentialTestTokenAddress;
 exports.getDeployedAddress = getDeployedAddress;
+exports.getFheAirdropComplianceImplementationAddress = getFheAirdropComplianceImplementationAddress;
+exports.getFheAirdropEcdsaImplementationAddress = getFheAirdropEcdsaImplementationAddress;
 exports.getFheAirdropFactoryAddress = getFheAirdropFactoryAddress;
+exports.getFheAirdropMerkleImplementationAddress = getFheAirdropMerkleImplementationAddress;
 exports.getFheDisperseSingletonAddress = getFheDisperseSingletonAddress;
 exports.getFheVestingFactoryAddress = getFheVestingFactoryAddress;
 exports.getTestTokenAddress = getTestTokenAddress;

package/dist/chunk-66IHPTOK.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+// 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;
+
+exports.asAirdropId = asAirdropId;
+exports.asDisperseId = asDisperseId;
+exports.asEncryptedHandle = asEncryptedHandle;
+exports.asExternalInputProof = asExternalInputProof;
+exports.asRole = asRole;
+exports.asSignature = asSignature;
+exports.asTxHash = asTxHash;
+exports.asVestingId = asVestingId;

package/dist/{chunk-2RNW4MIJ.cjs → chunk-67OV5CX2.cjs}

@@ -494,16 +494,6 @@ var TokenOpsContractError = class extends TokenOpsSdkError {
   }
 };
 
-// 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;
-
 exports.AccessDeniedError = AccessDeniedError;
 exports.AlreadyInitializedError = AlreadyInitializedError;
 exports.BatchTooLargeError = BatchTooLargeError;
@@ -542,12 +532,4 @@ exports.UserDecryptNotAllowedError = UserDecryptNotAllowedError;
 exports.UserRejectedSignatureError = UserRejectedSignatureError;
 exports.WalletChainMismatchError = WalletChainMismatchError;
 exports.WalletRejectedError = WalletRejectedError;
-exports.asAirdropId = asAirdropId;
-exports.asDisperseId = asDisperseId;
-exports.asEncryptedHandle = asEncryptedHandle;
-exports.asExternalInputProof = asExternalInputProof;
-exports.asRole = asRole;
-exports.asSignature = asSignature;
-exports.asTxHash = asTxHash;
-exports.asVestingId = asVestingId;
 exports.isTokenOpsSdkError = isTokenOpsSdkError;

package/dist/{chunk-PD7ME2BT.js → chunk-6GNR22OV.js}

@@ -1,4 +1,5 @@
-import { InvalidArgumentError, asExternalInputProof, asEncryptedHandle } from './chunk-DRSPMIZ7.js';
+import { asExternalInputProof, asEncryptedHandle } from './chunk-KWFFIJYX.js';
+import { InvalidArgumentError } from './chunk-QBJ7O2B4.js';
 import { bytesToHex } from 'viem';
 
 // src/fhe/scale-ratio.ts

package/dist/{chunk-VHSNYUYV.js → chunk-6NAVMWZQ.js}

@@ -1,8 +1,8 @@
-import { createConfidentialVestingManagerClient } from './chunk-TN65XNTI.js';
-import { resolveEncryptor } from './chunk-PD7ME2BT.js';
-import { createConfidentialVestingFactoryClient } from './chunk-V5D7BHW3.js';
-import { getFheVestingFactoryAddress } from './chunk-QKKBBH7I.js';
-import { DeploymentAddressUnavailableError } from './chunk-DRSPMIZ7.js';
+import { createConfidentialVestingManagerClient } from './chunk-TWT3STIX.js';
+import { resolveEncryptor } from './chunk-6GNR22OV.js';
+import { createConfidentialVestingFactoryClient } from './chunk-EAJ7SYHE.js';
+import { getFheVestingFactoryAddress } from './chunk-DZHYSUGY.js';
+import { DeploymentAddressUnavailableError } from './chunk-QBJ7O2B4.js';
 import { useMemo, useRef, useEffect } from 'react';
 import { usePublicClient, useWalletClient } from 'wagmi';