@ocap/tx-protocols 1.28.9 → 1.29.1

package/lib/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/lib/execute.cjs

@@ -0,0 +1,231 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.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_camelCase = require("lodash/camelCase");
+lodash_camelCase = require_rolldown_runtime.__toESM(lodash_camelCase);
+let lodash_get = require("lodash/get");
+lodash_get = require_rolldown_runtime.__toESM(lodash_get);
+let lodash_merge = require("lodash/merge");
+lodash_merge = require_rolldown_runtime.__toESM(lodash_merge);
+let lodash_pick = require("lodash/pick");
+lodash_pick = require_rolldown_runtime.__toESM(lodash_pick);
+
+//#region src/execute.ts
+const ensureTxGas = require_pipes_ensure_gas.default(() => ({
+	create: 0,
+	update: 2
+}));
+const ensureTxCost = require_pipes_ensure_cost.default({
+	attachSenderChanges: true,
+	gasOnly: true
+});
+const getTxName = (typeUrl) => (0, lodash_camelCase.default)(typeUrl.split(":").pop() ?? "");
+/** Get states helper with type guard - throws if states is not initialized */
+const getStates = (context) => {
+	if (!context.states) throw new _ocap_util_lib_error.CustomError("INTERNAL", "States helper is not initialized in context");
+	return context.states;
+};
+const flushEvents = (context, extra = {}) => {
+	(context.events || []).forEach((e) => {
+		const table = context.statedb[e.table];
+		if (table?.emit) table.emit(e.name, e.data, {
+			...e.ctx,
+			...extra
+		});
+	});
+	context.events = [];
+};
+const shouldPersistTx = (err) => !err || Boolean((0, lodash_get.default)(err, "props.persist"));
+const createExecute = ({ filter, runAsLambda }) => {
+	const pre = new _ocap_tx_pipeline.Runner("pre-execute");
+	pre.use(_ocap_tx_pipeline.pipes.DecodeTx);
+	pre.use(_ocap_tx_pipeline.pipes.VerifyBlocked({
+		filter,
+		stateKeys: ["tx.from"]
+	}));
+	pre.use(_ocap_tx_pipeline.pipes.DecodeItx);
+	pre.use(_ocap_tx_pipeline.pipes.VerifyTx);
+	pre.use(_ocap_tx_pipeline.pipes.VerifyServiceFee);
+	pre.use(async (context, next) => {
+		if (filter.has(context.txHash)) {
+			if (await context.statedb.tx.get(context.txHash, context)) return next(new _ocap_util_lib_error.CustomError("DUPLICATE_TX", "Can not execute duplicate transaction"));
+		}
+		filter.add(context.txHash);
+		return next();
+	});
+	pre.use(_ocap_tx_pipeline.pipes.VerifyTxSize);
+	pre.use(_ocap_tx_pipeline.pipes.VerifySignature);
+	const ensureGasFeePaid = (context) => {
+		const gasRunner = new _ocap_tx_pipeline.Runner("ensure-gas-fee-paid");
+		gasRunner.use(ensureTxGas);
+		gasRunner.use(ensureTxCost);
+		gasRunner.use(async (ctx, next) => {
+			const { tx, statedb, senderUpdates, updateVaults } = ctx;
+			if (ctx.senderState && ctx.states && tx) {
+				const senderState = ctx.stateSnapshot?.[ctx.senderState.address] || ctx.senderState;
+				const updates = ctx.states.account.update(senderState, {
+					nonce: tx.nonce,
+					pk: tx.pk,
+					...senderUpdates
+				}, ctx);
+				await statedb.account.update(senderState.address, updates, ctx);
+				if (updateVaults) await updateVaults();
+			}
+			return next();
+		});
+		return new Promise((resolve, reject) => {
+			gasRunner.run(context, (err) => {
+				if (err) {
+					context.logger?.error("Failed to charge gas fee for errored tx", {
+						error: err,
+						tx: context.tx,
+						txBase64: context.txBase64,
+						txHash: context.txHash
+					});
+					reject(err);
+					return;
+				}
+				resolve();
+			});
+		});
+	};
+	const execute = async (context, protocols, isRetrySupported = false) => new Promise((resolve, reject) => {
+		pre.run(context, (err) => {
+			if (err) {
+				context.logger?.error("Failed to prepare transaction", {
+					error: err,
+					txHash: context.txHash,
+					request: context.extra?.request
+				});
+				return reject(err);
+			}
+			const protocol = protocols[getTxName(context.txType)];
+			if (!protocol) return reject(new _ocap_util_lib_error.CustomError("UNSUPPORTED_TX", `Unsupported tx type ${context.txType}`));
+			protocol.run(context, async (error) => {
+				if (isRetrySupported) {
+					if (error) return reject(error);
+					return resolve(context);
+				}
+				const txStatus = error ? error.code || "INTERNAL" : "OK";
+				const states = getStates(context);
+				let txState = states.tx.create(context, txStatus);
+				if (shouldPersistTx(error)) try {
+					if (error) {
+						await ensureGasFeePaid(context);
+						txState = states.tx.create(context, txStatus);
+					}
+					await context.statedb.tx.create(txState.hash, txState, context);
+					flushEvents(context, { txState });
+				} catch (e) {
+					context.logger?.error("Failed to save transaction to statedb", {
+						error: e,
+						txError: error,
+						txHash: context.txHash,
+						txState
+					});
+					return reject(error);
+				}
+				context.logger?.info("Tx finalized", {
+					txHash: context.txHash,
+					txStatus,
+					txState,
+					error
+				});
+				if (error) return reject(error);
+				return resolve(context);
+			});
+		});
+	});
+	if (typeof runAsLambda === "function") return async (context, protocols) => {
+		let ctx = context;
+		const startTime = Date.now();
+		try {
+			const txState = await runAsLambda(async (txn) => {
+				ctx = (0, lodash_pick.default)(context, [
+					"txBase64",
+					"statedb",
+					"indexdb",
+					"config",
+					"states",
+					"filter",
+					"extra",
+					"logger"
+				]);
+				ctx.txn = txn;
+				await execute(ctx, protocols, true);
+				const state = getStates(context).tx.create(ctx, "OK");
+				await context.statedb.tx.create(state.hash, state, ctx);
+				return state;
+			}, {
+				cleanWorkingSet: true,
+				verifyHash: true,
+				context: ctx
+			});
+			flushEvents(ctx, { txState });
+			ctx.logger?.info("Tx finalized", {
+				txHash: ctx.txHash,
+				txState,
+				txStatus: "OK",
+				duration: Date.now() - startTime
+			});
+		} catch (error) {
+			const err = error;
+			const txStatus = err.code || "INTERNAL";
+			let txState = ctx.tx ? getStates(context).tx.create(ctx, txStatus, false) : null;
+			ctx.logger?.error("Failed to execute transaction", {
+				error,
+				txHash: ctx.txHash,
+				txState,
+				request: context.extra?.request
+			});
+			if (txState && shouldPersistTx(err)) {
+				ctx.events = [];
+				try {
+					txState = await runAsLambda(async (txn) => {
+						ctx = Object.assign({}, ctx, {
+							txn,
+							cacheStates: null
+						});
+						await ensureGasFeePaid(ctx);
+						const state = getStates(context).tx.create(ctx, txStatus);
+						await ctx.statedb.tx.create(state.hash, state, ctx);
+						return state;
+					}, {
+						cleanWorkingSet: true,
+						verifyHash: true,
+						context: ctx
+					});
+					flushEvents(ctx, { txState });
+					ctx.logger?.info("Tx finalized", {
+						txHash: ctx.txHash,
+						txState,
+						txStatus,
+						error,
+						duration: Date.now() - startTime
+					});
+				} catch (innerErr) {
+					ctx.logger?.error("Failed to save invalid transaction to statedb", {
+						error: innerErr,
+						txError: error,
+						txHash: ctx.txHash,
+						txState,
+						request: context.extra?.request
+					});
+					throw error;
+				}
+			}
+			throw error;
+		} finally {
+			(0, lodash_merge.default)(context, ctx);
+		}
+		return ctx;
+	};
+	return execute;
+};
+var execute_default = createExecute;
+
+//#endregion
+exports.default = execute_default;

