@tokenops/sdk 1.0.0

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

@@ -0,0 +1,109 @@
+import type { Address, WalletClient } from "viem";
+import { type EncryptedHandle, type Signature } from "../core/brands.js";
+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.
+ */
+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. For airdrops the
+ * `userAddress` MUST be the **recipient** (not the admin), because the contract's
+ * `FHE.fromExternal` rejects proofs bound to any other address.
+ *
+ * @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: airdropAddress,
+ *   userAddress: recipientAddress, // must be the recipient, not the admin
+ *   value: 1_000_000n,             // raw token units; ERC-7984 uses 6 decimals
+ * });
+ * const signature = await signClaimAuthorization({
+ *   walletClient,
+ *   airdropAddress,
+ *   recipient: recipientAddress,
+ *   encryptedAmountHandle: encrypted.handle,
+ * });
+ */
+export declare function encryptUint64({ encryptor, contractAddress, userAddress, value, }: EncryptUint64Args): Promise<EncryptedInput>;
+/**
+ * Encrypt N `uint64` values into N handles bound by a single input proof.
+ */
+export declare function encryptUint64Batch({ encryptor, contractAddress, userAddress, values, }: EncryptUint64BatchArgs): Promise<EncryptedInputs>;
+/**
+ * Build an EIP712 signature for a `Claim(address recipient, bytes32 encryptedAmount)` struct.
+ *
+ * The admin calls this to sign a claim authorisation. The resulting `signature`
+ * is passed by the recipient to `claim()` or `getClaimAmount()`.
+ *
+ * @param args Claim signing request. `walletClient` must sign with DEFAULT_ADMIN_ROLE on the airdrop clone.
+ * @returns `0x`-prefixed ECDSA signature bytes.
+ */
+export declare function signClaimAuthorization(args: {
+    walletClient: WalletClient;
+    airdropAddress: Address;
+    recipient: Address;
+    encryptedAmountHandle: EncryptedHandle;
+}): Promise<Signature>;

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

@@ -0,0 +1,60 @@
+import type { Address } from "viem";
+import { TokenOpsSdkError } from "../core/errors.js";
+/**
+ * The admin-signed claim signature has already been used. Airdrops use a
+ * per-signature replay guard (`claimedSignatures[structHash]`); each signed
+ * `(recipient, encryptedAmount)` pair is single-use.
+ */
+export declare class AlreadyClaimedError extends TokenOpsSdkError {
+    readonly name = "AlreadyClaimedError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        caller?: Address;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        caller?: Address;
+        cause?: unknown;
+    });
+}
+/**
+ * The airdrop's claim window has not opened yet. `startsAt` is populated
+ * when the SDK has read the immutable start time; UIs can render a countdown.
+ */
+export declare class ClaimNotStartedError extends TokenOpsSdkError {
+    readonly name = "ClaimNotStartedError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        /** Unix seconds. Multiply by 1000 for `new Date(...)`. */
+        startsAt?: number;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        startsAt?: number;
+        cause?: unknown;
+    });
+}
+/**
+ * The airdrop's claim window has closed. `endedAt` is populated when the SDK
+ * has read the current end time. For airdrops with `CAN_EXTEND_CLAIM_WINDOW`
+ * set, the admin can extend via `extendClaimWindow`.
+ */
+export declare class ClaimWindowClosedError extends TokenOpsSdkError {
+    readonly name = "ClaimWindowClosedError";
+    readonly context: {
+        method: string;
+        contractAddress: Address;
+        /** Unix seconds. Multiply by 1000 for `new Date(...)`. */
+        endedAt?: number;
+    };
+    constructor(args: {
+        method: string;
+        contractAddress: Address;
+        endedAt?: number;
+        cause?: unknown;
+    });
+}

package/dist/fhe-airdrop/factory.d.ts

