@gerege-systems/eid-mongolia-sdk 0.9.0 → 0.10.0

package/dist/index.js

@@ -6,12 +6,15 @@ import {
   ForbiddenError,
   NetworkError,
   ON_BEHALF_ERROR_CODES,
+  RETRYABLE_ERROR_CODES,
   SessionFailedError,
   ValidationError,
   deviceLink,
   isMobileUserAgent,
-  openOrShowQR
-} from "./chunk-NXDKQZIW.js";
+  maskPath,
+  openOrShowQR,
+  parseRetryAfter
+} from "./chunk-YDVPZMAL.js";
 
 // src/http.ts
 var DEFAULT_TIMEOUT_MS = 15e3;
@@ -54,26 +57,32 @@ var Http = class {
     };
     if (this.cfg.dispatcher) init.dispatcher = this.cfg.dispatcher;
     let res;
+    const op = `${method} ${maskPath(path)}`;
     try {
       res = await f(url, init);
     } catch (e) {
       const err = e;
       if (err.name === "TimeoutError" || err.name === "AbortError") {
-        throw new NetworkError(`\u0425\u04AF\u0441\u044D\u043B\u0442 \u0445\u0443\u0433\u0430\u0446\u0430\u0430 \u0445\u044D\u0442\u044D\u0440\u043B\u044D\u044D: ${method} ${path}`);
+        throw new NetworkError(`\u0425\u04AF\u0441\u044D\u043B\u0442 \u0445\u0443\u0433\u0430\u0446\u0430\u0430 \u0445\u044D\u0442\u044D\u0440\u043B\u044D\u044D: ${op}`, { op, timeout: true });
       }
-      throw new NetworkError(`\u0421\u04AF\u043B\u0436\u044D\u044D\u043D\u0438\u0439 \u0430\u043B\u0434\u0430\u0430 (${method} ${path}): ${err.message}`);
+      throw new NetworkError(`\u0421\u04AF\u043B\u0436\u044D\u044D\u043D\u0438\u0439 \u0430\u043B\u0434\u0430\u0430 (${op}): ${err.message.split(url).join(op)}`, { op, timeout: false });
     }
     if (res.status < 300) return res;
     const text = await res.text();
     const { error, code } = errorBody(text);
-    if (res.status === 401) throw new AuthenticationError("API secret \u0431\u0443\u0440\u0443\u0443 \u044D\u0441\u0432\u044D\u043B \u0431\u0430\u0439\u0445\u0433\u04AF\u0439 (401)");
+    const headers = res.headers;
+    const retryAfterMs = parseRetryAfter(headers.get("Retry-After"));
+    if (res.status === 401) {
+      throw new AuthenticationError(`API secret \u0431\u0443\u0440\u0443\u0443 \u044D\u0441\u0432\u044D\u043B \u0431\u0430\u0439\u0445\u0433\u04AF\u0439 (401${code ? ` ${code}` : ""})`, { code, serverMessage: error, body: text, headers });
+    }
     if (res.status === 403) {
       throw new ForbiddenError(
         error ? `RP-API 403${code ? ` ${code}` : ""}: ${error}` : "IP allowlist \u044D\u0441\u0432\u044D\u043B mTLS \u0437\u04E9\u0432\u0448\u04E9\u04E9\u0440\u04E9\u04E9\u0433\u04AF\u0439 (403)",
-        code
+        code,
+        { headers, retryAfterMs }
       );
     }
-    throw new ApiError(res.status, text, code);
+    throw new ApiError(res.status, text, code, { headers, retryAfterMs });
   }
 };
 function errorBody(text) {
@@ -90,6 +99,48 @@ function errorBody(text) {
   }
 }
 
