@arcblock/did-connect-js 1.29.27 → 1.30.0

package/esm/schema/claims.d.mts

@@ -1,18 +1,16 @@
-import { ObjectSchema } from "joi";
-
 //#region src/schema/claims.d.ts
 interface ClaimsSchema {
-  authPrincipal: ObjectSchema;
-  profile: ObjectSchema;
-  signature: ObjectSchema;
-  prepareTx: ObjectSchema;
-  agreement: ObjectSchema;
-  verifiableCredential: ObjectSchema;
-  asset: ObjectSchema;
-  assetOrVC: ObjectSchema;
-  keyPair: ObjectSchema;
-  encryptionKey: ObjectSchema;
+  authPrincipal: any;
+  profile: any;
+  signature: any;
+  prepareTx: any;
+  agreement: any;
+  verifiableCredential: any;
+  asset: any;
+  assetOrVC: any;
+  keyPair: any;
+  encryptionKey: any;
 }
-declare const _default: (chainInfo: ObjectSchema) => ClaimsSchema;
+declare const _default: (chainInfo: any) => ClaimsSchema;
 //#endregion
 export { ClaimsSchema, _default as default };

package/esm/schema/claims.mjs

@@ -1,150 +1,212 @@
-import { Joi } from "@arcblock/validator";
+import { any, array, boolean, check, literal, looseObject, maxValue, minLength, minValue, number, object, optional, picklist, pipe, rawTransform, regex, string, transform, union } from "../node_modules/valibot/dist/index.mjs";
+import { vBNPositive, vDID } from "@arcblock/validator";
 import { types } from "@ocap/mcrypto";
 
 //#region src/schema/claims.ts
