@ocap/resolver 1.28.8 → 1.29.0

package/lib/index.d.cts

@@ -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.cjs";
+import { MigrationChainManager } from "./migration-chain.cjs";
+import { TokenDistributionManager } from "./token-distribution.cjs";
+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 };

package/lib/migration-chain.cjs

@@ -0,0 +1,99 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let _arcblock_did = require("@arcblock/did");
+
+//#region src/migration-chain.ts
+var MigrationNode = class {
+	constructor(address, validFrom, validUntil = null, nextAddress = null) {
+		this.address = address;
+		this.validFrom = validFrom;
+		this.validUntil = validUntil;
+		this.nextAddress = nextAddress;
+	}
+};
+var MigrationChainManager = class {
+	constructor() {
+		this.chains = /* @__PURE__ */ new Map();
+		this.rootAddresses = /* @__PURE__ */ new Map();
+	}
+	validateMigration(migration) {
+		if (!migration?.tx?.from || !migration?.tx?.itxJson?.address || !migration?.time) throw new Error("Invalid migration format");
+		if (new Date(migration.time).toString() === "Invalid Date") throw new Error("Invalid timestamp");
+		return true;
+	}
+	/**
+	* Build migration chains from a list of migration transactions
+	* @param migrations - List of migration transactions
+	*/
+	buildChains(migrations) {
+		if (!Array.isArray(migrations)) throw new Error("Migrations must be an array");
+		migrations.forEach((migration) => this.validateMigration(migration));
+		const sortedMigrations = [...migrations].sort((a, b) => new Date(a.time).getTime() - new Date(b.time).getTime());
+		for (const migration of sortedMigrations) {
+			const fromAddr = migration.tx.from;
+			const toAddr = migration.tx.itxJson.address;
+			const timestamp = new Date(migration.time);
+			this._processMigration(fromAddr, toAddr, timestamp);
+		}
+	}
+	/**
+	* Process a single migration and update the chains
+	* @param fromAddr - Source address
+	* @param toAddr - Destination address
+	* @param timestamp - Migration timestamp
+	*/
+	_processMigration(fromAddr, toAddr, timestamp) {
+		const rootAddr = this.getRootAddress(fromAddr);
+		if (!this.chains.has(rootAddr)) this.chains.set(rootAddr, []);
+		const chain = this.chains.get(rootAddr);
+		if (chain.length === 0) {
+			chain.push(new MigrationNode(fromAddr, /* @__PURE__ */ new Date(0), timestamp));
+			chain.push(new MigrationNode(toAddr, timestamp));
+		} else {
+			const lastNode = chain[chain.length - 1];
+			lastNode.validUntil = timestamp;
+			lastNode.nextAddress = toAddr;
+			chain.push(new MigrationNode(toAddr, timestamp));
+		}
+		this.rootAddresses.set(this.formatAddress(toAddr), rootAddr);
+	}
+	/**
+	* Find the valid address at a specific timestamp
+	* @param address - Address to look up
+	* @param timestamp - Timestamp to check
+	* @returns Valid address at the timestamp
+	*/
+	findAddressAtTime(address, timestamp) {
+		const chains = this.getMigrationHistory(address);
+		if (!chains?.length) return address;
+		let left = 0;
+		let right = chains.length - 1;
+		while (left <= right) {
+			const mid = Math.floor((left + right) / 2);
+			const node = chains[mid];
+			if (node.validFrom <= timestamp && (!node.validUntil || timestamp < node.validUntil)) return node.address;
+			if (timestamp < node.validFrom) right = mid - 1;
+			else left = mid + 1;
+		}
+		return chains[chains.length - 1].address;
+	}
+	formatAddress(address) {
+		return (0, _arcblock_did.isEthereumDid)(address) ? address.toLowerCase() : address;
+	}
+	getRootAddress(address) {
+		const formattedAddress = this.formatAddress(address);
+		return this.rootAddresses.get(formattedAddress) || formattedAddress;
+	}
+	/**
+	* Get the complete migration history for an address
+	* @param address - Address to look up
+	* @returns List of migration nodes
+	*/
+	getMigrationHistory(address) {
+		const rootAddr = this.getRootAddress(address);
+		return this.chains.get(rootAddr) || [];
+	}
+};
+
+//#endregion
+exports.MigrationChainManager = MigrationChainManager;
+exports.MigrationNode = MigrationNode;

