@ocap/resolver 1.28.8 → 1.29.0

package/esm/api.d.mts

@@ -0,0 +1,24 @@
+import { TIndexedTokenState } from "./types.mjs";
+import { Router } from "express";
+
+//#region src/api.d.ts
+
+/**
+ * Resolver interface for API handler
+ */
+interface IAPIResolver {
+  getTokenState(params: {
+    address: string;
+  }): Promise<TIndexedTokenState | null>;
+}
+/**
+ * Parameters for createAPIHandler
+ */
+interface ICreateAPIHandlerParams {
+  resolver: IAPIResolver;
+}
+declare function createAPIHandler({
+  resolver
+}: ICreateAPIHandlerParams): Router;
+//#endregion
+export { createAPIHandler };

package/esm/api.mjs

@@ -0,0 +1,53 @@
+import { getNftBGColorFromDid, getSvg } from "@arcblock/nft-display";
+import { Router } from "express";
+
+//#region src/api.ts
+function createAPIHandler({ resolver }) {
+	const router = Router();
+	router.get("/token/display", async (req, res) => {
+		const { address } = req.query;
+		if (!address) return res.status(400).json({ error: "address is required" });
+		const token = await resolver.getTokenState({ address });
+		if (!token) return res.status(400).json({ error: "token not found" });
+		let iconUri = "";
+		if (token.icon) {
+			let iconWidth = 40;
+			let iconHeight = 40;
+			const viewBoxMatch = token.icon.match(/viewBox\s*=\s*["']([^"']+)["']/i);
+			if (viewBoxMatch) {
+				const viewBoxValues = viewBoxMatch[1].split(/\s+/);
+				if (viewBoxValues.length >= 4) {
+					iconWidth = +viewBoxValues[2] || iconWidth;
+					iconHeight = +viewBoxValues[3] || iconHeight;
+				}
+			}
+			const fixedSvg = token.icon.replace(/<svg([^>]*)>/, `<svg$1 width="${iconWidth}" height="${iconHeight}">`);
+			iconUri = `data:image/svg+xml;base64,${Buffer.from(fixedSvg).toString("base64")}`;
+		}
+		const svg = getSvg({
+			color: getNftBGColorFromDid(address),
+			did: address,
+			variant: "app-passport",
+			verifiable: true,
+			chain: "arcblock",
+			header: {
+				icon: iconUri,
+				name: token.symbol
+			},
+			issuer: {
+				name: token.symbol,
+				icon: iconUri
+			},
+			extra: {
+				key: "Name",
+				value: token.name
+			}
+		});
+		res.setHeader("Content-Type", "image/svg+xml");
+		res.send(svg);
+	});
+	return router;
+}
+
+//#endregion
+export { createAPIHandler };

package/esm/hooks.d.mts

