@ocap/tx-protocols 1.28.9 → 1.29.0

package/lib/protocols/rollup/close.cjs

@@ -0,0 +1,107 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.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_ensure_validator = require('./pipes/ensure-validator.cjs');
+const require_protocols_rollup_pipes_verify_signers = require('./pipes/verify-signers.cjs');
+const require_protocols_rollup_pipes_verify_status = require('./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 _arcblock_validator = require("@arcblock/validator");
+
+//#region src/protocols/rollup/close.ts
+const runner = new _ocap_tx_pipeline.Runner("close_rollup");
+const schema = _arcblock_validator.Joi.object({
+	rollup: _arcblock_validator.Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	message: _arcblock_validator.Joi.string().trim().min(1).max(512).required(),
+	token: _arcblock_validator.Joi.object({
+		address: _arcblock_validator.Joi.DID().prefix().wallet("ethereum").required(),
+		value: _arcblock_validator.Joi.BN().positive().required()
+	}),
+	data: _arcblock_validator.Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use(({ itx }, next) => {
+	const { error } = schema.validate(itx);
+	return next(error ? new _ocap_util_lib_error.CustomError("INVALID_TX", `Invalid itx: ${error.message}`) : void 0);
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.rollup",
+	to: "rollupState",
+	status: "INVALID_ROLLUP",
+	table: "rollup"
+}));
+runner.use(require_protocols_rollup_pipes_ensure_validator.default(true));
+runner.use(require_protocols_rollup_pipes_verify_status.default({
+	paused: true,
+	closed: false
+}));
+runner.use(require_protocols_rollup_pipes_verify_signers.default({
+	signersKey: "tx.signaturesList",
+	allowSender: true
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSigV2({ signersKey: "signers" }));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+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 { validators, address } = context.rollupState;
+	context.stakeAddresses = validators.map((x) => (0, _arcblock_did_util.toStakeAddress)(x.address, address));
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "stakeAddresses",
+	to: "stakeStates",
+	status: "INVALID_STAKE_STATE",
+	table: "stake"
+}));
+runner.use(require_pipes_ensure_gas.default((context) => ({
+	create: 0,
+	update: (context.stakeStates || []).length + 2,
+	payment: 0
+})));
+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, senderUpdates, updateVaults, rollupState, senderState } = context;
+	const stakeStates = context.stakeStates || [];
+	const [newSenderState, newRollupState, newStakeStates] = await Promise.all([
+		statedb.account.update(senderState.address, _ocap_state.account.update(senderState, {
+			nonce: tx.nonce,
+			...senderUpdates
+		}, context), context),
+		statedb.rollup.update(itx.rollup, _ocap_state.rollup.close(rollupState, context), context),
+		Promise.all(stakeStates.map((x) => statedb.stake.update(x.address, _ocap_state.stake.update(x, {
+			revocable: true,
+			revokeWaitingPeriod: rollupState.leaveWaitingPeriod
+		}, context), context)))
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.rollupState = newRollupState;
+	context.stakeStates = newStakeStates;
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var close_default = runner;
+
+//#endregion
+exports.default = close_default;

package/lib/protocols/rollup/close.d.cts

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

package/lib/protocols/rollup/create-block.cjs

@@ -0,0 +1,309 @@
+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_ensure_validator = require('./pipes/ensure-validator.cjs');
+const require_protocols_rollup_pipes_verify_signers = require('./pipes/verify-signers.cjs');
+const require_protocols_rollup_pipes_verify_status = require('./pipes/verify-status.cjs');
+const require_protocols_rollup_pipes_verify_evidence = require('./pipes/verify-evidence.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 _arcblock_did_util = require("@arcblock/did-util");
+let _ocap_state = require("@ocap/state");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let _ocap_message = require("@ocap/message");
+let _ocap_util_lib_get_list_field = require("@ocap/util/lib/get-list-field");
+let lodash_cloneDeep = require("lodash/cloneDeep");
+lodash_cloneDeep = require_rolldown_runtime.__toESM(lodash_cloneDeep);
+let _arcblock_validator = require("@arcblock/validator");
+let _ocap_merkle_tree = require("@ocap/merkle-tree");
+_ocap_merkle_tree = require_rolldown_runtime.__toESM(_ocap_merkle_tree);
+
+//#region src/protocols/rollup/create-block.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:create-rollup-block");
+const runner = new _ocap_tx_pipeline.Runner("create_rollup_block");
+const schema = _arcblock_validator.Joi.object({
+	hash: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required(),
+	height: _arcblock_validator.Joi.number().integer().greater(0).required(),
+	merkleRoot: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required(),
+	previousHash: _arcblock_validator.Joi.string().when("height", {
+		is: 1,
+		then: _arcblock_validator.Joi.string().optional().allow(null).allow(""),
+		otherwise: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required()
+	}),
+	txsHash: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required(),
+	txsList: _arcblock_validator.Joi.array().items(_arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required()).min(1).unique().required(),
+	proposer: _arcblock_validator.Joi.DID().prefix().wallet("ethereum").required(),
+	signaturesList: _arcblock_validator.schemas.multiSig.min(1).required(),
+	rollup: _arcblock_validator.Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	minReward: _arcblock_validator.Joi.BN().min(0).required(),
+	governance: _arcblock_validator.Joi.boolean().default(false),
+	data: _arcblock_validator.Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use((context, next) => {
+	const { tx, itx } = context;
+	context.formattedItx = (0, _ocap_message.formatMessage)("CreateRollupBlockTx", itx);
+	const { error } = schema.validate(itx);
+	if (error) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", error.message));
+	if (tx.from !== itx.proposer) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "itx.proposer must be same with tx.from"));
+	if ((0, _ocap_util_lib_get_list_field.getListField)(tx, "signatures").some((x) => x.signer === itx.proposer) === false) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "itx.proposer must exist in signatures"));
+	const txsList = (0, _ocap_util_lib_get_list_field.getListField)(itx, "txs");
+	if (_ocap_merkle_tree.default.getListHash(txsList) !== itx.txsHash) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "itx.txsHash does not match with itx.txs"));
+	if (_ocap_merkle_tree.default.getBlockHash({
+		...(0, lodash_pick.default)(itx, [
+			"height",
+			"merkleRoot",
+			"txsHash"
+		]),
+		previousHash: itx.height === 1 ? "" : itx.previousHash
+	}) !== itx.hash) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "itx.hash invalid"));
+	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_ensure_validator.default(false));
+runner.use(require_protocols_rollup_pipes_verify_status.default({ closed: false }));
+runner.use((context, next) => {
+	const { itx, rollupState } = context;
+	if (itx.height !== (rollupState?.blockHeight || 0) + 1) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Expect new block height to be ${(rollupState?.blockHeight || 0) + 1}, got ${itx.height}`));
+	const itxTxsList = (0, _ocap_util_lib_get_list_field.getListField)(itx, "txs");
+	if (itx.governance) {
+		if (itx.minReward !== "0") return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "itx.minReward should be 0 for governance block"));
+		if (itxTxsList.length !== 1) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "itx.txs should contain only 1 tx for governance block"));
+	} else {
+		if (rollupState?.paused) return next(new _ocap_util_lib_error.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 _ocap_util_lib_error.CustomError("INVALID_TX", `Expect at least ${rollupState?.minBlockSize || 0} tx in the block, got ${blockSize}`));
+		if (blockSize > (rollupState?.maxBlockSize || 0)) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Expect at most ${rollupState?.maxBlockSize || 0} tx in the block, got ${blockSize}`));
+	}
+	return next();
+});
+runner.use(require_protocols_rollup_pipes_verify_signers.default({
+	signersKey: "itx.signaturesList",
+	allowSender: true
+}));
+runner.use(require_protocols_rollup_pipes_verify_evidence.default({
+	evidenceKey: "itx.hash",
+	signaturesKey: "itx.signaturesList",
+	verifyMethod: "ethVerify"
+}));
+runner.use(require_protocols_rollup_pipes_verify_signers.default({
+	signersKey: "tx.signaturesList",
+	allowSender: true
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSigV2({ signersKey: "signers" }));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+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(_ocap_tx_pipeline.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 _ocap_util_lib_error.CustomError("INVALID_TX", `Rollup block with height ${itx.height} does not exist`));
+		if (itx.height !== previousBlock.height + 1) return next(new _ocap_util_lib_error.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 _ocap_util_lib_error.CustomError("INVALID_TX", `Block does not comply with minBlockInterval: ${new Date(minBlockTime).toISOString()}`));
+		}
+	}
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.hash",
+	to: "newBlock",
+	status: "OK",
+	table: "rollupBlock"
+}));
+runner.use((context, next) => {
+	if (context.newBlock) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Rollup block with height ${context.itx.height} already exists`));
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "rollupState.tokenAddress",
+	to: "tokenState",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(_ocap_tx_pipeline.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 _ocap_util_lib_error.CustomError("INVALID_TX", "Should not include finalized tx in later block"));
+	if (txList.some((x) => x.code !== "OK")) return next(new _ocap_util_lib_error.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 _ocap_util_lib_error.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 _ocap_util_lib_error.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 _ocap_util_lib_error.CustomError("INVALID_TX", `Rollup block can only include tx from rollup ${itx.rollup}`));
+	if (_ocap_merkle_tree.default.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: _ocap_merkle_tree.default.BLACK_HOLE,
+			amount: "0"
+		};
+		if (x.type === "resume_rollup") return {
+			hash: x.hash,
+			to: _ocap_merkle_tree.default.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 _ocap_util_lib_error.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 (0, _arcblock_did_util.toStakeAddress)(txItxJson.proposer, itx.rollup);
+	});
+	const withdrawLockerStakeAddr = txList.filter((x) => x.type === "withdraw_token_v2").map((x) => (0, _arcblock_did_util.toStakeAddress)(x.tx.from, itx.rollup));
+	context.stakeAddresses = [
+		...depositProposerStakeAddr,
+		...withdrawLockerStakeAddr,
+		require_util.getRewardLocker(itx.rollup)
+	];
+	return next();
+});
+runner.use(_ocap_tx_pipeline.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 = require_util.ensureBlockReward(rollupState, itx.minReward, txStatesForReward);
+		context.senders = Object.keys(result.accountUpdates);
+		Object.assign(context, result);
+		return next();
+	} catch (err) {
+		return next(err);
+	}
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "senders",
+	to: "senderStates",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(require_pipes_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(require_pipes_ensure_cost.default({ attachSenderChanges: true }));
+runner.use(_ocap_tx_pipeline.pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx, 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, _ocap_state.account.update(senderState, {
+			nonce: tx.nonce,
+			...senderUpdates
+		}, context), context),
+		Promise.all(stakeStatesList.map((x) => stakeUpdatesMap[x.address] ? statedb.stake.update(x.address, _ocap_state.stake.update(x, require_util.applyTokenChange(x, stakeUpdatesMap[x.address]), context), context) : Promise.resolve(x))),
+		Promise.all(senderStatesList.map((x) => statedb.account.update(x.address, _ocap_state.account.update(x, require_util.applyTokenChange(x, accountUpdatesMap[x.address]), context), context))),
+		statedb.rollup.update(rollupState.address, _ocap_state.rollup.update(rollupState, {
+			blockHeight: itx.height,
+			blockHash: itx.hash
+		}, context), context),
+		statedb.rollupBlock.create(itx.hash, _ocap_state.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, _ocap_state.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(...(0, lodash_cloneDeep.default)(Object.values(stakeUpdatesMap)));
+	context.updatedAccounts.push(...(0, lodash_cloneDeep.default)(Object.values(accountUpdatesMap)));
+	debug$1("create-rollup-block", {
+		itx,
+		updatedAccounts: context.updatedAccounts
+	});
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var create_block_default = runner;
+
+//#endregion
+exports.default = create_block_default;

package/lib/protocols/rollup/create-block.d.cts

@@ -0,0 +1,11 @@
+//#region src/protocols/rollup/create-block.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/lib/protocols/rollup/create.cjs

@@ -0,0 +1,169 @@
+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');
+let _ocap_tx_pipeline = require("@ocap/tx-pipeline");
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let _arcblock_did = require("@arcblock/did");
+let _arcblock_did_util = require("@arcblock/did-util");
+let _ocap_state = require("@ocap/state");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let _ocap_message = require("@ocap/message");
+let _ocap_util_lib_get_list_field = require("@ocap/util/lib/get-list-field");
+let lodash_cloneDeep = require("lodash/cloneDeep");
+lodash_cloneDeep = require_rolldown_runtime.__toESM(lodash_cloneDeep);
+let lodash_isEmpty = require("lodash/isEmpty");
+lodash_isEmpty = require_rolldown_runtime.__toESM(lodash_isEmpty);
+
+//#region src/protocols/rollup/create.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:create-rollup");
+const runner = new _ocap_tx_pipeline.Runner("create_rollup");
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSig(0));
+runner.use((context, next) => {
+	const { itx } = context;
+	context.formattedItx = (0, _ocap_message.formatMessage)("CreateRollupTx", itx);
+	try {
+		_ocap_state.rollup.create(context.formattedItx, context);
+	} catch (err) {
+		return next(new _ocap_util_lib_error.CustomError("INVALID_TX", err.message));
+	}
+	return next();
+});
+runner.use(_ocap_tx_pipeline.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 }) => (0, _arcblock_did.isFromPublicKey)(address, pk));
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Seed validator must use ethereum compatible address",
+		fn: (ctx) => {
+			return (ctx.formattedItx?.seedValidators || []).every(({ address }) => (0, _arcblock_did.isEthereumDid)(address));
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Rollup address is not valid",
+		fn: (ctx) => {
+			const context = ctx;
+			const itx = (0, lodash_cloneDeep.default)(context.itx);
+			itx.data = require_util.decodeAnySafe(itx.data);
+			itx.address = "";
+			context.rollupData = itx.data;
+			context.seedValidators = (0, _ocap_util_lib_get_list_field.getListField)(itx, "seedValidators").map((x) => x.address);
+			return (0, _arcblock_did_util.toRollupAddress)(itx) === context.itx.address;
+		}
+	}
+]));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "seedValidators",
+	to: "validatorStates",
+	status: "INVALID_VALIDATOR_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	signerKey: "validatorStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.delegator",
+	to: "delegatorState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "delegatorState",
+	addressKey: "tx.delegator"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyDelegation({
+	type: "signature",
+	signerKey: "senderState",
+	delegatorKey: "delegatorState",
+	getRequirements: require_util.getDelegationRequirements
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.tokenAddress",
+	to: "tokenState",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "INVALID_TOKEN",
+	message: "Token does not have foreignToken attached",
+	fn: (ctx) => {
+		return (0, lodash_isEmpty.default)(ctx.tokenState?.foreignToken) === false;
+	}
+}]));
+runner.use(async (context, next) => {
+	const { statedb, itx } = context;
+	if (await statedb.rollup.existByToken(itx.tokenAddress, context)) return next(new _ocap_util_lib_error.CustomError("DUPLICATE_ROLLUP", "Only 1 active rollup can be created for the token"));
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.address",
+	to: "rollupState",
+	status: "OK",
+	table: "rollup"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "DUPLICATE_ROLLUP",
+	message: "This rollup already exist on chain",
+	fn: (ctx) => {
+		return (0, lodash_isEmpty.default)(ctx.rollupState);
+	}
+}]));
+runner.use(require_pipes_ensure_gas.default(() => ({
+	create: 1,
+	update: 2,
+	payment: 0
+})));
+runner.use(require_pipes_ensure_cost.default({ attachSenderChanges: true }));
+runner.use(_ocap_tx_pipeline.pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx, 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, _ocap_state.account.update(senderState, {
+			nonce: tx.nonce,
+			...senderUpdates
+		}, context), context),
+		statedb.rollup.create(formattedItx.address, _ocap_state.rollup.create({
+			...formattedItx,
+			issuer,
+			validators: formattedItx.seedValidators || [],
+			data: rollupData
+		}, context), context),
+		context.isDelegationChanged && delegationState ? statedb.delegation.update(delegationState.address, _ocap_state.delegation.update(delegationState, {}, context), context) : Promise.resolve(delegationState)
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.rollupState = newRollupState;
+	context.delegationState = newDelegationState;
+	debug$1("create-rollup", newRollupState);
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var create_default = runner;
+
+//#endregion
+exports.default = create_default;

package/lib/protocols/rollup/create.d.cts

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