@ocap/tx-protocols 1.28.9 → 1.29.0

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

@@ -0,0 +1,178 @@
+import { 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, 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/revoke-stake.ts
+const debug = Debug("@ocap/tx-protocols:revoke-stake");
+const runner = new Runner("revoke_stake");
+runner.use(pipes.VerifyMultiSig(0));
+const schema = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_STAKE").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 revoke 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: "SENDER_NOT_MATCH",
+		message: "You are not allowed to revoke stake from this address",
+		fn: (ctx) => {
+			const context = ctx;
+			return getRelatedAddresses(context.senderState).includes(context.stakeState.sender);
+		}
+	},
+	{
+		error: "STAKE_NOT_REVOCABLE",
+		message: "This stake address is not revocable",
+		fn: (ctx) => {
+			return ctx.stakeState.revocable;
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Can not revoke assets that are not locked in the stake",
+		fn: (ctx) => {
+			const context = ctx;
+			return (context.assets || []).every((x) => (context.stakeState.assets || []).includes(x));
+		}
+	}
+]));
+runner.use(pipes.ExtractState({
+	from: "tokens",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use((context, next) => {
+	const { outputs = [], stakeState } = context;
+	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.tokenCondition = {
+		owner: stakeState.address,
+		tokens: Object.keys(tokens).map((address) => ({
+			address,
+			value: tokens[address]
+		}))
+	};
+	next();
+});
+runner.use(pipes.VerifyTokenBalance({
+	ownerKey: "stakeState",
+	conditionKey: "tokenCondition"
+}));
+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(() => ({
+	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, outputs = [], statedb, senderState, senderUpdates, stakeState, updateVaults } = context;
+	const stakeUpdates = {
+		tokens: stakeState.tokens || {},
+		assets: stakeState.assets || [],
+		revokedTokens: stakeState.revokedTokens || {},
+		revokedAssets: stakeState.revokedAssets || []
+	};
+	outputs.forEach((x) => {
+		const tokensList = getListField(x, "tokens");
+		const assetsList = getListField(x, "assets");
+		stakeUpdates.tokens = applyTokenUpdates(tokensList, { tokens: stakeUpdates.tokens }, "sub").tokens;
+		stakeUpdates.assets = stakeUpdates.assets.filter((a) => assetsList.includes(a) === false);
+		stakeUpdates.revokedTokens = applyTokenUpdates(tokensList, { tokens: stakeUpdates.revokedTokens }, "add").tokens;
+		stakeUpdates.revokedAssets = stakeUpdates.revokedAssets.concat(...assetsList);
+	});
+	const [newSenderState, newStakeState] = await Promise.all([statedb.account.update(senderState.address, account.update(senderState, {
+		nonce: tx$1.nonce,
+		...senderUpdates
+	}, context), context), statedb.stake.update(stakeState.address, stake.update(stakeState, stakeUpdates, context), context)]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.stakeState = newStakeState;
+	debug("revoke-stake", {
+		address: itx.address,
+		stakeUpdates
+	});
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var revoke_stake_default = runner;
+
+//#endregion
+export { revoke_stake_default as default };

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

@@ -0,0 +1,17 @@
+//#region src/protocols/governance/slash-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[];
+}
+declare const runner: any;
+//#endregion
+export { MultiOutput, TokenInput, runner as default };

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

@@ -0,0 +1,213 @@
+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/slash-stake.ts
+const debug = Debug("@ocap/tx-protocols:slash-stake");
+const runner = new Runner("slash_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 slash 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.ExtractState({
+	from: "stakeState.slashers",
+	to: "slasherStates",
+	status: "INVALID_SLASH_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyInfo([{
+	error: "INVALID_TX",
+	message: "You are not allowed to slash from this stake",
+	fn: (ctx) => {
+		const context = ctx;
+		const slasherStates = context.slasherStates || [];
+		return (isEmpty(slasherStates) ? [context.stakeState.receiver] : slasherStates.map((x) => x.address)).includes(context.senderState.address);
+	}
+}, {
+	error: "INVALID_TX",
+	message: "Can only send slashed token/assets to vault or specified slasher",
+	fn: (ctx) => {
+		const context = ctx;
+		const slasherStates = context.slasherStates || [];
+		return (context.receivers || []).every((x) => x === context.config.vaults.slashedStake || slasherStates.some((s) => s.address === x));
+	}
+}]));
+runner.use(pipes.ExtractState({
+	from: "tokens",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use((context, next) => {
+	const { outputs = [], stakeState } = context;
+	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));
+		});
+	});
+	const lockedState = {
+		address: stakeState.address,
+		tokens: { ...stakeState.tokens },
+		assets: [...stakeState.assets || [], ...stakeState.revokedAssets || []]
+	};
+	Object.keys(stakeState.revokedTokens || {}).forEach((address) => {
+		lockedState.tokens[address] = new BN(stakeState.revokedTokens[address] || "0").add(new BN(stakeState.tokens[address] || "0")).toString(10);
+	});
+	context.lockedState = lockedState;
+	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 slash 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 || [],
+		revokedTokens: stakeState.revokedTokens || {},
+		revokedAssets: stakeState.revokedAssets || []
+	};
+	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.revokedAssets = stakeUpdates.revokedAssets.filter((a) => assetsList.includes(a) === false);
+		const [newTokens, newRevoked] = applyTokenUpdates(tokensList, [{ tokens: stakeUpdates.tokens }, { tokens: stakeUpdates.revokedTokens }], "sub");
+		stakeUpdates.tokens = newTokens.tokens;
+		stakeUpdates.revokedTokens = newRevoked.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 }, 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)))
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.receiverStates = newReceiverStates;
+	context.stakeState = newStakeState;
+	context.assetStates = newAssetStates;
+	debug("slash-stake", {
+		address: itx.address,
+		stakeUpdates
+	});
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var slash_stake_default = runner;
+
+//#endregion
+export { slash_stake_default as default };

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