@@ -0,0 +1,153 @@
+import { IIndexDB, IIndexTable, IPipelineLogger, IRollupValidator, ITokenCache, TIndexedAccountState, TIndexedRollupState, TIndexedRollupValidator, TIndexedStakeState, TIndexedTransaction, TTransactionReceipt } from "./types.mjs";
+
+//#region src/hooks.d.ts
+
+/**
+ * Rollup state for hooks (subset of TIndexedRollupState)
+ */
+interface IHooksRollupState {
+  address: string;
+  tokenAddress: string;
+  genesisTime: string;
+  seedValidators: IRollupValidator[];
+  validators: IRollupValidator[];
+  totalDepositAmount?: string;
+  totalWithdrawAmount?: string;
+}
+/**
+ * Token balance in array format
+ */
+interface ITokenBalance {
+  address: string;
+  balance: string;
+}
+/**
+ * Stake state for hooks (with array-format tokens)
+ */
+interface IHooksStakeState {
+  address: string;
+  receiver: string;
+  tokens: ITokenBalance[];
+}
+/**
+ * Transaction state in context
+ */
+interface ITxState {
+  time: string;
+  receipts: TTransactionReceipt[];
+}
+/**
+ * Hook context passed to handlers
+ */
+interface IHooksContext {
+  txType?: string;
+  txState?: ITxState;
+  rollupState?: {
+    address: string;
+    tokenAddress?: string;
+  };
+  blockState?: {
+    signatures: Array<{
+      signer: string;
+    }>;
+  };
+  stateSnapshot?: Record<string, unknown>;
+}
+/**
+ * Transaction for hooks
+ */
+interface IHooksTx {
+  code: string;
+  hash: string;
+  time: string;
+  receipts?: TTransactionReceipt[];
+  tx: {
+    from: string;
+    signatures?: Array<{
+      signer: string;
+    }>;
+    itxJson: {
+      type_url: string;
+      address?: string;
+      receiver?: string;
+      rollup?: string;
+      endpoint?: string;
+      token?: {
+        value: string;
+      };
+      actualFee?: string;
+    };
+  };
+}
+/**
+ * Block for rollup block hooks
+ */
+interface IHooksBlock {
+  hash: string;
+  height: number;
+  genesisTime: string;
+  validators: string[];
+  proposer: string;
+}
+/**
+ * Block context for rollup block hooks
+ */
+interface IHooksBlockContext {
+  rollupState: {
+    address: string;
+  };
+  txStates: Array<{
+    type: string;
+    hash: string;
+    tx: {
+      itxJson: {
+        actualFee: string;
+      };
+    };
+  }>;
+}
+/**
+ * IndexDB interface for hooks (specialized tables)
+ */
+interface IHooksIndexDB extends IIndexDB {
+  account: IIndexTable<TIndexedAccountState> & {
+    get(address: string): Promise<TIndexedAccountState>;
+  };
+  rollup: IIndexTable<TIndexedRollupState> & {
+    get(address: string): Promise<IHooksRollupState | null>;
+    update(address: string, doc: unknown): Promise<void>;
+  };
+  rollupValidator: IIndexTable<TIndexedRollupValidator> & {
+    get(address: string): Promise<TIndexedRollupValidator | null>;
+    insert(doc: TIndexedRollupValidator): Promise<TIndexedRollupValidator>;
+    update(address: string, doc: TIndexedRollupValidator): Promise<void>;
+  };
+  stake: IIndexTable<TIndexedStakeState> & {
+    get(address: string): Promise<IHooksStakeState>;
+  };
+  tx: IIndexTable<TIndexedTransaction> & {
+    get(hash: string): Promise<unknown>;
+    update(hash: string, updates: unknown): Promise<void>;
+  };
+}
+/**
+ * Resolver interface for hooks
+ */
+interface IHooksResolver {
+  indexdb: IHooksIndexDB;
+  logger: IPipelineLogger;
+  tokenDistribution: {
+    updateByTx: (tx: IHooksTx, ctx: IHooksContext) => Promise<void>;
+  };
+  buildMigrationChain: () => Promise<void>;
+  tokenCache?: ITokenCache;
+}
+declare const onCreateRollup: (rollup: IHooksRollupState, _ctx: unknown, indexdb: IHooksIndexDB) => void;
+declare const onCreateRollupBlock: (block: IHooksBlock, ctx: IHooksBlockContext, indexdb: IHooksIndexDB) => void;
+declare const onUpdateToken: (tokenDoc: {
+  address: string;
+  [key: string]: unknown;
+}, _ctx: unknown, _indexdb: unknown, resolver: IHooksResolver) => void;
+declare const onCreateTx: (tx: IHooksTx, ctx: IHooksContext, resolver: IHooksResolver) => Promise<void>;
+//#endregion
+export { onCreateRollup, onCreateRollupBlock, onCreateTx, onUpdateToken };

package/esm/hooks.mjs

