@ocap/tx-protocols 1.28.9 → 1.29.0

package/esm/protocols/rollup/create-block.mjs

@@ -0,0 +1,303 @@
+import { applyTokenChange, ensureBlockReward, getRewardLocker } from "../../util.mjs";
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import ensure_validator_default from "./pipes/ensure-validator.mjs";
+import verify_signers_default from "./pipes/verify-signers.mjs";
+import verify_status_default from "./pipes/verify-status.mjs";
+import verify_evidence_default from "./pipes/verify-evidence.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import pick from "lodash/pick.js";
+import { toStakeAddress } from "@arcblock/did-util";
+import { account, rollup, rollupBlock, stake, tx } from "@ocap/state";
+import Debug from "debug";
+import { formatMessage } from "@ocap/message";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import cloneDeep from "lodash/cloneDeep.js";
+import { Joi, patterns, schemas } from "@arcblock/validator";
+import MerkleTree from "@ocap/merkle-tree";
+
+//#region src/protocols/rollup/create-block.ts
+const debug = Debug("@ocap/tx-protocols:create-rollup-block");
+const runner = new Runner("create_rollup_block");
+const schema = Joi.object({
+	hash: Joi.string().regex(patterns.txHash).required(),
+	height: Joi.number().integer().greater(0).required(),
+	merkleRoot: Joi.string().regex(patterns.txHash).required(),
+	previousHash: Joi.string().when("height", {
+		is: 1,
+		then: Joi.string().optional().allow(null).allow(""),
+		otherwise: Joi.string().regex(patterns.txHash).required()
+	}),
+	txsHash: Joi.string().regex(patterns.txHash).required(),
+	txsList: Joi.array().items(Joi.string().regex(patterns.txHash).required()).min(1).unique().required(),
+	proposer: Joi.DID().prefix().wallet("ethereum").required(),
+	signaturesList: schemas.multiSig.min(1).required(),
+	rollup: Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	minReward: Joi.BN().min(0).required(),
+	governance: Joi.boolean().default(false),
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use((context, next) => {
+	const { tx: tx$1, itx } = context;
+	context.formattedItx = formatMessage("CreateRollupBlockTx", itx);
+	const { error } = schema.validate(itx);
+	if (error) return next(new CustomError("INVALID_TX", error.message));
+	if (tx$1.from !== itx.proposer) return next(new CustomError("INVALID_TX", "itx.proposer must be same with tx.from"));
+	if (getListField(tx$1, "signatures").some((x) => x.signer === itx.proposer) === false) return next(new CustomError("INVALID_TX", "itx.proposer must exist in signatures"));
+	const txsList = getListField(itx, "txs");
+	if (MerkleTree.getListHash(txsList) !== itx.txsHash) return next(new CustomError("INVALID_TX", "itx.txsHash does not match with itx.txs"));
+	if (MerkleTree.getBlockHash({
+		...pick(itx, [
+			"height",
+			"merkleRoot",
+			"txsHash"
+		]),
+		previousHash: itx.height === 1 ? "" : itx.previousHash
+	}) !== itx.hash) return next(new CustomError("INVALID_TX", "itx.hash invalid"));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "itx.rollup",
+	to: "rollupState",
+	status: "INVALID_ROLLUP",
+	table: "rollup"
+}));
+runner.use(ensure_validator_default(false));
+runner.use(verify_status_default({ closed: false }));
+runner.use((context, next) => {
+	const { itx, rollupState } = context;
+	if (itx.height !== (rollupState?.blockHeight || 0) + 1) return next(new CustomError("INVALID_TX", `Expect new block height to be ${(rollupState?.blockHeight || 0) + 1}, got ${itx.height}`));
+	const itxTxsList = getListField(itx, "txs");
+	if (itx.governance) {
+		if (itx.minReward !== "0") return next(new CustomError("INVALID_TX", "itx.minReward should be 0 for governance block"));
+		if (itxTxsList.length !== 1) return next(new CustomError("INVALID_TX", "itx.txs should contain only 1 tx for governance block"));
+	} else {
+		if (rollupState?.paused) return next(new CustomError("INVALID_TX", "Normal block is only allowed when rollup is not paused"));
+		const blockSize = itxTxsList.length;
+		if (blockSize < (rollupState?.minBlockSize || 0)) return next(new CustomError("INVALID_TX", `Expect at least ${rollupState?.minBlockSize || 0} tx in the block, got ${blockSize}`));
+		if (blockSize > (rollupState?.maxBlockSize || 0)) return next(new CustomError("INVALID_TX", `Expect at most ${rollupState?.maxBlockSize || 0} tx in the block, got ${blockSize}`));
+	}
+	return next();
+});
+runner.use(verify_signers_default({
+	signersKey: "itx.signaturesList",
+	allowSender: true
+}));
+runner.use(verify_evidence_default({
+	evidenceKey: "itx.hash",
+	signaturesKey: "itx.signaturesList",
+	verifyMethod: "ethVerify"
+}));
+runner.use(verify_signers_default({
+	signersKey: "tx.signaturesList",
+	allowSender: true
+}));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: "signers" }));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	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(pipes.ExtractState({
+	from: "itx.previousHash",
+	to: "previousBlock",
+	status: "OK",
+	table: "rollupBlock"
+}));
+runner.use((context, next) => {
+	const { txTime, itx, previousBlock, rollupState } = context;
+	if (itx.height > 1) {
+		if (!previousBlock) return next(new CustomError("INVALID_TX", `Rollup block with height ${itx.height} does not exist`));
+		if (itx.height !== previousBlock.height + 1) return next(new CustomError("INVALID_TX", `Unexpected previous block height, expected ${itx.height - 1}, got ${previousBlock.height}`));
+		if (itx.governance === false) {
+			const minBlockTime = +new Date(previousBlock.context.genesisTime) + (rollupState?.minBlockInterval || 0) * 1e3;
+			if (+new Date(txTime) < minBlockTime) return next(new CustomError("INVALID_TX", `Block does not comply with minBlockInterval: ${new Date(minBlockTime).toISOString()}`));
+		}
+	}
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "itx.hash",
+	to: "newBlock",
+	status: "OK",
+	table: "rollupBlock"
+}));
+runner.use((context, next) => {
+	if (context.newBlock) return next(new CustomError("INVALID_TX", `Rollup block with height ${context.itx.height} already exists`));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "rollupState.tokenAddress",
+	to: "tokenState",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.txsList",
+	to: "txStates",
+	status: "INVALID_TX",
+	table: "tx"
+}));
+runner.use(({ itx, txStates }, next) => {
+	const normalTxTypes = ["deposit_token_v2", "withdraw_token_v2"];
+	const governanceTxTypes = [
+		"pause_rollup",
+		"resume_rollup",
+		"migrate_rollup"
+	];
+	const txList = txStates || [];
+	if (txList.some((x) => x.finalized)) return next(new CustomError("INVALID_TX", "Should not include finalized tx in later block"));
+	if (txList.some((x) => x.code !== "OK")) return next(new CustomError("INVALID_TX", "Rollup block can only include successful executed transactions"));
+	if (itx.governance) {
+		if (txList.some((x) => governanceTxTypes.includes(x.type) === false)) return next(new CustomError("INVALID_TX", `Governance block can only include governance txs: ${governanceTxTypes.join(",")}`));
+	} else if (txList.some((x) => normalTxTypes.includes(x.type) === false)) return next(new CustomError("INVALID_TX", `Rollup block can only include normal txs: ${normalTxTypes.join(",")}`));
+	if (txList.some((x) => {
+		return (x.tx?.itxJson)?.rollup !== itx.rollup;
+	})) return next(new CustomError("INVALID_TX", `Rollup block can only include tx from rollup ${itx.rollup}`));
+	if (MerkleTree.getBlockMerkleTree(txList.map((x) => {
+		const txItxJson = x.tx?.itxJson;
+		if (x.type === "withdraw_token_v2") return {
+			hash: x.hash,
+			to: txItxJson?.to,
+			amount: txItxJson?.token?.value
+		};
+		if (x.type === "pause_rollup") return {
+			hash: x.hash,
+			to: MerkleTree.BLACK_HOLE,
+			amount: "0"
+		};
+		if (x.type === "resume_rollup") return {
+			hash: x.hash,
+			to: MerkleTree.BLACK_HOLE,
+			amount: "0"
+		};
+		if (x.type === "migrate_rollup") return {
+			hash: x.hash,
+			to: txItxJson?.to,
+			amount: "0"
+		};
+		return null;
+	}).filter(Boolean)).getHexRoot() !== itx.merkleRoot) return next(new CustomError("INVALID_TX", "Invalid rollup block merkle root"));
+	return next();
+});
+runner.use((context, next) => {
+	const { itx, txStates } = context;
+	const txList = txStates || [];
+	const depositProposerStakeAddr = txList.filter((x) => x.type === "deposit_token_v2").map((x) => {
+		const txItxJson = x.tx?.itxJson;
+		return toStakeAddress(txItxJson.proposer, itx.rollup);
+	});
+	const withdrawLockerStakeAddr = txList.filter((x) => x.type === "withdraw_token_v2").map((x) => toStakeAddress(x.tx.from, itx.rollup));
+	context.stakeAddresses = [
+		...depositProposerStakeAddr,
+		...withdrawLockerStakeAddr,
+		getRewardLocker(itx.rollup)
+	];
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "stakeAddresses",
+	to: "stakeStates",
+	status: "INVALID_STAKE_STATE",
+	table: "stake"
+}));
+runner.use((context, next) => {
+	const { itx, txStates, rollupState } = context;
+	try {
+		const txStatesForReward = txStates || [];
+		const result = ensureBlockReward(rollupState, itx.minReward, txStatesForReward);
+		context.senders = Object.keys(result.accountUpdates);
+		Object.assign(context, result);
+		return next();
+	} catch (err) {
+		return next(err);
+	}
+});
+runner.use(pipes.ExtractState({
+	from: "senders",
+	to: "senderStates",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(ensure_gas_default((context) => {
+	const result = {
+		create: 1,
+		update: 2,
+		payment: 0
+	};
+	result.update += (context.stakeStates || []).filter((x) => context.stakeUpdates?.[x.address]).length;
+	result.update += (context.txStates || []).length;
+	result.update += (context.senderStates || []).length;
+	return result;
+}));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, itx, statedb, rollupState, senderState, stakeStates, txStates, formattedItx, senderUpdates, updateVaults } = context;
+	const senderStatesList = context.senderStates || [];
+	const stakeStatesList = stakeStates || [];
+	const txStatesList = txStates || [];
+	const stakeUpdatesMap = context.stakeUpdates || {};
+	const accountUpdatesMap = context.accountUpdates || {};
+	const [newSenderState, newStakeStates, newSenderStates, newRollupState, rollupBlockState, newTxStates] = await Promise.all([
+		statedb.account.update(senderState.address, account.update(senderState, {
+			nonce: tx$1.nonce,
+			...senderUpdates
+		}, context), context),
+		Promise.all(stakeStatesList.map((x) => stakeUpdatesMap[x.address] ? statedb.stake.update(x.address, stake.update(x, applyTokenChange(x, stakeUpdatesMap[x.address]), context), context) : Promise.resolve(x))),
+		Promise.all(senderStatesList.map((x) => statedb.account.update(x.address, account.update(x, applyTokenChange(x, accountUpdatesMap[x.address]), context), context))),
+		statedb.rollup.update(rollupState.address, rollup.update(rollupState, {
+			blockHeight: itx.height,
+			blockHash: itx.hash
+		}, context), context),
+		statedb.rollupBlock.create(itx.hash, rollupBlock.create({
+			...formattedItx,
+			...[
+				"rewardAmount",
+				"mintedAmount",
+				"burnedAmount"
+			].reduce((acc, x) => {
+				const val = context[x];
+				acc[x] = val ? val.toString(10) : "0";
+				return acc;
+			}, {})
+		}, context), context),
+		Promise.all(txStatesList.map((x) => statedb.tx.update(x.hash, tx.update(x, { finalized: true }), context)))
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.stakeStates = newStakeStates.filter((x) => stakeUpdatesMap[x.address]);
+	context.newSenderStates = newSenderStates;
+	context.rollupState = newRollupState;
+	context.createdRollupBlock = rollupBlockState;
+	context.txStates = newTxStates;
+	context.updatedAccounts = context.updatedAccounts || [];
+	context.updatedAccounts.push(...cloneDeep(Object.values(stakeUpdatesMap)));
+	context.updatedAccounts.push(...cloneDeep(Object.values(accountUpdatesMap)));
+	debug("create-rollup-block", {
+		itx,
+		updatedAccounts: context.updatedAccounts
+	});
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var create_block_default = runner;
+
+//#endregion
+export { create_block_default as default };

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

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

package/esm/protocols/rollup/create.mjs

@@ -0,0 +1,164 @@
+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 { isEthereumDid, isFromPublicKey } from "@arcblock/did";
+import { toRollupAddress } from "@arcblock/did-util";
+import { account, delegation, rollup } from "@ocap/state";
+import Debug from "debug";
+import { formatMessage } from "@ocap/message";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import cloneDeep from "lodash/cloneDeep.js";
+import isEmpty from "lodash/isEmpty.js";
+
+//#region src/protocols/rollup/create.ts
+const debug = Debug("@ocap/tx-protocols:create-rollup");
+const runner = new Runner("create_rollup");
+runner.use(pipes.VerifyMultiSig(0));
+runner.use((context, next) => {
+	const { itx } = context;
+	context.formattedItx = formatMessage("CreateRollupTx", itx);
+	try {
+		rollup.create(context.formattedItx, context);
+	} catch (err) {
+		return next(new CustomError("INVALID_TX", err.message));
+	}
+	return next();
+});
+runner.use(pipes.VerifyInfo([
+	{
+		error: "INVALID_TX",
+		message: "Sum of itx.proposerFeeShare and itx.publisherFeeShare must be less than 10000",
+		fn: (ctx) => {
+			const context = ctx;
+			return context.itx.proposerFeeShare + context.itx.publisherFeeShare < 1e4;
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Seed validator pk and address not match",
+		fn: (ctx) => {
+			return (ctx.formattedItx?.seedValidators || []).every(({ pk, address }) => isFromPublicKey(address, pk));
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Seed validator must use ethereum compatible address",
+		fn: (ctx) => {
+			return (ctx.formattedItx?.seedValidators || []).every(({ address }) => isEthereumDid(address));
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Rollup address is not valid",
+		fn: (ctx) => {
+			const context = ctx;
+			const itx = cloneDeep(context.itx);
+			itx.data = decodeAnySafe(itx.data);
+			itx.address = "";
+			context.rollupData = itx.data;
+			context.seedValidators = getListField(itx, "seedValidators").map((x) => x.address);
+			return toRollupAddress(itx) === context.itx.address;
+		}
+	}
+]));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "seedValidators",
+	to: "validatorStates",
+	status: "INVALID_VALIDATOR_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	signerKey: "validatorStates",
+	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.tokenAddress",
+	to: "tokenState",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(pipes.VerifyInfo([{
+	error: "INVALID_TOKEN",
+	message: "Token does not have foreignToken attached",
+	fn: (ctx) => {
+		return isEmpty(ctx.tokenState?.foreignToken) === false;
+	}
+}]));
+runner.use(async (context, next) => {
+	const { statedb, itx } = context;
+	if (await statedb.rollup.existByToken(itx.tokenAddress, context)) return next(new CustomError("DUPLICATE_ROLLUP", "Only 1 active rollup can be created for the token"));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "itx.address",
+	to: "rollupState",
+	status: "OK",
+	table: "rollup"
+}));
+runner.use(pipes.VerifyInfo([{
+	error: "DUPLICATE_ROLLUP",
+	message: "This rollup already exist on chain",
+	fn: (ctx) => {
+		return isEmpty(ctx.rollupState);
+	}
+}]));
+runner.use(ensure_gas_default(() => ({
+	create: 1,
+	update: 2,
+	payment: 0
+})));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, formattedItx, rollupData, statedb, senderState, delegatorState, delegationState, senderUpdates, updateVaults } = context;
+	const issuer = delegatorState ? delegatorState.address : senderState.address;
+	const [newSenderState, newRollupState, newDelegationState] = await Promise.all([
+		statedb.account.update(senderState.address, account.update(senderState, {
+			nonce: tx$1.nonce,
+			...senderUpdates
+		}, context), context),
+		statedb.rollup.create(formattedItx.address, rollup.create({
+			...formattedItx,
+			issuer,
+			validators: formattedItx.seedValidators || [],
+			data: rollupData
+		}, context), context),
+		context.isDelegationChanged && delegationState ? statedb.delegation.update(delegationState.address, delegation.update(delegationState, {}, context), context) : Promise.resolve(delegationState)
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.rollupState = newRollupState;
+	context.delegationState = newDelegationState;
+	debug("create-rollup", newRollupState);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var create_default = runner;
+
+//#endregion
+export { create_default as default };

package/esm/protocols/rollup/join.d.mts

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

package/esm/protocols/rollup/join.mjs

@@ -0,0 +1,152 @@
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import verify_signers_default from "./pipes/verify-signers.mjs";
+import verify_status_default from "./pipes/verify-status.mjs";
+import verify_evidence_default from "./pipes/verify-evidence.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { isEthereumDid } from "@arcblock/did";
+import { toStakeAddress } from "@arcblock/did-util";
+import { account, evidence, rollup, stake } from "@ocap/state";
+import { BN, toHex } from "@ocap/util";
+import Debug from "debug";
+import { Joi, patterns, schemas } from "@arcblock/validator";
+import MerkleTree from "@ocap/merkle-tree";
+import joinUrl from "url-join";
+
+//#region src/protocols/rollup/join.ts
+const debug = Debug("@ocap/tx-protocols:join-rollup");
+const runner = new Runner("join_rollup");
+const schema = Joi.object({
+	rollup: Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	endpoint: Joi.string().uri({ scheme: [/https?/] }).required(),
+	evidence: Joi.object({ hash: Joi.string().regex(patterns.txHash).required() }).required(),
+	signaturesList: schemas.multiSig.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.ExtractState({
+	from: "itx.rollup",
+	to: "rollupState",
+	status: "INVALID_ROLLUP",
+	table: "rollup"
+}));
+runner.use(verify_status_default({ paused: false }));
+runner.use((context, next) => {
+	const { tx: tx$1, itx, rollupState } = context;
+	const validator = {
+		pk: toHex(tx$1.pk),
+		address: tx$1.from,
+		endpoint: itx.endpoint
+	};
+	if (isEthereumDid(tx$1.from) === false) return next(new CustomError("INVALID_TX", "Invalid tx.from: only ethereum compatible address can join rollup"));
+	if (rollupState?.validators.some((x) => x.address === validator.address)) return next(new CustomError("INVALID_TX", `Address ${validator.address} already exist in validators`));
+	if (rollupState?.validators.some((x) => joinUrl(x.endpoint, "/") === joinUrl(validator.endpoint, "/"))) return next(new CustomError("INVALID_TX", `Endpoint ${validator.endpoint} already exist in validators`));
+	context.newValidator = validator;
+	context.validatorsHash = MerkleTree.getListHash([validator.address]);
+	return next();
+});
+runner.use(verify_signers_default({
+	signersKey: "itx.signaturesList",
+	allowSender: false
+}));
+runner.use(verify_evidence_default({
+	evidenceKey: "validatorsHash",
+	signaturesKey: "itx.signaturesList",
+	verifyMethod: "ethVerify"
+}));
+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", "Join evidence already seen on this chain"));
+	return next();
+});
+runner.use(verify_signers_default({
+	signersKey: "tx.signaturesList",
+	allowSender: false
+}));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: "signers" }));
+runner.use((context, next) => {
+	const { tx: tx$1, itx } = context;
+	context.stakeAddress = toStakeAddress(tx$1.from, itx.rollup);
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "stakeAddress",
+	to: "stakeState",
+	status: "INVALID_STAKE_STATE",
+	table: "stake"
+}));
+runner.use((context, next) => {
+	const { stakeState, rollupState } = context;
+	if (stakeState?.revocable === false) return next(new CustomError("INVALID_STAKE_STATE", `Staking already locked: ${stakeState.address}`));
+	const actualStake = new BN(stakeState?.tokens[rollupState?.tokenAddress || ""] || 0);
+	const requiredStake = new BN(rollupState?.minStakeAmount || 0);
+	if (actualStake.lt(requiredStake)) return next(new CustomError("INVALID_STAKE_STATE", `Staking does not match min stake amount: ${requiredStake}`));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	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(() => ({
+	create: 1,
+	update: 3,
+	payment: 0
+})));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, itx, rollupState, statedb, senderState, stakeState, newValidator, stakeAddress, senderUpdates, updateVaults } = context;
+	const newValidators = rollupState.validators.concat([newValidator]);
+	const [newSenderState, newRollupState, newStakeState, newEvidenceState] = await Promise.all([
+		statedb.account.update(senderState.address, account.update(senderState, {
+			nonce: tx$1.nonce,
+			...senderUpdates
+		}, context), context),
+		statedb.rollup.update(rollupState.address, rollup.update(rollupState, { validators: newValidators }, context), context),
+		statedb.stake.update(stakeAddress, stake.update(stakeState, {
+			revocable: false,
+			revokeWaitingPeriod: rollupState.leaveWaitingPeriod
+		}, context), context),
+		statedb.evidence.create(itx.evidence.hash, evidence.create({
+			hash: itx.evidence.hash,
+			data: "rollup-join"
+		}, context), context)
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.rollupState = newRollupState;
+	context.stakeState = newStakeState;
+	context.evidenceState = newEvidenceState;
+	debug("join-rollup", newValidators);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var join_default = runner;
+
+//#endregion
+export { join_default as default };

package/esm/protocols/rollup/leave.d.mts

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