@ocap/resolver 1.28.8 → 1.29.0

package/esm/token-flow.d.mts

@@ -0,0 +1,139 @@
+import { IChainConfig, IFilter, IMigrationChain, IPipelineLogger, IResolverPaging, IStateDB, ITokenCache, TTransactionReceipt } from "./types.mjs";
+import { BN } from "@ocap/util";
+
+//#region src/token-flow.d.ts
+
+/**
+ * Transfer item with BN value for calculation
+ */
+interface ITransferItem {
+  address: string;
+  value: InstanceType<typeof BN>;
+  action?: string;
+  archived?: boolean;
+}
+/**
+ * Transfer flow with BN value
+ */
+interface ITransferFlow {
+  from: string;
+  to: string;
+  value: InstanceType<typeof BN>;
+  hash: string;
+}
+/**
+ * Transfer flow result with string value
+ */
+interface ITransferFlowResult {
+  from: string;
+  to: string;
+  value: string;
+  hash: string;
+}
+/**
+ * Risk check result
+ */
+interface IRiskCheckResult {
+  isRisky: boolean;
+  reason?: string;
+  data: {
+    address?: string;
+    balance?: string | number;
+    transferIn?: string;
+    transferOut?: string;
+    accountCount: number;
+    txCount: number;
+  };
+}
+/**
+ * Parameters for verifyAccountRisk
+ */
+interface IVerifyAccountRiskParams {
+  accountAddress: string;
+  tokenAddress: string;
+  accountLimit?: number;
+  txLimit?: number;
+  tolerance?: string;
+}
+/**
+ * Parameters for listTokenFlows
+ */
+interface IListTokenFlowsParams {
+  accountAddress: string;
+  tokenAddress: string;
+  paging?: IResolverPaging;
+  depth?: number;
+  direction?: 'IN' | 'OUT';
+}
+/**
+ * Simplified transaction for token flow
+ */
+interface ITokenFlowTx {
+  hash: string;
+  time: string;
+  receipts?: TTransactionReceipt[];
+  [key: string]: unknown;
+}
+/**
+ * Resolver interface for token flow operations
+ */
+interface ITokenFlowResolver {
+  config: IChainConfig;
+  tokenCache: ITokenCache;
+  filter?: IFilter;
+  logger: IPipelineLogger;
+  statedb: IStateDB;
+  getMigrationChain: () => Promise<IMigrationChain>;
+  _getAllResults: <T>(type: string, fetcher: (paging: IResolverPaging) => Promise<{
+    transactions?: T[];
+    data?: T[];
+  }>, limit?: number) => Promise<T[]>;
+  listTransactions: (params: {
+    paging?: IResolverPaging;
+    accountFilter?: {
+      accounts: string[];
+    };
+    tokenFilter?: {
+      tokens: string[];
+    };
+  }, ctx?: Record<string, unknown>) => Promise<{
+    transactions: ITokenFlowTx[];
+  }>;
+  runAsLambda: <T>(fn: (txn: unknown) => Promise<T>, options?: {
+    retryLimit?: number;
+  }) => Promise<T>;
+}
+/**
+ * Parse transfer in/out list from transaction
+ * @param tx Transaction object
+ * @param tokenAddress Token address to filter by
+ * @returns Object containing transferInList and transferOutList
+ */
+declare const getTransferList: (tx: ITokenFlowTx, tokenAddress: string) => {
+  transferInList: ITransferItem[];
+  transferOutList: ITransferItem[];
+};
+/**
+ * Parse transfer flow from transaction
+ * @param tx Transaction object
+ * @param tokenAddress Token address to filter by
+ * @returns Array of transfer flows
+ */
+declare const getTransferFlow: (tx: ITokenFlowTx, tokenAddress: string) => ITransferFlow[];
+declare const fixMigrateReceipts: (tx: ITokenFlowTx, resolver: ITokenFlowResolver) => Promise<void>;
+declare const verifyAccountRisk: ({
+  accountAddress,
+  tokenAddress,
+  accountLimit,
+  txLimit,
+  tolerance
+}: IVerifyAccountRiskParams, resolver: ITokenFlowResolver, ctx?: Record<string, unknown>) => Promise<IRiskCheckResult>;
+declare const listTokenFlows: ({
+  accountAddress,
+  tokenAddress,
+  paging,
+  depth,
+  direction
+}: IListTokenFlowsParams, resolver: ITokenFlowResolver, ctx?: Record<string, unknown>) => Promise<ITransferFlowResult[]>;
+//#endregion
+export { fixMigrateReceipts, getTransferFlow, getTransferList, listTokenFlows, verifyAccountRisk };

