@arcadiasol/game-sdk 1.0.0 → 1.1.0

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

@@ -235,45 +235,61 @@
      * Wallet address management
      */
     class WalletManager {
-        constructor(messageHandler, isIframe) {
+        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
+         * Get wallet address from parent window (iframe) or API (non-iframe)
          */
         async getWalletAddress() {
-            if (!this.isIframe) {
-                throw new NotInIframeError();
-            }
-            try {
-                const response = await this.messageHandler.sendMessage(MessageType.GET_WALLET_ADDRESS);
-                this.walletAddress = response.walletAddress;
-                this.walletConnected = response.connected;
-                return this.walletAddress;
+            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;
+                }
             }
-            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 (!this.isIframe) {
-                return false;
-            }
             // If we have cached address, return true
             if (this.walletAddress) {
                 return true;
             }
-            // Otherwise, fetch from parent
+            // Otherwise, fetch from parent (iframe) or API (non-iframe)
             const address = await this.getWalletAddress();
             return address !== null;
         }
@@ -337,20 +353,22 @@
      * Payment processing
      */
     class PaymentManager {
-        constructor(gameId, isIframe, messageHandler, walletManager) {
+        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) {
+        async payToPlay(amount, token, txSignature) {
             this.validatePaymentParams(amount, token);
-            if (!this.isIframe) {
-                throw new NotInIframeError('payToPlay only works when the game is running in an Arcadia iframe');
-            }
             // Check wallet connection
             const isConnected = await this.walletManager.isWalletConnected();
             if (!isConnected) {
@@ -361,47 +379,93 @@
                 token,
                 type: 'pay_to_play',
                 gameId: this.gameId,
+                txSignature, // Optional for iframe mode, required for non-iframe
             };
-            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 (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,
+                    };
                 }
-                if (!response.amount || !response.token || !response.timestamp) {
-                    throw new PaymentFailedError('Payment succeeded but incomplete payment details received');
+                catch (error) {
+                    if (error instanceof PaymentFailedError || error instanceof WalletNotConnectedError) {
+                        throw error;
+                    }
+                    throw new PaymentFailedError(error instanceof Error ? error.message : 'Payment failed');
                 }
-                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;
+            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');
                 }
-                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) {
+        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');
             }
-            if (!this.isIframe) {
-                throw new NotInIframeError('purchaseItem only works when the game is running in an Arcadia iframe');
-            }
             // Check wallet connection
             const isConnected = await this.walletManager.isWalletConnected();
             if (!isConnected) {
@@ -413,34 +477,79 @@
                 type: 'in_game_purchase',
                 gameId: this.gameId,
                 itemId: itemId.trim(),
+                txSignature, // Optional for iframe mode, required for non-iframe
             };
-            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 (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,
+                    };
                 }
-                if (!response.amount || !response.token || !response.timestamp) {
-                    throw new PaymentFailedError('Purchase succeeded but incomplete payment details received');
+                catch (error) {
+                    if (error instanceof PaymentFailedError || error instanceof WalletNotConnectedError) {
+                        throw error;
+                    }
+                    throw new PaymentFailedError(error instanceof Error ? error.message : 'Purchase failed');
                 }
-                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;
+            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');
                 }
-                throw new PaymentFailedError(error instanceof Error ? error.message : 'Purchase failed');
             }
         }
         /**
@@ -450,9 +559,180 @@
             if (typeof amount !== 'number' || isNaN(amount) || amount <= 0) {
                 throw new InvalidAmountError();
             }
-            if (token !== 'SOL' && token !== 'USDC') {
+            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();
         }
     }
 
@@ -465,6 +745,7 @@
          */
         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');
@@ -479,42 +760,73 @@
             // Initialize message handler
             this.messageHandler = new MessageHandler(this.config.parentOrigin, this.config.timeout);
             // Initialize managers
-            this.walletManager = new WalletManager(this.messageHandler, this.isIframe);
-            this.paymentManager = new PaymentManager(this.config.gameId, this.isIframe, this.messageHandler, this.walletManager);
+            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
+         * Initialize SDK and request initialization data from parent (iframe) or API (non-iframe)
          */
         async init() {
             if (this.initialized) {
                 return; // Already initialized
             }
-            if (!this.isIframe) {
-                // Not in iframe - can't initialize
-                this.initialized = true;
-                return;
-            }
-            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);
+            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);
                 }
-                // 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);
+                }
             }
         }
         /**
@@ -619,6 +931,7 @@
      */
     // Main SDK class
 
+    exports.APIClient = APIClient;
     exports.ArcadiaSDK = ArcadiaSDK;
     exports.ArcadiaSDKError = ArcadiaSDKError;
     exports.InvalidAmountError = InvalidAmountError;