@arcblock/did-connect-js 4.0.1 → 4.0.3

package/dist/schema/index.cjs

@@ -0,0 +1,413 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/schema/index.ts
+var schema_exports = {};
+__export(schema_exports, {
+  appInfo: () => appInfo,
+  chainInfo: () => chainInfo,
+  claims: () => claims
+});
+module.exports = __toCommonJS(schema_exports);
+var import_validator2 = require("@arcblock/validator");
+var v2 = __toESM(require("valibot"), 1);
+
+// src/schema/claims.ts
+var import_validator = require("@arcblock/validator");
+var import_mcrypto = require("@ocap/mcrypto");
+var v = __toESM(require("valibot"), 1);
+var isHttpUrl = (s) => {
+  try {
+    const url = new URL(s);
+    return ["http:", "https:"].includes(url.protocol);
+  } catch {
+    return false;
+  }
+};
+var trustedIssuerSchema = v.union([
+  v.object({
+    did: (0, import_validator.vDID)(),
+    endpoint: v.pipe(v.string(), v.check(isHttpUrl, "Must be a valid HTTP/HTTPS URL"))
+  }),
+  (0, import_validator.vDID)()
+]);
+var optionalUrlSchema = v.optional(
+  v.pipe(
+    v.string(),
+    v.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")
+  ),
+  ""
+);
+var requirementSchema = v.object({
+  tokens: v.array(
+    v.object({
+      address: (0, import_validator.vDID)(),
+      value: (0, import_validator.vBNPositive)()
+    })
+  ),
+  assets: v.optional(
+    v.object({
+      address: v.optional(v.array((0, import_validator.vDID)())),
+      parent: v.optional(v.array((0, import_validator.vDID)())),
+      issuer: v.optional(v.array((0, import_validator.vDID)())),
+      amount: v.optional(v.pipe(v.number(), v.check((n) => n > 0, "Must be positive"), v.minValue(1)))
+    })
+  )
+});
+var targetTypeSchema = v.optional(
+  v.object({
+    key: v.optional(
+      v.picklist(Object.keys(import_mcrypto.types.KeyType).map((x) => x.toLowerCase())),
+      "ed25519"
+    ),
+    hash: v.optional(
+      v.picklist(Object.keys(import_mcrypto.types.HashType).map((x) => x.toLowerCase())),
+      "sha3"
+    ),
+    role: v.optional(
+      v.picklist(Object.keys(import_mcrypto.types.RoleType).map((x) => x.toLowerCase().split("_").pop())),
+      "account"
+    ),
+    encoding: v.optional(
+      v.picklist(Object.keys(import_mcrypto.types.EncodingType).map((x) => x.toLowerCase())),
+      "base58"
+    )
+  })
+);
+function withValidate(schema) {
+  return Object.assign(schema, {
+    validate: (data) => {
+      const { value, error } = (0, import_validator.vValidate)(schema, data);
+      if (error) error.toString = () => error.message;
+      return { value, error };
+    }
+  });
+}
+var profileItemValues = ["did", "fullName", "email", "phone", "signature", "avatar", "birthday", "url"];
+var claims_default = (chainInfo2) => {
+  const createStandardFields = (type, description) => ({
+    type: v.optional(v.literal(type), type),
+    description: v.optional(v.pipe(v.string(), v.minLength(1)), description),
+    chainInfo: v.optional(chainInfo2),
+    mfaCode: v.optional(v.array(v.optional(v.pipe(v.number(), v.minValue(10), v.maxValue(99)))), []),
+    meta: v.optional(v.any(), {})
+  });
+  const authPrincipal = withValidate(
+    v.object({
+      ...createStandardFields("authPrincipal", "Please continue with your account"),
+      target: v.optional(v.union([v.literal(""), (0, import_validator.vDID)()]), ""),
+      supervised: v.optional(v.boolean(), false),
+      targetType: targetTypeSchema
+    })
+  );
+  const keyPair = withValidate(
+    v.object({
+      ...createStandardFields("keyPair", "Please create account to continue."),
+      moniker: v.pipe(v.string(), v.regex(/^[a-zA-Z0-9][-a-zA-Z0-9_]{2,128}$/)),
+      declare: v.optional(v.boolean(), true),
+      migrateFrom: v.optional(v.union([v.literal(""), (0, import_validator.vDID)()]), ""),
+      targetType: targetTypeSchema
+    })
+  );
+  const encryptionKey = withValidate(
+    v.object({
+      ...createStandardFields("encryptionKey", "Please provide encryptionKey to continue."),
+      salt: v.string(),
+      delegation: v.optional(v.union([v.literal(""), v.string()]), "")
+    })
+  );
+  const profile = withValidate(
+    v.pipe(
+      v.looseObject({
+        ...createStandardFields("profile", "Please provide your profile to continue.")
+      }),
+      // Rename fields → items (ignoreUndefined: true, override: true)
+      v.transform((obj) => {
+        const { fields, ...rest } = obj;
+        if (fields !== void 0) {
+          return { ...rest, items: fields };
+        }
+        return rest;
+      }),
+      v.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 = withValidate(
+    v.object({
+      ...createStandardFields("signature", "Sign this transaction or message to continue."),
+      typeUrl: v.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: v.optional(v.union([v.literal(""), v.string()]), ""),
+      method: v.optional(
+        v.picklist(["none", ...Object.keys(import_mcrypto.types.HashType).map((x) => x.toLowerCase())]),
+        "sha3"
+      ),
+      digest: v.optional(v.union([v.literal(""), v.string()]), ""),
+      origin: v.optional(v.union([v.literal(""), v.string()]), ""),
+      nonce: v.optional(v.union([v.literal(""), v.string()]), ""),
+      requirement: v.optional(requirementSchema)
+    })
+  );
+  const prepareTx = withValidate(
+    v.object({
+      ...createStandardFields("prepareTx", "Prepare and sign this transaction to continue."),
+      display: v.optional(v.union([v.literal(""), v.string()]), ""),
+      partialTx: v.string(),
+      nonce: v.optional(v.union([v.literal(""), v.string()]), ""),
+      requirement: requirementSchema
+    })
+  );
+  const agreement = withValidate(
+    v.object({
+      ...createStandardFields("agreement", "Confirm your agreement to continue."),
+      uri: v.union([
+        v.literal(""),
+        v.pipe(v.string(), v.check(isHttpUrl, "Must be a valid HTTP/HTTPS URL"))
+      ]),
+      method: v.optional(
+        v.picklist(Object.keys(import_mcrypto.types.HashType).map((x) => x.toLowerCase())),
+        "sha2"
+      ),
+      digest: v.string()
+    })
+  );
+  const vcFilterSchema = v.object({
+    type: v.optional(v.pipe(v.array(v.pipe(v.string(), v.minLength(1))), v.minLength(1))),
+    target: v.optional((0, import_validator.vDID)()),
+    trustedIssuers: v.optional(v.pipe(v.array(trustedIssuerSchema), v.minLength(1))),
+    tag: v.optional(v.pipe(v.string(), v.check((s) => s === "" || s.length >= 1, "Must be non-empty or empty string")), ""),
+    ownerDid: v.optional(v.array((0, import_validator.vDID)()), []),
+    claimUrl: optionalUrlSchema,
+    acquireUrl: optionalUrlSchema
+  });
+  const verifiableCredential = withValidate(
+    v.object({
+      ...createStandardFields("verifiableCredential", "Please present a verifiable credential to continue."),
+      optional: v.optional(v.boolean(), false),
+      claimUrl: optionalUrlSchema,
+      acquireUrl: optionalUrlSchema,
+      // v1
+      item: v.optional(v.pipe(v.array(v.pipe(v.string(), v.minLength(1))), v.minLength(1))),
+      target: v.optional((0, import_validator.vDID)()),
+      trustedIssuers: v.optional(v.pipe(v.array(trustedIssuerSchema), v.minLength(1))),
+      tag: v.optional(v.pipe(v.string(), v.check((s) => s === "" || s.length >= 1, "Must be non-empty or empty string")), ""),
+      ownerDid: v.optional(v.array((0, import_validator.vDID)()), []),
+      // v2
+      filters: v.optional(v.array(vcFilterSchema))
+    })
+  );
+  const assetFilterSchema = v.object({
+    address: v.optional((0, import_validator.vDID)()),
+    trustedIssuers: v.optional(v.pipe(v.array(trustedIssuerSchema), v.minLength(1))),
+    trustedParents: v.optional(v.pipe(v.array((0, import_validator.vDID)()), v.minLength(1))),
+    tag: v.optional(v.pipe(v.string(), v.check((s) => s === "" || s.length >= 1, "Must be non-empty or empty string")), ""),
+    ownerDid: v.optional(v.array((0, import_validator.vDID)()), []),
+    consumed: v.optional(v.boolean()),
+    acquireUrl: optionalUrlSchema
+  });
+  const asset = withValidate(
+    v.object({
+      ...createStandardFields("asset", "Please present an on chain asset to continue."),
+      optional: v.optional(v.boolean(), false),
+      // v1
+      address: v.optional((0, import_validator.vDID)()),
+      trustedIssuers: v.optional(v.pipe(v.array(trustedIssuerSchema), v.minLength(1))),
+      trustedParents: v.optional(v.pipe(v.array((0, import_validator.vDID)()), v.minLength(1))),
+      tag: v.optional(v.pipe(v.string(), v.check((s) => s === "" || s.length >= 1, "Must be non-empty or empty string")), ""),
+      ownerDid: v.optional(v.array((0, import_validator.vDID)()), []),
+      consumed: v.optional(v.boolean()),
+      acquireUrl: optionalUrlSchema,
+      // v2
+      filters: v.optional(v.array(assetFilterSchema))
+    })
+  );
+  const assetOrVCFilterSchema = v.object({
+    type: v.optional(v.pipe(v.array(v.pipe(v.string(), v.minLength(1))), v.minLength(1))),
+    address: v.optional((0, import_validator.vDID)()),
+    trustedIssuers: v.optional(v.pipe(v.array(trustedIssuerSchema), v.minLength(1))),
+    trustedParents: v.optional(v.pipe(v.array((0, import_validator.vDID)()), v.minLength(1))),
+    tag: v.optional(v.pipe(v.string(), v.check((s) => s === "" || s.length >= 1, "Must be non-empty or empty string")), ""),
+    ownerDid: v.optional(v.array((0, import_validator.vDID)()), []),
+    consumed: v.optional(v.boolean()),
+    claimUrl: optionalUrlSchema,
+    acquireUrl: optionalUrlSchema
+  });
+  const assetOrVC = withValidate(
+    v.object({
+      ...createStandardFields("assetOrVC", "Please present NFT to continue."),
+      filters: v.pipe(v.array(assetOrVCFilterSchema), v.minLength(1)),
+      optional: v.optional(v.boolean(), false)
+    })
+  );
+  return {
+    authPrincipal,
+    profile,
+    signature,
+    prepareTx,
+    agreement,
+    verifiableCredential,
+    asset,
+    assetOrVC,
+    keyPair,
+    encryptionKey
+  };
+};
+
+// src/schema/index.ts
+var isHttpUrl2 = (s) => {
+  try {
+    const url = new URL(s);
+    return ["http:", "https:"].includes(url.protocol);
+  } catch {
+    return false;
+  }
+};
+var chainInfoSchema = v2.pipe(
+  v2.object({
+    type: v2.optional(v2.picklist(["arcblock", "ethereum", "solona"]), "arcblock"),
+    id: v2.optional(v2.any()),
+    host: v2.optional(v2.any())
+  }),
+  v2.rawTransform(({ dataset, addIssue, NEVER }) => {
+    const obj = dataset.value;
+    let typeSchema;
+    switch (obj.type) {
+      case "arcblock":
+        typeSchema = v2.object({
+          type: v2.literal("arcblock"),
+          id: v2.optional(v2.string(), "none"),
+          host: v2.optional(
+            v2.pipe(
+              v2.string(),
+              v2.check(
+                (s) => s === "none" || isHttpUrl2(s),
+                "must be a valid uri with a scheme matching the http|https pattern"
+              )
+            ),
+            "none"
+          )
+        });
+        break;
+      case "ethereum":
+        typeSchema = v2.object({
+          type: v2.literal("ethereum"),
+          id: v2.pipe(v2.string(), v2.regex(/^[0-9]+$/, "fails to match the numbers pattern")),
+          host: v2.optional(v2.string())
+        });
+        break;
+      case "solona":
+        typeSchema = v2.object({
+          type: v2.literal("solona"),
+          id: v2.pipe(v2.string(), v2.regex(/^[0-9]+$/, "fails to match the numbers pattern")),
+          host: v2.optional(v2.string())
+        });
+        break;
+    }
+    const result = v2.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;
+  })
+);
+var appInfoSchema = v2.looseObject({
+  name: v2.string(),
+  description: v2.string(),
+  icon: v2.pipe(v2.string(), v2.check(isHttpUrl2, "Must be a valid HTTP/HTTPS URL")),
+  link: v2.optional(v2.pipe(v2.string(), v2.check(isHttpUrl2, "Must be a valid HTTP/HTTPS URL"))),
+  path: v2.optional(v2.pipe(v2.string(), v2.check(isHttpUrl2, "Must be a valid HTTP/HTTPS URL")), "https://abtwallet.io/i/"),
+  publisher: v2.optional((0, import_validator2.vDID)()),
+  updateSubEndpoint: v2.optional(v2.boolean()),
+  subscriptionEndpoint: v2.optional(v2.string()),
+  nodeDid: v2.optional((0, import_validator2.vDID)()),
+  agentDid: v2.optional((0, import_validator2.vDID)())
+});
+function withValidate2(schema) {
+  return Object.assign(schema, {
+    validate: (data) => {
+      const { value, error } = (0, import_validator2.vValidate)(schema, data);
+      if (error) error.toString = () => error.message;
+      return { value, error };
+    },
+    validateAsync: (data) => {
+      const { value, error } = (0, import_validator2.vValidate)(schema, data);
+      return error ? Promise.reject(new Error(error.message)) : Promise.resolve(value);
+    }
+  });
+}
+var chainInfo = withValidate2(chainInfoSchema);
+var appInfo = withValidate2(appInfoSchema);
+var claims = claims_default(chainInfoSchema);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appInfo,
+  chainInfo,
+  claims
+});

