@tokenops/sdk 1.0.0

package/dist/fhe-disperse/abis/wallet.d.ts

@@ -0,0 +1,111 @@
+export declare const disperseWalletAbi: readonly [{
+    readonly inputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidAddress";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidInitialization";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NotController";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NotInitializing";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly name: "SafeERC20FailedOperation";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ZamaProtocolUnsupported";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint64";
+        readonly name: "version";
+        readonly type: "uint64";
+    }];
+    readonly name: "Initialized";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly name: "approveToken";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "controller";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "controller_";
+        readonly type: "address";
+    }];
+    readonly name: "initialize";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }];
+    readonly name: "recoverConfidentialToken";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }];
+    readonly name: "recoverERC20";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly name: "revokeToken";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];

package/dist/fhe-disperse/encryption.d.ts

@@ -0,0 +1,77 @@
+import type { Address } from "viem";
+import type { EncryptedInput, EncryptedInputs } from "./types.js";
+/**
+ * FHE input values, discriminated by ciphertext type. Mirrors the shape of
+ * `EncryptInput` from `@zama-fhe/sdk` so that a `RelayerWeb` / `RelayerNode`
+ * / `MockFhevmInstance` instance is structurally assignable to {@link Encryptor}
+ * without casting.
+ */
+export type FheValueInput = {
+    value: boolean | bigint;
+    type: "ebool";
+} | {
+    value: Address;
+    type: "eaddress";
+} | {
+    value: bigint;
+    type: "euint8" | "euint16" | "euint32" | "euint64" | "euint128" | "euint160" | "euint256" | "ebytes64" | "ebytes128" | "ebytes256";
+};
+/**
+ * Subset of `@zama-fhe/sdk` `RelayerSDK` we depend on. Declared structurally so
+ * consumers can pass any v3 RelayerSDK without us importing the optional peer dep.
+ */
+export interface Encryptor {
+    encrypt(params: {
+        values: FheValueInput[];
+        contractAddress: Address;
+        userAddress: Address;
+    }): Promise<{
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    }>;
+}
+/**
+ * Eager or lazy {@link Encryptor} reference. Lazy form for React/Vue/signals
+ * hosts where the encryptor lifetime doesn't match the client's.
+ *
+ * **Wallet-switch contract.** A `RelayerWeb` instance binds to the keypair
+ * derived from the active signing account at construction time. The input
+ * proofs it produces are committed to `(contractAddress, userAddress)`
+ * pairs — the KMSVerifier rejects on-chain submission when those don't
+ * match the executing tx.
+ *
+ * For multi-wallet React hosts the lazy form MUST return a freshly
+ * constructed `RelayerWeb` for the current `walletClient.account` —
+ * returning a memoised instance built for a previous account is a silent
+ * proof-invalidation bug that surfaces only at submit time.
+ */
+export type EncryptorSource = Encryptor | (() => Encryptor | undefined);
+/** Normalize an {@link EncryptorSource} to the underlying {@link Encryptor}. */
+export declare function resolveEncryptor(source: EncryptorSource | undefined): Encryptor | undefined;
+export interface EncryptUint64Args {
+    encryptor: Encryptor;
+    contractAddress: Address;
+    userAddress: Address;
+    value: bigint;
+}
+export interface EncryptUint64BatchArgs {
+    encryptor: Encryptor;
+    contractAddress: Address;
+    userAddress: Address;
+    values: bigint[];
+}
+/**
+ * Encrypt a single `uint64` value into an `externalEuint64` handle + KMS input proof.
+ */
+export declare function encryptUint64({ encryptor, contractAddress, userAddress, value, }: EncryptUint64Args): Promise<EncryptedInput>;
+/**
+ * Encrypt N `uint64` values into N handles bound by a single input proof.
+ *
+ * Used by {@link disperse} to encrypt `amounts[]` and the two subtotals in a
+ * single round-trip. Handles are returned in the same order as `values`.
+ *
+ * For `disperseConfidentialTokens` / `disperseConfidentialTokensWithTokenFee`:
+ * the last two entries in `values` should be `[subtotal0, subtotal1]` and the
+ * corresponding `handles[n-2]` / `handles[n-1]` are the subtotal handles.
+ */
+export declare function encryptUint64Batch({ encryptor, contractAddress, userAddress, values, }: EncryptUint64BatchArgs): Promise<EncryptedInputs>;

