@ocap/indexdb-memory 1.28.9 → 1.29.1

package/lib/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,29 @@
+//#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 __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.__toESM = __toESM;

package/lib/db/base.cjs

@@ -0,0 +1,434 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_package = require('../package.cjs');
+let _ocap_indexdb = require("@ocap/indexdb");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let _arcblock_did_lib_type = require("@arcblock/did/lib/type");
+let _ocap_util = require("@ocap/util");
+let _ocap_util_lib_constant = require("@ocap/util/lib/constant");
+let lodash_omit = require("lodash/omit");
+lodash_omit = require_rolldown_runtime.__toESM(lodash_omit);
+
+//#region src/db/base.ts
+const debug$1 = (0, debug.default)(require_package.name);
+const MAX_REQUEST_FACTORY_ADDRESS_SIZE = 100;
+/** Helper to safely get collection from IIndexTable */
+function getCollection(table) {
+	return table.collection;
+}
+function applyTimeFilter(query, timeFilter, defaultField, validFields) {
+	let { startDateTime, endDateTime, field = defaultField } = timeFilter;
+	startDateTime = (0, _ocap_indexdb.parseDateTime)(startDateTime);
+	endDateTime = (0, _ocap_indexdb.parseDateTime)(endDateTime);
+	if (!validFields.includes(field)) field = defaultField;
+	if (startDateTime && endDateTime) query.where((x) => x[field] > startDateTime && x[field] <= endDateTime);
+	else if (startDateTime) query.where((x) => x[field] > startDateTime);
+	else if (endDateTime) query.where((x) => x[field] <= endDateTime);
+}
+function applyArrayFilter(query, items, fieldName, isArrayField) {
+	if (!items.length) return;
+	if (isArrayField) query.where((x) => x[fieldName].some((f) => items.includes(f)));
+	else query.where((x) => items.includes(x[fieldName]));
+}
+function buildPagingResult(total, pagination, itemCount) {
+	return {
+		cursor: String(pagination.cursor + itemCount),
+		next: itemCount >= pagination.size,
+		total
+	};
+}
+var LocalBaseIndexDB = class extends _ocap_indexdb.BaseIndexDB {
+	listTransactions(params = {}) {
+		const { addressFilter = {}, paging = {}, timeFilter = {}, typeFilter = {}, assetFilter = {}, factoryFilter = {}, tokenFilter = {}, accountFilter = {}, validityFilter = {}, txFilter = {}, rollupFilter = {}, stakeFilter = {}, delegationFilter = {}, tokenFactoryFilter = {}, includeItxData = false } = params;
+		const query = getCollection(this.tx).chain();
+		const { sender, receiver, direction = "UNION" } = addressFilter;
+		const { types = [] } = typeFilter;
+		const { factories = [] } = factoryFilter;
+		const { assets = [] } = assetFilter;
+		const { tokens = [] } = tokenFilter;
+		const { accounts = [] } = accountFilter;
+		const { txs = [] } = txFilter;
+		const { rollups = [] } = rollupFilter;
+		const { stakes = [] } = stakeFilter;
+		const { delegations = [] } = delegationFilter;
+		const { tokenFactories = [] } = tokenFactoryFilter;
+		const pagination = (0, _ocap_indexdb.formatPagination)({
+			paging,
+			defaultSortField: "time"
+		});
+		debug$1("listTransactions", {
+			sender,
+			receiver,
+			pagination,
+			types,
+			factories,
+			assets,
+			tokens,
+			accounts,
+			rollups,
+			stakes,
+			delegations,
+			includeItxData
+		});
+		if (sender && receiver) {
+			if (direction === "MUTUAL") query.where((x) => x.sender === sender && x.receiver === receiver || x.sender === receiver && x.receiver === sender);
+			else if (direction === "ONE_WAY") query.where((x) => x.sender === sender && x.receiver === receiver);
+			else if (direction === "UNION") query.where((x) => x.sender === sender || x.receiver === receiver);
+		} else if (sender) query.where((x) => x.sender === sender);
+		else if (receiver) query.where((x) => x.receiver === receiver);
+		applyArrayFilter(query, types, "type", false);
+		applyArrayFilter(query, factories, "factories", true);
+		applyArrayFilter(query, assets, "assets", true);
+		applyArrayFilter(query, tokens, "tokens", true);
+		applyArrayFilter(query, accounts, "accounts", true);
+		applyArrayFilter(query, tokenFactories, "tokenFactories", true);
+		applyArrayFilter(query, txs, "hash", false);
+		applyArrayFilter(query, rollups, "rollups", true);
+		applyArrayFilter(query, stakes, "stakes", true);
+		applyArrayFilter(query, delegations, "delegations", true);
+		applyTimeFilter(query, timeFilter, "time", ["time"]);
+		const { validity } = validityFilter;
+		if (validity === "VALID") query.where((x) => x.valid === true);
+		else if (validity === "INVALID") query.where((x) => x.valid === false);
+		let transactions = query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		if (!includeItxData) transactions = transactions.map((tx) => {
+			if (tx.tx && tx.tx?.itxJson) return {
+				...tx,
+				tx: {
+					...tx.tx,
+					itxJson: (0, lodash_omit.default)(tx.tx.itxJson, ["data"])
+				}
+			};
+			return tx;
+		});
+		const total = query.count();
+		return {
+			transactions,
+			paging: buildPagingResult(total, pagination, transactions.length)
+		};
+	}
+	async getRelatedAddresses(address) {
+		let account = await this.account.get(address);
+		if (!account) return [];
+		const related = [address];
+		while (account?.migratedFrom && related.length <= 8) {
+			const migratedFrom = account.migratedFrom;
+			related.push(migratedFrom);
+			account = await this.account.get(migratedFrom);
+		}
+		return related.filter(Boolean);
+	}
+	async listAssets(params = {}) {
+		const { ownerAddress, factoryAddress, paging, timeFilter = {} } = params;
+		if (!ownerAddress && !factoryAddress) return {
+			assets: [],
+			account: null,
+			paging: {
+				cursor: "0",
+				next: false,
+				total: 0
+			}
+		};
+		const pagination = (0, _ocap_indexdb.formatPagination)({
+			paging,
+			defaultSortField: "renaissanceTime"
+		});
+		const { field = "renaissanceTime" } = timeFilter;
+		if ([
+			"genesisTime",
+			"renaissanceTime",
+			"consumedTime"
+		].includes(field) === false) throw new Error("invalid field specified in timeFilter");
+		const query = getCollection(this.asset).chain();
+		if (ownerAddress) {
+			const possibleOwners = await this.getRelatedAddresses(ownerAddress);
+			if (possibleOwners.length) query.where((x) => possibleOwners.includes(x.owner));
+			else return {
+				assets: [],
+				account: null,
+				paging: {
+					cursor: "0",
+					next: false,
+					total: 0
+				}
+			};
+		}
+		if (factoryAddress) query.where((x) => x.parent === factoryAddress);
+		applyTimeFilter(query, timeFilter, "renaissanceTime", [
+			"genesisTime",
+			"renaissanceTime",
+			"consumedTime"
+		]);
+		debug$1("listAssets", {
+			ownerAddress,
+			factoryAddress,
+			timeFilter,
+			paging,
+			pagination
+		});
+		const assets = query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		const total = query.count();
+		return {
+			assets,
+			account: ownerAddress ? await this.account.get(ownerAddress) : null,
+			paging: (0, _ocap_indexdb.formatNextPagination)(total, pagination)
+		};
+	}
+	async listTopAccounts(params = {}) {
+		const { paging, tokenAddress } = params;
+		const query = getCollection(this.account).chain();
+		const pagination = (0, _ocap_indexdb.formatPagination)({
+			paging,
+			defaultSortField: "balance",
+			supportedSortFields: [
+				"genesisTime",
+				"renaissanceTime",
+				"balance",
+				"moniker"
+			]
+		});
+		debug$1("listTopAccounts", {
+			tokenAddress,
+			paging,
+			pagination
+		});
+		query.where((x) => {
+			const owned = x.tokens.find((t) => t.address === tokenAddress);
+			return owned ? owned.balance > "0" : false;
+		});
+		if (pagination.order.field === "balance") {
+			const descending = pagination.order.type === "desc";
+			query.sort((a, b) => {
+				const tokenA = a.tokens.find((t) => t.address === tokenAddress);
+				const tokenB = b.tokens.find((t) => t.address === tokenAddress);
+				const balanceA = new _ocap_util.BN(tokenA ? tokenA.balance : "0");
+				const balanceB = new _ocap_util.BN(tokenB ? tokenB.balance : "0");
+				if (balanceB.gt(balanceA)) return descending ? 1 : -1;
+				if (balanceB.eq(balanceA)) return 0;
+				return descending ? -1 : 1;
+			});
+		} else query.simplesort(pagination.order.field, pagination.order.type === "desc");
+		const accounts = query.offset(pagination.cursor).limit(pagination.size).data();
+		const total = query.count();
+		accounts.forEach((account) => {
+			const acc = account;
+			if (Array.isArray(acc.tokens) && acc.tokens.length) acc.tokens = acc.tokens.map((token) => {
+				token.decimal = typeof token.decimal === "undefined" ? _ocap_util_lib_constant.DEFAULT_TOKEN_DECIMAL : token.decimal;
+				return token;
+			});
+		});
+		return {
+			accounts,
+			paging: (0, _ocap_indexdb.formatNextPagination)(total, pagination)
+		};
+	}
+	async listTokens(params = {}) {
+		const { issuerAddress, paging } = params;
+		const conditions = {};
+		if (issuerAddress) conditions.issuer = issuerAddress;
+		const pagination = (0, _ocap_indexdb.formatPagination)({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: [
+				"genesisTime",
+				"renaissanceTime",
+				"issuer",
+				"symbol",
+				"totalSupply"
+			]
+		});
+		debug$1("listTokens", {
+			issuerAddress,
+			paging,
+			conditions,
+			pagination
+		});
+		let tokens = getCollection(this.token).chain().find(conditions).simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		tokens = tokens.map((token) => {
+			const t = token;
+			t.decimal = typeof t.decimal === "undefined" ? _ocap_util_lib_constant.DEFAULT_TOKEN_DECIMAL : t.decimal;
+			return t;
+		});
+		const total = this.token.count(Object.keys(conditions).length ? conditions : void 0);
+		return {
+			tokens,
+			paging: (0, _ocap_indexdb.formatNextPagination)(total, pagination)
+		};
+	}
+	async listTokenFactories(params = {}) {
+		const { owner, reserveAddress, tokenAddress, paging } = params;
+		const conditions = {};
+		if (owner) conditions.owner = owner;
+		if (reserveAddress) conditions.reserveAddress = reserveAddress;
+		if (tokenAddress) conditions.tokenAddress = tokenAddress;
+		const pagination = (0, _ocap_indexdb.formatPagination)({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: [
+				"genesisTime",
+				"renaissanceTime",
+				"reserveBalance",
+				"currentSupply"
+			]
+		});
+		debug$1("listTokenFactories", {
+			owner,
+			reserveAddress,
+			tokenAddress,
+			paging,
+			conditions,
+			pagination
+		});
+		return {
+			tokenFactories: getCollection(this.tokenFactory).chain().find(conditions).simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data(),
+			paging: (0, _ocap_indexdb.formatNextPagination)(this.tokenFactory.count(Object.keys(conditions).length ? conditions : void 0), pagination)
+		};
+	}
+	async listFactories(params = {}) {
+		const { ownerAddress, addressList, paging } = params;
+		const conditions = {};
+		if (ownerAddress) conditions.owner = ownerAddress;
+		if (Array.isArray(addressList) && addressList.length > 0) {
+			if (addressList.length > MAX_REQUEST_FACTORY_ADDRESS_SIZE) throw new Error(`The length of 'addressList' cannot exceed the length of ${MAX_REQUEST_FACTORY_ADDRESS_SIZE}`);
+			conditions.address = { $in: addressList };
+		}
+		const pagination = (0, _ocap_indexdb.formatPagination)({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: [
+				"genesisTime",
+				"renaissanceTime",
+				"owner",
+				"numMinted",
+				"limit",
+				"name"
+			]
+		});
+		debug$1("listFactories", {
+			ownerAddress,
+			paging,
+			conditions,
+			pagination
+		});
+		return {
+			factories: getCollection(this.factory).chain().find(conditions).simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data(),
+			paging: (0, _ocap_indexdb.formatNextPagination)(this.factory.count(Object.keys(conditions).length ? conditions : void 0), pagination)
+		};
+	}
+	listStakes(params = {}) {
+		const { addressFilter = {}, paging = {}, timeFilter = {}, assetFilter = {} } = params;
+		const query = getCollection(this.stake).chain();
+		const { sender, receiver } = addressFilter;
+		const { assets = [] } = assetFilter;
+		const pagination = (0, _ocap_indexdb.formatPagination)({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: ["genesisTime", "renaissanceTime"]
+		});
+		if (sender && receiver) query.where((x) => x.sender === sender && x.receiver === receiver);
+		else if (sender) query.where((x) => x.sender === sender);
+		else if (receiver) query.where((x) => x.receiver === receiver);
+		applyArrayFilter(query, assets, "assets", true);
+		applyTimeFilter(query, timeFilter, "renaissanceTime", ["genesisTime", "renaissanceTime"]);
+		const stakes = query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		return {
+			stakes,
+			paging: buildPagingResult(query.count(), pagination, stakes.length)
+		};
+	}
+	async listRollups(params = {}) {
+		const { paging, tokenAddress = "", erc20TokenAddress = "", foreignTokenAddress = "" } = params;
+		const pagination = (0, _ocap_indexdb.formatPagination)({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: ["genesisTime", "renaissanceTime"]
+		});
+		const query = getCollection(this.rollup).chain();
+		if (tokenAddress) query.where((x) => x.tokenAddress === tokenAddress);
+		const foreignTokenAddr = foreignTokenAddress || erc20TokenAddress;
+		if (erc20TokenAddress) query.where((x) => x.foreignToken.contractAddress === (0, _arcblock_did_lib_type.toChecksumAddress)(foreignTokenAddr));
+		debug$1("listRollups", {
+			paging,
+			pagination
+		});
+		return {
+			rollups: query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data(),
+			paging: (0, _ocap_indexdb.formatNextPagination)(query.count(), pagination)
+		};
+	}
+	listRollupBlocks(params = {}) {
+		const { paging = {}, rollupAddress = "", tokenAddress = "", proposer = "", height = "", timeFilter = {}, txFilter = {}, validatorFilter = {} } = params;
+		const query = getCollection(this.rollupBlock).chain();
+		const { txs = [] } = txFilter;
+		const { validators = [] } = validatorFilter;
+		const pagination = (0, _ocap_indexdb.formatPagination)({
+			paging,
+			defaultSortField: "genesisTime",
+			supportedSortFields: ["genesisTime", "renaissanceTime"]
+		});
+		if (rollupAddress) query.where((x) => x.rollup === rollupAddress);
+		if (Number(height) > 0) query.where((x) => Number(x.height) === Number(height));
+		if (proposer) query.where((x) => x.proposer === proposer);
+		if (tokenAddress) query.where((x) => x.tokenInfo.address === tokenAddress);
+		applyArrayFilter(query, txs, "txs", true);
+		applyArrayFilter(query, validators, "validators", true);
+		applyTimeFilter(query, timeFilter, "genesisTime", ["genesisTime", "renaissanceTime"]);
+		const blocks = query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		return {
+			blocks,
+			paging: buildPagingResult(query.count(), pagination, blocks.length)
+		};
+	}
+	listRollupValidators(params = {}) {
+		const { paging = {}, rollupAddress = "" } = params;
+		const query = getCollection(this.rollupValidator).chain();
+		const pagination = (0, _ocap_indexdb.formatPagination)({
+			paging,
+			defaultSortField: "genesisTime",
+			supportedSortFields: [
+				"joinTime",
+				"leaveTime",
+				"genesisTime",
+				"renaissanceTime"
+			]
+		});
+		if (rollupAddress) query.where((x) => x.rollup === rollupAddress);
+		const validators = query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		return {
+			validators,
+			paging: buildPagingResult(query.count(), pagination, validators.length)
+		};
+	}
+	listDelegations(params = {}) {
+		const { from, to, paging = {}, timeFilter = {} } = params;
+		if (!from && !to) return {
+			delegations: [],
+			paging: {
+				cursor: "0",
+				next: false,
+				total: 0
+			}
+		};
+		const query = getCollection(this.delegation).chain();
+		const pagination = (0, _ocap_indexdb.formatPagination)({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: ["genesisTime", "renaissanceTime"]
+		});
+		if (from && to) query.where((x) => x.from === from && x.to === to);
+		else if (from) query.where((x) => x.from === from);
+		else if (to) query.where((x) => x.to === to);
+		applyTimeFilter(query, timeFilter, "renaissanceTime", ["genesisTime", "renaissanceTime"]);
+		const delegations = query.simplesort(pagination.order.field, pagination.order.type === "desc").offset(pagination.cursor).limit(pagination.size).data();
+		const total = query.count();
+		return {
+			delegations: delegations.map((d) => (0, _ocap_indexdb.formatDelegationAfterRead)(d)),
+			paging: buildPagingResult(total, pagination, delegations.length)
+		};
+	}
+};
+var base_default = LocalBaseIndexDB;
+
+//#endregion
+exports.default = base_default;

