@ocap/state 1.29.27 → 1.30.1

package/esm/states/stake.d.mts

@@ -1,12 +1,32 @@
 import { StateContextInput } from "../contexts/state.mjs";
+import { v } from "@arcblock/validator";
 import { IStakeState } from "@ocap/types";
-import * as joi5 from "joi";
 
 //#region src/states/stake.d.ts
 declare namespace stake_d_exports {
   export { create, schema, update, validate };
 }
-declare const schema: joi5.ObjectSchema<any>;
+declare const schema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly address: any;
+  readonly sender: any;
+  readonly receiver: any;
+  readonly tokens: v.OptionalSchema<any, {}>;
+  readonly assets: v.OptionalSchema<v.ArraySchema<any, undefined>, readonly []>;
+  readonly slashers: v.OptionalSchema<v.ArraySchema<any, undefined>, readonly []>;
+  readonly revocable: v.OptionalSchema<v.BooleanSchema<undefined>, true>;
+  readonly message: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>;
+  readonly revokeWaitingPeriod: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, 0>;
+  readonly revokedTokens: v.OptionalSchema<any, {}>;
+  readonly revokedAssets: v.OptionalSchema<v.ArraySchema<any, undefined>, readonly []>;
+  readonly context: v.ObjectSchema<{
+    readonly genesisTime: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must be valid ISO date">]>;
+    readonly genesisTx: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must match tx hash pattern or be empty">]>;
+    readonly renaissanceTime: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must be valid ISO date">]>;
+    readonly renaissanceTx: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must match tx hash pattern or be empty">]>;
+  }, undefined>;
+  readonly data: v.OptionalSchema<v.NullableSchema<v.AnySchema, undefined>, undefined>;
+  readonly nonce: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.CheckAction<string, "Must be 1-256 chars or empty">]>, undefined>, undefined>;
+}, undefined>, 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;

package/esm/states/stake.mjs

@@ -3,7 +3,7 @@ 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";
+import { schemas, v, vBN, vBNMin, vDID, vFilteredRecord, vStripUnknown, vValidate } from "@arcblock/validator";
 
 //#region src/states/stake.ts
 var stake_exports = /* @__PURE__ */ __exportAll({
@@ -12,25 +12,37 @@ var stake_exports = /* @__PURE__ */ __exportAll({
 	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([]),
+const schema = v.pipe(v.object({
+	address: vDID({
+		prefix: true,
+		role: "ROLE_STAKE"
+	}),
+	sender: vDID({ prefix: true }),
+	receiver: vDID({ prefix: true }),
+	tokens: v.optional(vFilteredRecord(vDID({
+		prefix: true,
+		role: "ROLE_TOKEN"
+	}), vBN(vBNMin(0))), {}),
+	assets: v.optional(v.array(vDID({
+		prefix: true,
+		role: "ROLE_ASSET"
+	})), []),
+	slashers: v.optional(v.array(vDID({ prefix: true })), []),
+	revocable: v.optional(v.boolean(), true),
+	message: v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(256)),
+	revokeWaitingPeriod: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0)), 0),
+	revokedTokens: v.optional(vFilteredRecord(vDID({
+		prefix: true,
+		role: "ROLE_TOKEN"
+	}), vBN(vBNMin(0))), {}),
+	revokedAssets: v.optional(v.array(vDID({
+		prefix: true,
+		role: "ROLE_ASSET"
+	})), []),
 	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
-});
+	data: v.optional(v.nullable(v.any())),
+	nonce: v.optional(v.nullable(v.pipe(v.string(), v.trim(), v.check((s) => s === "" || s.length >= 1 && s.length <= 256, "Must be 1-256 chars or empty"))))
+}), vStripUnknown());
 const create = (attrs, context) => {
 	const stake = {
 		tokens: {},
@@ -79,7 +91,7 @@ const update = (state, attrs, context) => {
 	});
 };
 const validate = (state) => {
-	const { value, error } = schema.validate(state);
+	const { value, error } = vValidate(schema, 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;

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

@@ -1,14 +1,25 @@
 import { StateContextInput } from "../contexts/state.mjs";
+import { v } from "@arcblock/validator";
 import { ITokenFactoryState } from "@ocap/types";
-import * as joi3 from "joi";
 
 //#region src/states/token-factory.d.ts
 declare namespace token_factory_d_exports {
-  export { create, curveSchema, update, validate };
+  export { create, update, vCurveSchema, validate };
 }
-declare const curveSchema: joi3.AlternativesSchema<any>;
+declare const vCurveSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"linear", undefined>;
+  readonly basePrice: any;
+  readonly slope: any;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"constant", undefined>;
+  readonly fixedPrice: any;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"quadratic", undefined>;
+  readonly basePrice: any;
+  readonly constant: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.CheckAction<number, "Must be greater than 0">]>;
+}, undefined>], undefined>;
 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 };
