@ocap/tx-protocols 1.28.9 → 1.29.0

package/esm/protocols/rollup/leave.mjs

@@ -0,0 +1,137 @@
+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 { toStakeAddress } from "@arcblock/did-util";
+import { account, evidence, rollup, stake } from "@ocap/state";
+import Debug from "debug";
+import { Joi, patterns, schemas } from "@arcblock/validator";
+import MerkleTree from "@ocap/merkle-tree";
+
+//#region src/protocols/rollup/leave.ts
+const debug = Debug("@ocap/tx-protocols:leave-rollup");
+const runner = new Runner("leave_rollup");
+const schema = Joi.object({
+	rollup: Joi.DID().prefix().role("ROLE_ROLLUP").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(ensure_validator_default(false));
+runner.use(verify_status_default({ paused: false }));
+runner.use((context, next) => {
+	context.validatorsHash = MerkleTree.getListHash([context.tx.from]);
+	return next();
+});
+runner.use(verify_signers_default({
+	signersKey: "itx.signaturesList",
+	allowSender: false,
+	allowShrink: true
+}));
+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((context, next) => {
+	if (context.evidenceState) return next(new CustomError("INVALID_TX", "Leave evidence already seen on this chain"));
+	return next();
+});
+runner.use(verify_signers_default({
+	signersKey: "tx.signaturesList",
+	allowSender: false,
+	allowShrink: true
+}));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: "signers" }));
+runner.use((context, next) => {
+	const { tx: tx$1, rollupState } = context;
+	if (rollupState?.seedValidators.some((x) => x.address === tx$1.from)) return next(new CustomError("INVALID_TX", `Address ${tx$1.from} can not leave since it's seed validator`));
+	if (rollupState?.validators.some((x) => x.address === tx$1.from) === false) return next(new CustomError("INVALID_TX", `Address ${tx$1.from} not exist in validator whitelist`));
+	return next();
+});
+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(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, stakeAddress, senderUpdates, updateVaults } = context;
+	const newValidators = rollupState.validators.filter((x) => x.address !== tx$1.from);
+	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: true }, context), context),
+		statedb.evidence.create(itx.evidence.hash, evidence.create({
+			hash: itx.evidence.hash,
+			data: "rollup-leave"
+		}, context), context)
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.rollupState = newRollupState;
+	context.stakeState = newStakeState;
+	context.evidenceState = newEvidenceState;
+	debug("leave-rollup", newValidators);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var leave_default = runner;
+
+//#endregion
+export { leave_default as default };

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

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

package/esm/protocols/rollup/migrate.mjs