package/dist/fhe-disperse/errors.d.ts

@@ -0,0 +1,39 @@
+import type { Address } from "viem";
+import { TokenOpsSdkError } from "../core/errors.js";
+/**
+ * The user has not yet called `register(token)`. Wallet-mode disperse paths
+ * require the per-user OZ-clone wallet pair to exist before they can transfer.
+ */
+export declare class NotRegisteredError extends TokenOpsSdkError {
+    readonly name = "NotRegisteredError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        user: Address;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        user: Address;
+        cause?: unknown;
+    });
+}
+/**
+ * The user has already registered — `register(token)` is single-use per user.
+ * Use `approveUserWalletsForToken(token)` to grant the existing wallet pair
+ * approval over a new token.
+ */
+export declare class AlreadyRegisteredError extends TokenOpsSdkError {
+    readonly name = "AlreadyRegisteredError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        user: Address;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        user: Address;
+        cause?: unknown;
+    });
+}

package/dist/fhe-disperse/index.cjs

@@ -0,0 +1,248 @@
+'use strict';
+
+var chunkHTOMTEA3_cjs = require('../chunk-HTOMTEA3.cjs');
+var chunkITQ7WKVC_cjs = require('../chunk-ITQ7WKVC.cjs');
+var chunkFWHYQZ5E_cjs = require('../chunk-FWHYQZ5E.cjs');
+require('../chunk-NS44KBV5.cjs');
+require('../chunk-Q7ARQSUH.cjs');
+require('../chunk-VDXVNZCO.cjs');
+require('../chunk-OLDGMKW2.cjs');
+require('../chunk-CQIPRNS7.cjs');
+require('../chunk-VJKZWYYJ.cjs');
+require('../chunk-66IHPTOK.cjs');
+var chunk56UI7LUR_cjs = require('../chunk-56UI7LUR.cjs');
+
+
+
+Object.defineProperty(exports, "AlreadyRegisteredError", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.AlreadyRegisteredError; }
+});
+Object.defineProperty(exports, "ConfidentialDisperseClient", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.ConfidentialDisperseClient; }
+});
+Object.defineProperty(exports, "DEFAULT_ADMIN_ROLE", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.DEFAULT_ADMIN_ROLE; }
+});
+Object.defineProperty(exports, "DisperseEncryptedReserveNotGrantedError", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.DisperseEncryptedReserveNotGrantedError; }
+});
+Object.defineProperty(exports, "DisperseSubwalletNotFoundError", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.DisperseSubwalletNotFoundError; }
+});
+Object.defineProperty(exports, "FEE_COLLECTOR_ROLE", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.FEE_COLLECTOR_ROLE; }
+});
+Object.defineProperty(exports, "FEE_MANAGER_ROLE", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.FEE_MANAGER_ROLE; }
+});
+Object.defineProperty(exports, "NotRegisteredError", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.NotRegisteredError; }
+});
+Object.defineProperty(exports, "PAUSER_ROLE", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.PAUSER_ROLE; }
+});
+Object.defineProperty(exports, "WITHDRAWER_ROLE", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.WITHDRAWER_ROLE; }
+});
+Object.defineProperty(exports, "computeSubtotals", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.computeSubtotals; }
+});
+Object.defineProperty(exports, "createConfidentialDisperseClient", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.createConfidentialDisperseClient; }
+});
+Object.defineProperty(exports, "disperseConfidentialAbi", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.disperseConfidentialAbi; }
+});
+Object.defineProperty(exports, "disperseWalletAbi", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.disperseWalletAbi; }
+});
+Object.defineProperty(exports, "encryptUint64", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.encryptUint64; }
+});
+Object.defineProperty(exports, "encryptUint64Batch", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.encryptUint64Batch; }
+});
+Object.defineProperty(exports, "resolveEncryptor", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.resolveEncryptor; }
+});
+Object.defineProperty(exports, "ERC7984_OPERATOR_MAX_DEADLINE", {
+  enumerable: true,
+  get: function () { return chunkITQ7WKVC_cjs.ERC7984_OPERATOR_MAX_DEADLINE; }
+});
+Object.defineProperty(exports, "revokeOperator", {
+  enumerable: true,
+  get: function () { return chunkITQ7WKVC_cjs.revokeOperator; }
+});
+Object.defineProperty(exports, "setOperator", {
+  enumerable: true,
+  get: function () { return chunkITQ7WKVC_cjs.setOperator; }
+});
+Object.defineProperty(exports, "erc7984OperatorAbi", {
+  enumerable: true,
+  get: function () { return chunkFWHYQZ5E_cjs.erc7984OperatorAbi; }
+});
+Object.defineProperty(exports, "AccessDeniedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.AccessDeniedError; }
+});
+Object.defineProperty(exports, "AlreadyInitializedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.AlreadyInitializedError; }
+});
+Object.defineProperty(exports, "BatchTooLargeError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.BatchTooLargeError; }
+});
+Object.defineProperty(exports, "ContractRevertError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.ContractRevertError; }
+});
+Object.defineProperty(exports, "DecryptionFailedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.DecryptionFailedError; }
+});
+Object.defineProperty(exports, "DeploymentAddressUnavailableError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.DeploymentAddressUnavailableError; }
+});
+Object.defineProperty(exports, "EncryptionFailedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.EncryptionFailedError; }
+});
+Object.defineProperty(exports, "FeatureDisabledError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.FeatureDisabledError; }
+});
+Object.defineProperty(exports, "FheHandleNotAllowedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.FheHandleNotAllowedError; }
+});
+Object.defineProperty(exports, "InsufficientBalanceError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.InsufficientBalanceError; }
+});
+Object.defineProperty(exports, "InsufficientFeeError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.InsufficientFeeError; }
+});
+Object.defineProperty(exports, "InsufficientGasFundsError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.InsufficientGasFundsError; }
+});
+Object.defineProperty(exports, "InvalidArgumentError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.InvalidArgumentError; }
+});
+Object.defineProperty(exports, "InvalidSignatureError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.InvalidSignatureError; }
+});
+Object.defineProperty(exports, "MissingAccountError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.MissingAccountError; }
+});
+Object.defineProperty(exports, "MissingClientError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.MissingClientError; }
+});
+Object.defineProperty(exports, "MissingEncryptorError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.MissingEncryptorError; }
+});
+Object.defineProperty(exports, "MissingPublicClientError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.MissingPublicClientError; }
+});
+Object.defineProperty(exports, "MissingWalletClientError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.MissingWalletClientError; }
+});
+Object.defineProperty(exports, "NetworkError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.NetworkError; }
+});
+Object.defineProperty(exports, "PausedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.PausedError; }
+});
+Object.defineProperty(exports, "ReceiptEventAmbiguousError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.ReceiptEventAmbiguousError; }
+});
+Object.defineProperty(exports, "ReceiptEventNotFoundError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.ReceiptEventNotFoundError; }
+});
+Object.defineProperty(exports, "ReentrancyError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.ReentrancyError; }
+});
+Object.defineProperty(exports, "RelayerUnreachableError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.RelayerUnreachableError; }
+});
+Object.defineProperty(exports, "SigningFailedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.SigningFailedError; }
+});
+Object.defineProperty(exports, "TokenOpsContractError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.TokenOpsContractError; }
+});
+Object.defineProperty(exports, "TokenOpsSdkError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.TokenOpsSdkError; }
+});
+Object.defineProperty(exports, "TokenOpsValidationError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.TokenOpsValidationError; }
+});
+Object.defineProperty(exports, "TransferFailedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.TransferFailedError; }
+});
+Object.defineProperty(exports, "UnknownWriteFailureError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.UnknownWriteFailureError; }
+});
+Object.defineProperty(exports, "UnsupportedChainError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.UnsupportedChainError; }
+});
+Object.defineProperty(exports, "UserDecryptNotAllowedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.UserDecryptNotAllowedError; }
+});
+Object.defineProperty(exports, "UserRejectedSignatureError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.UserRejectedSignatureError; }
+});
+Object.defineProperty(exports, "WalletChainMismatchError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.WalletChainMismatchError; }
+});
+Object.defineProperty(exports, "WalletRejectedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.WalletRejectedError; }
+});
+Object.defineProperty(exports, "isTokenOpsSdkError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.isTokenOpsSdkError; }
+});

