@arcadiasol/game-sdk 1.0.0 → 1.1.0

package/dist/esm/index.js

@@ -229,45 +229,61 @@ class MessageHandler {
  * 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;
     }
@@ -331,20 +347,22 @@ class WalletManager {
  * 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) {
@@ -355,47 +373,93 @@ class PaymentManager {
             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) {
@@ -407,34 +471,79 @@ class PaymentManager {
             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');
         }
     }
     /**
@@ -444,9 +553,180 @@ class PaymentManager {
         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();
     }
 }
 
@@ -459,6 +739,7 @@ class ArcadiaSDK {
      */
     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');
@@ -473,42 +754,73 @@ class ArcadiaSDK {
         // 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);
+            }
         }
     }
     /**
@@ -613,5 +925,5 @@ class ArcadiaSDK {
  */
 // Main SDK class
 
-export { ArcadiaSDK, ArcadiaSDKError, InvalidAmountError, InvalidConfigError, InvalidTokenError, NotInIframeError, PaymentFailedError, TimeoutError, WalletNotConnectedError, ArcadiaSDK as default };
+export { APIClient, ArcadiaSDK, ArcadiaSDKError, InvalidAmountError, InvalidConfigError, InvalidTokenError, NotInIframeError, PaymentFailedError, TimeoutError, WalletNotConnectedError, ArcadiaSDK as default };
 //# sourceMappingURL=index.js.map