@ocap/tx-protocols 1.28.9 → 1.29.0

package/esm/protocols/factory/create.mjs

@@ -0,0 +1,155 @@
+import { decodeAnySafe, getDelegationRequirements } from "../../util.mjs";
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import get from "lodash/get.js";
+import { toFactoryAddress } from "@arcblock/did-util";
+import { account, delegation, factory } from "@ocap/state";
+import { BN } from "@ocap/util";
+import Debug from "debug";
+import { formatMessage } from "@ocap/message";
+import cloneDeep from "lodash/cloneDeep.js";
+import { isValidFactory } from "@ocap/asset";
+import isEmpty from "lodash/isEmpty.js";
+
+//#region src/protocols/factory/create.ts
+const debug = Debug("@ocap/tx-protocols:create-factory");
+const runner = new Runner("create_factory");
+runner.use(pipes.VerifyMultiSig(0));
+runner.use((context, next) => {
+	const factoryProps = formatMessage("CreateFactoryTx", context.itx);
+	try {
+		isValidFactory(factoryProps);
+	} catch (err) {
+		return next(new CustomError("INVALID_FACTORY_PROPS", err.message));
+	}
+	if (factoryProps.output.data) factoryProps.output.data = decodeAnySafe(factoryProps.output.data);
+	if (factoryProps.name.length < 2 || factoryProps.name.length > 255) return next(new CustomError("INVALID_FACTORY_PROPS", "Length of factory name should between 2 and 255 characters"));
+	const props = cloneDeep(factoryProps);
+	props.address = "";
+	if (toFactoryAddress(props) !== factoryProps.address) return next(new CustomError("INVALID_FACTORY_PROPS", "Factory address is not valid"));
+	const factoryTokenAddresses = (factoryProps.input.tokens || []).map((x) => x.address);
+	const maxListSize = get(context, "config.transaction.maxListSize");
+	if (factoryTokenAddresses.length > maxListSize) return next(new CustomError("INVALID_FACTORY_INPUT", `input.tokens exceeded max allowed length: ${maxListSize}`));
+	if (factoryProps.input.assets.length > maxListSize) return next(new CustomError("INVALID_FACTORY_INPUT", `input.assets exceeded max allowed length: ${maxListSize}`));
+	if (new BN(factoryProps.input.value || 0).gt(new 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(pipes.ExtractState({
+	from: "itx.address",
+	to: "factoryState",
+	status: "OK"
+}));
+runner.use(pipes.VerifyInfo([{
+	error: "DUPLICATE_FACTORY",
+	message: "This asset factory already exist on chain",
+	fn: (ctx) => {
+		return isEmpty(ctx.factoryState);
+	}
+}]));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	table: "account",
+	status: "INVALID_SENDER_STATE"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(pipes.ExtractState({
+	from: "tx.delegator",
+	to: "delegatorState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "delegatorState",
+	addressKey: "tx.delegator"
+}));
+runner.use(pipes.VerifyDelegation({
+	type: "signature",
+	signerKey: "senderState",
+	delegatorKey: "delegatorState",
+	getRequirements: getDelegationRequirements
+}));
+runner.use(pipes.ExtractState({
+	from: "factoryTokens",
+	to: "tokenStates",
+	table: "token",
+	status: "INVALID_FACTORY_INPUT"
+}));
+runner.use(pipes.ExtractState({
+	from: "factoryProps.input.assets",
+	to: "inputAssetStates",
+	table: "asset",
+	status: "OK"
+}));
+runner.use(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 CustomError("INVALID_FACTORY_INPUT", "Some of input.assets already consumed"));
+	if (inputAssetStates.length + inputFactoryStates.length === factoryProps.input.assets.length) return next();
+	return next(new CustomError("INVALID_FACTORY_INPUT", "Not all input.assets exist on chain"));
+});
+runner.use(pipes.ExtractState({
+	from: "factoryProps.trustedIssuers",
+	to: "issuerStates",
+	table: "account",
+	status: "INVALID_ISSUER_STATE"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "issuerStates",
+	addressKey: "factoryProps.trustedIssuers"
+}));
+runner.use(ensure_gas_default(() => ({
+	create: 1,
+	update: 2,
+	payment: 0
+})));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, 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, account.update(senderState, {
+			nonce: tx$1.nonce,
+			pk: tx$1.pk,
+			...senderUpdates
+		}, context), context),
+		statedb.factory.create(itx.address, factory.create({
+			...factoryProps,
+			tokens,
+			owner
+		}, context), context),
+		context.isDelegationChanged ? statedb.delegation.update(delegationState.address, 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("createFactory", factoryState);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var create_default = runner;
+
+//#endregion
+export { create_default as default };

package/esm/protocols/governance/claim-stake.d.mts

@@ -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 };

package/esm/protocols/governance/claim-stake.mjs

@@ -0,0 +1,220 @@
+import { applyTokenChange, applyTokenUpdates } from "../../util.mjs";
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { account, asset, evidence, stake } from "@ocap/state";
+import { BN } from "@ocap/util";
+import Debug from "debug";
+import { Joi, patterns } from "@arcblock/validator";
+import { getRelatedAddresses } from "@ocap/util/lib/get-related-addr";
+
+//#region src/protocols/governance/claim-stake.ts
+const debug = Debug("@ocap/tx-protocols:claim-stake");
+const runner = new Runner("claim_stake");
+runner.use(pipes.VerifyMultiSig(0));
+const schema = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_STAKE").required(),
+	evidence: Joi.object({ hash: Joi.string().regex(patterns.txHash).required() }).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: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.address",
+	to: "stakeState",
+	status: "INVALID_STAKE_STATE",
+	table: "stake"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(pipes.VerifyInfo([{
+	error: "SENDER_NOT_MATCH",
+	message: "You are not allowed to claim stake from this address",
+	fn: (ctx) => {
+		const { senderState, stakeState } = ctx;
+		return getRelatedAddresses(senderState).includes(stakeState.sender);
+	}
+}]));
+runner.use(pipes.ExtractState({
+	from: "itx.evidence.hash",
+	to: "evidenceState",
+	status: "OK",
+	table: "evidence"
+}));
+runner.use(pipes.VerifyInfo([{
+	error: "ALREADY_CLAIMED",
+	message: "Revoke evidence already seen on this chain",
+	fn: (ctx) => {
+		const { evidenceState } = ctx;
+		return !evidenceState;
+	}
+}]));
+runner.use(pipes.ExtractState({
+	from: "itx.evidence.hash",
+	to: "txState",
+	status: "INVALID_TX",
+	table: "tx"
+}));
+runner.use(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(pipes.VerifyTxInput({
+	fieldKey: "txState.tx.itxJson.outputs",
+	inputsKey: "outputs",
+	sendersKey: "receivers",
+	tokensKey: "tokens",
+	assetsKey: "assets"
+}));
+runner.use(pipes.ExtractState({
+	from: "receivers",
+	to: "receiverStates",
+	status: "INVALID_RECEIVER_STATE",
+	table: "account"
+}));
+runner.use(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 BN(0);
+			tokensToClaim[address] = tokensToClaim[address].add(new BN(value));
+		});
+	});
+	context.tokenCondition = {
+		owner: stakeState.address,
+		tokens: Object.keys(tokensToClaim).map((address) => ({
+			address,
+			value: tokensToClaim[address]
+		}))
+	};
+	next();
+});
+runner.use(pipes.VerifyTokenBalance({
+	ownerKey: "stakeState",
+	conditionKey: "tokenCondition",
+	tokensKey: "revokedTokens"
+}));
+runner.use(pipes.ExtractState({
+	from: "assets",
+	to: "assetStates",
+	status: "OK",
+	table: "asset"
+}));
+runner.use(pipes.VerifyTransferrable({ assets: "assetStates" }));
+runner.use(pipes.VerifyUpdater({
+	assetKey: "assetStates",
+	ownerKey: "stakeState"
+}));
+runner.use(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(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, 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) => getRelatedAddresses(s).includes(owner));
+		receiverUpdates[ownerState.address] = applyTokenUpdates(tokens || [], ownerState, "add");
+		if (senderChange && ownerState.address === senderChange.address) receiverUpdates[ownerState.address] = applyTokenChange(receiverUpdates[ownerState.address], senderChange);
+		(assets || []).forEach((a) => {
+			assetUpdates[a] = { owner: ownerState.address };
+		});
+		stakeUpdates.revokedTokens = 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, account.update(senderState, Object.assign({ nonce: tx$1.nonce }, receiverUpdates[senderState.address] || (senderChange ? applyTokenChange(senderState, senderChange) : {})), context), context),
+		Promise.all(receiverStates.filter((x) => x.address !== senderState.address).map((x) => statedb.account.update(x.address, account.update(x, receiverUpdates[x.address], context), context))),
+		statedb.stake.update(stakeState.address, stake.update(stakeState, stakeUpdates, context), context),
+		Promise.all(assetStates.map((x) => statedb.asset.update(x.address, asset.update(x, assetUpdates[x.address], context), context))),
+		statedb.evidence.create(itx.evidence.hash, 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("claim-stake", {
+		address: itx.address,
+		stakeUpdates,
+		receiverUpdates,
+		assetUpdates
+	});
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var claim_stake_default = runner;
+
+//#endregion
+export { claim_stake_default as default };

package/esm/protocols/governance/return-stake.d.mts

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

package/esm/protocols/governance/return-stake.mjs

@@ -0,0 +1,211 @@
+import { applyTokenChange, applyTokenUpdates } from "../../util.mjs";
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { account, asset, stake } from "@ocap/state";
+import { BN } from "@ocap/util";
+import Debug from "debug";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import { Joi, schemas } from "@arcblock/validator";
+import { getRelatedAddresses } from "@ocap/util/lib/get-related-addr";
+import isEmpty from "lodash/isEmpty.js";
+
+//#region src/protocols/governance/return-stake.ts
+const debug = Debug("@ocap/tx-protocols:return-stake");
+const runner = new Runner("return_stake");
+runner.use(pipes.VerifyMultiSig(0));
+const schema = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_STAKE").required(),
+	message: Joi.string().trim().min(1).max(256).required(),
+	outputsList: schemas.multiInput.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.VerifyTxInput({
+	fieldKey: "itx.outputs",
+	inputsKey: "outputs",
+	sendersKey: "receivers",
+	tokensKey: "tokens",
+	assetsKey: "assets"
+}));
+runner.use(pipes.VerifyInfo([{
+	error: "INSUFFICIENT_DATA",
+	message: "Can not return stake without any output",
+	fn: (ctx) => {
+		const context = ctx;
+		return !(isEmpty(context.tokens) && isEmpty(context.assets));
+	}
+}]));
+runner.use(pipes.VerifyListSize({ listKey: [
+	"outputs",
+	"receivers",
+	"tokens",
+	"assets"
+] }));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "receivers",
+	to: "receiverStates",
+	status: "INVALID_RECEIVER_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyBlocked({ stateKeys: ["receiverStates"] }));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.address",
+	to: "stakeState",
+	status: "INVALID_STAKE_STATE",
+	table: "stake"
+}));
+runner.use(pipes.VerifyInfo([
+	{
+		error: "INVALID_TX",
+		message: "Can only return from none-self staking",
+		fn: (ctx) => {
+			const context = ctx;
+			return context.stakeState.sender !== context.stakeState.receiver;
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Can only return stake from receiver",
+		fn: (ctx) => {
+			const context = ctx;
+			return getRelatedAddresses(context.senderState).includes(context.stakeState.receiver);
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Can only return stake to sender",
+		fn: (ctx) => {
+			const context = ctx;
+			return (context.receiverStates || []).every((x) => getRelatedAddresses(x).includes(context.stakeState.sender));
+		}
+	}
+]));
+runner.use(pipes.ExtractState({
+	from: "tokens",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use((context, next) => {
+	const { stakeState } = context;
+	const outputs = context.outputs || [];
+	const tokens = {};
+	outputs.forEach((output) => {
+		getListField(output, "tokens").forEach(({ address, value }) => {
+			if (typeof tokens[address] === "undefined") tokens[address] = new BN(0);
+			tokens[address] = tokens[address].add(new BN(value));
+		});
+	});
+	context.lockedState = {
+		address: stakeState.address,
+		tokens: { ...stakeState.tokens || {} },
+		assets: [...stakeState.assets || []]
+	};
+	context.tokenCondition = {
+		owner: stakeState.address,
+		tokens: Object.keys(tokens).map((address) => ({
+			address,
+			value: tokens[address]
+		}))
+	};
+	next();
+});
+runner.use(pipes.VerifyTokenBalance({
+	ownerKey: "lockedState",
+	conditionKey: "tokenCondition"
+}));
+runner.use(pipes.VerifyInfo([{
+	error: "INVALID_TX",
+	message: "Can not return assets that are not locked in the stake",
+	fn: (ctx) => {
+		const context = ctx;
+		return (context.assets || []).every((x) => (context.lockedState?.assets || []).includes(x));
+	}
+}]));
+runner.use(pipes.ExtractState({
+	from: "assets",
+	to: "assetStates",
+	status: "INVALID_ASSET_STATE",
+	table: "asset"
+}));
+runner.use(pipes.VerifyTransferrable({ assets: "assetStates" }));
+runner.use(pipes.VerifyUpdater({
+	assetKey: "assetStates",
+	ownerKey: "stakeState"
+}));
+runner.use(ensure_gas_default((context) => {
+	const result = {
+		create: 0,
+		update: 2,
+		payment: 0
+	};
+	if (context.receiverStates) result.update += context.receiverStates.length;
+	if (context.assetStates) result.update += context.assetStates.length;
+	return result;
+}));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, itx, outputs = [], statedb, senderState, receiverStates = [], assetStates = [], stakeState, updateVaults, senderChange } = context;
+	const receiverUpdates = {};
+	const assetUpdates = {};
+	const stakeUpdates = {
+		tokens: stakeState.tokens || {},
+		assets: stakeState.assets || []
+	};
+	outputs.forEach((x) => {
+		const { owner } = x;
+		const tokensList = getListField(x, "tokens");
+		const assetsList = getListField(x, "assets");
+		stakeUpdates.assets = stakeUpdates.assets.filter((a) => assetsList.includes(a) === false);
+		stakeUpdates.tokens = applyTokenUpdates(tokensList, { tokens: stakeUpdates.tokens }, "sub").tokens;
+		const ownerState = receiverStates.find((s) => getRelatedAddresses(s).includes(owner));
+		receiverUpdates[ownerState.address] = applyTokenUpdates(tokensList, ownerState, "add");
+		if (senderChange && ownerState.address === senderChange.address) receiverUpdates[ownerState.address] = applyTokenChange(receiverUpdates[ownerState.address], senderChange);
+		assetsList.forEach((a) => {
+			assetUpdates[a] = { owner: ownerState.address };
+		});
+	});
+	const [newSenderState, newReceiverStates, newStakeState, newAssetStates] = await Promise.all([
+		statedb.account.update(senderState.address, account.update(senderState, Object.assign({ nonce: tx$1.nonce }, senderChange ? applyTokenChange(senderState, senderChange) : {}), context), context),
+		Promise.all(receiverStates.map((x) => statedb.account.update(x.address, account.update(x, receiverUpdates[x.address], context), context))),
+		statedb.stake.update(stakeState.address, stake.update(stakeState, stakeUpdates, context), context),
+		Promise.all(assetStates.map((x) => statedb.asset.update(x.address, asset.update(x, assetUpdates[x.address], context), context)))
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.receiverStates = newReceiverStates;
+	context.stakeState = newStakeState;
+	context.assetStates = newAssetStates;
+	debug("return-stake", {
+		address: itx.address,
+		stakeUpdates,
+		assetUpdates,
+		senderChange,
+		...receiverUpdates
+	});
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var return_stake_default = runner;
+
+//#endregion
+export { return_stake_default as default };

package/esm/protocols/governance/revoke-stake.d.mts

@@ -0,0 +1,27 @@
+import { BN } from "@ocap/util";
+
+//#region src/protocols/governance/revoke-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 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 };