+export { create, token_factory_d_exports, update, vCurveSchema, validate };

package/esm/states/token-factory.mjs

@@ -1,43 +1,59 @@
 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";
+import { schemas, v, vBN, vBNGreater, vBNMin, vDID, vStripUnknown, vValidate } from "@arcblock/validator";
 
 //#region src/states/token-factory.ts
 var token_factory_exports = /* @__PURE__ */ __exportAll({
 	create: () => create,
-	curveSchema: () => curveSchema,
 	update: () => update,
+	vCurveSchema: () => vCurveSchema,
 	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),
+const vCurveSchema = v.variant("type", [
+	v.object({
+		type: v.literal("linear"),
+		basePrice: vBN(vBNGreater(0)),
+		slope: vBN(vBNGreater(0))
+	}),
+	v.object({
+		type: v.literal("constant"),
+		fixedPrice: vBN(vBNMin(1))
+	}),
+	v.object({
+		type: v.literal("quadratic"),
+		basePrice: vBN(vBNGreater(0)),
+		constant: v.pipe(v.number(), v.check((n) => n > 0, "Must be greater than 0"))
+	})
+]);
+const stateSchema = v.pipe(v.object({
+	address: vDID({
+		prefix: true,
+		role: "ROLE_TOKEN_FACTORY"
+	}),
+	owner: v.union([vDID({
+		prefix: true,
+		role: "ROLE_ACCOUNT"
+	}), vDID({
+		prefix: true,
+		role: "ROLE_APPLICATION"
+	})]),
+	tokenAddress: vDID({
+		prefix: true,
+		role: "ROLE_TOKEN"
+	}),
+	reserveAddress: vDID({
+		prefix: true,
+		role: "ROLE_TOKEN"
+	}),
+	currentSupply: vBN(vBNMin(0)),
+	reserveBalance: vBN(vBNMin(0)),
+	status: v.picklist(["ACTIVE", "PAUSED"]),
+	feeRate: v.pipe(v.number(), v.minValue(0), v.maxValue(2e3)),
+	curve: v.optional(v.nullable(vCurveSchema)),
 	context: schemas.context,
-	data: Joi.any().optional().allow(null)
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
+	data: v.optional(v.nullable(v.any()))
+}), vStripUnknown());
 const create = (attrs, context) => {
 	const tokenFactory = {
 		context: create$1(context),
@@ -67,10 +83,10 @@ const update = (state, attrs, context) => validate({
 	context: update$1(state.context, context)
 });
 const validate = (state) => {
-	const { value, error } = stateSchema.validate(state);
+	const { value, error } = vValidate(stateSchema, 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 };
+export { create, token_factory_exports, update, vCurveSchema, validate };

package/esm/states/token.d.mts

@@ -1,13 +1,54 @@
 import { StateContextInput } from "../contexts/state.mjs";
+import { v } from "@arcblock/validator";
 import { ITokenState } from "@ocap/types";
-import * as joi6 from "joi";
 
 //#region src/states/token.d.ts
 declare namespace token_d_exports {
   export { create, metadataSchema, stateSchema, update, validate };
 }
-declare const metadataSchema: joi6.ObjectSchema<any>;
-declare const stateSchema: joi6.ObjectSchema<any>;
+declare const metadataSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly communityUrl: v.OptionalSchema<v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"", undefined>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 256, undefined>, v.CheckAction<string, "Must be HTTPS URL">]>], undefined>, undefined>, undefined>;
+  readonly issuer: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 64, undefined>]>;
+}, undefined>, any]>;
+declare const stateSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly address: any;
+  readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 32, undefined>]>;
+  readonly description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 16, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
+  readonly symbol: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 2, undefined>, v.MaxLengthAction<string, 6, undefined>, v.TransformAction<string, string>]>;
+  readonly unit: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 6, undefined>, v.TransformAction<string, string>]>;
+  readonly decimal: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 2, undefined>, v.MaxValueAction<number, 18, undefined>]>;
+  readonly icon: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+  readonly totalSupply: any;
+  readonly initialSupply: any;
+  readonly maxTotalSupply: v.OptionalSchema<v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"", undefined>, any], undefined>, undefined>, undefined>;
+  readonly foreignToken: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+    readonly type: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 32, undefined>]>;
+    readonly contractAddress: any;
+    readonly chainType: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 32, undefined>]>;
+    readonly chainName: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 32, undefined>]>;
+    readonly chainId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.CheckAction<number, "Must be positive">]>;
+  }, undefined>, undefined>, undefined>;
+  readonly issuer: v.OptionalSchema<v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"", undefined>, any], undefined>, undefined>, undefined>;
+  readonly website: v.OptionalSchema<v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"", undefined>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 256, undefined>, v.CheckAction<string, "Must be valid URL">]>], undefined>, undefined>, undefined>;
+  readonly metadata: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+    readonly type: v.PicklistSchema<["json"], undefined>;
+    readonly value: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+      readonly communityUrl: v.OptionalSchema<v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"", undefined>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 256, undefined>, v.CheckAction<string, "Must be HTTPS URL">]>], undefined>, undefined>, undefined>;
+      readonly issuer: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 64, undefined>]>;
+    }, undefined>, any]>, undefined>;
+  }, undefined>, undefined>, undefined>;
+  readonly tokenFactoryAddress: v.OptionalSchema<v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"", undefined>, any], undefined>, undefined>, undefined>;
+  readonly spenders: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.ArraySchema<any, undefined>, v.MaxLengthAction<any[], 30, undefined>]>, undefined>, undefined>;
+  readonly minters: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.ArraySchema<any, undefined>, v.MaxLengthAction<any[], 30, undefined>]>, undefined>, undefined>;
+  readonly type: v.OptionalSchema<v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"", undefined>, v.PicklistSchema<["Token", "CreditToken", "BondingCurveToken"], undefined>], undefined>, undefined>, undefined>;
+  readonly context: v.ObjectSchema<{
+    readonly genesisTime: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must be valid ISO date">]>;
+    readonly genesisTx: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must match tx hash pattern or be empty">]>;
+    readonly renaissanceTime: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must be valid ISO date">]>;
+    readonly renaissanceTx: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must match tx hash pattern or be empty">]>;
+  }, undefined>;
+  readonly data: v.OptionalSchema<v.NullableSchema<v.AnySchema, undefined>, undefined>;
+}, undefined>, 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;

