@ocap/statedb-sqlite 1.29.5

package/lib/table/account.cjs

@@ -0,0 +1,101 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_table_base = require('./base.cjs');
+let _ocap_state_lib_states_account = require("@ocap/state/lib/states/account");
+
+//#region src/table/account.ts
+/**
+* Account Table
+* Standard account state with balance sync support
+* Includes migration chain following and circular migration detection
+*/
+var AccountTable = class extends require_table_base.default {
+	constructor(config) {
+		super({
+			...config,
+			name: "account",
+			uniqIndex: "address",
+			schema: { jsonFields: [
+				"migratedTo",
+				"migratedFrom",
+				"stake",
+				"tokens",
+				"data",
+				"context",
+				"poke"
+			] }
+		});
+	}
+	/**
+	* Check if adding migration targets would create a cycle
+	* @param sourceAddress - The address that will have migratedTo set
+	* @param targets - The migration targets to check
+	* @param context - Operation context with transaction
+	* @returns true if a cycle would be created
+	*/
+	async wouldCreateCycle(sourceAddress, targets, context) {
+		const visited = /* @__PURE__ */ new Set();
+		visited.add(sourceAddress);
+		const checkTarget = async (target) => {
+			const normalizedTarget = (0, _ocap_state_lib_states_account.ensureChecksumAddress)(target);
+			if (normalizedTarget === sourceAddress) return true;
+			if (visited.has(normalizedTarget)) return false;
+			visited.add(normalizedTarget);
+			const targetAccount = await super._get(normalizedTarget, context);
+			if (targetAccount?.migratedTo?.length) {
+				for (const nextTarget of targetAccount.migratedTo) if (await checkTarget(nextTarget)) return true;
+			}
+			return false;
+		};
+		for (const target of targets) if (await checkTarget(target)) return true;
+		return false;
+	}
+	/**
+	* Get account with migration chain following
+	* When an account has migratedTo set, follows the chain to get the final account
+	*/
+	async _get(address, context = {}) {
+		const { traceMigration = true, ...restContext } = context;
+		const normalizedAddress = (0, _ocap_state_lib_states_account.ensureChecksumAddress)(address);
+		const current = await super._get(normalizedAddress, restContext);
+		if (current && traceMigration && Array.isArray(current.migratedTo) && current.migratedTo.length) {
+			const visitedAddresses = context._visitedAddresses || /* @__PURE__ */ new Set();
+			if (visitedAddresses.has(normalizedAddress)) return null;
+			visitedAddresses.add(normalizedAddress);
+			return this._get(current.migratedTo[0], {
+				...context,
+				_visitedAddresses: visitedAddresses
+			});
+		}
+		return current;
+	}
+	/**
+	* Create account with address normalization and circular migration detection
+	*/
+	async _create(key, attrs = {}, context) {
+		const address = (0, _ocap_state_lib_states_account.ensureChecksumAddress)(key);
+		const attrsWithMigration = attrs;
+		if (attrsWithMigration.migratedTo?.length) {
+			if (await this.wouldCreateCycle(address, attrsWithMigration.migratedTo, context)) throw new Error(`Circular migration detected: ${address} -> ${attrsWithMigration.migratedTo.join(", ")}`);
+		}
+		return super._create(address, {
+			...attrs,
+			[this.uniqIndex]: address
+		}, context);
+	}
+	/**
+	* Update account with circular migration detection
+	*/
+	async _update(key, updates, context) {
+		const address = (0, _ocap_state_lib_states_account.ensureChecksumAddress)(key);
+		const updatesWithMigration = updates;
+		if (updatesWithMigration.migratedTo?.length) {
+			if (await this.wouldCreateCycle(address, updatesWithMigration.migratedTo, context)) throw new Error(`Circular migration detected: ${address} -> ${updatesWithMigration.migratedTo.join(", ")}`);
+		}
+		return super._update(address, updates, context);
+	}
+};
+var account_default = AccountTable;
+
+//#endregion
+exports.default = account_default;

package/lib/table/account.d.cts

