@ocap/tx-protocols 1.28.8 → 1.29.0

package/esm/protocols/token/create.d.mts

@@ -0,0 +1,4 @@
+//#region src/protocols/token/create.d.ts
+declare const runner: any;
+//#endregion
+export { runner as default };

package/esm/protocols/token/create.mjs

@@ -0,0 +1,150 @@
+import { decodeAnySafe, getDelegationRequirements } 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 { toTokenAddress } from "@arcblock/did-util";
+import { account, delegation, token } from "@ocap/state";
+import { fromTokenToUnit } from "@ocap/util";
+import Debug from "debug";
+import cloneDeep from "lodash/cloneDeep.js";
+import { Joi, schemas } from "@arcblock/validator";
+import uniq from "lodash/uniq.js";
+import isEmpty from "lodash/isEmpty.js";
+
+//#region src/protocols/token/create.ts
+const debug = Debug("@ocap/tx-protocols:create-token");
+const MAX_TOTAL_SUPPLY = fromTokenToUnit(1e4 * 1e8, 18);
+const runner = new Runner("create_token");
+runner.use(pipes.VerifyMultiSig(0));
+const schema = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_TOKEN").required(),
+	name: Joi.string().min(1).max(32).required(),
+	description: Joi.string().min(16).max(128).required(),
+	symbol: Joi.string().min(2).max(6).uppercase().required(),
+	unit: Joi.string().min(1).max(6).lowercase().required(),
+	decimal: Joi.number().min(2).max(18).required(),
+	icon: Joi.string().optional().allow(null).valid(""),
+	totalSupply: Joi.BN().greater(0).max(MAX_TOTAL_SUPPLY).required(),
+	initialSupply: Joi.BN().greater(0).max(Joi.ref("totalSupply")).required(),
+	maxTotalSupply: Joi.alternatives().try(Joi.BN().greater(0).max(Joi.ref("totalSupply")), Joi.string().valid("")).optional().allow(null),
+	foreignToken: schemas.foreignToken.optional().allow(null).default(null),
+	spendersList: Joi.array().items(Joi.DID().prefix()).max(30).optional().allow(null).default(null),
+	tokenFactoryAddress: Joi.forbidden(),
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use(({ itx }, next) => {
+	const { error, value } = schema.validate(itx);
+	if (error) return next(new CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	const spendersList = value.spendersList;
+	itx.spenders = spendersList?.length ? uniq(spendersList) : null;
+	delete itx.spendersList;
+	return next();
+});
+runner.use(pipes.VerifyInfo([{
+	error: "INVALID_TOKEN",
+	message: "Token address is not valid",
+	fn: (ctx) => {
+		const context = ctx;
+		const itx = cloneDeep(context.itx);
+		itx.data = decodeAnySafe(itx.data ?? null);
+		itx.address = "";
+		return toTokenAddress(itx) === context.itx.address;
+	}
+}]));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(pipes.ExtractState({
+	from: "tx.delegator",
+	to: "delegatorState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "delegatorState",
+	addressKey: "tx.delegator"
+}));
+runner.use(pipes.VerifyDelegation({
+	type: "signature",
+	signerKey: "senderState",
+	delegatorKey: "delegatorState",
+	getRequirements: getDelegationRequirements
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.address",
+	to: "tokenState",
+	table: "token",
+	status: "OK"
+}));
+runner.use(pipes.VerifyInfo([{
+	error: "DUPLICATE_TOKEN",
+	message: "Token address already exists on chain",
+	fn: (ctx) => isEmpty(ctx.tokenState)
+}]));
+runner.use(async function EnsureTokenSymbol(context, next) {
+	const { symbol } = context.config.token;
+	if (symbol.toLowerCase() === context.itx.symbol.toLowerCase()) return next(new CustomError("DUPLICATE_SYMBOL", `Token symbol can not be ${symbol}`));
+	if (await context.statedb.token.existBySymbol(context.itx.symbol, context)) return next(new CustomError("DUPLICATE_SYMBOL", "Token symbol already exists"));
+	return next();
+}, { persistError: true });
+runner.use(ensure_gas_default((context) => {
+	const result = {
+		create: 1,
+		update: 2,
+		payment: 0
+	};
+	if (context.delegatorState) result.update += 1;
+	return result;
+}));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, itx, statedb, senderState, delegatorState, delegationState, senderUpdates, updateVaults } = context;
+	const data = decodeAnySafe(itx.data ?? null);
+	const owner = delegatorState ? delegatorState.address : senderState.address;
+	const delegatorUpdates = {};
+	const updates = senderUpdates;
+	updates.tokens = updates.tokens || senderState.tokens || {};
+	if (delegatorState) {
+		delegatorUpdates.tokens = delegatorState.tokens || {};
+		delegatorUpdates.tokens[itx.address] = itx.initialSupply;
+	} else updates.tokens[itx.address] = itx.initialSupply;
+	const [newSenderState, tokenState, newDelegatorState, newDelegationState] = await Promise.all([
+		statedb.account.update(senderState.address, account.update(senderState, {
+			nonce: tx$1.nonce,
+			pk: tx$1.pk,
+			...senderUpdates
+		}, context), context),
+		statedb.token.create(itx.address, token.create({
+			...cloneDeep(itx),
+			data,
+			issuer: owner,
+			type: "Token"
+		}, context), context),
+		delegatorState ? statedb.account.update(delegatorState.address, account.update(delegatorState, delegatorUpdates, context), context) : null,
+		context.isDelegationChanged ? statedb.delegation.update(delegationState.address, delegation.update(delegationState, {}, context), context) : delegationState
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.tokenState = tokenState;
+	context.delegatorState = newDelegatorState ?? void 0;
+	context.delegationState = newDelegationState ?? void 0;
+	debug("create token v2", tokenState);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var create_default = runner;
+
+//#endregion
+export { create_default as default };

package/esm/protocols/token/deposit-v2.d.mts

@@ -0,0 +1,11 @@
+//#region src/protocols/token/deposit-v2.d.ts
+/** Token change for updates */
+interface TokenChange {
+  address: string;
+  token: string;
+  delta: string;
+  action: string;
+}
+declare const runner: any;
+//#endregion
+export { TokenChange, runner as default };

package/esm/protocols/token/deposit-v2.mjs

@@ -0,0 +1,216 @@
+import { applyTokenChange, applyTokenUpdates, getBNSum, getRewardLocker, getTxFee } from "../../util.mjs";
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import verify_signers_default from "../rollup/pipes/verify-signers.mjs";
+import verify_status_default from "../rollup/pipes/verify-status.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { toStakeAddress } from "@arcblock/did-util";
+import { account, evidence, stake } from "@ocap/state";
+import { BN, fromUnitToToken } from "@ocap/util";
+import Debug from "debug";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import { Joi, patterns, schemas } from "@arcblock/validator";
+
+//#region src/protocols/token/deposit-v2.ts
+const debug = Debug("@ocap/tx-protocols:deposit-token");
+const schema = Joi.object({
+	token: schemas.tokenInput.required(),
+	to: Joi.DID().prefix().wallet("ethereum").required(),
+	proposer: Joi.DID().prefix().wallet("ethereum").required(),
+	evidence: Joi.object({ hash: Joi.string().regex(patterns.txHash).required() }).required(),
+	rollup: Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	actualFee: Joi.BN().min(0).required(),
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const runner = new Runner("deposit_token_v2");
+runner.use(({ tx: tx$1, itx }, next) => {
+	const { error } = schema.validate(itx);
+	if (error) return next(new CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	if (itx.to !== tx$1.from) return next(new CustomError("INVALID_TX", "You can only deposit to tx sender account"));
+	const signatures = getListField(tx$1, "signatures");
+	if (signatures.some((x) => x.signer === itx.proposer) === false) return next(new CustomError("INVALID_TX", "itx.proposer must exist in signatures"));
+	if (signatures.some((x) => x.signer === tx$1.from)) return next(new CustomError("INVALID_TX", "tx.from should not exist in signatures"));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "itx.rollup",
+	to: "rollupState",
+	status: "INVALID_ROLLUP",
+	table: "rollup"
+}));
+runner.use(verify_status_default({ paused: false }));
+runner.use((context, next) => {
+	const { itx, rollupState } = context;
+	if (rollupState.tokenAddress !== itx.token.address) return next(new CustomError("INVALID_TX", "Deposit token address does not match with rollup state"));
+	if (rollupState.validators.some((x) => x.address === itx.proposer) === false) return next(new CustomError("INVALID_TX", "itx.proposer does not exist in validators"));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "itx.evidence.hash",
+	to: "evidenceState",
+	status: "OK",
+	table: "evidence"
+}));
+runner.use(({ evidenceState }, next) => {
+	if (evidenceState) return next(new CustomError("INVALID_TX", "Deposit evidence already seen on this chain"));
+	return next();
+});
+runner.use(verify_signers_default({
+	signersKey: "tx.signaturesList",
+	allowSender: true
+}));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: "signers" }));
+runner.use(pipes.ExtractState({
+	from: "itx.token.address",
+	to: "tokenState",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use((context, next) => {
+	const { itx } = context;
+	context.stakeAddress = toStakeAddress(itx.proposer, itx.rollup);
+	context.lockerAddress = getRewardLocker(itx.rollup);
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "lockerAddress",
+	to: "lockerState",
+	status: "OK",
+	table: "stake"
+}));
+runner.use(pipes.ExtractState({
+	from: "stakeAddress",
+	to: "stakeState",
+	status: "INVALID_STAKE_STATE",
+	table: "stake"
+}));
+runner.use((context, next) => {
+	const { itx, stakeState, tokenState, rollupState } = context;
+	if (stakeState.revocable === true) return next(new CustomError("INVALID_STAKE_STATE", `Staking not locked for deposit: ${stakeState.address}`));
+	const depositAmount = new BN(itx.token.value).add(new BN(itx.actualFee));
+	const minDepositAmount = new BN(rollupState.minDepositAmount);
+	const maxDepositAmount = new BN(rollupState.maxDepositAmount);
+	if (depositAmount.lt(minDepositAmount)) return next(new CustomError("INVALID_TX", `Deposit amount must be greater than minDepositAmount: ${fromUnitToToken(minDepositAmount, tokenState.decimal)}`));
+	if (depositAmount.gt(maxDepositAmount)) return next(new CustomError("INVALID_TX", `Deposit amount must be less than maxDepositAmount: ${fromUnitToToken(maxDepositAmount, tokenState.decimal)}`));
+	const stakedAmount = new BN(stakeState.tokens[rollupState.tokenAddress] || 0);
+	if (depositAmount.gt(stakedAmount)) return next(new CustomError("INSUFFICIENT_STAKE", `Deposit amount must be less than available stake: ${fromUnitToToken(stakedAmount, tokenState.decimal)}`));
+	return next();
+});
+runner.use((context, next) => {
+	const { itx, rollupState, tokenState } = context;
+	const { depositFeeRate, maxDepositFee, minDepositFee } = rollupState;
+	const { reward } = getTxFee({
+		amount: itx.token.value,
+		feeRate: depositFeeRate,
+		maxFee: maxDepositFee,
+		minFee: minDepositFee
+	});
+	if (new BN(itx.actualFee).lt(new BN(reward))) return next(new CustomError("INVALID_TX", `itx.actualFee too low, expect at least ${fromUnitToToken(reward, tokenState.decimal)}, got ${fromUnitToToken(itx.actualFee, tokenState.decimal)}`));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "signers",
+	to: "signerStates",
+	status: "INVALID_SIGNER_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(ensure_gas_default((context) => {
+	const result = {
+		create: 1,
+		update: 1,
+		payment: 0
+	};
+	if (context.senderState) result.update += 1;
+	else result.create += 1;
+	if (context.lockerState) result.update += 1;
+	else result.create += 1;
+	return result;
+}));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, itx, statedb, senderState, stakeState, stakeAddress, lockerState, lockerAddress, senderChange, updateVaults } = context;
+	const user = itx.token.value;
+	const fee = itx.actualFee;
+	const total = getBNSum(user, fee);
+	const stakeUpdates = applyTokenUpdates([{
+		address: itx.token.address,
+		value: total
+	}], stakeState, "sub");
+	let senderUpdates = applyTokenUpdates([{
+		address: itx.token.address,
+		value: user
+	}], senderState || {}, "add");
+	const lockerUpdates = applyTokenUpdates([{
+		address: itx.token.address,
+		value: fee
+	}], lockerState || { tokens: {} }, "add");
+	if (senderChange && senderState) senderUpdates = applyTokenChange(senderUpdates, senderChange);
+	const sender = senderState ? senderState.address : tx$1.from;
+	const [newSenderState, newStakeState, newLockerState, evidenceState] = await Promise.all([
+		statedb.account.updateOrCreate(senderState ?? null, account.updateOrCreate(senderState ?? null, {
+			address: sender,
+			nonce: tx$1.nonce,
+			pk: tx$1.pk,
+			...senderUpdates
+		}, context), context),
+		statedb.stake.update(stakeAddress, stake.update(stakeState, stakeUpdates, context), context),
+		lockerState ? statedb.stake.update(lockerState.address, stake.update(lockerState, lockerUpdates, context), context) : statedb.stake.create(lockerAddress, stake.create({
+			address: lockerAddress,
+			sender: itx.rollup,
+			receiver: itx.rollup,
+			revocable: false,
+			message: "pending-block-reward",
+			revokeWaitingPeriod: 0,
+			...lockerUpdates
+		}, context), context),
+		statedb.evidence.create(itx.evidence.hash, evidence.create({
+			hash: itx.evidence.hash,
+			data: "rollup-deposit"
+		}, context), context)
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.stakeState = newStakeState;
+	context.evidenceState = evidenceState;
+	context.stakeStates = [newStakeState, newLockerState];
+	context.updatedAccounts = context.updatedAccounts || [];
+	context.updatedAccounts.push({
+		address: stakeAddress,
+		token: itx.token.address,
+		delta: `-${total}`,
+		action: "unlock"
+	}, {
+		address: sender,
+		token: itx.token.address,
+		delta: user,
+		action: "unlock"
+	}, {
+		address: lockerAddress,
+		token: itx.token.address,
+		delta: fee,
+		action: "pending"
+	});
+	debug("deposit-token-v2", itx);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var deposit_v2_default = runner;
+
+//#endregion
+export { deposit_v2_default as default };

package/esm/protocols/token/withdraw-v2.d.mts

@@ -0,0 +1,9 @@
+//#region src/protocols/token/withdraw-v2.d.ts
+/** Token input */
+interface TokenInput {
+  address: string;
+  value: string;
+}
+declare const runner: any;
+//#endregion
+export { TokenInput, runner as default };

package/esm/protocols/token/withdraw-v2.mjs

@@ -0,0 +1,222 @@
+import { applyTokenChange, applyTokenUpdates, getBNSum, getRewardLocker, getTxFee } from "../../util.mjs";
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import verify_status_default from "../rollup/pipes/verify-status.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { toStakeAddress } from "@arcblock/did-util";
+import { account, stake } from "@ocap/state";
+import { BN, fromUnitToToken } from "@ocap/util";
+import Debug from "debug";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import { Joi, schemas } from "@arcblock/validator";
+
+//#region src/protocols/token/withdraw-v2.ts
+const debug = Debug("@ocap/tx-protocols:withdraw-token");
+const verifyMultiSigV2 = pipes.VerifyMultiSigV2({ signersKey: "signers" });
+const schema = Joi.object({
+	token: schemas.tokenInput.required(),
+	to: Joi.DID().prefix().wallet("ethereum").required(),
+	rollup: Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	proposer: Joi.DID().prefix().wallet("ethereum").optional().allow(null).allow("").default(""),
+	actualFee: Joi.BN().min(0).required(),
+	maxFee: Joi.BN().min(0).required(),
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const runner = new Runner("withdraw_token_v2");
+runner.use(({ tx: tx$1, itx }, next) => {
+	const { error } = schema.validate(itx);
+	if (error) return next(new CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	if (itx.to !== tx$1.from) return next(new CustomError("INVALID_TX", "You can only withdraw to tx sender account"));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "itx.rollup",
+	to: "rollupState",
+	status: "INVALID_ROLLUP",
+	table: "rollup"
+}));
+runner.use(verify_status_default({ paused: false }));
+runner.use((context, next) => {
+	const { itx, rollupState } = context;
+	if (rollupState.tokenAddress !== itx.token.address) return next(new CustomError("INVALID_TX", "Withdraw token address does not match with rollup"));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "itx.token.address",
+	to: "tokenState",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use((context, next) => {
+	const { tx: tx$1, itx, tokenState, rollupState } = context;
+	const withdrawAmount = new BN(itx.token.value);
+	const minWithdrawAmount = new BN(rollupState.minWithdrawAmount);
+	const maxWithdrawAmount = new BN(rollupState.maxWithdrawAmount);
+	if (withdrawAmount.lt(minWithdrawAmount)) return next(new CustomError("INVALID_TX", `Withdraw amount must be greater than: ${fromUnitToToken(minWithdrawAmount, tokenState.decimal)}`));
+	if (withdrawAmount.gt(maxWithdrawAmount)) return next(new CustomError("INVALID_TX", `Withdraw amount must be less than maxWithdrawAmount: ${fromUnitToToken(maxWithdrawAmount, tokenState.decimal)}`));
+	const maxAmount = getBNSum(itx.token.value, itx.actualFee, itx.maxFee);
+	context.tokenConditions = {
+		owner: tx$1.from,
+		tokens: [{
+			address: itx.token.address,
+			value: maxAmount
+		}]
+	};
+	return next();
+});
+runner.use(pipes.VerifyTokenBalance({
+	ownerKey: "senderState",
+	conditionKey: "tokenConditions"
+}));
+runner.use((context, next) => {
+	const { itx, rollupState, tokenState } = context;
+	const { withdrawFeeRate, maxWithdrawFee, minWithdrawFee } = rollupState;
+	if (new BN(itx.maxFee).isZero()) {
+		const { reward } = getTxFee({
+			amount: itx.token.value,
+			feeRate: withdrawFeeRate,
+			maxFee: maxWithdrawFee,
+			minFee: minWithdrawFee
+		});
+		if (new BN(itx.actualFee).lt(new BN(reward))) return next(new CustomError("INVALID_TX", `itx.actualFee too low, expect at least ${fromUnitToToken(reward, tokenState.decimal)}, got ${fromUnitToToken(itx.actualFee, tokenState.decimal)}`));
+	}
+	return next();
+});
+runner.use((context, next) => {
+	const { tx: tx$1, itx } = context;
+	if (new BN(itx.maxFee).isZero()) return next();
+	const signatures = getListField(tx$1, "signatures");
+	if (signatures.length !== 1) return next(new CustomError("INVALID_TX", "Withdraw with maxFee should have one multi-sig"));
+	if (signatures.some((x) => x.signer === itx.proposer) === false) return next(new CustomError("INVALID_TX", "itx.proposer must exist in tx.signatures"));
+	context.signers = signatures.map((x) => x.signer);
+	verifyMultiSigV2(context, next);
+});
+runner.use(pipes.ExtractState({
+	from: "signers",
+	to: "signerStates",
+	status: "INVALID_SIGNER_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use((context, next) => {
+	const { itx, senderState } = context;
+	context.stakeAddress = toStakeAddress(senderState.address, itx.rollup);
+	context.lockerAddress = getRewardLocker(itx.rollup);
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "lockerAddress",
+	to: "lockerState",
+	status: "OK",
+	table: "stake"
+}));
+runner.use(pipes.ExtractState({
+	from: "stakeAddress",
+	to: "stakeState",
+	status: "OK",
+	table: "stake"
+}));
+runner.use((context, next) => {
+	const { stakeState } = context;
+	if (stakeState && stakeState.revocable === true) return next(new CustomError("INVALID_STAKE_STATE", `Staking not locked for withdraw: ${stakeState.address}`));
+	return next();
+});
+runner.use(ensure_gas_default((context) => {
+	const result = {
+		create: 0,
+		update: 1,
+		payment: 0
+	};
+	if (context.stakeState) result.update += 1;
+	else result.create += 1;
+	if (context.lockerState) result.update += 1;
+	else result.create += 1;
+	return result;
+}));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, itx, statedb, stakeState, senderState, lockerState, lockerAddress, stakeAddress, senderChange, updateVaults } = context;
+	const total = getBNSum(itx.token.value, itx.actualFee, itx.maxFee);
+	const fee = getBNSum(itx.actualFee, itx.maxFee);
+	let senderUpdates = applyTokenUpdates([{
+		address: itx.token.address,
+		value: total
+	}], senderState, "sub");
+	if (senderChange) senderUpdates = applyTokenChange(senderUpdates, senderChange);
+	const stakeUpdates = applyTokenUpdates([{
+		address: itx.token.address,
+		value: itx.token.value
+	}], stakeState || {}, "add");
+	const lockerUpdates = applyTokenUpdates([{
+		address: itx.token.address,
+		value: fee
+	}], lockerState || { tokens: {} }, "add");
+	const [newSenderState, newStakeState, newLockerState] = await Promise.all([
+		statedb.account.update(senderState.address, account.update(senderState, {
+			nonce: tx$1.nonce,
+			...senderUpdates
+		}, context), context),
+		stakeState ? statedb.stake.update(stakeAddress, stake.update(stakeState, stakeUpdates, context), context) : statedb.stake.create(stakeAddress, stake.create({
+			address: stakeAddress,
+			sender: senderState.address,
+			receiver: itx.rollup,
+			revocable: false,
+			tokens: stakeUpdates.tokens,
+			message: "withdraw-locker",
+			assets: []
+		}, context), context),
+		lockerState ? statedb.stake.update(lockerState.address, stake.update(lockerState, lockerUpdates, context), context) : statedb.stake.create(lockerAddress, stake.create({
+			address: lockerAddress,
+			sender: itx.rollup,
+			receiver: itx.rollup,
+			revocable: false,
+			message: "pending-block-reward",
+			revokeWaitingPeriod: 0,
+			...lockerUpdates
+		}, context), context)
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.stakeState = newStakeState;
+	context.lockerState = newLockerState;
+	context.stakeStates = [newStakeState, newLockerState];
+	context.updatedAccounts = context.updatedAccounts || [];
+	context.updatedAccounts.push({
+		address: senderState.address,
+		token: itx.token.address,
+		delta: `-${total}`,
+		action: "lock"
+	}, {
+		address: stakeAddress,
+		token: itx.token.address,
+		delta: itx.token.value,
+		action: "lock"
+	}, {
+		address: lockerAddress,
+		token: itx.token.address,
+		delta: fee,
+		action: "pending"
+	});
+	debug("withdraw-token-v2", itx);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var withdraw_v2_default = runner;
+
+//#endregion
+export { withdraw_v2_default as default };

package/esm/protocols/token-factory/burn.d.mts

@@ -0,0 +1,15 @@
+//#region src/protocols/token-factory/burn.d.ts
+/** Token input type */
+interface TokenInput {
+  address: string;
+  value: string;
+}
+/** Multi-input type */
+interface MultiInput {
+  owner: string;
+  tokensList: TokenInput[];
+  assetsList: string[];
+}
+declare const runner: any;
+//#endregion
+export { MultiInput, TokenInput, runner as default };