@smoothsend/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,2097 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var axios = require('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' }
+ * );
+ * ```
+ */
+class SmoothSendError extends Error {
+    /**
+     * 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, code, statusCode, details) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = 'SmoothSendError';
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+/**
+ * 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);
+ *   }
+ * }
+ * ```
+ */
+class AuthenticationError extends SmoothSendError {
+    /**
+     * Creates a new AuthenticationError
+     *
+     * @param message - Human-readable error message
+     * @param details - Additional error details
+     */
+    constructor(message, details) {
+        super(message, 'AUTHENTICATION_ERROR', 401, {
+            ...details,
+            docs: 'https://docs.smoothsend.xyz/api-keys',
+            suggestion: 'Check your API key at dashboard.smoothsend.xyz'
+        });
+        this.name = 'AuthenticationError';
+    }
+}
+/**
+ * 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}`);
+ *   }
+ * }
+ * ```
+ */
+class RateLimitError extends SmoothSendError {
+    /**
+     * 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, limit, remaining, resetTime) {
+        super(message, 'RATE_LIMIT_EXCEEDED', 429, {
+            limit,
+            remaining,
+            resetTime,
+            docs: 'https://docs.smoothsend.xyz/rate-limits',
+            suggestion: 'Wait until rate limit resets or upgrade your tier'
+        });
+        this.limit = limit;
+        this.remaining = remaining;
+        this.resetTime = resetTime;
+        this.name = 'RateLimitError';
+    }
+}
+/**
+ * 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);
+ *   }
+ * }
+ * ```
+ */
+class ValidationError extends SmoothSendError {
+    /**
+     * 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, field, details) {
+        super(message, 'VALIDATION_ERROR', 400, {
+            field,
+            ...details,
+            suggestion: `Check the '${field}' parameter and try again`
+        });
+        this.field = field;
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * 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);
+ *   }
+ * }
+ * ```
+ */
+class NetworkError extends SmoothSendError {
+    /**
+     * Creates a new NetworkError
+     *
+     * @param message - Human-readable error message
+     * @param originalError - Original error that caused the network failure
+     */
+    constructor(message, originalError) {
+        super(message, 'NETWORK_ERROR', 0, {
+            originalError: originalError?.message,
+            suggestion: 'Check your internet connection and try again'
+        });
+        this.originalError = originalError;
+        this.name = 'NetworkError';
+    }
+}
+/**
+ * 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;
+ * ```
+ */
+function createErrorFromResponse(statusCode, errorData, defaultMessage = 'An error occurred') {
+    const message = errorData?.error || errorData?.message || defaultMessage;
+    const details = errorData?.details || {};
+    switch (statusCode) {
+        case 401:
+            return new AuthenticationError(message, details);
+        case 429:
+            return new RateLimitError(message, parseInt(details.limit || '0'), parseInt(details.remaining || '0'), details.reset || details.resetTime || '');
+        case 400:
+            return new ValidationError(message, details.field || 'unknown', details);
+        default:
+            return new SmoothSendError(message, errorData?.errorCode || 'UNKNOWN_ERROR', statusCode, details);
+    }
+}
+/**
+ * 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);
+ * }
+ * ```
+ */
+function createNetworkError(error) {
+    const message = error?.message || 'Network request failed';
+    return new NetworkError(message, error instanceof Error ? error : undefined);
+}
+
+// Export error classes
+/**
+ * Mapping of supported chains to their respective ecosystems
+ * Used internally for adapter selection and routing
+ */
+const CHAIN_ECOSYSTEM_MAP = {
+    'avalanche': 'evm',
+    'aptos-testnet': 'aptos',
+    'aptos-mainnet': 'aptos'
+};
+/**
+ * Aptos-specific error codes
+ * Used for detailed error handling in Aptos adapter
+ *
+ * @remarks
+ * Error codes are prefixed with APTOS_ for easy identification
+ */
+const APTOS_ERROR_CODES = {
+    // Signature verification errors
+    /** Missing signature in request */
+    MISSING_SIGNATURE: 'APTOS_MISSING_SIGNATURE',
+    /** Missing public key for verification */
+    MISSING_PUBLIC_KEY: 'APTOS_MISSING_PUBLIC_KEY',
+    /** Invalid signature format */
+    INVALID_SIGNATURE_FORMAT: 'APTOS_INVALID_SIGNATURE_FORMAT',
+    /** Invalid public key format */
+    INVALID_PUBLIC_KEY_FORMAT: 'APTOS_INVALID_PUBLIC_KEY_FORMAT',
+    /** Address doesn't match public key */
+    ADDRESS_MISMATCH: 'APTOS_ADDRESS_MISMATCH',
+    /** Signature verification failed */
+    SIGNATURE_VERIFICATION_FAILED: 'APTOS_SIGNATURE_VERIFICATION_FAILED',
+    // Transaction errors
+    /** Missing transaction data */
+    MISSING_TRANSACTION_DATA: 'APTOS_MISSING_TRANSACTION_DATA',
+    /** Invalid transaction format */
+    INVALID_TRANSACTION_FORMAT: 'APTOS_INVALID_TRANSACTION_FORMAT',
+    // Address validation errors
+    /** Empty address provided */
+    EMPTY_ADDRESS: 'APTOS_EMPTY_ADDRESS',
+    /** Invalid address format */
+    INVALID_ADDRESS_FORMAT: 'APTOS_INVALID_ADDRESS_FORMAT',
+    // General errors
+    /** Error fetching quote */
+    QUOTE_ERROR: 'APTOS_QUOTE_ERROR',
+    /** Error executing transfer */
+    EXECUTE_ERROR: 'APTOS_EXECUTE_ERROR',
+    /** Error fetching balance */
+    BALANCE_ERROR: 'APTOS_BALANCE_ERROR',
+    /** Error fetching token info */
+    TOKEN_INFO_ERROR: 'APTOS_TOKEN_INFO_ERROR',
+    /** Error checking status */
+    STATUS_ERROR: 'APTOS_STATUS_ERROR',
+    /** Error calling Move function */
+    MOVE_CALL_ERROR: 'APTOS_MOVE_CALL_ERROR',
+    /** Unsupported token */
+    UNSUPPORTED_TOKEN: 'APTOS_UNSUPPORTED_TOKEN'
+};
+
+/**
+ * Shared Constants for SmoothSend Platform
+ *
+ * IMPORTANT: This file must be kept in sync across all repositories:
+ * - smoothsend-worker-proxy/src/shared-constants.ts
+ * - smoothsend-dev-console/src/lib/shared-constants.ts
+ * - smoothsend-sdk/src/shared-constants.ts
+ *
+ * Any changes to these constants must be replicated to all three locations.
+ */
+/**
+ * API Key Prefixes
+ * Used to identify key types from their prefix
+ */
+/**
+ * Usage Response Headers
+ * Headers sent by worker and read by SDK/Console
+ *
+ * IMPORTANT: Header names must match exactly
+ */
+const USAGE_HEADERS = {
+    RATE_LIMIT: 'X-Rate-Limit-Limit',
+    RATE_REMAINING: 'X-Rate-Limit-Remaining',
+    RATE_RESET: 'X-Rate-Limit-Reset',
+    MONTHLY_LIMIT: 'X-Monthly-Limit',
+    MONTHLY_USAGE: 'X-Monthly-Usage',
+    MONTHLY_REMAINING: 'X-Monthly-Remaining',
+    REQUEST_ID: 'X-Request-ID'};
+
+/**
+ * HTTP Client for proxy worker integration
+ * Handles authentication, rate limiting, usage tracking, and retry logic
+ */
+class HttpClient {
+    /**
+     * Constructor supports both old (baseURL, timeout) and new (config object) patterns
+     * for backward compatibility during migration
+     */
+    constructor(configOrBaseURL, timeout) {
+        // Determine if using new config object or old baseURL pattern
+        if (typeof configOrBaseURL === 'string') {
+            // Old pattern: constructor(baseURL, timeout)
+            this.baseURL = configOrBaseURL;
+            this.network = 'testnet';
+            this.maxRetries = 3;
+            this.isProxyMode = false;
+            this.includeOrigin = false;
+            this.client = axios.create({
+                baseURL: this.baseURL,
+                timeout: timeout || 30000,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+        }
+        else {
+            // New pattern: constructor(config)
+            const config = configOrBaseURL;
+            this.apiKey = config.apiKey;
+            this.network = config.network || 'testnet';
+            this.maxRetries = config.retries || 3;
+            this.baseURL = 'https://proxy.smoothsend.xyz';
+            this.isProxyMode = true;
+            this.includeOrigin = config.includeOrigin || false;
+            const headers = {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+                'X-Network': this.network,
+                ...config.customHeaders,
+            };
+            // Add Origin header if in browser and includeOrigin is true
+            if (this.includeOrigin && typeof window !== 'undefined' && window.location) {
+                headers['Origin'] = window.location.origin;
+            }
+            this.client = axios.create({
+                baseURL: this.baseURL,
+                timeout: config.timeout || 30000,
+                headers,
+            });
+        }
+        // Request interceptor - add timestamp to prevent caching
+        this.client.interceptors.request.use((config) => {
+            config.params = { ...config.params, _t: Date.now() };
+            return config;
+        }, (error) => Promise.reject(error));
+        // Response interceptor - handle errors but don't transform responses
+        this.client.interceptors.response.use((response) => response, (error) => {
+            // Let the request methods handle errors for proper retry logic
+            return Promise.reject(error);
+        });
+    }
+    /**
+     * Extract usage metadata from response headers (proxy mode only)
+     * Uses USAGE_HEADERS constants for consistency across systems
+     */
+    extractMetadata(response) {
+        if (!this.isProxyMode) {
+            return undefined;
+        }
+        // Convert header names to lowercase for case-insensitive lookup
+        const headers = response.headers;
+        return {
+            rateLimit: {
+                limit: headers[USAGE_HEADERS.RATE_LIMIT.toLowerCase()] || '0',
+                remaining: headers[USAGE_HEADERS.RATE_REMAINING.toLowerCase()] || '0',
+                reset: headers[USAGE_HEADERS.RATE_RESET.toLowerCase()] || '',
+            },
+            monthly: {
+                limit: headers[USAGE_HEADERS.MONTHLY_LIMIT.toLowerCase()] || '0',
+                usage: headers[USAGE_HEADERS.MONTHLY_USAGE.toLowerCase()] || '0',
+                remaining: headers[USAGE_HEADERS.MONTHLY_REMAINING.toLowerCase()] || '0',
+            },
+            requestId: headers[USAGE_HEADERS.REQUEST_ID.toLowerCase()] || '',
+        };
+    }
+    /**
+     * Determine if an error should be retried
+     */
+    shouldRetry(error, attempt) {
+        // Don't retry if we've exceeded max retries
+        if (attempt >= this.maxRetries) {
+            return false;
+        }
+        // Only retry in proxy mode (legacy mode doesn't have retry logic)
+        if (!this.isProxyMode) {
+            return false;
+        }
+        // Network errors - retry
+        if (!error.response) {
+            return true;
+        }
+        const status = error.response.status;
+        // 5xx server errors - retry
+        if (status >= 500 && status < 600) {
+            return true;
+        }
+        // 4xx client errors - don't retry (including 429 rate limit)
+        if (status >= 400 && status < 500) {
+            return false;
+        }
+        return false;
+    }
+    /**
+     * Calculate exponential backoff delay with jitter
+     */
+    calculateBackoff(attempt) {
+        const baseDelay = 1000; // 1 second
+        const maxDelay = 10000; // 10 seconds
+        const exponentialDelay = baseDelay * Math.pow(2, attempt);
+        const delay = Math.min(exponentialDelay, maxDelay);
+        // Add jitter (±20%)
+        const jitter = delay * 0.2 * (Math.random() * 2 - 1);
+        return Math.floor(delay + jitter);
+    }
+    /**
+     * Execute request with retry logic (proxy mode) or single attempt (legacy mode)
+     */
+    async executeWithRetry(operation) {
+        let lastError;
+        const maxAttempts = this.isProxyMode ? this.maxRetries : 0;
+        for (let attempt = 0; attempt <= maxAttempts; attempt++) {
+            try {
+                const response = await operation();
+                // Success - extract metadata (if proxy mode) and return
+                const result = {
+                    success: true,
+                    data: response.data,
+                };
+                const metadata = this.extractMetadata(response);
+                if (metadata) {
+                    result.metadata = metadata;
+                }
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                // Check if we should retry
+                if (!this.shouldRetry(error, attempt)) {
+                    break;
+                }
+                // Wait before retrying (except on last attempt)
+                if (attempt < maxAttempts) {
+                    const delay = this.calculateBackoff(attempt);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        // All retries failed - handle error
+        return this.handleError(lastError);
+    }
+    /**
+     * Handle errors and create appropriate error responses
+     */
+    handleError(error) {
+        if (this.isProxyMode) {
+            // Proxy mode: use typed errors
+            if (error.response) {
+                // Server responded with error status
+                const { status, data } = error.response;
+                const sdkError = createErrorFromResponse(status, data);
+                throw sdkError;
+            }
+            else if (error.request) {
+                // Network error - no response received
+                const networkError = createNetworkError(error);
+                throw networkError;
+            }
+            else {
+                // Other error (request setup, etc.)
+                const networkError = createNetworkError(error);
+                throw networkError;
+            }
+        }
+        else {
+            // Legacy mode: return error response without throwing
+            if (error.response) {
+                const { status, data } = error.response;
+                return {
+                    success: false,
+                    error: data?.error || `HTTP Error ${status}`,
+                    details: data?.details,
+                    errorCode: data?.errorCode || `HTTP_${status}`,
+                };
+            }
+            else if (error.request) {
+                return {
+                    success: false,
+                    error: 'Network error - unable to connect to server',
+                    errorCode: 'NETWORK_ERROR',
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    error: error.message || 'Unknown error occurred',
+                    errorCode: 'UNKNOWN_ERROR',
+                };
+            }
+        }
+    }
+    /**
+     * GET request
+     */
+    async get(url, config) {
+        return this.executeWithRetry(() => this.client.get(url, config));
+    }
+    /**
+     * POST request
+     */
+    async post(url, data, config) {
+        return this.executeWithRetry(() => this.client.post(url, data, config));
+    }
+    /**
+     * PUT request
+     */
+    async put(url, data, config) {
+        return this.executeWithRetry(() => this.client.put(url, data, config));
+    }
+    /**
+     * DELETE request
+     */
+    async delete(url, config) {
+        return this.executeWithRetry(() => this.client.delete(url, config));
+    }
+    /**
+     * Update network parameter for subsequent requests
+     */
+    setNetwork(network) {
+        this.network = network;
+        this.client.defaults.headers['X-Network'] = network;
+    }
+    /**
+     * Get current network
+     */
+    getNetwork() {
+        return this.network;
+    }
+}
+
+var http = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    HttpClient: HttpClient
+});
+
+/**
+ * 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
+ */
+class AptosAdapter {
+    constructor(chain, config, apiKey, network = 'testnet', includeOrigin = false) {
+        // Validate this is an Aptos chain
+        if (CHAIN_ECOSYSTEM_MAP[chain] !== 'aptos') {
+            throw new SmoothSendError(`AptosAdapter can only handle Aptos chains, got: ${chain}`, 'INVALID_CHAIN_FOR_ADAPTER', 400, { chain });
+        }
+        this.chain = chain;
+        this.config = config;
+        this.apiKey = apiKey;
+        this.network = network;
+        // Initialize HTTP client with proxy configuration
+        this.httpClient = new HttpClient({
+            apiKey: this.apiKey,
+            network: this.network,
+            timeout: 30000,
+            retries: 3,
+            includeOrigin
+        });
+    }
+    /**
+     * Build API path for proxy worker routing to Aptos relayer
+     * All requests route through /api/v1/relayer/aptos/* endpoints
+     */
+    getApiPath(endpoint) {
+        return `/api/v1/relayer/aptos${endpoint}`;
+    }
+    /**
+     * Update network parameter for subsequent requests
+     * Network is passed via X-Network header to proxy worker
+     */
+    setNetwork(network) {
+        this.network = network;
+        this.httpClient.setNetwork(network);
+    }
+    /**
+     * Get current network
+     */
+    getNetwork() {
+        return this.network;
+    }
+    /**
+     * Estimate fee for a transfer (v2 interface method)
+     * Routes through proxy: POST /api/v1/relayer/aptos/quote
+     */
+    async estimateFee(request) {
+        try {
+            const response = await this.httpClient.post(this.getApiPath('/quote'), {
+                fromAddress: request.from,
+                toAddress: request.to,
+                amount: request.amount,
+                coinType: this.getAptosTokenAddress(request.token)
+            });
+            const responseData = response.data;
+            const quote = responseData.quote;
+            const feeEstimate = {
+                relayerFee: quote.relayerFee,
+                feeInUSD: quote.feeInUSD || '0',
+                coinType: this.getAptosTokenAddress(request.token),
+                estimatedGas: quote.estimatedGas || '0',
+                network: this.network
+            };
+            // Attach usage metadata from proxy response headers
+            if (response.metadata) {
+                feeEstimate.metadata = response.metadata;
+            }
+            return feeEstimate;
+        }
+        catch (error) {
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to estimate Aptos fee: ${error instanceof Error ? error.message : String(error)}`, APTOS_ERROR_CODES.QUOTE_ERROR, 500, { chain: this.chain });
+        }
+    }
+    /**
+     * Execute gasless transfer (v2 interface method)
+     * Routes through proxy: POST /api/v1/relayer/aptos/execute
+     */
+    async executeGaslessTransfer(signedData) {
+        return this.executeTransfer(signedData);
+    }
+    /**
+     * Get quote for a transfer (legacy method, kept for backward compatibility)
+     * Routes through proxy: POST /api/v1/relayer/aptos/quote
+     */
+    async getQuote(request) {
+        try {
+            // Route through proxy: POST /api/v1/relayer/aptos/quote
+            const response = await this.httpClient.post(this.getApiPath('/quote'), {
+                fromAddress: request.from,
+                toAddress: request.to,
+                amount: request.amount,
+                coinType: this.getAptosTokenAddress(request.token)
+            });
+            // In proxy mode, errors are thrown by HttpClient, so we only handle success
+            const responseData = response.data;
+            const quote = responseData.quote;
+            return {
+                amount: request.amount,
+                relayerFee: quote.relayerFee,
+                total: (BigInt(request.amount) + BigInt(quote.relayerFee)).toString(),
+                feePercentage: 0, // Aptos uses different fee structure
+                contractAddress: responseData.transactionData.function.split('::')[0],
+                // Store Aptos-specific data for later use
+                aptosTransactionData: responseData.transactionData
+            };
+        }
+        catch (error) {
+            // Re-throw typed errors from HttpClient, wrap others
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to get Aptos quote: ${error instanceof Error ? error.message : String(error)}`, APTOS_ERROR_CODES.QUOTE_ERROR, 500, { chain: this.chain });
+        }
+    }
+    async prepareTransfer(request, quote) {
+        // For Aptos, the transaction data is provided in the quote response
+        // The user will sign this transaction directly in their wallet
+        const aptosQuote = quote;
+        if (!aptosQuote.aptosTransactionData) {
+            throw new SmoothSendError('Missing Aptos transaction data from quote', APTOS_ERROR_CODES.MISSING_TRANSACTION_DATA, 400, { chain: this.chain });
+        }
+        // Return the transaction data that needs to be signed
+        // NOTE: After signing, you must serialize the transaction and authenticator
+        // using the Aptos SDK and provide them as transactionBytes and authenticatorBytes
+        return {
+            domain: null, // Aptos doesn't use domain separation like EVM
+            types: null,
+            message: aptosQuote.aptosTransactionData,
+            primaryType: 'AptosTransaction',
+            // Add metadata to help with serialization - using any type for flexibility
+            metadata: {
+                requiresSerialization: true,
+                serializationInstructions: 'After signing, serialize the SimpleTransaction and AccountAuthenticator using Aptos SDK',
+                expectedFormat: 'transactionBytes and authenticatorBytes as number arrays'
+            }
+        };
+    }
+    async executeTransfer(signedData) {
+        try {
+            // Validate that we have the required serialized transaction data
+            this.validateSerializedTransactionData(signedData);
+            // Route through proxy: POST /api/v1/relayer/aptos/execute
+            const response = await this.httpClient.post(this.getApiPath('/execute'), {
+                transactionBytes: signedData.transactionBytes,
+                authenticatorBytes: signedData.authenticatorBytes
+            });
+            // In proxy mode, errors are thrown by HttpClient, so we only handle success
+            const transferData = response.data;
+            const result = {
+                success: transferData.success || true,
+                // Use standardized field names (txHash, transferId)
+                txHash: transferData.txHash || transferData.hash, // Support both formats
+                transferId: transferData.transferId || transferData.transactionId, // Support both formats
+                explorerUrl: this.buildAptosExplorerUrl(transferData.txHash || transferData.hash),
+                // Standard fields
+                gasUsed: transferData.gasUsed,
+                // Aptos-specific fields from enhanced response format
+                gasFeePaidBy: transferData.gasFeePaidBy || 'relayer',
+                userPaidAPT: transferData.userPaidAPT || false,
+                vmStatus: transferData.vmStatus,
+                sender: transferData.sender,
+                chain: transferData.chain,
+                relayerFee: transferData.relayerFee,
+                message: transferData.message
+            };
+            // Attach usage metadata from proxy response headers
+            if (response.metadata) {
+                result.metadata = response.metadata;
+            }
+            return result;
+        }
+        catch (error) {
+            // Re-throw typed errors from HttpClient, wrap others
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to execute Aptos transfer: ${error instanceof Error ? error.message : String(error)}`, APTOS_ERROR_CODES.EXECUTE_ERROR, 500, { chain: this.chain });
+        }
+    }
+    async getBalance(address, token) {
+        try {
+            // Route through proxy: GET /api/v1/relayer/aptos/balance/:address
+            const response = await this.httpClient.get(this.getApiPath(`/balance/${address}`));
+            // In proxy mode, errors are thrown by HttpClient, so we only handle success
+            const balanceData = response.data;
+            return [{
+                    token: balanceData?.symbol || token || 'USDC',
+                    balance: balanceData?.balance?.toString() || '0',
+                    decimals: balanceData?.decimals || 6,
+                    symbol: balanceData?.symbol || token || 'USDC',
+                    name: balanceData?.name || 'USD Coin (Testnet)'
+                }];
+        }
+        catch (error) {
+            // Re-throw typed errors from HttpClient, wrap others
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to get Aptos balance: ${error instanceof Error ? error.message : String(error)}`, APTOS_ERROR_CODES.BALANCE_ERROR, 500, { chain: this.chain });
+        }
+    }
+    async getTokenInfo(token) {
+        try {
+            // Route through proxy: GET /api/v1/relayer/aptos/tokens
+            const response = await this.httpClient.get(this.getApiPath('/tokens'));
+            // In proxy mode, errors are thrown by HttpClient, so we only handle success
+            const tokens = response.data.tokens || {};
+            const tokenInfo = tokens[token.toUpperCase()];
+            if (!tokenInfo) {
+                throw new Error(`Token ${token} not supported on ${this.chain}`);
+            }
+            return {
+                symbol: tokenInfo.symbol,
+                address: tokenInfo.address,
+                decimals: tokenInfo.decimals,
+                name: tokenInfo.name
+            };
+        }
+        catch (error) {
+            // Re-throw typed errors from HttpClient, wrap others
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to get Aptos token info: ${error instanceof Error ? error.message : String(error)}`, APTOS_ERROR_CODES.TOKEN_INFO_ERROR, 500, { chain: this.chain });
+        }
+    }
+    async getNonce(address) {
+        // Aptos uses sequence numbers instead of nonces
+        // For compatibility, we return a timestamp-based value
+        // The actual sequence number is managed by the Aptos blockchain
+        return Date.now().toString();
+    }
+    async getTransactionStatus(txHash) {
+        try {
+            // Route through proxy: GET /api/v1/relayer/aptos/status/:txHash
+            const response = await this.httpClient.get(this.getApiPath(`/status/${txHash}`));
+            // In proxy mode, errors are thrown by HttpClient, so we only handle success
+            return response.data;
+        }
+        catch (error) {
+            // Re-throw typed errors from HttpClient, wrap others
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to get Aptos transaction status: ${error instanceof Error ? error.message : String(error)}`, APTOS_ERROR_CODES.STATUS_ERROR, 500, { chain: this.chain });
+        }
+    }
+    /**
+     * Get health status of Aptos relayer through proxy
+     * Routes through proxy: GET /api/v1/relayer/aptos/health
+     */
+    async getHealth() {
+        try {
+            const response = await this.httpClient.get(this.getApiPath('/health'));
+            const healthResponse = {
+                success: true,
+                status: response.data.status || 'healthy',
+                timestamp: response.data.timestamp || new Date().toISOString(),
+                version: response.data.version || '2.0'
+            };
+            // Attach usage metadata from proxy response headers
+            if (response.metadata) {
+                healthResponse.metadata = response.metadata;
+            }
+            return healthResponse;
+        }
+        catch (error) {
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to get Aptos health status: ${error instanceof Error ? error.message : String(error)}`, 'HEALTH_CHECK_ERROR', 500, { chain: this.chain });
+        }
+    }
+    validateAddress(address) {
+        // Aptos address validation (0x prefix, up to 64 hex characters)
+        // Aptos addresses can be shorter and are automatically padded
+        return /^0x[a-fA-F0-9]{1,64}$/.test(address);
+    }
+    validateAmount(amount) {
+        try {
+            const amountBN = BigInt(amount);
+            return amountBN > 0n;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get Aptos token address from symbol
+     */
+    getAptosTokenAddress(tokenSymbol) {
+        // This would typically come from the chain configuration
+        if (tokenSymbol.toUpperCase() === 'USDC') {
+            if (this.chain === 'aptos-testnet') {
+                return '0x3c27315fb69ba6e4b960f1507d1cefcc9a4247869f26a8d59d6b7869d23782c::test_coins::USDC';
+            }
+        }
+        throw new SmoothSendError(`Unsupported token: ${tokenSymbol} on ${this.chain}`, APTOS_ERROR_CODES.UNSUPPORTED_TOKEN, 400, { chain: this.chain, token: tokenSymbol });
+    }
+    /**
+     * Build Aptos explorer URL for transaction
+     */
+    buildAptosExplorerUrl(txHash) {
+        if (this.chain === 'aptos-testnet') {
+            return `https://explorer.aptoslabs.com/txn/${txHash}?network=testnet`;
+        }
+        return `https://explorer.aptoslabs.com/txn/${txHash}`;
+    }
+    /**
+     * Validate serialized transaction data for proxy worker
+     * @param signedData The signed transfer data to validate
+     */
+    validateSerializedTransactionData(signedData) {
+        if (!signedData.transactionBytes) {
+            throw new SmoothSendError('Serialized transaction bytes are required for Aptos transactions', APTOS_ERROR_CODES.MISSING_TRANSACTION_DATA, 400, { chain: this.chain });
+        }
+        if (!signedData.authenticatorBytes) {
+            throw new SmoothSendError('Serialized authenticator bytes are required for Aptos transactions', APTOS_ERROR_CODES.MISSING_SIGNATURE, 400, { chain: this.chain });
+        }
+        // Validate that transaction bytes is an array of numbers (0-255)
+        if (!Array.isArray(signedData.transactionBytes) ||
+            !signedData.transactionBytes.every((b) => typeof b === 'number' && b >= 0 && b <= 255)) {
+            throw new SmoothSendError('Invalid transaction bytes format. Expected array of numbers 0-255.', APTOS_ERROR_CODES.INVALID_SIGNATURE_FORMAT, 400, { chain: this.chain });
+        }
+        // Validate that authenticator bytes is an array of numbers (0-255)
+        if (!Array.isArray(signedData.authenticatorBytes) ||
+            !signedData.authenticatorBytes.every((b) => typeof b === 'number' && b >= 0 && b <= 255)) {
+            throw new SmoothSendError('Invalid authenticator bytes format. Expected array of numbers 0-255.', APTOS_ERROR_CODES.INVALID_PUBLIC_KEY_FORMAT, 400, { chain: this.chain });
+        }
+    }
+    /**
+     * Enhanced address validation with detailed error messages
+     * @param address The address to validate
+     * @returns true if valid, throws error if invalid
+     */
+    validateAddressStrict(address) {
+        if (!address) {
+            throw new SmoothSendError('Address cannot be empty', APTOS_ERROR_CODES.EMPTY_ADDRESS, 400, { chain: this.chain });
+        }
+        // Aptos address validation (0x prefix, up to 64 hex characters)
+        if (!/^0x[a-fA-F0-9]{1,64}$/.test(address)) {
+            throw new SmoothSendError('Invalid Aptos address format. Must start with 0x and contain 1-64 hex characters.', APTOS_ERROR_CODES.INVALID_ADDRESS_FORMAT, 400, { chain: this.chain });
+        }
+        return true;
+    }
+    /**
+     * 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
+     */
+    async verifyPublicKeyAddress(publicKey, expectedAddress) {
+        try {
+            // This would typically use the Aptos SDK to derive address from public key
+            // For now, we'll do basic validation and let the relayer handle the actual verification
+            this.validateAddressStrict(expectedAddress);
+            if (!publicKey || !publicKey.startsWith('0x')) {
+                return false;
+            }
+            // The actual verification is done by the relayer using the Aptos SDK
+            // This is just a preliminary check
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Enhanced transaction preparation with better signature data structure
+     * @param request Transfer request
+     * @param quote Transfer quote
+     * @returns Signature data with enhanced structure
+     */
+    async prepareTransferEnhanced(request, quote) {
+        const baseSignatureData = await this.prepareTransfer(request, quote);
+        return {
+            ...baseSignatureData,
+            metadata: {
+                chain: this.chain,
+                fromAddress: request.from,
+                toAddress: request.to,
+                amount: request.amount,
+                token: request.token,
+                relayerFee: quote.relayerFee,
+                signatureVersion: '2.0', // Version for tracking signature format changes
+                requiresPublicKey: true, // Indicates this chain requires public key for verification
+                verificationMethod: 'ed25519_with_address_derivation' // Indicates verification method used
+            }
+        };
+    }
+    /**
+     * Aptos-specific Move contract interaction
+     */
+    async callMoveFunction(functionName, args) {
+        try {
+            // Route through proxy: POST /api/v1/relayer/aptos/move/call
+            const response = await this.httpClient.post(this.getApiPath('/move/call'), {
+                function: functionName,
+                arguments: args
+            });
+            // In proxy mode, errors are thrown by HttpClient, so we only handle success
+            return response.data;
+        }
+        catch (error) {
+            // Re-throw typed errors from HttpClient, wrap others
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to call Move function: ${error instanceof Error ? error.message : String(error)}`, APTOS_ERROR_CODES.MOVE_CALL_ERROR, 500, { chain: this.chain });
+        }
+    }
+}
+
+class SmoothSendSDK {
+    constructor(config) {
+        this.adapters = new Map();
+        this.eventListeners = [];
+        this.hasWarnedAboutSecretKey = false;
+        // Validate API key is provided
+        if (!config.apiKey) {
+            throw new SmoothSendError('API key is required. Get your API key from dashboard.smoothsend.xyz', 'MISSING_API_KEY');
+        }
+        // Detect and validate API key type
+        this.keyType = this.detectKeyType(config.apiKey);
+        // Warn if secret key is used in browser environment
+        this.warnIfSecretKeyInBrowser();
+        // Validate network parameter if provided
+        if (config.network && config.network !== 'testnet' && config.network !== 'mainnet') {
+            throw new SmoothSendError('Invalid network parameter. Must be "testnet" or "mainnet"', 'INVALID_NETWORK');
+        }
+        // Set configuration with defaults
+        this.config = {
+            apiKey: config.apiKey,
+            network: config.network || 'testnet', // Default to testnet
+            timeout: config.timeout || 30000,
+            retries: config.retries || 3,
+            customHeaders: config.customHeaders || {}
+        };
+    }
+    /**
+     * Detect key type from API key prefix
+     * Supports pk_nogas_* (public), sk_nogas_* (secret), and no_gas_* (legacy)
+     */
+    detectKeyType(apiKey) {
+        if (apiKey.startsWith('pk_nogas_')) {
+            return 'public';
+        }
+        if (apiKey.startsWith('sk_nogas_')) {
+            return 'secret';
+        }
+        if (apiKey.startsWith('no_gas_')) {
+            return 'legacy';
+        }
+        throw new SmoothSendError('Invalid API key format. API key must start with "pk_nogas_", "sk_nogas_", or "no_gas_"', 'INVALID_API_KEY_FORMAT');
+    }
+    /**
+     * Check if running in browser environment
+     * Used for conditional warnings and Origin header logic
+     */
+    isBrowserEnvironment() {
+        return typeof window !== 'undefined' && typeof window.document !== 'undefined';
+    }
+    /**
+     * Warn if secret key is used in browser environment
+     * Only warns once per SDK instance
+     */
+    warnIfSecretKeyInBrowser() {
+        if (this.hasWarnedAboutSecretKey) {
+            return;
+        }
+        if (this.keyType === 'secret' && this.isBrowserEnvironment()) {
+            console.warn('⚠️ WARNING: Secret key detected in browser environment.\n' +
+                'Secret keys (sk_nogas_*) should only be used in server-side code.\n' +
+                'Use public keys (pk_nogas_*) for frontend applications.\n' +
+                'Learn more: https://docs.smoothsend.xyz/security/api-keys');
+            this.hasWarnedAboutSecretKey = true;
+        }
+    }
+    /**
+     * Determine if Origin header should be included in requests
+     * Include Origin header only for public keys in browser environment
+     */
+    shouldIncludeOrigin() {
+        return this.keyType === 'public' && this.isBrowserEnvironment();
+    }
+    /**
+     * Get or create adapter for a specific chain on-demand
+     */
+    getOrCreateAdapter(chain) {
+        // Check if adapter already exists
+        let adapter = this.adapters.get(chain);
+        if (!adapter) {
+            // Create adapter on-demand
+            const ecosystem = CHAIN_ECOSYSTEM_MAP[chain];
+            if (ecosystem === 'aptos') {
+                // Create minimal config for adapter (proxy handles actual configuration)
+                const minimalConfig = {
+                    name: chain,
+                    displayName: chain,
+                    chainId: 0,
+                    rpcUrl: '',
+                    relayerUrl: 'https://proxy.smoothsend.xyz',
+                    explorerUrl: '',
+                    tokens: [],
+                    nativeCurrency: {
+                        name: 'APT',
+                        symbol: 'APT',
+                        decimals: 8
+                    }
+                };
+                adapter = new AptosAdapter(chain, minimalConfig, this.config.apiKey, this.config.network || 'testnet', this.shouldIncludeOrigin());
+            }
+            else if (ecosystem === 'evm') {
+                // EVM adapter will be implemented in future phase
+                throw new SmoothSendError(`EVM chains not yet supported in v2. Chain: ${chain}`, 'UNSUPPORTED_CHAIN');
+            }
+            else {
+                throw new SmoothSendError(`Unsupported ecosystem: ${ecosystem}`, 'UNSUPPORTED_ECOSYSTEM');
+            }
+            // Cache the adapter for future use
+            this.adapters.set(chain, adapter);
+        }
+        return adapter;
+    }
+    // Event handling
+    addEventListener(listener) {
+        this.eventListeners.push(listener);
+    }
+    removeEventListener(listener) {
+        const index = this.eventListeners.indexOf(listener);
+        if (index > -1) {
+            this.eventListeners.splice(index, 1);
+        }
+    }
+    emitEvent(event) {
+        this.eventListeners.forEach(listener => {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                console.error('Error in event listener:', error);
+            }
+        });
+    }
+    // Core transfer methods
+    async estimateFee(request) {
+        const adapter = this.getOrCreateAdapter(request.chain);
+        this.emitEvent({
+            type: 'transfer_initiated',
+            data: { request },
+            timestamp: Date.now(),
+            chain: request.chain
+        });
+        try {
+            const feeEstimate = await adapter.estimateFee(request);
+            // Metadata is already attached by the adapter from HTTP response headers
+            return feeEstimate;
+        }
+        catch (error) {
+            this.emitEvent({
+                type: 'transfer_failed',
+                data: { error: error instanceof Error ? error.message : String(error), step: 'estimate_fee' },
+                timestamp: Date.now(),
+                chain: request.chain
+            });
+            throw error;
+        }
+    }
+    async executeGaslessTransfer(signedData) {
+        const adapter = this.getOrCreateAdapter(signedData.chain);
+        this.emitEvent({
+            type: 'transfer_submitted',
+            data: { signedData },
+            timestamp: Date.now(),
+            chain: signedData.chain
+        });
+        try {
+            const result = await adapter.executeGaslessTransfer(signedData);
+            this.emitEvent({
+                type: 'transfer_confirmed',
+                data: { result },
+                timestamp: Date.now(),
+                chain: signedData.chain
+            });
+            return result;
+        }
+        catch (error) {
+            this.emitEvent({
+                type: 'transfer_failed',
+                data: { error: error instanceof Error ? error.message : String(error), step: 'execute' },
+                timestamp: Date.now(),
+                chain: signedData.chain
+            });
+            throw error;
+        }
+    }
+    /**
+     * 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
+     */
+    async transfer(request, wallet) {
+        this.emitEvent({
+            type: 'transfer_initiated',
+            data: { request },
+            timestamp: Date.now(),
+            chain: request.chain
+        });
+        try {
+            // Step 1: Get fee estimate
+            const feeEstimate = await this.estimateFee(request);
+            // Step 2: Build transaction with wallet
+            const transaction = await wallet.buildTransaction({
+                sender: request.from,
+                recipient: request.to,
+                amount: request.amount,
+                coinType: feeEstimate.coinType,
+                relayerFee: feeEstimate.relayerFee
+            });
+            this.emitEvent({
+                type: 'transfer_signed',
+                data: { transaction },
+                timestamp: Date.now(),
+                chain: request.chain
+            });
+            // Step 3: Sign and serialize transaction with wallet
+            const signedTx = await wallet.signTransaction(transaction);
+            // Step 4: Execute gasless transfer
+            const result = await this.executeGaslessTransfer({
+                transactionBytes: signedTx.transactionBytes,
+                authenticatorBytes: signedTx.authenticatorBytes,
+                chain: request.chain,
+                network: this.config.network
+            });
+            return result;
+        }
+        catch (error) {
+            this.emitEvent({
+                type: 'transfer_failed',
+                data: {
+                    error: error instanceof Error ? error.message : String(error),
+                    step: 'transfer'
+                },
+                timestamp: Date.now(),
+                chain: request.chain
+            });
+            throw error;
+        }
+    }
+    // Note: Batch transfer support will be implemented in a future phase
+    // Utility methods
+    /**
+     * 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);
+     * ```
+     */
+    async getTransactionStatus(chain, txHash) {
+        if (!this.isChainSupported(chain)) {
+            throw new SmoothSendError(`Chain ${chain} is not supported`, 'UNSUPPORTED_CHAIN', 400, { chain, supportedChains: this.getSupportedChains() });
+        }
+        if (!txHash || txHash.trim() === '') {
+            throw new SmoothSendError('Transaction hash is required', 'MISSING_TX_HASH', 400);
+        }
+        const adapter = this.getOrCreateAdapter(chain);
+        return await adapter.getTransactionStatus(txHash);
+    }
+    validateAddress(chain, address) {
+        const adapter = this.getOrCreateAdapter(chain);
+        return adapter.validateAddress(address);
+    }
+    validateAmount(chain, amount) {
+        const adapter = this.getOrCreateAdapter(chain);
+        return adapter.validateAmount(amount);
+    }
+    /**
+     * 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.');
+     *   }
+     * }
+     * ```
+     */
+    async getHealth() {
+        // Import HttpClient for direct proxy health check
+        const { HttpClient } = await Promise.resolve().then(function () { return http; });
+        // Create HTTP client for direct proxy communication
+        const httpClient = new HttpClient({
+            apiKey: this.config.apiKey,
+            network: this.config.network || 'testnet',
+            timeout: this.config.timeout,
+            retries: this.config.retries,
+            includeOrigin: this.shouldIncludeOrigin()
+        });
+        try {
+            // Check proxy's general health endpoint (not chain-specific)
+            const response = await httpClient.get('/health');
+            const healthResponse = {
+                success: true,
+                status: response.data.status || 'healthy',
+                timestamp: response.data.timestamp || new Date().toISOString(),
+                version: response.data.version || '2.0'
+            };
+            // Attach usage metadata from proxy response headers
+            if (response.metadata) {
+                healthResponse.metadata = response.metadata;
+            }
+            return healthResponse;
+        }
+        catch (error) {
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to check proxy health: ${error instanceof Error ? error.message : String(error)}. Please check your connection and retry.`, 'HEALTH_CHECK_ERROR', 500);
+        }
+    }
+    /**
+     * 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() {
+        // Return statically supported chains for v2
+        return ['aptos-testnet', 'aptos-mainnet'];
+    }
+    /**
+     * 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}`);
+     * });
+     * ```
+     */
+    async getSupportedChainsFromProxy() {
+        const { HttpClient } = await Promise.resolve().then(function () { return http; });
+        const httpClient = new HttpClient({
+            apiKey: this.config.apiKey,
+            network: this.config.network || 'testnet',
+            timeout: this.config.timeout,
+            retries: this.config.retries,
+            includeOrigin: this.shouldIncludeOrigin()
+        });
+        try {
+            const response = await httpClient.get('/api/v1/chains');
+            if (!response.data.chains) {
+                throw new Error('Invalid response format from proxy');
+            }
+            return response.data.chains;
+        }
+        catch (error) {
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to fetch supported chains from proxy: ${error instanceof Error ? error.message : String(error)}`, 'CHAINS_FETCH_ERROR', 500);
+        }
+    }
+    /**
+     * 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) {
+        const supportedChains = this.getSupportedChains();
+        return supportedChains.includes(chain);
+    }
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    async getChainHealth(chain) {
+        if (!this.isChainSupported(chain)) {
+            throw new SmoothSendError(`Chain ${chain} is not supported`, 'UNSUPPORTED_CHAIN', 400, { chain, supportedChains: this.getSupportedChains() });
+        }
+        const adapter = this.getOrCreateAdapter(chain);
+        return await adapter.getHealth();
+    }
+    /**
+     * 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!');
+     * }
+     * ```
+     */
+    async getUsageStats() {
+        try {
+            // Make a health check request to get usage metadata from headers
+            const health = await this.getHealth();
+            // The health response includes metadata from the HTTP client
+            const healthWithMetadata = health;
+            if (!healthWithMetadata.metadata) {
+                throw new SmoothSendError('Usage metadata not available. This may occur if not using proxy mode.', 'METADATA_NOT_AVAILABLE');
+            }
+            return healthWithMetadata.metadata;
+        }
+        catch (error) {
+            // If health check fails, we can't get usage stats
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to retrieve usage statistics: ${error instanceof Error ? error.message : String(error)}`, 'USAGE_STATS_ERROR');
+        }
+    }
+    /**
+     * 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) {
+        return result.metadata?.requestId;
+    }
+    /**
+     * 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, threshold = 20) {
+        if (!result.metadata?.rateLimit) {
+            return false;
+        }
+        const limit = parseInt(result.metadata.rateLimit.limit);
+        const remaining = parseInt(result.metadata.rateLimit.remaining);
+        if (isNaN(limit) || isNaN(remaining) || limit === 0) {
+            return false;
+        }
+        const percentageRemaining = (remaining / limit) * 100;
+        return percentageRemaining <= threshold;
+    }
+    /**
+     * 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, threshold = 90) {
+        if (!result.metadata?.monthly) {
+            return false;
+        }
+        const limit = parseInt(result.metadata.monthly.limit);
+        const usage = parseInt(result.metadata.monthly.usage);
+        if (isNaN(limit) || isNaN(usage) || limit === 0) {
+            return false;
+        }
+        const percentageUsed = (usage / limit) * 100;
+        return percentageUsed >= threshold;
+    }
+    // Ecosystem-specific methods for advanced usage
+    /**
+     * Check if a chain belongs to a specific ecosystem
+     */
+    getChainEcosystem(chain) {
+        return CHAIN_ECOSYSTEM_MAP[chain];
+    }
+    // Static utility methods
+    /**
+     * 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() {
+        return ['aptos-testnet', 'aptos-mainnet'];
+    }
+}
+
+/**
+ * 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>
+ * ```
+ */
+/**
+ * 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.
+ */
+class SmoothSendTransactionSubmitter {
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error('SmoothSend API key is required. Get your key at dashboard.smoothsend.xyz');
+        }
+        // Validate API key format
+        if (!config.apiKey.startsWith('pk_nogas_') &&
+            !config.apiKey.startsWith('sk_nogas_') &&
+            !config.apiKey.startsWith('no_gas_')) {
+            throw new Error('Invalid API key format. Key must start with pk_nogas_, sk_nogas_, or no_gas_');
+        }
+        // Warn if using secret key in browser
+        if (config.apiKey.startsWith('sk_nogas_') && typeof window !== 'undefined') {
+            console.warn('⚠️ WARNING: Secret key detected in browser environment.\n' +
+                'Secret keys (sk_nogas_*) should only be used in server-side code.\n' +
+                'Use public keys (pk_nogas_*) for frontend applications.');
+        }
+        this.apiKey = config.apiKey;
+        this.network = config.network || 'testnet';
+        this.gatewayUrl = config.gatewayUrl || 'https://proxy.smoothsend.xyz';
+        this.timeout = config.timeout || 30000;
+        this.debug = config.debug || false;
+    }
+    /**
+     * 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.
+     */
+    async submitTransaction(args) {
+        const { transaction, senderAuthenticator, pluginParams } = args;
+        if (this.debug) {
+            console.log('[SmoothSend] Submitting gasless transaction:', {
+                sender: transaction.rawTransaction?.sender?.toString(),
+                network: this.network,
+            });
+        }
+        try {
+            // Serialize transaction and authenticator to bytes
+            const transactionBytes = Array.from(transaction.bcsToBytes());
+            const authenticatorBytes = Array.from(senderAuthenticator.bcsToBytes());
+            // Prepare request payload
+            const payload = {
+                transactionBytes,
+                authenticatorBytes,
+                network: this.network,
+                functionName: pluginParams?.functionName || 'unknown',
+            };
+            // Make request to SmoothSend gateway
+            const response = await this.makeRequest('/api/v1/relayer/gasless-transaction', payload);
+            if (!response.success || !response.txnHash) {
+                throw new Error(response.error || response.details || 'Transaction submission failed');
+            }
+            if (this.debug) {
+                console.log('[SmoothSend] Transaction successful:', {
+                    hash: response.txnHash,
+                    gasUsed: response.gasUsed,
+                });
+            }
+            // Return in the format expected by Aptos SDK
+            return {
+                hash: response.txnHash,
+                sender: response.sender || transaction.rawTransaction?.sender?.toString() || '',
+                sequence_number: transaction.rawTransaction?.sequence_number?.toString() || '0',
+                max_gas_amount: transaction.rawTransaction?.max_gas_amount?.toString() || '0',
+                gas_unit_price: transaction.rawTransaction?.gas_unit_price?.toString() || '0',
+                expiration_timestamp_secs: transaction.rawTransaction?.expiration_timestamp_secs?.toString() || '0',
+                payload: {},
+                signature: undefined,
+            };
+        }
+        catch (error) {
+            if (this.debug) {
+                console.error('[SmoothSend] Transaction failed:', error);
+            }
+            throw new Error(`SmoothSend gasless transaction failed: ${error.message}`);
+        }
+    }
+    /**
+     * Make an HTTP request to the SmoothSend gateway
+     */
+    async makeRequest(endpoint, payload) {
+        const url = `${this.gatewayUrl}${endpoint}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-API-Key': this.apiKey,
+            'X-Chain': `aptos-${this.network}`,
+        };
+        // Add Origin header for public keys in browser
+        if (this.apiKey.startsWith('pk_nogas_') && typeof window !== 'undefined') {
+            headers['Origin'] = window.location.origin;
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                throw new Error(errorData.error || errorData.message || `HTTP ${response.status}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === 'AbortError') {
+                throw new Error('Request timed out');
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get the current configuration
+     */
+    getConfig() {
+        return {
+            apiKey: this.apiKey.substring(0, 15) + '...', // Don't expose full key
+            network: this.network,
+            gatewayUrl: this.gatewayUrl,
+            timeout: this.timeout,
+            debug: this.debug,
+        };
+    }
+}
+/**
+ * Create a SmoothSend transaction submitter with minimal configuration
+ *
+ * @example
+ * ```typescript
+ * const submitter = createSmoothSendSubmitter('pk_nogas_your_key');
+ * ```
+ */
+function createSmoothSendSubmitter(apiKey, options) {
+    return new SmoothSendTransactionSubmitter({
+        apiKey,
+        ...options,
+    });
+}
+
+/**
+ * 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);
+ * ```
+ */
+/**
+ * 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.
+ */
+class ScriptComposerClient {
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new SmoothSendError('API key is required', 'MISSING_API_KEY', 400);
+        }
+        if (!config.network) {
+            throw new SmoothSendError('Network is required (testnet or mainnet)', 'MISSING_NETWORK', 400);
+        }
+        this.config = {
+            apiKey: config.apiKey,
+            network: config.network,
+            proxyUrl: config.proxyUrl,
+            timeout: config.timeout || 30000,
+            debug: config.debug || false,
+        };
+        this.httpClient = new HttpClient({
+            apiKey: this.config.apiKey,
+            network: this.config.network,
+            timeout: this.config.timeout,
+            retries: 3,
+            includeOrigin: this.isBrowser(),
+        });
+    }
+    isBrowser() {
+        return typeof window !== 'undefined' && typeof window.document !== 'undefined';
+    }
+    log(message, data) {
+        if (this.config.debug) {
+            console.log(`[ScriptComposer] ${message}`, data || '');
+        }
+    }
+    /**
+     * Estimate fee for a transfer without building the transaction
+     *
+     * @param params Transfer parameters
+     * @returns Fee estimation with pricing details
+     */
+    async estimateFee(params) {
+        this.log('Estimating fee', params);
+        try {
+            const response = await this.httpClient.post('/api/v1/relayer/estimate-fee', {
+                sender: params.sender,
+                recipient: params.recipient,
+                amount: params.amount,
+                assetType: params.assetType,
+                decimals: params.decimals,
+                symbol: params.symbol,
+                network: this.config.network,
+                apiKey: this.config.apiKey,
+            });
+            this.log('Fee estimate received', response.data);
+            return response.data;
+        }
+        catch (error) {
+            this.log('Fee estimation failed', error);
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to estimate fee: ${error.message}`, 'FEE_ESTIMATION_FAILED', 500, { originalError: error.message });
+        }
+    }
+    /**
+     * 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
+     */
+    async buildTransfer(params) {
+        this.log('Building transfer', params);
+        // Validate parameters
+        if (!params.sender || !params.recipient || !params.amount) {
+            throw new SmoothSendError('Missing required parameters: sender, recipient, amount', 'INVALID_PARAMETERS', 400);
+        }
+        if (!params.assetType || params.decimals === undefined || !params.symbol) {
+            throw new SmoothSendError('Missing token parameters: assetType, decimals, symbol', 'INVALID_PARAMETERS', 400);
+        }
+        try {
+            // Call the gasless-transaction endpoint in Script Composer mode
+            const response = await this.httpClient.post('/api/v1/relayer/gasless-transaction', {
+                sender: params.sender,
+                recipient: params.recipient,
+                amount: params.amount,
+                assetType: params.assetType,
+                decimals: params.decimals,
+                symbol: params.symbol,
+                network: this.config.network,
+            });
+            this.log('Transaction built', response.data);
+            return response.data;
+        }
+        catch (error) {
+            this.log('Build transfer failed', error);
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to build transfer: ${error.message}`, 'BUILD_TRANSFER_FAILED', 500, { originalError: error.message });
+        }
+    }
+    /**
+     * 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
+     */
+    async submitSignedTransaction(params) {
+        this.log('Submitting signed transaction');
+        if (!params.transactionBytes || !params.authenticatorBytes) {
+            throw new SmoothSendError('Missing required parameters: transactionBytes, authenticatorBytes', 'INVALID_PARAMETERS', 400);
+        }
+        try {
+            // Call the gasless-transaction endpoint in Legacy mode (with signed tx)
+            const response = await this.httpClient.post('/api/v1/relayer/gasless-transaction', {
+                transactionBytes: params.transactionBytes,
+                authenticatorBytes: params.authenticatorBytes,
+                network: this.config.network,
+            });
+            this.log('Transaction submitted', response.data);
+            return {
+                success: response.data.success,
+                requestId: response.data.requestId,
+                txHash: response.data.txnHash || response.data.txHash,
+                gasUsed: response.data.gasUsed,
+                vmStatus: response.data.vmStatus,
+                sender: response.data.sender,
+            };
+        }
+        catch (error) {
+            this.log('Submit transaction failed', error);
+            if (error instanceof SmoothSendError) {
+                throw error;
+            }
+            throw new SmoothSendError(`Failed to submit transaction: ${error.message}`, 'SUBMIT_FAILED', 500, { originalError: error.message });
+        }
+    }
+    /**
+     * 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);
+     * ```
+     */
+    async transfer(params, wallet) {
+        this.log('Starting complete transfer flow');
+        // Step 1: Build transaction
+        const buildResult = await this.buildTransfer(params);
+        this.log('Transaction built, fee:', buildResult.fee);
+        // Step 2: Sign with wallet
+        const signedTx = await wallet.signTransaction(buildResult.transactionBytes);
+        this.log('Transaction signed');
+        // Step 3: Submit
+        const result = await this.submitSignedTransaction({
+            transactionBytes: signedTx.transactionBytes,
+            authenticatorBytes: signedTx.authenticatorBytes,
+        });
+        this.log('Transfer complete', result);
+        return result;
+    }
+    /**
+     * Get current network
+     */
+    getNetwork() {
+        return this.config.network;
+    }
+    /**
+     * Set network
+     */
+    setNetwork(network) {
+        this.config.network = network;
+        this.httpClient.setNetwork(network);
+    }
+}
+/**
+ * Create a Script Composer client (convenience function)
+ */
+function createScriptComposerClient(config) {
+    return new ScriptComposerClient(config);
+}
+
+/**
+ * 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);
+ * ```
+ */
+// Main SDK export
+/**
+ * SDK version
+ * @public
+ */
+const VERSION = '2.1.0'; // Updated for wallet adapter support
+
+exports.APTOS_ERROR_CODES = APTOS_ERROR_CODES;
+exports.AptosAdapter = AptosAdapter;
+exports.AuthenticationError = AuthenticationError;
+exports.CHAIN_ECOSYSTEM_MAP = CHAIN_ECOSYSTEM_MAP;
+exports.HttpClient = HttpClient;
+exports.NetworkError = NetworkError;
+exports.RateLimitError = RateLimitError;
+exports.ScriptComposerClient = ScriptComposerClient;
+exports.SmoothSendError = SmoothSendError;
+exports.SmoothSendSDK = SmoothSendSDK;
+exports.SmoothSendTransactionSubmitter = SmoothSendTransactionSubmitter;
+exports.VERSION = VERSION;
+exports.ValidationError = ValidationError;
+exports.createErrorFromResponse = createErrorFromResponse;
+exports.createNetworkError = createNetworkError;
+exports.createScriptComposerClient = createScriptComposerClient;
+exports.createSmoothSendSubmitter = createSmoothSendSubmitter;
+exports.default = SmoothSendSDK;
+//# sourceMappingURL=index.js.map