@tokenops/sdk 1.1.1 → 1.6.0

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

@@ -1,12 +1,12 @@
-import { mapZamaError } from './chunk-ZXCOJY2Z.js';
-import { scaleRatio } from './chunk-XSNLAS5M.js';
-import { getFhevmAclAddress, requireFhevmAclAddress, ACL_ALLOWED_EVENT } from './chunk-FYQ2UW4T.js';
-import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-JFLEEXKP.js';
-import { normaliseAddress } from './chunk-BE2AIZ3K.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-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, MissingEncryptorError, ReceiptEventNotFoundError, ReceiptEventAmbiguousError, MissingWalletClientError, MissingAccountError } from './chunk-IVE3QEGD.js';
-import { bytesToHex, parseEventLogs, isAddress } from 'viem';
+import { parseEventLogs, isAddress, BaseError, ContractFunctionZeroDataError } from 'viem';
 
 // src/fhe-vesting/abis/manager.ts
 var confidentialVestingManagerAbi = [
@@ -986,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 {
@@ -1529,6 +1457,118 @@ var ConfidentialVestingManagerClient = class {
     }
     return { ready: blockers.length === 0, blockers };
   }
+  /**
+   * Read-only preflight for {@link createVesting} / {@link batchCreateVesting}.
+   * 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: `token`, `hasCreatorRole`, `isOperatorSet`, `ready`,
+   * `blockers`, `blockerErrors` — see {@link CreateVestingPreflightReport} for
+   * the meaning of each.
+   *
+   * Checks performed (all read-only, no gas):
+   * - Structural `params` validation mirroring the contract's
+   *   `_validateVestingParams` (`InvalidArgumentError` blockers): recipient is
+   *   a checksummed non-zero address, `startTimestamp < endTimestamp`, cliff
+   *   within the window, `initialUnlockBps + cliffAmountBps ≤ 10000`.
+   * - Role: creator holds `VESTING_CREATOR_ROLE`
+   *   ({@link AccessDeniedError} blocker).
+   * - 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
+   *   SDK cannot read in plaintext. An underfunded create does **not** revert:
+   *   the contract's all-or-nothing `FHE.select` pattern silently zeroes the
+   *   vesting amounts instead. Confirm the creator's balance covers the total
+   *   before submitting.
+   * - `batchCreateVesting` additionally enforces `items.length ≤ maxBatchSize()`
+   *   on-chain; check {@link maxBatchSize} for batches.
+   *
+   * Pausing the manager does NOT block vesting creation (only claims), so
+   * paused state is intentionally not a blocker here.
+   *
+   * @param args.params The vesting schedule parameters to validate.
+   * @param args.creator The address that will send the create transaction.
+   * @returns A {@link CreateVestingPreflightReport}.
+   */
+  async preflightCreateVesting(args) {
+    const blockers = [];
+    const blockerErrors = [];
+    const pushBlocker = (err) => {
+      blockerErrors.push(err);
+      blockers.push(err.message);
+    };
+    for (const err of collectVestingParamsErrors(args.params, "createVesting")) {
+      pushBlocker(err);
+    }
+    const [token, creatorRole] = await Promise.all([
+      this.token(),
+      this.#read("VESTING_CREATOR_ROLE")
+    ]);
+    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({
+          method: "createVesting",
+          contractAddress: this.address,
+          account: args.creator,
+          role: creatorRole
+        })
+      );
+    }
+    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",
+          contractAddress: this.address,
+          tokenAddress: token,
+          holder: args.creator,
+          spender: this.address
+        })
+      );
+    }
+    return {
+      token,
+      hasCreatorRole,
+      isOperatorSet,
+      ready: blockers.length === 0,
+      blockers,
+      blockerErrors
+    };
+  }
   // ============================================================
   //                     ENCRYPTED VIEWS (TX)
   // ============================================================
