@ocap/tx-protocols 1.28.9 → 1.29.0

package/lib/protocols/token/withdraw-v2.cjs

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

package/lib/protocols/token/withdraw-v2.d.cts

@@ -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/lib/protocols/token-factory/burn.cjs

@@ -0,0 +1,236 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_util = require('../../util.cjs');
+const require_pipes_ensure_cost = require('../../pipes/ensure-cost.cjs');
+const require_pipes_ensure_gas = require('../../pipes/ensure-gas.cjs');
+const require_protocols_token_factory_pipes_calc_reserve = require('./pipes/calc-reserve.cjs');
+let _ocap_tx_pipeline = require("@ocap/tx-pipeline");
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let lodash_pick = require("lodash/pick");
+lodash_pick = require_rolldown_runtime.__toESM(lodash_pick);
+let _ocap_state = require("@ocap/state");
+let _ocap_util = require("@ocap/util");
+let _ocap_util_lib_get_list_field = require("@ocap/util/lib/get-list-field");
+let _arcblock_validator = require("@arcblock/validator");
+
+//#region src/protocols/token-factory/burn.ts
+const runner = new _ocap_tx_pipeline.Runner("burn_token");
+const schema = _arcblock_validator.Joi.object({
+	tokenFactory: _arcblock_validator.Joi.DID().prefix().role("ROLE_TOKEN_FACTORY").required(),
+	receiver: _arcblock_validator.schemas.tokenHolder.required(),
+	minReserve: _arcblock_validator.Joi.alternatives().try(_arcblock_validator.Joi.BN().greater(0), _arcblock_validator.Joi.equal("")).optional(),
+	inputsList: _arcblock_validator.schemas.multiInput.min(1).required(),
+	data: _arcblock_validator.Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use(({ itx }, next) => {
+	const { error } = schema.validate(itx);
+	if (error) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.tokenFactory",
+	to: "tokenFactoryState",
+	status: "INVALID_TOKEN_FACTORY",
+	table: "tokenFactory"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tokenFactoryState.tokenAddress",
+	to: "tokenState",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyTxInput({
+	fieldKey: "itx.inputs",
+	inputsKey: "inputs",
+	sendersKey: "senders",
+	tokensKey: "tokens",
+	assetsKey: null
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyListSize({ listKey: [
+	"inputs",
+	"senders",
+	"tokens",
+	"assets"
+] }));
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSigV2({ signersKey: "senders" }));
+runner.use((context, next) => {
+	const { tokenFactoryState, inputs } = context;
+	if (!(inputs || []).every((input) => {
+		const tokensList = (0, _ocap_util_lib_get_list_field.getListField)(input, "tokens");
+		const assetsList = (0, _ocap_util_lib_get_list_field.getListField)(input, "assets");
+		return tokensList.length && tokensList.every((x) => x.address === tokenFactoryState.tokenAddress) && !assetsList.length;
+	})) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Inputs only accept ${tokenFactoryState.tokenAddress}`));
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "senders",
+	to: "signerStates",
+	status: "INVALID_SIGNER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.receiver",
+	to: "receiverState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "receiverState",
+	addressKey: "itx.receiver"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyBlocked({ stateKeys: ["signerStates", "receiverState"] }));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tokenFactoryState.owner",
+	to: "ownerState",
+	status: "INVALID_OWNER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.verifyTokenAccess({
+	statesKey: "tokenState",
+	listFieldKey: "minters",
+	accountKeys: ["senderState"],
+	errorMessage: "Account {address} is not allowed to burn token {tokenAddress}"
+}));
+runner.use((context, next) => {
+	const { inputs = [], tokenFactoryState } = context;
+	let amount = new _ocap_util.BN("0");
+	for (const { tokensList } of inputs) {
+		const delta = tokensList.find((x) => x.address === tokenFactoryState.tokenAddress)?.value;
+		if (!delta) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "Invalid inputs"));
+		amount = amount.add(new _ocap_util.BN(delta));
+	}
+	context.burnAmount = amount.toString();
+	return next();
+});
+runner.use(require_protocols_token_factory_pipes_calc_reserve.default({
+	tokenFactoryKey: "tokenFactoryState",
+	tokenStateKey: "tokenState",
+	reserveKey: "reserveAmount",
+	feeKey: "reserveFee",
+	amountKey: "burnAmount",
+	direction: "burn"
+}), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use((context, next) => {
+	const { reserveAmount = "0", reserveFee } = context;
+	const { minReserve } = context.itx;
+	if (minReserve && new _ocap_util.BN(reserveAmount).lt(new _ocap_util.BN(minReserve).add(new _ocap_util.BN(reserveFee || "0")))) return next(new _ocap_util_lib_error.CustomError("SLIPPAGE_EXCEEDED", `Burn token failed due to price movement. Expected minimum: ${(0, _ocap_util.fromUnitToToken)(minReserve)}, actual: ${(0, _ocap_util.fromUnitToToken)(reserveAmount)}. Try reducing your minReserve.`));
+	return next();
+}, { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tokens",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyTokenBalance({
+	ownerKey: "signerStates",
+	conditionKey: "inputs"
+}));
+runner.use((context, next) => {
+	const { tokenFactoryState, burnAmount = "0", reserveAmount = "0" } = context;
+	if (new _ocap_util.BN(tokenFactoryState.currentSupply).lt(new _ocap_util.BN(burnAmount))) return next(new _ocap_util_lib_error.CustomError("INSUFFICIENT_FUND", "Token factory supply is not enough"));
+	if (new _ocap_util.BN(tokenFactoryState.reserveBalance).lt(new _ocap_util.BN(reserveAmount))) return next(new _ocap_util_lib_error.CustomError("INSUFFICIENT_FUND", "Token factory reserve balance is not enough"));
+	return next();
+});
+runner.use(require_pipes_ensure_gas.default((context) => {
+	const result = {
+		create: 0,
+		update: 2,
+		payment: 0
+	};
+	if (context.senderState) result.update += 1;
+	else result.create += 1;
+	if (context.tokenFactoryState?.curve) if (context.receiverState) result.update += 1;
+	else result.create += 1;
+	if (context.reserveFee) result.update += 1;
+	if (context.signerStates) result.update += context.signerStates.length;
+	return result;
+}));
+runner.use(require_pipes_ensure_cost.default({ attachSenderChanges: true }));
+runner.use(_ocap_tx_pipeline.pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx, senderState, receiverState, ownerState, statedb, senderChange, updateVaults, tokenFactoryState, tokenState, reserveAmount = "0", reserveFee, itx, inputs = [], signerStates = [], burnAmount = "0" } = context;
+	const { receiver } = itx;
+	const { reserveAddress, tokenAddress } = tokenFactoryState;
+	const accountUpdates = {};
+	const inputChanges = [];
+	inputs.forEach((input) => {
+		const { owner } = input;
+		const tokenChange = (0, _ocap_util_lib_get_list_field.getListField)(input, "tokens").find((item) => item.address === tokenAddress);
+		accountUpdates[owner] = require_util.applyTokenUpdates([tokenChange], signerStates.find((s) => s.address === owner), "sub");
+		inputChanges.push({
+			address: owner,
+			token: tokenAddress,
+			delta: new _ocap_util.BN(tokenChange.value).neg().toString()
+		});
+	});
+	if (!accountUpdates[tx.from]) accountUpdates[tx.from] = senderState || {};
+	if (reserveFee && new _ocap_util.BN(reserveFee).gt(new _ocap_util.BN(0))) accountUpdates[ownerState.address] = require_util.applyTokenChange(accountUpdates[ownerState.address] || ownerState, {
+		token: reserveAddress,
+		delta: reserveFee
+	});
+	if (tokenFactoryState.curve) accountUpdates[receiver] = require_util.applyTokenChange(accountUpdates[receiver] || receiverState || {
+		address: receiver,
+		tokens: {}
+	}, {
+		token: reserveAddress,
+		delta: new _ocap_util.BN(reserveAmount).sub(new _ocap_util.BN(reserveFee || "0")).toString()
+	});
+	if (senderChange) accountUpdates[senderChange.address] = require_util.applyTokenChange(accountUpdates[senderChange.address] || senderState, senderChange);
+	const [newAccountStates, newTokenFactoryState, newTokenState] = await Promise.all([
+		Promise.all(Object.entries(accountUpdates).map(([address, updates]) => {
+			const state = [
+				senderState,
+				receiverState,
+				ownerState,
+				...signerStates
+			].find((x) => x?.address === address);
+			const actualUpdates = state ? (0, lodash_pick.default)(updates, ["tokens"]) : {
+				...updates,
+				address
+			};
+			if (address === tx.from) {
+				actualUpdates.pk = tx.pk;
+				actualUpdates.nonce = tx.nonce;
+			}
+			return statedb.account.updateOrCreate(state ?? null, _ocap_state.account.updateOrCreate(state ?? null, actualUpdates, context), context);
+		})),
+		statedb.tokenFactory.update(tokenFactoryState.address, _ocap_state.tokenFactory.update(tokenFactoryState, {
+			currentSupply: new _ocap_util.BN(tokenFactoryState.currentSupply).sub(new _ocap_util.BN(burnAmount)).toString(),
+			reserveBalance: new _ocap_util.BN(tokenFactoryState.reserveBalance).sub(new _ocap_util.BN(reserveAmount)).toString()
+		}, context), context),
+		statedb.token.update(tokenAddress, _ocap_state.token.update(tokenState, { totalSupply: new _ocap_util.BN(tokenState.totalSupply).sub(new _ocap_util.BN(burnAmount)).toString() }), context)
+	]);
+	context.senderState = newAccountStates.find((x) => x.address === tx.from);
+	context.receiverState = newAccountStates.find((x) => x.address === receiver);
+	context.ownerState = newAccountStates.find((x) => x.address === ownerState.address) || ownerState;
+	context.signerStates = newAccountStates.filter((x) => signerStates.find((s) => s.address === x.address));
+	context.tokenFactoryState = newTokenFactoryState;
+	context.tokenState = newTokenState;
+	context.inputChanges = inputChanges;
+	if (updateVaults) await updateVaults();
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var burn_default = runner;
+
+//#endregion
+exports.default = burn_default;

package/lib/protocols/token-factory/burn.d.cts

@@ -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 };