@pooflabs/core 0.0.40 → 0.0.42

package/README.md

@@ -39,6 +39,15 @@ export interface User {
   address: string;
   provider: AuthProvider;
 }
+
+export interface GetManyResult {
+  path: string;
+  data: any | null;
+  error?: {
+    code: 'NOT_FOUND' | 'UNAUTHORIZED' | 'INVALID_PATH';
+    message: string;
+  };
+}
 ```
 
 ### Core Operations
@@ -52,6 +61,7 @@ function getConfig(): Promise<ClientConfig>;
 
 // Data operations
 function get(path: string): Promise<any>;
+function getMany(paths: string[], options?: { bypassCache?: boolean }): Promise<GetManyResult[]>;
 function set(path: string, data: any, options?: SetOptions): Promise<any>;
 function setMany(paths: { [key: string]: any }, options?: SetOptions): Promise<any>;
 function setFile(path: string, file: File, metadata?: any): Promise<any>;

package/dist/client/operations.d.ts

@@ -113,6 +113,20 @@ export declare function count(path: string, opts?: CountOptions): Promise<Aggreg
  */
 export declare function aggregate(path: string, operation: AggregateOperation, opts?: AggregateOptions): Promise<AggregateResult>;
 export declare function get(path: string, opts?: GetOptions): Promise<any>;
+export type GetManyResult = {
+    path: string;
+    data: any | null;
+    error?: {
+        code: 'NOT_FOUND' | 'UNAUTHORIZED' | 'INVALID_PATH';
+        message: string;
+    };
+};
+export declare function getMany(paths: string[], opts?: {
+    bypassCache?: boolean;
+    _overrides?: {
+        headers?: Record<string, string>;
+    };
+}): Promise<GetManyResult[]>;
 export type RunExpressionOptions = {
     returnType?: 'Bool' | 'String' | 'Int' | 'UInt';
     _overrides?: RequestOverrides;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { init } from './client/config';
 export { getConfig, ClientConfig } from './client/config';
-export { get, set, setMany, setFile, getFiles, runQuery, runQueryMany, runExpression, runExpressionMany, signMessage, signTransaction, signAndSubmitTransaction, count, aggregate, RequestOverrides, SetOptions, GetOptions, RunQueryOptions, CountOptions, AggregateOptions, AggregateOperation, AggregateResult, RunExpressionOptions, RunExpressionResult, InsufficientBalanceError } from './client/operations';
+export { get, getMany, set, setMany, setFile, getFiles, runQuery, runQueryMany, runExpression, runExpressionMany, signMessage, signTransaction, signAndSubmitTransaction, count, aggregate, RequestOverrides, SetOptions, GetOptions, RunQueryOptions, CountOptions, AggregateOptions, AggregateOperation, AggregateResult, RunExpressionOptions, RunExpressionResult, InsufficientBalanceError, GetManyResult } from './client/operations';
 export { subscribe, closeAllSubscriptions, clearCache, getCachedData, reconnectWithNewAuth } from './client/subscription';
 export * from './types';
 export { getIdToken } from './utils/utils';

package/dist/index.js

@@ -2977,7 +2977,7 @@ function convertRemainingAccounts(remainingAccounts) {
 // ─────────────────────────────────────────────────────────────
 // Updated Transaction Builder: It now accepts a PublicKey for the payer
 // ─────────────────────────────────────────────────────────────
-async function buildSetDocumentsTransaction(connection, idl, anchorProvider, payerPublicKey, args, remainingAccounts, lutKey, preInstructions, simulate) {
+async function buildSetDocumentsTransaction(connection, idl, anchorProvider, payerPublicKey, args, remainingAccounts, lutKey, preInstructions, simulate, additionalLutAddresses) {
     const computeBudgetIx = web3_js.ComputeBudgetProgram.setComputeUnitLimit({
         units: 1400000,
     });
@@ -3018,8 +3018,25 @@ async function buildSetDocumentsTransaction(connection, idl, anchorProvider, pay
     tx.feePayer = payerPublicKey;
     const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
     tx.recentBlockhash = blockhash;
-    if (lutKey == null) {
-        const isSurfnet = anchorProvider.connection.rpcEndpoint == "https://surfpool.fly.dev";
+    // Resolve LUTs: additionalLutAddresses (when present) is the authoritative set.
+    // Falls back to lutKey alone for backwards compatibility.
+    const lookupTables = [];
+    const isSurfnet = anchorProvider.connection.rpcEndpoint == "https://surfpool.fly.dev";
+    if (additionalLutAddresses && additionalLutAddresses.length > 0) {
+        const results = await Promise.all(additionalLutAddresses.map(addr => connection.getAddressLookupTable(new web3_js.PublicKey(addr)).catch(() => null)));
+        for (const result of results) {
+            if (result === null || result === void 0 ? void 0 : result.value) {
+                lookupTables.push(result.value);
+            }
+        }
+    }
+    else if (lutKey != null) {
+        const { value: table } = await connection.getAddressLookupTable(new web3_js.PublicKey(lutKey));
+        if (!table)
+            throw new Error('LUT not found after creation/extend');
+        lookupTables.push(table);
+    }
+    if (lookupTables.length === 0) {
         const computeUnits = isSurfnet ? 1400000 : await getSimulationComputeUnits(connection, tx.instructions, payerPublicKey, []);
         const computeBudgetIxOptimized = web3_js.ComputeBudgetProgram.setComputeUnitLimit({
             units: computeUnits ? computeUnits * 1.2 : 1400000,
@@ -3027,11 +3044,7 @@ async function buildSetDocumentsTransaction(connection, idl, anchorProvider, pay
         tx.instructions[0] = computeBudgetIxOptimized;
         return { tx, blockhash, lastValidBlockHeight };
     }
-    const { value: table } = await connection.getAddressLookupTable(new web3_js.PublicKey(lutKey));
-    if (!table)
-        throw new Error('LUT not found after creation/extend');
-    const isSurfnet = anchorProvider.connection.rpcEndpoint == "https://surfpool.fly.dev";
-    const computeUnits = isSurfnet ? 1400000 : await getSimulationComputeUnits(connection, tx.instructions, payerPublicKey, [table]);
+    const computeUnits = isSurfnet ? 1400000 : await getSimulationComputeUnits(connection, tx.instructions, payerPublicKey, lookupTables);
     const computeBudgetIxOptimized = web3_js.ComputeBudgetProgram.setComputeUnitLimit({
         units: computeUnits ? computeUnits * 1.2 : 1400000,
     }); // 20% buffer
@@ -3040,7 +3053,7 @@ async function buildSetDocumentsTransaction(connection, idl, anchorProvider, pay
         payerKey: payerPublicKey,
         recentBlockhash: blockhash,
         instructions: tx.instructions,
-    }).compileToV0Message([table]);
+    }).compileToV0Message(lookupTables);
     const vTx = new anchor__namespace.web3.VersionedTransaction(msgV0);
     return { tx: vTx, blockhash, lastValidBlockHeight };
 }
@@ -3735,6 +3748,90 @@ function cleanupExpiredCache() {
     });
     lastCacheCleanup = now;
 }
+async function getMany(paths, opts = {}) {
+    if (paths.length === 0) {
+        return [];
+    }
+    if (paths.length > 30) {
+        throw new Error('Cannot fetch more than 30 documents at once');
+    }
+    const normalizedPaths = [];
+    for (const path of paths) {
+        let normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+        if (normalizedPath.endsWith("*") && normalizedPath.length > 1) {
+            normalizedPath = normalizedPath.slice(0, -1);
+        }
+        if (!normalizedPath || normalizedPath.length === 0) {
+            throw new Error(`Invalid path provided: ${path}`);
+        }
+        const pathIsDocument = normalizedPath.split("/").length % 2 === 0;
+        if (!pathIsDocument) {
+            throw new Error(`Path must point to a document (even number of segments): ${path}`);
+        }
+        normalizedPaths.push(normalizedPath);
+    }
+    const now = Date.now();
+    const results = new Array(paths.length);
+    const uncachedIndices = [];
+    const uncachedPaths = [];
+    for (let i = 0; i < normalizedPaths.length; i++) {
+        const normalizedPath = normalizedPaths[i];
+        const cacheKey = `${normalizedPath}:`;
+        if (!opts.bypassCache && getCache[cacheKey] && now < getCache[cacheKey].expiresAt) {
+            results[i] = { path: normalizedPath, data: getCache[cacheKey].data };
+        }
+        else {
+            uncachedIndices.push(i);
+            uncachedPaths.push(normalizedPath);
+        }
+    }
+    if (uncachedPaths.length > 0) {
+        try {
+            const response = await makeApiRequest('POST', 'items/batch', { paths: uncachedPaths }, opts._overrides);
+            const serverResults = response.data.results;
+            const serverResultsMap = new Map();
+            for (const result of serverResults) {
+                serverResultsMap.set(result.path, result);
+            }
+            for (let i = 0; i < uncachedIndices.length; i++) {
+                const originalIndex = uncachedIndices[i];
+                const normalizedPath = uncachedPaths[i];
+                const serverResult = serverResultsMap.get(normalizedPath);
+                if (serverResult) {
+                    results[originalIndex] = serverResult;
+                    if (!serverResult.error && !opts.bypassCache) {
+                        const cacheKey = `${normalizedPath}:`;
+                        getCache[cacheKey] = {
+                            data: serverResult.data,
+                            expiresAt: now + GET_CACHE_TTL
+                        };
+                    }
+                }
+                else {
+                    results[originalIndex] = {
+                        path: normalizedPath,
+                        data: null,
+                        error: { code: 'NOT_FOUND', message: `No result returned for path ${normalizedPath}` }
+                    };
+                }
+            }
+            if (now - lastCacheCleanup > 5000) {
+                cleanupExpiredCache();
+                lastCacheCleanup = now;
+            }
+        }
+        catch (error) {
+            for (const originalIndex of uncachedIndices) {
+                results[originalIndex] = {
+                    path: normalizedPaths[originalIndex],
+                    data: null,
+                    error: { code: 'NOT_FOUND', message: error instanceof Error ? error.message : 'Unknown error' }
+                };
+            }
+        }
+    }
+    return results;
+}
 async function runQuery(absolutePath, queryName, queryArgs, opts) {
     const result = await runQueryMany([{ absolutePath, queryName, queryArgs }], opts);
     return result[0];
@@ -3924,6 +4021,7 @@ async function setMany(many, options) {
             appId: config.appId,
             txArgs: [solTransactionData],
             lutKey: (_c = tx.lutAddress) !== null && _c !== void 0 ? _c : null,
+            additionalLutAddresses: tx.additionalLutAddresses,
             network: tx.network,
             preInstructions: (_e = (_d = tx.preInstructions) === null || _d === void 0 ? void 0 : _d.map((ix) => {
                 var _a;
@@ -4993,6 +5091,7 @@ exports.getCachedData = getCachedData;
 exports.getConfig = getConfig;
 exports.getFiles = getFiles;
 exports.getIdToken = getIdToken;
+exports.getMany = getMany;
 exports.init = init;
 exports.reconnectWithNewAuth = reconnectWithNewAuth;
 exports.refreshSession = refreshSession;