@tokenops/sdk 1.0.0 → 1.1.1

package/dist/testnet-faucet/index.js

@@ -0,0 +1,7 @@
+export { FaucetSupplyExhaustedError, TESTNET_FAUCET_SUPPORTED_CHAIN_IDS, TestnetFaucetClient, assertTestnetFaucetChain, confidentialTokenopsTestTokenAbi, createTestnetFaucetClient, isTestnetFaucetChainId, tokenopsTestTokenAbi } from '../chunk-QE7ZONJ2.js';
+import '../chunk-JFLEEXKP.js';
+export { getConfidentialTestTokenAddress, getTestTokenAddress, requireConfidentialTestTokenAddress, requireTestTokenAddress } from '../chunk-M7V2EDPB.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/testnet-faucet/react/_shared.d.ts

@@ -0,0 +1,61 @@
+import type { Address, PublicClient, WalletClient } from "viem";
+import { type TokenOpsSdkError } from "../../core/errors.js";
+import { type TestnetFaucetClient } from "../faucet.js";
+/** Common per-hook overrides — every public hook accepts these alongside its own args. */
+export interface BaseHookOptions {
+    /**
+     * Override the on-chain CTTT proxy address. Defaults to
+     * {@link getConfidentialTestTokenAddress} keyed by chain id. Mirrors the
+     * headless client's single `address` knob — the backing TTT is always derived
+     * from this wrapper's `underlying()`, never supplied separately.
+     */
+    address?: Address;
+    /** Override the chain id used for default address resolution. Defaults to `usePublicClient().chain?.id`. */
+    chainId?: number;
+}
+/** Stable query-key prefix for every hook in this subpath. */
+export declare const TESTNET_FAUCET_KEY: "tokenops-sdk";
+export declare const TESTNET_FAUCET_NAMESPACE: "testnet-faucet";
+/**
+ * Resolve the CTTT proxy address for `chainId` (override → registry entry),
+ * returning `undefined` instead of throwing when it can't be resolved. Used by
+ * query-key builders and `enabled` gates.
+ *
+ * Returns `undefined` on a known non-testnet chain (before honoring any
+ * `override`) so {@link useMemoFaucetClient}'s `useMemo` never constructs a
+ * client — and thus never lets the headless constructor throw
+ * `UnsupportedChainError` during render. The unsupported-chain case is surfaced
+ * off the render path via {@link computeSingletonResolutionError} instead.
+ */
+export declare function tryResolveSingletonAddress(override: Address | undefined, chainId: number | undefined): Address | undefined;
+/**
+ * Memoize a {@link TestnetFaucetClient} keyed on
+ * `(publicClient, walletClient, address)`.
+ *
+ * @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 CTTT address
+ *   could not be resolved — gate queries with `enabled: !!client`.
+ *   `resolutionError` carries the typed deployment-address error the headless
+ *   `TestnetFaucetClient` constructor 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 useMemoFaucetClient(opts?: BaseHookOptions): {
+    client: TestnetFaucetClient | undefined;
+    resolutionError: TokenOpsSdkError | undefined;
+    publicClient: PublicClient | undefined;
+    walletClient: WalletClient | undefined;
+    chainId: number | undefined;
+    resolvedAddress: Address | undefined;
+};
+/**
+ * Build a stable TanStack Query key for a testnet-faucet 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>;

package/dist/testnet-faucet/react/index.cjs

@@ -0,0 +1,379 @@
+'use strict';
+
+var chunk5KHIQG7Y_cjs = require('../../chunk-5KHIQG7Y.cjs');
+require('../../chunk-VDXVNZCO.cjs');
+var chunk3ZRHDTEX_cjs = require('../../chunk-3ZRHDTEX.cjs');
+require('../../chunk-CQIPRNS7.cjs');
+require('../../chunk-VJKZWYYJ.cjs');
+require('../../chunk-66IHPTOK.cjs');
+var chunk56UI7LUR_cjs = require('../../chunk-56UI7LUR.cjs');
+var reactQuery = require('@tanstack/react-query');
+var wagmi = require('wagmi');
+var react = require('react');
+
+var TESTNET_FAUCET_KEY = "tokenops-sdk";
+var TESTNET_FAUCET_NAMESPACE = "testnet-faucet";
+function tryResolveSingletonAddress(override, chainId) {
+  if (chainId !== void 0 && !chunk5KHIQG7Y_cjs.isTestnetFaucetChainId(chainId)) return void 0;
+  if (override) return override;
+  if (chainId === void 0) return void 0;
+  return chunk3ZRHDTEX_cjs.getConfidentialTestTokenAddress(chainId);
+}
+function useMemoFaucetClient(opts = {}) {
+  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const resolvedAddress = tryResolveSingletonAddress(opts.address, chainId);
+  const resolutionError = computeSingletonResolutionError(opts.address, chainId);
+  const client = react.useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!resolvedAddress) return void 0;
+    return chunk5KHIQG7Y_cjs.createTestnetFaucetClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      ...opts.address ? { address: resolvedAddress } : {},
+      ...chainId !== void 0 ? { chainId } : {}
+    });
+  }, [publicClient, walletClient, resolvedAddress, chainId]);
+  return {
+    client,
+    resolutionError,
+    publicClient,
+    walletClient: walletClient ?? void 0,
+    chainId,
+    resolvedAddress
+  };
+}
+function computeSingletonResolutionError(override, chainId) {
+  if (chainId !== void 0 && !chunk5KHIQG7Y_cjs.isTestnetFaucetChainId(chainId)) {
+    return new chunk56UI7LUR_cjs.UnsupportedChainError(chainId);
+  }
+  if (override) return void 0;
+  if (chainId === void 0) {
+    return new chunk56UI7LUR_cjs.DeploymentAddressUnavailableError({
+      reason: "chain-id-missing",
+      product: "testnetFaucet",
+      contract: "confidentialTestToken",
+      clientLabel: "TestnetFaucetClient"
+    });
+  }
+  const resolved = chunk3ZRHDTEX_cjs.getConfidentialTestTokenAddress(chainId);
+  if (!resolved) {
+    return new chunk56UI7LUR_cjs.DeploymentAddressUnavailableError({
+      reason: "registry-not-deployed",
+      product: "testnetFaucet",
+      contract: "confidentialTestToken",
+      chainId,
+      clientLabel: "TestnetFaucetClient"
+    });
+  }
+  return void 0;
+}
+function buildQueryKey(method, chainId, address, ...args) {
+  return [
+    TESTNET_FAUCET_KEY,
+    TESTNET_FAUCET_NAMESPACE,
+    method,
+    chainId ?? null,
+    address ? address.toLowerCase() : null,
+    ...args.map(normalizeKeyArg)
+  ];
+}
+function normalizeKeyArg(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map(normalizeKeyArg);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, normalizeKeyArg(v)])
+    );
+  }
+  if (typeof value === "string" && value.startsWith("0x")) return value.toLowerCase();
+  return value;
+}
+
+// src/testnet-faucet/react/useConfidentialBalance.ts
+function useConfidentialBalance(args = {}) {
+  const { account, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoFaucetClient(base);
+  const { address: connected } = wagmi.useAccount();
+  const resolvedAccount = account ?? connected;
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("confidentialBalanceOf", chainId, resolvedAddress, resolvedAccount),
+    queryFn: () => client.confidentialBalanceOf(resolvedAccount),
+    enabled: !!client && !!resolvedAccount,
+    staleTime: 0
+  });
+}
+function useUnderlyingBalance(args = {}) {
+  const { account, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoFaucetClient(base);
+  const { address: connected } = wagmi.useAccount();
+  const resolvedAccount = account ?? connected;
+  return reactQuery.useQuery({
+    // The TTT is derived from the CTTT, which is already keyed via
+    // `resolvedAddress` — no separate underlying segment needed.
+    queryKey: buildQueryKey("underlyingBalanceOf", chainId, resolvedAddress, resolvedAccount),
+    queryFn: () => client.underlyingBalanceOf(resolvedAccount),
+    enabled: !!client && !!resolvedAccount,
+    staleTime: 0
+  });
+}
+function useFaucetRate(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFaucetClient(options);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("rate", chainId, resolvedAddress),
+    queryFn: () => client.rate(),
+    enabled: !!client,
+    // The conversion rate is fixed per deployment — never goes stale.
+    staleTime: Infinity
+  });
+}
+function useFaucetDecimals(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFaucetClient(options);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("decimals", chainId, resolvedAddress),
+    queryFn: () => client.decimals(),
+    enabled: !!client,
+    // CTTT decimals are fixed per deployment — never goes stale.
+    staleTime: Infinity
+  });
+}
+function useUnderlyingDecimals(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFaucetClient(options);
+  return reactQuery.useQuery({
+    // The TTT is derived from the CTTT, which is already keyed via
+    // `resolvedAddress` — no separate underlying segment needed.
+    queryKey: buildQueryKey("underlyingDecimals", chainId, resolvedAddress),
+    queryFn: () => client.underlyingDecimals(),
+    enabled: !!client,
+    // TTT decimals are fixed per deployment — never goes stale.
+    staleTime: Infinity
+  });
+}
+function useUnderlyingTokenAddress(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFaucetClient(options);
+  return reactQuery.useQuery({
+    // The TTT is derived from the CTTT, which is already keyed via
+    // `resolvedAddress` — no separate underlying segment needed.
+    queryKey: buildQueryKey("underlyingToken", chainId, resolvedAddress),
+    queryFn: () => client.underlyingToken(),
+    enabled: !!client,
+    // The backing token address is fixed per deployment — never goes stale.
+    staleTime: Infinity
+  });
+}
+function useInferredTotalSupply(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFaucetClient(options);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("inferredTotalSupply", chainId, resolvedAddress),
+    queryFn: () => client.inferredTotalSupply(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useMaxTotalSupply(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFaucetClient(options);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("maxTotalSupply", chainId, resolvedAddress),
+    queryFn: () => client.maxTotalSupply(),
+    enabled: !!client,
+    // `type(uint64).max` is fixed per deployment — never goes stale.
+    staleTime: Infinity
+  });
+}
+function useFaucetMetadata(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFaucetClient(options);
+  return reactQuery.useQuery({
+    // The `underlying` half of the metadata is derived from the CTTT, which is
+    // already keyed via `resolvedAddress` — no separate underlying segment needed.
+    queryKey: buildQueryKey("getMetadata", chainId, resolvedAddress),
+    queryFn: () => client.getMetadata(),
+    enabled: !!client,
+    // name/symbol/decimals/rate/maxTotalSupply are all fixed per deployment.
+    staleTime: Infinity
+  });
+}
+function useMintConfidential(options = {}) {
+  const { client, resolutionError } = useMemoFaucetClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useMintConfidential", "testnet-faucet");
+      }
+      return client.mintConfidential(args);
+    }
+  });
+}
+function useMintUnderlying(options = {}) {
+  const { client, resolutionError } = useMemoFaucetClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useMintUnderlying", "testnet-faucet");
+      }
+      return client.mintUnderlying(args);
+    }
+  });
+}
+
+Object.defineProperty(exports, "FaucetSupplyExhaustedError", {
+  enumerable: true,
+  get: function () { return chunk5KHIQG7Y_cjs.FaucetSupplyExhaustedError; }
+});
+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, "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; }
+});
+exports.TESTNET_FAUCET_KEY = TESTNET_FAUCET_KEY;
+exports.TESTNET_FAUCET_NAMESPACE = TESTNET_FAUCET_NAMESPACE;
+exports.useConfidentialBalance = useConfidentialBalance;
+exports.useFaucetDecimals = useFaucetDecimals;
+exports.useFaucetMetadata = useFaucetMetadata;
+exports.useFaucetRate = useFaucetRate;
+exports.useInferredTotalSupply = useInferredTotalSupply;
+exports.useMaxTotalSupply = useMaxTotalSupply;
+exports.useMintConfidential = useMintConfidential;
+exports.useMintUnderlying = useMintUnderlying;
+exports.useUnderlyingBalance = useUnderlyingBalance;
+exports.useUnderlyingDecimals = useUnderlyingDecimals;
+exports.useUnderlyingTokenAddress = useUnderlyingTokenAddress;

package/dist/testnet-faucet/react/index.d.cts

@@ -0,0 +1,38 @@
+/**
+ * React/wagmi hooks for `@tokenops/sdk/testnet-faucet`.
+ *
+ * Every public method on the headless `TestnetFaucetClient` is wrapped as
+ * a hook here. Hooks compose with wagmi (`usePublicClient`, `useWalletClient`,
+ * `useAccount`) and TanStack Query (`useQuery`, `useMutation`) — no extra
+ * provider needed beyond the standard wagmi `<WagmiProvider>` +
+ * `<QueryClientProvider>`.
+ *
+ * The CTTT proxy address is resolved per-chain via
+ * `getConfidentialTestTokenAddress`. Pass `address` to
+ * {@link BaseHookOptions} to override (e.g. for forks or local deployments).
+ *
+ * **No encryptor.** Unlike the FHE products, the faucet mints take PUBLIC
+ * plaintext amounts — no `encryptor`, no ACL address, and nothing imported
+ * from `@zama-fhe/react-sdk`. A pure-Node or pure-React consumer needs none of
+ * the Zama optional peer to use the faucet.
+ *
+ * Mutations do NOT auto-invalidate read queries — that's a consumer decision.
+ * Each mutation's TSDoc documents the recommended
+ * `queryClient.invalidateQueries({ queryKey: ["tokenops-sdk", "testnet-faucet"] })`.
+ */
+export { useConfidentialBalance, type UseConfidentialBalanceArgs, } from "./useConfidentialBalance.js";
+export { useUnderlyingBalance, type UseUnderlyingBalanceArgs } from "./useUnderlyingBalance.js";
+export { useFaucetRate } from "./useFaucetRate.js";
+export { useFaucetDecimals } from "./useFaucetDecimals.js";
+export { useUnderlyingDecimals } from "./useUnderlyingDecimals.js";
+export { useUnderlyingTokenAddress } from "./useUnderlyingTokenAddress.js";
+export { useInferredTotalSupply } from "./useInferredTotalSupply.js";
+export { useMaxTotalSupply } from "./useMaxTotalSupply.js";
+export { useFaucetMetadata } from "./useFaucetMetadata.js";
+export { useMintConfidential, type UseMintConfidentialArgs } from "./useMintConfidential.js";
+export { useMintUnderlying, type UseMintUnderlyingArgs } from "./useMintUnderlying.js";
+export type { BaseHookOptions } from "./_shared.js";
+export { TESTNET_FAUCET_KEY, TESTNET_FAUCET_NAMESPACE } from "./_shared.js";
+export type { FaucetMetadata, FaucetTokenMetadata, MintConfidentialArgs, MintConfidentialResult, MintUnderlyingArgs, MintUnderlyingResult, } from "../types.js";
+export { TokenOpsSdkError, isTokenOpsSdkError, DeploymentAddressUnavailableError, UnsupportedChainError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, InvalidArgumentError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, 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 { FaucetSupplyExhaustedError } from "../errors.js";

package/dist/testnet-faucet/react/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * React/wagmi hooks for `@tokenops/sdk/testnet-faucet`.
+ *
+ * Every public method on the headless `TestnetFaucetClient` is wrapped as
+ * a hook here. Hooks compose with wagmi (`usePublicClient`, `useWalletClient`,
+ * `useAccount`) and TanStack Query (`useQuery`, `useMutation`) — no extra
+ * provider needed beyond the standard wagmi `<WagmiProvider>` +
+ * `<QueryClientProvider>`.
+ *
+ * The CTTT proxy address is resolved per-chain via
+ * `getConfidentialTestTokenAddress`. Pass `address` to
+ * {@link BaseHookOptions} to override (e.g. for forks or local deployments).
+ *
+ * **No encryptor.** Unlike the FHE products, the faucet mints take PUBLIC
+ * plaintext amounts — no `encryptor`, no ACL address, and nothing imported
+ * from `@zama-fhe/react-sdk`. A pure-Node or pure-React consumer needs none of
+ * the Zama optional peer to use the faucet.
+ *
+ * Mutations do NOT auto-invalidate read queries — that's a consumer decision.
+ * Each mutation's TSDoc documents the recommended
+ * `queryClient.invalidateQueries({ queryKey: ["tokenops-sdk", "testnet-faucet"] })`.
+ */
+export { useConfidentialBalance, type UseConfidentialBalanceArgs, } from "./useConfidentialBalance.js";
+export { useUnderlyingBalance, type UseUnderlyingBalanceArgs } from "./useUnderlyingBalance.js";
+export { useFaucetRate } from "./useFaucetRate.js";
+export { useFaucetDecimals } from "./useFaucetDecimals.js";
+export { useUnderlyingDecimals } from "./useUnderlyingDecimals.js";
+export { useUnderlyingTokenAddress } from "./useUnderlyingTokenAddress.js";
+export { useInferredTotalSupply } from "./useInferredTotalSupply.js";
+export { useMaxTotalSupply } from "./useMaxTotalSupply.js";
+export { useFaucetMetadata } from "./useFaucetMetadata.js";
+export { useMintConfidential, type UseMintConfidentialArgs } from "./useMintConfidential.js";
+export { useMintUnderlying, type UseMintUnderlyingArgs } from "./useMintUnderlying.js";
+export type { BaseHookOptions } from "./_shared.js";
+export { TESTNET_FAUCET_KEY, TESTNET_FAUCET_NAMESPACE } from "./_shared.js";
+export type { FaucetMetadata, FaucetTokenMetadata, MintConfidentialArgs, MintConfidentialResult, MintUnderlyingArgs, MintUnderlyingResult, } from "../types.js";
+export { TokenOpsSdkError, isTokenOpsSdkError, DeploymentAddressUnavailableError, UnsupportedChainError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, InvalidArgumentError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, 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 { FaucetSupplyExhaustedError } from "../errors.js";