@ocap/tx-protocols 1.28.8 → 1.29.0

package/lib/protocols/asset/pipes/verify-itx-assets.d.cts

@@ -0,0 +1,18 @@
+import { IAssetFactoryState, IAssetState, IDecodedContext } from "@ocap/types";
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#region src/protocols/asset/pipes/verify-itx-assets.d.ts
+
+/**
+ * Context type for verify-itx-assets pipe.
+ * Requires: factoryState, itx
+ * Optional: expectedFactoryStates, assetStates
+ */
+type VerifyItxAssetsContext = IDecodedContext & {
+  factoryState?: IAssetFactoryState;
+  expectedFactoryStates?: IAssetFactoryState[];
+  assetStates?: IAssetState[];
+};
+declare const verify_itx_assets: PipeFunction<VerifyItxAssetsContext>;
+//#endregion
+export { verify_itx_assets as default };

package/lib/protocols/asset/pipes/verify-itx-variables.cjs

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let _ocap_util_lib_get_list_field = require("@ocap/util/lib/get-list-field");
+
+//#region src/protocols/asset/pipes/verify-itx-variables.ts
+const verify_itx_variables = (context, next) => {
+	const { factoryState, itx } = context;
+	const variables = factoryState.input.variables;
+	const factoryInputs = (0, _ocap_util_lib_get_list_field.getListField)(itx, "variables").reduce((acc, x) => {
+		acc[x.name] = x.value;
+		return acc;
+	}, {});
+	const missingVariables = variables.filter((x) => x.required && !factoryInputs[x.name]);
+	if (missingVariables.length) return next(new _ocap_util_lib_error.CustomError("INVALID_FACTORY_INPUT", `Invalid itx.variables: missing required input variable: ${missingVariables.map((x) => x.name).join(", ")}`));
+	context.factoryInputs = factoryInputs;
+	return next();
+};
+var verify_itx_variables_default = verify_itx_variables;
+
+//#endregion
+exports.default = verify_itx_variables_default;

package/lib/protocols/asset/pipes/verify-itx-variables.d.cts

@@ -0,0 +1,17 @@
+import { IAssetFactoryState, IDecodedContext } from "@ocap/types";
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#region src/protocols/asset/pipes/verify-itx-variables.d.ts
+
+/**
+ * Context type for verify-itx-variables pipe.
+ * Requires: factoryState, itx
+ * Sets: factoryInputs
+ */
+type VerifyItxVariablesContext = IDecodedContext & {
+  factoryState?: IAssetFactoryState;
+  factoryInputs?: Record<string, unknown>;
+};
+declare const verify_itx_variables: PipeFunction<VerifyItxVariablesContext>;
+//#endregion
+export { verify_itx_variables as default };

package/lib/protocols/asset/pipes/verify-mint-limit.cjs

@@ -0,0 +1,16 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+
+//#region src/protocols/asset/pipes/verify-mint-limit.ts
+const verify_mint_limit = ({ factoryState }, next) => {
+	const factory = factoryState;
+	const limit = factory.limit;
+	if (limit === 0) return next();
+	if (factory.numMinted < limit) return next();
+	return next(new _ocap_util_lib_error.CustomError("EXCEED_MINT_LIMIT", "This request will exceed factory mint limit"));
+};
+var verify_mint_limit_default = verify_mint_limit;
+
+//#endregion
+exports.default = verify_mint_limit_default;

package/lib/protocols/asset/pipes/verify-mint-limit.d.cts

@@ -0,0 +1,15 @@
+import { IAssetFactoryState, IBaseContext } from "@ocap/types";
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#region src/protocols/asset/pipes/verify-mint-limit.d.ts
+
+/**
+ * Context type for verify-mint-limit pipe.
+ * Requires: factoryState
+ */
+type VerifyMintLimitContext = IBaseContext & {
+  factoryState?: IAssetFactoryState;
+};
+declare const verify_mint_limit: PipeFunction<VerifyMintLimitContext>;
+//#endregion
+export { verify_mint_limit as default };

package/lib/protocols/asset/update.cjs

