@onchaindb/sdk 0.4.4 → 1.0.0

package/dist/client.js

@@ -15,11 +15,13 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
         super();
         const appKey = config.appKey || '';
         const userKey = config.userKey || '';
+        const agentKey = config.agentKey || '';
         this.config = {
             endpoint: config.endpoint,
             apiKey: config.apiKey || "",
             appKey: appKey,
             userKey: userKey,
+            agentKey: agentKey,
             appId: config.appId || undefined,
             timeout: config.timeout || 30000,
             retryCount: config.retryCount || 3,
@@ -37,6 +39,9 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
         if (userKey) {
             headers['X-User-Key'] = userKey;
         }
+        if (agentKey) {
+            headers['X-Agent-Key'] = agentKey;
+        }
         this.http = axios_1.default.create({
             baseURL: this.config.endpoint,
             timeout: this.config.timeout,
@@ -44,8 +49,12 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
         });
     }
     database(appId) {
-        if (!this._database || this._database['appId'] !== appId) {
-            this._database = (0, database_1.createDatabaseManager)(this.http, this.config.endpoint, appId, this.config.apiKey);
+        const resolvedAppId = appId || this.config.appId;
+        if (!resolvedAppId) {
+            throw new types_1.ValidationError('appId must be provided either in config or as an argument to database()');
+        }
+        if (!this._database || this._database['appId'] !== resolvedAppId) {
+            this._database = (0, database_1.createDatabaseManager)(this.http, resolvedAppId, this.config.apiKey);
         }
         return this._database;
     }
@@ -115,28 +124,12 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
         if (serverResult.ticket_id) {
             if (waitForConfirmation) {
                 const taskInfo = await this.waitForTaskCompletion(serverResult.ticket_id);
-                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 {
-                    id: serverResult.ticket_id,
-                    block_height: 0,
-                    transaction_hash: '',
-                    celestia_height: 0,
-                    namespace: '',
-                    confirmed: false,
-                    ticket_id: serverResult.ticket_id
-                };
+                return { id: serverResult.ticket_id, block_height: 0, transaction_hash: '', celestia_height: 0, namespace: '', confirmed: false, ticket_id: serverResult.ticket_id };
             }
         }
         throw new types_1.OnChainDBError('No ticket_id in response after payment', 'STORE_ERROR');
@@ -150,12 +143,6 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
         try {
             delete resolvedRequest.collection;
             const response = await this.http.post('/store', resolvedRequest);
-            if (response.status === 402 && response.data) {
-                const v = await this.handleX402(response, paymentCallback, resolvedRequest, waitForConfirmation);
-                if (v) {
-                    return v;
-                }
-            }
             const serverResult = response.data;
             if (serverResult.ticket_id) {
                 this.emit('transaction:queued', {
@@ -165,16 +152,8 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
                 });
                 if (waitForConfirmation) {
                     const taskInfo = await this.waitForTaskCompletion(serverResult.ticket_id);
-                    if (taskInfo.result && taskInfo.result.results && taskInfo.result.results.length > 0) {
-                        const firstResult = taskInfo.result.results[0];
-                        const result = {
-                            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) {
+                        const result = this.buildStoreResult(taskInfo.result.results[0]);
                         this.emit('transaction:confirmed', {
                             id: result.id,
                             status: 'confirmed',
@@ -189,29 +168,14 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
                     }
                 }
                 else {
-                    return {
-                        id: serverResult.ticket_id,
-                        block_height: 0,
-                        transaction_hash: '',
-                        celestia_height: 0,
-                        namespace: '',
-                        confirmed: false,
-                        ticket_id: serverResult.ticket_id
-                    };
+                    return { id: serverResult.ticket_id, block_height: 0, transaction_hash: '', celestia_height: 0, namespace: '', confirmed: false, ticket_id: serverResult.ticket_id };
                 }
             }
-            const firstResult = serverResult.results && serverResult.results[0];
+            const firstResult = serverResult.results?.[0];
             if (!firstResult) {
                 throw new types_1.OnChainDBError('No results returned from server', 'STORE_ERROR');
             }
-            const result = {
-                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);
             if (result.block_height === 0) {
                 this.emit('transaction:pending', {
                     id: result.id,
@@ -229,9 +193,6 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
                     celestia_height: result.celestia_height
                 });
             }
-            if (waitForConfirmation && result.block_height === 0) {
-                return await this.waitForConfirmation(result.transaction_hash);
-            }
             return result;
         }
         catch (error) {
@@ -245,66 +206,13 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
                 }
                 throw new types_1.OnChainDBError(JSON.stringify(err.response?.data), 'STORE_ERROR');
             }
+            console.error(error);
             const dbError = error instanceof types_1.OnChainDBError ? error :
                 new types_1.OnChainDBError(error.message, 'STORE_ERROR');
             this.emit('error', dbError);
             throw dbError;
         }
     }
-    async storeAndConfirm(request) {
-        return this.store(request, undefined, true);
-    }
-    async waitForConfirmation(transactionHash, maxWaitTime = 300000) {
-        const startTime = Date.now();
-        const pollInterval = 3000;
-        console.log(`🔄 Waiting for transaction ${transactionHash} confirmation...`);
-        while (Date.now() - startTime < maxWaitTime) {
-            try {
-                const rpcUrl = 'https://celestia-mocha-rpc.publicnode.com:443';
-                const txUrl = `${rpcUrl}/tx?hash=0x${transactionHash}`;
-                console.log(`🔍 Checking transaction status: attempt ${Math.floor((Date.now() - startTime) / pollInterval) + 1}`);
-                const response = await axios_1.default.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 = {
-                            id: transactionHash,
-                            namespace: '',
-                            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;
-                    }
-                }
-                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) {
-                if (Date.now() - startTime >= maxWaitTime) {
-                    throw new types_1.TransactionError(`Transaction confirmation timeout after ${maxWaitTime}ms`, transactionHash);
-                }
-                console.log(`⚠️ Error checking transaction (will retry): ${error}`);
-                await this.sleep(pollInterval);
-            }
-        }
-        throw new types_1.TransactionError(`Transaction confirmation timeout after ${maxWaitTime}ms`, transactionHash);
-    }
     async createIndex(request) {
         try {
             const appId = this.config.appId || 'default';
@@ -390,18 +298,6 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
             success: true,
             errors: []
         };
-        let existingIndexes = [];
-        try {
-            const response = await this.http.get(`/api/apps/${appId}/collections/${schema.name}/indexes`);
-            existingIndexes = response.data?.indexes || response.data || [];
-        }
-        catch (error) {
-            existingIndexes = [];
-        }
-        const existingByField = new Map();
-        for (const idx of existingIndexes) {
-            existingByField.set(idx.field_name, { type: idx.index_type, name: idx.name });
-        }
         const allFields = {};
         if (schema.useBaseFields !== false) {
             Object.assign(allFields, OnChainDBClient.BASE_FIELDS);
@@ -414,7 +310,7 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
             }
         }
         for (const fieldName of desiredIndexedFields) {
-            if (!existingByField.has(fieldName)) {
+            {
                 const fieldDef = allFields[fieldName];
                 const indexType = fieldDef.indexType || this.getDefaultIndexType(fieldDef.type);
                 try {
@@ -448,232 +344,237 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
                 }
             }
         }
-        for (const [fieldName, existing] of existingByField) {
-            if (!desiredIndexedFields.has(fieldName)) {
-                try {
-                    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;
             }
-        }
-        for (const [fieldName, existing] of existingByField) {
-            if (desiredIndexedFields.has(fieldName)) {
-                result.unchanged.push({
-                    field: fieldName,
-                    type: existing.type
-                });
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                result.errors.push(`Failed to configure sharding: ${errorMsg}`);
+                result.success = false;
             }
         }
         return result;
     }
-    async getCollectionInfo(collection) {
+    async setupSharding(collection, sharding) {
         const appId = this.config.appId;
         if (!appId) {
+            throw new types_1.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 types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to setup sharding', 'SHARDING_ERROR');
+        }
+    }
+    async deleteCollection(collection) {
+        const appId = this.config.appId;
+        if (!appId)
             throw new types_1.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 types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to delete collection', 'COLLECTION_ERROR');
+        }
+    }
+    async updateCollection(collection, updates) {
+        const appId = this.config.appId;
+        if (!appId)
+            throw new types_1.ValidationError('appId must be configured');
         try {
-            const response = await this.http.get(`/api/apps/${appId}/collections/${collection}`);
+            const response = await this.http.patch(`/api/apps/${appId}/collections/${collection}`, updates);
             return response.data;
         }
         catch (error) {
             throw error instanceof types_1.OnChainDBError ? error :
-                new types_1.OnChainDBError('Failed to get collection info', 'COLLECTION_ERROR');
+                new types_1.OnChainDBError('Failed to update collection', 'COLLECTION_ERROR');
         }
     }
-    async createRelation(request) {
+    async getRetention(collection) {
+        const appId = this.config.appId;
+        if (!appId)
+            throw new types_1.ValidationError('appId must be configured');
         try {
-            const appId = this.config.appId || 'default';
-            const response = await this.http.post(`/api/apps/${appId}/relations`, request);
+            const response = await this.http.get(`/api/apps/${appId}/collections/${collection}/retention`);
             return response.data;
         }
         catch (error) {
             throw error instanceof types_1.OnChainDBError ? error :
-                new types_1.OnChainDBError('Failed to create relation', 'RELATION_ERROR');
+                new types_1.OnChainDBError('Failed to get retention config', 'RETENTION_ERROR');
         }
     }
-    async health() {
+    async setRetention(collection, request) {
+        const appId = this.config.appId;
+        if (!appId)
+            throw new types_1.ValidationError('appId must be configured');
         try {
-            const response = await this.http.get('/');
+            const response = await this.http.post(`/api/apps/${appId}/collections/${collection}/retention`, request);
             return response.data;
         }
         catch (error) {
-            throw new types_1.OnChainDBError('Health check failed', 'HEALTH_ERROR');
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to set retention config', 'RETENTION_ERROR');
         }
     }
-    async getPricingQuote(request) {
+    async getRetentionCost() {
+        const appId = this.config.appId;
+        if (!appId)
+            throw new types_1.ValidationError('appId must be configured');
         try {
-            const response = await this.http.post('/api/pricing/quote', request);
+            const response = await this.http.get(`/api/apps/${appId}/retention/cost`);
             return response.data;
         }
         catch (error) {
             throw error instanceof types_1.OnChainDBError ? error :
-                new types_1.OnChainDBError('Failed to get pricing quote', 'PRICING_QUOTE_ERROR');
+                new types_1.OnChainDBError('Failed to get retention cost', 'RETENTION_ERROR');
         }
     }
-    async query(request) {
+    async sql(query, options) {
         try {
-            const queryBuilder = this.queryBuilder();
-            const root = this.resolveRoot(request);
-            if (request.filters) {
-                queryBuilder.find(builder => {
-                    const conditions = Object.entries(request.filters).map(([field, value]) => query_sdk_1.LogicalOperator.Condition(builder.field(field).equals(value)));
-                    return conditions.length === 1 ? conditions[0] : query_sdk_1.LogicalOperator.And(conditions);
-                });
-            }
-            if (request.limit) {
-                queryBuilder.limit(request.limit);
-            }
-            if (request.offset) {
-                queryBuilder.offset(request.offset);
-            }
-            return await queryBuilder.execute();
+            const body = { 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 types_1.OnChainDBError ? error :
-                new types_1.OnChainDBError('Failed to execute query', 'QUERY_ERROR');
+                new types_1.OnChainDBError('SQL query failed', 'SQL_ERROR');
         }
     }
-    queryBuilder() {
-        const { AxiosHttpClient } = require('./query-sdk/adapters/HttpClientAdapter');
-        const httpClient = new AxiosHttpClient(this.http);
-        return new query_sdk_1.QueryBuilder(httpClient, this.config.endpoint, this.config.appId);
+    async sqlInsert(sql) {
+        try {
+            const body = { sql };
+            const response = await this.http.post('/insert/sql', body);
+            return response.data;
+        }
+        catch (error) {
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('SQL insert failed', 'SQL_ERROR');
+        }
     }
-    batch() {
-        const { BatchOperations } = require('./batch');
-        return new BatchOperations(this);
+    async listQueries() {
+        const appId = this.config.appId;
+        if (!appId)
+            throw new types_1.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 types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to list predefined queries', 'QUERY_ERROR');
+        }
     }
-    async findUnique(collection, where) {
+    async createQuery(request) {
+        const appId = this.config.appId;
+        if (!appId)
+            throw new types_1.ValidationError('appId must be configured');
         try {
-            let queryBuilder = this.queryBuilder().collection(collection);
-            for (const [field, value] of Object.entries(where)) {
-                queryBuilder = queryBuilder.whereField(field).equals(value);
-            }
-            return await queryBuilder.selectAll().executeUnique();
+            const response = await this.http.post(`/apps/${appId}/queries`, request);
+            return response.data;
         }
         catch (error) {
-            console.error(`findUnique error for ${collection}:`, error);
-            return null;
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to create predefined query', 'QUERY_ERROR');
         }
     }
-    async findMany(collection, where = {}, options = {}) {
+    async getQuery(name) {
+        const appId = this.config.appId;
+        if (!appId)
+            throw new types_1.ValidationError('appId must be configured');
         try {
-            let queryBuilder = this.queryBuilder().collection(collection);
-            for (const [field, value] of Object.entries(where)) {
-                queryBuilder = queryBuilder.whereField(field).equals(value);
-            }
-            if (options.limit) {
-                queryBuilder = queryBuilder.limit(options.limit);
-            }
-            if (options.offset) {
-                queryBuilder = queryBuilder.offset(options.offset);
-            }
-            const result = await queryBuilder.selectAll().execute();
-            if (!result.records) {
-                return [];
-            }
-            let records = result.records;
-            if (options.sort) {
-                records = records.sort((a, b) => {
-                    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;
+            const response = await this.http.get(`/apps/${appId}/queries/${name}`);
+            return response.data;
         }
         catch (error) {
-            console.error(`findMany error for ${collection}:`, error);
-            return [];
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to get predefined query', 'QUERY_ERROR');
         }
     }
-    async createDocument(collection, data, paymentCallback, options) {
-        const document = {
-            id: options?.idGenerator ? options.idGenerator() : this.generateId(),
-            ...data,
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-        };
-        await this.store({
-            collection,
-            data: [document],
-        }, paymentCallback);
-        return document;
-    }
-    async updateDocument(collection, where, data, paymentCallback) {
-        const current = await this.findUnique(collection, where);
-        if (!current) {
-            return null;
-        }
-        const updated = {
-            ...current,
-            ...data,
-            updatedAt: new Date().toISOString(),
-        };
-        await this.store({
-            collection,
-            data: [updated],
-        }, paymentCallback);
-        return updated;
+    async deleteQuery(name) {
+        const appId = this.config.appId;
+        if (!appId)
+            throw new types_1.ValidationError('appId must be configured');
+        try {
+            const response = await this.http.delete(`/apps/${appId}/queries/${name}`);
+            return response.data;
+        }
+        catch (error) {
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to delete predefined query', 'QUERY_ERROR');
+        }
     }
-    async upsertDocument(collection, where, create, update, paymentCallback, options) {
-        const existing = await this.findUnique(collection, where);
-        if (existing) {
-            return (await this.updateDocument(collection, where, update, paymentCallback));
+    async executeQuery(name, params, version) {
+        const appId = this.config.appId;
+        if (!appId)
+            throw new types_1.ValidationError('appId must be configured');
+        try {
+            const queryParams = { ...params };
+            if (version !== undefined)
+                queryParams['v'] = version;
+            const response = await this.http.get(`/api/queries/${appId}/${name}/data`, { params: queryParams });
+            return response.data;
         }
-        else {
-            return await this.createDocument(collection, create, paymentCallback, options);
+        catch (error) {
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to execute predefined query', 'QUERY_ERROR');
         }
     }
-    async deleteDocument(collection, where, paymentCallback) {
-        const existing = await this.findUnique(collection, where);
-        if (!existing) {
-            return false;
+    async getCollectionInfo(collectionId) {
+        const appId = this.config.appId;
+        if (!appId) {
+            throw new types_1.ValidationError('appId must be configured');
+        }
+        try {
+            const response = await this.http.get(`/api/apps/${appId}/collections/${collectionId}`);
+            return response.data;
+        }
+        catch (error) {
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to get collection info', 'COLLECTION_ERROR');
         }
-        const deleted = {
-            ...existing,
-            deleted: true,
-            updatedAt: new Date().toISOString(),
-        };
-        await this.store({
-            collection,
-            data: [deleted],
-        }, paymentCallback);
-        return true;
     }
-    async countDocuments(collection, where = {}) {
+    async createRelation(request) {
         try {
-            let queryBuilder = this.queryBuilder().collection(collection);
-            for (const [field, value] of Object.entries(where)) {
-                queryBuilder = queryBuilder.whereField(field).equals(value);
-            }
-            return await queryBuilder.count();
+            const appId = this.config.appId || 'default';
+            const response = await this.http.post(`/api/apps/${appId}/relations`, request);
+            return response.data;
         }
         catch (error) {
-            console.error(`countDocuments error for ${collection}:`, error);
-            return 0;
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to create relation', 'RELATION_ERROR');
+        }
+    }
+    async health() {
+        try {
+            const response = await this.http.get('/');
+            return response.data;
+        }
+        catch (error) {
+            throw new types_1.OnChainDBError('Health check failed', 'HEALTH_ERROR');
         }
     }
-    generateId() {
-        const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-        let id = '';
-        for (let i = 0; i < 24; i++) {
-            id += chars[Math.floor(Math.random() * chars.length)];
+    async getPricingQuote(request) {
+        try {
+            const response = await this.http.post('/api/pricing/quote', request);
+            return response.data;
+        }
+        catch (error) {
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to get pricing quote', 'PRICING_QUOTE_ERROR');
         }
-        return id;
+    }
+    queryBuilder() {
+        const { AxiosHttpClient } = require('./query-sdk/adapters/HttpClientAdapter');
+        const httpClient = new AxiosHttpClient(this.http);
+        return new query_sdk_1.QueryBuilder(httpClient, this.config.endpoint, this.config.appId);
     }
     async getTaskStatus(ticketId) {
         try {
@@ -741,13 +642,7 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
                 formData.append('metadata', JSON.stringify(request.metadata));
             }
             const uploadWithHeaders = async (headers = {}) => {
-                return await this.http.post(`/api/apps/${appId}/blobs/${request.collection}`, formData, {
-                    headers: {
-                        'Content-Type': 'multipart/form-data',
-                        'X-App-Key': this.config.appKey,
-                        ...headers
-                    }
-                });
+                return await this.http.post(`/api/apps/${appId}/blobs/${request.collection}`, formData, { headers: { 'Content-Type': 'multipart/form-data', ...headers } });
             };
             try {
                 const response = await uploadWithHeaders();
@@ -785,12 +680,7 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
             if (!appId) {
                 throw new types_1.ValidationError('appId must be configured to retrieve blobs');
             }
-            const response = await this.http.get(`/api/apps/${appId}/blobs/${request.collection}/${request.blob_id}`, {
-                responseType: 'arraybuffer',
-                headers: {
-                    'X-App-Key': this.config.appKey
-                }
-            });
+            const response = await this.http.get(`/api/apps/${appId}/blobs/${request.collection}/${request.blob_id}`, { responseType: 'arraybuffer' });
             if (typeof global.window !== 'undefined' && typeof Blob !== 'undefined') {
                 const contentType = response.headers['content-type'] || 'application/octet-stream';
                 return new Blob([response.data], { type: contentType });
@@ -804,9 +694,6 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
                 new types_1.OnChainDBError('Failed to retrieve blob', 'BLOB_RETRIEVAL_ERROR');
         }
     }
-    async queryBlobMetadata(collection, where = {}) {
-        return await this.findMany(collection, where);
-    }
     getDefaultIndexType(fieldType) {
         switch (fieldType) {
             case 'string':
@@ -821,6 +708,16 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
                 return 'string';
         }
     }
+    buildStoreResult(raw) {
+        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
+        };
+    }
     validateStoreRequest(request) {
         if (!request.root && !request.collection) {
             throw new types_1.ValidationError('Either root or collection must be provided');
@@ -847,36 +744,15 @@ class OnChainDBClient extends eventemitter3_1.EventEmitter {
             throw new types_1.ValidationError('Total data size exceeds 5MB limit');
         }
     }
-    handleHttpError(error) {
-        console.error(error);
-        if (error.response) {
-            const statusCode = error.response.status;
-            const message = error.response.data?.error || error.message;
-            if (statusCode >= 400 && statusCode < 500) {
-                return new types_1.ValidationError(message, error.response.data);
-            }
-            return new types_1.OnChainDBError(message, 'HTTP_ERROR', statusCode, error.response.data);
-        }
-        if (error.request) {
-            return new types_1.OnChainDBError('Network error - could not reach OnChainDB service', 'NETWORK_ERROR');
-        }
-        return new types_1.OnChainDBError(error.message, 'UNKNOWN_ERROR');
-    }
     sleep(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
-    buildRoot(collection) {
-        if (!this.config.appId) {
-            return collection;
-        }
-        return `${this.config.appId}::${collection}`;
-    }
     resolveRoot(request) {
         if (request.root) {
             return request.root;
         }
         if (request.collection) {
-            return this.buildRoot(request.collection);
+            return this.config.appId ? `${this.config.appId}::${request.collection}` : request.collection;
         }
         throw new types_1.ValidationError('Either root or collection must be provided');
     }