package/esm/states/token.mjs

@@ -3,7 +3,7 @@ import { create as create$1 } from "../contexts/state.mjs";
 import { toChecksumAddress } from "@arcblock/did/lib/type";
 import { BN, toAddress } from "@ocap/util";
 import pick from "lodash/pick.js";
-import { Joi, schemas } from "@arcblock/validator";
+import { schemas, v, vBN, vBNGreater, vBNMin, vDID, vStripUnknown, vValidate } from "@arcblock/validator";
 import cloneDeep from "lodash/cloneDeep.js";
 
 //#region src/states/token.ts
@@ -15,47 +15,60 @@ var token_exports = /* @__PURE__ */ __exportAll({
 	validate: () => validate
 });
 const isTest = process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test" || process.env.CI;
-const metadataSchema = Joi.object({
-	communityUrl: Joi.string().uri({
-		scheme: ["https"],
-		allowRelative: false
-	}).max(256).optional().allow(null, ""),
-	issuer: Joi.string().max(64).required()
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
-const stateSchema = Joi.object({
-	address: Joi.DID().prefix().role("ROLE_TOKEN").required(),
-	name: Joi.string().min(1).max(32).required(),
-	description: Joi.string().min(16).max(128).required(),
-	symbol: Joi.string().min(2).max(6).uppercase().required(),
-	unit: Joi.string().min(1).max(6).lowercase().required(),
-	decimal: Joi.number().min(2).max(18).required(),
-	icon: Joi.string().optional().allow(null, ""),
-	totalSupply: Joi.BN().min(0).required(),
-	initialSupply: Joi.BN().min(0).required(),
-	maxTotalSupply: Joi.alternatives().try(Joi.BN().greater(0), Joi.string().valid("")).optional().allow(null),
-	foreignToken: schemas.foreignToken.optional().allow(null),
-	issuer: Joi.DID().prefix().optional().allow(null, ""),
-	website: Joi.string().uri({
-		scheme: isTest ? ["http", "https"] : ["https"],
-		allowRelative: false
-	}).max(256).optional().allow(null, ""),
-	metadata: Joi.object({
-		type: Joi.string().valid("json").required(),
-		value: metadataSchema.optional()
-	}).optional().allow(null),
-	tokenFactoryAddress: Joi.DID().prefix().role("ROLE_TOKEN_FACTORY").optional().allow(null, ""),
-	spenders: Joi.array().items(Joi.DID().prefix()).max(30).optional().allow(null),
-	minters: Joi.array().items(Joi.DID().prefix()).max(30).optional().allow(null),
-	type: Joi.string().valid("Token", "CreditToken", "BondingCurveToken").optional().allow(null, ""),
+const isValidWebsiteUrl = (s) => {
+	try {
+		const url = new URL(s);
+		return isTest ? ["http:", "https:"].includes(url.protocol) : url.protocol === "https:";
+	} catch {
+		return false;
+	}
+};
+const isHttpsUrl = (s) => {
+	try {
+		return new URL(s).protocol === "https:";
+	} catch {
+		return false;
+	}
+};
+const metadataSchema = v.pipe(v.object({
+	communityUrl: v.optional(v.nullable(v.union([v.literal(""), v.pipe(v.string(), v.maxLength(256), v.check(isHttpsUrl, "Must be HTTPS URL"))]))),
+	issuer: v.pipe(v.string(), v.maxLength(64))
+}), vStripUnknown());
+const stateSchema = v.pipe(v.object({
+	address: vDID({
+		prefix: true,
+		role: "ROLE_TOKEN"
+	}),
+	name: v.pipe(v.string(), v.minLength(1), v.maxLength(32)),
+	description: v.pipe(v.string(), v.minLength(16), v.maxLength(128)),
+	symbol: v.pipe(v.string(), v.minLength(2), v.maxLength(6), v.transform((s) => s.toUpperCase())),
+	unit: v.pipe(v.string(), v.minLength(1), v.maxLength(6), v.transform((s) => s.toLowerCase())),
+	decimal: v.pipe(v.number(), v.minValue(2), v.maxValue(18)),
+	icon: v.optional(v.nullable(v.string())),
+	totalSupply: vBN(vBNMin(0)),
+	initialSupply: vBN(vBNMin(0)),
+	maxTotalSupply: v.optional(v.nullable(v.union([v.literal(""), vBN(vBNGreater(0))]))),
+	foreignToken: v.optional(v.nullable(schemas.foreignToken)),
+	issuer: v.optional(v.nullable(v.union([v.literal(""), vDID({ prefix: true })]))),
+	website: v.optional(v.nullable(v.union([v.literal(""), v.pipe(v.string(), v.maxLength(256), v.check(isValidWebsiteUrl, "Must be valid URL"))]))),
+	metadata: v.optional(v.nullable(v.object({
+		type: v.picklist(["json"]),
+		value: v.optional(metadataSchema)
+	}))),
+	tokenFactoryAddress: v.optional(v.nullable(v.union([v.literal(""), vDID({
+		prefix: true,
+		role: "ROLE_TOKEN_FACTORY"
+	})]))),
+	spenders: v.optional(v.nullable(v.pipe(v.array(vDID({ prefix: true })), v.maxLength(30)))),
+	minters: v.optional(v.nullable(v.pipe(v.array(vDID({ prefix: true })), v.maxLength(30)))),
+	type: v.optional(v.nullable(v.union([v.literal(""), v.picklist([
+		"Token",
+		"CreditToken",
+		"BondingCurveToken"
+	])]))),
 	context: schemas.context,
-	data: Joi.any().optional().allow(null)
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
+	data: v.optional(v.nullable(v.any()))
+}), vStripUnknown());
 const create = (attrs, context) => {
 	const token = {
 		context: create$1(context),
@@ -99,8 +112,7 @@ const update = (state, attrs) => validate({
 });
 const validate = (state) => {
 	if (state.maxTotalSupply && new BN(state.maxTotalSupply).lt(new BN(state.totalSupply))) throw new Error("maxTotalSupply must be greater than or equal to totalSupply");
-	const data = cloneDeep(state);
-	const { value, error } = stateSchema.validate(data);
+	const { value, error } = vValidate(stateSchema, cloneDeep(state));
 	if (error) throw new Error(`Invalid token state: ${error.message}`);
 	return value;
 };

package/lib/_virtual/rolldown_runtime.cjs

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __exportAll = (all, symbols) => {
 	let target = {};
 	for (var name in all) {
@@ -39,5 +40,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 
+exports.__commonJSMin = __commonJSMin;
 exports.__exportAll = __exportAll;
 exports.__toESM = __toESM;