@@ -0,0 +1,114 @@
+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 _ocap_state = require("@ocap/state");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let _arcblock_validator = require("@arcblock/validator");
+let deep_diff = require("deep-diff");
+
+//#region src/protocols/asset/update.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:update-asset");
+const runner = new _ocap_tx_pipeline.Runner("update_asset");
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSig(0));
+const schema = _arcblock_validator.Joi.object({
+	address: _arcblock_validator.Joi.DID().prefix().role("ROLE_ASSET").required(),
+	moniker: _arcblock_validator.Joi.string().min(2).max(255).optional().allow(null).allow(""),
+	consumed: _arcblock_validator.Joi.boolean().optional().allow(null).default(false),
+	data: _arcblock_validator.Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use((context, next) => {
+	const { itx } = context;
+	const { error } = schema.validate(itx);
+	if (error) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	if (!itx.moniker && !itx.data) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "itx.moniker and itx.data can not be empty at the same time"));
+	context.newData = require_util.decodeAnySafe(itx.data ?? null);
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.address",
+	to: "assetState",
+	status: "INVALID_ASSET",
+	table: "asset"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "assetState.issuer",
+	to: "issuerState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyUpdater({
+	assetKey: "assetState",
+	ownerKey: "senderState",
+	updaterKey: ["owner", "issuer"]
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "READONLY_ASSET",
+	message: "Can not update a readonly asset",
+	fn: (ctx) => ctx.assetState.readonly === false,
+	persist: true
+}, {
+	error: "CONSUMED_ASSET",
+	message: "Can not consume an already consumed asset",
+	fn: (ctx) => {
+		const context = ctx;
+		return !(context.itx.consumed && context.assetState.consumedTime);
+	},
+	persist: true
+}]));
+runner.use((context, next) => {
+	const { itx, newData, senderState, assetState, issuerState } = context;
+	if (issuerState && senderState.address === issuerState.address) {
+		if (itx.moniker !== assetState.moniker) return next(new _ocap_util_lib_error.CustomError("FORBIDDEN", "Asset moniker can only be updated by owner"));
+		if (newData?.type !== assetState.data?.type) return next(new _ocap_util_lib_error.CustomError("FORBIDDEN", "Asset data type can only be updated by owner"));
+		if (((0, deep_diff.diff)(assetState.data?.value, newData?.value) || []).every((x) => x.kind === "N" || x.kind === "A" && x.item.kind === "N") === false) return next(new _ocap_util_lib_error.CustomError("APPEND_ONLY", "Asset data value can only be updated in append only mode"));
+	}
+	return next();
+});
+runner.use(require_pipes_ensure_gas.default(() => ({
+	create: 0,
+	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, itx, txTime, newData, statedb, senderState, senderUpdates, assetState, updateVaults } = context;
+	const updates = {
+		moniker: itx.moniker || assetState.moniker,
+		data: newData || assetState.data
+	};
+	if (itx.consumed && !assetState.consumedTime) updates.consumedTime = txTime;
+	const [newSenderState, newAssetState] = await Promise.all([statedb.account.update(senderState.address, _ocap_state.account.update(senderState, {
+		nonce: tx.nonce,
+		pk: tx.pk,
+		...senderUpdates
+	}, context), context), statedb.asset.update(itx.address, _ocap_state.asset.update(assetState, updates, context), context)]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.assetState = newAssetState;
+	debug$1("update", newAssetState);
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var update_default = runner;
+
+//#endregion
+exports.default = update_default;

package/lib/protocols/asset/update.d.cts

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

package/lib/protocols/factory/create.cjs

@@ -0,0 +1,161 @@
+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_get = require("lodash/get");
+lodash_get = require_rolldown_runtime.__toESM(lodash_get);
+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_message = require("@ocap/message");
+let lodash_cloneDeep = require("lodash/cloneDeep");
+lodash_cloneDeep = require_rolldown_runtime.__toESM(lodash_cloneDeep);
+let _ocap_asset = require("@ocap/asset");
+let lodash_isEmpty = require("lodash/isEmpty");
+lodash_isEmpty = require_rolldown_runtime.__toESM(lodash_isEmpty);
+
+//#region src/protocols/factory/create.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:create-factory");
+const runner = new _ocap_tx_pipeline.Runner("create_factory");
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSig(0));
+runner.use((context, next) => {
+	const factoryProps = (0, _ocap_message.formatMessage)("CreateFactoryTx", context.itx);
+	try {
+		(0, _ocap_asset.isValidFactory)(factoryProps);
+	} catch (err) {
+		return next(new _ocap_util_lib_error.CustomError("INVALID_FACTORY_PROPS", err.message));
+	}
+	if (factoryProps.output.data) factoryProps.output.data = require_util.decodeAnySafe(factoryProps.output.data);
+	if (factoryProps.name.length < 2 || factoryProps.name.length > 255) return next(new _ocap_util_lib_error.CustomError("INVALID_FACTORY_PROPS", "Length of factory name should between 2 and 255 characters"));
+	const props = (0, lodash_cloneDeep.default)(factoryProps);
+	props.address = "";
+	if ((0, _arcblock_did_util.toFactoryAddress)(props) !== factoryProps.address) return next(new _ocap_util_lib_error.CustomError("INVALID_FACTORY_PROPS", "Factory address is not valid"));
+	const factoryTokenAddresses = (factoryProps.input.tokens || []).map((x) => x.address);
+	const maxListSize = (0, lodash_get.default)(context, "config.transaction.maxListSize");
+	if (factoryTokenAddresses.length > maxListSize) return next(new _ocap_util_lib_error.CustomError("INVALID_FACTORY_INPUT", `input.tokens exceeded max allowed length: ${maxListSize}`));
+	if (factoryProps.input.assets.length > maxListSize) return next(new _ocap_util_lib_error.CustomError("INVALID_FACTORY_INPUT", `input.assets exceeded max allowed length: ${maxListSize}`));
+	if (new _ocap_util.BN(factoryProps.input.value || 0).gt(new _ocap_util.BN(0))) {
+		factoryTokenAddresses.push(context.config.token.address);
+		factoryProps.input.tokens.push({
+			address: context.config.token.address,
+			value: factoryProps.input.value
+		});
+		factoryProps.input.value = "0";
+	}
+	context.factoryTokens = factoryTokenAddresses;
+	context.factoryProps = factoryProps;
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.address",
+	to: "factoryState",
+	status: "OK"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "DUPLICATE_FACTORY",
+	message: "This asset factory already exist on chain",
+	fn: (ctx) => {
+		return (0, lodash_isEmpty.default)(ctx.factoryState);
+	}
+}]));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	table: "account",
+	status: "INVALID_SENDER_STATE"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	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: "factoryTokens",
+	to: "tokenStates",
+	table: "token",
+	status: "INVALID_FACTORY_INPUT"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "factoryProps.input.assets",
+	to: "inputAssetStates",
+	table: "asset",
+	status: "OK"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "factoryProps.input.assets",
+	to: "inputFactoryStates",
+	table: "factory",
+	status: "OK"
+}));
+runner.use((context, next) => {
+	const { inputAssetStates = [], inputFactoryStates = [], factoryProps } = context;
+	if (inputAssetStates.some((x) => !!x.consumedTime)) return next(new _ocap_util_lib_error.CustomError("INVALID_FACTORY_INPUT", "Some of input.assets already consumed"));
+	if (inputAssetStates.length + inputFactoryStates.length === factoryProps.input.assets.length) return next();
+	return next(new _ocap_util_lib_error.CustomError("INVALID_FACTORY_INPUT", "Not all input.assets exist on chain"));
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "factoryProps.trustedIssuers",
+	to: "issuerStates",
+	table: "account",
+	status: "INVALID_ISSUER_STATE"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "issuerStates",
+	addressKey: "factoryProps.trustedIssuers"
+}));
+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, itx, statedb, senderState, delegatorState, delegationState, senderUpdates, factoryProps, updateVaults } = context;
+	const tokens = { [context.config.token.address]: "0" };
+	const owner = delegatorState ? delegatorState.address : senderState.address;
+	const [newSenderState, factoryState, newDelegationState] = await Promise.all([
+		statedb.account.update(senderState.address, _ocap_state.account.update(senderState, {
+			nonce: tx.nonce,
+			pk: tx.pk,
+			...senderUpdates
+		}, context), context),
+		statedb.factory.create(itx.address, _ocap_state.factory.create({
+			...factoryProps,
+			tokens,
+			owner
+		}, context), context),
+		context.isDelegationChanged ? statedb.delegation.update(delegationState.address, _ocap_state.delegation.update(delegationState, {}, context), context) : delegationState ?? null
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.factoryState = factoryState ?? void 0;
+	context.delegationState = newDelegationState ?? void 0;
+	debug$1("createFactory", factoryState);
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var create_default = runner;
+
+//#endregion
+exports.default = create_default;

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

@@ -0,0 +1,29 @@
+//#region src/protocols/factory/create.d.ts
+/** Formatted factory properties from formatMessage */
+interface FormattedFactoryProps {
+  name: string;
+  description: string;
+  settlement: string;
+  limit: number;
+  trustedIssuers: string[];
+  input: {
+    value: string;
+    tokens: Array<{
+      address: string;
+      value: string;
+    }>;
+    assets: string[];
+    variables: unknown[];
+  };
+  output: {
+    data?: unknown;
+    [key: string]: unknown;
+  };
+  hooks: unknown[];
+  address: string;
+  display?: unknown;
+  data?: unknown;
+}
+declare const runner: any;
+//#endregion
+export { FormattedFactoryProps, runner as default };

package/lib/protocols/governance/claim-stake.cjs

@@ -0,0 +1,223 @@
+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 _ocap_state = require("@ocap/state");
+let _ocap_util = require("@ocap/util");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let _arcblock_validator = require("@arcblock/validator");
+let _ocap_util_lib_get_related_addr = require("@ocap/util/lib/get-related-addr");
+
+//#region src/protocols/governance/claim-stake.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:claim-stake");
+const runner = new _ocap_tx_pipeline.Runner("claim_stake");
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSig(0));
+const schema = _arcblock_validator.Joi.object({
+	address: _arcblock_validator.Joi.DID().prefix().role("ROLE_STAKE").required(),
+	evidence: _arcblock_validator.Joi.object({ hash: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required() }).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: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.address",
+	to: "stakeState",
+	status: "INVALID_STAKE_STATE",
+	table: "stake"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "SENDER_NOT_MATCH",
+	message: "You are not allowed to claim stake from this address",
+	fn: (ctx) => {
+		const { senderState, stakeState } = ctx;
+		return (0, _ocap_util_lib_get_related_addr.getRelatedAddresses)(senderState).includes(stakeState.sender);
+	}
+}]));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.evidence.hash",
+	to: "evidenceState",
+	status: "OK",
+	table: "evidence"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "ALREADY_CLAIMED",
+	message: "Revoke evidence already seen on this chain",
+	fn: (ctx) => {
+		const { evidenceState } = ctx;
+		return !evidenceState;
+	}
+}]));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.evidence.hash",
+	to: "txState",
+	status: "INVALID_TX",
+	table: "tx"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([
+	{
+		error: "INVALID_TX",
+		message: "Evidence tx is not valid",
+		fn: (ctx) => {
+			const { txState } = ctx;
+			return txState.code === "OK";
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Evidence tx type is not valid",
+		fn: (ctx) => {
+			const { txState } = ctx;
+			return txState.type === "revoke_stake";
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Evidence tx does not belong to same stake",
+		fn: (ctx) => {
+			const { txState, itx } = ctx;
+			return txState.tx.itxJson.address === itx.address;
+		}
+	},
+	{
+		error: "WITHIN_WAITING_PERIOD",
+		message: "You can not claim stake before waiting period ends",
+		fn: (ctx) => {
+			const { txState, stakeState, txTime } = ctx;
+			const end = +new Date(txState.time) + (stakeState.revokeWaitingPeriod || 0) * 1e3;
+			return +new Date(txTime) > end;
+		}
+	}
+]));
+runner.use(_ocap_tx_pipeline.pipes.VerifyTxInput({
+	fieldKey: "txState.tx.itxJson.outputs",
+	inputsKey: "outputs",
+	sendersKey: "receivers",
+	tokensKey: "tokens",
+	assetsKey: "assets"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "receivers",
+	to: "receiverStates",
+	status: "INVALID_RECEIVER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tokens",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use((context, next) => {
+	const { outputs = [], stakeState } = context;
+	const tokensToClaim = {};
+	outputs.forEach(({ tokens }) => {
+		(tokens || []).forEach(({ address, value }) => {
+			if (typeof tokensToClaim[address] === "undefined") tokensToClaim[address] = new _ocap_util.BN(0);
+			tokensToClaim[address] = tokensToClaim[address].add(new _ocap_util.BN(value));
+		});
+	});
+	context.tokenCondition = {
+		owner: stakeState.address,
+		tokens: Object.keys(tokensToClaim).map((address) => ({
+			address,
+			value: tokensToClaim[address]
+		}))
+	};
+	next();
+});
+runner.use(_ocap_tx_pipeline.pipes.VerifyTokenBalance({
+	ownerKey: "stakeState",
+	conditionKey: "tokenCondition",
+	tokensKey: "revokedTokens"
+}));
+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(_ocap_tx_pipeline.pipes.VerifyUpdater({
+	assetKey: "assetStates",
+	ownerKey: "stakeState"
+}));
+runner.use(require_pipes_ensure_gas.default((context) => {
+	const result = {
+		create: 1,
+		update: 2,
+		payment: 0
+	};
+	if (context.receiverStates) result.update += context.receiverStates.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, outputs = [], statedb, senderState, senderChange, stakeState, receiverStates = [], updateVaults, assetStates = [] } = context;
+	const receiverUpdates = {};
+	const assetUpdates = {};
+	const stakeUpdates = {
+		revokedTokens: stakeState.revokedTokens || {},
+		revokedAssets: stakeState.revokedAssets || []
+	};
+	outputs.forEach((x) => {
+		const { owner, tokens, assets } = x;
+		const ownerState = receiverStates.find((s) => (0, _ocap_util_lib_get_related_addr.getRelatedAddresses)(s).includes(owner));
+		receiverUpdates[ownerState.address] = require_util.applyTokenUpdates(tokens || [], ownerState, "add");
+		if (senderChange && ownerState.address === senderChange.address) receiverUpdates[ownerState.address] = require_util.applyTokenChange(receiverUpdates[ownerState.address], senderChange);
+		(assets || []).forEach((a) => {
+			assetUpdates[a] = { owner: ownerState.address };
+		});
+		stakeUpdates.revokedTokens = require_util.applyTokenUpdates(tokens || [], { tokens: stakeUpdates.revokedTokens }, "sub").tokens;
+		stakeUpdates.revokedAssets = stakeUpdates.revokedAssets.filter((a) => (assets || []).includes(a) === false);
+	});
+	const isAlsoSigner = !!receiverUpdates[senderState.address];
+	const [newSenderState, newReceiverStates, newStakeState, newAssetStates, newEvidenceState] = await Promise.all([
+		statedb.account.update(senderState.address, _ocap_state.account.update(senderState, Object.assign({ nonce: tx.nonce }, receiverUpdates[senderState.address] || (senderChange ? require_util.applyTokenChange(senderState, senderChange) : {})), context), context),
+		Promise.all(receiverStates.filter((x) => x.address !== senderState.address).map((x) => statedb.account.update(x.address, _ocap_state.account.update(x, receiverUpdates[x.address], context), context))),
+		statedb.stake.update(stakeState.address, _ocap_state.stake.update(stakeState, stakeUpdates, context), context),
+		Promise.all(assetStates.map((x) => statedb.asset.update(x.address, _ocap_state.asset.update(x, assetUpdates[x.address], context), context))),
+		statedb.evidence.create(itx.evidence.hash, _ocap_state.evidence.create({
+			hash: itx.evidence.hash,
+			data: "claim-stake"
+		}, context), context)
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.receiverStates = isAlsoSigner ? newReceiverStates.concat(newSenderState) : newReceiverStates;
+	context.stakeState = newStakeState;
+	context.assetStates = newAssetStates;
+	context.evidenceState = newEvidenceState;
+	debug$1("claim-stake", {
+		address: itx.address,
+		stakeUpdates,
+		receiverUpdates,
+		assetUpdates
+	});
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var claim_stake_default = runner;
+
+//#endregion
+exports.default = claim_stake_default;

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

@@ -0,0 +1,27 @@
+import { BN } from "@ocap/util";
+
+//#region src/protocols/governance/claim-stake.d.ts
+/** Token input type */
+interface TokenInput {
+  address: string;
+  value: string;
+}
+/** Multi-output type */
+interface MultiOutput {
+  owner: string;
+  tokensList?: TokenInput[];
+  tokens: TokenInput[];
+  assetsList?: string[];
+  assets: string[];
+}
+/** Token condition type for VerifyTokenBalance */
+interface TokenCondition {
+  owner: string;
+  tokens: Array<{
+    address: string;
+    value: BN;
+  }>;
+}
+declare const runner: any;
+//#endregion
+export { MultiOutput, TokenCondition, TokenInput, runner as default };