@gerege-systems/eid-mongolia-sdk 0.9.1 → 0.11.0

package/dist/index.cjs

@@ -23,7 +23,10 @@ __export(index_exports, {
   ApiError: () => ApiError,
   AuthApi: () => AuthApi,
   AuthenticationError: () => AuthenticationError,
+  CITIZEN_ISSUING_CA_SKI: () => CITIZEN_ISSUING_CA_SKI,
   DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  DEFAULT_PDF_MAX_BYTES: () => DEFAULT_PDF_MAX_BYTES,
+  DEFAULT_PDF_TIMEOUT_MS: () => DEFAULT_PDF_TIMEOUT_MS,
   DeviceLinkError: () => DeviceLinkError,
   EID_ACR_ADVANCED: () => EID_ACR_ADVANCED,
   EID_ACR_QUALIFIED: () => EID_ACR_QUALIFIED,
@@ -38,10 +41,14 @@ __export(index_exports, {
   ON_BEHALF_ERROR_CODES: () => ON_BEHALF_ERROR_CODES,
   OrganizationApi: () => OrganizationApi,
   PdfApi: () => PdfApi,
+  PersonApi: () => PersonApi,
+  RETRYABLE_ERROR_CODES: () => RETRYABLE_ERROR_CODES,
+  ResponseTooLargeError: () => ResponseTooLargeError,
   ResponseValidator: () => ResponseValidator,
   SessionApi: () => SessionApi,
   SessionFailedError: () => SessionFailedError,
   SignApi: () => SignApi,
+  TokenApi: () => TokenApi,
   ValidationError: () => ValidationError,
   acspV2Digest: () => acspV2Digest,
   buildAcspV2Payload: () => buildAcspV2Payload,
@@ -50,16 +57,21 @@ __export(index_exports, {
   interactionsToBase64: () => interactionsToBase64,
   isMobileUserAgent: () => isMobileUserAgent,
   openOrShowQR: () => openOrShowQR,
+  parseRetryAfter: () => parseRetryAfter,
   parseSessionResult: () => parseSessionResult,
   parseSubject: () => parseSubject,
+  personMatchesCertificate: () => personMatchesCertificate,
   pkceChallenge: () => pkceChallenge,
   qrDeviceLinkTicker: () => qrDeviceLinkTicker,
   randomChallenge: () => randomChallenge,
   resolveBaseUrl: () => resolveBaseUrl,
   sha256Base64: () => sha256Base64,
+  tokenAuthDigest: () => tokenAuthDigest,
+  tokenLimitOf: () => tokenLimitOf,
   userChallengeOf: () => userChallengeOf,
   verifyPayloadSignature: () => verifyPayloadSignature,
-  verifyPrehashedSignature: () => verifyPrehashedSignature
+  verifyPrehashedSignature: () => verifyPrehashedSignature,
+  verifyTokenCertificates: () => verifyTokenCertificates
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -71,25 +83,79 @@ var EidError = class extends Error {
   }
 };
 var AuthenticationError = class extends EidError {
+  /** Серверийн `{"code"}`; байхгүй / JSON биш (proxy) бол undefined. */
+  code;
+  /** Серверийн `{"error"}` текст (логт); JSON биш (proxy) бол undefined. */
+  serverMessage;
+  /** Хариуны бие (таслагдаагүй текст). */
+  body;
+  headers;
+  constructor(message, init) {
+    super(message);
+    this.code = init?.code;
+    this.serverMessage = init?.serverMessage;
+    this.body = init?.body;
+    this.headers = init?.headers;
+  }
 };
 var ForbiddenError = class extends EidError {
-  constructor(message, code) {
+  constructor(message, code, init) {
     super(message);
     this.code = code;
+    this.headers = init?.headers;
+    this.retryAfterMs = init?.retryAfterMs;
   }
   code;
+  headers;
+  /** Retry-After (мс), байхгүй бол undefined. */
+  retryAfterMs;
 };
 var ApiError = class extends EidError {
-  constructor(status, body, code) {
+  constructor(status, body, code, init) {
     super(`RP-API ${status}: ${body}`);
     this.status = status;
     this.body = body;
     this.code = code;
+    this.headers = init?.headers;
+    this.retryAfterMs = init?.retryAfterMs;
   }
   status;
   body;
   code;
+  headers;
+  /**
+   * Retry-After (мс, секунд эсвэл HTTP-огноо задалсан); байхгүй/буруу бол undefined. CA түр алдаанд (429
+   * PDF_PREPARE_BUSY / RATE_LIMITED, 503 DOCUMENT_PENDING / TSA_UNAVAILABLE / LTV_UNAVAILABLE г.м.) тавина.
+   */
+  retryAfterMs;
+  /**
+   * CA-ийн түр алдаа ({@link RETRYABLE_ERROR_CODES}-ийн нэг, эсвэл 429/503 + Retry-After): `retryAfterMs`-ийн дараа
+   * ижил хүсэлтийг давтаж болно.
+   */
+  get retryable() {
+    if (this.code && RETRYABLE_ERROR_CODES.includes(this.code)) return true;
+    return (this.status === 429 || this.status === 503) && (this.retryAfterMs ?? 0) > 0;
+  }
 };
+var RETRYABLE_ERROR_CODES = [
+  "PDF_PREPARE_BUSY",
+  "DOCUMENT_PENDING",
+  "TSA_UNAVAILABLE",
+  "LTV_UNAVAILABLE",
+  "RATE_LIMITED",
+  "STATE_UNAVAILABLE",
+  "ISSUANCE_PENDING"
+];
+function parseRetryAfter(value, now = Date.now()) {
+  const v = (value ?? "").trim();
+  if (!v) return void 0;
+  if (/^-?\d+$/.test(v)) {
+    const n = Number(v);
+    return n > 0 && n <= 86400 ? n * 1e3 : void 0;
+  }
+  const t = Date.parse(v);
+  return Number.isNaN(t) || t <= now ? void 0 : t - now;
+}
 var ON_BEHALF_ERROR_CODES = [
   "REPRESENTATION_DENIED",
   "REPRESENTATION_PENDING",
@@ -100,7 +166,28 @@ var ON_BEHALF_ERROR_CODES = [
   "REPRESENTATION_REVOKED"
 ];
 var NetworkError = class extends EidError {
+  /** "GET /session/…" (таних тэмдэг хасагдсан зам). */
+  op;
+  /** Хүсэлт хугацаа хэтэрсэн. */
+  timeout;
+  constructor(message, init) {
+    super(message);
+    this.op = init?.op;
+    this.timeout = init?.timeout;
+  }
+};
+var ResponseTooLargeError = class extends EidError {
+  constructor(op, limit) {
+    super(`${op}: \u0445\u0430\u0440\u0438\u0443 ${limit} \u0431\u0430\u0439\u0442\u0430\u0430\u0441 \u0438\u0445`);
+    this.op = op;
+    this.limit = limit;
+  }
+  op;
+  limit;
 };
+function maskPath(path) {
+  return path.split(/[?#]/)[0].replace(/\/(etsi|document)\/[^/?#\s]+/g, "/$1/\u2026");
+}
 var SessionFailedError = class extends EidError {
   constructor(endResult) {
     super(`Session \u0430\u043C\u0436\u0438\u043B\u0442\u0433\u04AF\u0439: ${endResult}`);
@@ -115,6 +202,7 @@ var DeviceLinkError = class extends EidError {
 
 // src/http.ts
 var DEFAULT_TIMEOUT_MS = 15e3;
+var MAX_JSON_BYTES = 4 << 20;
 var Http = class {
   constructor(cfg) {
     this.cfg = cfg;
@@ -130,14 +218,14 @@ var Http = class {
   postMultipart(path, form, timeoutMs) {
     return this.json("POST", path, form, void 0, timeoutMs);
   }
-  /** GET — хариуг байтаар (ж: гарын үсэгтэй PDF). */
-  async getBytes(path, timeoutMs) {
+  /** GET — хариуг байтаар (ж: гарын үсэгтэй PDF), `maxBytes` хүртэл; хэтэрвэл {@link ResponseTooLargeError}. */
+  async getBytes(path, timeoutMs, maxBytes = 64 << 20) {
     const res = await this.send("GET", path, void 0, void 0, timeoutMs);
-    return new Uint8Array(await res.arrayBuffer());
+    return readLimited(res, maxBytes, `GET ${maskPath(path)}`);
   }
   async json(method, path, body, contentType, timeoutMs) {
     const res = await this.send(method, path, body, contentType, timeoutMs);
-    const text = await res.text();
+    const text = new TextDecoder().decode(await readLimited(res, MAX_JSON_BYTES, `${method} ${maskPath(path)}`));
     return text ? JSON.parse(text) : {};
   }
   async send(method, path, body, contentType, timeoutMs) {
@@ -154,28 +242,62 @@ 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 });
   }
 };
+async function readLimited(res, limit, op) {
+  const declared = Number(res.headers.get("content-length") ?? NaN);
+  if (declared > limit) {
+    await res.body?.cancel().catch(() => void 0);
+    throw new ResponseTooLargeError(op, limit);
+  }
+  if (!res.body) return new Uint8Array(0);
+  const reader = res.body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > limit) {
+      await reader.cancel().catch(() => void 0);
+      throw new ResponseTooLargeError(op, limit);
+    }
+    chunks.push(value);
+  }
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.byteLength;
+  }
+  return out;
+}
 function errorBody(text) {
   try {
     const v = JSON.parse(text);
@@ -190,6 +312,51 @@ 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" },
+  pdfTokenPrepare: { method: "POST", path: "/pdf/token/prepare" },
+  pdfTokenFinalize: { method: "POST", path: "/pdf/token/{signingID}/finalize" },
+  pdfTokenDocument: { method: "GET", path: "/pdf/token/{signingID}/document" }
+};
+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
 var import_node_crypto = require("crypto");
 function sha256Base64(data) {
@@ -292,25 +459,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);
   }
 };
@@ -343,6 +510,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) {
@@ -355,12 +523,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 (богино текст баримтад тохиромжтой). */
@@ -401,9 +569,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);
@@ -457,7 +660,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-оос урт
     );
@@ -482,6 +685,8 @@ var SessionApi = class {
 
 // src/pdf.ts
 var import_node_crypto2 = require("crypto");
+var DEFAULT_PDF_MAX_BYTES = 64 << 20;
+var DEFAULT_PDF_TIMEOUT_MS = 8e4;
 function rec3(v) {
   return v && typeof v === "object" ? v : {};
 }
@@ -494,7 +699,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,
@@ -510,7 +718,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.timeout));
     const receivedAt = Date.now();
     const vc = rec3(r.vc).value;
     const dl = rec3(r.deviceLink);
@@ -532,10 +740,80 @@ 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.timeout, this.maxBytes);
+  }
+  get timeout() {
+    return this.defaults.timeoutMs ?? DEFAULT_PDF_TIMEOUT_MS;
+  }
+  get maxBytes() {
+    return this.defaults.maxBytes ?? DEFAULT_PDF_MAX_BYTES;
+  }
+  /**
+   * USB токены PAdES (CA docs/PADES_SIGNING.md §16.5, TOKEN_CERT.md) — session / утас оролцохгүй. POST /pdf/token/prepare
+   * (multipart: `request` JSON + `pdf`), SIGN эрх. Дараа нь токеноор `hashToSign`-ийг CKM_ECDSA (prehashed, P-256)-аар
+   * зурж {@link tokenFinalize}. Түр алдаа: `ApiError` 429 PDF_PREPARE_BUSY / RATE_LIMITED, 503 TSA_UNAVAILABLE /
+   * LTV_UNAVAILABLE / STATE_UNAVAILABLE (`retryable`). Гэрчилгээ токенд холбогдоогүй / цуцлагдсан → 409
+   * TOKEN_CERT_INVALID. Зам нь CA-д бий ч `/.well-known/eid`-д хараахан алга (гэрээний тест WARN).
+   */
+  async tokenPrepare(input) {
+    if (!input.pdf?.length || !input.certificate?.length || !input.signerEtsi?.trim() || !input.fileName?.trim()) {
+      throw new Error("eid: pdf token: pdf, certificate, signerEtsi, fileName \u0448\u0430\u0430\u0440\u0434\u043B\u0430\u0433\u0430\u0442\u0430\u0439");
+    }
+    const request = {
+      relyingPartyUUID: this.creds.rpUUID,
+      relyingPartyName: this.creds.rpName,
+      signer: { etsi: input.signerEtsi.trim() },
+      certificate: Buffer.from(input.certificate).toString("base64"),
+      fileName: input.fileName
+    };
+    if (input.docID?.trim()) request.docID = input.docID.trim();
+    if (input.onBehalfOf?.trim()) request.onBehalfOf = input.onBehalfOf.trim();
+    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 raw = await this.http.postMultipart(routePath(RP_ROUTES_UNDISCOVERED.pdfTokenPrepare), form, this.timeout);
+    const r = rec3(raw);
+    const hashToSign = new Uint8Array(Buffer.from(String(r.hashToSign ?? ""), "base64"));
+    if (!r.signingID || hashToSign.length !== 32) {
+      throw new ValidationError("pdf token prepare: signingID / hashToSign (32 \u0431\u0430\u0439\u0442) \u0431\u0443\u0440\u0443\u0443");
+    }
+    return {
+      signingId: String(r.signingID),
+      docId: String(r.docID ?? ""),
+      hashToSign,
+      hashAlgorithm: String(r.hashAlgorithm ?? ""),
+      signatureAlgorithm: String(r.signatureAlgorithm ?? ""),
+      signatureFormat: String(r.signatureFormat ?? ""),
+      expiresAt: String(r.expiresAt ?? ""),
+      raw
+    };
+  }
+  /**
+   * POST /pdf/token/{signingID}/finalize `{signature: base64 түүхий r||s}` — `signature` 64 байт (P-256 r||s, DER БИШ).
+   * Амжвал READY баримтын блок (`outSha256` — {@link tokenDocument}-оор татсан файлтай тулга). READY-ээс хойш идэмпотент.
+   * Алдаа: 400 SIGNATURE_INVALID (3 удаа → FAILED), 409 DOCUMENT_FAILED, 410 DOCUMENT_EXPIRED, 503 DOCUMENT_PENDING /
+   * TSA_UNAVAILABLE / LTV_UNAVAILABLE — ижил гарын үсгийг `retryAfterMs`-ийн дараа дахин илгээнэ.
+   */
+  async tokenFinalize(signingId, signature) {
+    if (signature?.length !== 64) throw new Error("eid: pdf token: signature \u043D\u044C \u0442\u04AF\u04AF\u0445\u0438\u0439 r||s 64 \u0431\u0430\u0439\u0442 \u0431\u0430\u0439\u0445 \u0451\u0441\u0442\u043E\u0439 (P-256, DER \u0431\u0438\u0448)");
+    const r = await this.http.post(
+      routePath(RP_ROUTES_UNDISCOVERED.pdfTokenFinalize, signingId),
+      { signature: Buffer.from(signature).toString("base64") },
+      this.timeout
+    );
+    return r;
+  }
+  /**
+   * GET /pdf/token/{signingID}/document — гарын үсэгтэй PDF (зөвхөн үүсгэсэн RP, expiresAt хүртэл), `pdfMaxBytes`
+   * хүртэл. SHA-256-ийг {@link tokenFinalize}-ийн `outSha256`-тай заавал тулга.
+   */
+  tokenDocument(signingId) {
+    return this.http.getBytes(routePath(RP_ROUTES_UNDISCOVERED.pdfTokenDocument, signingId), this.timeout, this.maxBytes);
   }
   /**
    * {@link document} + тулгалт: татсан байтын SHA-256 нь session poll-ийн `pdf.outSha256`-тай тэнцүү байх ёстой.
@@ -567,13 +845,53 @@ 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 };
+    return { personEtsi: String(raw.personEtsi ?? personEtsi), representations: list, raw };
   }
 };
 
-// src/validator.ts
+// 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
 var import_node_crypto4 = require("crypto");
 
 // src/subject.ts
@@ -680,8 +998,215 @@ function parseSubject(cert) {
   out.name = full || out.commonName || null;
   return out;
 }
+function certExtension(der, oid) {
+  return certExtensions(der).find((e) => e.oid === oid)?.value;
+}
+function certExtensions(der) {
+  const out = [];
+  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);
+        let critical = false;
+        if (v.tag === 1) {
+          critical = v.end > v.start && der[v.start] !== 0;
+          v = tlv(der, v.end, ext.end);
+        }
+        if (v.tag !== 4) throw new ValidationError("extension: extnValue OCTET STRING \u0431\u0438\u0448");
+        out.push({ oid: oidOf(der, id), critical, value: der.subarray(v.start, v.end) });
+        ep = ext.end;
+      }
+      return out;
+    }
+    pos = t.end;
+  }
+  return out;
+}
+
+// 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 (0, import_node_crypto4.timingSafeEqual)((0, import_node_crypto4.createHash)("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 import_node_crypto4.X509Certificate(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 (0, import_node_crypto4.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 import_node_crypto4.X509Certificate(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 (0, import_node_crypto4.createHash)("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
+var import_node_crypto5 = require("crypto");
+var CITIZEN_ISSUING_CA_SKI = "b8a37f2c64ad677912db7d9e34f246358a2fb909";
 var ResponseValidator = class {
   anchors;
   intermediates;
@@ -690,14 +1215,28 @@ var ResponseValidator = class {
   allowUntrusted;
   revocation;
   revocationMode;
+  allowedIssuers;
+  checkKeyUsage;
+  schemeName;
   constructor(trust = {}) {
-    this.anchors = (trust.trustAnchorsPem ?? []).map((p) => new import_node_crypto4.X509Certificate(p));
-    this.intermediates = (trust.intermediatesPem ?? []).map((p) => new import_node_crypto4.X509Certificate(p));
+    this.anchors = (trust.trustAnchorsPem ?? []).map((p) => new import_node_crypto5.X509Certificate(p));
+    this.intermediates = (trust.intermediatesPem ?? []).map((p) => new import_node_crypto5.X509Certificate(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 ──
   /**
@@ -725,6 +1264,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,
@@ -828,9 +1368,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 import_node_crypto4.X509Certificate(Buffer.from(result.certificateDerB64, "base64"));
+    const leaf = new import_node_crypto5.X509Certificate(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(
@@ -838,10 +1379,37 @@ var ResponseValidator = class {
         );
       }
     } else {
-      this.verifyChain(leaf);
+      this.verifyChain(leaf, protocol === "ACSP_V2" ? EKU_CLIENT_AUTH : EKU_EMAIL_PROTECTION);
     }
+    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);
@@ -855,21 +1423,40 @@ var ResponseValidator = class {
     const need = rank[this.requiredLevel] ?? 2;
     if (got < need) throw new ValidationError(`\u0413\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0438\u0439 \u0442\u04AF\u0432\u0448\u0438\u043D \u0445\u04AF\u0440\u044D\u043B\u0446\u044D\u0445\u0433\u04AF\u0439: ${level} < ${this.requiredLevel}`);
   }
-  /** leaf-ээс эхлэн issuer-ийг intermediates/anchors дотроос олж, anchor хүртэл chain зангидна. */
-  verifyChain(leaf) {
-    let current = leaf;
-    const pool = [...this.intermediates, ...this.anchors];
-    for (let depth = 0; depth < 8; depth++) {
-      for (const anchor of this.anchors) {
-        if (isCa(anchor) && current.checkIssued(anchor) && current.verify(anchor.publicKey)) return;
+  /**
+   * RFC 5280 замын шалгалт (Go SDK-ийн `x509.Certificate.Verify`-тэй ижил дүрэм): leaf-ээс trust anchor хүртэлх
+   * замыг intermediates/anchors-оос (backtracking-тай) угсарна. Issuer бүр: subject = child.issuer, AKI/SKI таарах,
+   * гарын үсэг, CA (basicConstraints CA:TRUE), KeyUsage тавьсан бол keyCertSign, **pathLenConstraint** (доорх
+   * завсрын CA-ийн тоо), хүчинтэй хугацаа, EKU тавьсан бол `usage` / anyExtendedKeyUsage агуулах. Leaf болон CA
+   * бүрийн үл таних **critical extension** → татгалзана. **Name constraints**-ийг SDK үнэлдэггүй — гинжинд байвал
+   * fail-closed (CA-ийн бодит гинж 01–04-т алга). Цаг = now, leaf-ийн хүчинтэй хугацаанд хавчсан (`clockSkewMs`-ийн
+   * хүрээнд; leaf-ийн хугацааг checkValidity шалгасан). certificatePolicies шалгахгүй (Go-той ижил).
+   */
+  verifyChain(leaf, usage) {
+    const now = Math.min(Math.max(Date.now(), Date.parse(leaf.validFrom)), Date.parse(leaf.validTo));
+    const leafReason = criticalReason(leaf) ?? ekuReason(leaf, usage);
+    if (leafReason) throw new ValidationError(`\u0413\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0438\u0439 \u0433\u0438\u043D\u0436 \u0445\u04AF\u0447\u0438\u043D\u0433\u04AF\u0439: ${leafReason}`);
+    let reason;
+    const extend = (cur, cas) => {
+      if (cas.length >= 8) return false;
+      for (const [cand, isAnchor] of [
+        ...this.anchors.map((c) => [c, true]),
+        ...this.intermediates.map((c) => [c, false])
+      ]) {
+        if (cas.includes(cand) || !signedBy(cur, cand)) continue;
+        const bad = caReason(cand, cas.length, now, usage);
+        if (bad) {
+          reason ??= bad;
+          continue;
+        }
+        if (isAnchor || extend(cand, [...cas, cand])) return true;
       }
-      const issuer = pool.find(
-        (c) => isCa(c) && current.checkIssued(c) && current.verify(c.publicKey)
-      );
-      if (!issuer) break;
-      current = issuer;
-    }
-    throw new ValidationError("\u0413\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0438\u0439 \u0438\u0442\u0433\u044D\u043B\u0446\u043B\u0438\u0439\u043D \u0433\u0438\u043D\u0436 trust anchor (Root CA) \u0445\u04AF\u0440\u0441\u044D\u043D\u0433\u04AF\u0439");
+      return false;
+    };
+    if (extend(leaf, [])) return;
+    throw new ValidationError(
+      reason ? `\u0413\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0438\u0439 \u0433\u0438\u043D\u0436 \u0445\u04AF\u0447\u0438\u043D\u0433\u04AF\u0439: ${reason}` : "\u0413\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0438\u0439 \u0438\u0442\u0433\u044D\u043B\u0446\u043B\u0438\u0439\u043D \u0433\u0438\u043D\u0436 trust anchor (Root CA) \u0445\u04AF\u0440\u0441\u044D\u043D\u0433\u04AF\u0439"
+    );
   }
   /** leaf-ийн шууд issuer-ийг trust pool-оос буцаана (revocation шалгагчид issuer хэрэгтэй). */
   findIssuer(leaf) {
@@ -884,14 +1471,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) {
@@ -906,16 +1502,16 @@ function signedCallbackUrl(fromResponse, rpCallback, flowType) {
   return fromResponse;
 }
 function userChallengeOf(verifier) {
-  return (0, import_node_crypto4.createHash)("sha256").update(verifier, "utf8").digest("base64url");
+  return (0, import_node_crypto5.createHash)("sha256").update(verifier, "utf8").digest("base64url");
 }
 function verifyPayloadSignature(payload, sigB64, key, alg, hash) {
   const sig = Buffer.from(sigB64, "base64");
   const h = nodeHash(hash);
   if (alg === "rsassa-pss") {
-    return (0, import_node_crypto4.verify)(h, payload, { key, padding: import_node_crypto4.constants.RSA_PKCS1_PSS_PADDING, saltLength: hashLen(hash) }, sig);
+    return (0, import_node_crypto5.verify)(h, payload, { key, padding: import_node_crypto5.constants.RSA_PKCS1_PSS_PADDING, saltLength: hashLen(hash) }, sig);
   }
-  if (alg === "ecdsa-with-SHA256") return (0, import_node_crypto4.verify)(h, payload, { key, dsaEncoding: "der" }, sig);
-  return (0, import_node_crypto4.verify)(h, payload, { key, padding: import_node_crypto4.constants.RSA_PKCS1_PADDING }, sig);
+  if (alg === "ecdsa-with-SHA256") return (0, import_node_crypto5.verify)(h, payload, { key, dsaEncoding: "der" }, sig);
+  return (0, import_node_crypto5.verify)(h, payload, { key, padding: import_node_crypto5.constants.RSA_PKCS1_PADDING }, sig);
 }
 function verifyPrehashedSignature(digest, sigB64, key, alg, hash) {
   const sig = Buffer.from(sigB64, "base64");
@@ -924,7 +1520,7 @@ function verifyPrehashedSignature(digest, sigB64, key, alg, hash) {
   if (!modBits || sig.length !== Math.ceil(modBits / 8)) return false;
   let em;
   try {
-    em = (0, import_node_crypto4.publicDecrypt)({ key, padding: import_node_crypto4.constants.RSA_NO_PADDING }, sig);
+    em = (0, import_node_crypto5.publicDecrypt)({ key, padding: import_node_crypto5.constants.RSA_NO_PADDING }, sig);
   } catch {
     return false;
   }
@@ -1008,7 +1604,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((0, import_node_crypto4.createHash)(nodeHash(hash)).update(seed).update(c).digest());
+    out.push((0, import_node_crypto5.createHash)(nodeHash(hash)).update(seed).update(c).digest());
   }
   return Buffer.concat(out).subarray(0, length);
 }
@@ -1032,12 +1628,118 @@ 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 = (0, import_node_crypto4.createHash)(nodeHash(hash)).update(Buffer.alloc(8)).update(mHash).update(salt).digest();
+  const h2 = (0, import_node_crypto5.createHash)(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;
 }
+var EKU_ANY = "2.5.29.37.0";
+var EKU_CLIENT_AUTH = "1.3.6.1.5.5.7.3.2";
+var EKU_EMAIL_PROTECTION = "1.3.6.1.5.5.7.3.4";
+var OID_NAME_CONSTRAINTS = "2.5.29.30";
+var HANDLED_CRITICAL = /* @__PURE__ */ new Set([
+  "2.5.29.14",
+  // subjectKeyIdentifier
+  "2.5.29.15",
+  // keyUsage
+  "2.5.29.17",
+  // subjectAltName
+  "2.5.29.19",
+  // basicConstraints
+  "2.5.29.30",
+  // nameConstraints (CA-д — caReason fail-closed)
+  "2.5.29.31",
+  // cRLDistributionPoints
+  "2.5.29.32",
+  // certificatePolicies
+  "2.5.29.35",
+  // authorityKeyIdentifier
+  "2.5.29.37",
+  // extKeyUsage
+  "1.3.6.1.5.5.7.1.1"
+  // authorityInfoAccess
+]);
+function signedBy(child, cand) {
+  if (child.issuer !== cand.subject) return false;
+  const aki = authorityKeyId(child);
+  const ski = subjectKeyId(cand);
+  if (aki && ski && aki !== ski) return false;
+  try {
+    return child.verify(cand.publicKey);
+  } catch {
+    return false;
+  }
+}
+function criticalReason(cert) {
+  return certExtensions(cert.raw).some((e) => e.critical && !HANDLED_CRITICAL.has(e.oid)) ? "\u04AF\u043B \u0442\u0430\u043D\u0438\u0445 critical extension" : void 0;
+}
+function ekuReason(cert, usage) {
+  const eku = extKeyUsage(cert);
+  return eku.length && !eku.includes(usage) && !eku.includes(EKU_ANY) ? "\u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0438\u0439 ExtKeyUsage \u044D\u043D\u044D \u04AF\u0439\u043B\u0434\u044D\u043B\u0434 \u0442\u043E\u0445\u0438\u0440\u043E\u0445\u0433\u04AF\u0439 (\u0433\u0438\u043D\u0436\u0438\u0439\u043D EKU)" : void 0;
+}
+function caReason(ca, below, now, usage) {
+  if (!isCa(ca)) return "\u0437\u0430\u0432\u0441\u0440\u044B\u043D \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D CA \u0431\u0438\u0448 \u044D\u0441\u0432\u044D\u043B keyCertSign \u044D\u0440\u0445\u0433\u04AF\u0439";
+  if (certExtension(ca.raw, "2.5.29.15") && !(keyUsageBits(ca) & 4)) return "CA-\u0438\u0439\u043D KeyUsage-\u0434 keyCertSign \u0430\u043B\u0433\u0430";
+  const from = Date.parse(ca.validFrom);
+  const to = Date.parse(ca.validTo);
+  if (Number.isNaN(from) || Number.isNaN(to) || now < from || now > to) {
+    return "\u0433\u0438\u043D\u0436\u0438\u0439\u043D \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D\u043D\u0438\u0439 \u0445\u0443\u0433\u0430\u0446\u0430\u0430 \u0434\u0443\u0443\u0441\u0441\u0430\u043D \u044D\u0441\u0432\u044D\u043B \u0445\u04AF\u0447\u0438\u043D\u0442\u044D\u0439 \u0431\u043E\u043B\u043E\u043E\u0433\u04AF\u0439";
+  }
+  const pathLen = basicConstraintsPathLen(ca);
+  if (pathLen !== void 0 && below > pathLen) return "pathLenConstraint \u0437\u04E9\u0440\u0447\u0441\u04E9\u043D (\u0437\u0430\u0432\u0441\u0440\u044B\u043D CA \u0445\u044D\u0442 \u043E\u043B\u043E\u043D)";
+  if (certExtension(ca.raw, OID_NAME_CONSTRAINTS)) return "CA-\u0434 name constraints \u0431\u0430\u0439\u043D\u0430 (SDK \u04AF\u043D\u044D\u043B\u0434\u044D\u0433\u0433\u04AF\u0439 \u2014 fail-closed)";
+  return criticalReason(ca) ?? ekuReason(ca, usage);
+}
+function basicConstraintsPathLen(cert) {
+  const v = certExtension(cert.raw, "2.5.29.19");
+  if (!v) return void 0;
+  const seq = tlv(v, 0, v.length);
+  for (let p = seq.start; p < seq.end; ) {
+    const t = tlv(v, p, seq.end);
+    if (t.tag === 2) {
+      if (t.end - t.start > 4 || (v[t.start] & 128) !== 0) throw new ValidationError("basicConstraints: pathLen \u0431\u0443\u0440\u0443\u0443");
+      let n = 0;
+      for (let i = t.start; i < t.end; i++) n = n * 256 + v[i];
+      return n;
+    }
+    p = t.end;
+  }
+  return void 0;
+}
 
 // src/client.ts
 var DEFAULT_BASE_URL = "https://rp.eidmongolia.mn";
@@ -1062,6 +1764,8 @@ var EidClient = class {
   sign;
   pdf;
   organization;
+  person;
+  token;
   session;
   validator;
   constructor(cfg) {
@@ -1077,8 +1781,14 @@ 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,
+      maxBytes: cfg.pdfMaxBytes && cfg.pdfMaxBytes > 0 ? cfg.pdfMaxBytes : DEFAULT_PDF_MAX_BYTES
+    });
     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 ?? {});
   }
@@ -1127,7 +1837,7 @@ function openOrShowQR(session, opts) {
 }
 
 // src/devicelinkv3.ts
-var import_node_crypto5 = require("crypto");
+var import_node_crypto6 = require("crypto");
 var TYPES = ["QR", "Web2App", "App2App"];
 var PROTOCOL = { auth: "ACSP_V2", sign: "RAW_DIGEST_SIGNATURE", cert: "" };
 var TOKEN_RE = /^[A-Za-z0-9_-]+$/;
@@ -1184,7 +1894,7 @@ function buildDeviceLink(p) {
     callback,
     unprotected
   ].join("|");
-  const authCode = (0, import_node_crypto5.createHmac)("sha256", Buffer.from(p.sessionSecret, "base64")).update(payload, "utf8").digest("base64url");
+  const authCode = (0, import_node_crypto6.createHmac)("sha256", Buffer.from(p.sessionSecret, "base64")).update(payload, "utf8").digest("base64url");
   return `${unprotected}&authCode=${authCode}`;
 }
 function qrDeviceLinkTicker(input, onLink, opts) {
@@ -1197,7 +1907,7 @@ function qrDeviceLinkTicker(input, onLink, opts) {
 }
 
 // src/oidc.ts
-var import_node_crypto6 = require("crypto");
+var import_node_crypto7 = require("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";
@@ -1234,7 +1944,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;
@@ -1282,7 +1992,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();
@@ -1361,7 +2071,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(
@@ -1454,7 +2164,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 && (0, import_node_crypto6.timingSafeEqual)(x, y);
+  return x.length === y.length && (0, import_node_crypto7.timingSafeEqual)(x, y);
 }
 function decodeJsonPart(s) {
   try {
@@ -1477,7 +2187,10 @@ function callbackParams(input) {
   ApiError,
   AuthApi,
   AuthenticationError,
+  CITIZEN_ISSUING_CA_SKI,
   DEFAULT_BASE_URL,
+  DEFAULT_PDF_MAX_BYTES,
+  DEFAULT_PDF_TIMEOUT_MS,
   DeviceLinkError,
   EID_ACR_ADVANCED,
   EID_ACR_QUALIFIED,
@@ -1492,10 +2205,14 @@ function callbackParams(input) {
   ON_BEHALF_ERROR_CODES,
   OrganizationApi,
   PdfApi,
+  PersonApi,
+  RETRYABLE_ERROR_CODES,
+  ResponseTooLargeError,
   ResponseValidator,
   SessionApi,
   SessionFailedError,
   SignApi,
+  TokenApi,
   ValidationError,
   acspV2Digest,
   buildAcspV2Payload,
@@ -1504,14 +2221,19 @@ function callbackParams(input) {
   interactionsToBase64,
   isMobileUserAgent,
   openOrShowQR,
+  parseRetryAfter,
   parseSessionResult,
   parseSubject,
+  personMatchesCertificate,
   pkceChallenge,
   qrDeviceLinkTicker,
   randomChallenge,
   resolveBaseUrl,
   sha256Base64,
+  tokenAuthDigest,
+  tokenLimitOf,
   userChallengeOf,
   verifyPayloadSignature,
-  verifyPrehashedSignature
+  verifyPrehashedSignature,
+  verifyTokenCertificates
 });