@tokenops/sdk 1.0.0

package/dist/fhe/index.js

@@ -0,0 +1,394 @@
+export { ERC7984_OPERATOR_MAX_DEADLINE, ERC7984_SET_OPERATOR_ABI, revokeOperator, setOperator } from '../chunk-WRCUDSUJ.js';
+export { erc7984OperatorAbi } from '../chunk-7VELUOMI.js';
+export { FHE_SPLIT_DENOMINATOR, scaleRatio, share } from '../chunk-XSNLAS5M.js';
+export { ACL_ALLOWED_EVENT, FHEVM_ACL_ADDRESS_BY_CHAIN, getFhevmAclAddress, requireFhevmAclAddress } from '../chunk-FYQ2UW4T.js';
+import { normaliseAddress } from '../chunk-BE2AIZ3K.js';
+import { withTelemetry } from '../chunk-Q2GP5UDC.js';
+import { TokenOpsContractError } from '../chunk-IVE3QEGD.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';
+import { RelayerWeb, MainnetConfig, SepoliaConfig } from '@zama-fhe/sdk';
+
+// src/fhe/mock-encryptor.ts
+var FHEVM_HANDLE_VERSION = 0;
+var FHEVM_EXECUTOR_ADDRESS_LOCAL = "0xe3a9105a3a932253A70F126eb1E3b589C643dD24";
+var COPROCESSOR_SIGNER_PRIVATE_KEY_LOCAL = "0x7ec8ada6642fc4ccfb7729bc29c17cf8d21b61abd5642d1db992c0b8672ab901";
+async function requirePeerDep(spec, hint) {
+  try {
+    return await import(
+      /* webpackIgnore: true */
+      spec
+    );
+  } catch (err) {
+    throw new Error(
+      `@tokenops/sdk: peer dependency "${spec}" is required for createMockEncryptor.
+  install it with: ${hint}
+  underlying error: ${String(err)}`
+    );
+  }
+}
+async function createMockRelayerProvider(mockUtils, ethers, opts) {
+  const provider = new ethers.JsonRpcProvider(opts.rpcUrl);
+  const signer = new ethers.Wallet(opts.coprocessorSignerPrivateKey, provider);
+  const db = new mockUtils.FhevmDBMap();
+  const head = await provider.getBlockNumber();
+  await db.init(head);
+  const coprocessor = await mockUtils.MockCoprocessor.create(provider, {
+    coprocessorContractAddress: opts.fhevmExecutorContractAddress,
+    coprocessorSigners: [signer],
+    inputVerifierContractAddress: opts.inputVerifierContractAddress,
+    db
+  });
+  return {
+    provider,
+    async send(method, params) {
+      switch (method) {
+        case mockUtils.relayer.RELAYER_V1_INPUT_PROOF: {
+          const payload = params[0];
+          mockUtils.relayer.assertIsMockRelayerV1InputProofPayload(payload);
+          const contractChainId = Number(payload.contractChainId);
+          if (opts.aclContractAddress.toLowerCase() !== payload.mockData.aclContractAddress.toLowerCase()) {
+            throw new Error(
+              `createMockEncryptor: ACL mismatch: expected ${opts.aclContractAddress}, got ${payload.mockData.aclContractAddress}`
+            );
+          }
+          const handlesBytes32List = mockUtils.FhevmHandle.computeHandles(
+            ethers.getBytes(payload.ciphertextWithInputVerification),
+            payload.mockData.fhevmTypes,
+            payload.mockData.aclContractAddress,
+            contractChainId,
+            FHEVM_HANDLE_VERSION
+          );
+          const response = await coprocessor.computeCoprocessorSignatures(
+            handlesBytes32List,
+            contractChainId,
+            payload.contractAddress,
+            payload.userAddress,
+            payload.extraData
+          );
+          for (let i = 0; i < response.handles.length; i++) {
+            const raw = response.handles[i] ?? "";
+            const handleHex = raw.startsWith("0x") ? raw : `0x${raw}`;
+            const cleartext = payload.mockData.clearTextValuesBigIntHex[i] ?? "0x0";
+            const meta = payload.mockData.metadatas[i];
+            await coprocessor.insertHandleBytes32(handleHex, cleartext, meta);
+          }
+          return response;
+        }
+        case mockUtils.relayer.RELAYER_V1_USER_DECRYPT: {
+          const payload = params[0];
+          mockUtils.relayer.assertIsRelayerV1UserDecryptPayload(payload);
+          await coprocessor.awaitCoprocessor();
+          await mockUtils.MockFhevmInstance.verifyUserACLPermissions(
+            provider,
+            opts.aclContractAddress,
+            payload.handleContractPairs,
+            payload.userAddress
+          );
+          await mockUtils.MockFhevmInstance.verifyUserDecryptSignature(
+            payload.publicKey,
+            payload.signature,
+            payload.contractAddresses,
+            payload.userAddress,
+            Number(payload.requestValidity.startTimestamp),
+            Number(payload.requestValidity.durationDays),
+            opts.verifyingContractAddressDecryption,
+            Number(payload.contractsChainId)
+          );
+          const handleBytes32HexList = payload.handleContractPairs.map(
+            (h) => ethers.toBeHex(ethers.toBigInt(h.handle), 32)
+          );
+          const clearTextHexList = await coprocessor.queryHandlesBytes32AsHex(handleBytes32HexList);
+          return {
+            payload: { decrypted_values: clearTextHexList },
+            signature: ethers.ZeroHash
+          };
+        }
+        default:
+          return provider.send(method, params);
+      }
+    }
+  };
+}
+async function createMockEncryptor(options = {}) {
+  const rpcUrl = options.rpcUrl ?? "http://127.0.0.1:8545";
+  const chainId = options.chainId ?? 31337;
+  const mockUtils = await requirePeerDep(
+    "@fhevm/mock-utils",
+    "pnpm add -D @fhevm/mock-utils"
+  );
+  const zamaSdk = await requirePeerDep(
+    "@zama-fhe/sdk",
+    "pnpm add @zama-fhe/sdk@^3"
+  );
+  const ethers = await requirePeerDep(
+    "ethers",
+    "pnpm add ethers@^6 (peer dep of @fhevm/mock-utils)"
+  );
+  const HardhatConfig = zamaSdk.HardhatConfig;
+  const hostAddresses = {
+    aclContractAddress: options.hostAddresses?.aclContractAddress ?? HardhatConfig.aclContractAddress,
+    inputVerifierContractAddress: options.hostAddresses?.inputVerifierContractAddress ?? HardhatConfig.inputVerifierContractAddress,
+    kmsContractAddress: options.hostAddresses?.kmsContractAddress ?? HardhatConfig.kmsContractAddress,
+    verifyingContractAddressDecryption: options.hostAddresses?.verifyingContractAddressDecryption ?? HardhatConfig.verifyingContractAddressDecryption,
+    verifyingContractAddressInputVerification: options.hostAddresses?.verifyingContractAddressInputVerification ?? HardhatConfig.verifyingContractAddressInputVerification,
+    fhevmExecutorContractAddress: options.hostAddresses?.fhevmExecutorContractAddress ?? FHEVM_EXECUTOR_ADDRESS_LOCAL,
+    gatewayChainId: options.hostAddresses?.gatewayChainId ?? HardhatConfig.gatewayChainId
+  };
+  const relayer = await createMockRelayerProvider(mockUtils, ethers, {
+    rpcUrl,
+    aclContractAddress: hostAddresses.aclContractAddress,
+    inputVerifierContractAddress: hostAddresses.inputVerifierContractAddress,
+    verifyingContractAddressDecryption: hostAddresses.verifyingContractAddressDecryption,
+    fhevmExecutorContractAddress: hostAddresses.fhevmExecutorContractAddress,
+    coprocessorSignerPrivateKey: options.coprocessorSignerPrivateKey ?? COPROCESSOR_SIGNER_PRIVATE_KEY_LOCAL
+  });
+  const instance = await mockUtils.MockFhevmInstance.create(
+    relayer,
+    relayer.provider,
+    {
+      aclContractAddress: hostAddresses.aclContractAddress,
+      inputVerifierContractAddress: hostAddresses.inputVerifierContractAddress,
+      kmsContractAddress: hostAddresses.kmsContractAddress,
+      verifyingContractAddressDecryption: hostAddresses.verifyingContractAddressDecryption,
+      verifyingContractAddressInputVerification: hostAddresses.verifyingContractAddressInputVerification,
+      chainId,
+      gatewayChainId: hostAddresses.gatewayChainId
+    },
+    { inputVerifierProperties: {}, kmsVerifierProperties: {} }
+  );
+  return {
+    instance,
+    chainId,
+    async encrypt({ values, contractAddress, userAddress }) {
+      const input = instance.createEncryptedInput(contractAddress, userAddress);
+      for (const v of values) {
+        addValue(input, v);
+      }
+      return input.encrypt();
+    }
+  };
+}
+function addValue(input, v) {
+  switch (v.type) {
+    case "euint8":
+      input.add8(v.value);
+      return;
+    case "euint16":
+      input.add16(v.value);
+      return;
+    case "euint32":
+      input.add32(v.value);
+      return;
+    case "euint64":
+      input.add64(v.value);
+      return;
+    case "euint128":
+      input.add128(v.value);
+      return;
+    case "ebool":
+      input.addBool(v.value);
+      return;
+    case "eaddress":
+      input.addAddress(v.value);
+      return;
+    default:
+      throw new Error(
+        `createMockEncryptor: unsupported FHE type "${v.type}"`
+      );
+  }
+}
+var createLocalFhevmEncryptor = createMockEncryptor;
+
+// src/fhe/mock-erc7984.ts
+var MOCK_ERC7984_MINT_ABI = [
+  {
+    type: "function",
+    name: "mint",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint64" }
+    ],
+    outputs: []
+  }
+];
+var UINT64_MAX = (1n << 64n) - 1n;
+async function mintMockERC7984(args) {
+  const { publicClient, walletClient, account, waitForReceipt = true, telemetry } = args;
+  const token = normaliseAddress(args.token);
+  const to = normaliseAddress(args.to);
+  return withTelemetry(telemetry, "fhe.mintMockERC7984", async () => {
+    const fromAccount = account ?? walletClient.account;
+    if (!fromAccount) {
+      throw new TokenOpsContractError(
+        "mintMockERC7984: no account available \u2014 pass `account` explicitly or attach an account to the walletClient",
+        { contract: "ERC7984", call: "mint" }
+      );
+    }
+    if (args.amount < 0n || args.amount > UINT64_MAX) {
+      throw new TokenOpsContractError(
+        `mintMockERC7984: amount ${args.amount} out of uint64 range [0, ${UINT64_MAX}]`,
+        { contract: "ERC7984", call: "mint", amount: args.amount.toString() }
+      );
+    }
+    let hash;
+    try {
+      hash = await walletClient.writeContract({
+        address: token,
+        abi: MOCK_ERC7984_MINT_ABI,
+        functionName: "mint",
+        args: [to, args.amount],
+        account: fromAccount,
+        // viem requires `chain` to be passed explicitly when the wallet has
+        // no default chain. Forward whatever the wallet is bound to.
+        chain: walletClient.chain
+      });
+    } catch (err) {
+      throw new TokenOpsContractError(
+        `mintMockERC7984: writeContract failed (token=${token}, to=${to})`,
+        {
+          contract: "ERC7984",
+          call: "mint",
+          token,
+          to,
+          cause: err
+        }
+      );
+    }
+    let blockNumber = 0n;
+    if (waitForReceipt) {
+      try {
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+        blockNumber = receipt.blockNumber;
+      } catch (err) {
+        throw new TokenOpsContractError(`mintMockERC7984: receipt wait failed (tx=${hash})`, {
+          contract: "ERC7984",
+          call: "mint",
+          tx: hash,
+          cause: err
+        });
+      }
+    }
+    return { hash, blockNumber };
+  });
+}
+function createMockErc7984Client(args) {
+  const address = normaliseAddress(args.address);
+  const { publicClient, walletClient, telemetry } = args;
+  return {
+    address,
+    mint(callArgs) {
+      return mintMockERC7984({
+        publicClient,
+        walletClient,
+        token: address,
+        ...telemetry !== void 0 ? { telemetry } : {},
+        ...callArgs
+      });
+    }
+  };
+}
+
+// src/fhe/sepolia-encryptor.ts
+var SEPOLIA_CHAIN_ID = 11155111;
+var MAINNET_CHAIN_ID = 1;
+async function requirePeerDep2(spec, hint) {
+  try {
+    return await import(
+      /* webpackIgnore: true */
+      spec
+    );
+  } catch (err) {
+    throw new Error(
+      `@tokenops/sdk: peer dependency "${spec}" is required for createSepoliaEncryptor.
+  install it with: ${hint}
+  underlying error: ${String(err)}`
+    );
+  }
+}
+async function createSepoliaEncryptor(options = {}) {
+  const chainId = options.chainId ?? SEPOLIA_CHAIN_ID;
+  const zamaSdkNode = await requirePeerDep2(
+    "@zama-fhe/sdk/node",
+    "pnpm add @zama-fhe/sdk@^3"
+  );
+  const baseConfig = chainId === MAINNET_CHAIN_ID ? zamaSdkNode.MainnetConfig : zamaSdkNode.SepoliaConfig;
+  const transportConfig = { ...baseConfig };
+  if (options.relayerUrl !== void 0) {
+    transportConfig.relayerUrl = options.relayerUrl;
+  }
+  const safeLogger = options.logger ? {
+    debug: () => {
+    },
+    info: () => {
+    },
+    warn: () => {
+    },
+    error: () => {
+    },
+    ...options.logger
+  } : void 0;
+  const instance = new zamaSdkNode.RelayerNode({
+    transports: { [chainId]: transportConfig },
+    getChainId: () => Promise.resolve(chainId),
+    poolSize: options.poolSize,
+    logger: safeLogger,
+    fheArtifactStorage: options.fheArtifactStorage,
+    fheArtifactCacheTTL: options.fheArtifactCacheTTL
+  });
+  return {
+    instance,
+    chainId,
+    async encrypt({ values, contractAddress, userAddress }) {
+      return instance.encrypt({ values, contractAddress, userAddress });
+    },
+    terminate() {
+      instance.terminate();
+    }
+  };
+}
+function createSepoliaEncryptorWeb(opts) {
+  const chainId = opts.chainId ?? SEPOLIA_CHAIN_ID;
+  if (typeof RelayerWeb !== "function") {
+    throw new Error(
+      `@tokenops/sdk: @zama-fhe/sdk is required for createSepoliaEncryptorWeb.
+  install it with: pnpm add @zama-fhe/sdk@^3
+  (RelayerWeb was not a constructor \u2014 the module resolved to ${typeof RelayerWeb})`
+    );
+  }
+  const baseConfig = chainId === MAINNET_CHAIN_ID ? MainnetConfig : SepoliaConfig;
+  const transportConfig = { ...baseConfig };
+  if (opts.relayerUrl !== void 0) {
+    transportConfig.relayerUrl = opts.relayerUrl;
+  }
+  void opts.publicClient;
+  void opts.walletClient;
+  const safeLogger = opts.logger ? {
+    debug: () => {
+    },
+    info: () => {
+    },
+    warn: () => {
+    },
+    error: () => {
+    },
+    ...opts.logger
+  } : void 0;
+  const instance = new RelayerWeb({
+    transports: { [chainId]: transportConfig },
+    getChainId: () => Promise.resolve(chainId),
+    logger: safeLogger
+  });
+  return Promise.resolve({
+    instance,
+    chainId,
+    encrypt({ values, contractAddress, userAddress }) {
+      return instance.encrypt({ values, contractAddress, userAddress });
+    },
+    terminate() {
+      instance.terminate();
+    }
+  });
+}
+
+export { MAINNET_CHAIN_ID, MOCK_ERC7984_MINT_ABI, SEPOLIA_CHAIN_ID, createLocalFhevmEncryptor, createMockEncryptor, createMockErc7984Client, createSepoliaEncryptor, createSepoliaEncryptorWeb, mintMockERC7984 };

