@ocap/resolver 1.28.8 → 1.29.0

package/lib/index.cjs

@@ -0,0 +1,1343 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_package = require('./package.cjs');
+const require_hooks = require('./hooks.cjs');
+const require_migration_chain = require('./migration-chain.cjs');
+const require_token_cache = require('./token-cache.cjs');
+const require_token_distribution = require('./token-distribution.cjs');
+const require_token_flow = require('./token-flow.cjs');
+let _arcblock_did_util = require("@arcblock/did-util");
+let _ocap_util = require("@ocap/util");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let lodash_pick = require("lodash/pick");
+lodash_pick = require_rolldown_runtime.__toESM(lodash_pick);
+let _arcblock_did = require("@arcblock/did");
+let _arcblock_validator = require("@arcblock/validator");
+let _ocap_config = require("@ocap/config");
+_ocap_config = require_rolldown_runtime.__toESM(_ocap_config);
+let _ocap_mcrypto = require("@ocap/mcrypto");
+let _ocap_message = require("@ocap/message");
+let _ocap_state = require("@ocap/state");
+_ocap_state = require_rolldown_runtime.__toESM(_ocap_state);
+let _ocap_tx_protocols = require("@ocap/tx-protocols");
+let _ocap_tx_protocols_lib_util = require("@ocap/tx-protocols/lib/util");
+let _ocap_util_lib_constant = require("@ocap/util/lib/constant");
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let _ocap_util_lib_md5 = require("@ocap/util/lib/md5");
+let lodash_get = require("lodash/get");
+lodash_get = require_rolldown_runtime.__toESM(lodash_get);
+let lodash_isEmpty = require("lodash/isEmpty");
+lodash_isEmpty = require_rolldown_runtime.__toESM(lodash_isEmpty);
+let lodash_isEqual = require("lodash/isEqual");
+lodash_isEqual = require_rolldown_runtime.__toESM(lodash_isEqual);
+let lodash_omit = require("lodash/omit");
+lodash_omit = require_rolldown_runtime.__toESM(lodash_omit);
+let lodash_set = require("lodash/set");
+lodash_set = require_rolldown_runtime.__toESM(lodash_set);
+let lodash_unionBy = require("lodash/unionBy");
+lodash_unionBy = require_rolldown_runtime.__toESM(lodash_unionBy);
+let lodash_uniq = require("lodash/uniq");
+lodash_uniq = require_rolldown_runtime.__toESM(lodash_uniq);
+let queue = require("queue");
+queue = require_rolldown_runtime.__toESM(queue);
+let _ocap_indexdb_lib_util = require("@ocap/indexdb/lib/util");
+let _ocap_state_lib_states_tx = require("@ocap/state/lib/states/tx");
+
+//#region src/index.ts
+const debug$1 = (0, debug.default)(require_package.name);
+const noop = (x) => x;
+const CHAIN_ADDR = (0, _ocap_util_lib_md5.md5)("OCAP_CHAIN_ADDR");
+const maxGasOps = {
+	"fg:t:account_migrate": {
+		create: 2,
+		update: 1
+	},
+	"fg:t:delegate": {
+		create: 3,
+		update: 1
+	},
+	"fg:t:revoke_delegate": {
+		create: 1,
+		update: 2
+	},
+	"fg:t:create_asset": {
+		create: 2,
+		update: 2
+	},
+	"fg:t:update_asset": {
+		create: 1,
+		update: 2
+	},
+	"fg:t:consume_asset": {
+		create: 1,
+		update: 2
+	},
+	"fg:t:create_factory": {
+		create: 2,
+		update: 2
+	},
+	"fg:t:acquire_asset_v2": {
+		create: 2,
+		update: 12
+	},
+	"fg:t:acquire_asset_v3": {
+		create: 3,
+		update: 12
+	},
+	"fg:t:mint_asset": {
+		create: 3,
+		update: 10
+	},
+	"fg:t:create_token": {
+		create: 2,
+		update: 3
+	},
+	"fg:t:deposit_token_v2": {
+		create: 3,
+		update: 3
+	},
+	"fg:t:withdraw_token_v2": {
+		create: 2,
+		update: 3
+	},
+	"fg:t:stake": {
+		create: 2,
+		update: 18
+	},
+	"fg:t:revoke_stake": {
+		create: 1,
+		update: 2
+	},
+	"fg:t:claim_stake": {
+		create: 2,
+		update: 18
+	},
+	"fg:t:slash_stake": { update: 18 },
+	"fg:t:return_stake": { update: 8 },
+	"fg:t:transfer": {
+		create: 2,
+		update: 20
+	},
+	"fg:t:transfer_v2": {
+		create: 2,
+		update: 20
+	},
+	"fg:t:transfer_v3": {
+		create: 9,
+		update: 16
+	},
+	"fg:t:exchange_v2": {
+		create: 1,
+		update: 18
+	},
+	"fg:t:create_token_factory": {
+		create: 2,
+		update: 3
+	},
+	"fg:t:update_token_factory": {
+		create: 0,
+		update: 3
+	},
+	"fg:t:mint_token": {
+		create: 2,
+		update: 13
+	},
+	"fg:t:burn_token": {
+		create: 2,
+		update: 13
+	},
+	"fg:t:create_rollup": {
+		create: 2,
+		update: 2
+	},
+	"fg:t:update_rollup": {
+		create: 1,
+		update: 2
+	},
+	"fg:t:pause_rollup": {
+		create: 1,
+		update: 2
+	},
+	"fg:t:close_rollup": {
+		create: 1,
+		update: 26
+	},
+	"fg:t:resume_rollup": {
+		create: 1,
+		update: 2
+	},
+	"fg:t:join_rollup": {
+		create: 2,
+		update: 3
+	},
+	"fg:t:leave_rollup": {
+		create: 2,
+		update: 3
+	},
+	"fg:t:migrate_rollup": {
+		create: 1,
+		update: 2
+	},
+	"fg:t:create_rollup_block": {
+		create: 2,
+		update: 38
+	},
+	"fg:t:claim_block_reward": {
+		create: 2,
+		update: 38
+	}
+};
+const txRequestConfig = {
+	maxRequest: Number(process.env.TX_MAX_REQUEST) || 200,
+	concurrent: Number(process.env.TX_CONCURRENCY) || 10,
+	timeout: Number(process.env.TX_TIMEOUT) || 1e3 * 30
+};
+const formatData = (data) => {
+	if (!data) return data;
+	if (data.type_url) return data;
+	if (data.typeUrl && ["json", "vc"].includes(data.typeUrl)) try {
+		JSON.parse(data.value);
+		data.type_url = data.typeUrl;
+		return data;
+	} catch (_err) {
+		try {
+			JSON.parse(data.value.replace(/\\"/g, "\""));
+			data.type_url = data.typeUrl;
+			data.value = data.value.replace(/\\"/g, "\"");
+			return data;
+		} catch (_e) {}
+	}
+	const decoded = data.typeUrl ? (0, _ocap_tx_protocols_lib_util.decodeAnySafe)(data) : data;
+	if (!decoded) return {
+		typeUrl: "",
+		type_url: "",
+		value: ""
+	};
+	if ([
+		"json",
+		"vc",
+		"AssetFactory"
+	].includes(decoded.type)) return {
+		typeUrl: decoded.type,
+		type_url: decoded.type,
+		value: JSON.stringify(decoded.value)
+	};
+	return {
+		typeUrl: decoded.type,
+		type_url: decoded.type,
+		value: decoded.value
+	};
+};
+const formatDelegationOps = (state) => {
+	if (state?.ops && typeof state.ops === "object" && !Array.isArray(state.ops)) {
+		const opsRecord = state.ops;
+		state.ops = Object.keys(opsRecord).map((x) => ({
+			key: x,
+			value: opsRecord[x]
+		}));
+	}
+	return state;
+};
+const extractTokenMeta = (address, tokenStates) => {
+	const tokenState = tokenStates.filter(Boolean).find((t) => t.address === address);
+	if (!tokenState) return {};
+	return {
+		address,
+		decimal: typeof tokenState.decimal === "undefined" ? _ocap_util_lib_constant.DEFAULT_TOKEN_DECIMAL : tokenState.decimal,
+		unit: tokenState.unit,
+		symbol: tokenState.symbol,
+		foreignToken: tokenState.foreignToken
+	};
+};
+var OCAPResolver = class {
+	/**
+	* 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 = true, logger }) {
+		if (!statedb) throw new Error("OCAP Resolver requires a valid statedb implementation to work");
+		if (!indexdb) throw new Error("OCAP Resolver requires a valid indexdb implementation to work");
+		this.logger = logger || console;
+		this.statedb = statedb;
+		this.indexdb = indexdb;
+		this.filter = filter;
+		this.config = Object.freeze(_ocap_config.validate(config));
+		this.chainAddr = (0, _ocap_util_lib_md5.md5)(config.chainId);
+		this.tokenItx = _ocap_config.genTokenItx(this.config);
+		this.consensus = `${statedb.name} v${statedb.version}`;
+		this.queue = new queue.default({
+			autostart: true,
+			concurrency: txRequestConfig.concurrent,
+			timeout: txRequestConfig.timeout
+		});
+		if (indexdb) {
+			this.tokenCache = require_token_cache.getInstance(indexdb.token);
+			this.tokenDistribution = new require_token_distribution.TokenDistributionManager(this);
+		}
+		if (this.tokenItx) {
+			this.config.token.address = this.tokenItx.address;
+			if (this.tokenCache) this.tokenCache.set(this.tokenItx.address, this.tokenItx);
+		}
+		this.executor = (0, _ocap_tx_protocols.createExecutor)({
+			filter,
+			runAsLambda: typeof statedb.runAsLambda === "function" ? statedb.runAsLambda.bind(statedb) : void 0
+		});
+		this.formatTx = this._formatTx.bind(this);
+		if (validateTokenConfig) this.validateTokenConfig();
+		this.connectIndexDB();
+		this.initializeStateDB().catch((err) => {
+			this.logger.error("Failed to initialize statedb:", err.message);
+			process.exit(1);
+		});
+	}
+	sendTx({ tx: txBase64, extra }, ctx = {}) {
+		debug$1("sendTx", {
+			txBase64,
+			request: ctx.request
+		});
+		if (process.env.CHAIN_MODE === "readonly") throw new _ocap_util_lib_error.CustomError("FORBIDDEN", "This chain node is running in readonly mode");
+		if (this.queue.length >= txRequestConfig.maxRequest) throw new _ocap_util_lib_error.CustomError("FORBIDDEN", "Chain is busy");
+		const context = {
+			txBase64,
+			statedb: this.statedb,
+			indexdb: this.indexdb,
+			config: this.config,
+			filter: this.filter,
+			logger: this.logger,
+			extra: {
+				...ctx,
+				txExtra: extra
+			}
+		};
+		return new Promise((resolve, reject) => {
+			const task = async () => {
+				try {
+					resolve((await this.executor.execute(context)).txHash);
+				} catch (err) {
+					reject(err);
+				}
+			};
+			this.queue.push(task);
+		});
+	}
+	getTx({ hash }, ctx) {
+		if (_arcblock_validator.patterns.txHash.test(hash)) return this._getState({
+			table: "tx",
+			id: hash.toUpperCase(),
+			dataKey: "tx.itxJson.data",
+			onRead: (tx) => this.formatTx(tx, ctx),
+			expandContext: false,
+			ctx
+		});
+		return Promise.resolve(null);
+	}
+	getBlock() {
+		return null;
+	}
+	getBlocks() {
+		return [];
+	}
+	getUnconfirmedTxs() {
+		return [];
+	}
+	async getChainInfo() {
+		return {
+			id: this.chainAddr,
+			totalTxs: await this.indexdb.tx.count(),
+			blockHash: (0, _ocap_util_lib_md5.md5)(""),
+			blockHeight: 0,
+			blockTime: "",
+			version: this.config.version,
+			address: this.chainAddr,
+			appHash: (0, _ocap_util_lib_md5.md5)((/* @__PURE__ */ new Date()).toISOString()),
+			consensusVersion: this.consensus,
+			forgeAppsVersion: [],
+			moniker: this.config.chainId,
+			network: this.config.chainId,
+			supportedTxs: this.config.transaction.supportedTxs,
+			synced: true,
+			votingPower: "10"
+		};
+	}
+	getNodeInfo() {
+		return Promise.resolve({
+			address: this.chainAddr,
+			appHash: (0, _ocap_util_lib_md5.md5)((/* @__PURE__ */ new Date()).toISOString()),
+			consensusVersion: this.consensus,
+			forgeAppsVersion: [],
+			geoInfo: {
+				city: "Unknown",
+				country: "Unknown",
+				latitude: 0,
+				longitude: 0
+			},
+			id: this.chainAddr,
+			ip: "",
+			moniker: this.config.chainId,
+			network: this.config.chainId,
+			p2pAddress: "",
+			supportedTxs: this.config.transaction.supportedTxs,
+			synced: true,
+			votingPower: "10"
+		});
+	}
+	getNetInfo() {
+		return Promise.resolve({
+			listeners: [],
+			listening: true,
+			nPeers: 0,
+			peers: []
+		});
+	}
+	getValidatorsInfo() {
+		return Promise.resolve({
+			blockHeight: 0,
+			validators: [{
+				address: (0, _arcblock_did.fromPublicKey)(this.chainAddr),
+				name: "",
+				proposerPriority: "0",
+				votingPower: "10"
+			}]
+		});
+	}
+	getConfig() {
+		return JSON.stringify(this.config);
+	}
+	getAccountState({ address, traceMigration = true, expandContext = true }, ctx) {
+		return this._getState({
+			table: "account",
+			id: address,
+			dataKey: "data",
+			extraParams: { traceMigration },
+			expandContext,
+			onRead: async (state) => {
+				if (state) {
+					if (state.tokens) state.tokens = await this.formatTokenMap(state.tokens);
+				}
+				return state;
+			},
+			ctx
+		});
+	}
+	getStakeState({ address }, ctx) {
+		return this._getState({
+			table: "stake",
+			id: address,
+			dataKey: "data",
+			onRead: async (state) => {
+				if (state) {
+					if (state.tokens) state.tokens = await this.formatTokenMap(state.tokens);
+					if (state.revokedTokens) state.revokedTokens = await this.formatTokenMap(state.revokedTokens);
+				}
+				return state;
+			},
+			ctx
+		});
+	}
+	async getRollupState({ address }, ctx) {
+		const rollup = await this._getState({
+			table: "rollup",
+			id: address,
+			dataKey: "data",
+			onRead: async (state) => {
+				if (state) {
+					state.tokenInfo = (await this.formatTokenMap({ [state.tokenAddress]: "0" })).find((x) => x.address === state.tokenAddress);
+					state.foreignToken = state.tokenInfo?.foreignToken;
+				}
+				return state;
+			},
+			ctx
+		});
+		if (!rollup) return null;
+		const indexed = await this.indexdb.rollup.get(address);
+		if (indexed) {
+			rollup.totalDepositAmount = indexed.totalDepositAmount || "0";
+			rollup.totalWithdrawAmount = indexed.totalWithdrawAmount || "0";
+		}
+		return rollup;
+	}
+	async getRollupBlock({ hash, height, rollupAddress }, ctx) {
+		if (hash) return this._getState({
+			table: "rollupBlock",
+			id: hash,
+			dataKey: "data",
+			ctx
+		});
+		const blockHeight = Number(height || 0);
+		if (blockHeight > 0 && rollupAddress) {
+			const { blocks } = await this._doPaginatedSearch("listRollupBlocks", {
+				height: blockHeight,
+				rollupAddress
+			}, "blocks", "data", ctx);
+			if (blocks.length) return this._getState({
+				table: "rollupBlock",
+				id: blocks[0].hash,
+				dataKey: "data",
+				ctx
+			});
+			return null;
+		}
+		throw new Error("Can not get rollup block without hash or height + rollup");
+	}
+	getAssetState({ address }, ctx) {
+		return this._getState({
+			table: "asset",
+			id: address,
+			dataKey: "data",
+			onRead: (state) => {
+				if (state && Array.isArray(state.tagsList)) state.tags = state.tagsList;
+				return state;
+			},
+			ctx
+		});
+	}
+	getEvidenceState({ hash }, ctx) {
+		return this._getState({
+			table: "evidence",
+			id: hash,
+			dataKey: null,
+			ctx
+		});
+	}
+	getFactoryState({ address }, ctx) {
+		return this._getState({
+			table: "factory",
+			id: address,
+			dataKey: "data",
+			onRead: async (state) => {
+				if (state) {
+					state.tokens = await this.formatTokenMap(state.tokens || {});
+					const input = state.input;
+					if (Array.isArray(input?.tokens) && input.tokens.length > 0) input.tokens = await this.formatTokenArray(input.tokens || []);
+					const output = state.output;
+					if (output) output.data = formatData(output.data);
+				}
+				return state;
+			},
+			ctx
+		});
+	}
+	async getTokenState({ address }, ctx) {
+		const state = await this._getState({
+			table: "token",
+			id: address,
+			dataKey: "data",
+			ctx
+		});
+		if (state) {
+			if (typeof state.decimal === "undefined") state.decimal = _ocap_util_lib_constant.DEFAULT_TOKEN_DECIMAL;
+			if (state.metadata) state.metadata = formatData(state.metadata);
+		}
+		return state;
+	}
+	getTokenFactoryState(args, ctx) {
+		return this._getState({
+			table: "tokenFactory",
+			id: args.address,
+			dataKey: "data",
+			ctx,
+			onRead: async (state) => {
+				if (state) {
+					const [token, reserveToken] = await Promise.all([this.getTokenState({ address: state.tokenAddress }), this.getTokenState({ address: state.reserveAddress })]);
+					state.token = {
+						...token,
+						metadata: formatData(token?.metadata)
+					};
+					state.reserveToken = {
+						...reserveToken,
+						metadata: formatData(reserveToken?.metadata)
+					};
+				}
+				return state;
+			}
+		});
+	}
+	getDelegateState({ address }, ctx) {
+		return this._getState({
+			table: "delegation",
+			id: address,
+			dataKey: "data",
+			onRead: async (state) => {
+				if (state) {
+					formatDelegationOps(state);
+					await this.formatDelegateState(state);
+				}
+				return state;
+			},
+			ctx
+		});
+	}
+	async getAccountTokens({ address, token }, ctx) {
+		if (!address) return [];
+		let state = null;
+		if ((0, _arcblock_did.toTypeInfo)(address).role === _ocap_mcrypto.types.RoleType.ROLE_ASSET) state = await this._getState({
+			table: "factory",
+			id: address,
+			dataKey: "data",
+			expandContext: false,
+			ctx
+		});
+		else state = await this._getState({
+			table: "account",
+			id: address,
+			dataKey: "data",
+			expandContext: false,
+			ctx
+		});
+		if (!state || !state.tokens) return [];
+		const allTokens = Object.keys(state.tokens);
+		const wantedTokens = token ? allTokens.filter((x) => x === token) : allTokens;
+		const tokensInfo = (await Promise.all(wantedTokens.map((x) => this._getState({
+			table: "token",
+			id: x,
+			dataKey: "data",
+			expandContext: false,
+			ctx
+		})))).reduce((acc, x) => {
+			acc[x.address] = {
+				symbol: x.symbol,
+				decimal: x.decimal || _ocap_util_lib_constant.DEFAULT_TOKEN_DECIMAL,
+				unit: x.unit
+			};
+			return acc;
+		}, {});
+		return wantedTokens.map((x) => ({
+			address: x,
+			...tokensInfo[x],
+			balance: state.tokens[x]
+		}));
+	}
+	getForgeState() {
+		const { accounts, token, transaction, vaults } = this.config;
+		return Promise.resolve({
+			accountConfig: accounts,
+			address: "forge_state",
+			consensus: {
+				maxBytes: "150000",
+				maxCandidates: 256,
+				maxGas: "-1",
+				maxValidators: 64,
+				paramChanged: false,
+				validatorChanged: false
+			},
+			data: null,
+			tasks: [],
+			token,
+			vaults,
+			txConfig: {
+				...transaction,
+				txGas: {
+					...transaction.txGas,
+					minStake: (0, _ocap_util.fromTokenToUnit)(transaction.txGas.minStake, token.decimal).toString(10),
+					maxStake: (0, _ocap_util.fromTokenToUnit)(transaction.txGas.maxStake, token.decimal).toString(10)
+				},
+				txStake: {
+					...transaction.txStake,
+					createToken: (0, _ocap_util.fromTokenToUnit)(transaction.txStake.createToken, token.decimal).toString(10),
+					createCreditToken: (0, _ocap_util.fromTokenToUnit)(transaction.txStake.createCreditToken, token.decimal).toString(10)
+				},
+				txFee: Object.keys(transaction.txFee).filter((x) => x !== "default").map((x) => ({
+					typeUrl: x,
+					fee: (0, _ocap_util.fromTokenToUnit)(transaction.txFee[x], token.decimal).toString(10)
+				}))
+			},
+			upgradeInfo: null,
+			reservedSymbols: this.config.reservedSymbols
+		});
+	}
+	async getForgeStats() {
+		const [accountCount, assetCount, txCount] = await Promise.all([
+			this.indexdb.account.count(),
+			this.indexdb.asset.count(),
+			this.indexdb.tx.count()
+		]);
+		return {
+			avgBlockTime: 1,
+			avgTps: 0,
+			maxTps: 0,
+			numAccountMigrateTxs: ["0"],
+			numBlocks: [txCount],
+			numConsensusUpgradeTxs: [0],
+			numConsumeAssetTxs: ["0"],
+			numCreateAssetTxs: [assetCount],
+			numDeclareFileTxs: ["0"],
+			numDeclareTxs: [accountCount],
+			numExchangeTxs: ["0"],
+			numPokeTxs: ["0"],
+			numStakeTxs: ["0"],
+			numStakes: ["0"],
+			numSysUpgradeTxs: [0],
+			numTransferTxs: ["0"],
+			numTxs: [txCount],
+			numUpdateAssetTxs: ["0"],
+			numValidators: [1],
+			tps: [0]
+		};
+	}
+	async listTransactions(args = {}, ctx) {
+		return await this._doPaginatedSearch("listTransactions", args, "transactions", "tx.itxJson.data", ctx);
+	}
+	listAssets(args = {}, ctx) {
+		return this._doPaginatedSearch("listAssets", args, "assets", "data", ctx);
+	}
+	listAssetTransactions(args = {}, ctx = {}) {
+		if (!args.address) return Promise.resolve({ transactions: [] });
+		return this._doPaginatedSearch("listTransactions", {
+			...args,
+			assetFilter: { assets: [args.address] }
+		}, "transactions", "tx.itxJson.data", ctx);
+	}
+	async listFactories(args = {}, ctx) {
+		const result = await this._doPaginatedSearch("listFactories", args, "factories", "data", ctx);
+		result.factories = result.factories.map((x) => {
+			const output = x.output;
+			if (output) output.data = formatData(output.data);
+			return x;
+		});
+		return result;
+	}
+	listTopAccounts(args = {}) {
+		if (!args.tokenAddress) args.tokenAddress = this.tokenItx.address;
+		return this._doPaginatedSearch("listTopAccounts", args, "accounts");
+	}
+	listTokens(args = {}, ctx) {
+		return this._doPaginatedSearch("listTokens", args, "tokens", ["data", "metadata"], ctx);
+	}
+	listTokenFactories(args = {}, ctx) {
+		return this._doPaginatedSearch("listTokenFactories", args, "tokenFactories", "data", ctx);
+	}
+	listStakes(args = {}, ctx) {
+		return this._doPaginatedSearch("listStakes", args, "stakes", "data", ctx);
+	}
+	listRollups(args = {}, ctx) {
+		return this._doPaginatedSearch("listRollups", args, "rollups", "data", ctx);
+	}
+	listRollupBlocks(args = {}, ctx) {
+		return this._doPaginatedSearch("listRollupBlocks", args, "blocks", "data", ctx);
+	}
+	async listRollupValidators(args = {}, ctx) {
+		if (!args.rollupAddress) return { validators: [] };
+		const rollup = await this.statedb.rollup.get(args.rollupAddress);
+		if (!rollup) return { validators: [] };
+		const result = await this._doPaginatedSearch("listRollupValidators", args, "validators", null, ctx);
+		const stakes = (await Promise.all(result.validators.map((x) => {
+			const stakeAddress = (0, _arcblock_did_util.toStakeAddress)(x.address, args.rollupAddress);
+			return this.statedb.stake.get(stakeAddress);
+		}))).filter(Boolean);
+		result.validators.forEach((x) => {
+			const stakeAddress = (0, _arcblock_did_util.toStakeAddress)(x.address, args.rollupAddress);
+			const stake = stakes.find((s) => s.address === stakeAddress);
+			x.availableStake = stake ? stake.tokens[rollup.tokenAddress] : "0";
+		});
+		return result;
+	}
+	listDelegations(args = {}, ctx) {
+		return this._doPaginatedSearch("listDelegations", args, "delegations", "data", ctx);
+	}
+	verifyAccountRisk(args = {}, ctx) {
+		if (process.env.TOKEN_FLOW_ENABLED === "true") return require_token_flow.verifyAccountRisk({
+			...args,
+			tokenAddress: (0, _ocap_util.toAddress)(args.tokenAddress || this.config.token.address),
+			accountAddress: (0, _ocap_util.toAddress)(args.accountAddress || ""),
+			accountLimit: Number(process.env.VERIFY_RISK_ACCOUNT_LIMIT) || void 0,
+			txLimit: Number(process.env.VERIFY_RISK_TX_LIMIT) || void 0,
+			tolerance: process.env.VERIFY_RISK_TOLERANCE || void 0
+		}, this, ctx);
+		return null;
+	}
+	listTokenFlows(args = {}, ctx) {
+		if (process.env.TOKEN_FLOW_ENABLED === "true") return require_token_flow.listTokenFlows(args, this, ctx);
+		return [];
+	}
+	async search(args) {
+		if (!args.keyword) return { results: [] };
+		const doSearch = async (type, keyword) => {
+			return await this.indexdb[type].get(keyword) ? {
+				type,
+				id: keyword
+			} : null;
+		};
+		if (_arcblock_validator.patterns.txHash.test(args.keyword)) return { results: (await Promise.all([doSearch("tx", args.keyword.toUpperCase()), doSearch("rollupBlock", args.keyword)])).filter(Boolean) };
+		const entitiesByDid = [
+			"account",
+			"asset",
+			"delegation",
+			"factory",
+			"token",
+			"stake",
+			"rollup",
+			"tokenFactory"
+		];
+		if ((0, _arcblock_did.isValid)(args.keyword)) {
+			const keyword = (0, _ocap_util.toAddress)(args.keyword);
+			return { results: (await Promise.all(entitiesByDid.map((type) => doSearch(type, keyword)))).filter(Boolean) };
+		}
+		return { results: [] };
+	}
+	estimateGas(args = {}) {
+		const { typeUrl = "" } = args;
+		if (!typeUrl || !maxGasOps[typeUrl]) throw new _ocap_util_lib_error.CustomError("INVALID_REQUEST", "Unknown tx typeUrl");
+		const { txGas, maxTxSize } = this.config.transaction;
+		const estimate = maxGasOps[args.typeUrl];
+		let totalGas = new _ocap_util.BN(txGas.price).mul(new _ocap_util.BN(txGas.dataStorage)).mul(new _ocap_util.BN(maxTxSize[args.typeUrl]));
+		totalGas = totalGas.add(new _ocap_util.BN(txGas.price).mul(new _ocap_util.BN(txGas.createState)).mul(new _ocap_util.BN((estimate.create || 0) + 1)));
+		totalGas = totalGas.add(new _ocap_util.BN(txGas.price).mul(new _ocap_util.BN(txGas.updateState)).mul(new _ocap_util.BN(estimate.update)));
+		return { estimate: { max: totalGas.toString(10) } };
+	}
+	listBlocks() {
+		return { blocks: [] };
+	}
+	validateTokenConfig() {
+		const { accounts, token } = this.config;
+		const sum = accounts.reduce((acc, x) => acc.add((0, _ocap_util.toBN)(x.balance ?? 0)), (0, _ocap_util.toBN)(0));
+		const initialSupply = (0, _ocap_util.toBN)(token.initialSupply);
+		if (!sum.eq(initialSupply)) throw new Error("Invalid config, account balance sum does not equal to token supply");
+	}
+	runAsLambda(fn, args) {
+		if (typeof this.statedb.runAsLambda === "function") return this.statedb.runAsLambda((txn) => fn(txn), args);
+		return Promise.resolve(fn());
+	}
+	async getChain() {
+		return this.statedb.chain.get(CHAIN_ADDR);
+	}
+	async getToken(id) {
+		return this.statedb.token.get(id);
+	}
+	async initializeStateDB() {
+		const { accounts, token } = this.config;
+		const { account: accountDB, chain: chainDB, token: tokenDB } = this.statedb;
+		const { account: accountState, chain: chainState, token: tokenState } = _ocap_state;
+		const context = {
+			txTime: (/* @__PURE__ */ new Date()).toISOString(),
+			txHash: ""
+		};
+		await this.runAsLambda(async (txn) => {
+			const info = await this.statedb.chain.get(CHAIN_ADDR, { txn });
+			const config = (0, lodash_omit.default)(this.config, ["reservedSymbols"]);
+			if (!info) {
+				const state = chainState.create({
+					...config,
+					address: CHAIN_ADDR,
+					context
+				});
+				const result = await chainDB.create(CHAIN_ADDR, state, { txn });
+				this.logger.debug("create chain state", { result });
+			} else if ((0, lodash_isEqual.default)((0, lodash_pick.default)(info, Object.keys(config)), config) === false) {
+				const state = chainState.update(info, {
+					...config,
+					context
+				});
+				const result = await chainDB.update(CHAIN_ADDR, state, { txn });
+				this.logger.debug("update chain state", { result });
+			}
+		}, { commitMessage: "initialize chain" });
+		if (this.tokenItx) {
+			await this.runAsLambda(async (txn) => {
+				const existToken = await this.statedb.token.get(this.tokenItx.address);
+				if (!existToken) {
+					const state = tokenState.create(this.tokenItx, context);
+					const result = await tokenDB.create(this.tokenItx.address, state, { txn });
+					tokenDB.emit("create", result, { txn });
+					this.logger.debug("create token state", { address: result?.address });
+				} else {
+					const changedKeys = [
+						"icon",
+						"website",
+						"metadata"
+					];
+					const pickStateToken = (0, lodash_pick.default)(existToken, changedKeys);
+					const pickConfigToken = (0, lodash_pick.default)(this.tokenItx, changedKeys);
+					if (!(0, lodash_isEqual.default)(pickStateToken, pickConfigToken)) {
+						const state = tokenState.update(existToken, pickConfigToken);
+						const result = await tokenDB.update(this.tokenItx.address, state, { txn });
+						tokenDB.emit("update", result, { txn });
+						this.logger.info("update token state", { result });
+					}
+				}
+			}, { commitMessage: "initialize token" });
+			await this.runAsLambda(async (txn) => {
+				for (let i = 0; i < accounts.length; i++) {
+					const { address, balance, moniker, pk } = accounts[i];
+					try {
+						if (!await accountDB.get(address, { txn })) {
+							const balanceStr = (0, _ocap_util.fromTokenToUnit)(balance ?? 0, token.decimal ?? 18).toString(10);
+							const state = accountState.create({
+								address,
+								tokens: { [this.tokenItx.address]: balanceStr },
+								moniker: moniker || "token-holder",
+								pk
+							}, context);
+							const result = await accountDB.create(address, state, { txn });
+							accountDB.emit("create", result, { txn });
+							this.logger.info("create account done", { address });
+						}
+					} catch (err) {
+						this.logger.error("Failed to initialize initial token holders", err);
+					}
+				}
+			}, { commitMessage: "initialize accounts" });
+		}
+	}
+	connectIndexDB() {
+		const getToken = this.getToken.bind(this);
+		this.statedb.tx.on("create", async (x, ctx) => {
+			if (!ctx) return;
+			try {
+				const tx = await (0, _ocap_indexdb_lib_util.createIndexedTransaction)(x, ctx, this.indexdb);
+				await this.indexdb.tx.insert(tx);
+				if (typeof require_hooks.onCreateTx === "function") await require_hooks.onCreateTx(tx, ctx, this);
+			} catch (error) {
+				this.logger.error("create tx index failed", {
+					account: x,
+					error
+				});
+			}
+		});
+		this.statedb.account.on("create", async (x) => {
+			try {
+				await this.indexdb.account.insert(await (0, _ocap_indexdb_lib_util.createIndexedAccount)(x, getToken));
+			} catch (error) {
+				this.logger.error("create account index failed", {
+					account: x,
+					error
+				});
+			}
+		});
+		this.statedb.account.on("update", async (x) => {
+			try {
+				await this.indexdb.account.update(x.address, await (0, _ocap_indexdb_lib_util.createIndexedAccount)(x, getToken));
+			} catch (error) {
+				this.logger.error("update account index failed", {
+					account: x,
+					error
+				});
+			}
+		});
+		const mapping = {
+			asset: [
+				_ocap_indexdb_lib_util.createIndexedAsset,
+				"address",
+				void 0,
+				void 0
+			],
+			delegation: [
+				_ocap_indexdb_lib_util.createIndexedDelegation,
+				"address",
+				void 0,
+				void 0
+			],
+			token: [
+				_ocap_indexdb_lib_util.createIndexedToken,
+				"address",
+				null,
+				require_hooks.onUpdateToken
+			],
+			factory: [
+				_ocap_indexdb_lib_util.createIndexedFactory,
+				"address",
+				void 0,
+				void 0
+			],
+			stake: [
+				_ocap_indexdb_lib_util.createIndexedStake,
+				"address",
+				void 0,
+				void 0
+			],
+			rollup: [
+				_ocap_indexdb_lib_util.createIndexedRollup,
+				"address",
+				require_hooks.onCreateRollup,
+				void 0
+			],
+			rollupBlock: [
+				_ocap_indexdb_lib_util.createIndexedRollupBlock,
+				"hash",
+				require_hooks.onCreateRollupBlock,
+				void 0
+			],
+			tokenFactory: [
+				_ocap_indexdb_lib_util.createIndexedTokenFactory,
+				"address",
+				void 0,
+				void 0
+			]
+		};
+		Object.keys(mapping).forEach((table) => {
+			const [fn, key, onCreate, onUpdate] = mapping[table];
+			this.statedb[table].on("create", async (x, _ctx) => {
+				try {
+					const ctx = this.enrichIndexContext(_ctx);
+					const doc = await fn(x, ctx, this.indexdb);
+					await this.indexdb[table].insert(doc);
+					if (typeof onCreate === "function") await onCreate(doc, ctx, this.indexdb, this);
+				} catch (error) {
+					this.logger.error(`create ${table} index failed`, {
+						[table]: x,
+						error
+					});
+				}
+			});
+			this.statedb[table].on("update", async (x, _ctx) => {
+				try {
+					const ctx = this.enrichIndexContext(_ctx);
+					const doc = await fn(x, ctx, this.indexdb);
+					await this.indexdb[table].update(doc[key], doc);
+					if (typeof onUpdate === "function") onUpdate(doc, ctx, this.indexdb, this);
+				} catch (error) {
+					this.logger.error(`update ${table} index failed`, {
+						[table]: x,
+						error
+					});
+				}
+			});
+		});
+	}
+	async _getState({ table, id, dataKey, extraParams = {}, onRead = noop, expandContext = true, ctx }) {
+		if (!id) throw new _ocap_util_lib_error.CustomError("INVALID_REQUEST", `Missing required parameter to read ${table} state`);
+		const unified = (0, _arcblock_did.isValid)(id) ? (0, _ocap_util.toAddress)(id) : id;
+		const state = await this.statedb[table].get(unified, { ...extraParams });
+		if (state) {
+			if (dataKey) (0, lodash_set.default)(state, dataKey, formatData((0, lodash_get.default)(state, dataKey)));
+			if (expandContext && state.context) {
+				const { genesisTx, renaissanceTx } = state.context;
+				const txs = (await Promise.all((0, lodash_uniq.default)([genesisTx, renaissanceTx]).filter((x) => Boolean(x)).map((x) => this.getTx({ hash: x }, ctx)))).filter(Boolean);
+				state.context.genesisTx = txs.find((x) => x.hash === genesisTx);
+				state.context.renaissanceTx = txs.find((x) => x.hash === renaissanceTx);
+				if (!state.context.genesisTx) state.context.genesisTx = { hash: genesisTx };
+				if (!state.context.renaissanceTx) state.context.renaissanceTx = { hash: renaissanceTx };
+			}
+		}
+		return onRead(state);
+	}
+	async _doPaginatedSearch(fn, args, listKey, dataKey, ctx) {
+		const { [listKey]: items = [], ...rest } = await this.indexdb[fn](args);
+		let data = items;
+		if (dataKey) data = await Promise.all(items.map(async (x) => {
+			let tx = x;
+			[].concat(dataKey).forEach((key) => {
+				tx = (0, lodash_set.default)(tx, key, formatData((0, lodash_get.default)(tx, key)));
+			});
+			if (listKey === "transactions") tx = await this.formatTx(tx, ctx);
+			if (listKey === "delegations") tx = await this.formatDelegateState(tx);
+			return tx;
+		}));
+		const final = {
+			[listKey]: data,
+			...rest
+		};
+		if (!final.paging) final.paging = {
+			cursor: "0",
+			next: false,
+			total: 0
+		};
+		return final;
+	}
+	async _formatTx(tx, ctx) {
+		if (!tx) return tx;
+		if (!tx.sender && !tx.receiver) {
+			const typeUrl$1 = (0, _ocap_message.fromTypeUrl)(tx.tx.itx.typeUrl);
+			tx.sender = (0, _ocap_state_lib_states_tx.getTxSender)({
+				tx: tx.tx,
+				itx: tx.tx.itxJson,
+				typeUrl: typeUrl$1
+			});
+			tx.receiver = (0, _ocap_state_lib_states_tx.getTxReceiver)({
+				tx: tx.tx,
+				itx: tx.tx.itxJson,
+				typeUrl: typeUrl$1
+			});
+		}
+		if (!tx.receipts) tx.receipts = (0, _ocap_state_lib_states_tx.getTxReceipts)(tx, { config: this.config });
+		const typeUrl = (0, lodash_get.default)(tx, "tx.itxJson.type_url");
+		if (typeUrl === "fg:t:revoke_withdraw" || typeUrl === "fg:t:approve_withdraw") {
+			const withdrawHash = (0, lodash_get.default)(tx, "tx.itxJson.withdraw_tx_hash");
+			if (withdrawHash && withdrawHash !== tx.hash) {
+				const withdrawTx = await this.getTx({ hash: withdrawHash }, ctx);
+				tx.receipts = (0, _ocap_state_lib_states_tx.getTxReceipts)(tx, {
+					config: this.config,
+					withdrawTx
+				});
+			}
+		}
+		if (typeUrl && [
+			"fg:t:deposit_token",
+			"fg:t:withdraw_token",
+			"fg:t:revoke_swap"
+		].includes(typeUrl)) tx.receipts = (0, _ocap_state_lib_states_tx.getTxReceipts)(tx, { config: this.config });
+		if (typeUrl === "fg:t:account_migrate") {
+			const fromState = await this.statedb.account.get(tx.tx.from, { traceMigration: false });
+			if (fromState) tx.receipts = (0, _ocap_state_lib_states_tx.getTxReceipts)(tx, {
+				config: this.config,
+				fromState
+			});
+		}
+		if (typeUrl === "fg:t:declare") tx.receipts = (0, _ocap_state_lib_states_tx.getTxReceipts)(tx, {
+			config: this.config,
+			time: tx.time
+		});
+		tx.receipts = (0, _ocap_state_lib_states_tx.mergeTxReceipts)(tx.receipts);
+		tx.tokenSymbols = await this.getTxTokenSymbols(tx);
+		this.fixReceiptTokens(tx);
+		this.fixTokenSymbols(tx);
+		return (0, _ocap_state_lib_states_tx.attachPaidTxGas)(tx);
+	}
+	async _getAllResults(dataKey, fn, limit) {
+		const pageSize = 100;
+		const { paging, [dataKey]: firstPage } = await fn({ size: pageSize });
+		if (limit && paging.total > limit) throw new _ocap_util_lib_error.CustomError("EXCEED_LIMIT", `Total exceeds limit ${limit}`);
+		if (paging.total <= pageSize) return firstPage;
+		const totalPage = Math.ceil(paging.total / pageSize) - 1;
+		const cursors = new Array(totalPage).fill(true).map((_, i) => (i + 1) * pageSize);
+		const step = Number(process.env.RESOLVER_BATCH_CONCURRENCY) || 3;
+		let results = firstPage;
+		for (let i = 0; i < cursors.length; i += step) {
+			const batchResults = await Promise.all(cursors.slice(i, i + step).map(async (cursor) => {
+				const { [dataKey]: list } = await fn({
+					size: pageSize,
+					cursor
+				});
+				return list;
+			}));
+			results = results.concat(batchResults.flat());
+		}
+		return results;
+	}
+	async formatTokenArray(tokens) {
+		const uniqTokens = (0, lodash_unionBy.default)(tokens, "address");
+		const tokenStates = await Promise.all(uniqTokens.map((token) => this.tokenCache.get(token.address)));
+		return uniqTokens.map((token) => ({
+			...token,
+			...extractTokenMeta(token.address, tokenStates)
+		}));
+	}
+	async formatTokenMap(tokens) {
+		if ((0, lodash_isEmpty.default)(tokens)) return [];
+		const tasks = Object.keys(tokens).map((address) => this.tokenCache.get(address));
+		const tokenStates = await Promise.all(tasks);
+		return Object.keys(tokens).map((address) => ({
+			value: tokens[address],
+			...extractTokenMeta(address, tokenStates)
+		}));
+	}
+	async getTxTokenSymbols(tx) {
+		if (!tx) return [];
+		const rollupTxs = [
+			"DepositTokenV2Tx",
+			"WithdrawTokenV2Tx",
+			"JoinRollupTx",
+			"LeaveRollupTx",
+			"CreateRollupBlockTx",
+			"ClaimBlockRewardTx"
+		];
+		const typeUrl = (0, _ocap_util.formatTxType)(tx.tx.itxJson._type || "");
+		const tokens = [];
+		if ((0, _ocap_indexdb_lib_util.isDefaultTokenChanged)(tx, this.config.token)) tokens.push(this.tokenItx);
+		if (typeUrl === "AcquireAssetV2Tx") {
+			const factoryInput = (await this.indexdb.factory.get(tx.tx.itxJson.factory))?.input;
+			if (factoryInput?.tokens) tokens.push(...factoryInput.tokens);
+		} else if (typeUrl === "ExchangeV2Tx") {
+			tokens.push(...tx.tx.itxJson.sender?.tokens || []);
+			tokens.push(...tx.tx.itxJson.receiver?.tokens || []);
+		} else if (typeUrl === "TransferV2Tx") tokens.push(...tx.tx.itxJson.tokens || []);
+		else if ([
+			"TransferV3Tx",
+			"AcquireAssetV3Tx",
+			"StakeTx"
+		].includes(typeUrl)) tokens.push(...(0, lodash_unionBy.default)((tx.tx.itxJson.inputs || []).reduce((acc, x) => acc.concat(x.tokens || []), []), "address").filter((x) => x.address));
+		else if ([
+			"RevokeStakeTx",
+			"SlashStakeTx",
+			"ReturnStakeTx"
+		].includes(typeUrl)) tokens.push(...(0, lodash_unionBy.default)((tx.tx.itxJson.outputs || []).reduce((acc, x) => acc.concat(x.tokens || []), []), "address").filter((x) => x.address));
+		else if (typeUrl === "ClaimStakeTx") {
+			const revokeTx = await this.indexdb.tx.get(tx.tx.itxJson.evidence.hash);
+			if (revokeTx) {
+				const revokeTxAny = revokeTx;
+				tokens.push(...(0, lodash_unionBy.default)((revokeTxAny.tx?.itxJson?.outputs || []).reduce((acc, x) => acc.concat(x.tokens || []), []), "address").filter((x) => x.address));
+			} else this.logger.warn("Revoke stake tx not found", { tx });
+		} else if (rollupTxs.includes(typeUrl)) {
+			const rollup = await this.indexdb.rollup.get(tx.tx.itxJson.rollup);
+			if (rollup) tokens.push({
+				address: rollup.tokenAddress,
+				value: "0"
+			});
+		} else if (typeUrl === "CreateTokenTx") return [extractTokenMeta(tx.tx.itxJson.address, [tx.tx.itxJson])];
+		else if (typeUrl === "MintTokenTx" || typeUrl === "BurnTokenTx") {
+			const token = await this.indexdb.tokenFactory.get(tx.tx.itxJson.tokenFactory);
+			if (token) tokens.push({ address: token.tokenAddress });
+		} else if (typeUrl === "CreateTokenFactoryTx") tokens.push({ address: tx.tx.itxJson.token.address });
+		if (tokens.length > 0) return this.formatTokenArray(tokens);
+		return [];
+	}
+	fixReceiptTokens(tx) {
+		tx.receipts.forEach((receipt) => receipt.changes.forEach((x) => {
+			if (x.target === "") x.target = this.tokenItx.address;
+		}));
+		return tx;
+	}
+	fixTokenSymbols(tx) {
+		if (tx.tokenSymbols.findIndex((x) => x.address === this.tokenItx.address) === -1) tx.tokenSymbols.push(extractTokenMeta(this.tokenItx.address, [this.tokenItx]));
+		return tx;
+	}
+	enrichIndexContext(ctx) {
+		if (Array.isArray(ctx.tokenStates)) return {
+			...ctx,
+			tokenStates: [...ctx.tokenStates, this.tokenItx]
+		};
+		if (ctx.tokenState) return {
+			...ctx,
+			tokenStates: [ctx.tokenState]
+		};
+		return ctx;
+	}
+	async formatDelegateState(state) {
+		if (Array.isArray(state.ops) && state.ops.length > 0) await Promise.all(state.ops.map(async (op) => {
+			if (op.value.limit && Array.isArray(op.value.limit.tokens)) op.value.limit.tokens = await this.formatTokenArray(op.value.limit.tokens || []);
+		}));
+		return state;
+	}
+	async buildMigrationChain() {
+		const migrationTxs = await this._getAllResults("transactions", (paging) => this.listTransactions({
+			paging,
+			typeFilter: { types: ["account_migrate"] },
+			validityFilter: { validity: "VALID" }
+		}));
+		const migrationChain = new require_migration_chain.MigrationChainManager();
+		migrationChain.buildChains(migrationTxs);
+		this.migrationChain = migrationChain;
+	}
+	async getMigrationChain() {
+		if (!this.migrationChain) await this.buildMigrationChain();
+		return this.migrationChain;
+	}
+	/** fix accounts field of legacy approve_withdraw transactions in indexdb */
+	async fixApproveWithdrawAccounts() {
+		const approveWithdrawTxs = await this._getAllResults("transactions", (paging) => this.listTransactions({
+			paging,
+			typeFilter: { types: ["approve_withdraw"] },
+			validityFilter: { validity: ["VALID"] }
+		}));
+		return (await Promise.all(approveWithdrawTxs.map(async (tx) => {
+			const withdrawHash = tx.tx?.itxJson?.withdraw_tx_hash;
+			if (!withdrawHash) return;
+			const indexdbTx = await this.indexdb.tx.get(tx.hash);
+			const from = (await this.getTx({ hash: withdrawHash }))?.tx?.from;
+			if (!from || !indexdbTx) return;
+			const accounts = (0, lodash_uniq.default)((indexdbTx.accounts || []).concat([from]).filter(Boolean));
+			debug$1("fixApproveWithdrawAccounts", {
+				tx,
+				from,
+				accounts
+			});
+			return await this.indexdb.tx.update(tx.hash, { accounts });
+		}))).filter(Boolean);
+	}
+	async updateTokenDistribution({ tokenAddress = this.config.token.address, force = false } = {}) {
+		const validation = _arcblock_validator.Joi.object({
+			tokenAddress: _arcblock_validator.Joi.DID().prefix().role("ROLE_TOKEN").required(),
+			force: _arcblock_validator.Joi.boolean().required()
+		}).validate({
+			tokenAddress,
+			force
+		});
+		if (validation.error) throw new _ocap_util_lib_error.CustomError("INVALID_PARAMS", validation.error.message);
+		return await this.tokenDistribution.updateByToken(tokenAddress, force);
+	}
+	async getTokenDistribution(args = {}) {
+		const { tokenAddress = this.config.token.address } = args;
+		return await this.tokenDistribution.getDistribution(tokenAddress);
+	}
+	/**
+	* Fetch data in chunks to handle large datasets
+	* @param fn Function to fetch data
+	* @param params Chunk parameters
+	* @returns Iterator with next function
+	*/
+	listChunks(fn, { total, concurrency = 3, chunkSize = 2100, pageSize = 100, timeKey, dataKey }) {
+		let done = false;
+		let time;
+		const totalPage = Math.ceil(total / pageSize);
+		let curPage = 0;
+		const next = async () => {
+			if (done) return [];
+			let results = [];
+			for (; curPage < totalPage; curPage += concurrency) {
+				const flatResults = (await Promise.all(new Array(Math.min(concurrency, totalPage - curPage)).fill(true).map(async (_, i) => {
+					const { [dataKey]: list } = await fn({
+						size: pageSize,
+						cursor: i * pageSize,
+						time
+					});
+					return list;
+				}))).flat();
+				if (!flatResults.length) {
+					done = true;
+					return results;
+				}
+				results = results.concat(flatResults);
+				time = results.length ? results[results.length - 1][timeKey] : void 0;
+				if (results.length >= chunkSize) return results;
+			}
+			done = true;
+			return results;
+		};
+		return {
+			next,
+			done
+		};
+	}
+	async listTransactionsChunks(args = {}, { chunkSize = 2100, pageSize = 100 } = {}) {
+		return this.listChunks(({ size, time, cursor }) => this.listTransactions({
+			...args,
+			paging: {
+				order: {
+					field: "time",
+					type: "asc"
+				},
+				...args.paging || {},
+				size,
+				cursor
+			},
+			timeFilter: Object.assign(args.timeFilter || {}, time ? { startDateTime: time } : {})
+		}), {
+			dataKey: "transactions",
+			timeKey: "time",
+			total: await this.indexdb.tx.count(),
+			chunkSize,
+			pageSize
+		});
+	}
+	async listStakeChunks(args = {}, { chunkSize = 2100, pageSize = 100 } = {}) {
+		return this.listChunks(({ size, time, cursor }) => this.listStakes({
+			...args,
+			paging: {
+				order: {
+					field: "time",
+					type: "asc"
+				},
+				...args.paging || {},
+				size,
+				cursor
+			},
+			timeFilter: Object.assign(args.timeFilter || {}, time ? { startDateTime: time } : {})
+		}), {
+			dataKey: "stakes",
+			timeKey: "renaissanceTime",
+			total: await this.indexdb.stake.count(),
+			chunkSize,
+			pageSize
+		});
+	}
+};
+
+//#endregion
+exports.default = OCAPResolver;
+exports.formatData = formatData;
+exports.formatDelegationOps = formatDelegationOps;