@@ -0,0 +1,281 @@
+import type { Account, Address, Hex, PublicClient, WalletClient } from "viem";
+import { type TxHash } from "../core/brands.js";
+import { type SdkTelemetry } from "../core/telemetry.js";
+import { type Encryptor, type EncryptorSource } from "./encryption.js";
+import type { AirdropParams, CustomFee, EncryptedInput } from "./types.js";
+export interface ConfidentialAirdropFactoryClientConfig {
+    publicClient: PublicClient;
+    walletClient?: WalletClient;
+    /** Override the on-chain factory address. Falls back to `getFheAirdropFactoryAddress(chainId)`. */
+    address?: Address;
+    /** Explicit chain id used to look up the default factory address. Defaults to `publicClient.chain?.id`. */
+    chainId?: number | undefined;
+    /**
+     * Default encryptor used by fund methods. Optional at construction time but
+     * required at call time for `createAndFundConfidentialAirdrop` and `fundConfidentialAirdrop`.
+     */
+    encryptor?: EncryptorSource | undefined;
+    /**
+     * Optional telemetry sink. When provided, the SDK emits a `fhe-airdrop.client.init`
+     * event on construction and brackets public write methods with named spans
+     * (`fhe-airdrop.factory.createConfidentialAirdrop`, `…createAndFundConfidentialAirdrop`, …).
+     * Defaults to a no-op — zero overhead, zero leakage of consumer-side identifiers.
+     *
+     * The shape is structurally compatible with `NoopTelemetry` / `ConsoleTelemetry` /
+     * `TokenOpsTelemetry` exported from `@tokenops/sdk/telemetry`.
+     */
+    telemetry?: SdkTelemetry | undefined;
+}
+export interface CreateAirdropArgs {
+    params: AirdropParams;
+    /** Any unique 32-byte salt. Combined with msg.sender to derive the CREATE2 salt. */
+    userSalt: Hex;
+    account?: Account | Address | undefined;
+}
+/** Common fields for {@link CreateAndFundAirdropArgs} — discriminated below. */
+interface CreateAndFundAirdropArgsCommon {
+    params: AirdropParams;
+    userSalt: Hex;
+    /**
+     * Plaintext token amount. The SDK encrypts via `encryptor`. Mutually
+     * exclusive with `encryptedInput` — supply exactly one.
+     */
+    amount?: bigint;
+    encryptor?: Encryptor;
+    /** Pre-encrypted input — mutually exclusive with `amount`. */
+    encryptedInput?: EncryptedInput;
+    account?: Account | Address;
+}
+/**
+ * Discriminated union: provide EITHER an encryptor (the SDK encrypts `amount`)
+ * OR a pre-built `encryptedInput`. Passing both is a compile error.
+ */
+export type CreateAndFundAirdropArgs = (CreateAndFundAirdropArgsCommon & {
+    /** Plaintext token amount. The SDK encrypts via `encryptor`. */
+    amount: bigint;
+    encryptor?: Encryptor | undefined;
+    encryptedInput?: never;
+}) | (CreateAndFundAirdropArgsCommon & {
+    /** Pre-encrypted input — bypasses `encryptor`. */
+    encryptedInput: EncryptedInput;
+    amount?: never;
+    encryptor?: never;
+});
+/** Common fields for {@link FundAirdropArgs} — discriminated below. */
+interface FundAirdropArgsCommon {
+    token: Address;
+    params: AirdropParams;
+    userSalt: Hex;
+    deployer: Address;
+    /**
+     * Gas fee in wei that was active for the deployer at airdrop creation time.
+     * Must match the value used when the clone was created (custom fee if one was
+     * set for that deployer, otherwise `defaultGasFee`). Determines the CREATE2
+     * salt and the predicted clone address — a mismatch will target the wrong address.
+     *
+     * Obtain via `factory.getCustomFee(deployer)` or `factory.defaultGasFee()`.
+     */
+    gasFee: bigint;
+    /**
+     * Plaintext token amount. The SDK encrypts via `encryptor`. Mutually
+     * exclusive with `encryptedInput` — supply exactly one.
+     */
+    amount?: bigint;
+    encryptor?: Encryptor;
+    /** Pre-encrypted input — mutually exclusive with `amount`. */
+    encryptedInput?: EncryptedInput;
+    account?: Account | Address;
+}
+/**
+ * Discriminated union: provide EITHER an encryptor (the SDK encrypts `amount`)
+ * OR a pre-built `encryptedInput`. Passing both is a compile error.
+ */
+export type FundAirdropArgs = (FundAirdropArgsCommon & {
+    /** Plaintext token amount. The SDK encrypts via `encryptor`. */
+    amount: bigint;
+    encryptor?: Encryptor | undefined;
+    encryptedInput?: never;
+}) | (FundAirdropArgsCommon & {
+    /** Pre-encrypted input — bypasses `encryptor`. */
+    encryptedInput: EncryptedInput;
+    amount?: never;
+    encryptor?: never;
+});
+/**
+ * Rich-return shape from {@link ConfidentialAirdropFactoryClient.createConfidentialAirdrop}
+ * and {@link ConfidentialAirdropFactoryClient.createAndFundConfidentialAirdrop}.
+ *
+ * Branded `hash: TxHash` and `airdrop: Address` so consumers can't accidentally
+ * swap them at the destructure site (R03 S-1 anti-footgun).
+ */
+export interface CreateAirdropResult {
+    /** Tx hash that deployed the clone. */
+    hash: TxHash;
+    /** Address of the deployed clone, parsed from the `ConfidentialAirdropCreated` event. */
+    airdrop: Address;
+}
+export interface PredictAirdropArgs {
+    params: AirdropParams;
+    userSalt: Hex;
+    deployer: Address;
+    /**
+     * Gas fee in wei to embed into the CREATE2 salt computation.
+     * Must match the fee that will be (or was) active for `deployer` at deploy time:
+     * custom fee if `getCustomFee(deployer).enabled`, otherwise `defaultGasFee`.
+     *
+     * Passing the wrong value produces a different address than the deployed clone.
+     */
+    gasFee: bigint;
+}
+/**
+ * Typed wrapper around the deployed `ConfidentialAirdropFactory`. Resolves the
+ * factory address per chain and encapsulates FHE encryption for fund methods.
+ *
+ * @example
+ * const factory = createConfidentialAirdropFactoryClient({ publicClient, walletClient, encryptor });
+ * const hash = await factory.createConfidentialAirdrop({ params, userSalt });
+ */
+export declare class ConfidentialAirdropFactoryClient {
+    #private;
+    readonly publicClient: PublicClient;
+    readonly walletClient?: WalletClient;
+    readonly address: Address;
+    readonly encryptor?: EncryptorSource;
+    constructor(config: ConfidentialAirdropFactoryClientConfig);
+    /**
+     * Deploy a new airdrop clone via the factory and return its address, parsed
+     * from the `ConfidentialAirdropCreated` event in the tx receipt.
+     *
+     * **This is the headline factory entry point.** R02 ADR P-1 collapses the
+     * old hash-only + `…AndGetAddress` pair down to one rich-return method —
+     * 90 %+ of consumers want the deployed address back, and the SDK already
+     * waits + parses the event, so there's no reason to make consumers do it
+     * themselves.
+     *
+     * Internally: `writeContract` → {@link PublicClient.waitForTransactionReceipt} →
+     * `parseEventLogs({ eventName: "ConfidentialAirdropCreated" })`.
+     *
+     * For genuine pre-mine prediction (rare), import
+     * `ConfidentialAirdropFactoryAdvancedClient` from
+     * `@tokenops/sdk/fhe-airdrop/advanced` and call `predictAirdropAddress`.
+     *
+     * @example
+     * const { hash, airdrop } = await factory.createConfidentialAirdrop({
+     *   params, userSalt,
+     * });
+     */
+    createConfidentialAirdrop(args: CreateAirdropArgs): Promise<CreateAirdropResult>;
+    /**
+     * Deploy and fund a new airdrop in a single transaction, and return its
+     * address. The SDK encrypts `amount` into an `externalEuint64` before
+     * passing to the contract.
+     *
+     * Prerequisites: caller must have set this factory as an operator on the
+     * token: `token.setOperator(factoryAddress, deadline)`.
+     *
+     * Symmetric with {@link ConfidentialAirdropFactoryClient.createConfidentialAirdrop}
+     * — both return `{ hash, airdrop }` parsed from the
+     * `ConfidentialAirdropCreated` event (R02 ADR P-1).
+     *
+     * @example
+     * const { hash, airdrop } = await factory.createAndFundConfidentialAirdrop({
+     *   params, userSalt, amount: 1_000_000n,
+     * });
+     */
+    createAndFundConfidentialAirdrop(args: CreateAndFundAirdropArgs): Promise<CreateAirdropResult>;
+    /**
+     * Fund an existing (or not-yet-deployed) airdrop with encrypted tokens.
+     *
+     * Prerequisites: caller must have set this factory as an operator on the token:
+     * `token.setOperator(factoryAddress, deadline)`
+     *
+     * @returns Transaction hash.
+     */
+    fundConfidentialAirdrop(args: FundAirdropArgs): Promise<Hex>;
+    /**
+     * Deploy a new airdrop clone and return its address, parsed from the
+     * `ConfidentialAirdropCreated` event in the tx receipt.
+     *
+     * Symmetry helper with the fhe-vesting client. Use this when you want a
+     * one-call "deploy and use" shape; otherwise call
+     * {@link ConfidentialAirdropFactoryClient.createConfidentialAirdrop} and parse
+     * the receipt yourself, or call
+     * {@link ConfidentialAirdropFactoryClient.predictAirdropAddress} before mining.
+     *
+     * Internally: {@link ConfidentialAirdropFactoryClient.createConfidentialAirdrop} →
+     * {@link PublicClient.waitForTransactionReceipt} →
+     * `parseEventLogs({ eventName: "ConfidentialAirdropCreated" })`.
+     *
+     * @example
+     * const { hash, airdrop } = await factory.createConfidentialAirdropAndGetAddress({
+     *   params, userSalt,
+     * });
+     */
+    createConfidentialAirdropAndGetAddress(args: CreateAirdropArgs): Promise<CreateAirdropResult>;
+    /**
+     * Deploy AND fund a new airdrop clone in one tx, returning its address parsed
+     * from the `ConfidentialAirdropCreated` event in the receipt.
+     *
+     * Symmetry with {@link ConfidentialAirdropFactoryClient.createConfidentialAirdropAndGetAddress}
+     * — use this when you also need to seed the pool in the same transaction.
+     *
+     * Internally: {@link ConfidentialAirdropFactoryClient.createAndFundConfidentialAirdrop} →
+     * {@link PublicClient.waitForTransactionReceipt} →
+     * `parseEventLogs({ eventName: "ConfidentialAirdropCreated" })`.
+     *
+     * @example
+     * const { hash, airdrop } = await factory.createAndFundConfidentialAirdropAndGetAddress({
+     *   params, userSalt, amount, encryptor,
+     * });
+     */
+    createAndFundConfidentialAirdropAndGetAddress(args: CreateAndFundAirdropArgs): Promise<CreateAirdropResult>;
+    /** Change the fee collector address. FEE_MANAGER_ROLE only. */
+    setFeeCollector(newFeeCollector: Address, account?: Account | Address): Promise<TxHash>;
+    /** Change the default per-claim gas fee in wei. FEE_MANAGER_ROLE only. */
+    setDefaultGasFee(newGasFee: bigint, account?: Account | Address): Promise<TxHash>;
+    /** Set a per-creator gas fee override. FEE_MANAGER_ROLE only. */
+    setCustomFee(campaignCreator: Address, gasFee: bigint, account?: Account | Address): Promise<TxHash>;
+    /** Remove a per-creator fee override, reverting to `defaultGasFee`. FEE_MANAGER_ROLE only. */
+    disableCustomFee(campaignCreator: Address, account?: Account | Address): Promise<TxHash>;
+    /** Current LibClone implementation address. */
+    implementation(): Promise<Address>;
+    /**
+     * Alias for {@link ConfidentialAirdropFactoryClient.implementation} that matches
+     * the contract's storage field name (`_airdropImplementation`).
+     *
+     * Shipped proactively in R17 for parity with `fhe-vesting`'s
+     * `managerImplementation()` alias (commit 6f6d7bc, closing
+     * backend-integrator-r14 minor). The airdrop factory has the same
+     * LibClone shape mirroring `_airdropImplementation` storage, so server
+     * devs reading the Solidity first reach for `factory.airdropImplementation()`
+     * via autocomplete and would otherwise hit a TS2551 on the SDK's
+     * `implementation()` shape. The canonical `implementation()` method is
+     * retained for backwards-compat and cross-factory uniformity.
+     */
+    airdropImplementation(): Promise<Address>;
+    /** Default per-claim gas fee in wei. Used when no custom fee is set for the campaign creator. */
+    defaultGasFee(): Promise<bigint>;
+    /** Address authorized to collect gas fees from airdrop clones. */
+    feeCollector(): Promise<Address>;
+    /** Per-creator custom fee override. `enabled` is `false` when no override is set. */
+    getCustomFee(campaignCreator: Address): Promise<CustomFee>;
+    /**
+     * Compute the CREATE2 init-code hash for a given set of params and gas fee.
+     * Useful for deriving the clone address off-chain. Use `predictAirdropAddress` from
+     * `@tokenops/sdk/fhe-airdrop/advanced` for the full address derivation.
+     * @param args `{ params, gasFee }` — must match the values used at deploy time.
+     * @returns `bytes32` init-code hash.
+     */
+    getInitCodeHash(args: {
+        params: AirdropParams;
+        gasFee: bigint;
+    }): Promise<Hex>;
+}
+/**
+ * Create a {@link ConfidentialAirdropFactoryClient}. Mirrors viem's `create*` convention.
+ *
+ * @example
+ * const factory = createConfidentialAirdropFactoryClient({ publicClient, walletClient, encryptor });
+ */
+export declare function createConfidentialAirdropFactoryClient(config: ConfidentialAirdropFactoryClientConfig): ConfidentialAirdropFactoryClient;
+export {};

