@onchaindb/sdk 0.4.5 → 2.0.0

package/src/client.ts

@@ -1,24 +1,35 @@
 import axios, {AxiosError, AxiosInstance} from 'axios';
 import {EventEmitter} from 'eventemitter3';
 import {
-    BlobMetadata,
     CreateCollectionResult,
     IndexRequest,
     IndexResponse,
-    OnChainDBConfig,
-    OnChainDBError,
+    OnDBConfig,
+    OnDBError,
     PricingQuoteRequest,
-    PricingQuoteResponse,
     RelationRequest,
     RelationResponse,
     RetrieveBlobRequest,
     SimpleCollectionSchema,
+    SimpleCollectionSchemaWithSharding,
     SimpleFieldDefinition,
+    ShardingStrategy,
+    UpdateCollectionRequest,
+    SetRetentionRequest,
+    RetentionConfig,
+    RetentionCostResponse,
+    SqlQueryRequest,
+    SqlQueryResponse,
+    SqlInsertRequest,
+    CreateQueryRequest,
+    CreateQueryResponse,
+    QueryDefinition,
+    QueryDataResponse,
+    CollectionResponse,
     StoreRequest,
     StoreResponse,
     SyncCollectionResult,
     TaskInfo,
-    TransactionError,
     TransactionEvents,
     UploadBlobRequest,
     UploadBlobResponse,
@@ -28,7 +39,7 @@ import {
 // Import query builder components
 // Import database management
 import {createDatabaseManager, DatabaseManager} from './database';
-import {LogicalOperator, QueryBuilder, QueryResponse} from "./query-sdk";
+import {QueryBuilder} from "./query-sdk";
 
 // Import x402 utilities
 import {
@@ -46,38 +57,44 @@ import {
 } from './x402';
 
 /**
- * OnChainDB TypeScript SDK
+ * OnDB TypeScript SDK
  *
- * Provides a complete interface for storing and querying data on OnChainDB,
+ * Provides a complete interface for storing and querying data on OnDB,
  * built on Celestia blockchain with automatic transaction management.
  *
  * @example
  * ```typescript
- * // Initialize with app key (for writes) and user key (for Auto-Pay)
- * const db = new OnChainDBClient({
+ * // Initialize with app key (for writes)
+ * const db = new OnDBClient({
  *   endpoint: 'http://localhost:9092',
  *   appId: 'app_abc123',
- *   appKey: 'app_xxx...', // Required for write operations
- *   userKey: 'user_yyy...' // Optional: enables Auto-Pay for reads/writes
+ *   appKey: 'app_xxx...', // Required for write operations (X-App-Key header)
+ * });
+ *
+ * // Agent Key: autonomous agent that pays other apps inline via USDC (EIP-3009)
+ * const agent = new OnDBClient({
+ *   endpoint: 'http://localhost:9092',
+ *   appId: 'app_abc123',
+ *   agentKey: 'agent_zzz...', // X-Agent-Key header — key must have Pay permission
  * });
  *
  * // Store data (requires appKey)
  * const result = await db.store({
- *   data: [{ message: 'Hello OnChainDB!', user: 'alice' }],
+ *   data: [{ message: 'Hello OnDB!', user: 'alice' }],
  *   collection: 'messages'
  * });
  *
- * // Query data (userKey enables Auto-Pay if authz granted)
+ * // Query data
  * const messages = await db.query({ collection: 'messages' });
  *
  * // Backwards compatible: legacy apiKey maps to appKey
- * const legacyDb = new OnChainDBClient({
+ * const legacyDb = new OnDBClient({
  *   endpoint: 'http://localhost:9092',
  *   apiKey: 'app_xxx...' // Still works, maps to appKey
  * });
  * ```
  */
-export class OnChainDBClient extends EventEmitter<TransactionEvents> {
+export class OnDBClient extends EventEmitter<TransactionEvents> {
     /**
      * Base fields that are automatically indexed when useBaseFields is true
      */
@@ -88,28 +105,30 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
         deletedAt: {type: 'date', index: true}
     };
     private http: AxiosInstance;
-    private config: Required<Omit<OnChainDBConfig, 'appId'>> & { appId?: string; appKey?: string; userKey?: string };
+    private config: Required<Omit<OnDBConfig, 'appId'>> & { appId?: string; appKey?: string; userKey?: string; agentKey?: string };
     private _database?: DatabaseManager;
 
-    constructor(config: OnChainDBConfig) {
+    constructor(config: OnDBConfig) {
         super();
 
         // Support legacy apiKey for backwards compatibility (maps to appKey)
         const appKey = config.appKey || '';
         const userKey = config.userKey || '';
+        const agentKey = config.agentKey || '';
 
         this.config = {
             endpoint: config.endpoint,
             apiKey: config.apiKey || "", // Keep for backwards compat, but maps to appKey
             appKey: appKey,
             userKey: userKey,
+            agentKey: agentKey,
             appId: config.appId || undefined,
             timeout: config.timeout || 30000,
             retryCount: config.retryCount || 3,
             retryDelay: config.retryDelay || 1000
         };
 
-        // Build headers with both keys if provided
+        // Build headers with provided keys
         const headers: Record<string, string> = {
             'Content-Type': 'application/json'
         };
@@ -122,11 +141,15 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
             headers['X-Api-Key'] = config.apiKey;
         }
 
-
         if (userKey) {
             headers['X-User-Key'] = userKey;
         }
 
+        // Agent Keys use X-Agent-Key (not X-API-Key / X-App-Key)
+        if (agentKey) {
+            headers['X-Agent-Key'] = agentKey;
+        }
+
         this.http = axios.create({
             baseURL: this.config.endpoint,
             timeout: this.config.timeout,
@@ -162,12 +185,15 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
      * });
      * ```
      */
-    database(appId: string): DatabaseManager {
-        if (!this._database || this._database['appId'] !== appId) {
+    database(appId?: string): DatabaseManager {
+        const resolvedAppId = appId || this.config.appId;
+        if (!resolvedAppId) {
+            throw new ValidationError('appId must be provided either in config or as an argument to database()');
+        }
+        if (!this._database || this._database['appId'] !== resolvedAppId) {
             this._database = createDatabaseManager(
                 this.http,
-                this.config.endpoint,
-                appId,
+                resolvedAppId,
                 this.config.apiKey
             );
         }
@@ -187,7 +213,7 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
      * @param waitForConfirmation - Whether to wait for blockchain confirmation
      * @returns Promise resolving to the operation result
      */
-    async handleX402(
+    private async handleX402(
         response: { data: any },
         paymentCallback: ((quote: X402Quote) => Promise<X402PaymentCallbackResult>) | undefined,
         finalRequest: any,
@@ -200,7 +226,7 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
         try {
             x402Response = parseX402Response(response.data);
         } catch (e) {
-            throw new OnChainDBError(
+            throw new OnDBError(
                 `Invalid x402 response: ${e instanceof Error ? e.message : String(e)}`,
                 'PAYMENT_ERROR',
                 402
@@ -224,7 +250,7 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
 
         // Call payment callback if provided
         if (!paymentCallback) {
-            throw new OnChainDBError(
+            throw new OnDBError(
                 'Payment required but no payment callback provided. Please provide a payment callback to handle x402.',
                 'PAYMENT_REQUIRED',
                 402,
@@ -248,7 +274,7 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
             );
 
             if (!selectedRequirement) {
-                throw new OnChainDBError(
+                throw new OnDBError(
                     `Payment callback returned network '${facilitatorPayment.network}' but no matching payment option found`,
                     'PAYMENT_ERROR'
                 );
@@ -268,7 +294,7 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
                     transaction: facilitatorPayment.solanaAuthorization.transaction,
                 });
             } else {
-                throw new OnChainDBError(
+                throw new OnDBError(
                     'Facilitator payment missing authorization data',
                     'PAYMENT_ERROR'
                 );
@@ -295,37 +321,19 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
         if (serverResult.ticket_id) {
             if (waitForConfirmation) {
                 const taskInfo = await this.waitForTaskCompletion(serverResult.ticket_id);
-                // Extract result from task
-                if (taskInfo.result && taskInfo.result.results && taskInfo.result.results.length > 0) {
-                    const firstResult = taskInfo.result.results[0];
-                    return {
-                        id: firstResult.id,
-                        block_height: firstResult.celestia_height || 0,
-                        transaction_hash: firstResult.blob_id || '',
-                        celestia_height: firstResult.celestia_height || 0,
-                        namespace: firstResult.namespace || '',
-                        confirmed: firstResult.celestia_height > 0
-                    };
+                if (taskInfo.result?.results?.length > 0) {
+                    return this.buildStoreResult(taskInfo.result.results[0]);
                 }
             } else {
-                // Return ticket without waiting
-                return {
-                    id: serverResult.ticket_id,
-                    block_height: 0,
-                    transaction_hash: '',
-                    celestia_height: 0,
-                    namespace: '',
-                    confirmed: false,
-                    ticket_id: serverResult.ticket_id
-                } as StoreResponse;
+                return { id: serverResult.ticket_id, block_height: 0, transaction_hash: '', celestia_height: 0, namespace: '', confirmed: false, ticket_id: serverResult.ticket_id } as StoreResponse;
             }
         }
 
-        throw new OnChainDBError('No ticket_id in response after payment', 'STORE_ERROR');
+        throw new OnDBError('No ticket_id in response after payment', 'STORE_ERROR');
     }
 
     /**
-     * Store data on OnChainDB using the new root-based API with broker payment
+     * Store data on OnDB using the new root-based API with broker payment
      *
      * @param request - Store request with root (app::collection) and data array
      * @param paymentOptions - Payment configuration for broker fees
@@ -368,18 +376,7 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
             delete resolvedRequest.collection;
 
 
-            // Step 1: Try to store without payment (may get 402)
             const response = await this.http.post('/store', resolvedRequest);
-
-            // Step 2: Handle 402 Payment Required (x402)
-            if (response.status === 402 && response.data) {
-                const v = await this.handleX402(response, paymentCallback, resolvedRequest, waitForConfirmation);
-
-                if (v) {
-                    return v;
-                }
-            }
-
             const serverResult = response.data;
 
             // Check if we got an async response with ticket_id (new flow)
@@ -396,20 +393,8 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
                     const taskInfo = await this.waitForTaskCompletion(serverResult.ticket_id);
 
                     // Extract the actual storage result from the completed task
-                    if (taskInfo.result && taskInfo.result.results && taskInfo.result.results.length > 0) {
-                        const firstResult = taskInfo.result.results[0];
-
-                        // Transform to SDK format
-                        const result: StoreResponse = {
-                            id: firstResult.id,
-                            block_height: firstResult.celestia_height || 0,
-                            transaction_hash: firstResult.blob_id || '',
-                            celestia_height: firstResult.celestia_height || 0,
-                            namespace: firstResult.namespace || '',
-                            confirmed: firstResult.celestia_height > 0
-                        };
-
-                        // Emit completion event
+                    if (taskInfo.result?.results?.length > 0) {
+                        const result = this.buildStoreResult(taskInfo.result.results[0]);
                         this.emit('transaction:confirmed', {
                             id: result.id,
                             status: 'confirmed',
@@ -417,40 +402,22 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
                             transaction_hash: result.transaction_hash,
                             celestia_height: result.celestia_height
                         });
-
                         return result;
                     } else {
-                        throw new OnChainDBError('Task completed but no storage results found', 'STORE_ERROR');
+                        throw new OnDBError('Task completed but no storage results found', 'STORE_ERROR');
                     }
                 } else {
-                    // Return ticket info without waiting
-                    return {
-                        id: serverResult.ticket_id,
-                        block_height: 0,
-                        transaction_hash: '',
-                        celestia_height: 0,
-                        namespace: '',
-                        confirmed: false,
-                        ticket_id: serverResult.ticket_id
-                    } as StoreResponse;
+                    return { id: serverResult.ticket_id, block_height: 0, transaction_hash: '', celestia_height: 0, namespace: '', confirmed: false, ticket_id: serverResult.ticket_id } as StoreResponse;
                 }
             }
 
             // Legacy response format (if server returns old format)
-            const firstResult = serverResult.results && serverResult.results[0];
+            const firstResult = serverResult.results?.[0];
             if (!firstResult) {
-                throw new OnChainDBError('No results returned from server', 'STORE_ERROR');
+                throw new OnDBError('No results returned from server', 'STORE_ERROR');
             }
 
-            // Transform server response to SDK format
-            const result: StoreResponse = {
-                id: firstResult.id,
-                block_height: firstResult.celestia_height || 0,
-                transaction_hash: firstResult.blob_id || '',
-                celestia_height: firstResult.celestia_height || 0,
-                namespace: firstResult.namespace || '',
-                confirmed: firstResult.celestia_height > 0
-            };
+            const result = this.buildStoreResult(firstResult);
 
             // Emit appropriate event based on height
             if (result.block_height === 0) {
@@ -470,10 +437,6 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
                 });
             }
 
-            if (waitForConfirmation && result.block_height === 0) {
-                return await this.waitForConfirmation(result.transaction_hash);
-            }
-
             return result;
         } catch (error: any) {
             if ((error as AxiosError)?.response) {
@@ -486,109 +449,17 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
                     }
                 }
 
-                throw new OnChainDBError(JSON.stringify(err.response?.data), 'STORE_ERROR');
+                throw new OnDBError(JSON.stringify(err.response?.data), 'STORE_ERROR');
             }
 
             console.error(error)
-            const dbError = error instanceof OnChainDBError ? error :
-                new OnChainDBError(error.message, 'STORE_ERROR');
+            const dbError = error instanceof OnDBError ? error :
+                new OnDBError(error.message, 'STORE_ERROR');
             this.emit('error', dbError);
             throw dbError;
         }
     }
 
-    /**
-     * Store data and return a promise that resolves when transaction is confirmed
-     *
-     * @param request - Store request
-     * @param paymentOptions - Payment configuration for broker fees
-     * @returns Promise resolving when transaction is confirmed on blockchain
-     */
-    async storeAndConfirm(
-        request: StoreRequest
-    ): Promise<StoreResponse> {
-        return this.store(request, undefined, true);
-    }
-
-    /**
-     * Wait for transaction confirmation
-     *
-     * @param transactionHash - Transaction hash to monitor
-     * @param maxWaitTime - Maximum wait time in milliseconds (default: 5 minutes)
-     * @returns Promise resolving to confirmed transaction
-     */
-    async waitForConfirmation(transactionHash: string, maxWaitTime: number = 300000): Promise<StoreResponse> {
-        const startTime = Date.now();
-        const pollInterval = 3000; // Poll every 3 seconds (same as server)
-
-        console.log(`🔄 Waiting for transaction ${transactionHash} confirmation...`);
-
-        while (Date.now() - startTime < maxWaitTime) {
-            try {
-                // Query Celestia RPC directly to check transaction status
-                const rpcUrl = 'https://celestia-mocha-rpc.publicnode.com:443'; // Default testnet RPC
-                const txUrl = `${rpcUrl}/tx?hash=0x${transactionHash}`;
-
-                console.log(`🔍 Checking transaction status: attempt ${Math.floor((Date.now() - startTime) / pollInterval) + 1}`);
-
-                const response = await axios.get(txUrl);
-
-                if (response.data?.result && response.data.result !== null) {
-                    const txResult = response.data.result;
-                    const height = parseInt(txResult.height);
-
-                    if (height > 0) {
-                        console.log(`✅ Transaction ${transactionHash} confirmed at height ${height}`);
-
-                        const confirmedTx: StoreResponse = {
-                            id: transactionHash, // Use transaction hash as ID for confirmation
-                            namespace: '', // Will be filled by actual usage
-                            block_height: height,
-                            transaction_hash: transactionHash,
-                            celestia_height: height,
-                            confirmed: true
-                        };
-
-                        this.emit('transaction:confirmed', {
-                            id: transactionHash,
-                            status: 'confirmed',
-                            block_height: height,
-                            transaction_hash: transactionHash
-                        });
-                        return confirmedTx;
-                    }
-                }
-
-                // Still pending, wait and retry
-                console.log(`⏳ Transaction still pending, waiting ${pollInterval}ms...`);
-                this.emit('transaction:pending', {
-                    id: transactionHash,
-                    status: 'pending',
-                    block_height: 0,
-                    transaction_hash: transactionHash
-                });
-                await this.sleep(pollInterval);
-
-            } catch (error) {
-                // For 404 or other errors, the transaction might not be confirmed yet
-                if (Date.now() - startTime >= maxWaitTime) {
-                    throw new TransactionError(
-                        `Transaction confirmation timeout after ${maxWaitTime}ms`,
-                        transactionHash
-                    );
-                }
-
-                // Wait and retry for temporary errors
-                console.log(`⚠️ Error checking transaction (will retry): ${error}`);
-                await this.sleep(pollInterval);
-            }
-        }
-
-        throw new TransactionError(
-            `Transaction confirmation timeout after ${maxWaitTime}ms`,
-            transactionHash
-        );
-    }
 
     /**
      * Create an index on a collection field
@@ -603,8 +474,8 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
             const response = await this.http.post<IndexResponse>(`/api/apps/${appId}/indexes`, request);
             return response.data;
         } catch (error) {
-            throw error instanceof OnChainDBError ? error :
-                new OnChainDBError('Failed to create index', 'INDEX_ERROR');
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to create index', 'INDEX_ERROR');
         }
     }
 
@@ -652,7 +523,7 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
         const allFields: Record<string, SimpleFieldDefinition> = {};
 
         if (schema.useBaseFields !== false) {
-            Object.assign(allFields, OnChainDBClient.BASE_FIELDS);
+            Object.assign(allFields, OnDBClient.BASE_FIELDS);
         }
 
         Object.assign(allFields, schema.fields);
@@ -752,7 +623,7 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
      * console.log('Removed:', result.removed);  // [{ field: 'username', type: 'string' }]
      * ```
      */
-    async syncCollection(schema: SimpleCollectionSchema): Promise<SyncCollectionResult> {
+    async syncCollection(schema: SimpleCollectionSchemaWithSharding): Promise<SyncCollectionResult> {
         const appId = this.config.appId;
         if (!appId) {
             throw new ValidationError('appId must be configured to sync collections');
@@ -767,26 +638,10 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
             errors: []
         };
 
-        // Get existing indexes for this collection
-        let existingIndexes: Array<{ field_name: string; index_type: string; name: string }> = [];
-        try {
-            const response = await this.http.get(`/api/apps/${appId}/collections/${schema.name}/indexes`);
-            existingIndexes = response.data?.indexes || response.data || [];
-        } catch (error) {
-            // Collection might not exist yet, that's okay
-            existingIndexes = [];
-        }
-
-        // Build map of existing indexes by field name
-        const existingByField = new Map<string, { type: string; name: string }>();
-        for (const idx of existingIndexes) {
-            existingByField.set(idx.field_name, {type: idx.index_type, name: idx.name});
-        }
-
         // Merge base fields if enabled (default: true)
         const allFields: Record<string, SimpleFieldDefinition> = {};
         if (schema.useBaseFields !== false) {
-            Object.assign(allFields, OnChainDBClient.BASE_FIELDS);
+            Object.assign(allFields, OnDBClient.BASE_FIELDS);
         }
         Object.assign(allFields, schema.fields);
 
@@ -798,9 +653,9 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
             }
         }
 
-        // Find indexes to create (in desired but not existing)
+        // Create all desired indexes (broker handles upsert)
         for (const fieldName of desiredIndexedFields) {
-            if (!existingByField.has(fieldName)) {
+            {
                 const fieldDef = allFields[fieldName];
                 const indexType = fieldDef.indexType || this.getDefaultIndexType(fieldDef.type);
 
@@ -840,36 +695,179 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
             }
         }
 
-        // Find indexes to remove (existing but not in desired)
-        for (const [fieldName, existing] of existingByField) {
-            if (!desiredIndexedFields.has(fieldName)) {
-                try {
-                    // Index ID format: {collection}_{field_name}_index
-                    const indexId = `${schema.name}_${fieldName}_index`;
-                    await this.http.delete(`/api/apps/${appId}/indexes/${indexId}`);
-                    result.removed.push({
-                        field: fieldName,
-                        type: existing.type
-                    });
-                } catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : String(error);
-                    result.errors!.push(`Failed to remove index on ${fieldName}: ${errorMsg}`);
-                    result.success = false;
-                }
+        if (schema.sharding) {
+            try {
+                await this.setupSharding(schema.name, schema.sharding);
+                result.sharding_configured = true;
+            } catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                result.errors!.push(`Failed to configure sharding: ${errorMsg}`);
+                result.success = false;
             }
         }
 
-        // Track unchanged indexes
-        for (const [fieldName, existing] of existingByField) {
-            if (desiredIndexedFields.has(fieldName)) {
-                result.unchanged.push({
-                    field: fieldName,
-                    type: existing.type
-                });
-            }
+        return result;
+    }
+
+    async setupSharding(collection: string, sharding: ShardingStrategy): Promise<void> {
+        const appId = this.config.appId;
+        if (!appId) {
+            throw new ValidationError('appId must be configured to setup sharding');
         }
+        try {
+            await this.http.patch(
+                `/api/apps/${appId}/collections/${collection}/sharding`,
+                sharding
+            );
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to setup sharding', 'SHARDING_ERROR');
+        }
+    }
 
-        return result;
+    async deleteCollection(collection: string): Promise<{ success: boolean }> {
+        const appId = this.config.appId;
+        if (!appId) throw new ValidationError('appId must be configured');
+        try {
+            const response = await this.http.delete(`/api/apps/${appId}/collections/${collection}`);
+            return response.data;
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to delete collection', 'COLLECTION_ERROR');
+        }
+    }
+
+    async updateCollection(collection: string, updates: UpdateCollectionRequest): Promise<any> {
+        const appId = this.config.appId;
+        if (!appId) throw new ValidationError('appId must be configured');
+        try {
+            const response = await this.http.patch(`/api/apps/${appId}/collections/${collection}`, updates);
+            return response.data;
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to update collection', 'COLLECTION_ERROR');
+        }
+    }
+
+    async getRetention(collection: string): Promise<RetentionConfig> {
+        const appId = this.config.appId;
+        if (!appId) throw new ValidationError('appId must be configured');
+        try {
+            const response = await this.http.get(`/api/apps/${appId}/collections/${collection}/retention`);
+            return response.data;
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to get retention config', 'RETENTION_ERROR');
+        }
+    }
+
+    async setRetention(collection: string, request: SetRetentionRequest): Promise<{ message: string; config: RetentionConfig }> {
+        const appId = this.config.appId;
+        if (!appId) throw new ValidationError('appId must be configured');
+        try {
+            const response = await this.http.post(`/api/apps/${appId}/collections/${collection}/retention`, request);
+            return response.data;
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to set retention config', 'RETENTION_ERROR');
+        }
+    }
+
+    async getRetentionCost(): Promise<RetentionCostResponse> {
+        const appId = this.config.appId;
+        if (!appId) throw new ValidationError('appId must be configured');
+        try {
+            const response = await this.http.get(`/api/apps/${appId}/retention/cost`);
+            return response.data;
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to get retention cost', 'RETENTION_ERROR');
+        }
+    }
+
+    async sql(query: string, options?: { includeHistory?: boolean }): Promise<SqlQueryResponse> {
+        try {
+            const body: SqlQueryRequest = { sql: query };
+            if (options?.includeHistory !== undefined) body.include_history = options.includeHistory;
+            const response = await this.http.post('/query/sql', body);
+            return response.data;
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('SQL query failed', 'SQL_ERROR');
+        }
+    }
+
+    async sqlInsert(sql: string): Promise<any> {
+        try {
+            const body: SqlInsertRequest = { sql };
+            const response = await this.http.post('/insert/sql', body);
+            return response.data;
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('SQL insert failed', 'SQL_ERROR');
+        }
+    }
+
+    async listQueries(): Promise<QueryDefinition[]> {
+        const appId = this.config.appId;
+        if (!appId) throw new ValidationError('appId must be configured');
+        try {
+            const response = await this.http.get(`/apps/${appId}/queries`);
+            return response.data.queries ?? response.data;
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to list predefined queries', 'QUERY_ERROR');
+        }
+    }
+
+    async createQuery(request: CreateQueryRequest): Promise<CreateQueryResponse> {
+        const appId = this.config.appId;
+        if (!appId) throw new ValidationError('appId must be configured');
+        try {
+            const response = await this.http.post(`/apps/${appId}/queries`, request);
+            return response.data;
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to create predefined query', 'QUERY_ERROR');
+        }
+    }
+
+    async getQuery(name: string): Promise<QueryDefinition> {
+        const appId = this.config.appId;
+        if (!appId) throw new ValidationError('appId must be configured');
+        try {
+            const response = await this.http.get(`/apps/${appId}/queries/${name}`);
+            return response.data;
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to get predefined query', 'QUERY_ERROR');
+        }
+    }
+
+    async deleteQuery(name: string): Promise<{ success: boolean }> {
+        const appId = this.config.appId;
+        if (!appId) throw new ValidationError('appId must be configured');
+        try {
+            const response = await this.http.delete(`/apps/${appId}/queries/${name}`);
+            return response.data;
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to delete predefined query', 'QUERY_ERROR');
+        }
+    }
+
+    async executeQuery(name: string, params?: Record<string, string>, version?: number): Promise<QueryDataResponse> {
+        const appId = this.config.appId;
+        if (!appId) throw new ValidationError('appId must be configured');
+        try {
+            const queryParams: Record<string, string | number> = { ...params };
+            if (version !== undefined) queryParams['v'] = version;
+            const response = await this.http.get(`/api/queries/${appId}/${name}/data`, { params: queryParams });
+            return response.data;
+        } catch (error) {
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to execute predefined query', 'QUERY_ERROR');
+        }
     }
 
     /**
@@ -878,18 +876,18 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
      * @param collection - Collection name
      * @returns Collection information
      */
-    async getCollectionInfo(collection: string): Promise<{ indexes: string[]; recordCount?: number }> {
+    async getCollectionInfo(collectionId: string): Promise<CollectionResponse> {
         const appId = this.config.appId;
         if (!appId) {
             throw new ValidationError('appId must be configured');
         }
 
         try {
-            const response = await this.http.get(`/api/apps/${appId}/collections/${collection}`);
+            const response = await this.http.get(`/api/apps/${appId}/collections/${collectionId}`);
             return response.data;
         } catch (error) {
-            throw error instanceof OnChainDBError ? error :
-                new OnChainDBError('Failed to get collection info', 'COLLECTION_ERROR');
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to get collection info', 'COLLECTION_ERROR');
         }
     }
 
@@ -934,13 +932,13 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
             const response = await this.http.post<RelationResponse>(`/api/apps/${appId}/relations`, request);
             return response.data;
         } catch (error) {
-            throw error instanceof OnChainDBError ? error :
-                new OnChainDBError('Failed to create relation', 'RELATION_ERROR');
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to create relation', 'RELATION_ERROR');
         }
     }
 
     /**
-     * Get health status of OnChainDB service
+     * Get health status of OnDB service
      *
      * @returns Health check response
      */
@@ -949,98 +947,10 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
             const response = await this.http.get('/');
             return response.data;
         } catch (error) {
-            throw new OnChainDBError('Health check failed', 'HEALTH_ERROR');
+            throw new OnDBError('Health check failed', 'HEALTH_ERROR');
         }
     }
 
-    /**
-     * Get pricing quote for an operation before executing it
-     *
-     * Use this to estimate costs before committing to a store operation,
-     * especially useful for large files or high-volume scenarios.
-     *
-     * @param request - Pricing quote request with app_id, operation type, size, and collection
-     * @returns Pricing quote with detailed cost breakdown
-     *
-     * @example
-     * ```typescript
-     * const quote = await db.getPricingQuote({
-     *   app_id: 'my_app',
-     *   operation_type: 'write',
-     *   size_kb: 50,
-     *   collection: 'users',
-     *   monthly_volume_kb: 1000
-     * });
-     *
-     * console.log(`Total cost: ${quote.total_cost_utia} utia`);
-     * console.log(`Indexing costs:`, quote.indexing_costs_utia);
-     * ```
-     */
-    async getPricingQuote(request: PricingQuoteRequest): Promise<PricingQuoteResponse> {
-        try {
-            const response = await this.http.post('/api/pricing/quote', request);
-            return response.data;
-        } catch (error) {
-            throw error instanceof OnChainDBError ? error :
-                new OnChainDBError('Failed to get pricing quote', 'PRICING_QUOTE_ERROR');
-        }
-    }
-
-    /**
-     * Execute a simple query with basic filtering
-     *
-     * @param request - Simple query request
-     * @returns Query response with records
-     *
-     * @example
-     * ```typescript
-     * const tweets = await db.query({
-     *   collection: 'tweets',
-     *   filters: { author: 'alice' },
-     *   limit: 10
-     * });
-     * ```
-     */
-    async query(request: {
-        collection: string;
-        filters?: Record<string, any>;
-        limit?: number;
-        offset?: number;
-        sort?: string[];
-    }): Promise<QueryResponse> {
-        try {
-            const queryBuilder = this.queryBuilder();
-
-            // Set collection using root building
-            const root = this.resolveRoot(request);
-
-            // Add filters if provided
-            if (request.filters) {
-                queryBuilder.find(builder => {
-                    const conditions = Object.entries(request.filters!).map(([field, value]) =>
-                        LogicalOperator.Condition(builder.field(field).equals(value))
-                    );
-                    return conditions.length === 1 ? conditions[0] : LogicalOperator.And(conditions);
-                });
-            }
-
-            // Set limit and offset
-            if (request.limit) {
-                queryBuilder.limit(request.limit);
-            }
-
-            if (request.offset) {
-                queryBuilder.offset(request.offset);
-            }
-
-            // Execute the query
-            return await queryBuilder.execute();
-
-        } catch (error) {
-            throw error instanceof OnChainDBError ? error :
-                new OnChainDBError('Failed to execute query', 'QUERY_ERROR');
-        }
-    }
 
     /**
      * Create a fluent query builder instance
@@ -1051,10 +961,10 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
      * ```typescript
      * const results = await db.queryBuilder()
      *   .find(builder =>
-     *     LogicalOperator.And([
-     *       LogicalOperator.Condition(builder.field('status').equals('published')),
-     *       LogicalOperator.Condition(builder.field('author').equals('alice'))
-     *     ])
+     *     builder.and(
+     *       builder.field('status').equals('published'),
+     *       builder.field('author').equals('alice')
+     *     )
      *   )
      *   .select(selection =>
      *     selection.field('title').field('content')
@@ -1070,359 +980,6 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
         return new QueryBuilder(httpClient, this.config.endpoint, this.config.appId);
     }
 
-    /**
-     * Create a batch operations instance for this client
-     *
-     * @returns BatchOperations instance
-     *
-     * @example
-     * ```typescript
-     * const batch = db.batch();
-     * const results = await batch.store([...], { concurrency: 5 });
-     * ```
-     */
-    batch() {
-        const {BatchOperations} = require('./batch');
-        return new BatchOperations(this);
-    }
-
-    /**
-     * Find a single document by query (Prisma-style findUnique)
-     * Returns the latest record by metadata (updatedAt or createdAt) if multiple matches.
-     *
-     * @param collection - Collection name to search in
-     * @param where - Query conditions as key-value pairs
-     * @returns Promise resolving to document or null if not found
-     *
-     * @example
-     * ```typescript
-     * const user = await client.findUnique('users', { email: 'alice@example.com' });
-     * if (user) {
-     *   console.log('Found user:', user);
-     * }
-     * ```
-     */
-    async findUnique<T extends Record<string, any>>(
-        collection: string,
-        where: Record<string, any>
-    ): Promise<T | null> {
-        try {
-            let queryBuilder = this.queryBuilder().collection(collection);
-
-            // Add each where condition
-            for (const [field, value] of Object.entries(where)) {
-                queryBuilder = queryBuilder.whereField(field).equals(value);
-            }
-
-            // Execute query and return the latest record by metadata
-            return await queryBuilder.selectAll().executeUnique<T>();
-        } catch (error) {
-            console.error(`findUnique error for ${collection}:`, error);
-            return null;
-        }
-    }
-
-    // ===== PRISMA-LIKE CRUD OPERATIONS =====
-
-    /**
-     * Find multiple documents by query (Prisma-style findMany)
-     *
-     * @param collection - Collection name to search in
-     * @param where - Query conditions as key-value pairs
-     * @param options - Query options (limit, offset, sort)
-     * @returns Promise resolving to array of documents
-     *
-     * @example
-     * ```typescript
-     * const users = await client.findMany('users',
-     *   { active: true },
-     *   { limit: 10, sort: { field: 'createdAt', order: 'desc' } }
-     * );
-     * ```
-     */
-    async findMany<T>(
-        collection: string,
-        where: Record<string, any> = {},
-        options: {
-            limit?: number;
-            offset?: number;
-            sort?: { field: string; order: 'asc' | 'desc' };
-        } = {}
-    ): Promise<T[]> {
-        try {
-            let queryBuilder = this.queryBuilder().collection(collection);
-
-            // Add where conditions
-            for (const [field, value] of Object.entries(where)) {
-                queryBuilder = queryBuilder.whereField(field).equals(value);
-            }
-
-            // Add limit
-            if (options.limit) {
-                queryBuilder = queryBuilder.limit(options.limit);
-            }
-
-            // Add offset
-            if (options.offset) {
-                queryBuilder = queryBuilder.offset(options.offset);
-            }
-
-            const result = await queryBuilder.selectAll().execute();
-
-            if (!result.records) {
-                return [];
-            }
-
-            // Apply sorting if specified (client-side for now)
-            let records = result.records as T[];
-            if (options.sort) {
-                records = records.sort((a: any, b: any) => {
-                    const aVal = a[options.sort!.field];
-                    const bVal = b[options.sort!.field];
-
-                    if (options.sort!.order === 'asc') {
-                        return aVal > bVal ? 1 : -1;
-                    } else {
-                        return aVal < bVal ? 1 : -1;
-                    }
-                });
-            }
-
-            return records;
-        } catch (error) {
-            console.error(`findMany error for ${collection}:`, error);
-            return [];
-        }
-    }
-
-    /**
-     * Create a new document (Prisma-style create)
-     *
-     * @param collection - Collection name
-     * @param data - Document data (without id, createdAt, updatedAt)
-     * @param paymentCallback - x402 payment callback for handling payment
-     * @param options - Optional settings (idGenerator)
-     * @returns Promise resolving to created document
-     *
-     * @example
-     * ```typescript
-     * const user = await client.createDocument('users',
-     *   { email: 'alice@example.com', name: 'Alice' },
-     *   async (quote) => {
-     *     const txHash = await signAndBroadcastPayment(quote);
-     *     return { txHash, network: quote.network, sender: userAddress, chainType: quote.chainType, paymentMethod: quote.paymentMethod };
-     *   }
-     * );
-     * ```
-     */
-    async createDocument<T extends Record<string, any>>(
-        collection: string,
-        data: Omit<T, 'id' | 'createdAt' | 'updatedAt'>,
-        paymentCallback?: (quote: X402Quote) => Promise<X402PaymentResult>,
-        options?: {
-            idGenerator?: () => string;
-        }
-    ): Promise<T> {
-        const document: any = {
-            id: options?.idGenerator ? options.idGenerator() : this.generateId(),
-            ...data,
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-        };
-
-        // Use the store method with x402 payment callback
-        await this.store({
-            collection,
-            data: [document],
-        }, paymentCallback);
-
-        return document as T;
-    }
-
-    /**
-     * Update an existing document (Prisma-style update)
-     *
-     * @param collection - Collection name
-     * @param where - Query conditions to find document
-     * @param data - Partial data to update
-     * @param paymentCallback - x402 payment callback for handling payment
-     * @returns Promise resolving to updated document or null if not found
-     *
-     * @example
-     * ```typescript
-     * const updated = await client.updateDocument('users',
-     *   { email: 'alice@example.com' },
-     *   { name: 'Alice Smith' },
-     *   async (quote) => {
-     *     const txHash = await signAndBroadcastPayment(quote);
-     *     return { txHash, network: quote.network, sender: userAddress, chainType: quote.chainType, paymentMethod: quote.paymentMethod };
-     *   }
-     * );
-     * ```
-     */
-    async updateDocument<T extends Record<string, any>>(
-        collection: string,
-        where: Record<string, any>,
-        data: Partial<T>,
-        paymentCallback?: (quote: X402Quote) => Promise<X402PaymentResult>
-    ): Promise<T | null> {
-        // Fetch current document
-        const current = await this.findUnique<T>(collection, where);
-
-        if (!current) {
-            return null;
-        }
-
-        // Create updated document
-        const updated: any = {
-            ...current,
-            ...data,
-            updatedAt: new Date().toISOString(),
-        };
-
-        // Store updated version with x402 payment callback
-        await this.store({
-            collection,
-            data: [updated],
-        }, paymentCallback);
-
-        return updated as T;
-    }
-
-    /**
-     * Upsert a document (Prisma-style upsert - create or update)
-     *
-     * @param collection - Collection name
-     * @param where - Query conditions to find document
-     * @param create - Data for creating new document
-     * @param update - Data for updating existing document
-     * @param paymentCallback - x402 payment callback for handling payment
-     * @param options - Optional settings (idGenerator)
-     * @returns Promise resolving to created/updated document
-     *
-     * @example
-     * ```typescript
-     * const user = await client.upsertDocument('users',
-     *   { email: 'alice@example.com' },
-     *   { email: 'alice@example.com', name: 'Alice', active: true },
-     *   { active: true },
-     *   async (quote) => {
-     *     const txHash = await signAndBroadcastPayment(quote);
-     *     return { txHash, network: quote.network, sender: userAddress, chainType: quote.chainType, paymentMethod: quote.paymentMethod };
-     *   }
-     * );
-     * ```
-     */
-    async upsertDocument<T extends Record<string, any>>(
-        collection: string,
-        where: Record<string, any>,
-        create: Omit<T, 'id' | 'createdAt' | 'updatedAt'>,
-        update: Partial<T>,
-        paymentCallback?: (quote: X402Quote) => Promise<X402PaymentResult>,
-        options?: {
-            idGenerator?: () => string;
-        }
-    ): Promise<T> {
-        const existing = await this.findUnique<T>(collection, where);
-
-        if (existing) {
-            return (await this.updateDocument<T>(collection, where, update, paymentCallback))!;
-        } else {
-            return await this.createDocument<T>(collection, create, paymentCallback, options);
-        }
-    }
-
-    /**
-     * Soft delete a document by marking it as deleted
-     *
-     * @param collection - Collection name
-     * @param where - Query conditions to find document
-     * @param paymentCallback - x402 payment callback for handling payment
-     * @returns Promise resolving to true if deleted, false if not found
-     *
-     * @example
-     * ```typescript
-     * const deleted = await client.deleteDocument('users',
-     *   { email: 'alice@example.com' },
-     *   async (quote) => {
-     *     const txHash = await signAndBroadcastPayment(quote);
-     *     return { txHash, network: quote.network, sender: userAddress, chainType: quote.chainType, paymentMethod: quote.paymentMethod };
-     *   }
-     * );
-     * ```
-     */
-    async deleteDocument<T extends Record<string, any>>(
-        collection: string,
-        where: Record<string, any>,
-        paymentCallback?: (quote: X402Quote) => Promise<X402PaymentResult>
-    ): Promise<boolean> {
-        const existing = await this.findUnique<T>(collection, where);
-
-        if (!existing) {
-            return false;
-        }
-
-        // Soft delete by marking
-        const deleted: any = {
-            ...existing,
-            deleted: true,
-            updatedAt: new Date().toISOString(),
-        };
-
-        // Store deleted version with x402 payment callback
-        await this.store({
-            collection,
-            data: [deleted],
-        }, paymentCallback);
-
-        return true;
-    }
-
-    /**
-     * Count documents matching criteria
-     * Uses server-side aggregation via QueryBuilder for efficiency.
-     *
-     * @param collection - Collection name
-     * @param where - Query conditions
-     * @returns Promise resolving to count
-     *
-     * @example
-     * ```typescript
-     * const activeUsers = await client.countDocuments('users', { active: true });
-     * console.log(`Active users: ${activeUsers}`);
-     * ```
-     */
-    async countDocuments(collection: string, where: Record<string, any> = {}): Promise<number> {
-        try {
-            let queryBuilder = this.queryBuilder().collection(collection);
-
-            // Add where conditions
-            for (const [field, value] of Object.entries(where)) {
-                queryBuilder = queryBuilder.whereField(field).equals(value);
-            }
-
-            return await queryBuilder.count();
-        } catch (error) {
-            console.error(`countDocuments error for ${collection}:`, error);
-            return 0;
-        }
-    }
-
-    /**
-     * Generate a unique ID for documents (simple base62 implementation)
-     * Override this if you want to use a different ID generation strategy
-     *
-     * @returns Unique ID string
-     */
-    generateId(): string {
-        const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-        let id = '';
-        for (let i = 0; i < 24; i++) {
-            id += chars[Math.floor(Math.random() * chars.length)];
-        }
-        return id;
-    }
-
     /**
      * Get task status by ticket ID
      * @param ticketId - The ticket ID returned from async store operation
@@ -1433,8 +990,8 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
             const response = await this.http.get(`/task/${ticketId}`);
             return response.data;
         } catch (error) {
-            throw error instanceof OnChainDBError ? error :
-                new OnChainDBError('Failed to get task status', 'TASK_STATUS_ERROR');
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to get task status', 'TASK_STATUS_ERROR');
         }
     }
 
@@ -1471,13 +1028,13 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
                 if (typeof taskInfo.status === 'object' && 'Failed' in taskInfo.status) {
                     const error = (taskInfo.status as { Failed: { error: string } }).Failed.error;
                     console.error(`🚫 Task ${ticketId} failed: ${error}`);
-                    throw new OnChainDBError(`Task failed: ${error}`, 'TASK_FAILED');
+                    throw new OnDBError(`Task failed: ${error}`, 'TASK_FAILED');
                 }
 
                 // Check for any other error-like statuses
                 if (typeof taskInfo.status === 'string' && taskInfo.status.toLowerCase().includes('error')) {
                     console.error(`🚫 Task ${ticketId} has error status: ${taskInfo.status}`);
-                    throw new OnChainDBError(`Task error: ${taskInfo.status}`, 'TASK_FAILED');
+                    throw new OnDBError(`Task error: ${taskInfo.status}`, 'TASK_FAILED');
                 }
 
                 // Task still in progress, wait and check again
@@ -1487,8 +1044,8 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
                 console.error(`❌ Error polling task ${ticketId}:`, error);
 
                 // Check if this is a permanent error (like 404, 400, etc.) that shouldn't be retried
-                if (error instanceof OnChainDBError) {
-                    // OnChainDB errors with specific codes should stop polling
+                if (error instanceof OnDBError) {
+                    // OnDB errors with specific codes should stop polling
                     if (error.code === 'TASK_FAILED' || error.statusCode === 404 || error.statusCode === 400) {
                         console.error(`🚫 Stopping polling due to permanent error: ${error.message}`);
                         throw error;
@@ -1497,7 +1054,7 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
 
                 // For network/temporary errors, check if we've exceeded max wait time
                 if (Date.now() - startTime >= maxWaitTime) {
-                    throw new OnChainDBError(
+                    throw new OnDBError(
                         `Task completion timeout after ${maxWaitTime}ms. Last error: ${error instanceof Error ? error.message : String(error)}`,
                         'TASK_TIMEOUT'
                     );
@@ -1509,14 +1066,14 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
             }
         }
 
-        throw new OnChainDBError(
+        throw new OnDBError(
             `Task completion timeout after ${maxWaitTime}ms`,
             'TASK_TIMEOUT'
         );
     }
 
     /**
-     * Upload a blob (binary file) to OnChainDB with optional custom metadata fields
+     * Upload a blob (binary file) to OnDB with optional custom metadata fields
      *
      * Supports images, videos, documents, and any binary data up to 2MB.
      * Automatically handles multipart/form-data upload and returns a ticket for tracking.
@@ -1575,13 +1132,7 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
                 return await this.http.post<UploadBlobResponse>(
                     `/api/apps/${appId}/blobs/${request.collection}`,
                     formData,
-                    {
-                        headers: {
-                            'Content-Type': 'multipart/form-data',
-                            'X-App-Key': this.config.appKey,
-                            ...headers
-                        }
-                    }
+                    { headers: { 'Content-Type': 'multipart/form-data', ...headers } }
                 );
             };
 
@@ -1599,7 +1150,7 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
                     const quote = requirementToQuote(requirement, x402Response.accepts);
 
                     if (!paymentCallback) {
-                        throw new OnChainDBError(
+                        throw new OnDBError(
                             'Payment required but no payment callback provided',
                             'PAYMENT_REQUIRED',
                             402,
@@ -1621,13 +1172,13 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
                 throw error;
             }
         } catch (error) {
-            throw error instanceof OnChainDBError ? error :
-                new OnChainDBError('Failed to upload blob', 'BLOB_UPLOAD_ERROR');
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to upload blob', 'BLOB_UPLOAD_ERROR');
         }
     }
 
     /**
-     * Retrieve a blob (binary file) from OnChainDB by blob_id
+     * Retrieve a blob (binary file) from OnDB by blob_id
      *
      * Returns the raw blob data with proper Content-Type headers.
      * Can be used to serve images, videos, documents, etc.
@@ -1666,12 +1217,7 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
             // Retrieve blob via GET endpoint
             const response = await this.http.get(
                 `/api/apps/${appId}/blobs/${request.collection}/${request.blob_id}`,
-                {
-                    responseType: 'arraybuffer',
-                    headers: {
-                        'X-App-Key': this.config.appKey
-                    }
-                }
+                { responseType: 'arraybuffer' }
             );
 
             // Return as Blob in browser, Buffer in Node.js
@@ -1684,54 +1230,11 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
                 return Buffer.from(response.data);
             }
         } catch (error) {
-            throw error instanceof OnChainDBError ? error :
-                new OnChainDBError('Failed to retrieve blob', 'BLOB_RETRIEVAL_ERROR');
+            throw error instanceof OnDBError ? error :
+                new OnDBError('Failed to retrieve blob', 'BLOB_RETRIEVAL_ERROR');
         }
     }
 
-    /**
-     * Query blob metadata using the standard query interface
-     *
-     * Returns metadata about blobs without downloading the actual binary data.
-     * Useful for listing, filtering, and searching blobs by their metadata.
-     *
-     * @param collection - Blob collection name
-     * @param where - Query conditions for filtering blobs
-     * @returns Promise resolving to array of blob metadata records
-     *
-     * @example
-     * ```typescript
-     * // Query all blobs by user
-     * const userBlobs = await client.queryBlobMetadata('avatars', {
-     *   user_address: 'celestia1abc...'
-     * });
-     *
-     * // Query blobs by content type
-     * const images = await client.queryBlobMetadata('uploads', {
-     *   content_type: { $regex: 'image/' }
-     * });
-     *
-     * // Query recent blobs
-     * const recentBlobs = await client.queryBlobMetadata('files', {
-     *   uploaded_at: { $gte: '2024-01-01T00:00:00Z' }
-     * });
-     *
-     * // Access blob metadata
-     * for (const blob of userBlobs) {
-     *   console.log('Blob ID:', blob.blob_id);
-     *   console.log('Size:', blob.size_bytes);
-     *   console.log('Type:', blob.content_type);
-     *   console.log('Custom fields:', blob);
-     * }
-     * ```
-     */
-    async queryBlobMetadata(
-        collection: string,
-        where: Record<string, any> = {}
-    ): Promise<BlobMetadata[]> {
-        return await this.findMany<BlobMetadata>(collection, where);
-    }
-
     /**
      * Get default index type based on field type
      */
@@ -1750,6 +1253,17 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
         }
     }
 
+    private buildStoreResult(raw: any): StoreResponse {
+        return {
+            id: raw.id,
+            block_height: raw.celestia_height || 0,
+            transaction_hash: raw.blob_id || '',
+            celestia_height: raw.celestia_height || 0,
+            namespace: raw.namespace || '',
+            confirmed: raw.celestia_height > 0
+        };
+    }
+
     private validateStoreRequest(request: StoreRequest): void {
         // Validate that either root or collection is provided
         if (!request.root && !request.collection) {
@@ -1786,67 +1300,17 @@ export class OnChainDBClient extends EventEmitter<TransactionEvents> {
         }
     }
 
-    private handleHttpError(error: AxiosError): OnChainDBError {
-        console.error(error);
-        if (error.response) {
-            const statusCode = error.response.status;
-            const message = (error.response.data as any)?.error || error.message;
-
-
-            if (statusCode >= 400 && statusCode < 500) {
-                return new ValidationError(message, error.response.data);
-            }
-
-            return new OnChainDBError(
-                message,
-                'HTTP_ERROR',
-                statusCode,
-                error.response.data
-            );
-        }
-
-        if (error.request) {
-            return new OnChainDBError(
-                'Network error - could not reach OnChainDB service',
-                'NETWORK_ERROR'
-            );
-        }
-
-        return new OnChainDBError(error.message, 'UNKNOWN_ERROR');
-    }
-
     private sleep(ms: number): Promise<void> {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
 
-    /**
-     * Build root string from collection name using configured appId
-     *
-     * @param collection - Collection name
-     * @returns Full root string in format "appId::collection" or just collection for system ops
-     */
-    private buildRoot(collection: string): string {
-        if (!this.config.appId) {
-            return collection; // System operation or no appId configured
-        }
-        return `${this.config.appId}::${collection}`;
-    }
-
-    /**
-     * Resolve root parameter from request, building it if needed
-     *
-     * @param request - Store or Query request
-     * @returns Resolved root string
-     */
     private resolveRoot(request: { root?: string; collection?: string }): string {
         if (request.root) {
-            return request.root; // Explicit root takes precedence
+            return request.root;
         }
-
         if (request.collection) {
-            return this.buildRoot(request.collection); // Build from collection + appId
+            return this.config.appId ? `${this.config.appId}::${request.collection}` : request.collection;
         }
-
         throw new ValidationError('Either root or collection must be provided');
     }