@@ -0,0 +1,40 @@
+import SqliteTable, { SqliteTableConfig } from "./base.cjs";
+import { IAccountState, IOperationContext } from "@ocap/types";
+
+//#region src/table/account.d.ts
+interface AccountOperationContext extends IOperationContext {
+  traceMigration?: boolean;
+  /** Internal: tracks visited addresses to detect circular migrations */
+  _visitedAddresses?: Set<string>;
+}
+/**
+ * Account Table
+ * Standard account state with balance sync support
+ * Includes migration chain following and circular migration detection
+ */
+declare class AccountTable extends SqliteTable<IAccountState> {
+  constructor(config: Omit<SqliteTableConfig, 'name' | 'uniqIndex' | 'schema'>);
+  /**
+   * Check if adding migration targets would create a cycle
+   * @param sourceAddress - The address that will have migratedTo set
+   * @param targets - The migration targets to check
+   * @param context - Operation context with transaction
+   * @returns true if a cycle would be created
+   */
+  private wouldCreateCycle;
+  /**
+   * Get account with migration chain following
+   * When an account has migratedTo set, follows the chain to get the final account
+   */
+  _get(address: string, context?: AccountOperationContext): Promise<IAccountState | null>;
+  /**
+   * Create account with address normalization and circular migration detection
+   */
+  _create(key: string, attrs?: Partial<IAccountState>, context?: IOperationContext): Promise<IAccountState>;
+  /**
+   * Update account with circular migration detection
+   */
+  _update(key: string, updates: Partial<IAccountState>, context?: IOperationContext): Promise<IAccountState>;
+}
+//#endregion
+export { AccountTable as default };

package/lib/table/balance.cjs

@@ -0,0 +1,71 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_table_base = require('./base.cjs');
+let _ocap_state_lib_states_account = require("@ocap/state/lib/states/account");
+
+//#region src/table/balance.ts
+/**
+* Balance Table
+* Manages token balances with composite primary key (address, tokenAddress)
+*/
+var BalanceTable = class extends require_table_base.default {
+	constructor(config) {
+		super({
+			...config,
+			name: "balance",
+			uniqIndex: ["address", "tokenAddress"],
+			schema: { jsonFields: ["context"] }
+		});
+	}
+	/**
+	* Get all token balances for an address
+	*
+	* @param address - Account address
+	* @param _context - Operation context
+	* @returns Object mapping tokenAddress to balance
+	*/
+	async getBalance(address, _context) {
+		const sqlContext = _context;
+		const executor = this.getExecutor(sqlContext);
+		const normalizedAddress = (0, _ocap_state_lib_states_account.ensureChecksumAddress)(address);
+		return (await executor.selectFrom("balance").selectAll().where("address", "=", normalizedAddress).execute() || []).reduce((acc, token) => {
+			acc[token.tokenAddress] = token.balance;
+			return acc;
+		}, {});
+	}
+	/**
+	* Update token balances for an address
+	* Creates new records for new tokens, updates existing ones
+	*
+	* @param params - Update parameters
+	* @param ctx - Operation context
+	* @returns Updated token balances
+	*/
+	async updateBalance({ address, tokens, context = {} }, ctx) {
+		if (!Object.keys(tokens).length) return {};
+		const tokenBalances = await this.getBalance(address, ctx);
+		const updatedTokens = Object.keys(tokens).filter((token) => tokenBalances[token] && tokenBalances[token] !== "0" || tokens[token] && tokens[token] !== "0").filter((token) => tokenBalances[token] !== tokens[token]);
+		await Promise.all(updatedTokens.map(async (tokenAddress) => {
+			const key = {
+				address,
+				tokenAddress
+			};
+			if (tokenBalances[tokenAddress]) await this.update(key, {
+				...key,
+				balance: tokens[tokenAddress],
+				context
+			}, ctx);
+			else await this.create(key, {
+				...key,
+				balance: tokens[tokenAddress],
+				context
+			}, ctx);
+			tokenBalances[tokenAddress] = tokens[tokenAddress];
+		}));
+		return tokens;
+	}
+};
+var balance_default = BalanceTable;
+
+//#endregion
+exports.default = balance_default;

package/lib/table/balance.d.cts

@@ -0,0 +1,39 @@
+import SqliteTable, { SqliteTableConfig } from "./base.cjs";
+import { IBalanceState, IOperationContext } from "@ocap/types";
+
+//#region src/table/balance.d.ts
+
+/**
+ * Balance Table
+ * Manages token balances with composite primary key (address, tokenAddress)
+ */
+declare class BalanceTable extends SqliteTable<IBalanceState> {
+  constructor(config: Omit<SqliteTableConfig, 'name' | 'uniqIndex' | 'schema'>);
+  /**
+   * Get all token balances for an address
+   *
+   * @param address - Account address
+   * @param _context - Operation context
+   * @returns Object mapping tokenAddress to balance
+   */
+  getBalance(address: string, _context?: IOperationContext): Promise<Record<string, string>>;
+  /**
+   * Update token balances for an address
+   * Creates new records for new tokens, updates existing ones
+   *
+   * @param params - Update parameters
+   * @param ctx - Operation context
+   * @returns Updated token balances
+   */
+  updateBalance({
+    address,
+    tokens,
+    context
+  }: {
+    address: string;
+    tokens: Record<string, string>;
+    context?: unknown;
+  }, ctx?: IOperationContext): Promise<Record<string, string>>;
+}
+//#endregion
+export { BalanceTable as default };

