@ocap/tx-protocols 1.28.8 → 1.29.0

package/lib/protocols/governance/stake.cjs

@@ -0,0 +1,275 @@
+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 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 _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");
+let node_util = require("node:util");
+let lodash_isEmpty = require("lodash/isEmpty");
+lodash_isEmpty = require_rolldown_runtime.__toESM(lodash_isEmpty);
+
+//#region src/protocols/governance/stake.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:stake");
+const verifyAssetOwner = (0, node_util.promisify)(_ocap_tx_pipeline.pipes.VerifyUpdater({
+	assetKey: "assets",
+	ownerKey: "owner"
+}));
+const runner = new _ocap_tx_pipeline.Runner("stake");
+const schema = _arcblock_validator.Joi.object({
+	address: _arcblock_validator.Joi.DID().prefix().role("ROLE_STAKE").required(),
+	receiver: _arcblock_validator.Joi.DID().prefix().required(),
+	slashersList: _arcblock_validator.Joi.array().items(_arcblock_validator.Joi.DID().prefix()).default([]),
+	locked: _arcblock_validator.Joi.boolean().default(false),
+	inputsList: _arcblock_validator.schemas.multiInput.min(1).required(),
+	message: _arcblock_validator.Joi.string().trim().min(1).max(256).required(),
+	revokeWaitingPeriod: _arcblock_validator.Joi.number().integer().min(0).default(0),
+	data: _arcblock_validator.Joi.any().optional().allow(null),
+	nonce: _arcblock_validator.Joi.string().trim().min(1).max(256).allow("").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.VerifyTxInput({
+	fieldKey: "itx.inputs",
+	inputsKey: "inputs",
+	sendersKey: "senders",
+	tokensKey: "tokens",
+	assetsKey: "assets"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([
+	{
+		error: "INVALID_TX",
+		message: "Invalid staking address",
+		fn: (ctx) => {
+			const context = ctx;
+			return (0, _arcblock_did_util.toStakeAddress)(context.tx.from, context.itx.receiver, context.itx.nonce) === context.itx.address;
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Tx sender can not be slasher",
+		fn: (ctx) => {
+			const context = ctx;
+			const slashers = (0, _ocap_util_lib_get_list_field.getListField)(context.itx, "slashers");
+			return slashers.length === 0 || slashers.includes(context.tx.from) === false;
+		}
+	},
+	{
+		error: "INSUFFICIENT_DATA",
+		message: "Can not stake without any token or asset",
+		fn: (ctx) => {
+			const context = ctx;
+			return !((0, lodash_isEmpty.default)(context.tokens) && (0, lodash_isEmpty.default)(context.assets));
+		}
+	}
+]));
+runner.use(_ocap_tx_pipeline.pipes.VerifyListSize({ listKey: [
+	"inputs",
+	"senders",
+	"tokens",
+	"assets"
+] }));
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSigV2({ signersKey: "senders" }));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.address",
+	to: "stakeState",
+	status: "OK",
+	table: "stake"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "OK",
+	table: "account"
+}));
+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: "INVALID_RECEIVER_STATE"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyBlocked({ stateKeys: ["signerStates", "receiverState"] }));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "receiverState",
+	addressKey: "itx.receiver"
+}));
+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(_ocap_tx_pipeline.pipes.verifyTokenAccess({
+	statesKey: "tokenStates",
+	listFieldKey: "spenders",
+	accountKeys: ["senderState"],
+	errorMessage: "Account {address} is not allowed to stake token {tokenAddress}"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "assets",
+	to: "assetStates",
+	status: "OK",
+	table: "asset"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyTransferrable({ assets: "assetStates" }));
+runner.use(async (context, next) => {
+	const { inputs = [], assetStates = [], signerStates = [] } = context;
+	for (const input of inputs) {
+		const { owner } = input;
+		const assetsList = (0, _ocap_util_lib_get_list_field.getListField)(input, "assets");
+		const states = assetStates.filter((x) => assetsList.includes(x.address));
+		const signer = signerStates.find((x) => x.address === owner);
+		try {
+			await verifyAssetOwner({
+				assets: states,
+				owner: signer
+			});
+		} catch (err) {
+			return next(err);
+		}
+	}
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.slashersList",
+	to: "slasherStates",
+	status: "INVALID_SLASHER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "slasherStates",
+	addressKey: "itx.slashersList"
+}));
+runner.use((context, next) => {
+	const { tx, itx, inputs = [] } = context;
+	const { config } = context;
+	const { token, transaction } = config;
+	const { minStake, maxStake } = transaction.txGas;
+	context.isGasStake = require_util.isGasStakeAddress(tx.from, itx.address) && require_util.isGasStakeInput(inputs, token.address);
+	if (context.isGasStake) {
+		const [tokenInput] = (0, _ocap_util_lib_get_list_field.getListField)(inputs[0], "tokens");
+		const actualStake = new _ocap_util.BN(tokenInput.value);
+		const expectedMinStake = (0, _ocap_util.fromTokenToUnit)(minStake, token.decimal);
+		const expectedMaxStake = (0, _ocap_util.fromTokenToUnit)(maxStake, token.decimal);
+		if (actualStake.lt(expectedMinStake)) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Stake for gas should be greater than: ${minStake}`));
+		if (actualStake.gt(expectedMaxStake)) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Stake for gas should be less than: ${maxStake}`));
+	}
+	if (context.isGasStake) {
+		context.revokeWaitingPeriod = transaction.txGas.stakeLockPeriod;
+		context.slashers = [config.moderator.address];
+	} else {
+		context.revokeWaitingPeriod = itx.revokeWaitingPeriod;
+		context.slashers = (0, _ocap_util_lib_get_list_field.getListField)(itx, "slashers");
+	}
+	return next();
+});
+runner.use(require_pipes_ensure_gas.default((context) => {
+	const result = {
+		create: 0,
+		update: 0,
+		payment: 0
+	};
+	if ((context.senderState ? context.senderState.address : context.tx.from) === (context.receiverState ? context.receiverState.address : context.itx.receiver)) {
+		Object.defineProperty(context, "txBaseGas", { value: false });
+		return result;
+	}
+	if (context.senderState) result.update += 1;
+	else result.create += 1;
+	if (context.stakeState) result.update += 1;
+	else result.create += 1;
+	if (context.signerStates) result.update += context.signerStates.length;
+	if (context.assetStates) result.update += context.assetStates.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, inputs = [], statedb, senderState, senderChange, stakeState, signerStates = [], updateVaults, assetStates = [] } = context;
+	const signerUpdates = {};
+	const stakeUpdates = stakeState ? {
+		tokens: stakeState.tokens,
+		assets: stakeState.assets || [],
+		data: itx.data
+	} : {
+		tokens: {},
+		assets: [],
+		data: itx.data
+	};
+	inputs.forEach((x) => {
+		const { owner } = x;
+		const tokensList = (0, _ocap_util_lib_get_list_field.getListField)(x, "tokens");
+		const assetsList = (0, _ocap_util_lib_get_list_field.getListField)(x, "assets");
+		signerUpdates[owner] = require_util.applyTokenUpdates(tokensList, signerStates.find((s) => s.address === owner), "sub");
+		if (senderChange && owner === senderChange.address) signerUpdates[owner] = require_util.applyTokenChange(signerUpdates[owner], senderChange);
+		Object.assign(stakeUpdates, require_util.applyTokenUpdates(tokensList, stakeUpdates, "add"));
+		stakeUpdates.assets.push(...assetsList);
+	});
+	const isAlsoSigner = !!signerUpdates[tx.from];
+	const [newSenderState, newSignerStates, newStakeState, newAssetStates] = await Promise.all([
+		statedb.account.updateOrCreate(senderState ?? null, _ocap_state.account.updateOrCreate(senderState ?? null, Object.assign({
+			address: tx.from,
+			nonce: tx.nonce,
+			pk: tx.pk
+		}, signerUpdates[tx.from] || (senderChange ? require_util.applyTokenChange(senderState ?? {}, senderChange) : {})), context), context),
+		Promise.all(signerStates.filter((x) => x.address !== tx.from).map((x) => statedb.account.update(x.address, _ocap_state.account.update(x, signerUpdates[x.address], context), context))),
+		stakeState ? statedb.stake.update(stakeState.address, _ocap_state.stake.update(stakeState, stakeUpdates, context), context) : statedb.stake.create(itx.address, _ocap_state.stake.create({
+			sender: tx.from,
+			revocable: !itx.locked,
+			slashers: context.slashers,
+			revokeWaitingPeriod: context.revokeWaitingPeriod,
+			...(0, lodash_pick.default)(itx, [
+				"address",
+				"receiver",
+				"message",
+				"data",
+				"nonce"
+			]),
+			...stakeUpdates
+		}, context), context),
+		Promise.all(assetStates.map((x) => statedb.asset.update(x.address, _ocap_state.asset.update(x, { owner: itx.address }, context), context)))
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.signerStates = isAlsoSigner ? newSignerStates.concat(newSenderState) : newSignerStates;
+	context.stakeState = newStakeState;
+	context.assetStates = newAssetStates;
+	debug$1("stake", {
+		address: itx.address,
+		stakeUpdates,
+		signerUpdates
+	});
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var stake_default = runner;
+
+//#endregion
+exports.default = stake_default;

package/lib/protocols/governance/stake.d.cts

@@ -0,0 +1,15 @@
+//#region src/protocols/governance/stake.d.ts
+/** Token input type */
+interface TokenInput {
+  address: string;
+  value: string;
+}
+/** Multi-input type - uses List suffix in proto but runtime has both */
+interface MultiInput {
+  owner: string;
+  tokensList?: TokenInput[];
+  assetsList?: string[];
+}
+declare const runner: any;
+//#endregion
+export { MultiInput, TokenInput, runner as default };

package/lib/protocols/rollup/claim-reward.cjs

@@ -0,0 +1,328 @@
+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');
+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 lodash_cloneDeep = require("lodash/cloneDeep");
+lodash_cloneDeep = require_rolldown_runtime.__toESM(lodash_cloneDeep);
+let lodash_groupBy = require("lodash/groupBy");
+lodash_groupBy = require_rolldown_runtime.__toESM(lodash_groupBy);
+let _arcblock_validator = require("@arcblock/validator");
+let lodash_uniqBy = require("lodash/uniqBy");
+lodash_uniqBy = require_rolldown_runtime.__toESM(lodash_uniqBy);
+
+//#region src/protocols/rollup/claim-reward.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:claim-block-reward");
+const runner = new _ocap_tx_pipeline.Runner("claim_block_reward");
+const schema = _arcblock_validator.Joi.object({
+	rollup: _arcblock_validator.Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	blockHeight: _arcblock_validator.Joi.number().integer().greater(0).required(),
+	blockHash: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required(),
+	evidence: _arcblock_validator.Joi.object({ hash: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required() }).required(),
+	publisher: _arcblock_validator.Joi.DID().prefix().wallet("ethereum").required(),
+	data: _arcblock_validator.Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use((context, next) => {
+	const { tx, itx } = context;
+	const { error } = schema.validate(itx);
+	if (error) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", error.message));
+	if (tx.from !== itx.publisher) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "itx.publisher must be same with tx.from"));
+	context.lockerAddress = require_util.getRewardLocker(itx.rollup);
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.evidence.hash",
+	to: "evidenceSeen",
+	status: "OK",
+	table: "evidence"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.blockHash",
+	to: "blockClaimed",
+	status: "OK",
+	table: "evidence"
+}));
+runner.use(({ evidenceSeen, blockClaimed }, next) => {
+	if (evidenceSeen) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "Claim evidence already seen on this chain"));
+	if (blockClaimed) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "Block reward already claimed before this tx"));
+	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(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.blockHash",
+	to: "blockState",
+	status: "INVALID_ROLLUP_BLOCK",
+	table: "rollupBlock"
+}));
+runner.use((context, next) => {
+	const { blockState, rollupState, itx } = context;
+	if (blockState.rollup !== rollupState.address) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "Rollup block belonging does not match"));
+	if (blockState.height !== itx.blockHeight) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "Rollup block height does not match"));
+	if (blockState.proposer !== itx.publisher) {
+		const proposedAt = +new Date(blockState.context.genesisTime);
+		const publishedAt = +new Date(context.txTime);
+		if (proposedAt + rollupState.publishWaitingPeriod * 1e3 > publishedAt) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "Rollup block can only be published by producer during waiting period"));
+	}
+	context.producerStakeAddress = (0, _arcblock_did_util.toStakeAddress)(blockState.proposer, itx.rollup);
+	return next();
+});
+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: "lockerAddress",
+	to: "lockerState",
+	status: "INVALID_LOCKER_STATE",
+	table: "stake"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "producerStakeAddress",
+	to: "stakeState",
+	status: "INVALID_STAKE_STATE",
+	table: "stake"
+}));
+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: "rollupState.tokenAddress",
+	to: "tokenState",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "blockState.txs",
+	to: "txs",
+	status: "INVALID_TX",
+	table: "tx"
+}));
+runner.use((context, next) => {
+	const { itx, txs, rollupState, blockState, lockerState, tokenState, stakeState } = context;
+	const { proposerFeeShare, publisherFeeShare } = rollupState;
+	const shares = {
+		publisher: publisherFeeShare,
+		proposer: proposerFeeShare,
+		validator: 1e4 - publisherFeeShare - proposerFeeShare
+	};
+	const changes = {
+		account: [],
+		stake: []
+	};
+	if (blockState.proposer !== itx.publisher) {
+		const slashAmount = new _ocap_util.BN(rollupState.minStakeAmount).mul(new _ocap_util.BN(rollupState.publishSlashRate)).div(require_util.RATE_BASE);
+		const slashShare = slashAmount.div(new _ocap_util.BN(2));
+		changes.stake.push({
+			address: stakeState.address,
+			delta: `-${slashAmount.toString(10)}`,
+			action: "slash"
+		});
+		changes.stake.push({
+			address: lockerState.address,
+			delta: slashShare.toString(10),
+			action: "slash"
+		});
+		changes.account.push({
+			address: itx.publisher,
+			delta: slashShare.toString(10),
+			action: "reward"
+		});
+	}
+	(txs || []).forEach((x) => {
+		const txData = x.tx;
+		const { actualFee } = txData.itxJson;
+		const { publisher, proposer, validator } = require_util.splitTxFee({
+			total: actualFee,
+			shares,
+			stringify: false
+		});
+		changes.stake.push({
+			address: lockerState.address,
+			delta: `-${actualFee}`,
+			action: "claim"
+		});
+		changes.account.push({
+			address: itx.publisher,
+			delta: publisher.toString(10),
+			action: "fee"
+		});
+		if (x.type === "deposit_token_v2") {
+			const txItxJson = txData.itxJson;
+			changes.account.push({
+				address: txItxJson.proposer,
+				delta: proposer.toString(10),
+				action: "fee"
+			});
+			const txSignatures = txData.signatures;
+			const blockSignatures = blockState.signatures;
+			const validators = txSignatures.map((s) => s.signer).concat(blockSignatures.map((s) => s.signer));
+			const validatorShare = validator.div(new _ocap_util.BN(validators.length));
+			validators.forEach((v) => changes.account.push({
+				address: v,
+				delta: validatorShare.toString(10),
+				action: "fee"
+			}));
+		} else if (x.type === "withdraw_token_v2") {
+			changes.account.push({
+				address: blockState.proposer,
+				delta: proposer.toString(10),
+				action: "fee"
+			});
+			const validators = blockState.signatures.map((s) => s.signer);
+			const validatorShares = require_util.splitTxFee({
+				total: validator.toString(10),
+				shares: validators.reduce((acc, signer) => {
+					acc[signer] = 1;
+					return acc;
+				}, {}),
+				rateBase: new _ocap_util.BN(validators.length)
+			});
+			Object.keys(validatorShares).forEach((v) => changes.account.push({
+				address: v,
+				delta: validatorShares[v],
+				action: "fee"
+			}));
+		}
+	});
+	const grouped = {
+		account: (0, lodash_groupBy.default)(changes.account, "address"),
+		stake: (0, lodash_groupBy.default)(changes.stake, "address")
+	};
+	const updates = {
+		stake: Object.keys(grouped.stake).reduce((acc, x) => {
+			acc[x] = {
+				address: x,
+				token: tokenState.address,
+				delta: require_util.getBNSum(...grouped.stake[x].map((c) => c.delta)),
+				action: grouped.stake[x][grouped.stake[x].length - 1].action
+			};
+			return acc;
+		}, {}),
+		account: Object.keys(grouped.account).reduce((acc, x) => {
+			acc[x] = {
+				address: x,
+				token: tokenState.address,
+				delta: require_util.getBNSum(...grouped.account[x].map((c) => c.delta)),
+				action: grouped.account[x][grouped.account[x].length - 1].action
+			};
+			return acc;
+		}, {})
+	};
+	context.changes = changes;
+	context.updates = updates;
+	return next();
+});
+runner.use((context, next) => {
+	const { updates, senderState, signerStates } = context;
+	const requiredAccounts = Object.keys(updates.account);
+	const knownAccounts = { [senderState.address]: senderState };
+	(signerStates || []).forEach((x) => knownAccounts[x.address] = x);
+	context.missingAccounts = requiredAccounts.filter((x) => !knownAccounts[x]);
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "missingAccounts",
+	to: "missingAccountStates",
+	status: "INVALID_SIGNER_STATE",
+	table: "account"
+}));
+runner.use((context, next) => {
+	const { senderState, signerStates, missingAccountStates } = context;
+	context.accountStates = (0, lodash_uniqBy.default)([
+		senderState,
+		...signerStates || [],
+		...missingAccountStates || []
+	], "address");
+	return next();
+});
+runner.use(require_pipes_ensure_gas.default((context) => {
+	const result = {
+		create: 2,
+		update: 1,
+		payment: 0
+	};
+	result.update += context.accountStates?.length || 0;
+	if (context.updates?.stake[context.lockerState.address]) result.update += 1;
+	if (context.updates?.stake[context.stakeState.address]) result.update += 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, updates, statedb, senderState, blockState, lockerState, stakeState, accountStates, senderChange, updateVaults } = context;
+	const stakeUpdates = updates.stake;
+	const accountUpdates = updates.account;
+	const [newStakeStates, newAccountStates, newBlockState] = await Promise.all([
+		Promise.all([lockerState, stakeState].map((x) => stakeUpdates[x.address] ? statedb.stake.update(x.address, _ocap_state.stake.update(x, require_util.applyTokenChange(x, stakeUpdates[x.address]), context), context) : x)),
+		Promise.all((accountStates || []).map((x) => {
+			if (accountUpdates[x.address]) {
+				let updateSet = require_util.applyTokenChange(x, accountUpdates[x.address]);
+				if (x.address === senderState.address) {
+					updateSet.nonce = tx.nonce;
+					updateSet = Object.assign(updateSet, senderChange ? require_util.applyTokenChange(updateSet, senderChange) : {});
+				}
+				return statedb.account.update(x.address, _ocap_state.account.update(x, updateSet, context), context);
+			}
+			return x;
+		})),
+		statedb.rollupBlock.update(blockState.hash, _ocap_state.rollupBlock.update(blockState, context), context),
+		statedb.evidence.create(itx.evidence.hash, _ocap_state.evidence.create({
+			hash: itx.evidence.hash,
+			data: "rollup-claim-block-reward"
+		}, context), context),
+		statedb.evidence.create(itx.blockHash, _ocap_state.evidence.create({
+			hash: itx.blockHash,
+			data: "rollup-claim-block-reward"
+		}, context), context)
+	]);
+	if (updateVaults) await updateVaults();
+	delete context.stakeState;
+	context.stakeStates = newStakeStates.filter((x) => stakeUpdates[x.address]);
+	context.accountStates = newAccountStates;
+	context.blockState = newBlockState;
+	context.updatedAccounts = context.updatedAccounts || [];
+	context.updatedAccounts.push(...(0, lodash_cloneDeep.default)(Object.values(accountUpdates)));
+	context.updatedAccounts.push(...(0, lodash_cloneDeep.default)(Object.values(stakeUpdates)));
+	debug$1("claim-block-reward", itx);
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var claim_reward_default = runner;
+
+//#endregion
+exports.default = claim_reward_default;

package/lib/protocols/rollup/claim-reward.d.cts

@@ -0,0 +1,11 @@
+//#region src/protocols/rollup/claim-reward.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 };