@ocap/tx-protocols 1.28.8 → 1.29.0

package/esm/protocols/token-factory/mint.mjs

@@ -0,0 +1,234 @@
+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 calc_reserve_default from "./pipes/calc-reserve.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import pick from "lodash/pick.js";
+import { account, token, tokenFactory } from "@ocap/state";
+import { BN, fromUnitToToken } from "@ocap/util";
+import { getListField } from "@ocap/util/lib/get-list-field";
+import { Joi, schemas } from "@arcblock/validator";
+
+//#region src/protocols/token-factory/mint.ts
+const runner = new Runner("mint_token");
+const schema = Joi.object({
+	tokenFactory: Joi.DID().prefix().role("ROLE_TOKEN_FACTORY").required(),
+	receiver: schemas.tokenHolder.required(),
+	amount: Joi.BN().greater(0).required(),
+	data: Joi.any().optional().allow(null),
+	inputsList: schemas.multiInput.optional()
+}).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.tokenFactory",
+	to: "tokenFactoryState",
+	status: "INVALID_TOKEN_FACTORY",
+	table: "tokenFactory"
+}));
+runner.use(pipes.ExtractState({
+	from: "tokenFactoryState.tokenAddress",
+	to: "tokenState",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(pipes.VerifyTxInput({
+	fieldKey: "itx.inputs",
+	inputsKey: "inputs",
+	sendersKey: "senders",
+	tokensKey: "tokens",
+	assetsKey: null
+}), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use(pipes.VerifyListSize({ listKey: [
+	"inputs",
+	"senders",
+	"tokens",
+	"assets"
+] }), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use(pipes.VerifyMultiSigV2({ signersKey: "senders" }), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use((context, next) => {
+	const { tokenFactoryState, inputs = [] } = context;
+	if (!inputs.every((input) => {
+		const tokensList = getListField(input, "tokens");
+		const assetsList = getListField(input, "assets");
+		return tokensList.length && tokensList.every((x) => x.address === tokenFactoryState.reserveAddress) && !assetsList.length;
+	})) return next(new CustomError("INVALID_TX", `Inputs only accept ${tokenFactoryState.reserveAddress}`));
+	return next();
+}, { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+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"
+}), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use(pipes.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use(pipes.ExtractState({
+	from: "itx.receiver",
+	to: "receiverState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(pipes.VerifyAccountMigration({
+	stateKey: "receiverState",
+	addressKey: "itx.receiver"
+}));
+runner.use(pipes.VerifyBlocked({ stateKeys: ["signerStates", "receiverState"] }));
+runner.use(pipes.ExtractState({
+	from: "tokenFactoryState.owner",
+	to: "ownerState",
+	status: "INVALID_OWNER_STATE",
+	table: "account"
+}));
+runner.use(pipes.verifyTokenAccess({
+	statesKey: "tokenState",
+	listFieldKey: "minters",
+	accountKeys: ["senderState"],
+	errorMessage: "Account {address} is not allowed to mint token {tokenAddress}"
+}));
+runner.use(calc_reserve_default({
+	tokenFactoryKey: "tokenFactoryState",
+	tokenStateKey: "tokenState",
+	reserveKey: "reserveAmount",
+	amountKey: "itx.amount"
+}), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use((context, next) => {
+	const { tokenState, itx } = context;
+	if (tokenState.maxTotalSupply) {
+		const availableSupply = new BN(tokenState.maxTotalSupply).sub(new BN(tokenState.totalSupply));
+		if (new BN(itx.amount).gt(availableSupply)) return next(new CustomError("INVALID_TOKEN", `Maximum mintable tokens are ${fromUnitToToken(availableSupply, tokenState.decimal)} ${tokenState.symbol}`));
+	}
+	next();
+});
+runner.use((context, next) => {
+	const { reserveAmount, reserveFee, inputs = [], tokenFactoryState } = context;
+	const maxReserve = inputs.reduce((total, input) => {
+		const reserveToken = getListField(input, "tokens").find((x) => x.address === tokenFactoryState.reserveAddress);
+		if (reserveToken) return total.add(new BN(reserveToken.value));
+		return total;
+	}, new BN(0));
+	const actual = new BN(reserveAmount ?? "0").add(new BN(reserveFee || "0"));
+	if (actual.gt(maxReserve)) return next(new CustomError("SLIPPAGE_EXCEEDED", `Mint token failed due to price movement. Expected maximum: ${fromUnitToToken(maxReserve)}, actual: ${fromUnitToToken(actual)}. Try increasing your inputs.`));
+	next();
+}, { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use(pipes.ExtractState({
+	from: "tokens",
+	to: "tokenStates",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(pipes.VerifyTokenBalance({
+	ownerKey: "signerStates",
+	conditionKey: "inputs"
+}), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use(ensure_gas_default((context) => {
+	const result = {
+		create: 0,
+		update: 2,
+		payment: 0
+	};
+	if (context.senderState) result.update += 1;
+	else result.create += 1;
+	if (context.receiverState) result.update += 1;
+	else result.create += 1;
+	if (context.reserveFee) result.update += 1;
+	if (context.signerStates) result.update += context.signerStates.length;
+	return result;
+}));
+runner.use(ensure_cost_default({ attachSenderChanges: true }));
+runner.use(pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx: tx$1, senderState, receiverState, ownerState, statedb, senderChange, updateVaults, tokenFactoryState, tokenState, reserveAmount, reserveFee, itx } = context;
+	const { amount, receiver } = itx;
+	const { reserveAddress, tokenAddress } = tokenFactoryState;
+	const signerStates = tokenFactoryState.curve ? context.signerStates || [] : [];
+	const inputs = tokenFactoryState.curve ? context.inputs || [] : [];
+	const totalReserveCost = new BN(reserveAmount || "0").add(new BN(reserveFee || "0"));
+	let currentReserveCost = new BN("0");
+	const accountUpdates = {};
+	const inputChanges = [];
+	inputs.forEach((input) => {
+		const { owner } = input;
+		const reserveTokenChange = getListField(input, "tokens").find((item) => item.address === reserveAddress);
+		if (!reserveTokenChange) return;
+		let reserveValue = new BN(reserveTokenChange.value);
+		if (currentReserveCost.add(reserveValue).gt(totalReserveCost)) {
+			reserveTokenChange.value = totalReserveCost.sub(currentReserveCost).toString();
+			reserveValue = new BN(reserveTokenChange.value);
+		}
+		currentReserveCost = currentReserveCost.add(reserveValue);
+		accountUpdates[owner] = applyTokenUpdates([reserveTokenChange], signerStates.find((s) => s.address === owner), "sub");
+		inputChanges.push({
+			address: owner,
+			token: reserveAddress,
+			delta: reserveValue.neg().toString()
+		});
+	});
+	if (!accountUpdates[tx$1.from]) accountUpdates[tx$1.from] = senderState || {};
+	if (reserveFee && new BN(reserveFee).gt(new BN(0))) accountUpdates[ownerState.address] = applyTokenChange(accountUpdates[ownerState.address] || ownerState, {
+		token: reserveAddress,
+		delta: reserveFee
+	});
+	accountUpdates[receiver] = applyTokenChange(accountUpdates[receiver] || receiverState || {
+		address: receiver,
+		tokens: {}
+	}, {
+		token: tokenAddress,
+		delta: String(amount)
+	});
+	if (senderChange) accountUpdates[senderChange.address] = applyTokenChange(accountUpdates[senderChange.address] || senderState, senderChange);
+	const [newAccountStates, newTokenFactoryState, newTokenState] = await Promise.all([
+		Promise.all(Object.entries(accountUpdates).map(([address, updates]) => {
+			const state = [
+				senderState,
+				receiverState,
+				ownerState,
+				...signerStates
+			].find((x) => x?.address === address);
+			const actualUpdates = state ? pick(updates, ["tokens"]) : {
+				...updates,
+				address
+			};
+			if (address === tx$1.from) {
+				actualUpdates.pk = tx$1.pk;
+				actualUpdates.nonce = tx$1.nonce;
+			}
+			return statedb.account.updateOrCreate(state ?? null, account.updateOrCreate(state ?? null, actualUpdates, context), context);
+		})),
+		statedb.tokenFactory.update(tokenFactoryState.address, tokenFactory.update(tokenFactoryState, {
+			currentSupply: new BN(tokenFactoryState.currentSupply).add(new BN(amount)).toString(),
+			reserveBalance: new BN(tokenFactoryState.reserveBalance).add(new BN(reserveAmount || "0")).toString()
+		}, context), context),
+		statedb.token.update(tokenAddress, token.update(tokenState, { totalSupply: new BN(tokenState.totalSupply).add(new BN(amount)).toString() }), context)
+	]);
+	context.senderState = newAccountStates.find((x) => x.address === tx$1.from);
+	context.receiverState = newAccountStates.find((x) => x.address === receiver);
+	context.ownerState = newAccountStates.find((x) => x.address === ownerState.address) || ownerState;
+	context.signerStates = newAccountStates.filter((x) => signerStates.find((s) => s.address === x.address));
+	context.tokenFactoryState = newTokenFactoryState;
+	context.tokenState = newTokenState;
+	context.inputChanges = inputChanges;
+	if (updateVaults) await updateVaults();
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var mint_default = runner;
+
+//#endregion
+export { mint_default as default };

package/esm/protocols/token-factory/pipes/calc-reserve.d.mts

@@ -0,0 +1,21 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#region src/protocols/token-factory/pipes/calc-reserve.d.ts
+interface ICalcReserveOptions {
+  tokenFactoryKey?: string;
+  tokenStateKey?: string;
+  reserveKey?: string;
+  feeKey?: string;
+  amountKey?: string;
+  direction?: 'mint' | 'burn';
+}
+declare const calcReserve: ({
+  tokenFactoryKey,
+  tokenStateKey,
+  reserveKey,
+  feeKey,
+  amountKey,
+  direction
+}?: ICalcReserveOptions) => PipeFunction<any>;
+//#endregion
+export { calcReserve as default };

package/esm/protocols/token-factory/pipes/calc-reserve.mjs

@@ -0,0 +1,34 @@
+import { CustomError } from "@ocap/util/lib/error";
+import get from "lodash/get.js";
+import { calcCost, calcFee } from "@ocap/util/lib/curve";
+import set from "lodash/set.js";
+
+//#region src/protocols/token-factory/pipes/calc-reserve.ts
+const calcReserve = ({ tokenFactoryKey = "tokenFactoryState", tokenStateKey = "tokenState", reserveKey = "reserveAmount", feeKey = "reserveFee", amountKey = "itx.amount", direction = "mint" } = {}) => (context, next) => {
+	const tokenFactoryState = get(context, tokenFactoryKey);
+	const tokenState = get(context, tokenStateKey);
+	const amount = get(context, amountKey);
+	if (!tokenFactoryState) return next(new CustomError("INVALID_TOKEN_FACTORY", "Token factory state not found"));
+	if (!tokenState) return next(new CustomError("INVALID_TOKEN", "Token state not found"));
+	const factoryState = tokenFactoryState;
+	const tokenStateTyped = tokenState;
+	const { curve, currentSupply, feeRate } = factoryState;
+	const { decimal } = tokenStateTyped;
+	const reserveAmount = calcCost({
+		amount,
+		decimal,
+		currentSupply,
+		direction,
+		curve
+	});
+	set(context, reserveKey, reserveAmount?.toString());
+	set(context, feeKey, calcFee({
+		reserveAmount: reserveAmount?.toString() || "0",
+		feeRate: String(feeRate)
+	})?.toString());
+	return next();
+};
+var calc_reserve_default = calcReserve;
+
+//#endregion
+export { calc_reserve_default as default };

package/esm/protocols/token-factory/pipes/verify-icon.d.mts

@@ -0,0 +1,14 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+import { IDecodedContext } from "@ocap/types";
+
+//#region src/protocols/token-factory/pipes/verify-icon.d.ts
+interface IVerifyIconOptions {
+  iconKey?: string;
+  size?: number;
+}
+declare const verifyIcon: ({
+  iconKey,
+  size
+}?: IVerifyIconOptions) => PipeFunction<IDecodedContext>;
+//#endregion
+export { verifyIcon as default };

package/esm/protocols/token-factory/pipes/verify-icon.mjs

@@ -0,0 +1,18 @@
+import { CustomError } from "@ocap/util/lib/error";
+import get from "lodash/get.js";
+import set from "lodash/set.js";
+import { isSvgFile, sanitizeSvg } from "@blocklet/xss";
+
+//#region src/protocols/token-factory/pipes/verify-icon.ts
+const verifyIcon = ({ iconKey = "itx.token.icon", size = 16 * 1024 } = {}) => (context, next) => {
+	const icon = get(context, iconKey);
+	if (!icon) return next();
+	if (!isSvgFile(icon)) return next(new CustomError("INVALID_ICON", "Token Icon is not a valid SVG file"));
+	if (Buffer.from(icon, "utf8").length > size) return next(new CustomError("INVALID_ICON", `Token Icon must be less than ${Math.floor(size / 1024)}k`));
+	set(context, iconKey, sanitizeSvg(icon, { preserveCase: true }));
+	return next();
+};
+var verify_icon_default = verifyIcon;
+
+//#endregion
+export { verify_icon_default as default };

package/esm/protocols/token-factory/pipes/verify-ownership.d.mts

@@ -0,0 +1,12 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+import { IDecodedContext } from "@ocap/types";
+
+//#region src/protocols/token-factory/pipes/verify-ownership.d.ts
+interface IVerifyOwnershipOptions {
+  tokenKey?: string;
+}
+declare const verifyOwnership: ({
+  tokenKey
+}?: IVerifyOwnershipOptions) => PipeFunction<IDecodedContext>;
+//#endregion
+export { verifyOwnership as default };

package/esm/protocols/token-factory/pipes/verify-ownership.mjs

@@ -0,0 +1,63 @@
+import { CustomError } from "@ocap/util/lib/error";
+import get from "lodash/get.js";
+import { verify } from "@arcblock/vc";
+import { verifyUrl } from "@ocap/util/lib/url";
+
+//#region src/protocols/token-factory/pipes/verify-ownership.ts
+const isTest = ["development", "test"].includes(process.env.NODE_ENV) || !!process.env.CI;
+const verifyOwnership = ({ tokenKey = "itx.token" } = {}) => async (context, next) => {
+	const { symbol, address, website } = get(context, tokenKey) || {};
+	if (!website) return next();
+	try {
+		await verifyUrl(website, isTest ? {
+			protocols: ["http:", "https:"],
+			blockedHosts: [],
+			allowIp: true
+		} : { checkDns: true });
+	} catch (error) {
+		return next(new CustomError("INVALID_WEBSITE", `Website ${website} must be a valid URL: ${error.message}`));
+	}
+	const { from, delegator } = context.tx;
+	const chainId = context.config.chainId;
+	const sender = delegator || from;
+	const { origin } = new URL(website);
+	const verificationUrl = `${origin}/.well-known/ocap/tokens.json`;
+	try {
+		const response = await fetch(verificationUrl, { redirect: "manual" });
+		if (!response || !response.ok) {
+			context.logger?.info("Website verification failed", {
+				symbol,
+				website,
+				status: response?.status,
+				statusText: response?.statusText
+			});
+			return next(new CustomError("INVALID_WEBSITE", `Website ${website} verification failed`));
+		}
+		const data = await response.json();
+		if ((await Promise.all(data.filter(Boolean).filter((item) => {
+			if (item.type !== "TokenIssueCredential") return false;
+			if (item.issuer?.id !== sender) return false;
+			const { id, issued } = item.credentialSubject || {};
+			return id === sender && issued?.address === address && issued?.symbol === symbol && issued?.chainId === chainId && issued?.website === website;
+		}).map((item) => {
+			return verify({
+				vc: item,
+				ownerDid: sender,
+				trustedIssuers: sender
+			});
+		}))).some((valid) => valid)) return next();
+		context.logger?.warn("Website verification failed", {
+			address,
+			symbol,
+			website,
+			data
+		});
+		return next(new CustomError("INVALID_WEBSITE", `Website ${website} verification failed`));
+	} catch (error) {
+		return next(new CustomError("INVALID_WEBSITE", `Website ${website} verification failed: ${error.message}`));
+	}
+};
+var verify_ownership_default = verifyOwnership;
+
+//#endregion
+export { verify_ownership_default as default };

package/esm/protocols/token-factory/pipes/verify-url.d.mts

@@ -0,0 +1,12 @@
+import { PipeFunction } from "@ocap/tx-pipeline";
+import { IDecodedContext } from "@ocap/types";
+
+//#region src/protocols/token-factory/pipes/verify-url.d.ts
+interface IVerifyUrlOptions {
+  urlKeys?: string[];
+}
+declare const verifyUrlPipe: ({
+  urlKeys
+}?: IVerifyUrlOptions) => PipeFunction<IDecodedContext>;
+//#endregion
+export { verifyUrlPipe as default };

package/esm/protocols/token-factory/pipes/verify-url.mjs

@@ -0,0 +1,26 @@
+import { CustomError } from "@ocap/util/lib/error";
+import get from "lodash/get.js";
+import { verifyUrl } from "@ocap/util/lib/url";
+
+//#region src/protocols/token-factory/pipes/verify-url.ts
+const isTest = ["development", "test"].includes(process.env.NODE_ENV) || !!process.env.CI;
+const verifyUrlPipe = ({ urlKeys = ["itx.token.website", "itx.token.metadata.value.communityUrl"] } = {}) => async (context, next) => {
+	for (const key of urlKeys) {
+		const url = get(context, key);
+		if (!url) continue;
+		try {
+			await verifyUrl(url, isTest ? {
+				protocols: ["http:", "https:"],
+				blockedHosts: [],
+				allowIp: true
+			} : {});
+		} catch (error) {
+			return next(new CustomError("INVALID_TX", `${key.split(".").pop()} is not valid: ${error.message}`));
+		}
+	}
+	return next();
+};
+var verify_url_default = verifyUrlPipe;
+
+//#endregion
+export { verify_url_default as default };

package/esm/protocols/token-factory/update.d.mts

@@ -0,0 +1,10 @@
+//#region src/protocols/token-factory/update.d.ts
+/** Token info for website verification */
+interface TokenInfoForVerification {
+  symbol: string;
+  address: string;
+  website?: string | null;
+}
+declare const runner: any;
+//#endregion
+export { TokenInfoForVerification, runner as default };

package/esm/protocols/token-factory/update.mjs

@@ -0,0 +1,152 @@
+import { applyTokenChange, decodeAnySafe, getDelegationRequirements } from "../../util.mjs";
+import ensure_cost_default from "../../pipes/ensure-cost.mjs";
+import ensure_gas_default from "../../pipes/ensure-gas.mjs";
+import verify_icon_default from "./pipes/verify-icon.mjs";
+import verify_ownership_default from "./pipes/verify-ownership.mjs";
+import verify_url_default from "./pipes/verify-url.mjs";
+import { Runner, pipes } from "@ocap/tx-pipeline";
+import { CustomError } from "@ocap/util/lib/error";
+import { account, delegation, token, tokenFactory } from "@ocap/state";
+import Debug from "debug";
+import { Joi } from "@arcblock/validator";
+
+//#region src/protocols/token-factory/update.ts
+const debug = Debug("@ocap/tx-protocols:update-token-factory");
+const runner = new Runner("update_token_factory");
+const isTest = process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test" || process.env.CI;
+runner.use(pipes.VerifyMultiSig(0));
+const schema = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_TOKEN_FACTORY").required(),
+	feeRate: Joi.number().min(0).max(2e3).optional().allow(null),
+	token: Joi.object({
+		icon: Joi.string().optional().allow(null, ""),
+		website: Joi.string().uri({
+			scheme: isTest ? ["http", "https"] : ["https"],
+			allowRelative: false
+		}).max(256).optional().allow(null, ""),
+		metadata: Joi.any().optional().allow(null)
+	}).optional().allow(null),
+	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}`));
+	if (context.itx.token?.metadata) {
+		const metadata = decodeAnySafe(context.itx.token.metadata ?? null);
+		if (metadata) {
+			const { error: metadataError, value: metadataValue } = token.metadataSchema.validate(metadata.value);
+			if (metadataError) return next(new CustomError("INVALID_TX", `Invalid metadata: ${metadataError.message}`));
+			context.itx.token.metadata = {
+				...metadata,
+				value: metadataValue
+			};
+		}
+	}
+	return next();
+});
+runner.use(verify_icon_default({ iconKey: "itx.token.icon" }));
+runner.use(verify_url_default({ urlKeys: ["itx.token.website", "itx.token.metadata.value.communityUrl"] }));
+runner.use(pipes.ExtractState({
+	from: "itx.address",
+	to: "tokenFactoryState",
+	table: "tokenFactory",
+	status: "INVALID_TOKEN_FACTORY"
+}));
+runner.use(pipes.ExtractState({
+	from: "tokenFactoryState.tokenAddress",
+	to: "tokenState",
+	table: "token",
+	status: "INVALID_TOKEN"
+}));
+runner.use((context, next) => {
+	const { tokenState, itx } = context;
+	context.tokenInfoForVerification = {
+		symbol: tokenState.symbol,
+		address: tokenState.address,
+		website: itx.token?.website ?? null
+	};
+	return next();
+});
+runner.use(verify_ownership_default({ tokenKey: "tokenInfoForVerification" }));
+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.VerifyBlocked({ stateKeys: ["senderState"] }));
+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((context, next) => {
+	const { tokenFactoryState, delegatorState, senderState } = context;
+	if ((delegatorState ? delegatorState.address : senderState.address) !== tokenFactoryState.owner) return next(new CustomError("FORBIDDEN", "Token factory can only be updated by owner"));
+	return next();
+});
+runner.use(ensure_gas_default((context) => {
+	const result = {
+		create: 0,
+		update: 2,
+		payment: 0
+	};
+	if (context.isDelegationChanged) 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, statedb, senderState, tokenFactoryState, tokenState, senderChange, updateVaults, delegationState } = context;
+	const senderStateValue = senderState;
+	const tokenFactoryStateValue = tokenFactoryState;
+	const tokenStateValue = tokenState;
+	const { tokens: senderTokens = {} } = senderStateValue;
+	const senderUpdates = senderChange ? applyTokenChange({ tokens: senderTokens }, senderChange) : { tokens: senderTokens };
+	const factoryUpdates = itx.feeRate ? { feeRate: itx.feeRate } : {};
+	const tokenUpdates = itx.token ? {
+		icon: itx.token?.icon || tokenStateValue.icon,
+		website: itx.token?.website || tokenStateValue.website,
+		metadata: itx.token?.metadata || tokenStateValue.metadata
+	} : null;
+	const [newSenderState, newTokenFactoryState, newTokenState, newDelegationState] = await Promise.all([
+		statedb.account.update(senderStateValue.address, account.update(senderStateValue, {
+			nonce: tx$1.nonce,
+			pk: tx$1.pk,
+			...senderUpdates
+		}, context), context),
+		statedb.tokenFactory.update(tokenFactoryStateValue.address, tokenFactory.update(tokenFactoryStateValue, factoryUpdates, context), context),
+		tokenUpdates ? statedb.token.update(tokenStateValue.address, token.update(tokenStateValue, tokenUpdates), context) : tokenStateValue,
+		context.isDelegationChanged && delegationState ? statedb.delegation.update(delegationState.address, delegation.update(delegationState, {}, context), context) : delegationState
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.tokenFactoryState = newTokenFactoryState;
+	context.tokenState = newTokenState;
+	context.delegationState = newDelegationState;
+	debug("update token factory", newTokenFactoryState, newTokenState);
+	next();
+}, { persistError: true });
+runner.use(pipes.VerifyStateDiff());
+var update_default = runner;
+
+//#endregion
+export { update_default as default };

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

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