package/lib/migration-chain.d.cts

@@ -0,0 +1,52 @@
+//#region src/migration-chain.d.ts
+interface Migration {
+  time: string;
+  tx: {
+    from: string;
+    itxJson: {
+      address: string;
+    };
+  };
+}
+declare class MigrationNode {
+  address: string;
+  validFrom: Date;
+  validUntil: Date | null;
+  nextAddress: string | null;
+  constructor(address: string, validFrom: Date, validUntil?: Date | null, nextAddress?: string | null);
+}
+declare class MigrationChainManager {
+  chains: Map<string, MigrationNode[]>;
+  rootAddresses: Map<string, string>;
+  constructor();
+  validateMigration(migration: Migration): boolean;
+  /**
+   * Build migration chains from a list of migration transactions
+   * @param migrations - List of migration transactions
+   */
+  buildChains(migrations: Migration[]): void;
+  /**
+   * Process a single migration and update the chains
+   * @param fromAddr - Source address
+   * @param toAddr - Destination address
+   * @param timestamp - Migration timestamp
+   */
+  private _processMigration;
+  /**
+   * Find the valid address at a specific timestamp
+   * @param address - Address to look up
+   * @param timestamp - Timestamp to check
+   * @returns Valid address at the timestamp
+   */
+  findAddressAtTime(address: string, timestamp: Date): string;
+  formatAddress(address: string): string;
+  getRootAddress(address: string): string;
+  /**
+   * Get the complete migration history for an address
+   * @param address - Address to look up
+   * @returns List of migration nodes
+   */
+  getMigrationHistory(address: string): MigrationNode[];
+}
+//#endregion
+export { MigrationChainManager, MigrationNode };

package/lib/package.cjs

@@ -0,0 +1,11 @@
+
+//#region package.json
+var name = "@ocap/resolver";
+
+//#endregion
+Object.defineProperty(exports, 'name', {
+  enumerable: true,
+  get: function () {
+    return name;
+  }
+});

package/lib/token-cache.cjs

@@ -0,0 +1,27 @@
+
+//#region src/token-cache.ts
+var Cache = class {
+	constructor(dbAdapter) {
+		this.dbAdapter = dbAdapter;
+		this.cache = /* @__PURE__ */ new Map();
+	}
+	async get(address) {
+		if (this.cache.has(address)) return this.cache.get(address);
+		const token = await this.dbAdapter.get(address);
+		if (token) this.cache.set(address, token);
+		return token;
+	}
+	set(address, token) {
+		this.cache.set(address, token);
+		return token;
+	}
+};
+let cache = null;
+function getInstance(dbAdapter) {
+	if (cache !== null) return cache;
+	cache = new Cache(dbAdapter);
+	return cache;
+}
+
+//#endregion
+exports.getInstance = getInstance;

package/lib/token-cache.d.cts

@@ -0,0 +1,20 @@
+import { TIndexedTokenState } from "./types.cjs";
+
+//#region src/token-cache.d.ts
+
+/**
+ * Token DB adapter interface for cache
+ */
+interface ITokenDBAdapter {
+  get(address: string): Promise<TIndexedTokenState | null>;
+}
+declare class Cache {
+  private dbAdapter;
+  private cache;
+  constructor(dbAdapter: ITokenDBAdapter);
+  get(address: string): Promise<TIndexedTokenState | null | undefined>;
+  set(address: string, token: TIndexedTokenState): TIndexedTokenState;
+}
+declare function getInstance(dbAdapter: ITokenDBAdapter): Cache;
+//#endregion
+export { getInstance };

package/lib/token-distribution.cjs