package/lib/db/base.d.cts

@@ -0,0 +1,20 @@
+import { BaseIndexDB } from "@ocap/indexdb";
+import { IIndexDB, IListAccountsResult, IListAssetsResult, IListDelegationsResult, IListFactoriesResult, IListRollupBlocksResult, IListRollupValidatorsResult, IListRollupsResult, IListStakesResult, IListTokenFactoriesResult, IListTokensResult, IListTransactionsResult, TRequestListAssets, TRequestListDelegations, TRequestListFactories, TRequestListRollupBlocks, TRequestListRollupValidators, TRequestListRollups, TRequestListStakes, TRequestListTokenFactories, TRequestListTokens, TRequestListTopAccounts, TRequestListTransactions } from "@ocap/types";
+
+//#region src/db/base.d.ts
+declare class LocalBaseIndexDB extends BaseIndexDB implements IIndexDB {
+  listTransactions(params?: Partial<TRequestListTransactions>): IListTransactionsResult;
+  getRelatedAddresses(address: string): Promise<string[]>;
+  listAssets(params?: Partial<TRequestListAssets>): Promise<IListAssetsResult>;
+  listTopAccounts(params?: Partial<TRequestListTopAccounts>): Promise<IListAccountsResult>;
+  listTokens(params?: Partial<TRequestListTokens>): Promise<IListTokensResult>;
+  listTokenFactories(params?: Partial<TRequestListTokenFactories>): Promise<IListTokenFactoriesResult>;
+  listFactories(params?: Partial<TRequestListFactories>): Promise<IListFactoriesResult>;
+  listStakes(params?: Partial<TRequestListStakes>): IListStakesResult;
+  listRollups(params?: Partial<TRequestListRollups>): Promise<IListRollupsResult>;
+  listRollupBlocks(params?: Partial<TRequestListRollupBlocks>): IListRollupBlocksResult;
+  listRollupValidators(params?: Partial<TRequestListRollupValidators>): IListRollupValidatorsResult;
+  listDelegations(params?: Partial<TRequestListDelegations>): IListDelegationsResult;
+}
+//#endregion
+export { LocalBaseIndexDB as default };

