@ocap/statedb-sqlite 1.29.5

package/esm/table/base.mjs

@@ -0,0 +1,217 @@
+import { StateDBTable } from "@ocap/statedb";
+import crypto from "node:crypto";
+import omit from "lodash/omit.js";
+
+//#region src/table/base.ts
+/**
+* SQLite State Table base class
+* Extends StateDBTable to provide SQLite-specific implementation
+*/
+var SqliteTable = class SqliteTable extends StateDBTable {
+	constructor(config) {
+		super(config.uniqIndex);
+		this.name = config.name;
+		this.db = config.db;
+		this.schema = config.schema || {};
+		this.balanceTable = config.balanceTable;
+		this.syncBalance = config.syncBalance ?? false;
+		if (this.syncBalance && !this.balanceTable) throw new Error("balanceTable is required when syncBalance is true");
+		this.markReady();
+	}
+	/**
+	* Get the Kysely executor (use transaction if available)
+	*/
+	getExecutor(context) {
+		return context?.txn || this.db;
+	}
+	/**
+	* Generate primary key from document
+	* Handles both simple string keys and composite keys
+	*/
+	generatePrimaryKey(doc) {
+		if (typeof doc === "string") return doc;
+		if (Array.isArray(this.uniqIndex)) {
+			const key = this.uniqIndex.map((id) => doc[id]).map((item) => typeof item === "object" ? JSON.stringify(item) : item).join("-");
+			return crypto.createHash("md5").update(key).digest("hex");
+		}
+		return doc[this.uniqIndex];
+	}
+	/**
+	* Convert a key to a query object
+	*/
+	formatKeyToQuery(key) {
+		if (Array.isArray(this.uniqIndex) && typeof key === "object") {
+			const keyObj = key;
+			return Object.fromEntries(this.uniqIndex.map((k) => [this.mapColumnName(k), keyObj[k]]));
+		}
+		if (typeof key === "object") {
+			const keyObj = key;
+			return { [this.mapColumnName(this.primaryKey)]: keyObj[this.primaryKey] };
+		}
+		return { [this.mapColumnName(this.primaryKey)]: key };
+	}
+	/**
+	* Map column name for reserved keywords
+	*/
+	mapColumnName(name) {
+		return this.schema.columnMapping?.[name] ?? name;
+	}
+	/**
+	* Reverse map column name
+	*/
+	unmapColumnName(name) {
+		const mapping = this.schema.columnMapping;
+		if (!mapping) return name;
+		for (const [original, mapped] of Object.entries(mapping)) if (mapped === name) return original;
+		return name;
+	}
+	/**
+	* Serialize data for database insert
+	* - Converts objects/arrays to JSON strings
+	* - Converts booleans to integers (0/1) for SQLite
+	* - Maps column names for reserved keywords
+	*/
+	serializeForDb(data) {
+		const result = {};
+		const jsonFields = new Set(this.schema.jsonFields || []);
+		const booleanFields = new Set(this.schema.booleanFields || []);
+		for (const [key, value] of Object.entries(data)) {
+			const mappedKey = this.mapColumnName(key);
+			if (value === void 0) result[mappedKey] = null;
+			else if (booleanFields.has(key) && typeof value === "boolean") result[mappedKey] = value ? 1 : 0;
+			else if (jsonFields.has(key) || value !== null && typeof value === "object") result[mappedKey] = JSON.stringify(value);
+			else result[mappedKey] = value;
+		}
+		return result;
+	}
+	/**
+	* Deserialize data from database read
+	* - Parses JSON strings back to objects
+	* - Converts integers (0/1) back to booleans
+	* - Unmaps column names
+	*/
+	deserializeFromDb(data) {
+		if (!data) return null;
+		const result = {};
+		const jsonFields = new Set(this.schema.jsonFields || []);
+		const booleanFields = new Set(this.schema.booleanFields || []);
+		for (const [key, value] of Object.entries(data)) {
+			const unmappedKey = this.unmapColumnName(key);
+			if (booleanFields.has(unmappedKey) && typeof value === "number") result[unmappedKey] = value === 1;
+			else if (jsonFields.has(unmappedKey) && typeof value === "string") try {
+				result[unmappedKey] = JSON.parse(value);
+			} catch {
+				result[unmappedKey] = value;
+			}
+			else result[unmappedKey] = value;
+		}
+		delete result.$loki;
+		delete result.meta;
+		return result;
+	}
+	async _create(key, attrs = {}, context) {
+		const sqlContext = context;
+		const executor = this.getExecutor(sqlContext);
+		const insertAttrs = { ...attrs };
+		if (Array.isArray(this.uniqIndex)) {
+			if (typeof key === "object") Object.assign(insertAttrs, key);
+		} else {
+			const id = this.generatePrimaryKey(key);
+			insertAttrs[this.primaryKey] = id;
+		}
+		const lookupKey = Array.isArray(this.uniqIndex) ? Object.fromEntries(this.uniqIndex.map((k) => [k, insertAttrs[k]])) : insertAttrs[this.primaryKey];
+		if (await SqliteTable.prototype._get.call(this, lookupKey, context)) throw new Error(`${this.name} already exists: ${JSON.stringify(key)}`);
+		if (this.syncBalance) delete insertAttrs.tokens;
+		const serialized = this.serializeForDb(insertAttrs);
+		await executor.insertInto(this.name).values(serialized).execute();
+		if (this.syncBalance && attrs.tokens) insertAttrs.tokens = await this.balanceTable.updateBalance({
+			address: insertAttrs.address,
+			tokens: attrs.tokens,
+			context: attrs.context
+		}, context);
+		return insertAttrs;
+	}
+	async _get(key, context) {
+		if (!key) return null;
+		const sqlContext = context;
+		const executor = this.getExecutor(sqlContext);
+		let query;
+		if (Array.isArray(this.uniqIndex)) if (typeof key === "object") {
+			const keyObj = key;
+			query = Object.fromEntries(this.uniqIndex.map((k) => [this.mapColumnName(k), keyObj[k]]));
+		} else return null;
+		else query = this.formatKeyToQuery(key);
+		let qb = executor.selectFrom(this.name).selectAll();
+		for (const [k, v] of Object.entries(query)) {
+			if (v === void 0) continue;
+			qb = qb.where(k, "=", v);
+		}
+		const result = await qb.executeTakeFirst();
+		const deserialized = this.deserializeFromDb(result);
+		if (deserialized && this.syncBalance) {
+			const balance = await this.balanceTable.getBalance(deserialized.address, context);
+			deserialized.tokens = {
+				...deserialized.tokens || {},
+				...balance
+			};
+		}
+		return deserialized;
+	}
+	_history(_key, _context) {
+		return [];
+	}
+	async _update(key, updates, context) {
+		const sqlContext = context;
+		const executor = this.getExecutor(sqlContext);
+		let lookupKey = key;
+		if (Array.isArray(this.uniqIndex) && typeof key !== "object") {
+			const updatesObj = updates;
+			lookupKey = Object.fromEntries(this.uniqIndex.map((k) => [k, updatesObj[k]]));
+		}
+		const existing = await SqliteTable.prototype._get.call(this, lookupKey, context);
+		if (!existing) throw new Error(`${this.name} does not exist: ${JSON.stringify(key)}`);
+		let query;
+		if (Array.isArray(this.uniqIndex)) {
+			const keyObj = typeof lookupKey === "object" ? lookupKey : existing;
+			query = Object.fromEntries(this.uniqIndex.map((k) => [this.mapColumnName(k), keyObj[k]]));
+		} else query = this.formatKeyToQuery(key);
+		const updateAttrs = { ...updates };
+		if (Array.isArray(this.uniqIndex)) for (const k of this.uniqIndex) delete updateAttrs[k];
+		else delete updateAttrs[this.primaryKey];
+		if (this.syncBalance) delete updateAttrs.tokens;
+		if (Object.keys(updateAttrs).length > 0) {
+			const serialized = this.serializeForDb(updateAttrs);
+			let qb = executor.updateTable(this.name).set(serialized);
+			for (const [k, v] of Object.entries(query)) {
+				if (v === void 0) continue;
+				qb = qb.where(k, "=", v);
+			}
+			await qb.execute();
+		}
+		const merged = {
+			...existing,
+			...updateAttrs
+		};
+		if (this.syncBalance && updates.tokens) merged.tokens = await this.balanceTable.updateBalance({
+			address: merged.address,
+			tokens: updates.tokens,
+			context: updates.context
+		}, context);
+		return merged;
+	}
+	async _reset(_context) {
+		const sqlContext = _context;
+		await this.getExecutor(sqlContext).deleteFrom(this.name).execute();
+	}
+	async updateOrCreate(exist, state, ctx) {
+		const id = this.generatePrimaryKey(state);
+		const attrs = omit(state, Array.isArray(this.uniqIndex) ? this.uniqIndex : [this.uniqIndex]);
+		if (!id) throw new Error("Cannot update or create without uniq index");
+		if (exist) return this.update(id, attrs, ctx);
+		return this.create(id, attrs, ctx);
+	}
+};
+var base_default = SqliteTable;
+
+//#endregion
+export { base_default as default };

