@ocap/tx-protocols 1.28.9 → 1.29.1

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

@@ -0,0 +1,265 @@
+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, factory } from "@ocap/state";
+import { BN } from "@ocap/util";
+import Debug from "debug";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import { Joi, schemas } from "@arcblock/validator";
+import { promisify } from "node:util";
+import isEqual from "lodash/isEqual.js";
+
+//#region src/protocols/asset/acquire-v3.ts
+const debug = Debug("@ocap/tx-protocols:acquire-asset-v3");
+const verifyAssetOwner = promisify(pipes.VerifyUpdater({
+	assetKey: "assets",
+	ownerKey: "owner"
+}));
+const runner = new Runner("acquire_asset_v3");
+const schema = Joi.object({
+	factory: Joi.DID().prefix().role("ROLE_FACTORY").required(),
+	address: Joi.DID().prefix().role("ROLE_ASSET").required(),
+	inputsList: schemas.multiInput.min(1).required(),
+	owner: schemas.tokenHolder.required(),
+	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.VerifyTxInput({
+	fieldKey: "itx.inputs",
+	inputsKey: "inputs",
+	sendersKey: "senders",
+	tokensKey: "tokens",
+	assetsKey: "assets"
+}));
+runner.use(pipes.VerifyListSize({ listKey: [
+	"inputs",
+	"senders",
+	"tokens",
+	"assets"
+] }));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: "senders" }));
+runner.use(pipes.ExtractState({
+	from: "itx.factory",
+	to: "factoryState",
+	status: "INVALID_FACTORY_STATE",
+	table: "factory"
+}));
+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(extract_factory_tokens_default);
+runner.use(verify_mint_limit_default);
+runner.use(verify_itx_variables_default);
+runner.use(pipes.VerifyInfo([{
+	error: "INVALID_TX",
+	message: "Input token address does not match with factory input requirement",
+	fn: (ctx) => {
+		const context = ctx;
+		return isEqual(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) => {
+			getListField(input, "tokens").forEach(({ address, value }) => {
+				if (typeof inputMap[address] === "undefined") inputMap[address] = new BN(0);
+				inputMap[address] = inputMap[address].add(new BN(value));
+			});
+		});
+		const expectedTokens = factoryTokens.reduce((acc, x) => {
+			acc[x.address] = new BN(x.value);
+			return acc;
+		}, {});
+		return Object.keys(expectedTokens).every((address) => inputMap[address].eq(expectedTokens[address]));
+	}
+}]));
+runner.use(pipes.ExtractState({
+	from: "tx.from",
+	to: "senderState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "senders",
+	to: "signerStates",
+	status: "INVALID_SIGNER_STATE",
+	table: "account"
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.owner",
+	to: "ownerState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}));
+runner.use(pipes.VerifyBlocked({ stateKeys: ["signerStates", "ownerState"] }));
+runner.use(pipes.ExtractState({
+	from: "tokens",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(pipes.VerifyTokenBalance({
+	ownerKey: "signerStates",
+	conditionKey: "inputs"
+}));
+runner.use(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 = 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(pipes.ExtractState({
+	from: "factoryState.input.assets",
+	to: "expectedFactoryStates",
+	status: "OK",
+	table: "factory"
+}));
+runner.use(verify_itx_address_default("acquire-v3"));
+runner.use(verify_itx_assets_default);
+runner.use(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(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, 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] = applyTokenUpdates(getListField(x, "tokens"), signerStates.find((s) => s.address === owner$1), "sub");
+		if (senderChange && owner$1 === senderChange.address) signerUpdates[owner$1] = applyTokenChange(signerUpdates[owner$1], senderChange);
+	});
+	const isAlsoSigner = !!signerUpdates[tx$1.from];
+	const owner = ownerState ? ownerState.address : itx.owner;
+	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, newReceiverState, assetState, newSignerStates, newFactoryState, newAssetStates] = await Promise.all([
+		statedb.account.updateOrCreate(senderState ?? null, account.updateOrCreate(senderState ?? null, Object.assign({
+			address: tx$1.from,
+			nonce: tx$1.nonce,
+			pk: tx$1.pk
+		}, signerUpdates[tx$1.from] || (senderChange ? applyTokenChange(senderState, senderChange) : {})), context), context),
+		ownerState || owner === tx$1.from ? Promise.resolve(ownerState) : statedb.account.create(owner, account.create({ address: owner }, context), context),
+		statedb.asset.create(itx.address, asset.create({
+			...mintedAsset,
+			owner,
+			address: mintedAddress
+		}, context), context),
+		Promise.all(signerStates.filter((x) => x.address !== tx$1.from).map((x) => statedb.account.update(x.address, account.update(x, signerUpdates[x.address], 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)))
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.receiverState = owner === tx$1.from ? newSenderState : newReceiverState ?? void 0;
+	context.signerStates = isAlsoSigner ? newSignerStates.concat(newSenderState) : newSignerStates;
+	context.assetState = assetState;
+	context.factoryState = newFactoryState;
+	context.assetStates = newAssetStates;
+	debug("acquire-v3", assetState);
+	next();
+}, { persistError: true });
+runner.use(exec_mint_hook_default, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var acquire_v3_default = runner;
+
+//#endregion
+export { acquire_v3_default as default };

package/esm/protocols/asset/calls/transfer-token.d.mts

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

package/esm/protocols/asset/calls/transfer-token.mjs

@@ -0,0 +1,36 @@
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { BN } from "@ocap/util";
+import Debug from "debug";
+import cloneDeep from "lodash/cloneDeep.js";
+
+//#region src/protocols/asset/calls/transfer-token.ts
+const debug = Debug("@ocap/tx-protocols:acquire-asset:transfer-token");
+const runner = new Runner("transfer_token_call");
+runner.use(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 BN(amount);
+	const newTokens = cloneDeep(receiver.tokens || {});
+	if (newTokens[tokenAddress]) newTokens[tokenAddress] = new 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("contract.transfer-token", context.updateSet);
+	next();
+});
+var transfer_token_default = runner;
+
+//#endregion
+export { transfer_token_default as default };

package/esm/protocols/asset/calls/transfer.d.mts

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

package/esm/protocols/asset/calls/transfer.mjs

@@ -0,0 +1,32 @@
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { BN } from "@ocap/util";
+import Debug from "debug";
+
+//#region src/protocols/asset/calls/transfer.ts
+const debug = Debug("@ocap/tx-protocols:acquire-asset:transfer");
+const runner = new Runner("transfer_call");
+runner.use(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 BN(receiver.balance);
+	const delta = new BN(transferArgs.amount);
+	context.updateSet = {
+		address: receiver.address,
+		updates: statesAny.account.update(receiver, { balance: old.add(delta).toString() }, context),
+		delta: transferArgs.amount,
+		token: ""
+	};
+	debug("contract.transfer", context.updateSet);
+	next();
+});
+var transfer_default = runner;
+
+//#endregion
+export { transfer_default as default };

package/esm/protocols/asset/consume.d.mts

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

package/esm/protocols/asset/consume.mjs

@@ -0,0 +1,92 @@
+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, asset } from "@ocap/state";
+import Debug from "debug";
+import { Joi } from "@arcblock/validator";
+
+//#region src/protocols/asset/consume.ts
+const debug = Debug("@ocap/tx-protocols:consume-asset");
+const runner = new Runner("consume_asset");
+const schema = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_ASSET").required(),
+	data: 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 CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	return next();
+});
+runner.use(pipes.ExtractState({
+	from: "itx.address",
+	to: "assetState",
+	status: "INVALID_ASSET",
+	table: "asset"
+}));
+runner.use((context, next) => {
+	const { assetState } = context;
+	if (!assetState) return next(new CustomError("INVALID_TX", "Asset state not found"));
+	const { issuer, consumedTime } = assetState;
+	if (!issuer) return next(new CustomError("INVALID_TX", "Asset without issuer can not be consumed"));
+	if (consumedTime) return next(new CustomError("INVALID_TX", `Asset already consumed on ${consumedTime}`));
+	return 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: "assetState.issuer",
+	to: "issuerState",
+	status: "INVALID_ISSUER_STATE",
+	table: "account"
+}));
+runner.use(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(pipes.VerifyMultiSigV2({ signersKey: "signers" }));
+runner.use(pipes.VerifyAccountMigration({ signerKey: "signerStates" }));
+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, txTime, statedb, senderState, senderUpdates, assetState, updateVaults } = context;
+	const [newSenderState, newAssetState] = await Promise.all([statedb.account.update(senderState.address, account.update(senderState, {
+		nonce: tx$1.nonce,
+		pk: tx$1.pk,
+		...senderUpdates
+	}, context), context), statedb.asset.update(itx.address, asset.update(assetState, { consumedTime: txTime }, context), context)]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.assetState = newAssetState;
+	debug("consume", newAssetState);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var consume_default = runner;
+
+//#endregion
+export { consume_default as default };

package/esm/protocols/asset/create.d.mts

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

package/esm/protocols/asset/create.mjs

@@ -0,0 +1,136 @@
+import { decodeAnySafe, getDelegationRequirements } 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 { toAssetAddress } from "@arcblock/did-util";
+import { account, asset, delegation } from "@ocap/state";
+import Debug from "debug";
+import { formatMessage } from "@ocap/message";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import cloneDeep from "lodash/cloneDeep.js";
+
+//#region src/protocols/asset/create.ts
+const debug = Debug("@ocap/tx-protocols:create-asset");
+const runner = new Runner("create_asset");
+runner.use((context, next) => {
+	const itx = formatMessage("CreateAssetTx", context.itx);
+	const { error } = asset.schema.validate(itx);
+	if (error) return next(new CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	return next();
+});
+runner.use(pipes.VerifyInfo([{
+	error: "INVALID_ASSET",
+	message: "Asset address is not valid",
+	fn: (ctx) => {
+		const context = ctx;
+		const itx = cloneDeep(context.itx);
+		const decodedData = decodeAnySafe(itx.data ?? null);
+		itx.data = decodedData;
+		itx.address = "";
+		context.assetData = decodedData;
+		context.signers = [itx.issuer].filter(Boolean);
+		return toAssetAddress(itx) === context.itx.address;
+	}
+}]));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: "signers" }));
+runner.use(pipes.ExtractState({
+	from: "itx.address",
+	to: "assetState",
+	status: "OK"
+}));
+runner.use(pipes.VerifyInfo([{
+	error: "INVALID_ASSET",
+	message: "This asset already exist on chain",
+	fn: (ctx) => !ctx.assetState
+}]));
+runner.use(pipes.ExtractState({
+	from: "itx.issuer",
+	to: "issuerState",
+	status: "INVALID_ISSUER_STATE",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({ signerKey: "issuerState" }));
+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",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "delegatorState",
+	addressKey: "tx.delegator"
+}));
+runner.use(pipes.VerifyDelegation({
+	type: "signature",
+	signerKey: "senderState",
+	delegatorKey: "delegatorState",
+	getRequirements: getDelegationRequirements
+}));
+runner.use(pipes.ExtractState({
+	from: "itx.parent",
+	to: "factoryState",
+	status: "OK",
+	table: "factory"
+}));
+runner.use(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(pipes.ExtractState({
+	from: "itx.parent",
+	to: "parentAsset",
+	status: "INVALID_ASSET",
+	table: "asset"
+}));
+runner.use(ensure_gas_default(() => ({
+	create: 1,
+	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, 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, account.update(senderState, {
+			nonce: tx$1.nonce,
+			pk: tx$1.pk,
+			...senderUpdates
+		}, context), context),
+		statedb.asset.create(itx.address, asset.create({
+			...itx,
+			tags: getListField(itx, "tags"),
+			data: assetData ?? void 0,
+			owner
+		}, context), context),
+		context.isDelegationChanged && delegationState ? statedb.delegation.update(delegationState.address, delegation.update(delegationState, {}, context), context) : delegationState
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.assetState = assetState;
+	context.delegationState = newDelegationState;
+	debug("createAsset", assetState);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var create_default = runner;
+
+//#endregion
+export { create_default as default };

package/esm/protocols/asset/mint.d.mts

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