@ocap/indexdb 1.28.8 → 1.29.0

package/esm/util.mjs

@@ -0,0 +1,556 @@
+import { BN } from "@ocap/util";
+import { createSortedList } from "@ocap/util/lib/create-sorted-list";
+import get from "lodash/get.js";
+import pick from "lodash/pick.js";
+import uniq from "lodash/uniq.js";
+import uniqBy from "lodash/uniqBy.js";
+
+//#region src/util.ts
+/**
+* Format token with metadata from token states
+* @param token - Token with address
+* @param tokenStates - Array of token states for metadata lookup
+* @param rest - Additional args for debug logging
+*/
+const formatTokenMeta = (token, tokenStates, ...rest) => {
+	if (!tokenStates) return token;
+	const tokenState = tokenStates.filter(Boolean).find((x) => x.address === token.address);
+	if (tokenState) {
+		token.decimal = tokenState.decimal;
+		token.unit = tokenState.unit;
+		token.symbol = tokenState.symbol;
+		token.icon = tokenState.icon;
+	} else console.warn("Invalid token state on formatting", token, tokenStates, ...rest);
+	return token;
+};
+/**
+* Create indexed account from account state
+*/
+const createIndexedAccount = async (x, getTokenFn) => {
+	const tasks = Object.keys(x.tokens || {}).map((address) => getTokenFn(address));
+	const tokenStates = await Promise.all(tasks);
+	return {
+		address: x.address,
+		balance: x.balance || "0",
+		moniker: x.moniker || "",
+		nonce: x.nonce ?? 0,
+		numAssets: x.numAssets ?? 0,
+		numTxs: x.numTxs ?? 0,
+		recentNumTxs: [],
+		renaissanceTime: x.context.renaissanceTime,
+		tokens: Object.keys(x.tokens || {}).map((address) => formatTokenMeta({
+			address,
+			balance: x.tokens[address]
+		}, tokenStates)),
+		genesisTime: x.context.genesisTime,
+		migratedTo: x.migratedTo?.[0] || "",
+		migratedFrom: x.migratedFrom?.[0] || ""
+	};
+};
+/**
+* Create indexed asset from asset state
+* Note: display/endpoint/data types from IAssetState may differ from TIndexedAssetState,
+* they are passed through without transformation
+*/
+const createIndexedAsset = (x) => ({
+	address: x.address,
+	issuer: x.issuer,
+	moniker: x.moniker,
+	owner: x.owner,
+	parent: x.parent,
+	readonly: x.readonly,
+	transferrable: x.transferrable,
+	ttl: String(x.ttl || 0),
+	consumedTime: x.consumedTime || "",
+	genesisTime: x.context.genesisTime,
+	renaissanceTime: x.context.renaissanceTime,
+	data: x.data,
+	display: x.display,
+	endpoint: x.endpoint,
+	tags: x.tags || []
+});
+/**
+* Create indexed delegation from delegation state
+*/
+const createIndexedDelegation = (x, ctx) => {
+	const result = {
+		address: x.address,
+		data: x.data,
+		genesisTime: x.context.genesisTime,
+		renaissanceTime: x.context.renaissanceTime,
+		ops: [x.ops]
+	};
+	if (x.from) result.from = x.from;
+	else if (ctx.senderState) result.from = get(ctx, "senderState.address", "");
+	else result.from = get(ctx, "tx.from", "");
+	if (x.to) result.to = x.to;
+	else if (ctx.receiverState) result.to = get(ctx, "receiverState.address", "");
+	else result.to = get(ctx, "itx.to", "");
+	return result;
+};
+/**
+* Create indexed token from token state
+* Note: foreignToken/metadata/data types from ITokenState may differ from TIndexedTokenState,
+* they are passed through without transformation
+*/
+const createIndexedToken = (x) => ({
+	address: x.address,
+	issuer: x.issuer || "",
+	name: x.name,
+	description: x.description,
+	symbol: x.symbol,
+	unit: x.unit,
+	decimal: x.decimal,
+	icon: x.icon || "",
+	website: x.website || "",
+	totalSupply: x.totalSupply,
+	initialSupply: x.initialSupply,
+	maxTotalSupply: x.maxTotalSupply || "",
+	foreignToken: x.foreignToken,
+	tokenFactoryAddress: x.tokenFactoryAddress || "",
+	metadata: x.metadata,
+	spenders: x.spenders || [],
+	minters: x.minters || [],
+	type: x.type || "",
+	data: x.data,
+	genesisTime: x.context.genesisTime,
+	renaissanceTime: x.context.renaissanceTime
+});
+/**
+* Create indexed token factory from token factory state
+* Note: token/reserveToken may not have all TIndexedTokenInput fields filled,
+* they are populated with available metadata from context
+*/
+const createIndexedTokenFactory = (tokenFactory, context) => {
+	return {
+		...pick(tokenFactory, [
+			"address",
+			"owner",
+			"tokenAddress",
+			"reserveAddress",
+			"curve",
+			"feeRate",
+			"currentSupply",
+			"reserveBalance",
+			"status",
+			"data"
+		]),
+		token: formatTokenMeta({ address: tokenFactory.tokenAddress }, context.itx?.token ? [context.itx.token] : []),
+		reserveToken: formatTokenMeta({ address: tokenFactory.reserveAddress }, context.config?.token ? [context.config.token] : []),
+		genesisTime: tokenFactory.context.genesisTime,
+		renaissanceTime: tokenFactory.context.renaissanceTime
+	};
+};
+/**
+* Create indexed factory from asset factory state
+* Note: tokens array may not have all TTokenMeta fields filled,
+* they are populated with available metadata from context
+*/
+const createIndexedFactory = (factory, context) => {
+	if (context.factoryTokens && context.factoryTokens.length > 0 && factory.input?.tokens) factory.input.tokens = factory.input.tokens.map((token) => formatTokenMeta(token, context.tokenStates));
+	return {
+		...pick(factory, [
+			"address",
+			"owner",
+			"name",
+			"description",
+			"settlement",
+			"limit",
+			"trustedIssuers",
+			"input",
+			"output",
+			"hooks",
+			"data",
+			"numMinted",
+			"lastSettlement",
+			"balance",
+			"display"
+		]),
+		tokens: Object.keys(factory.tokens || {}).map((address) => formatTokenMeta({
+			address,
+			balance: factory.tokens[address]
+		}, context.tokenStates)),
+		genesisTime: factory.context.genesisTime,
+		renaissanceTime: factory.context.renaissanceTime
+	};
+};
+/**
+* Create indexed transaction from transaction context
+* These fields are used internally to filter transactions by some entity
+*/
+const createIndexedTransaction = async (tx, ctx, indexdb) => {
+	tx.accounts = [
+		tx.tx.from,
+		tx.sender,
+		tx.receiver
+	].filter(Boolean);
+	tx.assets = [];
+	tx.tokens = [];
+	tx.factories = [];
+	tx.stakes = [];
+	tx.rollups = [];
+	tx.delegations = [];
+	tx.tokenFactories = [];
+	tx.valid = tx.code === "OK";
+	if (ctx.senderState) tx.accounts.push(ctx.senderState.address);
+	if (ctx.receiverState) tx.accounts.push(ctx.receiverState.address);
+	if (ctx.feeVaultState && ctx.feeVaultChange) tx.accounts.push(ctx.feeVaultState.address);
+	if (ctx.gasVaultState && ctx.gasVaultChange) tx.accounts.push(ctx.gasVaultState.address);
+	if (ctx.updatedAccounts && Array.isArray(ctx.updatedAccounts)) tx.accounts.push(...ctx.updatedAccounts.map((x) => x.address));
+	if (ctx.delegatorState) tx.accounts.push(ctx.delegatorState.address);
+	if (ctx.delegationState) tx.delegations.push(ctx.delegationState.address);
+	if (ctx.delegationState && ctx.txType === "fg:t:revoke_delegate") {
+		const indexed = await indexdb.delegation?.get(ctx.delegationState.address);
+		if (indexed) tx.accounts.push(indexed.to);
+	}
+	if (Array.isArray(ctx.delegatorStates)) tx.accounts.push(...ctx.delegatorStates.map((x) => x.address));
+	if (Array.isArray(ctx.signerStates)) tx.accounts.push(...ctx.signerStates.map((x) => x.address));
+	if (Array.isArray(ctx.receiverStates)) tx.accounts.push(...ctx.receiverStates.map((x) => x.address));
+	if (ctx.assetState) {
+		tx.assets.push(ctx.assetState.address);
+		if (ctx.txType === "fg:t:update_asset") tx.accounts.push(ctx.assetState.owner);
+		if (ctx.txType === "fg:t:mint_asset") tx.accounts.push(ctx.ownerAddress);
+	}
+	if (ctx.assetStates && Array.isArray(ctx.assetStates)) tx.assets.push(...ctx.assetStates.map((x) => x.address));
+	if (ctx.tokenState) tx.tokens.push(ctx.tokenState.address);
+	if (ctx.tokenStates && Array.isArray(ctx.tokenStates)) tx.tokens.push(...ctx.tokenStates.map((x) => x.address));
+	if (ctx.factoryState) tx.factories.push(ctx.factoryState.address);
+	if (ctx.stakeState) {
+		tx.stakes.push(ctx.stakeState.address);
+		if (ctx.txType === "fg:t:slash_stake") tx.accounts.push(ctx.stakeState.sender);
+		if (ctx.txType === "fg:t:return_stake") tx.accounts.push(ctx.stakeState.sender);
+	}
+	if (Array.isArray(ctx.stakeStates)) tx.stakes.push(...ctx.stakeStates.map((x) => x.address));
+	if (ctx.rollupState) tx.rollups.push(ctx.rollupState.address);
+	if (ctx.tokenFactoryState) tx.tokenFactories.push(ctx.tokenFactoryState.address);
+	const pickedFields = [
+		"address",
+		"symbol",
+		"decimal",
+		"unit"
+	];
+	if (Array.isArray(ctx.tokenStates)) tx.tokenSymbols = ctx.tokenStates.map((t) => pick(t, pickedFields));
+	else if (ctx.tokenState) tx.tokenSymbols = [pick(ctx.tokenState, pickedFields)];
+	else tx.tokenSymbols = [];
+	tx.accounts = [...tx.accounts, ...tx.stakes];
+	return tx;
+};
+/**
+* Create indexed stake from stake state
+* Note: tokens/revokedTokens arrays may not have all TTokenMeta fields filled,
+* they are populated with available metadata from context
+*/
+const createIndexedStake = async (x, ctx, indexdb) => {
+	const tokens = uniq(Object.keys(x.tokens || {}).concat(Object.keys(x.revokedTokens || {})));
+	const existTokenStates = ctx.tokenStates || [];
+	const missingTokenStates = await Promise.all(tokens.filter((a) => !existTokenStates.find((t) => t.address === a)).map((t) => indexdb.token?.get(t)));
+	const tokenStates = [...existTokenStates, ...missingTokenStates.filter(Boolean)];
+	return {
+		...pick(x, [
+			"address",
+			"sender",
+			"receiver",
+			"assets",
+			"slashers",
+			"revocable",
+			"data",
+			"nonce",
+			"message",
+			"revokeWaitingPeriod",
+			"revokedAssets"
+		]),
+		tokens: Object.keys(x.tokens || {}).map((address) => formatTokenMeta({
+			address,
+			balance: x.tokens[address]
+		}, tokenStates, x)),
+		revokedTokens: Object.keys(x.revokedTokens || {}).map((address) => formatTokenMeta({
+			address,
+			balance: x.revokedTokens[address]
+		}, tokenStates)),
+		genesisTime: x.context.genesisTime,
+		renaissanceTime: x.context.renaissanceTime
+	};
+};
+/**
+* Create indexed rollup from rollup state
+* Note: foreignToken from TokenStateInfo is passed through without transformation
+*/
+const createIndexedRollup = (x, ctx) => {
+	const rollup = {
+		...pick(x, [
+			"address",
+			"paused",
+			"closed",
+			"tokenAddress",
+			"vaultAddress",
+			"contractAddress",
+			"seedValidators",
+			"validators",
+			"minStakeAmount",
+			"maxStakeAmount",
+			"minSignerCount",
+			"maxSignerCount",
+			"minBlockSize",
+			"maxBlockSize",
+			"minBlockInterval",
+			"minBlockConfirmation",
+			"minDepositAmount",
+			"maxDepositAmount",
+			"minWithdrawAmount",
+			"maxWithdrawAmount",
+			"depositFeeRate",
+			"withdrawFeeRate",
+			"proposerFeeShare",
+			"publisherFeeShare",
+			"minDepositFee",
+			"maxDepositFee",
+			"minWithdrawFee",
+			"maxWithdrawFee",
+			"issuer",
+			"blockHeight",
+			"blockHash",
+			"leaveWaitingPeriod",
+			"publishWaitingPeriod",
+			"publishSlashRate",
+			"migrateHistory",
+			"vaultHistory",
+			"data"
+		]),
+		genesisTime: x.context.genesisTime,
+		renaissanceTime: x.context.renaissanceTime
+	};
+	if (ctx.tokenStates) {
+		const tokenState = ctx.tokenStates.find((t) => t.address === x.tokenAddress);
+		rollup.tokenInfo = formatTokenMeta({
+			address: x.tokenAddress,
+			value: "0"
+		}, ctx.tokenStates);
+		if (tokenState) rollup.foreignToken = tokenState.foreignToken;
+	}
+	return rollup;
+};
+/**
+* Create indexed rollup block from rollup block state
+* Note: tokenInfo may not have all TIndexedTokenInput fields filled,
+* they are populated with available metadata from context
+*/
+const createIndexedRollupBlock = (x, ctx) => {
+	const signatures = x.signaturesList || x.signatures || [];
+	return {
+		...pick(x, [
+			"hash",
+			"height",
+			"merkleRoot",
+			"previousHash",
+			"txsHash",
+			"txs",
+			"proposer",
+			"signatures",
+			"rollup",
+			"mintedAmount",
+			"burnedAmount",
+			"rewardAmount",
+			"minReward",
+			"governance",
+			"data"
+		]),
+		genesisTime: x.context.genesisTime,
+		renaissanceTime: x.context.renaissanceTime,
+		tokenInfo: ctx.rollupState ? formatTokenMeta({
+			address: ctx.rollupState.tokenAddress,
+			value: "0"
+		}, ctx.tokenStates) : void 0,
+		validators: signatures.map((v) => v.signer)
+	};
+};
+/**
+* Create indexed token distribution
+*/
+const createIndexedTokenDistribution = (x) => {
+	return {
+		tokenAddress: x.tokenAddress,
+		txTime: x.txTime,
+		account: x.account.toString(),
+		gas: x.gas.toString(),
+		fee: x.fee.toString(),
+		slashedVault: x.slashedVault.toString(),
+		stake: x.stake.toString(),
+		revokedStake: x.revokedStake.toString(),
+		gasStake: x.gasStake.toString()
+	};
+};
+/**
+* Format transaction before inserting to index
+*/
+const formatTxBeforeInsert = (row) => {
+	const tx = { ...row };
+	tx.sender = tx.sender || "";
+	tx.receiver = tx.receiver || "";
+	if (!tx.tx || !tx.tx.itxJson) return tx;
+	const itx = tx.tx.itxJson;
+	tx.assets = tx.assets || [];
+	if (["transfer", "transfer_v2"].includes(tx.type || "") && itx.assets) tx.assets.push(...itx.assets);
+	else if (["transfer_v3", "stake"].includes(tx.type || "") && itx.inputs) tx.assets.push(...createSortedList(itx.inputs.map((x) => x.assets || [])));
+	else if ([
+		"revoke_stake",
+		"slash_stake",
+		"return_stake"
+	].includes(tx.type || "") && itx.outputs) tx.assets.push(...createSortedList(itx.outputs.map((x) => x.assets || [])));
+	else if (["exchange", "exchange_v2"].includes(tx.type || "")) tx.assets.push(...itx.sender?.assets || [], ...itx.receiver?.assets || []);
+	else if ([
+		"create_asset",
+		"update_asset",
+		"acquire_asset_v2",
+		"mint_asset"
+	].includes(tx.type || "") && itx.address) tx.assets.push(itx.address);
+	tx.factories = tx.factories || [];
+	if ([
+		"acquire_asset_v2",
+		"acquire_asset_v3",
+		"mint_asset",
+		"create_factory"
+	].includes(tx.type || "") && itx.factory) tx.factories.push(itx.factory);
+	tx.tokens = tx.tokens || [];
+	if (tx.type === "transfer_v2" && itx.tokens) tx.tokens.push(...itx.tokens.map((x) => x.address));
+	else if (["transfer_v3", "stake"].includes(tx.type || "") && itx.inputs) tx.tokens.push(...createSortedList(itx.inputs.map((x) => (x.tokens || []).map((t) => t.address))));
+	else if ([
+		"revoke_stake",
+		"slash_stake",
+		"return_stake"
+	].includes(tx.type || "") && itx.outputs) tx.tokens.push(...createSortedList(itx.outputs.map((x) => (x.tokens || []).map((t) => t.address))));
+	else if (tx.type === "exchange_v2") tx.tokens.push(...(itx.sender?.tokens || []).map((x) => x.address), ...(itx.receiver?.tokens || []).map((x) => x.address));
+	tx.accounts = tx.accounts || [];
+	tx.stakes = tx.stakes || [];
+	tx.assets = uniq(tx.assets).filter(Boolean);
+	tx.factories = uniq(tx.factories).filter(Boolean);
+	tx.tokens = uniq(tx.tokens).filter(Boolean);
+	tx.accounts = uniq(tx.accounts).filter(Boolean);
+	tx.stakes = uniq(tx.stakes).filter(Boolean);
+	tx.rollups = uniq(tx.rollups || []).filter(Boolean);
+	tx.tokenSymbols = uniqBy(tx.tokenSymbols || [], "address");
+	return tx;
+};
+/**
+* Format transaction after reading from index (remove internal indexing fields)
+*/
+const formatTxAfterRead = (tx) => {
+	delete tx.assets;
+	delete tx.factories;
+	delete tx.tokens;
+	delete tx.accounts;
+	delete tx.stakes;
+	delete tx.rollups;
+	delete tx.delegations;
+	return tx;
+};
+/**
+* Format delegation after reading from index
+*/
+const formatDelegationAfterRead = (delegation) => {
+	const opsRecord = Array.isArray(delegation.ops) ? delegation.ops[0] : delegation.ops;
+	return {
+		...delegation,
+		ops: Object.keys(opsRecord).map((x) => ({
+			key: x,
+			value: opsRecord[x]
+		}))
+	};
+};
+/**
+* Parse date time string to ISO format
+*/
+const parseDateTime = (str) => {
+	if (!str) return "";
+	const parsed = Date.parse(str);
+	if (Number.isNaN(parsed)) return "";
+	return new Date(parsed).toISOString();
+};
+const PAGE_SIZE_DEFAULT = 20;
+const PAGE_SIZE_MAX = 100;
+/**
+* Format pagination parameters with defaults
+*/
+const formatPagination = ({ paging, defaultSortField, supportedSortFields = [] }) => {
+	if (!defaultSortField) throw new Error("argument defaultSortField is required");
+	const pagination = {
+		size: paging?.size ?? PAGE_SIZE_DEFAULT,
+		cursor: typeof paging?.cursor === "number" ? paging.cursor : Number(paging?.cursor) || 0,
+		order: {
+			field: defaultSortField,
+			type: "desc"
+		}
+	};
+	let inputOrder = paging?.order;
+	if (Array.isArray(inputOrder)) inputOrder = inputOrder[0];
+	if (inputOrder?.field) pagination.order.field = inputOrder.field;
+	if (supportedSortFields.length > 0 && !supportedSortFields.includes(pagination.order.field)) pagination.order.field = defaultSortField;
+	if (inputOrder?.type) pagination.order.type = inputOrder.type;
+	pagination.size = Math.min(pagination.size, PAGE_SIZE_MAX);
+	return pagination;
+};
+/**
+* Format next pagination info for response
+*/
+const formatNextPagination = (total, pagination) => {
+	const nextCursor = pagination.cursor + pagination.size;
+	if (total > nextCursor) return {
+		cursor: String(nextCursor),
+		next: true,
+		total
+	};
+	return {
+		cursor: "0",
+		next: false,
+		total
+	};
+};
+/**
+* Check if a transaction changes the default token balance
+*/
+const isDefaultTokenChanged = (tx, token) => {
+	const itx = tx.tx.itxJson;
+	if ([
+		"fg:t:transfer",
+		"fg:t:transfer_v2",
+		"fg:t:transfer_v3",
+		"fg:t:acquire_asset_v2",
+		"fg:t:acquire_asset_v3",
+		"fg:t:exchange",
+		"fg:t:exchange_v2",
+		"fg:t:deposit_token",
+		"fg:t:withdraw_token",
+		"fg:t:faucet",
+		"fg:t:poke",
+		"fg:t:setup_swap",
+		"fg:t:retrieve_swap",
+		"fg:t:stake",
+		"fg:t:revoke_stake"
+	].includes(itx.type_url || "") === false) return false;
+	const ZERO = new BN(0);
+	const isDefaultToken = (id) => [token.address, ""].includes(id);
+	const isPositive = (v) => new BN(v || 0).gt(ZERO);
+	const isChangedByInput = (input) => isPositive(input.value) || (input.tokens?.some((x) => isDefaultToken(x.address) && isPositive(x.value)) ?? false);
+	switch (itx.type_url) {
+		case "fg:t:transfer": return isPositive(itx.value);
+		case "fg:t:transfer_v2": return isChangedByInput(itx);
+		case "fg:t:transfer_v3":
+		case "fg:t:acquire_asset_v3": return (itx.inputs || []).some((input) => isChangedByInput(input));
+		case "fg:t:acquire_asset_v2": return (tx.receipts || []).some((r) => r.changes.some((c) => isDefaultToken(c.target) && isPositive(c.value)));
+		case "fg:t:exchange": return isPositive(itx.sender?.value) || isPositive(itx.receiver?.value);
+		case "fg:t:exchange_v2": return isChangedByInput(itx.sender || {}) || isChangedByInput(itx.receiver || {});
+		case "fg:t:deposit_token":
+		case "fg:t:withdraw_token": return isPositive(itx.value);
+		case "fg:t:setup_swap":
+		case "fg:t:retrieve_swap": return isPositive(itx.value);
+		case "fg:t:poke": return true;
+		case "fg:t:faucet": return !itx.token;
+		case "fg:t:stake": return (itx.inputs || []).some((input) => isChangedByInput(input));
+		case "fg:t:revoke_stake":
+		case "fg:t:slash_stake":
+		case "fg:t:return_stake": return (itx.outputs || []).some((output) => isChangedByInput(output));
+		default: return false;
+	}
+};
+
+//#endregion
+export { createIndexedAccount, createIndexedAsset, createIndexedDelegation, createIndexedFactory, createIndexedRollup, createIndexedRollupBlock, createIndexedStake, createIndexedToken, createIndexedTokenDistribution, createIndexedTokenFactory, createIndexedTransaction, formatDelegationAfterRead, formatNextPagination, formatPagination, formatTokenMeta, formatTxAfterRead, formatTxBeforeInsert, isDefaultTokenChanged, parseDateTime };

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.cjs

