@ocap/tx-protocols 1.28.9 → 1.29.0

package/esm/protocols/account/delegate.mjs

@@ -0,0 +1,195 @@
+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 get from "lodash/get.js";
+import pick from "lodash/pick.js";
+import { toDelegateAddress } from "@arcblock/did-util";
+import { account, delegation } from "@ocap/state";
+import Debug from "debug";
+import { formatMessage } from "@ocap/message";
+import cloneDeep from "lodash/cloneDeep.js";
+import { Joi } from "@arcblock/validator";
+
+//#region src/protocols/account/delegate.ts
+const debug = Debug("@ocap/tx-protocols:delegate");
+const runner = new Runner("delegate");
+runner.use(pipes.VerifyMultiSig(0));
+const rateLimit = Joi.object({
+	interval: Joi.number().integer().greater(0).required(),
+	anchor: Joi.number().integer().min(0).optional().allow(null).default(0)
+});
+const tokenLimit = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_TOKEN").required(),
+	toList: Joi.array().items(Joi.DID().prefix()).max(32).unique().optional().allow(null).default([]),
+	txCount: Joi.number().integer().min(0).empty("").optional().allow(null).default(0),
+	txAllowance: Joi.BN().optional().allow(null).default("0"),
+	totalAllowance: Joi.BN().optional().allow(null).default("0"),
+	validUntil: Joi.number().integer().min(0).empty("").optional().allow(null).default(0),
+	rate: rateLimit.optional().allow(null)
+});
+const assetLimit = Joi.object({
+	address: Joi.array().items(Joi.DID().prefix().role("ROLE_ASSET")).unique().max(1024).optional().allow(null).default([]),
+	toList: Joi.array().items(Joi.DID().prefix()).unique().max(32).optional().allow(null).default([]),
+	txCount: Joi.number().integer().min(0).empty("").optional().allow(null).default(0),
+	validUntil: Joi.number().integer().min(0).empty("").optional().allow(null).default(0),
+	rate: rateLimit.optional().allow(null)
+});
+const schema = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_DELEGATION").required(),
+	to: Joi.DID().prefix().required(),
+	opsList: Joi.array().items(Joi.object({
+		typeUrl: Joi.string().required(),
+		limit: Joi.object({
+			tokensList: Joi.array().items(tokenLimit).unique((a, b) => a.address === b.address).max(32),
+			assetsList: Joi.array().items(assetLimit).max(32)
+		}).optional().allow(null).default({
+			tokensList: [],
+			assetsList: []
+		})
+	})).unique((a, b) => a.typeUrl === b.typeUrl).min(1).required(),
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use((context, next) => {
+	const { error, value } = schema.validate(context.itx);
+	if (error) return next(new CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	context.formattedItx = formatMessage("DelegateTx", context.itx);
+	context.validatedItx = value;
+	return next();
+});
+runner.use(pipes.VerifyInfo([{
+	error: "INVALID_TX",
+	message: "Delegation address does not match",
+	fn: (ctx) => {
+		const context = ctx;
+		return toDelegateAddress(context.tx.from, context.itx.to) === context.itx.address;
+	}
+}, {
+	error: "INVALID_DELEGATION_TYPE_URL",
+	message: "Delegation type url is not allowed",
+	fn: (ctx) => {
+		const context = ctx;
+		const allowed = get(context.config, "transaction.delegate.typeUrls", []);
+		return (context.formattedItx?.ops || []).every((op) => allowed.includes(op.typeUrl));
+	}
+}]));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.to",
+	to: "receiverState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.VerifyBlocked({ stateKeys: ["receiverState"] }));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "receiverState",
+	addressKey: "itx.to"
+}));
+runner.use(pipes.AntiLandAttack({
+	senderState: "senderState",
+	receiverState: "receiverState"
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.address",
+	to: "delegationState",
+	table: "delegation",
+	status: "OK"
+}));
+runner.use(ensure_gas_default((context) => {
+	const result = {
+		create: 0,
+		update: 1,
+		payment: 0
+	};
+	if (context.receiverState) result.update += 1;
+	else result.create += 1;
+	if (context.delegationState) result.update += 1;
+	else result.create += 1;
+	return result;
+}));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, itx, formattedItx, validatedItx, statedb, senderState, receiverState, delegationState, senderUpdates, updateVaults } = context;
+	const ops = formattedItx?.ops || [];
+	const opsList = validatedItx?.opsList || [];
+	const merged = cloneDeep(ops).reduce((acc, x, i) => {
+		const tokens = x.limit?.tokens || [];
+		const assets = x.limit?.assets || [];
+		acc[x.typeUrl] = { limit: {
+			tokens: tokens.map((y, j) => {
+				const input = opsList[i]?.limit?.tokensList?.[j] || {};
+				return Object.assign(y, pick(input, [
+					"txCount",
+					"txAllowance",
+					"totalAllowance",
+					"validUntil",
+					"rate"
+				]), {
+					txSent: 0,
+					lastTx: y.rate ? y.rate.anchor : 0,
+					spentAllowance: "0"
+				});
+			}),
+			assets: assets.map((y, j) => {
+				const input = opsList[i]?.limit?.assetsList?.[j] || {};
+				return Object.assign(y, pick(input, [
+					"txCount",
+					"validUntil",
+					"rate"
+				]), {
+					txSent: 0,
+					lastTx: y.rate ? y.rate.anchor : 0
+				});
+			})
+		} };
+		return acc;
+	}, delegationState ? delegationState.ops : {});
+	const sender = senderState ? senderState.address : tx$1.from;
+	const receiver = receiverState ? receiverState.address : itx.to;
+	const tokenAddress = context.config.token.address;
+	const [newSenderState, newReceiverState, newDelegationState] = await Promise.all([
+		statedb.account.updateOrCreate(senderState ?? null, account.updateOrCreate(senderState ?? null, {
+			...senderUpdates,
+			address: sender,
+			nonce: tx$1.nonce,
+			pk: tx$1.pk
+		}, context), context),
+		receiverState ? Promise.resolve(receiverState) : statedb.account.create(receiver, account.create({
+			address: receiver,
+			tokens: { [tokenAddress]: "0" }
+		}, context), context),
+		delegationState ? statedb.delegation.update(itx.address, delegation.update(delegationState, {
+			...itx,
+			from: sender,
+			ops: merged
+		}, context), context) : statedb.delegation.create(itx.address, delegation.create({
+			...itx,
+			from: sender,
+			ops: merged
+		}, context), context)
+	]);
+	if (updateVaults) await updateVaults();
+	debug(delegationState ? "update" : "create", newDelegationState);
+	context.senderState = newSenderState;
+	context.receiverState = newReceiverState;
+	context.delegationState = newDelegationState;
+	return next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var delegate_default = runner;
+
+//#endregion
+export { delegate_default as default };

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

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

