@ocap/tx-protocols 1.28.9 → 1.29.1

package/esm/protocols/asset/mint.mjs

@@ -0,0 +1,156 @@
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import verify_itx_address_default from "./pipes/verify-itx-address.mjs";
+import verify_itx_assets_default from "./pipes/verify-itx-assets.mjs";
+import verify_itx_variables_default from "./pipes/verify-itx-variables.mjs";
+import verify_mint_limit_default from "./pipes/verify-mint-limit.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { account, asset, factory } from "@ocap/state";
+import Debug from "debug";
+import { Joi, schemas } from "@arcblock/validator";
+
+//#region src/protocols/asset/mint.ts
+const debug = Debug("@ocap/tx-protocols:mint-asset");
+const runner = new Runner("mint_asset");
+runner.use(pipes.VerifyMultiSig(0));
+const schema = Joi.object({
+	factory: Joi.DID().prefix().role("ROLE_FACTORY").required(),
+	address: Joi.DID().prefix().role("ROLE_ASSET").required(),
+	assetsList: Joi.array().items(Joi.DID().prefix().role("ROLE_ASSET")).default([]),
+	variablesList: Joi.array().items(schemas.variableInput).optional().allow(null).default([]),
+	owner: schemas.tokenHolder.required(),
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use(({ itx }, next) => {
+	const { error } = schema.validate(itx);
+	if (error) return next(new CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "itx.address",
+	to: "duplicateAsset",
+	status: "OK",
+	table: "asset"
+}));
+runner.use(pipes.VerifyInfo([{
+	error: "FORBIDDEN",
+	message: "Asset with same address already exists",
+	fn: (ctx) => {
+		return !ctx.duplicateAsset;
+	},
+	persist: true
+}]));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.factory",
+	to: "factoryState",
+	status: "INVALID_FACTORY_STATE",
+	table: "factory"
+}));
+runner.use(pipes.ExtractState({
+	from: "factoryState.owner",
+	to: "factoryOwnerState",
+	status: "INVALID_ISSUER_STATE",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "factoryState.trustedIssuers",
+	to: "issuerStates",
+	status: "INVALID_ISSUER_STATE",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.owner",
+	to: "ownerState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.VerifyBlocked({ stateKeys: ["ownerState"] }));
+runner.use(pipes.VerifyInfo([{
+	error: "FORBIDDEN",
+	message: "Only factory owner and trusted issuers are allowed to mint",
+	fn: (ctx) => {
+		const context = ctx;
+		const { factoryOwnerState, senderState } = context;
+		const issuerStates = context.issuerStates || [];
+		return senderState.address === factoryOwnerState.address || issuerStates.some((x) => x.address === senderState.address);
+	},
+	persist: true
+}]));
+runner.use(pipes.ExtractState({
+	from: "itx.assetsList",
+	to: "assetStates",
+	status: "OK",
+	table: "asset"
+}));
+runner.use(pipes.ExtractState({
+	from: "factoryState.input.assets",
+	to: "expectedFactoryStates",
+	status: "OK",
+	table: "factory"
+}));
+runner.use(verify_mint_limit_default);
+runner.use(verify_itx_variables_default);
+runner.use(verify_itx_address_default("mint"));
+runner.use(pipes.VerifyUpdater({
+	assetKey: "assetStates",
+	ownerKey: "ownerState"
+}));
+runner.use(verify_itx_assets_default);
+runner.use(ensure_gas_default((context) => {
+	const result = {
+		create: 1,
+		update: 2,
+		payment: 0
+	};
+	if (!context.ownerState) result.create += 1;
+	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, txTime, statedb, senderState, factoryState, mintedAsset, mintedAddress, ownerState, senderUpdates, assetStates = [], updateVaults, ownerAddress } = context;
+	const factoryUpdates = { numMinted: factoryState.numMinted + 1 };
+	const [newSenderState, newReceiverState, assetState, newFactoryState, newAssetStates] = await Promise.all([
+		statedb.account.update(senderState.address, account.update(senderState, {
+			nonce: tx$1.nonce,
+			pk: tx$1.pk,
+			...senderUpdates
+		}, context), context),
+		ownerState ? Promise.resolve(ownerState) : statedb.account.create(ownerAddress, account.create({ address: ownerAddress }, context), context),
+		statedb.asset.create(itx.address, asset.create({
+			...mintedAsset,
+			owner: ownerAddress,
+			address: mintedAddress
+		}, context), context),
+		statedb.factory.update(factoryState.address, factory.update(factoryState, factoryUpdates, context), context),
+		Promise.all(assetStates.map((x) => statedb.asset.update(x.address, asset.update(x, { consumedTime: txTime }, context), context)))
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.receiverState = newReceiverState;
+	context.assetState = assetState;
+	context.factoryState = newFactoryState;
+	context.assetStates = newAssetStates;
+	debug("mint", assetState);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var mint_default = runner;
+
+//#endregion
+export { mint_default as default };

package/esm/protocols/asset/pipes/exec-mint-hook.d.mts

@@ -0,0 +1,24 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+import { IAccountState, IAccountUpdate, IAssetFactoryState, IDecodedContext, IStateDB, TTransactionReceipt } from "@ocap/types";
+
+//#region src/protocols/asset/pipes/exec-mint-hook.d.ts
+
+/**
+ * Context type for exec-mint-hook pipe.
+ * Requires: statedb, factoryState, config
+ * Optional: tokenUpdates
+ * Sets: updatedAccounts, mintHookStates, receipts
+ */
+type ExecMintHookContext = IDecodedContext & {
+  statedb: IStateDB;
+  factoryState?: IAssetFactoryState;
+  tokenUpdates?: Record<string, string>;
+  updatedAccounts?: IAccountUpdate[];
+  mintHookStates?: IAccountState[];
+  receipts?: TTransactionReceipt[];
+  states?: unknown;
+  txn?: unknown;
+};
+declare const execMintHook: PipeFunction<ExecMintHookContext>;
+//#endregion
+export { execMintHook as default };

package/esm/protocols/asset/pipes/exec-mint-hook.mjs

@@ -0,0 +1,54 @@
+import transfer_default from "../calls/transfer.mjs";
+import transfer_token_default from "../calls/transfer-token.mjs";
+import cloneDeep from "lodash/cloneDeep.js";
+
+//#region src/protocols/asset/pipes/exec-mint-hook.ts
+const contractCalls = {
+	transfer: transfer_default,
+	transferToken: transfer_token_default
+};
+const execMintHook = async (context, next) => {
+	const { statedb, factoryState, tokenUpdates, config } = context;
+	const factory = factoryState;
+	if (factory.settlement === "instant") {
+		const mintHook = factory.hooks.find((x) => x.name === "mint");
+		if (mintHook && mintHook.type === "contract") {
+			context.updatedAccounts = context.updatedAccounts || [];
+			const clone = cloneDeep(mintHook.compiled);
+			const mintHookStates = {};
+			for (const x of clone) {
+				if (x.call === "transfer") {
+					x.call = "transferToken";
+					x.args.tokenAddress = config.token.address;
+				}
+				const { updateSet } = await contractCalls[x.call].runAsync({
+					states: context.states,
+					statedb,
+					txn: context.txn,
+					txTime: context.txTime,
+					txHash: context.txHash,
+					logger: context.logger,
+					args: x.args
+				});
+				mintHookStates[updateSet.address] = await statedb.account.update(updateSet.address, updateSet.updates, context);
+				context.updatedAccounts.push(updateSet);
+			}
+			context.mintHookStates = Object.values(mintHookStates);
+		}
+	} else if (tokenUpdates) {
+		const updates = tokenUpdates;
+		if (updates.tokens) context.receipts = [{
+			address: factory.address,
+			changes: Object.keys(updates.tokens).map((x) => ({
+				target: x,
+				action: "transfer",
+				value: updates.tokens[x]
+			})).filter((x) => Number(x.value) > 0)
+		}];
+	}
+	next();
+};
+var exec_mint_hook_default = execMintHook;
+
+//#endregion
+export { exec_mint_hook_default as default };

package/esm/protocols/asset/pipes/extract-factory-tokens.d.mts

@@ -0,0 +1,21 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+import { IAssetFactoryState, IBaseContext } from "@ocap/types";
+
+//#region src/protocols/asset/pipes/extract-factory-tokens.d.ts
+interface TokenInput {
+  address: string;
+  value: string;
+}
+/**
+ * Context type for extract-factory-tokens pipe.
+ * Requires: factoryState, config
+ * Sets: factoryTokens, tokenAddress (array of token addresses)
+ */
+type ExtractFactoryTokensContext = IBaseContext & {
+  factoryState?: IAssetFactoryState;
+  factoryTokens?: TokenInput[];
+  tokenAddress?: string[];
+};
+declare const extract_factory_tokens: PipeFunction<ExtractFactoryTokensContext>;
+//#endregion
+export { TokenInput, extract_factory_tokens as default };

package/esm/protocols/asset/pipes/extract-factory-tokens.mjs

@@ -0,0 +1,22 @@
+import { BN } from "@ocap/util";
+import { createSortedList } from "@ocap/util/lib/create-sorted-list";
+import uniqBy from "lodash/uniqBy.js";
+
+//#region src/protocols/asset/pipes/extract-factory-tokens.ts
+const extract_factory_tokens = (context, next) => {
+	const { factoryState, config } = context;
+	const input = factoryState.input;
+	context.factoryTokens = [...input.tokens];
+	const factoryTokens = context.factoryTokens;
+	if (!factoryTokens.find((x) => x.address === config.token.address) && new BN(input.value).gt(new BN(0))) factoryTokens.push({
+		address: config.token.address,
+		value: input.value
+	});
+	context.factoryTokens = uniqBy(context.factoryTokens, "address");
+	context.tokenAddress = createSortedList((context.factoryTokens || []).map((x) => x.address));
+	next();
+};
+var extract_factory_tokens_default = extract_factory_tokens;
+
+//#endregion
+export { extract_factory_tokens_default as default };

package/esm/protocols/asset/pipes/verify-itx-address.d.mts

@@ -0,0 +1,32 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+import { IAccountState, IAssetFactoryState, IDecodedContext } from "@ocap/types";
+
+//#region src/protocols/asset/pipes/verify-itx-address.d.ts
+type VerifyItxAddressMode = 'acquire-v2' | 'acquire-v3' | 'mint';
+/**
+ * Inner transaction type for acquire/mint operations
+ */
+interface AcquireMintItx {
+  address: string;
+  issuer?: unknown;
+  owner?: string;
+}
+/**
+ * Context type for verify-itx-address pipe.
+ * Requires: itx, factoryState, factoryInputs
+ * Optional: senderState, delegatorState
+ * Sets: ownerAddress, mintedAsset, mintedAddress, assetOwner (for acquire-v2)
+ */
+type VerifyItxAddressContext = IDecodedContext<AcquireMintItx> & {
+  senderState?: IAccountState;
+  delegatorState?: IAccountState;
+  factoryState?: IAssetFactoryState;
+  factoryInputs?: Record<string, unknown>;
+  ownerAddress?: string;
+  mintedAsset?: Record<string, unknown>;
+  mintedAddress?: string;
+  assetOwner?: IAccountState;
+};
+declare const verify_itx_address: (mode: VerifyItxAddressMode) => PipeFunction<VerifyItxAddressContext>;
+//#endregion
+export { verify_itx_address as default };

package/esm/protocols/asset/pipes/verify-itx-address.mjs

@@ -0,0 +1,56 @@
+import { CustomError } from "@ocap/util/lib/error";
+import Debug from "debug";
+import { mintFromFactory } from "@ocap/asset";
+
+//#region src/protocols/asset/pipes/verify-itx-address.ts
+const debug = Debug("@ocap/tx-protocols:pipes:verify-itx-address");
+const verify_itx_address = (mode) => (context, next) => {
+	const { itx, senderState, factoryState, delegatorState, factoryInputs } = context;
+	const sender = senderState;
+	const factory = factoryState;
+	const inputs = factoryInputs;
+	let issuer = null;
+	let owner = null;
+	if (mode === "acquire-v2") {
+		owner = delegatorState || sender;
+		issuer = itx.issuer;
+		context.assetOwner = owner;
+	} else if (mode === "acquire-v3") {
+		owner = { address: itx.owner };
+		issuer = itx.issuer;
+	} else if (mode === "mint") {
+		owner = { address: itx.owner };
+		issuer = {
+			id: sender.address,
+			pk: sender.pk,
+			name: sender.moniker
+		};
+	}
+	const minted = mintFromFactory({
+		factory,
+		inputs,
+		owner: owner.address,
+		issuer
+	});
+	if (minted.address !== itx.address) {
+		debug("asset address mismatch", {
+			owner,
+			issuer,
+			minted,
+			itx,
+			factoryInputs,
+			factoryState,
+			senderState,
+			delegatorState
+		});
+		return next(new CustomError("INVALID_ASSET", "Invalid itx.address: does not match with minted asset address"));
+	}
+	context.ownerAddress = owner.address;
+	context.mintedAsset = minted.asset;
+	context.mintedAddress = minted.address;
+	return next();
+};
+var verify_itx_address_default = verify_itx_address;
+
+//#endregion
+export { verify_itx_address_default as default };

package/esm/protocols/asset/pipes/verify-itx-assets.d.mts

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

package/esm/protocols/asset/pipes/verify-itx-assets.mjs

@@ -0,0 +1,27 @@
+import { CustomError } from "@ocap/util/lib/error";
+import { getListField } from "@ocap/util/lib/get-list-field";
+
+//#region src/protocols/asset/pipes/verify-itx-assets.ts
+const verify_itx_assets = (context, next) => {
+	const { factoryState, expectedFactoryStates = [], assetStates: actualAssetStates = [], itx } = context;
+	const expectedAssets = factoryState.input.assets;
+	const assetStates = actualAssetStates;
+	if (expectedAssets.length === 0) return next();
+	if (getListField(itx, "assets").length > assetStates.length) return next(new CustomError("INVALID_ASSET", "Input asset does not exist on chain"));
+	if (expectedFactoryStates.length === expectedAssets.length) {
+		if (assetStates.every((x) => x.parent && expectedAssets.includes(x.parent)) === false) return next(new CustomError("INVALID_ASSET", "Input asset not minted from any of factory.input.assets"));
+		if (assetStates.every((x) => !x.consumedTime) === false) return next(new CustomError("INVALID_ASSET", "Some input asset already consumed"));
+		return next();
+	}
+	for (const address of expectedAssets) {
+		const plainAsset = assetStates.find((x) => x.address === address);
+		if (plainAsset) {
+			if (plainAsset.consumedTime) return next(new CustomError("INVALID_ASSET", `Input asset ${address} already consumed`));
+		} else if (!assetStates.find((x) => x.parent === address)) return next(new CustomError("INVALID_ASSET", `Input asset not found ${address}`));
+	}
+	return next();
+};
+var verify_itx_assets_default = verify_itx_assets;
+
+//#endregion
+export { verify_itx_assets_default as default };

package/esm/protocols/asset/pipes/verify-itx-variables.d.mts

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

package/esm/protocols/asset/pipes/verify-itx-variables.mjs

@@ -0,0 +1,20 @@
+import { CustomError } from "@ocap/util/lib/error";
+import { getListField } from "@ocap/util/lib/get-list-field";
+
+//#region src/protocols/asset/pipes/verify-itx-variables.ts
+const verify_itx_variables = (context, next) => {
+	const { factoryState, itx } = context;
+	const variables = factoryState.input.variables;
+	const factoryInputs = getListField(itx, "variables").reduce((acc, x) => {
+		acc[x.name] = x.value;
+		return acc;
+	}, {});
+	const missingVariables = variables.filter((x) => x.required && !factoryInputs[x.name]);
+	if (missingVariables.length) return next(new CustomError("INVALID_FACTORY_INPUT", `Invalid itx.variables: missing required input variable: ${missingVariables.map((x) => x.name).join(", ")}`));
+	context.factoryInputs = factoryInputs;
+	return next();
+};
+var verify_itx_variables_default = verify_itx_variables;
+
+//#endregion
+export { verify_itx_variables_default as default };

package/esm/protocols/asset/pipes/verify-mint-limit.d.mts

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

package/esm/protocols/asset/pipes/verify-mint-limit.mjs

@@ -0,0 +1,14 @@
+import { CustomError } from "@ocap/util/lib/error";
+
+//#region src/protocols/asset/pipes/verify-mint-limit.ts
+const verify_mint_limit = ({ factoryState }, next) => {
+	const factory = factoryState;
+	const limit = factory.limit;
+	if (limit === 0) return next();
+	if (factory.numMinted < limit) return next();
+	return next(new CustomError("EXCEED_MINT_LIMIT", "This request will exceed factory mint limit"));
+};
+var verify_mint_limit_default = verify_mint_limit;
+
+//#endregion
+export { verify_mint_limit_default as default };

package/esm/protocols/asset/update.d.mts

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

package/esm/protocols/asset/update.mjs

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

package/esm/protocols/factory/create.d.mts

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