@fastxyz/allset-sdk 0.1.12 → 1.0.0

package/dist/index.d.ts

@@ -1,8 +1,661 @@
+import { Hex, Address, Hash, Chain, Account, WalletClient, PublicClient } from 'viem';
+import { Signer, FastProvider } from '@fastxyz/sdk';
+
+declare function fastAddressToBytes(address: string): Uint8Array;
+declare function fastAddressToBytes32(address: string): Hex;
+
 /**
- * @fastxyz/allset-sdk — browser-safe core helpers
+ * intents.ts — Intent builders for AllSet external execution
  *
- * Root exports are pure helpers only. Use `@fastxyz/allset-sdk/node` for
- * provider, executor, wallet, bridge execution, and file-backed config APIs.
+ * Intents define what actions to perform on EVM chains after
+ * transferring tokens from Fast network.
  */
-export * from './core/index.js';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * Intent action types supported by AllSet bridge.
+ */
+declare enum IntentAction {
+    /** Generic contract call */
+    Execute = 0,
+    /** ERC-20 transfer to address */
+    DynamicTransfer = 1,
+    /** Deposit tokens back to Fast network */
+    DynamicDeposit = 2,
+    /** Cancel/revoke pending intent */
+    Revoke = 3
+}
+/**
+ * An intent to execute on an EVM chain.
+ */
+interface Intent {
+    /** The action type */
+    action: IntentAction;
+    /** ABI-encoded payload for the action */
+    payload: `0x${string}`;
+    /** Native token value (ETH) to send, 0 for ERC-20 operations */
+    value: bigint;
+}
+/**
+ * Build a transfer intent to send ERC-20 tokens to an address.
+ *
+ * @param token - ERC-20 token contract address
+ * @param receiver - Recipient EVM address
+ * @returns Intent for DynamicTransfer action
+ *
+ * @example
+ * ```ts
+ * const intent = buildTransferIntent(
+ *   '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d', // USDC
+ *   '0xRecipientAddress'
+ * );
+ * ```
+ */
+declare function buildTransferIntent(token: string, receiver: string): Intent;
+/**
+ * Build a generic execute intent for arbitrary contract calls.
+ *
+ * @param target - Target contract address
+ * @param calldata - ABI-encoded function call data
+ * @param value - Native token value to send (default: 0)
+ * @returns Intent for Execute action
+ *
+ * @example
+ * ```ts
+ * // Call a contract function
+ * const calldata = encodeFunctionData({
+ *   abi: contractAbi,
+ *   functionName: 'someFunction',
+ *   args: [arg1, arg2],
+ * });
+ * const intent = buildExecuteIntent('0xContractAddress', calldata);
+ * ```
+ */
+declare function buildExecuteIntent(target: string, calldata: string, value?: bigint): Intent;
+/**
+ * Build an intent to deposit tokens back to Fast network.
+ *
+ * @param token - ERC-20 token contract address on EVM
+ * @param fastReceiver - Fast network recipient address (fast1...)
+ * @returns Intent for DynamicDeposit action
+ *
+ * @example
+ * ```ts
+ * const intent = buildDepositBackIntent(
+ *   '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d', // USDC
+ *   'fast1recipientaddress...'
+ * );
+ * ```
+ */
+declare function buildDepositBackIntent(token: string, fastReceiver: string): Intent;
+/**
+ * Build a revoke intent to cancel pending operations.
+ *
+ * @returns Intent for Revoke action
+ *
+ * @example
+ * ```ts
+ * const intent = buildRevokeIntent();
+ * ```
+ */
+declare function buildRevokeIntent(): Intent;
+
+/**
+ * claims.ts — Claim encoding and ID extraction for AllSet bridge
+ *
+ * Provides standalone functions for encoding TransferClaim and IntentClaim
+ * structures, building intent claim bytes for submitClaim(), and extracting
+ * claim IDs from cross-sign results.
+ *
+ * These were previously inlined in bridge.ts executeIntent().
+ */
+
+interface TransferClaimParams {
+    /** Sender address (will be lowercased) */
+    from: string;
+    /** Transaction nonce */
+    nonce: number | bigint;
+    /** Asset identifier (e.g. token symbol or address) */
+    asset: string;
+    /** Amount in smallest units */
+    amount: bigint;
+    /** Recipient address */
+    to: string;
+}
+/**
+ * ABI-encode a TransferClaim struct.
+ *
+ * @returns ABI-encoded hex string
+ */
+declare function encodeTransferClaim(params: TransferClaimParams): Hex;
+/**
+ * Compute the keccak256 hash of a TransferClaim (used as claim ID in some flows).
+ *
+ * @returns 0x-prefixed keccak256 hash
+ */
+declare function hashTransferClaim(params: TransferClaimParams): Hex;
+interface IntentClaimParams {
+    /** Transfer transaction ID (bytes32 hex) */
+    transferFastTxId: string;
+    /** Unix timestamp deadline */
+    deadline: bigint;
+    /** Array of intents to execute on EVM */
+    intents: Intent[];
+}
+/**
+ * ABI-encode an IntentClaim struct.
+ *
+ * @returns ABI-encoded hex string
+ */
+declare function encodeIntentClaim(params: IntentClaimParams): Hex;
+/**
+ * Build the intent claim bytes for use with `window.fastset.submitClaim()` or
+ * `TransactionBuilder.addExternalClaim()`.
+ *
+ * This is a convenience function that constructs an IntentClaim with the given
+ * parameters and returns it as a Uint8Array ready for submission.
+ *
+ * @param transferFastTxId - The transfer transaction ID (bytes32 hex from cross-sign)
+ * @param intents - Array of intents to execute on EVM
+ * @param deadline - Optional Unix timestamp deadline (defaults to 1 hour from now)
+ * @returns Uint8Array of ABI-encoded IntentClaim
+ *
+ * @example
+ * ```ts
+ * const intentBytes = buildIntentClaimBytes({
+ *   transferFastTxId: '0xabc...',
+ *   intents: [buildTransferIntent(tokenAddr, receiverAddr)],
+ * });
+ *
+ * // Use with browser wallet
+ * await window.fastset.submitClaim({
+ *   claimData: Array.from(intentBytes),
+ *   recipient: bridgeAddress,
+ *   account: currentAccount,
+ * });
+ * ```
+ */
+declare function buildIntentClaimBytes(params: {
+    transferFastTxId: string;
+    intents: Intent[];
+    deadline?: bigint;
+}): Uint8Array;
+/**
+ * Extract the claim ID (Fast transaction hash) from an evmSign cross-sign result.
+ *
+ * The cross-sign service returns transaction bytes where bytes[32:64] contain
+ * the canonical Fast network transaction hash.
+ *
+ * @param crossSignTransaction - The `transaction` field from an `EvmSignResult`
+ * @returns 0x-prefixed hex string of the claim ID
+ *
+ * @example
+ * ```ts
+ * const crossSign = await evmSign(certificate, crossSignUrl);
+ * const claimId = extractClaimId(crossSign.transaction);
+ * // claimId === '0xabc123...'
+ * ```
+ */
+declare function extractClaimId(crossSignTransaction: number[]): Hex;
+
+interface BuildDepositTransactionParams {
+    chainId: number;
+    bridgeContract: `0x${string}`;
+    tokenAddress: `0x${string}`;
+    isNative?: boolean;
+    amount: bigint;
+    /** Receiver Fast address (fast1...) */
+    receiver: string;
+}
+interface EncodeDepositCalldataParams {
+    tokenAddress: string;
+    amount: bigint;
+    receiverBytes32: `0x${string}`;
+}
+interface DepositTransactionPlan {
+    chainId: number;
+    to: `0x${string}`;
+    data: `0x${string}`;
+    value: bigint;
+    receiverBytes32: `0x${string}`;
+}
+/**
+ * Encode calldata for the bridge deposit(token, amount, receiver) call.
+ */
+declare function encodeDepositCalldata(params: EncodeDepositCalldataParams): `0x${string}`;
+/**
+ * Build a deposit transaction plan for bridging tokens from EVM to Fast network.
+ *
+ * All configuration values (chainId, bridgeContract, tokenAddress) must be
+ * provided by the caller — this function contains no embedded config.
+ *
+ * @example
+ * ```ts
+ * const plan = buildDepositTransaction({
+ *   chainId: 421614,
+ *   bridgeContract: '0xb536...',
+ *   tokenAddress: '0x75fa...',
+ *   amount: 1000000n,
+ *   receiver: 'fast1abc...',
+ * });
+ * // plan.to, plan.data, plan.value are ready to send via viem walletClient
+ * ```
+ */
+declare function buildDepositTransaction(params: BuildDepositTransactionParams): DepositTransactionPlan;
+
+/**
+ * eip7702.ts — EIP-7702 smartDeposit via AllSet Portal relay
+ *
+ * Flow:
+ *   1. Check ERC-20 balance; throw InsufficientBalanceError if < amount
+ *   2. POST /userop/prepare  → backend assembles UserOp + paymasterData (3 retries)
+ *   3. Pin delegate address against TRUSTED_DELEGATES allowlist
+ *   4. Sign EIP-7702 authorization (re-delegate EOA to v0.8 impl)
+ *   5. Sign UserOperation (EIP-712, v0.8)
+ *   6. POST /userop/submit  → backend calls Pimlico eth_sendUserOperation
+ *
+ * Private key never leaves the SDK.
+ * Pimlico API key never touches the SDK.
+ * Gas is paid in USDC via ERC-20 Paymaster.
+ * Chain is inferred from rpcUrl (backend calls eth_chainId) — no hardcoded chain list.
+ */
+
+interface SmartDepositParams {
+    /**
+     * EOA private key — stays local, never sent to backend.
+     * The EOA should be quiescent during this call: do not send other
+     * transactions from this key concurrently. EIP-7702 authorization
+     * signing binds to the account nonce, and a concurrent tx from
+     * another process will silently invalidate the delegation.
+     */
+    privateKey: Hex;
+    /** EVM JSON-RPC URL — used for balance check and forwarded to backend for chainId detection */
+    rpcUrl: string;
+    /** AllSet Portal backend base URL, e.g. https://api.allset.xyz */
+    allsetApiUrl: string;
+    /** ERC-20 token to deposit (e.g. USDC on Base) */
+    tokenAddress: Address;
+    /** Exact token amount to deposit (raw, with decimals); throws if balance is insufficient */
+    amount: bigint;
+    /** AllSet bridge contract address */
+    bridgeAddress: Address;
+    /** Encoded bridge.deposit(...) calldata from encodeDepositCalldata() */
+    depositCalldata: Hex;
+    /** Per-request HTTP timeout in ms for backend POSTs (default: 60000) */
+    requestTimeoutMs?: number;
+}
+interface SmartDepositResult {
+    txHash: Hash;
+    userOpHash: Hash;
+    userAddress: Address;
+}
+declare class InsufficientBalanceError extends Error {
+    readonly balance: bigint;
+    readonly required: bigint;
+    readonly tokenAddress: Address;
+    constructor(balance: bigint, required: bigint, tokenAddress: Address);
+}
+declare function smartDeposit(params: SmartDepositParams): Promise<SmartDepositResult>;
+
+/**
+ * Account-compatible wallet returned by createEvmWallet().
+ *
+ * Includes the normalized private key so generated accounts can be persisted
+ * or reconstructed by the caller.
+ */
+type EvmAccount = Account & {
+    privateKey: `0x${string}`;
+};
+/**
+ * Create an EVM wallet from an optional private key.
+ *
+ * @param privateKey - Optional. If omitted, generates a new random wallet.
+ *   Accepts a hex private key (64 chars, with or without 0x prefix).
+ *
+ * @returns Account-compatible object with viem signing methods and `privateKey`
+ *
+ * @example
+ * ```ts
+ * // Generate new wallet
+ * const account = createEvmWallet();
+ * console.log(account.address);    // 0x...
+ * console.log(account.privateKey); // persist this to reuse the wallet
+ *
+ * // Restore from private key
+ * const account = createEvmWallet('0x1234...64hexchars');
+ * ```
+ */
+declare function createEvmWallet(privateKey?: string): EvmAccount;
+/** ERC20 ABI for allowance, approve, and balanceOf */
+declare const ERC20_ABI: readonly [{
+    readonly name: "approve";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "spender";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "allowance";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }, {
+        readonly type: "address";
+        readonly name: "spender";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "balanceOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+/** Bundled supported chain mappings */
+declare const CHAIN_MAP: Record<number, Chain>;
+/**
+ * EVM clients returned by createEvmExecutor.
+ */
+interface EvmClients {
+    walletClient: WalletClient;
+    publicClient: PublicClient;
+}
+/**
+ * Create viem wallet and public clients for EVM operations.
+ *
+ * @param account - viem Account from createEvmWallet() or privateKeyToAccount()
+ * @param rpcUrl - RPC endpoint URL
+ * @param chainOrId - A viem Chain object, or a chain ID number (looked up in CHAIN_MAP).
+ *
+ * @example
+ * ```ts
+ * import { arbitrumSepolia } from 'viem/chains';
+ *
+ * const account = createEvmWallet('0xabc123...');
+ * // Pass a Chain object directly (preferred — no hardcoded map):
+ * const { walletClient, publicClient } = createEvmExecutor(account, rpcUrl, arbitrumSepolia);
+ * // Or pass a chain ID (uses built-in CHAIN_MAP):
+ * const { walletClient, publicClient } = createEvmExecutor(account, rpcUrl, 421614);
+ * ```
+ */
+declare function createEvmExecutor(account: Account, rpcUrl: string, chainOrId: Chain | number): EvmClients;
+/**
+ * Get the ERC-20 token balance of an EVM address.
+ *
+ * @param rpcUrl - EVM RPC endpoint
+ * @param tokenAddress - ERC-20 contract address
+ * @param ownerAddress - Account to query
+ * @returns Raw balance as bigint (in token's smallest unit)
+ */
+declare function getEvmErc20Balance(rpcUrl: string, tokenAddress: string, ownerAddress: string): Promise<bigint>;
+/**
+ * Get the native token (ETH / gas token) balance of an EVM address.
+ *
+ * @param rpcUrl - EVM RPC endpoint
+ * @param address - Account to query
+ * @returns Balance in wei as bigint
+ */
+declare function getEvmNativeBalance(rpcUrl: string, address: string): Promise<bigint>;
+
+interface BridgeResult {
+    txHash: string;
+    orderId: string;
+    estimatedTime?: string;
+}
+interface ExecuteDepositParams {
+    /** EVM chain ID */
+    chainId: number;
+    /** AllSet bridge contract address on EVM */
+    bridgeContract: `0x${string}`;
+    /** ERC-20 token contract address on EVM (ignored when isNative is true) */
+    tokenAddress: `0x${string}`;
+    /** Set to true for native ETH deposits */
+    isNative?: boolean;
+    /** Amount in smallest units (e.g., '1000000' for 1 USDC) */
+    amount: string;
+    /** Receiver Fast address (fast1...) */
+    receiverAddress: string;
+    /** viem clients from createEvmExecutor() */
+    evmClients: EvmClients;
+}
+interface ExecuteIntentParams {
+    /** AllSet bridge address on the Fast network (fast1...) */
+    fastBridgeAddress: string;
+    /** AllSet relayer URL for the destination EVM chain */
+    relayerUrl: string;
+    /** AllSet cross-sign service URL */
+    crossSignUrl: string;
+    /** Token contract address on EVM (used in relayer payload) */
+    tokenEvmAddress: string;
+    /** Token ID on the Fast network (hex string, without 0x) */
+    tokenFastTokenId: string;
+    /** Amount in smallest units (e.g., '1000000' for 1 USDC) */
+    amount: string;
+    /** Intents to execute on EVM chain after bridge */
+    intents: Intent[];
+    /**
+     * EVM address for the relayer target.
+     * Required when intents do not include a transfer recipient or execute target
+     * (e.g., for buildDepositBackIntent or buildRevokeIntent flows).
+     */
+    externalAddress?: string;
+    /** Deadline in seconds from now (default: 3600) */
+    deadlineSeconds?: number;
+    /** Ed25519 signer from @fastxyz/sdk */
+    signer: Signer;
+    /** Fast RPC provider from @fastxyz/sdk */
+    provider: FastProvider;
+    /** Fast network ID (e.g. 'fast:testnet', 'fast:mainnet') */
+    networkId: string;
+}
+interface ExecuteWithdrawParams {
+    /** AllSet bridge address on the Fast network (fast1...) */
+    fastBridgeAddress: string;
+    /** AllSet relayer URL for the destination EVM chain */
+    relayerUrl: string;
+    /** AllSet cross-sign service URL */
+    crossSignUrl: string;
+    /** Token contract address on EVM */
+    tokenEvmAddress: string;
+    /** Token ID on the Fast network (hex string, without 0x) */
+    tokenFastTokenId: string;
+    /** Amount in smallest units (e.g., '1000000' for 1 USDC) */
+    amount: string;
+    /** EVM address to receive the withdrawn tokens */
+    receiverEvmAddress: string;
+    /** Deadline in seconds from now (default: 3600) */
+    deadlineSeconds?: number;
+    /** Ed25519 signer from @fastxyz/sdk */
+    signer: Signer;
+    /** Fast RPC provider from @fastxyz/sdk */
+    provider: FastProvider;
+    /** Fast network ID (e.g. 'fast:testnet', 'fast:mainnet') */
+    networkId: string;
+}
+
+interface EvmSignResult {
+    transaction: number[];
+    signature: string;
+}
+/**
+ * Request EVM cross-signing for a Fast network certificate.
+ *
+ * @param certificate - Certificate from fastWallet.submit()
+ * @param crossSignUrl - AllSet cross-sign service URL (required)
+ */
+declare function evmSign(certificate: unknown, crossSignUrl: string): Promise<EvmSignResult>;
+/**
+ * Execute a deposit from an EVM chain to the Fast network.
+ *
+ * All configuration values must be provided by the caller.
+ *
+ * @example
+ * ```ts
+ * const result = await executeDeposit({
+ *   chainId: 421614,
+ *   bridgeContract: '0xb536...',
+ *   tokenAddress: '0x75fa...',
+ *   amount: '1000000',
+ *   receiverAddress: 'fast1abc...',
+ *   evmClients,
+ * });
+ * ```
+ */
+declare function executeDeposit(params: ExecuteDepositParams): Promise<BridgeResult>;
+/**
+ * Execute intents on an EVM chain after transferring tokens from the Fast network.
+ *
+ * This is the core function for all Fast→EVM flows:
+ * - Simple withdrawal: use buildTransferIntent + executeIntent (or use executeWithdraw)
+ * - Custom contract call: use buildExecuteIntent + executeIntent
+ * - Deposit back to Fast: use buildDepositBackIntent + executeIntent
+ *
+ * All configuration values must be provided by the caller.
+ *
+ * @example
+ * ```ts
+ * import { Signer, FastProvider } from '@fastxyz/sdk';
+ *
+ * const signer = new Signer(privateKeyHex);
+ * const provider = new FastProvider({ rpcUrl: 'https://proxy.fast.xyz' });
+ *
+ * const intent = buildTransferIntent(tokenEvmAddress, receiverEvmAddress);
+ * const result = await executeIntent({
+ *   fastBridgeAddress: 'fast1...',
+ *   relayerUrl: 'https://...',
+ *   crossSignUrl: 'https://...',
+ *   tokenEvmAddress: '0x...',
+ *   tokenFastTokenId: 'abc123...',
+ *   amount: '1000000',
+ *   intents: [intent],
+ *   signer,
+ *   provider,
+ *   networkId: 'fast:testnet',
+ * });
+ * ```
+ */
+declare function executeIntent(params: ExecuteIntentParams): Promise<BridgeResult>;
+/**
+ * Withdraw tokens from the Fast network to an EVM address.
+ *
+ * This is a convenience wrapper around executeIntent that builds a
+ * DynamicTransfer intent automatically.
+ *
+ * @example
+ * ```ts
+ * import { Signer, FastProvider } from '@fastxyz/sdk';
+ *
+ * const signer = new Signer(privateKeyHex);
+ * const provider = new FastProvider({ rpcUrl: 'https://proxy.fast.xyz' });
+ *
+ * const result = await executeWithdraw({
+ *   fastBridgeAddress: 'fast1...',
+ *   relayerUrl: 'https://...',
+ *   crossSignUrl: 'https://...',
+ *   tokenEvmAddress: '0x...',
+ *   tokenFastTokenId: 'abc123...',
+ *   amount: '1000000',
+ *   receiverEvmAddress: '0xRecipient...',
+ *   signer,
+ *   provider,
+ *   networkId: 'fast:testnet',
+ * });
+ * ```
+ */
+declare function executeWithdraw(params: ExecuteWithdrawParams): Promise<BridgeResult>;
+
+/**
+ * relay.ts — Standalone relayer submission for AllSet bridge
+ *
+ * Extracted from the bridge execution flow so Portal and other consumers
+ * can call the relayer independently (e.g. for step-by-step UI, retry, revoke).
+ */
+/**
+ * Parameters for submitting a relay request to the AllSet relayer.
+ */
+interface RelayParams {
+    /** AllSet relayer URL for the destination EVM chain */
+    relayerUrl: string;
+    /** Cross-signed transfer claim bytes (from evmSign result) */
+    encodedTransferClaim: number[];
+    /** EVM signature proof for the transfer claim */
+    transferProof: string;
+    /** Fast network transaction ID for the transfer */
+    transferFastTxId: string;
+    /** Fast network sender address (fast1...) */
+    fastsetAddress: string;
+    /** EVM recipient/target address (0x...) */
+    externalAddress: string;
+    /** Cross-signed intent claim bytes (from evmSign result) */
+    encodedIntentClaim?: number[];
+    /** EVM signature proof for the intent claim */
+    intentProof?: string;
+    /** Fast network transaction ID for the intent */
+    intentFastTxId?: string;
+    /** Claim ID for the intent (may differ from intentFastTxId) */
+    intentClaimId?: string;
+    /** Token contract address on the destination EVM chain */
+    externalTokenAddress?: string;
+}
+/**
+ * Result from a successful relay submission.
+ */
+interface RelayResult {
+    /** Whether the relayer accepted the request */
+    success: boolean;
+}
+/**
+ * Submit a relay request to the AllSet relayer service.
+ *
+ * The relayer executes the bridged operation on the destination EVM chain
+ * (e.g. ERC-20 transfer, contract call, deposit back, or revoke).
+ *
+ * @example
+ * ```ts
+ * await relayExecute({
+ *   relayerUrl: 'https://relayer.allset.xyz',
+ *   encodedTransferClaim: Array.from(transferCrossSign.transaction),
+ *   transferProof: transferCrossSign.signature,
+ *   transferFastTxId: '0x...',
+ *   fastsetAddress: 'fast1...',
+ *   externalAddress: '0xRecipient...',
+ *   encodedIntentClaim: Array.from(intentCrossSign.transaction),
+ *   intentProof: intentCrossSign.signature,
+ *   intentFastTxId: '0x...',
+ *   externalTokenAddress: '0xToken...',
+ * });
+ * ```
+ */
+declare function relayExecute(params: RelayParams): Promise<RelayResult>;
+
+/**
+ * errors.ts — Structured error codes for AllSet SDK.
+ *
+ * Every throwable error from the SDK is a FastError with a machine-readable
+ * `code`. Agents can switch on `code` instead of parsing message strings.
+ */
+type FastErrorCode = 'INSUFFICIENT_BALANCE' | 'NETWORK_NOT_CONFIGURED' | 'TX_FAILED' | 'INVALID_ADDRESS' | 'TOKEN_NOT_FOUND' | 'INVALID_PARAMS' | 'UNSUPPORTED_OPERATION' | 'KEYFILE_NOT_FOUND';
+declare class FastError extends Error {
+    readonly code: FastErrorCode;
+    readonly note: string;
+    constructor(code: FastErrorCode, message: string, opts?: {
+        note?: string;
+    });
+    toJSON(): Record<string, unknown>;
+}
+
+export { type BridgeResult, type BuildDepositTransactionParams, CHAIN_MAP, type DepositTransactionPlan, ERC20_ABI, type EncodeDepositCalldataParams, type EvmAccount, type EvmClients, type EvmSignResult, type ExecuteDepositParams, type ExecuteIntentParams, type ExecuteWithdrawParams, FastError, type FastErrorCode, InsufficientBalanceError, type Intent, IntentAction, type IntentClaimParams, type RelayParams, type RelayResult, type SmartDepositParams, type SmartDepositResult, type TransferClaimParams, buildDepositBackIntent, buildDepositTransaction, buildExecuteIntent, buildIntentClaimBytes, buildRevokeIntent, buildTransferIntent, createEvmExecutor, createEvmWallet, encodeDepositCalldata, encodeIntentClaim, encodeTransferClaim, evmSign, executeDeposit, executeIntent, executeWithdraw, extractClaimId, fastAddressToBytes, fastAddressToBytes32, getEvmErc20Balance, getEvmNativeBalance, hashTransferClaim, relayExecute, smartDeposit };