package/lib/db/index.cjs

@@ -0,0 +1,40 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_package = require('../package.cjs');
+const require_table_base = require('../table/base.cjs');
+const require_table_transaction = require('../table/transaction.cjs');
+const require_db_base = require('./base.cjs');
+let _ocap_util_lib_md5 = require("@ocap/util/lib/md5");
+let lokijs = require("lokijs");
+lokijs = require_rolldown_runtime.__toESM(lokijs);
+
+//#region src/db/index.ts
+let instanceCounter = 0;
+var MemoryIndexDB = class extends require_db_base.default {
+	constructor() {
+		super();
+		this.name = require_package.name;
+		this.version = require_package.version;
+		this.md5 = _ocap_util_lib_md5.md5;
+		instanceCounter += 1;
+		this.db = new lokijs.default(`ocap-memory-indexdb-${instanceCounter}.db`);
+		this.account = new require_table_base.default("account", "address", this.db);
+		this.asset = new require_table_base.default("asset", "address", this.db);
+		this.delegation = new require_table_base.default("delegation", "address", this.db);
+		this.tx = new require_table_transaction.default("tx", "hash", this.db);
+		this.factory = new require_table_base.default("factory", "address", this.db);
+		this.token = new require_table_base.default("token", "address", this.db);
+		this.stake = new require_table_base.default("stake", "address", this.db);
+		this.rollup = new require_table_base.default("rollup", "address", this.db);
+		this.rollupBlock = new require_table_base.default("rollupBlock", "hash", this.db);
+		this.rollupValidator = new require_table_base.default("rollupValidator", "address", this.db);
+		this.tokenDistribution = new require_table_base.default("tokenDistribution", "tokenAddress", this.db);
+		this.balance = new require_table_base.default("balance", ["address", "tokenAddress"], this.db);
+		this.tokenFactory = new require_table_base.default("tokenFactory", "address", this.db);
+		this.attachReadyListeners();
+	}
+};
+var db_default = MemoryIndexDB;
+
+//#endregion
+exports.default = db_default;

