@ocap/statedb-sqlite 1.29.5

package/lib/db.d.cts

@@ -0,0 +1,92 @@
+import { Database } from "./interfaces.cjs";
+import { SqliteConfig } from "./kysely.cjs";
+import { StateDB } from "@ocap/statedb";
+import { IAccountState, IAssetFactoryState, IAssetState, IBalanceTable, IChainState, IDelegateState, IEvidenceState, IRollupBlock, IRollupTable, IStakeState, IStateDB, IStateTable, ITokenFactoryState, ITokenTable, ITxState } from "@ocap/types";
+import { Kysely, Transaction } from "kysely";
+
+//#region src/db.d.ts
+
+/**
+ * SQLite StateDB Implementation
+ * Uses SQLite via Kysely as the storage backend
+ */
+declare class SqliteStateDB extends StateDB implements IStateDB {
+  name: string;
+  version: string;
+  private db;
+  private config;
+  private initialized;
+  balance: IBalanceTable;
+  account: IStateTable<IAccountState>;
+  factory: IStateTable<IAssetFactoryState>;
+  stake: IStateTable<IStakeState>;
+  asset: IStateTable<IAssetState>;
+  delegation: IStateTable<IDelegateState>;
+  tx: IStateTable<ITxState>;
+  token: ITokenTable;
+  chain: IStateTable<IChainState>;
+  rollup: IRollupTable;
+  rollupBlock: IStateTable<IRollupBlock>;
+  evidence: IStateTable<IEvidenceState>;
+  tokenFactory: IStateTable<ITokenFactoryState>;
+  /**
+   * 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?: SqliteConfig);
+  /**
+   * Synchronous initialization
+   * Called from constructor for immediate table availability
+   */
+  private initSync;
+  /**
+   * Async initialization - runs migrations
+   * Call this after constructor to ensure database schema is ready
+   */
+  initialize(): Promise<void>;
+  /**
+   * 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();
+   * });
+   * ```
+   */
+  runAsLambda<T>(fn: (txn: Transaction<Database>) => T | Promise<T>, options?: {
+    retryLimit?: number;
+  }): Promise<T>;
+  /**
+   * Reset all tables (for testing)
+   */
+  reset(): Promise<void>;
+  /**
+   * Close database connection
+   */
+  close(): Promise<void>;
+  /**
+   * Get the underlying Kysely instance (for advanced operations)
+   */
+  getKysely(): Kysely<Database>;
+}
+//#endregion
+export { SqliteStateDB as default };

package/lib/index.cjs

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_db = require('./db.cjs');
+
+//#region src/index.ts
+var src_default = require_db.default;
+
+//#endregion
+exports.SqliteStateDB = require_db.default;
+exports.default = src_default;

package/lib/index.d.cts

@@ -0,0 +1,4 @@
+import { Database, SqliteOperationContext } from "./interfaces.cjs";
+import { SqliteConfig } from "./kysely.cjs";
+import SqliteStateDB from "./db.cjs";
+export { type Database, type SqliteConfig, type SqliteOperationContext, SqliteStateDB, SqliteStateDB as default };

package/lib/interfaces.d.cts

