@ocap/tx-protocols 1.28.9 → 1.29.0

package/lib/protocols/asset/acquire-v2.cjs

@@ -0,0 +1,216 @@
+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');
+const require_protocols_asset_pipes_exec_mint_hook = require('./pipes/exec-mint-hook.cjs');
+const require_protocols_asset_pipes_extract_factory_tokens = require('./pipes/extract-factory-tokens.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");
+let node_util = require("node:util");
+
+//#region src/protocols/asset/acquire-v2.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:acquire-asset-v2");
+const verifyTokenBalance = (0, node_util.promisify)(_ocap_tx_pipeline.pipes.VerifyTokenBalance({
+	ownerKey: "senders",
+	conditionKey: "conditions"
+}));
+const runner = new _ocap_tx_pipeline.Runner("acquire_asset_v2");
+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([]),
+	issuer: _arcblock_validator.schemas.nftIssuer.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: "tx.delegator",
+	to: "delegatorState",
+	status: "OK"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.factory",
+	to: "factoryState",
+	status: "INVALID_FACTORY_STATE",
+	table: "factory"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyDelegation({
+	type: "signature",
+	signerKey: "senderState",
+	delegatorKey: "delegatorState",
+	getRequirements: (context) => {
+		return context.factoryState.input.tokens.map((x) => ({
+			type: "token",
+			...x
+		}));
+	}
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "factoryState.owner",
+	to: "factoryOwnerState",
+	status: "INVALID_OWNER_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.issuer.id",
+	to: "issuerState",
+	status: "INVALID_ISSUER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "issuerState",
+	addressKey: "itx.issuer.id"
+}));
+runner.use(_ocap_tx_pipeline.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(_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_extract_factory_tokens.default);
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tokenAddress",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+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("acquire-v2"));
+runner.use(_ocap_tx_pipeline.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(_ocap_tx_pipeline.pipes.VerifyUpdater({
+	assetKey: "assetStates",
+	ownerKey: "assetOwner"
+}));
+runner.use(require_protocols_asset_pipes_verify_itx_assets.default);
+runner.use(require_pipes_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(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, assetOwner, factoryState, factoryTokens = [], delegationState, mintedAsset, mintedAddress, senderChange, updateVaults, assetStates = [] } = context;
+	const senderUpdates = {
+		nonce: tx.nonce,
+		pk: tx.pk,
+		...require_util.applyTokenUpdates(factoryTokens, senderChange ? require_util.applyTokenChange(senderState, senderChange) : senderState, "sub")
+	};
+	const ownerUpdates = {};
+	const factoryUpdates = { numMinted: factoryState.numMinted + 1 };
+	if (factoryState.settlement !== "instant") {
+		Object.assign(factoryUpdates, require_util.applyTokenUpdates(factoryTokens, factoryState, "add"));
+		context.tokenUpdates = require_util.applyTokenUpdates(factoryTokens, { tokens: {} }, "add");
+	}
+	const [newSenderState, assetState, newFactoryState, newAssetStates, newDelegationState] = await Promise.all([
+		statedb.account.update(senderState.address, _ocap_state.account.update(senderState, senderUpdates, context), context),
+		statedb.asset.create(itx.address, _ocap_state.asset.create({
+			...mintedAsset,
+			owner: assetOwner.address,
+			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))),
+		context.isDelegationChanged ? statedb.delegation.update(delegationState.address, _ocap_state.delegation.update(delegationState, {}, context), context) : delegationState,
+		context.delegatorState ? statedb.account.update(assetOwner.address, _ocap_state.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$1("acquire-v2", assetState);
+	next();
+}, { persistError: true });
+runner.use(require_protocols_asset_pipes_exec_mint_hook.default, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var acquire_v2_default = runner;
+
+//#endregion
+exports.default = acquire_v2_default;

package/lib/protocols/asset/acquire-v2.d.cts

@@ -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/lib/protocols/asset/acquire-v3.cjs

@@ -0,0 +1,269 @@
+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');
+const require_protocols_asset_pipes_exec_mint_hook = require('./pipes/exec-mint-hook.cjs');
+const require_protocols_asset_pipes_extract_factory_tokens = require('./pipes/extract-factory-tokens.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 _ocap_util = require("@ocap/util");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let _ocap_util_lib_get_list_field = require("@ocap/util/lib/get-list-field");
+let _arcblock_validator = require("@arcblock/validator");
+let node_util = require("node:util");
+let lodash_isEqual = require("lodash/isEqual");
+lodash_isEqual = require_rolldown_runtime.__toESM(lodash_isEqual);
+
+//#region src/protocols/asset/acquire-v3.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:acquire-asset-v3");
+const verifyAssetOwner = (0, node_util.promisify)(_ocap_tx_pipeline.pipes.VerifyUpdater({
+	assetKey: "assets",
+	ownerKey: "owner"
+}));
+const runner = new _ocap_tx_pipeline.Runner("acquire_asset_v3");
+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(),
+	inputsList: _arcblock_validator.schemas.multiInput.min(1).required(),
+	owner: _arcblock_validator.schemas.tokenHolder.required(),
+	variablesList: _arcblock_validator.Joi.array().items(_arcblock_validator.schemas.variableInput).optional().allow(null).default([]),
+	issuer: _arcblock_validator.schemas.nftIssuer.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.VerifyTxInput({
+	fieldKey: "itx.inputs",
+	inputsKey: "inputs",
+	sendersKey: "senders",
+	tokensKey: "tokens",
+	assetsKey: "assets"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyListSize({ listKey: [
+	"inputs",
+	"senders",
+	"tokens",
+	"assets"
+] }));
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSigV2({ signersKey: "senders" }));
+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_OWNER_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.issuer.id",
+	to: "issuerState",
+	status: "INVALID_ISSUER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "issuerState",
+	addressKey: "itx.issuer.id"
+}));
+runner.use(_ocap_tx_pipeline.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(require_protocols_asset_pipes_extract_factory_tokens.default);
+runner.use(require_protocols_asset_pipes_verify_mint_limit.default);
+runner.use(require_protocols_asset_pipes_verify_itx_variables.default);
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "INVALID_TX",
+	message: "Input token address does not match with factory input requirement",
+	fn: (ctx) => {
+		const context = ctx;
+		return (0, lodash_isEqual.default)(context.tokens || [], context.tokenAddress || []);
+	}
+}, {
+	error: "INVALID_TX",
+	message: "Input token amount does not match with factory input requirement",
+	fn: (ctx) => {
+		const context = ctx;
+		const inputs = context.inputs || [];
+		const factoryTokens = context.factoryTokens || [];
+		const inputMap = {};
+		inputs.forEach((input) => {
+			(0, _ocap_util_lib_get_list_field.getListField)(input, "tokens").forEach(({ address, value }) => {
+				if (typeof inputMap[address] === "undefined") inputMap[address] = new _ocap_util.BN(0);
+				inputMap[address] = inputMap[address].add(new _ocap_util.BN(value));
+			});
+		});
+		const expectedTokens = factoryTokens.reduce((acc, x) => {
+			acc[x.address] = new _ocap_util.BN(x.value);
+			return acc;
+		}, {});
+		return Object.keys(expectedTokens).every((address) => inputMap[address].eq(expectedTokens[address]));
+	}
+}]));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "senders",
+	to: "signerStates",
+	status: "INVALID_SIGNER_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.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyBlocked({ stateKeys: ["signerStates", "ownerState"] }));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tokens",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyTokenBalance({
+	ownerKey: "signerStates",
+	conditionKey: "inputs"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "assets",
+	to: "assetStates",
+	status: "OK",
+	table: "asset"
+}));
+runner.use(async (context, next) => {
+	const { inputs = [], assetStates = [], signerStates = [] } = context;
+	for (const input of inputs) {
+		const { owner } = input;
+		const assetsList = (0, _ocap_util_lib_get_list_field.getListField)(input, "assets");
+		const states = assetStates.filter((x) => assetsList.includes(x.address));
+		const signer = signerStates.find((x) => x.address === owner);
+		try {
+			await verifyAssetOwner({
+				assets: states,
+				owner: signer
+			});
+		} catch (err) {
+			return next(err);
+		}
+	}
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "factoryState.input.assets",
+	to: "expectedFactoryStates",
+	status: "OK",
+	table: "factory"
+}));
+runner.use(require_protocols_asset_pipes_verify_itx_address.default("acquire-v3"));
+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.assetStates) result.update += context.assetStates.length;
+	if (context.signerStates) result.update += context.signerStates.length;
+	if (!context.ownerState) result.create += 1;
+	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, inputs = [], statedb, senderState, ownerState, factoryState, factoryTokens = [], mintedAsset, mintedAddress, signerStates = [], senderChange, updateVaults, assetStates = [] } = context;
+	const signerUpdates = {};
+	inputs.forEach((x) => {
+		const { owner: owner$1 } = x;
+		signerUpdates[owner$1] = require_util.applyTokenUpdates((0, _ocap_util_lib_get_list_field.getListField)(x, "tokens"), signerStates.find((s) => s.address === owner$1), "sub");
+		if (senderChange && owner$1 === senderChange.address) signerUpdates[owner$1] = require_util.applyTokenChange(signerUpdates[owner$1], senderChange);
+	});
+	const isAlsoSigner = !!signerUpdates[tx.from];
+	const owner = ownerState ? ownerState.address : itx.owner;
+	const factoryUpdates = { numMinted: factoryState.numMinted + 1 };
+	if (factoryState.settlement !== "instant") {
+		Object.assign(factoryUpdates, require_util.applyTokenUpdates(factoryTokens, factoryState, "add"));
+		context.tokenUpdates = require_util.applyTokenUpdates(factoryTokens, { tokens: {} }, "add");
+	}
+	const [newSenderState, newReceiverState, assetState, newSignerStates, newFactoryState, newAssetStates] = await Promise.all([
+		statedb.account.updateOrCreate(senderState ?? null, _ocap_state.account.updateOrCreate(senderState ?? null, Object.assign({
+			address: tx.from,
+			nonce: tx.nonce,
+			pk: tx.pk
+		}, signerUpdates[tx.from] || (senderChange ? require_util.applyTokenChange(senderState, senderChange) : {})), context), context),
+		ownerState || owner === tx.from ? Promise.resolve(ownerState) : statedb.account.create(owner, _ocap_state.account.create({ address: owner }, context), context),
+		statedb.asset.create(itx.address, _ocap_state.asset.create({
+			...mintedAsset,
+			owner,
+			address: mintedAddress
+		}, context), context),
+		Promise.all(signerStates.filter((x) => x.address !== tx.from).map((x) => statedb.account.update(x.address, _ocap_state.account.update(x, signerUpdates[x.address], 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 = owner === tx.from ? newSenderState : newReceiverState ?? void 0;
+	context.signerStates = isAlsoSigner ? newSignerStates.concat(newSenderState) : newSignerStates;
+	context.assetState = assetState;
+	context.factoryState = newFactoryState;
+	context.assetStates = newAssetStates;
+	debug$1("acquire-v3", assetState);
+	next();
+}, { persistError: true });
+runner.use(require_protocols_asset_pipes_exec_mint_hook.default, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var acquire_v3_default = runner;
+
+//#endregion
+exports.default = acquire_v3_default;

package/lib/protocols/asset/acquire-v3.d.cts

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

package/lib/protocols/asset/calls/transfer-token.cjs

@@ -0,0 +1,40 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _ocap_tx_pipeline = require("@ocap/tx-pipeline");
+let _ocap_util = require("@ocap/util");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let lodash_cloneDeep = require("lodash/cloneDeep");
+lodash_cloneDeep = require_rolldown_runtime.__toESM(lodash_cloneDeep);
+
+//#region src/protocols/asset/calls/transfer-token.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:acquire-asset:transfer-token");
+const runner = new _ocap_tx_pipeline.Runner("transfer_token_call");
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "args.to",
+	to: "receiverState",
+	status: "INVALID_RECEIVER_STATE"
+}));
+runner.use((context, next) => {
+	const { receiverState, args } = context;
+	const receiver = receiverState;
+	const transferArgs = args;
+	const statesAny = context.states;
+	const { tokenAddress, amount } = transferArgs;
+	const delta = new _ocap_util.BN(amount);
+	const newTokens = (0, lodash_cloneDeep.default)(receiver.tokens || {});
+	if (newTokens[tokenAddress]) newTokens[tokenAddress] = new _ocap_util.BN(newTokens[tokenAddress]).add(delta).toString();
+	else newTokens[tokenAddress] = delta.toString();
+	context.updateSet = {
+		address: receiver.address,
+		updates: statesAny.account.update(receiver, { tokens: newTokens }, context),
+		delta: amount,
+		token: tokenAddress
+	};
+	debug$1("contract.transfer-token", context.updateSet);
+	next();
+});
+var transfer_token_default = runner;
+
+//#endregion
+exports.default = transfer_token_default;

package/lib/protocols/asset/calls/transfer-token.d.cts

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

package/lib/protocols/asset/calls/transfer.cjs

@@ -0,0 +1,35 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _ocap_tx_pipeline = require("@ocap/tx-pipeline");
+let _ocap_util = require("@ocap/util");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+
+//#region src/protocols/asset/calls/transfer.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:acquire-asset:transfer");
+const runner = new _ocap_tx_pipeline.Runner("transfer_call");
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "args.to",
+	to: "receiverState",
+	status: "INVALID_RECEIVER_STATE"
+}));
+runner.use((context, next) => {
+	const { receiverState, args } = context;
+	const receiver = receiverState;
+	const transferArgs = args;
+	const statesAny = context.states;
+	const old = new _ocap_util.BN(receiver.balance);
+	const delta = new _ocap_util.BN(transferArgs.amount);
+	context.updateSet = {
+		address: receiver.address,
+		updates: statesAny.account.update(receiver, { balance: old.add(delta).toString() }, context),
+		delta: transferArgs.amount,
+		token: ""
+	};
+	debug$1("contract.transfer", context.updateSet);
+	next();
+});
+var transfer_default = runner;
+
+//#endregion
+exports.default = transfer_default;

package/lib/protocols/asset/calls/transfer.d.cts

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