package/dist/fhe/mock-encryptor.d.ts

@@ -0,0 +1,90 @@
+import type { Address } from "viem";
+import type { Encryptor } from "../fhe-vesting/encryption.js";
+/**
+ * Configuration for {@link createMockEncryptor}. Most consumers only need
+ * `rpcUrl`; everything else has deterministic defaults that match what
+ * `pnpm fhevm:up` deploys.
+ */
+export interface CreateMockEncryptorOptions {
+    /**
+     * JSON-RPC endpoint of a local Anvil node with FHEVM host contracts already
+     * deployed (i.e. `pnpm fhevm:up` succeeded). Defaults to
+     * `http://127.0.0.1:8545`.
+     */
+    rpcUrl?: string;
+    /**
+     * Chain id of the local node. Defaults to `31337` (forge-fhevm default).
+     * Override only if you ran `pnpm fhevm:up` with a non-default `--chain-id`.
+     */
+    chainId?: number;
+    /**
+     * Mock-utils host-contract addresses. Defaults to the Zama `HardhatConfig`
+     * deterministic deployment forge-fhevm produces. Override if you brought
+     * the FHEVM host contracts up some other way and they landed at different
+     * addresses.
+     */
+    hostAddresses?: {
+        aclContractAddress: Address;
+        inputVerifierContractAddress: Address;
+        kmsContractAddress: Address;
+        verifyingContractAddressDecryption: Address;
+        verifyingContractAddressInputVerification: Address;
+        fhevmExecutorContractAddress?: Address;
+        gatewayChainId?: number;
+    };
+    /**
+     * Override the coprocessor signer private key. Defaults to the deterministic
+     * forge-fhevm signer; you only need this if you deployed the host contracts
+     * with a custom KMS / coprocessor signer set.
+     */
+    coprocessorSignerPrivateKey?: `0x${string}`;
+}
+/** Returned by {@link createMockEncryptor}. Carries the underlying
+ * `MockFhevmInstance` so consumers who need user-decrypt can reach it. */
+export interface MockEncryptor extends Encryptor {
+    /**
+     * The underlying `MockFhevmInstance`. Use this for `userDecrypt` flows that
+     * the SDK's structural {@link Encryptor} interface doesn't expose.
+     * **Process-scoped:** handles produced by one instance can only be decrypted
+     * by that same instance (the cleartext db lives in memory).
+     */
+    readonly instance: unknown;
+    /** Local chain id this encryptor is bound to. */
+    readonly chainId: number;
+}
+/**
+ * Construct an SDK-shaped {@link Encryptor} backed by `MockFhevmInstance`
+ * against a local FHEVM-ready Anvil node (`pnpm fhevm:up`). One call replaces
+ * the 7-address `MockFhevmInstance.create` boilerplate every local-chain
+ * consumer used to copy from `node_modules/@fhevm/mock-utils`.
+ *
+ * @example
+ * ```ts
+ * import { createMockEncryptor } from "@tokenops/sdk/fhe";
+ *
+ * const encryptor = await createMockEncryptor({ rpcUrl: "http://127.0.0.1:8545" });
+ * const mgr = createConfidentialVestingManagerClient({ publicClient, walletClient, address, encryptor });
+ * await mgr.createVesting({ params, amount: 1_000_000n });
+ * ```
+ *
+ * @remarks
+ *   `MockFhevmInstance` is **process-scoped**: handles produced by one instance
+ *   are only decryptable by that same instance. For end-to-end encrypt →
+ *   submit → decrypt loops, keep one encryptor alive for the whole run and
+ *   serialize state (`vestingId`, `manager`, etc.) to disk between steps. See
+ *   `/concepts/encryption` for the recommended pattern.
+ *
+ * @remarks
+ *   For Sepolia / mainnet, use {@link createSepoliaEncryptor} (the SDK's
+ *   one-call wrapper over `RelayerNode` from `@zama-fhe/sdk/node`) in Node, and
+ *   `RelayerWeb` from `@zama-fhe/sdk` (root) in the browser. The legacy
+ *   `RelayerNode.create({ chainId })` / `RelayerWeb.create({ chainId })`
+ *   docs snippets refer to a static factory that does NOT exist on either
+ *   class — both are constructed with `new ...({ transports, getChainId })`.
+ */
+export declare function createMockEncryptor(options?: CreateMockEncryptorOptions): Promise<MockEncryptor>;
+/**
+ * Alias for {@link createMockEncryptor}. Some docs and consumer agents reach
+ * for the more-descriptive name; both resolve to the same implementation.
+ */
+export declare const createLocalFhevmEncryptor: typeof createMockEncryptor;

