@ocap/tx-protocols 1.28.9 → 1.29.0

package/esm/protocols/trade/exchange-v2.mjs

@@ -0,0 +1,239 @@
+import { applyTokenChange } from "../../util.mjs";
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { account } from "@ocap/state";
+import { BN } from "@ocap/util";
+import Debug from "debug";
+import { decodeBigInt } from "@ocap/message";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import { Joi, schemas } from "@arcblock/validator";
+import { createSortedList } from "@ocap/util/lib/create-sorted-list";
+import isEmpty from "lodash/isEmpty.js";
+
+//#region src/protocols/trade/exchange-v2.ts
+const debug = Debug("@ocap/tx-protocols:exchange-v2");
+const runner = new Runner("exchange_v2");
+const exchangeInfoSchema = Joi.object({
+	value: Joi.any().optional().allow(null),
+	tokensList: Joi.array().items(schemas.tokenInput).default([]),
+	assetsList: Joi.array().items(Joi.DID().prefix().role("ROLE_ASSET")).default([])
+});
+const schema = Joi.object({
+	to: schemas.tokenHolder.required(),
+	sender: exchangeInfoSchema.required(),
+	receiver: exchangeInfoSchema.required(),
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use(({ itx }, next) => {
+	const { error } = schema.validate(itx);
+	return next(error ? new CustomError("INVALID_TX", `Invalid itx: ${error.message}`) : void 0);
+});
+runner.use(pipes.VerifyMultiSig(1));
+runner.use(pipes.ExtractReceiver({ from: [
+	"tx.signaturesList",
+	"tx.signatures",
+	"itx.to"
+] }));
+runner.use(pipes.VerifyInfo([{
+	error: "INVALID_TX",
+	message: "Can not exchange without any token or assets",
+	fn: (ctx) => {
+		const context = ctx;
+		const zero = new BN(0);
+		const { itx, config } = context;
+		context.senderAssets = getListField(itx, "sender.assets");
+		context.receiverAssets = getListField(itx, "receiver.assets");
+		const senderTokensLocal = getListField(itx, "sender.tokens");
+		const receiverTokensLocal = getListField(itx, "receiver.tokens");
+		const senderValue = itx.sender?.value;
+		const senderAmount = senderValue ? decodeBigInt(senderValue) : 0;
+		if (new BN(senderAmount).gt(zero)) {
+			senderTokensLocal.push({
+				address: config.token.address,
+				value: senderAmount
+			});
+			itx.sender.value = "0";
+		}
+		const receiverValue = itx.receiver?.value;
+		const receiverAmount = receiverValue ? decodeBigInt(receiverValue) : 0;
+		if (new BN(receiverAmount).gt(zero)) {
+			receiverTokensLocal.push({
+				address: config.token.address,
+				value: receiverAmount
+			});
+			itx.receiver.value = "0";
+		}
+		context.senderTokens = senderTokensLocal;
+		context.receiverTokens = receiverTokensLocal;
+		context.tokenAddress = createSortedList((context.senderTokens || []).concat(context.receiverTokens || []).map((x) => x.address));
+		if (isEmpty(context.senderAssets) && isEmpty(context.senderTokens)) return false;
+		if (isEmpty(context.receiverAssets) && isEmpty(context.receiverTokens)) return false;
+		return true;
+	}
+}]));
+runner.use(pipes.VerifySigner({ signer: "itx.to" }));
+runner.use(pipes.VerifyListSize({ listKey: ["senderAssets", "receiverAssets"] }));
+runner.use(pipes.VerifyListSize({ listKey: ["senderTokens", "receiverTokens"] }));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "INVALID_SENDER_STATE",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "tx.delegator",
+	to: "delegatorState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.VerifyDelegation({
+	type: "signature",
+	signerKey: "senderState",
+	delegatorKey: "delegatorState"
+}));
+runner.use(pipes.ExtractSigner({
+	signerKey: "signerStates",
+	delegatorKey: "delegatorStates"
+}));
+runner.use(pipes.VerifyDelegation({
+	type: "multisig",
+	signerKey: "signerStates",
+	delegatorKey: "delegatorStates",
+	delegationKey: "delegationStates",
+	getRequirements: () => []
+}));
+runner.use(pipes.ExtractState({
+	from: "tokenAddress",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(pipes.ExtractState({
+	from: "receiver",
+	to: "receiverState",
+	status: "INVALID_RECEIVER_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use((context, next) => {
+	context.senderTokenConditions = {
+		owner: context.senderState.address,
+		tokens: context.senderTokens || []
+	};
+	context.receiverTokenConditions = {
+		owner: context.receiverState.address,
+		tokens: context.receiverTokens || []
+	};
+	next();
+});
+runner.use(pipes.VerifyTokenBalance({
+	ownerKey: "senderState",
+	conditionKey: "senderTokenConditions"
+}));
+runner.use(pipes.VerifyTokenBalance({
+	ownerKey: "receiverState",
+	conditionKey: "receiverTokenConditions"
+}));
+runner.use(pipes.AntiLandAttack({
+	senderState: "senderState",
+	receiverState: "receiverState"
+}));
+runner.use(pipes.VerifyBlocked({ stateKeys: ["senderState", "receiverState"] }));
+runner.use(pipes.verifyTokenAccess({
+	statesKey: "tokenStates",
+	listFieldKey: "spenders",
+	accountKeys: ["senderState"],
+	errorMessage: "Account {address} is not allowed to exchange token {tokenAddress}"
+}));
+runner.use(pipes.ExtractState({
+	from: "senderAssets",
+	to: "priv.senderAssets",
+	status: "INVALID_ASSET",
+	table: "asset"
+}));
+runner.use(pipes.VerifyTransferrable({ assets: "priv.senderAssets" }));
+runner.use(pipes.VerifyUpdater({
+	assetKey: "priv.senderAssets",
+	ownerKey: "senderState"
+}));
+runner.use(pipes.ExtractState({
+	from: "receiverAssets",
+	to: "priv.receiverAssets",
+	status: "INVALID_ASSET",
+	table: "asset"
+}));
+runner.use(pipes.VerifyTransferrable({ assets: "priv.receiverAssets" }));
+runner.use(pipes.VerifyUpdater({
+	assetKey: "priv.receiverAssets",
+	ownerKey: "receiverState"
+}));
+runner.use(ensure_gas_default((context) => {
+	const ops = {
+		create: 0,
+		update: 3,
+		payment: 0
+	};
+	ops.update += (context.senderAssets || []).length;
+	ops.update += (context.receiverAssets || []).length;
+	return ops;
+}));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.UpdateOwner({
+	assets: "priv.senderAssets",
+	owner: "receiverState"
+}));
+runner.use(pipes.UpdateOwner({
+	assets: "priv.receiverAssets",
+	owner: "senderState"
+}));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, itx, senderAssets = [], receiverAssets = [], senderTokens = [], receiverTokens = [], senderState, receiverState, senderChange, updateVaults, statedb } = context;
+	const senderStateTokens = senderState?.tokens || {};
+	const receiverStateTokens = receiverState?.tokens || {};
+	for (const { address, value } of senderTokens) {
+		const delta = new BN(value);
+		senderStateTokens[address] = new BN(senderStateTokens[address]).sub(delta).toString();
+		receiverStateTokens[address] = new BN(receiverStateTokens[address] || "0").add(delta).toString();
+	}
+	for (const { address, value } of receiverTokens) {
+		const delta = new BN(value);
+		senderStateTokens[address] = new BN(senderStateTokens[address]).add(delta).toString();
+		receiverStateTokens[address] = new BN(receiverStateTokens[address] || "0").sub(delta).toString();
+	}
+	const senderUpdates = senderChange ? applyTokenChange({ tokens: senderStateTokens }, senderChange) : { tokens: senderStateTokens };
+	const [newSenderState, newReceiverState] = await Promise.all([statedb.account.update(senderState.address, account.update(senderState, {
+		nonce: tx$1.nonce,
+		...senderUpdates
+	}, context), context), statedb.account.update(receiverState.address, account.update(receiverState, { tokens: receiverStateTokens }, context), context)]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.receiverState = newReceiverState;
+	debug("exchange", {
+		from: tx$1.from,
+		to: itx.to,
+		sender: {
+			assets: senderAssets.length,
+			token: senderTokens.length
+		},
+		receiver: {
+			assets: receiverAssets.length,
+			token: receiverTokens.length
+		}
+	});
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var exchange_v2_default = runner;
+
+//#endregion
+export { exchange_v2_default as default };

package/esm/protocols/trade/transfer-v2.d.mts

@@ -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/esm/protocols/trade/transfer-v2.mjs

@@ -0,0 +1,226 @@
+import { applyTokenChange } 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 { toStakeAddress } from "@arcblock/did-util";
+import { account, delegation } from "@ocap/state";
+import { BN } from "@ocap/util";
+import { decodeBigInt } from "@ocap/message";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import { Joi, schemas } from "@arcblock/validator";
+import isEmpty from "lodash/isEmpty.js";
+
+//#region src/protocols/trade/transfer-v2.ts
+const runner = new Runner("transfer_v2");
+runner.use(pipes.VerifyMultiSig(0));
+const schema = Joi.object({
+	to: schemas.tokenHolder.required(),
+	value: Joi.any().optional().allow(null),
+	tokensList: Joi.array().items(schemas.tokenInput).default([]),
+	assetsList: Joi.array().items(Joi.DID().prefix().role("ROLE_ASSET")).default([]),
+	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((context, next) => {
+	context.assets = getListField(context, "itx.assets");
+	context.tokens = getListField(context, "itx.tokens");
+	context.tokenAddress = (context.tokens || []).map((x) => x.address);
+	next();
+});
+runner.use(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 || isEmpty(assets) === false || isEmpty(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 (isEmpty(tokens) && isEmpty(assets)) {
+			if (new BN(itx.value ? decodeBigInt(itx.value) : 0).lte(new BN(0))) return false;
+		}
+		return true;
+	}
+}]));
+runner.use(pipes.VerifyListSize({ listKey: ["assets", "tokens"] }));
+runner.use((context, next) => {
+	if (context.itx.value) {
+		const amount = new BN(decodeBigInt(context.itx.value));
+		if (amount.gt(new 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(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: tx$1, gasVault } = context;
+	const accounts = [
+		tx$1.from,
+		context.receiver,
+		gasVault
+	].filter(Boolean);
+	await Promise.all([...accounts.map((x) => statedb.account.get(x, context)), statedb.stake.get(toStakeAddress(tx$1.from, tx$1.from), context)]);
+	next();
+});
+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: "tokenAddress",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use((context, next) => {
+	context.tokenConditions = {
+		owner: context.senderState.address,
+		tokens: context.tokens || []
+	};
+	next();
+});
+runner.use(pipes.VerifyTokenBalance({
+	ownerKey: "senderState",
+	conditionKey: "tokenConditions"
+}));
+runner.use(pipes.ExtractState({
+	from: "tx.delegator",
+	to: "delegatorState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "delegatorState",
+	addressKey: "tx.delegator"
+}));
+runner.use(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(pipes.ExtractReceiver({
+	from: "itx.to",
+	to: "receiver"
+}));
+runner.use(pipes.ExtractState({
+	from: "receiver",
+	to: "receiverState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.AntiLandAttack({
+	senderState: "senderState",
+	receiverState: "receiverState"
+}));
+runner.use(pipes.VerifyBlocked({ stateKeys: ["senderState", "receiverState"] }));
+runner.use(pipes.verifyTokenAccess({
+	statesKey: "tokenStates",
+	listFieldKey: "spenders",
+	accountKeys: ["senderState"],
+	errorMessage: "Account {address} is not allowed to transfer token {tokenAddress}"
+}));
+runner.use(pipes.ExtractState({
+	from: "assets",
+	to: "assetStates",
+	status: "INVALID_ASSET",
+	table: "asset"
+}));
+runner.use(pipes.VerifyTransferrable({ assets: "assetStates" }));
+runner.use(pipes.VerifyUpdater({
+	assetKey: "assetStates",
+	ownerKey: "senderState"
+}));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use((context, next) => {
+	const { itx, receiverState } = context;
+	context.receiverAddr = receiverState ? receiverState.address : itx.to;
+	return next();
+});
+runner.use(pipes.UpdateOwner({
+	assets: "assetStates",
+	owner: "receiverAddr"
+}));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, tokens, senderState, receiverAddr, receiverState, statedb, senderChange, delegationState, updateVaults } = context;
+	const senderTokens = senderState?.tokens || {};
+	const receiverTokens = receiverState?.tokens || {};
+	for (const token$1 of tokens || []) {
+		const delta = new BN(token$1.value);
+		senderTokens[token$1.address] = new BN(senderTokens[token$1.address]).sub(delta).toString();
+		receiverTokens[token$1.address] = new BN(receiverTokens[token$1.address] || "0").add(delta).toString();
+	}
+	const senderUpdates = senderChange ? applyTokenChange({ tokens: senderTokens }, senderChange) : { tokens: senderTokens };
+	const [newSenderState, newReceiverState, newDelegationState] = await Promise.all([
+		statedb.account.update(senderState.address, account.update(senderState, {
+			nonce: tx$1.nonce,
+			pk: tx$1.pk,
+			...senderUpdates
+		}, context), context),
+		statedb.account.updateOrCreate(receiverState ?? null, account.updateOrCreate(receiverState ?? null, {
+			address: receiverAddr,
+			tokens: receiverTokens
+		}, context), context),
+		context.isDelegationChanged && delegationState ? statedb.delegation.update(delegationState.address, delegation.update(delegationState, {}, context), context) : delegationState
+	]);
+	context.senderState = newSenderState;
+	context.receiverState = newReceiverState;
+	context.delegationState = newDelegationState;
+	if (updateVaults) await updateVaults();
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var transfer_v2_default = runner;
+
+//#endregion
+export { transfer_v2_default as default };

package/esm/protocols/trade/transfer-v3.d.mts

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