package/dist/fhe-airdrop/index.cjs

@@ -0,0 +1,227 @@
+'use strict';
+
+var chunk5SA2HF2W_cjs = require('../chunk-5SA2HF2W.cjs');
+var chunk6ECAHP5O_cjs = require('../chunk-6ECAHP5O.cjs');
+var chunkFWHYQZ5E_cjs = require('../chunk-FWHYQZ5E.cjs');
+require('../chunk-Q7ARQSUH.cjs');
+require('../chunk-VDXVNZCO.cjs');
+require('../chunk-OLDGMKW2.cjs');
+require('../chunk-CQIPRNS7.cjs');
+require('../chunk-VJKZWYYJ.cjs');
+var chunk66IHPTOK_cjs = require('../chunk-66IHPTOK.cjs');
+var chunk56UI7LUR_cjs = require('../chunk-56UI7LUR.cjs');
+
+
+
+Object.defineProperty(exports, "AlreadyClaimedError", {
+  enumerable: true,
+  get: function () { return chunk5SA2HF2W_cjs.AlreadyClaimedError; }
+});
+Object.defineProperty(exports, "ClaimNotStartedError", {
+  enumerable: true,
+  get: function () { return chunk5SA2HF2W_cjs.ClaimNotStartedError; }
+});
+Object.defineProperty(exports, "ClaimWindowClosedError", {
+  enumerable: true,
+  get: function () { return chunk5SA2HF2W_cjs.ClaimWindowClosedError; }
+});
+Object.defineProperty(exports, "ConfidentialAirdropClient", {
+  enumerable: true,
+  get: function () { return chunk5SA2HF2W_cjs.ConfidentialAirdropClient; }
+});
+Object.defineProperty(exports, "confidentialAirdropCloneableAbi", {
+  enumerable: true,
+  get: function () { return chunk5SA2HF2W_cjs.confidentialAirdropCloneableAbi; }
+});
+Object.defineProperty(exports, "createConfidentialAirdropClient", {
+  enumerable: true,
+  get: function () { return chunk5SA2HF2W_cjs.createConfidentialAirdropClient; }
+});
+Object.defineProperty(exports, "ConfidentialAirdropFactoryClient", {
+  enumerable: true,
+  get: function () { return chunk6ECAHP5O_cjs.ConfidentialAirdropFactoryClient; }
+});
+Object.defineProperty(exports, "confidentialAirdropFactoryAbi", {
+  enumerable: true,
+  get: function () { return chunk6ECAHP5O_cjs.confidentialAirdropFactoryAbi; }
+});
+Object.defineProperty(exports, "createConfidentialAirdropFactoryClient", {
+  enumerable: true,
+  get: function () { return chunk6ECAHP5O_cjs.createConfidentialAirdropFactoryClient; }
+});
+Object.defineProperty(exports, "encryptUint64", {
+  enumerable: true,
+  get: function () { return chunk6ECAHP5O_cjs.encryptUint64; }
+});
+Object.defineProperty(exports, "encryptUint64Batch", {
+  enumerable: true,
+  get: function () { return chunk6ECAHP5O_cjs.encryptUint64Batch; }
+});
+Object.defineProperty(exports, "resolveEncryptor", {
+  enumerable: true,
+  get: function () { return chunk6ECAHP5O_cjs.resolveEncryptor; }
+});
+Object.defineProperty(exports, "signClaimAuthorization", {
+  enumerable: true,
+  get: function () { return chunk6ECAHP5O_cjs.signClaimAuthorization; }
+});
+Object.defineProperty(exports, "erc7984OperatorAbi", {
+  enumerable: true,
+  get: function () { return chunkFWHYQZ5E_cjs.erc7984OperatorAbi; }
+});
+Object.defineProperty(exports, "asAirdropId", {
+  enumerable: true,
+  get: function () { return chunk66IHPTOK_cjs.asAirdropId; }
+});
+Object.defineProperty(exports, "asEncryptedHandle", {
+  enumerable: true,
+  get: function () { return chunk66IHPTOK_cjs.asEncryptedHandle; }
+});
+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; }
+});