@ocap/state 1.28.8 → 1.29.0

package/esm/states/tx.mjs

@@ -0,0 +1,867 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { toTypeInfo, types } from "@arcblock/did";
+import { BN, fromTokenToUnit, isBN, toBase64 } from "@ocap/util";
+import { CustomError } from "@ocap/util/lib/error";
+import pick from "lodash/pick.js";
+import get from "lodash/get.js";
+import { decodeAny, formatMessage, fromTypeUrl } from "@ocap/message";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import { getRelatedAddresses } from "@ocap/util/lib/get-related-addr";
+import camelCase from "lodash/camelCase.js";
+import groupBy from "lodash/groupBy.js";
+import merge from "lodash/merge.js";
+import upperFirst from "lodash/upperFirst.js";
+
+//#region src/states/tx.ts
+var tx_exports = /* @__PURE__ */ __exportAll({
+	FORGE_TOKEN_HOLDER: () => FORGE_TOKEN_HOLDER,
+	attachPaidTxGas: () => attachPaidTxGas,
+	create: () => create,
+	eachReceipts: () => eachReceipts,
+	getTxReceipts: () => getTxReceipts,
+	getTxReceiver: () => getTxReceiver,
+	getTxSender: () => getTxSender,
+	groupReceiptTokenChanges: () => groupReceiptTokenChanges,
+	mergeTxReceipts: () => mergeTxReceipts,
+	update: () => update,
+	verifyTxReceipts: () => verifyTxReceipts
+});
+const ZERO = new BN(0);
+const { RoleType } = types;
+const FORGE_TOKEN_HOLDER = "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz";
+const FORGE_FEE_RECEIVER = "z1EJUBdbPYqMiWHfRZvSAvbYeWcEHB19Xyfc";
+const QLDB_MIGRATION_TIME = /* @__PURE__ */ new Date("2021-05-03T12:46:56.245Z");
+function eachReceipts(receipts, callback) {
+	return (receipts || []).map((receipt) => {
+		return (receipt.changes || []).map((change) => callback(receipt.address, change));
+	}).flat();
+}
+function groupReceiptTokenChanges(receipts) {
+	const tokenChanges = {};
+	eachReceipts(receipts || [], (address, change) => {
+		if (toTypeInfo(change.target).role !== RoleType.ROLE_TOKEN) return;
+		if (change.value === "0") return;
+		if (!tokenChanges[address]) tokenChanges[address] = {};
+		const tokenChange = tokenChanges[address];
+		tokenChange[change.target] = new BN(tokenChange[change.target] || 0).add(new BN(change.value)).toString();
+	});
+	return tokenChanges;
+}
+const getTxReceiver = ({ tx, itx, typeUrl }) => {
+	switch (typeUrl) {
+		case "TransferTx":
+		case "ExchangeTx":
+		case "TransferV2Tx":
+		case "ExchangeV2Tx": return itx.to;
+		case "MintAssetTx": return itx.owner;
+		case "CreateTokenTx":
+		case "CreateAssetTx":
+		case "AcquireAssetV2Tx": return tx.delegator || tx.from;
+		case "AcquireAssetV3Tx": return itx.owner;
+		case "SetupSwapTx": return itx.receiver;
+		case "StakeTx": return itx.address;
+		default: return "";
+	}
+};
+const getTxSender = ({ tx, typeUrl }) => {
+	switch (typeUrl) {
+		case "TransferTx":
+		case "TransferV2Tx":
+		case "ExchangeTx":
+		case "ExchangeV2Tx":
+		case "AcquireAssetV2Tx":
+		case "SetupSwapTx":
+		case "WithdrawTokenTx":
+		case "StakeTx":
+		case "ReturnStakeTx":
+		case "SlashStakeTx": return tx.from;
+		default: return "";
+	}
+};
+const getReceiptChange = (receipts, { address, action }) => {
+	return receipts.filter((x) => !address || x.address === address).flatMap((x) => x.changes.filter((c) => !action || c.action === action));
+};
+const getTransferReceipts = (tx) => {
+	const senderReceipt = {
+		address: tx.from,
+		changes: []
+	};
+	const receiverReceipt = {
+		address: tx.itxJson.to,
+		changes: []
+	};
+	if (new BN(tx.itxJson.value).gt(ZERO)) {
+		senderReceipt.changes.push({
+			target: "",
+			action: "transfer",
+			value: `-${tx.itxJson.value}`
+		});
+		receiverReceipt.changes.push({
+			target: "",
+			action: "transfer",
+			value: tx.itxJson.value
+		});
+	}
+	if (Array.isArray(tx.itxJson.tokens)) tx.itxJson.tokens.forEach((x) => {
+		senderReceipt.changes.push({
+			target: x.address,
+			action: "transfer",
+			value: `-${x.value}`
+		});
+		receiverReceipt.changes.push({
+			target: x.address,
+			action: "transfer",
+			value: x.value
+		});
+	});
+	if (Array.isArray(tx.itxJson.assets)) tx.itxJson.assets.forEach((x) => {
+		senderReceipt.changes.push({
+			target: x,
+			action: "transfer",
+			value: "-1"
+		});
+		receiverReceipt.changes.push({
+			target: x,
+			action: "transfer",
+			value: "1"
+		});
+	});
+	return [senderReceipt, receiverReceipt];
+};
+const getReceiptsFromTxInput = (inputs, symbol, action = "transfer") => {
+	const receipts = [];
+	inputs.forEach((x) => {
+		const receipt = {
+			address: x.owner,
+			changes: []
+		};
+		getListField(x, "tokens").forEach(({ address, value }) => {
+			receipt.changes.push({
+				target: address,
+				action,
+				value: `${symbol}${value}`
+			});
+		});
+		getListField(x, "assets").forEach((address) => receipt.changes.push({
+			target: address,
+			action,
+			value: `${symbol}1`
+		}));
+		receipts.push(receipt);
+	});
+	return receipts;
+};
+const getReceiptsFromContext = (ctx) => {
+	if (Array.isArray(ctx.updatedAccounts)) {
+		const grouped = groupBy(ctx.updatedAccounts.filter((x) => x.address && x.delta), "address");
+		return Object.keys(grouped).map((k) => ({
+			address: k,
+			changes: grouped[k].map((x) => ({
+				target: x.token,
+				action: x.action || "transfer",
+				value: x.delta
+			}))
+		}));
+	}
+	return [];
+};
+/**
+* Add receipts for tx that have gasPaid but no receipts
+* This is used to handle legacy data that gas receipts were not properly recorded
+*/
+const getReceiptsFromGasPaid = (tx, { config, typeUrl }) => {
+	const gasReceipt = getReceiptChange(tx.receipts || [], { action: "gas" });
+	const gasPaid = new BN(tx.gasPaid || 0);
+	if (gasReceipt.length) return [];
+	if (gasPaid.lte(ZERO)) return [];
+	const gasPayer = { AccountMigrateTx: tx.itxJson?.address }[typeUrl] || tx.from;
+	const gasReceiver = config?.vaults?.txGas?.[0] || FORGE_FEE_RECEIVER;
+	if (!gasPayer) return [];
+	return [{
+		address: gasPayer,
+		changes: [{
+			target: "",
+			action: "gas",
+			value: gasPaid.neg().toString()
+		}]
+	}, {
+		address: gasReceiver,
+		changes: [{
+			target: "",
+			action: "gas",
+			value: gasPaid.toString()
+		}]
+	}];
+};
+const getTransferV3Receipts = (tx) => [...getReceiptsFromTxInput(tx.itxJson.inputs || [], "-", "transfer"), ...getReceiptsFromTxInput(tx.itxJson.outputs || [], "", "transfer")];
+const getExchangeReceipts = (tx, ctx) => {
+	const { senderState, receiverState } = ctx;
+	const { sender, receiver } = tx.itxJson;
+	const senderReceipt = {
+		address: senderState ? senderState.address : tx.from,
+		changes: []
+	};
+	const receiverReceipt = {
+		address: receiverState ? receiverState.address : tx.itxJson.to,
+		changes: []
+	};
+	if (sender && new BN(sender.value).gt(ZERO)) {
+		senderReceipt.changes.push({
+			target: "",
+			action: "transfer",
+			value: `-${sender.value}`
+		});
+		receiverReceipt.changes.push({
+			target: "",
+			action: "transfer",
+			value: sender.value
+		});
+	}
+	if (receiver && new BN(receiver.value).gt(ZERO)) {
+		receiverReceipt.changes.push({
+			target: "",
+			action: "transfer",
+			value: `-${receiver.value}`
+		});
+		senderReceipt.changes.push({
+			target: "",
+			action: "transfer",
+			value: receiver.value
+		});
+	}
+	if (Array.isArray(sender?.tokens)) sender.tokens.forEach((x) => {
+		senderReceipt.changes.push({
+			target: x.address,
+			action: "transfer",
+			value: `-${x.value}`
+		});
+		receiverReceipt.changes.push({
+			target: x.address,
+			action: "transfer",
+			value: x.value
+		});
+	});
+	if (Array.isArray(receiver?.tokens)) receiver.tokens.forEach((x) => {
+		receiverReceipt.changes.push({
+			target: x.address,
+			action: "transfer",
+			value: `-${x.value}`
+		});
+		senderReceipt.changes.push({
+			target: x.address,
+			action: "transfer",
+			value: x.value
+		});
+	});
+	if (Array.isArray(sender?.assets)) sender.assets.forEach((x) => {
+		senderReceipt.changes.push({
+			target: x,
+			action: "transfer",
+			value: "-1"
+		});
+		receiverReceipt.changes.push({
+			target: x,
+			action: "transfer",
+			value: "1"
+		});
+	});
+	if (Array.isArray(receiver?.assets)) receiver.assets.forEach((x) => {
+		receiverReceipt.changes.push({
+			target: x,
+			action: "transfer",
+			value: "-1"
+		});
+		senderReceipt.changes.push({
+			target: x,
+			action: "transfer",
+			value: "1"
+		});
+	});
+	return [senderReceipt, receiverReceipt];
+};
+const getCreateAssetReceipts = (tx) => {
+	return [{
+		address: tx.delegator || tx.from,
+		changes: [{
+			target: tx.itxJson.address,
+			action: "create",
+			value: "1"
+		}]
+	}];
+};
+const getMintAssetReceipts = (tx, ctx) => {
+	const { assets = [], address, owner } = tx.itxJson;
+	const ownerReceipt = {
+		address: ctx.ownerAddress || owner,
+		changes: [{
+			target: address,
+			action: "mint",
+			value: "1"
+		}]
+	};
+	assets.map((x) => ownerReceipt.changes.push({
+		target: x,
+		action: "consume",
+		value: "-1"
+	}));
+	return [ownerReceipt];
+};
+const getAcquireAssetReceipts = (tx, ctx) => {
+	const { assets = [], address } = tx.itxJson;
+	const ownerReceipt = {
+		address: tx.delegator || tx.from,
+		changes: [{
+			target: address,
+			action: "mint",
+			value: "1"
+		}]
+	};
+	const senderReceipt = {
+		address: tx.from,
+		changes: []
+	};
+	assets.map((x) => senderReceipt.changes.push({
+		target: x,
+		action: "consume",
+		value: "-1"
+	}));
+	if (ctx.factoryState) {
+		const { value, tokens } = ctx.factoryState.input;
+		if (new BN(value).gt(ZERO)) senderReceipt.changes.push({
+			target: "",
+			action: "consume",
+			value: `-${value}`
+		});
+		tokens.map((x) => senderReceipt.changes.push({
+			target: x.address,
+			action: "consume",
+			value: `-${x.value}`
+		}));
+	}
+	let mergedReceipts = [ownerReceipt, senderReceipt];
+	if (ownerReceipt.address === senderReceipt.address) {
+		senderReceipt.changes = [...ownerReceipt.changes, ...senderReceipt.changes];
+		mergedReceipts = [senderReceipt];
+	}
+	return [...mergedReceipts];
+};
+const getAcquireAssetV3Receipts = (tx) => {
+	const { inputs, owner, address } = tx.itxJson;
+	return [{
+		address: owner,
+		changes: [{
+			target: address,
+			action: "mint",
+			value: "1"
+		}]
+	}, ...getReceiptsFromTxInput(inputs, "-", "consume")];
+};
+const getStakeReceipts = (tx) => {
+	const { inputs, address } = tx.itxJson;
+	const tokens = {};
+	const assets = [];
+	inputs.forEach((input) => {
+		input.tokens.forEach((x) => {
+			if (typeof tokens[x.address] === "undefined") tokens[x.address] = new BN(0);
+			tokens[x.address] = tokens[x.address].add(new BN(x.value));
+		});
+		assets.push(...input.assets);
+	});
+	const stakeReceipt = {
+		address,
+		changes: []
+	};
+	assets.forEach((x) => stakeReceipt.changes.push({
+		target: x,
+		action: "stake",
+		value: "1"
+	}));
+	Object.keys(tokens).forEach((x) => stakeReceipt.changes.push({
+		target: x,
+		action: "stake",
+		value: tokens[x].toString(10)
+	}));
+	return [stakeReceipt, ...getReceiptsFromTxInput(inputs, "-", "stake")];
+};
+const getClaimStakeReceipts = (tx, ctx, action) => {
+	const { address } = tx.itxJson;
+	const { outputs } = ctx;
+	const tokens = {};
+	const assets = [];
+	outputs.forEach((output) => {
+		getListField(output, "tokens").forEach((x) => {
+			if (typeof tokens[x.address] === "undefined") tokens[x.address] = new BN(0);
+			tokens[x.address] = tokens[x.address].add(new BN(x.value));
+		});
+		assets.push(...getListField(output, "assets"));
+	});
+	const stakeReceipt = {
+		address,
+		changes: []
+	};
+	assets.forEach((x) => stakeReceipt.changes.push({
+		target: x,
+		action,
+		value: "-1"
+	}));
+	Object.keys(tokens).forEach((x) => stakeReceipt.changes.push({
+		target: x,
+		action,
+		value: `-${tokens[x].toString(10)}`
+	}));
+	return [stakeReceipt, ...getReceiptsFromTxInput(outputs, "", action)];
+};
+const getCreateTokenReceipts = (tx) => {
+	const { initialSupply, address } = tx.itxJson;
+	const balance = new BN(initialSupply).toString();
+	return [{
+		address: tx.delegator || tx.from,
+		changes: [{
+			target: address,
+			action: "mint",
+			value: balance
+		}]
+	}];
+};
+const getMintTokenReceipts = (tx, ctx) => {
+	const { inputChanges, tokenFactoryState } = ctx;
+	const { reserveAddress, tokenAddress, owner } = tokenFactoryState;
+	const hasFee = new BN(ctx.reserveFee || "0").gt(ZERO);
+	return inputChanges.map((input) => {
+		return {
+			address: input.address,
+			changes: [{
+				target: reserveAddress,
+				action: "swap",
+				value: input.delta
+			}]
+		};
+	}).concat([{
+		address: tx.itxJson.receiver,
+		changes: [{
+			target: tokenAddress,
+			action: "mint",
+			value: `${tx.itxJson.amount}`
+		}]
+	}]).concat(hasFee ? [{
+		address: owner,
+		changes: [{
+			target: reserveAddress,
+			action: "fee",
+			value: `${ctx.reserveFee}`
+		}]
+	}] : []);
+};
+const getBurnTokenReceipts = (tx, ctx) => {
+	const { inputChanges, tokenFactoryState } = ctx;
+	const { reserveAddress, tokenAddress, owner } = tokenFactoryState;
+	const fee = new BN(ctx.reserveFee || "0");
+	const receiveAmount = new BN(ctx.reserveAmount || "0").sub(fee);
+	return inputChanges.map((input) => {
+		return {
+			address: input.address,
+			changes: [{
+				target: tokenAddress,
+				action: "burn",
+				value: input.delta
+			}]
+		};
+	}).concat(receiveAmount.gt(ZERO) ? [{
+		address: tx.itxJson.receiver,
+		changes: [{
+			target: reserveAddress,
+			action: "swap",
+			value: receiveAmount.toString()
+		}]
+	}] : []).concat(fee.gt(ZERO) ? [{
+		address: owner,
+		changes: [{
+			target: reserveAddress,
+			action: "fee",
+			value: fee.toString()
+		}]
+	}] : []);
+};
+const getDepositTokenReceipts = (tx) => [{
+	address: tx.itxJson.address,
+	changes: [{
+		target: "",
+		action: "mint",
+		value: tx.itxJson.value
+	}]
+}];
+const getWithdrawFee = (value) => {
+	let fee = new BN(value).abs().mul(new BN("1")).div(new BN("1000"));
+	fee = BN.min(fee, new BN("100000000000000000000"));
+	fee = BN.max(fee, new BN("1000000000000000000"));
+	return fee;
+};
+const getWithdrawTokenReceipts = (tx) => {
+	const fee = getWithdrawFee(tx.itxJson.value);
+	return [{
+		address: tx.from,
+		changes: [{
+			target: "",
+			action: "lock",
+			value: `-${tx.itxJson.value}`
+		}, {
+			target: "",
+			action: "fee",
+			value: `-${fee.toString()}`
+		}]
+	}, {
+		address: FORGE_TOKEN_HOLDER,
+		changes: [{
+			target: "",
+			action: "lock",
+			value: tx.itxJson.value
+		}, {
+			target: "",
+			action: "fee",
+			value: fee.toString()
+		}]
+	}];
+};
+const getRevokeWithdrawReceipts = (tx, ctx) => {
+	const { withdrawTx } = ctx;
+	if (!withdrawTx?.tx?.from) return [];
+	if (withdrawTx.hash !== tx.itxJson.withdraw_tx_hash) return [];
+	const account = withdrawTx.tx.from;
+	const lockChange = (withdrawTx.receipts?.find((x) => x.address === account))?.changes?.find((x) => x.action === "lock");
+	if (!lockChange) return [];
+	const value = new BN(lockChange.value).abs();
+	const fee = getWithdrawFee(value.toString());
+	const revokeFee = fee.mul(new BN("5")).div(new BN("100"));
+	return [
+		{
+			address: account,
+			changes: [{
+				target: "",
+				action: "unlock",
+				value: value.toString()
+			}, {
+				target: "",
+				action: "fee",
+				value: fee.sub(revokeFee).toString()
+			}]
+		},
+		{
+			address: FORGE_TOKEN_HOLDER,
+			changes: [{
+				target: "",
+				action: "unlock",
+				value: `-${value.toString()}`
+			}, {
+				target: "",
+				action: "fee",
+				value: `-${fee.toString()}`
+			}]
+		},
+		{
+			address: FORGE_FEE_RECEIVER,
+			changes: [{
+				target: "",
+				action: "fee",
+				value: revokeFee.toString()
+			}]
+		}
+	];
+};
+const getApproveWithdrawReceipts = (tx, ctx) => {
+	const { withdrawTx } = ctx;
+	if (!withdrawTx?.tx?.itxJson?.value) return [];
+	if (withdrawTx.hash !== tx.itxJson.withdraw_tx_hash) return [];
+	const { value } = withdrawTx.tx.itxJson;
+	const fee = getWithdrawFee(value);
+	return [{
+		address: FORGE_TOKEN_HOLDER,
+		changes: [{
+			target: "",
+			action: "burn",
+			value: `-${value}`
+		}, {
+			target: "",
+			action: "fee",
+			value: `-${fee.toString()}`
+		}]
+	}, {
+		address: FORGE_FEE_RECEIVER,
+		changes: [{
+			target: "",
+			action: "fee",
+			value: fee.toString()
+		}]
+	}];
+};
+const getSetupSwapReceipts = (tx) => [{
+	address: tx.from,
+	changes: [new BN(tx.itxJson.value).gt(ZERO) ? {
+		target: "",
+		action: "swap",
+		value: `-${tx.itxJson.value}`
+	} : null, ...tx.itxJson.assets.map((x) => ({
+		target: x,
+		action: "swap",
+		value: "-1"
+	}))].filter(Boolean)
+}];
+const getRetrieveSwapReceipts = (tx) => [{
+	address: tx.from,
+	changes: [new BN(tx.itxJson.value).gt(ZERO) ? {
+		target: "",
+		action: "swap",
+		value: tx.itxJson.value
+	} : null, ...tx.itxJson.assets.map((x) => ({
+		target: x,
+		action: "swap",
+		value: "1"
+	}))].filter(Boolean)
+}];
+const getMigrateReceipts = (tx, context) => {
+	const fromState = context.fromState || context.senderState;
+	if (!fromState?.tokens) return [];
+	if (!tx.itxJson?.address) return [];
+	const changes = Object.entries(fromState.tokens).filter(([, value]) => value && value !== "0").map(([address, value]) => ({
+		target: address,
+		action: "migrate",
+		value
+	}));
+	return changes.length ? [{
+		address: tx.itxJson.address,
+		changes
+	}] : [];
+};
+const getDeclareReceipts = (tx, ctx) => {
+	const txTime = new Date(ctx.time || "");
+	if (!tx.itxJson?.issuer) return [];
+	if (!ctx.config?.token) return [];
+	if (!ctx.time) return [];
+	if (txTime >= QLDB_MIGRATION_TIME) return [];
+	const gas = fromTokenToUnit("0.5", ctx.config.token.decimal || 18);
+	return [{
+		address: tx.itxJson.issuer,
+		changes: [{
+			target: ctx.config.token.address || "",
+			action: "gas",
+			value: `-${gas.toString()}`
+		}]
+	}, {
+		address: FORGE_FEE_RECEIVER,
+		changes: [{
+			target: ctx.config.token.address || "",
+			action: "gas",
+			value: gas.toString()
+		}]
+	}];
+};
+const mergeTxReceipts = (receipts) => {
+	const merged = {};
+	receipts.forEach((x) => {
+		if (merged[x.address] === void 0) merged[x.address] = x;
+		else merged[x.address].changes = [...merged[x.address].changes, ...x.changes];
+	});
+	return Object.values(merged);
+};
+/**
+* Get list of accounts with migration history
+*/
+const getAccountMigrationsFromContext = (ctx) => {
+	const migrationAddresses = [];
+	for (const [key, state] of Object.entries(ctx)) {
+		if (key.endsWith("State") && state && typeof state === "object" && "address" in state) migrationAddresses.push(getRelatedAddresses(state));
+		if (key.endsWith("States") && Array.isArray(state)) state.forEach((x) => {
+			if (x && typeof x === "object" && "address" in x) migrationAddresses.push(getRelatedAddresses(x));
+		});
+	}
+	return migrationAddresses;
+};
+/**
+* Group receipts by target
+*/
+const groupReceiptsByTarget = (receipts) => {
+	const targets = {};
+	for (const { address, changes } of receipts) for (const { target, value, action } of changes) {
+		if (!targets[target]) targets[target] = [];
+		targets[target].push({
+			address,
+			value: new BN(value),
+			action
+		});
+	}
+	return targets;
+};
+/**
+* Verify transaction receipts
+*/
+const verifyTxReceipts = (receipts, typeUrl, ctx = {}) => {
+	const targets = groupReceiptsByTarget(receipts);
+	const accountsWithMigration = getAccountMigrationsFromContext(ctx);
+	const skipActionsForType = {
+		MintAssetTx: ["mint", "consume"],
+		AcquireAssetV2Tx: ["mint", "consume"],
+		AcquireAssetV3Tx: ["mint", "consume"],
+		CreateAssetTx: ["create"],
+		CreateTokenTx: ["mint"],
+		CreateRollupBlockTx: ["burn", "mint"],
+		AccountMigrateTx: ["migrate"],
+		ApproveWithdrawTx: ["burn"],
+		SetupSwapTx: ["swap"],
+		RevokeSwapTx: ["swap"],
+		RetrieveSwapTx: ["swap"],
+		MintTokenTx: [
+			"swap",
+			"mint",
+			"fee"
+		],
+		BurnTokenTx: [
+			"burn",
+			"swap",
+			"fee"
+		]
+	}[typeUrl] || [];
+	for (const [target, changes] of Object.entries(targets)) {
+		const filteredChanges = changes.filter(({ action }) => {
+			if (!skipActionsForType.includes(action)) return true;
+			if (action === "consume" && toTypeInfo(target).role !== RoleType.ROLE_ASSET) return true;
+			return false;
+		});
+		const sum = filteredChanges.reduce((prev, current) => prev.add(current.value), new BN(0));
+		if (!sum.eq(ZERO)) throw new CustomError("INVALID_RECEIPTS_VALUE", `Receipts are not zero-sum, target: ${target}, sum: ${sum}`);
+		const accountValue = {};
+		for (const { address, value, action } of filteredChanges) {
+			const accounts = accountsWithMigration.find((x) => x.includes(address)) || [address];
+			for (const account of accounts) {
+				const key = `${action}-${account}`;
+				const existingValue = accountValue[key];
+				if (existingValue && (existingValue.gt(ZERO) && value.lt(ZERO) || existingValue.lt(ZERO) && value.gt(ZERO))) throw new CustomError("INVALID_RECEIPTS_ADDRESS", `Duplicate accounts in receipts, target: ${target}, address: ${address}, action: ${action}`);
+				accountValue[key] = value;
+			}
+		}
+	}
+	return true;
+};
+/**
+* Create transaction receipts, each receipt has following properties:
+*
+* - address: the entity did that changed
+* - changes:
+*   - target: the target address that was changed, can be token address, asset address
+*   - action: why the target has changed, such as consume, burn and transfer
+*   - value: the amount that has changed
+*/
+const getTxReceipts = ({ tx, code }, ctx = {}) => {
+	const typeUrl = upperFirst(camelCase(tx?.itxJson?._type || ""));
+	if (code !== "OK") {
+		const receiptsFromContext = ctx.gasPaid ? getReceiptsFromContext(ctx) : [];
+		const receiptsFromGas = getReceiptsFromGasPaid(tx, {
+			...ctx,
+			typeUrl
+		});
+		return receiptsFromContext.concat(receiptsFromGas);
+	}
+	let receipts = Array.isArray(ctx.receipts) ? ctx.receipts : [];
+	if (["TransferTx", "TransferV2Tx"].includes(typeUrl)) receipts = receipts.concat(getTransferReceipts(tx));
+	else if (["TransferV3Tx"].includes(typeUrl)) receipts = receipts.concat(getTransferV3Receipts(tx));
+	else if (["ExchangeTx", "ExchangeV2Tx"].includes(typeUrl)) receipts = receipts.concat(getExchangeReceipts(tx, ctx));
+	else if (["CreateAssetTx"].includes(typeUrl)) receipts = receipts.concat(getCreateAssetReceipts(tx));
+	else if (["MintAssetTx"].includes(typeUrl)) receipts = receipts.concat(getMintAssetReceipts(tx, ctx));
+	else if (["AcquireAssetV2Tx"].includes(typeUrl)) receipts = receipts.concat(getAcquireAssetReceipts(tx, ctx));
+	else if (["AcquireAssetV3Tx"].includes(typeUrl)) receipts = receipts.concat(getAcquireAssetV3Receipts(tx));
+	else if (["CreateTokenTx"].includes(typeUrl)) receipts = receipts.concat(getCreateTokenReceipts(tx));
+	else if (["MintTokenTx"].includes(typeUrl)) receipts = receipts.concat(getMintTokenReceipts(tx, ctx));
+	else if (["BurnTokenTx"].includes(typeUrl)) receipts = receipts.concat(getBurnTokenReceipts(tx, ctx));
+	else if (["DepositTokenTx"].includes(typeUrl)) receipts = receipts.concat(getDepositTokenReceipts(tx));
+	else if (["WithdrawTokenTx"].includes(typeUrl)) receipts = receipts.concat(getWithdrawTokenReceipts(tx));
+	else if (["SetupSwapTx"].includes(typeUrl)) receipts = receipts.concat(getSetupSwapReceipts(tx));
+	else if (["RetrieveSwapTx", "RevokeSwapTx"].includes(typeUrl)) receipts = receipts.concat(getRetrieveSwapReceipts(tx));
+	else if (["StakeTx"].includes(typeUrl)) receipts = receipts.concat(getStakeReceipts(tx));
+	else if (["ClaimStakeTx"].includes(typeUrl)) receipts = receipts.concat(getClaimStakeReceipts(tx, ctx, "claim"));
+	else if (["SlashStakeTx"].includes(typeUrl)) receipts = receipts.concat(getClaimStakeReceipts(tx, ctx, "slash"));
+	else if (["ReturnStakeTx"].includes(typeUrl)) receipts = receipts.concat(getClaimStakeReceipts(tx, ctx, "stake"));
+	else if (["RevokeWithdrawTx"].includes(typeUrl)) receipts = receipts.concat(getRevokeWithdrawReceipts(tx, ctx));
+	else if (["ApproveWithdrawTx"].includes(typeUrl)) receipts = receipts.concat(getApproveWithdrawReceipts(tx, ctx));
+	else if (["AccountMigrateTx"].includes(typeUrl)) receipts = receipts.concat(getMigrateReceipts(tx, ctx));
+	else if (["DeclareTx"].includes(typeUrl)) receipts = receipts.concat(getDeclareReceipts(tx, ctx));
+	receipts = receipts.concat(getReceiptsFromContext(ctx));
+	receipts = receipts.concat(getReceiptsFromGasPaid(tx, {
+		...ctx,
+		typeUrl
+	}));
+	const merged = mergeTxReceipts(receipts).filter((x) => x.address && Array.isArray(x.changes) && x.changes.length);
+	const tokenAddr = get(ctx, "config.token.address", "");
+	if (tokenAddr) merged.forEach((x) => x.changes.forEach((c) => {
+		if (c.target === "") c.target = tokenAddr;
+	}));
+	return merged;
+};
+const create = (context, code = "OK", verifyReceipts = true) => {
+	const { txHash, txTime, tx, totalGas, itxExtras = {}, extra = {} } = context;
+	const itx = decodeAny(tx.itx).value;
+	const typeUrl = fromTypeUrl(tx.itx.typeUrl);
+	const typeName = tx.itx.typeUrl.split(":").pop() || "";
+	const itxJson = formatMessage(typeUrl, itx);
+	const result = {
+		code,
+		hash: txHash,
+		height: 0,
+		index: 0,
+		time: txTime,
+		sender: getTxSender({
+			tx,
+			itx,
+			typeUrl
+		}),
+		receiver: getTxReceiver({
+			tx,
+			itx,
+			typeUrl
+		}),
+		type: typeName,
+		tx: {
+			chainId: tx.chainId,
+			delegator: tx.delegator,
+			from: tx.from,
+			nonce: tx.nonce,
+			serviceFee: tx.serviceFee || "0",
+			gasFee: isBN(totalGas) ? totalGas.toString(10) : "0",
+			pk: tx.pk ? toBase64(tx.pk) : void 0,
+			signature: tx.signature ? toBase64(tx.signature) : void 0,
+			signatures: getListField(tx, "signatures").map((x) => formatMessage("Multisig", x)),
+			itx: { __typename: typeUrl },
+			itxJson: {
+				_type: typeUrl,
+				encoded_value: tx.itx.value,
+				type_url: tx.itx.typeUrl,
+				...itxJson,
+				...itxExtras,
+				data: itx.data || null
+			},
+			extra: extra.txExtra || null
+		}
+	};
+	result.receipts = getTxReceipts(result, context);
+	if (code === "OK" && verifyReceipts) try {
+		verifyTxReceipts(result.receipts, typeUrl, context);
+		result.receiptsVerified = true;
+	} catch (err) {
+		console.warn(JSON.stringify(result, null));
+		console.error("verifyTxReceipts error", err);
+		result.receiptsVerified = false;
+	}
+	attachPaidTxGas(result);
+	return result;
+};
+const attachPaidTxGas = (tx) => {
+	if (tx.tx.gasPaid) return tx;
+	let gasChange = null;
+	(tx.receipts || []).forEach((r) => {
+		const tmp = r.changes.find((c) => c.action === "gas" && c.value === tx.tx.gasFee);
+		if (tmp) gasChange = tmp;
+	});
+	tx.tx.gasPaid = gasChange ? tx.tx.gasFee : "0";
+	return tx;
+};
+const update = (state, updates) => merge(state, pick(updates, ["finalized", "tx.itxJson.actualFee"]));
+
+//#endregion
+export { FORGE_TOKEN_HOLDER, attachPaidTxGas, create, eachReceipts, getTxReceipts, getTxReceiver, getTxSender, groupReceiptTokenChanges, mergeTxReceipts, tx_exports, update, verifyTxReceipts };