@ocap/tx-protocols 1.28.9 → 1.29.0

package/lib/protocols/asset/consume.cjs

@@ -0,0 +1,95 @@
+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 _ocap_state = require("@ocap/state");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let _arcblock_validator = require("@arcblock/validator");
+
+//#region src/protocols/asset/consume.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:consume-asset");
+const runner = new _ocap_tx_pipeline.Runner("consume_asset");
+const schema = _arcblock_validator.Joi.object({
+	address: _arcblock_validator.Joi.DID().prefix().role("ROLE_ASSET").required(),
+	data: _arcblock_validator.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 _ocap_util_lib_error.CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.address",
+	to: "assetState",
+	status: "INVALID_ASSET",
+	table: "asset"
+}));
+runner.use((context, next) => {
+	const { assetState } = context;
+	if (!assetState) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "Asset state not found"));
+	const { issuer, consumedTime } = assetState;
+	if (!issuer) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", "Asset without issuer can not be consumed"));
+	if (consumedTime) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Asset already consumed on ${consumedTime}`));
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "assetState.issuer",
+	to: "issuerState",
+	status: "INVALID_ISSUER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "assetState.owner",
+	to: "ownerState",
+	status: "INVALID_OWNER_STATE",
+	table: "account"
+}));
+runner.use((context, next) => {
+	context.signerStates = [context.ownerState, context.issuerState];
+	context.signers = [context.ownerState.address, context.issuerState.address];
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSigV2({ signersKey: "signers" }));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({ signerKey: "signerStates" }));
+runner.use(require_pipes_ensure_gas.default(() => ({
+	create: 0,
+	update: 2,
+	payment: 0
+})));
+runner.use(require_pipes_ensure_cost.default({ attachSenderChanges: true }));
+runner.use(_ocap_tx_pipeline.pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx, itx, txTime, statedb, senderState, senderUpdates, assetState, updateVaults } = context;
+	const [newSenderState, newAssetState] = await Promise.all([statedb.account.update(senderState.address, _ocap_state.account.update(senderState, {
+		nonce: tx.nonce,
+		pk: tx.pk,
+		...senderUpdates
+	}, context), context), statedb.asset.update(itx.address, _ocap_state.asset.update(assetState, { consumedTime: txTime }, context), context)]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.assetState = newAssetState;
+	debug$1("consume", newAssetState);
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var consume_default = runner;
+
+//#endregion
+exports.default = consume_default;

package/lib/protocols/asset/consume.d.cts

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

package/lib/protocols/asset/create.cjs

@@ -0,0 +1,140 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_util = require('../../util.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 _arcblock_did_util = require("@arcblock/did-util");
+let _ocap_state = require("@ocap/state");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let _ocap_message = require("@ocap/message");
+let _ocap_util_lib_get_list_field = require("@ocap/util/lib/get-list-field");
+let lodash_cloneDeep = require("lodash/cloneDeep");
+lodash_cloneDeep = require_rolldown_runtime.__toESM(lodash_cloneDeep);
+
+//#region src/protocols/asset/create.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:create-asset");
+const runner = new _ocap_tx_pipeline.Runner("create_asset");
+runner.use((context, next) => {
+	const itx = (0, _ocap_message.formatMessage)("CreateAssetTx", context.itx);
+	const { error } = _ocap_state.asset.schema.validate(itx);
+	if (error) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "INVALID_ASSET",
+	message: "Asset address is not valid",
+	fn: (ctx) => {
+		const context = ctx;
+		const itx = (0, lodash_cloneDeep.default)(context.itx);
+		const decodedData = require_util.decodeAnySafe(itx.data ?? null);
+		itx.data = decodedData;
+		itx.address = "";
+		context.assetData = decodedData;
+		context.signers = [itx.issuer].filter(Boolean);
+		return (0, _arcblock_did_util.toAssetAddress)(itx) === context.itx.address;
+	}
+}]));
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSigV2({ signersKey: "signers" }));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.address",
+	to: "assetState",
+	status: "OK"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "INVALID_ASSET",
+	message: "This asset already exist on chain",
+	fn: (ctx) => !ctx.assetState
+}]));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.issuer",
+	to: "issuerState",
+	status: "INVALID_ISSUER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({ signerKey: "issuerState" }));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.delegator",
+	to: "delegatorState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "delegatorState",
+	addressKey: "tx.delegator"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyDelegation({
+	type: "signature",
+	signerKey: "senderState",
+	delegatorKey: "delegatorState",
+	getRequirements: require_util.getDelegationRequirements
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.parent",
+	to: "factoryState",
+	status: "OK",
+	table: "factory"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "CREATE_FROM_FACTORY",
+	message: "You can only get asset from factory from acquire or mint",
+	fn: (ctx) => {
+		const { itx, factoryState } = ctx;
+		return !(itx.parent && factoryState);
+	},
+	persist: true
+}]));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.parent",
+	to: "parentAsset",
+	status: "INVALID_ASSET",
+	table: "asset"
+}));
+runner.use(require_pipes_ensure_gas.default(() => ({
+	create: 1,
+	update: 2,
+	payment: 0
+})));
+runner.use(require_pipes_ensure_cost.default({ attachSenderChanges: true }));
+runner.use(_ocap_tx_pipeline.pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx, itx, assetData, statedb, senderState, delegatorState, delegationState, senderUpdates, updateVaults } = context;
+	const owner = delegatorState ? delegatorState.address : senderState.address;
+	const [newSenderState, assetState, newDelegationState] = await Promise.all([
+		statedb.account.update(senderState.address, _ocap_state.account.update(senderState, {
+			nonce: tx.nonce,
+			pk: tx.pk,
+			...senderUpdates
+		}, context), context),
+		statedb.asset.create(itx.address, _ocap_state.asset.create({
+			...itx,
+			tags: (0, _ocap_util_lib_get_list_field.getListField)(itx, "tags"),
+			data: assetData ?? void 0,
+			owner
+		}, context), context),
+		context.isDelegationChanged && delegationState ? statedb.delegation.update(delegationState.address, _ocap_state.delegation.update(delegationState, {}, context), context) : delegationState
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.assetState = assetState;
+	context.delegationState = newDelegationState;
+	debug$1("createAsset", assetState);
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var create_default = runner;
+
+//#endregion
+exports.default = create_default;

package/lib/protocols/asset/create.d.cts

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

package/lib/protocols/asset/mint.cjs

@@ -0,0 +1,159 @@
+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');
+const require_protocols_asset_pipes_verify_itx_address = require('./pipes/verify-itx-address.cjs');
+const require_protocols_asset_pipes_verify_itx_assets = require('./pipes/verify-itx-assets.cjs');
+const require_protocols_asset_pipes_verify_itx_variables = require('./pipes/verify-itx-variables.cjs');
+const require_protocols_asset_pipes_verify_mint_limit = require('./pipes/verify-mint-limit.cjs');
+let _ocap_tx_pipeline = require("@ocap/tx-pipeline");
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let _ocap_state = require("@ocap/state");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let _arcblock_validator = require("@arcblock/validator");
+
+//#region src/protocols/asset/mint.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:mint-asset");
+const runner = new _ocap_tx_pipeline.Runner("mint_asset");
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSig(0));
+const schema = _arcblock_validator.Joi.object({
+	factory: _arcblock_validator.Joi.DID().prefix().role("ROLE_FACTORY").required(),
+	address: _arcblock_validator.Joi.DID().prefix().role("ROLE_ASSET").required(),
+	assetsList: _arcblock_validator.Joi.array().items(_arcblock_validator.Joi.DID().prefix().role("ROLE_ASSET")).default([]),
+	variablesList: _arcblock_validator.Joi.array().items(_arcblock_validator.schemas.variableInput).optional().allow(null).default([]),
+	owner: _arcblock_validator.schemas.tokenHolder.required(),
+	data: _arcblock_validator.Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use(({ itx }, next) => {
+	const { error } = schema.validate(itx);
+	if (error) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.address",
+	to: "duplicateAsset",
+	status: "OK",
+	table: "asset"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "FORBIDDEN",
+	message: "Asset with same address already exists",
+	fn: (ctx) => {
+		return !ctx.duplicateAsset;
+	},
+	persist: true
+}]));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.factory",
+	to: "factoryState",
+	status: "INVALID_FACTORY_STATE",
+	table: "factory"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "factoryState.owner",
+	to: "factoryOwnerState",
+	status: "INVALID_ISSUER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "factoryState.trustedIssuers",
+	to: "issuerStates",
+	status: "INVALID_ISSUER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.owner",
+	to: "ownerState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyBlocked({ stateKeys: ["ownerState"] }));
+runner.use(_ocap_tx_pipeline.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(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.assetsList",
+	to: "assetStates",
+	status: "OK",
+	table: "asset"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "factoryState.input.assets",
+	to: "expectedFactoryStates",
+	status: "OK",
+	table: "factory"
+}));
+runner.use(require_protocols_asset_pipes_verify_mint_limit.default);
+runner.use(require_protocols_asset_pipes_verify_itx_variables.default);
+runner.use(require_protocols_asset_pipes_verify_itx_address.default("mint"));
+runner.use(_ocap_tx_pipeline.pipes.VerifyUpdater({
+	assetKey: "assetStates",
+	ownerKey: "ownerState"
+}));
+runner.use(require_protocols_asset_pipes_verify_itx_assets.default);
+runner.use(require_pipes_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(require_pipes_ensure_cost.default({ attachSenderChanges: true }));
+runner.use(_ocap_tx_pipeline.pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx, 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, _ocap_state.account.update(senderState, {
+			nonce: tx.nonce,
+			pk: tx.pk,
+			...senderUpdates
+		}, context), context),
+		ownerState ? Promise.resolve(ownerState) : statedb.account.create(ownerAddress, _ocap_state.account.create({ address: ownerAddress }, context), context),
+		statedb.asset.create(itx.address, _ocap_state.asset.create({
+			...mintedAsset,
+			owner: ownerAddress,
+			address: mintedAddress
+		}, context), context),
+		statedb.factory.update(factoryState.address, _ocap_state.factory.update(factoryState, factoryUpdates, context), context),
+		Promise.all(assetStates.map((x) => statedb.asset.update(x.address, _ocap_state.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$1("mint", assetState);
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var mint_default = runner;
+
+//#endregion
+exports.default = mint_default;

package/lib/protocols/asset/mint.d.cts

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

package/lib/protocols/asset/pipes/exec-mint-hook.cjs

@@ -0,0 +1,57 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_protocols_asset_calls_transfer = require('../calls/transfer.cjs');
+const require_protocols_asset_calls_transfer_token = require('../calls/transfer-token.cjs');
+let lodash_cloneDeep = require("lodash/cloneDeep");
+lodash_cloneDeep = require_rolldown_runtime.__toESM(lodash_cloneDeep);
+
+//#region src/protocols/asset/pipes/exec-mint-hook.ts
+const contractCalls = {
+	transfer: require_protocols_asset_calls_transfer.default,
+	transferToken: require_protocols_asset_calls_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 = (0, lodash_cloneDeep.default)(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
+exports.default = exec_mint_hook_default;

package/lib/protocols/asset/pipes/exec-mint-hook.d.cts

@@ -0,0 +1,24 @@
+import { IAccountState, IAccountUpdate, IAssetFactoryState, IDecodedContext, IStateDB, TTransactionReceipt } from "@ocap/types";
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#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/lib/protocols/asset/pipes/extract-factory-tokens.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _ocap_util = require("@ocap/util");
+let _ocap_util_lib_create_sorted_list = require("@ocap/util/lib/create-sorted-list");
+let lodash_uniqBy = require("lodash/uniqBy");
+lodash_uniqBy = require_rolldown_runtime.__toESM(lodash_uniqBy);
+
+//#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 _ocap_util.BN(input.value).gt(new _ocap_util.BN(0))) factoryTokens.push({
+		address: config.token.address,
+		value: input.value
+	});
+	context.factoryTokens = (0, lodash_uniqBy.default)(context.factoryTokens, "address");
+	context.tokenAddress = (0, _ocap_util_lib_create_sorted_list.createSortedList)((context.factoryTokens || []).map((x) => x.address));
+	next();
+};
+var extract_factory_tokens_default = extract_factory_tokens;
+
+//#endregion
+exports.default = extract_factory_tokens_default;

package/lib/protocols/asset/pipes/extract-factory-tokens.d.cts

@@ -0,0 +1,21 @@
+import { IAssetFactoryState, IBaseContext } from "@ocap/types";
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#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/lib/protocols/asset/pipes/verify-itx-address.cjs

@@ -0,0 +1,59 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let _ocap_asset = require("@ocap/asset");
+
+//#region src/protocols/asset/pipes/verify-itx-address.ts
+const debug$1 = (0, debug.default)("@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 = (0, _ocap_asset.mintFromFactory)({
+		factory,
+		inputs,
+		owner: owner.address,
+		issuer
+	});
+	if (minted.address !== itx.address) {
+		debug$1("asset address mismatch", {
+			owner,
+			issuer,
+			minted,
+			itx,
+			factoryInputs,
+			factoryState,
+			senderState,
+			delegatorState
+		});
+		return next(new _ocap_util_lib_error.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
+exports.default = verify_itx_address_default;

package/lib/protocols/asset/pipes/verify-itx-address.d.cts

@@ -0,0 +1,32 @@
+import { IAccountState, IAssetFactoryState, IDecodedContext } from "@ocap/types";
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#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/lib/protocols/asset/pipes/verify-itx-assets.cjs

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let _ocap_util_lib_get_list_field = require("@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 ((0, _ocap_util_lib_get_list_field.getListField)(itx, "assets").length > assetStates.length) return next(new _ocap_util_lib_error.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 _ocap_util_lib_error.CustomError("INVALID_ASSET", "Input asset not minted from any of factory.input.assets"));
+		if (assetStates.every((x) => !x.consumedTime) === false) return next(new _ocap_util_lib_error.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 _ocap_util_lib_error.CustomError("INVALID_ASSET", `Input asset ${address} already consumed`));
+		} else if (!assetStates.find((x) => x.parent === address)) return next(new _ocap_util_lib_error.CustomError("INVALID_ASSET", `Input asset not found ${address}`));
+	}
+	return next();
+};
+var verify_itx_assets_default = verify_itx_assets;
+
+//#endregion
+exports.default = verify_itx_assets_default;