@tokenops/sdk 1.0.0

package/dist/fhe-vesting/advanced/factory-advanced.d.ts

@@ -0,0 +1,52 @@
+import type { Address } from "viem";
+import { ConfidentialVestingFactoryClient, type ConfidentialVestingFactoryClientConfig, type PredictManagerArgs } from "../factory.js";
+/**
+ * Advanced extension of {@link ConfidentialVestingFactoryClient} that re-exposes
+ * the CREATE2 address prediction read.
+ *
+ * **Why this is "advanced" surface.** R02 ADR P-1 + P-2 (alignment-auditor R04
+ * top-1): `predictManagerAddress` is block-dependent on a live chain — the
+ * factory packs the deployment block number into the clone's immutable args,
+ * which feed into the CREATE2 init-code hash. Predict at block N, mine at
+ * N+1, and the addresses differ. The vast majority of consumers want
+ * `createManager` (rich-return, `{ hash, manager }`) — the address is parsed
+ * from the `ManagerCreated` event in the tx receipt with no block guessing.
+ *
+ * Genuine use cases for the predict read:
+ * - Historical lookups (verifying a clone deployed at a known past block).
+ * - Tightly-coupled same-tx flash flows (rare).
+ *
+ * For everything else, the headline factory's `createManager` is the right
+ * entry point.
+ *
+ * @example
+ * import { createConfidentialVestingFactoryAdvancedClient } from "@tokenops/sdk/fhe-vesting/advanced";
+ *
+ * const factory = createConfidentialVestingFactoryAdvancedClient({ publicClient });
+ * const predicted = await factory.predictManagerAddress({
+ *   token, userSalt, deployer, blockNumber: 10_852_182n,
+ * });
+ */
+export declare class ConfidentialVestingFactoryAdvancedClient extends ConfidentialVestingFactoryClient {
+    /**
+     * Compute the deterministic CREATE2 clone address as the factory would have
+     * computed it at `args.blockNumber`.
+     *
+     * **Block-dependent.** See class TSDoc — predict at block N, mine at N+1,
+     * the addresses differ.
+     *
+     * For the common "deploy a clone and learn its address" flow, prefer the
+     * headline `factory.createManager`, which parses the address from the tx
+     * receipt's `ManagerCreated` event.
+     */
+    predictManagerAddress(args: PredictManagerArgs): Promise<Address>;
+}
+/**
+ * Create a {@link ConfidentialVestingFactoryAdvancedClient}. Mirrors viem's
+ * `create*` convention.
+ *
+ * @example
+ * const factory = createConfidentialVestingFactoryAdvancedClient({ publicClient, walletClient });
+ * const predicted = await factory.predictManagerAddress({ token, userSalt, deployer, blockNumber });
+ */
+export declare function createConfidentialVestingFactoryAdvancedClient(config: ConfidentialVestingFactoryClientConfig): ConfidentialVestingFactoryAdvancedClient;

package/dist/fhe-vesting/advanced/index.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var chunkQCA7O2Q5_cjs = require('../../chunk-QCA7O2Q5.cjs');
+require('../../chunk-62DF53UQ.cjs');
+require('../../chunk-VDXVNZCO.cjs');
+require('../../chunk-OLDGMKW2.cjs');
+require('../../chunk-CQIPRNS7.cjs');
+require('../../chunk-VJKZWYYJ.cjs');
+require('../../chunk-66IHPTOK.cjs');
+require('../../chunk-56UI7LUR.cjs');
+
+
+
+Object.defineProperty(exports, "ConfidentialVestingFactoryAdvancedClient", {
+  enumerable: true,
+  get: function () { return chunkQCA7O2Q5_cjs.ConfidentialVestingFactoryAdvancedClient; }
+});
+Object.defineProperty(exports, "createConfidentialVestingFactoryAdvancedClient", {
+  enumerable: true,
+  get: function () { return chunkQCA7O2Q5_cjs.createConfidentialVestingFactoryAdvancedClient; }
+});

package/dist/fhe-vesting/advanced/index.d.cts

@@ -0,0 +1,12 @@
+/**
+ * Advanced FHE-vesting primitives — power-user surface kept off the headline
+ * client to keep the 90 % path lean (R02 ADR P-2; alignment-auditor R04 top-1).
+ *
+ * Re-exports the {@link ConfidentialVestingFactoryAdvancedClient} subclass,
+ * which extends the headline factory client with `predictManagerAddress`. The
+ * predict read is block-dependent — see the subclass TSDoc. For the common
+ * "deploy and learn the address" case, the headline factory's
+ * `createManager` returns `{ hash, manager }` directly (R02 ADR P-1).
+ */
+export { ConfidentialVestingFactoryAdvancedClient, createConfidentialVestingFactoryAdvancedClient, } from "./factory-advanced.js";
+export type { PredictManagerArgs } from "../factory.js";

