@ordanetwork/sdk 1.2.0 → 1.3.0

package/dist/react/index.d.mts

@@ -0,0 +1,4581 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as abitype from 'abitype';
+import * as _reown_appkit_networks from '@reown/appkit/networks';
+import { AppKitNetwork } from '@reown/appkit/networks';
+import * as viem from 'viem';
+import { Chain as Chain$1, BaseError, Address } from 'viem';
+import { createAppKit } from '@reown/appkit/react';
+import { WagmiAdapter } from '@reown/appkit-adapter-wagmi';
+import { SolanaAdapter } from '@reown/appkit-adapter-solana';
+import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
+import * as React$1 from 'react';
+import { VariantProps } from 'class-variance-authority';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as vaul from 'vaul';
+import { Drawer as Drawer$1 } from 'vaul';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import { ClassValue } from 'clsx';
+
+declare class HmacAuthenticator {
+    private clientId;
+    private clientSecret;
+    private cryptoProvider;
+    constructor(clientId: string, clientSecret: string);
+    /**
+     * Canonicalizes a JavaScript object into deterministic JSON string
+     */
+    private canonicalizeJSON;
+    /**
+     * Generates HMAC signature for a payload
+     * @param payload The payload to sign
+     * @returns Hex-encoded signature
+     */
+    generateSignature(payload: any): Promise<string>;
+    /**
+     * Gets authentication headers for API requests
+     * @param body Request body to sign
+     * @param includeTimestamp Whether to include timestamp header
+     * @returns Authentication headers
+     */
+    getAuthHeaders(body: any, includeTimestamp?: boolean): Promise<Record<string, string>>;
+}
+
+/**
+ * JWT Bearer Token Authenticator
+ *
+ * Provides authentication headers using a JWT.
+ * The token is opaque to the SDK - it's simply passed as a Bearer token.
+ */
+declare class JWTAuthenticator {
+    private token;
+    constructor(token: string);
+    /**
+     * Updates the JWT dynamically without creating a new authenticator instance
+     *
+     * @param newToken - The new JWT to use for authentication
+     * @throws {Error} If the new token is empty or null
+     */
+    updateToken(newToken: string): void;
+    /**
+     * Gets authentication headers for API requests
+     * @returns Authentication headers with Bearer token
+     */
+    getAuthHeaders(): Promise<Record<string, string>>;
+}
+
+/**
+ * Request configuration
+ */
+interface RequestConfig {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    headers?: Record<string, string>;
+    params?: Record<string, any>;
+    body?: any;
+    timeout?: number;
+}
+/**
+ * Universal HTTP client using fetch API
+ */
+declare class UniversalHttpClient {
+    private baseUrl;
+    private timeout;
+    private authenticator?;
+    private enableTimestamp;
+    private debug;
+    constructor(baseUrl: string, timeout?: number, options?: {
+        authenticator?: HmacAuthenticator | JWTAuthenticator;
+        enableTimestamp?: boolean;
+        debug?: boolean;
+    });
+    /**
+     * Makes an HTTP request
+     */
+    request<T>(config: RequestConfig): Promise<T>;
+    /**
+     * Handles error responses from the API
+     */
+    private handleErrorResponse;
+    get<T>(path: string, params?: any): Promise<T>;
+    post<T>(path: string, body?: any): Promise<T>;
+    put<T>(path: string, body?: any): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+}
+
+/**
+ * Transaction-related types for SDK
+ * Based on backend implementation in src/utils/types/transfer.ts
+ */
+/**
+ * Parameters for token approval transaction
+ */
+interface ApprovalTransactionParams {
+    from: string;
+    to: string;
+    data: string;
+    value: string;
+    chainId?: number;
+    nonce?: number | string;
+    gas?: string;
+}
+/**
+ * Transaction request parameters
+ */
+interface TransactionRequest {
+    from: string;
+    to: string;
+    data: string;
+    value: string;
+    chainId: number;
+    gas?: string;
+    gasPrice?: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+    nonce?: string | number;
+    requestId?: string;
+}
+/**
+ * Provider quote details
+ * Structure may vary by provider, but common fields are included
+ */
+interface ProviderQuoteDetails {
+    provider: string;
+    subProvider?: string;
+    providerRequestId?: string;
+    [key: string]: unknown;
+}
+
+interface OffRampQuoteParams {
+    fromChain: string;
+    fromToken: string;
+    fromAddress: string;
+    intent: Intent;
+    recipientId?: string;
+    kycInformation?: KYCInformation;
+    fiatSettlementDetails?: FiatSettlementDetails;
+}
+interface OffRampQuoteResponse {
+    message: string;
+    transactionId: string;
+    quote: {
+        provider: string;
+        providerRequestId?: string;
+        fromToken: {
+            address: string;
+            symbol: string;
+        };
+        toCurrency: string;
+        fromAmount: string;
+        toAmount: string;
+        exchangeRate: string;
+        fromAddress: string;
+        estimatedDuration: number;
+    };
+    approvalTxParams?: ApprovalTransactionParams | Record<string, never>;
+    transactionRequest?: TransactionRequest | Record<string, never>;
+}
+type OffRampStatusType = 'Pending' | 'Processing' | 'Completed' | 'Failed' | 'Refunded';
+interface OffRampStatusResponse {
+    id: string;
+    status: OffRampStatusType;
+    createdAt: string;
+    updatedAt: string;
+    depositAddress: string;
+    depositAmount: string;
+    depositTxHash: string;
+    withdrawalAmount: string;
+    withdrawalDetails: {
+        bankAccountNumber?: string;
+        currency?: string;
+        status?: string;
+        [key: string]: any;
+    };
+}
+
+/**
+ * On-Ramp (Fiat to Crypto) Types
+ */
+interface OnRampQuoteParams {
+    fromCurrency: string;
+    intent: Intent;
+    recipientId?: string;
+    settlementDetails?: {
+        toChain: string;
+        toToken: string;
+        toAddress: string;
+    };
+}
+interface OnRampQuoteResponse {
+    message: string;
+    transactionId: string;
+    depositInstructions: {
+        method: string;
+        amount: number;
+        currency: string;
+        pixQrCode?: string;
+        pixKey?: string;
+        depositAddress?: string;
+        expiresAt: string;
+        referenceId: string;
+    };
+    quote: {
+        provider: string;
+        fromCurrency: string;
+        toCrypto: string;
+        fromAmount: string;
+        toAmount: string;
+        toAddress: string;
+        exchangeRate: number;
+        estimatedDuration: number;
+    };
+}
+interface OnRampStatusResponse {
+    transactionId: string;
+    status: string;
+    type: string;
+    fromCurrency: string;
+    toCrypto: string;
+    toChain: string;
+    fiatAmount: any;
+    cryptoAmount: any;
+    settlementAddress: string;
+    depositMethod: string;
+    depositStatus: string;
+    transferoOrderId?: string;
+    transferoReferenceId?: string;
+    createdAt: Date | string;
+    updatedAt: Date | string;
+}
+
+/**
+ * JWT Authentication & Authorization Types
+ *
+ * JWT serves dual purposes:
+ * - Authentication: Verifies identity via signature
+ * - Authorization: Permissions control access to resources
+ */
+/**
+ * Available permissions for JWT-based authorization
+ */
+type JWTPermission = 'quotes:read' | 'offramp:read' | 'onramp:read' | 'transactions:read' | 'recipients:read' | 'recipients:write' | 'balances:read' | 'prices:read';
+/**
+ * Request parameters for generating a JWT
+ */
+interface GenerateJWTRequest {
+    clientId: string;
+    clientSecret: string;
+    expiresIn?: number;
+    permissions?: JWTPermission[];
+}
+/**
+ * Response from JWT generation
+ */
+interface GenerateJWTResponse {
+    token: string;
+    expiresAt: string;
+}
+/**
+ * Configuration for JWT-based SDK authentication
+ */
+interface JWTAuthConfig {
+    token: string;
+    requestTimeout?: number;
+    debug?: boolean;
+    alchemyApiKey?: string;
+}
+
+interface TokenPriceRequest {
+    address: string;
+    chainId: string;
+}
+interface TokenPriceData {
+    address: string;
+    chainId: string;
+    usdPrice: number | null;
+    lastUpdatedAt: string | null;
+    error: string | null;
+}
+interface PricesFetchResponse {
+    data: {
+        prices: TokenPriceData[];
+    };
+    meta: {
+        cached: boolean;
+        cachedAt: string | null;
+        expiresAt: string | null;
+    };
+}
+
+/**
+ * Token balance information
+ */
+interface TokenBalance {
+    chainId: string;
+    tokenAddress: string;
+    balance: string;
+    balanceFormatted: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    isNative: boolean;
+    isKnown: boolean;
+}
+interface BalancesFetchOptions {
+    chainIds?: string[];
+    filter?: 'known' | 'all';
+}
+interface BalancesSummary {
+    totalTokens: number;
+    knownTokens: number;
+    unknownTokens: number;
+    chainsQueried?: number;
+    chainsSucceeded?: number;
+    chainsFailed?: number;
+}
+interface ChainFailure {
+    chainId: string;
+    error: string;
+}
+interface BalancesFetchResponse {
+    data: {
+        address: string;
+        balances: TokenBalance[];
+        summary: BalancesSummary;
+        failures?: ChainFailure[];
+    };
+    meta?: {
+        cached: boolean;
+        cachedAt: string | null;
+        expiresAt: string | null;
+    };
+}
+
+type IntentMethod = 'usd' | 'fromAmount' | 'toAmount';
+interface Intent {
+    method: IntentMethod;
+    value: string;
+}
+declare enum TransactionStatus {
+    PENDING = "Pending",
+    IN_PROGRESS = "In_progress",
+    COMPLETED = "Completed",
+    FAILED = "Failed",
+    CANCELLED = "Cancelled",
+    REFUNDED = "Refunded"
+}
+interface CryptoSettlementDetails {
+    toChain: string;
+    toToken: string;
+    toAddress?: string;
+}
+interface FiatSettlementDetails {
+    toCurrency: string;
+    pixKey?: string;
+    bankAccount?: string;
+    bankBranch?: string;
+    bankAccountType?: string;
+    iban?: string;
+    cbuCvu?: string;
+}
+interface KYCInformation {
+    taxId: string;
+    taxIdCountry: string;
+    email: string;
+    name: string;
+}
+interface QuoteRequestParams {
+    fromChain: string;
+    fromToken: string;
+    fromAddress: string;
+    intent: Intent;
+    recipientId?: string;
+    settlementDetails?: {
+        toChain: string;
+        toToken: string;
+        toAddress: string;
+    };
+    timeout?: number;
+}
+/**
+ * Quote response detail structure (inner quote object)
+ * Based on backend implementation
+ */
+interface QuoteResponseDetail {
+    provider: string;
+    subProvider?: string;
+    providerRequestId?: string;
+    fromToken: {
+        address: string;
+        decimals: number;
+        symbol: string;
+        price: number;
+        chainId?: number;
+    };
+    toToken: {
+        address: string;
+        decimals: number;
+        symbol: string;
+        price: number;
+        chainId?: number;
+    };
+    fromAmount: string;
+    toAmount: string;
+    fromAddress: string;
+    toAddress: string;
+    estimatedDuration: number;
+    fees: {
+        bridge: {
+            amount: string;
+            token: string;
+        };
+        gas: {
+            amount: string;
+            token: string;
+        };
+        integrator: number | string;
+        maxSlippage: number | null;
+    };
+}
+/**
+ * Transfer response for crypto-to-crypto transfers
+ */
+interface TransferResponse {
+    message: string;
+    transactionId: string | number;
+    quote: QuoteResponseDetail;
+    approvalTxParams: ApprovalTransactionParams | null;
+    transactionRequest: TransactionRequest;
+    providerQuoteDetails: ProviderQuoteDetails;
+}
+/**
+ * Direct transfer response (same chain transfers)
+ */
+interface DirectTransferResponse {
+    message: string;
+    transactionId: string | number;
+    transactionRequest: TransactionRequest;
+    feeTxParams: TransactionRequest | null;
+    providerQuoteDetails?: ProviderQuoteDetails;
+}
+interface CreateRecipientParams {
+    name: string;
+    cryptoSettlementDetails?: CryptoSettlementDetails;
+    kycInformation?: KYCInformation;
+    fiatSettlementDetails?: FiatSettlementDetails;
+}
+interface UpdateRecipientSettlementParams {
+    recipientId: string;
+    cryptoSettlementDetails?: CryptoSettlementDetails;
+    kycInformation?: KYCInformation;
+    fiatSettlementDetails?: FiatSettlementDetails;
+}
+interface DeactivateRecipientParams {
+    recipientId: string;
+}
+interface CreateRecipientResponse {
+    message: string;
+    recipientId: string;
+    smartWallet?: {
+        address: string;
+        privateKey: string;
+        type: string;
+        capabilities: string[];
+    };
+    smartWalletError?: string;
+}
+interface UpdateRecipientResponse {
+    message: string;
+    previousDetails: {
+        crypto?: {
+            toChain: string;
+            toToken: string;
+            toAddress: string;
+            updatedAt: Date;
+        };
+        fiat?: {
+            toCurrency: string | null;
+            bankAccount: string | null;
+            bankBranch: string | null;
+            bankAccountType: string | null;
+            iban: string | null;
+            pixKey: string | null;
+            cbuCvu: string | null;
+            updatedAt: Date;
+        };
+    };
+}
+interface DeactivateRecipientResponse {
+    message: string;
+    recipientName: string;
+    deactivatedAt: Date;
+}
+interface ListRecipientsFilters {
+    toAddress?: string;
+    name?: string;
+    pixKey?: string;
+    taxId?: string;
+    chainIds?: string | string[];
+}
+interface ListRecipientsParams {
+    page?: number;
+    limit?: number;
+    filters?: ListRecipientsFilters;
+}
+interface RecipientCryptoSettlement {
+    id: string;
+    toChain: string;
+    toToken: string;
+    toAddress: string;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}
+interface RecipientFiatSettlement {
+    id: string;
+    toCurrency: string;
+    method: string;
+    pixDetails?: {
+        pixKey: string;
+        keyType?: string | null;
+    } | null;
+    ibanDetails?: {
+        iban: string;
+        bankAccount?: string | null;
+        bankBranch?: string | null;
+        bankAccountType?: string | null;
+    } | null;
+    cbuDetails?: {
+        cbu: string;
+        cvu?: string | null;
+    } | null;
+}
+interface RecipientKycInformation {
+    taxId: string;
+    taxIdCountry: string;
+    name: string;
+    email: string;
+}
+interface RecipientDetails {
+    id: string;
+    name: string;
+    isActive: boolean;
+    projectId: string;
+    businessId: string;
+    smartWalletAddress?: string | null;
+    walletType?: string | null;
+    cryptoSettlement?: RecipientCryptoSettlement | null;
+    fiatSettlement?: RecipientFiatSettlement | null;
+    kycInformation?: RecipientKycInformation | null;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}
+interface ListRecipientsResponse {
+    success: boolean;
+    data: RecipientDetails[];
+    pagination: {
+        page: number;
+        limit: number;
+        totalCount: number;
+        totalPages: number;
+    };
+}
+interface TransactionStatusParams {
+    transactionId?: string;
+    sourceHash?: string;
+    destinationHash?: string;
+}
+type TransactionStatusType = 'Pending' | 'In_progress' | 'Completed' | 'Failed' | 'Refunded';
+type TransactionTypeResponse = 'Direct' | 'LiFi' | 'Relay' | 'Wormhole' | 'Transfero';
+interface TransactionStatusResponse {
+    requestSuccess: boolean;
+    transaction?: {
+        id: string;
+        status: TransactionStatusType;
+        type: TransactionTypeResponse;
+        fromChain: string;
+        toChain: string;
+        fromToken: string;
+        toToken: string;
+        fromAmount: string;
+        usdAmount: number;
+        sourceTransactionHash?: string;
+        destinationTransactionHash?: string;
+        failureReason?: string;
+        createdAt: string | Date;
+        updatedAt: string | Date;
+    };
+    error?: string;
+}
+interface TransactionListItem {
+    _id: string;
+    fromChain: string;
+    toChain: string;
+    fromToken: string;
+    toToken: string;
+    fromAmount: string;
+    toAmount: string;
+    usdAmount: number;
+    fromAddress: string;
+    toAddress: string;
+    type: TransactionTypeResponse;
+    fee: string;
+    createdAt: string;
+    sourceTransactionHash: string;
+    destinationTransactionHash: string;
+}
+
+/**
+ * API wrapper for quote operations
+ */
+declare class Quote {
+    private httpClient;
+    constructor(httpClient: UniversalHttpClient);
+    /**
+     * Requests a quote for a cross-chain transfer
+     * @param params Quote request parameters
+     * @returns Quote response with transaction ID and transfer details
+     * Returns either TransferResponse (crypto-to-crypto) or DirectTransferResponse (same chain)
+     */
+    request(params: QuoteRequestParams): Promise<TransferResponse | DirectTransferResponse>;
+}
+
+declare class Recipient {
+    private httpClient;
+    constructor(httpClient: UniversalHttpClient);
+    /**
+     * Creates a new recipient
+     * @param params Recipient creation parameters
+     * @returns Recipient response with ID and optional smart wallet
+     */
+    create(params: CreateRecipientParams): Promise<CreateRecipientResponse>;
+    /**
+     * Updates recipient settlement details
+     * @param params Update parameters including recipient ID
+     * @returns Update response
+     */
+    updateSettlement(params: UpdateRecipientSettlementParams): Promise<UpdateRecipientResponse>;
+    /**
+     * Deactivates a recipient
+     * @param params Deactivation parameters
+     * @returns Deactivation response
+     */
+    deactivate(params: DeactivateRecipientParams): Promise<DeactivateRecipientResponse>;
+    /**
+     * Lists recipients with pagination and filters
+     * @param params List parameters including pagination and filters
+     * @returns List of recipients with pagination metadata
+     */
+    list(params?: ListRecipientsParams): Promise<ListRecipientsResponse>;
+}
+
+interface PollingOptions {
+    intervalMs?: number;
+    timeoutMs?: number;
+    onStatusUpdate?: (status: TransactionStatus) => void;
+}
+declare class Transaction {
+    private httpClient;
+    constructor(httpClient: UniversalHttpClient);
+    /**
+     * Gets the status of a transaction
+     * @param params Query parameters for transaction lookup
+     * @returns Transaction status response
+     */
+    getStatus(params: TransactionStatusParams): Promise<TransactionStatusResponse>;
+    /**
+     * Gets all successful transactions
+     * @returns Array of successful transactions
+     */
+    getSuccessfulTransactions(): Promise<TransactionListItem[]>;
+    /**
+     * Waits for a transaction to reach a terminal state
+     * @param transactionId The transaction ID to monitor
+     * @param options Polling configuration
+     * @returns Final transaction status
+     */
+    waitForCompletion(transactionId: string, options?: PollingOptions): Promise<TransactionStatusResponse>;
+    /**
+     * Checks if a status is terminal
+     */
+    private isTerminalStatus;
+    private sleep;
+}
+
+/**
+ * Polling options for off-ramp operations
+ */
+interface OffRampPollingOptions {
+    intervalMs?: number;
+    timeoutMs?: number;
+    onStatusUpdate?: (status: OffRampStatusType) => void;
+}
+/**
+ * API wrapper for off-ramp (crypto to fiat) operations
+ */
+declare class OffRamp {
+    private httpClient;
+    constructor(httpClient: UniversalHttpClient);
+    /**
+     * Requests a quote for off-ramping crypto to fiat
+     * @param params Off-ramp quote parameters
+     * @returns Off-ramp quote response
+     */
+    requestQuote(params: OffRampQuoteParams): Promise<OffRampQuoteResponse>;
+    /**
+     * Gets the status of an off-ramp transaction
+     * @param transactionId The transaction ID
+     * @returns Off-ramp transaction status
+     */
+    getStatus(transactionId: string): Promise<OffRampStatusResponse>;
+    /**
+     * Waits for off-ramp completion using polling
+     * @param transactionId The transaction ID to monitor
+     * @param options Polling configuration
+     * @returns Final off-ramp status
+     */
+    waitForCompletion(transactionId: string, options?: OffRampPollingOptions): Promise<OffRampStatusResponse>;
+    /**
+     * Checks if a status is terminal
+     */
+    private isTerminalStatus;
+    /**
+     * Helper to sleep for a given duration
+     */
+    private sleep;
+}
+
+interface OnRampPollingOptions {
+    intervalMs?: number;
+    timeoutMs?: number;
+    onStatusUpdate?: (status: string) => void;
+}
+/**
+ * API wrapper for on-ramp (fiat to crypto) operations
+ */
+declare class OnRamp {
+    private httpClient;
+    constructor(httpClient: UniversalHttpClient);
+    /**
+     * Requests a quote for on-ramping fiat to crypto
+     * @param params On-ramp quote parameters
+     * @returns On-ramp quote response with deposit instructions
+     */
+    requestQuote(params: OnRampQuoteParams): Promise<OnRampQuoteResponse>;
+    /**
+     * Gets the status of an on-ramp transaction
+     * @param transactionId The transaction ID
+     * @returns On-ramp transaction status
+     */
+    getStatus(transactionId: string): Promise<OnRampStatusResponse>;
+    /**
+     * Waits for on-ramp completion using polling
+     * @param transactionId The transaction ID to monitor
+     * @param options Polling configuration
+     * @returns Final on-ramp status
+     */
+    waitForCompletion(transactionId: string, options?: OnRampPollingOptions): Promise<OnRampStatusResponse>;
+    /**
+     * Checks if a status is terminal
+     */
+    private isTerminalStatus;
+    /**
+     * Helper to sleep for a given duration
+     */
+    private sleep;
+}
+
+/**
+ * API wrapper for JWT authentication operations
+ *
+ * Handles generation of JWTs for client-side authentication.
+ * Note: "token" in this context refers to JWT (authentication), not ERC-20 tokens (assets).
+ */
+declare class JWT {
+    private httpClient;
+    constructor(httpClient: UniversalHttpClient);
+    /**
+     * Generates a JWT for authentication using project credentials
+     *
+     * This endpoint does NOT use HMAC authentication - it directly validates
+     * the clientId and clientSecret to generate a JWT.
+     *
+     * @param params JWT generation parameters
+     * @returns JWT string and expiration timestamp
+     *
+     * @example
+     * ```typescript
+     * // Create an unauthenticated client
+     * const client = new UniversalHttpClient('https://api.orda.network/v1');
+     *
+     * // Generate a JWT
+     * const jwtApi = new JWT(client);
+     * const { token, expiresAt } = await jwtApi.generate({
+     *   clientId: 'proj_xxx',
+     *   clientSecret: 'secret_yyy',
+     *   expiresIn: 3600,
+     *   permissions: ['quotes:read', 'transactions:read']
+     * });
+     *
+     * // Use the JWT with SDK
+     * const sdk = new OrdaSDK({ token });
+     * ```
+     */
+    generate(params: GenerateJWTRequest): Promise<GenerateJWTResponse>;
+}
+
+/**
+ * API wrapper for token price operations
+ */
+declare class Prices {
+    private httpClient;
+    constructor(httpClient: UniversalHttpClient);
+    /**
+     * Fetches USD prices for multiple tokens
+     * @param tokens Array of token identifiers (address + chainId)
+     * @returns Full price response including prices array and cache metadata
+     *
+     * @example
+     * ```typescript
+     * const response = await sdk.prices.fetch([
+     *   { address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', chainId: '1' }, // USDC
+     *   { address: '0x0000000000000000000000000000000000000000', chainId: '137' }, // Native MATIC
+     * ]);
+     * console.log(response.data.prices);
+     * console.log(response.meta.cached);
+     * ```
+     */
+    fetch(tokens: TokenPriceRequest[]): Promise<PricesFetchResponse>;
+}
+
+/**
+ * API wrapper for token balance operations
+ */
+declare class Balances {
+    private httpClient;
+    constructor(httpClient: UniversalHttpClient);
+    /**
+     * Fetches token balances for a wallet address across multiple chains
+     * @param address Wallet address to fetch balances for
+     * @param options Optional filtering options (chainIds, filter mode)
+     * @returns Balance fetch response with token balances and summary
+     *
+     * @example
+     * ```typescript
+     * // Fetch all known token balances
+     * const result = await sdk.balances.fetch('0x1234...5678');
+     *
+     * // Fetch balances for specific chains
+     * const result = await sdk.balances.fetch('0x1234...5678', {
+     *   chainIds: ['1', '137', '8453'],
+     *   filter: 'known',
+     * });
+     *
+     * console.log(result.data.balances);
+     * console.log(result.data.summary.totalTokens);
+     * ```
+     */
+    fetch(address: string, options?: BalancesFetchOptions): Promise<BalancesFetchResponse>;
+}
+
+type AccountType = 'MODULAR_ACCOUNT_V2' | 'LIGHT_ACCOUNT';
+type EntityType = 'project' | 'recipient';
+type TransportType = 'alchemy' | 'http';
+interface SmartWalletCredentials {
+    address: string;
+    privateKey: string;
+    type: AccountType;
+    entityType: EntityType;
+    entityId: string;
+    chainId: number;
+}
+interface SmartWalletConfig {
+    credentials: SmartWalletCredentials;
+    chain: number;
+    transport?: TransportType;
+    alchemyApiKey?: string;
+    rpcUrl?: string;
+}
+interface UserOperationRequest {
+    target: string;
+    data?: string;
+    value?: bigint;
+}
+interface TransactionResult {
+    hash: string;
+    sender: string;
+    status?: 'pending' | 'success' | 'failed';
+}
+interface SmartWalletState {
+    isConnected: boolean;
+    isDeployed?: boolean;
+    address?: string;
+    chainId?: number;
+}
+interface SmartWalletInterface {
+    connect(): Promise<void>;
+    disconnect(): void;
+    sendUserOperation(request: UserOperationRequest): Promise<TransactionResult>;
+    sendBatchUserOperation(requests: UserOperationRequest[]): Promise<TransactionResult>;
+    getAddress(): string;
+    isDeployed(): Promise<boolean>;
+    getState(): SmartWalletState;
+}
+
+declare class SmartWalletClient implements SmartWalletInterface {
+    private client?;
+    private publicClient?;
+    private config;
+    private state;
+    private signer;
+    constructor(config: SmartWalletConfig);
+    connect(): Promise<void>;
+    disconnect(): void;
+    sendUserOperation(request: UserOperationRequest): Promise<TransactionResult>;
+    sendBatchUserOperation(requests: UserOperationRequest[]): Promise<TransactionResult>;
+    getAddress(): string;
+    isDeployed(): Promise<boolean>;
+    getState(): SmartWalletState;
+    private getTransport;
+    waitForUserOperationReceipt(hash: string, timeout?: number): Promise<TransactionResult>;
+}
+
+interface SmartWalletManagerConfig {
+    alchemyApiKey?: string;
+}
+declare class SmartWalletManager {
+    private config;
+    constructor(config?: SmartWalletManagerConfig);
+    createProjectWallet(projectId: string, privateKey: string, chainId: number, accountType?: 'MODULAR_ACCOUNT_V2' | 'LIGHT_ACCOUNT'): Promise<SmartWalletClient>;
+    createRecipientWallet(recipientId: string, privateKey: string, chainId: number, accountType?: 'MODULAR_ACCOUNT_V2' | 'LIGHT_ACCOUNT'): Promise<SmartWalletClient>;
+    validatePrivateKey(privateKey: string): boolean;
+    generatePrivateKey(): Promise<{
+        privateKey: string;
+        address: string;
+    }>;
+    getAddressFromPrivateKey(privateKey: string): Promise<string>;
+}
+
+/**
+ * Configuration options for OrdaSDK
+ */
+interface OrdaConfig {
+    clientId: string;
+    clientSecret: string;
+    requestTimeout?: number;
+    enableTimestamp?: boolean;
+    debug?: boolean;
+    alchemyApiKey?: string;
+}
+/**
+ * Main SDK class for interacting with Orda API
+ *
+ * Supports both authentication modes:
+ * 1. HMAC: Server-side authentication with clientId/clientSecret
+ * 2. JWT: Client-side authentication with JWT
+ */
+declare class OrdaSDK {
+    private httpClient;
+    private config;
+    quote: Quote;
+    recipients: Recipient;
+    transactions: Transaction;
+    offRamp: OffRamp;
+    onRamp: OnRamp;
+    jwt: JWT;
+    prices: Prices;
+    balances: Balances;
+    smartWallets: SmartWalletManager;
+    constructor(config: OrdaConfig | JWTAuthConfig);
+    updateToken(newToken: string): void;
+    isJWTMode(): boolean;
+    /**
+     * Checks if the SDK is running in a browser environment
+     */
+    static isBrowser(): boolean;
+    /**
+     * Checks if the SDK is running in Node.js
+     */
+    static isNode(): boolean;
+    /**
+     * Gets the current SDK version
+     */
+    static get version(): string;
+}
+
+declare const evmNetworks: readonly [{
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://etherscan.io";
+            readonly apiUrl: "https://api.etherscan.io/api";
+        };
+    };
+    blockTime: 12000;
+    contracts: {
+        readonly ensUniversalResolver: {
+            readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+            readonly blockCreated: 23085558;
+        };
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 14353601;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 1;
+    name: "Ethereum";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://eth.merkle.io"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Arbiscan";
+            readonly url: "https://arbiscan.io";
+            readonly apiUrl: "https://api.arbiscan.io/api";
+        };
+    };
+    blockTime: 250;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 7654707;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 42161;
+    name: "Arbitrum One";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Basescan";
+            readonly url: "https://basescan.org";
+            readonly apiUrl: "https://api.basescan.org/api";
+        };
+    };
+    blockTime: 2000;
+    contracts: {
+        readonly disputeGameFactory: {
+            readonly 1: {
+                readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
+            };
+        };
+        readonly l2OutputOracle: {
+            readonly 1: {
+                readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
+            };
+        };
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 5022;
+        };
+        readonly portal: {
+            readonly 1: {
+                readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
+                readonly blockCreated: 17482143;
+            };
+        };
+        readonly l1StandardBridge: {
+            readonly 1: {
+                readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
+                readonly blockCreated: 17482143;
+            };
+        };
+        readonly gasPriceOracle: {
+            readonly address: "0x420000000000000000000000000000000000000F";
+        };
+        readonly l1Block: {
+            readonly address: "0x4200000000000000000000000000000000000015";
+        };
+        readonly l2CrossDomainMessenger: {
+            readonly address: "0x4200000000000000000000000000000000000007";
+        };
+        readonly l2Erc721Bridge: {
+            readonly address: "0x4200000000000000000000000000000000000014";
+        };
+        readonly l2StandardBridge: {
+            readonly address: "0x4200000000000000000000000000000000000010";
+        };
+        readonly l2ToL1MessagePasser: {
+            readonly address: "0x4200000000000000000000000000000000000016";
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 8453;
+    name: "Base";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://mainnet.base.org"];
+        };
+    };
+    sourceId: 1;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.OpStackRpcBlock, action?: string | undefined) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: viem.Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: abitype.Address;
+                mixHash: viem.Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentBeaconBlockRoot?: `0x${string}` | undefined;
+                parentHash: viem.Hash;
+                receiptsRoot: viem.Hex;
+                sealFields: viem.Hex[];
+                sha3Uncles: viem.Hash;
+                size: bigint;
+                stateRoot: viem.Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | _reown_appkit_networks.OpStackTransaction<boolean>[];
+                transactionsRoot: viem.Hash;
+                uncles: viem.Hash[];
+                withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                withdrawalsRoot?: `0x${string}` | undefined;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.OpStackRpcTransaction, action?: string | undefined) => ({
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean;
+                mint?: bigint | undefined | undefined;
+                sourceHash: viem.Hex;
+                type: "deposit";
+            } | {
+                r: viem.Hex;
+                s: viem.Hex;
+                v: bigint;
+                value: bigint;
+                gas: bigint;
+                to: abitype.Address | null;
+                from: abitype.Address;
+                nonce: number;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                transactionIndex: number | null;
+                hash: viem.Hash;
+                input: viem.Hex;
+                typeHex: viem.Hex | null;
+                accessList?: undefined | undefined;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId?: number | undefined;
+                yParity?: undefined | undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes: readonly viem.Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList: viem.SignedAuthorizationList;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip7702";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                blobGasPrice?: bigint | undefined;
+                blobGasUsed?: bigint | undefined;
+                blockHash: viem.Hash;
+                blockNumber: bigint;
+                contractAddress: abitype.Address | null | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                from: abitype.Address;
+                gasUsed: bigint;
+                logs: viem.Log<bigint, number, false>[];
+                logsBloom: viem.Hex;
+                root?: `0x${string}` | undefined;
+                status: "success" | "reverted";
+                to: abitype.Address | null;
+                transactionHash: viem.Hash;
+                transactionIndex: number;
+                type: viem.TransactionType;
+                l1GasPrice: bigint | null;
+                l1GasUsed: bigint | null;
+                l1Fee: bigint | null;
+                l1FeeScalar: number | null;
+            } & {};
+            type: "transactionReceipt";
+        };
+    };
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers: {
+        readonly transaction: typeof _reown_appkit_networks.serializeTransactionOpStack;
+    };
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Optimism Explorer";
+            readonly url: "https://optimistic.etherscan.io";
+            readonly apiUrl: "https://api-optimistic.etherscan.io/api";
+        };
+    };
+    blockTime: 2000;
+    contracts: {
+        readonly disputeGameFactory: {
+            readonly 1: {
+                readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
+            };
+        };
+        readonly l2OutputOracle: {
+            readonly 1: {
+                readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
+            };
+        };
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 4286263;
+        };
+        readonly portal: {
+            readonly 1: {
+                readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
+            };
+        };
+        readonly l1StandardBridge: {
+            readonly 1: {
+                readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
+            };
+        };
+        readonly gasPriceOracle: {
+            readonly address: "0x420000000000000000000000000000000000000F";
+        };
+        readonly l1Block: {
+            readonly address: "0x4200000000000000000000000000000000000015";
+        };
+        readonly l2CrossDomainMessenger: {
+            readonly address: "0x4200000000000000000000000000000000000007";
+        };
+        readonly l2Erc721Bridge: {
+            readonly address: "0x4200000000000000000000000000000000000014";
+        };
+        readonly l2StandardBridge: {
+            readonly address: "0x4200000000000000000000000000000000000010";
+        };
+        readonly l2ToL1MessagePasser: {
+            readonly address: "0x4200000000000000000000000000000000000016";
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 10;
+    name: "OP Mainnet";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://mainnet.optimism.io"];
+        };
+    };
+    sourceId: 1;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.OpStackRpcBlock, action?: string | undefined) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: viem.Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: abitype.Address;
+                mixHash: viem.Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentBeaconBlockRoot?: `0x${string}` | undefined;
+                parentHash: viem.Hash;
+                receiptsRoot: viem.Hex;
+                sealFields: viem.Hex[];
+                sha3Uncles: viem.Hash;
+                size: bigint;
+                stateRoot: viem.Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | _reown_appkit_networks.OpStackTransaction<boolean>[];
+                transactionsRoot: viem.Hash;
+                uncles: viem.Hash[];
+                withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                withdrawalsRoot?: `0x${string}` | undefined;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.OpStackRpcTransaction, action?: string | undefined) => ({
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean;
+                mint?: bigint | undefined | undefined;
+                sourceHash: viem.Hex;
+                type: "deposit";
+            } | {
+                r: viem.Hex;
+                s: viem.Hex;
+                v: bigint;
+                value: bigint;
+                gas: bigint;
+                to: abitype.Address | null;
+                from: abitype.Address;
+                nonce: number;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                transactionIndex: number | null;
+                hash: viem.Hash;
+                input: viem.Hex;
+                typeHex: viem.Hex | null;
+                accessList?: undefined | undefined;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId?: number | undefined;
+                yParity?: undefined | undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes: readonly viem.Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList: viem.SignedAuthorizationList;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip7702";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                blobGasPrice?: bigint | undefined;
+                blobGasUsed?: bigint | undefined;
+                blockHash: viem.Hash;
+                blockNumber: bigint;
+                contractAddress: abitype.Address | null | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                from: abitype.Address;
+                gasUsed: bigint;
+                logs: viem.Log<bigint, number, false>[];
+                logsBloom: viem.Hex;
+                root?: `0x${string}` | undefined;
+                status: "success" | "reverted";
+                to: abitype.Address | null;
+                transactionHash: viem.Hash;
+                transactionIndex: number;
+                type: viem.TransactionType;
+                l1GasPrice: bigint | null;
+                l1GasUsed: bigint | null;
+                l1Fee: bigint | null;
+                l1FeeScalar: number | null;
+            } & {};
+            type: "transactionReceipt";
+        };
+    };
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers: {
+        readonly transaction: typeof _reown_appkit_networks.serializeTransactionOpStack;
+    };
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "PolygonScan";
+            readonly url: "https://polygonscan.com";
+            readonly apiUrl: "https://api.polygonscan.com/api";
+        };
+    };
+    blockTime: 2000;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 25770160;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 137;
+    name: "Polygon";
+    nativeCurrency: {
+        readonly name: "POL";
+        readonly symbol: "POL";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://polygon-rpc.com"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "SnowTrace";
+            readonly url: "https://snowtrace.io";
+            readonly apiUrl: "https://api.snowtrace.io";
+        };
+    };
+    blockTime: 1700;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 11907934;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 43114;
+    name: "Avalanche";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Avalanche";
+        readonly symbol: "AVAX";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.avax.network/ext/bc/C/rpc"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "BscScan";
+            readonly url: "https://bscscan.com";
+            readonly apiUrl: "https://api.bscscan.com/api";
+        };
+    };
+    blockTime: 750;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 15921452;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 56;
+    name: "BNB Smart Chain";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "BNB";
+        readonly symbol: "BNB";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://56.rpc.thirdweb.com"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://lineascan.build";
+            readonly apiUrl: "https://api.lineascan.build/api";
+        };
+    };
+    blockTime: 2000;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+            readonly blockCreated: 42;
+        };
+        readonly ensRegistry: {
+            readonly address: "0x50130b669B28C339991d8676FA73CF122a121267";
+            readonly blockCreated: 6682888;
+        };
+        readonly ensUniversalResolver: {
+            readonly address: "0x4D41762915F83c76EcaF6776d9b08076aA32b492";
+            readonly blockCreated: 22222151;
+        };
+    };
+    ensTlds: readonly [".linea.eth"];
+    id: 59144;
+    name: "Linea Mainnet";
+    nativeCurrency: {
+        readonly name: "Linea Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.linea.build"];
+            readonly webSocket: readonly ["wss://rpc.linea.build"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    fees: {
+        readonly estimateFeesPerGas: ({ client, multiply, request, type, }: Parameters<viem.ChainEstimateFeesPerGasFn>[0]) => ReturnType<viem.ChainEstimateFeesPerGasFn>;
+        readonly maxPriorityFeePerGas: ({ block, client, request }: viem.ChainFeesFnParameters<viem.ChainFormatters | undefined>) => Promise<bigint | null>;
+    };
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Scrollscan";
+            readonly url: "https://scrollscan.com";
+            readonly apiUrl: "https://api.scrollscan.com/api";
+        };
+    };
+    blockTime: 3000;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 14;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 534352;
+    name: "Scroll";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.scroll.io"];
+            readonly webSocket: readonly ["wss://wss-rpc.scroll.io/ws"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Gnosisscan";
+            readonly url: "https://gnosisscan.io";
+            readonly apiUrl: "https://api.gnosisscan.io/api";
+        };
+    };
+    blockTime: 5000;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 21022491;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 100;
+    name: "Gnosis";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "xDAI";
+        readonly symbol: "XDAI";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.gnosischain.com"];
+            readonly webSocket: readonly ["wss://rpc.gnosischain.com/wss"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Celo Explorer";
+            readonly url: "https://celoscan.io";
+            readonly apiUrl: "https://api.celoscan.io/api";
+        };
+    };
+    blockTime: 1000;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+            readonly blockCreated: 13112599;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 42220;
+    name: "Celo";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "CELO";
+        readonly symbol: "CELO";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://forno.celo.org"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    fees: viem.ChainFees<{
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.CeloRpcBlock, action?: string | undefined) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: viem.Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: abitype.Address;
+                mixHash: viem.Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentBeaconBlockRoot?: `0x${string}` | undefined;
+                parentHash: viem.Hash;
+                receiptsRoot: viem.Hex;
+                sealFields: viem.Hex[];
+                sha3Uncles: viem.Hash;
+                size: bigint;
+                stateRoot: viem.Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | _reown_appkit_networks.CeloTransaction<boolean>[];
+                transactionsRoot: viem.Hash;
+                uncles: viem.Hash[];
+                withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                withdrawalsRoot?: `0x${string}` | undefined;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.CeloRpcTransaction, action?: string | undefined) => ({
+                r: viem.Hex;
+                s: viem.Hex;
+                v: bigint;
+                value: bigint;
+                gas: bigint;
+                to: abitype.Address | null;
+                from: abitype.Address;
+                nonce: number;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                transactionIndex: number | null;
+                hash: viem.Hash;
+                input: viem.Hex;
+                typeHex: viem.Hex | null;
+                accessList?: undefined | undefined;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId?: number | undefined;
+                yParity?: undefined | undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                feeCurrency: abitype.Address | null;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                feeCurrency: abitype.Address | null;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                feeCurrency: abitype.Address | null;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes: readonly viem.Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                feeCurrency: abitype.Address | null;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList: viem.SignedAuthorizationList;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip7702";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                feeCurrency: abitype.Address | null;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                accessList: viem.AccessList;
+                chainId: number;
+                feeCurrency: abitype.Address | null;
+                gatewayFee: bigint | null;
+                gatewayFeeRecipient: abitype.Address | null;
+                type: "cip42";
+                blobVersionedHashes?: undefined;
+                authorizationList?: undefined;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                accessList: viem.AccessList;
+                chainId: number;
+                feeCurrency: abitype.Address | null;
+                type: "cip64";
+                blobVersionedHashes?: undefined;
+                authorizationList?: undefined;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean;
+                mint?: bigint | undefined | undefined;
+                sourceHash: viem.Hex;
+                type: "deposit";
+                blobVersionedHashes?: undefined;
+                accessList?: undefined;
+                authorizationList?: undefined;
+                chainId?: undefined;
+                feeCurrency?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionRequest: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.CeloTransactionRequest, action?: string | undefined) => ({
+                data?: `0x${string}` | undefined;
+                from?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: `0x${string}` | null | undefined;
+                type?: "0x0" | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: `0x${string}` | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                blobs?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                accessList?: undefined;
+                sidecars?: undefined;
+                authorizationList?: undefined;
+                feeCurrency?: `0x${string}` | undefined;
+            } | {
+                data?: `0x${string}` | undefined;
+                from?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: `0x${string}` | null | undefined;
+                type?: "0x1" | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: `0x${string}` | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                accessList?: viem.AccessList | undefined;
+                blobs?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                authorizationList?: undefined;
+                feeCurrency?: `0x${string}` | undefined;
+            } | {
+                data?: `0x${string}` | undefined;
+                from?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: `0x${string}` | null | undefined;
+                type?: "0x2" | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                accessList?: viem.AccessList | undefined;
+                blobs?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                authorizationList?: undefined;
+                feeCurrency?: `0x${string}` | undefined;
+            } | {
+                type?: "0x3" | undefined;
+                data?: `0x${string}` | undefined;
+                value?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                from?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to: `0x${string}` | null;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: `0x${string}` | undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                accessList?: viem.AccessList | undefined;
+                sidecars?: readonly viem.BlobSidecar<`0x${string}`>[] | undefined;
+                blobs?: readonly `0x${string}`[] | readonly viem.ByteArray[] | undefined;
+                blobVersionedHashes: readonly viem.Hex[];
+                kzg?: undefined;
+                authorizationList?: undefined;
+                feeCurrency?: `0x${string}` | undefined;
+            } | {
+                type?: "0x3" | undefined;
+                data?: `0x${string}` | undefined;
+                value?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                from?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to: `0x${string}` | null;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: `0x${string}` | undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                accessList?: viem.AccessList | undefined;
+                sidecars?: readonly viem.BlobSidecar<`0x${string}`>[] | undefined;
+                blobs: readonly viem.Hex[] | readonly viem.ByteArray[];
+                blobVersionedHashes?: readonly `0x${string}`[] | undefined;
+                kzg?: viem.Kzg | undefined;
+                authorizationList?: undefined;
+                feeCurrency?: `0x${string}` | undefined;
+            } | {
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                type?: "0x4" | undefined;
+                data?: `0x${string}` | undefined;
+                value?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                to?: `0x${string}` | null | undefined;
+                from?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                accessList?: viem.AccessList | undefined;
+                authorizationList?: viem.RpcAuthorizationList | undefined;
+                blobs?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                feeCurrency?: `0x${string}` | undefined;
+            } | {
+                data?: `0x${string}` | undefined;
+                from?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: `0x${string}` | null | undefined;
+                type?: "0x7b" | undefined;
+                value?: `0x${string}` | undefined;
+                accessList?: viem.AccessList | undefined;
+                feeCurrency?: `0x${string}` | undefined;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                blobs?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                authorizationList?: undefined;
+            }) & {};
+            type: "transactionRequest";
+        };
+    }>;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.CeloRpcBlock, action?: string | undefined) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: viem.Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: abitype.Address;
+                mixHash: viem.Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentBeaconBlockRoot?: `0x${string}` | undefined;
+                parentHash: viem.Hash;
+                receiptsRoot: viem.Hex;
+                sealFields: viem.Hex[];
+                sha3Uncles: viem.Hash;
+                size: bigint;
+                stateRoot: viem.Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | _reown_appkit_networks.CeloTransaction<boolean>[];
+                transactionsRoot: viem.Hash;
+                uncles: viem.Hash[];
+                withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                withdrawalsRoot?: `0x${string}` | undefined;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.CeloRpcTransaction, action?: string | undefined) => ({
+                r: viem.Hex;
+                s: viem.Hex;
+                v: bigint;
+                value: bigint;
+                gas: bigint;
+                to: abitype.Address | null;
+                from: abitype.Address;
+                nonce: number;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                transactionIndex: number | null;
+                hash: viem.Hash;
+                input: viem.Hex;
+                typeHex: viem.Hex | null;
+                accessList?: undefined | undefined;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId?: number | undefined;
+                yParity?: undefined | undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                feeCurrency: abitype.Address | null;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                feeCurrency: abitype.Address | null;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                feeCurrency: abitype.Address | null;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes: readonly viem.Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                feeCurrency: abitype.Address | null;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList: viem.SignedAuthorizationList;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip7702";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                feeCurrency: abitype.Address | null;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                accessList: viem.AccessList;
+                chainId: number;
+                feeCurrency: abitype.Address | null;
+                gatewayFee: bigint | null;
+                gatewayFeeRecipient: abitype.Address | null;
+                type: "cip42";
+                blobVersionedHashes?: undefined;
+                authorizationList?: undefined;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                accessList: viem.AccessList;
+                chainId: number;
+                feeCurrency: abitype.Address | null;
+                type: "cip64";
+                blobVersionedHashes?: undefined;
+                authorizationList?: undefined;
+                mint?: undefined;
+                isSystemTx?: undefined;
+                sourceHash?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean;
+                mint?: bigint | undefined | undefined;
+                sourceHash: viem.Hex;
+                type: "deposit";
+                blobVersionedHashes?: undefined;
+                accessList?: undefined;
+                authorizationList?: undefined;
+                chainId?: undefined;
+                feeCurrency?: undefined;
+                gatewayFee?: undefined;
+                gatewayFeeRecipient?: undefined;
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionRequest: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.CeloTransactionRequest, action?: string | undefined) => ({
+                data?: `0x${string}` | undefined;
+                from?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: `0x${string}` | null | undefined;
+                type?: "0x0" | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: `0x${string}` | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                blobs?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                accessList?: undefined;
+                sidecars?: undefined;
+                authorizationList?: undefined;
+                feeCurrency?: `0x${string}` | undefined;
+            } | {
+                data?: `0x${string}` | undefined;
+                from?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: `0x${string}` | null | undefined;
+                type?: "0x1" | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: `0x${string}` | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                accessList?: viem.AccessList | undefined;
+                blobs?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                authorizationList?: undefined;
+                feeCurrency?: `0x${string}` | undefined;
+            } | {
+                data?: `0x${string}` | undefined;
+                from?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: `0x${string}` | null | undefined;
+                type?: "0x2" | undefined;
+                value?: `0x${string}` | undefined;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                accessList?: viem.AccessList | undefined;
+                blobs?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                authorizationList?: undefined;
+                feeCurrency?: `0x${string}` | undefined;
+            } | {
+                type?: "0x3" | undefined;
+                data?: `0x${string}` | undefined;
+                value?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                from?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to: `0x${string}` | null;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: `0x${string}` | undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                accessList?: viem.AccessList | undefined;
+                sidecars?: readonly viem.BlobSidecar<`0x${string}`>[] | undefined;
+                blobs?: readonly `0x${string}`[] | readonly viem.ByteArray[] | undefined;
+                blobVersionedHashes: readonly viem.Hex[];
+                kzg?: undefined;
+                authorizationList?: undefined;
+                feeCurrency?: `0x${string}` | undefined;
+            } | {
+                type?: "0x3" | undefined;
+                data?: `0x${string}` | undefined;
+                value?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                from?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to: `0x${string}` | null;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: `0x${string}` | undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                accessList?: viem.AccessList | undefined;
+                sidecars?: readonly viem.BlobSidecar<`0x${string}`>[] | undefined;
+                blobs: readonly viem.Hex[] | readonly viem.ByteArray[];
+                blobVersionedHashes?: readonly `0x${string}`[] | undefined;
+                kzg?: viem.Kzg | undefined;
+                authorizationList?: undefined;
+                feeCurrency?: `0x${string}` | undefined;
+            } | {
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                type?: "0x4" | undefined;
+                data?: `0x${string}` | undefined;
+                value?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                to?: `0x${string}` | null | undefined;
+                from?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                accessList?: viem.AccessList | undefined;
+                authorizationList?: viem.RpcAuthorizationList | undefined;
+                blobs?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                feeCurrency?: `0x${string}` | undefined;
+            } | {
+                data?: `0x${string}` | undefined;
+                from?: `0x${string}` | undefined;
+                gas?: `0x${string}` | undefined;
+                nonce?: `0x${string}` | undefined;
+                to?: `0x${string}` | null | undefined;
+                type?: "0x7b" | undefined;
+                value?: `0x${string}` | undefined;
+                accessList?: viem.AccessList | undefined;
+                feeCurrency?: `0x${string}` | undefined;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: `0x${string}` | undefined;
+                maxPriorityFeePerGas?: `0x${string}` | undefined;
+                blobs?: undefined;
+                blobVersionedHashes?: undefined;
+                kzg?: undefined;
+                sidecars?: undefined;
+                authorizationList?: undefined;
+            }) & {};
+            type: "transactionRequest";
+        };
+    };
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers: {
+        readonly transaction: typeof _reown_appkit_networks.serializeTransactionCelo;
+    };
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Mantle Explorer";
+            readonly url: "https://mantlescan.xyz/";
+            readonly apiUrl: "https://api.mantlescan.xyz/api";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+            readonly blockCreated: 304717;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 5000;
+    name: "Mantle";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "MNT";
+        readonly symbol: "MNT";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.mantle.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Seitrace";
+            readonly url: "https://seitrace.com";
+            readonly apiUrl: "https://seitrace.com/pacific-1/api";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 1329;
+    name: "Sei Network";
+    nativeCurrency: {
+        readonly name: "Sei";
+        readonly symbol: "SEI";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://evm-rpc.sei-apis.com/"];
+            readonly webSocket: readonly ["wss://evm-ws.sei-apis.com/"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Worldscan";
+            readonly url: "https://worldscan.org";
+            readonly apiUrl: "https://api.worldscan.org/api";
+        };
+        readonly blockscout: {
+            readonly name: "Blockscout";
+            readonly url: "https://worldchain-mainnet.explorer.alchemy.com";
+            readonly apiUrl: "https://worldchain-mainnet.explorer.alchemy.com/api";
+        };
+    };
+    blockTime: 2000;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 0;
+        };
+        readonly disputeGameFactory: {
+            readonly 1: {
+                readonly address: "0x069c4c579671f8c120b1327a73217D01Ea2EC5ea";
+            };
+        };
+        readonly l2OutputOracle: {
+            readonly 1: {
+                readonly address: "0x19A6d1E9034596196295CF148509796978343c5D";
+            };
+        };
+        readonly portal: {
+            readonly 1: {
+                readonly address: "0xd5ec14a83B7d95BE1E2Ac12523e2dEE12Cbeea6C";
+            };
+        };
+        readonly l1StandardBridge: {
+            readonly 1: {
+                readonly address: "0x470458C91978D2d929704489Ad730DC3E3001113";
+            };
+        };
+        readonly gasPriceOracle: {
+            readonly address: "0x420000000000000000000000000000000000000F";
+        };
+        readonly l1Block: {
+            readonly address: "0x4200000000000000000000000000000000000015";
+        };
+        readonly l2CrossDomainMessenger: {
+            readonly address: "0x4200000000000000000000000000000000000007";
+        };
+        readonly l2Erc721Bridge: {
+            readonly address: "0x4200000000000000000000000000000000000014";
+        };
+        readonly l2StandardBridge: {
+            readonly address: "0x4200000000000000000000000000000000000010";
+        };
+        readonly l2ToL1MessagePasser: {
+            readonly address: "0x4200000000000000000000000000000000000016";
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 480;
+    name: "World Chain";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://worldchain-mainnet.g.alchemy.com/public"];
+        };
+    };
+    sourceId: 1;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.OpStackRpcBlock, action?: string | undefined) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: viem.Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: abitype.Address;
+                mixHash: viem.Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentBeaconBlockRoot?: `0x${string}` | undefined;
+                parentHash: viem.Hash;
+                receiptsRoot: viem.Hex;
+                sealFields: viem.Hex[];
+                sha3Uncles: viem.Hash;
+                size: bigint;
+                stateRoot: viem.Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | _reown_appkit_networks.OpStackTransaction<boolean>[];
+                transactionsRoot: viem.Hash;
+                uncles: viem.Hash[];
+                withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                withdrawalsRoot?: `0x${string}` | undefined;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.OpStackRpcTransaction, action?: string | undefined) => ({
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean;
+                mint?: bigint | undefined | undefined;
+                sourceHash: viem.Hex;
+                type: "deposit";
+            } | {
+                r: viem.Hex;
+                s: viem.Hex;
+                v: bigint;
+                value: bigint;
+                gas: bigint;
+                to: abitype.Address | null;
+                from: abitype.Address;
+                nonce: number;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                transactionIndex: number | null;
+                hash: viem.Hash;
+                input: viem.Hex;
+                typeHex: viem.Hex | null;
+                accessList?: undefined | undefined;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId?: number | undefined;
+                yParity?: undefined | undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes: readonly viem.Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList: viem.SignedAuthorizationList;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip7702";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                blobGasPrice?: bigint | undefined;
+                blobGasUsed?: bigint | undefined;
+                blockHash: viem.Hash;
+                blockNumber: bigint;
+                contractAddress: abitype.Address | null | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                from: abitype.Address;
+                gasUsed: bigint;
+                logs: viem.Log<bigint, number, false>[];
+                logsBloom: viem.Hex;
+                root?: `0x${string}` | undefined;
+                status: "success" | "reverted";
+                to: abitype.Address | null;
+                transactionHash: viem.Hash;
+                transactionIndex: number;
+                type: viem.TransactionType;
+                l1GasPrice: bigint | null;
+                l1GasUsed: bigint | null;
+                l1Fee: bigint | null;
+                l1FeeScalar: number | null;
+            } & {};
+            type: "transactionReceipt";
+        };
+    };
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers: {
+        readonly transaction: typeof _reown_appkit_networks.serializeTransactionOpStack;
+    };
+    readonly network: "worldchain";
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Uniscan";
+            readonly url: "https://uniscan.xyz";
+            readonly apiUrl: "https://api.uniscan.xyz/api";
+        };
+    };
+    blockTime: 1000;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 0;
+        };
+        readonly disputeGameFactory: {
+            readonly 1: {
+                readonly address: "0x2F12d621a16e2d3285929C9996f478508951dFe4";
+            };
+        };
+        readonly portal: {
+            readonly 1: {
+                readonly address: "0x0bd48f6B86a26D3a217d0Fa6FfE2B491B956A7a2";
+            };
+        };
+        readonly l1StandardBridge: {
+            readonly 1: {
+                readonly address: "0x81014F44b0a345033bB2b3B21C7a1A308B35fEeA";
+            };
+        };
+        readonly gasPriceOracle: {
+            readonly address: "0x420000000000000000000000000000000000000F";
+        };
+        readonly l1Block: {
+            readonly address: "0x4200000000000000000000000000000000000015";
+        };
+        readonly l2CrossDomainMessenger: {
+            readonly address: "0x4200000000000000000000000000000000000007";
+        };
+        readonly l2Erc721Bridge: {
+            readonly address: "0x4200000000000000000000000000000000000014";
+        };
+        readonly l2StandardBridge: {
+            readonly address: "0x4200000000000000000000000000000000000010";
+        };
+        readonly l2ToL1MessagePasser: {
+            readonly address: "0x4200000000000000000000000000000000000016";
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 130;
+    name: "Unichain";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://mainnet.unichain.org/"];
+        };
+    };
+    sourceId: 1;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters: {
+        readonly block: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.OpStackRpcBlock, action?: string | undefined) => {
+                baseFeePerGas: bigint | null;
+                blobGasUsed: bigint;
+                difficulty: bigint;
+                excessBlobGas: bigint;
+                extraData: viem.Hex;
+                gasLimit: bigint;
+                gasUsed: bigint;
+                hash: `0x${string}` | null;
+                logsBloom: `0x${string}` | null;
+                miner: abitype.Address;
+                mixHash: viem.Hash;
+                nonce: `0x${string}` | null;
+                number: bigint | null;
+                parentBeaconBlockRoot?: `0x${string}` | undefined;
+                parentHash: viem.Hash;
+                receiptsRoot: viem.Hex;
+                sealFields: viem.Hex[];
+                sha3Uncles: viem.Hash;
+                size: bigint;
+                stateRoot: viem.Hash;
+                timestamp: bigint;
+                totalDifficulty: bigint | null;
+                transactions: `0x${string}`[] | _reown_appkit_networks.OpStackTransaction<boolean>[];
+                transactionsRoot: viem.Hash;
+                uncles: viem.Hash[];
+                withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                withdrawalsRoot?: `0x${string}` | undefined;
+            } & {};
+            type: "block";
+        };
+        readonly transaction: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.OpStackRpcTransaction, action?: string | undefined) => ({
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: boolean;
+                mint?: bigint | undefined | undefined;
+                sourceHash: viem.Hex;
+                type: "deposit";
+            } | {
+                r: viem.Hex;
+                s: viem.Hex;
+                v: bigint;
+                value: bigint;
+                gas: bigint;
+                to: abitype.Address | null;
+                from: abitype.Address;
+                nonce: number;
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                transactionIndex: number | null;
+                hash: viem.Hash;
+                input: viem.Hex;
+                typeHex: viem.Hex | null;
+                accessList?: undefined | undefined;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId?: number | undefined;
+                yParity?: undefined | undefined;
+                type: "legacy";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip2930";
+                gasPrice: bigint;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas?: undefined | undefined;
+                maxPriorityFeePerGas?: undefined | undefined;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip1559";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList?: undefined | undefined;
+                blobVersionedHashes: readonly viem.Hex[];
+                chainId: number;
+                type: "eip4844";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas: bigint;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            } | {
+                blockHash: `0x${string}` | null;
+                blockNumber: bigint | null;
+                from: abitype.Address;
+                gas: bigint;
+                hash: viem.Hash;
+                input: viem.Hex;
+                nonce: number;
+                r: viem.Hex;
+                s: viem.Hex;
+                to: abitype.Address | null;
+                transactionIndex: number | null;
+                typeHex: viem.Hex | null;
+                v: bigint;
+                value: bigint;
+                yParity: number;
+                accessList: viem.AccessList;
+                authorizationList: viem.SignedAuthorizationList;
+                blobVersionedHashes?: undefined | undefined;
+                chainId: number;
+                type: "eip7702";
+                gasPrice?: undefined | undefined;
+                maxFeePerBlobGas?: undefined | undefined;
+                maxFeePerGas: bigint;
+                maxPriorityFeePerGas: bigint;
+                isSystemTx?: undefined | undefined;
+                mint?: undefined | undefined;
+                sourceHash?: undefined | undefined;
+            }) & {};
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: _reown_appkit_networks.OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                blobGasPrice?: bigint | undefined;
+                blobGasUsed?: bigint | undefined;
+                blockHash: viem.Hash;
+                blockNumber: bigint;
+                contractAddress: abitype.Address | null | undefined;
+                cumulativeGasUsed: bigint;
+                effectiveGasPrice: bigint;
+                from: abitype.Address;
+                gasUsed: bigint;
+                logs: viem.Log<bigint, number, false>[];
+                logsBloom: viem.Hex;
+                root?: `0x${string}` | undefined;
+                status: "success" | "reverted";
+                to: abitype.Address | null;
+                transactionHash: viem.Hash;
+                transactionIndex: number;
+                type: viem.TransactionType;
+                l1GasPrice: bigint | null;
+                l1GasUsed: bigint | null;
+                l1Fee: bigint | null;
+                l1FeeScalar: number | null;
+            } & {};
+            type: "transactionReceipt";
+        };
+    };
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers: {
+        readonly transaction: typeof _reown_appkit_networks.serializeTransactionOpStack;
+    };
+}];
+declare const solanaNetworks: readonly [{
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Solscan";
+            readonly url: "https://solscan.io";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: viem.ChainContract | {
+            [sourceId: number]: viem.ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: viem.ChainContract | undefined;
+        ensUniversalResolver?: viem.ChainContract | undefined;
+        multicall3?: viem.ChainContract | undefined;
+        erc6492Verifier?: viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    name: "Solana";
+    nativeCurrency: {
+        readonly name: "Solana";
+        readonly symbol: "SOL";
+        readonly decimals: 9;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.walletconnect.org/v1"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    id: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+    chainNamespace: "solana";
+    caipNetworkId: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+    assets?: {
+        imageId: string | undefined;
+        imageUrl: string | undefined;
+    } | undefined;
+    readonly network: "solana-mainnet";
+    readonly deprecatedCaipNetworkId: "solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ";
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Solscan";
+            readonly url: "https://solscan.io";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: viem.ChainContract | {
+            [sourceId: number]: viem.ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: viem.ChainContract | undefined;
+        ensUniversalResolver?: viem.ChainContract | undefined;
+        multicall3?: viem.ChainContract | undefined;
+        erc6492Verifier?: viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    name: "Solana Devnet";
+    nativeCurrency: {
+        readonly name: "Solana";
+        readonly symbol: "SOL";
+        readonly decimals: 9;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.walletconnect.org/v1"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    id: "EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+    chainNamespace: "solana";
+    caipNetworkId: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+    assets?: {
+        imageId: string | undefined;
+        imageUrl: string | undefined;
+    } | undefined;
+    readonly network: "solana-devnet";
+    readonly deprecatedCaipNetworkId: "solana:8E9rvCKLFQia2Y35HXjjpWzj8weVo44K";
+}];
+interface AppKitFactoryConfig {
+    /**
+     * WalletConnect project ID from https://cloud.reown.com/
+     */
+    projectId: string;
+    /**
+     * Optional metadata for wallet connection modal
+     */
+    metadata?: {
+        name?: string;
+        description?: string;
+        url?: string;
+        icons?: string[];
+    };
+}
+interface AppKitConfig {
+    wagmiAdapter: WagmiAdapter;
+    wagmiConfig: WagmiAdapter['wagmiConfig'];
+    solanaAdapter: SolanaAdapter;
+    modal: ReturnType<typeof createAppKit>;
+}
+/**
+ * Creates AppKit configuration for wallet connections.
+ *
+ * Call this at module level (outside components) for SSR safety.
+ *
+ * @example
+ * ```tsx
+ * import { createAppKitConfig } from '@ordanetwork/sdk/react';
+ *
+ * const appKitConfig = createAppKitConfig({
+ *   projectId: process.env.NEXT_PUBLIC_WALLET_CONNECT_PROJECT_ID!,
+ *   metadata: {
+ *     name: 'My App',
+ *     description: 'My payment app',
+ *   },
+ * });
+ * ```
+ */
+declare function createAppKitConfig(config: AppKitFactoryConfig): AppKitConfig;
+
+/**
+ * JWT token response from getToken callback
+ */
+interface TokenResponse {
+    jwt: string;
+    expiresAt: number;
+}
+/**
+ * Configuration for OrdaProvider
+ */
+interface OrdaProviderConfig {
+    /**
+     * Function that returns a JWT token for SDK authentication.
+     * Called on initialization and before token expiration.
+     *
+     * @example
+     * ```ts
+     * getToken: async () => {
+     *   const res = await fetch('/api/auth/jwt', { method: 'POST' });
+     *   return res.json(); // { jwt: string, expiresAt: number }
+     * }
+     * ```
+     */
+    getToken: () => Promise<TokenResponse>;
+    /**
+     * AppKit configuration from createAppKitConfig().
+     * Provides wallet connection capabilities for EVM and Solana chains.
+     *
+     * @example
+     * ```ts
+     * const appKitConfig = createAppKitConfig({
+     *   projectId: process.env.NEXT_PUBLIC_WALLET_CONNECT_PROJECT_ID!,
+     * });
+     *
+     * <OrdaProvider config={{ appKitConfig, getToken }}>
+     * ```
+     */
+    appKitConfig: AppKitConfig;
+    debug?: boolean;
+}
+/**
+ * Props for OrdaProvider component
+ */
+interface OrdaProviderProps {
+    config: OrdaProviderConfig;
+    children: React.ReactNode;
+}
+/**
+ * SDK context value available via useOrdaSDK()
+ */
+interface OrdaSDKContextValue {
+    sdk: OrdaSDK | null;
+    isLoading: boolean;
+    error: Error | null;
+    refreshToken: () => Promise<void>;
+    isRefreshing: boolean;
+    waitForRefresh: () => Promise<void>;
+}
+
+/**
+ * Main provider component for the Orda SDK React integration.
+ *
+ * Provides:
+ * - Wallet connection (EVM + Solana via Reown AppKit)
+ * - SDK initialization and JWT management
+ * - TanStack Query for data fetching
+ * - Toast notifications
+ *
+ * @example
+ * ```tsx
+ * import { createAppKitConfig, OrdaProvider, Widget } from '@ordanetwork/sdk/react';
+ * import '@ordanetwork/sdk/react/styles.css';
+ *
+ * const appKitConfig = createAppKitConfig({
+ *   projectId: process.env.NEXT_PUBLIC_WALLET_CONNECT_PROJECT_ID!,
+ * });
+ *
+ * function App() {
+ *   return (
+ *     <OrdaProvider
+ *       config={{
+ *         getToken: async () => {
+ *           const res = await fetch('/api/auth/jwt', { method: 'POST' });
+ *           return res.json();
+ *         },
+ *         appKitConfig,
+ *       }}
+ *     >
+ *       <Widget />
+ *     </OrdaProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function OrdaProvider({ config, children }: OrdaProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hook to access the Orda SDK instance and authentication state.
+ *
+ * @throws Error if used outside of OrdaProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { sdk, isLoading, error } = useOrdaSDK();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *   if (!sdk) return null;
+ *
+ *   // Use sdk...
+ * }
+ * ```
+ */
+declare function useOrdaSDK(): OrdaSDKContextValue;
+
+interface UseQuoteReturn {
+    quote: TransferResponse | DirectTransferResponse | null;
+    isLoading: boolean;
+    error: Error | null;
+    requestQuote: (params: QuoteRequestParams) => Promise<TransferResponse | DirectTransferResponse | null>;
+    clearQuote: () => void;
+}
+/**
+ * Hook for requesting cross-chain transfer quotes
+ *
+ * @example
+ * ```tsx
+ * const { quote, isLoading, error, requestQuote } = useQuote();
+ *
+ * const handleGetQuote = async () => {
+ *   const result = await requestQuote({
+ *     fromChain: '1',
+ *     fromToken: '0x...',
+ *     fromAddress: '0x...',
+ *     intent: { method: 'usd', value: '100' },
+ *     recipientId: 'rec_xxx',
+ *   });
+ * };
+ * ```
+ */
+declare function useQuote(): UseQuoteReturn;
+
+interface UseRecipientReturn {
+    recipient: CreateRecipientResponse | UpdateRecipientResponse | null;
+    isLoading: boolean;
+    error: Error | null;
+    createRecipient: (params: CreateRecipientParams) => Promise<CreateRecipientResponse | null>;
+    updateRecipient: (params: UpdateRecipientSettlementParams) => Promise<UpdateRecipientResponse | null>;
+    deactivateRecipient: (params: DeactivateRecipientParams) => Promise<boolean>;
+    listRecipients: (params?: ListRecipientsParams) => Promise<ListRecipientsResponse | null>;
+    clearRecipient: () => void;
+}
+/**
+ * Hook for managing recipients (create, update, deactivate, list)
+ *
+ * @example
+ * ```tsx
+ * const { recipient, isLoading, createRecipient, listRecipients } = useRecipient();
+ *
+ * // Create a recipient
+ * const newRecipient = await createRecipient({
+ *   name: 'John Doe',
+ *   cryptoSettlementDetails: { toChain: '1', toToken: '0x...', toAddress: '0x...' },
+ * });
+ *
+ * // List recipients
+ * const recipients = await listRecipients({ limit: 10 });
+ * ```
+ */
+declare function useRecipient(): UseRecipientReturn;
+
+interface UseTransactionReturn {
+    status: TransactionStatusResponse | null;
+    isLoading: boolean;
+    error: Error | null;
+    getStatus: (params: TransactionStatusParams) => Promise<TransactionStatusResponse | null>;
+    waitForCompletion: (transactionId: string, options?: PollingOptions) => Promise<TransactionStatusResponse | null>;
+    getSuccessfulTransactions: () => Promise<TransactionListItem[] | null>;
+    clearStatus: () => void;
+}
+/**
+ * Hook for transaction status monitoring and polling
+ *
+ * @example
+ * ```tsx
+ * const { status, isLoading, getStatus, waitForCompletion } = useTransaction();
+ *
+ * // Get current status
+ * const result = await getStatus({ transactionId: 'tx_xxx' });
+ *
+ * // Wait for completion with polling
+ * const finalStatus = await waitForCompletion('tx_xxx', {
+ *   intervalMs: 5000,
+ *   timeoutMs: 300000,
+ *   onStatusUpdate: (status) => console.log('Status:', status),
+ * });
+ * ```
+ */
+declare function useTransaction(): UseTransactionReturn;
+
+interface UseOffRampReturn {
+    quote: OffRampQuoteResponse | null;
+    status: OffRampStatusResponse | null;
+    isLoading: boolean;
+    error: Error | null;
+    requestQuote: (params: OffRampQuoteParams) => Promise<OffRampQuoteResponse | null>;
+    getStatus: (transactionId: string) => Promise<OffRampStatusResponse | null>;
+    waitForCompletion: (transactionId: string, options?: OffRampPollingOptions) => Promise<OffRampStatusResponse | null>;
+    clearQuote: () => void;
+}
+/**
+ * Hook for off-ramp (crypto to fiat) operations
+ *
+ * @example
+ * ```tsx
+ * const { quote, status, isLoading, requestQuote, waitForCompletion } = useOffRamp();
+ *
+ * // Request off-ramp quote
+ * const quoteResult = await requestQuote({
+ *   fromChain: '137',
+ *   fromToken: '0x...',
+ *   fromAddress: '0x...',
+ *   fromAmount: '100000000',
+ *   recipientId: 'rec_xxx',
+ * });
+ *
+ * // Wait for completion
+ * const finalStatus = await waitForCompletion(quoteResult.transactionId);
+ * ```
+ */
+declare function useOffRamp(): UseOffRampReturn;
+
+interface UseOnRampReturn {
+    quote: OnRampQuoteResponse | null;
+    status: OnRampStatusResponse | null;
+    isLoading: boolean;
+    error: Error | null;
+    requestQuote: (params: OnRampQuoteParams) => Promise<OnRampQuoteResponse | null>;
+    getStatus: (transactionId: string) => Promise<OnRampStatusResponse | null>;
+    waitForCompletion: (transactionId: string, options?: OnRampPollingOptions) => Promise<OnRampStatusResponse | null>;
+    clearQuote: () => void;
+}
+/**
+ * Hook for on-ramp (fiat to crypto) operations
+ *
+ * @example
+ * ```tsx
+ * const { quote, status, isLoading, requestQuote, waitForCompletion } = useOnRamp();
+ *
+ * // Request on-ramp quote
+ * const quoteResult = await requestQuote({
+ *   toChain: '137',
+ *   toToken: '0x...',
+ *   toAddress: '0x...',
+ *   fiatAmount: '100',
+ *   fiatCurrency: 'BRL',
+ * });
+ *
+ * // Wait for completion
+ * const finalStatus = await waitForCompletion(quoteResult.transactionId);
+ * ```
+ */
+declare function useOnRamp(): UseOnRampReturn;
+
+interface UseTokenPricesOptions {
+    tokens: TokenPriceRequest[];
+    enabled?: boolean;
+    staleTime?: number;
+    refetchInterval?: number;
+}
+interface UseTokenPricesReturn {
+    prices: TokenPriceData[];
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for fetching token prices with TanStack Query caching
+ *
+ * Uses the SDK's backend-powered prices API
+ *
+ * @example
+ * ```tsx
+ * const { prices, isLoading, error } = useTokenPrices({
+ *   tokens: [
+ *     { address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', chainId: '1' }, // USDC
+ *     { address: '0x0000000000000000000000000000000000000000', chainId: '137' }, // Native MATIC
+ *   ],
+ * });
+ *
+ * // Access price data
+ * const usdcPrice = prices.find(p => p.chainId === '1')?.usdPrice;
+ * ```
+ */
+declare function useTokenPrices(options: UseTokenPricesOptions): UseTokenPricesReturn;
+
+interface UseBalancesOptions {
+    address: string | undefined;
+    options?: BalancesFetchOptions;
+    enabled?: boolean;
+    staleTime?: number;
+    refetchInterval?: number;
+}
+interface UseBalancesReturn {
+    data: BalancesFetchResponse | null;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for fetching wallet token balances with TanStack Query caching
+ *
+ * Uses the SDK's backend-powered balances.
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading, error } = useBalances({
+ *   address: walletAddress,
+ *   options: {
+ *     chainIds: ['1', '137', '8453'],
+ *     filter: 'known',
+ *   },
+ * });
+ *
+ * // Access balance data
+ * if (data) {
+ *   console.log('Total tokens:', data.data.summary.totalTokens);
+ *   data.data.balances.forEach(balance => {
+ *     console.log(`${balance.symbol}: ${balance.balanceFormatted}`);
+ *   });
+ * }
+ * ```
+ */
+declare function useBalances(options: UseBalancesOptions): UseBalancesReturn;
+
+/**
+ * Hook for responsive design using CSS media queries
+ *
+ * SSR-safe: Returns false during server-side rendering and initial hydration,
+ * then updates to the actual value after the component mounts. This prevents
+ * hydration mismatches when using media queries to conditionally render
+ * different components (e.g., Dialog vs Drawer).
+ *
+ * @example
+ * ```tsx
+ * const isMobile = useMediaQuery('(max-width: 768px)');
+ * const isTablet = useMediaQuery('(min-width: 769px) and (max-width: 1024px)');
+ * const prefersDark = useMediaQuery('(prefers-color-scheme: dark)');
+ *
+ * if (isMobile) {
+ *   return <MobileLayout />;
+ * }
+ * ```
+ */
+declare function useMediaQuery(query: string): boolean;
+
+/**
+ * Stored fiat (off-ramp) recipient with PIX payment details
+ */
+interface StoredFiatRecipient {
+    recipientId: string;
+    name: string;
+    pixKey: string;
+    createdAt: number;
+}
+/**
+ * Stored crypto (on-ramp) recipient with wallet details
+ */
+interface StoredCryptoRecipient {
+    recipientId: string;
+    name: string;
+    address: string;
+    chainId: string;
+    tokenAddress: string;
+    createdAt: number;
+}
+interface UseLocalRecipientsReturn {
+    fiatRecipients: StoredFiatRecipient[];
+    addFiatRecipient: (recipient: Omit<StoredFiatRecipient, 'createdAt'>) => void;
+    findFiatByPixKey: (pixKey: string) => StoredFiatRecipient | undefined;
+    cryptoRecipients: StoredCryptoRecipient[];
+    addCryptoRecipient: (recipient: Omit<StoredCryptoRecipient, 'createdAt'>) => void;
+    findCryptoByAddress: (address: string) => StoredCryptoRecipient | undefined;
+    findCryptoByAddressChainAndToken: (address: string, chainId: string, tokenAddress: string) => StoredCryptoRecipient | undefined;
+    getUniqueAddressRecipients: () => StoredCryptoRecipient[];
+}
+/**
+ * Hook for managing recipients in localStorage with fiat/crypto separation
+ *
+ * Persists recipient selections across sessions.
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   fiatRecipients,
+ *   addFiatRecipient,
+ *   findFiatByPixKey,
+ *   cryptoRecipients,
+ *   addCryptoRecipient,
+ *   findCryptoByAddressChainAndToken,
+ *   getUniqueAddressRecipients,
+ * } = useLocalRecipients();
+ *
+ * // Add a fiat recipient
+ * addFiatRecipient({
+ *   recipientId: 'rec_xxx',
+ *   name: 'John Doe',
+ *   pixKey: 'john@email.com',
+ * });
+ *
+ * // Add a crypto recipient
+ * addCryptoRecipient({
+ *   recipientId: 'rec_yyy',
+ *   name: 'Wallet 0x1234...',
+ *   address: '0x1234...',
+ *   chainId: '1',
+ *   tokenAddress: '0xA0b8...',
+ * });
+ *
+ * // Find existing recipient
+ * const existing = findCryptoByAddressChainAndToken('0x1234...', '1', '0xA0b8...');
+ * ```
+ */
+declare function useLocalRecipients(): UseLocalRecipientsReturn;
+
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const Input: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+
+declare const Label: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React$1.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: class_variance_authority_dist_types.ClassProp | undefined) => string> & React$1.RefAttributes<HTMLLabelElement>>;
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+declare function Dialog({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Root>): react_jsx_runtime.JSX.Element;
+declare function DialogTrigger({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
+declare function DialogPortal({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Portal>): react_jsx_runtime.JSX.Element;
+declare function DialogClose({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Close>): react_jsx_runtime.JSX.Element;
+declare function DialogOverlay({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Overlay>): react_jsx_runtime.JSX.Element;
+declare function DialogContent({ className, children, showCloseButton, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Content> & {
+    showCloseButton?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DialogHeader({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function DialogFooter({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function DialogTitle({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Title>): react_jsx_runtime.JSX.Element;
+declare function DialogDescription({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Description>): react_jsx_runtime.JSX.Element;
+
+declare const Drawer: {
+    ({ shouldScaleBackground, ...props }: React$1.ComponentProps<typeof Drawer$1.Root>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DrawerTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DrawerPortal: typeof vaul.Portal;
+declare const DrawerClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DrawerOverlay: React$1.ForwardRefExoticComponent<Omit<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DrawerContent: React$1.ForwardRefExoticComponent<Omit<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DrawerHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DrawerFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const DrawerTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DrawerDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const Popover: React$1.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Select: React$1.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React$1.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Sheet: React$1.FC<DialogPrimitive.DialogProps>;
+declare const SheetTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const SheetOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: ({
+    side?: "top" | "right" | "bottom" | "left" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: React$1.ForwardRefExoticComponent<SheetContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const Widget: () => react_jsx_runtime.JSX.Element;
+
+type Token = {
+    address?: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    chainId: string;
+    logoUrl?: string;
+    disabled?: boolean;
+};
+type Chain = {
+    value: string;
+    label: string;
+    logoUrl?: string;
+    symbol: string;
+};
+type TransactionType = 'onRamp' | 'offRamp' | 'swap';
+type RecipientType = {
+    key: string;
+    chain: string;
+    image: string;
+};
+
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * Converts nominal (human-readable) values to native (smallest unit) values
+ * Uses string manipulation to avoid floating-point precision issues
+ * Example: "100.5" USDC (6 decimals) → "100500000"
+ *
+ * @param nominalValue - Human-readable amount (e.g., "100.5")
+ * @param decimals - Token decimals (e.g., 6 for USDC, 18 for ETH)
+ * @returns Native units as string (e.g., "100500000")
+ */
+declare function parseToNativeUnits(nominalValue: string, decimals: number): string;
+/**
+ * Converts native (smallest unit) values to nominal (human-readable) values
+ * Example: "100500000" → "100.5" (6 decimals)
+ *
+ * @param nativeValue - Native units as string (e.g., "100500000")
+ * @param decimals - Token decimals (e.g., 6 for USDC, 18 for ETH)
+ * @returns Human-readable amount as string (e.g., "100.5")
+ */
+declare function parseFromNativeUnits(nativeValue: string, decimals: number): string;
+/**
+ * Format crypto amounts for display with smart decimal places
+ * Adjusts precision based on amount magnitude
+ *
+ * @param amount - Amount in native units as string
+ * @param decimals - Token decimals
+ * @returns Formatted display string (e.g., "100.50", "0.0012")
+ */
+declare function formatCryptoAmount(amount: string, decimals: number): string;
+/**
+ * Truncates an address for display
+ * Example: 0x1234567890abcdef... → 0x1234...cdef
+ *
+ * @param address - The full address to truncate
+ * @param chars - Number of characters to show at start and end (default: 4)
+ * @returns Truncated address string (e.g., "0x1234...cdef")
+ */
+declare function truncateAddress(address: string, chars?: number): string;
+
+/**
+ * Format USD values with smart precision based on magnitude
+ *
+ * Examples:
+ * - formatUsd(0.0067) → "$0.0067" (4 decimals for tiny values)
+ * - formatUsd(0.5) → "$0.50" (2 decimals for normal values)
+ * - formatUsd(1234.56) → "$1.23K" (abbreviated for thousands)
+ * - formatUsd(1234567) → "$1.23M" (abbreviated for millions)
+ */
+declare function formatUsd(value: number | null | undefined, options?: {
+    alwaysShowDecimals?: boolean;
+    compact?: boolean;
+}): string | null;
+/**
+ * Format USD with non-compact notation (always full number)
+ * Example: formatUsdFull(1234567) → "$1,234,567.00"
+ */
+declare function formatUsdFull(value: number | null | undefined): string | null;
+
+/**
+ * Validates Ethereum address format
+ * @param address - The address to validate
+ * @returns true if address is valid, false otherwise
+ */
+declare function isValidAddress(address: string): boolean;
+/**
+ * Validates amount input (positive number)
+ * @param amount - The amount string to validate
+ * @returns true if amount is valid and positive, false otherwise
+ */
+declare function isValidAmount(amount: string): boolean;
+/**
+ * Checks if two tokens represent the same asset (direct transfer)
+ * Used to determine if a quote API call is needed or if it's a direct 1:1 transfer
+ * @param token1 - First token with address and chainId
+ * @param token2 - Second token with address and chainId
+ * @returns true if tokens are the same, false otherwise
+ */
+declare function isSameToken(token1: {
+    address?: string;
+    chainId: string | number;
+}, token2: {
+    address?: string;
+    chainId: string | number;
+}): boolean;
+
+/**
+ * Map Orda chainId (number) to wagmi/viem chain objects.
+ * These chains are compatible with both viem and AppKit.
+ */
+declare function getWagmiChain(chainId: number | string): Chain$1 | undefined;
+/**
+ * Get human-readable chain name for error messages
+ */
+declare function getChainName$1(chainId: number | string): string;
+
+declare const copyToClipboard: (text: string) => Promise<void>;
+
+/**
+ * Network Mapping Utility
+ * Maps internal chain IDs to Reown AppKit network objects for wallet switching
+ */
+
+declare function getAppKitNetwork(chainId: string | number): AppKitNetwork | null;
+declare function requiresNetworkSwitch(chainId: string | number): boolean;
+declare function getNetworkDisplayName(chainId: string | number): string;
+/**
+ * Maps Alchemy network identifier to RPC endpoint URL
+ * Used for per-network balance fetching via Alchemy JSON-RPC
+ *
+ * @param network - Alchemy network identifier (e.g., 'eth-mainnet', 'polygon-mainnet')
+ * @param apiKey - Alchemy API key
+ * @returns Full RPC URL for the network, or null if unsupported
+ *
+ * @example
+ * const url = getAlchemyRpcUrl('eth-mainnet', 'abc123')
+ * // Returns: 'https://eth-mainnet.g.alchemy.com/v2/abc123'
+ */
+declare function getAlchemyRpcUrl(network: string, apiKey: string): string | null;
+/**
+ * Gets all supported Alchemy network identifiers for EVM chains
+ * Used to fetch balances across all configured networks
+ *
+ * @returns Array of Alchemy network identifiers
+ */
+declare function getAllAlchemyNetworks(): string[];
+/**
+ * Maps internal chain ID to Alchemy network identifier
+ * Used for price fetching and network identification
+ *
+ * @param chainId - Internal chain ID (e.g., '1', '137', '42161')
+ * @returns Alchemy network identifier (e.g., 'eth-mainnet') or null if unsupported
+ */
+declare function mapChainIdToAlchemyNetwork(chainId: string | number): string | null;
+/**
+ * Maps Alchemy network identifier back to internal chain ID (reverse mapping)
+ * Used for converting Alchemy API responses back to internal chain IDs
+ *
+ * @param alchemyNetwork - Alchemy network identifier (e.g., 'eth-mainnet')
+ * @returns Internal chain ID (e.g., '1') or null if unsupported
+ */
+declare function mapAlchemyNetworkToChainId(alchemyNetwork: string): string | null;
+
+/**
+ * Transaction utility helpers for safe parameter parsing and validation
+ */
+interface TransactionParams {
+    from: Address;
+    to: Address;
+    data: `0x${string}`;
+    value?: string | number | bigint;
+    gas?: string | number | bigint;
+    gasPrice?: string | number | bigint;
+    maxFeePerGas?: string | number | bigint;
+    maxPriorityFeePerGas?: string | number | bigint;
+    nonce?: number | string;
+    chainId: number;
+}
+/**
+ * Safely parse a value to BigInt, handling various formats
+ * - Hex strings: "0xdbb0" → 56240n
+ * - Decimal strings: "56240" → 56240n
+ * - Numbers: 56240 → 56240n
+ * - Empty/undefined: → 0n
+ * - BigInt: pass through
+ */
+declare function safeParseBigInt(value: string | number | bigint | null | undefined): bigint;
+/**
+ * Parse transaction value field safely
+ * Returns bigint, defaults to 0n for invalid values
+ */
+declare function parseTransactionValue(value: string | number | bigint | null | undefined): bigint;
+/**
+ * Parse gas parameter safely
+ * Returns bigint | undefined (undefined means let wallet estimate)
+ */
+declare function parseGasParam(gas: string | number | bigint | null | undefined): bigint | undefined;
+/**
+ * Validate transaction parameters before sending
+ * Throws descriptive errors if validation fails
+ */
+declare function validateTransactionParams(params: {
+    to?: string;
+    from?: string;
+    data?: string;
+    chainId?: number;
+}): void;
+/**
+ * Check if an error is a user rejection
+ */
+declare function isUserRejection(error: unknown): error is BaseError;
+/**
+ * Get user-friendly error message from transaction error
+ */
+declare function getTransactionErrorMessage(error: unknown): {
+    title: string;
+    description: string;
+};
+
+declare enum ChainId {
+    ETHEREUM = 1,
+    OPTIMISM = 10,
+    POLYGON = 137,
+    BASE = 8453,
+    ARBITRUM = 42161,
+    AVALANCHE = 43114,
+    LINEA = 59144,
+    SCROLL = 534352,
+    SOLANA = 1001001,
+    BITCOIN = 1001002,
+    BSC = 56,
+    GNOSIS = 100,
+    MANTLE = 5000,
+    CELO = 42220,
+    SEI = 1329,
+    WORLDCHAIN = 480,
+    UNICHAIN = 130
+}
+declare enum ChainType {
+    EVM = "EVM",
+    SOLANA = "SOLANA",
+    BITCOIN = "BITCOIN"
+}
+interface ChainInfo {
+    id: string;
+    name: string;
+    displayName: string;
+    symbol: string;
+    type: ChainType;
+    decimals: number;
+    rpcUrl?: string;
+    blockExplorer?: string;
+    logoUrl?: string;
+}
+interface FiatInfo {
+    id: string;
+    name: string;
+    displayName: string;
+    symbol: string;
+    logoUrl?: string;
+}
+declare const SUPPORTED_CHAINS: Record<string, ChainInfo>;
+declare const SUPPORTED_FIAT: Record<string, FiatInfo>;
+declare const CHAIN_OPTIONS: {
+    value: string;
+    label: string;
+    logoUrl: string | undefined;
+    symbol: string;
+}[];
+declare const FIAT_OPTION: {
+    value: string;
+    label: string;
+    logoUrl: string;
+    symbol: string;
+}[];
+declare function isSupportedChain(chainId: string | number): boolean;
+declare function isEVMChain(chainId: string | number): boolean;
+declare function isSolanaChain(chainId: string | number): boolean;
+declare function isBitcoinChain(chainId: string | number): boolean;
+declare function getChainInfo(chainId: string | number): ChainInfo | FiatInfo | undefined;
+declare function getChainName(chainId: string | number): string | undefined;
+declare function getChainLogoUrl(chainId: string | number, tokenSymbol?: string): string | undefined;
+declare const COMMON_CHAINS: string[];
+
+interface TokenInfo {
+    address?: Address | string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    chainId: string;
+    logoUrl?: string;
+}
+declare const COMMON_TOKENS: TokenInfo[];
+declare const FIAT_CURRENCIES: ({
+    symbol: string;
+    name: string;
+    decimals: number;
+    chainId: string;
+    logoUrl: string;
+    disabled?: undefined;
+} | {
+    symbol: string;
+    name: string;
+    decimals: number;
+    chainId: string;
+    logoUrl: string;
+    disabled: boolean;
+})[];
+declare const TAX_ID_COUNTRIES: {
+    value: string;
+    label: string;
+}[];
+
+/**
+ * Wrapped Native Token Address Mappings
+ *
+ * Maps chain IDs to their wrapped native token contract addresses.
+ * Used for fetching USD prices of native tokens (ETH, AVAX, etc.) via their wrapped equivalents.
+ *
+ * Native tokens use the zero address (0x0000000000000000000000000000000000000000),
+ * but price APIs typically don't return data for this address. Instead, we use the wrapped
+ * token address (WETH, WAVAX, etc.) which has the same price as the native token.
+ */
+declare const WRAPPED_NATIVE_TOKENS: Record<string, string>;
+/**
+ * Check if an address is the native token zero address
+ */
+declare function isNativeTokenAddress(address: string | null | undefined): boolean;
+/**
+ * Get the wrapped token address for a native token on a given chain
+ * Returns the wrapped address if available, otherwise returns the original address
+ */
+declare function getWrappedAddressForPricing(address: string | null | undefined, chainId: string | number): string | null;
+
+declare const VERSION = "1.0.0";
+
+export { type AppKitConfig, type AppKitFactoryConfig, Badge, type BadgeProps, type BalancesFetchOptions, type BalancesFetchResponse, Button, type ButtonProps, CHAIN_OPTIONS, COMMON_CHAINS, COMMON_TOKENS, type Chain, ChainId, type ChainInfo, ChainType, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, FIAT_CURRENCIES, FIAT_OPTION, type FiatInfo, Input, Label, OrdaProvider, type OrdaProviderConfig, type OrdaProviderProps, type OrdaSDKContextValue, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, type RecipientType, SUPPORTED_CHAINS, SUPPORTED_FIAT, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, type StoredCryptoRecipient, type StoredFiatRecipient, TAX_ID_COUNTRIES, type Token, type TokenBalance, type TokenInfo, type TokenPriceData, type TokenPriceRequest, type TokenResponse, type TransactionParams, type TransactionType, type UseBalancesOptions, type UseBalancesReturn, type UseLocalRecipientsReturn, type UseOffRampReturn, type UseOnRampReturn, type UseQuoteReturn, type UseRecipientReturn, type UseTokenPricesOptions, type UseTokenPricesReturn, type UseTransactionReturn, VERSION, WRAPPED_NATIVE_TOKENS, Widget, badgeVariants, buttonVariants, cn, copyToClipboard, createAppKitConfig, evmNetworks, formatCryptoAmount, formatUsd, formatUsdFull, getAlchemyRpcUrl, getAllAlchemyNetworks, getAppKitNetwork, getChainInfo, getChainLogoUrl, getChainName, getNetworkDisplayName, getTransactionErrorMessage, getWagmiChain, getChainName$1 as getWagmiChainName, getWrappedAddressForPricing, isBitcoinChain, isEVMChain, isNativeTokenAddress, isSameToken, isSolanaChain, isSupportedChain, isUserRejection, isValidAddress, isValidAmount, mapAlchemyNetworkToChainId, mapChainIdToAlchemyNetwork, parseFromNativeUnits, parseGasParam, parseToNativeUnits, parseTransactionValue, requiresNetworkSwitch, safeParseBigInt, solanaNetworks, truncateAddress, useBalances, useLocalRecipients, useMediaQuery, useOffRamp, useOnRamp, useOrdaSDK, useQuote, useRecipient, useTokenPrices, useTransaction, validateTransactionParams };