@ocap/indexdb 1.28.9 → 1.29.1

package/lib/util.d.cts

@@ -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 };

package/package.json

@@ -3,17 +3,41 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.28.9",
+  "version": "1.29.1",
+  "type": "module",
   "description": "Defines the basic interface for OCAP IndexDB",
-  "main": "lib/main.js",
+  "main": "./lib/main.cjs",
+  "module": "./esm/main.mjs",
+  "types": "./esm/main.d.mts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./esm/main.d.mts",
+      "import": "./esm/main.mjs",
+      "default": "./lib/main.cjs"
+    },
+    "./lib/*.js": {
+      "types": "./esm/*.d.mts",
+      "import": "./esm/*.mjs",
+      "default": "./lib/*.cjs"
+    },
+    "./lib/*": {
+      "types": "./esm/*.d.mts",
+      "import": "./esm/*.mjs",
+      "default": "./lib/*.cjs"
+    }
+  },
   "files": [
-    "lib"
+    "lib",
+    "esm"
   ],
   "scripts": {
     "lint": "biome check",
     "lint:fix": "biome check --write",
     "test": "bun test",
-    "coverage": "npm run test -- --coverage"
+    "coverage": "npm run test -- --coverage",
+    "build": "tsdown",
+    "build:watch": "tsdown -w"
   },
   "keywords": [],
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
@@ -21,11 +45,16 @@
     "wangshijun <shijun@arcblock.io> (https://github.com/wangshijun)"
   ],
   "license": "MIT",
-  "devDependencies": {},
+  "devDependencies": {
+    "@types/lodash": "^4.17.10",
+    "@types/node": "^22.7.5",
+    "tsdown": "^0.18.4"
+  },
   "dependencies": {
-    "@ocap/state": "1.28.9",
-    "@ocap/util": "1.28.9",
+    "@ocap/state": "1.29.1",
+    "@ocap/types": "1.29.1",
+    "@ocap/util": "1.29.1",
     "kareem": "^2.4.1",
-    "lodash": "^4.17.21"
+    "lodash": "^4.17.23"
   }
 }

package/lib/db.js

@@ -1,61 +0,0 @@
-const { Ready } = require('@ocap/util/lib/ready');
-const { indexes } = require('@ocap/state');
-
-class BaseIndexDB 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({ _addressFilter = {}, _paging = {}, _timeFilter = {}, _typeFilter = {} } = {}) {
-    throw new Error('listTransactions should be implemented in adapter');
-  }
-
-  listAssets({ _ownerAddress, _paging } = {}) {
-    throw new Error('listAssets should be implemented in adapter');
-  }
-
-  listFactories({ _ownerAddress, _paging } = {}) {
-    throw new Error('listFactories should be implemented in adapter');
-  }
-
-  listTopAccounts({ _paging, _tokenAddress } = {}) {
-    throw new Error('listTopAccounts should be implemented in adapter');
-  }
-
-  listTokens({ _paging } = {}) {
-    throw new Error('listTokens should be implemented in adapter');
-  }
-
-  listStakes({ _paging = {}, _addressFilter = {}, _timeFilter = {}, _assetFilter = {} } = {}) {
-    throw new Error('listStakes should be implemented in adapter');
-  }
-
-  listBlocks() {
-    return [];
-  }
-
-  listDelegations({ _from, _to, _paging = {}, _timeFilter = {} } = {}) {
-    throw new Error('listDelegations should be implemented in adapter');
-  }
-}
-
-module.exports = BaseIndexDB;

package/lib/index.js

@@ -1,79 +0,0 @@
-const crypto = require('node:crypto');
-const Kareem = require('kareem');
-const omit = require('lodash/omit');
-const { Ready } = require('@ocap/util/lib/ready');
-
-class BaseIndex extends Ready {
-  constructor(name, uniqIndex) {
-    super();
-
-    this.name = name;
-    this.ready = false;
-    this.readyCallbacks = [];
-    this.uniqIndex = uniqIndex;
-    this.primaryKey = typeof uniqIndex === 'string' ? uniqIndex : 'id';
-
-    const hooks = new Kareem();
-
-    Object.defineProperty(this, 'pre', { value: (n, fn) => hooks.pre(n, fn) });
-    Object.defineProperty(this, 'post', { value: (n, fn) => hooks.post(n, fn) });
-
-    ['insert', 'get', 'update', 'reset'].forEach((x) => {
-      Object.defineProperty(this, x, {
-        value: async (...args) => {
-          hooks.execPreSync(x, args);
-          const result = await this[`_${x}`](...args);
-          hooks.execPostSync(x, result);
-
-          if (['insert', 'update'].includes(x)) {
-            this.emit(x, omit(result, '$loki'));
-          }
-
-          return result;
-        },
-      });
-    });
-  }
-
-  count() {
-    throw new Error('`count` must be implemented in sub indexdb');
-  }
-
-  _insert(_attrs, _context) {
-    throw new Error('`_insert` must be implemented in sub indexdb');
-  }
-
-  _get(_id, _context) {
-    throw new Error('`_get` must be implemented in sub indexdb');
-  }
-
-  _update(_id, _updates, _context) {
-    throw new Error('`_update` must be implemented in sub indexdb');
-  }
-
-  _reset(_context) {
-    throw new Error('`_reset` must be implemented in sub indexdb');
-  }
-
-  /**
-   * Generate an ID composed of multiple primary keys
-   */
-  generatePrimaryKey(doc) {
-    if (typeof doc === 'string') {
-      return doc;
-    }
-
-    // composite primary key
-    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];
-  }
-}
-
-module.exports = BaseIndex;

package/lib/main.js

@@ -1,4 +0,0 @@
-const BaseIndex = require('./index');
-const BaseIndexDB = require('./db');
-
-module.exports = { BaseIndex, BaseIndexDB };