package/esm/table/rollup.d.mts

@@ -0,0 +1,22 @@
+import SqliteTable, { SqliteTableConfig } from "./base.mjs";
+import { IOperationContext, IRollupState } from "@ocap/types";
+
+//#region src/table/rollup.d.ts
+
+/**
+ * Rollup Table
+ * Extends base table with tokenAddress-based existence check
+ */
+declare class RollupTable extends SqliteTable<IRollupState> {
+  constructor(config: Omit<SqliteTableConfig, 'name' | 'uniqIndex' | 'schema'>);
+  /**
+   * Check if an active (non-paused) rollup with the given tokenAddress exists
+   *
+   * @param tokenAddress - Token address to check
+   * @param context - Operation context with optional transaction
+   * @returns true if active rollup with tokenAddress exists, false if tokenAddress is empty/undefined or rollup is paused
+   */
+  existByToken(tokenAddress: string, context?: IOperationContext): Promise<boolean>;
+}
+//#endregion
+export { RollupTable as default };

package/esm/table/rollup.mjs

@@ -0,0 +1,44 @@
+import base_default from "./base.mjs";
+
+//#region src/table/rollup.ts
+/**
+* Rollup Table
+* Extends base table with tokenAddress-based existence check
+*/
+var RollupTable = class extends base_default {
+	constructor(config) {
+		super({
+			...config,
+			name: "rollup",
+			uniqIndex: "address",
+			schema: {
+				jsonFields: [
+					"seedValidators",
+					"validators",
+					"migrateHistory",
+					"vaultHistory",
+					"data",
+					"context"
+				],
+				booleanFields: ["paused", "closed"]
+			}
+		});
+	}
+	/**
+	* Check if an active (non-paused) rollup with the given tokenAddress exists
+	*
+	* @param tokenAddress - Token address to check
+	* @param context - Operation context with optional transaction
+	* @returns true if active rollup with tokenAddress exists, false if tokenAddress is empty/undefined or rollup is paused
+	*/
+	async existByToken(tokenAddress, context) {
+		if (!tokenAddress) return false;
+		const sqlContext = context;
+		const executor = this.getExecutor(sqlContext);
+		return ((await executor.selectFrom("rollup").select(executor.fn.count("address").as("count")).where("tokenAddress", "=", tokenAddress).where("paused", "=", 0).executeTakeFirst())?.count ?? 0) > 0;
+	}
+};
+var rollup_default = RollupTable;
+
+//#endregion
+export { rollup_default as default };

