@arcadiasol/sdk 1.1.0

package/dist/esm/index.js

@@ -0,0 +1,929 @@
+/**
+ * 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
+
+export { APIClient, ArcadiaSDK, ArcadiaSDKError, InvalidAmountError, InvalidConfigError, InvalidTokenError, NotInIframeError, PaymentFailedError, TimeoutError, WalletNotConnectedError, ArcadiaSDK as default };
+//# sourceMappingURL=index.js.map