package/lib/execute.d.cts

@@ -0,0 +1,53 @@
+import { IAccountState, IGasContext } from "@ocap/types";
+import { CustomError } from "@ocap/util/lib/error";
+import { Blacklist } from "@ocap/state";
+
+//#region src/execute.d.ts
+/** State helpers interface */
+interface IStateHelpers {
+  tx: {
+    create: (ctx: IExecutionContext, status: string, persist?: boolean) => {
+      hash: string;
+    };
+  };
+  account: {
+    update: (state: unknown, updates: unknown, ctx: unknown) => unknown;
+  };
+}
+/** Extended context with tx-protocols specific fields */
+interface IExecutionContext extends IGasContext {
+  events?: Array<{
+    table: string;
+    name: string;
+    data: unknown;
+    ctx: Record<string, unknown>;
+  }>;
+  states?: IStateHelpers;
+  stateSnapshot?: Record<string, unknown>;
+  txn?: unknown;
+  cacheStates?: unknown;
+  senderState?: IAccountState;
+}
+/** Protocol runner interface */
+interface IProtocolRunner {
+  run: (context: IExecutionContext, callback: (error?: CustomError | null) => void) => void;
+}
+/** Protocols map */
+type ProtocolsMap = Record<string, IProtocolRunner>;
+/** Execute options */
+interface IExecuteOptions {
+  filter: InstanceType<typeof Blacklist>;
+  runAsLambda?: <T>(fn: (txn: unknown) => Promise<T>, opts: {
+    cleanWorkingSet: boolean;
+    verifyHash: boolean;
+    context: IExecutionContext;
+  }) => Promise<T>;
+}
+/** Execute function type */
+type ExecuteFn = (context: IExecutionContext, protocols: ProtocolsMap, isRetrySupported?: boolean) => Promise<IExecutionContext>;
+declare const createExecute: ({
+  filter,
+  runAsLambda
+}: IExecuteOptions) => ExecuteFn;
+//#endregion
+export { createExecute as default };

