@tokenops/sdk 2.0.0-alpha.1 → 2.0.0-alpha.2

package/dist/chunk-EYDA6Q6C.js

@@ -0,0 +1,245 @@
+import { createConfidentialAirdropFactoryClient, resolveEncryptor, createAirdropBaseClient, createMerkleAirdropClient, createComplianceManagerClient, createEcdsaAirdropClient } from './chunk-X7WBPCEU.js';
+import { getFheAirdropFactoryAddress } from './chunk-A4DCEE33.js';
+import { DeploymentAddressUnavailableError } from './chunk-QBJ7O2B4.js';
+import { useRef, useMemo } from 'react';
+import { usePublicClient, useWalletClient } from 'wagmi';
+
+var FHE_AIRDROP_KEY = "tokenops-sdk";
+var FHE_AIRDROP_NAMESPACE = "fhe-airdrop";
+function airdropQueryKey(params) {
+  return [
+    FHE_AIRDROP_KEY,
+    FHE_AIRDROP_NAMESPACE,
+    params.chainId ?? null,
+    params.address ? normalizeKeyArg(params.address) : null,
+    params.fn,
+    params.args.map(normalizeKeyArg)
+  ];
+}
+function airdropQueryKeyPrefix(params) {
+  const prefix = [
+    FHE_AIRDROP_KEY,
+    FHE_AIRDROP_NAMESPACE,
+    params.chainId ?? null,
+    params.address ? normalizeKeyArg(params.address) : null
+  ];
+  if (params.fn !== void 0) prefix.push(params.fn);
+  return prefix;
+}
+function normalizeKeyArg(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map(normalizeKeyArg);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, normalizeKeyArg(v)])
+    );
+  }
+  if (typeof value === "string" && value.startsWith("0x")) return value.toLowerCase();
+  return value;
+}
+function tryResolveAirdropFactoryAddress(override, chainId) {
+  if (override) return override;
+  if (chainId === void 0) return void 0;
+  return getFheAirdropFactoryAddress(chainId);
+}
+function computeAirdropFactoryResolutionError(override, chainId) {
+  if (override) return void 0;
+  if (chainId === void 0) {
+    return new DeploymentAddressUnavailableError({
+      reason: "chain-id-missing",
+      product: "fheAirdrop",
+      contract: "airdropFactory",
+      clientLabel: "ConfidentialAirdropFactoryClient"
+    });
+  }
+  const resolved = getFheAirdropFactoryAddress(chainId);
+  if (!resolved) {
+    return new DeploymentAddressUnavailableError({
+      reason: "registry-not-deployed",
+      product: "fheAirdrop",
+      contract: "airdropFactory",
+      chainId,
+      clientLabel: "ConfidentialAirdropFactoryClient"
+    });
+  }
+  return void 0;
+}
+function useMemoAirdropFactoryClient(opts = {}) {
+  const publicClient = usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const resolvedAddress = tryResolveAirdropFactoryAddress(opts.address, chainId);
+  const resolutionError = computeAirdropFactoryResolutionError(opts.address, chainId);
+  const encryptorSourceRef = useRef(opts.encryptor);
+  encryptorSourceRef.current = opts.encryptor;
+  const telemetry = opts.telemetry;
+  const client = useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!resolvedAddress) return void 0;
+    return createConfidentialAirdropFactoryClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: resolvedAddress,
+      ...chainId !== void 0 ? { chainId } : {},
+      // Lazy — invoked per-encryption inside the headless client.
+      encryptor: () => resolveEncryptor(encryptorSourceRef.current),
+      ...telemetry ? { telemetry } : {}
+    });
+  }, [publicClient, walletClient, resolvedAddress, chainId, telemetry]);
+  return {
+    client,
+    resolutionError,
+    publicClient,
+    walletClient: walletClient ?? void 0,
+    chainId,
+    resolvedAddress
+  };
+}
+function useMemoAirdropBaseClient(opts) {
+  const publicClient = usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const telemetry = opts.telemetry;
+  const client = useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return createAirdropBaseClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: opts.address,
+      ...chainId !== void 0 ? { chainId } : {},
+      ...telemetry ? { telemetry } : {}
+    });
+  }, [publicClient, walletClient, opts.address, chainId, telemetry]);
+  return { client, publicClient, walletClient: walletClient ?? void 0, chainId };
+}
+function useMemoMerkleAirdropClient(opts) {
+  const publicClient = usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const telemetry = opts.telemetry;
+  const client = useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return createMerkleAirdropClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: opts.address,
+      ...chainId !== void 0 ? { chainId } : {},
+      ...telemetry ? { telemetry } : {}
+    });
+  }, [publicClient, walletClient, opts.address, chainId, telemetry]);
+  return { client, publicClient, walletClient: walletClient ?? void 0, chainId };
+}
+function useMemoComplianceManagerClient(opts) {
+  const publicClient = usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const telemetry = opts.telemetry;
+  const client = useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return createComplianceManagerClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: opts.address,
+      ...chainId !== void 0 ? { chainId } : {},
+      ...telemetry ? { telemetry } : {}
+    });
+  }, [publicClient, walletClient, opts.address, chainId, telemetry]);
+  return { client, publicClient, walletClient: walletClient ?? void 0, chainId };
+}
+function useMemoEcdsaAirdropClient(opts) {
+  const publicClient = usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const telemetry = opts.telemetry;
+  const client = useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return createEcdsaAirdropClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: opts.address,
+      dedupMode: opts.dedupMode,
+      ...chainId !== void 0 ? { chainId } : {},
+      ...telemetry ? { telemetry } : {}
+    });
+  }, [publicClient, walletClient, opts.address, opts.dedupMode, chainId, telemetry]);
+  return { client, publicClient, walletClient: walletClient ?? void 0, chainId };
+}
+
+// src/fhe-airdrop/react/keys.ts
+var AIRDROP_FN = {
+  // instance reads
+  claimedAmount: "getClaimedAmount",
+  paused: "paused",
+  window: "window",
+  config: "config",
+  merkleRoot: "merkleRoot",
+  merkleRootMutable: "isMerkleRootMutable",
+  hasRole: "hasRole",
+  roleMembers: "roleMembers",
+  gasFee: "gasFee",
+  preflightCreate: "preflightCreate",
+  isSignatureValid: "isSignatureValid",
+  // factory reads
+  fees: "fees",
+  registry: "registry",
+  customFee: "customFee",
+  implementations: "implementations",
+  compliancePolicy: "compliancePolicy",
+  upgradeabilityPolicy: "upgradeabilityPolicy",
+  factoryHasRole: "factoryHasRole",
+  factoryRoleMembers: "factoryRoleMembers",
+  // compliance-manager reads
+  complianceInfo: "complianceInfo",
+  activeDelegate: "isActiveDelegate",
+  clientDelegates: "clientDelegates",
+  complianceHasRole: "complianceHasRole",
+  complianceRoleMembers: "complianceRoleMembers"
+};
+var airdropKeys = {
+  /** One account's cumulative delivered total. Keyed on the CLAIM IDENTITY, never the sender. */
+  claimedAmount: (s, account) => airdropQueryKey({ ...s, fn: AIRDROP_FN.claimedAmount, args: [account] }),
+  paused: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.paused, args: [] }),
+  window: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.window, args: [] }),
+  config: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.config, args: [] }),
+  gasFee: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.gasFee, args: [] }),
+  merkleRoot: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.merkleRoot, args: [] }),
+  merkleRootMutable: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.merkleRootMutable, args: [] }),
+  hasRole: (s, role, holder) => airdropQueryKey({ ...s, fn: AIRDROP_FN.hasRole, args: [role, holder] }),
+  /** Every cached `hasRole` for this instance, whatever role/holder pair was queried. */
+  hasRoleAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.hasRole }),
+  roleMembers: (s, role) => airdropQueryKey({ ...s, fn: AIRDROP_FN.roleMembers, args: [role] }),
+  roleMembersAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.roleMembers }),
+  /** Every cached create-preflight, whatever params/mode/salt combination was queried. */
+  preflightCreateAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.preflightCreate }),
+  /** Every cached signature check on this instance; a claim consumes a digest and flips it. */
+  isSignatureValidAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.isSignatureValid }),
+  fees: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.fees, args: [] }),
+  customFee: (s, creator) => airdropQueryKey({ ...s, fn: AIRDROP_FN.customFee, args: [creator] }),
+  customFeeAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.customFee }),
+  /** Every registry page, whatever offset/limit was queried. */
+  registryAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.registry }),
+  implementations: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.implementations, args: [] }),
+  compliancePolicy: (s, creator) => airdropQueryKey({ ...s, fn: AIRDROP_FN.compliancePolicy, args: [creator] }),
+  compliancePolicyAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.compliancePolicy }),
+  upgradeabilityPolicy: (s, creator) => airdropQueryKey({ ...s, fn: AIRDROP_FN.upgradeabilityPolicy, args: [creator] }),
+  upgradeabilityPolicyAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.upgradeabilityPolicy }),
+  factoryHasRole: (s, role, holder) => airdropQueryKey({ ...s, fn: AIRDROP_FN.factoryHasRole, args: [role, holder] }),
+  factoryHasRoleAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.factoryHasRole }),
+  factoryRoleMembers: (s, role) => airdropQueryKey({ ...s, fn: AIRDROP_FN.factoryRoleMembers, args: [role] }),
+  factoryRoleMembersAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.factoryRoleMembers }),
+  complianceInfo: (s) => airdropQueryKey({ ...s, fn: AIRDROP_FN.complianceInfo, args: [] }),
+  activeDelegate: (s, delegate) => airdropQueryKey({ ...s, fn: AIRDROP_FN.activeDelegate, args: [delegate] }),
+  activeDelegateAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.activeDelegate }),
+  clientDelegates: (s, index) => airdropQueryKey({ ...s, fn: AIRDROP_FN.clientDelegates, args: [index] }),
+  clientDelegatesAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.clientDelegates }),
+  complianceHasRole: (s, role, holder) => airdropQueryKey({ ...s, fn: AIRDROP_FN.complianceHasRole, args: [role, holder] }),
+  complianceHasRoleAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.complianceHasRole }),
+  complianceRoleMembers: (s, role) => airdropQueryKey({ ...s, fn: AIRDROP_FN.complianceRoleMembers, args: [role] }),
+  complianceRoleMembersAll: (s) => airdropQueryKeyPrefix({ ...s, fn: AIRDROP_FN.complianceRoleMembers })
+};
+
+export { AIRDROP_FN, airdropKeys, airdropQueryKey, airdropQueryKeyPrefix, useMemoAirdropBaseClient, useMemoAirdropFactoryClient, useMemoComplianceManagerClient, useMemoEcdsaAirdropClient, useMemoMerkleAirdropClient };