@@ -0,0 +1,201 @@
+import { IOperationContext } from "@ocap/types";
+import { Transaction } from "kysely";
+
+//#region src/interfaces.d.ts
+
+/**
+ * SQLite-specific operation context
+ * Extends base operation context with optional transaction
+ */
+interface SqliteOperationContext extends IOperationContext {
+  txn?: Transaction<Database>;
+}
+/**
+ * Database schema types for Kysely
+ * Each table is defined with its column types
+ */
+interface Database {
+  account: AccountTable;
+  balance: BalanceTable;
+  chain: ChainTable;
+  tx: TxTable;
+  asset: AssetTable;
+  token: TokenTable;
+  factory: FactoryTable;
+  tokenFactory: TokenFactoryTable;
+  stake: StakeTable;
+  delegation: DelegationTable;
+  rollup: RollupTable;
+  rollupBlock: RollupBlockTable;
+  evidence: EvidenceTable;
+}
+interface AccountTable {
+  address: string;
+  balance: string;
+  gasBalance: string | null;
+  moniker: string | null;
+  pk: string | null;
+  nonce: number;
+  numTxs: number;
+  numAssets: number;
+  issuer: string | null;
+  migratedTo: string | null;
+  migratedFrom: string | null;
+  stake: string | null;
+  tokens: string | null;
+  data: string | null;
+  context: string | null;
+  _retrievedAt: string | null;
+}
+interface BalanceTable {
+  address: string;
+  tokenAddress: string;
+  balance: string;
+  context: string | null;
+}
+interface ChainTable {
+  address: string;
+  chainId: string | null;
+  version: string | null;
+  accounts: string | null;
+  moderator: string | null;
+  token: string | null;
+  transaction: string | null;
+  vaults: string | null;
+  context: string | null;
+}
+interface TxTable {
+  hash: string;
+  code: string | null;
+  height: number | null;
+  index_: number | null;
+  receipts: string | null;
+  receiptsVerified: number | null;
+  receiver: string | null;
+  sender: string | null;
+  time: string | null;
+  tx: string | null;
+  type: string | null;
+  finalized: number | null;
+  valid: number | null;
+}
+interface AssetTable {
+  address: string;
+  owner: string | null;
+  moniker: string | null;
+  readonly: number | null;
+  transferrable: number | null;
+  issuer: string | null;
+  parent: string | null;
+  ttl: number | null;
+  consumedTime: string | null;
+  endpoint: string | null;
+  display: string | null;
+  tags: string | null;
+  stake: string | null;
+  data: string | null;
+  context: string | null;
+}
+interface TokenTable {
+  address: string;
+  symbol: string | null;
+  name: string | null;
+  decimal: number | null;
+  unit: string | null;
+  description: string | null;
+  icon: string | null;
+  totalSupply: string | null;
+  initialSupply: string | null;
+  maxTotalSupply: string | null;
+  foreignToken: string | null;
+  issuer: string | null;
+  website: string | null;
+  metadata: string | null;
+  tokenFactoryAddress: string | null;
+  spenders: string | null;
+  minters: string | null;
+  type: string | null;
+  data: string | null;
+  context: string | null;
+}
+interface FactoryTable {
+  address: string;
+  owner: string | null;
+  name: string | null;
+  description: string | null;
+  settlement: string | null;
+  limit: number | null;
+  trustedIssuers: string | null;
+  tokens: string | null;
+  numMinted: number | null;
+  lastSettlement: string | null;
+  input: string | null;
+  output: string | null;
+  display: string | null;
+  hooks: string | null;
+  data: string | null;
+  context: string | null;
+}
+interface TokenFactoryTable {
+  address: string;
+  owner: string | null;
+  name: string | null;
+  description: string | null;
+  moniker: string | null;
+  status: string | null;
+  curve: string | null;
+  input: string | null;
+  output: string | null;
+  data: string | null;
+  context: string | null;
+}
+interface StakeTable {
+  address: string;
+  sender: string | null;
+  receiver: string | null;
+  tokens: string | null;
+  revokedTokens: string | null;
+  message: string | null;
+  data: string | null;
+  context: string | null;
+}
+interface DelegationTable {
+  address: string;
+  from_: string | null;
+  to_: string | null;
+  ops: string | null;
+  data: string | null;
+  context: string | null;
+}
+interface RollupTable {
+  address: string;
+  tokenAddress: string | null;
+  paused: number | null;
+  seedValidators: string | null;
+  validators: string | null;
+  vaultAddress: string | null;
+  blockHash: string | null;
+  issuer: string | null;
+  data: string | null;
+  context: string | null;
+}
+interface RollupBlockTable {
+  hash: string;
+  rollup: string | null;
+  height: number | null;
+  previousHash: string | null;
+  mintedAmount: string | null;
+  burnedAmount: string | null;
+  rewardAmount: string | null;
+  signatures: string | null;
+  data: string | null;
+  context: string | null;
+}
+interface EvidenceTable {
+  hash: string;
+  type: string | null;
+  data: string | null;
+  context: string | null;
+}
+//#endregion
+export { AccountTable, AssetTable, BalanceTable, ChainTable, Database, DelegationTable, EvidenceTable, FactoryTable, RollupBlockTable, RollupTable, SqliteOperationContext, StakeTable, TokenFactoryTable, TokenTable, TxTable };