package/dist/fhe-disperse/index.d.cts

@@ -0,0 +1,14 @@
+export { ConfidentialDisperseClient, createConfidentialDisperseClient, computeSubtotals, type ConfidentialDisperseClientConfig, } from "./singleton.js";
+export { encryptUint64, encryptUint64Batch, resolveEncryptor, type Encryptor, type EncryptorSource, type EncryptUint64Args, type EncryptUint64BatchArgs, type FheValueInput, } from "./encryption.js";
+export { setOperator, revokeOperator, ERC7984_OPERATOR_MAX_DEADLINE, type SetOperatorArgs, type RevokeOperatorArgs, } from "../fhe/operators.js";
+export { DisperseSubwalletNotFoundError, DisperseEncryptedReserveNotGrantedError, type BatchDiscloseHandlesArgs, type BatchLimits, type CalculateFeeArgs, type CalculatedFee, type CustomFee, type DiscloseHandleArgs, type DisclosureResult, type DisperseArgs, type DisperseDistribution, type DisperseMode, type DisperseResult, type EncryptedInput, type EncryptedInputs, type EncryptedViewResult, type FeeConfig, type GetEncryptedFeeReserveArgs, type PreflightDisperseArgs, type PreflightReport, type RecipientCheck, type RegisterResult, type SubwalletApprovalState, type UserFees, type WithdrawTokenFeeResult, } from "./types.js";
+export { disperseConfidentialAbi, disperseWalletAbi } from "./abis/index.js";
+export { erc7984OperatorAbi } from "../fhe/erc7984-abi.js";
+export declare const FEE_COLLECTOR_ROLE: "0x2dca0f5ce7e75a4b43fe2b0d6f5d0b7a2bf92ecf89f8f0aa17b8308b67038821";
+export declare const FEE_MANAGER_ROLE: "0x6c0757dc3e6b28b2580c03fd9e96c274acf4f99d91fbec9b418fa1d70604ff1c";
+export declare const PAUSER_ROLE: "0x65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440d862a";
+export declare const WITHDRAWER_ROLE: "0x10dac8c06a04bec0b551627dad28bc00d6516b0caacd1c7b345fcdb5211334e4";
+export declare const DEFAULT_ADMIN_ROLE: "0x0000000000000000000000000000000000000000000000000000000000000000";
+export { TokenOpsSdkError, isTokenOpsSdkError, DeploymentAddressUnavailableError, UnsupportedChainError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, InvalidArgumentError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, TokenOpsValidationError, ContractRevertError, TokenOpsContractError, PausedError, AccessDeniedError, InsufficientFeeError, InsufficientBalanceError, BatchTooLargeError, FeatureDisabledError, TransferFailedError, FheHandleNotAllowedError, AlreadyInitializedError, ReentrancyError, InvalidSignatureError, WalletRejectedError, WalletChainMismatchError, NetworkError, InsufficientGasFundsError, UnknownWriteFailureError, UserRejectedSignatureError, SigningFailedError, RelayerUnreachableError, EncryptionFailedError, DecryptionFailedError, UserDecryptNotAllowedError, type DeploymentAddressUnavailableReason, type TokenOpsSdkErrorCode, } from "../core/errors.js";
+export { type PreflightResult } from "../core/preflight.js";
+export { NotRegisteredError, AlreadyRegisteredError } from "./errors.js";

