@ocap/indexdb 1.28.8 → 1.29.0

package/README.md

@@ -15,7 +15,7 @@ bun install @ocap/statedb-memory
 Then:
 
 ```javascript
-const MemoryIndexDB = require('@ocap/indexdb-memory');
+const MemoryIndexDB = require('@ocap/indexdb-memory').default;
 
 const indexdb = new MemoryIndexDB();
 

package/esm/db.d.mts

@@ -0,0 +1,40 @@
+import { Ready } from "@ocap/util/lib/ready";
+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";
+
+//#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 };

package/esm/db.mjs

@@ -0,0 +1,62 @@
+import { indexes } from "@ocap/state";
+import { Ready } from "@ocap/util/lib/ready";
+
+//#region src/db.ts
+var BaseIndexDB = class extends Ready {
+	constructor() {
+		super();
+		this.readyMarks = Object.fromEntries(indexes.map((x) => [x, false]));
+		this.readyListenersAttached = false;
+	}
+	attachReadyListeners() {
+		if (this.readyListenersAttached) return;
+		for (const index of 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
+export { db_default as default };

package/esm/index.d.mts

@@ -0,0 +1,58 @@
+import { Ready } from "@ocap/util/lib/ready";
+import { IIndexTable, IndexTableHookFn, Promisable } from "@ocap/types";
+
+//#region src/index.d.ts
+type UniqueIndex = string | string[];
+/**
+ * Base class for index tables
+ * Provides hook support (pre/post) and common operations
+ * Subclasses must implement _insert, _get, _update, _reset, count
+ */
+declare class BaseIndex<T = unknown> extends Ready implements IIndexTable<T> {
+  readonly name: string;
+  readonly primaryKey: string;
+  readonly uniqIndex: UniqueIndex;
+  ready: boolean;
+  readyCallbacks: Array<() => void>;
+  pre: (hookName: string, fn: IndexTableHookFn) => void;
+  post: (hookName: string, fn: IndexTableHookFn) => void;
+  insert: (doc: T | Record<string, unknown>) => Promise<T>;
+  get: (key: string | Record<string, unknown>) => Promise<T | null>;
+  update: (key: string | Record<string, unknown>, updates: Partial<T>) => Promise<T>;
+  reset: () => Promise<void>;
+  constructor(name?: string, uniqIndex?: UniqueIndex);
+  /**
+   * Count documents matching query
+   * Must be implemented by subclasses
+   */
+  count(_query?: unknown): Promisable<number>;
+  /**
+   * Internal insert implementation
+   * Called by the public `insert` method after pre-hooks
+   */
+  _insert(_doc: T | Record<string, unknown>): Promisable<T>;
+  /**
+   * Internal get implementation
+   * Called by the public `get` method after pre-hooks
+   */
+  _get(_key: string | Record<string, unknown>): Promisable<T | null>;
+  /**
+   * Internal update implementation
+   * Called by the public `update` method after pre-hooks
+   */
+  _update(_key: string | Record<string, unknown>, _updates: Partial<T>): Promisable<T>;
+  /**
+   * Internal reset implementation
+   * Called by the public `reset` method after pre-hooks
+   */
+  _reset(): Promisable<void>;
+  /**
+   * Generate primary key from document or key object
+   * For composite keys, generates MD5 hash of joined values
+   * @param doc - String key or document/key object
+   * @returns Primary key string
+   */
+  generatePrimaryKey(doc: string | Record<string, unknown>): string;
+}
+//#endregion
+export { BaseIndex as default };

package/esm/index.mjs

@@ -0,0 +1,91 @@
+import { Ready } from "@ocap/util/lib/ready";
+import crypto from "node:crypto";
+import Kareem from "kareem";
+import omit from "lodash/omit.js";
+
+//#region src/index.ts
+/**
+* Base class for index tables
+* Provides hook support (pre/post) and common operations
+* Subclasses must implement _insert, _get, _update, _reset, count
+*/
+var BaseIndex = class extends Ready {
+	constructor(name, uniqIndex) {
+		super();
+		this.name = name || "";
+		this.ready = false;
+		this.readyCallbacks = [];
+		this.uniqIndex = uniqIndex || "id";
+		this.primaryKey = typeof uniqIndex === "string" ? uniqIndex : "id";
+		const hooks = new Kareem();
+		Object.defineProperty(this, "pre", { value: (hookName, fn) => hooks.pre(hookName, fn) });
+		Object.defineProperty(this, "post", { value: (hookName, fn) => hooks.post(hookName, fn) });
+		[
+			"insert",
+			"get",
+			"update",
+			"reset"
+		].forEach((opName) => {
+			Object.defineProperty(this, opName, { value: async (...args) => {
+				hooks.execPreSync(opName, args);
+				const result = await this[`_${opName}`](...args);
+				hooks.execPostSync(opName, result);
+				if (["insert", "update"].includes(opName)) this.emit(opName, omit(result, "$loki"));
+				return result;
+			} });
+		});
+	}
+	/**
+	* Count documents matching query
+	* Must be implemented by subclasses
+	*/
+	count(_query) {
+		throw new Error("`count` must be implemented in sub indexdb");
+	}
+	/**
+	* Internal insert implementation
+	* Called by the public `insert` method after pre-hooks
+	*/
+	_insert(_doc) {
+		throw new Error("`_insert` must be implemented in sub indexdb");
+	}
+	/**
+	* Internal get implementation
+	* Called by the public `get` method after pre-hooks
+	*/
+	_get(_key) {
+		throw new Error("`_get` must be implemented in sub indexdb");
+	}
+	/**
+	* Internal update implementation
+	* Called by the public `update` method after pre-hooks
+	*/
+	_update(_key, _updates) {
+		throw new Error("`_update` must be implemented in sub indexdb");
+	}
+	/**
+	* Internal reset implementation
+	* Called by the public `reset` method after pre-hooks
+	*/
+	_reset() {
+		throw new Error("`_reset` must be implemented in sub indexdb");
+	}
+	/**
+	* Generate primary key from document or key object
+	* For composite keys, generates MD5 hash of joined values
+	* @param doc - String key or document/key object
+	* @returns Primary key string
+	*/
+	generatePrimaryKey(doc) {
+		if (typeof doc === "string") return doc;
+		if (Array.isArray(this.uniqIndex)) {
+			const key = this.uniqIndex.map((id) => doc[id]).map((item) => typeof item === "object" ? JSON.stringify(item) : item).join("-");
+			return crypto.createHash("md5").update(key).digest("hex");
+		}
+		return doc[this.uniqIndex];
+	}
+};
+var src_default = BaseIndex;
+
+//#endregion
+export { src_default as default };

package/esm/main.d.mts

@@ -0,0 +1,4 @@
+import BaseIndexDB from "./db.mjs";
+import BaseIndex from "./index.mjs";
+import { DelegationContext, FactoryContext, FormatPaginationParams, FormattedPagination, IndexDBForTx, PagingInput, RollupBlockContext, RollupContext, TokenFactoryContext, TokenStateInfo, TokenWithBalance, TxData, createIndexedAccount, createIndexedAsset, createIndexedDelegation, createIndexedFactory, createIndexedRollup, createIndexedRollupBlock, createIndexedStake, createIndexedToken, createIndexedTokenDistribution, createIndexedTokenFactory, createIndexedTransaction, formatDelegationAfterRead, formatNextPagination, formatPagination, formatTokenMeta, formatTxAfterRead, formatTxBeforeInsert, isDefaultTokenChanged, parseDateTime } from "./util.mjs";
+export { BaseIndex, BaseIndexDB, DelegationContext, FactoryContext, FormatPaginationParams, FormattedPagination, IndexDBForTx, PagingInput, RollupBlockContext, RollupContext, TokenFactoryContext, TokenStateInfo, TokenWithBalance, TxData, createIndexedAccount, createIndexedAsset, createIndexedDelegation, createIndexedFactory, createIndexedRollup, createIndexedRollupBlock, createIndexedStake, createIndexedToken, createIndexedTokenDistribution, createIndexedTokenFactory, createIndexedTransaction, formatDelegationAfterRead, formatNextPagination, formatPagination, formatTokenMeta, formatTxAfterRead, formatTxBeforeInsert, isDefaultTokenChanged, parseDateTime };

package/esm/main.mjs

@@ -0,0 +1,5 @@
+import db_default from "./db.mjs";
+import src_default from "./index.mjs";
+import { createIndexedAccount, createIndexedAsset, createIndexedDelegation, createIndexedFactory, createIndexedRollup, createIndexedRollupBlock, createIndexedStake, createIndexedToken, createIndexedTokenDistribution, createIndexedTokenFactory, createIndexedTransaction, formatDelegationAfterRead, formatNextPagination, formatPagination, formatTokenMeta, formatTxAfterRead, formatTxBeforeInsert, isDefaultTokenChanged, parseDateTime } from "./util.mjs";
+
+export { src_default as BaseIndex, db_default as BaseIndexDB, createIndexedAccount, createIndexedAsset, createIndexedDelegation, createIndexedFactory, createIndexedRollup, createIndexedRollupBlock, createIndexedStake, createIndexedToken, createIndexedTokenDistribution, createIndexedTokenFactory, createIndexedTransaction, formatDelegationAfterRead, formatNextPagination, formatPagination, formatTokenMeta, formatTxAfterRead, formatTxBeforeInsert, isDefaultTokenChanged, parseDateTime };

package/esm/util.d.mts

@@ -0,0 +1,374 @@
+import { FinalizedContext, IAccountState, IAssetFactoryState, IAssetState, IDelegateState, IIndexTable, IRollupBlock, IRollupState, IStakeState, ITokenFactoryState, ITokenState, TIndexedAccountState, TIndexedAssetState, TIndexedDelegationState, TIndexedTokenState, TPageInfo, TTokenDistribution, TTokenMeta } from "@ocap/types";
+
+//#region src/util.d.ts
+
+/**
+ * Token state with metadata for formatting
+ * Note: foreignToken type from ITokenState (IForeignToken) differs from TForeignToken,
+ * we use a flexible type here to accommodate both
+ */
+interface TokenStateInfo {
+  address: string;
+  decimal?: number;
+  unit?: string;
+  symbol?: string;
+  icon?: string;
+  /** Foreign token info - may be IForeignToken from state or TForeignToken when indexed */
+  foreignToken?: {
+    type?: string;
+    contractAddress?: string;
+    chainType?: string;
+    chainName?: string;
+    chainId?: number;
+  } | null;
+}
+/** Token with address and optional balance */
+interface TokenWithBalance {
+  address: string;
+  balance?: string;
+  value?: string;
+  [key: string]: unknown;
+}
+/** Minimal IndexDB interface for indexed transaction creation */
+interface IndexDBForTx {
+  delegation?: IIndexTable<{
+    to: string;
+    address: string;
+  }>;
+  token?: IIndexTable<TokenStateInfo>;
+}
+/** Inner transaction JSON structure */
+interface ItxJson {
+  type_url?: string;
+  value?: string | number;
+  to?: string;
+  token?: string;
+  assets?: string[];
+  tokens?: Array<{
+    address: string;
+    value?: string;
+  }>;
+  inputs?: Array<{
+    assets?: string[];
+    tokens?: Array<{
+      address: string;
+      value?: string;
+    }>;
+  }>;
+  outputs?: Array<{
+    assets?: string[];
+    tokens?: Array<{
+      address: string;
+      value?: string;
+    }>;
+  }>;
+  sender?: {
+    value?: string;
+    assets?: string[];
+    tokens?: Array<{
+      address: string;
+      value?: string;
+    }>;
+  };
+  receiver?: {
+    value?: string;
+    assets?: string[];
+    tokens?: Array<{
+      address: string;
+      value?: string;
+    }>;
+  };
+  address?: string;
+  factory?: string;
+  data?: {
+    type_url: string;
+    value: string;
+  };
+  [key: string]: unknown;
+}
+/** Decoded transaction structure */
+interface DecodedTx {
+  from: string;
+  itxJson: ItxJson;
+  [key: string]: unknown;
+}
+/** Transaction data for indexing */
+interface TxData {
+  hash?: string;
+  type?: string;
+  code?: string;
+  sender?: string;
+  receiver?: string;
+  time?: string;
+  valid?: boolean;
+  tx: DecodedTx;
+  receipts?: Array<{
+    changes: Array<{
+      target: string;
+      value: string;
+    }>;
+  }>;
+  accounts?: string[];
+  assets?: string[];
+  tokens?: string[];
+  factories?: string[];
+  stakes?: string[];
+  rollups?: string[];
+  delegations?: string[];
+  tokenFactories?: string[];
+  tokenSymbols?: Array<Partial<TTokenMeta>>;
+  [key: string]: unknown;
+}
+/** Context for creating indexed delegation */
+interface DelegationContext {
+  senderState?: IAccountState;
+  receiverState?: IAccountState;
+  tx?: {
+    from: string;
+  };
+  itx?: {
+    to: string;
+  };
+}
+/** Context for creating indexed factory */
+interface FactoryContext {
+  factoryTokens?: Array<{
+    address: string;
+    value: string;
+  }>;
+  tokenStates?: TokenStateInfo[];
+}
+/** Context for creating indexed token factory */
+interface TokenFactoryContext {
+  itx?: {
+    token?: TokenStateInfo;
+  };
+  config?: {
+    token?: TokenStateInfo;
+  };
+}
+/** Context for creating indexed rollup */
+interface RollupContext {
+  tokenStates?: TokenStateInfo[];
+}
+/** Context for creating indexed rollup block */
+interface RollupBlockContext {
+  rollupState?: {
+    tokenAddress: string;
+  };
+  tokenStates?: TokenStateInfo[];
+}
+/**
+ * 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
+ */
+declare const formatTokenMeta: (token: TokenWithBalance, tokenStates?: TokenStateInfo[] | null, ...rest: unknown[]) => TokenWithBalance;
+/**
+ * Create indexed account from account state
+ */
+declare const createIndexedAccount: (x: IAccountState & {
+  balance?: string;
+  migratedTo?: string[];
+  migratedFrom?: string[];
+  numAssets?: number;
+  numTxs?: number;
+}, getTokenFn: (address: string) => Promise<TokenStateInfo | null>) => Promise<Omit<TIndexedAccountState, "balance" | "totalReceivedStakes" | "totalStakes" | "totalUnstakes" | "nonce" | "numAssets" | "numTxs"> & {
+  balance: string;
+  nonce: number | string;
+  numAssets: number | string;
+  numTxs: number | string;
+}>;
+/**
+ * Create indexed asset from asset state
+ * Note: display/endpoint/data types from IAssetState may differ from TIndexedAssetState,
+ * they are passed through without transformation
+ */
+declare const createIndexedAsset: (x: IAssetState) => Omit<TIndexedAssetState, "display" | "endpoint" | "data"> & {
+  data?: IAssetState["data"];
+  display?: IAssetState["display"];
+  endpoint?: IAssetState["endpoint"];
+};
+/**
+ * Create indexed delegation from delegation state
+ */
+declare const createIndexedDelegation: (x: IDelegateState, ctx: DelegationContext) => Partial<TIndexedDelegationState> & {
+  ops: unknown[];
+};
+/**
+ * Create indexed token from token state
+ * Note: foreignToken/metadata/data types from ITokenState may differ from TIndexedTokenState,
+ * they are passed through without transformation
+ */
+declare const createIndexedToken: (x: ITokenState) => Omit<TIndexedTokenState, "foreignToken" | "metadata" | "data"> & {
+  foreignToken?: ITokenState["foreignToken"];
+  metadata?: ITokenState["metadata"];
+  data?: ITokenState["data"];
+};
+/**
+ * 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
+ */
+declare const createIndexedTokenFactory: (tokenFactory: ITokenFactoryState & {
+  tokenAddress: string;
+  reserveAddress: string;
+}, context: TokenFactoryContext) => Record<string, unknown> & {
+  token: TokenWithBalance;
+  reserveToken: TokenWithBalance;
+};
+/**
+ * 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
+ */
+declare const createIndexedFactory: (factory: IAssetFactoryState & {
+  input?: {
+    tokens?: TokenWithBalance[];
+  };
+}, context: FactoryContext) => Record<string, unknown> & {
+  tokens: TokenWithBalance[];
+};
+/**
+ * Create indexed transaction from transaction context
+ * These fields are used internally to filter transactions by some entity
+ */
+declare const createIndexedTransaction: (tx: TxData, ctx: FinalizedContext, indexdb: IndexDBForTx) => Promise<TxData>;
+/**
+ * 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
+ */
+declare const createIndexedStake: (x: IStakeState, ctx: {
+  tokenStates?: TokenStateInfo[];
+}, indexdb: {
+  token?: IIndexTable<TokenStateInfo>;
+}) => Promise<Record<string, unknown> & {
+  tokens: TokenWithBalance[];
+  revokedTokens: TokenWithBalance[];
+}>;
+/**
+ * Create indexed rollup from rollup state
+ * Note: foreignToken from TokenStateInfo is passed through without transformation
+ */
+declare const createIndexedRollup: (x: IRollupState & {
+  tokenAddress: string;
+}, ctx: RollupContext) => Record<string, unknown> & {
+  tokenInfo?: TokenWithBalance;
+  foreignToken?: TokenStateInfo["foreignToken"];
+};
+/**
+ * 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
+ */
+declare const createIndexedRollupBlock: (x: IRollupBlock & {
+  signaturesList?: Array<{
+    signer: string;
+  }>;
+}, ctx: RollupBlockContext) => Record<string, unknown> & {
+  tokenInfo?: TokenWithBalance;
+  validators: string[];
+};
+/**
+ * Create indexed token distribution
+ */
+declare const createIndexedTokenDistribution: (x: {
+  tokenAddress: string;
+  txTime: string;
+  account: {
+    toString: () => string;
+  };
+  gas: {
+    toString: () => string;
+  };
+  fee: {
+    toString: () => string;
+  };
+  slashedVault: {
+    toString: () => string;
+  };
+  stake: {
+    toString: () => string;
+  };
+  revokedStake: {
+    toString: () => string;
+  };
+  gasStake: {
+    toString: () => string;
+  };
+}) => Partial<TTokenDistribution>;
+/**
+ * Format transaction before inserting to index
+ */
+declare const formatTxBeforeInsert: (row: TxData) => TxData;
+/**
+ * Format transaction after reading from index (remove internal indexing fields)
+ */
+declare const formatTxAfterRead: (tx: TxData) => TxData;
+/**
+ * Format delegation after reading from index
+ */
+declare const formatDelegationAfterRead: (delegation: {
+  ops: unknown[] | Record<string, unknown>;
+}) => {
+  ops: Array<{
+    key: string;
+    value: unknown;
+  }>;
+};
+/**
+ * Parse date time string to ISO format
+ */
+declare const parseDateTime: (str: unknown) => string;
+/** Paging input parameters */
+interface PagingInput {
+  size?: number | null;
+  cursor?: string | number;
+  order?: {
+    field?: string;
+    type?: string;
+  } | Array<{
+    field?: string;
+    type?: string;
+  }>;
+}
+/** Parameters for formatPagination */
+interface FormatPaginationParams {
+  paging?: PagingInput | null;
+  defaultSortField: string;
+  supportedSortFields?: string[];
+}
+/** Formatted pagination result */
+interface FormattedPagination {
+  size: number;
+  cursor: number;
+  order: {
+    field: string;
+    type: string;
+  };
+}
+/**
+ * Format pagination parameters with defaults
+ */
+declare const formatPagination: ({
+  paging,
+  defaultSortField,
+  supportedSortFields
+}: FormatPaginationParams) => FormattedPagination;
+/**
+ * Format next pagination info for response
+ */
+declare const formatNextPagination: (total: number, pagination: {
+  cursor: number;
+  size: number;
+}) => TPageInfo;
+/**
+ * Check if a transaction changes the default token balance
+ */
+declare const isDefaultTokenChanged: (tx: TxData, token: {
+  address: string;
+}) => boolean;
+//#endregion
+export { DelegationContext, FactoryContext, FormatPaginationParams, FormattedPagination, IndexDBForTx, PagingInput, RollupBlockContext, RollupContext, TokenFactoryContext, TokenStateInfo, TokenWithBalance, TxData, createIndexedAccount, createIndexedAsset, createIndexedDelegation, createIndexedFactory, createIndexedRollup, createIndexedRollupBlock, createIndexedStake, createIndexedToken, createIndexedTokenDistribution, createIndexedTokenFactory, createIndexedTransaction, formatDelegationAfterRead, formatNextPagination, formatPagination, formatTokenMeta, formatTxAfterRead, formatTxBeforeInsert, isDefaultTokenChanged, parseDateTime };