package/lib/kysely.cjs

@@ -0,0 +1,63 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let kysely = require("kysely");
+
+//#region src/kysely.ts
+function isBunRuntime() {
+	return typeof globalThis.Bun !== "undefined";
+}
+/**
+* Create a Kysely instance with SQLite dialect
+* Automatically uses kysely-bun-sqlite in Bun or better-sqlite3 in Node.js
+*
+* @param config - SQLite configuration
+* @returns Kysely instance configured for the database
+*
+* @example
+* ```typescript
+* // In-memory database for testing
+* const db = createKysely({ filename: ':memory:' });
+*
+* // File-based database for production
+* const db = createKysely({ filename: './data/state.sqlite' });
+* ```
+*/
+function createKysely(config) {
+	if (isBunRuntime()) {
+		const { BunSqliteDialect } = {}.require("kysely-bun-sqlite");
+		const { Database: BunDatabase } = {}.require("bun:sqlite");
+		const sqlite$1 = new BunDatabase(config.filename, {
+			create: config.create !== false,
+			readonly: config.readonly === true
+		});
+		if (config.walMode !== false && !config.readonly && config.filename !== ":memory:") {
+			sqlite$1.exec("PRAGMA journal_mode = WAL");
+			sqlite$1.exec("PRAGMA synchronous = NORMAL");
+		}
+		sqlite$1.exec("PRAGMA foreign_keys = ON");
+		sqlite$1.exec("PRAGMA busy_timeout = 5000");
+		return new kysely.Kysely({ dialect: new BunSqliteDialect({ database: sqlite$1 }) });
+	}
+	const sqlite = new (require("better-sqlite3"))(config.filename, {
+		readonly: config.readonly === true,
+		fileMustExist: config.create === false
+	});
+	if (config.walMode !== false && !config.readonly && config.filename !== ":memory:") {
+		sqlite.pragma("journal_mode = WAL");
+		sqlite.pragma("synchronous = NORMAL");
+	}
+	sqlite.pragma("foreign_keys = ON");
+	sqlite.pragma("busy_timeout = 5000");
+	return new kysely.Kysely({ dialect: new kysely.SqliteDialect({ database: sqlite }) });
+}
+/**
+* Get the underlying SQLite database instance from Kysely
+* Useful for executing raw SQL or pragmas
+* Returns either bun:sqlite Database or better-sqlite3 Database depending on runtime
+*/
+function getRawDatabase(db) {
+	return db.getExecutor().adapter.db;
+}
+
+//#endregion
+exports.createKysely = createKysely;
+exports.getRawDatabase = getRawDatabase;

package/lib/kysely.d.cts

@@ -0,0 +1,43 @@
+import { Database } from "./interfaces.cjs";
+import { Kysely } from "kysely";
+
+//#region src/kysely.d.ts
+
+/**
+ * SQLite configuration options
+ */
+interface SqliteConfig {
+  /** Database file path. Use ':memory:' for in-memory database */
+  filename: string;
+  /** Open database in readonly mode */
+  readonly?: boolean;
+  /** Throw error if file doesn't exist (default: false, creates new file) */
+  create?: boolean;
+  /** Enable WAL mode (default: true) */
+  walMode?: boolean;
+}
+/**
+ * Create a Kysely instance with SQLite dialect
+ * Automatically uses kysely-bun-sqlite in Bun or better-sqlite3 in Node.js
+ *
+ * @param config - SQLite configuration
+ * @returns Kysely instance configured for the database
+ *
+ * @example
+ * ```typescript
+ * // In-memory database for testing
+ * const db = createKysely({ filename: ':memory:' });
+ *
+ * // File-based database for production
+ * const db = createKysely({ filename: './data/state.sqlite' });
+ * ```
+ */
+declare function createKysely(config: SqliteConfig): Kysely<Database>;
+/**
+ * Get the underlying SQLite database instance from Kysely
+ * Useful for executing raw SQL or pragmas
+ * Returns either bun:sqlite Database or better-sqlite3 Database depending on runtime
+ */
+declare function getRawDatabase(db: Kysely<Database>): any;
+//#endregion
+export { SqliteConfig, createKysely, getRawDatabase };

