@ocap/tx-protocols 1.28.8 → 1.29.0

package/lib/util.cjs

@@ -0,0 +1,296 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let _arcblock_did_util = require("@arcblock/did-util");
+let _ocap_util = require("@ocap/util");
+let _ocap_message = require("@ocap/message");
+let _ocap_util_lib_get_list_field = require("@ocap/util/lib/get-list-field");
+let lodash_cloneDeep = require("lodash/cloneDeep");
+lodash_cloneDeep = require_rolldown_runtime.__toESM(lodash_cloneDeep);
+let lodash_flattenDeep = require("lodash/flattenDeep");
+lodash_flattenDeep = require_rolldown_runtime.__toESM(lodash_flattenDeep);
+let lodash_groupBy = require("lodash/groupBy");
+lodash_groupBy = require_rolldown_runtime.__toESM(lodash_groupBy);
+
+//#region src/util.ts
+const ZERO = new _ocap_util.BN(0);
+const RATE_BASE = new _ocap_util.BN(1e4);
+const decodeAnyNested = (encoded) => {
+	if (!encoded) return encoded;
+	if (Array.isArray(encoded)) return encoded.map((k) => decodeAnyNested(k));
+	if (typeof encoded === "object") {
+		const obj = encoded;
+		if (obj.typeUrl && obj.value) {
+			const result = (0, _ocap_message.decodeAny)(obj);
+			result.value = decodeAnyNested(result.value);
+			return result;
+		}
+		return Object.keys(obj).reduce((acc, x) => {
+			acc[x] = decodeAnyNested(obj[x]);
+			return acc;
+		}, {});
+	}
+	return encoded;
+};
+const decodeAnySafe = (encoded) => {
+	if (!encoded) return null;
+	try {
+		const decoded = (0, _ocap_message.decodeAny)(encoded);
+		if (decoded.value && typeof decoded.value === "object") decoded.value = decodeAnyNested(decoded.value);
+		return decoded;
+	} catch (err) {
+		console.error("decodeAnySafe failed", err);
+		return null;
+	}
+};
+const applyTokenUpdates = (tokens, state, operator) => {
+	if (["add", "sub"].includes(operator) === false) throw new _ocap_util_lib_error.CustomError("UNEXPECTED_OPERATOR", `Invalid operator when applyTokenUpdates: ${operator}`);
+	if (!state) return {};
+	const states = (0, lodash_cloneDeep.default)((Array.isArray(state) ? state : [state]).map((x) => ({ tokens: x.tokens || {} })));
+	for (let i = 0; i < tokens.length; i++) {
+		const { address, value } = tokens[i];
+		const expectedDelta = new _ocap_util.BN(value);
+		let fulfilled = new _ocap_util.BN(0);
+		for (let j = 0; j < states.length; j++) {
+			const origin = states[j].tokens;
+			const updated = (0, lodash_cloneDeep.default)(origin);
+			const balance = new _ocap_util.BN(origin[address] || 0);
+			let newBalance;
+			if (operator === "add") {
+				fulfilled = fulfilled.add(expectedDelta);
+				newBalance = balance.add(expectedDelta);
+			} else {
+				const unfulfilledDelta = expectedDelta.sub(fulfilled);
+				const actualDelta = balance.lt(unfulfilledDelta) ? balance : unfulfilledDelta;
+				fulfilled = fulfilled.add(actualDelta);
+				newBalance = balance.sub(actualDelta);
+			}
+			updated[address] = newBalance.toString(10);
+			states[j].tokens = updated;
+		}
+		if (fulfilled.lt(expectedDelta)) throw new _ocap_util_lib_error.CustomError("INSUFFICIENT_FUND", `Negative token balance when applyTokenUpdates for ${address}, expected: ${expectedDelta.toString()} fulfilled: ${fulfilled.toString()}`);
+	}
+	return Array.isArray(state) ? states : states[0];
+};
+const applyTokenChange = (state, change) => {
+	const delta = typeof change.delta === "string" ? new _ocap_util.BN(change.delta) : change.delta;
+	if (delta.gt(ZERO)) return applyTokenUpdates([{
+		address: change.token,
+		value: delta.toString(10)
+	}], state, "add");
+	return applyTokenUpdates([{
+		address: change.token,
+		value: delta.abs().toString(10)
+	}], state, "sub");
+};
+const fixTokenInput = (input, config) => {
+	(0, _ocap_util_lib_get_list_field.getListField)(input, "tokens").forEach((t) => {
+		if (!t.address) t.address = config.token.address;
+	});
+	return input;
+};
+const getTxFee = ({ amount, feeRate, maxFee, minFee, stringify = true }) => {
+	const userAmount = new _ocap_util.BN(amount);
+	const maxFeeAmount = new _ocap_util.BN(maxFee);
+	const minFeeAmount = new _ocap_util.BN(minFee);
+	if (feeRate < 0) throw new _ocap_util_lib_error.CustomError("NEGATIVE_FEE_RATE", "Unexpected negative feeRate when getTxFee, abort!");
+	if (userAmount.isNeg()) throw new _ocap_util_lib_error.CustomError("NEGATIVE_AMOUNT", "Unexpected negative amount when getTxFee, abort!");
+	if (maxFeeAmount.isNeg()) throw new _ocap_util_lib_error.CustomError("NEGATIVE_MAX_FEE", "Unexpected negative maxFee when getTxFee, abort!");
+	if (minFeeAmount.isNeg()) throw new _ocap_util_lib_error.CustomError("NEGATIVE_MIN_FEE", "Unexpected negative minFee when getTxFee, abort!");
+	let rewardAmount = userAmount.mul(new _ocap_util.BN(feeRate)).div(RATE_BASE);
+	if (rewardAmount.lt(minFeeAmount)) rewardAmount = minFeeAmount;
+	if (rewardAmount.gt(maxFeeAmount)) rewardAmount = maxFeeAmount;
+	const totalAmount = userAmount.add(rewardAmount);
+	if (stringify) return {
+		total: totalAmount.toString(10),
+		user: userAmount.toString(10),
+		reward: rewardAmount.toString(10)
+	};
+	return {
+		total: totalAmount,
+		user: userAmount,
+		reward: rewardAmount
+	};
+};
+const getDelegationRequirements = (context) => {
+	const { txType, config } = context;
+	const txFee = config.transaction.txFee[txType];
+	if (!txFee) return [];
+	return [{
+		type: "token",
+		address: config.token.address,
+		value: (0, _ocap_util.fromTokenToUnit)(txFee, config.token.decimal).toString()
+	}];
+};
+const splitTxFee = ({ total, shares = {}, stringify = true, rateBase = RATE_BASE }) => {
+	const totalAmount = new _ocap_util.BN(total);
+	if (totalAmount.isNeg()) throw new _ocap_util_lib_error.CustomError("NEGATIVE_TOTAL_AMOUNT", "Unexpected negative total when splitTxFee, abort!");
+	Object.keys(shares).forEach((key) => {
+		if (shares[key] < 0) throw new _ocap_util_lib_error.CustomError("NEGATIVE_FEE_SHARE", `Unexpected negative shares[${key}] when splitTxFee, abort!`);
+	});
+	if (Object.values(shares).reduce((sum, x) => sum.add(new _ocap_util.BN(x)), new _ocap_util.BN(0)).eq(rateBase) === false) throw new _ocap_util_lib_error.CustomError("INVALID_FEE_SHARE", "Invalid share config when splitTxFee, abort!");
+	const rewardShares = Object.keys(shares).reduce((acc, x) => {
+		acc[x] = totalAmount.mul(new _ocap_util.BN(shares[x])).div(rateBase);
+		return acc;
+	}, {});
+	if (Object.values(rewardShares).reduce((sum, x) => sum.add(x), new _ocap_util.BN(0)).eq(totalAmount) === false) {
+		const firstKey = Object.keys(rewardShares)[0];
+		const currentSum = Object.values(rewardShares).reduce((sum, x) => sum.add(x), new _ocap_util.BN(0));
+		rewardShares[firstKey] = rewardShares[firstKey].add(totalAmount.sub(currentSum));
+	}
+	return Object.keys(rewardShares).reduce((acc, x) => {
+		acc[x] = stringify ? rewardShares[x].toString(10) : rewardShares[x];
+		return acc;
+	}, {});
+};
+const getRewardLocker = (rollupAddress) => (0, _arcblock_did_util.toStakeAddress)(rollupAddress, rollupAddress);
+const getBNSum = (...args) => (0, lodash_flattenDeep.default)(args).reduce((sum, x) => sum.add(new _ocap_util.BN(x)), new _ocap_util.BN(0)).toString(10);
+const isGovernanceTx = (x) => [
+	"pause_rollup",
+	"resume_rollup",
+	"migrate_rollup"
+].includes(x.type);
+const isFixedFee = (x) => !x.tx.itxJson.maxFee || new _ocap_util.BN(x.tx.itxJson.maxFee).isZero();
+const ensureBlockReward = (rollupState, minReward, txStates) => {
+	const { address, withdrawFeeRate, minWithdrawFee, maxWithdrawFee, tokenAddress } = rollupState;
+	const locker = getRewardLocker(address);
+	const result = {
+		mintedAmount: new _ocap_util.BN(0),
+		burnedAmount: new _ocap_util.BN(0),
+		rewardAmount: new _ocap_util.BN(0),
+		stakeUpdates: {},
+		accountUpdates: {}
+	};
+	const maxPossibleReward = txStates.reduce((sum, x) => sum.add(new _ocap_util.BN(isFixedFee(x) ? x.tx.itxJson.actualFee : x.tx.itxJson.maxFee)), new _ocap_util.BN(0));
+	const minRequiredReward = new _ocap_util.BN(minReward);
+	if (maxPossibleReward.lt(minRequiredReward)) throw new _ocap_util_lib_error.CustomError("INVALID_BLOCK", "Block reward does not match minReward requirement");
+	const dynamicFeeTxs = txStates.filter((x) => isGovernanceTx(x) === false && isFixedFee(x) === false);
+	const totalDynamicFee = dynamicFeeTxs.reduce((sum, x) => sum.add(new _ocap_util.BN(x.tx.itxJson.maxFee)), new _ocap_util.BN(0));
+	const totalFixedFee = txStates.filter((x) => isGovernanceTx(x) === false && isFixedFee(x)).reduce((sum, x) => sum.add(new _ocap_util.BN(x.tx.itxJson.actualFee)), new _ocap_util.BN(0));
+	const totalMissingFee = minRequiredReward.sub(totalFixedFee);
+	const minTxFee = minRequiredReward.div(new _ocap_util.BN(txStates.length));
+	const changes = {
+		stake: [],
+		account: []
+	};
+	dynamicFeeTxs.forEach((x) => {
+		const maxFee = new _ocap_util.BN(x.tx.itxJson.maxFee);
+		const defaults = getTxFee({
+			amount: x.tx.itxJson.token.value,
+			feeRate: withdrawFeeRate,
+			maxFee: maxWithdrawFee,
+			minFee: minWithdrawFee,
+			stringify: false
+		});
+		let actualFee = new _ocap_util.BN(0);
+		if (totalMissingFee.isNeg()) actualFee = defaults.reward;
+		else actualFee = totalMissingFee.mul(maxFee).div(totalDynamicFee);
+		if (actualFee.isNeg()) throw new _ocap_util_lib_error.CustomError("NEGATIVE_ACTUAL_FEE", "Got negative actualFee for tx, abort!");
+		if (actualFee.lt(defaults.reward)) actualFee = defaults.reward;
+		if (actualFee.lt(minTxFee)) actualFee = minTxFee;
+		if (actualFee.lt(maxFee)) {
+			const refundFee = maxFee.sub(actualFee).toString(10);
+			changes.account.push({
+				address: x.tx.from,
+				delta: refundFee,
+				action: "refund"
+			});
+			changes.stake.push({
+				address: locker,
+				delta: `-${refundFee}`,
+				action: "refund"
+			});
+		}
+		x.tx.itxJson.actualFee = actualFee.toString(10);
+	});
+	txStates.filter((x) => isGovernanceTx(x) === false).forEach((x) => {
+		const user = x.tx.itxJson.token.value;
+		const fee = x.tx.itxJson.actualFee;
+		const total = getBNSum(user, fee);
+		if (x.type === "deposit_token_v2") {
+			result.rewardAmount = result.rewardAmount.add(new _ocap_util.BN(fee));
+			result.mintedAmount = result.mintedAmount.add(new _ocap_util.BN(total));
+			changes.stake.push({
+				address: (0, _arcblock_did_util.toStakeAddress)(x.tx.itxJson.proposer, address),
+				delta: total,
+				action: "mint"
+			});
+		} else if (x.type === "withdraw_token_v2") {
+			result.rewardAmount = result.rewardAmount.add(new _ocap_util.BN(fee));
+			result.burnedAmount = result.burnedAmount.add(new _ocap_util.BN(user));
+			changes.stake.push({
+				address: (0, _arcblock_did_util.toStakeAddress)(x.tx.from, address),
+				delta: `-${user}`,
+				action: "burn"
+			});
+		}
+	});
+	const grouped = {
+		stake: (0, lodash_groupBy.default)(changes.stake, "address"),
+		account: (0, lodash_groupBy.default)(changes.account, "address")
+	};
+	result.stakeUpdates = Object.keys(grouped.stake).reduce((acc, x) => {
+		acc[x] = {
+			address: x,
+			token: tokenAddress,
+			delta: getBNSum(...grouped.stake[x].map((c) => c.delta)),
+			action: grouped.stake[x][grouped.stake[x].length - 1].action
+		};
+		return acc;
+	}, {});
+	result.accountUpdates = Object.keys(grouped.account).reduce((acc, x) => {
+		acc[x] = {
+			address: x,
+			token: tokenAddress,
+			delta: getBNSum(...grouped.account[x].map((c) => c.delta)),
+			action: grouped.account[x][grouped.account[x].length - 1].action
+		};
+		return acc;
+	}, {});
+	return {
+		mintedAmount: result.mintedAmount.toString(10),
+		burnedAmount: result.burnedAmount.toString(10),
+		rewardAmount: result.rewardAmount.toString(10),
+		stakeUpdates: result.stakeUpdates,
+		accountUpdates: result.accountUpdates
+	};
+};
+const isGasStakeAddress = (sender, stakeId) => (0, _arcblock_did_util.toStakeAddress)(sender, sender) === stakeId;
+const isGasStakeInput = (inputs, token) => {
+	if (inputs.length !== 1) return false;
+	const [{ assetsList, tokensList }] = inputs;
+	if (assetsList.length > 0) return false;
+	if (tokensList.length !== 1) return false;
+	const [tokenInput] = tokensList;
+	if (tokenInput.address !== token) return false;
+	return true;
+};
+const isGasStakeValid = (state, config) => {
+	if (!state) return false;
+	const { token, transaction } = config;
+	const { minStake } = transaction.txGas;
+	const expectedMin = (0, _ocap_util.fromTokenToUnit)(minStake, token.decimal);
+	if (state.tokens) {
+		if (new _ocap_util.BN(state.tokens[token.address] || 0).gte(expectedMin)) return true;
+	}
+	if (state.revokedTokens) {
+		if (new _ocap_util.BN(state.revokedTokens[token.address] || 0).gte(expectedMin)) return true;
+	}
+	return false;
+};
+
+//#endregion
+exports.RATE_BASE = RATE_BASE;
+exports.applyTokenChange = applyTokenChange;
+exports.applyTokenUpdates = applyTokenUpdates;
+exports.decodeAnySafe = decodeAnySafe;
+exports.ensureBlockReward = ensureBlockReward;
+exports.fixTokenInput = fixTokenInput;
+exports.getBNSum = getBNSum;
+exports.getDelegationRequirements = getDelegationRequirements;
+exports.getRewardLocker = getRewardLocker;
+exports.getTxFee = getTxFee;
+exports.isFixedFee = isFixedFee;
+exports.isGasStakeAddress = isGasStakeAddress;
+exports.isGasStakeInput = isGasStakeInput;
+exports.isGasStakeValid = isGasStakeValid;
+exports.splitTxFee = splitTxFee;

