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

package/dist/{chunk-CTED3MTR.cjs → chunk-IUKKNJ2R.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunkPUX5VXDB_cjs = require('./chunk-PUX5VXDB.cjs');
-var chunkM4IT6DNJ_cjs = require('./chunk-M4IT6DNJ.cjs');
+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');
@@ -11,7 +11,7 @@ function leafOf(args) {
   const inner = viem.keccak256(
     viem.encodeAbiParameters(
       [{ type: "address" }, { type: "address" }, { type: "bytes32" }],
-      [args.instance, args.recipient, args.handle]
+      [args.instance, args.account, args.handle]
     )
   );
   return viem.keccak256(inner);
@@ -42,19 +42,19 @@ function assertLeaves(instance, leaves, method) {
   }
   const seen = /* @__PURE__ */ new Map();
   leaves.forEach((leaf, index) => {
-    if (!viem.isAddress(leaf.recipient, { strict: false })) {
+    if (!viem.isAddress(leaf.account, { strict: false })) {
       throw new chunk67OV5CX2_cjs.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 (viem.isAddressEqual(leaf.recipient, viem.zeroAddress)) {
+    if (viem.isAddressEqual(leaf.account, viem.zeroAddress)) {
       throw new chunk67OV5CX2_cjs.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)) {
@@ -65,13 +65,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 chunk67OV5CX2_cjs.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);
@@ -83,22 +83,23 @@ function buildMerkleTree(args) {
 function buildMerkleTreeInternal({ instance, leaves }, method) {
   assertLeaves(instance, leaves, method);
   const airdrop = chunkJK4XMMKM_cjs.normaliseAddress(instance);
-  const accounts = leaves.map((leaf) => chunkJK4XMMKM_cjs.normaliseAddress(leaf.recipient));
+  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]`.
+    // `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");
 }
@@ -147,7 +148,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 (!viem.isAddress(instance, { strict: false })) {
     throw new chunk67OV5CX2_cjs.InvalidArgumentError({
@@ -164,17 +165,60 @@ async function encryptRoster({ instance, recipients, encryptor }, method) {
       reason: "is the zero address; inputs must be bound to the airdrop instance"
     });
   }
-  const enc = chunkPUX5VXDB_cjs.resolveEncryptor(encryptor);
+  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) => chunkPUX5VXDB_cjs.encryptUint64({
+      (r, i) => chunkPZZK3O3S_cjs.encryptUint64({
         encryptor: enc,
         contractAddress: airdrop,
         userAddress: accounts[i],
@@ -182,8 +226,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
   }));
@@ -194,9 +239,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({
@@ -206,7 +255,8 @@ async function planMerkleCampaign({
   creator,
   userSalt,
   recipients,
-  encryptor
+  encryptor,
+  submitter
 }) {
   validateCampaignRecipientsInternal(recipients, "planMerkleCampaign");
   const initCodeHashBefore = await factory.getMerkleInitCodeHash({ params, mode });
@@ -219,10 +269,11 @@ async function planMerkleCampaign({
   const campaign = await buildMerkleCampaign({
     instance: predictedAddress,
     recipients,
-    encryptor
+    encryptor,
+    submitter
   });
   const initCodeHashAfter = await factory.getMerkleInitCodeHash({ params, mode });
-  chunkM4IT6DNJ_cjs.assertPredictionFresh({
+  chunkAREQJHKA_cjs.assertPredictionFresh({
     variant: "merkle",
     initCodeHashBefore,
     initCodeHashAfter,
@@ -235,12 +286,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 };
@@ -258,7 +311,7 @@ var ASSIGNABLE_ROLES = [
 function planInstanceRoleSplit(args) {
   const { assignment, caller, airdropType } = args;
   if (assignment.feeCollector !== void 0) {
-    throw new chunkM4IT6DNJ_cjs.FeeCollectorSelfAdministeredError({ requestedGrantee: assignment.feeCollector });
+    throw new chunkAREQJHKA_cjs.FeeCollectorSelfAdministeredError({ requestedGrantee: assignment.feeCollector });
   }
   const steps = [];
   for (const { key, role, variant } of ASSIGNABLE_ROLES) {

package/dist/{chunk-FGEB7RMY.cjs → chunk-MM5BV5CS.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunk6PXXGACR_cjs = require('./chunk-6PXXGACR.cjs');
+var chunkUHHMVBLU_cjs = require('./chunk-UHHMVBLU.cjs');
 
 // src/fhe-vesting/advanced/factory-advanced.ts
-var ConfidentialVestingFactoryAdvancedClient = class extends chunk6PXXGACR_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 chunk6PXXGACR_cjs.C
     if (hasOptions) {
       return this.publicClient.readContract({
         address: this.address,
-        abi: chunk6PXXGACR_cjs.confidentialVestingFactoryAbi,
+        abi: chunkUHHMVBLU_cjs.confidentialVestingFactoryAbi,
         functionName: "predictManagerAddressWithOptions",
         args: [
           args.token,
@@ -34,7 +34,7 @@ var ConfidentialVestingFactoryAdvancedClient = class extends chunk6PXXGACR_cjs.C
     }
     return this.publicClient.readContract({
       address: this.address,
-      abi: chunk6PXXGACR_cjs.confidentialVestingFactoryAbi,
+      abi: chunkUHHMVBLU_cjs.confidentialVestingFactoryAbi,
       functionName: "predictManagerAddress",
       args: [args.token, args.userSalt, args.deployer],
       blockNumber: args.blockNumber

package/dist/{chunk-335Z2W67.js → chunk-PYYSB5ZN.js}

@@ -1,4 +1,4 @@
-import { ConfidentialVestingFactoryClient, confidentialVestingFactoryAbi } from './chunk-EAJ7SYHE.js';
+import { ConfidentialVestingFactoryClient, confidentialVestingFactoryAbi } from './chunk-WJMEBBU7.js';
 
 // src/fhe-vesting/advanced/factory-advanced.ts
 var ConfidentialVestingFactoryAdvancedClient = class extends ConfidentialVestingFactoryClient {