package/lib/index.cjs

@@ -0,0 +1,105 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_execute = require('./execute.cjs');
+const require_protocols_account_delegate = require('./protocols/account/delegate.cjs');
+const require_protocols_account_migrate = require('./protocols/account/migrate.cjs');
+const require_protocols_account_revoke_delegate = require('./protocols/account/revoke-delegate.cjs');
+const require_protocols_asset_acquire_v2 = require('./protocols/asset/acquire-v2.cjs');
+const require_protocols_asset_acquire_v3 = require('./protocols/asset/acquire-v3.cjs');
+const require_protocols_asset_consume = require('./protocols/asset/consume.cjs');
+const require_protocols_asset_create = require('./protocols/asset/create.cjs');
+const require_protocols_asset_mint = require('./protocols/asset/mint.cjs');
+const require_protocols_asset_update = require('./protocols/asset/update.cjs');
+const require_protocols_factory_create = require('./protocols/factory/create.cjs');
+const require_protocols_governance_claim_stake = require('./protocols/governance/claim-stake.cjs');
+const require_protocols_governance_return_stake = require('./protocols/governance/return-stake.cjs');
+const require_protocols_governance_revoke_stake = require('./protocols/governance/revoke-stake.cjs');
+const require_protocols_governance_slash_stake = require('./protocols/governance/slash-stake.cjs');
+const require_protocols_governance_stake = require('./protocols/governance/stake.cjs');
+const require_protocols_rollup_claim_reward = require('./protocols/rollup/claim-reward.cjs');
+const require_protocols_rollup_close = require('./protocols/rollup/close.cjs');
+const require_protocols_rollup_create = require('./protocols/rollup/create.cjs');
+const require_protocols_rollup_create_block = require('./protocols/rollup/create-block.cjs');
+const require_protocols_rollup_join = require('./protocols/rollup/join.cjs');
+const require_protocols_rollup_leave = require('./protocols/rollup/leave.cjs');
+const require_protocols_rollup_migrate = require('./protocols/rollup/migrate.cjs');
+const require_protocols_rollup_pause = require('./protocols/rollup/pause.cjs');
+const require_protocols_rollup_resume = require('./protocols/rollup/resume.cjs');
+const require_protocols_rollup_update = require('./protocols/rollup/update.cjs');
+const require_protocols_token_factory_burn = require('./protocols/token-factory/burn.cjs');
+const require_protocols_token_factory_create = require('./protocols/token-factory/create.cjs');
+const require_protocols_token_factory_mint = require('./protocols/token-factory/mint.cjs');
+const require_protocols_token_factory_update = require('./protocols/token-factory/update.cjs');
+const require_protocols_token_create = require('./protocols/token/create.cjs');
+const require_protocols_token_deposit_v2 = require('./protocols/token/deposit-v2.cjs');
+const require_protocols_token_withdraw_v2 = require('./protocols/token/withdraw-v2.cjs');
+const require_protocols_trade_exchange_v2 = require('./protocols/trade/exchange-v2.cjs');
+const require_protocols_trade_transfer_v2 = require('./protocols/trade/transfer-v2.cjs');
+const require_protocols_trade_transfer_v3 = require('./protocols/trade/transfer-v3.cjs');
+let _ocap_state = require("@ocap/state");
+_ocap_state = require_rolldown_runtime.__toESM(_ocap_state);
+
+//#region src/index.ts
+const createExecutor = ({ filter, runAsLambda }) => {
+	const protocols = {
+		transfer: require_protocols_trade_transfer_v2.default,
+		transferV2: require_protocols_trade_transfer_v2.default,
+		transferV3: require_protocols_trade_transfer_v3.default,
+		exchangeV2: require_protocols_trade_exchange_v2.default,
+		accountMigrate: require_protocols_account_migrate.default,
+		delegate: require_protocols_account_delegate.default,
+		revokeDelegate: require_protocols_account_revoke_delegate.default,
+		createAsset: require_protocols_asset_create.default,
+		updateAsset: require_protocols_asset_update.default,
+		consumeAsset: require_protocols_asset_consume.default,
+		acquireAssetV2: require_protocols_asset_acquire_v2.default,
+		acquireAssetV3: require_protocols_asset_acquire_v3.default,
+		mintAsset: require_protocols_asset_mint.default,
+		createFactory: require_protocols_factory_create.default,
+		createToken: require_protocols_token_create.default,
+		depositTokenV2: require_protocols_token_deposit_v2.default,
+		withdrawTokenV2: require_protocols_token_withdraw_v2.default,
+		createTokenFactory: require_protocols_token_factory_create.default,
+		updateTokenFactory: require_protocols_token_factory_update.default,
+		mintToken: require_protocols_token_factory_mint.default,
+		burnToken: require_protocols_token_factory_burn.default,
+		stake: require_protocols_governance_stake.default,
+		revokeStake: require_protocols_governance_revoke_stake.default,
+		claimStake: require_protocols_governance_claim_stake.default,
+		slashStake: require_protocols_governance_slash_stake.default,
+		returnStake: require_protocols_governance_return_stake.default,
+		createRollup: require_protocols_rollup_create.default,
+		updateRollup: require_protocols_rollup_update.default,
+		joinRollup: require_protocols_rollup_join.default,
+		leaveRollup: require_protocols_rollup_leave.default,
+		pauseRollup: require_protocols_rollup_pause.default,
+		closeRollup: require_protocols_rollup_close.default,
+		resumeRollup: require_protocols_rollup_resume.default,
+		createRollupBlock: require_protocols_rollup_create_block.default,
+		claimBlockReward: require_protocols_rollup_claim_reward.default,
+		migrateRollup: require_protocols_rollup_migrate.default
+	};
+	const execute$1 = require_execute.default({
+		filter,
+		runAsLambda
+	});
+	return {
+		...protocols,
+		execute: (context, done) => {
+			Object.defineProperty(context, "states", { value: _ocap_state });
+			if (typeof done === "function") return execute$1(context, protocols).then((res) => done(null, res)).catch((err) => done(err));
+			return execute$1(context, protocols);
+		}
+	};
+};
+const defaultExecutor = createExecutor({
+	filter: new _ocap_state.Blacklist(),
+	runAsLambda: void 0
+});
+const { execute } = defaultExecutor;
+var src_default = defaultExecutor;
+
+//#endregion
+exports.createExecutor = createExecutor;
+exports.default = src_default;
+exports.execute = execute;

