@ocap/state 1.29.26 → 1.30.0

package/esm/states/account.d.mts

@@ -1,12 +1,28 @@
 import { StateContextInput } from "../contexts/state.mjs";
+import { v } from "@arcblock/validator";
 import { IAccountState } from "@ocap/types";
-import * as joi0 from "joi";
 
 //#region src/states/account.d.ts
 declare namespace account_d_exports {
   export { create, ensureChecksumAddress, isMigrated, schema, update, updateOrCreate, validate };
 }
-declare const schema: joi0.ObjectSchema<any>;
+declare const schema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly address: any;
+  readonly pk: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+  readonly issuer: v.OptionalSchema<v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"", undefined>, any], undefined>, undefined>, undefined>;
+  readonly moniker: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Invalid moniker format">]>, undefined>;
+  readonly nonce: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>, 0>;
+  readonly tokens: v.OptionalSchema<any, {}>;
+  readonly migratedTo: v.OptionalSchema<v.ArraySchema<any, undefined>, readonly []>;
+  readonly migratedFrom: 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>;
+}, undefined>, any]>;
 declare const create: (attrs: Partial<IAccountState>, context: StateContextInput) => IAccountState;
 declare const update: (state: IAccountState, attrs: Partial<IAccountState>, context: StateContextInput) => IAccountState;
 declare const updateOrCreate: (state: IAccountState | null, attrs: Partial<IAccountState>, context: StateContextInput) => IAccountState;

package/esm/states/account.mjs

@@ -7,7 +7,7 @@ import { CustomError } from "@ocap/util/lib/error";
 import flatten from "lodash/flatten.js";
 import pick from "lodash/pick.js";
 import uniq from "lodash/uniq.js";