package/dist/storage/kv.cjs

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storage/kv.ts
+var kv_exports = {};
+__export(kv_exports, {
+  default: () => kv_default
+});
+module.exports = __toCommonJS(kv_exports);
+var import_events = require("events");
+var CloudflareKVStorage = class extends import_events.EventEmitter {
+  kv;
+  ttl;
+  prefix;
+  constructor(kv, options = {}) {
+    super();
+    this.kv = kv;
+    this.ttl = options.ttl ?? 300;
+    this.prefix = options.prefix ?? "";
+  }
+  key(token) {
+    return `${this.prefix}${token}`;
+  }
+  async create(token, status = "created") {
+    const record = { token, status };
+    await this.kv.put(this.key(token), JSON.stringify(record), { expirationTtl: this.ttl });
+    this.emit("create", record);
+    return record;
+  }
+  async read(token) {
+    const raw = await this.kv.get(this.key(token));
+    if (!raw) return null;
+    return JSON.parse(raw);
+  }
+  async update(token, updates) {
+    const existing = await this.read(token);
+    if (!existing) return null;
+    delete updates.token;
+    const merged = { ...existing, ...updates };
+    await this.kv.put(this.key(token), JSON.stringify(merged), { expirationTtl: this.ttl });
+    this.emit("update", merged);
+    return merged;
+  }
+  async delete(token) {
+    const existing = await this.read(token);
+    if (existing) {
+      this.emit("destroy", existing);
+    }
+    await this.kv.delete(this.key(token));
+  }
+  async exist(token, did) {
+    const record = await this.read(token);
+    if (!record) return false;
+    if (did) return record.did === did;
+    return true;
+  }
+};
+var kv_default = CloudflareKVStorage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcblock/did-connect-js",
-  "version": "4.0.1",
+  "version": "4.0.3",
   "description": "Server-side DID Connect protocol — WalletAuthenticator, WalletHandlers, framework adapters",
   "type": "module",
   "main": "./dist/index.js",