package/lib/index.d.cts

@@ -0,0 +1,95 @@
+import * as states from "@ocap/state";
+
+//#region src/index.d.ts
+interface ICreateExecutorOptions {
+  filter: InstanceType<typeof states.Blacklist>;
+  runAsLambda?: <T>(fn: (txn: unknown) => Promise<T>, opts: {
+    cleanWorkingSet: boolean;
+    verifyHash: boolean;
+    context: unknown;
+  }) => Promise<T>;
+}
+declare const createExecutor: ({
+  filter,
+  runAsLambda
+}: ICreateExecutorOptions) => {
+  execute: (context: unknown, done?: (err: Error | null, res?: unknown) => void) => any;
+  transfer: any;
+  transferV2: any;
+  transferV3: any;
+  exchangeV2: any;
+  accountMigrate: any;
+  delegate: any;
+  revokeDelegate: any;
+  createAsset: any;
+  updateAsset: any;
+  consumeAsset: any;
+  acquireAssetV2: any;
+  acquireAssetV3: any;
+  mintAsset: any;
+  createFactory: any;
+  createToken: any;
+  depositTokenV2: any;
+  withdrawTokenV2: any;
+  createTokenFactory: any;
+  updateTokenFactory: any;
+  mintToken: any;
+  burnToken: any;
+  stake: any;
+  revokeStake: any;
+  claimStake: any;
+  slashStake: any;
+  returnStake: any;
+  createRollup: any;
+  updateRollup: any;
+  joinRollup: any;
+  leaveRollup: any;
+  pauseRollup: any;
+  closeRollup: any;
+  resumeRollup: any;
+  createRollupBlock: any;
+  claimBlockReward: any;
+  migrateRollup: any;
+};
+declare const defaultExecutor: {
+  execute: (context: unknown, done?: (err: Error | null, res?: unknown) => void) => any;
+  transfer: any;
+  transferV2: any;
+  transferV3: any;
+  exchangeV2: any;
+  accountMigrate: any;
+  delegate: any;
+  revokeDelegate: any;
+  createAsset: any;
+  updateAsset: any;
+  consumeAsset: any;
+  acquireAssetV2: any;
+  acquireAssetV3: any;
+  mintAsset: any;
+  createFactory: any;
+  createToken: any;
+  depositTokenV2: any;
+  withdrawTokenV2: any;
+  createTokenFactory: any;
+  updateTokenFactory: any;
+  mintToken: any;
+  burnToken: any;
+  stake: any;
+  revokeStake: any;
+  claimStake: any;
+  slashStake: any;
+  returnStake: any;
+  createRollup: any;
+  updateRollup: any;
+  joinRollup: any;
+  leaveRollup: any;
+  pauseRollup: any;
+  closeRollup: any;
+  resumeRollup: any;
+  createRollupBlock: any;
+  claimBlockReward: any;
+  migrateRollup: any;
+};
+declare const execute: (context: unknown, done?: (err: Error | null, res?: unknown) => void) => any;
+//#endregion
+export { createExecutor, defaultExecutor as default, execute };