-const trustedIssuerSchema = Joi.alternatives().try(Joi.object({
-	did: Joi.DID().required(),
-	endpoint: Joi.string().uri({ scheme: ["http", "https"] }).required()
-}), Joi.DID().required());
-const optionalUrlSchema = Joi.string().uri({
-	scheme: ["http", "https"],
-	allowRelative: true
-}).optional().default("").allow("");
-const requirementSchema = Joi.object({
-	tokens: Joi.array().items(Joi.object({
-		address: Joi.DID().required(),
-		value: Joi.BN().positive().required()
-	})).required(),
-	assets: Joi.object({
-		address: Joi.array().items(Joi.DID()).optional(),
-		parent: Joi.array().items(Joi.DID()).optional(),
-		issuer: Joi.array().items(Joi.DID()).optional(),
-		amount: Joi.number().positive().min(1)
-	}).optional()
+const trustedIssuerSchema = union([object({
+	did: vDID(),
+	endpoint: pipe(string(), check((s) => {
+		try {
+			const url = new URL(s);
+			return ["http:", "https:"].includes(url.protocol);
+		} catch {
+			return false;
+		}
+	}, "Must be a valid HTTP/HTTPS URL"))
+}), vDID()]);
+const optionalUrlSchema = optional(pipe(string(), check((s) => {
+	if (s === "") return true;
+	try {
+		const url = new URL(s);
+		return ["http:", "https:"].includes(url.protocol);
+	} catch {
+		return s.startsWith("/");
+	}
+}, "Must be a valid URL")), "");
+const requirementSchema = object({
+	tokens: array(object({
+		address: vDID(),
+		value: vBNPositive()
+	})),
+	assets: optional(object({
+		address: optional(array(vDID())),
+		parent: optional(array(vDID())),
+		issuer: optional(array(vDID())),
+		amount: optional(pipe(number(), check((n) => n > 0, "Must be positive"), minValue(1)))
+	}))
 });
-const targetTypeSchema = Joi.object({
-	key: Joi.string().valid(...Object.keys(types.KeyType).map((x) => x.toLowerCase())).default("ed25519"),
-	hash: Joi.string().valid(...Object.keys(types.HashType).map((x) => x.toLowerCase())).default("sha3"),
-	role: Joi.string().valid(...Object.keys(types.RoleType).map((x) => x.toLowerCase().split("_").pop())).default("account"),
-	encoding: Joi.string().valid(...Object.keys(types.EncodingType).map((x) => x.toLowerCase())).default("base58")
-}).optional();
+const targetTypeSchema = optional(object({
+	key: optional(picklist(Object.keys(types.KeyType).map((x) => x.toLowerCase())), "ed25519"),
+	hash: optional(picklist(Object.keys(types.HashType).map((x) => x.toLowerCase())), "sha3"),
+	role: optional(picklist(Object.keys(types.RoleType).map((x) => x.toLowerCase().split("_").pop())), "account"),
+	encoding: optional(picklist(Object.keys(types.EncodingType).map((x) => x.toLowerCase())), "base58")
+}));
 var claims_default = (chainInfo) => {
-	const options = {
-		stripUnknown: true,
-		noDefaults: false
-	};
 	const createStandardFields = (type, description) => ({
-		type: Joi.string().valid(type).default(type),
-		description: Joi.string().min(1).default(description),
-		chainInfo,
-		mfaCode: Joi.array().items(Joi.number().min(10).max(99).optional()).default([]),
-		meta: Joi.any().optional().default({})
+		type: optional(literal(type), type),
+		description: optional(pipe(string(), minLength(1)), description),
+		chainInfo: optional(chainInfo),
+		mfaCode: optional(array(optional(pipe(number(), minValue(10), maxValue(99)))), []),
+		meta: optional(any(), {})
 	});
-	const authPrincipal = Joi.object({
+	const authPrincipal = object({
 		...createStandardFields("authPrincipal", "Please continue with your account"),
-		target: Joi.DID().optional().allow("").default(""),
-		supervised: Joi.boolean().default(false),
+		target: optional(union([literal(""), vDID()]), ""),
+		supervised: optional(boolean(), false),
 		targetType: targetTypeSchema
-	}).options(options);
-	const keyPair = Joi.object({
+	});
+	const keyPair = object({
 		...createStandardFields("keyPair", "Please create account to continue."),
-		moniker: Joi.string().regex(/^[a-zA-Z0-9][-a-zA-Z0-9_]{2,128}$/).required(),
-		declare: Joi.boolean().optional().default(true),
-		migrateFrom: Joi.DID().optional().allow("").default(""),
+		moniker: pipe(string(), regex(/^[a-zA-Z0-9][-a-zA-Z0-9_]{2,128}$/)),
+		declare: optional(boolean(), true),
+		migrateFrom: optional(union([literal(""), vDID()]), ""),
 		targetType: targetTypeSchema
-	}).options(options);
-	const encryptionKey = Joi.object({
+	});
+	const encryptionKey = object({
 		...createStandardFields("encryptionKey", "Please provide encryptionKey to continue."),
-		salt: Joi.string().required(),
-		delegation: Joi.string().optional().allow("").default("")
-	}).options(options);
+		salt: string(),
+		delegation: optional(union([literal(""), string()]), "")
+	});
+	const profileItemValues = [
+		"did",
+		"fullName",
+		"email",
+		"phone",
+		"signature",
+		"avatar",
+		"birthday",
+		"url"
+	];
+	const profile = pipe(looseObject({ ...createStandardFields("profile", "Please provide your profile to continue.") }), transform((obj) => {
+		const { fields, ...rest } = obj;
+		if (fields !== void 0) return {
+			...rest,
+			items: fields
+		};
+		return rest;
+	}), rawTransform(({ dataset, addIssue, NEVER }) => {
+		const obj = dataset.value;
+		const items = obj.items ?? ["fullName"];
+		if (!Array.isArray(items) || items.length < 1) {
+			addIssue({ message: "\"items\" must contain at least 1 items" });
+			return NEVER;
+		}
+		const validSet = new Set(profileItemValues);
+		for (let i = 0; i < items.length; i++) if (!validSet.has(items[i])) {
+			addIssue({ message: `"items[${i}]" must be one of [${[...profileItemValues].join(", ")}]` });
+			return NEVER;
+		}
+		return {
+			...obj,
+			items
+		};
+	}));
+	const signature = object({
+		...createStandardFields("signature", "Sign this transaction or message to continue."),
+		typeUrl: picklist([
+			"fg:x:delegation",
+			"fg:t:transaction",
+			"mime:text/plain",
+			"mime:text/html",
+			"eth:transaction",
+			"eth:standard-data",
+			"eth:personal-data",
+			"eth:typed-data",
+			"eth:legacy-data"
+		]),
+		display: optional(union([literal(""), string()]), ""),
+		method: optional(picklist(["none", ...Object.keys(types.HashType).map((x) => x.toLowerCase())]), "sha3"),
+		digest: optional(union([literal(""), string()]), ""),
+		origin: optional(union([literal(""), string()]), ""),
+		nonce: optional(union([literal(""), string()]), ""),
+		requirement: optional(requirementSchema)
+	});
+	const prepareTx = object({
+		...createStandardFields("prepareTx", "Prepare and sign this transaction to continue."),
+		display: optional(union([literal(""), string()]), ""),
+		partialTx: string(),
+		nonce: optional(union([literal(""), string()]), ""),
+		requirement: requirementSchema
+	});
+	const agreement = object({
+		...createStandardFields("agreement", "Confirm your agreement to continue."),
+		uri: union([literal(""), pipe(string(), check((s) => {
+			try {
+				const url = new URL(s);
+				return ["http:", "https:"].includes(url.protocol);
+			} catch {
+				return false;
+			}
+		}, "Must be a valid HTTP/HTTPS URL"))]),
+		method: optional(picklist(Object.keys(types.HashType).map((x) => x.toLowerCase())), "sha2"),
+		digest: string()
+	});
+	const vcFilterSchema = object({
+		type: optional(pipe(array(pipe(string(), minLength(1))), minLength(1))),
+		target: optional(vDID()),
+		trustedIssuers: optional(pipe(array(trustedIssuerSchema), minLength(1))),
+		tag: optional(pipe(string(), check((s) => s === "" || s.length >= 1, "Must be non-empty or empty string")), ""),
+		ownerDid: optional(array(vDID()), []),
+		claimUrl: optionalUrlSchema,
+		acquireUrl: optionalUrlSchema
+	});
+	const verifiableCredential = object({
+		...createStandardFields("verifiableCredential", "Please present a verifiable credential to continue."),
+		optional: optional(boolean(), false),
+		claimUrl: optionalUrlSchema,
+		acquireUrl: optionalUrlSchema,
+		item: optional(pipe(array(pipe(string(), minLength(1))), minLength(1))),
+		target: optional(vDID()),
+		trustedIssuers: optional(pipe(array(trustedIssuerSchema), minLength(1))),
+		tag: optional(pipe(string(), check((s) => s === "" || s.length >= 1, "Must be non-empty or empty string")), ""),
+		ownerDid: optional(array(vDID()), []),
+		filters: optional(array(vcFilterSchema))
+	});
+	const assetFilterSchema = object({
+		address: optional(vDID()),
+		trustedIssuers: optional(pipe(array(trustedIssuerSchema), minLength(1))),
+		trustedParents: optional(pipe(array(vDID()), minLength(1))),
+		tag: optional(pipe(string(), check((s) => s === "" || s.length >= 1, "Must be non-empty or empty string")), ""),
+		ownerDid: optional(array(vDID()), []),
+		consumed: optional(boolean()),
+		acquireUrl: optionalUrlSchema
+	});
+	const asset = object({
+		...createStandardFields("asset", "Please present an on chain asset to continue."),
+		optional: optional(boolean(), false),
+		address: optional(vDID()),
+		trustedIssuers: optional(pipe(array(trustedIssuerSchema), minLength(1))),
+		trustedParents: optional(pipe(array(vDID()), minLength(1))),
+		tag: optional(pipe(string(), check((s) => s === "" || s.length >= 1, "Must be non-empty or empty string")), ""),
+		ownerDid: optional(array(vDID()), []),
+		consumed: optional(boolean()),
+		acquireUrl: optionalUrlSchema,
+		filters: optional(array(assetFilterSchema))
+	});
+	const assetOrVCFilterSchema = object({
+		type: optional(pipe(array(pipe(string(), minLength(1))), minLength(1))),
+		address: optional(vDID()),
+		trustedIssuers: optional(pipe(array(trustedIssuerSchema), minLength(1))),
+		trustedParents: optional(pipe(array(vDID()), minLength(1))),
+		tag: optional(pipe(string(), check((s) => s === "" || s.length >= 1, "Must be non-empty or empty string")), ""),
+		ownerDid: optional(array(vDID()), []),
+		consumed: optional(boolean()),
+		claimUrl: optionalUrlSchema,
+		acquireUrl: optionalUrlSchema
+	});
 	return {
 		authPrincipal,
-		profile: Joi.object({
-			...createStandardFields("profile", "Please provide your profile to continue."),
-			items: Joi.array().items(Joi.string().valid("did", "fullName", "email", "phone", "signature", "avatar", "birthday", "url")).min(1).default(["fullName"])
-		}).rename("fields", "items", {
-			ignoreUndefined: true,
-			override: true
-		}).options(options),
-		signature: Joi.object({
-			...createStandardFields("signature", "Sign this transaction or message to continue."),
-			typeUrl: Joi.string().valid("fg:x:delegation", "fg:t:transaction", "mime:text/plain", "mime:text/html", "eth:transaction", "eth:standard-data", "eth:personal-data", "eth:typed-data", "eth:legacy-data").required(),
-			display: Joi.string().allow("").default(""),
-			method: Joi.string().allow("none", ...Object.keys(types.HashType).map((x) => x.toLowerCase())).optional().default("sha3"),
-			digest: Joi.string().allow("").default(""),
-			origin: Joi.string().allow("").default(""),
-			nonce: Joi.string().allow("").default(""),
-			requirement: requirementSchema.optional()
-		}).options(options),
-		prepareTx: Joi.object({
-			...createStandardFields("prepareTx", "Prepare and sign this transaction to continue."),
-			display: Joi.string().allow("").default(""),
-			partialTx: Joi.string().required(),
-			nonce: Joi.string().allow("").default(""),
-			requirement: requirementSchema.required()
-		}).options(options),
-		agreement: Joi.object({
-			...createStandardFields("agreement", "Confirm your agreement to continue."),
-			uri: Joi.string().uri({ scheme: ["http", "https"] }).required().allow(""),
-			method: Joi.string().allow(...Object.keys(types.HashType).map((x) => x.toLowerCase())).optional().default("sha2"),
-			digest: Joi.string().required()
-		}).options(options),
-		verifiableCredential: Joi.object({
-			...createStandardFields("verifiableCredential", "Please present a verifiable credential to continue."),
-			optional: Joi.boolean().default(false),
-			claimUrl: optionalUrlSchema,
-			acquireUrl: optionalUrlSchema,
-			item: Joi.array().items(Joi.string().min(1).required()).min(1).optional(),
-			target: Joi.DID().optional(),
-			trustedIssuers: Joi.array().items(trustedIssuerSchema).min(1).optional(),
-			tag: Joi.string().min(1).allow("").default(""),
-			ownerDid: Joi.array().items(Joi.DID()).optional().default([]),
-			filters: Joi.array().items(Joi.object({
-				type: Joi.array().items(Joi.string().min(1).required()).min(1).optional(),
-				target: Joi.DID().optional(),
-				trustedIssuers: Joi.array().items(trustedIssuerSchema).min(1).optional(),
-				tag: Joi.string().min(1).allow("").default(""),
-				ownerDid: Joi.array().items(Joi.DID()).optional().default([]),
-				claimUrl: optionalUrlSchema,
-				acquireUrl: optionalUrlSchema
-			})).optional()
-		}).options(options),
-		asset: Joi.object({
-			...createStandardFields("asset", "Please present an on chain asset to continue."),
-			optional: Joi.boolean().default(false),
-			address: Joi.DID().optional(),
-			trustedIssuers: Joi.array().items(trustedIssuerSchema).min(1).optional(),
-			trustedParents: Joi.array().items(Joi.DID().required()).min(1).optional(),
-			tag: Joi.string().min(1).allow("").default(""),
-			ownerDid: Joi.array().items(Joi.DID()).optional().default([]),
-			consumed: Joi.boolean().optional(),
-			acquireUrl: optionalUrlSchema,
-			filters: Joi.array().items(Joi.object({
-				address: Joi.DID().optional(),
-				trustedIssuers: Joi.array().items(trustedIssuerSchema).min(1).optional(),
-				trustedParents: Joi.array().items(Joi.DID().required()).min(1).optional(),
-				tag: Joi.string().min(1).allow("").default(""),
-				ownerDid: Joi.array().items(Joi.DID()).optional().default([]),
-				consumed: Joi.boolean().optional(),
-				acquireUrl: optionalUrlSchema
-			})).optional()
-		}).options(options),
-		assetOrVC: Joi.object({
+		profile,
+		signature,
+		prepareTx,
+		agreement,
+		verifiableCredential,
+		asset,
+		assetOrVC: object({
 			...createStandardFields("assetOrVC", "Please present NFT to continue."),
-			filters: Joi.array().items(Joi.object({
-				type: Joi.array().items(Joi.string().min(1).required()).min(1).optional(),
-				address: Joi.DID().optional(),
-				trustedIssuers: Joi.array().items(trustedIssuerSchema).min(1).optional(),
-				trustedParents: Joi.array().items(Joi.DID().required()).min(1).optional(),
-				tag: Joi.string().min(1).allow("").default(""),
-				ownerDid: Joi.array().items(Joi.DID()).optional().default([]),
-				consumed: Joi.boolean().optional(),
-				claimUrl: optionalUrlSchema,
-				acquireUrl: optionalUrlSchema
-			})).required().min(1),
-			optional: Joi.boolean().default(false)
-		}).options(options),
+			filters: pipe(array(assetOrVCFilterSchema), minLength(1)),
+			optional: optional(boolean(), false)
+		}),
 		keyPair,
 		encryptionKey
 	};

package/esm/schema/index.d.mts

@@ -1,9 +1,29 @@
 import { ClaimsSchema } from "./claims.mjs";
-import * as joi0 from "joi";
+import { vValidate } from "@arcblock/validator";
+import * as v from "valibot";
 
 //#region src/schema/index.d.ts
-declare const chainInfo: joi0.ObjectSchema<any>;
-declare const appInfo: joi0.ObjectSchema<any>;
+declare const chainInfo: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly type: v.OptionalSchema<v.PicklistSchema<["arcblock", "ethereum", "solona"], undefined>, "arcblock">;
+  readonly id: v.OptionalSchema<v.AnySchema, undefined>;
+  readonly host: v.OptionalSchema<v.AnySchema, undefined>;
+}, undefined>, v.RawTransformAction<{
+  type: "arcblock" | "ethereum" | "solona";
+  id?: any;
+  host?: any;
+}, any>]>;
+declare const appInfo: v.LooseObjectSchema<{
+  readonly name: v.StringSchema<undefined>;
+  readonly description: v.StringSchema<undefined>;
+  readonly icon: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must be a valid HTTP/HTTPS URL">]>;
+  readonly link: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must be a valid HTTP/HTTPS URL">]>, undefined>;
+  readonly path: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Must be a valid HTTP/HTTPS URL">]>, "https://abtwallet.io/i/">;
+  readonly publisher: v.OptionalSchema<any, undefined>;
+  readonly updateSubEndpoint: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  readonly subscriptionEndpoint: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly nodeDid: v.OptionalSchema<any, undefined>;
+  readonly agentDid: v.OptionalSchema<any, undefined>;
+}, undefined>;
 declare const claims: ClaimsSchema;
 //#endregion
-export { appInfo, chainInfo, claims };
+export { appInfo, chainInfo, claims, vValidate };

package/esm/schema/index.mjs

@@ -1,49 +1,75 @@
+import { any, boolean, check, literal, looseObject, object, optional, picklist, pipe, rawTransform, regex, safeParse, string } from "../node_modules/valibot/dist/index.mjs";
 import claims_default from "./claims.mjs";
-import { Joi } from "@arcblock/validator";
+import { vDID, vValidate } from "@arcblock/validator";
 
 //#region src/schema/index.ts
-const chainInfo = Joi.object({
-	type: Joi.string().optional().valid("arcblock", "ethereum", "solona").default("arcblock"),
-	id: Joi.any().when("type", {
-		is: "arcblock",
-		then: Joi.string().optional().default("none")
-	}).when("type", {
-		is: "ethereum",
-		then: Joi.string().required().pattern(/^[0-9]+$/, "numbers")
-	}).when("type", {
-		is: "solona",
-		then: Joi.string().required().pattern(/^[0-9]+$/, "numbers")
-	}),
-	host: Joi.string().when("type", {
-		is: "ethereum",
-		then: Joi.string().optional().allow("")
-	}).when("type", {
-		is: "solona",
-		then: Joi.string().optional().allow("")
-	}).when("type", {
-		is: "arcblock",
-		then: Joi.string().uri({ scheme: ["http", "https"] }).allow("none").default("none")
-	})
-}).options({
-	stripUnknown: true,
-	noDefaults: false
-});
-const appInfo = Joi.object({
-	name: Joi.string().required(),
-	description: Joi.string().required(),
-	icon: Joi.string().uri({ scheme: ["http", "https"] }).required(),
-	link: Joi.string().uri({ scheme: ["http", "https"] }).optional(),
-	path: Joi.string().uri({ scheme: ["http", "https"] }).default("https://abtwallet.io/i/"),
-	publisher: Joi.DID().optional(),
-	updateSubEndpoint: Joi.boolean().optional(),
-	subscriptionEndpoint: Joi.string().optional(),
-	nodeDid: Joi.DID().optional(),
-	agentDid: Joi.DID().optional()
-}).options({
-	stripUnknown: false,
-	noDefaults: false
+const isHttpUrl = (s) => {
+	try {
+		const url = new URL(s);
+		return ["http:", "https:"].includes(url.protocol);
+	} catch {
+		return false;
+	}
+};
+const chainInfo = pipe(object({
+	type: optional(picklist([
+		"arcblock",
+		"ethereum",
+		"solona"
+	]), "arcblock"),
+	id: optional(any()),
+	host: optional(any())
+}), rawTransform(({ dataset, addIssue, NEVER }) => {
+	const obj = dataset.value;
+	let typeSchema;
+	switch (obj.type) {
+		case "arcblock":
+			typeSchema = object({
+				type: literal("arcblock"),
+				id: optional(string(), "none"),
+				host: optional(pipe(string(), check((s) => s === "none" || isHttpUrl(s), "must be a valid uri with a scheme matching the http|https pattern")), "none")
+			});
+			break;
+		case "ethereum":
+			typeSchema = object({
+				type: literal("ethereum"),
+				id: pipe(string(), regex(/^[0-9]+$/, "fails to match the numbers pattern")),
+				host: optional(string())
+			});
+			break;
+		case "solona":
+			typeSchema = object({
+				type: literal("solona"),
+				id: pipe(string(), regex(/^[0-9]+$/, "fails to match the numbers pattern")),
+				host: optional(string())
+			});
+			break;
+	}
+	const result = safeParse(typeSchema, obj);
+	if (!result.success) {
+		for (const issue of result.issues) addIssue({
+			message: issue.message,
+			path: issue.path
+		});
+		return NEVER;
+	}
+	const output = {};
+	for (const [k, val] of Object.entries(result.output)) if (val !== void 0) output[k] = val;
+	return output;
+}));
+const appInfo = looseObject({
+	name: string(),
+	description: string(),
+	icon: pipe(string(), check(isHttpUrl, "Must be a valid HTTP/HTTPS URL")),
+	link: optional(pipe(string(), check(isHttpUrl, "Must be a valid HTTP/HTTPS URL"))),
+	path: optional(pipe(string(), check(isHttpUrl, "Must be a valid HTTP/HTTPS URL")), "https://abtwallet.io/i/"),
+	publisher: optional(vDID()),
+	updateSubEndpoint: optional(boolean()),
+	subscriptionEndpoint: optional(string()),
+	nodeDid: optional(vDID()),
+	agentDid: optional(vDID())
 });
 const claims = claims_default(chainInfo);
 
 //#endregion
-export { appInfo, chainInfo, claims };
+export { appInfo, chainInfo, claims, vValidate };

package/lib/authenticator/base.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_package$1 = require('../package.cjs');
+const require_package$1 = require('../did/did-connect/package.cjs');
 let _ocap_wallet = require("@ocap/wallet");
 let _arcblock_jwt = require("@arcblock/jwt");
 _arcblock_jwt = require_rolldown_runtime.__toESM(_arcblock_jwt);

package/lib/authenticator/wallet.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_package$1 = require('../package.cjs');
+const require_package$1 = require('../did/did-connect/package.cjs');
 const require_authenticator_base = require('./base.cjs');
 const require_schema_index = require('../schema/index.cjs');
 let node_querystring = require("node:querystring");
@@ -20,6 +20,7 @@ let lodash_random = require("lodash/random");
 lodash_random = require_rolldown_runtime.__toESM(lodash_random);
 let lodash_shuffle = require("lodash/shuffle");
 lodash_shuffle = require_rolldown_runtime.__toESM(lodash_shuffle);
+let _arcblock_validator = require("@arcblock/validator");
 
 //#region src/authenticator/wallet.ts
 const debug = require("debug")(`${require_package$1.default.name}:authenticator:wallet`);
@@ -369,7 +370,7 @@ var WalletAuthenticator = class WalletAuthenticator extends require_authenticato
 				}
 				result.mfaCode = (0, lodash_shuffle.default)(result.mfaCode);
 			}
-			const { value, error } = require_schema_index.claims[name].validate(result);
+			const { value, error } = (0, _arcblock_validator.vValidate)(require_schema_index.claims[name], result);
 			if (error) throw new Error(`Invalid ${name} claim: ${error.message}`);
 			return value;
 		}));