package/dist/{chunk-XAYGD4E4.cjs → chunk-FEDX7B6T.cjs}

@@ -2,7 +2,7 @@
 
 var chunkUG5RKLU2_cjs = require('./chunk-UG5RKLU2.cjs');
 var chunkMVDQMV25_cjs = require('./chunk-MVDQMV25.cjs');
-var chunk5576FRT3_cjs = require('./chunk-5576FRT3.cjs');
+var chunkFT5H2Q7Y_cjs = require('./chunk-FT5H2Q7Y.cjs');
 var chunkJK4XMMKM_cjs = require('./chunk-JK4XMMKM.cjs');
 var chunk66IHPTOK_cjs = require('./chunk-66IHPTOK.cjs');
 var chunk67OV5CX2_cjs = require('./chunk-67OV5CX2.cjs');
@@ -1826,7 +1826,7 @@ var TestnetFaucetClient = class {
     this.#chainId = chainId;
     assertTestnetFaucetChain(chainId);
     const addressOverride = config.address ? chunkJK4XMMKM_cjs.normaliseAddress(config.address) : void 0;
-    const resolved = addressOverride ?? (chainId === void 0 ? void 0 : chunk5576FRT3_cjs.getConfidentialTestTokenAddress(chainId));
+    const resolved = addressOverride ?? (chainId === void 0 ? void 0 : chunkFT5H2Q7Y_cjs.getConfidentialTestTokenAddress(chainId));
     if (!resolved) {
       throw new chunk67OV5CX2_cjs.DeploymentAddressUnavailableError({
         reason: chainId === void 0 ? "chain-id-missing" : "registry-not-deployed",
@@ -1864,7 +1864,7 @@ var TestnetFaucetClient = class {
    */
   async underlyingToken() {
     if (this.#cachedUnderlying) return this.#cachedUnderlying;
-    const fromRegistry = this.#cttAddressIsOverride || this.#chainId === void 0 ? void 0 : chunk5576FRT3_cjs.getTestTokenAddress(this.#chainId);
+    const fromRegistry = this.#cttAddressIsOverride || this.#chainId === void 0 ? void 0 : chunkFT5H2Q7Y_cjs.getTestTokenAddress(this.#chainId);
     const resolved = fromRegistry ?? await this.#readCtt("underlying");
     this.#cachedUnderlying = chunkJK4XMMKM_cjs.normaliseAddress(resolved);
     return this.#cachedUnderlying;

package/dist/{chunk-JQYC66TO.cjs → chunk-FHWSBGWE.cjs}

@@ -2,8 +2,8 @@
 
 var chunkWJLECC22_cjs = require('./chunk-WJLECC22.cjs');
 var chunk3QHNYEQD_cjs = require('./chunk-3QHNYEQD.cjs');
-var chunk6PXXGACR_cjs = require('./chunk-6PXXGACR.cjs');
-var chunk5576FRT3_cjs = require('./chunk-5576FRT3.cjs');
+var chunkUHHMVBLU_cjs = require('./chunk-UHHMVBLU.cjs');
+var chunkFT5H2Q7Y_cjs = require('./chunk-FT5H2Q7Y.cjs');
 var chunk67OV5CX2_cjs = require('./chunk-67OV5CX2.cjs');
 var react = require('react');
 var wagmi = require('wagmi');
@@ -26,7 +26,7 @@ function useHookFiredEvent(hookName, telemetry, hasWallet, chainId) {
 function tryResolveFactoryAddress(override, chainId) {
   if (override) return override;
   if (chainId === void 0) return void 0;
-  return chunk5576FRT3_cjs.getFheVestingFactoryAddress(chainId);
+  return chunkFT5H2Q7Y_cjs.getFheVestingFactoryAddress(chainId);
 }
 function useMemoFactoryClient(opts = {}) {
   const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
@@ -39,7 +39,7 @@ function useMemoFactoryClient(opts = {}) {
   const client = react.useMemo(() => {
     if (!publicClient) return void 0;
     if (!resolvedAddress) return void 0;
-    return chunk6PXXGACR_cjs.createConfidentialVestingFactoryClient({
+    return chunkUHHMVBLU_cjs.createConfidentialVestingFactoryClient({
       publicClient,
       ...walletClient ? { walletClient } : {},
       address: resolvedAddress,
@@ -66,7 +66,7 @@ function computeFactoryResolutionError(override, chainId) {
       clientLabel: "ConfidentialVestingFactoryClient"
     });
   }
-  const resolved = chunk5576FRT3_cjs.getFheVestingFactoryAddress(chainId);
+  const resolved = chunkFT5H2Q7Y_cjs.getFheVestingFactoryAddress(chainId);
   if (!resolved) {
     return new chunk67OV5CX2_cjs.DeploymentAddressUnavailableError({
       reason: "registry-not-deployed",

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

@@ -10,22 +10,28 @@ var DEPLOYED_ADDRESSES = {
       // mainnet omitted — not deployed.
     }
   },
-  // Airdrop v2 (tokenops-fhe-airdrop-v2 @ 8e5b144). The four contracts deploy
+  // Airdrop v2 (tokenops-fhe-airdrop-v2 @ 7175ac8). The four contracts deploy
   // together in one scripted run, so a chain either has all of them or none —
   // which is what `chainsWithDeployment` assumes.
+  //
+  // Every address moved at 7175ac8: `claim`'s breaking signature change forced a
+  // fresh Merkle implementation, and the run redeploys the whole system rather
+  // than repointing one implementation slot. A campaign planned against the old
+  // factory therefore predicts an address the new factory will never produce —
+  // `PredictionDriftError` is what catches that.
   fheAirdrop: {
     airdropFactory: {
-      [chains.sepolia.id]: "0x383083B6f13a0ee513596A6750B511c5E482d2d1"
+      [chains.sepolia.id]: "0x174A7CB40F64aBC4C95CecB4172A066Cf531e4E9"
       // mainnet omitted — ZamaConfig-gated, not deployed.
     },
     ecdsaImplementation: {
-      [chains.sepolia.id]: "0xefE40570C1837210f8E4Ae938635e11bd1ae788E"
+      [chains.sepolia.id]: "0xDeD7AB391f87B8F891F89AaEC64C7c9C800C6645"
     },
     merkleImplementation: {
-      [chains.sepolia.id]: "0x9f3156546744F3ceE98Dc44bed817d98A8b8ae74"
+      [chains.sepolia.id]: "0x815E65Cdd707F07F09332537b47C530d0E87aAf5"
     },
     complianceManagerImplementation: {
-      [chains.sepolia.id]: "0x6adA841250C048364d1d3027958C662Dd4E62136"
+      [chains.sepolia.id]: "0x885474FA494748C85410482244a406C6Ad570CCe"
     }
   },
   fheDisperse: {

package/dist/{chunk-456VDDA3.js → chunk-GADGBQJO.js}

@@ -1,5 +1,5 @@
-import { resolveEncryptor, encryptUint64 } from './chunk-GKKDAW44.js';
-import { assertPredictionFresh, FeeCollectorSelfAdministeredError } from './chunk-O5676ZWY.js';
+import { resolveEncryptor, encryptUint64Batch, encryptUint64 } from './chunk-X7WBPCEU.js';
+import { assertPredictionFresh, FeeCollectorSelfAdministeredError } from './chunk-VW356KR3.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';
@@ -9,7 +9,7 @@ function leafOf(args) {
   const inner = keccak256(
     encodeAbiParameters(
       [{ type: "address" }, { type: "address" }, { type: "bytes32" }],
-      [args.instance, args.recipient, args.handle]
+      [args.instance, args.account, args.handle]
     )
   );
   return keccak256(inner);
@@ -40,19 +40,19 @@ function assertLeaves(instance, leaves, method) {
   }
   const seen = /* @__PURE__ */ new Map();
   leaves.forEach((leaf, index) => {
-    if (!isAddress(leaf.recipient, { strict: false })) {
+    if (!isAddress(leaf.account, { strict: false })) {
       throw new InvalidArgumentError({
         method,
-        argument: `leaves[${index}].recipient`,
+        argument: `leaves[${index}].account`,
         reason: "is not a 20-byte hex address",
-        value: leaf.recipient
+        value: leaf.account
       });
     }
-    if (isAddressEqual(leaf.recipient, zeroAddress)) {
+    if (isAddressEqual(leaf.account, zeroAddress)) {
       throw new InvalidArgumentError({
         method,
-        argument: `leaves[${index}].recipient`,
-        reason: "is the zero address, whose leaf can never be claimed"
+        argument: `leaves[${index}].account`,
+        reason: "is the zero address; the contract rejects it with ZeroAccount"
       });
     }
     if (!HANDLE_PATTERN.test(leaf.handle)) {
@@ -63,13 +63,13 @@ function assertLeaves(instance, leaves, method) {
         value: leaf.handle
       });
     }
-    const key = leaf.recipient.toLowerCase();
+    const key = leaf.account.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`
+        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);
@@ -81,22 +81,23 @@ function buildMerkleTree(args) {
 function buildMerkleTreeInternal({ instance, leaves }, method) {
   assertLeaves(instance, leaves, method);
   const airdrop = normaliseAddress(instance);
-  const accounts = leaves.map((leaf) => normaliseAddress(leaf.recipient));
+  const accounts = leaves.map((leaf) => normaliseAddress(leaf.account));
   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]`.
+    // `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],
+      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");
 }
@@ -145,7 +146,7 @@ function validateCampaignRecipientsInternal(recipients, method) {
     seen.set(key, index);
   });
 }
-async function encryptRoster({ instance, recipients, encryptor }, method) {
+async function encryptRoster({ instance, recipients, encryptor, submitter }, method) {
   validateCampaignRecipientsInternal(recipients, method);
   if (!isAddress(instance, { strict: false })) {
     throw new InvalidArgumentError({
@@ -168,8 +169,51 @@ async function encryptRoster({ instance, recipients, encryptor }, method) {
       hint: "Pass an encryptor instance, or a lazy factory that returns one."
     });
   }
+  if (submitter !== void 0) {
+    if (!isAddress(submitter, { strict: false })) {
+      throw new InvalidArgumentError({
+        method,
+        argument: "submitter",
+        reason: "is not a 20-byte hex address",
+        value: submitter
+      });
+    }
+    if (isAddressEqual(submitter, zeroAddress)) {
+      throw new InvalidArgumentError({
+        method,
+        argument: "submitter",
+        reason: "is the zero address; no proof can be bound to it, so no leaf would be claimable"
+      });
+    }
+  }
   const airdrop = normaliseAddress(instance);
   const accounts = recipients.map((r) => normaliseAddress(r.recipient));
+  if (submitter !== void 0) {
+    const boundTo = 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) => 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) => encryptUint64({
@@ -180,8 +224,9 @@ async function encryptRoster({ instance, recipients, encryptor }, method) {
       })
     )
   );
-  return accounts.map((recipient, i) => ({
-    recipient,
+  return accounts.map((account, i) => ({
+    account,
+    boundTo: account,
     handle: encrypted[i].handle,
     inputProof: encrypted[i].inputProof
   }));
@@ -192,9 +237,13 @@ async function encryptCampaignAmounts(args) {
 async function buildMerkleCampaign({
   instance,
   recipients,
-  encryptor
+  encryptor,
+  submitter
 }) {
-  const leaves = await encryptRoster({ instance, recipients, encryptor }, "buildMerkleCampaign");
+  const leaves = await encryptRoster(
+    { instance, recipients, encryptor, submitter },
+    "buildMerkleCampaign"
+  );
   return buildMerkleTreeInternal({ instance, leaves }, "buildMerkleCampaign");
 }
 async function planMerkleCampaign({
@@ -204,7 +253,8 @@ async function planMerkleCampaign({
   creator,
   userSalt,
   recipients,
-  encryptor
+  encryptor,
+  submitter
 }) {
   validateCampaignRecipientsInternal(recipients, "planMerkleCampaign");
   const initCodeHashBefore = await factory.getMerkleInitCodeHash({ params, mode });
@@ -217,7 +267,8 @@ async function planMerkleCampaign({
   const campaign = await buildMerkleCampaign({
     instance: predictedAddress,
     recipients,
-    encryptor
+    encryptor,
+    submitter
   });
   const initCodeHashAfter = await factory.getMerkleInitCodeHash({ params, mode });
   assertPredictionFresh({
@@ -233,12 +284,14 @@ async function rotateMerkleRoot({
   airdrop,
   recipients,
   encryptor,
+  submitter,
   account
 }) {
   const campaign = await buildMerkleCampaign({
     instance: airdrop.address,
     recipients,
-    encryptor
+    encryptor,
+    submitter
   });
   const hash = await airdrop.setMerkleRoot({ newRoot: campaign.root, account });
   return { ...campaign, hash };

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

@@ -1,7 +1,7 @@
 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 { createConfidentialVestingFactoryClient } from './chunk-WJMEBBU7.js';
+import { getFheVestingFactoryAddress } from './chunk-A4DCEE33.js';
 import { DeploymentAddressUnavailableError } from './chunk-QBJ7O2B4.js';
 import { useMemo, useRef, useEffect } from 'react';
 import { usePublicClient, useWalletClient } from 'wagmi';