@ocap/tx-protocols 1.28.8 → 1.29.0

package/esm/protocols/trade/transfer-v3.mjs

@@ -0,0 +1,270 @@
+import { applyTokenChange, applyTokenUpdates } from "../../util.mjs";
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { account, asset } from "@ocap/state";
+import { BN } from "@ocap/util";
+import Debug from "debug";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import { Joi, schemas } from "@arcblock/validator";
+import { getRelatedAddresses } from "@ocap/util/lib/get-related-addr";
+import { promisify } from "node:util";
+import isEqual from "lodash/isEqual.js";
+
+//#region src/protocols/trade/transfer-v3.ts
+const debug = Debug("@ocap/tx-protocols:transfer-v2");
+const runner = new Runner("transfer_v3");
+const verifyAssetOwner = promisify(pipes.VerifyUpdater({
+	assetKey: "assets",
+	ownerKey: "owner"
+}));
+const schema = Joi.object({
+	inputsList: schemas.multiInput.min(1).required(),
+	outputsList: schemas.multiInput.min(1).required(),
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use(({ itx }, next) => {
+	const { error } = schema.validate(itx);
+	return next(error ? new CustomError("INVALID_TX", `Invalid itx: ${error.message}`) : void 0);
+});
+runner.use(pipes.VerifyTxInput({
+	fieldKey: "itx.inputs",
+	inputsKey: "inputs",
+	sendersKey: "senders",
+	tokensKey: "inputTokens",
+	assetsKey: "inputAssets"
+}));
+runner.use(pipes.VerifyTxInput({
+	fieldKey: "itx.outputs",
+	inputsKey: "outputs",
+	sendersKey: "receivers",
+	tokensKey: "outputTokens",
+	assetsKey: "outputAssets"
+}));
+runner.use(pipes.VerifyListSize({ listKey: [
+	"inputs",
+	"outputs",
+	"senders",
+	"receivers",
+	"inputTokens",
+	"inputAssets",
+	"outputTokens",
+	"outputAssets"
+] }));
+runner.use(pipes.VerifyInfo([
+	{
+		error: "INVALID_TX",
+		message: "An owner can not exist in tx input and output at the same time",
+		fn: (ctx) => {
+			const context = ctx;
+			return (context.senders || []).every((x) => (context.receivers || []).includes(x) === false);
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Input and output token address does not match",
+		fn: (ctx) => {
+			const context = ctx;
+			return isEqual(context.inputTokens || [], context.outputTokens || []);
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Input and output asset address does not match",
+		fn: (ctx) => {
+			const context = ctx;
+			return isEqual(context.inputAssets || [], context.outputAssets || []);
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Input and output token amount does not match",
+		fn: (ctx) => {
+			const context = ctx;
+			const inputs = context.inputs || [];
+			const outputs = context.outputs || [];
+			const inputTokens = context.inputTokens || [];
+			const inputMap = {};
+			const outputMap = {};
+			inputs.forEach((input) => {
+				getListField(input, "tokens").forEach(({ address, value }) => {
+					if (typeof inputMap[address] === "undefined") inputMap[address] = new BN(0);
+					inputMap[address] = inputMap[address].add(new BN(value));
+				});
+			});
+			outputs.forEach((output) => {
+				getListField(output, "tokens").forEach(({ address, value }) => {
+					if (typeof outputMap[address] === "undefined") outputMap[address] = new BN(0);
+					outputMap[address] = outputMap[address].add(new BN(value));
+				});
+			});
+			return inputTokens.every((address) => inputMap[address].eq(outputMap[address]));
+		}
+	}
+]));
+runner.use(pipes.ExtractState({
+	from: "inputTokens",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use((context, next) => {
+	const { tx: tx$1, inputTokens = [], tokenStates = [] } = context;
+	if (inputTokens.every((tokenAddress) => {
+		const tokenState = tokenStates.find((t) => t.address === tokenAddress);
+		return tokenState && tokenState.type === "CreditToken" && tokenState.issuer === tx$1.from;
+	})) return next();
+	return pipes.VerifyMultiSigV2({ signersKey: "senders" })(context, next);
+});
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "senders",
+	to: "signerStates",
+	status: "INVALID_SIGNER_STATE",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "receivers",
+	to: "receiverStates",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.VerifyBlocked({ stateKeys: ["signerStates", "receiverStates"] }));
+runner.use(pipes.AntiLandAttack({
+	senderState: "signerStates",
+	receiverState: "receiverStates"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(pipes.VerifyTokenBalance({
+	ownerKey: "signerStates",
+	conditionKey: "inputs"
+}));
+runner.use(pipes.verifyTokenAccess({
+	statesKey: "tokenStates",
+	listFieldKey: "spenders",
+	accountKeys: ["senderState"],
+	errorMessage: "Account {address} is not allowed to transfer token {tokenAddress}"
+}));
+runner.use(pipes.ExtractState({
+	from: "inputAssets",
+	to: "assetStates",
+	status: "INVALID_ASSET",
+	table: "asset"
+}));
+runner.use(pipes.VerifyTransferrable({ assets: "assetStates" }));
+runner.use(async (context, next) => {
+	const { inputs = [], assetStates = [], signerStates = [] } = context;
+	for (const input of inputs) {
+		const { owner } = input;
+		const assetsList = getListField(input, "assets");
+		const states = assetStates.filter((x) => assetsList.includes(x.address));
+		const signer = signerStates.find((x) => x.address === owner);
+		try {
+			await verifyAssetOwner({
+				assets: states,
+				owner: signer
+			});
+		} catch (err) {
+			return next(err);
+		}
+	}
+	return next();
+});
+runner.use(ensure_gas_default((context) => {
+	const ops = {
+		create: 0,
+		update: 0,
+		payment: 0
+	};
+	ops.update += (context.signerStates || []).length;
+	ops.update += (context.inputAssets || []).length;
+	(context.receivers || []).forEach((x) => {
+		if ((context.receiverStates || []).find((r) => r.address === x)) ops.update += 1;
+		else ops.create += 1;
+	});
+	if (context.senderState) ops.update += 1;
+	else ops.create += 1;
+	return ops;
+}));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, inputs = [], outputs = [], receivers = [], senderState, signerStates = [], senderChange, updateVaults, receiverStates = [], assetStates = [], statedb } = context;
+	const signerUpdates = {};
+	inputs.forEach((x) => {
+		const { owner } = x;
+		signerUpdates[owner] = applyTokenUpdates(getListField(x, "tokens"), signerStates.find((s) => s.address === owner), "sub");
+		if (senderChange && owner === senderChange.address) signerUpdates[owner] = applyTokenChange(signerUpdates[owner], senderChange);
+	});
+	const receiverUpdates = {};
+	const assetUpdates = {};
+	outputs.forEach((x) => {
+		const { owner } = x;
+		const tokensList = getListField(x, "tokens");
+		const assetsList = getListField(x, "assets");
+		const ownerState = receiverStates.find((s) => getRelatedAddresses(s).includes(owner)) || { address: owner };
+		receiverUpdates[ownerState.address] = applyTokenUpdates(tokensList, ownerState, "add");
+		if (senderChange && ownerState.address === senderChange.address) receiverUpdates[ownerState.address] = applyTokenChange(receiverUpdates[ownerState.address], senderChange);
+		assetsList.forEach((address) => {
+			assetUpdates[address] = { owner: ownerState.address };
+		});
+	});
+	const sender = senderState ? senderState.address : tx$1.from;
+	const isAlsoSigner = !!signerUpdates[sender];
+	const isAlsoReceiver = !!receiverUpdates[sender];
+	const senderUpdatesLocal = {};
+	if (!isAlsoSigner && !isAlsoReceiver && senderState && senderChange) senderUpdatesLocal[sender] = applyTokenChange(senderState, senderChange);
+	debug("transfer-v3", {
+		signerUpdates,
+		receiverUpdates,
+		assetUpdates,
+		isAlsoSigner,
+		isAlsoReceiver
+	});
+	const [newSenderState, newSignerStates, newReceiverStates, newAssetStates] = await Promise.all([
+		statedb.account.updateOrCreate(senderState ?? null, account.updateOrCreate(senderState ?? null, Object.assign({
+			address: sender,
+			nonce: tx$1.nonce,
+			pk: tx$1.pk
+		}, signerUpdates[sender] || {}, receiverUpdates[sender] || {}, senderUpdatesLocal[sender] || {}), context), context),
+		Promise.all(signerStates.filter((x) => x.address !== sender).map((x) => statedb.account.update(x.address, account.update(x, signerUpdates[x.address], context), context))),
+		Promise.all(receivers.filter((x) => x !== sender).map((x) => {
+			const receiverState = receiverStates.find((s) => getRelatedAddresses(s).includes(x));
+			const owner = receiverState ? receiverState.address : x;
+			const updates = receiverUpdates[owner] || {};
+			return statedb.account.updateOrCreate(receiverState ?? null, account.updateOrCreate(receiverState ?? null, {
+				...updates,
+				address: owner
+			}, context), context);
+		})),
+		Promise.all(assetStates.map((x) => statedb.asset.update(x.address, asset.update(x, assetUpdates[x.address], context), context)))
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.signerStates = isAlsoSigner ? newSignerStates.concat(newSenderState) : newSignerStates;
+	context.receiverStates = isAlsoReceiver ? newReceiverStates.concat(newSenderState) : newReceiverStates;
+	context.assetStates = newAssetStates;
+	debug("transfer-v3", {
+		inputs,
+		outputs
+	});
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var transfer_v3_default = runner;
+
+//#endregion
+export { transfer_v3_default as default };

package/esm/util.d.mts

@@ -0,0 +1,141 @@
+import { BN } from "@ocap/util";
+import { AnyData } from "@ocap/message";
+import { IChainConfig, IStakeState, TokenBalanceMap } from "@ocap/types";
+
+//#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/esm/util.mjs

@@ -0,0 +1,278 @@
+import { CustomError } from "@ocap/util/lib/error";
+import { toStakeAddress } from "@arcblock/did-util";
+import { BN, fromTokenToUnit } from "@ocap/util";
+import { decodeAny } from "@ocap/message";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import cloneDeep from "lodash/cloneDeep.js";
+import flattenDeep from "lodash/flattenDeep.js";
+import groupBy from "lodash/groupBy.js";
+
+//#region src/util.ts
+const ZERO = new BN(0);
+const RATE_BASE = new 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 = 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 = 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 CustomError("UNEXPECTED_OPERATOR", `Invalid operator when applyTokenUpdates: ${operator}`);
+	if (!state) return {};
+	const states = cloneDeep((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 BN(value);
+		let fulfilled = new BN(0);
+		for (let j = 0; j < states.length; j++) {
+			const origin = states[j].tokens;
+			const updated = cloneDeep(origin);
+			const balance = new 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 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 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) => {
+	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 BN(amount);
+	const maxFeeAmount = new BN(maxFee);
+	const minFeeAmount = new BN(minFee);
+	if (feeRate < 0) throw new CustomError("NEGATIVE_FEE_RATE", "Unexpected negative feeRate when getTxFee, abort!");
+	if (userAmount.isNeg()) throw new CustomError("NEGATIVE_AMOUNT", "Unexpected negative amount when getTxFee, abort!");
+	if (maxFeeAmount.isNeg()) throw new CustomError("NEGATIVE_MAX_FEE", "Unexpected negative maxFee when getTxFee, abort!");
+	if (minFeeAmount.isNeg()) throw new CustomError("NEGATIVE_MIN_FEE", "Unexpected negative minFee when getTxFee, abort!");
+	let rewardAmount = userAmount.mul(new 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: fromTokenToUnit(txFee, config.token.decimal).toString()
+	}];
+};
+const splitTxFee = ({ total, shares = {}, stringify = true, rateBase = RATE_BASE }) => {
+	const totalAmount = new BN(total);
+	if (totalAmount.isNeg()) throw new CustomError("NEGATIVE_TOTAL_AMOUNT", "Unexpected negative total when splitTxFee, abort!");
+	Object.keys(shares).forEach((key) => {
+		if (shares[key] < 0) throw new CustomError("NEGATIVE_FEE_SHARE", `Unexpected negative shares[${key}] when splitTxFee, abort!`);
+	});
+	if (Object.values(shares).reduce((sum, x) => sum.add(new BN(x)), new BN(0)).eq(rateBase) === false) throw new CustomError("INVALID_FEE_SHARE", "Invalid share config when splitTxFee, abort!");
+	const rewardShares = Object.keys(shares).reduce((acc, x) => {
+		acc[x] = totalAmount.mul(new BN(shares[x])).div(rateBase);
+		return acc;
+	}, {});
+	if (Object.values(rewardShares).reduce((sum, x) => sum.add(x), new BN(0)).eq(totalAmount) === false) {
+		const firstKey = Object.keys(rewardShares)[0];
+		const currentSum = Object.values(rewardShares).reduce((sum, x) => sum.add(x), new 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) => toStakeAddress(rollupAddress, rollupAddress);
+const getBNSum = (...args) => flattenDeep(args).reduce((sum, x) => sum.add(new BN(x)), new BN(0)).toString(10);
+const isGovernanceTx = (x) => [
+	"pause_rollup",
+	"resume_rollup",
+	"migrate_rollup"
+].includes(x.type);
+const isFixedFee = (x) => !x.tx.itxJson.maxFee || new 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 BN(0),
+		burnedAmount: new BN(0),
+		rewardAmount: new BN(0),
+		stakeUpdates: {},
+		accountUpdates: {}
+	};
+	const maxPossibleReward = txStates.reduce((sum, x) => sum.add(new BN(isFixedFee(x) ? x.tx.itxJson.actualFee : x.tx.itxJson.maxFee)), new BN(0));
+	const minRequiredReward = new BN(minReward);
+	if (maxPossibleReward.lt(minRequiredReward)) throw new 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 BN(x.tx.itxJson.maxFee)), new BN(0));
+	const totalFixedFee = txStates.filter((x) => isGovernanceTx(x) === false && isFixedFee(x)).reduce((sum, x) => sum.add(new BN(x.tx.itxJson.actualFee)), new BN(0));
+	const totalMissingFee = minRequiredReward.sub(totalFixedFee);
+	const minTxFee = minRequiredReward.div(new BN(txStates.length));
+	const changes = {
+		stake: [],
+		account: []
+	};
+	dynamicFeeTxs.forEach((x) => {
+		const maxFee = new 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 BN(0);
+		if (totalMissingFee.isNeg()) actualFee = defaults.reward;
+		else actualFee = totalMissingFee.mul(maxFee).div(totalDynamicFee);
+		if (actualFee.isNeg()) throw new 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 BN(fee));
+			result.mintedAmount = result.mintedAmount.add(new BN(total));
+			changes.stake.push({
+				address: toStakeAddress(x.tx.itxJson.proposer, address),
+				delta: total,
+				action: "mint"
+			});
+		} else if (x.type === "withdraw_token_v2") {
+			result.rewardAmount = result.rewardAmount.add(new BN(fee));
+			result.burnedAmount = result.burnedAmount.add(new BN(user));
+			changes.stake.push({
+				address: toStakeAddress(x.tx.from, address),
+				delta: `-${user}`,
+				action: "burn"
+			});
+		}
+	});
+	const grouped = {
+		stake: groupBy(changes.stake, "address"),
+		account: groupBy(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) => 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 = fromTokenToUnit(minStake, token.decimal);
+	if (state.tokens) {
+		if (new BN(state.tokens[token.address] || 0).gte(expectedMin)) return true;
+	}
+	if (state.revokedTokens) {
+		if (new BN(state.revokedTokens[token.address] || 0).gte(expectedMin)) return true;
+	}
+	return false;
+};
+
+//#endregion
+export { RATE_BASE, applyTokenChange, applyTokenUpdates, decodeAnySafe, ensureBlockReward, fixTokenInput, getBNSum, getDelegationRequirements, getRewardLocker, getTxFee, isFixedFee, isGasStakeAddress, isGasStakeInput, isGasStakeValid, splitTxFee };