@zama-fhe/sdk 1.0.0-alpha.10

package/dist/token.types-CUTkehsp.d.ts

@@ -0,0 +1,299 @@
+import { Address } from '@zama-fhe/relayer-sdk/bundle';
+import { E as EIP712TypedData, H as Hex } from './relayer-sdk.types-CgHZ6qZn.js';
+
+/**
+ * Framework-agnostic event decoders for confidential token contracts.
+ * No viem/ethers dependency — works with raw log data from any provider.
+ */
+
+/** Framework-agnostic log shape compatible with any Ethereum provider. */
+interface RawLog {
+    /** Indexed event topics (topic[0] is the event signature hash). */
+    readonly topics: readonly string[];
+    /** ABI-encoded non-indexed event data. */
+    readonly data: string;
+}
+/**
+ * Event topic0 constants (keccak256 of the canonical Solidity signature).
+ * Pass to `getLogs({ topics: [Object.values(Topics)] })` to fetch all events.
+ */
+declare const Topics: {
+    /** `ConfidentialTransfer(address indexed from, address indexed to, bytes32 indexed amount)` */
+    readonly ConfidentialTransfer: "0x67500e8d0ed826d2194f514dd0d8124f35648ab6e3fb5e6ed867134cffe661e9";
+    /** `Wrapped(uint64 mintAmount, uint256 amountIn, uint256 feeAmount, address indexed to_, uint256 indexed mintTxId)` */
+    readonly Wrapped: "0x1f7907f4d84043abe0fb7c74e8865ee5fe93fe4f691c54a7b8fa9d6fb17c7cba";
+    /** `UnwrapRequested(address indexed receiver, bytes32 amount)` */
+    readonly UnwrapRequested: "0x77d02d353c5629272875d11f1b34ec4c65d7430b075575b78cd2502034c469ee";
+    /** `UnwrappedFinalized(bytes32 indexed burntAmountHandle, ...)` */
+    readonly UnwrappedFinalized: "0xc64e7c81b18b674fc5b037d8a0041bfe3332d86c780a4688f404ee01fbabb152";
+    /** `UnwrappedStarted(bool returnVal, uint256 indexed requestId, ...)` */
+    readonly UnwrappedStarted: "0x3838891d4843c6d7f9f494570b6fd8843f4e3c3ddb817c1411760bd31b819806";
+};
+/** Decoded `ConfidentialTransfer` event — an encrypted token transfer. */
+interface ConfidentialTransferEvent {
+    readonly eventName: "ConfidentialTransfer";
+    /** Sender address. */
+    readonly from: string;
+    /** Receiver address. */
+    readonly to: string;
+    /** FHE ciphertext handle for the transferred amount. */
+    readonly encryptedAmountHandle: string;
+}
+/** Decoded `Wrapped` event — an ERC-20 shield (wrap) operation. */
+interface WrappedEvent {
+    readonly eventName: "Wrapped";
+    /** Confidential tokens minted. */
+    readonly mintAmount: bigint;
+    /** Underlying ERC-20 tokens deposited. */
+    readonly amountIn: bigint;
+    /** Fee deducted during wrapping. */
+    readonly feeAmount: bigint;
+    /** Receiver of the minted confidential tokens. */
+    readonly to: string;
+    /** On-chain mint transaction ID. */
+    readonly mintTxId: bigint;
+}
+/** Decoded `UnwrapRequested` event — an unshield request submitted. */
+interface UnwrapRequestedEvent {
+    readonly eventName: "UnwrapRequested";
+    /** Address that will receive the unwrapped ERC-20 tokens. */
+    readonly receiver: string;
+    /** FHE ciphertext handle for the requested unshield amount. */
+    readonly encryptedAmount: Address;
+}
+/** Decoded `UnwrappedFinalized` event — an unshield completed on-chain. */
+interface UnwrappedFinalizedEvent {
+    readonly eventName: "UnwrappedFinalized";
+    /** FHE handle of the burnt confidential balance. */
+    readonly burntAmountHandle: string;
+    /** Whether the finalization succeeded. */
+    readonly finalizeSuccess: boolean;
+    /** Whether the fee transfer succeeded. */
+    readonly feeTransferSuccess: boolean;
+    /** Amount of confidential tokens burnt. */
+    readonly burnAmount: bigint;
+    /** Amount of underlying ERC-20 tokens returned. */
+    readonly unwrapAmount: bigint;
+    /** Fee deducted during unwrapping. */
+    readonly feeAmount: bigint;
+    /** Next on-chain transaction ID. */
+    readonly nextTxId: bigint;
+}
+/** Decoded `UnwrappedStarted` event — the relayer began processing an unshield. */
+interface UnwrappedStartedEvent {
+    readonly eventName: "UnwrappedStarted";
+    /** Whether the unwrap start succeeded. */
+    readonly returnVal: boolean;
+    /** On-chain request ID. */
+    readonly requestId: bigint;
+    /** On-chain transaction ID. */
+    readonly txId: bigint;
+    /** Receiver address. */
+    readonly to: string;
+    /** Refund address (if applicable). */
+    readonly refund: string;
+    /** FHE handle of the requested amount. */
+    readonly requestedAmount: string;
+    /** FHE handle of the burn amount. */
+    readonly burnAmount: string;
+}
+/** Union of all decoded confidential token event types. */
+type OnChainEvent = ConfidentialTransferEvent | WrappedEvent | UnwrapRequestedEvent | UnwrappedFinalizedEvent | UnwrappedStartedEvent;
+/**
+ * ConfidentialTransfer(address indexed from, address indexed to, bytes32 indexed amount)
+ * All 3 params indexed → topics[1..3], no data.
+ */
+declare function decodeConfidentialTransfer(log: RawLog): ConfidentialTransferEvent | null;
+/**
+ * Wrapped(uint64 mintAmount, uint256 amountIn, uint256 feeAmount, address indexed to_, uint256 indexed mintTxId)
+ * Indexed: to_ (topics[1]), mintTxId (topics[2])
+ * Data: mintAmount (uint64, abi-encoded as uint256), amountIn, feeAmount
+ */
+declare function decodeWrapped(log: RawLog): WrappedEvent | null;
+/**
+ * UnwrapRequested(address indexed receiver, bytes32 amount)
+ * Indexed: receiver (topics[1])
+ * Data: amount (bytes32)
+ */
+declare function decodeUnwrapRequested(log: RawLog): UnwrapRequestedEvent | null;
+/**
+ * UnwrappedFinalized(bytes32 indexed burntAmountHandle, bool finalizeSuccess, bool feeTransferSuccess,
+ *                    uint64 burnAmount, uint256 unwrapAmount, uint256 feeAmount, uint256 indexed nextTxId)
+ * Indexed: burntAmountHandle (topics[1]), nextTxId (topics[2])
+ * Data: finalizeSuccess, feeTransferSuccess, burnAmount, unwrapAmount, feeAmount
+ */
+declare function decodeUnwrappedFinalized(log: RawLog): UnwrappedFinalizedEvent | null;
+/**
+ * UnwrappedStarted(bool returnVal, uint256 indexed requestId, uint256 indexed txId, address indexed to,
+ *                  address refund, bytes32 requestedAmount, bytes32 burnAmount)
+ * Indexed: requestId (topics[1]), txId (topics[2]), to (topics[3])
+ * Data: returnVal, refund, requestedAmount, burnAmount
+ */
+declare function decodeUnwrappedStarted(log: RawLog): UnwrappedStartedEvent | null;
+/**
+ * Try all decoders on a single log and return the first match, or `null`.
+ *
+ * @example
+ * ```ts
+ * const event = decodeOnChainEvent(log);
+ * if (event?.eventName === "ConfidentialTransfer") {
+ *   console.log(event.from, event.to);
+ * }
+ * ```
+ */
+declare function decodeOnChainEvent(log: RawLog): OnChainEvent | null;
+/**
+ * Batch-decode an array of logs, skipping unrecognized entries.
+ *
+ * @example
+ * ```ts
+ * const events = decodeOnChainEvents(receipt.logs);
+ * ```
+ */
+declare function decodeOnChainEvents(logs: readonly RawLog[]): OnChainEvent[];
+/**
+ * Find the first {@link UnwrapRequestedEvent} in a logs array.
+ *
+ * @example
+ * ```ts
+ * const event = findUnwrapRequested(receipt.logs);
+ * if (event) console.log(event.receiver, event.encryptedAmount);
+ * ```
+ */
+declare function findUnwrapRequested(logs: readonly RawLog[]): UnwrapRequestedEvent | null;
+/**
+ * Find the first {@link WrappedEvent} in a logs array.
+ *
+ * @example
+ * ```ts
+ * const event = findWrapped(receipt.logs);
+ * if (event) console.log(event.to, event.amountIn);
+ * ```
+ */
+declare function findWrapped(logs: readonly RawLog[]): WrappedEvent | null;
+/**
+ * All 5 confidential token event topic0 hashes.
+ * Pass to `getLogs({ topics: [TOKEN_TOPICS] })` to fetch
+ * all confidential token events in a single RPC call.
+ */
+declare const TOKEN_TOPICS: readonly ["0x67500e8d0ed826d2194f514dd0d8124f35648ab6e3fb5e6ed867134cffe661e9", "0x1f7907f4d84043abe0fb7c74e8865ee5fe93fe4f691c54a7b8fa9d6fb17c7cba", "0x77d02d353c5629272875d11f1b34ec4c65d7430b075575b78cd2502034c469ee", "0xc64e7c81b18b674fc5b037d8a0041bfe3332d86c780a4688f404ee01fbabb152", "0x3838891d4843c6d7f9f494570b6fd8843f4e3c3ddb817c1411760bd31b819806"];
+
+/** Framework-agnostic transaction receipt (only the fields the SDK needs). */
+interface TransactionReceipt {
+    /** Event logs emitted during the transaction. */
+    readonly logs: readonly RawLog[];
+}
+/** Result of a write operation: the tx hash and its mined receipt. */
+interface TransactionResult {
+    /** The transaction hash. */
+    txHash: Hex;
+    /** The mined transaction receipt. */
+    receipt: TransactionReceipt;
+}
+/**
+ * Minimal contract call configuration.
+ * Matches the shape returned by contract call builder functions in `src/contracts/`.
+ */
+interface ContractCallConfig {
+    /** Target contract address. */
+    readonly address: Address;
+    /** ABI fragment for the function being called. */
+    readonly abi: readonly unknown[];
+    /** Solidity function name. */
+    readonly functionName: string;
+    /** Encoded function arguments. */
+    readonly args: readonly unknown[];
+    /** Native value to send with the transaction (for payable functions). */
+    readonly value?: bigint;
+    /** Gas limit override. */
+    readonly gas?: bigint;
+}
+/** Callbacks for signer lifecycle events (wallet disconnect, account switch). */
+interface SignerLifecycleCallbacks {
+    /** Called when the wallet disconnects. */
+    onDisconnect?: () => void;
+    /** Called when the active account changes. */
+    onAccountChange?: (newAddress: Address) => void;
+}
+/**
+ * Framework-agnostic signer interface.
+ * Wallet devs implement this with their library of choice.
+ * The React SDK ships pre-built adapters for wagmi/viem/ethers.
+ */
+interface GenericSigner {
+    /** Return the chain ID of the connected network. */
+    getChainId(): Promise<number>;
+    /** The connected wallet address. */
+    getAddress: () => Promise<Address>;
+    /** Sign EIP-712 typed data (used for decrypt authorization). */
+    signTypedData(typedData: EIP712TypedData): Promise<Hex>;
+    /** Send a write transaction and return the tx hash. */
+    writeContract<C extends ContractCallConfig>(config: C): Promise<Hex>;
+    /** Execute a read-only call and return the decoded result. */
+    readContract<T = unknown, C extends ContractCallConfig = ContractCallConfig>(config: C): Promise<T>;
+    /** Wait for a transaction to be mined and return its receipt. */
+    waitForTransactionReceipt(hash: Hex): Promise<TransactionReceipt>;
+    /**
+     * Subscribe to wallet lifecycle events (disconnect, account change).
+     * Returns an unsubscribe function. When no EIP-1193 provider is available,
+     * returns a no-op unsubscribe.
+     *
+     * Optional — server-side signers or custom implementations that don't
+     * support lifecycle events can omit this method entirely.
+     */
+    subscribe?: (callbacks: SignerLifecycleCallbacks) => () => void;
+}
+/**
+ * Pluggable key-value store for persisting FHE credentials.
+ *
+ * The SDK stores objects directly (not JSON strings). Implementations must
+ * preserve value types through round-trips — e.g. `IndexedDBStorage` uses
+ * structured clone, `MemoryStorage` stores values as-is. If your custom
+ * backend serializes to JSON internally, it must handle `JSON.parse` /
+ * `JSON.stringify` transparently so callers always receive the original type.
+ */
+interface GenericStorage {
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+/** Stored FHE credential data (serialized as JSON in the credential store). */
+interface StoredCredentials {
+    /** FHE public key (hex-encoded). */
+    publicKey: string;
+    /** FHE private key (hex-encoded, encrypted at rest via AES-GCM). */
+    privateKey: string;
+    /** EIP-712 signature authorizing decryption. */
+    signature: string;
+    /** Contract addresses this credential is authorized for. */
+    contractAddresses: Address[];
+    /** Unix timestamp (seconds) when the credential became valid. */
+    startTimestamp: number;
+    /** Number of days the credential remains valid. */
+    durationDays: number;
+}
+/** Progress callbacks for multi-step unshield operations. */
+interface UnshieldCallbacks {
+    /** Fired after the unwrap transaction is submitted. */
+    onUnwrapSubmitted?: (txHash: Hex) => void;
+    /** Fired when the finalization step begins (receipt parsed, about to finalize). */
+    onFinalizing?: () => void;
+    /** Fired after the finalize transaction is submitted. */
+    onFinalizeSubmitted?: (txHash: Hex) => void;
+}
+/** Progress callbacks for multi-step shield operations. */
+interface ShieldCallbacks {
+    /** Fired after the ERC-20 approval transaction is submitted (skipped when `approvalStrategy: "skip"`). */
+    onApprovalSubmitted?: (txHash: Hex) => void;
+    /** Fired after the shield (wrap) transaction is submitted. */
+    onShieldSubmitted?: (txHash: Hex) => void;
+}
+/** Progress callbacks for multi-step confidential transfer operations. */
+interface TransferCallbacks {
+    /** Fired after FHE encryption of the transfer amount completes. */
+    onEncryptComplete?: () => void;
+    /** Fired after the transfer transaction is submitted. */
+    onTransferSubmitted?: (txHash: Hex) => void;
+}
+
+export { type ContractCallConfig as C, type GenericSigner as G, type OnChainEvent as O, type RawLog as R, type SignerLifecycleCallbacks as S, type TransactionReceipt as T, type UnshieldCallbacks as U, type WrappedEvent as W, type GenericStorage as a, type StoredCredentials as b, type TransferCallbacks as c, type TransactionResult as d, type ShieldCallbacks as e, type ConfidentialTransferEvent as f, TOKEN_TOPICS as g, Topics as h, type UnwrapRequestedEvent as i, type UnwrappedFinalizedEvent as j, type UnwrappedStartedEvent as k, decodeConfidentialTransfer as l, decodeOnChainEvent as m, decodeOnChainEvents as n, decodeUnwrapRequested as o, decodeUnwrappedFinalized as p, decodeUnwrappedStarted as q, decodeWrapped as r, findUnwrapRequested as s, findWrapped as t };

package/dist/transfer-batcher-CNtrNMz6.d.ts

@@ -0,0 +1,197 @@
+import { Address } from '@zama-fhe/relayer-sdk/bundle';
+
+/** Batch transfer data for confidentialBatchTransfer. */
+interface BatchTransferData {
+    to: Address;
+    encryptedAmount: Address;
+    inputProof: Address;
+    retryFor: bigint;
+}
+/**
+ * Returns the contract config for a confidential batch transfer.
+ *
+ * @example
+ * ```ts
+ * const txHash = await signer.writeContract(
+ *   confidentialBatchTransferContract(batcherAddress, tokenAddress, fromAddress, data, fees),
+ * );
+ * ```
+ */
+declare function confidentialBatchTransferContract(batcherAddress: Address, tokenAddress: Address, fromAddress: Address, batchTransferData: BatchTransferData[], fees: bigint): {
+    readonly address: `0x${string}`;
+    readonly abi: readonly [{
+        readonly inputs: readonly [{
+            readonly internalType: "contract AdminProvider";
+            readonly name: "adminProvider_";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "nonpayable";
+        readonly type: "constructor";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "holder";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "spender";
+            readonly type: "address";
+        }];
+        readonly name: "ERC7984UnauthorizedSpender";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "EmptyTransferArray";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "FeeTransferFailed";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "InsufficientFee";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "OnlyOriginalSenderCanRetry";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "ZamaProtocolUnsupported";
+        readonly type: "error";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "cToken";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "startTxId";
+            readonly type: "uint256";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "endTxId";
+            readonly type: "uint256";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "fee";
+            readonly type: "uint256";
+        }];
+        readonly name: "BatchTransfer";
+        readonly type: "event";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "cToken";
+            readonly type: "address";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "originalTxId";
+            readonly type: "uint256";
+        }, {
+            readonly indexed: false;
+            readonly internalType: "uint256";
+            readonly name: "retryTxId";
+            readonly type: "uint256";
+        }];
+        readonly name: "RetryTransfer";
+        readonly type: "event";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "adminProvider";
+        readonly outputs: readonly [{
+            readonly internalType: "contract AdminProvider";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "contract RegulatedERC7984Upgradeable";
+            readonly name: "cToken";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "from";
+            readonly type: "address";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "to";
+                readonly type: "address";
+            }, {
+                readonly internalType: "externalEuint64";
+                readonly name: "encryptedAmount";
+                readonly type: "bytes32";
+            }, {
+                readonly internalType: "bytes";
+                readonly name: "inputProof";
+                readonly type: "bytes";
+            }, {
+                readonly internalType: "uint256";
+                readonly name: "retryFor";
+                readonly type: "uint256";
+            }];
+            readonly internalType: "struct ERC7984TransferBatcher.ConfidentialTransferInput[]";
+            readonly name: "transfers";
+            readonly type: "tuple[]";
+        }];
+        readonly name: "confidentialBatchTransfer";
+        readonly outputs: readonly [];
+        readonly stateMutability: "payable";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "confidentialProtocolId";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "cToken";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "txId";
+            readonly type: "uint256";
+        }];
+        readonly name: "txIdToSender";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "sender";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
+    }];
+    readonly functionName: "confidentialBatchTransfer";
+    readonly args: readonly [`0x${string}`, `0x${string}`, BatchTransferData[]];
+    readonly value: bigint;
+    readonly gas: 5000000n;
+};
+
+export { type BatchTransferData as B, confidentialBatchTransferContract as c };

