@ocap/resolver 1.28.8 → 1.29.0

package/lib/api.d.cts

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

package/lib/hooks.cjs

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

package/lib/hooks.d.cts

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