package/dist/fhe-vesting/advanced/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Advanced FHE-vesting primitives — power-user surface kept off the headline
+ * client to keep the 90 % path lean (R02 ADR P-2; alignment-auditor R04 top-1).
+ *
+ * Re-exports the {@link ConfidentialVestingFactoryAdvancedClient} subclass,
+ * which extends the headline factory client with `predictManagerAddress`. The
+ * predict read is block-dependent — see the subclass TSDoc. For the common
+ * "deploy and learn the address" case, the headline factory's
+ * `createManager` returns `{ hash, manager }` directly (R02 ADR P-1).
+ */
+export { ConfidentialVestingFactoryAdvancedClient, createConfidentialVestingFactoryAdvancedClient, } from "./factory-advanced.js";
+export type { PredictManagerArgs } from "../factory.js";

package/dist/fhe-vesting/advanced/index.js

@@ -0,0 +1,8 @@
+export { ConfidentialVestingFactoryAdvancedClient, createConfidentialVestingFactoryAdvancedClient } from '../../chunk-CMRETRZO.js';
+import '../../chunk-72YGZEQE.js';
+import '../../chunk-JFLEEXKP.js';
+import '../../chunk-COPFW5Z4.js';
+import '../../chunk-BE2AIZ3K.js';
+import '../../chunk-Q2GP5UDC.js';
+import '../../chunk-KWFFIJYX.js';
+import '../../chunk-IVE3QEGD.js';

package/dist/fhe-vesting/advanced/react/index.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+var chunkJFR5J4FL_cjs = require('../../../chunk-JFR5J4FL.cjs');
+require('../../../chunk-SUOG3BQS.cjs');
+require('../../../chunk-NS44KBV5.cjs');
+require('../../../chunk-5SGMJADP.cjs');
+require('../../../chunk-Q7ARQSUH.cjs');
+var chunkQCA7O2Q5_cjs = require('../../../chunk-QCA7O2Q5.cjs');
+require('../../../chunk-62DF53UQ.cjs');
+require('../../../chunk-VDXVNZCO.cjs');
+var chunkOLDGMKW2_cjs = require('../../../chunk-OLDGMKW2.cjs');
+require('../../../chunk-CQIPRNS7.cjs');
+require('../../../chunk-VJKZWYYJ.cjs');
+require('../../../chunk-66IHPTOK.cjs');
+require('../../../chunk-56UI7LUR.cjs');
+var react = require('react');
+var reactQuery = require('@tanstack/react-query');
+var wagmi = require('wagmi');
+
+function usePredictManagerAddress(args = {}) {
+  const {
+    token,
+    userSalt,
+    deployer,
+    blockNumber,
+    splitEnabled,
+    pausableEnabled,
+    address,
+    chainId,
+    publicClient
+  } = args;
+  const wagmiPublicClient = wagmi.usePublicClient({ ...chainId !== void 0 ? { chainId } : {} });
+  const resolvedPublicClient = publicClient ?? wagmiPublicClient;
+  const { data: walletClient } = wagmi.useWalletClient({
+    ...chainId !== void 0 ? { chainId } : {}
+  });
+  const resolvedChainId = chainId ?? resolvedPublicClient?.chain?.id;
+  const resolvedAddress = address ?? (resolvedChainId === void 0 ? void 0 : chunkOLDGMKW2_cjs.DEPLOYED_ADDRESSES.fheVesting?.confidentialVestingFactory?.[resolvedChainId] ?? void 0);
+  react.useRef(void 0);
+  const client = react.useMemo(() => {
+    if (!resolvedPublicClient) return void 0;
+    if (!resolvedAddress) return void 0;
+    return chunkQCA7O2Q5_cjs.createConfidentialVestingFactoryAdvancedClient({
+      publicClient: resolvedPublicClient,
+      ...walletClient ? { walletClient } : {},
+      address: resolvedAddress,
+      ...resolvedChainId !== void 0 ? { chainId: resolvedChainId } : {}
+    });
+  }, [resolvedPublicClient, walletClient, resolvedAddress, resolvedChainId]);
+  return reactQuery.useQuery({
+    queryKey: chunkJFR5J4FL_cjs.buildQueryKey(
+      "factory:predictManagerAddress",
+      resolvedChainId,
+      resolvedAddress,
+      token,
+      userSalt,
+      deployer,
+      blockNumber,
+      splitEnabled ?? null,
+      pausableEnabled ?? null
+    ),
+    queryFn: () => client.predictManagerAddress({
+      token,
+      userSalt,
+      deployer,
+      blockNumber,
+      ...splitEnabled !== void 0 && { splitEnabled },
+      ...pausableEnabled !== void 0 && { pausableEnabled }
+    }),
+    enabled: !!client && !!token && !!userSalt && !!deployer && blockNumber !== void 0,
+    staleTime: 0
+  });
+}
+
+exports.usePredictManagerAddress = usePredictManagerAddress;