@@ -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/esm/protocols/governance/stake.mjs

@@ -0,0 +1,270 @@
+import { applyTokenChange, applyTokenUpdates, isGasStakeAddress, isGasStakeInput } 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 pick from "lodash/pick.js";
+import { toStakeAddress } from "@arcblock/did-util";
+import { account, asset, stake } from "@ocap/state";
+import { BN, fromTokenToUnit } from "@ocap/util";
+import Debug from "debug";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import { Joi, schemas } from "@arcblock/validator";
+import { promisify } from "node:util";
+import isEmpty from "lodash/isEmpty.js";
+
+//#region src/protocols/governance/stake.ts
+const debug = Debug("@ocap/tx-protocols:stake");
+const verifyAssetOwner = promisify(pipes.VerifyUpdater({
+	assetKey: "assets",
+	ownerKey: "owner"
+}));
+const runner = new Runner("stake");
+const schema = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_STAKE").required(),
+	receiver: Joi.DID().prefix().required(),
+	slashersList: Joi.array().items(Joi.DID().prefix()).default([]),
+	locked: Joi.boolean().default(false),
+	inputsList: schemas.multiInput.min(1).required(),
+	message: Joi.string().trim().min(1).max(256).required(),
+	revokeWaitingPeriod: Joi.number().integer().min(0).default(0),
+	data: Joi.any().optional().allow(null),
+	nonce: 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 CustomError("INVALID_TX", `Invalid itx: ${error.message}`) : void 0);
+});
+runner.use(pipes.VerifyTxInput({
+	fieldKey: "itx.inputs",
+	inputsKey: "inputs",
+	sendersKey: "senders",
+	tokensKey: "tokens",
+	assetsKey: "assets"
+}));
+runner.use(pipes.VerifyInfo([
+	{
+		error: "INVALID_TX",
+		message: "Invalid staking address",
+		fn: (ctx) => {
+			const context = ctx;
+			return 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 = 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 !(isEmpty(context.tokens) && isEmpty(context.assets));
+		}
+	}
+]));
+runner.use(pipes.VerifyListSize({ listKey: [
+	"inputs",
+	"senders",
+	"tokens",
+	"assets"
+] }));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: "senders" }));
+runner.use(pipes.ExtractState({
+	from: "itx.address",
+	to: "stakeState",
+	status: "OK",
+	table: "stake"
+}));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "senders",
+	to: "signerStates",
+	status: "INVALID_SIGNER_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.receiver",
+	to: "receiverState",
+	status: "INVALID_RECEIVER_STATE"
+}));
+runner.use(pipes.VerifyBlocked({ stateKeys: ["signerStates", "receiverState"] }));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "receiverState",
+	addressKey: "itx.receiver"
+}));
+runner.use(pipes.ExtractState({
+	from: "tokens",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(pipes.VerifyTokenBalance({
+	ownerKey: "signerStates",
+	conditionKey: "inputs"
+}));
+runner.use(pipes.verifyTokenAccess({
+	statesKey: "tokenStates",
+	listFieldKey: "spenders",
+	accountKeys: ["senderState"],
+	errorMessage: "Account {address} is not allowed to stake token {tokenAddress}"
+}));
+runner.use(pipes.ExtractState({
+	from: "assets",
+	to: "assetStates",
+	status: "OK",
+	table: "asset"
+}));
+runner.use(pipes.VerifyTransferrable({ assets: "assetStates" }));
+runner.use(async (context, next) => {
+	const { inputs = [], assetStates = [], signerStates = [] } = context;
+	for (const input of inputs) {
+		const { owner } = input;
+		const assetsList = 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(pipes.ExtractState({
+	from: "itx.slashersList",
+	to: "slasherStates",
+	status: "INVALID_SLASHER_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "slasherStates",
+	addressKey: "itx.slashersList"
+}));
+runner.use((context, next) => {
+	const { tx: tx$1, itx, inputs = [] } = context;
+	const { config } = context;
+	const { token: token$1, transaction } = config;
+	const { minStake, maxStake } = transaction.txGas;
+	context.isGasStake = isGasStakeAddress(tx$1.from, itx.address) && isGasStakeInput(inputs, token$1.address);
+	if (context.isGasStake) {
+		const [tokenInput] = getListField(inputs[0], "tokens");
+		const actualStake = new BN(tokenInput.value);
+		const expectedMinStake = fromTokenToUnit(minStake, token$1.decimal);
+		const expectedMaxStake = fromTokenToUnit(maxStake, token$1.decimal);
+		if (actualStake.lt(expectedMinStake)) return next(new CustomError("INVALID_TX", `Stake for gas should be greater than: ${minStake}`));
+		if (actualStake.gt(expectedMaxStake)) return next(new 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 = getListField(itx, "slashers");
+	}
+	return next();
+});
+runner.use(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(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, 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 = getListField(x, "tokens");
+		const assetsList = getListField(x, "assets");
+		signerUpdates[owner] = applyTokenUpdates(tokensList, signerStates.find((s) => s.address === owner), "sub");
+		if (senderChange && owner === senderChange.address) signerUpdates[owner] = applyTokenChange(signerUpdates[owner], senderChange);
+		Object.assign(stakeUpdates, applyTokenUpdates(tokensList, stakeUpdates, "add"));
+		stakeUpdates.assets.push(...assetsList);
+	});
+	const isAlsoSigner = !!signerUpdates[tx$1.from];
+	const [newSenderState, newSignerStates, newStakeState, newAssetStates] = await Promise.all([
+		statedb.account.updateOrCreate(senderState ?? null, account.updateOrCreate(senderState ?? null, Object.assign({
+			address: tx$1.from,
+			nonce: tx$1.nonce,
+			pk: tx$1.pk
+		}, signerUpdates[tx$1.from] || (senderChange ? applyTokenChange(senderState ?? {}, senderChange) : {})), context), context),
+		Promise.all(signerStates.filter((x) => x.address !== tx$1.from).map((x) => statedb.account.update(x.address, account.update(x, signerUpdates[x.address], context), context))),
+		stakeState ? statedb.stake.update(stakeState.address, stake.update(stakeState, stakeUpdates, context), context) : statedb.stake.create(itx.address, stake.create({
+			sender: tx$1.from,
+			revocable: !itx.locked,
+			slashers: context.slashers,
+			revokeWaitingPeriod: context.revokeWaitingPeriod,
+			...pick(itx, [
+				"address",
+				"receiver",
+				"message",
+				"data",
+				"nonce"
+			]),
+			...stakeUpdates
+		}, context), context),
+		Promise.all(assetStates.map((x) => statedb.asset.update(x.address, 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("stake", {
+		address: itx.address,
+		stakeUpdates,
+		signerUpdates
+	});
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var stake_default = runner;
+
+//#endregion
+export { stake_default as default };