package/esm/table/token.d.mts

@@ -0,0 +1,23 @@
+import SqliteTable, { SqliteTableConfig } from "./base.mjs";
+import { IOperationContext, ITokenState } from "@ocap/types";
+
+//#region src/table/token.d.ts
+
+/**
+ * Token Table
+ * Extends base table with symbol-based existence check
+ */
+declare class TokenTable extends SqliteTable<ITokenState> {
+  constructor(config: Omit<SqliteTableConfig, 'name' | 'uniqIndex' | 'schema'>);
+  /**
+   * Check if a token with the given symbol exists
+   *
+   * @param symbol - Token symbol to check
+   * @param context - Operation context with optional transaction
+   * @returns true if token with symbol exists
+   * @throws Error if symbol is empty
+   */
+  existBySymbol(symbol: string, context?: IOperationContext): Promise<boolean>;
+}
+//#endregion
+export { TokenTable as default };

package/esm/table/token.mjs

@@ -0,0 +1,42 @@
+import base_default from "./base.mjs";
+
+//#region src/table/token.ts
+/**
+* Token Table
+* Extends base table with symbol-based existence check
+*/
+var TokenTable = class extends base_default {
+	constructor(config) {
+		super({
+			...config,
+			name: "token",
+			uniqIndex: "address",
+			schema: { jsonFields: [
+				"foreignToken",
+				"metadata",
+				"spenders",
+				"minters",
+				"data",
+				"context"
+			] }
+		});
+	}
+	/**
+	* Check if a token with the given symbol exists
+	*
+	* @param symbol - Token symbol to check
+	* @param context - Operation context with optional transaction
+	* @returns true if token with symbol exists
+	* @throws Error if symbol is empty
+	*/
+	async existBySymbol(symbol, context) {
+		if (!symbol) throw new Error("param symbol is required");
+		const sqlContext = context;
+		const executor = this.getExecutor(sqlContext);
+		return ((await executor.selectFrom("token").select(executor.fn.count("address").as("count")).where("symbol", "=", symbol).executeTakeFirst())?.count ?? 0) > 0;
+	}
+};
+var token_default = TokenTable;
+
+//#endregion
+export { token_default as default };