@@ -0,0 +1,267 @@
+import { name } from "./package.mjs";
+import { toStakeAddress } from "@arcblock/did-util";
+import { BN } from "@ocap/util";
+import createDebug from "debug";
+import merge from "lodash/merge.js";
+import pick from "lodash/pick.js";
+
+//#region src/hooks.ts
+const debug = createDebug(name);
+const onCreateRollup = (rollup, _ctx, indexdb) => {
+	rollup.seedValidators.forEach(async (x) => {
+		const { pk, address, endpoint } = x;
+		try {
+			const account = await indexdb.account.get(address);
+			if (!account) return;
+			await indexdb.rollupValidator.insert({
+				rollup: rollup.address,
+				pk,
+				address,
+				endpoint,
+				moniker: account.moniker,
+				joinTime: rollup.genesisTime,
+				leaveTime: "",
+				genesisTime: account.genesisTime,
+				renaissanceTime: account.renaissanceTime,
+				totalStake: "0",
+				revokedStake: "0",
+				availableStake: "0",
+				totalGain: "0",
+				proposedBlockCount: 0,
+				verifiedBlockCount: 0,
+				latestBlockHeight: 0,
+				latestBlockHash: ""
+			});
+			debug("create rollup validator", address);
+		} catch (err) {
+			console.error("create rollup validator error", err);
+		}
+	});
+};
+const ensureRollupValidator = async (address, rollupAddress, ctx, indexdb, upsert = true) => {
+	const doc = await indexdb.rollupValidator.get(address);
+	if (doc) {
+		doc.rollup = rollupAddress;
+		if (!doc.pk || !doc.endpoint) {
+			const validator$1 = (await indexdb.rollup.get(rollupAddress)).validators.find((v) => v.address === address);
+			doc.pk = validator$1.pk;
+			doc.endpoint = validator$1.endpoint;
+			await indexdb.rollupValidator.update(address, doc);
+			return doc;
+		}
+		return doc;
+	}
+	if (upsert === false) throw new Error("Rollup validator not found and upsert is disabled");
+	const stakeAddress = toStakeAddress(address, rollupAddress);
+	const [rollup, stake, account] = await Promise.all([
+		indexdb.rollup.get(rollupAddress),
+		indexdb.stake.get(stakeAddress),
+		indexdb.account.get(address)
+	]);
+	if (!stake || !account || !rollup) throw new Error("Required state not found for rollup validator");
+	const token = stake.tokens.find((t) => t.address === rollup.tokenAddress);
+	const validator = rollup.validators.find((v) => v.address === address);
+	debug("ensure rollup validator", {
+		txType: ctx.txType,
+		address,
+		rollupAddress,
+		validator,
+		token
+	});
+	return indexdb.rollupValidator.insert({
+		rollup: rollup.address,
+		address,
+		pk: validator ? validator.pk : "",
+		endpoint: validator ? validator.endpoint : "",
+		moniker: account.moniker,
+		joinTime: "",
+		leaveTime: "",
+		genesisTime: ctx.txState.time,
+		renaissanceTime: ctx.txState.time,
+		totalStake: token.balance,
+		revokedStake: "0",
+		availableStake: "0",
+		totalGain: "0",
+		proposedBlockCount: 0,
+		verifiedBlockCount: 0,
+		latestBlockHeight: 0,
+		latestBlockHash: ""
+	});
+};
+const onCreateRollupBlock = (block, ctx, indexdb) => {
+	const { validators, proposer } = block;
+	const { rollupState, txStates } = ctx;
+	validators.forEach(async (address) => {
+		try {
+			const doc = await ensureRollupValidator(address, rollupState.address, ctx, indexdb);
+			doc.rollup = rollupState.address;
+			doc.renaissanceTime = block.genesisTime;
+			doc.verifiedBlockCount += 1;
+			if (address === proposer) {
+				doc.latestBlockHeight = block.height;
+				doc.latestBlockHash = block.hash;
+				doc.proposedBlockCount += 1;
+			}
+			await indexdb.rollupValidator.update(address, doc);
+			debug("update rollup validator on new block", address);
+		} catch (err) {
+			console.error("update rollup validator error", err);
+		}
+	});
+	if (Array.isArray(txStates)) txStates.filter((x) => x.type === "withdraw_token_v2").forEach(async (x) => {
+		try {
+			const updates = merge(await indexdb.tx.get(x.hash), pick(x, ["tx.itxJson.actualFee"]));
+			await indexdb.tx.update(x.hash, updates);
+			debug("update tx on new block", x.hash);
+		} catch (err) {
+			console.error("update tx on new block error", err);
+		}
+	});
+};
+const updateRollupStats = async (address, value, key, indexdb) => {
+	try {
+		const doc = await indexdb.rollup.get(address);
+		if (!doc) return;
+		const rollupDoc = doc;
+		rollupDoc[key] = new BN(rollupDoc[key] || "0").add(new BN(value)).toString(10);
+		await indexdb.rollup.update(address, doc);
+		debug("update rollup", address);
+	} catch (err) {
+		console.error("update rollup error", err);
+	}
+};
+const onDepositTokenV2 = async (tx, ctx, indexdb) => {
+	const { signatures } = tx.tx;
+	const { rollupState } = ctx;
+	signatures.forEach(async ({ signer: address }) => {
+		try {
+			const doc = await ensureRollupValidator(address, rollupState.address, ctx, indexdb);
+			doc.renaissanceTime = tx.time;
+			await indexdb.rollupValidator.update(address, doc);
+			debug("update rollup validator on deposit", address);
+		} catch (err) {
+			console.error("update rollup validator error", err);
+		}
+	});
+	const amount = new BN(tx.tx.itxJson.token.value).add(new BN(tx.tx.itxJson.actualFee));
+	await updateRollupStats(ctx.rollupState.address, amount.toString(), "totalDepositAmount", indexdb);
+};
+const onClaimBlockReward = async (tx, ctx, indexdb) => {
+	const { rollupState, blockState } = ctx;
+	const { signatures } = blockState;
+	await Promise.all(signatures.map(async ({ signer }) => {
+		try {
+			const doc = await ensureRollupValidator(signer, rollupState.address, ctx, indexdb);
+			const receipt = tx.receipts.find((x) => x.address === signer);
+			if (receipt) {
+				const change = receipt.changes.find((x) => x.target === rollupState.tokenAddress && new BN(x.value).isNeg() === false);
+				doc.totalGain = new BN(doc.totalGain).add(new BN(change.value).abs()).toString(10);
+				await indexdb.rollupValidator.update(signer, doc);
+				debug("update rollup validator on claim reward", signer);
+			}
+		} catch (err) {
+			console.error("update rollup validator on claim reward error", err);
+		}
+	}));
+};
+const onJoinRollup = async (tx, ctx, indexdb) => {
+	try {
+		const address = tx.tx.from;
+		const doc = await ensureRollupValidator(address, tx.tx.itxJson.rollup, ctx, indexdb);
+		doc.endpoint = tx.tx.itxJson.endpoint;
+		doc.joinTime = tx.time;
+		doc.renaissanceTime = tx.time;
+		doc.leaveTime = "";
+		await indexdb.rollupValidator.update(address, doc);
+		debug("join rollup validator", address);
+	} catch (err) {
+		console.error("join rollup validator error", err);
+	}
+};
+const onLeaveRollup = async (tx, ctx, indexdb) => {
+	try {
+		const address = tx.tx.from;
+		const doc = await ensureRollupValidator(address, tx.tx.itxJson.rollup, ctx, indexdb);
+		doc.leaveTime = tx.time;
+		doc.renaissanceTime = tx.time;
+		doc.rollup = "";
+		await indexdb.rollupValidator.update(address, doc);
+		debug("leave rollup validator", address);
+	} catch (err) {
+		console.error("leave rollup validator error", err);
+	}
+};
+const onStake = async (tx, ctx, indexdb) => {
+	try {
+		const rollup = await indexdb.rollup.get(tx.tx.itxJson.receiver);
+		if (!rollup) return;
+		const address = tx.tx.from;
+		if (rollup.validators.find((x) => x.address === address) === void 0) return;
+		const stakeAddress = toStakeAddress(address, rollup.address);
+		const doc = await ensureRollupValidator(address, rollup.address, ctx, indexdb);
+		const change = ctx.txState.receipts.find((x) => x.address === stakeAddress).changes.find((x) => x.target === rollup.tokenAddress);
+		doc.totalStake = new BN(doc.totalStake).add(new BN(change.value).abs()).toString(10);
+		doc.renaissanceTime = tx.time;
+		await indexdb.rollupValidator.update(address, doc);
+		debug("stake rollup validator", address);
+	} catch (err) {
+		console.error("stake rollup validator error", err);
+	}
+};
+const onClaimStake = async (tx, ctx, indexdb) => {
+	try {
+		const stake = await indexdb.stake.get(tx.tx.itxJson.address);
+		if (!stake) return;
+		const rollup = await indexdb.rollup.get(stake.receiver);
+		if (!rollup) return;
+		const address = tx.tx.from;
+		const doc = await ensureRollupValidator(address, rollup.address, ctx, indexdb, false);
+		const change = ctx.txState.receipts.find((x) => x.address === stake.address).changes.find((x) => x.target === rollup.tokenAddress);
+		doc.renaissanceTime = tx.time;
+		doc.totalStake = new BN(doc.totalStake).sub(new BN(change.value).abs()).toString(10);
+		doc.revokedStake = new BN(doc.revokedStake).add(new BN(change.value).abs()).toString(10);
+		await indexdb.rollupValidator.update(address, doc);
+		debug("claim-stake rollup validator", address);
+	} catch (err) {
+		console.error("claim-stake rollup validator error", err);
+	}
+};
+const onAccountMigrate = async (_tx, resolver) => {
+	try {
+		await resolver.buildMigrationChain();
+	} catch (e) {
+		console.error("build migration chain error", e);
+	}
+};
+const onUpdateToken = (tokenDoc, _ctx, _indexdb, resolver) => {
+	if (resolver.tokenCache) resolver.tokenCache.set(tokenDoc.address, tokenDoc);
+};
+const onCreateTx = async (tx, ctx, resolver) => {
+	try {
+		await resolver.tokenDistribution.updateByTx(tx, ctx);
+	} catch (e) {
+		resolver.logger.error("Failed to update token distribution", {
+			error: e,
+			tx,
+			ctx
+		});
+	}
+	if (tx.code !== "OK") return;
+	const { indexdb } = resolver;
+	switch (tx.tx.itxJson.type_url) {
+		case "fg:t:stake": return onStake(tx, ctx, indexdb);
+		case "fg:t:claim_stake": return onClaimStake(tx, ctx, indexdb);
+		case "fg:t:join_rollup": return onJoinRollup(tx, ctx, indexdb);
+		case "fg:t:leave_rollup": return onLeaveRollup(tx, ctx, indexdb);
+		case "fg:t:deposit_token_v2": return onDepositTokenV2(tx, ctx, indexdb);
+		case "fg:t:claim_block_reward":
+			await onClaimBlockReward(tx, ctx, indexdb);
+			return;
+		case "fg:t:withdraw_token_v2": return updateRollupStats(ctx.rollupState.address, tx.tx.itxJson.token.value, "totalWithdrawAmount", indexdb);
+		case "fg:t:account_migrate": return onAccountMigrate(tx, resolver);
+		default:
+	}
+};
+
+//#endregion
+export { onCreateRollup, onCreateRollupBlock, onCreateTx, onUpdateToken };