package/dist/fhe-disperse/index.d.ts

@@ -0,0 +1,14 @@
+export { ConfidentialDisperseClient, createConfidentialDisperseClient, computeSubtotals, type ConfidentialDisperseClientConfig, } from "./singleton.js";
+export { encryptUint64, encryptUint64Batch, resolveEncryptor, type Encryptor, type EncryptorSource, type EncryptUint64Args, type EncryptUint64BatchArgs, type FheValueInput, } from "./encryption.js";
+export { setOperator, revokeOperator, ERC7984_OPERATOR_MAX_DEADLINE, type SetOperatorArgs, type RevokeOperatorArgs, } from "../fhe/operators.js";
+export { DisperseSubwalletNotFoundError, DisperseEncryptedReserveNotGrantedError, type BatchDiscloseHandlesArgs, type BatchLimits, type CalculateFeeArgs, type CalculatedFee, type CustomFee, type DiscloseHandleArgs, type DisclosureResult, type DisperseArgs, type DisperseDistribution, type DisperseMode, type DisperseResult, type EncryptedInput, type EncryptedInputs, type EncryptedViewResult, type FeeConfig, type GetEncryptedFeeReserveArgs, type PreflightDisperseArgs, type PreflightReport, type RecipientCheck, type RegisterResult, type SubwalletApprovalState, type UserFees, type WithdrawTokenFeeResult, } from "./types.js";
+export { disperseConfidentialAbi, disperseWalletAbi } from "./abis/index.js";
+export { erc7984OperatorAbi } from "../fhe/erc7984-abi.js";
+export declare const FEE_COLLECTOR_ROLE: "0x2dca0f5ce7e75a4b43fe2b0d6f5d0b7a2bf92ecf89f8f0aa17b8308b67038821";
+export declare const FEE_MANAGER_ROLE: "0x6c0757dc3e6b28b2580c03fd9e96c274acf4f99d91fbec9b418fa1d70604ff1c";
+export declare const PAUSER_ROLE: "0x65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440d862a";
+export declare const WITHDRAWER_ROLE: "0x10dac8c06a04bec0b551627dad28bc00d6516b0caacd1c7b345fcdb5211334e4";
+export declare const DEFAULT_ADMIN_ROLE: "0x0000000000000000000000000000000000000000000000000000000000000000";
+export { TokenOpsSdkError, isTokenOpsSdkError, DeploymentAddressUnavailableError, UnsupportedChainError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, InvalidArgumentError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, TokenOpsValidationError, ContractRevertError, TokenOpsContractError, PausedError, AccessDeniedError, InsufficientFeeError, InsufficientBalanceError, BatchTooLargeError, FeatureDisabledError, TransferFailedError, FheHandleNotAllowedError, AlreadyInitializedError, ReentrancyError, InvalidSignatureError, WalletRejectedError, WalletChainMismatchError, NetworkError, InsufficientGasFundsError, UnknownWriteFailureError, UserRejectedSignatureError, SigningFailedError, RelayerUnreachableError, EncryptionFailedError, DecryptionFailedError, UserDecryptNotAllowedError, type DeploymentAddressUnavailableReason, type TokenOpsSdkErrorCode, } from "../core/errors.js";
+export { type PreflightResult } from "../core/preflight.js";
+export { NotRegisteredError, AlreadyRegisteredError } from "./errors.js";

