@ocap/tx-protocols 1.28.9 → 1.29.0

package/esm/execute.d.mts

@@ -0,0 +1,53 @@
+import { CustomError } from "@ocap/util/lib/error";
+import { Blacklist } from "@ocap/state";
+import { IAccountState, IGasContext } from "@ocap/types";
+
+//#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/esm/execute.mjs

@@ -0,0 +1,225 @@
+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 camelCase from "lodash/camelCase.js";
+import get from "lodash/get.js";
+import merge from "lodash/merge.js";
+import pick from "lodash/pick.js";
+
+//#region src/execute.ts
+const ensureTxGas = ensure_gas_default(() => ({
+	create: 0,
+	update: 2
+}));
+const ensureTxCost = ensure_cost_default({
+	attachSenderChanges: true,
+	gasOnly: true
+});
+const getTxName = (typeUrl) => camelCase(typeUrl.split(":").pop() ?? "");
+/** Get states helper with type guard - throws if states is not initialized */
+const getStates = (context) => {
+	if (!context.states) throw new 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(get(err, "props.persist"));
+const createExecute = ({ filter, runAsLambda }) => {
+	const pre = new Runner("pre-execute");
+	pre.use(pipes.DecodeTx);
+	pre.use(pipes.VerifyBlocked({
+		filter,
+		stateKeys: ["tx.from"]
+	}));
+	pre.use(pipes.DecodeItx);
+	pre.use(pipes.VerifyTx);
+	pre.use(pipes.VerifyServiceFee);
+	pre.use(async (context, next) => {
+		if (filter.has(context.txHash)) {
+			if (await context.statedb.tx.get(context.txHash, context)) return next(new CustomError("DUPLICATE_TX", "Can not execute duplicate transaction"));
+		}
+		filter.add(context.txHash);
+		return next();
+	});
+	pre.use(pipes.VerifyTxSize);
+	pre.use(pipes.VerifySignature);
+	const ensureGasFeePaid = (context) => {
+		const gasRunner = new 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 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 = pick(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 {
+			merge(context, ctx);
+		}
+		return ctx;
+	};
+	return execute;
+};
+var execute_default = createExecute;
+
+//#endregion
+export { execute_default as default };

package/esm/index.d.mts

@@ -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/esm/index.mjs

@@ -0,0 +1,100 @@
+import execute_default from "./execute.mjs";
+import delegate_default from "./protocols/account/delegate.mjs";
+import migrate_default from "./protocols/account/migrate.mjs";
+import revoke_delegate_default from "./protocols/account/revoke-delegate.mjs";
+import acquire_v2_default from "./protocols/asset/acquire-v2.mjs";
+import acquire_v3_default from "./protocols/asset/acquire-v3.mjs";
+import consume_default from "./protocols/asset/consume.mjs";
+import create_default from "./protocols/asset/create.mjs";
+import mint_default from "./protocols/asset/mint.mjs";
+import update_default from "./protocols/asset/update.mjs";
+import create_default$1 from "./protocols/factory/create.mjs";
+import claim_stake_default from "./protocols/governance/claim-stake.mjs";
+import return_stake_default from "./protocols/governance/return-stake.mjs";
+import revoke_stake_default from "./protocols/governance/revoke-stake.mjs";
+import slash_stake_default from "./protocols/governance/slash-stake.mjs";
+import stake_default from "./protocols/governance/stake.mjs";
+import claim_reward_default from "./protocols/rollup/claim-reward.mjs";
+import close_default from "./protocols/rollup/close.mjs";
+import create_default$2 from "./protocols/rollup/create.mjs";
+import create_block_default from "./protocols/rollup/create-block.mjs";
+import join_default from "./protocols/rollup/join.mjs";
+import leave_default from "./protocols/rollup/leave.mjs";
+import migrate_default$1 from "./protocols/rollup/migrate.mjs";
+import pause_default from "./protocols/rollup/pause.mjs";
+import resume_default from "./protocols/rollup/resume.mjs";
+import update_default$1 from "./protocols/rollup/update.mjs";
+import burn_default from "./protocols/token-factory/burn.mjs";
+import create_default$3 from "./protocols/token-factory/create.mjs";
+import mint_default$1 from "./protocols/token-factory/mint.mjs";
+import update_default$2 from "./protocols/token-factory/update.mjs";
+import create_default$4 from "./protocols/token/create.mjs";
+import deposit_v2_default from "./protocols/token/deposit-v2.mjs";
+import withdraw_v2_default from "./protocols/token/withdraw-v2.mjs";
+import exchange_v2_default from "./protocols/trade/exchange-v2.mjs";
+import transfer_v2_default from "./protocols/trade/transfer-v2.mjs";
+import transfer_v3_default from "./protocols/trade/transfer-v3.mjs";
+import * as states from "@ocap/state";
+
+//#region src/index.ts
+const createExecutor = ({ filter, runAsLambda }) => {
+	const protocols = {
+		transfer: transfer_v2_default,
+		transferV2: transfer_v2_default,
+		transferV3: transfer_v3_default,
+		exchangeV2: exchange_v2_default,
+		accountMigrate: migrate_default,
+		delegate: delegate_default,
+		revokeDelegate: revoke_delegate_default,
+		createAsset: create_default,
+		updateAsset: update_default,
+		consumeAsset: consume_default,
+		acquireAssetV2: acquire_v2_default,
+		acquireAssetV3: acquire_v3_default,
+		mintAsset: mint_default,
+		createFactory: create_default$1,
+		createToken: create_default$4,
+		depositTokenV2: deposit_v2_default,
+		withdrawTokenV2: withdraw_v2_default,
+		createTokenFactory: create_default$3,
+		updateTokenFactory: update_default$2,
+		mintToken: mint_default$1,
+		burnToken: burn_default,
+		stake: stake_default,
+		revokeStake: revoke_stake_default,
+		claimStake: claim_stake_default,
+		slashStake: slash_stake_default,
+		returnStake: return_stake_default,
+		createRollup: create_default$2,
+		updateRollup: update_default$1,
+		joinRollup: join_default,
+		leaveRollup: leave_default,
+		pauseRollup: pause_default,
+		closeRollup: close_default,
+		resumeRollup: resume_default,
+		createRollupBlock: create_block_default,
+		claimBlockReward: claim_reward_default,
+		migrateRollup: migrate_default$1
+	};
+	const execute$1 = execute_default({
+		filter,
+		runAsLambda
+	});
+	return {
+		...protocols,
+		execute: (context, done) => {
+			Object.defineProperty(context, "states", { value: states });
+			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 states.Blacklist(),
+	runAsLambda: void 0
+});
+const { execute } = defaultExecutor;
+var src_default = defaultExecutor;
+
+//#endregion
+export { createExecutor, src_default as default, execute };

package/esm/pipes/ensure-cost.d.mts

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

package/esm/pipes/ensure-cost.mjs

@@ -0,0 +1,136 @@
+import { applyTokenUpdates, isGasStakeValid } from "../util.mjs";
+import { CustomError } from "@ocap/util/lib/error";
+import { toAddress } from "@arcblock/did";
+import { toStakeAddress } from "@arcblock/did-util";
+import * as JWT from "@arcblock/jwt";
+import { account } from "@ocap/state";
+import { BN, fromTokenToUnit, fromUnitToToken, hexToNumber } from "@ocap/util";
+import noop from "lodash/noop.js";
+import Debug from "debug";
+
+//#region src/pipes/ensure-cost.ts
+const debug = Debug("@ocap/tx-protocols:pipes:ensure-cost");
+const ZERO = new 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: tx$1, extra = {}, txHash = "" } = context;
+		const { token: token$1, pk } = extra.gasStakeHeaders || {};
+		const gasStake = {};
+		if (token$1 && pk && await JWT.verify(token$1, pk, {
+			enforceTimestamp: true,
+			tolerance: 5
+		})) {
+			const decoded = JWT.decode(token$1);
+			if ((decoded.txHash || "").split(",").map((x) => x.trim()).filter(Boolean).includes(txHash)) {
+				gasStake.owner = toAddress(decoded.iss);
+				gasStake.stakeId = toStakeAddress(gasStake.owner, gasStake.owner);
+			} else console.warn(`Invalid gas payer header for: ${txHash}`);
+		}
+		if (!gasStake.owner && tx$1?.from) {
+			const owner = tx$1.from;
+			gasStake.owner = owner;
+			gasStake.stakeId = toStakeAddress(owner, owner);
+		}
+		gasStake.state = await statedb.stake.get(gasStake.stakeId, context);
+		gasStake.valid = isGasStakeValid(gasStake.state, config);
+		context.gasStake = gasStake;
+		debug("gasStake", gasStake, context.extra);
+		const changes = {};
+		let txCost = new BN(0);
+		const txFeeMap = config.transaction.txFee;
+		const txFee = txType ? txFeeMap[txType] : void 0;
+		if (!gasOnly && txFee) {
+			const totalFee = 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 = 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 BN(gasEstimate?.payment || 0).add(txCost);
+			const actual = new BN(senderState?.tokens?.[config.token.address] || 0);
+			if (senderState && actual.gte(expected)) {
+				isCostCharged = true;
+				context.senderUpdates = 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({
+					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, account.update(feeVaultState, applyTokenUpdates([changes.fee], feeVaultState, "add"), context), context) : null, changes.gas && gasVaultState ? statedb.account.update(gasVaultState.address, account.update(gasVaultState, 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 CustomError("INVALID_GAS_PAYER", `Gas payer ${tx$1.from} does not exist on chain`));
+			else if (throwOnInsufficientFund) return next(new CustomError("INSUFFICIENT_FUND", `Insufficient fund to pay for tx cost from ${senderState.address || tx$1.from}, expected ${fromUnitToToken(expected, config.token.decimal)} ${config.token.symbol}, got ${fromUnitToToken(actual, config.token.decimal)} ${config.token.symbol}`));
+		}
+		if (!isCostCharged) {
+			context.senderUpdates = {};
+			context.senderChange = null;
+			context.updateVaults = noop;
+			context.updatedAccounts = [];
+		}
+		return next();
+	};
+}
+var ensure_cost_default = CreateEnsureTxCostPipe;
+
+//#endregion
+export { ensure_cost_default as default };

package/esm/pipes/ensure-gas.d.mts

@@ -0,0 +1,14 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#region src/pipes/ensure-gas.d.ts
+/** Gas estimate result */
+interface IGasEstimate {
+  create: number;
+  update: number;
+  payment?: number;
+}
+/** Gas estimator function type - uses any for flexible context access */
+type GasEstimatorFn = (context: any) => IGasEstimate;
+declare function CreateGasEnsureFn(estimateTxGas: GasEstimatorFn): PipeFunction<any>;
+//#endregion
+export { CreateGasEnsureFn as default };

package/esm/pipes/ensure-gas.mjs

@@ -0,0 +1,38 @@
+import { BN, hexToNumber } from "@ocap/util";
+import Debug from "debug";
+
+//#region src/pipes/ensure-gas.ts
+const debug = Debug("@ocap/tx-protocols:pipes:ensure-gas");
+function CreateGasEnsureFn(estimateTxGas) {
+	return function EnsureTxGas(context, next) {
+		const { txHash = "", config } = context;
+		const { txGas } = config.transaction;
+		const basePrice = new BN(txGas.price);
+		const estimate = estimateTxGas(context);
+		let totalGas = new BN(0);
+		if (context.txBaseGas) {
+			totalGas = basePrice.mul(new BN(txGas.dataStorage)).mul(new BN(context.txSize));
+			totalGas = totalGas.add(basePrice.mul(new BN(txGas.createState)).mul(new BN(estimate.create + 1)));
+			totalGas = totalGas.add(basePrice.mul(new BN(txGas.updateState)).mul(new BN(estimate.update)));
+		}
+		const { txGas: gasVaults = [] } = config.vaults;
+		const gasVault = gasVaults[gasVaults.length > 0 ? hexToNumber(txHash.slice(-8)) % gasVaults.length : 0];
+		context.gasVault = gasVault;
+		debug({
+			txType: context.txType,
+			txHash: context.txHash,
+			txSize: context.txSize,
+			txBaseGas: context.txBaseGas,
+			totalGas: totalGas.toString(10),
+			gasVault,
+			estimate
+		});
+		context.totalGas = totalGas;
+		context.gasEstimate = estimate;
+		return next();
+	};
+}
+var ensure_gas_default = CreateGasEnsureFn;
+
+//#endregion
+export { ensure_gas_default as default };

package/esm/protocols/account/delegate.d.mts

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