@pooflabs/web 0.0.92 → 0.0.94

package/dist/{index-6iINLG88.esm.js → index-Cnx5UBPU.esm.js}

@@ -1,5 +1,5 @@
 import globalAxios from 'axios';
-import { PublicKey, SystemProgram, TransactionInstruction, ComputeBudgetProgram, Keypair, VersionedTransaction, TransactionMessage, Transaction, Connection, VersionedMessage } from '@solana/web3.js';
+import { PublicKey, SystemProgram, TransactionInstruction, Connection, VersionedTransaction, ComputeBudgetProgram, Keypair, TransactionMessage, Transaction, VersionedMessage } from '@solana/web3.js';
 import * as anchor from '@coral-xyz/anchor';
 import { Program } from '@coral-xyz/anchor';
 import * as React$2 from 'react';
@@ -6683,7 +6683,14 @@ async function createSessionWithPrivy(authToken, address, privyIdToken) {
     const appId = config.appId;
     const response = await client.post('/session', {
         appId,
-        authMethod: config.authMethod,
+        // createSessionWithPrivy is, by definition, the Privy session path, so the
+        // server must receive authMethod:'privy' (its branch validates authToken+
+        // idToken+appId). Do NOT read config.authMethod here: on a Phantom-primary app
+        // with the staged Privy email swap, config.authMethod is still 'phantom' at this
+        // point (commitPrivy runs after login() resolves), which routes the request to
+        // the signature/message branch and fails. Hardcoding 'privy' also correctly
+        // covers 'privy-expo', which the backend expects mapped to 'privy'.
+        authMethod: 'privy',
         authToken,
         idToken: privyIdToken,
         address
@@ -9940,6 +9947,14 @@ async function updateIdTokenAndAccessToken(idToken, accessToken, isServer = fals
     await WebSessionManager.updateIdTokenAndAccessToken(idToken, accessToken);
 }
 
+var utils = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	createAuthHeader: createAuthHeader,
+	getIdToken: getIdToken$1,
+	getRefreshToken: getRefreshToken,
+	updateIdTokenAndAccessToken: updateIdTokenAndAccessToken
+});
+
 const apiClient = globalAxios.create();
 axiosRetry(apiClient, {
     retries: 2,
@@ -10367,7 +10382,7 @@ async function get(path, opts = {}) {
                 // For realtime chains, prefer WebSocket reads (lower latency, already connected)
                 const config = await getConfig();
                 const pathIsDocument = normalizedPath.split("/").length % 2 === 0;
-                if (((_a = config.chain) === null || _a === void 0 ? void 0 : _a.startsWith('realtime_')) && !config.isServer && !opts.prompt && !opts.shape && !opts.cursor) {
+                if (((_a = config.chain) === null || _a === void 0 ? void 0 : _a.startsWith('realtime_')) && !config.isServer && !opts.prompt && !opts.shape && !opts.cursor && !opts.includeSubPaths) {
                     try {
                         const { wsGet, wsQuery, hasActiveConnection } = await Promise.resolve().then(function () { return subscriptionV2; });
                         if (hasActiveConnection()) {
@@ -10598,7 +10613,7 @@ async function set(path, document, options) {
     return result;
 }
 async function setMany(many, options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     // Returns the data that was set, or undefined if the document was already set.
     try {
         const config = await getConfig();
@@ -10641,12 +10656,24 @@ async function setMany(many, options) {
                 try {
                     const { wsSet, hasActiveConnection } = await Promise.resolve().then(function () { return subscriptionV2; });
                     if (hasActiveConnection()) {
+                        // Connection is active — send via WS. If this throws, the write
+                        // may have been applied server-side (ack lost). Do NOT fall through
+                        // to HTTP, as that would double-apply non-idempotent ops (Increment).
                         const wsResult = await wsSet(documents);
-                        // Normalize to same shape as HTTP 200 response so downstream handling is identical
                         setResponse = { data: wsResult, status: 200 };
                     }
                 }
-                catch ( /* fall through to HTTP */_j) { /* fall through to HTTP */ }
+                catch (wsError) {
+                    // Only fall through to HTTP if the request was never sent (connection not available).
+                    // If the request was sent and ack was lost (timeout), the server may have
+                    // applied it — re-sending via HTTP risks double-write for non-idempotent ops.
+                    const msg = (_d = wsError === null || wsError === void 0 ? void 0 : wsError.message) !== null && _d !== void 0 ? _d : '';
+                    const neverSent = msg.includes('not available') || msg.includes('connection timeout');
+                    if (!neverSent) {
+                        throw wsError;
+                    }
+                    // Safe to retry via HTTP — request was never sent
+                }
             }
             if (!setResponse) {
                 setResponse = await makeApiRequest('PUT', `items`, { documents }, options === null || options === void 0 ? void 0 : options._overrides);
@@ -10654,9 +10681,9 @@ async function setMany(many, options) {
         }
         catch (error) {
             if ((error === null || error === void 0 ? void 0 : error.statusCode) === 402 && (error === null || error === void 0 ? void 0 : error.error) === 'INSUFFICIENT_BALANCE') {
-                const deficitLamports = Number((_d = error.deficitLamports) !== null && _d !== void 0 ? _d : 0);
-                const deficitSol = Number((_e = error.deficitSol) !== null && _e !== void 0 ? _e : deficitLamports / 1000000000);
-                throw new InsufficientBalanceError(String((_f = error.address) !== null && _f !== void 0 ? _f : ''), Number((_g = error.balanceLamports) !== null && _g !== void 0 ? _g : 0), Number((_h = error.estimatedCostLamports) !== null && _h !== void 0 ? _h : 0), deficitLamports, deficitSol);
+                const deficitLamports = Number((_e = error.deficitLamports) !== null && _e !== void 0 ? _e : 0);
+                const deficitSol = Number((_f = error.deficitSol) !== null && _f !== void 0 ? _f : deficitLamports / 1000000000);
+                throw new InsufficientBalanceError(String((_g = error.address) !== null && _g !== void 0 ? _g : ''), Number((_h = error.balanceLamports) !== null && _h !== void 0 ? _h : 0), Number((_j = error.estimatedCostLamports) !== null && _j !== void 0 ? _j : 0), deficitLamports, deficitSol);
             }
             throw error;
         }
@@ -10678,7 +10705,13 @@ async function setMany(many, options) {
             let signedTransaction = undefined;
             for (let i = 0; i < transactions.length; i++) {
                 const curTx = transactions[i];
-                const transactionResult = await handleSolanaTransaction(curTx, authProvider, options);
+                let transactionResult;
+                if (curTx.serializedTransaction) {
+                    transactionResult = await handlePreBuiltTransaction(curTx, authProvider, options);
+                }
+                else {
+                    transactionResult = await handleSolanaTransaction(curTx, authProvider, options);
+                }
                 lastTxSignature = transactionResult.transactionSignature;
                 signedTransaction = transactionResult.signedTransaction;
             }
@@ -10784,6 +10817,68 @@ async function setMany(many, options) {
         const transactionResult = await authProvider.runTransaction(undefined, solTransaction, options);
         return transactionResult;
     }
+    async function handlePreBuiltTransaction(tx, authProvider, options) {
+        var _a, _b;
+        const config = await getConfig();
+        const rpcUrl = config.rpcUrl || (tx.network === 'solana_devnet'
+            ? 'https://api.devnet.solana.com'
+            : 'https://api.mainnet-beta.solana.com');
+        const connection = new Connection(rpcUrl, 'confirmed');
+        const txBytes = bufferExports$1.Buffer.from(tx.serializedTransaction, 'base64');
+        const transaction = VersionedTransaction.deserialize(txBytes);
+        // Validate the transaction before signing: ensure only allowed programs
+        // and no unauthorized System program instructions (e.g., SOL transfers)
+        const TAROBASE_PROGRAM = 'poof4b5pk1L9tmThvBmaABjcyjfhFGbMbQP5BXk2QZp';
+        const COMPUTE_BUDGET = 'ComputeBudget111111111111111111111111111111';
+        const SYSTEM_PROGRAM = '11111111111111111111111111111111';
+        const ALLOWED_PROGRAMS = new Set([TAROBASE_PROGRAM, COMPUTE_BUDGET, SYSTEM_PROGRAM]);
+        // System program instruction discriminators (first 4 bytes, little-endian u32)
+        const SYSTEM_TRANSFER = 2; // Transfer instruction index
+        const SYSTEM_TRANSFER_WITH_SEED = 11;
+        const accountKeys = transaction.message.staticAccountKeys;
+        for (const ix of transaction.message.compiledInstructions) {
+            if (ix.programIdIndex >= accountKeys.length) {
+                throw new Error('Pre-built transaction has program ID in lookup table (not allowed)');
+            }
+            const programId = accountKeys[ix.programIdIndex].toBase58();
+            if (!ALLOWED_PROGRAMS.has(programId)) {
+                throw new Error(`Pre-built transaction contains unauthorized program: ${programId}`);
+            }
+            // Block System program transfer instructions — a compromised DO could
+            // embed a SOL drain. Only allow createAccount/allocate (needed for PDA init).
+            if (programId === SYSTEM_PROGRAM && ix.data.length >= 4) {
+                const ixIndex = ix.data[0] | (ix.data[1] << 8) | (ix.data[2] << 16) | (ix.data[3] << 24);
+                if (ixIndex === SYSTEM_TRANSFER || ixIndex === SYSTEM_TRANSFER_WITH_SEED) {
+                    throw new Error('Pre-built transaction contains unauthorized System transfer instruction');
+                }
+            }
+        }
+        const signedTx = await authProvider.signTransaction(transaction);
+        const rawTx = signedTx.serialize();
+        if ((options === null || options === void 0 ? void 0 : options.shouldSubmitTx) === false) {
+            return {
+                transactionSignature: '',
+                signedTransaction: bufferExports$1.Buffer.from(rawTx).toString('base64'),
+                blockNumber: 0,
+                gasUsed: '0',
+            };
+        }
+        const signature = await connection.sendRawTransaction(rawTx, {
+            skipPreflight: false,
+            maxRetries: 3,
+        });
+        const confirmation = await connection.confirmTransaction({
+            signature,
+            blockhash: tx.blockhash,
+            lastValidBlockHeight: tx.lastValidBlockHeight,
+        }, 'confirmed');
+        return {
+            transactionSignature: signature,
+            signedTransaction: bufferExports$1.Buffer.from(rawTx).toString('base64'),
+            blockNumber: (_b = (_a = confirmation.context) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : 0,
+            gasUsed: '0',
+        };
+    }
     async function handleOffchainTransaction(tx, authProvider, options) {
         var _a, _b, _c, _d, _e, _f;
         const config = await getConfig();
@@ -12096,30 +12191,53 @@ class RealtimeStore {
         this.idbDirtyKeys = new Set();
         this.closed = false;
         this.authToken = null;
+        this.isServer = false;
+        this.tokenRefreshTimer = null;
+        // -----------------------------------------------------------------------
+        // WebSocket connection
+        // -----------------------------------------------------------------------
+        this.initPromise = null;
     }
     // -----------------------------------------------------------------------
     // Initialization
     // -----------------------------------------------------------------------
     async init() {
-        var _a, _b;
         const config = await getConfig();
         this.appId = config.appId;
         this.wsUrl = config.wsApiUrl;
-        if (config.authProvider) {
-            try {
-                const headers = await ((_b = (_a = config.authProvider).getAuthHeaders) === null || _b === void 0 ? void 0 : _b.call(_a));
-                if (headers === null || headers === void 0 ? void 0 : headers.Authorization) {
-                    this.authToken = headers.Authorization.replace('Bearer ', '');
-                }
-            }
-            catch ( /* no auth */_c) { /* no auth */ }
+        this.isServer = config.isServer;
+        await this.refreshToken();
+        this.startTokenRefresh();
+    }
+    async refreshToken() {
+        try {
+            const { getIdToken } = await Promise.resolve().then(function () { return utils; });
+            const token = await getIdToken(this.isServer);
+            if (token)
+                this.authToken = token;
         }
+        catch ( /* no auth available */_a) { /* no auth available */ }
+    }
+    startTokenRefresh() {
+        if (this.tokenRefreshTimer)
+            return;
+        this.tokenRefreshTimer = setInterval(async () => {
+            var _a;
+            const prevToken = this.authToken;
+            await this.refreshToken();
+            if (this.authToken && this.authToken !== prevToken && ((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+                // Token changed — reconnect with fresh token
+                this.ws.close(1000, 'Token refreshed');
+            }
+        }, 5 * 60 * 1000); // Check every 5 minutes
     }
-    // -----------------------------------------------------------------------
-    // WebSocket connection
-    // -----------------------------------------------------------------------
     async ensureConnected() {
         var _a;
+        if (!this.appId) {
+            if (!this.initPromise)
+                this.initPromise = this.init();
+            await this.initPromise;
+        }
         if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN)
             return;
         if (this.connectPromise)
@@ -12135,10 +12253,12 @@ class RealtimeStore {
             }
             const params = new URLSearchParams();
             params.set('apiKey', this.appId);
-            // Auth token sent via subprotocol to avoid leaking in URL/logs
+            if (this.authToken)
+                params.set('authorization', this.authToken);
+            // Note: token in URL is required until DO server supports subprotocol auth.
+            // WSS encrypts the full URL including query params on the wire.
             const url = `${this.wsUrl}?${params.toString()}`;
-            const protocols = this.authToken ? [`bearer-${this.authToken}`] : undefined;
-            const ws = protocols ? new WebSocket(url, protocols) : new WebSocket(url);
+            const ws = new WebSocket(url);
             this.ws = ws;
             const onOpen = () => {
                 ws.removeEventListener('error', onError);
@@ -12769,6 +12889,8 @@ class RealtimeStore {
             clearTimeout(this.reconnectTimer);
         if (this.idbFlushTimer)
             clearTimeout(this.idbFlushTimer);
+        if (this.tokenRefreshTimer)
+            clearInterval(this.tokenRefreshTimer);
         this.flushIdb();
         if (this.ws) {
             this.ws.close(1000, 'Store closed');
@@ -13142,6 +13264,15 @@ class OffchainAuthProvider {
     async getNativeMethods() {
         return this.wrappedProvider.getNativeMethods();
     }
+    // Forward wallet export to the wrapped provider (only Privy embedded wallets
+    // implement it). Duck-typed so wrappers around non-embedded providers throw
+    // a clear error rather than a "not a function" crash.
+    async exportWallet(address) {
+        if (typeof this.wrappedProvider.exportWallet !== 'function') {
+            throw new Error('Wallet export is not available for this wallet.');
+        }
+        await this.wrappedProvider.exportWallet(address);
+    }
     // ============ signMessage delegates to wrapped provider ============
     async signMessage(message) {
         // Delegate to wrapped provider for real wallet signing
@@ -14112,7 +14243,11 @@ async function login$1(options) {
     return null;
 }
 function getCurrentAuthMethod() {
-    return currentAuthMethod;
+    // Fall back to the persisted login method so consumers (e.g. a "show export
+    // wallet" gate) get the correct value synchronously on reload, before init()
+    // has rebuilt the in-memory provider. The stored value is cleared on logout,
+    // so a logged-out user still yields null.
+    return currentAuthMethod !== null && currentAuthMethod !== void 0 ? currentAuthMethod : getStoredAuthMethod();
 }
 async function logout$1() {
     if (!currentAuthProvider) {
@@ -14123,6 +14258,21 @@ async function logout$1() {
     currentAuthProvider = null;
     currentAuthMethod = null;
 }
+/**
+ * Opens the active provider's wallet-export flow (Privy's hosted modal). Only
+ * embedded (email) wallets implement `exportWallet`; external wallets (Phantom)
+ * throw. The private key is revealed only to the user on Privy's origin — it is
+ * never exposed to this SDK or the host app.
+ */
+async function exportWallet(address) {
+    if (!currentAuthProvider) {
+        throw new Error("Auth provider not initialized. Please call init() first.");
+    }
+    if (typeof currentAuthProvider.exportWallet !== 'function') {
+        throw new Error("Wallet export is only available for embedded (email) wallets.");
+    }
+    await currentAuthProvider.exportWallet(address);
+}
 
 let authProviderInstance = null;
 let currentUser = null;
@@ -16799,7 +16949,7 @@ async function loadDependencies() {
         const [reactModule, reactDomModule, phantomModule] = await Promise.all([
             import('react'),
             import('react-dom/client'),
-            import('./index-dEUHmDSl.esm.js')
+            import('./index-DSSkK8ZR.esm.js')
         ]);
         // Extract default export from ESM module namespace
         // Dynamic import() returns { default: Module, ...exports }, not the module directly
@@ -21956,6 +22106,25 @@ class PrivyWalletProvider {
         await this.ensureReady();
         return (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.usePrivy;
     }
+    /**
+     * Opens Privy's hosted export modal so the user can reveal/copy the private key
+     * for their embedded Solana wallet. The key is assembled on Privy's origin —
+     * neither this SDK nor the host app ever receives it. Only available for Privy
+     * embedded wallets (email login); throws otherwise.
+     */
+    async exportWallet(address) {
+        var _a, _b;
+        await this.ensureReady({ waitForWallets: true });
+        const exportFn = (_b = (_a = this.privyMethods) === null || _a === void 0 ? void 0 : _a.useSolanaWallets) === null || _b === void 0 ? void 0 : _b.exportWallet;
+        if (typeof exportFn !== 'function') {
+            throw new Error('Wallet export is not available for this wallet.');
+        }
+        // Default to the session's embedded wallet address so the correct wallet is
+        // exported in any HD/multi-wallet case; omit to let Privy export index 0.
+        const session = await WebSessionManager.getSession();
+        const target = address !== null && address !== void 0 ? address : session === null || session === void 0 ? void 0 : session.address;
+        await exportFn(target ? { address: target } : undefined);
+    }
     async logout() {
         await this.ensureReady();
         await this.privyMethods.logout();
@@ -23031,7 +23200,7 @@ async function registerMobileWalletAdapter(config) {
     if (typeof window === 'undefined')
         return;
     try {
-        const walletStandardMobile = await import('./index.browser-RwalL3F4.esm.js');
+        const walletStandardMobile = await import('./index.browser-AkckBwjb.esm.js');
         const registerMwa = walletStandardMobile.registerMwa || ((_a = walletStandardMobile.default) === null || _a === void 0 ? void 0 : _a.registerMwa);
         if (!registerMwa) {
             console.warn('[SolanaMobileWallet] registerMwa not found in @solana-mobile/wallet-standard-mobile');
@@ -23170,7 +23339,7 @@ class SolanaMobileWalletProvider {
     async ensureWallet() {
         if (this.wallet)
             return this.wallet;
-        const mod = await import('./index.browser-RwalL3F4.esm.js');
+        const mod = await import('./index.browser-AkckBwjb.esm.js');
         const chain = mapChainToWalletStandard(this.cluster);
         this.wallet = new mod.LocalSolanaMobileWalletAdapterWallet({
             appIdentity: this.appIdentity,
@@ -24362,5 +24531,5 @@ class PrivyExpoProvider {
     }
 }
 
-export { genSolanaMessage as $, subscribe as A, useAuth as B, deserializeTransaction as C, getIdToken as D, setPlatform as E, getPlatform as F, PrivyWalletProvider as G, DEFAULT_TEST_ADDRESS as H, isMobileWalletAvailable as I, registerMobileWalletAdapter as J, PrivyExpoProvider as K, InsufficientBalanceError as L, MockAuthProvider as M, RealtimeStore as N, OffchainAuthProvider as O, PhantomWalletProvider as P, ServerSessionManager as Q, ReactNativeSessionManager as R, SolanaMobileWalletProvider as S, buildSetDocumentsTransaction as T, clearCache as U, closeAllSubscriptions as V, WebSessionManager as W, convertRemainingAccounts as X, createSessionWithPrivy as Y, createSessionWithSignature as Z, genAuthNonce as _, base58 as a, getCachedData as a0, getMany as a1, getRealtimeStore as a2, hasActiveConnection as a3, reconnectWithNewAuth as a4, refreshSession as a5, resetRealtimeStore as a6, signSessionCreateMessage as a7, wsDelete as a8, wsGet as a9, wsGetMany as aa, wsQuery as ab, wsSet as ac, bufferExports as b, getCurrentUser as c, onAuthLoadingChanged as d, getAuthLoading as e, logout as f, getDefaultExportFromCjs$1 as g, getConfig as h, init as i, getAuthProvider as j, get as k, login as l, setMany as m, setFile as n, onAuthStateChanged as o, getFiles as p, runQueryMany as q, runQuery as r, set as s, runExpression as t, runExpressionMany as u, signMessage as v, signTransaction as w, signAndSubmitTransaction as x, count as y, aggregate as z };
-//# sourceMappingURL=index-6iINLG88.esm.js.map
+export { convertRemainingAccounts as $, signTransaction as A, signAndSubmitTransaction as B, count as C, aggregate as D, subscribe as E, useAuth as F, deserializeTransaction as G, getIdToken as H, setPlatform as I, getPlatform as J, PrivyWalletProvider as K, DEFAULT_TEST_ADDRESS as L, MockAuthProvider as M, isMobileWalletAvailable as N, OffchainAuthProvider as O, PhantomWalletProvider as P, registerMobileWalletAdapter as Q, PrivyExpoProvider as R, SolanaMobileWalletProvider as S, InsufficientBalanceError as T, ReactNativeSessionManager as U, RealtimeStore as V, ServerSessionManager as W, WebSessionManager as X, buildSetDocumentsTransaction as Y, clearCache as Z, closeAllSubscriptions as _, base58 as a, createSessionWithPrivy as a0, createSessionWithSignature as a1, genAuthNonce as a2, genSolanaMessage as a3, getCachedData as a4, getMany as a5, getRealtimeStore as a6, hasActiveConnection as a7, reconnectWithNewAuth as a8, refreshSession as a9, resetRealtimeStore as aa, signSessionCreateMessage as ab, wsDelete as ac, wsGet as ad, wsGetMany as ae, wsQuery as af, wsSet as ag, bufferExports as b, commonjsRequire as c, getCurrentUser as d, onAuthLoadingChanged as e, getAuthLoading as f, getDefaultExportFromCjs$1 as g, logout as h, init as i, getConfig as j, getAuthProvider as k, login as l, getCurrentAuthMethod as m, exportWallet as n, onAuthStateChanged as o, get as p, setMany as q, require$$0 as r, set as s, setFile as t, getFiles as u, runQuery as v, runQueryMany as w, runExpression as x, runExpressionMany as y, signMessage as z };
+//# sourceMappingURL=index-Cnx5UBPU.esm.js.map