package/esm/token-flow.mjs

@@ -0,0 +1,330 @@
+import { BN, fromTokenToUnit, isSameDid } from "@ocap/util";
+import { Joi, schemas } from "@arcblock/validator";
+import { CustomError } from "@ocap/util/lib/error";
+import uniq from "lodash/uniq.js";
+import { FORGE_TOKEN_HOLDER } from "@ocap/state/lib/states/tx";
+
+//#region src/token-flow.ts
+const ZERO = new BN(0);
+const paramsSchema = Joi.object({
+	accountAddress: schemas.tokenHolder.required(),
+	tokenAddress: Joi.DID().prefix().role("ROLE_TOKEN").required(),
+	resolver: Joi.object().required()
+});
+/**
+* Parse transfer in/out list from transaction
+* @param tx Transaction object
+* @param tokenAddress Token address to filter by
+* @returns Object containing transferInList and transferOutList
+*/
+const getTransferList = (tx, tokenAddress) => {
+	const transferInList = [];
+	const transferOutList = [];
+	for (const receipt of tx.receipts || []) {
+		const changes = receipt.changes.filter((item) => item.target === tokenAddress && item.value !== "0");
+		for (const change of changes) {
+			const value = new BN(change.value);
+			const item = {
+				address: receipt.address,
+				value: value.abs(),
+				action: change.action
+			};
+			if (value.lt(ZERO)) transferOutList.push(item);
+			else transferInList.push(item);
+		}
+	}
+	return {
+		transferInList,
+		transferOutList
+	};
+};
+/**
+* Parse transfer flow from transaction
+* @param tx Transaction object
+* @param tokenAddress Token address to filter by
+* @returns Array of transfer flows
+*/
+const getTransferFlow = (tx, tokenAddress) => {
+	const { transferInList, transferOutList } = getTransferList(tx, tokenAddress);
+	const txTransfers = [];
+	for (const outItem of transferOutList) {
+		if (outItem.archived) continue;
+		const matchedInItem = transferInList.find((x) => x.value.eq(outItem.value));
+		if (matchedInItem) {
+			txTransfers.push({
+				from: outItem.address,
+				to: matchedInItem.address,
+				value: outItem.value,
+				hash: tx.hash
+			});
+			matchedInItem.archived = true;
+			outItem.archived = true;
+			continue;
+		}
+		for (const inItem of transferInList) {
+			if (inItem.archived) continue;
+			if (outItem.archived) continue;
+			if (outItem.value.gt(inItem.value)) {
+				txTransfers.push({
+					from: outItem.address,
+					to: inItem.address,
+					value: inItem.value,
+					hash: tx.hash
+				});
+				inItem.archived = true;
+				outItem.value = outItem.value.sub(inItem.value);
+				continue;
+			}
+			if (outItem.value.lt(inItem.value)) {
+				txTransfers.push({
+					from: outItem.address,
+					to: inItem.address,
+					value: outItem.value,
+					hash: tx.hash
+				});
+				outItem.archived = true;
+				inItem.value = inItem.value.sub(outItem.value);
+				continue;
+			}
+			if (outItem.value.eq(inItem.value)) {
+				txTransfers.push({
+					from: outItem.address,
+					to: inItem.address,
+					value: inItem.value,
+					hash: tx.hash
+				});
+				inItem.archived = true;
+				outItem.archived = true;
+			}
+		}
+	}
+	return txTransfers;
+};
+const getVaultAccounts = (config) => {
+	return Object.values(config.vaults).flat().concat(FORGE_TOKEN_HOLDER);
+};
+const getInitialBalance = (address, config) => {
+	const account = config?.accounts?.find((x) => isSameDid(x.address, address));
+	return account ? fromTokenToUnit(account.balance ?? 0) : ZERO;
+};
+const getBalance = async (address, tokenAddress, { resolver, txn }) => {
+	const state = await resolver.statedb.account.get(address, {
+		txn,
+		traceMigration: false
+	});
+	if (!state) throw new CustomError("INVALID_REQUEST", `Invalid address ${address}`);
+	return state.tokens[tokenAddress] || 0;
+};
+const fixMigrateReceipts = async (tx, resolver) => {
+	const migrationChain = await resolver.getMigrationChain();
+	const txTime = new Date(tx.time);
+	tx.receipts?.forEach((receipt) => {
+		receipt.address = migrationChain.findAddressAtTime(receipt.address, txTime);
+	});
+};
+const verifyAccountRisk = async ({ accountAddress, tokenAddress, accountLimit = 400, txLimit = 1e4, tolerance = "0.0000000001" }, resolver, ctx = {}) => {
+	const validation = paramsSchema.validate({
+		accountAddress,
+		tokenAddress,
+		resolver
+	});
+	if (validation.error) throw new CustomError("INVALID_PARAMS", validation.error.message);
+	const { logger } = resolver;
+	const checkedAccounts = /* @__PURE__ */ new Map();
+	const checkedTx = /* @__PURE__ */ new Map();
+	const toleranceUnit = fromTokenToUnit(tolerance, (await resolver.tokenCache.get(tokenAddress))?.decimal);
+	const vaultAccounts = getVaultAccounts(resolver.config);
+	const accountQueue = [[{
+		address: accountAddress,
+		chain: []
+	}]];
+	const execute = async (depth, txn) => {
+		const queue = accountQueue[depth];
+		for (let i = 0; i < queue.length; i++) {
+			if (checkedAccounts.size >= accountLimit) {
+				logger.warn("Account risk check reached max account size limit", {
+					address: accountAddress,
+					tokenAddress,
+					accountCount: checkedAccounts.size,
+					txCount: checkedTx.size,
+					depth,
+					accountLimit,
+					txLimit,
+					tolerance
+				});
+				return {
+					isRisky: false,
+					reason: "MAX_ACCOUNT_SIZE_LIMIT",
+					data: {
+						accountCount: checkedAccounts.size,
+						txCount: checkedTx.size
+					}
+				};
+			}
+			const { address, chain } = queue[i];
+			chain.push(address);
+			if (checkedAccounts.has(address)) continue;
+			const trustedConfig = await resolver.filter?.getTrustedAccountConfig?.(address);
+			if (trustedConfig && !trustedConfig.tolerance) {
+				checkedAccounts.set(address, true);
+				continue;
+			}
+			let balance = 0;
+			let transactions = [];
+			try {
+				[balance, transactions] = await Promise.all([getBalance(address, tokenAddress, {
+					resolver,
+					txn
+				}), resolver._getAllResults("transactions", (paging) => resolver.listTransactions({
+					paging,
+					accountFilter: { accounts: [address] }
+				}, ctx), txLimit)]);
+			} catch (e) {
+				if (e?.code === "EXCEED_LIMIT") {
+					logger.warn("Skip checking account cause tx count exceeding limit", {
+						address,
+						txLimit
+					});
+					checkedAccounts.set(address, true);
+					continue;
+				}
+				throw e;
+			}
+			let transferIn = getInitialBalance(address, resolver.config);
+			let transferOut = ZERO;
+			for (const tx of transactions) {
+				if (!checkedTx.has(tx.hash)) {
+					await fixMigrateReceipts(tx, resolver);
+					checkedTx.set(tx.hash, getTransferList(tx, tokenAddress));
+				}
+				const { transferInList, transferOutList } = checkedTx.get(tx.hash);
+				const transferInAmount = transferInList.filter((item) => isSameDid(item.address, address)).map((item) => item.value).reduce((prev, cur) => prev.add(cur), ZERO);
+				const transferOutAmount = transferOutList.filter((item) => isSameDid(item.address, address)).map((item) => item.value).reduce((prev, cur) => prev.add(cur), ZERO);
+				transferIn = transferIn.add(transferInAmount);
+				transferOut = transferOut.add(transferOutAmount);
+				if (transferInAmount.gt(ZERO)) {
+					if (!accountQueue[depth + 1]) accountQueue[depth + 1] = [];
+					const accountsToQueue = transferOutList.filter((item) => {
+						if (checkedAccounts.has(item.address)) return false;
+						if (schemas.tokenHolder.validate(item.address).error) return false;
+						if (vaultAccounts.includes(item.address)) return false;
+						if (["gas", "fee"].includes(item.action || "")) return false;
+						return true;
+					}).map((item) => item.address);
+					accountQueue[depth + 1].push(...uniq(accountsToQueue).map((x) => ({
+						address: x,
+						chain: chain.concat()
+					})));
+				}
+			}
+			checkedAccounts.set(address, true);
+			const diff = transferIn.sub(transferOut).sub(new BN(balance)).add(fromTokenToUnit(trustedConfig?.tolerance || 0));
+			if (diff.abs().gt(toleranceUnit)) {
+				const data = {
+					address: chain.join("->"),
+					balance,
+					transferIn: transferIn.toString(),
+					transferOut: transferOut.toString(),
+					accountCount: checkedAccounts.size,
+					txCount: checkedTx.size
+				};
+				logger.warn("Account balance does not match transfer records", {
+					...data,
+					sourceAccount: accountAddress,
+					tokenAddress,
+					diff: diff.toString(),
+					depth,
+					accountLimit,
+					txLimit,
+					tolerance
+				});
+				return {
+					isRisky: true,
+					reason: "INVALID_BALANCE",
+					data
+				};
+			}
+		}
+	};
+	for (let depth = 0; depth < accountQueue.length; depth++) {
+		let isExecuted = false;
+		const result = await resolver.runAsLambda((txn) => {
+			if (isExecuted) throw new CustomError("INVALID_REQUEST", "verifyAccountRisk should not retry");
+			isExecuted = true;
+			return execute(depth, txn);
+		}, { retryLimit: 0 });
+		if (result) return result;
+	}
+	logger.info("Account risk check completed", {
+		address: accountAddress,
+		tokenAddress,
+		accountCount: checkedAccounts.size,
+		txCount: checkedTx.size,
+		depth: accountQueue.length,
+		accountLimit,
+		txLimit,
+		tolerance
+	});
+	return {
+		isRisky: false,
+		data: {
+			accountCount: checkedAccounts.size,
+			txCount: checkedTx.size
+		}
+	};
+};
+const listTokenFlows = async ({ accountAddress, tokenAddress, paging = {}, depth = 2, direction = "OUT" }, resolver, ctx = {}) => {
+	const { error } = paramsSchema.validate({
+		accountAddress,
+		tokenAddress,
+		resolver
+	});
+	if (error) throw new CustomError("INVALID_PARAMS", error.message);
+	const minAmount = fromTokenToUnit(1, (await resolver.tokenCache.get(tokenAddress))?.decimal || 18);
+	const maxAccountSize = Math.min(200, paging.size || 200);
+	const maxDepth = Math.min(5, depth);
+	const vaultAccounts = getVaultAccounts(resolver.config);
+	const tokenFlows = [];
+	const checkedAccounts = /* @__PURE__ */ new Map();
+	const checkedTx = /* @__PURE__ */ new Map();
+	let curDepth = 1;
+	const depthQueue = { [curDepth]: [accountAddress] };
+	while (depthQueue[curDepth]?.length && curDepth <= maxDepth && checkedAccounts.size < maxAccountSize) {
+		for (const address of depthQueue[curDepth]) {
+			if (checkedAccounts.has(address)) continue;
+			if (schemas.tokenHolder.validate(address).error) continue;
+			const transactions = await resolver._getAllResults("transactions", (page) => resolver.listTransactions({
+				paging: page,
+				accountFilter: { accounts: [address] },
+				tokenFilter: { tokens: [tokenAddress] }
+			}, ctx));
+			let accountsToQueue = [];
+			for (const tx of transactions) {
+				if (!checkedTx.has(tx.hash)) {
+					await fixMigrateReceipts(tx, resolver);
+					checkedTx.set(tx.hash, getTransferFlow(tx, tokenAddress));
+				}
+				const txTransfers = checkedTx.get(tx.hash).filter((item) => {
+					if (direction === "OUT" && item.from !== address) return false;
+					if (direction === "IN" && item.to !== address) return false;
+					if (item.value.lt(minAmount)) return false;
+					return true;
+				});
+				tokenFlows.push(...txTransfers.map((item) => ({
+					...item,
+					value: item.value.toString()
+				})));
+				accountsToQueue = accountsToQueue.concat(txTransfers.map((item) => direction === "IN" ? item.from : item.to).filter((item) => !vaultAccounts.includes(item)));
+			}
+			checkedAccounts.set(address, true);
+			if (checkedAccounts.size >= maxAccountSize) break;
+			if (!depthQueue[curDepth + 1]) depthQueue[curDepth + 1] = [];
+			depthQueue[curDepth + 1].push(...uniq(accountsToQueue));
+		}
+		curDepth++;
+	}
+	return tokenFlows;
+};
+
+//#endregion
+export { fixMigrateReceipts, getTransferFlow, getTransferList, listTokenFlows, verifyAccountRisk };