package/lib/db/index.d.cts

@@ -0,0 +1,27 @@
+import LocalBaseIndexDB from "./base.cjs";
+import { IIndexDB, IIndexTable, IndexTableTypeMap } from "@ocap/types";
+import { md5 } from "@ocap/util/lib/md5";
+import Lokijs from "lokijs";
+
+//#region src/db/index.d.ts
+declare class MemoryIndexDB extends LocalBaseIndexDB implements IIndexDB {
+  name: string;
+  version: string;
+  md5: typeof md5;
+  db: Lokijs;
+  tx: IIndexTable<IndexTableTypeMap['tx']>;
+  account: IIndexTable<IndexTableTypeMap['account']>;
+  asset: IIndexTable<IndexTableTypeMap['asset']>;
+  token: IIndexTable<IndexTableTypeMap['token']>;
+  factory: IIndexTable<IndexTableTypeMap['factory']>;
+  stake: IIndexTable<IndexTableTypeMap['stake']>;
+  delegation: IIndexTable<IndexTableTypeMap['delegation']>;
+  rollup: IIndexTable<IndexTableTypeMap['rollup']>;
+  rollupBlock: IIndexTable<IndexTableTypeMap['rollupBlock']>;
+  rollupValidator: IIndexTable<IndexTableTypeMap['rollupValidator']>;
+  tokenDistribution: IIndexTable<IndexTableTypeMap['tokenDistribution']>;
+  tokenFactory: IIndexTable<IndexTableTypeMap['tokenFactory']>;
+  constructor();
+}
+//#endregion
+export { MemoryIndexDB as default };

