@arcadiasol/sdk 1.1.0

package/dist/umd/arcadia-game-sdk.js

@@ -0,0 +1,949 @@
+(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.ArcadiaGameSDK = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * Message types for postMessage communication
+     */
+    var MessageType;
+    (function (MessageType) {
+        // SDK → Parent
+        MessageType["INIT_REQUEST"] = "INIT_REQUEST";
+        MessageType["GET_WALLET_ADDRESS"] = "GET_WALLET_ADDRESS";
+        MessageType["PAYMENT_REQUEST"] = "PAYMENT_REQUEST";
+        MessageType["GAME_READY"] = "GAME_READY";
+        // Parent → SDK
+        MessageType["INIT"] = "INIT";
+        MessageType["WALLET_ADDRESS_RESPONSE"] = "WALLET_ADDRESS_RESPONSE";
+        MessageType["WALLET_UPDATE"] = "WALLET_UPDATE";
+        MessageType["PAYMENT_RESPONSE"] = "PAYMENT_RESPONSE";
+    })(MessageType || (MessageType = {}));
+
+    /**
+     * Base error class for all SDK errors
+     */
+    class ArcadiaSDKError extends Error {
+        constructor(message, code) {
+            super(message);
+            this.code = code;
+            this.name = 'ArcadiaSDKError';
+            Object.setPrototypeOf(this, ArcadiaSDKError.prototype);
+        }
+    }
+    /**
+     * Error thrown when wallet is not connected
+     */
+    class WalletNotConnectedError extends ArcadiaSDKError {
+        constructor(message = 'Wallet is not connected. Please connect your wallet in Arcadia.') {
+            super(message, 'WALLET_NOT_CONNECTED');
+            this.name = 'WalletNotConnectedError';
+            Object.setPrototypeOf(this, WalletNotConnectedError.prototype);
+        }
+    }
+    /**
+     * Error thrown when payment fails
+     */
+    class PaymentFailedError extends ArcadiaSDKError {
+        constructor(message = 'Payment failed', txSignature) {
+            super(message, 'PAYMENT_FAILED');
+            this.txSignature = txSignature;
+            this.name = 'PaymentFailedError';
+            Object.setPrototypeOf(this, PaymentFailedError.prototype);
+        }
+    }
+    /**
+     * Error thrown when request times out
+     */
+    class TimeoutError extends ArcadiaSDKError {
+        constructor(message = 'Request timed out. Please try again.') {
+            super(message, 'TIMEOUT');
+            this.name = 'TimeoutError';
+            Object.setPrototypeOf(this, TimeoutError.prototype);
+        }
+    }
+    /**
+     * Error thrown when SDK configuration is invalid
+     */
+    class InvalidConfigError extends ArcadiaSDKError {
+        constructor(message = 'Invalid SDK configuration') {
+            super(message, 'INVALID_CONFIG');
+            this.name = 'InvalidConfigError';
+            Object.setPrototypeOf(this, InvalidConfigError.prototype);
+        }
+    }
+    /**
+     * Error thrown when SDK is not running in iframe
+     */
+    class NotInIframeError extends ArcadiaSDKError {
+        constructor(message = 'This function only works when the game is running in an Arcadia iframe') {
+            super(message, 'NOT_IN_IFRAME');
+            this.name = 'NotInIframeError';
+            Object.setPrototypeOf(this, NotInIframeError.prototype);
+        }
+    }
+    /**
+     * Error thrown when invalid amount is provided
+     */
+    class InvalidAmountError extends ArcadiaSDKError {
+        constructor(message = 'Invalid payment amount. Amount must be greater than 0.') {
+            super(message, 'INVALID_AMOUNT');
+            this.name = 'InvalidAmountError';
+            Object.setPrototypeOf(this, InvalidAmountError.prototype);
+        }
+    }
+    /**
+     * Error thrown when invalid token is provided
+     */
+    class InvalidTokenError extends ArcadiaSDKError {
+        constructor(message = "Invalid token. Must be 'SOL' or 'USDC'.") {
+            super(message, 'INVALID_TOKEN');
+            this.name = 'InvalidTokenError';
+            Object.setPrototypeOf(this, InvalidTokenError.prototype);
+        }
+    }
+
+    /**
+     * Handles postMessage communication with parent window
+     */
+    class MessageHandler {
+        constructor(parentOrigin = '*', timeout = 30000) {
+            this.messageId = 0;
+            this.pendingRequests = new Map();
+            this.messageListener = null;
+            this.parentOrigin = parentOrigin;
+            this.timeout = timeout;
+        }
+        /**
+         * Initialize message listener
+         */
+        init() {
+            if (this.messageListener) {
+                return; // Already initialized
+            }
+            this.messageListener = (event) => {
+                this.handleMessage(event);
+            };
+            window.addEventListener('message', this.messageListener);
+        }
+        /**
+         * Cleanup message listener
+         */
+        destroy() {
+            if (this.messageListener) {
+                window.removeEventListener('message', this.messageListener);
+                this.messageListener = null;
+            }
+            // Clear all pending requests
+            this.pendingRequests.forEach((request) => {
+                clearTimeout(request.timeout);
+                request.reject(new Error('Message handler destroyed'));
+            });
+            this.pendingRequests.clear();
+        }
+        /**
+         * Send message to parent window and wait for response
+         */
+        sendMessage(type, payload) {
+            return new Promise((resolve, reject) => {
+                const id = ++this.messageId;
+                // Set up timeout
+                const timeout = setTimeout(() => {
+                    this.pendingRequests.delete(id);
+                    reject(new TimeoutError(`Request ${type} timed out after ${this.timeout}ms`));
+                }, this.timeout);
+                // Store request
+                this.pendingRequests.set(id, {
+                    resolve: (value) => {
+                        clearTimeout(timeout);
+                        resolve(value);
+                    },
+                    reject: (error) => {
+                        clearTimeout(timeout);
+                        reject(error);
+                    },
+                    timeout,
+                });
+                // Send message to parent
+                const message = {
+                    type,
+                    id,
+                    payload,
+                };
+                if (window.parent) {
+                    window.parent.postMessage(message, this.parentOrigin);
+                }
+                else {
+                    clearTimeout(timeout);
+                    this.pendingRequests.delete(id);
+                    reject(new Error('No parent window found'));
+                }
+            });
+        }
+        /**
+         * Handle incoming messages from parent
+         */
+        handleMessage(event) {
+            // Validate origin if specified
+            if (this.parentOrigin !== '*' && event.origin !== this.parentOrigin) {
+                return; // Ignore messages from unauthorized origins
+            }
+            const message = event.data;
+            // Handle response messages (have ID)
+            if (message.id !== undefined) {
+                const request = this.pendingRequests.get(message.id);
+                if (request) {
+                    this.pendingRequests.delete(message.id);
+                    if (message.type === MessageType.PAYMENT_RESPONSE) {
+                        const response = message.payload;
+                        if (response.success) {
+                            request.resolve(response);
+                        }
+                        else {
+                            request.reject(new Error(response.error || 'Payment failed'));
+                        }
+                    }
+                    else if (message.type === MessageType.WALLET_ADDRESS_RESPONSE) {
+                        request.resolve(message.payload);
+                    }
+                    else if (message.type === MessageType.INIT) {
+                        request.resolve(message.payload);
+                    }
+                    else {
+                        // Generic response - resolve with payload
+                        request.resolve(message.payload);
+                    }
+                }
+            }
+        }
+        /**
+         * Send one-way message (no response expected)
+         */
+        sendOneWay(type, payload) {
+            const message = {
+                type,
+                payload,
+            };
+            if (window.parent) {
+                window.parent.postMessage(message, this.parentOrigin);
+            }
+        }
+    }
+
+    /**
+     * Wallet address management
+     */
+    class WalletManager {
+        constructor(messageHandler, isIframe, apiClient) {
+            this.walletAddress = null;
+            this.walletConnected = false;
+            this.apiClient = null;
+            this.walletChangeCallbacks = [];
+            this.messageHandler = messageHandler;
+            this.isIframe = isIframe;
+            this.apiClient = apiClient || null;
+        }
+        /**
+         * Get wallet address from parent window (iframe) or API (non-iframe)
+         */
+        async getWalletAddress() {
+            if (this.isIframe) {
+                // Iframe mode: use postMessage
+                try {
+                    const response = await this.messageHandler.sendMessage(MessageType.GET_WALLET_ADDRESS);
+                    this.walletAddress = response.walletAddress;
+                    this.walletConnected = response.connected;
+                    return this.walletAddress;
+                }
+                catch (error) {
+                    // If request fails, assume wallet not connected
+                    this.walletAddress = null;
+                    this.walletConnected = false;
+                    return null;
+                }
+            }
+            else {
+                // Non-iframe mode: use API
+                if (!this.apiClient) {
+                    throw new Error('API client not initialized. Ensure apiBaseURL is configured in SDK config.');
+                }
+                try {
+                    const response = await this.apiClient.getWalletAddress();
+                    this.walletAddress = response.walletAddress;
+                    this.walletConnected = response.connected;
+                    return this.walletAddress;
+                }
+                catch (error) {
+                    this.walletAddress = null;
+                    this.walletConnected = false;
+                    return null;
+                }
+            }
+        }
+        /**
+         * Check if wallet is connected
+         */
+        async isWalletConnected() {
+            // If we have cached address, return true
+            if (this.walletAddress) {
+                return true;
+            }
+            // Otherwise, fetch from parent (iframe) or API (non-iframe)
+            const address = await this.getWalletAddress();
+            return address !== null;
+        }
+        /**
+         * Listen for wallet connection changes
+         */
+        onWalletChange(callback) {
+            this.walletChangeCallbacks.push(callback);
+        }
+        /**
+         * Remove wallet change listener
+         */
+        offWalletChange(callback) {
+            const index = this.walletChangeCallbacks.indexOf(callback);
+            if (index > -1) {
+                this.walletChangeCallbacks.splice(index, 1);
+            }
+        }
+        /**
+         * Update wallet status (called by SDK when receiving WALLET_UPDATE message)
+         */
+        updateWalletStatus(walletInfo) {
+            const oldAddress = this.walletAddress;
+            const oldConnected = this.walletConnected;
+            this.walletAddress = walletInfo.address;
+            this.walletConnected = walletInfo.connected;
+            // Notify callbacks if status changed
+            if (oldAddress !== this.walletAddress || oldConnected !== this.walletConnected) {
+                this.walletChangeCallbacks.forEach((callback) => {
+                    try {
+                        callback(this.walletConnected, this.walletAddress);
+                    }
+                    catch (error) {
+                        console.error('Error in wallet change callback:', error);
+                    }
+                });
+            }
+        }
+        /**
+         * Get current cached wallet address (without fetching)
+         */
+        getCachedWalletAddress() {
+            return this.walletAddress;
+        }
+        /**
+         * Get current cached connection status (without fetching)
+         */
+        getCachedConnectionStatus() {
+            return this.walletConnected;
+        }
+        /**
+         * Clear cached wallet data
+         */
+        clearCache() {
+            this.walletAddress = null;
+            this.walletConnected = false;
+        }
+    }
+
+    /**
+     * Payment processing
+     */
+    class PaymentManager {
+        constructor(gameId, isIframe, messageHandler, walletManager, apiClient) {
+            this.apiClient = null;
+            this.gameId = gameId;
+            this.isIframe = isIframe;
+            this.messageHandler = messageHandler;
+            this.walletManager = walletManager;
+            this.apiClient = apiClient || null;
+        }
+        /**
+         * Pay to play - one-time payment to access game
+         * @param amount - Payment amount
+         * @param token - Token type: 'SOL', 'USDC', or custom token symbol/mint address
+         * @param txSignature - Transaction signature (required for non-iframe mode)
+         */
+        async payToPlay(amount, token, txSignature) {
+            this.validatePaymentParams(amount, token);
+            // Check wallet connection
+            const isConnected = await this.walletManager.isWalletConnected();
+            if (!isConnected) {
+                throw new WalletNotConnectedError();
+            }
+            const request = {
+                amount,
+                token,
+                type: 'pay_to_play',
+                gameId: this.gameId,
+                txSignature, // Optional for iframe mode, required for non-iframe
+            };
+            if (this.isIframe) {
+                // Iframe mode: use postMessage
+                try {
+                    const response = await this.messageHandler.sendMessage(MessageType.PAYMENT_REQUEST, request);
+                    if (!response.success) {
+                        throw new PaymentFailedError(response.error || 'Payment failed', response.txSignature);
+                    }
+                    if (!response.txSignature) {
+                        throw new PaymentFailedError('Payment succeeded but no transaction signature received');
+                    }
+                    if (!response.amount || !response.token || !response.timestamp) {
+                        throw new PaymentFailedError('Payment succeeded but incomplete payment details received');
+                    }
+                    return {
+                        success: true,
+                        txSignature: response.txSignature,
+                        amount: response.amount,
+                        token: response.token,
+                        timestamp: response.timestamp,
+                        purchaseId: response.purchaseId,
+                        platformFee: response.platformFee,
+                        developerAmount: response.developerAmount,
+                    };
+                }
+                catch (error) {
+                    if (error instanceof PaymentFailedError || error instanceof WalletNotConnectedError) {
+                        throw error;
+                    }
+                    throw new PaymentFailedError(error instanceof Error ? error.message : 'Payment failed');
+                }
+            }
+            else {
+                // Non-iframe mode: use API
+                if (!this.apiClient) {
+                    throw new Error('API client not initialized. Ensure apiBaseURL is configured in SDK config.');
+                }
+                if (!txSignature) {
+                    throw new PaymentFailedError('Transaction signature is required for non-iframe payments. ' +
+                        'Please sign the transaction first and provide the signature.');
+                }
+                try {
+                    const response = await this.apiClient.sendPaymentRequest(this.gameId, {
+                        ...request,
+                        txSignature,
+                    });
+                    if (!response.success) {
+                        throw new PaymentFailedError(response.error || 'Payment failed', response.txSignature);
+                    }
+                    if (!response.txSignature) {
+                        throw new PaymentFailedError('Payment succeeded but no transaction signature received');
+                    }
+                    if (!response.amount || !response.token || !response.timestamp) {
+                        throw new PaymentFailedError('Payment succeeded but incomplete payment details received');
+                    }
+                    return {
+                        success: true,
+                        txSignature: response.txSignature,
+                        amount: response.amount,
+                        token: response.token,
+                        timestamp: response.timestamp,
+                        purchaseId: response.purchaseId,
+                        platformFee: response.platformFee,
+                        developerAmount: response.developerAmount,
+                    };
+                }
+                catch (error) {
+                    if (error instanceof PaymentFailedError || error instanceof WalletNotConnectedError) {
+                        throw error;
+                    }
+                    throw new PaymentFailedError(error instanceof Error ? error.message : 'Payment failed');
+                }
+            }
+        }
+        /**
+         * Purchase in-game item
+         * @param itemId - Item identifier
+         * @param amount - Payment amount
+         * @param token - Token type: 'SOL', 'USDC', or custom token symbol/mint address
+         * @param txSignature - Transaction signature (required for non-iframe mode)
+         */
+        async purchaseItem(itemId, amount, token, txSignature) {
+            this.validatePaymentParams(amount, token);
+            if (!itemId || typeof itemId !== 'string' || itemId.trim().length === 0) {
+                throw new Error('Item ID is required and must be a non-empty string');
+            }
+            // Check wallet connection
+            const isConnected = await this.walletManager.isWalletConnected();
+            if (!isConnected) {
+                throw new WalletNotConnectedError();
+            }
+            const request = {
+                amount,
+                token,
+                type: 'in_game_purchase',
+                gameId: this.gameId,
+                itemId: itemId.trim(),
+                txSignature, // Optional for iframe mode, required for non-iframe
+            };
+            if (this.isIframe) {
+                // Iframe mode: use postMessage
+                try {
+                    const response = await this.messageHandler.sendMessage(MessageType.PAYMENT_REQUEST, request);
+                    if (!response.success) {
+                        throw new PaymentFailedError(response.error || 'Purchase failed', response.txSignature);
+                    }
+                    if (!response.txSignature) {
+                        throw new PaymentFailedError('Purchase succeeded but no transaction signature received');
+                    }
+                    if (!response.amount || !response.token || !response.timestamp) {
+                        throw new PaymentFailedError('Purchase succeeded but incomplete payment details received');
+                    }
+                    return {
+                        success: true,
+                        txSignature: response.txSignature,
+                        amount: response.amount,
+                        token: response.token,
+                        timestamp: response.timestamp,
+                        purchaseId: response.purchaseId,
+                        platformFee: response.platformFee,
+                        developerAmount: response.developerAmount,
+                    };
+                }
+                catch (error) {
+                    if (error instanceof PaymentFailedError || error instanceof WalletNotConnectedError) {
+                        throw error;
+                    }
+                    throw new PaymentFailedError(error instanceof Error ? error.message : 'Purchase failed');
+                }
+            }
+            else {
+                // Non-iframe mode: use API
+                if (!this.apiClient) {
+                    throw new Error('API client not initialized. Ensure apiBaseURL is configured in SDK config.');
+                }
+                if (!txSignature) {
+                    throw new PaymentFailedError('Transaction signature is required for non-iframe purchases. ' +
+                        'Please sign the transaction first and provide the signature.');
+                }
+                try {
+                    const response = await this.apiClient.sendPaymentRequest(this.gameId, {
+                        ...request,
+                        txSignature,
+                    });
+                    if (!response.success) {
+                        throw new PaymentFailedError(response.error || 'Purchase failed', response.txSignature);
+                    }
+                    if (!response.txSignature) {
+                        throw new PaymentFailedError('Purchase succeeded but no transaction signature received');
+                    }
+                    if (!response.amount || !response.token || !response.timestamp) {
+                        throw new PaymentFailedError('Purchase succeeded but incomplete payment details received');
+                    }
+                    return {
+                        success: true,
+                        txSignature: response.txSignature,
+                        amount: response.amount,
+                        token: response.token,
+                        timestamp: response.timestamp,
+                        purchaseId: response.purchaseId,
+                        platformFee: response.platformFee,
+                        developerAmount: response.developerAmount,
+                    };
+                }
+                catch (error) {
+                    if (error instanceof PaymentFailedError || error instanceof WalletNotConnectedError) {
+                        throw error;
+                    }
+                    throw new PaymentFailedError(error instanceof Error ? error.message : 'Purchase failed');
+                }
+            }
+        }
+        /**
+         * Validate payment parameters
+         */
+        validatePaymentParams(amount, token) {
+            if (typeof amount !== 'number' || isNaN(amount) || amount <= 0) {
+                throw new InvalidAmountError();
+            }
+            if (!token || typeof token !== 'string' || token.trim().length === 0) {
+                throw new InvalidTokenError();
+            }
+            // SOL and USDC are always valid
+            // Custom tokens will be validated by the backend
+        }
+    }
+
+    /**
+     * API Client for non-iframe environments
+     * Handles direct REST API calls when SDK is not running in iframe
+     */
+    class APIClient {
+        constructor(baseURL) {
+            this.authToken = null;
+            this.walletAddress = null;
+            // Use provided base URL or detect from environment
+            this.baseURL = baseURL || this.detectBaseURL();
+        }
+        /**
+         * Detect Arcadia base URL from environment or use default
+         */
+        detectBaseURL() {
+            // Check for explicit base URL in config
+            if (typeof window !== 'undefined' && window.ARCADIA_API_URL) {
+                return window.ARCADIA_API_URL;
+            }
+            // Try to detect from current page (if game is hosted on Arcadia subdomain)
+            if (typeof window !== 'undefined') {
+                const hostname = window.location.hostname;
+                // If on arcadia.com or subdomain, use same origin
+                if (hostname.includes('arcadia')) {
+                    return `${window.location.protocol}//${hostname}`;
+                }
+            }
+            // Default fallback (should be configured by developer)
+            return 'https://arcadia.com';
+        }
+        /**
+         * Set authentication token (from wallet authentication)
+         */
+        setAuthToken(token) {
+            this.authToken = token;
+        }
+        /**
+         * Set wallet address (for wallet-based auth)
+         */
+        setWalletAddress(address) {
+            this.walletAddress = address;
+        }
+        /**
+         * Authenticate with wallet
+         * Returns auth token for subsequent API calls
+         */
+        async authenticateWithWallet(walletAddress, signature, message) {
+            const response = await this.request('/api/auth/wallet/connect', {
+                method: 'POST',
+                body: {
+                    walletAddress,
+                    signature,
+                    message,
+                },
+            });
+            // Store auth token from response
+            // Note: You may need to extract token from response based on your auth implementation
+            if (response.token) {
+                this.authToken = response.token;
+            }
+            return response;
+        }
+        /**
+         * Get wallet address (for non-iframe)
+         * Requires authentication
+         */
+        async getWalletAddress() {
+            if (!this.authToken && !this.walletAddress) {
+                return {
+                    walletAddress: null,
+                    connected: false,
+                };
+            }
+            // If we have wallet address cached, return it
+            if (this.walletAddress) {
+                return {
+                    walletAddress: this.walletAddress,
+                    connected: true,
+                };
+            }
+            // Otherwise, fetch from profile endpoint
+            try {
+                const profile = await this.request('/api/profile', {
+                    method: 'GET',
+                });
+                if (profile?.walletAddress) {
+                    this.walletAddress = profile.walletAddress;
+                    return {
+                        walletAddress: profile.walletAddress,
+                        connected: true,
+                    };
+                }
+            }
+            catch (error) {
+                console.warn('Failed to fetch wallet address:', error);
+            }
+            return {
+                walletAddress: null,
+                connected: false,
+            };
+        }
+        /**
+         * Send payment request via API
+         */
+        async sendPaymentRequest(gameId, request) {
+            const endpoint = request.type === 'pay_to_play'
+                ? `/api/games/${gameId}/pay-to-play`
+                : `/api/games/${gameId}/purchase-item`;
+            return await this.request(endpoint, {
+                method: 'POST',
+                body: {
+                    amount: request.amount,
+                    token: request.token,
+                    txSignature: request.txSignature, // App must provide this
+                    itemId: request.itemId,
+                },
+            });
+        }
+        /**
+         * Update playtime/stats
+         */
+        async updatePlaytime(gameId, playtimeHours, status) {
+            await this.request('/api/library', {
+                method: 'POST',
+                body: {
+                    gameId,
+                    playtimeHours,
+                    status: status || 'playing',
+                },
+            });
+        }
+        /**
+         * Update online status
+         */
+        async updateOnlineStatus(isOnline, gameId) {
+            await this.request('/api/online-status', {
+                method: 'POST',
+                body: {
+                    isOnline,
+                    gameId,
+                },
+            });
+        }
+        /**
+         * Generic request method
+         */
+        async request(endpoint, options = {}) {
+            const url = `${this.baseURL}${endpoint}`;
+            const headers = {
+                'Content-Type': 'application/json',
+                ...options.headers,
+            };
+            // Add auth token if available
+            if (this.authToken) {
+                headers['Authorization'] = `Bearer ${this.authToken}`;
+            }
+            const response = await fetch(url, {
+                method: options.method || 'GET',
+                headers,
+                body: options.body ? JSON.stringify(options.body) : undefined,
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({ error: 'Request failed' }));
+                throw new Error(error.error || `Request failed with status ${response.status}`);
+            }
+            return await response.json();
+        }
+    }
+
+    /**
+     * Main Arcadia Game SDK class
+     */
+    class ArcadiaSDK {
+        /**
+         * Create new SDK instance
+         */
+        constructor(config) {
+            this.initialized = false;
+            this.apiClient = null;
+            // Validate config
+            if (!config || !config.gameId || typeof config.gameId !== 'string' || config.gameId.trim().length === 0) {
+                throw new InvalidConfigError('gameId is required and must be a non-empty string');
+            }
+            this.config = {
+                gameId: config.gameId.trim(),
+                parentOrigin: config.parentOrigin || '*',
+                timeout: config.timeout || 30000,
+            };
+            // Detect iframe environment
+            this.isIframe = typeof window !== 'undefined' && window.self !== window.top;
+            // Initialize message handler
+            this.messageHandler = new MessageHandler(this.config.parentOrigin, this.config.timeout);
+            // Initialize managers
+            this.walletManager = new WalletManager(this.messageHandler, this.isIframe, this.apiClient);
+            this.paymentManager = new PaymentManager(this.config.gameId, this.isIframe, this.messageHandler, this.walletManager, this.apiClient);
+            // Set up message listener if in iframe
+            if (this.isIframe) {
+                this.messageHandler.init();
+                this.setupMessageListener();
+            }
+            else {
+                // Initialize API client for non-iframe environments
+                this.apiClient = new APIClient(this.config.apiBaseURL);
+                // Set auth token if provided
+                if (this.config.authToken) {
+                    this.apiClient.setAuthToken(this.config.authToken);
+                }
+                // Set wallet address if provided
+                if (this.config.walletAddress) {
+                    this.apiClient.setWalletAddress(this.config.walletAddress);
+                }
+            }
+        }
+        /**
+         * Initialize SDK and request initialization data from parent (iframe) or API (non-iframe)
+         */
+        async init() {
+            if (this.initialized) {
+                return; // Already initialized
+            }
+            if (this.isIframe) {
+                // Iframe mode: use postMessage
+                try {
+                    // Request initialization from parent
+                    const initData = await this.messageHandler.sendMessage(MessageType.INIT_REQUEST);
+                    // Update wallet status from init data
+                    if (initData.wallet) {
+                        this.walletManager.updateWalletStatus(initData.wallet);
+                    }
+                    // Notify parent that game is ready
+                    this.messageHandler.sendOneWay(MessageType.GAME_READY);
+                    this.initialized = true;
+                }
+                catch (error) {
+                    // Initialization failed, but SDK can still be used
+                    // Wallet functions will fetch on demand
+                    this.initialized = true;
+                    console.warn('SDK initialization failed:', error);
+                }
+            }
+            else {
+                // Non-iframe mode: use API
+                if (!this.apiClient) {
+                    throw new Error('API client not initialized. Ensure apiBaseURL is configured.');
+                }
+                try {
+                    // Fetch wallet address from API
+                    const walletResponse = await this.apiClient.getWalletAddress();
+                    // Update wallet manager with API response
+                    this.walletManager.updateWalletStatus({
+                        connected: walletResponse.connected,
+                        address: walletResponse.walletAddress,
+                    });
+                    this.initialized = true;
+                }
+                catch (error) {
+                    // Initialization failed, but SDK can still be used
+                    this.initialized = true;
+                    console.warn('SDK API initialization failed:', error);
+                }
+            }
+        }
+        /**
+         * Get wallet address - use this as user identifier
+         * Games should link all save data to this wallet address
+         * Returns null if wallet not connected
+         */
+        async getWalletAddress() {
+            return this.walletManager.getWalletAddress();
+        }
+        /**
+         * Check if wallet is connected
+         */
+        async isWalletConnected() {
+            return this.walletManager.isWalletConnected();
+        }
+        /**
+         * Listen for wallet connection changes
+         */
+        onWalletChange(callback) {
+            this.walletManager.onWalletChange(callback);
+        }
+        /**
+         * Remove wallet change listener
+         */
+        offWalletChange(callback) {
+            this.walletManager.offWalletChange(callback);
+        }
+        /**
+         * Payment methods
+         */
+        get payment() {
+            return {
+                /**
+                 * Pay to play - one-time payment to start/access game
+                 */
+                payToPlay: (amount, token) => {
+                    return this.paymentManager.payToPlay(amount, token);
+                },
+                /**
+                 * In-game purchase - buy items, upgrades, etc.
+                 */
+                purchaseItem: (itemId, amount, token) => {
+                    return this.paymentManager.purchaseItem(itemId, amount, token);
+                },
+            };
+        }
+        /**
+         * Get SDK configuration
+         */
+        getConfig() {
+            return { ...this.config };
+        }
+        /**
+         * Check if SDK is running in iframe
+         */
+        isInIframe() {
+            return this.isIframe;
+        }
+        /**
+         * Check if SDK is initialized
+         */
+        isInitialized() {
+            return this.initialized;
+        }
+        /**
+         * Cleanup SDK resources
+         */
+        destroy() {
+            this.messageHandler.destroy();
+            this.walletManager.clearCache();
+            this.initialized = false;
+        }
+        /**
+         * Set up message listener for wallet updates
+         */
+        setupMessageListener() {
+            // Additional listener for wallet updates (not request/response)
+            const listener = (event) => {
+                // Validate origin if specified
+                if (this.config.parentOrigin !== '*' && event.origin !== this.config.parentOrigin) {
+                    return;
+                }
+                const message = event.data;
+                // Handle wallet update messages
+                if (message.type === MessageType.WALLET_UPDATE && message.payload) {
+                    const walletInfo = message.payload;
+                    this.walletManager.updateWalletStatus(walletInfo);
+                }
+            };
+            window.addEventListener('message', listener);
+            // Store listener for cleanup (though SDK doesn't typically need cleanup)
+            // This is handled by messageHandler.destroy()
+        }
+    }
+
+    /**
+     * Arcadia Game SDK
+     *
+     * SDK for integrating Arcadia wallet and payment features into Web3 games.
+     * Works in iframe environments by communicating with parent window via postMessage.
+     */
+    // Main SDK class
+
+    exports.APIClient = APIClient;
+    exports.ArcadiaSDK = ArcadiaSDK;
+    exports.ArcadiaSDKError = ArcadiaSDKError;
+    exports.InvalidAmountError = InvalidAmountError;
+    exports.InvalidConfigError = InvalidConfigError;
+    exports.InvalidTokenError = InvalidTokenError;
+    exports.NotInIframeError = NotInIframeError;
+    exports.PaymentFailedError = PaymentFailedError;
+    exports.TimeoutError = TimeoutError;
+    exports.WalletNotConnectedError = WalletNotConnectedError;
+    exports.default = ArcadiaSDK;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=arcadia-game-sdk.js.map