package/esm/types.d.mts

@@ -0,0 +1,115 @@
+import { Address, BN, DirectionMap, Hash, IAccountState, IAddressArgs, IAny, IAssetFactoryState, IAssetState, IBalanceTable, IChainConfig, IChainConfig as IChainConfig$1, IChainState, IDelegateState, IEvidenceState, IExecutedContext, IForeignToken, IGetAccountStateArgs, IGetAccountTokensArgs, IIndexDB, IIndexDB as IIndexDB$1, IIndexTable, IIndexTable as IIndexTable$1, IListAccountsResult, IListAssetsResult, IListDelegationsResult, IListFactoriesResult, IListRollupBlocksResult, IListRollupValidatorsResult, IListRollupsResult, IListStakesResult, IListTokenFactoriesResult, IListTokensResult, IListTransactionsResult, IOperationContext, IPipelineLogger, IPipelineLogger as IPipelineLogger$1, IResolver, IResolverAccountState, IResolverChainInfo, IResolverContext, IResolverContext as IResolverContext$1, IResolverFactoryState, IResolverForgeStats, IResolverListAccountsResult, IResolverListAssetsResult, IResolverListDelegationsResult, IResolverListFactoriesResult, IResolverListRollupBlocksResult, IResolverListRollupValidatorsResult, IResolverListRollupsResult, IResolverListStakesResult, IResolverListTokenFactoriesResult, IResolverListTokensResult, IResolverListTransactionsResult, IResolverNetInfo, IResolverNodeInfo, IResolverPaging, IResolverPaging as IResolverPaging$1, IResolverRollupState, IResolverStakeState, IResolverTransaction, IResolverTxItxJson, IResolverValidatorsInfo, IRollupBlock, IRollupState, IRollupValidator, IStakeState, IStateContext, IStateDB, IStateDB as IStateDB$1, IStateTable, IStateTable as IStateTable$1, ITokenConfig, ITokenFactoryState, ITokenFlowsResult, ITokenInfo, ITokenInfo as ITokenInfo$1, ITokenMetadata, ITokenState, ITransactionConfig, ITxGasConfig, ITxStakeConfig, ITxState, IVaultsConfig, IndexTableTypeMap, Promisable, TAccountFilter, TAccountToken, TAddressFilter, TAssetFilter, TDelegationFilter, TFactoryFilter, TIndexedAccountState, TIndexedAssetState, TIndexedDelegationState, TIndexedFactoryState, TIndexedRollupBlock, TIndexedRollupState, TIndexedRollupValidator, TIndexedStakeState, TIndexedTokenFactoryState, TIndexedTokenState, TIndexedTokenState as TIndexedTokenState$1, TIndexedTransaction, TPage, TPageInfo, TPageOrder, TRangeFilter, TReceiptChange, TRequestEstimateGas, TRequestGetEvidenceState, TRequestGetRollupBlock, TRequestGetTokenDistribution, TRequestGetTx, TRequestListAssetTransactions, TRequestListAssets, TRequestListDelegations, TRequestListFactories, TRequestListRollupBlocks, TRequestListRollupValidators, TRequestListRollups, TRequestListStakes, TRequestListTokenFactories, TRequestListTokenFlows, TRequestListTokens, TRequestListTopAccounts, TRequestListTransactions, TRequestSearch, TRequestVerifyAccountRisk, TRollupFilter, TSearchResult, TStakeFilter, TTimeFilter, TTokenDistribution, TTokenFactoryFilter, TTokenFilter, TTokenMeta, TTransactionReceipt, TTxFilter, TTypeFilter, TValidatorFilter, TValidityFilter, TVerifyAccountRiskResult, TokenBalanceMap, ValidityMap } from "@ocap/types";
+
+//#region src/types.d.ts
+
+/**
+ * Flexible StateDB type that supports dynamic table access
+ */
+type FlexibleStateDB = IStateDB$1 & {
+  [key: string]: IStateTable$1<unknown>;
+};
+/**
+ * Flexible IndexDB type that supports dynamic table access
+ */
+type FlexibleIndexDB = IIndexDB$1 & {
+  [key: string]: IIndexTable$1<unknown> | ((...args: unknown[]) => Promise<unknown>);
+};
+/**
+ * Data object for encoded data fields (typeUrl + value)
+ */
+interface IDataObject {
+  type_url?: string;
+  typeUrl?: string;
+  value?: string;
+  type?: string;
+  [key: string]: unknown;
+}
+/**
+ * Delegation operation
+ */
+interface IDelegationOp {
+  key: string;
+  value: {
+    limit?: {
+      tokens?: ITokenInfo$1[];
+    };
+    [key: string]: unknown;
+  };
+}
+/**
+ * Chunk iterator for paginated data fetching
+ */
+interface IChunkIterator<T> {
+  next: () => Promise<T[]>;
+  done: boolean;
+}
+/**
+ * Parameters for list chunks operation
+ */
+interface IListChunksParams {
+  total: number;
+  concurrency?: number;
+  chunkSize?: number;
+  pageSize?: number;
+  timeKey: string;
+  dataKey: string;
+}
+/**
+ * Generic paginated result
+ */
+interface IPaginatedResult<T> {
+  paging?: IResolverPaging$1;
+  [key: string]: T[] | IResolverPaging$1 | unknown;
+}
+/**
+ * Filter interface for risk verification
+ */
+interface IFilter {
+  getTrustedAccountConfig?: (address: string) => Promise<ITrustedAccountConfig | null>;
+  [key: string]: any;
+}
+/**
+ * Trusted account configuration
+ */
+interface ITrustedAccountConfig {
+  tolerance?: string | number;
+  [key: string]: unknown;
+}
+/**
+ * Resolver constructor parameters
+ */
+interface IResolverParams {
+  statedb: IStateDB$1;
+  indexdb: IIndexDB$1;
+  config: IChainConfig$1;
+  filter?: IFilter;
+  validateTokenConfig?: boolean;
+  logger?: IPipelineLogger$1;
+}
+/**
+ * Get state parameters
+ */
+interface IGetStateParams {
+  table: string;
+  id: string;
+  dataKey?: string | string[] | null;
+  extraParams?: Record<string, unknown>;
+  onRead?: (state: any) => any;
+  expandContext?: boolean;
+  ctx?: IResolverContext$1;
+}
+/**
+ * Token cache interface
+ */
+interface ITokenCache {
+  get: (address: string) => Promise<TIndexedTokenState$1 | null>;
+  set: (address: string, token: TIndexedTokenState$1) => void;
+}
+/**
+ * Migration chain interface
+ */
+interface IMigrationChain {
+  findAddressAtTime: (address: string, time: Date) => string;
+}
+//#endregion
+export { type Address, type BN, type DirectionMap, FlexibleIndexDB, FlexibleStateDB, type Hash, type IAccountState, type IAddressArgs, type IAny, type IAssetFactoryState, type IAssetState, type IBalanceTable, type IChainConfig, type IChainState, IChunkIterator, IDataObject, type IDelegateState, IDelegationOp, type IEvidenceState, type IExecutedContext, IFilter, type IForeignToken, type IGetAccountStateArgs, type IGetAccountTokensArgs, IGetStateParams, type IIndexDB, type IIndexTable, type IListAccountsResult, type IListAssetsResult, IListChunksParams, type IListDelegationsResult, type IListFactoriesResult, type IListRollupBlocksResult, type IListRollupValidatorsResult, type IListRollupsResult, type IListStakesResult, type IListTokenFactoriesResult, type IListTokensResult, type IListTransactionsResult, IMigrationChain, type IOperationContext, IPaginatedResult, type IPipelineLogger, type IResolver, type IResolverAccountState, type IResolverChainInfo, type IResolverContext, type IResolverFactoryState, type IResolverForgeStats, type IResolverListAccountsResult, type IResolverListAssetsResult, type IResolverListDelegationsResult, type IResolverListFactoriesResult, type IResolverListRollupBlocksResult, type IResolverListRollupValidatorsResult, type IResolverListRollupsResult, type IResolverListStakesResult, type IResolverListTokenFactoriesResult, type IResolverListTokensResult, type IResolverListTransactionsResult, type IResolverNetInfo, type IResolverNodeInfo, type IResolverPaging, IResolverParams, type IResolverRollupState, type IResolverStakeState, type IResolverTransaction, type IResolverTxItxJson, type IResolverValidatorsInfo, type IRollupBlock, type IRollupState, type IRollupValidator, type IStakeState, type IStateContext, type IStateDB, type IStateTable, ITokenCache, type ITokenConfig, type ITokenFactoryState, type ITokenFlowsResult, type ITokenInfo, type ITokenMetadata, type ITokenState, type ITransactionConfig, ITrustedAccountConfig, type ITxGasConfig, type ITxStakeConfig, type ITxState, type IVaultsConfig, type IndexTableTypeMap, type Promisable, type TAccountFilter, type TAccountToken, type TAddressFilter, type TAssetFilter, type TDelegationFilter, type TFactoryFilter, type TIndexedAccountState, type TIndexedAssetState, type TIndexedDelegationState, type TIndexedFactoryState, type TIndexedRollupBlock, type TIndexedRollupState, type TIndexedRollupValidator, type TIndexedStakeState, type TIndexedTokenFactoryState, type TIndexedTokenState, type TIndexedTransaction, type TPage, type TPageInfo, type TPageOrder, type TRangeFilter, type TReceiptChange, type TRequestEstimateGas, type TRequestGetEvidenceState, type TRequestGetRollupBlock, type TRequestGetTokenDistribution, type TRequestGetTx, type TRequestListAssetTransactions, type TRequestListAssets, type TRequestListDelegations, type TRequestListFactories, type TRequestListRollupBlocks, type TRequestListRollupValidators, type TRequestListRollups, type TRequestListStakes, type TRequestListTokenFactories, type TRequestListTokenFlows, type TRequestListTokens, type TRequestListTopAccounts, type TRequestListTransactions, type TRequestSearch, type TRequestVerifyAccountRisk, type TRollupFilter, type TSearchResult, type TStakeFilter, type TTimeFilter, type TTokenDistribution, type TTokenFactoryFilter, type TTokenFilter, type TTokenMeta, type TTransactionReceipt, type TTxFilter, type TTypeFilter, type TValidatorFilter, type TValidityFilter, type TVerifyAccountRiskResult, type TokenBalanceMap, type ValidityMap };

package/esm/types.mjs

@@ -0,0 +1 @@
+export {  };

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

@@ -0,0 +1,54 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let _arcblock_nft_display = require("@arcblock/nft-display");
+let express = require("express");
+
+//#region src/api.ts
+function createAPIHandler({ resolver }) {
+	const router = (0, express.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 = (0, _arcblock_nft_display.getSvg)({
+			color: (0, _arcblock_nft_display.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
+exports.createAPIHandler = createAPIHandler;