@tokenops/sdk 1.1.1 → 1.6.0

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

@@ -1,10 +1,10 @@
-import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-JFLEEXKP.js';
-import { getFheAirdropFactoryAddress } from './chunk-M7V2EDPB.js';
-import { normaliseAddress } from './chunk-BE2AIZ3K.js';
+import { erc7984OperatorAbi } from './chunk-7VELUOMI.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, MissingWalletClientError, MissingEncryptorError } from './chunk-IVE3QEGD.js';
-import { bytesToHex, parseEventLogs } from 'viem';
+import { bytesToHex, isAddress, parseEventLogs, BaseError, ContractFunctionZeroDataError } from 'viem';
 
 // src/fhe-airdrop/abis/factory.ts
 var confidentialAirdropFactoryAbi = [
@@ -1116,6 +1116,14 @@ var ConfidentialAirdropFactoryClient = class {
    * Prerequisites: caller must have set this factory as an operator on the
    * token: `token.setOperator(factoryAddress, deadline)`.
    *
+   * **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.
+   *
+   * **Amount units:** TokenOps confidential (ERC-7984) tokens use a 6-decimals
+   * convention (1 token = 1_000_000 base units), not the 18 decimals typical of
+   * ERC-20. Amount parameters are base units of the token's actual decimals:
+   * for the CTTT test token (6 decimals) `1_000_000n` = 1 CTTT, while the
+   * transparent TTT test token uses 18 decimals.
+   *
    * Symmetric with {@link ConfidentialAirdropFactoryClient.createConfidentialAirdrop}
    * — both return `{ hash, airdrop }` parsed from the
    * `ConfidentialAirdropCreated` event.
@@ -1178,6 +1186,14 @@ var ConfidentialAirdropFactoryClient = class {
    * Prerequisites: caller must have set this factory as an operator on the token:
    * `token.setOperator(factoryAddress, deadline)`
    *
+   * **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.
+   *
+   * **Amount units:** TokenOps confidential (ERC-7984) tokens use a 6-decimals
+   * convention (1 token = 1_000_000 base units), not the 18 decimals typical of
+   * ERC-20. Amount parameters are base units of the token's actual decimals:
+   * for the CTTT test token (6 decimals) `1_000_000n` = 1 CTTT, while the
+   * transparent TTT test token uses 18 decimals.
+   *
    * @returns Transaction hash.
    */
   async fundConfidentialAirdrop(args) {
@@ -1247,6 +1263,14 @@ var ConfidentialAirdropFactoryClient = class {
    * Symmetry with {@link ConfidentialAirdropFactoryClient.createConfidentialAirdropAndGetAddress}
    * — use this when you also need to seed the pool in the same transaction.
    *
+   * **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.
+   *
+   * **Amount units:** TokenOps confidential (ERC-7984) tokens use a 6-decimals
+   * convention (1 token = 1_000_000 base units), not the 18 decimals typical of
+   * ERC-20. Amount parameters are base units of the token's actual decimals:
+   * for the CTTT test token (6 decimals) `1_000_000n` = 1 CTTT, while the
+   * transparent TTT test token uses 18 decimals.
+   *
    * Internally: {@link ConfidentialAirdropFactoryClient.createAndFundConfidentialAirdrop} →
    * {@link PublicClient.waitForTransactionReceipt} →
    * `parseEventLogs({ eventName: "ConfidentialAirdropCreated" })`.
@@ -1329,6 +1353,163 @@ var ConfidentialAirdropFactoryClient = class {
   async getInitCodeHash(args) {
     return this.#read("getInitCodeHash", [toAbiParams(args.params), args.gasFee]);
   }
+  // ----------------------- preflight -----------------------
+  /**
+   * Read-only preflight for {@link createConfidentialAirdrop} /
+   * {@link createAndFundConfidentialAirdrop}. Runs the
+   * deterministic-from-off-chain checks and reports blockers both as
+   * human-readable strings (`blockers`) and as typed {@link TokenOpsSdkError}s
+   * (`blockerErrors`), index-aligned.
+   *
+   * Preflight is **opt-in**. Consumers who have already validated state can
+   * skip this call and invoke the write directly — they'll receive the same
+   * typed errors at write time via the revert mapper.
+   *
+   * Report fields: `isFactoryOperator`, `gasFee`, `predictedAirdrop`,
+   * `alreadyDeployed`, `ready`, `blockers`, `blockerErrors` — see
+   * {@link CreateAirdropPreflightReport} for the meaning of each.
+   *
+   * Checks performed (all read-only, no gas):
+   * - Structural `params` validation mirroring the factory + clone
+   *   `initialize` requirements (`InvalidArgumentError` blockers): `token` and
+   *   `admin` are checksummed non-zero addresses,
+   *   `startTimestamp < endTimestamp`, and `endTimestamp` is in the future
+   *   (the clone's `initialize` reverts with `EndTimeInPast`).
+   * - Operator: creator has approved this factory as an ERC-7984 operator on
+   *   `params.token` — a blocker only when `funding: true`
+   *   ({@link OperatorNotApprovedError}); otherwise informational via
+   *   `isFactoryOperator`.
+   * - Collision (only when `userSalt` is supplied): bytecode already at the
+   *   predicted CREATE2 address means a repeat create with the same
+   *   `(params, userSalt, gasFee)` would revert
+   *   ({@link AlreadyInitializedError} blocker).
+   *
+   * **Not preflight-detectable — read before trusting `ready: true`:** the
+   * creator's confidential token balance is an encrypted `euint64` the SDK
+   * cannot read in plaintext, and an underfunded `createAndFund` does **not**
+   * revert — the ERC-7984 transfer silently moves an encrypted zero. Confirm
+   * the creator's balance covers the pool before submitting.
+   *
+   * @param args See {@link PreflightCreateAirdropArgs}.
+   * @returns A {@link CreateAirdropPreflightReport}.
+   */
+  async preflightCreateAirdrop(args) {
+    const { params, creator, userSalt, funding } = args;
+    const blockers = [];
+    const blockerErrors = [];
+    const pushBlocker = (err) => {
+      blockerErrors.push(err);
+      blockers.push(err.message);
+    };
+    const tokenOk = isAddress(params.token, { strict: true }) && params.token !== ZERO_ADDRESS;
+    if (!tokenOk) {
+      pushBlocker(
+        new InvalidArgumentError({
+          method: "createConfidentialAirdrop",
+          argument: "params.token",
+          reason: "must be a valid, non-zero EIP-55 checksummed address",
+          value: params.token
+        })
+      );
+    }
+    const adminOk = isAddress(params.admin, { strict: true }) && params.admin !== ZERO_ADDRESS;
+    if (!adminOk) {
+      pushBlocker(
+        new InvalidArgumentError({
+          method: "createConfidentialAirdrop",
+          argument: "params.admin",
+          reason: "must be a valid, non-zero EIP-55 checksummed address",
+          value: params.admin
+        })
+      );
+    }
+    if (params.startTimestamp >= params.endTimestamp) {
+      pushBlocker(
+        new InvalidArgumentError({
+          method: "createConfidentialAirdrop",
+          argument: "params.startTimestamp/params.endTimestamp",
+          reason: "startTimestamp must be strictly less than endTimestamp",
+          value: { startTimestamp: params.startTimestamp, endTimestamp: params.endTimestamp }
+        })
+      );
+    }
+    const [block, customFee, defaultFee, operatorRead] = await Promise.all([
+      this.publicClient.getBlock(),
+      this.getCustomFee(creator),
+      this.defaultGasFee(),
+      tokenOk ? this.publicClient.readContract({
+        address: params.token,
+        abi: erc7984OperatorAbi,
+        functionName: "isOperator",
+        args: [creator, this.address]
+      }).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(
+        new InvalidArgumentError({
+          method: "createConfidentialAirdrop",
+          argument: "params.endTimestamp",
+          reason: "must be in the future (the clone's initialize reverts with EndTimeInPast)",
+          value: params.endTimestamp
+        })
+      );
+    }
+    if (funding === true && tokenOk && operatorRead.ok && !isFactoryOperator) {
+      pushBlocker(
+        new OperatorNotApprovedError({
+          method: "createAndFundConfidentialAirdrop",
+          contractAddress: this.address,
+          tokenAddress: params.token,
+          holder: creator,
+          spender: this.address
+        })
+      );
+    }
+    let predictedAirdrop;
+    let alreadyDeployed;
+    if (userSalt !== void 0 && tokenOk && adminOk) {
+      predictedAirdrop = await this.#read("predictAirdropAddress", [
+        toAbiParams(params),
+        userSalt,
+        creator,
+        gasFee
+      ]);
+      const bytecode = await this.publicClient.getCode({ address: predictedAirdrop });
+      alreadyDeployed = bytecode !== void 0 && bytecode !== "0x";
+      if (alreadyDeployed) {
+        pushBlocker(
+          new AlreadyInitializedError({
+            method: "createConfidentialAirdrop",
+            contractAddress: predictedAirdrop
+          })
+        );
+      }
+    }
+    return {
+      isFactoryOperator,
+      gasFee,
+      predictedAirdrop,
+      alreadyDeployed,
+      ready: blockers.length === 0,
+      blockers,
+      blockerErrors
+    };
+  }
   // ----------------------- internals -----------------------
   /**
    * Wait for the receipt of a clone-deploy tx and parse the
@@ -1470,6 +1651,12 @@ 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;
 }

package/dist/{chunk-NS44KBV5.cjs → chunk-UJS4N2XM.cjs}

@@ -1,29 +1,29 @@
 'use strict';
 
-var chunk56UI7LUR_cjs = require('./chunk-56UI7LUR.cjs');
+var chunk2RNW4MIJ_cjs = require('./chunk-2RNW4MIJ.cjs');
 
 // src/core/zama-error-mapper.ts
 function mapZamaError(error, args) {
-  if (error instanceof chunk56UI7LUR_cjs.TokenOpsSdkError) return error;
+  if (error instanceof chunk2RNW4MIJ_cjs.TokenOpsSdkError) return error;
   const zama = readZamaError(error);
   if (zama?.code) {
     switch (zama.code) {
       case "SIGNING_REJECTED":
-        return new chunk56UI7LUR_cjs.UserRejectedSignatureError({ ...args, cause: error });
+        return new chunk2RNW4MIJ_cjs.UserRejectedSignatureError({ ...args, cause: error });
       case "SIGNING_FAILED":
-        return new chunk56UI7LUR_cjs.SigningFailedError({ ...args, cause: error });
+        return new chunk2RNW4MIJ_cjs.SigningFailedError({ ...args, cause: error });
       case "RELAYER_REQUEST_FAILED":
-        return new chunk56UI7LUR_cjs.RelayerUnreachableError({
+        return new chunk2RNW4MIJ_cjs.RelayerUnreachableError({
           ...args,
           statusCode: zama.statusCode,
           cause: error
         });
       case "ENCRYPTION_FAILED":
-        return new chunk56UI7LUR_cjs.EncryptionFailedError({ ...args, cause: error });
+        return new chunk2RNW4MIJ_cjs.EncryptionFailedError({ ...args, cause: error });
       case "DECRYPTION_FAILED":
-        return new chunk56UI7LUR_cjs.DecryptionFailedError({ ...args, cause: error });
+        return new chunk2RNW4MIJ_cjs.DecryptionFailedError({ ...args, cause: error });
       case "CONFIGURATION":
-        return new chunk56UI7LUR_cjs.InvalidArgumentError({
+        return new chunk2RNW4MIJ_cjs.InvalidArgumentError({
           method: args.method,
           argument: "config",
           reason: "Zama SDK configuration is invalid (chain id, type, or signer state).",
@@ -34,13 +34,13 @@ function mapZamaError(error, args) {
   const message = readMessage(error);
   if (message) {
     if (USER_REJECTION_PATTERNS.some((pat) => pat.test(message))) {
-      return new chunk56UI7LUR_cjs.UserRejectedSignatureError({ ...args, cause: error });
+      return new chunk2RNW4MIJ_cjs.UserRejectedSignatureError({ ...args, cause: error });
     }
     if (USER_DECRYPT_NOT_ALLOWED_PATTERNS.some((pat) => pat.test(message))) {
-      return new chunk56UI7LUR_cjs.UserDecryptNotAllowedError({ method: args.method, cause: error });
+      return new chunk2RNW4MIJ_cjs.UserDecryptNotAllowedError({ method: args.method, cause: error });
     }
     if (INVALID_INPUT_PATTERNS.some((pat) => pat.test(message))) {
-      return new chunk56UI7LUR_cjs.InvalidArgumentError({
+      return new chunk2RNW4MIJ_cjs.InvalidArgumentError({
         method: args.method,
         argument: "input",
         reason: "encrypted input value rejected by FHE SDK \u2014 see `error.cause` for details",
@@ -48,7 +48,7 @@ function mapZamaError(error, args) {
       });
     }
   }
-  return args.operation === "encrypt" ? new chunk56UI7LUR_cjs.EncryptionFailedError({ ...args, cause: error }) : new chunk56UI7LUR_cjs.DecryptionFailedError({ ...args, cause: error });
+  return args.operation === "encrypt" ? new chunk2RNW4MIJ_cjs.EncryptionFailedError({ ...args, cause: error }) : new chunk2RNW4MIJ_cjs.DecryptionFailedError({ ...args, cause: error });
 }
 function readZamaError(err) {
   if (typeof err !== "object" || err === null) return void 0;

package/dist/{chunk-IR5AK5U5.js → chunk-V5D7BHW3.js}

@@ -1,9 +1,8 @@
-import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-JFLEEXKP.js';
-import { getFheVestingFactoryAddress } from './chunk-M7V2EDPB.js';
-import { normaliseAddress } from './chunk-BE2AIZ3K.js';
+import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-6WSNS3UV.js';
+import { getFheVestingFactoryAddress } from './chunk-QKKBBH7I.js';
+import { normaliseAddress } from './chunk-46T67CE2.js';
+import { DeploymentAddressUnavailableError, TokenOpsSdkError, asTxHash, MissingWalletClientError, MissingAccountError } from './chunk-DRSPMIZ7.js';
 import { withTelemetry } from './chunk-Q2GP5UDC.js';
-import { asTxHash } from './chunk-KWFFIJYX.js';
-import { DeploymentAddressUnavailableError, TokenOpsSdkError, MissingWalletClientError, MissingAccountError } from './chunk-IVE3QEGD.js';
 import { parseEventLogs } from 'viem';
 
 // src/fhe-vesting/abis/factory.ts

package/dist/{chunk-3PQ2RFPC.js → chunk-VHSNYUYV.js}

@@ -1,7 +1,8 @@
-import { createConfidentialVestingManagerClient, resolveEncryptor } from './chunk-X56UVEXS.js';
-import { createConfidentialVestingFactoryClient } from './chunk-IR5AK5U5.js';
-import { getFheVestingFactoryAddress } from './chunk-M7V2EDPB.js';
-import { DeploymentAddressUnavailableError } from './chunk-IVE3QEGD.js';
+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 { useMemo, useRef, useEffect } from 'react';
 import { usePublicClient, useWalletClient } from 'wagmi';
 

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

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

package/dist/{chunk-G7G75C46.cjs → chunk-WO72UBQD.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunk5SA2HF2W_cjs = require('./chunk-5SA2HF2W.cjs');
-var chunkSYHXDHWX_cjs = require('./chunk-SYHXDHWX.cjs');
-var chunk3ZRHDTEX_cjs = require('./chunk-3ZRHDTEX.cjs');
-var chunk56UI7LUR_cjs = require('./chunk-56UI7LUR.cjs');
+var chunkSPGSO5SO_cjs = require('./chunk-SPGSO5SO.cjs');
+var chunkLBWRFZR3_cjs = require('./chunk-LBWRFZR3.cjs');
+var chunkWUXUWTFW_cjs = require('./chunk-WUXUWTFW.cjs');
+var chunk2RNW4MIJ_cjs = require('./chunk-2RNW4MIJ.cjs');
 var react = require('react');
 var wagmi = require('wagmi');
 
@@ -12,7 +12,7 @@ var FHE_AIRDROP_NAMESPACE = "fhe-airdrop";
 function tryResolveFactoryAddress(override, chainId) {
   if (override) return override;
   if (chainId === void 0) return void 0;
-  return chunk3ZRHDTEX_cjs.getFheAirdropFactoryAddress(chainId);
+  return chunkWUXUWTFW_cjs.getFheAirdropFactoryAddress(chainId);
 }
 function useMemoFactoryClient(opts = {}) {
   const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
@@ -25,14 +25,14 @@ function useMemoFactoryClient(opts = {}) {
   const client = react.useMemo(() => {
     if (!publicClient) return void 0;
     if (!resolvedAddress) return void 0;
-    return chunkSYHXDHWX_cjs.createConfidentialAirdropFactoryClient({
+    return chunkLBWRFZR3_cjs.createConfidentialAirdropFactoryClient({
       publicClient,
       ...walletClient ? { walletClient } : {},
       address: resolvedAddress,
       ...chainId !== void 0 ? { chainId } : {},
       // Lazy — invoked per-encryption inside the headless client. Picks up
       // whichever EncryptorSource the consumer last passed in.
-      encryptor: () => chunkSYHXDHWX_cjs.resolveEncryptor(encryptorSourceRef.current)
+      encryptor: () => chunkLBWRFZR3_cjs.resolveEncryptor(encryptorSourceRef.current)
     });
   }, [publicClient, walletClient, resolvedAddress, chainId]);
   return {
@@ -47,16 +47,16 @@ function useMemoFactoryClient(opts = {}) {
 function computeFactoryResolutionError(override, chainId) {
   if (override) return void 0;
   if (chainId === void 0) {
-    return new chunk56UI7LUR_cjs.DeploymentAddressUnavailableError({
+    return new chunk2RNW4MIJ_cjs.DeploymentAddressUnavailableError({
       reason: "chain-id-missing",
       product: "fheAirdrop",
       contract: "confidentialAirdropFactory",
       clientLabel: "ConfidentialAirdropFactoryClient"
     });
   }
-  const resolved = chunk3ZRHDTEX_cjs.getFheAirdropFactoryAddress(chainId);
+  const resolved = chunkWUXUWTFW_cjs.getFheAirdropFactoryAddress(chainId);
   if (!resolved) {
-    return new chunk56UI7LUR_cjs.DeploymentAddressUnavailableError({
+    return new chunk2RNW4MIJ_cjs.DeploymentAddressUnavailableError({
       reason: "registry-not-deployed",
       product: "fheAirdrop",
       contract: "confidentialAirdropFactory",
@@ -73,7 +73,7 @@ function useMemoAirdropClient(opts) {
   const client = react.useMemo(() => {
     if (!publicClient) return void 0;
     if (!opts.address) return void 0;
-    return chunk5SA2HF2W_cjs.createConfidentialAirdropClient({
+    return chunkSPGSO5SO_cjs.createConfidentialAirdropClient({
       publicClient,
       ...walletClient ? { walletClient } : {},
       address: opts.address,

package/dist/chunk-WOEETTH7.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+var chunkZQUE2B3Q_cjs = require('./chunk-ZQUE2B3Q.cjs');
+var chunk4ZCXK4VI_cjs = require('./chunk-4ZCXK4VI.cjs');
+var chunk2RNW4MIJ_cjs = require('./chunk-2RNW4MIJ.cjs');
+var reactQuery = require('@tanstack/react-query');
+var wagmi = require('wagmi');
+
+function useIsOperator(options = {}) {
+  const publicClient = wagmi.usePublicClient({ chainId: options.chainId });
+  const { address: connected } = chunkZQUE2B3Q_cjs.useWagmiAccount();
+  const chainId = options.chainId ?? publicClient?.chain?.id;
+  const holder = options.holder ?? connected;
+  const { token, spender, telemetry } = options;
+  return reactQuery.useQuery({
+    queryKey: [
+      "tokenops-sdk",
+      "fhe",
+      "isOperator",
+      chainId ?? null,
+      token ? token.toLowerCase() : null,
+      holder ? holder.toLowerCase() : null,
+      spender ? spender.toLowerCase() : null
+    ],
+    queryFn: () => chunk4ZCXK4VI_cjs.isOperator({
+      publicClient,
+      token,
+      holder,
+      spender,
+      ...telemetry ? { telemetry } : {}
+    }),
+    enabled: !!publicClient && !!token && !!holder && !!spender && options.enabled !== false,
+    staleTime: 0
+  });
+}
+function useEnsureOperator(options = {}) {
+  const publicClient = wagmi.usePublicClient({ chainId: options.chainId });
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: options.chainId });
+  const telemetry = options.telemetry;
+  return reactQuery.useMutation({
+    mutationFn: async (vars) => {
+      if (!publicClient) throw new chunk2RNW4MIJ_cjs.MissingPublicClientError("useEnsureOperator");
+      if (!walletClient) throw new chunk2RNW4MIJ_cjs.MissingWalletClientError("useEnsureOperator");
+      return chunk4ZCXK4VI_cjs.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 } : {}
+      });
+    }
+  });
+}
+
+exports.useEnsureOperator = useEnsureOperator;
+exports.useIsOperator = useIsOperator;

package/dist/{chunk-QE7ZONJ2.js → chunk-WTK6JDSI.js}

@@ -1,9 +1,8 @@
-import { SDK_VERSION, isContractRevert, mapContractRevert } from './chunk-JFLEEXKP.js';
-import { getConfidentialTestTokenAddress, getTestTokenAddress } from './chunk-M7V2EDPB.js';
-import { normaliseAddress } from './chunk-BE2AIZ3K.js';
+import { SDK_VERSION, isContractRevert, mapContractRevert } from './chunk-6WSNS3UV.js';
+import { getConfidentialTestTokenAddress, getTestTokenAddress } from './chunk-QKKBBH7I.js';
+import { normaliseAddress } from './chunk-46T67CE2.js';
+import { TokenOpsSdkError, UnsupportedChainError, DeploymentAddressUnavailableError, asEncryptedHandle, TokenOpsContractError, ReceiptEventNotFoundError, ReceiptEventAmbiguousError, asTxHash, MissingWalletClientError, MissingAccountError, InvalidArgumentError } from './chunk-DRSPMIZ7.js';
 import { withTelemetry } from './chunk-Q2GP5UDC.js';
-import { asEncryptedHandle, asTxHash } from './chunk-KWFFIJYX.js';
-import { TokenOpsSdkError, UnsupportedChainError, DeploymentAddressUnavailableError, TokenOpsContractError, ReceiptEventNotFoundError, ReceiptEventAmbiguousError, MissingWalletClientError, MissingAccountError, InvalidArgumentError } from './chunk-IVE3QEGD.js';
 import { sepolia } from 'viem/chains';
 import { parseEventLogs } from 'viem';
 

package/dist/{chunk-3ZRHDTEX.cjs → chunk-WUXUWTFW.cjs}

@@ -1,12 +1,12 @@
 'use strict';
 
-var chunk56UI7LUR_cjs = require('./chunk-56UI7LUR.cjs');
+var chunk2RNW4MIJ_cjs = require('./chunk-2RNW4MIJ.cjs');
 var chains = require('viem/chains');
 
 var DEPLOYED_ADDRESSES = {
   fheVesting: {
     confidentialVestingFactory: {
-      [chains.sepolia.id]: "0xA87701CE9A52D43681600583a99c85b50DbE3150"
+      [chains.sepolia.id]: "0x059d6Bb8ff9a13E794fe416d4757d7310CdC69ab"
       // mainnet omitted — not deployed.
     }
   },
@@ -50,7 +50,7 @@ function requireDeployedAddress(product, contract, chainId) {
   const contractEntry = productEntry[contract];
   const entry = contractEntry?.[chainId];
   if (entry) return entry;
-  throw new chunk56UI7LUR_cjs.DeploymentAddressUnavailableError({
+  throw new chunk2RNW4MIJ_cjs.DeploymentAddressUnavailableError({
     reason: entry === null ? "registry-not-deployed" : "registry-unknown-chain",
     product: String(product),
     contract: String(contract),