package/lib/util.d.cts

@@ -0,0 +1,141 @@
+import { IChainConfig, IStakeState, TokenBalanceMap } from "@ocap/types";
+import { BN } from "@ocap/util";
+import { AnyData } from "@ocap/message";
+
+//#region src/util.d.ts
+/** Token update input for applyTokenUpdates */
+interface ITokenUpdateInput {
+  address: string;
+  value: string;
+}
+/** State with token balances */
+interface IStateWithTokens {
+  tokens?: TokenBalanceMap;
+}
+/** Token change input for applyTokenChange */
+interface ITokenChange {
+  token: string;
+  delta: string | BN;
+}
+/** Tx fee calculation params */
+interface ITxFeeParams {
+  amount: string;
+  feeRate: number;
+  maxFee: string;
+  minFee: string;
+  stringify?: boolean;
+}
+/** Tx fee result (stringified) */
+interface ITxFeeResultString {
+  total: string;
+  user: string;
+  reward: string;
+}
+/** Tx fee result (BN) */
+interface ITxFeeResultBN {
+  total: BN;
+  user: BN;
+  reward: BN;
+}
+/** Context for getDelegationRequirements */
+interface IDelegationContext {
+  txType: string;
+  config: IChainConfig;
+}
+/** Delegation requirement */
+interface IDelegationRequirement {
+  type: string;
+  address: string;
+  value: string;
+}
+/** Split tx fee params */
+interface ISplitTxFeeParams {
+  total: string;
+  shares?: Record<string, number>;
+  stringify?: boolean;
+  rateBase?: BN;
+}
+/** Rollup state for ensureBlockReward */
+interface IRollupStateForReward {
+  address: string;
+  withdrawFeeRate: number;
+  minWithdrawFee: string;
+  maxWithdrawFee: string;
+  tokenAddress: string;
+}
+/** Tx state for ensureBlockReward */
+interface ITxStateForReward {
+  type: string;
+  tx: {
+    from: string;
+    itxJson: {
+      maxFee?: string;
+      actualFee?: string;
+      token?: {
+        value: string;
+      };
+      proposer?: string;
+    };
+  };
+}
+/** Block reward result */
+interface IBlockRewardResult {
+  mintedAmount: string;
+  burnedAmount: string;
+  rewardAmount: string;
+  stakeUpdates: Record<string, {
+    address: string;
+    token: string;
+    delta: string;
+    action: string;
+  }>;
+  accountUpdates: Record<string, {
+    address: string;
+    token: string;
+    delta: string;
+    action: string;
+  }>;
+}
+/** Tx input for isGasStakeInput */
+interface ITxInput {
+  assetsList: string[];
+  tokensList: Array<{
+    address: string;
+    value: string;
+  }>;
+}
+/** Token input for fixTokenInput */
+interface ITokenInputForFix {
+  tokensList: Array<{
+    address?: string;
+    value: string;
+  }>;
+}
+declare const RATE_BASE: any;
+declare const decodeAnySafe: (encoded: AnyData | null) => AnyData | null;
+declare const applyTokenUpdates: (tokens: ITokenUpdateInput[], state: IStateWithTokens | IStateWithTokens[] | null | undefined, operator: "add" | "sub") => IStateWithTokens | IStateWithTokens[] | Record<string, string>;
+declare const applyTokenChange: (state: IStateWithTokens | IStateWithTokens[], change: ITokenChange) => IStateWithTokens | IStateWithTokens[] | Record<string, never>;
+declare const fixTokenInput: (input: ITokenInputForFix, config: IChainConfig) => ITokenInputForFix;
+declare const getTxFee: ({
+  amount,
+  feeRate,
+  maxFee,
+  minFee,
+  stringify
+}: ITxFeeParams) => ITxFeeResultString | ITxFeeResultBN;
+declare const getDelegationRequirements: (context: IDelegationContext) => IDelegationRequirement[];
+declare const splitTxFee: ({
+  total,
+  shares,
+  stringify,
+  rateBase
+}: ISplitTxFeeParams) => Record<string, string | BN>;
+declare const getRewardLocker: (rollupAddress: string) => string;
+declare const getBNSum: (...args: Array<string | string[]>) => string;
+declare const isFixedFee: (x: ITxStateForReward) => boolean;
+declare const ensureBlockReward: (rollupState: IRollupStateForReward, minReward: string, txStates: ITxStateForReward[]) => IBlockRewardResult;
+declare const isGasStakeAddress: (sender: string, stakeId: string) => boolean;
+declare const isGasStakeInput: (inputs: ITxInput[], token: string) => boolean;
+declare const isGasStakeValid: (state: IStakeState | null | undefined, config: IChainConfig) => boolean;
+//#endregion
+export { RATE_BASE, applyTokenChange, applyTokenUpdates, decodeAnySafe, ensureBlockReward, fixTokenInput, getBNSum, getDelegationRequirements, getRewardLocker, getTxFee, isFixedFee, isGasStakeAddress, isGasStakeInput, isGasStakeValid, splitTxFee };