@@ -0,0 +1,64 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let _ocap_state = require("@ocap/state");
+let _ocap_util_lib_ready = require("@ocap/util/lib/ready");
+
+//#region src/db.ts
+var BaseIndexDB = class extends _ocap_util_lib_ready.Ready {
+	constructor() {
+		super();
+		this.readyMarks = Object.fromEntries(_ocap_state.indexes.map((x) => [x, false]));
+		this.readyListenersAttached = false;
+	}
+	attachReadyListeners() {
+		if (this.readyListenersAttached) return;
+		for (const index of _ocap_state.indexes) {
+			if (typeof this[index] === "undefined") throw new Error(`Missing index ${index} in indexdb adapter: ${this.name}`);
+			this[index].onReady(() => this.markReady(index));
+		}
+		this.readyListenersAttached = true;
+	}
+	listTransactions(_params) {
+		throw new Error("listTransactions should be implemented in adapter");
+	}
+	listAssets(_params) {
+		throw new Error("listAssets should be implemented in adapter");
+	}
+	listTopAccounts(_params) {
+		throw new Error("listTopAccounts should be implemented in adapter");
+	}
+	listTokens(_params) {
+		throw new Error("listTokens should be implemented in adapter");
+	}
+	listFactories(_params) {
+		throw new Error("listFactories should be implemented in adapter");
+	}
+	listStakes(_params) {
+		throw new Error("listStakes should be implemented in adapter");
+	}
+	listDelegations(_params) {
+		throw new Error("listDelegations should be implemented in adapter");
+	}
+	listRollups(_params) {
+		throw new Error("listRollups should be implemented in adapter");
+	}
+	listRollupBlocks(_params) {
+		throw new Error("listRollupBlocks should be implemented in adapter");
+	}
+	listRollupValidators(_params) {
+		throw new Error("listRollupValidators should be implemented in adapter");
+	}
+	listTokenFactories(_params) {
+		throw new Error("listTokenFactories should be implemented in adapter");
+	}
+	getRelatedAddresses(_address) {
+		return [];
+	}
+	listBlocks() {
+		return [];
+	}
+};
+var db_default = BaseIndexDB;
+
+//#endregion
+exports.default = db_default;