package/dist/fhe-disperse/index.js

@@ -0,0 +1,11 @@
+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 } from '../chunk-QIHZVLIK.js';
+export { ERC7984_OPERATOR_MAX_DEADLINE, revokeOperator, setOperator } from '../chunk-WRCUDSUJ.js';
+export { erc7984OperatorAbi } from '../chunk-7VELUOMI.js';
+import '../chunk-ZXCOJY2Z.js';
+import '../chunk-FYQ2UW4T.js';
+import '../chunk-JFLEEXKP.js';
+import '../chunk-COPFW5Z4.js';
+import '../chunk-BE2AIZ3K.js';
+import '../chunk-Q2GP5UDC.js';
+import '../chunk-KWFFIJYX.js';
+export { AccessDeniedError, AlreadyInitializedError, BatchTooLargeError, ContractRevertError, DecryptionFailedError, DeploymentAddressUnavailableError, EncryptionFailedError, FeatureDisabledError, FheHandleNotAllowedError, InsufficientBalanceError, InsufficientFeeError, InsufficientGasFundsError, InvalidArgumentError, InvalidSignatureError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, NetworkError, PausedError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, ReentrancyError, RelayerUnreachableError, SigningFailedError, TokenOpsContractError, TokenOpsSdkError, TokenOpsValidationError, TransferFailedError, UnknownWriteFailureError, UnsupportedChainError, UserDecryptNotAllowedError, UserRejectedSignatureError, WalletChainMismatchError, WalletRejectedError, isTokenOpsSdkError } from '../chunk-IVE3QEGD.js';