package/package.json

@@ -3,13 +3,38 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.28.8",
+  "version": "1.29.0",
   "description": "Predefined tx pipeline sets to execute certain type of transactions",
-  "main": "lib/index.js",
+  "type": "module",
+  "main": "./lib/index.cjs",
+  "module": "./esm/index.mjs",
+  "types": "./esm/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./esm/index.d.mts",
+      "import": "./esm/index.mjs",
+      "default": "./lib/index.cjs"
+    },
+    "./lib/*.js": {
+      "types": "./esm/*.d.mts",
+      "import": "./esm/*.mjs",
+      "default": "./lib/*.cjs"
+    },
+    "./lib/*": {
+      "types": "./esm/*.d.mts",
+      "import": "./esm/*.mjs",
+      "default": "./lib/*.cjs"
+    },
+    "./tools/*": "./tools/*.ts"
+  },
   "files": [
-    "lib"
+    "lib",
+    "esm",
+    "tools"
   ],
   "scripts": {
+    "build": "tsdown",
+    "prebuild": "rm -rf lib esm",
     "lint": "biome check",
     "lint:fix": "biome check --write",
     "test": "bun test",
@@ -20,25 +45,25 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@arcblock/did": "1.28.8",
-    "@arcblock/did-util": "1.28.8",
-    "@arcblock/jwt": "1.28.8",
-    "@arcblock/validator": "1.28.8",
-    "@arcblock/vc": "1.28.8",
+    "@arcblock/did": "1.29.0",
+    "@arcblock/did-util": "1.29.0",
+    "@arcblock/jwt": "1.29.0",
+    "@arcblock/validator": "1.29.0",
+    "@arcblock/vc": "1.29.0",
     "@blocklet/xss": "^0.3.7",
-    "@ocap/asset": "1.28.8",
-    "@ocap/client": "1.28.8",
-    "@ocap/mcrypto": "1.28.8",
-    "@ocap/merkle-tree": "1.28.8",
-    "@ocap/message": "1.28.8",
-    "@ocap/state": "1.28.8",
-    "@ocap/tx-pipeline": "1.28.8",
-    "@ocap/util": "1.28.8",
-    "@ocap/wallet": "1.28.8",
-    "debug": "^4.3.6",
+    "@ocap/asset": "1.29.0",
+    "@ocap/client": "1.29.0",
+    "@ocap/mcrypto": "1.29.0",
+    "@ocap/merkle-tree": "1.29.0",
+    "@ocap/message": "1.29.0",
+    "@ocap/state": "1.29.0",
+    "@ocap/tx-pipeline": "1.29.0",
+    "@ocap/types": "1.29.0",
+    "@ocap/util": "1.29.0",
+    "@ocap/wallet": "1.29.0",
+    "debug": "^4.4.3",
     "deep-diff": "^1.0.2",
-    "empty-value": "^1.0.1",
-    "lodash": "^4.17.21",
+    "lodash": "^4.17.23",
     "url-join": "^4.0.1"
   },
   "resolutions": {
@@ -46,8 +71,10 @@
     "elliptic": "6.5.3"
   },
   "devDependencies": {
-    "@ocap/e2e-test": "1.28.8",
-    "@ocap/statedb-memory": "1.28.8",
+    "@ocap/e2e-test": "1.29.0",
+    "@ocap/statedb-memory": "1.29.0",
+    "@types/debug": "^4.1.12",
+    "@types/lodash": "^4.17.16",
     "start-server-and-test": "^1.14.0"
   }
 }