package/lib/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,43 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__exportAll = __exportAll;
+exports.__toESM = __toESM;

package/lib/db.cjs

@@ -0,0 +1,259 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_kysely = require('./kysely.cjs');
+const require_migrations_index = require('./migrations/index.cjs');
+const require_table_base = require('./table/base.cjs');
+const require_table_account = require('./table/account.cjs');
+const require_table_balance = require('./table/balance.cjs');
+const require_table_rollup = require('./table/rollup.cjs');
+const require_table_token = require('./table/token.cjs');
+const require_package = require('./package.cjs');
+let _ocap_statedb = require("@ocap/statedb");
+
+//#region src/db.ts
+const { name, version } = require_package.default;
+const SQLITE_BUSY_CODES = ["SQLITE_BUSY", "SQLITE_LOCKED"];
+/**
+* SQLite StateDB Implementation
+* Uses SQLite via Kysely as the storage backend
+*/
+var SqliteStateDB = class extends _ocap_statedb.StateDB {
+	/**
+	* Creates an instance of SqliteStateDB
+	*
+	* @param config - SQLite configuration (defaults to in-memory)
+	*
+	* @example
+	* ```typescript
+	* // In-memory database for testing
+	* const db = new SqliteStateDB();
+	* await db.initialize();
+	*
+	* // File-based database for production
+	* const db = new SqliteStateDB({ filename: './data/state.sqlite' });
+	* await db.initialize();
+	* ```
+	*/
+	constructor(config = { filename: ":memory:" }) {
+		super();
+		this.initialized = false;
+		this.name = name;
+		this.version = version;
+		this.config = config;
+		this.initSync();
+	}
+	/**
+	* Synchronous initialization
+	* Called from constructor for immediate table availability
+	*/
+	initSync() {
+		this.db = require_kysely.createKysely(this.config);
+		this.balance = new require_table_balance.default({ db: this.db });
+		this.account = new require_table_account.default({
+			db: this.db,
+			syncBalance: true,
+			balanceTable: this.balance
+		});
+		this.factory = new require_table_base.default({
+			name: "factory",
+			uniqIndex: "address",
+			db: this.db,
+			syncBalance: true,
+			balanceTable: this.balance,
+			schema: { jsonFields: [
+				"trustedIssuers",
+				"tokens",
+				"input",
+				"output",
+				"display",
+				"hooks",
+				"data",
+				"context",
+				"stake"
+			] }
+		});
+		this.stake = new require_table_base.default({
+			name: "stake",
+			uniqIndex: "address",
+			db: this.db,
+			syncBalance: true,
+			balanceTable: this.balance,
+			schema: {
+				jsonFields: [
+					"tokens",
+					"assets",
+					"slashers",
+					"revokedTokens",
+					"revokedAssets",
+					"data",
+					"context"
+				],
+				booleanFields: ["revocable"]
+			}
+		});
+		this.asset = new require_table_base.default({
+			name: "asset",
+			uniqIndex: "address",
+			db: this.db,
+			schema: {
+				jsonFields: [
+					"endpoint",
+					"display",
+					"tags",
+					"stake",
+					"data",
+					"context"
+				],
+				booleanFields: ["readonly", "transferrable"]
+			}
+		});
+		this.delegation = new require_table_base.default({
+			name: "delegation",
+			uniqIndex: "address",
+			db: this.db,
+			schema: {
+				jsonFields: [
+					"ops",
+					"data",
+					"context"
+				],
+				columnMapping: {
+					from: "from_",
+					to: "to_"
+				}
+			}
+		});
+		this.tx = new require_table_base.default({
+			name: "tx",
+			uniqIndex: "hash",
+			db: this.db,
+			schema: {
+				jsonFields: [
+					"receipts",
+					"tx",
+					"context"
+				],
+				columnMapping: { index: "index_" },
+				booleanFields: [
+					"receiptsVerified",
+					"finalized",
+					"valid"
+				]
+			}
+		});
+		this.token = new require_table_token.default({ db: this.db });
+		this.chain = new require_table_base.default({
+			name: "chain",
+			uniqIndex: "address",
+			db: this.db,
+			schema: { jsonFields: [
+				"accounts",
+				"moderator",
+				"token",
+				"transaction",
+				"vaults",
+				"context"
+			] }
+		});
+		this.rollup = new require_table_rollup.default({ db: this.db });
+		this.rollupBlock = new require_table_base.default({
+			name: "rollupBlock",
+			uniqIndex: "hash",
+			db: this.db,
+			schema: {
+				jsonFields: [
+					"txs",
+					"signatures",
+					"data",
+					"context"
+				],
+				booleanFields: ["governance"]
+			}
+		});
+		this.evidence = new require_table_base.default({
+			name: "evidence",
+			uniqIndex: "hash",
+			db: this.db,
+			schema: { jsonFields: ["data", "context"] }
+		});
+		this.tokenFactory = new require_table_base.default({
+			name: "tokenFactory",
+			uniqIndex: "address",
+			db: this.db,
+			schema: { jsonFields: [
+				"curve",
+				"input",
+				"output",
+				"data",
+				"context"
+			] }
+		});
+		this.attachReadyListeners();
+	}
+	/**
+	* Async initialization - runs migrations
+	* Call this after constructor to ensure database schema is ready
+	*/
+	async initialize() {
+		if (this.initialized) return;
+		await require_migrations_index.runMigrations(this.db);
+		this.initialized = true;
+	}
+	/**
+	* Execute multiple operations within a database transaction
+	* Provides retry logic for SQLite BUSY errors (lock conflicts)
+	*
+	* @param fn - Function receiving Kysely transaction object
+	* @param options - Optional retry configuration
+	* @returns Result of the transaction function
+	*
+	* @example
+	* ```typescript
+	* await db.runAsLambda(async (txn) => {
+	*   await txn.insertInto('account').values({ ... }).execute();
+	*   await txn.updateTable('balance').set({ ... }).execute();
+	* });
+	* ```
+	*/
+	async runAsLambda(fn, options = {}) {
+		const { retryLimit = 2 } = options;
+		let lastError;
+		for (let attempt = 0; attempt <= retryLimit; attempt++) try {
+			return await this.db.transaction().execute(async (txn) => {
+				return await fn(txn);
+			});
+		} catch (err) {
+			lastError = err;
+			const code = err?.code;
+			if (!SQLITE_BUSY_CODES.includes(code)) throw err;
+			if (attempt < retryLimit) await new Promise((r) => setTimeout(r, 10 * 2 ** attempt));
+		}
+		throw lastError;
+	}
+	/**
+	* Reset all tables (for testing)
+	*/
+	async reset() {
+		const tables = Object.keys(this.readyMarks);
+		for (const table of tables) {
+			const tableInstance = this[table];
+			if (tableInstance?.reset) await tableInstance.reset();
+		}
+	}
+	/**
+	* Close database connection
+	*/
+	async close() {
+		await this.db.destroy();
+	}
+	/**
+	* Get the underlying Kysely instance (for advanced operations)
+	*/
+	getKysely() {
+		return this.db;
+	}
+};
+var db_default = SqliteStateDB;
+
+//#endregion
+exports.default = db_default;