package/lib/main.cjs

@@ -0,0 +1,10 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_db_base = require('./db/base.cjs');
+const require_db_index = require('./db/index.cjs');
+
+//#region src/main.ts
+var main_default = require_db_index.default;
+
+//#endregion
+exports.LocalBaseIndexDB = require_db_base.default;
+exports.default = main_default;

package/lib/main.d.cts

@@ -0,0 +1,3 @@
+import LocalBaseIndexDB from "./db/base.cjs";
+import MemoryIndexDB from "./db/index.cjs";
+export { LocalBaseIndexDB, MemoryIndexDB as default };

package/lib/package.cjs

@@ -0,0 +1,18 @@
+
+//#region package.json
+var name = "@ocap/indexdb-memory";
+var version = "1.20.2";
+
+//#endregion
+Object.defineProperty(exports, 'name', {
+  enumerable: true,
+  get: function () {
+    return name;
+  }
+});
+Object.defineProperty(exports, 'version', {
+  enumerable: true,
+  get: function () {
+    return version;
+  }
+});

package/lib/table/base.cjs

@@ -0,0 +1,55 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_package = require('../package.cjs');
+let _ocap_indexdb = require("@ocap/indexdb");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+
+//#region src/table/base.ts
+const debug$1 = (0, debug.default)(require_package.name);
+var MemoryIndex = class MemoryIndex extends _ocap_indexdb.BaseIndex {
+	/**
+	* @param name table name
+	* @param uniqIndex primary key(s)
+	* @param db LokiJS database instance
+	*/
+	constructor(name$1, uniqIndex, db) {
+		super(name$1, uniqIndex);
+		if (!db) throw new Error("db is required for MemoryIndex");
+		this.collection = db.addCollection(name$1, {
+			unique: [this.primaryKey],
+			clone: true
+		});
+		this.markReady();
+	}
+	count(...args) {
+		return this.collection.count(...args);
+	}
+	_insert(row) {
+		debug$1(`insert ${this.name}`, row);
+		const id = this.generatePrimaryKey(row);
+		return this.collection.insert({
+			[this.primaryKey]: id,
+			...row
+		});
+	}
+	_get(key) {
+		const id = this.generatePrimaryKey(key);
+		return key ? this.collection.by(this.primaryKey, id) ?? null : null;
+	}
+	_update(key, updates) {
+		const id = this.generatePrimaryKey(key);
+		const doc = MemoryIndex.prototype._get.call(this, id);
+		if (!doc) throw new Error(`${this.name} does not exists: ${key}`);
+		Object.assign(doc, updates);
+		this.collection.update(doc);
+		return doc;
+	}
+	_reset() {
+		this.collection.removeWhere({});
+	}
+};
+var base_default = MemoryIndex;
+
+//#endregion
+exports.default = base_default;

package/lib/table/base.d.cts

@@ -0,0 +1,22 @@
+import { BaseIndex } from "@ocap/indexdb";
+import { IIndexTable } from "@ocap/types";
+import Lokijs from "lokijs";
+
+//#region src/table/base.d.ts
+type UniqueIndex = string | string[];
+declare class MemoryIndex<T = unknown> extends BaseIndex<T> implements IIndexTable<T> {
+  collection: Lokijs.Collection<T & Record<string, unknown>>;
+  /**
+   * @param name table name
+   * @param uniqIndex primary key(s)
+   * @param db LokiJS database instance
+   */
+  constructor(name: string, uniqIndex: UniqueIndex, db: Lokijs);
+  count(...args: Parameters<Lokijs.Collection['count']>): number;
+  _insert(row: Record<string, unknown>): T & Record<string, unknown>;
+  _get(key: string | Record<string, unknown>): (T & Record<string, unknown>) | null;
+  _update(key: string | Record<string, unknown>, updates: Record<string, unknown>): T & Record<string, unknown>;
+  _reset(): void;
+}
+//#endregion
+export { MemoryIndex as default };