@0xio/sdk 2.1.3

package/dist/index.js

@@ -0,0 +1,1745 @@
+'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.js.map