@ocap/state 1.28.9 → 1.29.0

package/esm/states/factory.mjs

@@ -0,0 +1,76 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { create as create$1, update as update$1 } from "../contexts/state.mjs";
+import { toAddress } from "@ocap/util";
+import pick from "lodash/pick.js";
+import { Joi, schemas } from "@arcblock/validator";
+import { compile, getQuota, merge } from "@ocap/contract";
+
+//#region src/states/factory.ts
+var factory_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	update: () => update,
+	validate: () => validate
+});
+const stateSchema = Joi.object({
+	...schemas.factoryProps,
+	owner: Joi.DID().prefix().required(),
+	numMinted: Joi.number().min(0).default(0),
+	lastSettlement: Joi.date().iso().raw().allow(""),
+	tokens: Joi.object().pattern(Joi.DID().prefix().role("ROLE_TOKEN"), Joi.BN().min(0)).default({}),
+	context: schemas.context
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const compileHook = (hook) => {
+	if (hook.type === "contract") hook.compiled = merge(compile(hook.hook));
+	return hook;
+};
+const create = (attrs, context) => {
+	const factory = {
+		numMinted: 0,
+		lastSettlement: "",
+		tokens: {},
+		context: create$1(context),
+		...pick(attrs, [
+			"address",
+			"owner",
+			"name",
+			"description",
+			"settlement",
+			"limit",
+			"tokens",
+			"trustedIssuers",
+			"input",
+			"output",
+			"display",
+			"hooks",
+			"data"
+		])
+	};
+	if (!factory.data) factory.data = null;
+	getQuota(factory.input);
+	factory.hooks = (factory.hooks || []).map((x) => compileHook(x));
+	factory.address = toAddress(factory.address);
+	return validate(factory);
+};
+const update = (state, attrs, context) => {
+	const factory = {
+		...state,
+		...pick(attrs, ["numMinted", "tokens"]),
+		context: update$1(state.context, context)
+	};
+	if (factory.output?.tags === null) factory.output.tags = [];
+	return validate(factory);
+};
+const validate = (state) => {
+	const { value, error } = stateSchema.validate(state);
+	if (error) throw new Error(`Invalid factory: ${error.details.map((x) => x.message).join(", ")}`);
+	["display"].forEach((key) => {
+		if (!value[key]) delete value[key];
+	});
+	return value;
+};
+
+//#endregion
+export { create, factory_exports, update, validate };

package/esm/states/rollup-block.d.mts

@@ -0,0 +1,13 @@
+import { StateContextInput } from "../contexts/state.mjs";
+import { IRollupBlock } from "@ocap/types";
+
+//#region src/states/rollup-block.d.ts
+declare namespace rollup_block_d_exports {
+  export { create, schema, update, validate };
+}
+declare const schema: any;
+declare const create: (attrs: Partial<IRollupBlock>, context: StateContextInput) => IRollupBlock;
+declare const update: (state: IRollupBlock, context: StateContextInput) => IRollupBlock;
+declare const validate: (state: IRollupBlock) => IRollupBlock;
+//#endregion
+export { create, rollup_block_d_exports, schema, update, validate };

package/esm/states/rollup-block.mjs

@@ -0,0 +1,75 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { create as create$1, update as update$1 } from "../contexts/state.mjs";
+import { CustomError } from "@ocap/util/lib/error";
+import pick from "lodash/pick.js";
+import { Joi, patterns, schemas } from "@arcblock/validator";
+
+//#region src/states/rollup-block.ts
+var rollup_block_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	schema: () => schema,
+	update: () => update,
+	validate: () => validate
+});
+const schema = Joi.object({
+	hash: Joi.string().regex(patterns.txHash).required(),
+	height: Joi.number().integer().greater(0).required(),
+	merkleRoot: Joi.string().regex(patterns.txHash).required(),
+	previousHash: Joi.string().when("height", {
+		is: 1,
+		then: Joi.string().optional().allow(null).allow(""),
+		otherwise: Joi.string().regex(patterns.txHash).required()
+	}),
+	txsHash: Joi.string().regex(patterns.txHash).required(),
+	txs: Joi.array().items(Joi.string().regex(patterns.txHash).required()).min(1).unique().required(),
+	proposer: Joi.DID().prefix().wallet("ethereum").required(),
+	signatures: schemas.multiSig.min(1).required(),
+	rollup: Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	mintedAmount: Joi.BN().min(0).optional().allow(null).default("0"),
+	burnedAmount: Joi.BN().min(0).optional().allow(null).default("0"),
+	rewardAmount: Joi.BN().min(0).optional().allow(null).default("0"),
+	minReward: Joi.BN().min(0).required(),
+	governance: Joi.boolean().default(false),
+	context: schemas.context,
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const create = (attrs, context) => {
+	return validate({
+		context: create$1(context),
+		...pick(attrs, [
+			"hash",
+			"height",
+			"merkleRoot",
+			"previousHash",
+			"txsHash",
+			"txs",
+			"proposer",
+			"signatures",
+			"rollup",
+			"mintedAmount",
+			"burnedAmount",
+			"rewardAmount",
+			"minReward",
+			"governance",
+			"data"
+		])
+	});
+};
+const update = (state, context) => {
+	return validate({
+		...state,
+		context: update$1(state.context, context)
+	});
+};
+const validate = (state) => {
+	const { value, error } = schema.validate(state);
+	if (error) throw new CustomError("INVALID_ROLLUP_BLOCK", `Invalid rollup block: ${error.details.map((x) => x.message).join(", ")}`);
+	if (!value.data) value.data = null;
+	return value;
+};
+
+//#endregion
+export { create, rollup_block_exports, schema, update, validate };

package/esm/states/rollup.d.mts

@@ -0,0 +1,18 @@
+import { StateContextInput } from "../contexts/state.mjs";
+import { IRollupState } from "@ocap/types";
+
+//#region src/states/rollup.d.ts
+declare namespace rollup_d_exports {
+  export { close, create, migrateContract, migrateVault, pause, resume, schema, update, validate };
+}
+declare const schema: any;
+declare const create: (attrs: Partial<IRollupState>, context: StateContextInput) => IRollupState;
+declare const update: (state: IRollupState, updates: Partial<IRollupState>, context: StateContextInput) => IRollupState;
+declare const pause: (state: IRollupState, context: StateContextInput) => IRollupState;
+declare const close: (state: IRollupState, context: StateContextInput) => IRollupState;
+declare const resume: (state: IRollupState, context: StateContextInput) => IRollupState;
+declare const migrateContract: (state: IRollupState, to: string, context: StateContextInput) => IRollupState;
+declare const migrateVault: (state: IRollupState, to: string, context: StateContextInput) => IRollupState;
+declare const validate: (state: IRollupState) => IRollupState;
+//#endregion
+export { close, create, migrateContract, migrateVault, pause, resume, rollup_d_exports, schema, update, validate };

package/esm/states/rollup.mjs

@@ -0,0 +1,215 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { create as create$1, update as update$1 } from "../contexts/state.mjs";
+import { toAddress } from "@ocap/util";
+import { CustomError } from "@ocap/util/lib/error";
+import pick from "lodash/pick.js";
+import { Joi, patterns, schemas } from "@arcblock/validator";
+
+//#region src/states/rollup.ts
+var rollup_exports = /* @__PURE__ */ __exportAll({
+	close: () => close,
+	create: () => create,
+	migrateContract: () => migrateContract,
+	migrateVault: () => migrateVault,
+	pause: () => pause,
+	resume: () => resume,
+	schema: () => schema,
+	update: () => update,
+	validate: () => validate
+});
+const validator = Joi.object({
+	pk: Joi.string().required(),
+	address: Joi.DID().prefix().required(),
+	endpoint: Joi.string().uri({ scheme: [/https?/] }).required()
+});
+const schema = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_ROLLUP").required(),
+	tokenAddress: Joi.DID().prefix().role("ROLE_TOKEN").required(),
+	contractAddress: Joi.DID().prefix().wallet("ethereum").required(),
+	vaultAddress: Joi.DID().wallet("ethereum").optional().allow(null).allow(""),
+	migrateHistory: Joi.array().items(Joi.DID().prefix().wallet("ethereum")).default([]),
+	vaultHistory: Joi.array().items(Joi.DID().prefix().wallet("ethereum")).default([]),
+	paused: Joi.boolean().default(false),
+	closed: Joi.boolean().default(false),
+	seedValidators: Joi.array().items(validator).min(1).required(),
+	validators: Joi.array().items(validator).max(24).default([]),
+	minStakeAmount: Joi.BN().positive().required(),
+	maxStakeAmount: Joi.BN().min(Joi.ref("minStakeAmount")).required(),
+	minSignerCount: Joi.number().integer().min(Joi.ref("seedValidators", { adjust: (v) => v.length })).required(),
+	maxSignerCount: Joi.number().integer().min(1).max(8).min(Joi.ref("minSignerCount")).required(),
+	minBlockSize: Joi.number().integer().min(1).required(),
+	maxBlockSize: Joi.number().integer().min(1).max(15).min(Joi.ref("minBlockSize")).required(),
+	minBlockInterval: Joi.number().integer().min(1).max(3600).required(),
+	minBlockConfirmation: Joi.number().integer().min(1).max(100).required(),
+	minDepositAmount: Joi.BN().positive().less(Joi.ref("minStakeAmount")).required(),
+	maxDepositAmount: Joi.BN().greater(Joi.ref("minDepositAmount")).less(Joi.ref("minStakeAmount")).required(),
+	minWithdrawAmount: Joi.BN().positive().required(),
+	maxWithdrawAmount: Joi.BN().greater(Joi.ref("minWithdrawAmount")).required(),
+	depositFeeRate: Joi.number().integer().min(0).max(1e4).required(),
+	withdrawFeeRate: Joi.number().integer().min(0).max(1e4).required(),
+	proposerFeeShare: Joi.number().integer().min(1).max(1e4).required(),
+	publisherFeeShare: Joi.number().integer().min(1).max(1e4).required(),
+	minDepositFee: Joi.BN().positive().required(),
+	maxDepositFee: Joi.BN().min(Joi.ref("minDepositFee")).required(),
+	minWithdrawFee: Joi.BN().positive().required(),
+	maxWithdrawFee: Joi.BN().min(Joi.ref("minWithdrawFee")).required(),
+	blockHeight: Joi.number().integer().min(0).required(),
+	blockHash: Joi.string().regex(patterns.txHash).optional().allow(null).allow(""),
+	issuer: Joi.DID().prefix().optional().allow(null),
+	leaveWaitingPeriod: Joi.number().integer().min(Joi.ref("minBlockInterval")).default(0),
+	publishWaitingPeriod: Joi.number().integer().min(Joi.ref("minBlockInterval")).default(0),
+	publishSlashRate: Joi.number().integer().min(1).max(1e4).required(),
+	context: schemas.context,
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const create = (attrs, context) => {
+	const rollup = {
+		context: create$1(context),
+		paused: false,
+		closed: false,
+		migrateHistory: [],
+		vaultHistory: [],
+		blockHeight: 0,
+		blockHash: "",
+		...pick(attrs, [
+			"address",
+			"tokenAddress",
+			"vaultAddress",
+			"contractAddress",
+			"seedValidators",
+			"validators",
+			"minStakeAmount",
+			"maxStakeAmount",
+			"minSignerCount",
+			"maxSignerCount",
+			"minBlockSize",
+			"maxBlockSize",
+			"minBlockInterval",
+			"minBlockConfirmation",
+			"minDepositAmount",
+			"maxDepositAmount",
+			"minWithdrawAmount",
+			"maxWithdrawAmount",
+			"depositFeeRate",
+			"withdrawFeeRate",
+			"proposerFeeShare",
+			"publisherFeeShare",
+			"minDepositFee",
+			"maxDepositFee",
+			"minWithdrawFee",
+			"maxWithdrawFee",
+			"leaveWaitingPeriod",
+			"publishWaitingPeriod",
+			"publishSlashRate",
+			"issuer",
+			"data"
+		])
+	};
+	rollup.address = toAddress(rollup.address);
+	return validate(rollup);
+};
+const update = (state, updates, context) => {
+	if (updates.blockHeight && !updates.blockHash) throw new CustomError("INVALID_ROLLUP_UPDATE", "blockHash must be updated together with blockHeight");
+	if (updates.blockHash && !updates.blockHeight) throw new CustomError("INVALID_ROLLUP_UPDATE", "blockHeight must be updated together with blockHash");
+	if (updates.blockHeight && updates.blockHash) {
+		if (updates.blockHeight !== state.blockHeight + 1) throw new CustomError("INVALID_ROLLUP_UPDATE", "blockHeight must be incremented");
+		if (updates.blockHash === state.blockHash) throw new CustomError("INVALID_ROLLUP_UPDATE", "blockHash can not remain unchanged between blocks");
+	}
+	if (typeof updates.blockHeight !== "undefined" && !updates.blockHeight) throw new CustomError("INVALID_ROLLUP_UPDATE", "blockHeight can not be unset");
+	if (typeof updates.blockHash !== "undefined" && !updates.blockHash) throw new CustomError("INVALID_ROLLUP_UPDATE", "blockHash can not be unset");
+	return validate({
+		...state,
+		...pick(updates, [
+			"validators",
+			"minStakeAmount",
+			"maxStakeAmount",
+			"minSignerCount",
+			"maxSignerCount",
+			"minBlockSize",
+			"maxBlockSize",
+			"minBlockInterval",
+			"minBlockConfirmation",
+			"minDepositAmount",
+			"maxDepositAmount",
+			"minWithdrawAmount",
+			"maxWithdrawAmount",
+			"depositFeeRate",
+			"withdrawFeeRate",
+			"publisherFeeShare",
+			"minDepositFee",
+			"maxDepositFee",
+			"minWithdrawFee",
+			"maxWithdrawFee",
+			"blockHeight",
+			"blockHash",
+			"leaveWaitingPeriod",
+			"publishWaitingPeriod",
+			"publishSlashRate",
+			"data"
+		]),
+		context: update$1(state.context, context)
+	});
+};
+const pause = (state, context) => {
+	if (state.closed) throw new CustomError("INVALID_PAUSE_ATTEMPT", "rollup already closed");
+	if (state.paused) throw new CustomError("INVALID_PAUSE_ATTEMPT", "rollup already paused");
+	return validate({
+		...state,
+		paused: true,
+		context: update$1(state.context, context)
+	});
+};
+const close = (state, context) => {
+	if (state.closed) throw new CustomError("INVALID_CLOSE_ATTEMPT", "rollup already closed");
+	if (!state.paused) throw new CustomError("INVALID_CLOSE_ATTEMPT", "rollup must be paused");
+	return validate({
+		...state,
+		closed: true,
+		context: update$1(state.context, context)
+	});
+};
+const resume = (state, context) => {
+	if (state.closed) throw new CustomError("INVALID_RESUME_ATTEMPT", "rollup is closed");
+	if (state.paused === false) throw new CustomError("INVALID_RESUME_ATTEMPT", "rollup not paused");
+	return validate({
+		...state,
+		paused: false,
+		context: update$1(state.context, context)
+	});
+};
+const migrateContract = (state, to, context) => {
+	if (state.closed) throw new CustomError("INVALID_MIGRATE_ATTEMPT", "rollup is closed");
+	if (state.paused === false) throw new CustomError("INVALID_MIGRATE_ATTEMPT", "rollup not paused");
+	if (state.contractAddress === to) throw new CustomError("INVALID_MIGRATE_ATTEMPT", "can not migrate contract to self");
+	if (state.migrateHistory.includes(to)) throw new CustomError("INVALID_MIGRATE_ATTEMPT", "can not migrate contract to history contracts");
+	return validate({
+		...state,
+		contractAddress: to,
+		migrateHistory: [...state.migrateHistory, state.contractAddress],
+		context: update$1(state.context, context)
+	});
+};
+const migrateVault = (state, to, context) => {
+	if (state.closed) throw new CustomError("INVALID_MIGRATE_ATTEMPT", "rollup is closed");
+	if (state.paused === false) throw new CustomError("INVALID_MIGRATE_ATTEMPT", "rollup not paused");
+	if (state.vaultAddress === to) throw new CustomError("INVALID_MIGRATE_ATTEMPT", "can not migrate vault to self");
+	if (state.vaultHistory.includes(to)) throw new CustomError("INVALID_MIGRATE_ATTEMPT", "can not migrate vault to history vaults");
+	return validate({
+		...state,
+		vaultAddress: to,
+		vaultHistory: [...state.vaultHistory, state.vaultAddress],
+		context: update$1(state.context, context)
+	});
+};
+const validate = (state) => {
+	const { value, error } = schema.validate(state);
+	if (error) throw new CustomError("INVALID_ROLLUP_PROPS", error.details.map((x) => x.message).join(", "));
+	if (!value.data) value.data = null;
+	return value;
+};
+
+//#endregion
+export { close, create, migrateContract, migrateVault, pause, resume, rollup_exports, schema, update, validate };

package/esm/states/stake.d.mts

@@ -0,0 +1,13 @@
+import { StateContextInput } from "../contexts/state.mjs";
+import { IStakeState } from "@ocap/types";
+
+//#region src/states/stake.d.ts
+declare namespace stake_d_exports {
+  export { create, schema, update, validate };
+}
+declare const schema: any;
+declare const create: (attrs: Partial<IStakeState>, context: StateContextInput) => IStakeState;
+declare const update: (state: IStakeState, attrs: Partial<IStakeState>, context: StateContextInput) => IStakeState;
+declare const validate: (state: IStakeState) => IStakeState;
+//#endregion
+export { create, schema, stake_d_exports, update, validate };

package/esm/states/stake.mjs

@@ -0,0 +1,89 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { create as create$1, update as update$1 } from "../contexts/state.mjs";
+import { toAddress } from "@ocap/util";
+import { CustomError } from "@ocap/util/lib/error";
+import pick from "lodash/pick.js";
+import { Joi, schemas } from "@arcblock/validator";
+
+//#region src/states/stake.ts
+var stake_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	schema: () => schema,
+	update: () => update,
+	validate: () => validate
+});
+const schema = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_STAKE").trim().required(),
+	sender: Joi.DID().prefix().trim().required(),
+	receiver: Joi.DID().prefix().trim().required(),
+	tokens: Joi.object({}).pattern(Joi.DID().prefix().role("ROLE_TOKEN"), Joi.BN().min(0)).default({}),
+	assets: Joi.array().items(Joi.DID().prefix().role("ROLE_ASSET")).default([]),
+	slashers: Joi.array().items(Joi.DID().prefix()).default([]),
+	revocable: Joi.boolean().default(true),
+	message: Joi.string().trim().min(1).max(256).required(),
+	revokeWaitingPeriod: Joi.number().integer().min(0).default(0),
+	revokedTokens: Joi.object({}).pattern(Joi.DID().prefix().role("ROLE_TOKEN"), Joi.BN().min(0)).default({}),
+	revokedAssets: Joi.array().items(Joi.DID().prefix().role("ROLE_ASSET")).default([]),
+	context: schemas.context,
+	data: Joi.any().optional().allow(null),
+	nonce: Joi.string().trim().min(1).max(256).allow("").allow(null).optional()
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const create = (attrs, context) => {
+	const stake = {
+		tokens: {},
+		assets: [],
+		slashers: [],
+		revocable: true,
+		revokedTokens: {},
+		revokedAssets: [],
+		revokeWaitingPeriod: 0,
+		nonce: "",
+		context: create$1(context),
+		...pick(attrs, [
+			"address",
+			"sender",
+			"receiver",
+			"tokens",
+			"assets",
+			"slashers",
+			"revocable",
+			"data",
+			"nonce",
+			"message",
+			"revokeWaitingPeriod"
+		])
+	};
+	stake.address = toAddress(stake.address);
+	return validate(stake);
+};
+const update = (state, attrs, context) => {
+	return validate({
+		...state,
+		revokedTokens: state.revokedTokens ?? {},
+		revokedAssets: state.revokedAssets ?? [],
+		revokeWaitingPeriod: state.revokeWaitingPeriod ?? 0,
+		...pick(attrs, [
+			"tokens",
+			"assets",
+			"revocable",
+			"data",
+			"revokeWaitingPeriod",
+			"revokedTokens",
+			"revokedAssets"
+		]),
+		message: state.message || "empty",
+		context: update$1(state.context, context)
+	});
+};
+const validate = (state) => {
+	const { value, error } = schema.validate(state);
+	if (error) throw new CustomError("INVALID_STAKE", `Invalid stake state: ${error.details.map((x) => x.message).join(", ")}`);
+	if (!value.data) value.data = null;
+	return value;
+};
+
+//#endregion
+export { create, schema, stake_exports, update, validate };