@@ -0,0 +1,85 @@
+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 { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { account, rollup } from "@ocap/state";
+import { Joi } from "@arcblock/validator";
+
+//#region src/protocols/rollup/migrate.ts
+const runner = new Runner("migrate_rollup");
+const schema = Joi.object({
+	rollup: Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	to: Joi.DID().prefix().wallet("ethereum").required(),
+	type: Joi.string().trim().valid("vault", "contract").required(),
+	message: Joi.string().trim().min(1).max(512).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(ensure_validator_default(true));
+runner.use(verify_status_default({
+	paused: true,
+	closed: false
+}));
+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(ensure_gas_default(() => ({
+	create: 0,
+	update: 2,
+	payment: 0
+})));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, itx, statedb, rollupState, senderState, senderUpdates, updateVaults } = context;
+	let updates = {};
+	if (itx.type === "vault") updates = rollup.migrateVault(rollupState, itx.to, context);
+	if (itx.type === "contract") updates = rollup.migrateContract(rollupState, itx.to, context);
+	const [newSenderState, newRollupState] = await Promise.all([statedb.account.update(senderState.address, account.update(senderState, {
+		nonce: tx$1.nonce,
+		...senderUpdates
+	}, context), context), statedb.rollup.update(itx.rollup, updates, context)]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.rollupState = newRollupState;
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var migrate_default = runner;
+
+//#endregion
+export { migrate_default as default };

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

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

package/esm/protocols/rollup/pause.mjs

@@ -0,0 +1,76 @@
+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 { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { account, rollup } from "@ocap/state";
+import { Joi } from "@arcblock/validator";
+
+//#region src/protocols/rollup/pause.ts
+const runner = new Runner("pause_rollup");
+const schema = Joi.object({
+	rollup: Joi.DID().prefix().role("ROLE_ROLLUP").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(ensure_validator_default(true));
+runner.use(verify_status_default({ paused: false }));
+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(ensure_gas_default(() => ({
+	create: 0,
+	update: 2,
+	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, senderUpdates, updateVaults } = context;
+	const [newSenderState, newRollupState] = await Promise.all([statedb.account.update(senderState.address, account.update(senderState, {
+		nonce: tx$1.nonce,
+		...senderUpdates
+	}, context), context), statedb.rollup.update(itx.rollup, rollup.pause(rollupState, context), context)]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.rollupState = newRollupState;
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var pause_default = runner;
+
+//#endregion
+export { pause_default as default };

package/esm/protocols/rollup/pipes/ensure-validator.d.mts

@@ -0,0 +1,6 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#region src/protocols/rollup/pipes/ensure-validator.d.ts
+declare const ensure_validator: (isSeed: boolean) => PipeFunction<any>;
+//#endregion
+export { ensure_validator as default };

package/esm/protocols/rollup/pipes/ensure-validator.mjs

@@ -0,0 +1,12 @@
+import { CustomError } from "@ocap/util/lib/error";
+
+//#region src/protocols/rollup/pipes/ensure-validator.ts
+const ensure_validator = (isSeed) => (context, next) => {
+	const { rollupState, tx } = context;
+	if ((isSeed ? rollupState.seedValidators : rollupState.validators).some((x) => x.address === tx?.from) === false) return next(new CustomError("INVALID_TX", "Tx sender is not an expected validator"));
+	return next();
+};
+var ensure_validator_default = ensure_validator;
+
+//#endregion
+export { ensure_validator_default as default };

package/esm/protocols/rollup/pipes/verify-evidence.d.mts

@@ -0,0 +1,15 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#region src/protocols/rollup/pipes/verify-evidence.d.ts
+interface IVerifyEvidenceOptions {
+  evidenceKey: string;
+  signaturesKey: string;
+  verifyMethod?: 'verify' | 'ethVerify';
+}
+declare function CreateVerifyEvidencePipe({
+  evidenceKey,
+  signaturesKey,
+  verifyMethod
+}: IVerifyEvidenceOptions): PipeFunction<any>;
+//#endregion
+export { CreateVerifyEvidencePipe as default };

package/esm/protocols/rollup/pipes/verify-evidence.mjs

@@ -0,0 +1,29 @@
+import { CustomError } from "@ocap/util/lib/error";
+import get from "lodash/get.js";
+import { toTypeInfo } from "@arcblock/did";
+import { toHex } from "@ocap/util";
+import { fromPublicKey as fromPublicKey$1 } from "@ocap/wallet";
+
+//#region src/protocols/rollup/pipes/verify-evidence.ts
+function CreateVerifyEvidencePipe({ evidenceKey, signaturesKey, verifyMethod = "verify" }) {
+	if (["verify", "ethVerify"].includes(verifyMethod) === false) throw new CustomError("INVALID_ARGUMENT", `Invalid verify method: ${verifyMethod}, supported methods are: verify, ethVerify`);
+	return async (context, next) => {
+		const evidence = get(context, evidenceKey);
+		const signatures = get(context, signaturesKey);
+		for (const sig of signatures) {
+			const { signer, pk, delegator, signature } = sig;
+			const address = delegator || signer;
+			const wallet = fromPublicKey$1(pk, toTypeInfo(address));
+			try {
+				if (await wallet[verifyMethod](toHex(evidence), toHex(signature)) === false) return next(new CustomError("INVALID_SIGNATURE", `Signature for evidence from ${address} is not valid`));
+			} catch (err) {
+				return next(new CustomError("INVALID_SIGNATURE", `Signature for evidence from ${address} verify failed: ${err.message}`));
+			}
+		}
+		return next();
+	};
+}
+var verify_evidence_default = CreateVerifyEvidencePipe;
+
+//#endregion
+export { verify_evidence_default as default };

package/esm/protocols/rollup/pipes/verify-signers.d.mts

@@ -0,0 +1,15 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#region src/protocols/rollup/pipes/verify-signers.d.ts
+interface IVerifySignersOptions {
+  signersKey: string;
+  allowSender?: boolean;
+  allowShrink?: boolean;
+}
+declare function CreateVerifySignersPipe({
+  signersKey,
+  allowSender,
+  allowShrink
+}: IVerifySignersOptions): PipeFunction<any>;
+//#endregion
+export { CreateVerifySignersPipe as default };

package/esm/protocols/rollup/pipes/verify-signers.mjs

@@ -0,0 +1,36 @@
+import { CustomError } from "@ocap/util/lib/error";
+import get from "lodash/get.js";
+
+//#region src/protocols/rollup/pipes/verify-signers.ts
+function CreateVerifySignersPipe({ signersKey, allowSender = true, allowShrink = false }) {
+	return (context, next) => {
+		const { tx, rollupState } = context;
+		const rollup = rollupState;
+		const { minSignerCount, maxSignerCount } = rollup;
+		const signatures = get(context, signersKey);
+		const signerCount = signatures.length;
+		const seedValidators = rollup.seedValidators.map((x) => x.address);
+		const validators = rollup.validators.map((x) => x.address);
+		if (!allowSender && signatures.some((x) => x.signer === tx.from)) return next(new CustomError("INVALID_SIGNATURE", `Invalid: ${signersKey}, sender not allowed to sign`));
+		if (validators.length > minSignerCount) {
+			if (signerCount < minSignerCount) return next(new CustomError("INVALID_SIGNATURE", `Invalid: ${signersKey}, expect at least ${minSignerCount} signatures, got ${signerCount}`));
+			if (signerCount > maxSignerCount) return next(new CustomError("INVALID_SIGNATURE", `Invalid: ${signersKey}, Expect at most ${maxSignerCount} signatures, got ${signerCount}`));
+		} else {
+			let actualValidatorCount = validators.length;
+			if (!allowSender && allowShrink) actualValidatorCount -= 1;
+			const expectedSignerCount = Math.min(actualValidatorCount, minSignerCount);
+			if (signerCount < expectedSignerCount) return next(new CustomError("INVALID_SIGNATURE", `Invalid ${signersKey}, all validators are expected to sign because we have less than ${expectedSignerCount} validators`));
+		}
+		const signers = signatures.map((x) => x.signer);
+		const missingSigner = seedValidators.find((x) => signers.includes(x) === false);
+		if (missingSigner) return next(new CustomError("INVALID_SIGNATURE", `Invalid: ${signersKey}, missing signature from seed validator: ${missingSigner}`));
+		const invalidSigner = signers.find((x) => validators.includes(x) === false);
+		if (invalidSigner) return next(new CustomError("INVALID_SIGNATURE", `Invalid: ${signersKey}, signer ${invalidSigner} does not exist in validator whitelist`));
+		context.signers = signers;
+		return next();
+	};
+}
+var verify_signers_default = CreateVerifySignersPipe;
+
+//#endregion
+export { verify_signers_default as default };

package/esm/protocols/rollup/pipes/verify-status.d.mts

@@ -0,0 +1,13 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#region src/protocols/rollup/pipes/verify-status.d.ts
+interface IVerifyStatusOptions {
+  paused?: boolean;
+  closed?: boolean;
+}
+declare const verify_status: ({
+  paused,
+  closed
+}?: IVerifyStatusOptions) => PipeFunction<any>;
+//#endregion
+export { verify_status as default };

package/esm/protocols/rollup/pipes/verify-status.mjs

@@ -0,0 +1,26 @@
+import { pipes } from "@ocap/tx-pipeline";
+
+//#region src/protocols/rollup/pipes/verify-status.ts
+const verify_status = ({ paused, closed } = {}) => {
+	const fns = [];
+	if (paused === false) fns.push({
+		error: "INVALID_TX",
+		message: "The rollup is paused",
+		fn: (context) => !context.rollupState.paused
+	});
+	if (paused === true) fns.push({
+		error: "INVALID_TX",
+		message: "The rollup is not paused",
+		fn: (context) => context.rollupState.paused
+	});
+	if (closed === false) fns.push({
+		error: "INVALID_TX",
+		message: "The rollup is closed",
+		fn: (context) => !context.rollupState.closed
+	});
+	return pipes.VerifyInfo(fns);
+};
+var verify_status_default = verify_status;
+
+//#endregion
+export { verify_status_default as default };

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

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

package/esm/protocols/rollup/resume.mjs

@@ -0,0 +1,79 @@
+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 { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { account, rollup } from "@ocap/state";
+import { Joi } from "@arcblock/validator";
+
+//#region src/protocols/rollup/resume.ts
+const runner = new Runner("resume_rollup");
+const schema = Joi.object({
+	rollup: Joi.DID().prefix().role("ROLE_ROLLUP").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(ensure_validator_default(true));
+runner.use(verify_status_default({
+	paused: true,
+	closed: false
+}));
+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(ensure_gas_default(() => ({
+	create: 0,
+	update: 2,
+	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, senderUpdates, updateVaults } = context;
+	const [newSenderState, newRollupState] = await Promise.all([statedb.account.update(senderState.address, account.update(senderState, {
+		nonce: tx$1.nonce,
+		...senderUpdates
+	}, context), context), statedb.rollup.update(itx.rollup, rollup.resume(rollupState, context), context)]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.rollupState = newRollupState;
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var resume_default = runner;
+
+//#endregion
+export { resume_default as default };

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

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

package/esm/protocols/rollup/update.mjs

@@ -0,0 +1,111 @@
+import { decodeAnySafe } 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 { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { account, rollup } from "@ocap/state";
+import Debug from "debug";
+import { Joi } from "@arcblock/validator";
+
+//#region src/protocols/rollup/update.ts
+const debug = Debug("@ocap/tx-protocols:update-rollup");
+const runner = new Runner("update_rollup");
+const schema = Joi.object({
+	rollup: Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	minStakeAmount: Joi.BN().greater(0).required(),
+	maxStakeAmount: Joi.BN().greater(Joi.ref("minStakeAmount")).required(),
+	minSignerCount: Joi.number().integer().required(),
+	maxSignerCount: Joi.number().integer().min(1).max(8).greater(Joi.ref("minSignerCount")).required(),
+	minBlockSize: Joi.number().integer().min(1).required(),
+	maxBlockSize: Joi.number().integer().min(1).max(10).greater(Joi.ref("minBlockSize")).required(),
+	minBlockInterval: Joi.number().integer().min(1).max(3600).required(),
+	minBlockConfirmation: Joi.number().integer().min(1).max(100).required(),
+	minDepositAmount: Joi.BN().positive().required(),
+	maxDepositAmount: Joi.BN().greater(Joi.ref("minDepositAmount")).required(),
+	minWithdrawAmount: Joi.BN().positive().required(),
+	maxWithdrawAmount: Joi.BN().greater(Joi.ref("minWithdrawAmount")).required(),
+	depositFeeRate: Joi.number().integer().min(1).max(1e4).required(),
+	withdrawFeeRate: Joi.number().integer().min(1).max(1e4).required(),
+	publisherFeeShare: Joi.number().integer().min(1).max(1e4).required(),
+	minDepositFee: Joi.BN().positive().required(),
+	maxDepositFee: Joi.BN().greater(Joi.ref("minDepositFee")).required(),
+	minWithdrawFee: Joi.BN().positive().required(),
+	maxWithdrawFee: Joi.BN().greater(Joi.ref("minWithdrawFee")).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.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;
+	}
+}]));
+runner.use(pipes.ExtractState({
+	from: "itx.rollup",
+	to: "rollupState",
+	status: "INVALID_ROLLUP",
+	table: "rollup"
+}));
+runner.use(ensure_validator_default(true));
+runner.use(verify_status_default({ paused: false }));
+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(ensure_gas_default(() => ({
+	create: 0,
+	update: 2,
+	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, senderUpdates, updateVaults } = context;
+	const data = decodeAnySafe(itx.data ?? null);
+	const [newSenderState, newRollupState] = await Promise.all([statedb.account.update(senderState.address, account.update(senderState, {
+		nonce: tx$1.nonce,
+		...senderUpdates
+	}, context), context), statedb.rollup.update(itx.rollup, rollup.update(rollupState, {
+		...itx,
+		data
+	}, context), context)]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.rollupState = newRollupState;
+	debug("update-rollup", newRollupState);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var update_default = runner;
+
+//#endregion
+export { update_default as default };