@smoothsend/sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2072 @@
+import { AxiosRequestConfig } from 'axios';
+
+/**
+ * Error handling system for SmoothSend SDK v2
+ * Provides typed error classes for different failure scenarios
+ *
+ * @remarks
+ * All SDK errors extend SmoothSendError for consistent error handling
+ * Use instanceof checks to handle specific error types
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await sdk.transfer(request, wallet);
+ * } catch (error) {
+ *   if (error instanceof AuthenticationError) {
+ *     console.error('Invalid API key');
+ *   } else if (error instanceof RateLimitError) {
+ *     console.error('Rate limit exceeded');
+ *   }
+ * }
+ * ```
+ */
+/**
+ * Base error class for all SmoothSend SDK errors
+ *
+ * @remarks
+ * All SDK-specific errors extend this class
+ * Contains error code, HTTP status code, and additional details
+ *
+ * @example
+ * ```typescript
+ * throw new SmoothSendError(
+ *   'Something went wrong',
+ *   'CUSTOM_ERROR',
+ *   500,
+ *   { additionalInfo: 'details' }
+ * );
+ * ```
+ */
+declare class SmoothSendError extends Error {
+    code: string;
+    statusCode?: number | undefined;
+    details?: any | undefined;
+    /**
+     * Creates a new SmoothSendError
+     *
+     * @param message - Human-readable error message
+     * @param code - Error code for programmatic handling
+     * @param statusCode - HTTP status code (if applicable)
+     * @param details - Additional error details
+     */
+    constructor(message: string, code: string, statusCode?: number | undefined, details?: any | undefined);
+}
+/**
+ * Authentication error - thrown when API key is invalid, missing, or expired
+ *
+ * @remarks
+ * HTTP Status Code: 401
+ * Indicates authentication failure with the proxy worker
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await sdk.transfer(request, wallet);
+ * } catch (error) {
+ *   if (error instanceof AuthenticationError) {
+ *     console.error('Invalid API key:', error.message);
+ *     console.log('Get a new key at:', error.details.suggestion);
+ *   }
+ * }
+ * ```
+ */
+declare class AuthenticationError extends SmoothSendError {
+    /**
+     * Creates a new AuthenticationError
+     *
+     * @param message - Human-readable error message
+     * @param details - Additional error details
+     */
+    constructor(message: string, details?: any);
+}
+/**
+ * Rate limit error - thrown when request rate limit is exceeded
+ *
+ * @remarks
+ * HTTP Status Code: 429
+ * Contains rate limit details including reset time
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await sdk.transfer(request, wallet);
+ * } catch (error) {
+ *   if (error instanceof RateLimitError) {
+ *     console.error('Rate limit exceeded');
+ *     console.log(`Limit: ${error.limit}`);
+ *     console.log(`Remaining: ${error.remaining}`);
+ *     console.log(`Resets at: ${error.resetTime}`);
+ *   }
+ * }
+ * ```
+ */
+declare class RateLimitError extends SmoothSendError {
+    limit: number;
+    remaining: number;
+    resetTime: string;
+    /**
+     * Creates a new RateLimitError
+     *
+     * @param message - Human-readable error message
+     * @param limit - Maximum requests allowed per period
+     * @param remaining - Remaining requests in current period
+     * @param resetTime - When the rate limit resets (ISO 8601 timestamp)
+     */
+    constructor(message: string, limit: number, remaining: number, resetTime: string);
+}
+/**
+ * Validation error - thrown when request parameters are invalid
+ *
+ * @remarks
+ * HTTP Status Code: 400
+ * Contains field name that failed validation
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await sdk.transfer(request, wallet);
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.error(`Invalid ${error.field}:`, error.message);
+ *   }
+ * }
+ * ```
+ */
+declare class ValidationError extends SmoothSendError {
+    field: string;
+    /**
+     * Creates a new ValidationError
+     *
+     * @param message - Human-readable error message
+     * @param field - Name of the field that failed validation
+     * @param details - Additional error details
+     */
+    constructor(message: string, field: string, details?: any);
+}
+/**
+ * Network error - thrown when network connectivity issues occur
+ *
+ * @remarks
+ * HTTP Status Code: 0 (no HTTP response)
+ * Indicates network connectivity problems
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await sdk.transfer(request, wallet);
+ * } catch (error) {
+ *   if (error instanceof NetworkError) {
+ *     console.error('Network error:', error.message);
+ *     console.log('Original error:', error.originalError);
+ *   }
+ * }
+ * ```
+ */
+declare class NetworkError extends SmoothSendError {
+    originalError?: Error | undefined;
+    /**
+     * Creates a new NetworkError
+     *
+     * @param message - Human-readable error message
+     * @param originalError - Original error that caused the network failure
+     */
+    constructor(message: string, originalError?: Error | undefined);
+}
+/**
+ * Helper function to create appropriate error from HTTP response
+ *
+ * @remarks
+ * Parses HTTP error response and creates typed error object
+ * Used internally by HTTP client
+ *
+ * @param statusCode - HTTP status code
+ * @param errorData - Error response data from API
+ * @param defaultMessage - Default message if none provided in response
+ * @returns Typed error object
+ *
+ * @example
+ * ```typescript
+ * const error = createErrorFromResponse(401, {
+ *   error: 'Invalid API key',
+ *   details: { field: 'apiKey' }
+ * });
+ * throw error;
+ * ```
+ */
+declare function createErrorFromResponse(statusCode: number, errorData: any, defaultMessage?: string): SmoothSendError;
+/**
+ * Helper function to create network error from exception
+ *
+ * @remarks
+ * Wraps generic exceptions in NetworkError for consistent error handling
+ * Used internally by HTTP client
+ *
+ * @param error - Original error or exception
+ * @returns NetworkError instance
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await fetch(url);
+ * } catch (error) {
+ *   throw createNetworkError(error);
+ * }
+ * ```
+ */
+declare function createNetworkError(error: any): NetworkError;
+
+/**
+ * Supported blockchain chains in the SmoothSend SDK
+ *
+ * @remarks
+ * - `avalanche`: Avalanche C-Chain (EVM-compatible)
+ * - `aptos-testnet`: Aptos testnet
+ * - `aptos-mainnet`: Aptos mainnet
+ */
+type SupportedChain = 'avalanche' | 'aptos-testnet' | 'aptos-mainnet';
+/**
+ * Chain ecosystem types for routing to correct relayers
+ *
+ * @remarks
+ * - `evm`: Ethereum Virtual Machine compatible chains (Avalanche, Base, Arbitrum, etc.)
+ * - `aptos`: Aptos blockchain ecosystem
+ */
+type ChainEcosystem = 'evm' | 'aptos';
+/**
+ * Mapping of supported chains to their respective ecosystems
+ * Used internally for adapter selection and routing
+ */
+declare const CHAIN_ECOSYSTEM_MAP: Record<SupportedChain, ChainEcosystem>;
+/**
+ * Base success response structure
+ * All successful API responses extend this interface
+ */
+interface SuccessResponse {
+    /** Indicates the request was successful */
+    success: true;
+}
+/**
+ * Base error response structure
+ * All error API responses extend this interface
+ */
+interface ErrorResponse {
+    /** Indicates the request failed */
+    success: false;
+    /** Human-readable error message */
+    error: string;
+    /** Additional error details or validation errors */
+    details?: string[];
+    /** Unique request identifier for debugging */
+    requestId?: string;
+}
+/**
+ * Chain information structure
+ * Contains metadata about a supported blockchain
+ */
+interface ChainInfo {
+    /** Chain identifier (e.g., 'aptos-testnet') */
+    name: string;
+    /** Human-readable chain name */
+    displayName: string;
+    /** Numeric chain ID */
+    chainId: number;
+    /** Block explorer base URL */
+    explorerUrl: string;
+    /** List of supported token symbols */
+    tokens: string[];
+}
+/**
+ * Token information structure
+ * Contains metadata about a supported token
+ */
+interface TokenInfo {
+    /** Token symbol (e.g., 'USDC') */
+    symbol: string;
+    /** Token contract address */
+    address: string;
+    /** Number of decimal places */
+    decimals: number;
+    /** Full token name */
+    name: string;
+}
+/**
+ * Chain configuration structure
+ * Complete configuration for a blockchain network
+ */
+interface ChainConfig {
+    /** Chain identifier */
+    name: string;
+    /** Human-readable chain name */
+    displayName: string;
+    /** Numeric chain ID */
+    chainId: number;
+    /** RPC endpoint URL */
+    rpcUrl: string;
+    /** Relayer service URL */
+    relayerUrl: string;
+    /** Block explorer base URL */
+    explorerUrl: string;
+    /** List of supported token symbols */
+    tokens: string[];
+    /** Native currency information */
+    nativeCurrency: {
+        /** Currency name */
+        name: string;
+        /** Currency symbol */
+        symbol: string;
+        /** Number of decimal places */
+        decimals: number;
+    };
+}
+/**
+ * Transfer request parameters
+ * Used to initiate a gasless token transfer
+ *
+ * @example
+ * ```typescript
+ * const request: TransferRequest = {
+ *   from: '0x123...',
+ *   to: '0x456...',
+ *   token: 'USDC',
+ *   amount: '1000000', // 1 USDC (6 decimals)
+ *   chain: 'aptos-testnet'
+ * };
+ * ```
+ */
+interface TransferRequest {
+    /** Sender's wallet address */
+    from: string;
+    /** Recipient's wallet address */
+    to: string;
+    /** Token symbol or contract address */
+    token: string;
+    /** Amount in smallest unit (wei, octas, etc.) */
+    amount: string;
+    /** Target blockchain */
+    chain: SupportedChain;
+}
+/**
+ * Transfer quote response from API
+ * Contains fee information for a transfer
+ */
+interface TransferQuoteResponse extends SuccessResponse {
+    /** Chain identifier */
+    chainName: string;
+    /** Token symbol */
+    token: string;
+    /** Transfer amount */
+    amount: string;
+    /** Relayer fee amount */
+    relayerFee: string;
+    /** Total amount (amount + fee) */
+    total: string;
+    /** Fee as percentage of amount */
+    feePercentage: number;
+    /** Token contract address */
+    contractAddress: string;
+}
+/**
+ * Fee estimate response from proxy worker
+ * Contains detailed fee information for a transfer
+ *
+ * @remarks
+ * Returned by `estimateFee()` method
+ */
+interface FeeEstimate {
+    /** Fee charged by relayer in token units */
+    relayerFee: string;
+    /** Fee in USD for reference */
+    feeInUSD: string;
+    /** Full coin type identifier (e.g., '0x1::aptos_coin::AptosCoin') */
+    coinType: string;
+    /** Estimated gas units */
+    estimatedGas: string;
+    /** Network (testnet or mainnet) */
+    network: 'testnet' | 'mainnet';
+}
+/**
+ * Transfer quote information
+ * Contains fee breakdown and contract details
+ */
+interface TransferQuote {
+    /** Transfer amount */
+    amount: string;
+    /** Relayer fee amount */
+    relayerFee: string;
+    /** Total amount (amount + fee) */
+    total: string;
+    /** Fee as percentage of amount */
+    feePercentage: number;
+    /** Token contract address */
+    contractAddress: string;
+    /** Aptos-specific transaction data (optional for backward compatibility) */
+    aptosTransactionData?: any;
+}
+/**
+ * Relay transfer response from API
+ * Contains transaction execution details
+ */
+interface RelayTransferResponse extends SuccessResponse {
+    /** Unique transfer identifier */
+    transferId: string;
+    /** Transaction hash */
+    txHash: string;
+    /** Block number where transaction was included */
+    blockNumber: number;
+    /** Gas units consumed */
+    gasUsed: string;
+    /** Block explorer URL for transaction */
+    explorerUrl: string;
+    /** Fee paid for the transfer */
+    fee: string;
+    /** Execution time in milliseconds */
+    executionTime: number;
+}
+/**
+ * Transfer result structure
+ * Contains complete information about a transfer execution
+ *
+ * @remarks
+ * Returned by `executeGaslessTransfer()` and `transfer()` methods
+ *
+ * @example
+ * ```typescript
+ * const result = await sdk.executeGaslessTransfer(signedData);
+ * console.log(`Transaction: ${result.txHash}`);
+ * console.log(`Explorer: ${result.explorerUrl}`);
+ * console.log(`Rate limit remaining: ${result.metadata?.rateLimit.remaining}`);
+ * ```
+ */
+interface TransferResult {
+    /** Indicates if transfer was successful */
+    success: boolean;
+    /** Transaction hash */
+    txHash: string;
+    /** Block number where transaction was included */
+    blockNumber?: number;
+    /** Gas units consumed */
+    gasUsed?: string;
+    /** Unique transfer identifier */
+    transferId?: string;
+    /** Block explorer URL for transaction */
+    explorerUrl?: string;
+    /** Fee paid for the transfer */
+    fee?: string;
+    /** Execution time in milliseconds */
+    executionTime?: number;
+    /** Address that paid the gas fee (Aptos-specific) */
+    gasFeePaidBy?: string;
+    /** Whether user paid in APT (Aptos-specific) */
+    userPaidAPT?: boolean;
+    /** Transparency information (Aptos-specific) */
+    transparency?: string;
+    /** VM execution status (Aptos-specific) */
+    vmStatus?: string;
+    /** Sender address (Aptos-specific) */
+    sender?: string;
+    /** Chain identifier (Aptos-specific) */
+    chain?: string;
+    /** Relayer fee amount (Aptos-specific) */
+    relayerFee?: string;
+    /** Additional message or status information */
+    message?: string;
+    /** Usage metadata from proxy worker (v2) */
+    metadata?: UsageMetadata;
+}
+/**
+ * Batch transfer request parameters
+ * Used to execute multiple transfers in a single transaction
+ *
+ * @remarks
+ * Batch transfers are more gas-efficient than individual transfers
+ */
+interface BatchTransferRequest {
+    /** Array of transfer requests to execute */
+    transfers: TransferRequest[];
+    /** Target blockchain */
+    chain: SupportedChain;
+}
+/**
+ * EVM transfer data structure
+ * Contains signed transfer data for EVM-compatible chains
+ *
+ * @remarks
+ * Used for Avalanche and other EVM chains
+ */
+interface EVMTransferData {
+    /** Chain identifier */
+    chainName: string;
+    /** Sender address */
+    from: string;
+    /** Recipient address */
+    to: string;
+    /** Token symbol */
+    tokenSymbol: string;
+    /** Transfer amount */
+    amount: string;
+    /** Relayer fee amount */
+    relayerFee: string;
+    /** Transaction nonce */
+    nonce: string;
+    /** Signature deadline timestamp */
+    deadline: number;
+    /** EIP-712 signature */
+    signature: string;
+    /** ERC-2612 permit data (optional) */
+    permitData?: {
+        /** Permit value */
+        value: string;
+        /** Permit deadline */
+        deadline: number;
+        /** Signature v component */
+        v: number;
+        /** Signature r component */
+        r: string;
+        /** Signature s component */
+        s: string;
+    };
+}
+/**
+ * Legacy type alias for Avalanche transfers
+ * @deprecated Use EVMTransferData instead
+ */
+type AvalancheTransferData = EVMTransferData;
+/**
+ * Aptos transfer data structure
+ * Contains serialized transaction data for secure Aptos transfers
+ *
+ * @remarks
+ * Uses serialized transaction approach for enhanced security
+ * Transaction must be built and signed by wallet before submission
+ *
+ * @example
+ * ```typescript
+ * const aptosData: AptosTransferData = {
+ *   transactionBytes: Array.from(signedTx.transactionBytes),
+ *   authenticatorBytes: Array.from(signedTx.authenticatorBytes)
+ * };
+ * ```
+ */
+interface AptosTransferData {
+    /** Serialized SimpleTransaction as byte array */
+    transactionBytes: number[];
+    /** Serialized AccountAuthenticator as byte array */
+    authenticatorBytes: number[];
+    /** Optional function name for debugging/tracking */
+    functionName?: string;
+    /** Sender address (optional metadata) */
+    fromAddress?: string;
+    /** Recipient address (optional metadata) */
+    toAddress?: string;
+    /** Transfer amount (optional metadata) */
+    amount?: string;
+    /** Coin type identifier (optional metadata) */
+    coinType?: string;
+}
+/**
+ * EIP-712 signature data structure
+ * Contains typed data for signature verification
+ */
+interface SignatureData {
+    /** EIP-712 domain separator */
+    domain: any;
+    /** Type definitions */
+    types: any;
+    /** Message to sign */
+    message: any;
+    /** Primary type name */
+    primaryType: string;
+    /** Enhanced metadata for signature verification */
+    metadata?: {
+        /** Target chain */
+        chain?: SupportedChain;
+        /** Sender address */
+        fromAddress?: string;
+        /** Recipient address */
+        toAddress?: string;
+        /** Transfer amount */
+        amount?: string;
+        /** Token symbol */
+        token?: string;
+        /** Relayer fee */
+        relayerFee?: string;
+        /** Signature version */
+        signatureVersion?: string;
+        /** Whether public key is required */
+        requiresPublicKey?: boolean;
+        /** Verification method */
+        verificationMethod?: string;
+    };
+}
+/**
+ * Signed transfer data for SDK v2
+ * Contains serialized transaction bytes for secure Aptos transfers
+ *
+ * @remarks
+ * Used with `executeGaslessTransfer()` method
+ * Transaction must be built and signed by wallet before creating this structure
+ *
+ * @example
+ * ```typescript
+ * const signedData: SignedTransferData = {
+ *   transactionBytes: Array.from(signedTx.transactionBytes),
+ *   authenticatorBytes: Array.from(signedTx.authenticatorBytes),
+ *   chain: 'aptos-testnet',
+ *   network: 'testnet'
+ * };
+ * const result = await sdk.executeGaslessTransfer(signedData);
+ * ```
+ */
+interface SignedTransferData {
+    /** Serialized transaction (Aptos) */
+    transactionBytes: number[];
+    /** Serialized authenticator (Aptos) */
+    authenticatorBytes: number[];
+    /** Target blockchain */
+    chain: SupportedChain;
+    /** Optional network override (testnet or mainnet) */
+    network?: 'testnet' | 'mainnet';
+}
+/**
+ * Token balance information
+ * Contains balance and metadata for a specific token
+ */
+interface TokenBalance {
+    /** Token symbol or address */
+    token: string;
+    /** Balance in smallest unit */
+    balance: string;
+    /** Number of decimal places */
+    decimals: number;
+    /** Token symbol */
+    symbol: string;
+    /** Full token name (optional) */
+    name?: string;
+}
+/**
+ * Transfer quote request parameters
+ * Used to request fee estimate from API
+ */
+interface TransferQuoteRequest {
+    /** Chain identifier */
+    chainName: string;
+    /** Token symbol */
+    token: string;
+    /** Transfer amount */
+    amount: string;
+}
+/**
+ * Prepare signature request parameters
+ * Used to get typed data for EIP-712 signature
+ */
+interface PrepareSignatureRequest {
+    /** Chain identifier */
+    chainName: string;
+    /** Sender address */
+    from: string;
+    /** Recipient address */
+    to: string;
+    /** Token symbol */
+    tokenSymbol: string;
+    /** Transfer amount */
+    amount: string;
+    /** Relayer fee amount */
+    relayerFee: string;
+    /** Transaction nonce */
+    nonce: string;
+    /** Signature deadline timestamp */
+    deadline: number;
+}
+/**
+ * Relay transfer request parameters
+ * Used to submit signed transfer to relayer
+ */
+interface RelayTransferRequest {
+    /** Chain identifier */
+    chainName: string;
+    /** Sender address */
+    from: string;
+    /** Recipient address */
+    to: string;
+    /** Token symbol */
+    tokenSymbol: string;
+    /** Transfer amount */
+    amount: string;
+    /** Relayer fee amount */
+    relayerFee: string;
+    /** Transaction nonce */
+    nonce: string;
+    /** Signature deadline timestamp */
+    deadline: number;
+    /** EIP-712 signature */
+    signature: string;
+    /** ERC-2612 permit data (optional) */
+    permitData?: PermitData;
+}
+/**
+ * Batch relay transfer request parameters
+ * Used to submit multiple signed transfers in one transaction
+ */
+interface BatchRelayTransferRequest {
+    /** Chain identifier */
+    chainName: string;
+    /** Array of transfer requests */
+    transfers: RelayTransferRequest[];
+}
+/**
+ * Gas estimate request parameters
+ * Used to estimate gas cost for transfers
+ */
+interface EstimateGasRequest {
+    /** Chain identifier */
+    chainName: string;
+    /** Array of transfer data */
+    transfers: TransferData[];
+}
+/**
+ * Transfer data structure
+ * Contains complete transfer information including signature
+ */
+interface TransferData {
+    /** Sender address */
+    from: string;
+    /** Recipient address */
+    to: string;
+    /** Token symbol or address */
+    token: string;
+    /** Transfer amount */
+    amount: string;
+    /** Relayer fee amount */
+    relayerFee: string;
+    /** Transaction nonce */
+    nonce: string;
+    /** Signature deadline timestamp */
+    deadline: number;
+    /** EIP-712 signature */
+    signature: string;
+    /** ERC-2612 permit data (optional) */
+    permitData?: PermitData;
+}
+/**
+ * ERC-2612 permit data structure
+ * Used for gasless token approvals
+ */
+interface PermitData {
+    /** Permit value (amount) */
+    value: string;
+    /** Permit deadline timestamp */
+    deadline: number;
+    /** Signature v component */
+    v: number;
+    /** Signature r component */
+    r: string;
+    /** Signature s component */
+    s: string;
+}
+/**
+ * Prepare signature response from API
+ * Contains EIP-712 typed data for signing
+ */
+interface PrepareSignatureResponse extends SuccessResponse {
+    /** EIP-712 typed data structure */
+    typedData: any;
+    /** Keccak256 hash of the message */
+    messageHash: string;
+    /** Human-readable message */
+    message: string;
+}
+/**
+ * Gas estimate response from API
+ * Contains estimated gas cost for transfers
+ */
+interface GasEstimateResponse extends SuccessResponse {
+    /** Chain identifier */
+    chainName: string;
+    /** Estimated gas units */
+    gasEstimate: string;
+    /** Current gas price */
+    gasPrice: string;
+    /** Estimated cost in native currency */
+    estimatedCost: string;
+    /** Number of transfers in batch */
+    transferCount: number;
+}
+/**
+ * Health check response
+ * Contains service health status information
+ *
+ * @remarks
+ * Returned by `getHealth()` and `getChainHealth()` methods
+ */
+interface HealthResponse extends SuccessResponse {
+    /** Service status (e.g., 'healthy', 'degraded') */
+    status: string;
+    /** Response timestamp (ISO 8601) */
+    timestamp: string;
+    /** Service version */
+    version: string;
+}
+/**
+ * Domain separator response from API
+ * Contains EIP-712 domain separator for a chain
+ */
+interface DomainSeparatorResponse extends SuccessResponse {
+    /** Chain identifier */
+    chainName: string;
+    /** EIP-712 domain separator hash */
+    domainSeparator: string;
+}
+/**
+ * Transfer status response from API
+ * Contains execution status of a transfer
+ */
+interface TransferStatusResponse extends SuccessResponse {
+    /** Chain identifier */
+    chainName: string;
+    /** Transfer transaction hash */
+    transferHash: string;
+    /** Whether transfer has been executed */
+    executed: boolean;
+}
+/**
+ * Aptos-specific error codes
+ * Used for detailed error handling in Aptos adapter
+ *
+ * @remarks
+ * Error codes are prefixed with APTOS_ for easy identification
+ */
+declare const APTOS_ERROR_CODES: {
+    /** Missing signature in request */
+    readonly MISSING_SIGNATURE: "APTOS_MISSING_SIGNATURE";
+    /** Missing public key for verification */
+    readonly MISSING_PUBLIC_KEY: "APTOS_MISSING_PUBLIC_KEY";
+    /** Invalid signature format */
+    readonly INVALID_SIGNATURE_FORMAT: "APTOS_INVALID_SIGNATURE_FORMAT";
+    /** Invalid public key format */
+    readonly INVALID_PUBLIC_KEY_FORMAT: "APTOS_INVALID_PUBLIC_KEY_FORMAT";
+    /** Address doesn't match public key */
+    readonly ADDRESS_MISMATCH: "APTOS_ADDRESS_MISMATCH";
+    /** Signature verification failed */
+    readonly SIGNATURE_VERIFICATION_FAILED: "APTOS_SIGNATURE_VERIFICATION_FAILED";
+    /** Missing transaction data */
+    readonly MISSING_TRANSACTION_DATA: "APTOS_MISSING_TRANSACTION_DATA";
+    /** Invalid transaction format */
+    readonly INVALID_TRANSACTION_FORMAT: "APTOS_INVALID_TRANSACTION_FORMAT";
+    /** Empty address provided */
+    readonly EMPTY_ADDRESS: "APTOS_EMPTY_ADDRESS";
+    /** Invalid address format */
+    readonly INVALID_ADDRESS_FORMAT: "APTOS_INVALID_ADDRESS_FORMAT";
+    /** Error fetching quote */
+    readonly QUOTE_ERROR: "APTOS_QUOTE_ERROR";
+    /** Error executing transfer */
+    readonly EXECUTE_ERROR: "APTOS_EXECUTE_ERROR";
+    /** Error fetching balance */
+    readonly BALANCE_ERROR: "APTOS_BALANCE_ERROR";
+    /** Error fetching token info */
+    readonly TOKEN_INFO_ERROR: "APTOS_TOKEN_INFO_ERROR";
+    /** Error checking status */
+    readonly STATUS_ERROR: "APTOS_STATUS_ERROR";
+    /** Error calling Move function */
+    readonly MOVE_CALL_ERROR: "APTOS_MOVE_CALL_ERROR";
+    /** Unsupported token */
+    readonly UNSUPPORTED_TOKEN: "APTOS_UNSUPPORTED_TOKEN";
+};
+/**
+ * Type for Aptos error codes
+ * Ensures type safety when using error codes
+ */
+type AptosErrorCode = typeof APTOS_ERROR_CODES[keyof typeof APTOS_ERROR_CODES];
+/**
+ * Generic API response structure
+ * Used for all API responses with optional data payload
+ *
+ * @typeParam T - Type of the response data
+ *
+ * @example
+ * ```typescript
+ * const response: ApiResponse<TransferResult> = await api.transfer(data);
+ * if (response.success && response.data) {
+ *   console.log('Transfer successful:', response.data.txHash);
+ * }
+ * ```
+ */
+interface ApiResponse<T = any> {
+    /** Indicates if request was successful */
+    success: boolean;
+    /** Response data (present on success) */
+    data?: T;
+    /** Error message (present on failure) */
+    error?: string;
+    /** Additional error details */
+    details?: string[];
+    /** Unique request identifier */
+    requestId?: string;
+    /** Error code for programmatic handling */
+    errorCode?: string;
+    /** Chain where request was made */
+    chain?: SupportedChain;
+    /** Response timestamp (ISO 8601) */
+    timestamp?: string;
+    /** Usage metadata from proxy worker (v2) */
+    metadata?: UsageMetadata;
+}
+/**
+ * SDK configuration for v2 - Proxy-based architecture
+ *
+ * @remarks
+ * All requests route through proxy.smoothsend.xyz with API key authentication
+ *
+ * @example
+ * ```typescript
+ * const config: SmoothSendConfig = {
+ *   apiKey: 'no_gas_abc123...',
+ *   network: 'testnet',
+ *   timeout: 30000,
+ *   retries: 3
+ * };
+ * const sdk = new SmoothSendSDK(config);
+ * ```
+ */
+interface SmoothSendConfig {
+    /** API key with no_gas_ prefix for authentication (required) */
+    apiKey: string;
+    /** Network to use: testnet or mainnet (default: testnet) */
+    network?: 'testnet' | 'mainnet';
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum retry attempts for failed requests (default: 3) */
+    retries?: number;
+    /** Additional headers to include in requests */
+    customHeaders?: Record<string, string>;
+}
+/**
+ * Usage metadata from proxy worker response headers
+ * Contains rate limiting and usage tracking information
+ *
+ * @remarks
+ * Attached to all transfer results and available via `getUsageStats()`
+ *
+ * @example
+ * ```typescript
+ * const result = await sdk.transfer(request, wallet);
+ * console.log('Rate limit:', result.metadata?.rateLimit);
+ * console.log('Monthly usage:', result.metadata?.monthly);
+ *
+ * // Check if approaching limits
+ * if (parseInt(result.metadata.rateLimit.remaining) < 2) {
+ *   console.warn('Approaching rate limit!');
+ * }
+ * ```
+ */
+interface UsageMetadata {
+    /** Rate limit information (per minute) */
+    rateLimit: {
+        /** Maximum requests per minute */
+        limit: string;
+        /** Remaining requests this minute */
+        remaining: string;
+        /** When rate limit resets (ISO 8601 timestamp) */
+        reset: string;
+    };
+    /** Monthly usage information */
+    monthly: {
+        /** Total monthly request limit */
+        limit: string;
+        /** Requests used this month */
+        usage: string;
+        /** Remaining requests this month */
+        remaining: string;
+    };
+    /** Unique request identifier for debugging */
+    requestId: string;
+}
+/**
+ * Transfer event types
+ * Emitted during transfer lifecycle for monitoring and debugging
+ */
+interface TransferEvent {
+    /** Event type */
+    type: 'transfer_initiated' | 'transfer_signed' | 'transfer_submitted' | 'transfer_confirmed' | 'transfer_failed';
+    /** Event data (varies by type) */
+    data: any;
+    /** Event timestamp (Unix milliseconds) */
+    timestamp: number;
+    /** Chain where event occurred */
+    chain: SupportedChain;
+}
+/**
+ * Event listener callback function
+ * Called when transfer events are emitted
+ *
+ * @param event - Transfer event object
+ *
+ * @example
+ * ```typescript
+ * const listener: EventListener = (event) => {
+ *   console.log(`Event: ${event.type} on ${event.chain}`);
+ * };
+ * sdk.addEventListener(listener);
+ * ```
+ */
+type EventListener = (event: TransferEvent) => void;
+/**
+ * Chain Adapter Interface - v2 Proxy Architecture
+ *
+ * @remarks
+ * All adapters route requests through proxy.smoothsend.xyz with API key authentication.
+ * The proxy handles relayer URL routing, so adapters no longer need direct relayer configuration.
+ *
+ * Key changes from v1:
+ * - Removed `config` property (relayer URLs handled by proxy)
+ * - Simplified to core methods: estimateFee, executeGaslessTransfer
+ * - Removed getQuote, prepareTransfer, getNonce, getTokenInfo (not needed for proxy flow)
+ * - Network parameter (testnet/mainnet) passed via HTTP headers, not method parameters
+ * - Client-side validation methods remain for address and amount validation
+ *
+ * Design rationale:
+ * - Consistent interface across all chains
+ * - Minimal surface area - only essential methods
+ * - Async by default for all I/O operations
+ * - Client-side validation done locally without network calls
+ * - Wallet libraries handle balance queries and transaction building
+ *
+ * @example
+ * ```typescript
+ * class MyChainAdapter implements IChainAdapter {
+ *   readonly chain: SupportedChain = 'aptos-testnet';
+ *
+ *   async estimateFee(request: TransferRequest): Promise<FeeEstimate> {
+ *     // Implementation
+ *   }
+ *
+ *   async executeGaslessTransfer(signedData: SignedTransferData): Promise<TransferResult> {
+ *     // Implementation
+ *   }
+ *
+ *   // ... other methods
+ * }
+ * ```
+ */
+interface IChainAdapter {
+    /** Chain identifier this adapter handles */
+    readonly chain: SupportedChain;
+    /**
+     * Estimate fee for a transfer
+     *
+     * @param request - Transfer request parameters
+     * @returns Fee estimate with relayer fee and gas information
+     * @throws {ValidationError} If request parameters are invalid
+     * @throws {NetworkError} If unable to reach proxy/relayer
+     *
+     * @example
+     * ```typescript
+     * const estimate = await adapter.estimateFee({
+     *   from: '0x123...',
+     *   to: '0x456...',
+     *   token: 'USDC',
+     *   amount: '1000000',
+     *   chain: 'aptos-testnet'
+     * });
+     * console.log('Fee:', estimate.relayerFee);
+     * ```
+     */
+    estimateFee(request: TransferRequest): Promise<FeeEstimate>;
+    /**
+     * Execute a gasless transfer with signed transaction data
+     *
+     * @param signedData - Signed transfer data with serialized transaction
+     * @returns Transfer result with transaction hash and metadata
+     * @throws {AuthenticationError} If API key is invalid
+     * @throws {RateLimitError} If rate limit is exceeded
+     * @throws {ValidationError} If signed data is invalid
+     * @throws {NetworkError} If unable to reach proxy/relayer
+     *
+     * @example
+     * ```typescript
+     * const result = await adapter.executeGaslessTransfer({
+     *   transactionBytes: [1, 2, 3, ...],
+     *   authenticatorBytes: [4, 5, 6, ...],
+     *   chain: 'aptos-testnet',
+     *   network: 'testnet'
+     * });
+     * console.log('Transaction:', result.txHash);
+     * ```
+     */
+    executeGaslessTransfer(signedData: SignedTransferData): Promise<TransferResult>;
+    /**
+     * Get transaction status by hash
+     *
+     * @param txHash - Transaction hash to query
+     * @returns Transaction status information
+     * @throws {ValidationError} If transaction hash is invalid
+     * @throws {NetworkError} If unable to reach proxy/relayer
+     *
+     * @example
+     * ```typescript
+     * const status = await adapter.getTransactionStatus('0xabc123...');
+     * console.log('Status:', status);
+     * ```
+     */
+    getTransactionStatus(txHash: string): Promise<any>;
+    /**
+     * Check health status of the chain's relayer
+     *
+     * @returns Health response with status and version
+     * @throws {NetworkError} If unable to reach proxy/relayer
+     *
+     * @example
+     * ```typescript
+     * const health = await adapter.getHealth();
+     * console.log('Status:', health.status);
+     * ```
+     */
+    getHealth(): Promise<HealthResponse>;
+    /**
+     * Validate address format (client-side, no network call)
+     *
+     * @param address - Address to validate
+     * @returns true if address format is valid, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const isValid = adapter.validateAddress('0x123...');
+     * if (!isValid) {
+     *   console.error('Invalid address format');
+     * }
+     * ```
+     */
+    validateAddress(address: string): boolean;
+    /**
+     * Validate amount format (client-side, no network call)
+     *
+     * @param amount - Amount to validate (in smallest unit)
+     * @returns true if amount format is valid, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const isValid = adapter.validateAmount('1000000');
+     * if (!isValid) {
+     *   console.error('Invalid amount format');
+     * }
+     * ```
+     */
+    validateAmount(amount: string): boolean;
+}
+
+declare class SmoothSendSDK {
+    private adapters;
+    private eventListeners;
+    private config;
+    private keyType;
+    private hasWarnedAboutSecretKey;
+    constructor(config: SmoothSendConfig);
+    /**
+     * Detect key type from API key prefix
+     * Supports pk_nogas_* (public), sk_nogas_* (secret), and no_gas_* (legacy)
+     */
+    private detectKeyType;
+    /**
+     * Check if running in browser environment
+     * Used for conditional warnings and Origin header logic
+     */
+    private isBrowserEnvironment;
+    /**
+     * Warn if secret key is used in browser environment
+     * Only warns once per SDK instance
+     */
+    private warnIfSecretKeyInBrowser;
+    /**
+     * Determine if Origin header should be included in requests
+     * Include Origin header only for public keys in browser environment
+     */
+    private shouldIncludeOrigin;
+    /**
+     * Get or create adapter for a specific chain on-demand
+     */
+    private getOrCreateAdapter;
+    addEventListener(listener: EventListener): void;
+    removeEventListener(listener: EventListener): void;
+    private emitEvent;
+    estimateFee(request: TransferRequest): Promise<FeeEstimate & {
+        metadata?: UsageMetadata;
+    }>;
+    executeGaslessTransfer(signedData: SignedTransferData): Promise<TransferResult>;
+    /**
+     * Convenience method for complete transfer flow
+     * Combines estimateFee and executeGaslessTransfer into a single call
+     *
+     * @param request Transfer request with from, to, token, amount, chain
+     * @param wallet Wallet instance that can build and sign transactions
+     * @returns Transfer result with transaction hash and usage metadata
+     *
+     * Note: The wallet parameter should have methods:
+     * - buildTransaction(params): Build transaction from parameters
+     * - signTransaction(transaction): Sign and serialize transaction
+     *
+     * The wallet's signTransaction should return an object with:
+     * - transactionBytes: number[] - Serialized transaction
+     * - authenticatorBytes: number[] - Serialized authenticator
+     */
+    transfer(request: TransferRequest, wallet: {
+        buildTransaction: (params: any) => Promise<any>;
+        signTransaction: (transaction: any) => Promise<{
+            transactionBytes: number[];
+            authenticatorBytes: number[];
+        }>;
+    }): Promise<TransferResult>;
+    /**
+     * Get transaction status for a specific transaction
+     * Routes through proxy to chain-specific status endpoint
+     *
+     * @param chain Chain where the transaction was executed
+     * @param txHash Transaction hash to query
+     * @returns Transaction status information
+     * @throws SmoothSendError if chain is not supported or status check fails
+     *
+     * @example
+     * ```typescript
+     * const status = await sdk.getTransactionStatus('aptos-testnet', '0x123...');
+     * console.log('Transaction status:', status);
+     * ```
+     */
+    getTransactionStatus(chain: SupportedChain, txHash: string): Promise<any>;
+    validateAddress(chain: SupportedChain, address: string): boolean;
+    validateAmount(chain: SupportedChain, amount: string): boolean;
+    /**
+     * Check proxy worker health status
+     * Routes directly to proxy's /health endpoint (not chain-specific)
+     *
+     * @returns Health response with status, version, and timestamp
+     * @throws NetworkError if proxy is unavailable
+     * @throws SmoothSendError for other errors
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const health = await sdk.getHealth();
+     *   console.log('Proxy status:', health.status);
+     *   console.log('Version:', health.version);
+     * } catch (error) {
+     *   if (error instanceof NetworkError) {
+     *     console.error('Proxy unavailable. Please retry later.');
+     *   }
+     * }
+     * ```
+     */
+    getHealth(): Promise<HealthResponse>;
+    /**
+     * Get list of supported chains (static list)
+     * For dynamic list from proxy, use getSupportedChainsFromProxy()
+     *
+     * @returns Array of supported chain identifiers
+     *
+     * @example
+     * ```typescript
+     * const chains = sdk.getSupportedChains();
+     * console.log('Supported chains:', chains);
+     * // Output: ['aptos-testnet', 'aptos-mainnet']
+     * ```
+     */
+    getSupportedChains(): SupportedChain[];
+    /**
+     * Get list of supported chains from proxy worker (dynamic)
+     * Queries the proxy for the current list of supported chains
+     *
+     * @returns Promise with array of chain information including status
+     * @throws SmoothSendError if unable to fetch chains from proxy
+     *
+     * @example
+     * ```typescript
+     * const chains = await sdk.getSupportedChainsFromProxy();
+     * chains.forEach(chain => {
+     *   console.log(`${chain.name} (${chain.id}): ${chain.status}`);
+     * });
+     * ```
+     */
+    getSupportedChainsFromProxy(): Promise<Array<{
+        id: string;
+        name: string;
+        ecosystem: string;
+        network: string;
+        status: string;
+    }>>;
+    /**
+     * Check if a specific chain is currently supported
+     *
+     * @param chain Chain identifier to check
+     * @returns true if chain is supported, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (sdk.isChainSupported('aptos-testnet')) {
+     *   console.log('Aptos testnet is supported');
+     * } else {
+     *   console.log('Chain not supported');
+     * }
+     * ```
+     */
+    isChainSupported(chain: string): boolean;
+    /**
+     * Check health status of a specific chain's relayer
+     * Routes through proxy to chain-specific health endpoint
+     *
+     * @param chain Chain identifier to check
+     * @returns Health response for the specific chain
+     * @throws SmoothSendError if chain is not supported or health check fails
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const health = await sdk.getChainHealth('aptos-testnet');
+     *   console.log('Aptos testnet status:', health.status);
+     * } catch (error) {
+     *   console.error('Chain health check failed:', error.message);
+     * }
+     * ```
+     */
+    getChainHealth(chain: SupportedChain): Promise<HealthResponse>;
+    /**
+     * Get current usage statistics without making a transfer
+     * Makes a lightweight health check request to retrieve usage metadata
+     *
+     * @returns Usage metadata with rate limit and monthly usage information
+     * @throws Error if unable to retrieve usage stats
+     *
+     * @example
+     * ```typescript
+     * const usage = await sdk.getUsageStats();
+     * console.log('Rate limit:', usage.rateLimit);
+     * console.log('Monthly usage:', usage.monthly);
+     * console.log('Request ID:', usage.requestId);
+     *
+     * // Check if approaching limits
+     * if (parseInt(usage.rateLimit.remaining) < 2) {
+     *   console.warn('Approaching rate limit!');
+     * }
+     * ```
+     */
+    getUsageStats(): Promise<UsageMetadata>;
+    /**
+     * Extract request ID from a transfer result for debugging and support
+     *
+     * @param result Transfer result from executeGaslessTransfer or transfer
+     * @returns Request ID if available, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.executeGaslessTransfer(signedData);
+     * const requestId = sdk.getRequestId(result);
+     * if (requestId) {
+     *   console.log('Request ID for support:', requestId);
+     * }
+     * ```
+     */
+    getRequestId(result: TransferResult): string | undefined;
+    /**
+     * Check if approaching rate limit based on transfer result metadata
+     *
+     * @param result Transfer result with metadata
+     * @param threshold Percentage threshold (0-100) to consider as "approaching" (default: 20)
+     * @returns true if remaining requests are below threshold percentage
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.transfer(request, wallet);
+     * if (sdk.isApproachingRateLimit(result)) {
+     *   console.warn('Approaching rate limit, consider slowing down requests');
+     * }
+     * ```
+     */
+    isApproachingRateLimit(result: TransferResult, threshold?: number): boolean;
+    /**
+     * Check if approaching monthly usage limit based on transfer result metadata
+     *
+     * @param result Transfer result with metadata
+     * @param threshold Percentage threshold (0-100) to consider as "approaching" (default: 90)
+     * @returns true if monthly usage is above threshold percentage
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.transfer(request, wallet);
+     * if (sdk.isApproachingMonthlyLimit(result)) {
+     *   console.warn('Approaching monthly limit, consider upgrading plan');
+     * }
+     * ```
+     */
+    isApproachingMonthlyLimit(result: TransferResult, threshold?: number): boolean;
+    /**
+     * Check if a chain belongs to a specific ecosystem
+     */
+    getChainEcosystem(chain: SupportedChain): ChainEcosystem;
+    /**
+     * Get list of supported chains (static method)
+     * Can be called without instantiating the SDK
+     *
+     * @returns Array of supported chain identifiers
+     *
+     * @example
+     * ```typescript
+     * const chains = SmoothSendSDK.getSupportedChains();
+     * console.log('Supported chains:', chains);
+     * ```
+     */
+    static getSupportedChains(): SupportedChain[];
+}
+
+/**
+ * SmoothSend Transaction Submitter
+ *
+ * A TransactionSubmitter implementation that integrates with the Aptos Wallet Adapter
+ * to enable gasless transactions via SmoothSend's relayer network.
+ *
+ * @example
+ * ```typescript
+ * import { SmoothSendTransactionSubmitter } from '@smoothsend/sdk';
+ * import { AptosWalletAdapterProvider } from '@aptos-labs/wallet-adapter-react';
+ *
+ * // Create the transaction submitter
+ * const transactionSubmitter = new SmoothSendTransactionSubmitter({
+ *   apiKey: 'pk_nogas_your_api_key_here',
+ *   network: 'testnet'
+ * });
+ *
+ * // Use in your wallet provider - that's it!
+ * <AptosWalletAdapterProvider
+ *   dappConfig={{
+ *     network: Network.TESTNET,
+ *     transactionSubmitter: transactionSubmitter
+ *   }}
+ * >
+ *   <App />
+ * </AptosWalletAdapterProvider>
+ * ```
+ */
+/**
+ * Minimal type definitions for Aptos SDK compatibility
+ * These match the @aptos-labs/ts-sdk types without requiring it as a dependency
+ */
+/** Represents an Aptos configuration object */
+interface AptosConfig {
+    network?: string;
+    fullnode?: string;
+    [key: string]: unknown;
+}
+/** Represents a pending transaction response */
+interface PendingTransactionResponse {
+    hash: string;
+    sender: string;
+    sequence_number: string;
+    max_gas_amount: string;
+    gas_unit_price: string;
+    expiration_timestamp_secs: string;
+    payload: unknown;
+    signature?: unknown;
+    type?: string;
+}
+/**
+ * Represents any raw transaction from the Aptos SDK
+ * Compatible with SimpleTransaction and MultiAgentTransaction
+ */
+interface AnyRawTransaction {
+    rawTransaction: {
+        sender: {
+            bcsToBytes(): Uint8Array;
+            toString(): string;
+        };
+        sequence_number: {
+            toString(): string;
+        };
+        max_gas_amount: {
+            toString(): string;
+        };
+        gas_unit_price: {
+            toString(): string;
+        };
+        expiration_timestamp_secs: {
+            toString(): string;
+        };
+    };
+    bcsToBytes(): Uint8Array;
+    feePayerAddress?: {
+        bcsToBytes(): Uint8Array;
+    };
+    secondarySignerAddresses?: Array<{
+        bcsToBytes(): Uint8Array;
+    }>;
+}
+/** Represents an account authenticator from the Aptos SDK */
+interface AccountAuthenticator {
+    bcsToBytes(): Uint8Array;
+}
+/**
+ * Configuration options for SmoothSendTransactionSubmitter
+ */
+interface SmoothSendTransactionSubmitterConfig {
+    /**
+     * Your SmoothSend API key
+     * - Use `pk_nogas_*` for frontend applications (CORS protected)
+     * - Use `sk_nogas_*` for backend applications only
+     */
+    apiKey: string;
+    /**
+     * Network to use
+     * @default 'testnet'
+     */
+    network?: 'testnet' | 'mainnet';
+    /**
+     * Gateway URL (usually you don't need to change this)
+     * @default 'https://proxy.smoothsend.xyz'
+     */
+    gatewayUrl?: string;
+    /**
+     * Request timeout in milliseconds
+     * @default 30000
+     */
+    timeout?: number;
+    /**
+     * Enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+}
+/**
+ * TransactionSubmitter interface compatible with @aptos-labs/ts-sdk v2.x
+ * This interface allows the SmoothSendTransactionSubmitter to work as a drop-in
+ * replacement for the default transaction submitter in the Aptos Wallet Adapter.
+ */
+interface TransactionSubmitter {
+    submitTransaction(args: {
+        aptosConfig: AptosConfig;
+        transaction: AnyRawTransaction;
+        senderAuthenticator: AccountAuthenticator;
+        feePayerAuthenticator?: AccountAuthenticator;
+        additionalSignersAuthenticators?: Array<AccountAuthenticator>;
+        pluginParams?: Record<string, unknown>;
+    }): Promise<PendingTransactionResponse>;
+}
+/**
+ * SmoothSend Transaction Submitter
+ *
+ * Implements the TransactionSubmitter interface to enable gasless transactions
+ * through the Aptos Wallet Adapter. Simply pass this to your AptosWalletAdapterProvider
+ * and all transactions will automatically be submitted as gasless through SmoothSend.
+ */
+declare class SmoothSendTransactionSubmitter implements TransactionSubmitter {
+    private readonly apiKey;
+    private readonly network;
+    private readonly gatewayUrl;
+    private readonly timeout;
+    private readonly debug;
+    constructor(config: SmoothSendTransactionSubmitterConfig);
+    /**
+     * Submit a transaction through SmoothSend's gasless relayer
+     *
+     * This method is called automatically by the Aptos Wallet Adapter when
+     * you use signAndSubmitTransaction. The transaction is submitted to
+     * SmoothSend's relayer which sponsors the gas fees.
+     */
+    submitTransaction(args: {
+        aptosConfig: AptosConfig;
+        transaction: AnyRawTransaction;
+        senderAuthenticator: AccountAuthenticator;
+        feePayerAuthenticator?: AccountAuthenticator;
+        additionalSignersAuthenticators?: Array<AccountAuthenticator>;
+        pluginParams?: Record<string, unknown>;
+    }): Promise<PendingTransactionResponse>;
+    /**
+     * Make an HTTP request to the SmoothSend gateway
+     */
+    private makeRequest;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): Readonly<SmoothSendTransactionSubmitterConfig>;
+}
+/**
+ * Create a SmoothSend transaction submitter with minimal configuration
+ *
+ * @example
+ * ```typescript
+ * const submitter = createSmoothSendSubmitter('pk_nogas_your_key');
+ * ```
+ */
+declare function createSmoothSendSubmitter(apiKey: string, options?: Partial<Omit<SmoothSendTransactionSubmitterConfig, 'apiKey'>>): SmoothSendTransactionSubmitter;
+
+/**
+ * Script Composer Client
+ *
+ * Wrapper for Script Composer gasless transactions.
+ * Use this for token transfers on mainnet with free tier (fee deducted from token).
+ *
+ * @remarks
+ * Script Composer builds a batched transaction that:
+ * 1. Withdraws (amount + fee) from sender
+ * 2. Deposits amount to recipient
+ * 3. Deposits fee to treasury
+ *
+ * This allows gasless transactions where the fee is paid in the token being transferred.
+ *
+ * @example
+ * ```typescript
+ * import { ScriptComposerClient } from '@smoothsend/aptos-sdk';
+ *
+ * const client = new ScriptComposerClient({
+ *   apiKey: 'pk_nogas_xxx',
+ *   network: 'mainnet'
+ * });
+ *
+ * // Step 1: Build transaction (fee calculated automatically)
+ * const { transactionBytes, fee, totalAmount } = await client.buildTransfer({
+ *   sender: wallet.address,
+ *   recipient: '0x123...',
+ *   amount: '1000000', // 1 USDC (6 decimals)
+ *   assetType: '0x...::usdc::USDC',
+ *   decimals: 6,
+ *   symbol: 'USDC'
+ * });
+ *
+ * // Step 2: Sign with wallet
+ * const signedTx = await wallet.signTransaction(transactionBytes);
+ *
+ * // Step 3: Submit
+ * const result = await client.submitSignedTransaction({
+ *   transactionBytes: signedTx.transactionBytes,
+ *   authenticatorBytes: signedTx.authenticatorBytes
+ * });
+ *
+ * console.log('Tx:', result.txHash);
+ * ```
+ */
+/**
+ * Configuration for Script Composer Client
+ */
+interface ScriptComposerConfig {
+    /** API key for authentication (pk_nogas_* or sk_nogas_*) */
+    apiKey: string;
+    /** Network to use: 'testnet' or 'mainnet' */
+    network: 'testnet' | 'mainnet';
+    /** Custom proxy URL (optional, defaults to proxy.smoothsend.xyz) */
+    proxyUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Parameters for building a Script Composer transfer
+ */
+interface BuildTransferParams {
+    /** Sender's wallet address */
+    sender: string;
+    /** Recipient's wallet address */
+    recipient: string;
+    /** Amount in smallest units (e.g., 1000000 for 1 USDC) */
+    amount: string;
+    /** Full asset type address (e.g., '0x...::usdc::USDC') */
+    assetType: string;
+    /** Token decimals (e.g., 6 for USDC, 8 for APT) */
+    decimals: number;
+    /** Token symbol (e.g., 'USDC', 'APT') */
+    symbol: string;
+}
+/**
+ * Result from building a transfer
+ */
+interface BuildTransferResult {
+    /** Success status */
+    success: boolean;
+    /** Request ID for tracking */
+    requestId: string;
+    /** Serialized transaction bytes for wallet signing */
+    transactionBytes: number[];
+    /** Transaction details */
+    transaction: {
+        sender: string;
+        recipient: string;
+        amount: string;
+        assetType: string;
+        network: string;
+    };
+    /** Fee amount in smallest units */
+    fee: string;
+    /** Total amount (amount + fee) in smallest units */
+    totalAmount: string;
+    /** Fee breakdown with formatted values */
+    feeBreakdown: {
+        amount: string;
+        fee: string;
+        totalAmount: string;
+        formatted: {
+            amount: string;
+            fee: string;
+            totalAmount: string;
+        };
+        pricing: {
+            tier: string;
+            zeroFees: boolean;
+            feeInUsd: number;
+            tokenPrice: number | null;
+            description: string;
+        };
+    };
+}
+/**
+ * Parameters for submitting a signed transaction
+ */
+interface SubmitSignedTransactionParams {
+    /** Serialized transaction bytes (from wallet signing) */
+    transactionBytes: number[];
+    /** Serialized authenticator bytes (from wallet signing) */
+    authenticatorBytes: number[];
+}
+/**
+ * Result from submitting a transaction
+ */
+interface SubmitTransactionResult {
+    /** Success status */
+    success: boolean;
+    /** Request ID for tracking */
+    requestId: string;
+    /** Transaction hash */
+    txHash: string;
+    /** Gas used */
+    gasUsed?: string;
+    /** VM status */
+    vmStatus?: string;
+    /** Sender address */
+    sender?: string;
+}
+/**
+ * Fee estimation result
+ */
+interface FeeEstimateResult {
+    /** Success status */
+    success: boolean;
+    /** Request ID for tracking */
+    requestId: string;
+    /** Fee estimation details */
+    estimation: {
+        /** Amount in smallest units */
+        amount: string;
+        /** Fee in smallest units */
+        fee: string;
+        /** Total amount in smallest units */
+        totalAmount: string;
+        /** Formatted values for display */
+        formatted: {
+            amount: string;
+            fee: string;
+            totalAmount: string;
+        };
+        /** Pricing information */
+        pricing: {
+            tier: string;
+            zeroFees: boolean;
+            feeInUsd: number;
+            tokenPrice: number | null;
+            description: string;
+        };
+        /** Usage information */
+        usage: {
+            monthlyLimit: number;
+            usedThisMonth: number;
+            remaining: number;
+        };
+    };
+}
+/**
+ * Script Composer Client
+ *
+ * For gasless token transfers with fee deducted from the token.
+ * Use this on mainnet with free tier, or anytime you want fee-in-token.
+ */
+declare class ScriptComposerClient {
+    private httpClient;
+    private config;
+    constructor(config: ScriptComposerConfig);
+    private isBrowser;
+    private log;
+    /**
+     * Estimate fee for a transfer without building the transaction
+     *
+     * @param params Transfer parameters
+     * @returns Fee estimation with pricing details
+     */
+    estimateFee(params: BuildTransferParams): Promise<FeeEstimateResult>;
+    /**
+     * Build a gasless transfer transaction
+     *
+     * Returns unsigned transaction bytes that must be signed by the user's wallet.
+     * The fee will be deducted from the token being transferred.
+     *
+     * @param params Transfer parameters
+     * @returns Transaction bytes for signing and fee details
+     */
+    buildTransfer(params: BuildTransferParams): Promise<BuildTransferResult>;
+    /**
+     * Submit a signed transaction
+     *
+     * After the user signs the transaction bytes returned by buildTransfer(),
+     * use this method to submit the signed transaction.
+     *
+     * @param params Signed transaction bytes
+     * @returns Transaction result with hash
+     */
+    submitSignedTransaction(params: SubmitSignedTransactionParams): Promise<SubmitTransactionResult>;
+    /**
+     * Complete transfer flow: build, sign, and submit
+     *
+     * Convenience method that handles the entire flow.
+     * Requires a wallet that can sign transactions.
+     *
+     * @param params Transfer parameters
+     * @param wallet Wallet with signTransaction method
+     * @returns Transaction result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.transfer({
+     *   sender: wallet.address,
+     *   recipient: '0x123...',
+     *   amount: '1000000',
+     *   assetType: USDC_ADDRESS,
+     *   decimals: 6,
+     *   symbol: 'USDC'
+     * }, wallet);
+     * ```
+     */
+    transfer(params: BuildTransferParams, wallet: {
+        signTransaction: (txBytes: number[]) => Promise<{
+            transactionBytes: number[];
+            authenticatorBytes: number[];
+        }>;
+    }): Promise<SubmitTransactionResult>;
+    /**
+     * Get current network
+     */
+    getNetwork(): 'testnet' | 'mainnet';
+    /**
+     * Set network
+     */
+    setNetwork(network: 'testnet' | 'mainnet'): void;
+}
+/**
+ * Create a Script Composer client (convenience function)
+ */
+declare function createScriptComposerClient(config: ScriptComposerConfig): ScriptComposerClient;
+
+/**
+ * Aptos Multi-Chain Adapter - v2 Proxy Architecture
+ * Handles all Aptos chains (aptos-testnet, aptos-mainnet)
+ * Routes all requests through proxy.smoothsend.xyz with API key authentication
+ * Supports Aptos-specific features like gasless transactions and Move-based contracts
+ */
+declare class AptosAdapter implements IChainAdapter {
+    readonly chain: SupportedChain;
+    readonly config: ChainConfig;
+    private httpClient;
+    private apiKey;
+    private network;
+    constructor(chain: SupportedChain, config: ChainConfig, apiKey: string, network?: 'testnet' | 'mainnet', includeOrigin?: boolean);
+    /**
+     * Build API path for proxy worker routing to Aptos relayer
+     * All requests route through /api/v1/relayer/aptos/* endpoints
+     */
+    private getApiPath;
+    /**
+     * Update network parameter for subsequent requests
+     * Network is passed via X-Network header to proxy worker
+     */
+    setNetwork(network: 'testnet' | 'mainnet'): void;
+    /**
+     * Get current network
+     */
+    getNetwork(): 'testnet' | 'mainnet';
+    /**
+     * Estimate fee for a transfer (v2 interface method)
+     * Routes through proxy: POST /api/v1/relayer/aptos/quote
+     */
+    estimateFee(request: TransferRequest): Promise<FeeEstimate>;
+    /**
+     * Execute gasless transfer (v2 interface method)
+     * Routes through proxy: POST /api/v1/relayer/aptos/execute
+     */
+    executeGaslessTransfer(signedData: SignedTransferData): Promise<TransferResult>;
+    /**
+     * Get quote for a transfer (legacy method, kept for backward compatibility)
+     * Routes through proxy: POST /api/v1/relayer/aptos/quote
+     */
+    getQuote(request: TransferRequest): Promise<TransferQuote>;
+    prepareTransfer(request: TransferRequest, quote: TransferQuote): Promise<SignatureData>;
+    executeTransfer(signedData: SignedTransferData): Promise<TransferResult>;
+    getBalance(address: string, token?: string): Promise<TokenBalance[]>;
+    getTokenInfo(token: string): Promise<TokenInfo>;
+    getNonce(address: string): Promise<string>;
+    getTransactionStatus(txHash: string): Promise<any>;
+    /**
+     * Get health status of Aptos relayer through proxy
+     * Routes through proxy: GET /api/v1/relayer/aptos/health
+     */
+    getHealth(): Promise<HealthResponse>;
+    validateAddress(address: string): boolean;
+    validateAmount(amount: string): boolean;
+    /**
+     * Get Aptos token address from symbol
+     */
+    private getAptosTokenAddress;
+    /**
+     * Build Aptos explorer URL for transaction
+     */
+    private buildAptosExplorerUrl;
+    /**
+     * Validate serialized transaction data for proxy worker
+     * @param signedData The signed transfer data to validate
+     */
+    private validateSerializedTransactionData;
+    /**
+     * Enhanced address validation with detailed error messages
+     * @param address The address to validate
+     * @returns true if valid, throws error if invalid
+     */
+    validateAddressStrict(address: string): boolean;
+    /**
+     * Verify that a public key corresponds to an expected address
+     * This mirrors the enhanced verification in the relayer
+     * @param publicKey The public key to verify
+     * @param expectedAddress The expected address
+     * @returns true if they match
+     */
+    verifyPublicKeyAddress(publicKey: string, expectedAddress: string): Promise<boolean>;
+    /**
+     * Enhanced transaction preparation with better signature data structure
+     * @param request Transfer request
+     * @param quote Transfer quote
+     * @returns Signature data with enhanced structure
+     */
+    prepareTransferEnhanced(request: TransferRequest, quote: TransferQuote): Promise<SignatureData & {
+        metadata: any;
+    }>;
+    /**
+     * Aptos-specific Move contract interaction
+     */
+    callMoveFunction(functionName: string, args: any[]): Promise<any>;
+}
+
+/**
+ * Configuration for HTTP client
+ */
+interface HttpClientConfig {
+    apiKey: string;
+    network?: 'testnet' | 'mainnet';
+    timeout?: number;
+    retries?: number;
+    customHeaders?: Record<string, string>;
+    includeOrigin?: boolean;
+}
+/**
+ * HTTP Client for proxy worker integration
+ * Handles authentication, rate limiting, usage tracking, and retry logic
+ */
+declare class HttpClient {
+    private client;
+    private apiKey?;
+    private network;
+    private maxRetries;
+    private baseURL;
+    private isProxyMode;
+    private includeOrigin;
+    /**
+     * Constructor supports both old (baseURL, timeout) and new (config object) patterns
+     * for backward compatibility during migration
+     */
+    constructor(configOrBaseURL: HttpClientConfig | string, timeout?: number);
+    /**
+     * Extract usage metadata from response headers (proxy mode only)
+     * Uses USAGE_HEADERS constants for consistency across systems
+     */
+    private extractMetadata;
+    /**
+     * Determine if an error should be retried
+     */
+    private shouldRetry;
+    /**
+     * Calculate exponential backoff delay with jitter
+     */
+    private calculateBackoff;
+    /**
+     * Execute request with retry logic (proxy mode) or single attempt (legacy mode)
+     */
+    private executeWithRetry;
+    /**
+     * Handle errors and create appropriate error responses
+     */
+    private handleError;
+    /**
+     * GET request
+     */
+    get<T = any>(url: string, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * POST request
+     */
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * PUT request
+     */
+    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * DELETE request
+     */
+    delete<T = any>(url: string, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Update network parameter for subsequent requests
+     */
+    setNetwork(network: 'testnet' | 'mainnet'): void;
+    /**
+     * Get current network
+     */
+    getNetwork(): 'testnet' | 'mainnet';
+}
+
+/**
+ * SmoothSend SDK v2.0
+ *
+ * Multi-chain gasless transaction SDK for seamless dApp integration
+ *
+ * @remarks
+ * The SDK provides a simple interface for executing gasless token transfers
+ * across multiple blockchain networks. All requests route through the proxy
+ * worker at proxy.smoothsend.xyz with API key authentication.
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * import { SmoothSendSDK } from '@smoothsend/sdk';
+ *
+ * const sdk = new SmoothSendSDK({
+ *   apiKey: 'no_gas_abc123...',
+ *   network: 'testnet'
+ * });
+ *
+ * const result = await sdk.transfer({
+ *   from: '0x123...',
+ *   to: '0x456...',
+ *   token: 'USDC',
+ *   amount: '1000000',
+ *   chain: 'aptos-testnet'
+ * }, wallet);
+ *
+ * console.log('Transaction:', result.txHash);
+ * ```
+ */
+
+/**
+ * SDK version
+ * @public
+ */
+declare const VERSION = "2.1.0";
+
+export { APTOS_ERROR_CODES, AptosAdapter, AuthenticationError, CHAIN_ECOSYSTEM_MAP, HttpClient, NetworkError, RateLimitError, ScriptComposerClient, SmoothSendError, SmoothSendSDK, SmoothSendTransactionSubmitter, VERSION, ValidationError, createErrorFromResponse, createNetworkError, createScriptComposerClient, createSmoothSendSubmitter, SmoothSendSDK as default };
+export type { ApiResponse, AptosErrorCode, AptosTransferData, AvalancheTransferData, BatchRelayTransferRequest, BatchTransferRequest, BuildTransferParams, BuildTransferResult, ChainConfig, ChainEcosystem, ChainInfo, DomainSeparatorResponse, EVMTransferData, ErrorResponse, EstimateGasRequest, EventListener, FeeEstimate, FeeEstimateResult, GasEstimateResponse, HealthResponse, IChainAdapter, PermitData, PrepareSignatureRequest, PrepareSignatureResponse, RelayTransferRequest, RelayTransferResponse, ScriptComposerConfig, SignatureData, SignedTransferData, SmoothSendConfig, SmoothSendTransactionSubmitterConfig, SubmitSignedTransactionParams, SubmitTransactionResult, SuccessResponse, SupportedChain, TokenBalance, TokenInfo, TransactionSubmitter, TransferData, TransferEvent, TransferQuote, TransferQuoteRequest, TransferQuoteResponse, TransferRequest, TransferResult, TransferStatusResponse, UsageMetadata };