package/dist/fhe-vesting/advanced/react/index.d.cts

@@ -0,0 +1,5 @@
+/**
+ * React hooks for `@tokenops/sdk/fhe-vesting/advanced`. The headline React
+ * subpath stays lean; pre-mine address prediction lives here per R02 ADR P-2.
+ */
+export { usePredictManagerAddress, type UsePredictManagerAddressArgs, } from "./usePredictManagerAddress.js";

package/dist/fhe-vesting/advanced/react/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * React hooks for `@tokenops/sdk/fhe-vesting/advanced`. The headline React
+ * subpath stays lean; pre-mine address prediction lives here per R02 ADR P-2.
+ */
+export { usePredictManagerAddress, type UsePredictManagerAddressArgs, } from "./usePredictManagerAddress.js";

package/dist/fhe-vesting/advanced/react/index.js

@@ -0,0 +1,73 @@
+import { buildQueryKey } from '../../../chunk-ECT3NL2L.js';
+import '../../../chunk-52TC6BF7.js';
+import '../../../chunk-ZXCOJY2Z.js';
+import '../../../chunk-XSNLAS5M.js';
+import '../../../chunk-FYQ2UW4T.js';
+import { createConfidentialVestingFactoryAdvancedClient } from '../../../chunk-CMRETRZO.js';
+import '../../../chunk-72YGZEQE.js';
+import '../../../chunk-JFLEEXKP.js';
+import { DEPLOYED_ADDRESSES } from '../../../chunk-COPFW5Z4.js';
+import '../../../chunk-BE2AIZ3K.js';
+import '../../../chunk-Q2GP5UDC.js';
+import '../../../chunk-KWFFIJYX.js';
+import '../../../chunk-IVE3QEGD.js';
+import { useRef, useMemo } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { usePublicClient, useWalletClient } from 'wagmi';
+
+function usePredictManagerAddress(args = {}) {
+  const {
+    token,
+    userSalt,
+    deployer,
+    blockNumber,
+    splitEnabled,
+    pausableEnabled,
+    address,
+    chainId,
+    publicClient
+  } = args;
+  const wagmiPublicClient = usePublicClient({ ...chainId !== void 0 ? { chainId } : {} });
+  const resolvedPublicClient = publicClient ?? wagmiPublicClient;
+  const { data: walletClient } = useWalletClient({
+    ...chainId !== void 0 ? { chainId } : {}
+  });
+  const resolvedChainId = chainId ?? resolvedPublicClient?.chain?.id;
+  const resolvedAddress = address ?? (resolvedChainId === void 0 ? void 0 : DEPLOYED_ADDRESSES.fheVesting?.confidentialVestingFactory?.[resolvedChainId] ?? void 0);
+  useRef(void 0);
+  const client = useMemo(() => {
+    if (!resolvedPublicClient) return void 0;
+    if (!resolvedAddress) return void 0;
+    return createConfidentialVestingFactoryAdvancedClient({
+      publicClient: resolvedPublicClient,
+      ...walletClient ? { walletClient } : {},
+      address: resolvedAddress,
+      ...resolvedChainId !== void 0 ? { chainId: resolvedChainId } : {}
+    });
+  }, [resolvedPublicClient, walletClient, resolvedAddress, resolvedChainId]);
+  return useQuery({
+    queryKey: buildQueryKey(
+      "factory:predictManagerAddress",
+      resolvedChainId,
+      resolvedAddress,
+      token,
+      userSalt,
+      deployer,
+      blockNumber,
+      splitEnabled ?? null,
+      pausableEnabled ?? null
+    ),
+    queryFn: () => client.predictManagerAddress({
+      token,
+      userSalt,
+      deployer,
+      blockNumber,
+      ...splitEnabled !== void 0 && { splitEnabled },
+      ...pausableEnabled !== void 0 && { pausableEnabled }
+    }),
+    enabled: !!client && !!token && !!userSalt && !!deployer && blockNumber !== void 0,
+    staleTime: 0
+  });
+}
+
+export { usePredictManagerAddress };

package/dist/fhe-vesting/advanced/react/usePredictManagerAddress.d.ts