package/lib/pipes/ensure-cost.cjs

@@ -0,0 +1,141 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_util = require('../util.cjs');
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let _arcblock_did = require("@arcblock/did");
+let _arcblock_did_util = require("@arcblock/did-util");
+let _arcblock_jwt = require("@arcblock/jwt");
+_arcblock_jwt = require_rolldown_runtime.__toESM(_arcblock_jwt);
+let _ocap_state = require("@ocap/state");
+let _ocap_util = require("@ocap/util");
+let lodash_noop = require("lodash/noop");
+lodash_noop = require_rolldown_runtime.__toESM(lodash_noop);
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+
+//#region src/pipes/ensure-cost.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:pipes:ensure-cost");
+const ZERO = new _ocap_util.BN(0);
+/** Context for ensure cost pipe */ function CreateEnsureTxCostPipe({ attachSenderChanges = true, throwOnInsufficientFund = true, gasOnly = false } = {}) {
+	return async function EnsureTxCost(context, next) {
+		const { statedb, txType, senderState, gasEstimate, totalGas } = context;
+		const { config } = context;
+		const { tx, extra = {}, txHash = "" } = context;
+		const { token, pk } = extra.gasStakeHeaders || {};
+		const gasStake = {};
+		if (token && pk && await _arcblock_jwt.verify(token, pk, {
+			enforceTimestamp: true,
+			tolerance: 5
+		})) {
+			const decoded = _arcblock_jwt.decode(token);
+			if ((decoded.txHash || "").split(",").map((x) => x.trim()).filter(Boolean).includes(txHash)) {
+				gasStake.owner = (0, _arcblock_did.toAddress)(decoded.iss);
+				gasStake.stakeId = (0, _arcblock_did_util.toStakeAddress)(gasStake.owner, gasStake.owner);
+			} else console.warn(`Invalid gas payer header for: ${txHash}`);
+		}
+		if (!gasStake.owner && tx?.from) {
+			const owner = tx.from;
+			gasStake.owner = owner;
+			gasStake.stakeId = (0, _arcblock_did_util.toStakeAddress)(owner, owner);
+		}
+		gasStake.state = await statedb.stake.get(gasStake.stakeId, context);
+		gasStake.valid = require_util.isGasStakeValid(gasStake.state, config);
+		context.gasStake = gasStake;
+		debug$1("gasStake", gasStake, context.extra);
+		const changes = {};
+		let txCost = new _ocap_util.BN(0);
+		const txFeeMap = config.transaction.txFee;
+		const txFee = txType ? txFeeMap[txType] : void 0;
+		if (!gasOnly && txFee) {
+			const totalFee = (0, _ocap_util.fromTokenToUnit)(txFee, config.token.decimal);
+			txCost = txCost.add(totalFee);
+			changes.fee = {
+				address: config.token.address,
+				value: totalFee.toString(10)
+			};
+			context.feeVaultChange = changes.fee;
+		}
+		const totalGasBN = totalGas ?? ZERO;
+		if (!gasStake.valid && totalGasBN.gt(ZERO)) {
+			txCost = txCost.add(totalGasBN);
+			changes.gas = {
+				address: config.token.address,
+				value: totalGasBN.toString(10)
+			};
+			context.gasVaultChange = changes.gas;
+		}
+		if (changes.fee) if (config.vaults.txFees?.length) {
+			const feeIndex = (0, _ocap_util.hexToNumber)(txHash.slice(-8)) % config.vaults.txFees.length;
+			context.feeVault = config.vaults.txFees[feeIndex];
+		} else context.feeVault = config.vaults.txFee;
+		let isCostCharged = false;
+		if (txCost.gt(ZERO)) {
+			const expected = new _ocap_util.BN(gasEstimate?.payment || 0).add(txCost);
+			const actual = new _ocap_util.BN(senderState?.tokens?.[config.token.address] || 0);
+			if (senderState && actual.gte(expected)) {
+				isCostCharged = true;
+				context.senderUpdates = require_util.applyTokenUpdates([{
+					address: config.token.address,
+					value: txCost.toString(10)
+				}], senderState, "sub");
+				context.senderChange = {
+					address: senderState.address,
+					token: config.token.address,
+					delta: `-${txCost.toString(10)}`
+				};
+				debug$1({
+					changes,
+					senderUpdates: context.senderUpdates
+				});
+				context.updateVaults = async function updateVaults() {
+					const [feeVaultState, gasVaultState] = await Promise.all([changes.fee && context.feeVault ? statedb.account.get(context.feeVault, context) : null, changes.gas && context.gasVault ? statedb.account.get(context.gasVault, context) : null]);
+					const [newFeeVaultState, newGasVaultState] = await Promise.all([changes.fee && feeVaultState ? statedb.account.update(feeVaultState.address, _ocap_state.account.update(feeVaultState, require_util.applyTokenUpdates([changes.fee], feeVaultState, "add"), context), context) : null, changes.gas && gasVaultState ? statedb.account.update(gasVaultState.address, _ocap_state.account.update(gasVaultState, require_util.applyTokenUpdates([changes.gas], gasVaultState, "add"), context), context) : null]);
+					if (newFeeVaultState) context.feeVaultState = newFeeVaultState;
+					if (newGasVaultState) context.gasVaultState = newGasVaultState;
+					context.updatedAccounts = context.updatedAccounts || [];
+					if (changes.fee && feeVaultState) {
+						context.updatedAccounts.push({
+							address: feeVaultState.address,
+							token: config.token.address,
+							delta: changes.fee.value,
+							action: "fee"
+						});
+						if (attachSenderChanges) context.updatedAccounts.push({
+							address: senderState.address,
+							token: config.token.address,
+							delta: `-${changes.fee.value}`,
+							action: "fee"
+						});
+					}
+					if (changes.gas && gasVaultState) {
+						context.updatedAccounts.push({
+							address: gasVaultState.address,
+							token: config.token.address,
+							delta: changes.gas.value,
+							action: "gas"
+						});
+						if (attachSenderChanges) context.updatedAccounts.push({
+							address: senderState.address,
+							token: config.token.address,
+							delta: `-${changes.gas.value}`,
+							action: "gas"
+						});
+					}
+					context.gasPaid = true;
+				};
+			} else if (!senderState) return next(new _ocap_util_lib_error.CustomError("INVALID_GAS_PAYER", `Gas payer ${tx.from} does not exist on chain`));
+			else if (throwOnInsufficientFund) return next(new _ocap_util_lib_error.CustomError("INSUFFICIENT_FUND", `Insufficient fund to pay for tx cost from ${senderState.address || tx.from}, expected ${(0, _ocap_util.fromUnitToToken)(expected, config.token.decimal)} ${config.token.symbol}, got ${(0, _ocap_util.fromUnitToToken)(actual, config.token.decimal)} ${config.token.symbol}`));
+		}
+		if (!isCostCharged) {
+			context.senderUpdates = {};
+			context.senderChange = null;
+			context.updateVaults = lodash_noop.default;
+			context.updatedAccounts = [];
+		}
+		return next();
+	};
+}
+var ensure_cost_default = CreateEnsureTxCostPipe;
+
+//#endregion
+exports.default = ensure_cost_default;

package/lib/pipes/ensure-cost.d.cts

@@ -0,0 +1,18 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#region src/pipes/ensure-cost.d.ts
+/** Options for CreateEnsureTxCostPipe */
+interface IEnsureTxCostOptions {
+  attachSenderChanges?: boolean;
+  throwOnInsufficientFund?: boolean;
+  gasOnly?: boolean;
+}
+/** Context for ensure cost pipe */
+declare function CreateEnsureTxCostPipe({
+  attachSenderChanges,
+  throwOnInsufficientFund,
+  // In some cases, we can tolerance insufficient fund, such as account migration
+  gasOnly
+}?: IEnsureTxCostOptions): PipeFunction<any>;
+//#endregion
+export { CreateEnsureTxCostPipe as default };