@0xio/sdk 2.1.3

package/dist/index.umd.js

@@ -0,0 +1,1751 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.OctraWalletSDK = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * 0xio Wallet SDK - Event System
+     * Type-safe event emitter for wallet events
+     */
+    class EventEmitter {
+        constructor(debug = false) {
+            this.listeners = new Map();
+            this.debug = debug;
+        }
+        /**
+         * Add event listener
+         */
+        on(eventType, listener) {
+            if (!this.listeners.has(eventType)) {
+                this.listeners.set(eventType, new Set());
+            }
+            this.listeners.get(eventType).add(listener);
+            if (this.debug) ;
+        }
+        /**
+         * Remove event listener
+         */
+        off(eventType, listener) {
+            const eventListeners = this.listeners.get(eventType);
+            if (eventListeners) {
+                eventListeners.delete(listener);
+                if (eventListeners.size === 0) {
+                    this.listeners.delete(eventType);
+                }
+                if (this.debug) ;
+            }
+        }
+        /**
+         * Add one-time event listener
+         */
+        once(eventType, listener) {
+            const onceListener = (event) => {
+                listener(event);
+                this.off(eventType, onceListener);
+            };
+            this.on(eventType, onceListener);
+        }
+        /**
+         * Emit event to all listeners
+         */
+        emit(eventType, data) {
+            const event = {
+                type: eventType,
+                data,
+                timestamp: Date.now()
+            };
+            const eventListeners = this.listeners.get(eventType);
+            if (eventListeners && eventListeners.size > 0) {
+                if (this.debug) ;
+                // Create a copy to avoid issues if listeners modify the set during iteration
+                const listenersArray = Array.from(eventListeners);
+                for (const listener of listenersArray) {
+                    try {
+                        listener(event);
+                    }
+                    catch (error) {
+                        // console.error(`[0xio SDK] Error in event listener for '${eventType}':`, error);
+                    }
+                }
+            }
+            else if (this.debug) ;
+        }
+        /**
+         * Remove all listeners for a specific event type
+         */
+        removeAllListeners(eventType) {
+            if (eventType) {
+                this.listeners.delete(eventType);
+                if (this.debug) ;
+            }
+            else {
+                this.listeners.clear();
+                if (this.debug) ;
+            }
+        }
+        /**
+         * Get number of listeners for an event type
+         */
+        listenerCount(eventType) {
+            const eventListeners = this.listeners.get(eventType);
+            return eventListeners ? eventListeners.size : 0;
+        }
+        /**
+         * Get all event types that have listeners
+         */
+        eventTypes() {
+            return Array.from(this.listeners.keys());
+        }
+        /**
+         * Check if there are any listeners for an event type
+         */
+        hasListeners(eventType) {
+            return this.listenerCount(eventType) > 0;
+        }
+    }
+
+    /**
+     * 0xio Wallet SDK - Type Definitions
+     * Comprehensive type system for 0xio wallet integration with Octra Network
+     */
+    // Error types
+    exports.ErrorCode = void 0;
+    (function (ErrorCode) {
+        ErrorCode["EXTENSION_NOT_FOUND"] = "EXTENSION_NOT_FOUND";
+        ErrorCode["CONNECTION_REFUSED"] = "CONNECTION_REFUSED";
+        ErrorCode["USER_REJECTED"] = "USER_REJECTED";
+        ErrorCode["INSUFFICIENT_BALANCE"] = "INSUFFICIENT_BALANCE";
+        ErrorCode["INVALID_ADDRESS"] = "INVALID_ADDRESS";
+        ErrorCode["INVALID_AMOUNT"] = "INVALID_AMOUNT";
+        ErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
+        ErrorCode["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
+        ErrorCode["PERMISSION_DENIED"] = "PERMISSION_DENIED";
+        ErrorCode["WALLET_LOCKED"] = "WALLET_LOCKED";
+        ErrorCode["RATE_LIMIT_EXCEEDED"] = "RATE_LIMIT_EXCEEDED";
+        ErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+    })(exports.ErrorCode || (exports.ErrorCode = {}));
+    class ZeroXIOWalletError extends Error {
+        constructor(code, message, details) {
+            super(message);
+            this.code = code;
+            this.details = details;
+            this.name = 'ZeroXIOWalletError';
+        }
+    }
+
+    /**
+     * 0xio Wallet SDK - Utilities
+     * Helper functions for validation, formatting, and common operations
+     */
+    // ===================
+    // VALIDATION UTILITIES
+    // ===================
+    /**
+     * Validate wallet address for Octra blockchain
+     */
+    function isValidAddress(address) {
+        if (!address || typeof address !== 'string') {
+            return false;
+        }
+        // Octra addresses should match the expected format
+        // This is a basic validation - adjust based on actual Octra address format
+        const addressRegex = /^[A-Za-z0-9]{20,64}$/;
+        return addressRegex.test(address);
+    }
+    /**
+     * Validate transaction amount
+     */
+    function isValidAmount(amount) {
+        return typeof amount === 'number' &&
+            amount > 0 &&
+            Number.isFinite(amount) &&
+            amount <= Number.MAX_SAFE_INTEGER;
+    }
+    /**
+     * Validate network ID
+     */
+    function isValidNetworkId(networkId) {
+        if (!networkId || typeof networkId !== 'string') {
+            return false;
+        }
+        const validNetworks = ['mainnet', 'testnet', 'devnet'];
+        return validNetworks.includes(networkId.toLowerCase());
+    }
+    /**
+     * Validate transaction message
+     */
+    function isValidMessage(message) {
+        if (!message) {
+            return true; // Empty messages are valid
+        }
+        if (typeof message !== 'string') {
+            return false;
+        }
+        // Check length (adjust based on network limits)
+        return message.length <= 280;
+    }
+    /**
+     * Validate fee level
+     */
+    function isValidFeeLevel(feeLevel) {
+        return feeLevel === 1 || feeLevel === 3;
+    }
+    // ===================
+    // FORMATTING UTILITIES
+    // ===================
+    /**
+     * Format OCT amount for display
+     */
+    function formatOCT(amount, decimals = 6) {
+        if (!isValidAmount(amount)) {
+            return '0';
+        }
+        return amount.toLocaleString(undefined, {
+            minimumFractionDigits: 0,
+            maximumFractionDigits: decimals
+        });
+    }
+    /**
+     * Format address for display (truncated)
+     */
+    function formatAddress(address, prefixLength = 6, suffixLength = 4) {
+        if (!isValidAddress(address)) {
+            return 'Invalid Address';
+        }
+        if (address.length <= prefixLength + suffixLength) {
+            return address;
+        }
+        return `${address.slice(0, prefixLength)}...${address.slice(-suffixLength)}`;
+    }
+    /**
+     * Format timestamp for display
+     */
+    function formatTimestamp(timestamp) {
+        const date = new Date(timestamp);
+        return date.toLocaleString();
+    }
+    /**
+     * Format transaction hash for display
+     */
+    function formatTxHash(hash, length = 12) {
+        if (!hash || typeof hash !== 'string') {
+            return 'Invalid Hash';
+        }
+        if (hash.length <= length) {
+            return hash;
+        }
+        const prefixLength = Math.ceil(length / 2);
+        const suffixLength = Math.floor(length / 2);
+        return `${hash.slice(0, prefixLength)}...${hash.slice(-suffixLength)}`;
+    }
+    // ===================
+    // CONVERSION UTILITIES
+    // ===================
+    /**
+     * Convert OCT to micro OCT (for network transmission)
+     */
+    function toMicroOCT(amount) {
+        if (!isValidAmount(amount)) {
+            throw new ZeroXIOWalletError(exports.ErrorCode.INVALID_AMOUNT, 'Invalid amount for conversion');
+        }
+        // Assuming OCT has 6 decimal places like many cryptocurrencies
+        const microOCT = Math.round(amount * 1000000);
+        return microOCT.toString();
+    }
+    /**
+     * Convert micro OCT to OCT (for display)
+     */
+    function fromMicroOCT(microAmount) {
+        const amount = typeof microAmount === 'string' ? parseInt(microAmount, 10) : microAmount;
+        if (!Number.isFinite(amount) || amount < 0) {
+            throw new ZeroXIOWalletError(exports.ErrorCode.INVALID_AMOUNT, 'Invalid micro OCT amount for conversion');
+        }
+        return amount / 1000000;
+    }
+    // ===================
+    // ERROR UTILITIES
+    // ===================
+    /**
+     * Create standardized error messages
+     */
+    function createErrorMessage(code, context) {
+        const baseMessages = {
+            [exports.ErrorCode.EXTENSION_NOT_FOUND]: '0xio Wallet extension is not installed or enabled',
+            [exports.ErrorCode.CONNECTION_REFUSED]: 'Connection to wallet was refused',
+            [exports.ErrorCode.USER_REJECTED]: 'User rejected the request',
+            [exports.ErrorCode.INSUFFICIENT_BALANCE]: 'Insufficient balance for this transaction',
+            [exports.ErrorCode.INVALID_ADDRESS]: 'Invalid wallet address provided',
+            [exports.ErrorCode.INVALID_AMOUNT]: 'Invalid transaction amount',
+            [exports.ErrorCode.NETWORK_ERROR]: 'Network communication error',
+            [exports.ErrorCode.TRANSACTION_FAILED]: 'Transaction failed to process',
+            [exports.ErrorCode.PERMISSION_DENIED]: 'Permission denied for this operation',
+            [exports.ErrorCode.WALLET_LOCKED]: 'Wallet is locked, please unlock first',
+            [exports.ErrorCode.RATE_LIMIT_EXCEEDED]: 'Rate limit exceeded, please try again later',
+            [exports.ErrorCode.UNKNOWN_ERROR]: 'An unknown error occurred'
+        };
+        const baseMessage = baseMessages[code] || 'Unknown error';
+        return context ? `${baseMessage}: ${context}` : baseMessage;
+    }
+    /**
+     * Check if error is a specific type
+     */
+    function isErrorType(error, code) {
+        return error instanceof ZeroXIOWalletError && error.code === code;
+    }
+    // ===================
+    // ASYNC UTILITIES
+    // ===================
+    /**
+     * Create a promise that resolves after a delay
+     */
+    function delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Retry an async operation with exponential backoff
+     */
+    async function retry(operation, maxRetries = 3, baseDelay = 1000) {
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt === maxRetries) {
+                    break; // Last attempt failed
+                }
+                // Exponential backoff: 1s, 2s, 4s, etc.
+                const delayMs = baseDelay * Math.pow(2, attempt);
+                await delay(delayMs);
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Timeout wrapper for promises
+     */
+    function withTimeout(promise, timeoutMs, timeoutMessage = 'Operation timed out') {
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new ZeroXIOWalletError(exports.ErrorCode.NETWORK_ERROR, timeoutMessage));
+            }, timeoutMs);
+        });
+        return Promise.race([promise, timeoutPromise]);
+    }
+    // ===================
+    // BROWSER UTILITIES
+    // ===================
+    /**
+     * Check if running in browser environment
+     */
+    function isBrowser() {
+        return typeof window !== 'undefined' && typeof document !== 'undefined';
+    }
+    /**
+     * Check if browser supports required features
+     */
+    function checkBrowserSupport() {
+        const missingFeatures = [];
+        if (!isBrowser()) {
+            missingFeatures.push('Browser environment');
+            return { supported: false, missingFeatures };
+        }
+        // Check for required browser APIs
+        if (typeof window.postMessage !== 'function') {
+            missingFeatures.push('PostMessage API');
+        }
+        if (typeof window.addEventListener !== 'function') {
+            missingFeatures.push('Event Listeners');
+        }
+        if (typeof Promise === 'undefined') {
+            missingFeatures.push('Promise support');
+        }
+        return {
+            supported: missingFeatures.length === 0,
+            missingFeatures
+        };
+    }
+    // ===================
+    // DEVELOPMENT UTILITIES
+    // ===================
+    /**
+     * Generate mock data for development/testing
+     */
+    function generateMockData() {
+        return {
+            address: 'OCT' + Math.random().toString(36).substr(2, 20).toUpperCase(),
+            balance: {
+                public: Math.floor(Math.random() * 10000),
+                private: Math.floor(Math.random() * 1000),
+                total: 0,
+                currency: 'OCT'
+            },
+            networkInfo: {
+                id: 'testnet',
+                name: 'Octra Testnet',
+                rpcUrl: 'https://testnet.octra.network',
+                color: '#f59e0b',
+                isTestnet: true
+            }
+        };
+    }
+    /**
+     * Create development logger
+     */
+    function createLogger(prefix, debug) {
+        const isDevelopment = typeof window !== 'undefined' && (window.location.hostname === 'localhost' ||
+            window.location.hostname === '127.0.0.1' ||
+            window.location.hostname.includes('dev') ||
+            window.__OCTRA_SDK_DEBUG__);
+        // Only enable logging in development mode AND when debug is explicitly enabled
+        const shouldLog = debug && isDevelopment;
+        return {
+            log: (...args) => {
+                if (shouldLog) {
+                    console.log(`[${prefix}]`, ...args);
+                }
+            },
+            warn: (...args) => {
+                if (shouldLog) {
+                    console.warn(`[${prefix}]`, ...args);
+                }
+            },
+            error: (...args) => {
+                // Always show errors in development, even without debug flag
+                if (isDevelopment) {
+                    console.error(`[${prefix}]`, ...args);
+                }
+            },
+            debug: (...args) => {
+                if (shouldLog) {
+                    console.debug(`[${prefix}]`, ...args);
+                }
+            },
+            table: (data) => {
+                if (shouldLog) {
+                    console.log(`[${prefix}] Table data:`);
+                    console.table(data);
+                }
+            },
+            group: (label) => {
+                if (shouldLog) {
+                    console.group(`[${prefix}] ${label}`);
+                }
+            },
+            groupEnd: () => {
+                if (shouldLog) {
+                    console.groupEnd();
+                }
+            }
+        };
+    }
+
+    /**
+     * 0xio Wallet SDK - Extension Communication Module
+     *
+     * @fileoverview Manages secure communication between the SDK and browser extension.
+     * Implements message passing, request/response handling, rate limiting, and origin validation
+     * to ensure secure wallet interactions.
+     *
+     * @module communication
+     * @version 1.2.0
+     * @license MIT
+     */
+    /**
+     * ExtensionCommunicator - Manages communication with the 0xio Wallet browser extension
+     *
+     * @class
+     * @extends EventEmitter
+     *
+     * @description
+     * Handles all communication between the SDK and wallet extension including:
+     * - Request/response message passing with origin validation
+     * - Rate limiting to prevent DoS attacks
+     * - Automatic retry logic with exponential backoff
+     * - Extension detection and availability monitoring
+     * - Cryptographically secure request ID generation
+     *
+     * @example
+     * ```typescript
+     * const communicator = new ExtensionCommunicator(true); // debug mode
+     * await communicator.initialize();
+     *
+     * const response = await communicator.sendRequest('get_balance', {});
+     * console.log(response);
+     * ```
+     */
+    class ExtensionCommunicator extends EventEmitter {
+        /**
+         * Creates a new ExtensionCommunicator instance
+         *
+         * @param {boolean} debug - Enable debug logging
+         */
+        constructor(debug = false) {
+            super(debug);
+            /** Legacy request counter (deprecated, kept for fallback) */
+            this.requestId = 0;
+            /** Map of pending requests awaiting responses */
+            this.pendingRequests = new Map();
+            /** Initialization state flag */
+            this.isInitialized = false;
+            /** Interval handle for periodic extension detection */
+            this.extensionDetectionInterval = null;
+            /** Current extension availability state */
+            this.isExtensionAvailableState = false;
+            // Rate limiting configuration
+            /** Maximum number of concurrent pending requests */
+            this.MAX_CONCURRENT_REQUESTS = 50;
+            /** Time window for rate limiting (milliseconds) */
+            this.RATE_LIMIT_WINDOW = 1000;
+            /** Maximum requests allowed per time window */
+            this.MAX_REQUESTS_PER_WINDOW = 20;
+            /** Timestamps of recent requests for rate limiting */
+            this.requestTimestamps = [];
+            this.logger = createLogger('ExtensionCommunicator', debug);
+            this.setupMessageListener();
+            this.startExtensionDetection();
+        }
+        /**
+         * Initialize communication with the wallet extension
+         *
+         * @description
+         * Performs initial setup and verification:
+         * 1. Waits for extension to become available
+         * 2. Sends ping to verify communication
+         * 3. Establishes message handlers
+         *
+         * Must be called before any other methods.
+         *
+         * @returns {Promise<boolean>} True if initialization succeeded, false otherwise
+         * @throws {ZeroXIOWalletError} If extension is not available after timeout
+         *
+         * @example
+         * ```typescript
+         * const success = await communicator.initialize();
+         * if (!success) {
+         *   console.error('Failed to initialize wallet connection');
+         * }
+         * ```
+         */
+        async initialize() {
+            if (this.isInitialized) {
+                return true;
+            }
+            try {
+                // Wait for extension detection with timeout
+                const available = await this.waitForExtensionAvailability(10000);
+                if (available) {
+                    // Verify with ping
+                    await withTimeout(this.sendRequestWithRetry('ping', {}, 3, 2000), 8000, 'Extension ping timeout during initialization');
+                    this.isInitialized = true;
+                    this.logger.log('Extension communication initialized successfully');
+                }
+                else {
+                    this.logger.error('Extension not available after waiting');
+                }
+                return this.isInitialized;
+            }
+            catch (error) {
+                this.logger.error('Failed to initialize extension communication:', error);
+                return false;
+            }
+        }
+        /**
+         * Check if extension is available
+         */
+        isExtensionAvailable() {
+            return this.isExtensionAvailableState && this.hasExtensionContext();
+        }
+        /**
+         * Send request to extension
+         */
+        async sendRequest(method, params = {}, timeout = 30000) {
+            return this.sendRequestWithRetry(method, params, 1, timeout);
+        }
+        /**
+         * Send request to extension with automatic retry logic
+         */
+        async sendRequestWithRetry(method, params = {}, maxRetries = 3, timeout = 30000) {
+            if (!this.hasExtensionContext()) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.EXTENSION_NOT_FOUND, '0xio Wallet extension is not installed or available', {
+                    method,
+                    params,
+                    browserContext: this.getBrowserDiagnostics()
+                });
+            }
+            if (!this.isExtensionAvailableState) {
+                // Wait a bit for extension to become available
+                await this.waitForExtensionAvailability(5000);
+                if (!this.isExtensionAvailableState) {
+                    throw new ZeroXIOWalletError(exports.ErrorCode.EXTENSION_NOT_FOUND, 'Extension not available for communication', {
+                        method,
+                        params,
+                        extensionState: this.getExtensionDiagnostics()
+                    });
+                }
+            }
+            // ✅ SECURITY: Check rate limits before processing
+            this.checkRateLimit();
+            return retry(async () => {
+                const requestId = this.generateRequestId();
+                const request = {
+                    id: requestId,
+                    method,
+                    params,
+                    timestamp: Date.now()
+                };
+                this.logger.log(`Sending request (${method}):`, { id: requestId, params });
+                return new Promise((resolve, reject) => {
+                    // Set up timeout
+                    const timeoutHandle = setTimeout(() => {
+                        const pending = this.pendingRequests.get(requestId);
+                        if (pending) {
+                            this.pendingRequests.delete(requestId);
+                            reject(new ZeroXIOWalletError(exports.ErrorCode.NETWORK_ERROR, `Request timeout after ${timeout}ms`, {
+                                method,
+                                params,
+                                requestId,
+                                retryCount: pending.retryCount,
+                                extensionState: this.getExtensionDiagnostics()
+                            }));
+                        }
+                    }, timeout);
+                    // Store request handlers
+                    this.pendingRequests.set(requestId, {
+                        resolve,
+                        reject,
+                        timeout: timeoutHandle,
+                        retryCount: 0
+                    });
+                    // Send message to extension via content script bridge
+                    this.postMessageToExtension(request);
+                });
+            }, maxRetries, 1000);
+        }
+        /**
+         * Setup message listener for responses from extension
+         */
+        setupMessageListener() {
+            if (typeof window === 'undefined') {
+                return; // Not in browser environment
+            }
+            const allowedOrigin = window.location.origin;
+            window.addEventListener('message', (event) => {
+                // ✅ SECURITY: Validate origin first - critical security check
+                if (event.origin !== allowedOrigin) {
+                    this.logger.warn('Blocked message from untrusted origin:', event.origin);
+                    return;
+                }
+                // Only accept messages from same window
+                if (event.source !== window) {
+                    return;
+                }
+                // Check if it's a 0xio SDK response
+                if (!event.data || event.data.source !== '0xio-sdk-bridge') {
+                    return;
+                }
+                // Handle different types of messages
+                if (event.data.response) {
+                    // Regular request/response
+                    const response = event.data.response;
+                    if (response && response.id) {
+                        this.handleExtensionResponse(response);
+                    }
+                }
+                else if (event.data.event) {
+                    // Event notification from extension
+                    this.handleExtensionEvent(event.data.event);
+                }
+            });
+            this.logger.log('Message listener setup complete');
+        }
+        /**
+         * Handle extension event
+         */
+        handleExtensionEvent(event) {
+            this.logger.log('Received extension event:', event.type);
+            // Forward the event to listeners
+            this.emit(event.type, event.data);
+        }
+        /**
+         * Handle response from extension
+         */
+        handleExtensionResponse(response) {
+            this.logger.log(`Received response:`, { id: response.id, success: response.success });
+            const pending = this.pendingRequests.get(response.id);
+            if (!pending) {
+                this.logger.warn(`Received response for unknown request ID: ${response.id}`);
+                return;
+            }
+            // Clear timeout and remove from pending
+            clearTimeout(pending.timeout);
+            this.pendingRequests.delete(response.id);
+            // Handle response
+            if (response.success) {
+                pending.resolve(response.data);
+            }
+            else {
+                const error = response.error;
+                if (error) {
+                    const enhancedError = new ZeroXIOWalletError(error.code, error.message, {
+                        ...error.details,
+                        requestId: response.id,
+                        retryCount: pending.retryCount,
+                        timestamp: Date.now(),
+                        extensionState: this.getExtensionDiagnostics()
+                    });
+                    pending.reject(enhancedError);
+                }
+                else {
+                    pending.reject(new ZeroXIOWalletError(exports.ErrorCode.UNKNOWN_ERROR, 'Unknown error occurred', {
+                        requestId: response.id,
+                        retryCount: pending.retryCount,
+                        extensionState: this.getExtensionDiagnostics()
+                    }));
+                }
+            }
+        }
+        /**
+         * Post message to extension via content script
+         */
+        postMessageToExtension(request) {
+            // ✅ SECURITY: Use specific origin instead of wildcard
+            const targetOrigin = window.location.origin;
+            window.postMessage({
+                source: '0xio-sdk-request',
+                request
+            }, targetOrigin);
+        }
+        /**
+         * Check if we're in a context that can communicate with extension
+         */
+        hasExtensionContext() {
+            return typeof window !== 'undefined' &&
+                typeof window.postMessage === 'function';
+        }
+        /**
+         * Check and enforce rate limits to prevent denial-of-service attacks
+         *
+         * @private
+         * @throws {ZeroXIOWalletError} RATE_LIMIT_EXCEEDED if limits are exceeded
+         *
+         * @description
+         * Implements two-tier rate limiting:
+         * 1. Concurrent requests: Maximum 50 pending requests at once
+         * 2. Request frequency: Maximum 20 requests per second
+         *
+         * Rate limiting protects both the SDK and extension from:
+         * - Accidental infinite loops in dApp code
+         * - Malicious DoS attacks
+         * - Resource exhaustion
+         *
+         * @security Critical security function - enforces resource limits
+         */
+        checkRateLimit() {
+            const now = Date.now();
+            // ✅ SECURITY: Check concurrent request limit
+            if (this.pendingRequests.size >= this.MAX_CONCURRENT_REQUESTS) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.RATE_LIMIT_EXCEEDED, `Too many concurrent requests (max: ${this.MAX_CONCURRENT_REQUESTS})`);
+            }
+            // ✅ SECURITY: Check requests per time window
+            this.requestTimestamps = this.requestTimestamps.filter(t => now - t < this.RATE_LIMIT_WINDOW);
+            if (this.requestTimestamps.length >= this.MAX_REQUESTS_PER_WINDOW) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.RATE_LIMIT_EXCEEDED, `Too many requests per second (max: ${this.MAX_REQUESTS_PER_WINDOW} per ${this.RATE_LIMIT_WINDOW}ms)`);
+            }
+            this.requestTimestamps.push(now);
+        }
+        /**
+         * Generate cryptographically secure unique request ID
+         *
+         * @private
+         * @returns {string} A unique, unpredictable request identifier
+         *
+         * @description
+         * Uses Web Crypto API for secure random ID generation:
+         * 1. Primary: crypto.randomUUID() - UUID v4 format
+         * 2. Fallback: crypto.getRandomValues() - 128-bit random hex
+         * 3. Last resort: timestamp + counter (logs warning)
+         *
+         * Security importance:
+         * - Prevents request ID prediction attacks
+         * - Mitigates replay attacks
+         * - Makes session hijacking more difficult
+         *
+         * @security Critical - IDs must be cryptographically unpredictable
+         */
+        generateRequestId() {
+            // ✅ SECURITY: Use crypto.randomUUID() for secure, unpredictable IDs
+            if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+                return `0xio-sdk-${crypto.randomUUID()}`;
+            }
+            // Fallback to crypto.getRandomValues for older browsers
+            if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+                const array = new Uint8Array(16);
+                crypto.getRandomValues(array);
+                const hex = Array.from(array, b => b.toString(16).padStart(2, '0')).join('');
+                return `0xio-sdk-${hex}`;
+            }
+            // Last resort fallback (not recommended for production)
+            this.logger.warn('Crypto API not available, using less secure ID generation');
+            return `0xio-sdk-${++this.requestId}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        }
+        /**
+         * Start continuous extension detection
+         */
+        startExtensionDetection() {
+            if (typeof window === 'undefined')
+                return;
+            // Listen for extension ready event (instant detection)
+            window.addEventListener('0xioWalletReady', () => {
+                this.logger.log('Received 0xioWalletReady event');
+                this.isExtensionAvailableState = true;
+            });
+            // Also listen for legacy event names
+            window.addEventListener('wallet0xioReady', () => {
+                this.logger.log('Received wallet0xioReady event');
+                this.isExtensionAvailableState = true;
+            });
+            window.addEventListener('octraWalletReady', () => {
+                this.logger.log('Received octraWalletReady event');
+                this.isExtensionAvailableState = true;
+            });
+            // Initial check (in case extension was already injected)
+            this.checkExtensionAvailability();
+            // Set up periodic checks as fallback
+            this.extensionDetectionInterval = setInterval(() => {
+                this.checkExtensionAvailability();
+            }, 2000);
+        }
+        /**
+         * Check if extension is currently available
+         */
+        checkExtensionAvailability() {
+            const wasAvailable = this.isExtensionAvailableState;
+            // Basic checks for extension context
+            this.isExtensionAvailableState = this.hasExtensionContext() && this.detectExtensionSignals();
+            if (!wasAvailable && this.isExtensionAvailableState) {
+                this.logger.log('Extension became available');
+            }
+            else if (wasAvailable && !this.isExtensionAvailableState) {
+                this.logger.warn('Extension became unavailable');
+            }
+        }
+        /**
+         * Detect extension signals/indicators
+         */
+        detectExtensionSignals() {
+            if (typeof window === 'undefined')
+                return false;
+            // Check for extension-injected indicators
+            const win = window;
+            // Look for common extension indicators
+            return !!(win.wallet0xio ||
+                win.ZeroXIOWallet ||
+                win.__0XIO_EXTENSION__ ||
+                win.__OCTRA_EXTENSION__ ||
+                win.octraWallet ||
+                (win.chrome?.runtime?.id) ||
+                document.querySelector('meta[name="0xio-extension"]') ||
+                document.querySelector('meta[name="octra-extension"]') ||
+                document.querySelector('[data-0xio-extension]') ||
+                document.querySelector('[data-octra-extension]'));
+        }
+        /**
+         * Wait for extension to become available
+         */
+        async waitForExtensionAvailability(timeoutMs) {
+            if (this.isExtensionAvailableState) {
+                return true;
+            }
+            return new Promise((resolve) => {
+                let resolved = false;
+                const startTime = Date.now();
+                // Cleanup function
+                const cleanup = () => {
+                    clearInterval(checkInterval);
+                    window.removeEventListener('0xioWalletReady', onReady);
+                    window.removeEventListener('wallet0xioReady', onReady);
+                    window.removeEventListener('octraWalletReady', onReady);
+                };
+                // Event handler for instant resolution
+                const onReady = () => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    this.isExtensionAvailableState = true;
+                    cleanup();
+                    resolve(true);
+                };
+                // Listen for extension ready events
+                window.addEventListener('0xioWalletReady', onReady);
+                window.addEventListener('wallet0xioReady', onReady);
+                window.addEventListener('octraWalletReady', onReady);
+                // Polling fallback with shorter interval
+                const checkInterval = setInterval(() => {
+                    if (resolved)
+                        return;
+                    if (this.isExtensionAvailableState) {
+                        resolved = true;
+                        cleanup();
+                        resolve(true);
+                        return;
+                    }
+                    if (Date.now() - startTime >= timeoutMs) {
+                        resolved = true;
+                        cleanup();
+                        resolve(false);
+                    }
+                }, 100);
+            });
+        }
+        /**
+         * Get browser diagnostics for error reporting
+         */
+        getBrowserDiagnostics() {
+            if (typeof window === 'undefined') {
+                return { environment: 'non-browser' };
+            }
+            const win = window;
+            return {
+                userAgent: navigator.userAgent,
+                hasChrome: !!win.chrome,
+                hasChromeRuntime: !!(win.chrome?.runtime),
+                hasPostMessage: typeof window.postMessage === 'function',
+                origin: window.location?.origin,
+                extensionDetection: {
+                    hasOctraExtension: !!win.__OCTRA_EXTENSION__,
+                    hasZeroXIOWallet: !!win.octraWallet,
+                    hasChromeRuntimeId: !!(win.chrome?.runtime?.id),
+                    hasMetaTag: !!document.querySelector('meta[name=\"octra-extension\"]'),
+                    hasDataAttribute: !!document.querySelector('[data-octra-extension]')
+                }
+            };
+        }
+        /**
+         * Get extension state diagnostics
+         */
+        getExtensionDiagnostics() {
+            return {
+                initialized: this.isInitialized,
+                available: this.isExtensionAvailableState,
+                pendingRequests: this.pendingRequests.size,
+                hasExtensionContext: this.hasExtensionContext(),
+                browserDiagnostics: this.getBrowserDiagnostics()
+            };
+        }
+        /**
+         * Cleanup pending requests
+         */
+        cleanup() {
+            if (this.extensionDetectionInterval) {
+                clearInterval(this.extensionDetectionInterval);
+                this.extensionDetectionInterval = null;
+            }
+            for (const [, pending] of this.pendingRequests) {
+                clearTimeout(pending.timeout);
+                pending.reject(new ZeroXIOWalletError(exports.ErrorCode.UNKNOWN_ERROR, 'SDK cleanup called'));
+            }
+            this.pendingRequests.clear();
+            this.isInitialized = false;
+            this.isExtensionAvailableState = false;
+            // Call parent cleanup
+            this.removeAllListeners();
+            this.logger.log('Communication cleanup complete');
+        }
+        /**
+         * Get debug information
+         */
+        getDebugInfo() {
+            return {
+                initialized: this.isInitialized,
+                available: this.isExtensionAvailableState,
+                pendingRequests: this.pendingRequests.size,
+                hasExtensionContext: this.hasExtensionContext(),
+                extensionDiagnostics: this.getExtensionDiagnostics()
+            };
+        }
+    }
+
+    /**
+     * Network configuration for 0xio SDK
+     */
+    const NETWORKS = {
+        'mainnet': {
+            id: 'mainnet',
+            name: 'Octra Mainnet Alpha',
+            rpcUrl: 'https://octra.network',
+            explorerUrl: 'https://octrascan.io/',
+            color: '#6366f1',
+            isTestnet: false
+        },
+        'custom': {
+            id: 'custom',
+            name: 'Custom Network',
+            rpcUrl: '',
+            explorerUrl: '',
+            color: '#64748b',
+            isTestnet: false // User configurable - can be mainnet or testnet
+        }
+    };
+    const DEFAULT_NETWORK_ID = 'mainnet';
+    /**
+     * Get network configuration by ID
+     */
+    function getNetworkConfig(networkId = DEFAULT_NETWORK_ID) {
+        const network = NETWORKS[networkId];
+        if (!network) {
+            throw new Error(`Unknown network ID: ${networkId}`);
+        }
+        return network;
+    }
+    /**
+     * Get all available networks
+     */
+    function getAllNetworks() {
+        return Object.values(NETWORKS);
+    }
+
+    /**
+     * SDK Configuration
+     */
+    /**
+     * Default balance structure
+     */
+    function createDefaultBalance(total = 0) {
+        return {
+            total,
+            public: total,
+            private: 0,
+            currency: 'OCT'
+        };
+    }
+    /**
+     * SDK Configuration constants
+     */
+    const SDK_CONFIG = {
+        version: '2.1.2',
+        defaultNetworkId: DEFAULT_NETWORK_ID,
+        communicationTimeout: 30000, // 30 seconds
+        retryAttempts: 3,
+        retryDelay: 1000, // 1 second
+    };
+    /**
+     * Get default network configuration
+     */
+    function getDefaultNetwork() {
+        return getNetworkConfig(SDK_CONFIG.defaultNetworkId);
+    }
+
+    /**
+     * 0xio Wallet SDK - Main Wallet Class
+     * Primary interface for DApp developers to interact with 0xio Wallet
+     */
+    class ZeroXIOWallet extends EventEmitter {
+        constructor(config) {
+            super(config.debug);
+            this.connectionInfo = { isConnected: false };
+            this.isInitialized = false;
+            this.config = {
+                ...config,
+                appVersion: config.appVersion || '1.0.0',
+                requiredPermissions: config.requiredPermissions || ['read_balance'],
+                debug: config.debug || false
+            };
+            this.logger = createLogger('ZeroXIOWallet', this.config.debug || false);
+            this.communicator = new ExtensionCommunicator(this.config.debug);
+            this.logger.log('Wallet instance created with config:', this.config);
+        }
+        // ===================
+        // INITIALIZATION
+        // ===================
+        /**
+         * Initialize the SDK
+         * Must be called before using any other methods
+         */
+        async initialize() {
+            if (this.isInitialized) {
+                return true;
+            }
+            try {
+                // Initialize extension communication
+                const communicationReady = await this.communicator.initialize();
+                if (!communicationReady) {
+                    throw new ZeroXIOWalletError(exports.ErrorCode.EXTENSION_NOT_FOUND, 'Failed to establish communication with 0xio Wallet extension');
+                }
+                // Register this DApp with the extension
+                await this.communicator.sendRequest('register_dapp', {
+                    appName: this.config.appName,
+                    appDescription: this.config.appDescription,
+                    appVersion: this.config.appVersion,
+                    appUrl: typeof window !== 'undefined' ? window.location.origin : undefined,
+                    appIcon: this.config.appIcon,
+                    requiredPermissions: this.config.requiredPermissions,
+                    networkId: this.config.networkId
+                });
+                // Setup event forwarding from extension
+                this.setupExtensionEventListeners();
+                this.isInitialized = true;
+                this.logger.log('SDK initialized successfully');
+                return true;
+            }
+            catch (error) {
+                this.logger.error('Failed to initialize:', error);
+                if (error instanceof ZeroXIOWalletError) {
+                    throw error;
+                }
+                throw new ZeroXIOWalletError(exports.ErrorCode.UNKNOWN_ERROR, 'Failed to initialize SDK', error);
+            }
+        }
+        /**
+         * Check if SDK is initialized
+         */
+        isReady() {
+            return this.isInitialized && this.communicator.isExtensionAvailable();
+        }
+        // ===================
+        // CONNECTION MANAGEMENT
+        // ===================
+        /**
+         * Connect to wallet
+         */
+        async connect(options = {}) {
+            this.ensureInitialized();
+            try {
+                this.logger.log('Attempting to connect with options:', options);
+                const result = await this.communicator.sendRequest('connect', {
+                    requestPermissions: options.requestPermissions || this.config.requiredPermissions,
+                    networkId: options.networkId || this.config.networkId
+                });
+                // Update connection info
+                this.connectionInfo = {
+                    isConnected: true,
+                    address: result.address,
+                    balance: result.balance,
+                    networkInfo: result.networkInfo,
+                    connectedAt: Date.now()
+                };
+                const connectEvent = {
+                    address: result.address,
+                    balance: result.balance,
+                    networkInfo: result.networkInfo,
+                    permissions: result.permissions
+                };
+                // Emit connect event
+                this.emit('connect', connectEvent);
+                this.logger.log('Connected successfully:', connectEvent);
+                return connectEvent;
+            }
+            catch (error) {
+                this.logger.error('Connection failed:', error);
+                if (error instanceof ZeroXIOWalletError) {
+                    throw error;
+                }
+                throw new ZeroXIOWalletError(exports.ErrorCode.CONNECTION_REFUSED, 'Failed to connect to wallet', error);
+            }
+        }
+        /**
+         * Disconnect from wallet
+         */
+        async disconnect() {
+            this.ensureInitialized();
+            try {
+                await this.communicator.sendRequest('disconnect');
+                this.connectionInfo = { isConnected: false };
+                const disconnectEvent = {
+                    reason: 'user_action'
+                };
+                this.emit('disconnect', disconnectEvent);
+                this.logger.log('Disconnected from wallet');
+            }
+            catch (error) {
+                this.logger.error('Disconnect failed:', error);
+                throw error;
+            }
+        }
+        /**
+         * Check if connected to wallet
+         */
+        isConnected() {
+            return this.connectionInfo.isConnected;
+        }
+        /**
+         * Get current connection info
+         */
+        getConnectionInfo() {
+            return { ...this.connectionInfo };
+        }
+        /**
+         * Check connection status with extension
+         */
+        async getConnectionStatus() {
+            this.ensureInitialized();
+            try {
+                const result = await this.communicator.sendRequest('getConnectionStatus');
+                if (result.isConnected && result.address) {
+                    // Update internal state if we discover an existing connection
+                    const balanceInfo = createDefaultBalance(result.balance);
+                    const networkInfo = getNetworkConfig(this.config.networkId);
+                    this.connectionInfo = {
+                        isConnected: true,
+                        address: result.address,
+                        balance: balanceInfo,
+                        networkInfo,
+                        connectedAt: result.connectedAt || Date.now()
+                    };
+                    this.logger.log('Discovered existing connection:', this.connectionInfo);
+                    // Emit connect event to notify the wrapper
+                    const connectEvent = {
+                        address: result.address,
+                        balance: balanceInfo,
+                        networkInfo,
+                        permissions: result.permissions || []
+                    };
+                    this.emit('connect', connectEvent);
+                }
+                else {
+                    // No existing connection
+                    this.connectionInfo = { isConnected: false };
+                }
+                return { ...this.connectionInfo };
+            }
+            catch (error) {
+                this.logger.error('Failed to get connection status:', error);
+                this.connectionInfo = { isConnected: false };
+                return { ...this.connectionInfo };
+            }
+        }
+        // ===================
+        // WALLET INFORMATION
+        // ===================
+        /**
+         * Get current wallet address
+         */
+        getAddress() {
+            return this.connectionInfo.address || null;
+        }
+        /**
+         * Get current balance
+         */
+        async getBalance(forceRefresh = false) {
+            this.ensureConnected();
+            try {
+                const address = this.getAddress();
+                if (!address) {
+                    throw new Error('No address found');
+                }
+                // Fetch balance from extension (bypasses CORS, has access to private balance)
+                let publicBalance = 0;
+                let privateBalance = 0;
+                const extResult = await this.communicator.sendRequest('getBalance', { forceRefresh });
+                publicBalance = parseFloat(extResult.balance || '0');
+                privateBalance = parseFloat(extResult.privateBalance || '0');
+                this.logger.log('Balance fetched from extension:', { public: publicBalance, private: privateBalance });
+                const result = {
+                    public: publicBalance,
+                    private: privateBalance,
+                    total: publicBalance + privateBalance,
+                    currency: 'OCT'
+                };
+                // Update cached balance
+                if (this.connectionInfo.balance) {
+                    const previousBalance = this.connectionInfo.balance;
+                    this.connectionInfo.balance = result;
+                    // Emit balance changed event if different
+                    if (previousBalance.total !== result.total) {
+                        const balanceChangedEvent = {
+                            address: this.connectionInfo.address,
+                            previousBalance,
+                            newBalance: result
+                        };
+                        this.emit('balanceChanged', balanceChangedEvent);
+                    }
+                }
+                else {
+                    this.connectionInfo.balance = result;
+                }
+                return result;
+            }
+            catch (error) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.NETWORK_ERROR, 'Failed to get balance', error);
+            }
+        }
+        /**
+         * Get network information
+         */
+        async getNetworkInfo() {
+            this.ensureInitialized();
+            try {
+                const result = await this.communicator.sendRequest('get_network_info');
+                // Update cached network info
+                if (this.connectionInfo.networkInfo) {
+                    const previousNetwork = this.connectionInfo.networkInfo;
+                    this.connectionInfo.networkInfo = result;
+                    // Emit network changed event if different
+                    if (previousNetwork.id !== result.id) {
+                        const networkChangedEvent = {
+                            previousNetwork,
+                            newNetwork: result
+                        };
+                        this.emit('networkChanged', networkChangedEvent);
+                    }
+                }
+                else {
+                    this.connectionInfo.networkInfo = result;
+                }
+                return result;
+            }
+            catch (error) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.NETWORK_ERROR, 'Failed to get network info', error);
+            }
+        }
+        // ===================
+        // TRANSACTIONS
+        // ===================
+        /**
+         * Send transaction
+         */
+        async sendTransaction(txData) {
+            this.ensureConnected();
+            try {
+                this.logger.log('Sending transaction:', txData);
+                const result = await this.communicator.sendRequest('send_transaction', txData);
+                this.logger.log('Transaction result:', result);
+                // Refresh balance after successful transaction
+                if (result.success) {
+                    setTimeout(() => {
+                        this.getBalance(true).catch(error => {
+                            this.logger.warn('Failed to refresh balance after transaction:', error);
+                        });
+                    }, 1000);
+                }
+                return result;
+            }
+            catch (error) {
+                this.logger.error('Transaction failed:', error);
+                if (error instanceof ZeroXIOWalletError) {
+                    throw error;
+                }
+                throw new ZeroXIOWalletError(exports.ErrorCode.TRANSACTION_FAILED, 'Failed to send transaction', error);
+            }
+        }
+        /**
+         * Get transaction history
+         */
+        async getTransactionHistory(page = 1, limit = 20) {
+            this.ensureConnected();
+            try {
+                const result = await this.communicator.sendRequest('get_transaction_history', {
+                    page,
+                    limit
+                });
+                return result;
+            }
+            catch (error) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.NETWORK_ERROR, 'Failed to get transaction history', error);
+            }
+        }
+        // ===================
+        // PRIVATE FEATURES
+        // ===================
+        /**
+         * Get private balance information
+         */
+        async getPrivateBalanceInfo() {
+            this.ensureConnected();
+            try {
+                const result = await this.communicator.sendRequest('get_private_balance_info');
+                return result;
+            }
+            catch (error) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.PERMISSION_DENIED, 'Failed to get private balance info', error);
+            }
+        }
+        /**
+         * Encrypt public balance to private
+         */
+        async encryptBalance(amount) {
+            this.ensureConnected();
+            try {
+                const result = await this.communicator.sendRequest('encrypt_balance', { amount });
+                // Refresh balance after encryption
+                setTimeout(() => {
+                    this.getBalance(true).catch(() => { });
+                }, 1000);
+                return result.success;
+            }
+            catch (error) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.TRANSACTION_FAILED, 'Failed to encrypt balance', error);
+            }
+        }
+        /**
+         * Decrypt private balance to public
+         */
+        async decryptBalance(amount) {
+            this.ensureConnected();
+            try {
+                const result = await this.communicator.sendRequest('decrypt_balance', { amount });
+                // Refresh balance after decryption
+                setTimeout(() => {
+                    this.getBalance(true).catch(() => { });
+                }, 1000);
+                return result.success;
+            }
+            catch (error) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.TRANSACTION_FAILED, 'Failed to decrypt balance', error);
+            }
+        }
+        /**
+         * Send private transfer
+         */
+        async sendPrivateTransfer(transferData) {
+            this.ensureConnected();
+            try {
+                const result = await this.communicator.sendRequest('send_private_transfer', transferData);
+                // Refresh balance after transfer
+                if (result.success) {
+                    setTimeout(() => {
+                        this.getBalance(true).catch(() => { });
+                    }, 1000);
+                }
+                return result;
+            }
+            catch (error) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.TRANSACTION_FAILED, 'Failed to send private transfer', error);
+            }
+        }
+        /**
+         * Get pending private transfers
+         */
+        async getPendingPrivateTransfers() {
+            this.ensureConnected();
+            try {
+                const result = await this.communicator.sendRequest('get_pending_private_transfers');
+                return result;
+            }
+            catch (error) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.NETWORK_ERROR, 'Failed to get pending private transfers', error);
+            }
+        }
+        /**
+         * Claim private transfer
+         */
+        async claimPrivateTransfer(transferId) {
+            this.ensureConnected();
+            try {
+                const result = await this.communicator.sendRequest('claim_private_transfer', {
+                    transferId
+                });
+                // Refresh balance after claiming
+                if (result.success) {
+                    setTimeout(() => {
+                        this.getBalance(true).catch(() => { });
+                    }, 1000);
+                }
+                return result;
+            }
+            catch (error) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.TRANSACTION_FAILED, 'Failed to claim private transfer', error);
+            }
+        }
+        // ===================
+        // PRIVATE METHODS
+        // ===================
+        ensureInitialized() {
+            if (!this.isInitialized) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.UNKNOWN_ERROR, 'SDK not initialized. Call initialize() first.');
+            }
+        }
+        ensureConnected() {
+            this.ensureInitialized();
+            if (!this.connectionInfo.isConnected) {
+                throw new ZeroXIOWalletError(exports.ErrorCode.CONNECTION_REFUSED, 'Wallet not connected. Call connect() first.');
+            }
+        }
+        setupExtensionEventListeners() {
+            // Listen for extension events through the communicator
+            this.communicator.on('accountChanged', (event) => {
+                this.handleAccountChanged(event.data);
+            });
+            this.communicator.on('networkChanged', (event) => {
+                this.handleNetworkChanged(event.data);
+            });
+            this.communicator.on('balanceChanged', (event) => {
+                this.handleBalanceChanged(event.data);
+            });
+            this.communicator.on('extensionLocked', () => {
+                this.handleExtensionLocked();
+            });
+            this.communicator.on('extensionUnlocked', () => {
+                this.handleExtensionUnlocked();
+            });
+            this.communicator.on('transactionConfirmed', (event) => {
+                this.handleTransactionConfirmed(event.data);
+            });
+            this.logger.log('Extension event listeners setup complete');
+        }
+        /**
+         * Handle account changed event from extension
+         */
+        handleAccountChanged(data) {
+            const previousAddress = this.connectionInfo.address;
+            this.connectionInfo.address = data.address;
+            if (data.balance) {
+                this.connectionInfo.balance = data.balance;
+            }
+            const accountChangedEvent = {
+                previousAddress,
+                newAddress: data.address,
+                balance: data.balance
+            };
+            this.emit('accountChanged', accountChangedEvent);
+            this.logger.log('Account changed:', accountChangedEvent);
+        }
+        /**
+         * Handle network changed event from extension
+         */
+        handleNetworkChanged(data) {
+            const previousNetwork = this.connectionInfo.networkInfo;
+            this.connectionInfo.networkInfo = data.networkInfo;
+            const networkChangedEvent = {
+                previousNetwork,
+                newNetwork: data.networkInfo
+            };
+            this.emit('networkChanged', networkChangedEvent);
+            this.logger.log('Network changed:', networkChangedEvent);
+        }
+        /**
+         * Handle balance changed event from extension
+         */
+        handleBalanceChanged(data) {
+            const previousBalance = this.connectionInfo.balance;
+            this.connectionInfo.balance = data.balance;
+            const balanceChangedEvent = {
+                address: this.connectionInfo.address,
+                previousBalance,
+                newBalance: data.balance
+            };
+            this.emit('balanceChanged', balanceChangedEvent);
+            this.logger.log('Balance changed:', balanceChangedEvent);
+        }
+        /**
+         * Handle extension locked event
+         */
+        handleExtensionLocked() {
+            this.connectionInfo = { isConnected: false };
+            const disconnectEvent = {
+                reason: 'extension_locked'
+            };
+            this.emit('disconnect', disconnectEvent);
+            this.logger.log('Extension locked - disconnected');
+        }
+        /**
+         * Handle extension unlocked event
+         */
+        handleExtensionUnlocked() {
+            // Attempt to restore connection
+            this.getConnectionStatus().catch(() => {
+                this.logger.warn('Could not restore connection after unlock');
+            });
+            this.logger.log('Extension unlocked');
+        }
+        /**
+         * Handle transaction confirmed event
+         */
+        handleTransactionConfirmed(data) {
+            this.emit('transactionConfirmed', {
+                txHash: data.txHash,
+                transaction: data.transaction,
+                confirmations: data.confirmations
+            });
+            // Refresh balance after transaction confirmation
+            setTimeout(() => {
+                this.getBalance(true).catch(() => { });
+            }, 2000);
+            this.logger.log('Transaction confirmed:', data.txHash);
+        }
+        // ===================
+        // CLEANUP
+        // ===================
+        /**
+         * Clean up SDK resources
+         */
+        cleanup() {
+            this.communicator.cleanup();
+            this.removeAllListeners();
+            this.connectionInfo = { isConnected: false };
+            this.isInitialized = false;
+            this.logger.log('SDK cleanup complete');
+        }
+    }
+
+    var wallet = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        ZeroXIOWallet: ZeroXIOWallet
+    });
+
+    /**
+     * 0xio Wallet SDK - Main Entry Point
+     * Official SDK for integrating with 0xio Wallet Extension
+     *
+     * @example
+     * ```typescript
+     * import { ZeroXIOWallet } from '@0xgery/wallet-sdk';
+     *
+     * const wallet = new ZeroXIOWallet({
+     *   appName: 'My DApp',
+     *   appDescription: 'An awesome decentralized application',
+     *   requiredPermissions: ['read_balance', 'send_transactions']
+     * });
+     *
+     * await wallet.initialize();
+     * await wallet.connect();
+     *
+     * const balance = await wallet.getBalance();
+     * console.log('Balance:', balance.total, 'OCT');
+     * ```
+     */
+    // Main exports
+    // Version information
+    const SDK_VERSION = '2.1.1';
+    const SUPPORTED_EXTENSION_VERSIONS = ['2.0.1', '2.0.3', '2.0.4'];
+    // Quick setup function for simple use cases
+    async function createZeroXIOWallet(config) {
+        const { ZeroXIOWallet } = await Promise.resolve().then(function () { return wallet; });
+        const wallet$1 = new ZeroXIOWallet({
+            appName: config.appName,
+            appDescription: config.appDescription,
+            debug: config.debug || false
+        });
+        await wallet$1.initialize();
+        if (config.autoConnect) {
+            try {
+                await wallet$1.connect();
+            }
+            catch (error) {
+                if (config.debug) ;
+                // Don't throw - let the app handle connection manually
+            }
+        }
+        return wallet$1;
+    }
+    // Legacy alias for backward compatibility
+    const createOctraWallet = createZeroXIOWallet;
+    // Browser detection and compatibility check
+    function checkSDKCompatibility() {
+        const issues = [];
+        const recommendations = [];
+        // Basic browser support check
+        if (typeof window === 'undefined') {
+            issues.push('Window object not available');
+            recommendations.push('SDK must be used in a browser environment');
+        }
+        // Check for extension APIs
+        if (typeof window !== 'undefined') {
+            const win = window;
+            if (!win.chrome || !win.chrome.runtime) {
+                issues.push('Chrome extension APIs not available');
+                recommendations.push('This SDK requires a Chromium-based browser (Chrome, Edge, Brave, etc.)');
+            }
+        }
+        return {
+            compatible: issues.length === 0,
+            issues,
+            recommendations
+        };
+    }
+    // Development helpers
+    if (typeof window !== 'undefined') {
+        // Expose SDK version for debugging (support both old and new naming)
+        window.__OCTRA_SDK_VERSION__ = SDK_VERSION;
+        window.__ZEROXIO_SDK_VERSION__ = SDK_VERSION;
+        // Development mode detection
+        const isDevelopment = window.location.hostname === 'localhost' ||
+            window.location.hostname === '127.0.0.1' ||
+            window.location.hostname.includes('dev');
+        if (isDevelopment) {
+            // Set debug flag but don't automatically log
+            window.__OCTRA_SDK_DEBUG__ = true;
+            window.__ZEROXIO_SDK_DEBUG__ = true;
+            // Expose debugging utilities (new branding)
+            window.__ZEROXIO_SDK_UTILS__ = {
+                enableDebugMode: () => {
+                    window.__ZEROXIO_SDK_DEBUG__ = true;
+                    window.__OCTRA_SDK_DEBUG__ = true;
+                    console.log('[0xio SDK] Debug mode enabled');
+                },
+                disableDebugMode: () => {
+                    window.__ZEROXIO_SDK_DEBUG__ = false;
+                    window.__OCTRA_SDK_DEBUG__ = false;
+                    console.log('[0xio SDK] Debug mode disabled');
+                },
+                getSDKInfo: () => ({
+                    version: SDK_VERSION,
+                    supportedExtensions: SUPPORTED_EXTENSION_VERSIONS,
+                    debugMode: !!window.__ZEROXIO_SDK_DEBUG__,
+                    environment: isDevelopment ? 'development' : 'production'
+                }),
+                simulateExtensionEvent: (eventType, data) => {
+                    window.postMessage({
+                        source: '0xio-sdk-bridge',
+                        event: { type: eventType, data }
+                    }, '*');
+                    console.log('[0xio SDK] Simulated extension event:', eventType, data);
+                },
+                showWelcome: () => {
+                    console.log(`[0xio SDK] Development mode - SDK v${SDK_VERSION}`);
+                    console.log('[0xio SDK] Debug utilities available at window.__ZEROXIO_SDK_UTILS__');
+                }
+            };
+            // Legacy alias for backward compatibility
+            window.__OCTRA_SDK_UTILS__ = window.__ZEROXIO_SDK_UTILS__;
+            // Only show welcome message if specifically requested or on localhost
+            // if (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1') {
+            //   (window as any).__ZEROXIO_SDK_UTILS__.showWelcome();
+            // }
+        }
+    }
+
+    exports.DEFAULT_NETWORK_ID = DEFAULT_NETWORK_ID;
+    exports.EventEmitter = EventEmitter;
+    exports.ExtensionCommunicator = ExtensionCommunicator;
+    exports.NETWORKS = NETWORKS;
+    exports.SDK_CONFIG = SDK_CONFIG;
+    exports.SDK_VERSION = SDK_VERSION;
+    exports.SUPPORTED_EXTENSION_VERSIONS = SUPPORTED_EXTENSION_VERSIONS;
+    exports.ZeroXIOWallet = ZeroXIOWallet;
+    exports.ZeroXIOWalletError = ZeroXIOWalletError;
+    exports.checkBrowserSupport = checkBrowserSupport;
+    exports.checkSDKCompatibility = checkSDKCompatibility;
+    exports.createDefaultBalance = createDefaultBalance;
+    exports.createErrorMessage = createErrorMessage;
+    exports.createLogger = createLogger;
+    exports.createOctraWallet = createOctraWallet;
+    exports.createZeroXIOWallet = createZeroXIOWallet;
+    exports.delay = delay;
+    exports.formatAddress = formatAddress;
+    exports.formatOCT = formatOCT;
+    exports.formatTimestamp = formatTimestamp;
+    exports.formatTxHash = formatTxHash;
+    exports.formatZeroXIO = formatOCT;
+    exports.fromMicroOCT = fromMicroOCT;
+    exports.fromMicroZeroXIO = fromMicroOCT;
+    exports.generateMockData = generateMockData;
+    exports.getAllNetworks = getAllNetworks;
+    exports.getDefaultNetwork = getDefaultNetwork;
+    exports.getNetworkConfig = getNetworkConfig;
+    exports.isBrowser = isBrowser;
+    exports.isErrorType = isErrorType;
+    exports.isValidAddress = isValidAddress;
+    exports.isValidAmount = isValidAmount;
+    exports.isValidFeeLevel = isValidFeeLevel;
+    exports.isValidMessage = isValidMessage;
+    exports.isValidNetworkId = isValidNetworkId;
+    exports.retry = retry;
+    exports.toMicroOCT = toMicroOCT;
+    exports.toMicroZeroXIO = toMicroOCT;
+    exports.withTimeout = withTimeout;
+
+}));
+//# sourceMappingURL=index.umd.js.map