package/lib/migrations/001-genesis.cjs

@@ -0,0 +1,59 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let kysely = require("kysely");
+
+//#region src/migrations/001-genesis.ts
+var _001_genesis_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	down: () => down,
+	up: () => up
+});
+/**
+* Genesis migration - creates all StateDB tables
+*/
+async function up(db) {
+	await db.schema.createTable("account").ifNotExists().addColumn("address", "text", (col) => col.primaryKey()).addColumn("balance", "text", (col) => col.notNull().defaultTo("0")).addColumn("gasBalance", "text", (col) => col.defaultTo("0")).addColumn("moniker", "text").addColumn("pk", "text").addColumn("nonce", "integer", (col) => col.defaultTo(0)).addColumn("numTxs", "integer", (col) => col.defaultTo(0)).addColumn("numAssets", "integer", (col) => col.defaultTo(0)).addColumn("issuer", "text").addColumn("migratedTo", "text").addColumn("migratedFrom", "text").addColumn("stake", "text").addColumn("tokens", "text").addColumn("data", "text").addColumn("context", "text").addColumn("poke", "text").addColumn("_retrievedAt", "text").execute();
+	await db.schema.createTable("balance").ifNotExists().addColumn("address", "text", (col) => col.notNull()).addColumn("tokenAddress", "text", (col) => col.notNull()).addColumn("balance", "text", (col) => col.notNull().defaultTo("0")).addColumn("context", "text").addPrimaryKeyConstraint("balance_pk", ["address", "tokenAddress"]).execute();
+	await db.schema.createTable("chain").ifNotExists().addColumn("address", "text", (col) => col.primaryKey()).addColumn("chainId", "text").addColumn("version", "text").addColumn("accounts", "text").addColumn("moderator", "text").addColumn("token", "text").addColumn("transaction", "text").addColumn("vaults", "text").addColumn("context", "text").execute();
+	await db.schema.createTable("tx").ifNotExists().addColumn("hash", "text", (col) => col.primaryKey()).addColumn("code", "text").addColumn("height", "integer").addColumn("index_", "integer").addColumn("receipts", "text").addColumn("receiptsVerified", "integer").addColumn("receiver", "text").addColumn("sender", "text").addColumn("time", "text").addColumn("tx", "text").addColumn("type", "text").addColumn("finalized", "integer").addColumn("valid", "integer").execute();
+	await db.schema.createTable("asset").ifNotExists().addColumn("address", "text", (col) => col.primaryKey()).addColumn("owner", "text").addColumn("moniker", "text").addColumn("readonly", "integer").addColumn("transferrable", "integer").addColumn("issuer", "text").addColumn("parent", "text").addColumn("ttl", "integer").addColumn("consumedTime", "text").addColumn("endpoint", "text").addColumn("display", "text").addColumn("tags", "text").addColumn("stake", "text").addColumn("data", "text").addColumn("context", "text").execute();
+	await db.schema.createTable("token").ifNotExists().addColumn("address", "text", (col) => col.primaryKey()).addColumn("symbol", "text").addColumn("name", "text").addColumn("decimal", "integer").addColumn("unit", "text").addColumn("description", "text").addColumn("icon", "text").addColumn("totalSupply", "text").addColumn("initialSupply", "text").addColumn("maxTotalSupply", "text").addColumn("foreignToken", "text").addColumn("issuer", "text").addColumn("website", "text").addColumn("metadata", "text").addColumn("tokenFactoryAddress", "text").addColumn("spenders", "text").addColumn("minters", "text").addColumn("type", "text").addColumn("data", "text").addColumn("context", "text").execute();
+	await kysely.sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_token_symbol ON token(symbol) WHERE symbol IS NOT NULL`.execute(db);
+	await db.schema.createTable("factory").ifNotExists().addColumn("address", "text", (col) => col.primaryKey()).addColumn("owner", "text").addColumn("name", "text").addColumn("description", "text").addColumn("settlement", "text").addColumn("limit", "integer").addColumn("trustedIssuers", "text").addColumn("tokens", "text").addColumn("numMinted", "integer").addColumn("lastSettlement", "text").addColumn("input", "text").addColumn("output", "text").addColumn("display", "text").addColumn("hooks", "text").addColumn("data", "text").addColumn("context", "text").addColumn("balance", "text").addColumn("stake", "text").execute();
+	await db.schema.createTable("tokenFactory").ifNotExists().addColumn("address", "text", (col) => col.primaryKey()).addColumn("owner", "text").addColumn("name", "text").addColumn("description", "text").addColumn("moniker", "text").addColumn("tokenAddress", "text").addColumn("reserveAddress", "text").addColumn("currentSupply", "text").addColumn("reserveBalance", "text").addColumn("feeRate", "integer").addColumn("status", "text").addColumn("curve", "text").addColumn("input", "text").addColumn("output", "text").addColumn("data", "text").addColumn("context", "text").execute();
+	await db.schema.createTable("stake").ifNotExists().addColumn("address", "text", (col) => col.primaryKey()).addColumn("sender", "text").addColumn("receiver", "text").addColumn("tokens", "text").addColumn("assets", "text").addColumn("slashers", "text").addColumn("revocable", "integer").addColumn("message", "text").addColumn("revokeWaitingPeriod", "integer").addColumn("revokedTokens", "text").addColumn("revokedAssets", "text").addColumn("nonce", "text").addColumn("data", "text").addColumn("context", "text").execute();
+	await db.schema.createTable("delegation").ifNotExists().addColumn("address", "text", (col) => col.primaryKey()).addColumn("from_", "text").addColumn("to_", "text").addColumn("ops", "text").addColumn("data", "text").addColumn("context", "text").execute();
+	await db.schema.createTable("rollup").ifNotExists().addColumn("address", "text", (col) => col.primaryKey()).addColumn("tokenAddress", "text").addColumn("vaultAddress", "text").addColumn("contractAddress", "text").addColumn("paused", "integer").addColumn("closed", "integer").addColumn("seedValidators", "text").addColumn("validators", "text").addColumn("minStakeAmount", "text").addColumn("maxStakeAmount", "text").addColumn("minSignerCount", "integer").addColumn("maxSignerCount", "integer").addColumn("minBlockSize", "integer").addColumn("maxBlockSize", "integer").addColumn("minBlockInterval", "integer").addColumn("minBlockConfirmation", "integer").addColumn("minDepositAmount", "text").addColumn("maxDepositAmount", "text").addColumn("minWithdrawAmount", "text").addColumn("maxWithdrawAmount", "text").addColumn("depositFeeRate", "integer").addColumn("withdrawFeeRate", "integer").addColumn("proposerFeeShare", "integer").addColumn("publisherFeeShare", "integer").addColumn("minDepositFee", "text").addColumn("maxDepositFee", "text").addColumn("minWithdrawFee", "text").addColumn("maxWithdrawFee", "text").addColumn("issuer", "text").addColumn("blockHeight", "integer").addColumn("blockHash", "text").addColumn("leaveWaitingPeriod", "integer").addColumn("publishWaitingPeriod", "integer").addColumn("publishSlashRate", "integer").addColumn("revokeWaitingPeriod", "integer").addColumn("erc20TokenAddress", "text").addColumn("foreignChainId", "text").addColumn("foreignChainType", "text").addColumn("migrateHistory", "text").addColumn("vaultHistory", "text").addColumn("data", "text").addColumn("context", "text").execute();
+	await kysely.sql`DROP INDEX IF EXISTS idx_rollup_token`.execute(db);
+	await kysely.sql`CREATE INDEX IF NOT EXISTS idx_rollup_token ON rollup(tokenAddress) WHERE tokenAddress IS NOT NULL`.execute(db);
+	await db.schema.createTable("rollupBlock").ifNotExists().addColumn("hash", "text", (col) => col.primaryKey()).addColumn("rollup", "text").addColumn("height", "integer").addColumn("merkleRoot", "text").addColumn("previousHash", "text").addColumn("txsHash", "text").addColumn("txs", "text").addColumn("proposer", "text").addColumn("mintedAmount", "text").addColumn("burnedAmount", "text").addColumn("rewardAmount", "text").addColumn("minReward", "text").addColumn("blockReward", "text").addColumn("governance", "integer").addColumn("checkpoint", "text").addColumn("txHash", "text").addColumn("signatures", "text").addColumn("data", "text").addColumn("context", "text").execute();
+	await db.schema.createTable("evidence").ifNotExists().addColumn("hash", "text", (col) => col.primaryKey()).addColumn("type", "text").addColumn("data", "text").addColumn("context", "text").execute();
+}
+/**
+* Rollback migration - drops all tables
+*/
+async function down(db) {
+	for (const table of [
+		"evidence",
+		"rollupBlock",
+		"rollup",
+		"delegation",
+		"stake",
+		"tokenFactory",
+		"factory",
+		"token",
+		"asset",
+		"tx",
+		"chain",
+		"balance",
+		"account"
+	]) await db.schema.dropTable(table).ifExists().execute();
+}
+
+//#endregion
+Object.defineProperty(exports, '_001_genesis_exports', {
+  enumerable: true,
+  get: function () {
+    return _001_genesis_exports;
+  }
+});
+exports.down = down;
+exports.up = up;

package/lib/migrations/001-genesis.d.cts

@@ -0,0 +1,14 @@
+import { Kysely } from "kysely";
+
+//#region src/migrations/001-genesis.d.ts
+
+/**
+ * Genesis migration - creates all StateDB tables
+ */
+declare function up(db: Kysely<unknown>): Promise<void>;
+/**
+ * Rollback migration - drops all tables
+ */
+declare function down(db: Kysely<unknown>): Promise<void>;
+//#endregion
+export { down, up };

package/lib/migrations/index.cjs

@@ -0,0 +1,62 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_migrations_001_genesis = require('./001-genesis.cjs');
+let kysely = require("kysely");
+
+//#region src/migrations/index.ts
+/**
+* In-memory migration provider
+* Provides migrations directly without filesystem access
+*/
+var InMemoryMigrationProvider = class {
+	constructor(migrations) {
+		this.migrations = migrations;
+	}
+	async getMigrations() {
+		return this.migrations;
+	}
+};
+/**
+* Run all pending migrations
+*
+* @param db - Kysely database instance
+* @throws Error if any migration fails
+*
+* @example
+* ```typescript
+* const db = createKysely({ filename: ':memory:' });
+* await runMigrations(db);
+* ```
+*/
+async function runMigrations(db) {
+	const { error, results } = await new kysely.Migrator({
+		db,
+		provider: new InMemoryMigrationProvider({ "001-genesis": require_migrations_001_genesis._001_genesis_exports })
+	}).migrateToLatest();
+	results?.forEach((it) => {
+		if (it.status === "Success") {} else if (it.status === "Error") console.error(`Migration "${it.migrationName}" failed`);
+	});
+	if (error) {
+		console.error("Migration failed:", error);
+		throw error;
+	}
+}
+/**
+* Roll back all migrations
+* WARNING: This will drop all tables and data
+*/
+async function rollbackMigrations(db) {
+	const migrator = new kysely.Migrator({
+		db,
+		provider: new InMemoryMigrationProvider({ "001-genesis": require_migrations_001_genesis._001_genesis_exports })
+	});
+	let hasMore = true;
+	while (hasMore) {
+		const { error, results } = await migrator.migrateDown();
+		if (error) throw error;
+		hasMore = results !== void 0 && results.length > 0;
+	}
+}
+
+//#endregion
+exports.rollbackMigrations = rollbackMigrations;
+exports.runMigrations = runMigrations;

package/lib/migrations/index.d.cts

@@ -0,0 +1,24 @@
+import { Kysely } from "kysely";
+
+//#region src/migrations/index.d.ts
+
+/**
+ * Run all pending migrations
+ *
+ * @param db - Kysely database instance
+ * @throws Error if any migration fails
+ *
+ * @example
+ * ```typescript
+ * const db = createKysely({ filename: ':memory:' });
+ * await runMigrations(db);
+ * ```
+ */
+declare function runMigrations(db: Kysely<unknown>): Promise<void>;
+/**
+ * Roll back all migrations
+ * WARNING: This will drop all tables and data
+ */
+declare function rollbackMigrations(db: Kysely<unknown>): Promise<void>;
+//#endregion
+export { rollbackMigrations, runMigrations };

package/lib/package.cjs

@@ -0,0 +1,76 @@
+
+//#region package.json
+var package_default = {
+	name: "@ocap/statedb-sqlite",
+	description: "OCAP statedb adapter that uses SQLite as backend",
+	version: "1.0.0",
+	author: "wangshijun <shijun@arcblock.io> (https://www.arcblock.io)",
+	bugs: {
+		"url": "https://github.com/ArcBlock/blockchain/issues",
+		"email": "shijun@arcblock.io"
+	},
+	publishConfig: { "access": "public" },
+	contributors: ["wangshijun <shijun@arcblock.io> (https://www.arcblock.io)"],
+	devDependencies: { "@ocap/statedb-test": "workspace:*" },
+	homepage: "https://github.com/ArcBlock/blockchain/tree/master/statedb/sqlite",
+	keywords: [
+		"ocap",
+		"statedb",
+		"sqlite",
+		"kysely"
+	],
+	license: "Apache-2.0",
+	type: "module",
+	main: "./lib/index.cjs",
+	module: "./esm/index.mjs",
+	types: "./esm/index.d.mts",
+	exports: {
+		".": {
+			"types": "./esm/index.d.mts",
+			"import": "./esm/index.mjs",
+			"default": "./lib/index.cjs"
+		},
+		"./lib/*.js": {
+			"types": "./esm/*.d.mts",
+			"import": "./esm/*.mjs",
+			"default": "./lib/*.cjs"
+		},
+		"./lib/*": {
+			"types": "./esm/*.d.mts",
+			"import": "./esm/*.mjs",
+			"default": "./lib/*.cjs"
+		}
+	},
+	files: ["lib", "esm"],
+	repository: {
+		"type": "git",
+		"url": "https://github.com/ArcBlock/blockchain/tree/master/statedb/sqlite"
+	},
+	scripts: {
+		"build": "tsdown",
+		"prebuild": "rm -rf lib esm",
+		"lint": "biome check",
+		"lint:fix": "biome check --write",
+		"test": "bun test",
+		"coverage": "npm run test -- --coverage"
+	},
+	dependencies: {
+		"@ocap/state": "workspace:*",
+		"@ocap/statedb": "workspace:*",
+		"@ocap/types": "workspace:*",
+		"@ocap/util": "workspace:*",
+		"debug": "^4.4.3",
+		"better-sqlite3": "^11.8.1",
+		"kysely": "^0.27.0",
+		"kysely-bun-sqlite": "^0.4.0",
+		"lodash": "^4.17.23"
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return package_default;
+  }
+});