@ocap/state 1.29.26 → 1.30.0

package/lib/states/account.cjs

@@ -22,21 +22,21 @@ var account_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	updateOrCreate: () => updateOrCreate,
 	validate: () => validate
 });
-const schema = _arcblock_validator.Joi.object({
-	address: _arcblock_validator.Joi.DID().prefix().required(),
-	pk: _arcblock_validator.Joi.string().allow(null).allow(""),
-	issuer: _arcblock_validator.Joi.DID().prefix().allow(null).allow(""),
-	moniker: _arcblock_validator.Joi.string().regex(/^[a-zA-Z0-9][-a-zA-Z0-9_]{2,128}$/).allow(""),
-	nonce: _arcblock_validator.Joi.number().min(0).default(0),
-	tokens: _arcblock_validator.Joi.object().pattern(_arcblock_validator.Joi.DID().prefix().role("ROLE_TOKEN"), _arcblock_validator.Joi.BN().min(0)).default({}),
-	migratedTo: _arcblock_validator.Joi.array().items(_arcblock_validator.Joi.DID().prefix()).default([]),
-	migratedFrom: _arcblock_validator.Joi.array().items(_arcblock_validator.Joi.DID().prefix()).default([]),
+const schema = _arcblock_validator.v.pipe(_arcblock_validator.v.object({
+	address: (0, _arcblock_validator.vDID)({ prefix: true }),
+	pk: _arcblock_validator.v.optional(_arcblock_validator.v.nullable(_arcblock_validator.v.string())),
+	issuer: _arcblock_validator.v.optional(_arcblock_validator.v.nullable(_arcblock_validator.v.union([_arcblock_validator.v.literal(""), (0, _arcblock_validator.vDID)({ prefix: true })]))),
+	moniker: _arcblock_validator.v.optional(_arcblock_validator.v.pipe(_arcblock_validator.v.string(), _arcblock_validator.v.check((s) => s === "" || /^[a-zA-Z0-9][-a-zA-Z0-9_]{2,128}$/.test(s), "Invalid moniker format"))),
+	nonce: _arcblock_validator.v.optional(_arcblock_validator.v.pipe(_arcblock_validator.v.number(), _arcblock_validator.v.minValue(0)), 0),
+	tokens: _arcblock_validator.v.optional((0, _arcblock_validator.vFilteredRecord)((0, _arcblock_validator.vDID)({
+		prefix: true,
+		role: "ROLE_TOKEN"
+	}), (0, _arcblock_validator.vBN)((0, _arcblock_validator.vBNMin)(0))), {}),
+	migratedTo: _arcblock_validator.v.optional(_arcblock_validator.v.array((0, _arcblock_validator.vDID)({ prefix: true })), []),
+	migratedFrom: _arcblock_validator.v.optional(_arcblock_validator.v.array((0, _arcblock_validator.vDID)({ prefix: true })), []),
 	context: _arcblock_validator.schemas.context,
-	data: _arcblock_validator.Joi.any().optional().allow(null)
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
+	data: _arcblock_validator.v.optional(_arcblock_validator.v.nullable(_arcblock_validator.v.any()))
+}), (0, _arcblock_validator.vStripUnknown)());
 const create = (attrs, context) => {
 	const account = {
 		nonce: 0,
@@ -82,7 +82,7 @@ const updateOrCreate = (state, attrs, context) => {
 };
 const validate = (state) => {
 	if (state.pk && typeof state.pk !== "string") state.pk = (0, _ocap_util.toBase58)(state.pk);
-	const { value, error } = schema.validate(state);
+	const { value, error } = (0, _arcblock_validator.vValidate)(schema, state);
 	if (error) throw new _ocap_util_lib_error.CustomError("INVALID_ACCOUNT", `Invalid account: ${error.details.map((x) => x.message).join(", ")}`);
 	if (!value.data) value.data = null;
 	return value;

package/lib/states/account.d.cts

@@ -1,12 +1,28 @@
 import { StateContextInput } from "../contexts/state.cjs";
 import { IAccountState } from "@ocap/types";
-import * as joi1 from "joi";
+import { v } from "@arcblock/validator";
 
 //#region src/states/account.d.ts
 declare namespace account_d_exports {
   export { create, ensureChecksumAddress, isMigrated, schema, update, updateOrCreate, validate };
 }
-declare const schema: joi1.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/lib/states/asset.cjs

@@ -9,21 +9,17 @@ let _arcblock_validator = require("@arcblock/validator");
 //#region src/states/asset.ts
 var asset_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	create: () => create,
-	schema: () => schema,
-	schemas: () => _arcblock_validator.schemas,
 	update: () => update,
 	validate: () => validate
 });
-const stateSchema = _arcblock_validator.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 = _arcblock_validator.v.pipe(_arcblock_validator.v.object({
 	..._arcblock_validator.schemas.assetProps,
-	owner: _arcblock_validator.Joi.DID().prefix().required(),
-	consumedTime: _arcblock_validator.Joi.date().iso().raw().allow(""),
+	owner: (0, _arcblock_validator.vDID)({ prefix: true }),
+	consumedTime: _arcblock_validator.v.optional(_arcblock_validator.v.pipe(_arcblock_validator.v.string(), _arcblock_validator.v.check(isIsoDateOrEmpty, "Must be valid ISO date or empty"))),
 	context: _arcblock_validator.schemas.context
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
-const schema = _arcblock_validator.schemas.assetSchema;
+}), (0, _arcblock_validator.vStripUnknown)());
 const create = (attrs, context) => {
 	const asset = {
 		consumedTime: "",
@@ -69,7 +65,7 @@ const update = (state, attrs, context) => {
 	return validate(asset);
 };
 const validate = (state) => {
-	const { value, error } = stateSchema.validate(state);
+	const { value, error } = (0, _arcblock_validator.vValidate)(stateSchema, state);
 	if (error) throw new _ocap_util_lib_error.CustomError("INVALID_ASSET", `Invalid asset: ${error.details.map((x) => x.message).join(", ")}`);
 	["endpoint", "display"].forEach((key) => {
 		if (!value[key]) delete value[key];
@@ -85,7 +81,5 @@ Object.defineProperty(exports, 'asset_exports', {
   }
 });
 exports.create = create;
-exports.schema = schema;
-exports.schemas = _arcblock_validator.schemas;
 exports.update = update;
 exports.validate = validate;

package/lib/states/asset.d.cts

@@ -1,15 +1,12 @@
 import { StateContextInput } from "../contexts/state.cjs";
 import { IAssetState } from "@ocap/types";
-import * as joi3 from "joi";
-import { schemas } from "@arcblock/validator";
 
 //#region src/states/asset.d.ts
 declare namespace asset_d_exports {
-  export { create, schema, schemas, update, validate };
+  export { create, update, validate };
 }
-declare const schema: joi3.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/lib/states/evidence.cjs

@@ -11,14 +11,11 @@ var evidence_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	schema: () => schema,
 	validate: () => validate
 });
-const schema = _arcblock_validator.Joi.object({
-	hash: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required(),
+const schema = _arcblock_validator.v.pipe(_arcblock_validator.v.object({
+	hash: _arcblock_validator.v.pipe(_arcblock_validator.v.string(), _arcblock_validator.v.regex(_arcblock_validator.patterns.txHash)),
 	context: _arcblock_validator.schemas.context,
-	data: _arcblock_validator.Joi.any().optional().allow(null)
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
+	data: _arcblock_validator.v.optional(_arcblock_validator.v.nullable(_arcblock_validator.v.any()))
+}), (0, _arcblock_validator.vStripUnknown)());
 const create = (attrs, context) => {
 	return validate({
 		context: require_contexts_state.create(context),
@@ -26,7 +23,7 @@ const create = (attrs, context) => {
 	});
 };
 const validate = (state) => {
-	const { value, error } = schema.validate(state);
+	const { value, error } = (0, _arcblock_validator.vValidate)(schema, state);
 	if (error) throw new _ocap_util_lib_error.CustomError("INVALID_EVIDENCE", `Invalid evidence state: ${error.details.map((x) => x.message).join(", ")}`);
 	if (!value.data) value.data = null;
 	return value;

package/lib/states/evidence.d.cts

@@ -1,12 +1,21 @@
 import { StateContextInput } from "../contexts/state.cjs";
 import { IEvidenceState } from "@ocap/types";
-import * as joi7 from "joi";
+import { v } from "@arcblock/validator";
 
 //#region src/states/evidence.d.ts
 declare namespace evidence_d_exports {
   export { create, schema, validate };
 }
-declare const schema: joi7.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/lib/states/factory.cjs

@@ -12,17 +12,21 @@ var factory_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
 	update: () => update,
 	validate: () => validate
 });
-const stateSchema = _arcblock_validator.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 = _arcblock_validator.v.pipe(_arcblock_validator.v.object({
 	..._arcblock_validator.schemas.factoryProps,
-	owner: _arcblock_validator.Joi.DID().prefix().required(),
-	numMinted: _arcblock_validator.Joi.number().min(0).default(0),
-	lastSettlement: _arcblock_validator.Joi.date().iso().raw().allow(""),
-	tokens: _arcblock_validator.Joi.object().pattern(_arcblock_validator.Joi.DID().prefix().role("ROLE_TOKEN"), _arcblock_validator.Joi.BN().min(0)).default({}),
+	input: _arcblock_validator.v.optional(_arcblock_validator.schemas.factoryProps.input),
+	output: _arcblock_validator.v.optional(_arcblock_validator.schemas.factoryProps.output),
+	owner: (0, _arcblock_validator.vDID)({ prefix: true }),
+	numMinted: _arcblock_validator.v.optional(_arcblock_validator.v.pipe(_arcblock_validator.v.number(), _arcblock_validator.v.minValue(0)), 0),
+	lastSettlement: _arcblock_validator.v.optional(_arcblock_validator.v.pipe(_arcblock_validator.v.string(), _arcblock_validator.v.check(isIsoDateOrEmpty, "Must be valid ISO date or empty"))),
+	tokens: _arcblock_validator.v.optional((0, _arcblock_validator.vFilteredRecord)((0, _arcblock_validator.vDID)({
+		prefix: true,
+		role: "ROLE_TOKEN"
+	}), (0, _arcblock_validator.vBN)((0, _arcblock_validator.vBNMin)(0))), {}),
 	context: _arcblock_validator.schemas.context
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
+}), (0, _arcblock_validator.vStripUnknown)());
 const compileHook = (hook) => {
 	if (hook.type === "contract") hook.compiled = (0, _ocap_contract.merge)((0, _ocap_contract.compile)(hook.hook));
 	return hook;
@@ -65,7 +69,7 @@ const update = (state, attrs, context) => {
 	return validate(factory);
 };
 const validate = (state) => {
-	const { value, error } = stateSchema.validate(state);
+	const { value, error } = (0, _arcblock_validator.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/lib/states/rollup-block.cjs

@@ -12,31 +12,33 @@ var rollup_block_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll(
 	update: () => update,
 	validate: () => validate
 });
-const schema = _arcblock_validator.Joi.object({
-	hash: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required(),
-	height: _arcblock_validator.Joi.number().integer().greater(0).required(),
-	merkleRoot: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required(),
-	previousHash: _arcblock_validator.Joi.string().when("height", {
-		is: 1,
-		then: _arcblock_validator.Joi.string().optional().allow(null).allow(""),
-		otherwise: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required()
+const schema = _arcblock_validator.v.pipe(_arcblock_validator.v.object({
+	hash: _arcblock_validator.v.pipe(_arcblock_validator.v.string(), _arcblock_validator.v.regex(_arcblock_validator.patterns.txHash)),
+	height: _arcblock_validator.v.pipe(_arcblock_validator.v.number(), _arcblock_validator.v.integer(), _arcblock_validator.v.check((n) => n > 0, "Must be greater than 0")),
+	merkleRoot: _arcblock_validator.v.pipe(_arcblock_validator.v.string(), _arcblock_validator.v.regex(_arcblock_validator.patterns.txHash)),
+	previousHash: _arcblock_validator.v.optional(_arcblock_validator.v.nullable(_arcblock_validator.v.string())),
+	txsHash: _arcblock_validator.v.pipe(_arcblock_validator.v.string(), _arcblock_validator.v.regex(_arcblock_validator.patterns.txHash)),
+	txs: _arcblock_validator.v.pipe(_arcblock_validator.v.array(_arcblock_validator.v.pipe(_arcblock_validator.v.string(), _arcblock_validator.v.regex(_arcblock_validator.patterns.txHash))), _arcblock_validator.v.minLength(1), _arcblock_validator.v.check((arr) => new Set(arr).size === arr.length, "Must contain unique values")),
+	proposer: (0, _arcblock_validator.vDID)({
+		prefix: true,
+		wallet: "ethereum"
 	}),
-	txsHash: _arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required(),
-	txs: _arcblock_validator.Joi.array().items(_arcblock_validator.Joi.string().regex(_arcblock_validator.patterns.txHash).required()).min(1).unique().required(),
-	proposer: _arcblock_validator.Joi.DID().prefix().wallet("ethereum").required(),
-	signatures: _arcblock_validator.schemas.multiSig.min(1).required(),
-	rollup: _arcblock_validator.Joi.DID().prefix().role("ROLE_ROLLUP").required(),
-	mintedAmount: _arcblock_validator.Joi.BN().min(0).optional().allow(null).default("0"),
-	burnedAmount: _arcblock_validator.Joi.BN().min(0).optional().allow(null).default("0"),
-	rewardAmount: _arcblock_validator.Joi.BN().min(0).optional().allow(null).default("0"),
-	minReward: _arcblock_validator.Joi.BN().min(0).required(),
-	governance: _arcblock_validator.Joi.boolean().default(false),
+	signatures: _arcblock_validator.v.pipe(_arcblock_validator.schemas.multiSig, _arcblock_validator.v.minLength(1)),
+	rollup: (0, _arcblock_validator.vDID)({
+		prefix: true,
+		role: "ROLE_ROLLUP"
+	}),
+	mintedAmount: _arcblock_validator.v.optional(_arcblock_validator.v.nullable((0, _arcblock_validator.vBN)((0, _arcblock_validator.vBNMin)(0))), "0"),
+	burnedAmount: _arcblock_validator.v.optional(_arcblock_validator.v.nullable((0, _arcblock_validator.vBN)((0, _arcblock_validator.vBNMin)(0))), "0"),
+	rewardAmount: _arcblock_validator.v.optional(_arcblock_validator.v.nullable((0, _arcblock_validator.vBN)((0, _arcblock_validator.vBNMin)(0))), "0"),
+	minReward: (0, _arcblock_validator.vBN)((0, _arcblock_validator.vBNMin)(0)),
+	governance: _arcblock_validator.v.optional(_arcblock_validator.v.boolean(), false),
 	context: _arcblock_validator.schemas.context,
-	data: _arcblock_validator.Joi.any().optional().allow(null)
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
+	data: _arcblock_validator.v.optional(_arcblock_validator.v.nullable(_arcblock_validator.v.any()))
+}), _arcblock_validator.v.forward(_arcblock_validator.v.check((d) => {
+	if (d.height === 1) return true;
+	return typeof d.previousHash === "string" && _arcblock_validator.patterns.txHash.test(d.previousHash);
+}, "previousHash must be a valid tx hash when height > 1"), ["previousHash"]), (0, _arcblock_validator.vStripUnknown)());
 const create = (attrs, context) => {
 	return validate({
 		context: require_contexts_state.create(context),
@@ -66,7 +68,7 @@ const update = (state, context) => {
 	});
 };
 const validate = (state) => {
-	const { value, error } = schema.validate(state);
+	const { value, error } = (0, _arcblock_validator.vValidate)(schema, state);
 	if (error) throw new _ocap_util_lib_error.CustomError("INVALID_ROLLUP_BLOCK", `Invalid rollup block: ${error.details.map((x) => x.message).join(", ")}`);
 	if (!value.data) value.data = null;
 	return value;

package/lib/states/rollup-block.d.cts

@@ -1,12 +1,46 @@
 import { StateContextInput } from "../contexts/state.cjs";
 import { IRollupBlock } from "@ocap/types";
-import * as joi0 from "joi";
+import { v } from "@arcblock/validator";
 
 //#region src/states/rollup-block.d.ts
 declare namespace rollup_block_d_exports {
   export { create, schema, update, validate };
 }
-declare const schema: joi0.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/lib/states/rollup.cjs

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

package/lib/states/rollup.d.cts

@@ -1,12 +1,72 @@
 import { StateContextInput } from "../contexts/state.cjs";
 import { IRollupState } from "@ocap/types";
-import * as joi0 from "joi";
+import { v } from "@arcblock/validator";
 
 //#region src/states/rollup.d.ts
 declare namespace rollup_d_exports {
   export { close, create, migrateContract, migrateVault, pause, resume, schema, update, validate };
 }
-declare const schema: joi0.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;