package/esm/states/token-factory.d.mts

@@ -0,0 +1,13 @@
+import { StateContextInput } from "../contexts/state.mjs";
+import { ITokenFactoryState } from "@ocap/types";
+
+//#region src/states/token-factory.d.ts
+declare namespace token_factory_d_exports {
+  export { create, curveSchema, update, validate };
+}
+declare const curveSchema: any;
+declare const create: (attrs: Partial<ITokenFactoryState>, context: StateContextInput) => ITokenFactoryState;
+declare const update: (state: ITokenFactoryState, attrs: Partial<ITokenFactoryState>, context: StateContextInput) => ITokenFactoryState;
+declare const validate: (state: ITokenFactoryState) => ITokenFactoryState;
+//#endregion
+export { create, curveSchema, token_factory_d_exports, update, validate };

package/esm/states/token-factory.mjs

@@ -0,0 +1,76 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { create as create$1, update as update$1 } from "../contexts/state.mjs";
+import pick from "lodash/pick.js";
+import { Joi, schemas } from "@arcblock/validator";
+
+//#region src/states/token-factory.ts
+var token_factory_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	curveSchema: () => curveSchema,
+	update: () => update,
+	validate: () => validate
+});
+const curveSchema = Joi.alternatives().try(Joi.object({
+	type: Joi.string().valid("linear").required(),
+	basePrice: Joi.BN().greater(0).required(),
+	slope: Joi.BN().greater(0).required()
+}), Joi.object({
+	type: Joi.string().valid("constant").required(),
+	fixedPrice: Joi.BN().min(1).required()
+}), Joi.object({
+	type: Joi.string().valid("quadratic").required(),
+	basePrice: Joi.BN().greater(0).required(),
+	constant: Joi.number().greater(0).required()
+}));
+const stateSchema = Joi.object({
+	address: Joi.DID().prefix().role("ROLE_TOKEN_FACTORY").required(),
+	owner: Joi.alternatives().try(Joi.DID().prefix().role("ROLE_ACCOUNT"), Joi.DID().prefix().role("ROLE_APPLICATION")).required(),
+	tokenAddress: Joi.DID().prefix().role("ROLE_TOKEN").required(),
+	reserveAddress: Joi.DID().prefix().role("ROLE_TOKEN").required(),
+	currentSupply: Joi.BN().min(0).required(),
+	reserveBalance: Joi.BN().min(0).required(),
+	status: Joi.string().valid("ACTIVE", "PAUSED").required(),
+	feeRate: Joi.number().min(0).max(2e3).required(),
+	curve: curveSchema.optional().allow(null),
+	context: schemas.context,
+	data: Joi.any().optional().allow(null)
+}).options({
+	stripUnknown: true,
+	noDefaults: false
+});
+const create = (attrs, context) => {
+	const tokenFactory = {
+		context: create$1(context),
+		currentSupply: "0",
+		reserveBalance: "0",
+		status: "ACTIVE",
+		...pick(attrs, [
+			"address",
+			"owner",
+			"tokenAddress",
+			"reserveAddress",
+			"curve",
+			"feeRate",
+			"data"
+		])
+	};
+	if (!tokenFactory.data) tokenFactory.data = null;
+	return validate(tokenFactory);
+};
+const update = (state, attrs, context) => validate({
+	...state,
+	...pick(attrs, [
+		"currentSupply",
+		"reserveBalance",
+		"feeRate"
+	]),
+	context: update$1(state.context, context)
+});
+const validate = (state) => {
+	const { value, error } = stateSchema.validate(state);
+	if (error) throw new Error(`Invalid token factory: ${error.details.map((x) => x.message).join(", ")}`);
+	return value;
+};
+
+//#endregion
+export { create, curveSchema, token_factory_exports, update, validate };

package/esm/states/token.d.mts

@@ -0,0 +1,14 @@
+import { StateContextInput } from "../contexts/state.mjs";
+import { ITokenState } from "@ocap/types";
+
+//#region src/states/token.d.ts
+declare namespace token_d_exports {
+  export { create, metadataSchema, stateSchema, update, validate };
+}
+declare const metadataSchema: any;
+declare const stateSchema: any;
+declare const create: (attrs: Partial<ITokenState>, context: StateContextInput) => ITokenState;
+declare const update: (state: ITokenState, attrs: Partial<ITokenState>) => ITokenState;
+declare const validate: (state: ITokenState) => ITokenState;
+//#endregion
+export { create, metadataSchema, stateSchema, token_d_exports, update, validate };