@@ -1594,6 +1634,21 @@ var ConfidentialVestingManagerClient = class {
    *
    * Pass `encryptedInput` to bypass the encryptor when you manage encryption yourself.
    *
+   * **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.
+   *
+   * 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({
@@ -1635,6 +1690,21 @@ var ConfidentialVestingManagerClient = class {
    *
    * Respects `maxBatchSize` — check before calling on large lists.
    *
+   * **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.
+   *
+   * 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) {
@@ -1685,6 +1755,9 @@ var ConfidentialVestingManagerClient = class {
   /**
    * Claim all currently vested tokens for `vestingId`.
    * For `FeeType.Gas` managers, pass `value` (gas fee in wei from `getFeeInfo()`).
+   *
+   * **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.
+   *
    * @param args Discriminated by `feeType`: pass `{ feeType, vestingId, value }` for Gas, `{ feeType, vestingId }` for DistributionToken.
    * @returns Transaction hash.
    * @example
@@ -1713,6 +1786,9 @@ var ConfidentialVestingManagerClient = class {
   /**
    * Admin variant of `claim` — callable by the manager admin on behalf of any recipient.
    * Useful for gas-sponsored claim flows. Same fee rules as `claim`.
+   *
+   * **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.
+   *
    * @param args Same discriminated union as `claim`.
    * @returns Transaction hash.
    */
@@ -1741,6 +1817,15 @@ var ConfidentialVestingManagerClient = class {
   /**
    * Claim a specific encrypted amount from a vesting schedule rather than the full claimable balance.
    * The SDK encrypts `amount` — pass plaintext. Alternatively pass `encryptedInput` to bypass encryption.
+   *
+   * **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.
+   *
    * @param args Includes `vestingId`, `amount` or `encryptedInput`, and optional `value` for Gas-fee managers.
    * @returns Transaction hash.
    */
@@ -1775,6 +1860,15 @@ var ConfidentialVestingManagerClient = class {
   }
   /**
    * Admin variant of `partialClaim` — callable by the manager admin on behalf of any recipient.
+   *
+   * **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.
+   *
    * @param args Same as `partialClaim`.
    * @returns Transaction hash.
    */
@@ -2164,6 +2258,13 @@ var ConfidentialVestingManagerClient = class {
   /**
    * Withdraw a confidential token amount from the manager's balance back to the admin.
    * The SDK encrypts `amount` — pass plaintext. Alternatively pass `encryptedInput`.
+   *
+   * **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.
+   *
    * @param args `{ amount }` (plaintext, SDK encrypts) or `{ encryptedInput }` (pre-encrypted).
    * @returns Transaction hash.
    */
@@ -2220,6 +2321,13 @@ var ConfidentialVestingManagerClient = class {
   /**
    * Withdraw accumulated token fees from a `FeeType.DistributionToken` manager. Admin only.
    * The SDK encrypts `amount` — pass plaintext. Alternatively pass `encryptedInput`.
+   *
+   * **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.
+   *
    * @param args `{ to, amount }` (plaintext, SDK encrypts) or `{ to, encryptedInput }` (pre-encrypted).
    * @returns Transaction hash.
    */
@@ -2633,45 +2741,8 @@ var ConfidentialVestingManagerClient = class {
    * than wait for the on-chain revert.
    */
   #validateVestingParams(params, where) {
-    if (!isAddress(params.recipient, { strict: true })) {
-      throw new InvalidArgumentError({
-        method: where,
-        argument: "recipient",
-        reason: "must be a valid EIP-55 checksummed address",
-        value: params.recipient
-      });
-    }
-    if (params.recipient === ZERO_ADDRESS) {
-      throw new InvalidArgumentError({
-        method: where,
-        argument: "recipient",
-        reason: "must not be the zero address"
-      });
-    }
-    if (params.startTimestamp >= params.endTimestamp) {
-      throw new InvalidArgumentError({
-        method: where,
-        argument: "startTimestamp/endTimestamp",
-        reason: "startTimestamp must be strictly less than endTimestamp",
-        value: { startTimestamp: params.startTimestamp, endTimestamp: params.endTimestamp }
-      });
-    }
-    if (params.startTimestamp + params.cliffSeconds > params.endTimestamp) {
-      throw new InvalidArgumentError({
-        method: where,
-        argument: "cliffSeconds",
-        reason: "cliff cannot extend past endTimestamp",
-        value: params.cliffSeconds
-      });
-    }
-    if (params.initialUnlockBps + params.cliffAmountBps > 1e4) {
-      throw new InvalidArgumentError({
-        method: where,
-        argument: "initialUnlockBps + cliffAmountBps",
-        reason: "must be \u2264 10000 (100%)",
-        value: { initialUnlockBps: params.initialUnlockBps, cliffAmountBps: params.cliffAmountBps }
-      });
-    }
+    const [first] = collectVestingParamsErrors(params, where);
+    if (first) throw first;
   }
   async #read(functionName, args = []) {
     const result = await this.publicClient.readContract({
@@ -2746,9 +2817,66 @@ 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;
 }
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function collectVestingParamsErrors(params, where) {
+  const errors = [];
+  if (!isAddress(params.recipient, { strict: true })) {
+    errors.push(
+      new InvalidArgumentError({
+        method: where,
+        argument: "recipient",
+        reason: "must be a valid EIP-55 checksummed address",
+        value: params.recipient
+      })
+    );
+  } else if (params.recipient === ZERO_ADDRESS) {
+    errors.push(
+      new InvalidArgumentError({
+        method: where,
+        argument: "recipient",
+        reason: "must not be the zero address"
+      })
+    );
+  }
+  if (params.startTimestamp >= params.endTimestamp) {
+    errors.push(
+      new InvalidArgumentError({
+        method: where,
+        argument: "startTimestamp/endTimestamp",
+        reason: "startTimestamp must be strictly less than endTimestamp",
+        value: { startTimestamp: params.startTimestamp, endTimestamp: params.endTimestamp }
+      })
+    );
+  }
+  if (params.startTimestamp < params.endTimestamp && params.startTimestamp + params.cliffSeconds > params.endTimestamp) {
+    errors.push(
+      new InvalidArgumentError({
+        method: where,
+        argument: "cliffSeconds",
+        reason: "cliff cannot extend past endTimestamp",
+        value: params.cliffSeconds
+      })
+    );
+  }
+  if (params.initialUnlockBps + params.cliffAmountBps > 1e4) {
+    errors.push(
+      new InvalidArgumentError({
+        method: where,
+        argument: "initialUnlockBps + cliffAmountBps",
+        reason: "must be \u2264 10000 (100%)",
+        value: { initialUnlockBps: params.initialUnlockBps, cliffAmountBps: params.cliffAmountBps }
+      })
+    );
+  }
+  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 };