package/lib/db.d.cts

@@ -0,0 +1,40 @@
+import { IIndexDB, IIndexTable, IListAccountsResult, IListAssetsResult, IListDelegationsResult, IListFactoriesResult, IListRollupBlocksResult, IListRollupValidatorsResult, IListRollupsResult, IListStakesResult, IListTokenFactoriesResult, IListTokensResult, IListTransactionsResult, IndexTableTypeMap, Promisable, TRequestListAssets, TRequestListDelegations, TRequestListFactories, TRequestListRollupBlocks, TRequestListRollupValidators, TRequestListRollups, TRequestListStakes, TRequestListTokenFactories, TRequestListTokens, TRequestListTopAccounts, TRequestListTransactions } from "@ocap/types";
+import { Ready } from "@ocap/util/lib/ready";
+
+//#region src/db.d.ts
+declare class BaseIndexDB extends Ready implements IIndexDB {
+  readyMarks: Record<string, boolean>;
+  readyListenersAttached: boolean;
+  name: string;
+  version: string;
+  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']>;
+  [key: string]: unknown;
+  constructor();
+  attachReadyListeners(): void;
+  listTransactions(_params?: Partial<TRequestListTransactions>): Promisable<IListTransactionsResult>;
+  listAssets(_params?: Partial<TRequestListAssets>): Promisable<IListAssetsResult>;
+  listTopAccounts(_params?: Partial<TRequestListTopAccounts>): Promisable<IListAccountsResult>;
+  listTokens(_params?: Partial<TRequestListTokens>): Promisable<IListTokensResult>;
+  listFactories(_params?: Partial<TRequestListFactories>): Promisable<IListFactoriesResult>;
+  listStakes(_params?: Partial<TRequestListStakes>): Promisable<IListStakesResult>;
+  listDelegations(_params?: Partial<TRequestListDelegations>): Promisable<IListDelegationsResult>;
+  listRollups(_params?: Partial<TRequestListRollups>): Promisable<IListRollupsResult>;
+  listRollupBlocks(_params?: Partial<TRequestListRollupBlocks>): Promisable<IListRollupBlocksResult>;
+  listRollupValidators(_params?: Partial<TRequestListRollupValidators>): Promisable<IListRollupValidatorsResult>;
+  listTokenFactories(_params?: Partial<TRequestListTokenFactories>): Promisable<IListTokenFactoriesResult>;
+  getRelatedAddresses(_address: string): Promisable<string[]>;
+  listBlocks(): unknown[];
+}
+//#endregion
+export { BaseIndexDB as default };