package/dist/viem/index.d.ts

@@ -0,0 +1,58 @@
+import { WalletClient, PublicClient, EIP1193Provider } from 'viem';
+import { E as EIP712TypedData, H as Hex } from '../relayer-sdk.types-CgHZ6qZn.js';
+import { G as GenericSigner, C as ContractCallConfig, T as TransactionReceipt, S as SignerLifecycleCallbacks } from '../token.types-CUTkehsp.js';
+export { R as RawLog } from '../token.types-CUTkehsp.js';
+import { Address } from '@zama-fhe/relayer-sdk/bundle';
+import { B as BatchTransferData } from '../transfer-batcher-CNtrNMz6.js';
+
+/**
+ * Configuration for {@link ViemSigner}.
+ *
+ * The optional `ethereum` field is needed for `subscribe()` (EIP-1193
+ * `accountsChanged` / `disconnect` events). It cannot be auto-extracted from
+ * `walletClient` because viem's `custom(ethereum)` transport captures the
+ * provider in a closure and does **not** expose `on` / `removeListener` on
+ * `walletClient.transport`.
+ *
+ * If you omit `ethereum`, `subscribe()` returns a no-op. For automatic
+ * wallet lifecycle handling, consider using `WagmiSigner` instead.
+ */
+interface ViemSignerConfig {
+    walletClient: WalletClient;
+    publicClient: PublicClient;
+    ethereum?: EIP1193Provider;
+}
+/**
+ * GenericSigner backed by viem.
+ *
+ * @param config - {@link ViemSignerConfig} with walletClient and publicClient
+ */
+declare class ViemSigner implements GenericSigner {
+    private readonly walletClient;
+    private readonly publicClient;
+    private readonly ethereum?;
+    constructor(config: ViemSignerConfig);
+    getChainId(): Promise<number>;
+    getAddress(): Promise<Address>;
+    signTypedData(typedData: EIP712TypedData): Promise<Hex>;
+    writeContract<C extends ContractCallConfig = ContractCallConfig>(config: C): Promise<Hex>;
+    readContract<T, C extends ContractCallConfig = ContractCallConfig>(config: C): Promise<T>;
+    waitForTransactionReceipt(hash: Hex): Promise<TransactionReceipt>;
+    subscribe(callbacks: SignerLifecycleCallbacks): () => void;
+}
+
+declare function readConfidentialBalanceOfContract(client: PublicClient, tokenAddress: Address, userAddress: Address): Promise<`0x${string}`>;
+declare function readWrapperForTokenContract(client: PublicClient, coordinator: Address, tokenAddress: Address): Promise<`0x${string}`>;
+declare function readUnderlyingTokenContract(client: PublicClient, wrapperAddress: Address): Promise<`0x${string}`>;
+declare function readWrapperExistsContract(client: PublicClient, coordinator: Address, tokenAddress: Address): Promise<boolean>;
+declare function readSupportsInterfaceContract(client: PublicClient, tokenAddress: Address, interfaceId: Address): Promise<boolean>;
+declare function writeConfidentialTransferContract(client: WalletClient, tokenAddress: Address, to: Address, handle: Uint8Array, inputProof: Uint8Array): Promise<`0x${string}`>;
+declare function writeConfidentialBatchTransferContract(client: WalletClient, batcherAddress: Address, tokenAddress: Address, fromAddress: Address, batchTransferData: BatchTransferData[], fees: bigint): Promise<`0x${string}`>;
+declare function writeUnwrapContract(client: WalletClient, encryptedErc20: Address, from: Address, to: Address, encryptedAmount: Uint8Array, inputProof: Uint8Array): Promise<`0x${string}`>;
+declare function writeUnwrapFromBalanceContract(client: WalletClient, encryptedErc20: Address, from: Address, to: Address, encryptedBalance: Address): Promise<`0x${string}`>;
+declare function writeFinalizeUnwrapContract(client: WalletClient, wrapper: Address, burntAmount: Address, burntAmountCleartext: bigint, decryptionProof: Address): Promise<`0x${string}`>;
+declare function writeSetOperatorContract(client: WalletClient, tokenAddress: Address, spender: Address, timestamp?: number): Promise<`0x${string}`>;
+declare function writeWrapContract(client: WalletClient, wrapperAddress: Address, to: Address, amount: bigint): Promise<`0x${string}`>;
+declare function writeWrapETHContract(client: WalletClient, wrapperAddress: Address, to: Address, amount: bigint, value: bigint): Promise<`0x${string}`>;
+
+export { BatchTransferData, ContractCallConfig, EIP712TypedData, GenericSigner, Hex, SignerLifecycleCallbacks, TransactionReceipt, ViemSigner, type ViemSignerConfig, readConfidentialBalanceOfContract, readSupportsInterfaceContract, readUnderlyingTokenContract, readWrapperExistsContract, readWrapperForTokenContract, writeConfidentialBatchTransferContract, writeConfidentialTransferContract, writeFinalizeUnwrapContract, writeSetOperatorContract, writeUnwrapContract, writeUnwrapFromBalanceContract, writeWrapContract, writeWrapETHContract };