package/dist/fhe/mock-erc7984.d.ts

@@ -0,0 +1,134 @@
+import type { Account, Address, Hex, PublicClient, WalletClient } from "viem";
+import { type SdkTelemetry } from "../core/telemetry.js";
+/**
+ * Minimal `mint(address,uint64)` ABI fragment. Embedded inline (rather than
+ * imported from a shared mock-token JSON artifact) because the selector is
+ * stable across every ERC-7984-conformant mock — production ERC-7984s with
+ * a `mint(address,uint64)` shape are accepted by the same fragment. No
+ * artifact dependency.
+ *
+ * The contract signature is:
+ *
+ * ```solidity
+ * function mint(address to, uint64 amount) external;
+ * ```
+ */
+export declare const MOCK_ERC7984_MINT_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "mint";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint64";
+    }];
+    readonly outputs: readonly [];
+}];
+/** Arguments for {@link mintMockERC7984}. Mirrors the shape of
+ * {@link import("./operators.js").SetOperatorArgs} so consumers wiring both
+ * helpers in sequence reuse the same client / account references. */
+export interface MintMockERC7984Args {
+    /** Read-only viem client for receipt waiting. */
+    publicClient: PublicClient;
+    /** Wallet client used to send the `mint` call. */
+    walletClient: WalletClient;
+    /** MockERC7984Token contract address. */
+    token: Address;
+    /** Recipient of the freshly-minted ciphertext balance. */
+    to: Address;
+    /**
+     * Amount to mint, base units. `uint64` upper bound (`2**64 - 1 ≈ 1.8e+19`)
+     * is the on-chain ceiling; the helper rejects bigints above that BEFORE
+     * viem encodes them so the revert message is the SDK's, not viem's.
+     */
+    amount: bigint;
+    /**
+     * Account paying the mint. Same `Account | Address` shape as
+     * {@link import("./operators.js").SetOperatorArgs.account} — passing the
+     * full `Account` object preserves the local-signing path
+     * (`eth_sendRawTransaction`); passing only an `Address` falls back to
+     * `eth_sendTransaction` which most public RPCs reject.
+     */
+    account?: Account | Address;
+    /**
+     * If `true` (default), waits for the transaction to be mined before
+     * returning. Set to `false` for fire-and-forget flows where the caller
+     * waits separately.
+     */
+    waitForReceipt?: boolean;
+    /** Optional telemetry sink — span emits as `fhe.mintMockERC7984`. */
+    telemetry?: SdkTelemetry;
+}
+/** Result of {@link mintMockERC7984}: the tx hash plus the mined block
+ * number (or `0n` when `waitForReceipt: false`). Shape mirrors the docs-site
+ * stopgap's return so the migration is a drop-in. */
+export interface MintMockERC7984Result {
+    hash: Hex;
+    blockNumber: bigint;
+}
+/**
+ * Mint `amount` MockERC7984 ciphertext units to `to`. Required pre-step for
+ * any outside-in `/fhe-vesting` / `/fhe-airdrop` / `/fhe-disperse` walkthrough
+ * where the operator's wallet needs a starting balance before the next
+ * `setOperator` + `createX` call.
+ *
+ * @example
+ * ```ts
+ * import { mintMockERC7984, DEPLOYED_ADDRESSES } from "@tokenops/sdk";
+ *
+ * const { hash, blockNumber } = await mintMockERC7984({
+ *   publicClient,
+ *   walletClient,
+ *   token: DEPLOYED_ADDRESSES.tokens.testConfidential[11155111]!,
+ *   to: walletClient.account!.address,
+ *   amount: 1_000_000n,
+ * });
+ * ```
+ *
+ * @throws {@link TokenOpsContractError} if the writeContract or receipt-wait
+ *   step throws. The original viem error is attached as the cause.
+ */
+export declare function mintMockERC7984(args: MintMockERC7984Args): Promise<MintMockERC7984Result>;
+/** Args for {@link createMockErc7984Client}. */
+export interface CreateMockErc7984ClientArgs {
+    publicClient: PublicClient;
+    walletClient: WalletClient;
+    address: Address;
+    /** Optional telemetry forwarded to every method call. */
+    telemetry?: SdkTelemetry;
+}
+/** Small client returned by {@link createMockErc7984Client}. Mirrors the
+ * broader SDK client shape (`{ address, mint }`) so consumers wiring multiple
+ * helpers can stash the client once and reuse the bound address. */
+export interface MockErc7984Client {
+    readonly address: Address;
+    /**
+     * Mint to `to`. The bound `address` is forwarded as the `token` — pass
+     * everything else inline. Same {@link MintMockERC7984Args} shape minus the
+     * `token`, `publicClient`, `walletClient`, `telemetry` fields the client
+     * already owns.
+     */
+    mint(args: Omit<MintMockERC7984Args, "token" | "publicClient" | "walletClient" | "telemetry">): Promise<MintMockERC7984Result>;
+}
+/**
+ * Construct a bound `MockERC7984Token` client. Lighter than
+ * {@link mintMockERC7984} when a consumer makes multiple mints against the
+ * same token — the bound `address` + clients are stashed once.
+ *
+ * @example
+ * ```ts
+ * import { createMockErc7984Client, DEPLOYED_ADDRESSES } from "@tokenops/sdk/fhe";
+ *
+ * const token = createMockErc7984Client({
+ *   publicClient,
+ *   walletClient,
+ *   address: DEPLOYED_ADDRESSES.tokens.testConfidential[11155111]!,
+ * });
+ *
+ * await token.mint({ to: alice, amount: 1_000_000n });
+ * await token.mint({ to: bob,   amount: 2_000_000n });
+ * ```
+ */
+export declare function createMockErc7984Client(args: CreateMockErc7984ClientArgs): MockErc7984Client;