@onchaindb/sdk 0.0.6

package/dist/client.js

@@ -0,0 +1,679 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnChainDBClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const eventemitter3_1 = require("eventemitter3");
+const types_1 = require("./types");
+const database_1 = require("./database");
+const query_sdk_1 = require("./query-sdk");
+class OnChainDBClient extends eventemitter3_1.EventEmitter {
+    constructor(config) {
+        super();
+        const appKey = config.appKey || config.apiKey || '';
+        const userKey = config.userKey || '';
+        this.config = {
+            endpoint: config.endpoint,
+            apiKey: appKey,
+            appKey: appKey,
+            userKey: userKey,
+            appId: config.appId || undefined,
+            timeout: config.timeout || 30000,
+            retryCount: config.retryCount || 3,
+            retryDelay: config.retryDelay || 1000
+        };
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (appKey) {
+            headers['X-App-Key'] = appKey;
+        }
+        if (userKey) {
+            headers['X-User-Key'] = userKey;
+        }
+        this.http = axios_1.default.create({
+            baseURL: this.config.endpoint,
+            timeout: this.config.timeout,
+            headers
+        });
+    }
+    database(appId) {
+        if (!this._database || this._database['appId'] !== appId) {
+            this._database = (0, database_1.createDatabaseManager)(this.http, this.config.endpoint, appId, this.config.apiKey);
+        }
+        return this._database;
+    }
+    async handlex420(response, paymentCallback, finalRequest, waitForConfirmation) {
+        console.log('💰 Received 402 Payment Required for store');
+        const x402Quote = response.data;
+        const requirement = x402Quote.accepts?.[0];
+        if (!requirement) {
+            throw new types_1.OnChainDBError('Invalid 402 response - no payment requirement', 'PAYMENT_ERROR', 402);
+        }
+        const quote = {
+            quote_id: requirement.quoteId,
+            total_cost_tia: parseInt(requirement.maxAmountRequired) / 1000000,
+            broker_address: requirement.payTo,
+            description: requirement.description,
+            expires_at: requirement.expiresAt
+        };
+        console.log('💳 Quote:', quote);
+        if (!paymentCallback) {
+            throw new types_1.OnChainDBError('Payment required but no payment callback provided. Please provide a payment callback to handle 402.', 'PAYMENT_REQUIRED', 402, quote);
+        }
+        console.log('💰 Calling payment callback...');
+        const payment = await paymentCallback(quote);
+        console.log('✅ Payment completed, tx hash:', payment.txHash);
+        const x402Payload = {
+            x402Version: 1,
+            scheme: payment.network?.includes('ethereum') || payment.network?.includes('sepolia')
+                ? 'ethereum-native' : 'celestia-native',
+            network: payment.network || 'mocha-4',
+            quoteId: requirement.quoteId,
+            payload: {
+                txHash: payment.txHash.toLowerCase(),
+                sender: 'unknown',
+                timestamp: Math.floor(Date.now() / 1000)
+            }
+        };
+        const encodedPayment = Buffer.from(JSON.stringify(x402Payload)).toString('base64');
+        console.log('📤 Retrying store with X-PAYMENT header...');
+        const retryResponse = await this.http.post('/store', finalRequest, {
+            headers: {
+                'X-PAYMENT': encodedPayment
+            }
+        });
+        console.log('Server response after payment:', retryResponse.data);
+        const serverResult = retryResponse.data;
+        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
+                    };
+                }
+            }
+            else {
+                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');
+    }
+    async store(request, paymentCallback, waitForConfirmation = true) {
+        this.validateStoreRequest(request);
+        const resolvedRequest = {
+            ...request,
+            root: this.resolveRoot(request)
+        };
+        try {
+            delete resolvedRequest.collection;
+            const response = await this.http.post('/store', resolvedRequest);
+            if (response.status === 402 && response.data) {
+                const v = await this.handlex420(response, paymentCallback, resolvedRequest, waitForConfirmation);
+                if (v) {
+                    return v;
+                }
+            }
+            console.log('Server response:', response.data);
+            const serverResult = response.data;
+            if (serverResult.ticket_id) {
+                console.log(`🎫 Got ticket ${serverResult.ticket_id}, polling for completion...`);
+                this.emit('transaction:queued', {
+                    ticket_id: serverResult.ticket_id,
+                    status: serverResult.status,
+                    message: serverResult.message
+                });
+                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
+                        };
+                        this.emit('transaction:confirmed', {
+                            id: result.id,
+                            status: 'confirmed',
+                            block_height: result.block_height,
+                            transaction_hash: result.transaction_hash,
+                            celestia_height: result.celestia_height
+                        });
+                        return result;
+                    }
+                    else {
+                        throw new types_1.OnChainDBError('Task completed but no storage results found', 'STORE_ERROR');
+                    }
+                }
+                else {
+                    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];
+            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
+            };
+            if (result.block_height === 0) {
+                this.emit('transaction:pending', {
+                    id: result.id,
+                    status: 'pending',
+                    block_height: result.block_height,
+                    transaction_hash: result.transaction_hash
+                });
+            }
+            else {
+                this.emit('transaction:confirmed', {
+                    id: result.id,
+                    status: 'confirmed',
+                    block_height: result.block_height,
+                    transaction_hash: result.transaction_hash,
+                    celestia_height: result.celestia_height
+                });
+            }
+            console.log('Transaction result:', result);
+            if (waitForConfirmation && result.block_height === 0) {
+                return await this.waitForConfirmation(result.transaction_hash);
+            }
+            return result;
+        }
+        catch (error) {
+            console.log("HERE", error);
+            if (error?.response) {
+                const err = error;
+                if (err.response?.status === 402 && err?.response?.data) {
+                    const v = await this.handlex420(err.response, paymentCallback, resolvedRequest, waitForConfirmation);
+                    if (v) {
+                        return v;
+                    }
+                }
+            }
+            const dbError = error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to store data', '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 getIndexCostEstimate(request) {
+        try {
+            const response = await this.http.post('/api/indexes/cost-estimate', request);
+            return response.data;
+        }
+        catch (error) {
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to get index cost estimate', 'COST_ESTIMATE_ERROR');
+        }
+    }
+    async getStorageCostEstimate(dataSizeBytes) {
+        try {
+            const response = await this.http.post('/api/storage/cost-estimate', {
+                data_size_bytes: dataSizeBytes
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to get storage cost estimate', 'COST_ESTIMATE_ERROR');
+        }
+    }
+    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');
+        }
+    }
+    async createIndex(request) {
+        try {
+            const appId = this.config.appId || 'default';
+            const response = await this.http.post(`/api/apps/${appId}/indexes`, request);
+            return response.data;
+        }
+        catch (error) {
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to create index', 'INDEX_ERROR');
+        }
+    }
+    async createRelation(request) {
+        try {
+            const appId = this.config.appId || 'default';
+            const response = await this.http.post(`/api/apps/${appId}/relations`, request);
+            return response.data;
+        }
+        catch (error) {
+            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');
+        }
+    }
+    async query(request) {
+        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();
+        }
+        catch (error) {
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to execute query', 'QUERY_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);
+    }
+    batch() {
+        const { BatchOperations } = require('./batch');
+        return new BatchOperations(this);
+    }
+    async findUnique(collection, where) {
+        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();
+        }
+        catch (error) {
+            console.error(`findUnique error for ${collection}:`, error);
+            return null;
+        }
+    }
+    async findMany(collection, where = {}, options = {}) {
+        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;
+        }
+        catch (error) {
+            console.error(`findMany error for ${collection}:`, error);
+            return [];
+        }
+    }
+    async createDocument(collection, data, paymentProof, 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],
+            ...paymentProof
+        });
+        return document;
+    }
+    async updateDocument(collection, where, data, paymentProof) {
+        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],
+            ...paymentProof
+        });
+        return updated;
+    }
+    async upsertDocument(collection, where, create, update, paymentProof, options) {
+        const existing = await this.findUnique(collection, where);
+        if (existing) {
+            return (await this.updateDocument(collection, where, update, paymentProof));
+        }
+        else {
+            return await this.createDocument(collection, create, paymentProof, options);
+        }
+    }
+    async deleteDocument(collection, where, paymentProof) {
+        const existing = await this.findUnique(collection, where);
+        if (!existing) {
+            return false;
+        }
+        const deleted = {
+            ...existing,
+            deleted: true,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.store({
+            collection,
+            data: [deleted],
+            ...paymentProof
+        });
+        return true;
+    }
+    async countDocuments(collection, where = {}) {
+        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();
+        }
+        catch (error) {
+            console.error(`countDocuments error for ${collection}:`, error);
+            return 0;
+        }
+    }
+    generateId() {
+        const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        let id = '';
+        for (let i = 0; i < 24; i++) {
+            id += chars[Math.floor(Math.random() * chars.length)];
+        }
+        return id;
+    }
+    async getTaskStatus(ticketId) {
+        try {
+            const response = await this.http.get(`/task/${ticketId}`);
+            return response.data;
+        }
+        catch (error) {
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to get task status', 'TASK_STATUS_ERROR');
+        }
+    }
+    async waitForTaskCompletion(ticketId, pollInterval = 2000, maxWaitTime = 600000) {
+        const startTime = Date.now();
+        console.log(`🔄 Waiting for task ${ticketId} to complete...`);
+        while (Date.now() - startTime < maxWaitTime) {
+            try {
+                const taskInfo = await this.getTaskStatus(ticketId);
+                if (typeof taskInfo.status === 'object') {
+                    console.log(`📊 Task ${ticketId} status:`, JSON.stringify(taskInfo.status));
+                }
+                else {
+                    console.log(`📊 Task ${ticketId} status: ${taskInfo.status}`);
+                }
+                if (taskInfo.status === 'Completed') {
+                    console.log(`✅ Task ${ticketId} completed successfully`);
+                    return taskInfo;
+                }
+                if (typeof taskInfo.status === 'object' && 'Failed' in taskInfo.status) {
+                    const error = taskInfo.status.Failed.error;
+                    console.error(`🚫 Task ${ticketId} failed: ${error}`);
+                    throw new types_1.OnChainDBError(`Task failed: ${error}`, 'TASK_FAILED');
+                }
+                if (typeof taskInfo.status === 'string' && taskInfo.status.toLowerCase().includes('error')) {
+                    console.error(`🚫 Task ${ticketId} has error status: ${taskInfo.status}`);
+                    throw new types_1.OnChainDBError(`Task error: ${taskInfo.status}`, 'TASK_FAILED');
+                }
+                await this.sleep(pollInterval);
+            }
+            catch (error) {
+                console.error(`❌ Error polling task ${ticketId}:`, error);
+                if (error instanceof types_1.OnChainDBError) {
+                    if (error.code === 'TASK_FAILED' || error.statusCode === 404 || error.statusCode === 400) {
+                        console.error(`🚫 Stopping polling due to permanent error: ${error.message}`);
+                        throw error;
+                    }
+                }
+                if (Date.now() - startTime >= maxWaitTime) {
+                    throw new types_1.OnChainDBError(`Task completion timeout after ${maxWaitTime}ms. Last error: ${error instanceof Error ? error.message : String(error)}`, 'TASK_TIMEOUT');
+                }
+                console.warn(`⚠️  Temporary error polling task ${ticketId}, retrying in ${pollInterval}ms...`);
+                await this.sleep(pollInterval);
+            }
+        }
+        throw new types_1.OnChainDBError(`Task completion timeout after ${maxWaitTime}ms`, 'TASK_TIMEOUT');
+    }
+    async uploadBlob(request) {
+        try {
+            const appId = this.config.appId;
+            if (!appId) {
+                throw new types_1.ValidationError('appId must be configured to upload blobs');
+            }
+            const formData = new FormData();
+            formData.append('blob', request.blob);
+            if (request.metadata) {
+                formData.append('metadata', JSON.stringify(request.metadata));
+            }
+            formData.append('payment_tx_hash', request.payment_tx_hash);
+            formData.append('user_address', request.user_address);
+            formData.append('broker_address', request.broker_address);
+            formData.append('amount_utia', String(request.amount_utia));
+            const response = await this.http.post(`/api/apps/${appId}/blobs/${request.collection}`, formData, {
+                headers: {
+                    'Content-Type': 'multipart/form-data',
+                    'X-App-Key': this.config.appKey
+                }
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to upload blob', 'BLOB_UPLOAD_ERROR');
+        }
+    }
+    async retrieveBlob(request) {
+        try {
+            const appId = this.config.appId;
+            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
+                }
+            });
+            if (typeof global.window !== 'undefined' && typeof Blob !== 'undefined') {
+                const contentType = response.headers['content-type'] || 'application/octet-stream';
+                return new Blob([response.data], { type: contentType });
+            }
+            else {
+                return Buffer.from(response.data);
+            }
+        }
+        catch (error) {
+            throw error instanceof types_1.OnChainDBError ? error :
+                new types_1.OnChainDBError('Failed to retrieve blob', 'BLOB_RETRIEVAL_ERROR');
+        }
+    }
+    async queryBlobMetadata(collection, where = {}) {
+        return await this.findMany(collection, where);
+    }
+    validateStoreRequest(request) {
+        if (!request.root && !request.collection) {
+            throw new types_1.ValidationError('Either root or collection must be provided');
+        }
+        if (request.root && typeof request.root !== 'string') {
+            throw new types_1.ValidationError('Root must be a valid string in format "app::collection"');
+        }
+        if (request.collection && typeof request.collection !== 'string') {
+            throw new types_1.ValidationError('Collection must be a valid string');
+        }
+        if (!request.data || !Array.isArray(request.data)) {
+            throw new types_1.ValidationError('Data must be an array of objects');
+        }
+        if (request.data.length === 0) {
+            throw new types_1.ValidationError('Data array cannot be empty');
+        }
+        for (const item of request.data) {
+            if (!item || typeof item !== 'object') {
+                throw new types_1.ValidationError('Each data item must be a valid object');
+            }
+        }
+        const dataSize = JSON.stringify(request.data).length;
+        if (dataSize > 5 * 1024 * 1024) {
+            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);
+        }
+        throw new types_1.ValidationError('Either root or collection must be provided');
+    }
+}
+exports.OnChainDBClient = OnChainDBClient;
+//# sourceMappingURL=client.js.map