hive-stream 2.0.6 → 3.0.1

package/dist/adapters/sqlite.adapter.js

@@ -1,398 +1,562 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqliteAdapter = void 0;
-const base_adapter_1 = require("./base.adapter");
-const sqlite3_1 = require("sqlite3");
-const path_1 = __importDefault(require("path"));
-class SqliteAdapter extends base_adapter_1.AdapterBase {
-    db = new sqlite3_1.Database(path_1.default.resolve(__dirname, 'hive-stream.db'));
-    blockNumber;
-    lastBlockNumber;
-    blockId;
-    prevBlockId;
-    transactionId;
-    getDb() {
-        return this.db;
-    }
-    async create() {
-        return new Promise((resolve) => {
-            this.db.serialize(() => {
-                const params = `CREATE TABLE IF NOT EXISTS params ( id INTEGER PRIMARY KEY, lastBlockNumber NUMERIC, actions TEXT )`;
-                const transfers = `CREATE TABLE IF NOT EXISTS transfers ( id TEXT NOT NULL UNIQUE, blockId TEXT, blockNumber INTEGER, sender TEXT, amount TEXT, contractName TEXT, contractAction TEXT, contractPayload TEXT)`;
-                const customJson = `CREATE TABLE IF NOT EXISTS customJson ( id TEXT NOT NULL UNIQUE, blockId TEXT, blockNumber INTEGER, sender TEXT, isSignedWithActiveKey INTEGER, contractName TEXT, contractAction TEXT, contractPayload TEXT)`;
-                const events = `CREATE TABLE IF NOT EXISTS events ( id INTEGER PRIMARY KEY, date TEXT, contract TEXT, action TEXT, payload TEXT, data TEXT )`;
-                this.db
-                    .run(params)
-                    .run(transfers)
-                    .run(customJson)
-                    .run(events, () => {
-                    resolve(true);
-                });
-            });
-        });
-    }
-    async loadActions() {
-        const state = await this.loadState();
-        if (state) {
-            return (state?.actions) ? state.actions : [];
-        }
-        return [];
-    }
-    async loadState() {
-        return new Promise((resolve, reject) => {
-            this.db.all('SELECT actions, lastBlockNumber FROM params LIMIT 1', (err, rows) => {
-                if (!err) {
-                    if (rows.length) {
-                        const row = rows[0];
-                        row.actions = JSON.parse(row.actions) ?? [];
-                        resolve(row);
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async saveState(data) {
-        return new Promise((resolve, reject) => {
-            const sql = `REPLACE INTO params (id, actions, lastBlockNumber) VALUES(1, '${JSON.stringify(data.actions)}', '${data.lastBlockNumber}')`;
-            this.db.run(sql, [], (err, result) => {
-                if (!err) {
-                    resolve(true);
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async processOperation(op, blockNumber, blockId, prevBlockId, trxId, blockTime) {
-        this.blockNumber = blockNumber;
-        this.blockId = blockId;
-        this.prevBlockId = prevBlockId;
-        this.transactionId = trxId;
-    }
-    async processTransfer(operation, payload, metadata) {
-        return new Promise((resolve, reject) => {
-            const sql = `INSERT INTO transfers (id, blockId, blockNumber, sender, amount, contractName, contractAction, contractPayload) 
-            VALUES ('${this.transactionId}', '${this.blockId}', ${this.blockNumber}, '${metadata.sender}', '${metadata.amount}', '${payload.name}', '${payload.action}', '${JSON.stringify(payload.payload)}')`;
-            this.db.run(sql, [], (err, result) => {
-                if (!err) {
-                    resolve(true);
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async processCustomJson(operation, payload, metadata) {
-        return new Promise((resolve, reject) => {
-            const sql = `INSERT INTO customJson (id, blockId, blockNumber, sender, isSignedWithActiveKey, contractName, contractAction, contractPayload) 
-            VALUES ('${this.transactionId}', '${this.blockId}', ${this.blockNumber},'${metadata.sender}', ${metadata.isSignedWithActiveKey}, '${payload.name}', '${payload.action}', '${JSON.stringify(payload.payload)}')`;
-            this.db.run(sql, [], (err, result) => {
-                if (!err) {
-                    resolve(true);
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async addEvent(date, contract, action, payload, data) {
-        return new Promise((resolve, reject) => {
-            const sql = `INSERT INTO events (date, contract, action, payload, data) 
-            VALUES ('${date}', '${contract}', '${action}', '${JSON.stringify(payload)}', '${JSON.stringify(data)}')`;
-            this.db.run(sql, [], (err, result) => {
-                if (!err) {
-                    resolve(true);
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async getTransfers() {
-        return new Promise((resolve, reject) => {
-            this.db.all('SELECT id, blockId, blockNumber, sender, amount, contractName, contractAction, contractPayload FROM transfers', (err, rows) => {
-                if (!err) {
-                    if (rows.length) {
-                        resolve(rows.reduce((arr, row) => {
-                            row.contractPayload = JSON.parse(row.contractPayload) ?? {};
-                            arr.push(row);
-                            return arr;
-                        }, []));
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async getEvents() {
-        return new Promise((resolve, reject) => {
-            this.db.all('SELECT id, date, contract, action, payload, data FROM events', (err, rows) => {
-                if (!err) {
-                    if (rows.length) {
-                        resolve(rows.reduce((arr, row) => {
-                            row.payload = JSON.parse(row.payload) ?? {};
-                            row.data = JSON.parse(row.data) ?? {};
-                            arr.push(row);
-                            return arr;
-                        }, []));
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async getTransfersByContract(contract) {
-        return new Promise((resolve, reject) => {
-            this.db.all(`SELECT id, blockId, blockNumber, sender, amount, contractName, contractAction, contractPayload FROM transfers WHERE contractName = '${contract}'`, (err, rows) => {
-                if (!err) {
-                    if (rows.length) {
-                        resolve(rows.reduce((arr, row) => {
-                            row.contractPayload = JSON.parse(row.contractPayload) ?? {};
-                            arr.push(row);
-                            return arr;
-                        }, []));
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async getTransfersByAccount(account) {
-        return new Promise((resolve, reject) => {
-            this.db.all(`SELECT id, blockId, blockNumber, sender, amount, contractName, contractAction, contractPayload FROM transfers WHERE sender = '${account}'`, (err, rows) => {
-                if (!err) {
-                    if (rows.length) {
-                        resolve(rows.reduce((arr, row) => {
-                            row.contractPayload = JSON.parse(row.contractPayload) ?? {};
-                            arr.push(row);
-                            return arr;
-                        }, []));
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async getTransfersByBlockid(blockId) {
-        return new Promise((resolve, reject) => {
-            this.db.all(`SELECT id, blockId, blockNumber, sender, amount, contractName, contractAction, contractPayload FROM transfers WHERE blockId = ${blockId}`, (err, rows) => {
-                if (!err) {
-                    if (rows.length) {
-                        resolve(rows.reduce((arr, row) => {
-                            row.contractPayload = JSON.parse(row.contractPayload) ?? {};
-                            arr.push(row);
-                            return arr;
-                        }, []));
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async getJson() {
-        return new Promise((resolve, reject) => {
-            this.db.all('SELECT id, blockId, blockNumber, sender, isSignedWithActiveKey, contractName, contractAction, contractPayload FROM customJson', (err, rows) => {
-                if (!err) {
-                    if (rows.length) {
-                        resolve(rows.reduce((arr, row) => {
-                            row.contractPayload = JSON.parse(row.contractPayload) ?? {};
-                            arr.push(row);
-                            return arr;
-                        }, []));
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async getJsonByContract(contract) {
-        return new Promise((resolve, reject) => {
-            this.db.all(`SELECT id, blockId, blockNumber, sender, isSignedWithActiveKey, contractName, contractAction, contractPayload FROM customJson WHERE contractName = '${contract}'`, (err, rows) => {
-                if (!err) {
-                    if (rows.length) {
-                        resolve(rows.reduce((arr, row) => {
-                            row.contractPayload = JSON.parse(row.contractPayload) ?? {};
-                            arr.push(row);
-                            return arr;
-                        }, []));
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async getJsonByAccount(account) {
-        return new Promise((resolve, reject) => {
-            this.db.all(`SELECT id, blockId, blockNumber, sender, isSignedWithActiveKey, contractName, contractAction, contractPayload FROM customJson WHERE sender = '${account}'`, (err, rows) => {
-                if (!err) {
-                    if (rows.length) {
-                        resolve(rows.reduce((arr, row) => {
-                            row.contractPayload = JSON.parse(row.contractPayload) ?? {};
-                            arr.push(row);
-                            return arr;
-                        }, []));
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async getJsonByBlockid(blockId) {
-        return new Promise((resolve, reject) => {
-            this.db.all(`SELECT id, blockId, blockNumber, sender, isSignedWithActiveKey, contractName, contractAction, contractPayload FROM customJson WHERE blockId = ${blockId}`, (err, rows) => {
-                if (!err) {
-                    if (rows.length) {
-                        resolve(rows.reduce((arr, row) => {
-                            row.contractPayload = JSON.parse(row.contractPayload) ?? {};
-                            arr.push(row);
-                            return arr;
-                        }, []));
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async destroy() {
-        return new Promise((resolve, reject) => {
-            this.db.close((err) => {
-                if (!err) {
-                    resolve(true);
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async find(table, query) {
-        return new Promise((resolve, reject) => {
-            query = Object.keys(query).reduce((arr, key) => {
-                arr.push(`${key} = ${query[key]}`);
-                return arr;
-            }, []).join(' AND ');
-            this.db.all(`SELECT * FROM ${table} WHERE ${query}`, (err, rows) => {
-                if (!err) {
-                    if (rows.length) {
-                        resolve(rows);
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async findOne(table, query) {
-        return new Promise((resolve, reject) => {
-            query = Object.keys(query).reduce((arr, key) => {
-                arr.push(`${key} = ${query[key]}`);
-                return arr;
-            }, []).join(' AND ');
-            this.db.get(`SELECT * FROM ${table} WHERE ${query}`, (err, row) => {
-                if (!err) {
-                    if (row) {
-                        resolve(row);
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async insert(table, data) {
-        return new Promise((resolve, reject) => {
-            this.db.run(`INSERT INTO ${table} VALUES (${data})`, (err) => {
-                if (!err) {
-                    resolve(true);
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    async replace(table, queryObject, data) {
-        return new Promise((resolve, reject) => {
-            queryObject = Object.keys(queryObject).reduce((arr, key) => {
-                arr.push(`${key} = ${queryObject[key]}`);
-                return arr;
-            }, []).join(' AND ');
-            this.db.run(`REPLACE INTO ${table} ${queryObject} VALUES (${data})`, (err) => {
-                if (!err) {
-                    resolve(data);
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-}
-exports.SqliteAdapter = SqliteAdapter;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteAdapter = void 0;
+const actions_1 = require("./../actions");
+const base_adapter_1 = require("./base.adapter");
+const knex_1 = require("knex");
+const path_1 = __importDefault(require("path"));
+class SqliteAdapter extends base_adapter_1.AdapterBase {
+    dbPath;
+    constructor(dbPath) {
+        super();
+        this.dbPath = dbPath || path_1.default.resolve(__dirname, 'hive-stream.db');
+        this.db = (0, knex_1.knex)({
+            client: 'better-sqlite3',
+            connection: {
+                filename: this.dbPath
+            },
+            useNullAsDefault: true,
+            pool: {
+                afterCreate: (conn, cb) => {
+                    conn.pragma('journal_mode = WAL');
+                    cb();
+                }
+            }
+        });
+    }
+    blockNumber;
+    lastBlockNumber;
+    blockId;
+    prevBlockId;
+    transactionId;
+    getDb() {
+        return this.db;
+    }
+    async create() {
+        try {
+            await this.db.schema.createTableIfNotExists('params', table => {
+                table.integer('id').primary();
+                table.integer('lastBlockNumber');
+                table.text('actions');
+            });
+            await this.db.schema.createTableIfNotExists('transfers', table => {
+                table.text('id').primary();
+                table.text('blockId');
+                table.integer('blockNumber');
+                table.text('sender');
+                table.text('amount');
+                table.text('contractName');
+                table.text('contractAction');
+                table.text('contractPayload');
+            });
+            await this.db.schema.createTableIfNotExists('customJson', table => {
+                table.text('id').primary();
+                table.text('blockId');
+                table.integer('blockNumber');
+                table.text('sender');
+                table.integer('isSignedWithActiveKey');
+                table.text('contractName');
+                table.text('contractAction');
+                table.text('contractPayload');
+            });
+            await this.db.schema.createTableIfNotExists('events', table => {
+                table.increments('id').primary();
+                table.text('date');
+                table.text('contract');
+                table.text('action');
+                table.text('payload');
+                table.text('data');
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error creating tables:', error);
+            throw error;
+        }
+    }
+    async loadActions() {
+        const state = await this.loadState();
+        if (state && state.actions) {
+            try {
+                return state.actions.map((actionData) => {
+                    try {
+                        return actions_1.TimeAction.fromJSON(actionData);
+                    }
+                    catch (error) {
+                        console.warn(`[SqliteAdapter] Failed to restore action ${actionData?.id || 'unknown'}:`, error);
+                        return null;
+                    }
+                }).filter(Boolean);
+            }
+            catch (error) {
+                console.error('[SqliteAdapter] Error loading actions:', error);
+                return [];
+            }
+        }
+        return [];
+    }
+    async loadState() {
+        try {
+            const row = await this.db('params')
+                .select('actions', 'lastBlockNumber')
+                .first();
+            if (row) {
+                try {
+                    row.actions = row.actions ? JSON.parse(row.actions) : [];
+                }
+                catch (parseError) {
+                    console.warn('[SqliteAdapter] Failed to parse actions from database, using empty array:', parseError);
+                    row.actions = [];
+                }
+                return row;
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error loading state:', error);
+            throw error;
+        }
+    }
+    async saveState(data) {
+        try {
+            let actionsJson;
+            try {
+                actionsJson = JSON.stringify(data.actions || []);
+            }
+            catch (error) {
+                console.error('[SqliteAdapter] Failed to serialize actions:', error);
+                actionsJson = '[]';
+            }
+            await this.db('params')
+                .insert({
+                id: 1,
+                actions: actionsJson,
+                lastBlockNumber: data.lastBlockNumber
+            })
+                .onConflict('id')
+                .merge();
+            return true;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error saving state:', error);
+            throw error;
+        }
+    }
+    async processOperation(op, blockNumber, blockId, prevBlockId, trxId, blockTime) {
+        this.blockNumber = blockNumber;
+        this.blockId = blockId;
+        this.prevBlockId = prevBlockId;
+        this.transactionId = trxId;
+    }
+    async processTransfer(operation, payload, metadata) {
+        try {
+            await this.db('transfers').insert({
+                id: metadata.transactionId || this.transactionId,
+                blockId: metadata.blockId || this.blockId,
+                blockNumber: metadata.blockNumber || this.blockNumber,
+                sender: metadata.sender,
+                amount: metadata.amount,
+                contractName: payload.contract,
+                contractAction: payload.action,
+                contractPayload: JSON.stringify(payload.payload)
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error processing transfer:', error);
+            throw error;
+        }
+    }
+    async processCustomJson(operation, payload, metadata) {
+        try {
+            await this.db('customJson').insert({
+                id: metadata.transactionId || this.transactionId,
+                blockId: metadata.blockId || this.blockId,
+                blockNumber: metadata.blockNumber || this.blockNumber,
+                sender: metadata.sender,
+                isSignedWithActiveKey: metadata.isSignedWithActiveKey ? 1 : 0,
+                contractName: payload.contract,
+                contractAction: payload.action,
+                contractPayload: JSON.stringify(payload.payload)
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error processing custom JSON:', error);
+            throw error;
+        }
+    }
+    async addEvent(date, contract, action, payload, data) {
+        try {
+            await this.db('events').insert({
+                date,
+                contract,
+                action,
+                payload: JSON.stringify(payload),
+                data: JSON.stringify(data)
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error adding event:', error);
+            throw error;
+        }
+    }
+    async getTransfers() {
+        try {
+            const rows = await this.db('transfers')
+                .select('id', 'blockId', 'blockNumber', 'sender', 'amount', 'contractName', 'contractAction', 'contractPayload');
+            if (rows.length) {
+                return rows.map(row => ({
+                    ...row,
+                    contractPayload: JSON.parse(row.contractPayload) ?? {}
+                }));
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting transfers:', error);
+            throw error;
+        }
+    }
+    async getEvents() {
+        try {
+            const rows = await this.db('events')
+                .select('id', 'date', 'contract', 'action', 'payload', 'data');
+            if (rows.length) {
+                return rows.map(row => ({
+                    ...row,
+                    payload: JSON.parse(row.payload) ?? {},
+                    data: JSON.parse(row.data) ?? {}
+                }));
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting events:', error);
+            throw error;
+        }
+    }
+    async getEventsByContract(contract) {
+        try {
+            const rows = await this.db('events')
+                .select('id', 'date', 'contract', 'action', 'payload', 'data')
+                .where('contract', contract);
+            if (rows.length) {
+                return rows.map(row => ({
+                    ...row,
+                    payload: JSON.parse(row.payload) ?? {},
+                    data: JSON.parse(row.data) ?? {}
+                }));
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting events by contract:', error);
+            throw error;
+        }
+    }
+    async getEventsByAccount(account) {
+        try {
+            const rows = await this.db('events')
+                .select('id', 'date', 'contract', 'action', 'payload', 'data')
+                .where('data', 'like', `%"${account}"%`);
+            if (rows.length) {
+                return rows.map(row => ({
+                    ...row,
+                    payload: JSON.parse(row.payload) ?? {},
+                    data: JSON.parse(row.data) ?? {}
+                }));
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting events by account:', error);
+            throw error;
+        }
+    }
+    async getTransfersByContract(contract) {
+        try {
+            const rows = await this.db('transfers')
+                .select('id', 'blockId', 'blockNumber', 'sender', 'amount', 'contractName', 'contractAction', 'contractPayload')
+                .where('contractName', contract);
+            if (rows.length) {
+                return rows.map(row => ({
+                    ...row,
+                    contractPayload: JSON.parse(row.contractPayload) ?? {}
+                }));
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting transfers by contract:', error);
+            throw error;
+        }
+    }
+    async getTransfersByAccount(account) {
+        try {
+            const rows = await this.db('transfers')
+                .select('id', 'blockId', 'blockNumber', 'sender', 'amount', 'contractName', 'contractAction', 'contractPayload')
+                .where('sender', account);
+            if (rows.length) {
+                return rows.map(row => ({
+                    ...row,
+                    contractPayload: JSON.parse(row.contractPayload) ?? {}
+                }));
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting transfers by account:', error);
+            throw error;
+        }
+    }
+    async getTransfersByBlockid(blockId) {
+        try {
+            const rows = await this.db('transfers')
+                .select('id', 'blockId', 'blockNumber', 'sender', 'amount', 'contractName', 'contractAction', 'contractPayload')
+                .where('blockId', blockId);
+            if (rows.length) {
+                return rows.map(row => ({
+                    ...row,
+                    contractPayload: JSON.parse(row.contractPayload) ?? {}
+                }));
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting transfers by blockId:', error);
+            throw error;
+        }
+    }
+    async getJson() {
+        try {
+            const rows = await this.db('customJson')
+                .select('id', 'blockId', 'blockNumber', 'sender', 'isSignedWithActiveKey', 'contractName', 'contractAction', 'contractPayload');
+            if (rows.length) {
+                return rows.map(row => ({
+                    ...row,
+                    contractPayload: JSON.parse(row.contractPayload) ?? {}
+                }));
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting JSON:', error);
+            throw error;
+        }
+    }
+    async getJsonByContract(contract) {
+        try {
+            const rows = await this.db('customJson')
+                .select('id', 'blockId', 'blockNumber', 'sender', 'isSignedWithActiveKey', 'contractName', 'contractAction', 'contractPayload')
+                .where('contractName', contract);
+            if (rows.length) {
+                return rows.map(row => ({
+                    ...row,
+                    contractPayload: JSON.parse(row.contractPayload) ?? {}
+                }));
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting JSON by contract:', error);
+            throw error;
+        }
+    }
+    async getJsonByAccount(account) {
+        try {
+            const rows = await this.db('customJson')
+                .select('id', 'blockId', 'blockNumber', 'sender', 'isSignedWithActiveKey', 'contractName', 'contractAction', 'contractPayload')
+                .where('sender', account);
+            if (rows.length) {
+                return rows.map(row => ({
+                    ...row,
+                    contractPayload: JSON.parse(row.contractPayload) ?? {}
+                }));
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting JSON by account:', error);
+            throw error;
+        }
+    }
+    async getJsonByBlockid(blockId) {
+        try {
+            const rows = await this.db('customJson')
+                .select('id', 'blockId', 'blockNumber', 'sender', 'isSignedWithActiveKey', 'contractName', 'contractAction', 'contractPayload')
+                .where('blockId', blockId);
+            if (rows.length) {
+                return rows.map(row => ({
+                    ...row,
+                    contractPayload: JSON.parse(row.contractPayload) ?? {}
+                }));
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting JSON by blockId:', error);
+            throw error;
+        }
+    }
+    async getExchangeBalances(account) {
+        try {
+            const query = this.db('exchange_balances')
+                .select('account', 'asset', 'available', 'locked');
+            if (account) {
+                query.where('account', account);
+            }
+            const rows = await query;
+            return rows.length ? rows : null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting exchange balances:', error);
+            throw error;
+        }
+    }
+    async getExchangeOrders(filters = {}) {
+        try {
+            const query = this.db('exchange_orders')
+                .select('id', 'account', 'side', 'base_asset', 'quote_asset', 'price', 'amount', 'remaining', 'status', 'created_at');
+            if (filters.account) {
+                query.where('account', filters.account);
+            }
+            if (filters.base) {
+                query.where('base_asset', filters.base);
+            }
+            if (filters.quote) {
+                query.where('quote_asset', filters.quote);
+            }
+            if (filters.status) {
+                query.where('status', filters.status);
+            }
+            const rows = await query;
+            return rows.length ? rows : null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting exchange orders:', error);
+            throw error;
+        }
+    }
+    async getExchangeTrades(filters = {}) {
+        try {
+            const query = this.db('exchange_trades')
+                .select('id', 'buy_order_id', 'sell_order_id', 'price', 'amount', 'base_asset', 'quote_asset', 'buyer', 'seller', 'created_at');
+            if (filters.account) {
+                query.where(builder => {
+                    builder.where('buyer', filters.account).orWhere('seller', filters.account);
+                });
+            }
+            if (filters.base) {
+                query.where('base_asset', filters.base);
+            }
+            if (filters.quote) {
+                query.where('quote_asset', filters.quote);
+            }
+            const rows = await query;
+            return rows.length ? rows : null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting exchange trades:', error);
+            throw error;
+        }
+    }
+    async getExchangeOrderBookSnapshots(filters = {}) {
+        try {
+            const query = this.db('exchange_orderbook_snapshots')
+                .select('id', 'base_asset', 'quote_asset', 'bids', 'asks', 'created_at')
+                .orderBy('created_at', 'desc');
+            if (filters.base) {
+                query.where('base_asset', filters.base);
+            }
+            if (filters.quote) {
+                query.where('quote_asset', filters.quote);
+            }
+            if (filters.limit) {
+                query.limit(filters.limit);
+            }
+            const rows = await query;
+            if (rows.length) {
+                return rows.map(row => ({
+                    ...row,
+                    bids: JSON.parse(row.bids) ?? [],
+                    asks: JSON.parse(row.asks) ?? []
+                }));
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error getting exchange order book snapshots:', error);
+            throw error;
+        }
+    }
+    async destroy() {
+        try {
+            await this.db.destroy();
+            return true;
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error destroying database connection:', error);
+            throw error;
+        }
+    }
+    async find(table, query) {
+        try {
+            const rows = await this.db(table).where(query);
+            return rows.length ? rows : null;
+        }
+        catch (error) {
+            console.error(`[SqliteAdapter] Error finding in table ${table}:`, error);
+            throw error;
+        }
+    }
+    async findOne(table, query) {
+        try {
+            const row = await this.db(table).where(query).first();
+            return row || null;
+        }
+        catch (error) {
+            console.error(`[SqliteAdapter] Error finding one in table ${table}:`, error);
+            throw error;
+        }
+    }
+    async insert(table, data) {
+        try {
+            await this.db(table).insert(data);
+            return true;
+        }
+        catch (error) {
+            console.error(`[SqliteAdapter] Error inserting into table ${table}:`, error);
+            throw error;
+        }
+    }
+    async replace(table, queryObject, data) {
+        try {
+            await this.db(table)
+                .insert(data)
+                .onConflict(Object.keys(queryObject))
+                .merge();
+            return data;
+        }
+        catch (error) {
+            console.error(`[SqliteAdapter] Error replacing in table ${table}:`, error);
+            throw error;
+        }
+    }
+    async query(sql, params) {
+        try {
+            const result = await this.db.raw(sql, params);
+            return result || [];
+        }
+        catch (error) {
+            console.error('[SqliteAdapter] Error executing raw query:', error);
+            throw error;
+        }
+    }
+}
+exports.SqliteAdapter = SqliteAdapter;
 //# sourceMappingURL=sqlite.adapter.js.map