@@ -528,12 +529,12 @@ var WalletAuthenticator = class WalletAuthenticator extends require_authenticato
 			if (allowEmpty === false) throw new Error("Wallet authenticator can not work with invalid appInfo: empty");
 			return null;
 		}
-		const { value, error } = require_schema_index.appInfo.validate(info);
+		const { value, error } = (0, _arcblock_validator.vValidate)(require_schema_index.appInfo, info);
 		if (error) throw new Error(`Wallet authenticator can not work with invalid appInfo: ${error.message}`);
 		return value;
 	}
 	_isValidChainInfo(x) {
-		const { error } = require_schema_index.chainInfo.validate(x);
+		const { error } = (0, _arcblock_validator.vValidate)(require_schema_index.chainInfo, x);
 		return !error;
 	}
 	tryWithTimeout(asyncFn, label = "") {

package/lib/{package.cjs → did/did-connect/package.cjs}

@@ -1,4 +1,4 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
 
 //#region package.json
 var require_package = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {

package/lib/handlers/util.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_package$1 = require('../package.cjs');
+const require_package$1 = require('../did/did-connect/package.cjs');
 const require_protocol = require('../protocol.cjs');
 let _arcblock_did = require("@arcblock/did");
 let _ocap_util = require("@ocap/util");

package/lib/handlers/wallet.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, '__esModule', { value: true });
-const require_package$1 = require('../package.cjs');
+const require_package$1 = require('../did/did-connect/package.cjs');
 const require_adapters_detect = require('../adapters/detect.cjs');
 const require_adapters_express = require('../adapters/express.cjs');
 const require_adapters_hono = require('../adapters/hono.cjs');