@@ -0,0 +1,243 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let _ocap_util = require("@ocap/util");
+let _arcblock_did = require("@arcblock/did");
+let _ocap_mcrypto = require("@ocap/mcrypto");
+let _ocap_tx_protocols_lib_util = require("@ocap/tx-protocols/lib/util");
+let lodash_omit = require("lodash/omit");
+lodash_omit = require_rolldown_runtime.__toESM(lodash_omit);
+let _ocap_indexdb_lib_util = require("@ocap/indexdb/lib/util");
+let _ocap_state_lib_states_tx = require("@ocap/state/lib/states/tx");
+
+//#region src/token-distribution.ts
+const { RoleType } = _ocap_mcrypto.types;
+const ZERO = new _ocap_util.BN(0);
+var TokenDistributionManager = class {
+	constructor(resolver) {
+		this.resolver = resolver;
+		this.indexdb = resolver.indexdb;
+		this.isProcessing = false;
+	}
+	formatDistribution(distribution) {
+		const { tokenAddress, account, gas, fee, slashedVault, stake, revokedStake, gasStake, other, txTime } = distribution;
+		return {
+			tokenAddress,
+			account: new _ocap_util.BN(account || 0),
+			gas: new _ocap_util.BN(gas || 0),
+			fee: new _ocap_util.BN(fee || 0),
+			slashedVault: new _ocap_util.BN(slashedVault || 0),
+			stake: new _ocap_util.BN(stake || 0),
+			revokedStake: new _ocap_util.BN(revokedStake || 0),
+			gasStake: new _ocap_util.BN(gasStake || 0),
+			other: new _ocap_util.BN(other || 0),
+			txTime: txTime || (/* @__PURE__ */ new Date(0)).toISOString()
+		};
+	}
+	async getDistribution(tokenAddress) {
+		const data = await this.indexdb.tokenDistribution.get(tokenAddress);
+		return data && (0, _ocap_indexdb_lib_util.createIndexedTokenDistribution)(data);
+	}
+	async saveDistribution(distribution, isEnsureLatest = true) {
+		const data = (0, _ocap_indexdb_lib_util.createIndexedTokenDistribution)(distribution);
+		const indexdbDistribution = await this.getDistribution(data.tokenAddress);
+		if (!indexdbDistribution) await this.indexdb.tokenDistribution.insert(data);
+		else {
+			if (isEnsureLatest) {
+				const latestTime = Math.max(new Date(indexdbDistribution.txTime).getTime(), new Date(data.txTime).getTime());
+				data.txTime = new Date(latestTime).toISOString();
+			}
+			await this.indexdb.tokenDistribution.update(data.tokenAddress, data);
+		}
+		return data;
+	}
+	/**
+	* Calculate token distribution based on all transaction data.
+	* This method is usually used to update historical token distribution data
+	*
+	* @param tokenAddress Token address
+	* @param force If force is false, only calculate distributions for new transactions after txTime in indexdb. default is false
+	* @returns The updated token distribution or null if failed
+	*/
+	async updateByToken(tokenAddress, force) {
+		const { logger, config } = this.resolver;
+		if (this.isProcessing) {
+			logger?.debug?.("Token distribution is already in progress", {
+				tokenAddress,
+				force
+			});
+			return;
+		}
+		const distribution = force ? this.formatDistribution({ tokenAddress }) : this.formatDistribution(await this.getDistribution(tokenAddress) || { tokenAddress });
+		const isDefaultToken = tokenAddress === config.token.address;
+		logger?.info(`Update distribution by token (${tokenAddress})`, { distribution: (0, _ocap_indexdb_lib_util.createIndexedTokenDistribution)(distribution) });
+		this.isProcessing = true;
+		try {
+			if (force && isDefaultToken) this.handleModerator(distribution);
+			const { next } = await this.resolver.listTransactionsChunks({
+				timeFilter: { startDateTime: distribution.txTime },
+				tokenFilter: isDefaultToken ? {} : { tokenFilter: { tokens: [tokenAddress] } }
+			});
+			let nextData = await next();
+			while (nextData.length) {
+				logger?.info("Updating token distribution in chunks", {
+					chunkSize: nextData.length,
+					startTime: nextData[0].time,
+					startHash: nextData[0].hash,
+					endTime: nextData[nextData.length - 1].time
+				});
+				const handlePromises = nextData.map((tx) => this.handleTx(tx, distribution));
+				await Promise.all(handlePromises);
+				await this.saveDistribution(distribution, false);
+				nextData = await next();
+			}
+			await this.splitStake(distribution);
+			await this.saveDistribution(distribution, false);
+			const result = (0, _ocap_indexdb_lib_util.createIndexedTokenDistribution)(distribution);
+			logger?.info(`Token distribution update completed (${tokenAddress})`, { distribution: result });
+			return result;
+		} catch (e) {
+			logger?.error("Token distribution update failed", { error: e });
+			return null;
+		} finally {
+			this.isProcessing = false;
+		}
+	}
+	/**
+	* Split out revokedStake / gasStake from stake
+	*
+	* @param distribution The distribution object to update
+	* @returns The updated distribution
+	*/
+	async splitStake(distribution) {
+		const { logger } = this.resolver;
+		const { tokenAddress } = distribution;
+		const { next } = await this.resolver.listStakeChunks();
+		let nextData = await next();
+		while (nextData.length) {
+			logger?.info("Updating stake distribution in chunks", {
+				chunkSize: nextData.length,
+				startTime: nextData[0].renaissanceTime,
+				startAddress: nextData[0].address,
+				endTime: nextData[nextData.length - 1].renaissanceTime
+			});
+			nextData.forEach((stakeState) => {
+				const isGasStake = this.isGasStake(stakeState);
+				const token = stakeState.tokens.find((x) => x.address === tokenAddress);
+				const revokedBalance = new _ocap_util.BN(stakeState.revokedTokens.find((x) => x.address === tokenAddress)?.balance || 0);
+				const balance = new _ocap_util.BN(token?.balance || 0);
+				distribution.revokedStake = distribution.revokedStake.add(revokedBalance);
+				distribution.stake = distribution.stake.sub(revokedBalance);
+				if (isGasStake) {
+					distribution.gasStake = distribution.gasStake.add(balance);
+					distribution.stake = distribution.stake.sub(balance);
+				}
+			});
+			nextData = await next();
+		}
+		return distribution;
+	}
+	/**
+	* Update token distribution by a single transaction.
+	* This method is usually used when a tx is completed.
+	*
+	* @param tx The transaction object
+	* @param context The transaction context
+	* @returns The updated token distributions
+	*/
+	async updateByTx(tx, context) {
+		const { logger } = this.resolver;
+		const ctx = (0, lodash_omit.default)(context, "txn");
+		if (this.isProcessing) {
+			logger?.debug?.("Token distribution is already in progress", { tx });
+			return;
+		}
+		const tokens = (await this.resolver.formatTx(tx)).tokenSymbols.map(({ address }) => address);
+		return await Promise.all(tokens.map(async (tokenAddress) => {
+			const distribution = this.formatDistribution(await this.getDistribution(tokenAddress) || { tokenAddress });
+			await this.handleTx(tx, distribution, {
+				context: ctx,
+				isHandleStake: true
+			});
+			return await this.saveDistribution(distribution);
+		}));
+	}
+	/**
+	* Parse token distribution for a single transaction
+	* @param tx The transaction
+	* @param distribution The distribution to update
+	* @param options Handle options
+	* @returns The updated token distribution
+	*/
+	async handleTx(tx, distribution, { context, isHandleStake = false } = {}) {
+		if (isHandleStake && !context) throw new Error("context is missing, handle revoke stake is not supported without context");
+		const type = tx.tx?.itxJson?._type;
+		const receipts = tx.receipts || [];
+		const { tokenAddress } = distribution;
+		const handlePromises = (0, _ocap_state_lib_states_tx.eachReceipts)(receipts, async (address, change) => {
+			if (!(0, _ocap_util.isSameDid)(change.target, tokenAddress)) return;
+			if (change.action === "migrate") return;
+			const roleType = (0, _arcblock_did.toTypeInfo)(address).role;
+			const value = new _ocap_util.BN(change.value);
+			if (roleType === RoleType.ROLE_STAKE) {
+				if (isHandleStake) {
+					const stakeState = await this.getStakeState(address, context);
+					const isGasStakeResult = this.isGasStake(stakeState);
+					if (type === "ClaimStakeTx") {
+						distribution.revokedStake = distribution.revokedStake.add(value);
+						return;
+					}
+					if (type === "SlashStakeTx") {
+						const beforeState = context.stateSnapshot[address];
+						const afterState = context.stakeState;
+						if (!beforeState || !afterState) throw new Error("stake state is missing on slash stake tx");
+						const revokeTokenDiff = new _ocap_util.BN(beforeState.revokedTokens[tokenAddress]).sub(new _ocap_util.BN(afterState.revokedTokens[tokenAddress]));
+						const tokenDiff = new _ocap_util.BN(beforeState.tokens[tokenAddress]).sub(new _ocap_util.BN(afterState.tokens[tokenAddress]));
+						distribution.revokedStake = distribution.revokedStake.sub(revokeTokenDiff);
+						if (isGasStakeResult) distribution.gasStake = distribution.gasStake.sub(tokenDiff);
+						else distribution.stake = distribution.stake.sub(tokenDiff);
+						return;
+					}
+					if (isGasStakeResult) {
+						distribution.gasStake = distribution.gasStake.add(value);
+						return;
+					}
+				}
+				distribution.stake = distribution.stake.add(value);
+			} else if (change.action === "gas" && value.gt(ZERO)) distribution.gas = distribution.gas.add(value);
+			else if (change.action === "fee" && value.gt(ZERO)) distribution.fee = distribution.fee.add(value);
+			else if (type === "SlashStakeTx" && value.gt(ZERO) && (0, _ocap_util.isSameDid)(address, this.resolver.config.vaults.slashedStake ?? "")) distribution.slashedVault = distribution.slashedVault.add(value);
+			else distribution.account = distribution.account.add(value);
+		});
+		await Promise.all(handlePromises);
+		if (isHandleStake && type === "RevokeStakeTx") {
+			const { address } = tx.tx.itxJson;
+			const stakeState = await this.getStakeState(address, context);
+			const isGasStakeResult = this.isGasStake(stakeState);
+			tx.tx.itxJson.outputs.forEach((x) => {
+				x.tokens.filter((change) => (0, _ocap_util.isSameDid)(change.address, tokenAddress)).forEach((change) => {
+					const value = new _ocap_util.BN(change.value || change.balance || 0);
+					distribution.revokedStake = distribution.revokedStake.add(value);
+					if (isGasStakeResult) distribution.gasStake = distribution.gasStake.sub(value);
+					else distribution.stake = distribution.stake.sub(value);
+				});
+			});
+		}
+		distribution.txTime = tx.time;
+		return distribution;
+	}
+	handleModerator(distribution) {
+		const { config } = this.resolver;
+		if (distribution.tokenAddress !== config.token.address) return distribution;
+		const value = config.accounts.filter((account) => Number(account.balance) > 0).map((account) => new _ocap_util.BN(account.balance)).reduce((cur, balance) => cur.add(balance), ZERO);
+		distribution.account = distribution.account.add((0, _ocap_util.fromTokenToUnit)(value.toString()));
+		return distribution;
+	}
+	async getStakeState(address, ctx) {
+		return await this.resolver.statedb.stake.get(address, ctx);
+	}
+	isGasStake(stakeState) {
+		return (0, _ocap_tx_protocols_lib_util.isGasStakeAddress)(stakeState.sender, stakeState.address) && stakeState.message === "stake-for-gas";
+	}
+};
+
+//#endregion
+exports.TokenDistributionManager = TokenDistributionManager;