package/lib/table/base.cjs

@@ -0,0 +1,221 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let _ocap_statedb = require("@ocap/statedb");
+let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto);
+let lodash_omit = require("lodash/omit");
+lodash_omit = require_rolldown_runtime.__toESM(lodash_omit);
+
+//#region src/table/base.ts
+/**
+* SQLite State Table base class
+* Extends StateDBTable to provide SQLite-specific implementation
+*/
+var SqliteTable = class SqliteTable extends _ocap_statedb.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 node_crypto.default.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 = (0, lodash_omit.default)(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
+exports.default = base_default;

package/lib/table/base.d.cts

@@ -0,0 +1,84 @@
+import { Database, SqliteOperationContext } from "../interfaces.cjs";
+import { StateDBTable } from "@ocap/statedb";
+import { IBalanceTable, IOperationContext } from "@ocap/types";
+import { Kysely, Transaction } from "kysely";
+
+//#region src/table/base.d.ts
+
+/**
+ * Table schema configuration
+ */
+interface TableSchema {
+  /** Column names that contain JSON data */
+  jsonFields?: string[];
+  /** Column names that contain boolean data (stored as integer 0/1 in SQLite) */
+  booleanFields?: string[];
+  /** Column name mapping (e.g., 'from' -> 'from_' for reserved keywords) */
+  columnMapping?: Record<string, string>;
+}
+/**
+ * Table configuration
+ */
+interface SqliteTableConfig {
+  name: string;
+  uniqIndex: string | string[];
+  db: Kysely<Database>;
+  schema?: TableSchema;
+  syncBalance?: boolean;
+  balanceTable?: IBalanceTable;
+}
+/**
+ * SQLite State Table base class
+ * Extends StateDBTable to provide SQLite-specific implementation
+ */
+declare class SqliteTable<T = unknown> extends StateDBTable<T> {
+  name: string;
+  db: Kysely<Database>;
+  schema: TableSchema;
+  balanceTable?: IBalanceTable;
+  syncBalance: boolean;
+  constructor(config: SqliteTableConfig);
+  /**
+   * Get the Kysely executor (use transaction if available)
+   */
+  protected getExecutor(context?: SqliteOperationContext): Kysely<Database> | Transaction<Database>;
+  /**
+   * Generate primary key from document
+   * Handles both simple string keys and composite keys
+   */
+  generatePrimaryKey(doc: string | Record<string, unknown>): string;
+  /**
+   * Convert a key to a query object
+   */
+  protected formatKeyToQuery(key: unknown): Record<string, unknown>;
+  /**
+   * Map column name for reserved keywords
+   */
+  protected mapColumnName(name: string): string;
+  /**
+   * Reverse map column name
+   */
+  protected unmapColumnName(name: string): string;
+  /**
+   * 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
+   */
+  protected serializeForDb(data: Record<string, unknown>): Record<string, unknown>;
+  /**
+   * Deserialize data from database read
+   * - Parses JSON strings back to objects
+   * - Converts integers (0/1) back to booleans
+   * - Unmaps column names
+   */
+  protected deserializeFromDb(data: Record<string, unknown> | undefined | null): Record<string, unknown> | null;
+  _create(key: string | Record<string, unknown>, attrs?: Partial<T>, context?: IOperationContext): Promise<T>;
+  _get(key: string | Record<string, unknown>, context?: IOperationContext): Promise<T | null>;
+  _history(_key?: string, _context?: IOperationContext): T[];
+  _update(key: string | Record<string, unknown>, updates: Partial<T>, context?: IOperationContext): Promise<T>;
+  _reset(_context?: IOperationContext): Promise<void>;
+  updateOrCreate(exist: unknown, state: Partial<T>, ctx?: IOperationContext): Promise<T>;
+}
+//#endregion
+export { SqliteTableConfig, TableSchema, SqliteTable as default };

package/lib/table/rollup.cjs

@@ -0,0 +1,45 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_table_base = require('./base.cjs');
+
+//#region src/table/rollup.ts
+/**
+* Rollup Table
+* Extends base table with tokenAddress-based existence check
+*/
+var RollupTable = class extends require_table_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
+exports.default = rollup_default;

package/lib/table/rollup.d.cts

@@ -0,0 +1,22 @@
+import SqliteTable, { SqliteTableConfig } from "./base.cjs";
+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/lib/table/token.cjs

@@ -0,0 +1,43 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_table_base = require('./base.cjs');
+
+//#region src/table/token.ts
+/**
+* Token Table
+* Extends base table with symbol-based existence check
+*/
+var TokenTable = class extends require_table_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
+exports.default = token_default;