package/esm/index.d.mts

@@ -0,0 +1,201 @@
+import { IAddressArgs, IAssetState, IChainConfig, IChunkIterator, IDataObject, IDelegateState, IEvidenceState, IFilter, IGetAccountStateArgs, IGetAccountTokensArgs, IGetStateParams, IIndexDB, IListChunksParams, IPaginatedResult, IPipelineLogger, IResolver, IResolverAccountState, IResolverChainInfo, IResolverContext, IResolverFactoryState, IResolverForgeStats, IResolverListAccountsResult, IResolverListAssetsResult, IResolverListDelegationsResult, IResolverListFactoriesResult, IResolverListRollupBlocksResult, IResolverListRollupValidatorsResult, IResolverListRollupsResult, IResolverListStakesResult, IResolverListTokenFactoriesResult, IResolverListTokensResult, IResolverListTransactionsResult, IResolverNetInfo, IResolverNodeInfo, IResolverPaging, IResolverParams, IResolverRollupState, IResolverStakeState, IResolverTransaction, IResolverValidatorsInfo, IRollupBlock, IStateDB, ITokenCache, ITokenFactoryState, ITokenFlowsResult, ITokenInfo, ITokenState, TIndexedTokenState, TRequestEstimateGas, TRequestGetEvidenceState, TRequestGetRollupBlock, TRequestGetTokenDistribution, TRequestGetTx, TRequestListAssetTransactions, TRequestListAssets, TRequestListDelegations, TRequestListFactories, TRequestListRollupBlocks, TRequestListRollupValidators, TRequestListRollups, TRequestListStakes, TRequestListTokenFactories, TRequestListTokenFlows, TRequestListTokens, TRequestListTopAccounts, TRequestListTransactions, TRequestSearch, TRequestVerifyAccountRisk, TTokenDistribution, TVerifyAccountRiskResult } from "./types.mjs";
+import { MigrationChainManager } from "./migration-chain.mjs";
+import { TokenDistributionManager } from "./token-distribution.mjs";
+import { createExecutor } from "@ocap/tx-protocols";
+import Queue from "queue";
+
+//#region src/index.d.ts
+declare const formatData: (data: IDataObject | null | undefined) => IDataObject | null | undefined;
+declare const formatDelegationOps: (state: IDelegateState) => any;
+declare class OCAPResolver implements IResolver {
+  statedb: IStateDB;
+  indexdb: IIndexDB;
+  filter?: IFilter;
+  config: IChainConfig;
+  chainAddr: string;
+  tokenItx: TIndexedTokenState | null;
+  consensus: string;
+  queue: Queue;
+  tokenCache: ITokenCache;
+  tokenDistribution: TokenDistributionManager;
+  executor: ReturnType<typeof createExecutor>;
+  logger: IPipelineLogger;
+  migrationChain?: MigrationChainManager;
+  formatTx: (tx: IResolverTransaction | null, ctx?: IResolverContext) => Promise<IResolverTransaction | null>;
+  /**
+   * Creates an instance of OCAPResolver.
+   * @param params Parameters to bootstrap the resolver
+   * @param params.statedb @ocap/statedb adapter
+   * @param params.indexdb @ocap/indexdb adapter
+   * @param params.config @ocap/config object
+   * @param params.filter bloom filter to do anti-replay check
+   * @param params.validateTokenConfig should we validate token supply and token-holder balance, should be disabled when starting an existing chain
+   */
+  constructor({
+    statedb,
+    indexdb,
+    config,
+    filter,
+    validateTokenConfig,
+    logger
+  }: IResolverParams);
+  sendTx({
+    tx: txBase64,
+    extra
+  }: {
+    tx: string;
+    extra?: Record<string, unknown>;
+  }, ctx?: IResolverContext): Promise<string>;
+  getTx({
+    hash
+  }: TRequestGetTx, ctx?: IResolverContext): Promise<IResolverTransaction | null>;
+  getBlock(): null;
+  getBlocks(): never[];
+  getUnconfirmedTxs(): never[];
+  getChainInfo(): Promise<IResolverChainInfo>;
+  getNodeInfo(): Promise<IResolverNodeInfo>;
+  getNetInfo(): Promise<IResolverNetInfo>;
+  getValidatorsInfo(): Promise<IResolverValidatorsInfo>;
+  getConfig(): string;
+  getAccountState({
+    address,
+    traceMigration,
+    expandContext
+  }: IGetAccountStateArgs & {
+    traceMigration?: boolean;
+  }, ctx?: IResolverContext): Promise<IResolverAccountState | null>;
+  getStakeState({
+    address
+  }: IAddressArgs, ctx?: IResolverContext): Promise<IResolverStakeState | null>;
+  getRollupState({
+    address
+  }: IAddressArgs, ctx?: IResolverContext): Promise<IResolverRollupState | null>;
+  getRollupBlock({
+    hash,
+    height,
+    rollupAddress
+  }: Partial<TRequestGetRollupBlock>, ctx?: IResolverContext): Promise<IRollupBlock | null>;
+  getAssetState({
+    address
+  }: IAddressArgs, ctx?: IResolverContext): Promise<IAssetState | null>;
+  getEvidenceState({
+    hash
+  }: TRequestGetEvidenceState, ctx?: IResolverContext): Promise<IEvidenceState | null>;
+  getFactoryState({
+    address
+  }: IAddressArgs, ctx?: IResolverContext): Promise<IResolverFactoryState | null>;
+  getTokenState({
+    address
+  }: IAddressArgs, ctx?: IResolverContext): Promise<ITokenState | null>;
+  getTokenFactoryState(args: IAddressArgs, ctx?: IResolverContext): Promise<ITokenFactoryState | null>;
+  getDelegateState({
+    address
+  }: IAddressArgs, ctx?: IResolverContext): Promise<IDelegateState | null>;
+  getAccountTokens({
+    address,
+    token
+  }: IGetAccountTokensArgs, ctx?: IResolverContext): Promise<ITokenInfo[]>;
+  getForgeState(): Promise<Record<string, unknown>>;
+  getForgeStats(): Promise<IResolverForgeStats>;
+  listTransactions(args?: Partial<TRequestListTransactions>, ctx?: IResolverContext): Promise<IResolverListTransactionsResult>;
+  listAssets(args?: Partial<TRequestListAssets>, ctx?: IResolverContext): Promise<IResolverListAssetsResult>;
+  listAssetTransactions(args?: Partial<TRequestListAssetTransactions>, ctx?: IResolverContext): Promise<IResolverListTransactionsResult>;
+  listFactories(args?: Partial<TRequestListFactories>, ctx?: IResolverContext): Promise<IResolverListFactoriesResult>;
+  listTopAccounts(args?: Partial<TRequestListTopAccounts>): Promise<IResolverListAccountsResult>;
+  listTokens(args?: Partial<TRequestListTokens>, ctx?: IResolverContext): Promise<IResolverListTokensResult>;
+  listTokenFactories(args?: Partial<TRequestListTokenFactories>, ctx?: IResolverContext): Promise<IResolverListTokenFactoriesResult>;
+  listStakes(args?: Partial<TRequestListStakes>, ctx?: IResolverContext): Promise<IResolverListStakesResult>;
+  listRollups(args?: Partial<TRequestListRollups>, ctx?: IResolverContext): Promise<IResolverListRollupsResult>;
+  listRollupBlocks(args?: Partial<TRequestListRollupBlocks>, ctx?: IResolverContext): Promise<IResolverListRollupBlocksResult>;
+  listRollupValidators(args?: Partial<TRequestListRollupValidators>, ctx?: IResolverContext): Promise<IResolverListRollupValidatorsResult>;
+  listDelegations(args?: Partial<TRequestListDelegations>, ctx?: IResolverContext): Promise<IResolverListDelegationsResult>;
+  verifyAccountRisk(args?: Partial<TRequestVerifyAccountRisk>, ctx?: IResolverContext): Promise<TVerifyAccountRiskResult | null> | null;
+  listTokenFlows(args?: Partial<TRequestListTokenFlows>, ctx?: IResolverContext): Promise<ITokenFlowsResult> | never[];
+  search(args: Partial<TRequestSearch>): Promise<{
+    results: Array<{
+      type: string;
+      id: string;
+    }>;
+  }>;
+  estimateGas(args?: Partial<TRequestEstimateGas>): {
+    estimate: {
+      max: string;
+    };
+  };
+  listBlocks(): {
+    blocks: never[];
+  };
+  validateTokenConfig(): void;
+  runAsLambda<T>(fn: (txn?: unknown) => T | Promise<T>, args?: Record<string, unknown>): Promise<T>;
+  getChain(): Promise<Record<string, unknown> | null>;
+  getToken(id: string): Promise<ITokenState | null>;
+  initializeStateDB(): Promise<void>;
+  connectIndexDB(): void;
+  _getState<T = Record<string, unknown>>({
+    table,
+    id,
+    dataKey,
+    extraParams,
+    onRead,
+    expandContext,
+    ctx
+  }: IGetStateParams): Promise<T | null>;
+  _doPaginatedSearch<TArgs extends Record<string, unknown>>(fn: string, args: TArgs, listKey: string, dataKey?: string | string[] | null, ctx?: IResolverContext): Promise<Record<string, unknown>>;
+  _formatTx(tx: IResolverTransaction | null, ctx?: IResolverContext): Promise<IResolverTransaction | null>;
+  _getAllResults<T>(dataKey: string, fn: (paging: IResolverPaging) => Promise<any>, limit?: number): Promise<T[]>;
+  formatTokenArray(tokens: ITokenInfo[]): Promise<ITokenInfo[]>;
+  formatTokenMap(tokens: Record<string, string>): Promise<ITokenInfo[]>;
+  getTxTokenSymbols(tx: IResolverTransaction): Promise<ITokenInfo[]>;
+  fixReceiptTokens(tx: IResolverTransaction): IResolverTransaction;
+  fixTokenSymbols(tx: IResolverTransaction): IResolverTransaction;
+  enrichIndexContext(ctx: Record<string, unknown>): Record<string, unknown>;
+  formatDelegateState(state: IDelegateState): Promise<IDelegateState>;
+  buildMigrationChain(): Promise<void>;
+  getMigrationChain(): Promise<MigrationChainManager>;
+  /** fix accounts field of legacy approve_withdraw transactions in indexdb */
+  fixApproveWithdrawAccounts(): Promise<IResolverTransaction[]>;
+  updateTokenDistribution({
+    tokenAddress,
+    force
+  }?: {
+    tokenAddress?: string | undefined;
+    force?: boolean | undefined;
+  }): Promise<unknown>;
+  getTokenDistribution(args?: Partial<TRequestGetTokenDistribution>): Promise<TTokenDistribution | null>;
+  /**
+   * Fetch data in chunks to handle large datasets
+   * @param fn Function to fetch data
+   * @param params Chunk parameters
+   * @returns Iterator with next function
+   */
+  listChunks<T extends Record<string, unknown>>(fn: (params: {
+    size: number;
+    cursor: number;
+    time?: string;
+  }) => Promise<{
+    [key: string]: T[];
+  }>, {
+    total,
+    concurrency,
+    chunkSize,
+    pageSize,
+    timeKey,
+    dataKey
+  }: IListChunksParams): IChunkIterator<T>;
+  listTransactionsChunks(args?: Partial<TRequestListTransactions>, {
+    chunkSize,
+    pageSize
+  }?: {
+    chunkSize?: number | undefined;
+    pageSize?: number | undefined;
+  }): Promise<IChunkIterator<IResolverTransaction>>;
+  listStakeChunks(args?: Partial<TRequestListStakes>, {
+    chunkSize,
+    pageSize
+  }?: {
+    chunkSize?: number | undefined;
+    pageSize?: number | undefined;
+  }): Promise<IChunkIterator<IResolverStakeState>>;
+}
+//#endregion
+export { type IChainConfig, type IChunkIterator, type IDataObject, type IPaginatedResult, type IResolverPaging, type IResolverParams, type IResolverTransaction, type ITokenInfo, OCAPResolver as default, formatData, formatDelegationOps };