@@ -0,0 +1,41 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address, Hex, PublicClient } from "viem";
+export interface UsePredictManagerAddressArgs {
+    token?: Address;
+    userSalt?: Hex;
+    deployer?: Address;
+    blockNumber?: bigint;
+    splitEnabled?: boolean;
+    pausableEnabled?: boolean;
+    /** Override the on-chain factory address. Defaults to {@link DEPLOYED_ADDRESSES}. */
+    address?: Address | undefined;
+    /** Override the chain id used for default address resolution. Defaults to `usePublicClient().chain?.id`. */
+    chainId?: number | undefined;
+    /** Override the viem `PublicClient` — bypasses the wagmi context. */
+    publicClient?: PublicClient | undefined;
+}
+/**
+ * Compute the deterministic CREATE2 clone address as the factory would have
+ * computed it at `blockNumber`.
+ *
+ * **Advanced surface — block-dependent.** The factory packs the deployment
+ * block number into the clone's immutable args, which feed into
+ * `keccak256(initCode)`. Predict at block N and mine at N+1 and you get
+ * different addresses. This hook is only useful for:
+ * - Historical lookups (verifying a clone deployed at a known past block).
+ * - Tightly-coupled same-tx flows (rare).
+ *
+ * **For the common "deploy a clone and learn its address" flow, prefer
+ * `useCreateManagerAndGetAddress`** on the headline React subpath — it parses
+ * the address out of the `ManagerCreated` event in the tx receipt without any
+ * block-number guessing.
+ *
+ * @example
+ * import { usePredictManagerAddress } from "@tokenops/sdk/fhe-vesting/advanced/react";
+ *
+ * // Historical lookup
+ * const { data: predictedAddress } = usePredictManagerAddress({
+ *   token, userSalt, deployer, blockNumber: 10_852_182n,
+ * });
+ */
+export declare function usePredictManagerAddress(args?: UsePredictManagerAddressArgs): UseQueryResult<Address, Error>;

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

@@ -0,0 +1,104 @@
+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. We restate it here instead of importing from the optional
+ * `@zama-fhe/sdk` peer dep.
+ */
+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 (`RelayerWeb`, `RelayerNode`, or a mock
+ * like `MockFhevmInstance`) without us importing the optional peer dep.
+ *
+ * The `values` shape matches Zama's `EncryptInput` discriminated union, so
+ * `relayer` instances satisfy this interface directly — no cast needed.
+ */
+export interface Encryptor {
+    encrypt(params: {
+        values: FheValueInput[];
+        contractAddress: Address;
+        userAddress: Address;
+    }): Promise<{
+        handles: Uint8Array[];
+        inputProof: Uint8Array;
+    }>;
+}
+/**
+ * Eager or lazy {@link Encryptor} reference. The lazy form (`() => Encryptor | undefined`)
+ * is for hosts where the encryptor instance lives in a context whose lifetime
+ * doesn't match the SDK client's — React contexts, Vue refs, signals, etc. The
+ * factory is invoked per-encryption, so the client always picks up the live
+ * instance without needing to be reconstructed when the host swaps it.
+ *
+ * Server-side and test code where the encryptor is built once at startup can
+ * keep passing an {@link Encryptor} directly; the union accepts both shapes.
+ */
+export type EncryptorSource = Encryptor | (() => Encryptor | undefined);
+/**
+ * Normalize an {@link EncryptorSource} to the underlying {@link Encryptor}, invoking the factory if lazy.
+ *
+ * @param source Eager encryptor instance or a lazy factory that returns one.
+ * @returns The resolved {@link Encryptor}, or `undefined` if `source` is `undefined` or the factory returned `undefined`.
+ * @example
+ * // Server / test — eager instance
+ * const encryptor = new RelayerNode({ transports: { ... }, getChainId: async () => sepolia.id });
+ * const resolved = resolveEncryptor(encryptor); // returns encryptor directly
+ *
+ * // React — lazy factory picks up the live ZamaSDK context
+ * const zamaSDK = useZamaSDK();
+ * const resolved = resolveEncryptor(() => zamaSDK.relayer);
+ */
+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.
+ *
+ * The handle and proof are bound to `contractAddress` and `userAddress` — they
+ * cannot be replayed against a different contract or sender.
+ *
+ * @param args Encryption request; `value` must fit in `uint64` (0 to 2^64-1).
+ * @returns `{ handle: Hex, inputProof: Hex }` — pass both to the contract.
+ * @example
+ * const encrypted = await encryptUint64({
+ *   encryptor, contractAddress: managerAddress,
+ *   userAddress: account.address, value: 1_000_000n,
+ * });
+ */
+export declare function encryptUint64({ encryptor, contractAddress, userAddress, value, }: EncryptUint64Args): Promise<EncryptedInput>;
+/**
+ * Encrypt N `uint64` values into N handles bound by a single input proof.
+ *
+ * Using a batch is more gas-efficient than N separate `encryptUint64` calls because
+ * the prover generates one proof for the entire set.
+ *
+ * @returns `{ handles: Hex[], inputProof: Hex }` — `handles[i]` corresponds to `values[i]`.
+ * @example
+ * const { handles, inputProof } = await encryptUint64Batch({
+ *   encryptor, contractAddress, userAddress,
+ *   values: [100_000n, 200_000n],
+ * });
+ */
+export declare function encryptUint64Batch({ encryptor, contractAddress, userAddress, values, }: EncryptUint64BatchArgs): Promise<EncryptedInputs>;

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

