@tokenops/sdk 1.5.1 → 1.6.0

package/dist/{chunk-2PWNH3UE.js → chunk-QET3Q4JP.js}

@@ -1,11 +1,10 @@
-import { mapZamaError } from './chunk-WMACINXO.js';
-import { getFhevmAclAddress, requireFhevmAclAddress, ACL_ALLOWED_EVENT } from './chunk-ZWXJTBZO.js';
-import { SDK_VERSION, isContractRevert, mapContractRevert } from './chunk-SG65XWH7.js';
-import { getFheDisperseSingletonAddress } from './chunk-XGGTQQFH.js';
-import { normaliseAddress } from './chunk-ZA673I3O.js';
+import { mapZamaError } from './chunk-NFW7AUEX.js';
+import { getFhevmAclAddress, requireFhevmAclAddress, ACL_ALLOWED_EVENT } from './chunk-YPYCWLYP.js';
+import { SDK_VERSION, isContractRevert, mapContractRevert } from './chunk-6WSNS3UV.js';
+import { getFheDisperseSingletonAddress } from './chunk-QKKBBH7I.js';
+import { normaliseAddress } from './chunk-46T67CE2.js';
+import { InvalidArgumentError, asExternalInputProof, asEncryptedHandle, TokenOpsSdkError, DeploymentAddressUnavailableError, PausedError, InsufficientFeeError, MissingEncryptorError, ReceiptEventAmbiguousError, MissingWalletClientError, MissingAccountError, BatchTooLargeError } from './chunk-DRSPMIZ7.js';
 import { withTelemetry } from './chunk-Q2GP5UDC.js';
-import { asExternalInputProof, asEncryptedHandle } from './chunk-KWFFIJYX.js';
-import { InvalidArgumentError, TokenOpsSdkError, DeploymentAddressUnavailableError, PausedError, InsufficientFeeError, MissingEncryptorError, ReceiptEventAmbiguousError, MissingWalletClientError, MissingAccountError, BatchTooLargeError } from './chunk-QBJ7O2B4.js';
 import { bytesToHex, keccak256, encodePacked, parseEventLogs, isAddress, getCreate2Address } from 'viem';
 
 // src/fhe-disperse/abis/singleton.ts
@@ -1771,6 +1770,44 @@ var NotRegisteredError = class extends TokenOpsSdkError {
     );
   }
 };