+// src/contract.ts
+var RP_ROUTES = {
+  authNotificationEtsi: { method: "POST", path: "/authentication/notification/etsi/{semanticsIdentifier}" },
+  authNotificationDocument: { method: "POST", path: "/authentication/notification/document/{documentNumber}" },
+  authDeviceLinkAnonymous: { method: "POST", path: "/authentication/device-link/anonymous" },
+  authDeviceLinkEtsi: { method: "POST", path: "/authentication/device-link/etsi/{semanticsIdentifier}" },
+  signNotificationEtsi: { method: "POST", path: "/signature/notification/etsi/{semanticsIdentifier}" },
+  signNotificationDocument: { method: "POST", path: "/signature/notification/document/{documentNumber}" },
+  pdfPrepare: { method: "POST", path: "/pdf/sign/prepare" },
+  pdfDocument: { method: "GET", path: "/pdf/sign/{sessionID}/document" },
+  orgRepresentations: { method: "GET", path: "/organization/representations/etsi/{personEtsi}" },
+  session: { method: "GET", path: "/session/{sessionId}" },
+  personCertificates: { method: "GET", path: "/certificates/etsi/{personEtsi}" },
+  personDevices: { method: "GET", path: "/devices/etsi/{personEtsi}" },
+  personActivity: { method: "GET", path: "/rp/activity/etsi/{personEtsi}" },
+  personSummary: { method: "GET", path: "/person/summary/etsi/{personEtsi}" },
+  personChildren: { method: "GET", path: "/person/children/etsi/{personEtsi}" },
+  tokenCertificate: { method: "POST", path: "/token/certificate" },
+  tokenCertificateResult: { method: "GET", path: "/token/certificate/{sessionID}" }
+};
+var RP_ROUTES_UNDISCOVERED = {
+  tokenAuthChallenge: { method: "POST", path: "/token/auth/challenge" },
+  tokenAuthVerify: { method: "POST", path: "/token/auth/verify" }
+};
+function routePath(route, ...args) {
+  let i = 0;
+  const out = route.path.replace(/\{[^}]*\}/g, () => {
+    const a = args[i++];
+    if (a === void 0) throw new Error(`eid: route ${route.path}: \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 \u0434\u0443\u0442\u0443\u0443`);
+    return encodeURIComponent(a);
+  });
+  if (i !== args.length) throw new Error(`eid: route ${route.path}: \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 \u0438\u043B\u04AF\u04AF`);
+  return out;
+}
+var OIDC_EXPECT = {
+  defaultScope: "openid",
+  pkceMethod: "S256",
+  idTokenAlg: "ES256",
+  /** `Authorization: Basic` (RFC 6749 §2.3.1). */
+  tokenEndpointAuthMethod: "client_secret_basic"
+};
+
 // src/crypto.ts
 import { createHash, randomBytes } from "crypto";
 function sha256Base64(data) {
@@ -192,25 +243,25 @@ var AuthApi = class {
   /** Push — РД/иргэний дугаар/ETSI-ээр (сервер төрлийг таьна). Иргэний утас руу мэдэгдэл очно. */
   async notificationByEtsi(id, interactions, opts) {
     const { body, acsp } = this.baseBody(randomChallenge(), interactions, ["Notification"], opts);
-    const raw = await this.http.post(`/authentication/notification/etsi/${encodeURIComponent(id)}`, body);
+    const raw = await this.http.post(routePath(RP_ROUTES.authNotificationEtsi, id), body);
     return this.parseNotification(raw, acsp);
   }
   /** Push — баримтын дугаараар (тодорхой төхөөрөмж рүү). */
   async notificationByDocument(documentNumber, interactions, opts) {
     const { body, acsp } = this.baseBody(randomChallenge(), interactions, ["Notification"], opts);
-    const raw = await this.http.post(`/authentication/notification/document/${encodeURIComponent(documentNumber)}`, body);
+    const raw = await this.http.post(routePath(RP_ROUTES.authNotificationDocument, documentNumber), body);
     return this.parseNotification(raw, acsp);
   }
   /** QR/App2App — нэр томьёололгүй (иргэн хэн болохыг урьдчилж мэдэхгүй). QR код үүсгэхэд. */
   async deviceLinkAnonymous(interactions, opts) {
     const { body, acsp } = this.baseBody(randomChallenge(), interactions, ["QR"], opts);
-    const raw = await this.http.post(`/authentication/device-link/anonymous`, body);
+    const raw = await this.http.post(routePath(RP_ROUTES.authDeviceLinkAnonymous), body);
     return this.parseDeviceLink(raw, acsp);
   }
   /** QR/App2App — тодорхой иргэн (РД/civil_id/ETSI). */
   async deviceLinkByEtsi(id, interactions, opts) {
     const { body, acsp } = this.baseBody(randomChallenge(), interactions, ["QR"], opts);
-    const raw = await this.http.post(`/authentication/device-link/etsi/${encodeURIComponent(id)}`, body);
+    const raw = await this.http.post(routePath(RP_ROUTES.authDeviceLinkEtsi, id), body);
     return this.parseDeviceLink(raw, acsp);
   }
 };
@@ -243,6 +294,7 @@ var SignApi = class {
     };
     if (opts?.callbackUrl?.trim()) body.initialCallbackUrl = opts.callbackUrl.trim();
     if (opts?.onBehalfOf?.trim()) body.onBehalfOf = opts.onBehalfOf.trim();
+    if (opts?.fileName?.trim()) body.fileName = opts.fileName.trim();
     return body;
   }
   parse(raw) {
@@ -255,12 +307,12 @@ var SignApi = class {
    * digest-ийг гаднаас бэлдэж өгнө — текст бус бинар баримтад тохиромжтой.
    */
   async digestByEtsi(id, digestB64, interactions, opts) {
-    const raw = await this.http.post(`/signature/notification/etsi/${encodeURIComponent(id)}`, this.body(digestB64, interactions, opts));
+    const raw = await this.http.post(routePath(RP_ROUTES.signNotificationEtsi, id), this.body(digestB64, interactions, opts));
     return this.parse(raw);
   }
   /** Бэлэн digest-ээр push sign — баримтын дугаараар (auth-аас гарсан documentNumber дээр). */
   async digestByDocument(documentNumber, digestB64, interactions, opts) {
-    const raw = await this.http.post(`/signature/notification/document/${encodeURIComponent(documentNumber)}`, this.body(digestB64, interactions, opts));
+    const raw = await this.http.post(routePath(RP_ROUTES.signNotificationDocument, documentNumber), this.body(digestB64, interactions, opts));
     return this.parse(raw);
   }
   /** Текстийн SHA-256 digest-ийг дотроо тооцоод push sign (богино текст баримтад тохиромжтой). */
@@ -301,9 +353,44 @@ function parseSessionResult(raw) {
     signatureAlgorithmParameters: parseSigParams(sig.signatureAlgorithmParameters),
     interactionTypeUsed: str(r.interactionTypeUsed),
     onBehalfOf: parseOrg(r.onBehalfOf),
-    pdf: parsePdf(r.pdf)
+    pdf: parsePdf(r.pdf),
+    person: parsePerson(r.person),
+    tokenCertificate: parseTokenCert(r.tokenCertificate),
+    raw
   };
 }
+var PERSON_STRINGS = [
+  "firstName",
+  "lastName",
+  "familyName",
+  "firstNameEn",
+  "lastNameEn",
+  "civilId",
+  "regNo",
+  "birthDate",
+  "gender"
+];
+function parsePerson(raw) {
+  const p = asRecord(raw);
+  const out = {};
+  for (const k of PERSON_STRINGS) if (typeof p[k] === "string" && p[k]) out[k] = p[k];
+  if (typeof p.geID === "number" && p.geID !== 0) out.geID = p.geID;
+  return Object.keys(out).length ? out : null;
+}
+function parseTokenCert(raw) {
+  const t = asRecord(raw);
+  const status = str(t.status);
+  if (!status) return null;
+  const out = { status };
+  if (t.errorCode) out.errorCode = String(t.errorCode);
+  if (t.authSerialHex) out.authSerialHex = String(t.authSerialHex);
+  if (t.signSerialHex) out.signSerialHex = String(t.signSerialHex);
+  return out;
+}
+function personMatchesCertificate(person, subject) {
+  const serial = typeof subject === "string" ? subject : subject?.serialNumber;
+  return !!person?.civilId && !!serial && serial === `PNOMN-${person.civilId}`;
+}
 function parsePdf(raw) {
   const p = asRecord(raw);
   const docID = str(p.docID);
@@ -357,7 +444,7 @@ var SessionApi = class {
   /** Нэг удаагийн long-poll. serverPollMs хүртэл хүлээнэ. */
   async poll(sessionId, serverPollMs = SERVER_POLL_MS) {
     const raw = await this.http.get(
-      `/session/${encodeURIComponent(sessionId)}?timeoutMs=${serverPollMs}`,
+      `${routePath(RP_ROUTES.session, sessionId)}?timeoutMs=${serverPollMs}`,
       serverPollMs + 1e4
       // HTTP timeout нь серверийн poll-оос урт
     );
@@ -382,6 +469,7 @@ var SessionApi = class {
 
 // src/pdf.ts
 import { createHash as createHash2 } from "crypto";
+var DEFAULT_PDF_TIMEOUT_MS = 8e4;
 function rec3(v) {
   return v && typeof v === "object" ? v : {};
 }
@@ -394,7 +482,10 @@ var PdfApi = class {
   http;
   creds;
   defaults;
-  /** POST /pdf/sign/prepare — multipart (`request` JSON + `pdf`). SIGN эрх шаардана. */
+  /**
+   * POST /pdf/sign/prepare — multipart (`request` JSON + `pdf`). SIGN эрх шаардана. Түр алдаа: `ApiError` 429
+   * PDF_PREPARE_BUSY, 503 LTV_UNAVAILABLE / TSA_UNAVAILABLE — `retryAfterMs`-ийн дараа дахин (`retryable`).
+   */
   async prepare(input) {
     const request = {
       relyingPartyUUID: this.creds.rpUUID,
@@ -410,7 +501,7 @@ var PdfApi = class {
     const form = new FormData();
     form.append("request", new Blob([JSON.stringify(request)], { type: "application/json" }));
     form.append("pdf", new Blob([input.pdf], { type: "application/pdf" }), input.fileName);
-    const r = rec3(await this.http.postMultipart("/pdf/sign/prepare", form, 6e4));
+    const r = rec3(await this.http.postMultipart(routePath(RP_ROUTES.pdfPrepare), form, this.defaults.timeoutMs ?? DEFAULT_PDF_TIMEOUT_MS));
     const receivedAt = Date.now();
     const vc = rec3(r.vc).value;
     const dl = rec3(r.deviceLink);
@@ -432,10 +523,12 @@ var PdfApi = class {
   }
   /**
    * GET /pdf/sign/{sessionID}/document — гарын үсэгтэй PDF (READY-ээс хойш 30 мин). Татсан байтын SHA-256-ийг
-   * session-ий `pdf.outSha256`-тай тулга. Эрх хасагдсан бол `ForbiddenError` `.code = "REPRESENTATION_REVOKED"`.
+   * session-ий `pdf.outSha256`-тай тулга. Эрх хасагдсан бол `ForbiddenError` `.code = "REPRESENTATION_REVOKED"`. Баримт
+   * бэлэн болоогүй бол `ApiError` 503 `.code` DOCUMENT_PENDING / TSA_UNAVAILABLE / LTV_UNAVAILABLE — `retryAfterMs`-ийн
+   * дараа дахин татна (`retryable`).
    */
   document(sessionId) {
-    return this.http.getBytes(`/pdf/sign/${encodeURIComponent(sessionId)}/document`, 6e4);
+    return this.http.getBytes(routePath(RP_ROUTES.pdfDocument, sessionId), this.defaults.timeoutMs ?? DEFAULT_PDF_TIMEOUT_MS);
   }
   /**
    * {@link document} + тулгалт: татсан байтын SHA-256 нь session poll-ийн `pdf.outSha256`-тай тэнцүү байх ёстой.
@@ -467,14 +560,54 @@ var OrganizationApi = class {
   http;
   /** GET /organization/representations/etsi/{personEtsi}. Сонголт нь итгэх эх биш — сервер дахин шалгана. */
   async getRepresentations(personEtsi) {
-    const raw = await this.http.get(`/organization/representations/etsi/${encodeURIComponent(personEtsi)}`);
+    const raw = await this.http.get(routePath(RP_ROUTES.orgRepresentations, personEtsi));
     const list = Array.isArray(raw.representations) ? raw.representations : [];
     return { personEtsi: String(raw.personEtsi ?? personEtsi), representations: list };
   }
 };
 
-// src/validator.ts
-import { X509Certificate as X509Certificate2, constants, createHash as createHash3, publicDecrypt, verify } from "crypto";
+// src/person.ts
+function rec4(v) {
+  return v && typeof v === "object" ? v : {};
+}
+var PersonApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async get(path) {
+    const raw = await this.http.get(path);
+    return { ...rec4(raw), raw };
+  }
+  /** Иргэний бүх гэрчилгээ + статусын тоолол. */
+  certificates(personEtsi) {
+    return this.get(routePath(RP_ROUTES.personCertificates, personEtsi));
+  }
+  /** Иргэний холбоотой төхөөрөмжүүд (идэвхтэй + идэвхгүй). */
+  devices(personEtsi) {
+    return this.get(routePath(RP_ROUTES.personDevices, personEtsi));
+  }
+  /** Иргэний үйл ажиллагааны түүх. */
+  activity(personEtsi, query) {
+    const q = new URLSearchParams();
+    if (query?.flow) q.set("flow", query.flow);
+    if (query?.limit && query.limit > 0) q.set("limit", String(query.limit));
+    if (query?.offset && query.offset > 0) q.set("offset", String(query.offset));
+    const qs = q.toString();
+    return this.get(routePath(RP_ROUTES.personActivity, personEtsi) + (qs ? `?${qs}` : ""));
+  }
+  /** Самбарын нэгдсэн тоо. */
+  summary(personEtsi) {
+    return this.get(routePath(RP_ROUTES.personSummary, personEtsi));
+  }
+  /** Асран хамгаалж буй хүүхдүүд (зөвхөн унших). */
+  children(personEtsi) {
+    return this.get(routePath(RP_ROUTES.personChildren, personEtsi));
+  }
+};
+
+// src/token.ts
+import { X509Certificate as X509Certificate2, createHash as createHash3, createPublicKey, timingSafeEqual } from "crypto";
 
 // src/subject.ts
 import { X509Certificate } from "crypto";
@@ -580,8 +713,207 @@ function parseSubject(cert) {
   out.name = full || out.commonName || null;
   return out;
 }
+function certExtension(der, oid) {
+  const top = tlv(der, 0, der.length);
+  const tbs = tlv(der, top.start, top.end);
+  let f = tlv(der, tbs.start, tbs.end);
+  if (f.tag === 160) f = tlv(der, f.end, tbs.end);
+  for (let k = 0; k < 5; k++) f = tlv(der, f.end, tbs.end);
+  for (let pos = f.end; pos < tbs.end; ) {
+    const t = tlv(der, pos, tbs.end);
+    if (t.tag === 163) {
+      const seq = tlv(der, t.start, t.end);
+      for (let ep = seq.start; ep < seq.end; ) {
+        const ext = tlv(der, ep, seq.end);
+        const id = tlv(der, ext.start, ext.end);
+        let v = tlv(der, id.end, ext.end);
+        if (v.tag === 1) v = tlv(der, v.end, ext.end);
+        if (v.tag !== 4) throw new ValidationError("extension: extnValue OCTET STRING \u0431\u0438\u0448");
+        if (oidOf(der, id) === oid) return der.subarray(v.start, v.end);
+        ep = ext.end;
+      }
+      return void 0;
+    }
+    pos = t.end;
+  }
+  return void 0;
+}
+
+// src/token.ts
+function rec5(v) {
+  return v && typeof v === "object" ? v : {};
+}
+function hexSha256Equal(hex, data) {
+  if (typeof hex !== "string" || !/^[0-9a-fA-F]{64}$/.test(hex)) return false;
+  return timingSafeEqual(createHash3("sha256").update(data).digest(), Buffer.from(hex, "hex"));
+}
+var TOKEN_RESULT_TIMEOUT_MS = 3e4;
+var TokenApi = class {
+  constructor(http, creds) {
+    this.http = http;
+    this.creds = creds;
+  }
+  http;
+  creds;
+  /**
+   * POST /token/certificate — токены AUTH + SIGN гэрчилгээ олголт эхлүүлнэ (иргэн утсаараа батална). CA-ийн буцаасан
+   * CSR hash-ууд илгээсэнтэй таарахгүй бол ValidationError.
+   */
+  async issueCertificate(input) {
+    if (!input.signerEtsi?.trim() || !input.csrAuth?.length || !input.csrSign?.length || !input.tokenSerial?.trim()) {
+      throw new Error("token: signerEtsi, csrAuth, csrSign, tokenSerial \u0448\u0430\u0430\u0440\u0434\u043B\u0430\u0433\u0430\u0442\u0430\u0439");
+    }
+    const body = {
+      relyingPartyUUID: this.creds.rpUUID,
+      relyingPartyName: this.creds.rpName,
+      signer: { etsi: input.signerEtsi.trim() },
+      csrAuth: Buffer.from(input.csrAuth).toString("base64"),
+      csrSign: Buffer.from(input.csrSign).toString("base64"),
+      tokenSerial: input.tokenSerial.trim(),
+      onBehalfOf: input.onBehalfOf?.trim() ?? "",
+      flow: "notification"
+    };
+    if (input.tokenLabel) body.tokenLabel = input.tokenLabel;
+    const r = rec5(await this.http.post(routePath(RP_ROUTES.tokenCertificate), body));
+    if (!hexSha256Equal(r.csrAuthSha256, input.csrAuth) || !hexSha256Equal(r.csrSignSha256, input.csrSign)) {
+      throw new ValidationError("token: CA-\u0438\u0439\u043D csrAuthSha256/csrSignSha256 \u0438\u043B\u0433\u044D\u044D\u0441\u044D\u043D CSR-\u0442\u044D\u0439 \u0442\u0430\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439");
+    }
+    const vc = rec5(r.vc).value ?? (typeof r.vc === "string" ? r.vc : void 0);
+    return {
+      sessionId: String(r.sessionID ?? ""),
+      vc: vc != null ? String(vc) : null,
+      csrAuthSha256: String(r.csrAuthSha256).toLowerCase(),
+      csrSignSha256: String(r.csrSignSha256).toLowerCase(),
+      ...typeof r.expiresAt === "string" ? { expiresAt: r.expiresAt } : {}
+    };
+  }
+  /**
+   * GET /token/certificate/{sessionID} — олгосон AUTH + SIGN гэрчилгээ + гинж. Токенд бичихээс өмнө
+   * {@link verifyTokenCertificates}-ээр CSR-ийн түлхүүртэй тулга.
+   */
+  async certificateResult(sessionId) {
+    const raw = await this.http.get(routePath(RP_ROUTES.tokenCertificateResult, sessionId), TOKEN_RESULT_TIMEOUT_MS);
+    const r = rec5(raw);
+    const item = (v) => v && typeof v === "object" ? v : null;
+    return {
+      status: String(r.status ?? ""),
+      auth: item(r.auth),
+      sign: item(r.sign),
+      chain: Array.isArray(r.chain) ? r.chain.map(String) : [],
+      chainPem: String(r.chainPem ?? ""),
+      organization: r.organization && typeof r.organization === "object" ? r.organization : null,
+      keyMedium: String(r.keyMedium ?? ""),
+      certificateLevel: String(r.certificateLevel ?? ""),
+      raw
+    };
+  }
+  /** POST /token/auth/challenge — энэ RP-д холбогдсон нэг удаагийн challenge (2 мин). */
+  async authChallenge() {
+    const r = rec5(
+      await this.http.post(routePath(RP_ROUTES_UNDISCOVERED.tokenAuthChallenge), {
+        relyingPartyUUID: this.creds.rpUUID,
+        relyingPartyName: this.creds.rpName
+      })
+    );
+    return {
+      challengeId: String(r.challengeId ?? ""),
+      challenge: String(r.challenge ?? ""),
+      rpUUID: String(r.rpUUID ?? ""),
+      expiresAt: String(r.expiresAt ?? "")
+    };
+  }
+  /**
+   * POST /token/auth/verify — токены AUTH гэрчилгээ (DER) + challenge дээрх түүхий r||s. CA гинж, төлөв, цуцлалт, гарын
+   * үсгийг шалгана; SDK нэмж endResult === OK ба identity.etsi === гэрчилгээний SERIALNUMBER-ийг тулгана (эс бөгөөс
+   * ValidationError). Challenge нэг удаагийн — алдааны дараа шинээр авна.
+   */
+  async authVerify(challengeId, certDer, signature) {
+    let serial;
+    try {
+      serial = parseSubject(new X509Certificate2(certDer)).serialNumber;
+    } catch {
+      throw new Error("token auth: \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0437\u0430\u0434\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439");
+    }
+    if (!challengeId || !signature?.length) throw new Error("token auth: challengeId \u0431\u0430 signature \u0448\u0430\u0430\u0440\u0434\u043B\u0430\u0433\u0430\u0442\u0430\u0439");
+    const raw = await this.http.post(routePath(RP_ROUTES_UNDISCOVERED.tokenAuthVerify), {
+      challengeId,
+      certificate: Buffer.from(certDer).toString("base64"),
+      signature: Buffer.from(signature).toString("base64")
+    });
+    const r = rec5(raw);
+    if (rec5(r.result).endResult !== "OK") throw new ValidationError("token auth: endResult OK \u0431\u0438\u0448");
+    const id = rec5(r.identity);
+    if (!id.etsi || id.etsi !== serial) throw new ValidationError("token auth: identity.etsi \u043D\u044C \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0438\u0439 SERIALNUMBER \u0431\u0438\u0448");
+    const org = rec5(r.organization);
+    const cert = rec5(r.cert);
+    return {
+      identity: { etsi: String(id.etsi), givenName: String(id.givenName ?? ""), surname: String(id.surname ?? "") },
+      serialHex: String(cert.serialHex ?? ""),
+      notAfter: String(cert.notAfter ?? ""),
+      organization: org.etsi ? { etsi: String(org.etsi), name: String(org.name ?? "") } : null,
+      raw
+    };
+  }
+};
+function csrSpki(csr) {
+  const top = tlv(csr, 0, csr.length);
+  const info = tlv(csr, top.start, top.end);
+  const version = tlv(csr, info.start, info.end);
+  const subject = tlv(csr, version.end, info.end);
+  const spki = tlv(csr, subject.end, info.end);
+  return createPublicKey({ key: Buffer.from(csr.subarray(subject.end, spki.end)), format: "der", type: "spki" }).export({
+    format: "der",
+    type: "spki"
+  });
+}
+function verifyTokenCertificates(result, csrAuth, csrSign) {
+  if (!result?.auth || !result.sign) throw new ValidationError("token: auth/sign \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0430\u043B\u0433\u0430");
+  for (const [name, item, csr] of [
+    ["auth", result.auth, csrAuth],
+    ["sign", result.sign, csrSign]
+  ]) {
+    let want;
+    try {
+      want = csrSpki(csr);
+    } catch {
+      throw new Error(`token: ${name} CSR \u0437\u0430\u0434\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439`);
+    }
+    let got;
+    try {
+      got = new X509Certificate2(Buffer.from(item.certificate, "base64")).publicKey.export({ format: "der", type: "spki" });
+    } catch {
+      throw new ValidationError(`token: ${name} \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0437\u0430\u0434\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439`);
+    }
+    if (!got.equals(want)) throw new ValidationError(`token: ${name} \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0438\u0439 \u0442\u04AF\u043B\u0445\u04AF\u04AF\u0440 CSR-\u0438\u0439\u043D\u0445\u0442\u044D\u0439 \u0442\u0430\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439`);
+  }
+}
+function tokenAuthDigest(rpUUID, challengeB64) {
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(rpUUID)) {
+    throw new Error("token auth: rpUUID \u0436\u0438\u0436\u0438\u0433 \u04AF\u0441\u0433\u0438\u0439\u043D 36 \u0442\u044D\u043C\u0434\u044D\u0433\u0442 UUID \u0431\u0438\u0448");
+  }
+  const ch = Buffer.from(challengeB64, "base64");
+  if (ch.length !== 32 || ch.toString("base64") !== challengeB64) throw new Error("token auth: challenge 32 \u0431\u0430\u0439\u0442 base64 \u0431\u0438\u0448");
+  return createHash3("sha256").update("eID-TOKEN-AUTH", "ascii").update(rpUUID, "ascii").update(ch).digest();
+}
+function tokenLimitOf(err) {
+  if (!(err instanceof ApiError) || err.code !== "TOKEN_LIMIT_REACHED") return void 0;
+  let b;
+  try {
+    b = rec5(JSON.parse(err.body));
+  } catch {
+    return void 0;
+  }
+  if (typeof b.limit !== "number" || !Number.isInteger(b.limit) || b.limit < 0) return void 0;
+  if (b.kind === "PERSONAL") return { kind: "PERSONAL", limit: b.limit };
+  if (b.kind === "ORGANIZATION" && typeof b.organization === "string" && b.organization.startsWith("NTRMN-")) {
+    return { kind: "ORGANIZATION", limit: b.limit, organization: b.organization };
+  }
+  return void 0;
+}
 
 // src/validator.ts
+import { X509Certificate as X509Certificate3, constants, createHash as createHash4, publicDecrypt, verify } from "crypto";
+var CITIZEN_ISSUING_CA_SKI = "b8a37f2c64ad677912db7d9e34f246358a2fb909";
 var ResponseValidator = class {
   anchors;
   intermediates;
@@ -590,14 +922,28 @@ var ResponseValidator = class {
   allowUntrusted;
   revocation;
   revocationMode;
+  allowedIssuers;
+  checkKeyUsage;
+  schemeName;
   constructor(trust = {}) {
-    this.anchors = (trust.trustAnchorsPem ?? []).map((p) => new X509Certificate2(p));
-    this.intermediates = (trust.intermediatesPem ?? []).map((p) => new X509Certificate2(p));
+    this.anchors = (trust.trustAnchorsPem ?? []).map((p) => new X509Certificate3(p));
+    this.intermediates = (trust.intermediatesPem ?? []).map((p) => new X509Certificate3(p));
     this.requiredLevel = trust.requiredLevel ?? "QUALIFIED";
     this.skew = trust.clockSkewMs ?? 0;
     this.allowUntrusted = trust.allowUntrusted ?? false;
     this.revocation = trust.revocation;
     this.revocationMode = trust.revocationMode ?? "hard-fail";
+    if (trust.allowedIssuerSkis?.length) {
+      this.allowedIssuers = new Set(
+        trust.allowedIssuerSkis.map((s) => {
+          const ski = s.trim().replace(/:/g, "").toLowerCase();
+          if (!/^(?:[0-9a-f]{2})+$/.test(ski)) throw new Error(`ResponseValidator: allowedIssuerSkis: "${s}" hex key identifier \u0431\u0438\u0448`);
+          return ski;
+        })
+      );
+    }
+    this.checkKeyUsage = trust.checkKeyUsage ?? false;
+    this.schemeName = trust.schemeName;
   }
   // ── нийтийн API ──
   /**
@@ -625,6 +971,7 @@ var ResponseValidator = class {
     if (!interactionTypeUsed) throw new ValidationError("interactionTypeUsed \u0430\u043B\u0433\u0430");
     const { alg, hash } = this.algorithmOf(result, leaf, acsp.signatureAlgorithm, acsp.hashAlgorithm);
     const payload = buildAcspV2Payload({
+      ...this.schemeName ? { schemeName: this.schemeName } : {},
       serverRandom,
       rpChallenge: acsp.rpChallenge,
       userChallenge,
@@ -648,10 +995,14 @@ var ResponseValidator = class {
   }
   /**
    * Sign session-ийн хариуг бүрэн шалгаж, баталгаажсан гарын үсгийг буцаана.
-   * @param hashAlgorithm — digest-ийг үүсгэсэн hash (хүсэлтэд илгээсэнтэй ижил; default SHA-256).
+   * @param opts — `hashAlgorithm` мөр (хуучин хэлбэр; default SHA-256) эсвэл {@link ValidateSignOptions}.
    */
-  validateSign(result, digestB64, hashAlgorithm = "SHA-256") {
+  validateSign(result, digestB64, opts = {}) {
+    const { hashAlgorithm = "SHA-256", expectedFlowType } = typeof opts === "string" ? { hashAlgorithm: opts } : opts;
     const leaf = this.precheck(result, "RAW_DIGEST_SIGNATURE");
+    if (expectedFlowType && result.flowType !== expectedFlowType) {
+      throw new ValidationError(`flowType ${result.flowType} \u2260 \u044D\u0445\u043B\u04AF\u04AF\u043B\u0441\u044D\u043D \u0443\u0440\u0441\u0433\u0430\u043B ${expectedFlowType} (relay \u0431\u0430\u0439\u0436 \u0431\u043E\u043B\u0437\u043E\u0448\u0433\u04AF\u0439)`);
+    }
     const digest = Buffer.from(digestB64, "base64");
     const { alg, hash } = this.algorithmOf(result, leaf, null, hashAlgorithm);
     if (digest.length !== hashLen(hash)) throw new ValidationError("digest \u0443\u0440\u0442 hashAlgorithm-\u0442\u0430\u0439 \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439");
@@ -724,9 +1075,10 @@ var ResponseValidator = class {
     if (!result.certificateDerB64) throw new ValidationError("\u0425\u0430\u0440\u0438\u0443\u043D\u0434 \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0430\u043B\u0433\u0430");
     if (!result.signatureValueB64) throw new ValidationError("\u0425\u0430\u0440\u0438\u0443\u043D\u0434 \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 \u0430\u043B\u0433\u0430");
     if (!result.documentNumber) throw new ValidationError("\u0425\u0430\u0440\u0438\u0443\u043D\u0434 documentNumber \u0430\u043B\u0433\u0430");
-    const leaf = new X509Certificate2(Buffer.from(result.certificateDerB64, "base64"));
+    const leaf = new X509Certificate3(Buffer.from(result.certificateDerB64, "base64"));
     this.checkValidity(leaf);
     this.checkLevel(String(result.certificateLevel ?? ""));
+    this.checkPurpose(leaf, protocol);
     if (this.anchors.length === 0) {
       if (!this.allowUntrusted) {
         throw new ValidationError(
@@ -736,8 +1088,35 @@ var ResponseValidator = class {
     } else {
       this.verifyChain(leaf);
     }
+    this.checkIssuer(leaf);
     return leaf;
   }
+  /**
+   * checkKeyUsage үед гэрчилгээний зориулалт протоколд тохирох эсэх (CA crypto/ca_profile.go): ACSP_V2 (auth) → KU
+   * digitalSignature + EKU clientAuth (эсвэл anyExtendedKeyUsage); RAW_DIGEST_SIGNATURE (sign) → KU contentCommitment.
+   */
+  checkPurpose(leaf, protocol) {
+    if (!this.checkKeyUsage) return;
+    const ku = keyUsageBits(leaf);
+    if (protocol === "ACSP_V2") {
+      if (!(ku & 128)) throw new ValidationError("\u041D\u044D\u0432\u0442\u0440\u044D\u043B\u0442\u0438\u0439\u043D \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0434 KeyUsage digitalSignature \u0430\u043B\u0433\u0430");
+      const eku = extKeyUsage(leaf);
+      if (!eku.includes("1.3.6.1.5.5.7.3.2") && !eku.includes("2.5.29.37.0")) {
+        throw new ValidationError("\u041D\u044D\u0432\u0442\u0440\u044D\u043B\u0442\u0438\u0439\u043D \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0434 ExtKeyUsage clientAuth \u0430\u043B\u0433\u0430 (\u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u0433\u0438\u0439\u043D \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0431\u0430\u0439\u0436 \u0431\u043E\u043B\u0437\u043E\u0448\u0433\u04AF\u0439)");
+      }
+      return;
+    }
+    if (!(ku & 64)) throw new ValidationError("\u0413\u0430\u0440\u044B\u043D \u04AF\u0441\u0433\u0438\u0439\u043D \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0434 KeyUsage nonRepudiation (contentCommitment) \u0430\u043B\u0433\u0430");
+  }
+  /** allowedIssuerSkis үед leaf-ийн шууд issuer-ийн SKI (issuer-т алга бол leaf-ийн AKI) жагсаалтад байх ёстой. */
+  checkIssuer(leaf) {
+    if (!this.allowedIssuers) return;
+    const issuer = this.findIssuer(leaf);
+    const ski = (issuer && subjectKeyId(issuer)) ?? authorityKeyId(leaf);
+    if (!ski || !this.allowedIssuers.has(ski)) {
+      throw new ValidationError("\u0413\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u0433 \u0433\u0430\u0440\u0433\u0430\u0441\u0430\u043D CA \u0437\u04E9\u0432\u0448\u04E9\u04E9\u0440\u04E9\u0433\u0434\u0441\u04E9\u043D \u0438\u0440\u0433\u044D\u043D\u0438\u0439 issuer \u0431\u0438\u0448 (allowedIssuerSkis)");
+    }
+  }
   checkValidity(cert) {
     const now = Date.now();
     const from = Date.parse(cert.validFrom);
@@ -780,14 +1159,23 @@ var ResponseValidator = class {
    * дуудна (тэдгээр нь sync; revocation нь сүлжээ I/O тул async).
    */
   async checkRevocation(cert) {
-    if (!this.revocation) return;
+    await this.checkRevocationStatus(cert);
+  }
+  /**
+   * {@link checkRevocation} + юу шийдсэнийг буцаана (лог/аудитад): "good" | "unchecked" (unknown, soft-fail) |
+   * "skipped" (hook алга). "revoked", мөн hard-fail горимд "unknown" → ValidationError; hook-ийн алдаа дамжина.
+   */
+  async checkRevocationStatus(cert) {
+    if (!this.revocation) return "skipped";
     const status = await this.revocation(cert, this.findIssuer(cert));
+    if (status === "good") return "good";
     if (status === "revoked") {
       throw new ValidationError("\u0413\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0446\u0443\u0446\u043B\u0430\u0433\u0434\u0441\u0430\u043D (revoked)");
     }
-    if (status === "unknown" && this.revocationMode === "hard-fail") {
+    if (this.revocationMode === "hard-fail") {
       throw new ValidationError("\u0413\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0438\u0439 revocation \u0442\u04E9\u043B\u04E9\u0432 \u0442\u043E\u0433\u0442\u043E\u043E\u0433\u0434\u0441\u043E\u043D\u0433\u04AF\u0439 (hard-fail)");
     }
+    return "unchecked";
   }
 };
 function signedCallbackUrl(fromResponse, rpCallback, flowType) {
@@ -802,7 +1190,7 @@ function signedCallbackUrl(fromResponse, rpCallback, flowType) {
   return fromResponse;
 }
 function userChallengeOf(verifier) {
-  return createHash3("sha256").update(verifier, "utf8").digest("base64url");
+  return createHash4("sha256").update(verifier, "utf8").digest("base64url");
 }
 function verifyPayloadSignature(payload, sigB64, key, alg, hash) {
   const sig = Buffer.from(sigB64, "base64");
@@ -904,7 +1292,7 @@ function mgf1(hash, seed, length) {
   for (let i = 0, n = 0; n < length; i++, n += hashLen(hash)) {
     const c = Buffer.alloc(4);
     c.writeUInt32BE(i, 0);
-    out.push(createHash3(nodeHash(hash)).update(seed).update(c).digest());
+    out.push(createHash4(nodeHash(hash)).update(seed).update(c).digest());
   }
   return Buffer.concat(out).subarray(0, length);
 }
@@ -928,9 +1316,42 @@ function emsaPssVerify(mHash, em, emBits, hash) {
   const psLen = emLen - hLen - sLen - 2;
   if (!db.subarray(0, psLen).every((b) => b === 0) || db[psLen] !== 1) return false;
   const salt = db.subarray(psLen + 1);
-  const h2 = createHash3(nodeHash(hash)).update(Buffer.alloc(8)).update(mHash).update(salt).digest();
+  const h2 = createHash4(nodeHash(hash)).update(Buffer.alloc(8)).update(mHash).update(salt).digest();
   return h.equals(h2);
 }
+function keyUsageBits(cert) {
+  const v = certExtension(cert.raw, "2.5.29.15");
+  if (!v) return 0;
+  const bs = tlv(v, 0, v.length);
+  if (bs.tag !== 3 || bs.end - bs.start < 2) return 0;
+  return v[bs.start + 1];
+}
+function extKeyUsage(cert) {
+  const v = certExtension(cert.raw, "2.5.29.37");
+  if (!v) return [];
+  const seq = tlv(v, 0, v.length);
+  const out = [];
+  for (let p = seq.start; p < seq.end; ) {
+    const t = tlv(v, p, seq.end);
+    out.push(oidOf(v, t));
+    p = t.end;
+  }
+  return out;
+}
+function subjectKeyId(cert) {
+  const v = certExtension(cert.raw, "2.5.29.14");
+  if (!v) return void 0;
+  const o = tlv(v, 0, v.length);
+  return o.tag === 4 && o.end > o.start ? Buffer.from(v.subarray(o.start, o.end)).toString("hex") : void 0;
+}
+function authorityKeyId(cert) {
+  const v = certExtension(cert.raw, "2.5.29.35");
+  if (!v) return void 0;
+  const seq = tlv(v, 0, v.length);
+  if (seq.start >= seq.end) return void 0;
+  const k = tlv(v, seq.start, seq.end);
+  return k.tag === 128 && k.end > k.start ? Buffer.from(v.subarray(k.start, k.end)).toString("hex") : void 0;
+}
 function isCa(cert) {
   return cert.ca === true;
 }
@@ -958,6 +1379,8 @@ var EidClient = class {
   sign;
   pdf;
   organization;
+  person;
+  token;
   session;
   validator;
   constructor(cfg) {
@@ -973,8 +1396,10 @@ var EidClient = class {
     const level = cfg.defaultCertificateLevel ?? "QUALIFIED";
     this.auth = new AuthApi(http, cfg.credentials, { certificateLevel: level });
     this.sign = new SignApi(http, cfg.credentials, { certificateLevel: level });
-    this.pdf = new PdfApi(http, cfg.credentials, { certificateLevel: level });
+    this.pdf = new PdfApi(http, cfg.credentials, { certificateLevel: level, timeoutMs: cfg.pdfTimeoutMs ?? DEFAULT_PDF_TIMEOUT_MS });
     this.organization = new OrganizationApi(http);
+    this.person = new PersonApi(http);
+    this.token = new TokenApi(http, cfg.credentials);
     this.session = new SessionApi(http);
     this.validator = new ResponseValidator(cfg.trust ?? {});
   }
@@ -1051,7 +1476,7 @@ function qrDeviceLinkTicker(input, onLink, opts) {
 }
 
 // src/oidc.ts
-import { timingSafeEqual } from "crypto";
+import { timingSafeEqual as timingSafeEqual2 } from "crypto";
 var EID_OIDC_ISSUER = "https://login.eidmongolia.mn";
 var EID_ACR_QUALIFIED = "urn:eidmongolia:loa:qualified";
 var EID_ACR_ADVANCED = "urn:eidmongolia:loa:advanced";
@@ -1088,7 +1513,7 @@ var EidOidcClient = class {
     if (!cfg.clientSecret) throw new EidError("EidOidcClient: clientSecret \u0445\u043E\u043E\u0441\u043E\u043D");
     if (!/^https:\/\//.test(cfg.redirectUri ?? "")) throw new EidError("EidOidcClient: redirectUri https:// \u0431\u0430\u0439\u0445 \u0451\u0441\u0442\u043E\u0439");
     this.issuer = (cfg.issuer ?? EID_OIDC_ISSUER).replace(/\/+$/, "");
-    this.scope = cfg.scope ?? "openid";
+    this.scope = cfg.scope ?? OIDC_EXPECT.defaultScope;
   }
   cfg;
   issuer;
@@ -1136,7 +1561,7 @@ var EidOidcClient = class {
       state,
       nonce,
       code_challenge: await pkceChallenge(codeVerifier),
-      code_challenge_method: "S256"
+      code_challenge_method: OIDC_EXPECT.pkceMethod
     });
     if (opts.display) p.set("display", opts.display);
     u.search = p.toString();
@@ -1215,7 +1640,7 @@ var EidOidcClient = class {
     const header = decodeJsonPart(parts[0]);
     const payload = decodeJsonPart(parts[1]);
     if (!header || !payload) throw bad("\u0445\u044D\u043B\u0431\u044D\u0440 \u0431\u0443\u0440\u0443\u0443");
-    if (header.alg !== "ES256") throw bad("alg ES256 \u0431\u0438\u0448");
+    if (header.alg !== OIDC_EXPECT.idTokenAlg) throw bad("alg ES256 \u0431\u0438\u0448");
     const kid = typeof header.kid === "string" ? header.kid : "";
     if (!kid) throw bad("kid \u0430\u043B\u0433\u0430");
     const pick = (ks) => ks.find(
@@ -1308,7 +1733,7 @@ function formEncode(s) {
 function timingSafeEqualStr(a, b) {
   const x = Buffer.from(a, "utf8");
   const y = Buffer.from(b, "utf8");
-  return x.length === y.length && timingSafeEqual(x, y);
+  return x.length === y.length && timingSafeEqual2(x, y);
 }
 function decodeJsonPart(s) {
   try {
@@ -1330,7 +1755,9 @@ export {
   ApiError,
   AuthApi,
   AuthenticationError,
+  CITIZEN_ISSUING_CA_SKI,
   DEFAULT_BASE_URL,
+  DEFAULT_PDF_TIMEOUT_MS,
   DeviceLinkError,
   EID_ACR_ADVANCED,
   EID_ACR_QUALIFIED,
@@ -1345,10 +1772,13 @@ export {
   ON_BEHALF_ERROR_CODES,
   OrganizationApi,
   PdfApi,
+  PersonApi,
+  RETRYABLE_ERROR_CODES,
   ResponseValidator,
   SessionApi,
   SessionFailedError,
   SignApi,
+  TokenApi,
   ValidationError,
   acspV2Digest,
   buildAcspV2Payload,
@@ -1357,14 +1787,19 @@ export {
   interactionsToBase64,
   isMobileUserAgent,
   openOrShowQR,
+  parseRetryAfter,
   parseSessionResult,
   parseSubject,
+  personMatchesCertificate,
   pkceChallenge,
   qrDeviceLinkTicker,
   randomChallenge,
   resolveBaseUrl,
   sha256Base64,
+  tokenAuthDigest,
+  tokenLimitOf,
   userChallengeOf,
   verifyPayloadSignature,
-  verifyPrehashedSignature
+  verifyPrehashedSignature,
+  verifyTokenCertificates
 };