@@ -8,15 +8,18 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     },
     "./storage/kv": {
       "types": "./dist/storage/kv.d.ts",
-      "import": "./dist/storage/kv.js"
+      "import": "./dist/storage/kv.js",
+      "require": "./dist/storage/kv.cjs"
     },
     "./schema": {
       "types": "./dist/schema/index.d.ts",
-      "import": "./dist/schema/index.js"
+      "import": "./dist/schema/index.js",
+      "require": "./dist/schema/index.cjs"
     }
   },
   "dependencies": {
@@ -32,7 +35,7 @@
     "debug": "^4.4.3",
     "fast-json-stable-stringify": "^2.1.0",
     "valibot": "^1.3.1",
-    "@arcblock/did-connect-core": "^4.0.1"
+    "@arcblock/did-connect-core": "^4.0.3"
   },
   "devDependencies": {
     "@arcblock/did-agent-storage-memory": "^1.8.0",
@@ -48,6 +51,7 @@
     "axios": "^1.17.0",
     "body-parser": "^2.2.2",
     "cookie-parser": "^1.4.7",
+    "esbuild": "^0.25.12",
     "express": "^5.2.1",
     "hono": "^4.12.23",
     "lodash": "^4.18.1",
@@ -62,7 +66,7 @@
   },
   "license": "Apache-2.0",
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && esbuild src/index.ts src/schema/index.ts src/storage/kv.ts --bundle --format=cjs --platform=node --target=node20 --packages=external --outdir=dist --outbase=src --out-extension:.js=.cjs",
     "lint": "biome check src/",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",