package/esm/protocols/account/migrate.mjs

@@ -0,0 +1,130 @@
+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 { fromPublicKey, toTypeInfo } from "@arcblock/did";
+import { account } from "@ocap/state";
+import Debug from "debug";
+import { Joi } from "@arcblock/validator";
+import { types } from "@ocap/mcrypto";
+import { getRelatedAddresses } from "@ocap/util/lib/get-related-addr";
+import flatten from "lodash/flatten.js";
+import uniq from "lodash/uniq.js";
+
+//#region src/protocols/account/migrate.ts
+const { RoleType } = types;
+const debug = Debug("@ocap/tx-protocols:migrate");
+const runner = new Runner("account_migrate");
+runner.use(pipes.VerifyMultiSig(0));
+const schema = Joi.object({
+	address: Joi.DID().prefix().required(),
+	pk: Joi.any().required(),
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use((context, next) => {
+	const { error } = schema.validate(context.itx);
+	if (error) return next(new CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	return next();
+});
+runner.use(pipes.VerifyInfo([{
+	error: "INVALID_RECEIVER_STATE",
+	message: "Receiver pk and address does not match",
+	fn: (ctx) => {
+		const context = ctx;
+		return fromPublicKey(context.itx.pk, toTypeInfo(context.itx.address)) === context.itx.address && context.itx.address !== context.tx.from;
+	}
+}]));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(ensure_gas_default((context) => {
+	const { senderState, tx: tx$1, itx } = context;
+	if ([senderState?.address || tx$1.from, itx.address].every((address) => toTypeInfo(address).role === RoleType.ROLE_APPLICATION)) {
+		Object.defineProperty(context, "txBaseGas", { value: false });
+		return {
+			create: 0,
+			update: 0,
+			payment: 0
+		};
+	}
+	if (itx.data) {
+		const decodedValue = decodeAnySafe(itx.data)?.value;
+		if (decodedValue && decodedValue.purpose === "connect-wallet") {
+			Object.defineProperty(context, "txBaseGas", { value: false });
+			return {
+				create: 0,
+				update: 0,
+				payment: 0
+			};
+		}
+	}
+	return {
+		create: context.senderState ? 1 : 2,
+		update: context.senderState ? getRelatedAddresses(context.senderState).length : 0,
+		payment: 0
+	};
+}));
+runner.use(ensure_cost_default({
+	attachSenderChanges: true,
+	throwOnInsufficientFund: false
+}));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { statedb, tx: tx$1, itx, senderUpdates, updateVaults } = context;
+	const sender = context.senderState;
+	const receiver = await statedb.account.get(itx.address, context);
+	const tokenAddress = context.config.token.address;
+	const senderTokens = sender?.tokens || { [tokenAddress]: "0" };
+	const senderAddress = sender?.address || tx$1.from;
+	if (receiver) return next(new CustomError("INVALID_RECEIVER_STATE", "Can not migrate to an existing account"));
+	const newAccount = await statedb.account.create(itx.address, account.create({
+		...sender || { tokens: senderTokens },
+		...senderUpdates,
+		address: itx.address,
+		pk: itx.pk,
+		migratedFrom: sender ? uniq(flatten([sender.address, ...sender.migratedFrom || []])) : [senderAddress]
+	}, context), context);
+	debug("new account", newAccount);
+	const addresses = sender ? getRelatedAddresses(sender) : [senderAddress];
+	const states = await Promise.all(addresses.map(async (address) => {
+		let state;
+		if (address === senderAddress) {
+			state = account.updateOrCreate(sender ?? null, {
+				address,
+				tokens: senderTokens,
+				migratedTo: [itx.address],
+				nonce: tx$1.nonce
+			}, context);
+			await statedb.account.updateOrCreate(sender ?? null, state, context);
+		} else {
+			const old = await statedb.account.get(address, {
+				traceMigration: false,
+				txn: context.txn
+			});
+			state = account.update(old, { migratedTo: [itx.address] }, context);
+			await statedb.account.update(address, state, context);
+		}
+		return state;
+	}));
+	debug("old accounts", states);
+	if (updateVaults) await updateVaults();
+	context.receiverState = newAccount;
+	context.senderState = states.find((x) => x.address === senderAddress);
+	return next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var migrate_default = runner;
+
+//#endregion
+export { migrate_default as default };

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

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

package/esm/protocols/account/revoke-delegate.mjs

@@ -0,0 +1,102 @@
+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 get from "lodash/get.js";
+import { toDelegateAddress } from "@arcblock/did-util";
+import { account, delegation } from "@ocap/state";
+import Debug from "debug";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import cloneDeep from "lodash/cloneDeep.js";
+import { Joi } from "@arcblock/validator";
+
+//#region src/protocols/account/revoke-delegate.ts
+const debug = Debug("@ocap/tx-protocols:delegate");
+const runner = new Runner("revoke_delegate");
+runner.use(pipes.VerifyMultiSig(0));
+const schema = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_DELEGATION").required(),
+	to: Joi.DID().prefix().required(),
+	typeUrlsList: Joi.array().items(Joi.string().required()).min(1).required(),
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use((context, next) => {
+	const { error } = schema.validate(context.itx);
+	if (error) return next(new CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	return next();
+});
+runner.use(pipes.VerifyInfo([
+	{
+		error: "OK",
+		fn: (ctx) => {
+			const context = ctx;
+			context.typeUrls = getListField(context, "itx.typeUrls");
+			return true;
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Delegation address does not match",
+		fn: (ctx) => {
+			const context = ctx;
+			return toDelegateAddress(context.tx.from, context.itx.to) === context.itx.address;
+		}
+	},
+	{
+		error: "INVALID_DELEGATION_TYPE_URL",
+		message: "Delegation type url is not allowed",
+		fn: (ctx) => {
+			const context = ctx;
+			const allowed = get(context.config, "transaction.delegate.typeUrls", []);
+			return (context.typeUrls || []).every((x) => allowed.includes(x));
+		}
+	}
+]));
+runner.use(pipes.ExtractState({
+	from: "itx.address",
+	to: "delegationState",
+	status: "INVALID_DELEGATION",
+	table: "delegation"
+}));
+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(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, typeUrls, statedb, senderState, senderUpdates, delegationState, updateVaults } = context;
+	debug("update", {
+		address: itx.address,
+		typeUrls
+	});
+	const newOps = cloneDeep(delegationState.ops);
+	(typeUrls || []).forEach((x) => delete newOps[x]);
+	const [newSenderState, newDelegationState] = await Promise.all([statedb.account.update(senderState.address, account.update(senderState, {
+		...senderUpdates,
+		nonce: tx$1.nonce
+	}, context), context), statedb.delegation.update(itx.address, delegation.update(delegationState, { ops: newOps }, context), context)]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.delegationState = newDelegationState;
+	return next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var revoke_delegate_default = runner;
+
+//#endregion
+export { revoke_delegate_default as default };

package/esm/protocols/asset/acquire-v2.d.mts

@@ -0,0 +1,9 @@
+//#region src/protocols/asset/acquire-v2.d.ts
+/** Token input type */
+interface TokenInput {
+  address: string;
+  value: string;
+}
+declare const runner: any;
+//#endregion
+export { TokenInput, runner as default };

package/esm/protocols/asset/acquire-v2.mjs

@@ -0,0 +1,213 @@
+import { applyTokenChange, applyTokenUpdates } from "../../util.mjs";
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import exec_mint_hook_default from "./pipes/exec-mint-hook.mjs";
+import extract_factory_tokens_default from "./pipes/extract-factory-tokens.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, delegation, factory } from "@ocap/state";
+import Debug from "debug";
+import { Joi, schemas } from "@arcblock/validator";
+import { promisify } from "node:util";
+
+//#region src/protocols/asset/acquire-v2.ts
+const debug = Debug("@ocap/tx-protocols:acquire-asset-v2");
+const verifyTokenBalance = promisify(pipes.VerifyTokenBalance({
+	ownerKey: "senders",
+	conditionKey: "conditions"
+}));
+const runner = new Runner("acquire_asset_v2");
+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([]),
+	issuer: schemas.nftIssuer.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: "tx.delegator",
+	to: "delegatorState",
+	status: "OK"
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.factory",
+	to: "factoryState",
+	status: "INVALID_FACTORY_STATE",
+	table: "factory"
+}));
+runner.use(pipes.VerifyDelegation({
+	type: "signature",
+	signerKey: "senderState",
+	delegatorKey: "delegatorState",
+	getRequirements: (context) => {
+		return context.factoryState.input.tokens.map((x) => ({
+			type: "token",
+			...x
+		}));
+	}
+}));
+runner.use(pipes.ExtractState({
+	from: "factoryState.owner",
+	to: "factoryOwnerState",
+	status: "INVALID_OWNER_STATE",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "factoryState.trustedIssuers",
+	to: "issuerStates",
+	status: "INVALID_ISSUER_STATE",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.issuer.id",
+	to: "issuerState",
+	status: "INVALID_ISSUER_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "issuerState",
+	addressKey: "itx.issuer.id"
+}));
+runner.use(pipes.VerifyInfo([{
+	error: "FORBIDDEN",
+	message: "Only factory owner and trusted issuers are allowed",
+	fn: (ctx) => {
+		const { issuerState, factoryOwnerState, issuerStates = [] } = ctx;
+		return factoryOwnerState.address === issuerState.address || !!issuerStates.find((x) => x.address === issuerState.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(extract_factory_tokens_default);
+runner.use(pipes.ExtractState({
+	from: "tokenAddress",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(verify_mint_limit_default);
+runner.use(verify_itx_variables_default);
+runner.use(verify_itx_address_default("acquire-v2"));
+runner.use(pipes.VerifyBlocked({ stateKeys: ["assetOwner"] }));
+runner.use(async (context, next) => {
+	const { factoryTokens = [], senderState } = context;
+	const condition = {
+		owner: senderState.address,
+		tokens: [...factoryTokens]
+	};
+	try {
+		await verifyTokenBalance({
+			senders: [senderState],
+			conditions: [condition]
+		});
+		return next();
+	} catch (err) {
+		return next(err);
+	}
+});
+runner.use(pipes.VerifyUpdater({
+	assetKey: "assetStates",
+	ownerKey: "assetOwner"
+}));
+runner.use(verify_itx_assets_default);
+runner.use(ensure_gas_default((context) => {
+	const result = {
+		create: 1,
+		update: 3,
+		payment: 0
+	};
+	if (context.assetStates) result.update += context.assetStates.length;
+	if (context.delegatorState) result.update += 1;
+	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, assetOwner, factoryState, factoryTokens = [], delegationState, mintedAsset, mintedAddress, senderChange, updateVaults, assetStates = [] } = context;
+	const senderUpdates = {
+		nonce: tx$1.nonce,
+		pk: tx$1.pk,
+		...applyTokenUpdates(factoryTokens, senderChange ? applyTokenChange(senderState, senderChange) : senderState, "sub")
+	};
+	const ownerUpdates = {};
+	const factoryUpdates = { numMinted: factoryState.numMinted + 1 };
+	if (factoryState.settlement !== "instant") {
+		Object.assign(factoryUpdates, applyTokenUpdates(factoryTokens, factoryState, "add"));
+		context.tokenUpdates = applyTokenUpdates(factoryTokens, { tokens: {} }, "add");
+	}
+	const [newSenderState, assetState, newFactoryState, newAssetStates, newDelegationState] = await Promise.all([
+		statedb.account.update(senderState.address, account.update(senderState, senderUpdates, context), context),
+		statedb.asset.create(itx.address, asset.create({
+			...mintedAsset,
+			owner: assetOwner.address,
+			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))),
+		context.isDelegationChanged ? statedb.delegation.update(delegationState.address, delegation.update(delegationState, {}, context), context) : delegationState,
+		context.delegatorState ? statedb.account.update(assetOwner.address, account.update(assetOwner, ownerUpdates, context), context) : null
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.assetState = assetState;
+	context.factoryState = newFactoryState;
+	context.assetStates = newAssetStates;
+	context.delegationState = newDelegationState ?? void 0;
+	debug("acquire-v2", assetState);
+	next();
+}, { persistError: true });
+runner.use(exec_mint_hook_default, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var acquire_v2_default = runner;
+
+//#endregion
+export { acquire_v2_default as default };

package/esm/protocols/asset/acquire-v3.d.mts

@@ -0,0 +1,17 @@
+//#region src/protocols/asset/acquire-v3.d.ts
+/** Token input type */
+interface TokenInput {
+  address: string;
+  value: string;
+}
+/** Multi-input type */
+interface MultiInput {
+  owner: string;
+  tokensList?: TokenInput[];
+  tokens?: TokenInput[];
+  assetsList?: string[];
+  assets?: string[];
+}
+declare const runner: any;
+//#endregion
+export { MultiInput, TokenInput, runner as default };