package/dist/fhe-disperse/react/_shared.d.ts

@@ -0,0 +1,104 @@
+import type { Address, PublicClient, WalletClient } from "viem";
+import { DeploymentAddressUnavailableError } from "../../core/errors.js";
+import { type Encryptor, type EncryptorSource } from "../encryption.js";
+import { type ConfidentialDisperseClient } from "../singleton.js";
+/** Common per-hook overrides — every public hook accepts these alongside its own args. */
+export interface BaseHookOptions {
+    /** Override the on-chain singleton address. Defaults to {@link getFheDisperseSingletonAddress} keyed by chain id. */
+    address?: Address;
+    /** Override the chain id used for default address resolution. Defaults to `usePublicClient().chain?.id`. */
+    chainId?: number;
+}
+/**
+ * Per-hook overrides for FHE-disperse hooks. The singleton has one deployed
+ * address per chain — `address` is optional and resolved by chain id via
+ * {@link getFheDisperseSingletonAddress}. Pass `encryptor` here so methods that submit
+ * encrypted inputs (`useDisperse`, `useWithdrawTokenFee`) can pick it up.
+ */
+export interface DisperseHookOptions extends BaseHookOptions {
+    /**
+     * Lazy or eager encryptor source. Optional at hook level; **required at call
+     * time** for methods that submit encrypted inputs (`useDisperse`,
+     * `useWithdrawTokenFee`).
+     *
+     * Recommended in React: capture `useZamaSDK()` once at the top of your
+     * component and wire `encryptor: () => sdk.relayer` — the SDK
+     * calls this per-encryption so it picks up the live `ZamaSDK` instance
+     * rather than a stale capture (CLAUDE.md Pitfall #3). An eager `Encryptor`
+     * instance also type-checks and is appropriate for server-side or test code.
+     *
+     * The SDK does NOT call `useZamaSDK()` automatically — calling a React hook
+     * from inside a mutation body would violate the rules of hooks. If
+     * `encryptor` is omitted and a method that needs one runs, the SDK throws
+     * `TokenOpsSdkError("Missing encryptor — pass ...")`.
+     */
+    encryptor?: EncryptorSource;
+    /** Override the FHEVM ACL address (defaults to chain-id lookup). */
+    aclAddress?: Address;
+}
+/** Stable query-key prefix for every hook in this subpath. */
+export declare const FHE_DISPERSE_KEY: "tokenops-sdk";
+export declare const FHE_DISPERSE_NAMESPACE: "fhe-disperse";
+/**
+ * Resolve the FHE-disperse singleton address for `chainId`, mirroring the
+ * headless client's resolution. Throws the same {@link TokenOpsSdkError} the
+ * headless client would throw at construction time.
+ */
+export declare function resolveSingletonAddress(override: Address | undefined, chainId: number | undefined): Address;
+/**
+ * Same as {@link resolveSingletonAddress} but returns `undefined` instead of
+ * throwing. Used by query-key builders and `enabled` gates.
+ */
+export declare function tryResolveSingletonAddress(override: Address | undefined, chainId: number | undefined): Address | undefined;
+/**
+ * Memoize a {@link ConfidentialDisperseClient} keyed on
+ * `(publicClient, walletClient, address, aclAddress)`. The encryptor source is
+ * passed through as a **lazy** function (mirroring Pitfall #3 from CLAUDE.md):
+ * the SDK calls it per-encryption, picking up the live React context at submit
+ * time rather than baking in a stale capture.
+ *
+ * @returns `{ client, resolutionError, publicClient, walletClient, chainId, resolvedAddress }`.
+ *   `client` is `undefined` when no `publicClient` is available (wagmi may
+ *   briefly return `undefined` during reconnects) or when the singleton
+ *   address could not be resolved — gate queries with `enabled: !!client`.
+ *   `resolutionError` carries the typed deployment-address error that
+ *   {@link resolveSingletonAddress} would have thrown (e.g.
+ *   `DeploymentAddressUnavailableError`); mutation hooks throw it before
+ *   falling back to a generic `MissingClientError` so consumers see the real
+ *   "unsupported chain" / "not deployed on this chain" reason.
+ */
+export declare function useMemoDisperseClient(opts?: DisperseHookOptions): {
+    client: ConfidentialDisperseClient | undefined;
+    resolutionError: DeploymentAddressUnavailableError | undefined;
+    publicClient: PublicClient | undefined;
+    walletClient: WalletClient | undefined;
+    chainId: number | undefined;
+    resolvedAddress: Address | undefined;
+};
+/**
+ * Resolve the encryptor for a mutation call. Order:
+ * 1. Explicit `override` (eager `Encryptor` or lazy `() => Encryptor | undefined`).
+ * 2. The hook-level `encryptor` source from the hook options.
+ *
+ * Both are resolved per-call (not cached), mirroring the lazy `EncryptorSource`
+ * pattern from CLAUDE.md Pitfall #3 — the consumer's React context is the
+ * source of truth.
+ *
+ * If both are missing, throws an actionable error. The hook layer does NOT
+ * dynamically import `@zama-fhe/react-sdk` — calling `useZamaSDK()` from
+ * inside `mutationFn` would violate the rules of hooks. Consumers wire the
+ * encryptor at hook construction. The safe pattern is two lines:
+ * `const sdk = useZamaSDK();` then `encryptor: () => sdk.relayer` — never
+ * `() => useZamaSDK().relayer` inline (that calls a React hook inside a
+ * mutation body, violating the rules of hooks).
+ */
+export declare function resolveCallTimeEncryptor(override: Encryptor | EncryptorSource | undefined, hookLevelSource: EncryptorSource | undefined): Encryptor;
+/**
+ * Build a stable TanStack Query key for an FHE-disperse hook.
+ *
+ * Conventions:
+ * - Lowercase the contract address (TanStack uses structural equality; viem
+ *   sometimes returns checksummed addresses).
+ * - Convert bigints to base-10 strings (TanStack's serializer doesn't handle bigints).
+ */
+export declare function buildQueryKey(method: string, chainId: number | undefined, address: Address | undefined, ...args: ReadonlyArray<unknown>): ReadonlyArray<unknown>;