+var SubwalletsNotApprovedError = class extends TokenOpsSdkError {
+  name = "SubwalletsNotApprovedError";
+  constructor(args) {
+    super(
+      `${args.method}: sub-wallets are not fully approved for token ${args.token} \u2014 wallet0: ${args.wallet0Approved}, wallet1: ${args.wallet1Approved}. Call \`approveUserWalletsForToken\` first.`,
+      {
+        code: "TOKENOPS_SUBWALLETS_NOT_APPROVED",
+        cause: args.cause,
+        context: {
+          method: args.method,
+          contractAddress: args.contractAddress,
+          user: args.user,
+          token: args.token,
+          wallet0Approved: args.wallet0Approved,
+          wallet1Approved: args.wallet1Approved
+        }
+      }
+    );
+  }
+};
+var SingletonNotApprovedError = class extends TokenOpsSdkError {
+  name = "SingletonNotApprovedError";
+  constructor(args) {
+    super(
+      `${args.method}: ${args.user} has not approved the singleton ${args.contractAddress} as an operator on token ${args.token}. Call setOperator() (see @tokenops/sdk/fhe) before this transaction.`,
+      {
+        code: "TOKENOPS_SINGLETON_NOT_APPROVED",
+        cause: args.cause,
+        context: {
+          method: args.method,
+          contractAddress: args.contractAddress,
+          user: args.user,
+          token: args.token
+        }
+      }
+    );
+  }
+};
 var AlreadyRegisteredError = class extends TokenOpsSdkError {
   name = "AlreadyRegisteredError";
   constructor(args) {
@@ -2335,13 +2372,32 @@ var ConfidentialDisperseClient = class {
         })
       );
     } else if (mode === "wallet" || mode === "wallet-token-fee") {
-      if (!hasApprovedSubwallets.both)
+      if (!hasApprovedSubwallets.both) {
         blockers.push(
           `Wallets not fully approved for token \u2014 wallet0: ${hasApprovedSubwallets.wallet0}, wallet1: ${hasApprovedSubwallets.wallet1}`
         );
+        blockerErrors.push(
+          new SubwalletsNotApprovedError({
+            method: "preflightDisperse",
+            contractAddress: this.address,
+            user: args.user,
+            token: args.token,
+            wallet0Approved: hasApprovedSubwallets.wallet0,
+            wallet1Approved: hasApprovedSubwallets.wallet1
+          })
+        );
+      }
     }
     if (mode === "direct" && hasApprovedSingleton === false) {
       blockers.push("Sender has not approved the singleton as operator on the token");
+      blockerErrors.push(
+        new SingletonNotApprovedError({
+          method: "preflightDisperse",
+          contractAddress: this.address,
+          user: args.user,
+          token: args.token
+        })
+      );
     }
     if (isPaused) {
       blockers.push("Singleton is paused");
@@ -3414,4 +3470,4 @@ var PAUSER_ROLE = "0x65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440
 var WITHDRAWER_ROLE = "0x10dac8c06a04bec0b551627dad28bc00d6516b0caacd1c7b345fcdb5211334e4";
 var DEFAULT_ADMIN_ROLE = "0x0000000000000000000000000000000000000000000000000000000000000000";
 
-export { AlreadyRegisteredError, ConfidentialDisperseClient, DEFAULT_ADMIN_ROLE, DisperseEncryptedReserveNotGrantedError, DisperseSubwalletNotFoundError, FEE_COLLECTOR_ROLE, FEE_MANAGER_ROLE, NotRegisteredError, PAUSER_ROLE, WITHDRAWER_ROLE, computeSubtotals, createConfidentialDisperseClient, disperseConfidentialAbi, disperseWalletAbi, encryptUint64, encryptUint64Batch, resolveEncryptor };
+export { AlreadyRegisteredError, ConfidentialDisperseClient, DEFAULT_ADMIN_ROLE, DisperseEncryptedReserveNotGrantedError, DisperseSubwalletNotFoundError, FEE_COLLECTOR_ROLE, FEE_MANAGER_ROLE, NotRegisteredError, PAUSER_ROLE, SingletonNotApprovedError, SubwalletsNotApprovedError, WITHDRAWER_ROLE, computeSubtotals, createConfidentialDisperseClient, disperseConfidentialAbi, disperseWalletAbi, encryptUint64, encryptUint64Batch, resolveEncryptor };

package/dist/{chunk-XGGTQQFH.js → chunk-QKKBBH7I.js}

@@ -1,10 +1,10 @@
-import { DeploymentAddressUnavailableError } from './chunk-QBJ7O2B4.js';
+import { DeploymentAddressUnavailableError } from './chunk-DRSPMIZ7.js';
 import { sepolia, mainnet } from 'viem/chains';
 
 var DEPLOYED_ADDRESSES = {
   fheVesting: {
     confidentialVestingFactory: {
-      [sepolia.id]: "0xA87701CE9A52D43681600583a99c85b50DbE3150"
+      [sepolia.id]: "0x059d6Bb8ff9a13E794fe416d4757d7310CdC69ab"
       // mainnet omitted — not deployed.
     }
   },

package/dist/{chunk-6R4KNAPK.js → chunk-S2XD75JM.js}

@@ -1,7 +1,7 @@
-import { getFhevmAclAddress, requireFhevmAclAddress, ACL_ALLOWED_EVENT } from './chunk-ZWXJTBZO.js';
-import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-SG65XWH7.js';
+import { getFhevmAclAddress, requireFhevmAclAddress, ACL_ALLOWED_EVENT } from './chunk-YPYCWLYP.js';
+import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-6WSNS3UV.js';
+import { TokenOpsSdkError, PausedError, InsufficientFeeError, ReceiptEventNotFoundError, ReceiptEventAmbiguousError, InvalidArgumentError, MissingWalletClientError, MissingAccountError, InsufficientBalanceError, InvalidSignatureError } from './chunk-DRSPMIZ7.js';
 import { withTelemetry } from './chunk-Q2GP5UDC.js';
-import { TokenOpsSdkError, PausedError, InsufficientFeeError, ReceiptEventNotFoundError, ReceiptEventAmbiguousError, InvalidArgumentError, MissingWalletClientError, MissingAccountError, InsufficientBalanceError, InvalidSignatureError } from './chunk-QBJ7O2B4.js';
 import { parseEventLogs, isAddress } from 'viem';
 
 // src/fhe-airdrop/abis/cloneable.ts
@@ -1360,6 +1360,13 @@ var ConfidentialAirdropClient = class {
    *
    * **Silent-zero transfers.** ERC-7984 transfers do not revert when the sender's encrypted balance is insufficient — the transfer succeeds and moves an encrypted zero instead. This is by design: reverting would leak balance information. The transaction receipt alone cannot tell you whether value actually moved.
    *
+   * **An unfunded pool is the opposite case — it reverts loudly.** Do not
+   * generalize the silent-zero rule above to a clone whose pool was never
+   * funded: that claim throws {@link FheHandleNotAllowedError} (the FHEVM ACL
+   * rejects `FHE.allowTransient` on an uninitialized handle), and
+   * {@link preflightClaim} cannot detect it because the pool balance is an
+   * encrypted `euint64` the SDK cannot read in plaintext.
+   *
    * @returns Transaction hash.
    * @example
    * const fee = await airdrop.gasFee();

package/dist/{chunk-MCRBVJGZ.cjs → chunk-SPGSO5SO.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunkFAXIIH5R_cjs = require('./chunk-FAXIIH5R.cjs');
-var chunkKLKI352M_cjs = require('./chunk-KLKI352M.cjs');
+var chunkSYHNZSZZ_cjs = require('./chunk-SYHNZSZZ.cjs');
+var chunk43RFBQ73_cjs = require('./chunk-43RFBQ73.cjs');
+var chunk2RNW4MIJ_cjs = require('./chunk-2RNW4MIJ.cjs');
 var chunkVJKZWYYJ_cjs = require('./chunk-VJKZWYYJ.cjs');
-var chunk67OV5CX2_cjs = require('./chunk-67OV5CX2.cjs');
 var viem = require('viem');
 
 // src/fhe-airdrop/abis/cloneable.ts
@@ -1016,7 +1016,7 @@ var confidentialAirdropCloneableAbi = [
 ];
 
 // src/fhe-airdrop/errors.ts
-var AlreadyClaimedError = class extends chunk67OV5CX2_cjs.TokenOpsSdkError {
+var AlreadyClaimedError = class extends chunk2RNW4MIJ_cjs.TokenOpsSdkError {
   name = "AlreadyClaimedError";
   constructor(args) {
     const who = args.caller ? `${args.caller}: ` : "";
@@ -1031,7 +1031,7 @@ var AlreadyClaimedError = class extends chunk67OV5CX2_cjs.TokenOpsSdkError {
     });
   }
 };
-var ClaimNotStartedError = class extends chunk67OV5CX2_cjs.TokenOpsSdkError {
+var ClaimNotStartedError = class extends chunk2RNW4MIJ_cjs.TokenOpsSdkError {
   name = "ClaimNotStartedError";
   constructor(args) {
     const detail = args.startsAt !== void 0 ? ` Opens at unix timestamp ${args.startsAt}.` : "";
@@ -1046,7 +1046,7 @@ var ClaimNotStartedError = class extends chunk67OV5CX2_cjs.TokenOpsSdkError {
     });
   }
 };
-var ClaimWindowClosedError = class extends chunk67OV5CX2_cjs.TokenOpsSdkError {
+var ClaimWindowClosedError = class extends chunk2RNW4MIJ_cjs.TokenOpsSdkError {
   name = "ClaimWindowClosedError";
   constructor(args) {
     const detail = args.endedAt !== void 0 ? ` Closed at unix timestamp ${args.endedAt}.` : "";
@@ -1081,10 +1081,10 @@ var airdropProductMapper = (name, _args, ctx) => {
     case "ECDSAInvalidSignature":
     case "ECDSAInvalidSignatureS":
     case "ECDSAInvalidSignatureLength":
-      return new chunk67OV5CX2_cjs.InvalidSignatureError(ctx);
+      return new chunk2RNW4MIJ_cjs.InvalidSignatureError(ctx);
     case "ZeroBalance":
     case "InsufficientBalance":
-      return CONFIDENTIAL_POOL_BALANCE_METHODS.has(ctx.method) ? new chunk67OV5CX2_cjs.InsufficientBalanceError({ ...ctx, balanceKind: "confidential" }) : void 0;
+      return CONFIDENTIAL_POOL_BALANCE_METHODS.has(ctx.method) ? new chunk2RNW4MIJ_cjs.InsufficientBalanceError({ ...ctx, balanceKind: "confidential" }) : void 0;
     default:
       return void 0;
   }
@@ -1107,8 +1107,8 @@ var ConfidentialAirdropClient = class {
       surface: "client",
       chainId: chainIdForInit ?? null,
       hasWallet: !!this.walletClient,
-      aclResolved: !!config.aclAddress || chainIdForInit !== void 0 && !!chunkFAXIIH5R_cjs.getFhevmAclAddress(chainIdForInit),
-      sdkVersion: chunkKLKI352M_cjs.SDK_VERSION
+      aclResolved: !!config.aclAddress || chainIdForInit !== void 0 && !!chunkSYHNZSZZ_cjs.getFhevmAclAddress(chainIdForInit),
+      sdkVersion: chunk43RFBQ73_cjs.SDK_VERSION
     });
   }
   /**
@@ -1119,7 +1119,7 @@ var ConfidentialAirdropClient = class {
    */
   get aclAddress() {
     if (this.#cachedAclAddress) return this.#cachedAclAddress;
-    this.#cachedAclAddress = this.#aclAddressOverride ?? chunkFAXIIH5R_cjs.requireFhevmAclAddress(this.publicClient.chain?.id, "ConfidentialAirdropClient");
+    this.#cachedAclAddress = this.#aclAddressOverride ?? chunkSYHNZSZZ_cjs.requireFhevmAclAddress(this.publicClient.chain?.id, "ConfidentialAirdropClient");
     return this.#cachedAclAddress;
   }
   // ============================================================
@@ -1254,7 +1254,7 @@ var ConfidentialAirdropClient = class {
         account: args.caller
       });
     } catch (err) {
-      throw chunkKLKI352M_cjs.mapContractRevert(err, {
+      throw chunk43RFBQ73_cjs.mapContractRevert(err, {
         method: "isSignatureValid",
         contractAddress: this.address,
         abi: confidentialAirdropCloneableAbi,
@@ -1308,7 +1308,7 @@ var ConfidentialAirdropClient = class {
     ]);
     const now = Number(block.timestamp);
     if (isPaused) {
-      blockers.push(new chunk67OV5CX2_cjs.PausedError({ method: "claim", contractAddress: this.address }));
+      blockers.push(new chunk2RNW4MIJ_cjs.PausedError({ method: "claim", contractAddress: this.address }));
     }
     if (now < startTime) {
       blockers.push(
@@ -1339,7 +1339,7 @@ var ConfidentialAirdropClient = class {
     }
     if (callerBalance < gasFee) {
       blockers.push(
-        new chunk67OV5CX2_cjs.InsufficientFeeError({
+        new chunk2RNW4MIJ_cjs.InsufficientFeeError({
           method: "claim",
           contractAddress: this.address,
           feeKind: "gas",
@@ -1362,6 +1362,13 @@ var ConfidentialAirdropClient = class {
    *
    * **Silent-zero transfers.** ERC-7984 transfers do not revert when the sender's encrypted balance is insufficient — the transfer succeeds and moves an encrypted zero instead. This is by design: reverting would leak balance information. The transaction receipt alone cannot tell you whether value actually moved.
    *
+   * **An unfunded pool is the opposite case — it reverts loudly.** Do not
+   * generalize the silent-zero rule above to a clone whose pool was never
+   * funded: that claim throws {@link FheHandleNotAllowedError} (the FHEVM ACL
+   * rejects `FHE.allowTransient` on an uninitialized handle), and
+   * {@link preflightClaim} cannot detect it because the pool balance is an
+   * encrypted `euint64` the SDK cannot read in plaintext.
+   *
    * @returns Transaction hash.
    * @example
    * const fee = await airdrop.gasFee();
@@ -1435,12 +1442,12 @@ var ConfidentialAirdropClient = class {
     const aclLogs = receipt.logs.filter(
       (log) => log.address.toLowerCase() === this.aclAddress.toLowerCase()
     );
-    const events = viem.parseEventLogs({ abi: [chunkFAXIIH5R_cjs.ACL_ALLOWED_EVENT], logs: aclLogs });
+    const events = viem.parseEventLogs({ abi: [chunkSYHNZSZZ_cjs.ACL_ALLOWED_EVENT], logs: aclLogs });
     const granted = events.filter(
       (ev) => ev.args.account.toLowerCase() === callerAddress && ev.args.caller.toLowerCase() === this.address.toLowerCase()
     );
     if (granted.length === 0) {
-      throw new chunk67OV5CX2_cjs.ReceiptEventNotFoundError({
+      throw new chunk2RNW4MIJ_cjs.ReceiptEventNotFoundError({
         method: "getClaimAmount",
         eventName: "Allowed",
         contractAddress: this.aclAddress,
@@ -1449,7 +1456,7 @@ var ConfidentialAirdropClient = class {
       });
     }
     if (granted.length > 1) {
-      throw new chunk67OV5CX2_cjs.ReceiptEventAmbiguousError({
+      throw new chunk2RNW4MIJ_cjs.ReceiptEventAmbiguousError({
         method: "getClaimAmount",
         eventName: "Allowed",
         contractAddress: this.aclAddress,
@@ -1537,7 +1544,7 @@ var ConfidentialAirdropClient = class {
   // ============================================================
   #requireChecksumAddress(method, argument, value) {
     if (!viem.isAddress(value, { strict: true })) {
-      throw new chunk67OV5CX2_cjs.InvalidArgumentError({
+      throw new chunk2RNW4MIJ_cjs.InvalidArgumentError({
         method,
         argument,
         reason: "must be a valid EIP-55 checksummed address",
@@ -1547,14 +1554,14 @@ var ConfidentialAirdropClient = class {
   }
   #requireWallet(method) {
     if (!this.walletClient) {
-      throw new chunk67OV5CX2_cjs.MissingWalletClientError(method);
+      throw new chunk2RNW4MIJ_cjs.MissingWalletClientError(method);
     }
     return this.walletClient;
   }
   #resolveAccount(wallet, override, method) {
     const acct = override ?? wallet.account;
     if (!acct) {
-      throw new chunk67OV5CX2_cjs.MissingAccountError(method);
+      throw new chunk2RNW4MIJ_cjs.MissingAccountError(method);
     }
     if (typeof acct === "string") {
       this.#requireChecksumAddress(method, "account", acct);
@@ -1562,7 +1569,7 @@ var ConfidentialAirdropClient = class {
     return acct;
   }
   #mapRevert(method, err, account) {
-    return chunkKLKI352M_cjs.mapContractRevert(err, {
+    return chunk43RFBQ73_cjs.mapContractRevert(err, {
       method,
       contractAddress: this.address,
       abi: confidentialAirdropCloneableAbi,
@@ -1607,7 +1614,7 @@ var ConfidentialAirdropClient = class {
         ...value !== void 0 ? { value } : {}
       });
     } catch (err) {
-      if (chunkKLKI352M_cjs.isContractRevert(err)) {
+      if (chunk43RFBQ73_cjs.isContractRevert(err)) {
         throw this.#mapRevert(method, err, accountAddress(account));
       }
     }

package/dist/{chunk-FAXIIH5R.cjs → chunk-SYHNZSZZ.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunk67OV5CX2_cjs = require('./chunk-67OV5CX2.cjs');
+var chunk2RNW4MIJ_cjs = require('./chunk-2RNW4MIJ.cjs');
 var viem = require('viem');
 
 var FHEVM_ACL_ADDRESS_BY_CHAIN = {
@@ -16,7 +16,7 @@ function getFhevmAclAddress(chainId) {
 }
 function requireFhevmAclAddress(chainId, clientLabel) {
   if (chainId === void 0) {
-    throw new chunk67OV5CX2_cjs.DeploymentAddressUnavailableError({
+    throw new chunk2RNW4MIJ_cjs.DeploymentAddressUnavailableError({
       reason: "chain-id-missing",
       product: "fhevm",
       contract: "acl",
@@ -26,7 +26,7 @@ function requireFhevmAclAddress(chainId, clientLabel) {
   }
   const addr = FHEVM_ACL_ADDRESS_BY_CHAIN[chainId];
   if (addr) return addr;
-  throw new chunk67OV5CX2_cjs.DeploymentAddressUnavailableError({
+  throw new chunk2RNW4MIJ_cjs.DeploymentAddressUnavailableError({
     reason: "registry-unknown-chain",
     product: "fhevm",
     contract: "acl",

package/dist/{chunk-IXLO7GO5.js → chunk-TN65XNTI.js}

@@ -1,13 +1,12 @@
-import { mapZamaError } from './chunk-WMACINXO.js';
-import { scaleRatio } from './chunk-AOP6HMPW.js';
-import { getFhevmAclAddress, requireFhevmAclAddress, ACL_ALLOWED_EVENT } from './chunk-ZWXJTBZO.js';
+import { mapZamaError } from './chunk-NFW7AUEX.js';
+import { resolveEncryptor, encryptUint64Batch, scaleRatio, encryptUint64 } from './chunk-PD7ME2BT.js';
+import { getFhevmAclAddress, requireFhevmAclAddress, ACL_ALLOWED_EVENT } from './chunk-YPYCWLYP.js';
 import { erc7984OperatorAbi } from './chunk-7VELUOMI.js';
-import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-SG65XWH7.js';
-import { normaliseAddress } from './chunk-ZA673I3O.js';
+import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-6WSNS3UV.js';
+import { normaliseAddress } from './chunk-46T67CE2.js';
+import { TokenOpsSdkError, PausedError, InsufficientFeeError, AccessDeniedError, InvalidArgumentError, OperatorNotApprovedError, MissingEncryptorError, ReceiptEventNotFoundError, ReceiptEventAmbiguousError, MissingWalletClientError, MissingAccountError, asEncryptedHandle, asTxHash } from './chunk-DRSPMIZ7.js';
 import { withTelemetry } from './chunk-Q2GP5UDC.js';
-import { asExternalInputProof, asEncryptedHandle, asTxHash } from './chunk-KWFFIJYX.js';
-import { InvalidArgumentError, TokenOpsSdkError, PausedError, InsufficientFeeError, AccessDeniedError, OperatorNotApprovedError, MissingEncryptorError, ReceiptEventNotFoundError, ReceiptEventAmbiguousError, MissingWalletClientError, MissingAccountError } from './chunk-QBJ7O2B4.js';
-import { bytesToHex, parseEventLogs, isAddress } from 'viem';
+import { parseEventLogs, isAddress, BaseError, ContractFunctionZeroDataError } from 'viem';
 
 // src/fhe-vesting/abis/manager.ts
 var confidentialVestingManagerAbi = [
@@ -987,78 +986,6 @@ var confidentialVestingManagerAbi = [
     type: "function"
   }
 ];
-function resolveEncryptor(source) {
-  if (source === void 0) return void 0;
-  return typeof source === "function" ? source() : source;
-}
-var MAX_UINT64 = (1n << 64n) - 1n;
-function assertUint64(value, label) {
-  if (value < 0n || value > MAX_UINT64) {
-    throw new InvalidArgumentError({
-      method: "encryptUint64",
-      argument: label,
-      reason: `does not fit in uint64 (0..2^64-1)`,
-      value
-    });
-  }
-}
-async function encryptUint64({
-  encryptor,
-  contractAddress,
-  userAddress,
-  value
-}) {
-  assertUint64(value, "value");
-  const { handles, inputProof } = await encryptor.encrypt({
-    values: [{ value, type: "euint64" }],
-    contractAddress,
-    userAddress
-  });
-  if (handles.length !== 1) {
-    throw new InvalidArgumentError({
-      method: "encryptUint64",
-      argument: "handles",
-      reason: `expected 1 handle, got ${handles.length}`,
-      value: handles.length
-    });
-  }
-  return {
-    handle: asEncryptedHandle(bytesToHex(handles[0])),
-    inputProof: asExternalInputProof(bytesToHex(inputProof))
-  };
-}
-async function encryptUint64Batch({
-  encryptor,
-  contractAddress,
-  userAddress,
-  values
-}) {
-  if (values.length === 0) {
-    throw new InvalidArgumentError({
-      method: "encryptUint64Batch",
-      argument: "values",
-      reason: "must be non-empty"
-    });
-  }
-  values.forEach((v, i) => assertUint64(v, `values[${i}]`));
-  const { handles, inputProof } = await encryptor.encrypt({
-    values: values.map((value) => ({ value, type: "euint64" })),
-    contractAddress,
-    userAddress
-  });
-  if (handles.length !== values.length) {
-    throw new InvalidArgumentError({
-      method: "encryptUint64Batch",
-      argument: "handles",
-      reason: `expected ${values.length} handles, got ${handles.length}`,
-      value: handles.length
-    });
-  }
-  return {
-    handles: handles.map((h) => asEncryptedHandle(bytesToHex(h))),
-    inputProof: asExternalInputProof(bytesToHex(inputProof))
-  };
-}
 
 // src/fhe-vesting/errors.ts
 var VestingNotFoundError = class extends TokenOpsSdkError {
@@ -1554,6 +1481,11 @@ var ConfidentialVestingManagerClient = class {
    * - Operator: creator has approved this manager as an ERC-7984 operator on
    *   the distribution token, required for the manager's
    *   `confidentialTransferFrom` pull ({@link OperatorNotApprovedError} blocker).
+   *   If the bound `token` does not implement the ERC-7984 `isOperator`
+   *   view — a revert, or a zero-data response for an EOA / undeployed
+   *   address — operator status is undetermined rather than the call
+   *   throwing: `isOperatorSet` reports `false` and the read failure becomes
+   *   an {@link InvalidArgumentError} blocker on `token` instead (TOK-436).
    *
    * **Not preflight-detectable — read before trusting `ready: true`:**
    * - The creator's confidential token balance is an encrypted `euint64` the
@@ -1585,15 +1517,19 @@ var ConfidentialVestingManagerClient = class {
       this.token(),
       this.#read("VESTING_CREATOR_ROLE")
     ]);
-    const [hasCreatorRole, isOperatorSet] = await Promise.all([
+    const [hasCreatorRole, operatorRead] = await Promise.all([
       this.hasRole(creatorRole, args.creator),
       this.publicClient.readContract({
         address: token,
         abi: erc7984OperatorAbi,
         functionName: "isOperator",
         args: [args.creator, this.address]
+      }).then((v) => ({ ok: true, value: v })).catch((err) => {
+        if (isNotErc7984Failure(err)) return { ok: false, err };
+        throw err;
       })
     ]);
+    const isOperatorSet = operatorRead.ok ? operatorRead.value : false;
     if (!hasCreatorRole) {
       pushBlocker(
         new AccessDeniedError({
@@ -1604,7 +1540,16 @@ var ConfidentialVestingManagerClient = class {
         })
       );
     }
-    if (!isOperatorSet) {
+    if (!operatorRead.ok) {
+      pushBlocker(
+        new InvalidArgumentError({
+          method: "createVesting",
+          argument: "token",
+          reason: "does not implement the ERC-7984 `isOperator(address,address)` view \u2014 it is not a confidential token (or the address holds no contract on this chain)",
+          value: token
+        })
+      );
+    } else if (!isOperatorSet) {
       pushBlocker(
         new OperatorNotApprovedError({
           method: "createVesting",
@@ -1697,6 +1642,13 @@ var ConfidentialVestingManagerClient = class {
    * for the CTTT test token (6 decimals) `1_000_000n` = 1 CTTT, while the
    * transparent TTT test token uses 18 decimals.
    *
+   * Prerequisites: caller must have set this manager as an operator on the
+   * token: `token.setOperator(managerAddress, deadline)` — or use
+   * `ensureOperator()` from `@tokenops/sdk/fhe`. Skipping it fails with
+   * {@link OperatorNotApprovedError} (the SDK's mapping of the on-chain
+   * `ERC7984UnauthorizedSpender` revert, whose message is the canonical
+   * `OPERATOR_NOT_APPROVED_REMEDIATION` copy).
+   *
    * @returns Transaction hash. Parse the `VestingCreated` event to extract the `vestingId`.
    * @example
    * const hash = await manager.createVesting({
@@ -1746,6 +1698,13 @@ var ConfidentialVestingManagerClient = class {
    * for the CTTT test token (6 decimals) `1_000_000n` = 1 CTTT, while the
    * transparent TTT test token uses 18 decimals.
    *
+   * Prerequisites: caller must have set this manager as an operator on the
+   * token: `token.setOperator(managerAddress, deadline)` — or use
+   * `ensureOperator()` from `@tokenops/sdk/fhe`. Skipping it fails with
+   * {@link OperatorNotApprovedError} (the SDK's mapping of the on-chain
+   * `ERC7984UnauthorizedSpender` revert, whose message is the canonical
+   * `OPERATOR_NOT_APPROVED_REMEDIATION` copy).
+   *
    * @returns Transaction hash.
    */
   async batchCreateVesting(args) {
@@ -2858,6 +2817,11 @@ var ConfidentialVestingManagerClient = class {
 function createConfidentialVestingManagerClient(config) {
   return new ConfidentialVestingManagerClient(config);
 }
+function isNotErc7984Failure(err) {
+  if (isContractRevert(err)) return true;
+  if (!(err instanceof BaseError)) return false;
+  return err.walk((e) => e instanceof ContractFunctionZeroDataError) instanceof ContractFunctionZeroDataError;
+}
 function accountAddress(account) {
   return typeof account === "string" ? account : account.address;
 }
@@ -2915,4 +2879,4 @@ function collectVestingParamsErrors(params, where) {
   return errors;
 }
 
-export { ClaimLockedError, ConfidentialVestingManagerClient, NoPendingTransferError, NotPendingRecipientError, NotVestingRecipientError, TransferAlreadyPendingError, TransferExpiredError, VestingExpiredError, VestingNotFoundError, VestingNotRevocableError, VestingRevokedError, confidentialVestingManagerAbi, createConfidentialVestingManagerClient, encryptUint64, encryptUint64Batch, resolveEncryptor };
+export { ClaimLockedError, ConfidentialVestingManagerClient, NoPendingTransferError, NotPendingRecipientError, NotVestingRecipientError, TransferAlreadyPendingError, TransferExpiredError, VestingExpiredError, VestingNotFoundError, VestingNotRevocableError, VestingRevokedError, confidentialVestingManagerAbi, createConfidentialVestingManagerClient };

package/dist/chunk-U57COLUE.js

@@ -0,0 +1,56 @@
+import { useWagmiAccount } from './chunk-FT4LNBOS.js';
+import { isOperator, ensureOperator } from './chunk-4KJ66YRH.js';
+import { MissingPublicClientError, MissingWalletClientError } from './chunk-DRSPMIZ7.js';
+import { useQuery, useMutation } from '@tanstack/react-query';
+import { usePublicClient, useWalletClient } from 'wagmi';
+
+function useIsOperator(options = {}) {
+  const publicClient = usePublicClient({ chainId: options.chainId });
+  const { address: connected } = useWagmiAccount();
+  const chainId = options.chainId ?? publicClient?.chain?.id;
+  const holder = options.holder ?? connected;
+  const { token, spender, telemetry } = options;
+  return useQuery({
+    queryKey: [
+      "tokenops-sdk",
+      "fhe",
+      "isOperator",
+      chainId ?? null,
+      token ? token.toLowerCase() : null,
+      holder ? holder.toLowerCase() : null,
+      spender ? spender.toLowerCase() : null
+    ],
+    queryFn: () => isOperator({
+      publicClient,
+      token,
+      holder,
+      spender,
+      ...telemetry ? { telemetry } : {}
+    }),
+    enabled: !!publicClient && !!token && !!holder && !!spender && options.enabled !== false,
+    staleTime: 0
+  });
+}
+function useEnsureOperator(options = {}) {
+  const publicClient = usePublicClient({ chainId: options.chainId });
+  const { data: walletClient } = useWalletClient({ chainId: options.chainId });
+  const telemetry = options.telemetry;
+  return useMutation({
+    mutationFn: async (vars) => {
+      if (!publicClient) throw new MissingPublicClientError("useEnsureOperator");
+      if (!walletClient) throw new MissingWalletClientError("useEnsureOperator");
+      return ensureOperator({
+        publicClient,
+        walletClient,
+        token: vars.token,
+        spender: vars.spender,
+        deadline: vars.deadline,
+        ...vars.account !== void 0 ? { account: vars.account } : {},
+        ...vars.waitForReceipt !== void 0 ? { waitForReceipt: vars.waitForReceipt } : {},
+        ...telemetry ? { telemetry } : {}
+      });
+    }
+  });
+}
+
+export { useEnsureOperator, useIsOperator };

package/dist/{chunk-DUZIIRPF.js → chunk-UE5XK2SY.js}

@@ -1,11 +1,10 @@
 import { erc7984OperatorAbi } from './chunk-7VELUOMI.js';
-import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-SG65XWH7.js';
-import { getFheAirdropFactoryAddress } from './chunk-XGGTQQFH.js';
-import { normaliseAddress } from './chunk-ZA673I3O.js';
+import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-6WSNS3UV.js';
+import { getFheAirdropFactoryAddress } from './chunk-QKKBBH7I.js';
+import { normaliseAddress } from './chunk-46T67CE2.js';
+import { InvalidArgumentError, asExternalInputProof, asEncryptedHandle, TokenOpsSdkError, MissingAccountError, asSignature, DeploymentAddressUnavailableError, OperatorNotApprovedError, AlreadyInitializedError, asTxHash, MissingWalletClientError, MissingEncryptorError } from './chunk-DRSPMIZ7.js';
 import { withTelemetry } from './chunk-Q2GP5UDC.js';
-import { asExternalInputProof, asEncryptedHandle, asSignature, asTxHash } from './chunk-KWFFIJYX.js';
-import { InvalidArgumentError, TokenOpsSdkError, MissingAccountError, DeploymentAddressUnavailableError, OperatorNotApprovedError, AlreadyInitializedError, MissingWalletClientError, MissingEncryptorError } from './chunk-QBJ7O2B4.js';
-import { bytesToHex, isAddress, parseEventLogs } from 'viem';
+import { bytesToHex, isAddress, parseEventLogs, BaseError, ContractFunctionZeroDataError } from 'viem';
 
 // src/fhe-airdrop/abis/factory.ts
 var confidentialAirdropFactoryAbi = [
@@ -1434,7 +1433,7 @@ var ConfidentialAirdropFactoryClient = class {
         })
       );
     }
-    const [block, customFee, defaultFee, isFactoryOperator] = await Promise.all([
+    const [block, customFee, defaultFee, operatorRead] = await Promise.all([
       this.publicClient.getBlock(),
       this.getCustomFee(creator),
       this.defaultGasFee(),
@@ -1443,8 +1442,22 @@ var ConfidentialAirdropFactoryClient = class {
         abi: erc7984OperatorAbi,
         functionName: "isOperator",
         args: [creator, this.address]
-      }) : Promise.resolve(false)
+      }).then((v) => ({ ok: true, value: v })).catch((err) => {
+        if (isNotErc7984Failure(err)) return { ok: false, err };
+        throw err;
+      }) : Promise.resolve({ ok: true, value: false })
     ]);
+    const isFactoryOperator = operatorRead.ok ? operatorRead.value : false;
+    if (!operatorRead.ok) {
+      pushBlocker(
+        new InvalidArgumentError({
+          method: "createConfidentialAirdrop",
+          argument: "params.token",
+          reason: "does not implement the ERC-7984 `isOperator(address,address)` view \u2014 it is not a confidential token (or the address holds no contract on this chain)",
+          value: params.token
+        })
+      );
+    }
     const gasFee = customFee.enabled ? customFee.gasFee : defaultFee;
     if (params.endTimestamp <= Number(block.timestamp)) {
       pushBlocker(
@@ -1456,7 +1469,7 @@ var ConfidentialAirdropFactoryClient = class {
         })
       );
     }
-    if (funding === true && !isFactoryOperator) {
+    if (funding === true && tokenOk && operatorRead.ok && !isFactoryOperator) {
       pushBlocker(
         new OperatorNotApprovedError({
           method: "createAndFundConfidentialAirdrop",
@@ -1638,6 +1651,11 @@ var ConfidentialAirdropFactoryClient = class {
 function createConfidentialAirdropFactoryClient(config) {
   return new ConfidentialAirdropFactoryClient(config);
 }
+function isNotErc7984Failure(err) {
+  if (isContractRevert(err)) return true;
+  if (!(err instanceof BaseError)) return false;
+  return err.walk((e) => e instanceof ContractFunctionZeroDataError) instanceof ContractFunctionZeroDataError;
+}
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 function accountAddress(account) {
   return typeof account === "string" ? account : account.address;