@ocap/tx-protocols 1.28.8 → 1.29.0

package/lib/protocols/token-factory/create.cjs

@@ -0,0 +1,260 @@
+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_token_factory_pipes_verify_icon = require('./pipes/verify-icon.cjs');
+const require_protocols_token_factory_pipes_verify_ownership = require('./pipes/verify-ownership.cjs');
+const require_protocols_token_factory_pipes_verify_url = require('./pipes/verify-url.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 debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let _ocap_util_lib_get_list_field = require("@ocap/util/lib/get-list-field");
+let lodash_cloneDeep = require("lodash/cloneDeep");
+lodash_cloneDeep = require_rolldown_runtime.__toESM(lodash_cloneDeep);
+let _arcblock_validator = require("@arcblock/validator");
+let lodash_uniq = require("lodash/uniq");
+lodash_uniq = require_rolldown_runtime.__toESM(lodash_uniq);
+let lodash_isEmpty = require("lodash/isEmpty");
+lodash_isEmpty = require_rolldown_runtime.__toESM(lodash_isEmpty);
+
+//#region src/protocols/token-factory/create.ts
+const debug$1 = (0, debug.default)("@ocap/tx-protocols:create-token-factory");
+const runner = new _ocap_tx_pipeline.Runner("create_token_factory");
+const isTest = process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test" || process.env.CI;
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSig(0));
+const schema = _arcblock_validator.Joi.object({
+	address: _arcblock_validator.Joi.DID().prefix().role("ROLE_TOKEN_FACTORY").required(),
+	feeRate: _arcblock_validator.Joi.number().min(0).max(2e3).required(),
+	curve: _arcblock_validator.Joi.when("token.type", {
+		is: "CreditToken",
+		then: _arcblock_validator.Joi.valid(null).optional().messages({ "any.only": "Should not provide curve for CreditToken" }),
+		otherwise: _ocap_state.tokenFactory.curveSchema.required()
+	}),
+	reserveAddress: _arcblock_validator.Joi.DID().prefix().role("ROLE_TOKEN").required(),
+	token: _arcblock_validator.Joi.object({
+		name: _arcblock_validator.Joi.string().min(1).max(32).required(),
+		description: _arcblock_validator.Joi.string().min(16).max(128).required(),
+		symbol: _arcblock_validator.Joi.string().min(2).max(6).uppercase().required(),
+		unit: _arcblock_validator.Joi.string().min(1).max(6).lowercase().required(),
+		decimal: _arcblock_validator.Joi.number().min(2).max(18).required(),
+		icon: _arcblock_validator.Joi.string().optional().allow(null, ""),
+		maxTotalSupply: _arcblock_validator.Joi.alternatives().try(_arcblock_validator.Joi.BN().greater(0), _arcblock_validator.Joi.string().valid("")).optional().allow(null),
+		website: _arcblock_validator.Joi.string().uri({
+			scheme: isTest ? ["http", "https"] : ["https"],
+			allowRelative: false
+		}).max(256).optional().allow(null, ""),
+		metadata: _arcblock_validator.Joi.any().required(),
+		spendersList: _arcblock_validator.Joi.array().items(_arcblock_validator.Joi.DID().prefix()).max(30).optional().allow(null).default(null),
+		mintersList: _arcblock_validator.Joi.array().items(_arcblock_validator.Joi.DID().prefix()).max(30).optional().allow(null).default(null),
+		type: _arcblock_validator.Joi.string().valid("CreditToken", "BondingCurveToken").required()
+	}).required(),
+	data: _arcblock_validator.Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+runner.use((context, next) => {
+	const { error, value } = schema.validate(context.itx);
+	if (error) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Invalid itx: ${error.message}`));
+	context.itx.curve = value.curve;
+	const itxToken = context.itx.token;
+	if (itxToken.metadata) {
+		const metadata = require_util.decodeAnySafe(itxToken.metadata ?? null);
+		const { error: metadataError, value: metadataValue } = _ocap_state.token.metadataSchema.validate(metadata?.value);
+		if (metadataError) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Invalid metadata: ${metadataError.message}`));
+		itxToken.metadata = {
+			...metadata,
+			value: metadataValue
+		};
+	}
+	const tokenWithLists = itxToken;
+	const spendersList = (0, _ocap_util_lib_get_list_field.getListField)(itxToken, "spenders");
+	itxToken.spenders = spendersList?.length ? (0, lodash_uniq.default)(spendersList) : null;
+	delete tokenWithLists.spendersList;
+	const mintersList = (0, _ocap_util_lib_get_list_field.getListField)(itxToken, "minters");
+	itxToken.minters = mintersList?.length ? (0, lodash_uniq.default)(mintersList) : null;
+	delete tokenWithLists.mintersList;
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([
+	{
+		error: "INVALID_TOKEN",
+		message: "Token address is not valid",
+		fn: (ctx) => {
+			const itxToken = ctx.itx.token;
+			return (0, _arcblock_did_util.toTokenAddress)({
+				...itxToken,
+				address: ""
+			}) === itxToken.address;
+		}
+	},
+	{
+		error: "INVALID_TOKEN_FACTORY",
+		message: "Token factory address is not valid",
+		fn: (ctx) => {
+			const context = ctx;
+			const itx = (0, lodash_cloneDeep.default)(context.itx);
+			itx.data = require_util.decodeAnySafe(itx.data ?? null);
+			itx.address = "";
+			return (0, _arcblock_did_util.toTokenFactoryAddress)(itx) === context.itx.address;
+		}
+	},
+	{
+		error: "INVALID_RESERVE_ADDRESS",
+		message: "Reserve address is not valid",
+		fn: (ctx) => {
+			const context = ctx;
+			return context.itx.reserveAddress === context.config.token.address;
+		}
+	}
+]));
+runner.use(require_protocols_token_factory_pipes_verify_icon.default());
+runner.use(require_protocols_token_factory_pipes_verify_url.default({ urlKeys: ["itx.token.website", "itx.token.metadata.value.communityUrl"] }));
+runner.use(require_protocols_token_factory_pipes_verify_ownership.default({ tokenKey: "itx.token" }));
+runner.use((context, next) => {
+	const { reservedSymbols = [] } = context.config;
+	const { symbol } = context.itx.token;
+	if (reservedSymbols.includes(symbol.toUpperCase())) return next(new _ocap_util_lib_error.CustomError("INVALID_SYMBOL", `Token symbol can not be ${symbol}`));
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.address",
+	to: "tokenFactoryState",
+	table: "tokenFactory",
+	status: "OK"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "DUPLICATE_TOKEN_FACTORY",
+	message: "Token factory address already exists on chain",
+	fn: (ctx) => {
+		return (0, lodash_isEmpty.default)(ctx.tokenFactoryState);
+	}
+}]));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.token.address",
+	to: "tokenState",
+	table: "token",
+	status: "OK"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyInfo([{
+	error: "DUPLICATE_TOKEN",
+	message: "Token address already exists on chain",
+	fn: (ctx) => {
+		return (0, lodash_isEmpty.default)(ctx.tokenState);
+	}
+}]));
+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.VerifyBlocked({ stateKeys: ["senderState"] }));
+runner.use((context, next) => {
+	const { tx, itx } = context;
+	const sender = tx.delegator || tx.from;
+	const receiver = context.config.token.address;
+	context.stakeAddress = (0, _arcblock_did_util.toStakeAddress)(sender, receiver, itx.token.symbol);
+	return next();
+});
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "stakeAddress",
+	to: "stakeState",
+	status: "INVALID_STAKE_STATE",
+	table: "stake"
+}));
+runner.use((context, next) => {
+	const { stakeState, config, itx } = context;
+	if (stakeState.revocable === false) return next(new _ocap_util_lib_error.CustomError("INVALID_STAKE_STATE", `Staking for token creating already locked: ${stakeState.address}`));
+	const actualStake = new _ocap_util.BN(stakeState.tokens[config.token.address] || 0);
+	const requiredStake = (0, _ocap_util.fromTokenToUnit)(itx.token.type === "CreditToken" ? config.transaction.txStake.createCreditToken : config.transaction.txStake.createToken, config.token.decimal);
+	if (actualStake.lt(requiredStake)) return next(new _ocap_util_lib_error.CustomError("INVALID_STAKE_STATE", `Insufficient stake amount: required ${(0, _ocap_util.fromUnitToToken)(requiredStake, config.token.decimal)} ${config.token.symbol}`));
+	return next();
+});
+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: require_util.getDelegationRequirements
+}));
+runner.use(async function EnsureTokenSymbol(context, next) {
+	const itxToken = context.itx.token;
+	if (await context.statedb.token.existBySymbol(itxToken.symbol, context)) return next(new _ocap_util_lib_error.CustomError("DUPLICATE_SYMBOL", "Token symbol already exists"));
+	return next();
+}, { persistError: true });
+runner.use(require_pipes_ensure_gas.default((context) => {
+	const result = {
+		create: 2,
+		update: 2,
+		payment: 0
+	};
+	if (context.isDelegationChanged) 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, statedb, senderState, delegatorState, delegationState, senderChange, stakeState, stakeAddress, updateVaults, config } = context;
+	const data = require_util.decodeAnySafe(itx.data ?? null);
+	const owner = delegatorState ? delegatorState.address : senderState.address;
+	const itxToken = itx.token;
+	const { tokens: senderTokens = {} } = senderState;
+	const senderUpdates = senderChange ? require_util.applyTokenChange({ tokens: senderTokens }, senderChange) : { tokens: senderTokens };
+	const [newSenderState, newTokenState, newTokenFactoryState, newDelegationState, newStakeState] = await Promise.all([
+		statedb.account.update(senderState.address, _ocap_state.account.update(senderState, {
+			nonce: tx.nonce,
+			pk: tx.pk,
+			...senderUpdates
+		}, context), context),
+		statedb.token.create(itxToken.address, _ocap_state.token.create({
+			...(0, lodash_cloneDeep.default)(itxToken),
+			totalSupply: "0",
+			initialSupply: "0",
+			issuer: owner,
+			tokenFactoryAddress: itx.address
+		}, context), context),
+		statedb.tokenFactory.create(itx.address, _ocap_state.tokenFactory.create({
+			...(0, lodash_cloneDeep.default)(itx),
+			owner,
+			tokenAddress: itxToken.address,
+			data
+		}, context), context),
+		context.isDelegationChanged ? statedb.delegation.update(delegationState.address, _ocap_state.delegation.update(delegationState, {}, context), context) : delegationState,
+		statedb.stake.update(stakeAddress, _ocap_state.stake.update(stakeState, {
+			revocable: false,
+			revokeWaitingPeriod: config.transaction.txStake.createTokenLockPeriod
+		}, context), context)
+	]);
+	if (updateVaults) await updateVaults();
+	context.senderState = newSenderState;
+	context.tokenState = newTokenState;
+	context.tokenFactoryState = newTokenFactoryState;
+	context.delegationState = newDelegationState;
+	context.stakeState = newStakeState;
+	debug$1("create token factory", newTokenFactoryState);
+	next();
+}, { persistError: true });
+runner.use(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var create_default = runner;
+
+//#endregion
+exports.default = create_default;

package/lib/protocols/token-factory/create.d.cts

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

package/lib/protocols/token-factory/mint.cjs

@@ -0,0 +1,237 @@
+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_token_factory_pipes_calc_reserve = require('./pipes/calc-reserve.cjs');
+let _ocap_tx_pipeline = require("@ocap/tx-pipeline");
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let lodash_pick = require("lodash/pick");
+lodash_pick = require_rolldown_runtime.__toESM(lodash_pick);
+let _ocap_state = require("@ocap/state");
+let _ocap_util = require("@ocap/util");
+let _ocap_util_lib_get_list_field = require("@ocap/util/lib/get-list-field");
+let _arcblock_validator = require("@arcblock/validator");
+
+//#region src/protocols/token-factory/mint.ts
+const runner = new _ocap_tx_pipeline.Runner("mint_token");
+const schema = _arcblock_validator.Joi.object({
+	tokenFactory: _arcblock_validator.Joi.DID().prefix().role("ROLE_TOKEN_FACTORY").required(),
+	receiver: _arcblock_validator.schemas.tokenHolder.required(),
+	amount: _arcblock_validator.Joi.BN().greater(0).required(),
+	data: _arcblock_validator.Joi.any().optional().allow(null),
+	inputsList: _arcblock_validator.schemas.multiInput.optional()
+}).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.tokenFactory",
+	to: "tokenFactoryState",
+	status: "INVALID_TOKEN_FACTORY",
+	table: "tokenFactory"
+}));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tokenFactoryState.tokenAddress",
+	to: "tokenState",
+	status: "INVALID_TOKEN",
+	table: "token"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyTxInput({
+	fieldKey: "itx.inputs",
+	inputsKey: "inputs",
+	sendersKey: "senders",
+	tokensKey: "tokens",
+	assetsKey: null
+}), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use(_ocap_tx_pipeline.pipes.VerifyListSize({ listKey: [
+	"inputs",
+	"senders",
+	"tokens",
+	"assets"
+] }), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use(_ocap_tx_pipeline.pipes.VerifyMultiSigV2({ signersKey: "senders" }), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use((context, next) => {
+	const { tokenFactoryState, inputs = [] } = context;
+	if (!inputs.every((input) => {
+		const tokensList = (0, _ocap_util_lib_get_list_field.getListField)(input, "tokens");
+		const assetsList = (0, _ocap_util_lib_get_list_field.getListField)(input, "assets");
+		return tokensList.length && tokensList.every((x) => x.address === tokenFactoryState.reserveAddress) && !assetsList.length;
+	})) return next(new _ocap_util_lib_error.CustomError("INVALID_TX", `Inputs only accept ${tokenFactoryState.reserveAddress}`));
+	return next();
+}, { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+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"
+}), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	signerKey: "signerStates",
+	stateKey: "senderState",
+	addressKey: "tx.from"
+}), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "itx.receiver",
+	to: "receiverState",
+	status: "OK",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyAccountMigration({
+	stateKey: "receiverState",
+	addressKey: "itx.receiver"
+}));
+runner.use(_ocap_tx_pipeline.pipes.VerifyBlocked({ stateKeys: ["signerStates", "receiverState"] }));
+runner.use(_ocap_tx_pipeline.pipes.ExtractState({
+	from: "tokenFactoryState.owner",
+	to: "ownerState",
+	status: "INVALID_OWNER_STATE",
+	table: "account"
+}));
+runner.use(_ocap_tx_pipeline.pipes.verifyTokenAccess({
+	statesKey: "tokenState",
+	listFieldKey: "minters",
+	accountKeys: ["senderState"],
+	errorMessage: "Account {address} is not allowed to mint token {tokenAddress}"
+}));
+runner.use(require_protocols_token_factory_pipes_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 _ocap_util.BN(tokenState.maxTotalSupply).sub(new _ocap_util.BN(tokenState.totalSupply));
+		if (new _ocap_util.BN(itx.amount).gt(availableSupply)) return next(new _ocap_util_lib_error.CustomError("INVALID_TOKEN", `Maximum mintable tokens are ${(0, _ocap_util.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 = (0, _ocap_util_lib_get_list_field.getListField)(input, "tokens").find((x) => x.address === tokenFactoryState.reserveAddress);
+		if (reserveToken) return total.add(new _ocap_util.BN(reserveToken.value));
+		return total;
+	}, new _ocap_util.BN(0));
+	const actual = new _ocap_util.BN(reserveAmount ?? "0").add(new _ocap_util.BN(reserveFee || "0"));
+	if (actual.gt(maxReserve)) return next(new _ocap_util_lib_error.CustomError("SLIPPAGE_EXCEEDED", `Mint token failed due to price movement. Expected maximum: ${(0, _ocap_util.fromUnitToToken)(maxReserve)}, actual: ${(0, _ocap_util.fromUnitToToken)(actual)}. Try increasing your inputs.`));
+	next();
+}, { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+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"
+}), { shouldSkip: (ctx) => !ctx.tokenFactoryState?.curve });
+runner.use(require_pipes_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(require_pipes_ensure_cost.default({ attachSenderChanges: true }));
+runner.use(_ocap_tx_pipeline.pipes.TakeStateSnapshot());
+runner.use(async (context, next) => {
+	const { tx, 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 _ocap_util.BN(reserveAmount || "0").add(new _ocap_util.BN(reserveFee || "0"));
+	let currentReserveCost = new _ocap_util.BN("0");
+	const accountUpdates = {};
+	const inputChanges = [];
+	inputs.forEach((input) => {
+		const { owner } = input;
+		const reserveTokenChange = (0, _ocap_util_lib_get_list_field.getListField)(input, "tokens").find((item) => item.address === reserveAddress);
+		if (!reserveTokenChange) return;
+		let reserveValue = new _ocap_util.BN(reserveTokenChange.value);
+		if (currentReserveCost.add(reserveValue).gt(totalReserveCost)) {
+			reserveTokenChange.value = totalReserveCost.sub(currentReserveCost).toString();
+			reserveValue = new _ocap_util.BN(reserveTokenChange.value);
+		}
+		currentReserveCost = currentReserveCost.add(reserveValue);
+		accountUpdates[owner] = require_util.applyTokenUpdates([reserveTokenChange], signerStates.find((s) => s.address === owner), "sub");
+		inputChanges.push({
+			address: owner,
+			token: reserveAddress,
+			delta: reserveValue.neg().toString()
+		});
+	});
+	if (!accountUpdates[tx.from]) accountUpdates[tx.from] = senderState || {};
+	if (reserveFee && new _ocap_util.BN(reserveFee).gt(new _ocap_util.BN(0))) accountUpdates[ownerState.address] = require_util.applyTokenChange(accountUpdates[ownerState.address] || ownerState, {
+		token: reserveAddress,
+		delta: reserveFee
+	});
+	accountUpdates[receiver] = require_util.applyTokenChange(accountUpdates[receiver] || receiverState || {
+		address: receiver,
+		tokens: {}
+	}, {
+		token: tokenAddress,
+		delta: String(amount)
+	});
+	if (senderChange) accountUpdates[senderChange.address] = require_util.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 ? (0, lodash_pick.default)(updates, ["tokens"]) : {
+				...updates,
+				address
+			};
+			if (address === tx.from) {
+				actualUpdates.pk = tx.pk;
+				actualUpdates.nonce = tx.nonce;
+			}
+			return statedb.account.updateOrCreate(state ?? null, _ocap_state.account.updateOrCreate(state ?? null, actualUpdates, context), context);
+		})),
+		statedb.tokenFactory.update(tokenFactoryState.address, _ocap_state.tokenFactory.update(tokenFactoryState, {
+			currentSupply: new _ocap_util.BN(tokenFactoryState.currentSupply).add(new _ocap_util.BN(amount)).toString(),
+			reserveBalance: new _ocap_util.BN(tokenFactoryState.reserveBalance).add(new _ocap_util.BN(reserveAmount || "0")).toString()
+		}, context), context),
+		statedb.token.update(tokenAddress, _ocap_state.token.update(tokenState, { totalSupply: new _ocap_util.BN(tokenState.totalSupply).add(new _ocap_util.BN(amount)).toString() }), context)
+	]);
+	context.senderState = newAccountStates.find((x) => x.address === tx.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(_ocap_tx_pipeline.pipes.VerifyStateDiff());
+var mint_default = runner;
+
+//#endregion
+exports.default = mint_default;

package/lib/protocols/token-factory/mint.d.cts

@@ -0,0 +1,15 @@
+//#region src/protocols/token-factory/mint.d.ts
+/** Token input type */
+interface TokenInput {
+  address: string;
+  value: string;
+}
+/** Multi-input type */
+interface MultiInput {
+  owner: string;
+  tokensList: TokenInput[];
+  assetsList: string[];
+}
+declare const runner: any;
+//#endregion
+export { MultiInput, TokenInput, runner as default };

package/lib/protocols/token-factory/pipes/calc-reserve.cjs

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let lodash_get = require("lodash/get");
+lodash_get = require_rolldown_runtime.__toESM(lodash_get);
+let _ocap_util_lib_curve = require("@ocap/util/lib/curve");
+let lodash_set = require("lodash/set");
+lodash_set = require_rolldown_runtime.__toESM(lodash_set);
+
+//#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 = (0, lodash_get.default)(context, tokenFactoryKey);
+	const tokenState = (0, lodash_get.default)(context, tokenStateKey);
+	const amount = (0, lodash_get.default)(context, amountKey);
+	if (!tokenFactoryState) return next(new _ocap_util_lib_error.CustomError("INVALID_TOKEN_FACTORY", "Token factory state not found"));
+	if (!tokenState) return next(new _ocap_util_lib_error.CustomError("INVALID_TOKEN", "Token state not found"));
+	const factoryState = tokenFactoryState;
+	const tokenStateTyped = tokenState;
+	const { curve, currentSupply, feeRate } = factoryState;
+	const { decimal } = tokenStateTyped;
+	const reserveAmount = (0, _ocap_util_lib_curve.calcCost)({
+		amount,
+		decimal,
+		currentSupply,
+		direction,
+		curve
+	});
+	(0, lodash_set.default)(context, reserveKey, reserveAmount?.toString());
+	(0, lodash_set.default)(context, feeKey, (0, _ocap_util_lib_curve.calcFee)({
+		reserveAmount: reserveAmount?.toString() || "0",
+		feeRate: String(feeRate)
+	})?.toString());
+	return next();
+};
+var calc_reserve_default = calcReserve;
+
+//#endregion
+exports.default = calc_reserve_default;

package/lib/protocols/token-factory/pipes/calc-reserve.d.cts

@@ -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/lib/protocols/token-factory/pipes/verify-icon.cjs

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _ocap_util_lib_error = require("@ocap/util/lib/error");
+let lodash_get = require("lodash/get");
+lodash_get = require_rolldown_runtime.__toESM(lodash_get);
+let lodash_set = require("lodash/set");
+lodash_set = require_rolldown_runtime.__toESM(lodash_set);
+let _blocklet_xss = require("@blocklet/xss");
+
+//#region src/protocols/token-factory/pipes/verify-icon.ts
+const verifyIcon = ({ iconKey = "itx.token.icon", size = 16 * 1024 } = {}) => (context, next) => {
+	const icon = (0, lodash_get.default)(context, iconKey);
+	if (!icon) return next();
+	if (!(0, _blocklet_xss.isSvgFile)(icon)) return next(new _ocap_util_lib_error.CustomError("INVALID_ICON", "Token Icon is not a valid SVG file"));
+	if (Buffer.from(icon, "utf8").length > size) return next(new _ocap_util_lib_error.CustomError("INVALID_ICON", `Token Icon must be less than ${Math.floor(size / 1024)}k`));
+	(0, lodash_set.default)(context, iconKey, (0, _blocklet_xss.sanitizeSvg)(icon, { preserveCase: true }));
+	return next();
+};
+var verify_icon_default = verifyIcon;
+
+//#endregion
+exports.default = verify_icon_default;

package/lib/protocols/token-factory/pipes/verify-icon.d.cts

@@ -0,0 +1,14 @@
+import { IDecodedContext } from "@ocap/types";
+import { PipeFunction } from "@ocap/tx-pipeline";
+
+//#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 };