@ocap/tx-protocols 1.28.9 → 1.29.0

package/lib/protocols/trade/transfer-v2.cjs

@@ -0,0 +1,229 @@
+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 _ocap_util = require("@ocap/util");
+let _ocap_message = require("@ocap/message");
+let _ocap_util_lib_get_list_field = require("@ocap/util/lib/get-list-field");
+let _arcblock_validator = require("@arcblock/validator");
+let lodash_isEmpty = require("lodash/isEmpty");
+lodash_isEmpty = require_rolldown_runtime.__toESM(lodash_isEmpty);
+
+//#region src/protocols/trade/transfer-v2.ts
+const runner = new _ocap_tx_pipeline.Runner("transfer_v2");
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSig(0));
+const schema = _arcblock_validator.Joi.object({
+	to: _arcblock_validator.schemas.tokenHolder.required(),
+	value: _arcblock_validator.Joi.any().optional().allow(null),
+	tokensList: _arcblock_validator.Joi.array().items(_arcblock_validator.schemas.tokenInput).default([]),
+	assetsList: _arcblock_validator.Joi.array().items(_arcblock_validator.Joi.DID().prefix().role("ROLE_ASSET")).default([]),
+	data: _arcblock_validator.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 _ocap_util_lib_error.CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	return next();
+});
+runner.use((context, next) => {
+	context.assets = (0, _ocap_util_lib_get_list_field.getListField)(context, "itx.assets");
+	context.tokens = (0, _ocap_util_lib_get_list_field.getListField)(context, "itx.tokens");
+	context.tokenAddress = (context.tokens || []).map((x) => x.address);
+	next();
+});
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "INSUFFICIENT_DATA",
+	message: "Can not transfer without any primary token or assets or secondary tokens",
+	fn: (ctx) => {
+		const { itx, assets, tokens } = ctx;
+		if (itx.to && (itx.value || (0, lodash_isEmpty.default)(assets) === false || (0, lodash_isEmpty.default)(tokens) === false)) return true;
+		return false;
+	}
+}, {
+	error: "INVALID_TX",
+	message: "Can not transfer primary token smaller than 0",
+	fn: (ctx) => {
+		const { itx, assets, tokens } = ctx;
+		if ((0, lodash_isEmpty.default)(tokens) && (0, lodash_isEmpty.default)(assets)) {
+			if (new _ocap_util.BN(itx.value ? (0, _ocap_message.decodeBigInt)(itx.value) : 0).lte(new _ocap_util.BN(0))) return false;
+		}
+		return true;
+	}
+}]));
+runner.use(_ocap_tx_pipeline.pipes.VerifyListSize({ listKey: ["assets", "tokens"] }));
+runner.use((context, next) => {
+	if (context.itx.value) {
+		const amount = new _ocap_util.BN((0, _ocap_message.decodeBigInt)(context.itx.value));
+		if (amount.gt(new _ocap_util.BN(0))) {
+			const tokens = context.tokens || [];
+			tokens.push({
+				address: context.config.token.address,
+				value: amount.toString()
+			});
+			context.tokens = tokens;
+			context.itx.value = void 0;
+		}
+	}
+	next();
+});
+runner.use(require_pipes_ensure_gas.default((context) => {
+	const result = {
+		create: 0,
+		update: 2,
+		payment: 0
+	};
+	result.update += context.assetStates?.length || 0;
+	if (context.receiverState) result.update += 1;
+	else result.create += 1;
+	return result;
+}));
+runner.use(async (context, next) => {
+	const { statedb, tx, gasVault } = context;
+	const accounts = [
+		tx.from,
+		context.receiver,
+		gasVault
+	].filter(Boolean);
+	await Promise.all([...accounts.map((x) => statedb.account.get(x, context)), statedb.stake.get((0, _arcblock_did_util.toStakeAddress)(tx.from, tx.from), context)]);
+	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: "tokenAddress",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use((context, next) => {
+	context.tokenConditions = {
+		owner: context.senderState.address,
+		tokens: context.tokens || []
+	};
+	next();
+});
+runner.use(_ocap_tx_pipeline.pipes.VerifyTokenBalance({
+	ownerKey: "senderState",
+	conditionKey: "tokenConditions"
+}));
+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: (ctx) => {
+		const context = ctx;
+		const tokens = context.tokens || [];
+		const assets = context.assets || [];
+		return [...tokens.map((x) => ({
+			type: "token",
+			address: x.address,
+			value: x.value,
+			to: context.itx.to
+		})), ...assets.map((x) => ({
+			type: "asset",
+			address: x,
+			to: context.itx.to
+		}))];
+	}
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractReceiver({
+	from: "itx.to",
+	to: "receiver"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "receiver",
+	to: "receiverState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.AntiLandAttack({
+	senderState: "senderState",
+	receiverState: "receiverState"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyBlocked({ stateKeys: ["senderState", "receiverState"] }));
+runner.use(_ocap_tx_pipeline.pipes.verifyTokenAccess({
+	statesKey: "tokenStates",
+	listFieldKey: "spenders",
+	accountKeys: ["senderState"],
+	errorMessage: "Account {address} is not allowed to transfer token {tokenAddress}"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "assets",
+	to: "assetStates",
+	status: "INVALID_ASSET",
+	table: "asset"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyTransferrable({ assets: "assetStates" }));
+runner.use(_ocap_tx_pipeline.pipes.VerifyUpdater({
+	assetKey: "assetStates",
+	ownerKey: "senderState"
+}));
+runner.use(require_pipes_ensure_cost.default({ attachSenderChanges: true }));
+runner.use((context, next) => {
+	const { itx, receiverState } = context;
+	context.receiverAddr = receiverState ? receiverState.address : itx.to;
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.UpdateOwner({
+	assets: "assetStates",
+	owner: "receiverAddr"
+}));
+runner.use(_ocap_tx_pipeline.pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx, tokens, senderState, receiverAddr, receiverState, statedb, senderChange, delegationState, updateVaults } = context;
+	const senderTokens = senderState?.tokens || {};
+	const receiverTokens = receiverState?.tokens || {};
+	for (const token of tokens || []) {
+		const delta = new _ocap_util.BN(token.value);
+		senderTokens[token.address] = new _ocap_util.BN(senderTokens[token.address]).sub(delta).toString();
+		receiverTokens[token.address] = new _ocap_util.BN(receiverTokens[token.address] || "0").add(delta).toString();
+	}
+	const senderUpdates = senderChange ? require_util.applyTokenChange({ tokens: senderTokens }, senderChange) : { tokens: senderTokens };
+	const [newSenderState, newReceiverState, newDelegationState] = await Promise.all([
+		statedb.account.update(senderState.address, _ocap_state.account.update(senderState, {
+			nonce: tx.nonce,
+			pk: tx.pk,
+			...senderUpdates
+		}, context), context),
+		statedb.account.updateOrCreate(receiverState ?? null, _ocap_state.account.updateOrCreate(receiverState ?? null, {
+			address: receiverAddr,
+			tokens: receiverTokens
+		}, context), context),
+		context.isDelegationChanged && delegationState ? statedb.delegation.update(delegationState.address, _ocap_state.delegation.update(delegationState, {}, context), context) : delegationState
+	]);
+	context.senderState = newSenderState;
+	context.receiverState = newReceiverState;
+	context.delegationState = newDelegationState;
+	if (updateVaults) await updateVaults();
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var transfer_v2_default = runner;
+
+//#endregion
+exports.default = transfer_v2_default;

package/lib/protocols/trade/transfer-v2.d.cts

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

package/lib/protocols/trade/transfer-v3.cjs

@@ -0,0 +1,274 @@
+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 _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 _ocap_util_lib_get_related_addr = require("@ocap/util/lib/get-related-addr");
+let node_util = require("node:util");
+let lodash_isEqual = require("lodash/isEqual");
+lodash_isEqual = require_rolldown_runtime.__toESM(lodash_isEqual);
+
+//#region src/protocols/trade/transfer-v3.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:transfer-v2");
+const runner = new _ocap_tx_pipeline.Runner("transfer_v3");
+const verifyAssetOwner = (0, node_util.promisify)(_ocap_tx_pipeline.pipes.VerifyUpdater({
+	assetKey: "assets",
+	ownerKey: "owner"
+}));
+const schema = _arcblock_validator.Joi.object({
+	inputsList: _arcblock_validator.schemas.multiInput.min(1).required(),
+	outputsList: _arcblock_validator.schemas.multiInput.min(1).required(),
+	data: _arcblock_validator.Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use(({ itx }, next) => {
+	const { error } = schema.validate(itx);
+	return next(error ? new _ocap_util_lib_error.CustomError("INVALID_TX", `Invalid itx: ${error.message}`) : void 0);
+});
+runner.use(_ocap_tx_pipeline.pipes.VerifyTxInput({
+	fieldKey: "itx.inputs",
+	inputsKey: "inputs",
+	sendersKey: "senders",
+	tokensKey: "inputTokens",
+	assetsKey: "inputAssets"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyTxInput({
+	fieldKey: "itx.outputs",
+	inputsKey: "outputs",
+	sendersKey: "receivers",
+	tokensKey: "outputTokens",
+	assetsKey: "outputAssets"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyListSize({ listKey: [
+	"inputs",
+	"outputs",
+	"senders",
+	"receivers",
+	"inputTokens",
+	"inputAssets",
+	"outputTokens",
+	"outputAssets"
+] }));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([
+	{
+		error: "INVALID_TX",
+		message: "An owner can not exist in tx input and output at the same time",
+		fn: (ctx) => {
+			const context = ctx;
+			return (context.senders || []).every((x) => (context.receivers || []).includes(x) === false);
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Input and output token address does not match",
+		fn: (ctx) => {
+			const context = ctx;
+			return (0, lodash_isEqual.default)(context.inputTokens || [], context.outputTokens || []);
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Input and output asset address does not match",
+		fn: (ctx) => {
+			const context = ctx;
+			return (0, lodash_isEqual.default)(context.inputAssets || [], context.outputAssets || []);
+		}
+	},
+	{
+		error: "INVALID_TX",
+		message: "Input and output token amount does not match",
+		fn: (ctx) => {
+			const context = ctx;
+			const inputs = context.inputs || [];
+			const outputs = context.outputs || [];
+			const inputTokens = context.inputTokens || [];
+			const inputMap = {};
+			const outputMap = {};
+			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));
+				});
+			});
+			outputs.forEach((output) => {
+				(0, _ocap_util_lib_get_list_field.getListField)(output, "tokens").forEach(({ address, value }) => {
+					if (typeof outputMap[address] === "undefined") outputMap[address] = new _ocap_util.BN(0);
+					outputMap[address] = outputMap[address].add(new _ocap_util.BN(value));
+				});
+			});
+			return inputTokens.every((address) => inputMap[address].eq(outputMap[address]));
+		}
+	}
+]));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "inputTokens",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use((context, next) => {
+	const { tx, inputTokens = [], tokenStates = [] } = context;
+	if (inputTokens.every((tokenAddress) => {
+		const tokenState = tokenStates.find((t) => t.address === tokenAddress);
+		return tokenState && tokenState.type === "CreditToken" && tokenState.issuer === tx.from;
+	})) return next();
+	return _ocap_tx_pipeline.pipes.VerifyMultiSigV2({ signersKey: "senders" })(context, next);
+});
+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: "receivers",
+	to: "receiverStates",
+	status: "OK",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyBlocked({ stateKeys: ["signerStates", "receiverStates"] }));
+runner.use(_ocap_tx_pipeline.pipes.AntiLandAttack({
+	senderState: "signerStates",
+	receiverState: "receiverStates"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyTokenBalance({
+	ownerKey: "signerStates",
+	conditionKey: "inputs"
+}));
+runner.use(_ocap_tx_pipeline.pipes.verifyTokenAccess({
+	statesKey: "tokenStates",
+	listFieldKey: "spenders",
+	accountKeys: ["senderState"],
+	errorMessage: "Account {address} is not allowed to transfer token {tokenAddress}"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "inputAssets",
+	to: "assetStates",
+	status: "INVALID_ASSET",
+	table: "asset"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyTransferrable({ assets: "assetStates" }));
+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(require_pipes_ensure_gas.default((context) => {
+	const ops = {
+		create: 0,
+		update: 0,
+		payment: 0
+	};
+	ops.update += (context.signerStates || []).length;
+	ops.update += (context.inputAssets || []).length;
+	(context.receivers || []).forEach((x) => {
+		if ((context.receiverStates || []).find((r) => r.address === x)) ops.update += 1;
+		else ops.create += 1;
+	});
+	if (context.senderState) ops.update += 1;
+	else ops.create += 1;
+	return ops;
+}));
+runner.use(require_pipes_ensure_cost.default({ attachSenderChanges: true }));
+runner.use(_ocap_tx_pipeline.pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx, inputs = [], outputs = [], receivers = [], senderState, signerStates = [], senderChange, updateVaults, receiverStates = [], assetStates = [], statedb } = context;
+	const signerUpdates = {};
+	inputs.forEach((x) => {
+		const { owner } = x;
+		signerUpdates[owner] = require_util.applyTokenUpdates((0, _ocap_util_lib_get_list_field.getListField)(x, "tokens"), signerStates.find((s) => s.address === owner), "sub");
+		if (senderChange && owner === senderChange.address) signerUpdates[owner] = require_util.applyTokenChange(signerUpdates[owner], senderChange);
+	});
+	const receiverUpdates = {};
+	const assetUpdates = {};
+	outputs.forEach((x) => {
+		const { owner } = x;
+		const tokensList = (0, _ocap_util_lib_get_list_field.getListField)(x, "tokens");
+		const assetsList = (0, _ocap_util_lib_get_list_field.getListField)(x, "assets");
+		const ownerState = receiverStates.find((s) => (0, _ocap_util_lib_get_related_addr.getRelatedAddresses)(s).includes(owner)) || { address: owner };
+		receiverUpdates[ownerState.address] = require_util.applyTokenUpdates(tokensList, ownerState, "add");
+		if (senderChange && ownerState.address === senderChange.address) receiverUpdates[ownerState.address] = require_util.applyTokenChange(receiverUpdates[ownerState.address], senderChange);
+		assetsList.forEach((address) => {
+			assetUpdates[address] = { owner: ownerState.address };
+		});
+	});
+	const sender = senderState ? senderState.address : tx.from;
+	const isAlsoSigner = !!signerUpdates[sender];
+	const isAlsoReceiver = !!receiverUpdates[sender];
+	const senderUpdatesLocal = {};
+	if (!isAlsoSigner && !isAlsoReceiver && senderState && senderChange) senderUpdatesLocal[sender] = require_util.applyTokenChange(senderState, senderChange);
+	debug$1("transfer-v3", {
+		signerUpdates,
+		receiverUpdates,
+		assetUpdates,
+		isAlsoSigner,
+		isAlsoReceiver
+	});
+	const [newSenderState, newSignerStates, newReceiverStates, newAssetStates] = await Promise.all([
+		statedb.account.updateOrCreate(senderState ?? null, _ocap_state.account.updateOrCreate(senderState ?? null, Object.assign({
+			address: sender,
+			nonce: tx.nonce,
+			pk: tx.pk
+		}, signerUpdates[sender] || {}, receiverUpdates[sender] || {}, senderUpdatesLocal[sender] || {}), context), context),
+		Promise.all(signerStates.filter((x) => x.address !== sender).map((x) => statedb.account.update(x.address, _ocap_state.account.update(x, signerUpdates[x.address], context), context))),
+		Promise.all(receivers.filter((x) => x !== sender).map((x) => {
+			const receiverState = receiverStates.find((s) => (0, _ocap_util_lib_get_related_addr.getRelatedAddresses)(s).includes(x));
+			const owner = receiverState ? receiverState.address : x;
+			const updates = receiverUpdates[owner] || {};
+			return statedb.account.updateOrCreate(receiverState ?? null, _ocap_state.account.updateOrCreate(receiverState ?? null, {
+				...updates,
+				address: owner
+			}, context), context);
+		})),
+		Promise.all(assetStates.map((x) => statedb.asset.update(x.address, _ocap_state.asset.update(x, assetUpdates[x.address], context), context)))
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.signerStates = isAlsoSigner ? newSignerStates.concat(newSenderState) : newSignerStates;
+	context.receiverStates = isAlsoReceiver ? newReceiverStates.concat(newSenderState) : newReceiverStates;
+	context.assetStates = newAssetStates;
+	debug$1("transfer-v3", {
+		inputs,
+		outputs
+	});
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var transfer_v3_default = runner;
+
+//#endregion
+exports.default = transfer_v3_default;

package/lib/protocols/trade/transfer-v3.d.cts

@@ -0,0 +1,17 @@
+//#region src/protocols/trade/transfer-v3.d.ts
+/** Token input type */
+interface TokenInput {
+  address: string;
+  value: string;
+}
+/** Multi-input type - uses List suffix in proto but runtime has both */
+interface MultiInput {
+  owner: string;
+  tokensList?: TokenInput[];
+  tokens?: TokenInput[];
+  assetsList?: string[];
+  assets?: string[];
+}
+declare const runner: any;
+//#endregion
+export { MultiInput, TokenInput, runner as default };