-import { Joi, schemas } from "@arcblock/validator";
+import { schemas, v, vBN, vBNMin, vDID, vFilteredRecord, vStripUnknown, vValidate } from "@arcblock/validator";
 
 //#region src/states/account.ts
 var account_exports = /* @__PURE__ */ __exportAll({
@@ -19,21 +19,21 @@ var account_exports = /* @__PURE__ */ __exportAll({
 	updateOrCreate: () => updateOrCreate,
 	validate: () => validate
 });
-const schema = Joi.object({
-	address: Joi.DID().prefix().required(),
-	pk: Joi.string().allow(null).allow(""),
-	issuer: Joi.DID().prefix().allow(null).allow(""),
-	moniker: Joi.string().regex(/^[a-zA-Z0-9][-a-zA-Z0-9_]{2,128}$/).allow(""),
-	nonce: Joi.number().min(0).default(0),
-	tokens: Joi.object().pattern(Joi.DID().prefix().role("ROLE_TOKEN"), Joi.BN().min(0)).default({}),
-	migratedTo: Joi.array().items(Joi.DID().prefix()).default([]),
-	migratedFrom: Joi.array().items(Joi.DID().prefix()).default([]),
+const schema = v.pipe(v.object({
+	address: vDID({ prefix: true }),
+	pk: v.optional(v.nullable(v.string())),
+	issuer: v.optional(v.nullable(v.union([v.literal(""), vDID({ prefix: true })]))),
+	moniker: v.optional(v.pipe(v.string(), v.check((s) => s === "" || /^[a-zA-Z0-9][-a-zA-Z0-9_]{2,128}$/.test(s), "Invalid moniker format"))),
+	nonce: v.optional(v.pipe(v.number(), v.minValue(0)), 0),
+	tokens: v.optional(vFilteredRecord(vDID({
+		prefix: true,
+		role: "ROLE_TOKEN"
+	}), vBN(vBNMin(0))), {}),
+	migratedTo: v.optional(v.array(vDID({ prefix: true })), []),
+	migratedFrom: v.optional(v.array(vDID({ prefix: true })), []),
 	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 account = {
 		nonce: 0,
@@ -79,7 +79,7 @@ const updateOrCreate = (state, attrs, context) => {
 };
 const validate = (state) => {
 	if (state.pk && typeof state.pk !== "string") state.pk = toBase58(state.pk);
-	const { value, error } = schema.validate(state);
+	const { value, error } = vValidate(schema, state);
 	if (error) throw new CustomError("INVALID_ACCOUNT", `Invalid account: ${error.details.map((x) => x.message).join(", ")}`);
 	if (!value.data) value.data = null;
 	return value;

package/esm/states/asset.d.mts

@@ -1,15 +1,12 @@
 import { StateContextInput } from "../contexts/state.mjs";
-import { schemas } from "@arcblock/validator";
 import { IAssetState } from "@ocap/types";
-import * as joi0 from "joi";
 
 //#region src/states/asset.d.ts
 declare namespace asset_d_exports {
-  export { create, schema, schemas, update, validate };
+  export { create, update, validate };
 }
-declare const schema: joi0.ObjectSchema<any>;
 declare const create: (attrs: Partial<IAssetState>, context: StateContextInput) => IAssetState;
 declare const update: (state: IAssetState, attrs: Partial<IAssetState>, context: StateContextInput) => IAssetState;
 declare const validate: (state: IAssetState) => IAssetState;
 //#endregion
-export { asset_d_exports, create, schema, schemas, update, validate };
+export { asset_d_exports, create, update, validate };

package/esm/states/asset.mjs

@@ -3,26 +3,22 @@ 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, vDID, vStripUnknown, vValidate } from "@arcblock/validator";
 
 //#region src/states/asset.ts
 var asset_exports = /* @__PURE__ */ __exportAll({
 	create: () => create,
-	schema: () => schema,
-	schemas: () => schemas,
 	update: () => update,
 	validate: () => validate
 });
-const stateSchema = Joi.object({
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/;
+const isIsoDateOrEmpty = (s) => s === "" || ISO_DATE_RE.test(s) && !Number.isNaN(new Date(s).getTime());
+const stateSchema = v.pipe(v.object({
 	...schemas.assetProps,
-	owner: Joi.DID().prefix().required(),
-	consumedTime: Joi.date().iso().raw().allow(""),
+	owner: vDID({ prefix: true }),
+	consumedTime: v.optional(v.pipe(v.string(), v.check(isIsoDateOrEmpty, "Must be valid ISO date or empty"))),
 	context: schemas.context
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
-const schema = schemas.assetSchema;
+}), vStripUnknown());
 const create = (attrs, context) => {
 	const asset = {
 		consumedTime: "",
@@ -68,7 +64,7 @@ const update = (state, attrs, context) => {
 	return validate(asset);
 };
 const validate = (state) => {
-	const { value, error } = stateSchema.validate(state);
+	const { value, error } = vValidate(stateSchema, state);
 	if (error) throw new CustomError("INVALID_ASSET", `Invalid asset: ${error.details.map((x) => x.message).join(", ")}`);
 	["endpoint", "display"].forEach((key) => {
 		if (!value[key]) delete value[key];
@@ -77,4 +73,4 @@ const validate = (state) => {
 };
 
 //#endregion
-export { asset_exports, create, schema, schemas, update, validate };
+export { asset_exports, create, update, validate };

package/esm/states/evidence.d.mts

@@ -1,12 +1,21 @@
 import { StateContextInput } from "../contexts/state.mjs";
+import { v } from "@arcblock/validator";
 import { IEvidenceState } from "@ocap/types";
-import * as joi1 from "joi";
 
 //#region src/states/evidence.d.ts
 declare namespace evidence_d_exports {
   export { create, schema, validate };
 }
-declare const schema: joi1.ObjectSchema<any>;
+declare const schema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly hash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, 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<IEvidenceState>, context: StateContextInput) => IEvidenceState;
 declare const validate: (state: IEvidenceState) => IEvidenceState;
 //#endregion

package/esm/states/evidence.mjs

@@ -2,7 +2,7 @@ import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
 import { create as create$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";
+import { patterns, schemas, v, vStripUnknown, vValidate } from "@arcblock/validator";
 
 //#region src/states/evidence.ts
 var evidence_exports = /* @__PURE__ */ __exportAll({
@@ -10,14 +10,11 @@ var evidence_exports = /* @__PURE__ */ __exportAll({
 	schema: () => schema,
 	validate: () => validate
 });
-const schema = Joi.object({
-	hash: Joi.string().regex(patterns.txHash).required(),
+const schema = v.pipe(v.object({
+	hash: v.pipe(v.string(), v.regex(patterns.txHash)),
 	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) => {
 	return validate({
 		context: create$1(context),
@@ -25,7 +22,7 @@ const create = (attrs, context) => {
 	});
 };
 const validate = (state) => {
-	const { value, error } = schema.validate(state);
+	const { value, error } = vValidate(schema, state);
 	if (error) throw new CustomError("INVALID_EVIDENCE", `Invalid evidence state: ${error.details.map((x) => x.message).join(", ")}`);
 	if (!value.data) value.data = null;
 	return value;

package/esm/states/factory.mjs

@@ -2,7 +2,7 @@ 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 { schemas, v, vBN, vBNMin, vDID, vFilteredRecord, vStripUnknown, vValidate } from "@arcblock/validator";
 import { compile, getQuota, merge } from "@ocap/contract";
 
 //#region src/states/factory.ts
@@ -11,17 +11,21 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 	update: () => update,
 	validate: () => validate
 });
-const stateSchema = Joi.object({
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/;
+const isIsoDateOrEmpty = (s) => s === "" || ISO_DATE_RE.test(s) && !Number.isNaN(new Date(s).getTime());
+const stateSchema = v.pipe(v.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({}),
+	input: v.optional(schemas.factoryProps.input),
+	output: v.optional(schemas.factoryProps.output),
+	owner: vDID({ prefix: true }),
+	numMinted: v.optional(v.pipe(v.number(), v.minValue(0)), 0),
+	lastSettlement: v.optional(v.pipe(v.string(), v.check(isIsoDateOrEmpty, "Must be valid ISO date or empty"))),
+	tokens: v.optional(vFilteredRecord(vDID({
+		prefix: true,
+		role: "ROLE_TOKEN"
+	}), vBN(vBNMin(0))), {}),
 	context: schemas.context
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
+}), vStripUnknown());
 const compileHook = (hook) => {
 	if (hook.type === "contract") hook.compiled = merge(compile(hook.hook));
 	return hook;
@@ -64,7 +68,7 @@ const update = (state, attrs, context) => {
 	return validate(factory);
 };
 const validate = (state) => {
-	const { value, error } = stateSchema.validate(state);
+	const { value, error } = vValidate(stateSchema, state);
 	if (error) throw new Error(`Invalid factory: ${error.details.map((x) => x.message).join(", ")}`);
 	["display"].forEach((key) => {
 		if (!value[key]) delete value[key];

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

@@ -1,12 +1,46 @@
 import { StateContextInput } from "../contexts/state.mjs";
+import { v } from "@arcblock/validator";
 import { IRollupBlock } from "@ocap/types";
-import * as joi2 from "joi";
 
 //#region src/states/rollup-block.d.ts
 declare namespace rollup_block_d_exports {
   export { create, schema, update, validate };
 }
-declare const schema: joi2.ObjectSchema<any>;
+declare const schema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly hash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+  readonly height: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.CheckAction<number, "Must be greater than 0">]>;
+  readonly merkleRoot: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+  readonly previousHash: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+  readonly txsHash: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+  readonly txs: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>, v.CheckAction<string[], "Must contain unique values">]>;
+  readonly proposer: any;
+  readonly signatures: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+    readonly signer: any;
+    readonly pk: v.AnySchema;
+    readonly signature: v.AnySchema;
+    readonly delegator: v.OptionalSchema<v.UnionSchema<[v.LiteralSchema<"", undefined>, any], undefined>, undefined>;
+    readonly data: v.OptionalSchema<v.AnySchema, undefined>;
+  }, undefined>, undefined>, v.MinLengthAction<{
+    readonly signer?: any;
+    pk: any;
+    signature: any;
+    delegator?: any;
+    data?: any;
+  }[], 1, undefined>]>;
+  readonly rollup: any;
+  readonly mintedAmount: v.OptionalSchema<v.NullableSchema<any, undefined>, "0">;
+  readonly burnedAmount: v.OptionalSchema<v.NullableSchema<any, undefined>, "0">;
+  readonly rewardAmount: v.OptionalSchema<v.NullableSchema<any, undefined>, "0">;
+  readonly minReward: any;
+  readonly governance: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+  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>, v.BaseValidation<any, any, v.CheckIssue<any>>, any]>;
 declare const create: (attrs: Partial<IRollupBlock>, context: StateContextInput) => IRollupBlock;
 declare const update: (state: IRollupBlock, context: StateContextInput) => IRollupBlock;
 declare const validate: (state: IRollupBlock) => IRollupBlock;

package/esm/states/rollup-block.mjs

@@ -2,7 +2,7 @@ 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";
+import { patterns, schemas, v, vBN, vBNMin, vDID, vStripUnknown, vValidate } from "@arcblock/validator";
 
 //#region src/states/rollup-block.ts
 var rollup_block_exports = /* @__PURE__ */ __exportAll({
@@ -11,31 +11,33 @@ var rollup_block_exports = /* @__PURE__ */ __exportAll({
 	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()
+const schema = v.pipe(v.object({
+	hash: v.pipe(v.string(), v.regex(patterns.txHash)),
+	height: v.pipe(v.number(), v.integer(), v.check((n) => n > 0, "Must be greater than 0")),
+	merkleRoot: v.pipe(v.string(), v.regex(patterns.txHash)),
+	previousHash: v.optional(v.nullable(v.string())),
+	txsHash: v.pipe(v.string(), v.regex(patterns.txHash)),
+	txs: v.pipe(v.array(v.pipe(v.string(), v.regex(patterns.txHash))), v.minLength(1), v.check((arr) => new Set(arr).size === arr.length, "Must contain unique values")),
+	proposer: vDID({
+		prefix: true,
+		wallet: "ethereum"
 	}),
-	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),
+	signatures: v.pipe(schemas.multiSig, v.minLength(1)),
+	rollup: vDID({
+		prefix: true,
+		role: "ROLE_ROLLUP"
+	}),
+	mintedAmount: v.optional(v.nullable(vBN(vBNMin(0))), "0"),
+	burnedAmount: v.optional(v.nullable(vBN(vBNMin(0))), "0"),
+	rewardAmount: v.optional(v.nullable(vBN(vBNMin(0))), "0"),
+	minReward: vBN(vBNMin(0)),
+	governance: v.optional(v.boolean(), false),
 	context: schemas.context,
-	data: Joi.any().optional().allow(null)
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
+	data: v.optional(v.nullable(v.any()))
+}), v.forward(v.check((d) => {
+	if (d.height === 1) return true;
+	return typeof d.previousHash === "string" && patterns.txHash.test(d.previousHash);
+}, "previousHash must be a valid tx hash when height > 1"), ["previousHash"]), vStripUnknown());
 const create = (attrs, context) => {
 	return validate({
 		context: create$1(context),
@@ -65,7 +67,7 @@ const update = (state, context) => {
 	});
 };
 const validate = (state) => {
-	const { value, error } = schema.validate(state);
+	const { value, error } = vValidate(schema, 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;

package/esm/states/rollup.d.mts

@@ -1,12 +1,72 @@
 import { StateContextInput } from "../contexts/state.mjs";
+import { v } from "@arcblock/validator";
 import { IRollupState } from "@ocap/types";
-import * as joi4 from "joi";
 
 //#region src/states/rollup.d.ts
 declare namespace rollup_d_exports {
   export { close, create, migrateContract, migrateVault, pause, resume, schema, update, validate };
 }
-declare const schema: joi4.ObjectSchema<any>;
+declare const schema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly address: any;
+  readonly tokenAddress: any;
+  readonly contractAddress: any;
+  readonly vaultAddress: v.OptionalSchema<v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"", undefined>, any], undefined>, undefined>, undefined>;
+  readonly migrateHistory: v.OptionalSchema<v.ArraySchema<any, undefined>, readonly []>;
+  readonly vaultHistory: v.OptionalSchema<v.ArraySchema<any, undefined>, readonly []>;
+  readonly paused: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+  readonly closed: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+  readonly seedValidators: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+    readonly pk: v.StringSchema<undefined>;
+    readonly address: any;
+    readonly endpoint: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must be a valid HTTP/HTTPS URL">]>;
+  }, undefined>, undefined>, v.MinLengthAction<{
+    pk: string;
+    readonly address?: any;
+    endpoint: string;
+  }[], 1, undefined>]>;
+  readonly validators: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+    readonly pk: v.StringSchema<undefined>;
+    readonly address: any;
+    readonly endpoint: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must be a valid HTTP/HTTPS URL">]>;
+  }, undefined>, undefined>, v.MaxLengthAction<{
+    pk: string;
+    readonly address?: any;
+    endpoint: string;
+  }[], 24, undefined>]>, readonly []>;
+  readonly minStakeAmount: any;
+  readonly maxStakeAmount: any;
+  readonly minSignerCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+  readonly maxSignerCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 8, undefined>]>;
+  readonly minBlockSize: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+  readonly maxBlockSize: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 15, undefined>]>;
+  readonly minBlockInterval: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 3600, undefined>]>;
+  readonly minBlockConfirmation: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 100, undefined>]>;
+  readonly minDepositAmount: any;
+  readonly maxDepositAmount: any;
+  readonly minWithdrawAmount: any;
+  readonly maxWithdrawAmount: any;
+  readonly depositFeeRate: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 10000, undefined>]>;
+  readonly withdrawFeeRate: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 10000, undefined>]>;
+  readonly proposerFeeShare: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 10000, undefined>]>;
+  readonly publisherFeeShare: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 10000, undefined>]>;
+  readonly minDepositFee: any;
+  readonly maxDepositFee: any;
+  readonly minWithdrawFee: any;
+  readonly maxWithdrawFee: any;
+  readonly blockHeight: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  readonly blockHash: v.OptionalSchema<v.NullableSchema<v.UnionSchema<[v.LiteralSchema<"", undefined>, v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>], undefined>, undefined>, undefined>;
+  readonly issuer: v.OptionalSchema<v.NullableSchema<any, undefined>, undefined>;
+  readonly leaveWaitingPeriod: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, 0>;
+  readonly publishWaitingPeriod: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, 0>;
+  readonly publishSlashRate: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 10000, 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>, v.BaseValidation<any, any, v.CheckIssue<any>>, v.BaseValidation<any, any, v.CheckIssue<any>>, v.BaseValidation<any, any, v.CheckIssue<any>>, v.BaseValidation<any, any, v.CheckIssue<any>>, v.BaseValidation<any, any, v.CheckIssue<any>>, v.BaseValidation<any, any, v.CheckIssue<any>>, v.BaseValidation<any, any, v.CheckIssue<any>>, v.BaseValidation<any, any, v.CheckIssue<any>>, v.BaseValidation<any, any, v.CheckIssue<any>>, v.BaseValidation<any, any, v.CheckIssue<any>>, v.BaseValidation<any, any, v.CheckIssue<any>>, 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;

package/esm/states/rollup.mjs

@@ -1,9 +1,10 @@
-import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { __exportAll, __toESM } from "../_virtual/rolldown_runtime.mjs";
 import { create as create$1, update as update$1 } from "../contexts/state.mjs";
+import { require_bn } from "../node_modules/bn.js/lib/bn.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";
+import { patterns, schemas, v, vBN, vBNPositive, vDID, vStripUnknown, vValidate } from "@arcblock/validator";
 
 //#region src/states/rollup.ts
 var rollup_exports = /* @__PURE__ */ __exportAll({
@@ -17,54 +18,77 @@ var rollup_exports = /* @__PURE__ */ __exportAll({
 	update: () => update,
 	validate: () => validate
 });
-const validator = Joi.object({
-	pk: Joi.string().required(),
-	address: Joi.DID().prefix().required(),
-	endpoint: Joi.string().uri({ scheme: [/https?/] }).required()
+var import_bn = /* @__PURE__ */ __toESM(require_bn(), 1);
+const isHttpOrHttpsUrl = (s) => {
+	try {
+		return ["http:", "https:"].includes(new URL(s).protocol);
+	} catch {
+		return false;
+	}
+};
+const validatorSchema = v.object({
+	pk: v.string(),
+	address: vDID({ prefix: true }),
+	endpoint: v.pipe(v.string(), v.check(isHttpOrHttpsUrl, "Must be a valid HTTP/HTTPS URL"))
 });
-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(),
+const schema = v.pipe(v.object({
+	address: vDID({
+		prefix: true,
+		role: "ROLE_ROLLUP"
+	}),
+	tokenAddress: vDID({
+		prefix: true,
+		role: "ROLE_TOKEN"
+	}),
+	contractAddress: vDID({
+		prefix: true,
+		wallet: "ethereum"
+	}),
+	vaultAddress: v.optional(v.nullable(v.union([v.literal(""), vDID({ wallet: "ethereum" })]))),
+	migrateHistory: v.optional(v.array(vDID({
+		prefix: true,
+		wallet: "ethereum"
+	})), []),
+	vaultHistory: v.optional(v.array(vDID({
+		prefix: true,
+		wallet: "ethereum"
+	})), []),
+	paused: v.optional(v.boolean(), false),
+	closed: v.optional(v.boolean(), false),
+	seedValidators: v.pipe(v.array(validatorSchema), v.minLength(1)),
+	validators: v.optional(v.pipe(v.array(validatorSchema), v.maxLength(24)), []),
+	minStakeAmount: vBN(vBNPositive()),
+	maxStakeAmount: vBN(),
+	minSignerCount: v.pipe(v.number(), v.integer()),
+	maxSignerCount: v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(8)),
+	minBlockSize: v.pipe(v.number(), v.integer(), v.minValue(1)),
+	maxBlockSize: v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(15)),
+	minBlockInterval: v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(3600)),
+	minBlockConfirmation: v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(100)),
+	minDepositAmount: vBN(vBNPositive()),
+	maxDepositAmount: vBN(),
+	minWithdrawAmount: vBN(vBNPositive()),
+	maxWithdrawAmount: vBN(),
+	depositFeeRate: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(1e4)),
+	withdrawFeeRate: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(1e4)),
+	proposerFeeShare: v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(1e4)),
+	publisherFeeShare: v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(1e4)),
+	minDepositFee: vBN(vBNPositive()),
+	maxDepositFee: vBN(),
+	minWithdrawFee: vBN(vBNPositive()),
+	maxWithdrawFee: vBN(),
+	blockHeight: v.pipe(v.number(), v.integer(), v.minValue(0)),
+	blockHash: v.optional(v.nullable(v.union([v.literal(""), v.pipe(v.string(), v.regex(patterns.txHash))]))),
+	issuer: v.optional(v.nullable(vDID({ prefix: true }))),
+	leaveWaitingPeriod: v.optional(v.pipe(v.number(), v.integer()), 0),
+	publishWaitingPeriod: v.optional(v.pipe(v.number(), v.integer()), 0),
+	publishSlashRate: v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(1e4)),
 	context: schemas.context,
-	data: Joi.any().optional().allow(null)
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
+	data: v.optional(v.nullable(v.any()))
+}), v.forward(v.check((d) => new import_bn.default(d.maxStakeAmount).gte(new import_bn.default(d.minStakeAmount)), "maxStakeAmount must be >= minStakeAmount"), ["maxStakeAmount"]), v.forward(v.check((d) => d.minSignerCount >= d.seedValidators.length, "minSignerCount must be >= seedValidators count"), ["minSignerCount"]), v.forward(v.check((d) => d.maxSignerCount >= d.minSignerCount, "maxSignerCount must be >= minSignerCount"), ["maxSignerCount"]), v.forward(v.check((d) => d.maxBlockSize >= d.minBlockSize, "maxBlockSize must be >= minBlockSize"), ["maxBlockSize"]), v.forward(v.check((d) => new import_bn.default(d.minDepositAmount).lt(new import_bn.default(d.minStakeAmount)), "minDepositAmount must be < minStakeAmount"), ["minDepositAmount"]), v.forward(v.check((d) => {
+	const max = new import_bn.default(d.maxDepositAmount);
+	return max.gt(new import_bn.default(d.minDepositAmount)) && max.lt(new import_bn.default(d.minStakeAmount));
+}, "maxDepositAmount must be > minDepositAmount and < minStakeAmount"), ["maxDepositAmount"]), v.forward(v.check((d) => new import_bn.default(d.maxWithdrawAmount).gt(new import_bn.default(d.minWithdrawAmount)), "maxWithdrawAmount must be > minWithdrawAmount"), ["maxWithdrawAmount"]), v.forward(v.check((d) => new import_bn.default(d.maxDepositFee).gte(new import_bn.default(d.minDepositFee)), "maxDepositFee must be >= minDepositFee"), ["maxDepositFee"]), v.forward(v.check((d) => new import_bn.default(d.maxWithdrawFee).gte(new import_bn.default(d.minWithdrawFee)), "maxWithdrawFee must be >= minWithdrawFee"), ["maxWithdrawFee"]), v.forward(v.check((d) => d.leaveWaitingPeriod >= d.minBlockInterval, "leaveWaitingPeriod must be >= minBlockInterval"), ["leaveWaitingPeriod"]), v.forward(v.check((d) => d.publishWaitingPeriod >= d.minBlockInterval, "publishWaitingPeriod must be >= minBlockInterval"), ["publishWaitingPeriod"]), vStripUnknown());
 const create = (attrs, context) => {
 	const rollup = {
 		context: create$1(context),
@@ -205,7 +229,7 @@ const migrateVault = (state, to, context) => {
 	});
 };
 const validate = (state) => {
-	const { value, error } = schema.validate(state);
+	const { value, error } = vValidate(schema, state);
 	if (error) throw new CustomError("INVALID_ROLLUP_PROPS", error.details.map((x) => x.message).join(", "));
 	if (!value.data) value.data = null;
 	return value;