@@ -0,0 +1,183 @@
+import type { Address, Hex } from "viem";
+import { TokenOpsSdkError } from "../core/errors.js";
+import type { RevertNameMapper } from "../core/revert-mapper.js";
+/** Vesting schedule with this ID does not exist. */
+export declare class VestingNotFoundError extends TokenOpsSdkError {
+    readonly name = "VestingNotFoundError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        cause?: unknown;
+    });
+}
+/** Caller is not the recipient of this vesting schedule. */
+export declare class NotVestingRecipientError extends TokenOpsSdkError {
+    readonly name = "NotVestingRecipientError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        caller?: Address;
+        expectedRecipient?: Address;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        caller?: Address;
+        expectedRecipient?: Address;
+        cause?: unknown;
+    });
+}
+/**
+ * Vesting has a timelock and the current block timestamp has not yet reached
+ * it. `unlocksAt` is populated when the SDK has read the vesting info; UIs can
+ * render a countdown.
+ */
+export declare class ClaimLockedError extends TokenOpsSdkError {
+    readonly name = "ClaimLockedError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        /** Unix seconds. Multiply by 1000 for `new Date(...)`. */
+        unlocksAt?: number;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        unlocksAt?: number;
+        cause?: unknown;
+    });
+}
+/** Vesting has already been revoked. `revokedAt` is in unix seconds. */
+export declare class VestingRevokedError extends TokenOpsSdkError {
+    readonly name = "VestingRevokedError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        /** Unix seconds. Multiply by 1000 for `new Date(...)`. */
+        revokedAt?: number;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        revokedAt?: number;
+        cause?: unknown;
+    });
+}
+/** Vesting was created with `isRevocable: false` and cannot be revoked. */
+export declare class VestingNotRevocableError extends TokenOpsSdkError {
+    readonly name = "VestingNotRevocableError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        cause?: unknown;
+    });
+}
+/** Vesting has ended (`block.timestamp > endTimestamp`); admin actions like revoke are no longer valid. */
+export declare class VestingExpiredError extends TokenOpsSdkError {
+    readonly name = "VestingExpiredError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        /** Unix seconds. Multiply by 1000 for `new Date(...)`. */
+        endedAt?: number;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        endedAt?: number;
+        cause?: unknown;
+    });
+}
+/** A vesting transfer is already pending — initiate fails until accepted/cancelled/expired. */
+export declare class TransferAlreadyPendingError extends TokenOpsSdkError {
+    readonly name = "TransferAlreadyPendingError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        pendingRecipient?: Address;
+        /** Unix seconds. Multiply by 1000 for `new Date(...)`. */
+        expiresAt?: number;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        pendingRecipient?: Address;
+        expiresAt?: number;
+        cause?: unknown;
+    });
+}
+/** No pending transfer exists — cancel/accept fails until one is initiated. */
+export declare class NoPendingTransferError extends TokenOpsSdkError {
+    readonly name = "NoPendingTransferError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        cause?: unknown;
+    });
+}
+/** Caller is not the pending recipient of this transfer. */
+export declare class NotPendingRecipientError extends TokenOpsSdkError {
+    readonly name = "NotPendingRecipientError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        caller?: Address;
+        expectedRecipient?: Address;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        caller?: Address;
+        expectedRecipient?: Address;
+        cause?: unknown;
+    });
+}
+/** Pending transfer has expired and can no longer be accepted. */
+export declare class TransferExpiredError extends TokenOpsSdkError {
+    readonly name = "TransferExpiredError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        /** Unix seconds. Multiply by 1000 for `new Date(...)`. */
+        expiredAt?: number;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        vestingId: Hex;
+        expiredAt?: number;
+        cause?: unknown;
+    });
+}
+export declare const vestingProductMapper: RevertNameMapper;