@gerege-systems/eid-mongolia-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,693 @@
+// src/errors.ts
+var EidError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var AuthenticationError = class extends EidError {
+};
+var ForbiddenError = class extends EidError {
+};
+var ApiError = class extends EidError {
+  constructor(status, body) {
+    super(`RP-API ${status}: ${body}`);
+    this.status = status;
+    this.body = body;
+  }
+  status;
+  body;
+};
+var NetworkError = class extends EidError {
+};
+var SessionFailedError = class extends EidError {
+  constructor(endResult) {
+    super(`Session \u0430\u043C\u0436\u0438\u043B\u0442\u0433\u04AF\u0439: ${endResult}`);
+    this.endResult = endResult;
+  }
+  endResult;
+};
+var ValidationError = class extends EidError {
+};
+
+// src/http.ts
+var DEFAULT_TIMEOUT_MS = 15e3;
+var Http = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  post(path, body, timeoutMs) {
+    return this.request("POST", path, body, timeoutMs);
+  }
+  get(path, timeoutMs) {
+    return this.request("GET", path, void 0, timeoutMs);
+  }
+  async request(method, path, body, timeoutMs) {
+    const f = this.cfg.fetchImpl ?? fetch;
+    const url = this.cfg.baseUrl + path;
+    const init = {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.cfg.apiSecret}`,
+        ...body !== void 0 ? { "Content-Type": "application/json" } : {}
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0,
+      signal: AbortSignal.timeout(timeoutMs ?? this.cfg.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    };
+    if (this.cfg.dispatcher) init.dispatcher = this.cfg.dispatcher;
+    let res;
+    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(`\u0421\u04AF\u043B\u0436\u044D\u044D\u043D\u0438\u0439 \u0430\u043B\u0434\u0430\u0430 (${method} ${path}): ${err.message}`);
+    }
+    const text = await res.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)");
+    if (res.status === 403) throw new ForbiddenError("IP allowlist \u044D\u0441\u0432\u044D\u043B mTLS \u0437\u04E9\u0432\u0448\u04E9\u04E9\u0440\u04E9\u04E9\u0433\u04AF\u0439 (403)");
+    if (res.status >= 300) throw new ApiError(res.status, text);
+    return text ? JSON.parse(text) : {};
+  }
+};
+
+// src/crypto.ts
+import { createHash, randomBytes } from "crypto";
+function sha256Base64(data) {
+  return createHash("sha256").update(data).digest("base64");
+}
+function randomChallenge(bytes = 64) {
+  return randomBytes(bytes).toString("base64");
+}
+function nodeHash(h) {
+  return h.toLowerCase().replace("-", "");
+}
+function hashLen(h) {
+  return createHash(nodeHash(h)).digest().length;
+}
+function interactionsToBase64(interactions) {
+  return Buffer.from(JSON.stringify(interactions), "utf8").toString("base64");
+}
+var b64 = (s) => Buffer.from(s, "utf8").toString("base64");
+function buildAcspV2Payload(p) {
+  const message = [
+    p.schemeName ?? "smart-id",
+    "ACSP_V2",
+    p.serverRandom,
+    p.rpChallenge,
+    p.userChallenge,
+    b64(p.relyingPartyName),
+    b64(p.brokeredRpName ?? ""),
+    createHash("sha256").update(p.interactions, "utf8").digest("base64"),
+    p.interactionTypeUsed,
+    p.initialCallbackUrl ?? "",
+    p.flowType
+  ].join("|");
+  return Buffer.from(message, "utf8");
+}
+function acspV2Digest(p, hashAlgorithm) {
+  return createHash(nodeHash(hashAlgorithm)).update(buildAcspV2Payload(p)).digest();
+}
+
+// src/auth.ts
+function rec(v) {
+  return v && typeof v === "object" ? v : {};
+}
+var AuthApi = class {
+  constructor(http, creds, defaults) {
+    this.http = http;
+    this.creds = creds;
+    this.defaults = defaults;
+  }
+  http;
+  creds;
+  defaults;
+  /** v3 nested body + validator-т хэрэгтэй контекст (ижил утгуудаас — байт зөрөхгүй). */
+  baseBody(rpChallenge, interactions, flows, opts) {
+    const callback = opts?.callbackUrl?.trim() ?? "";
+    const acsp = {
+      rpChallenge,
+      relyingPartyName: this.creds.rpName,
+      brokeredRpName: "",
+      interactions: interactionsToBase64(interactions),
+      initialCallbackUrl: callback,
+      flowTypes: callback ? [...flows, "App2App", "Web2App"] : flows,
+      signatureAlgorithm: opts?.signatureAlgorithm ?? "rsassa-pss",
+      hashAlgorithm: opts?.hashAlgorithm ?? "SHA-512"
+    };
+    const body = {
+      relyingPartyUUID: this.creds.rpUUID,
+      relyingPartyName: acsp.relyingPartyName,
+      certificateLevel: opts?.certificateLevel ?? this.defaults.certificateLevel,
+      signatureProtocol: "ACSP_V2",
+      signatureProtocolParameters: {
+        rpChallenge,
+        signatureAlgorithm: acsp.signatureAlgorithm,
+        signatureAlgorithmParameters: { hashAlgorithm: acsp.hashAlgorithm }
+      },
+      interactions: acsp.interactions
+    };
+    if (callback) body.initialCallbackUrl = callback;
+    if (opts?.onBehalfOf?.trim()) body.onBehalfOf = opts.onBehalfOf.trim();
+    return { body, acsp };
+  }
+  parseNotification(raw, acsp) {
+    const r = rec(raw);
+    const vc = rec(r.vc).value;
+    return { sessionId: String(r.sessionID), vc: vc != null ? String(vc) : null, rpChallenge: acsp.rpChallenge, acsp };
+  }
+  parseDeviceLink(raw, acsp) {
+    const r = rec(raw);
+    return {
+      sessionId: String(r.sessionID),
+      sessionToken: r.sessionToken != null ? String(r.sessionToken) : null,
+      sessionSecret: r.sessionSecret != null ? String(r.sessionSecret) : null,
+      deviceLinkBase: r.deviceLinkBase != null ? String(r.deviceLinkBase) : null,
+      rpChallenge: acsp.rpChallenge,
+      acsp
+    };
+  }
+  /** 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);
+    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);
+    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);
+    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);
+    return this.parseDeviceLink(raw, acsp);
+  }
+};
+
+// src/sign.ts
+function rec2(v) {
+  return v && typeof v === "object" ? v : {};
+}
+var SignApi = class {
+  constructor(http, creds, defaults) {
+    this.http = http;
+    this.creds = creds;
+    this.defaults = defaults;
+  }
+  http;
+  creds;
+  defaults;
+  body(digestB64, interactions, opts) {
+    const body = {
+      relyingPartyUUID: this.creds.rpUUID,
+      relyingPartyName: this.creds.rpName,
+      certificateLevel: opts?.certificateLevel ?? this.defaults.certificateLevel,
+      signatureProtocol: "RAW_DIGEST_SIGNATURE",
+      signatureProtocolParameters: {
+        digest: digestB64,
+        signatureAlgorithm: opts?.signatureAlgorithm ?? "rsassa-pss",
+        signatureAlgorithmParameters: { hashAlgorithm: opts?.hashAlgorithm ?? "SHA-256" }
+      },
+      interactions: interactionsToBase64(interactions)
+    };
+    if (opts?.callbackUrl?.trim()) body.initialCallbackUrl = opts.callbackUrl.trim();
+    if (opts?.onBehalfOf?.trim()) body.onBehalfOf = opts.onBehalfOf.trim();
+    return body;
+  }
+  parse(raw) {
+    const r = rec2(raw);
+    const vc = rec2(r.vc).value;
+    return { sessionId: String(r.sessionID), vc: vc != null ? String(vc) : null, rpChallenge: "" };
+  }
+  /**
+   * Бэлэн digest-ээр push sign (РД/civil_id/ETSI). Баримт (PDF/файл)-ын байтын SHA-256
+   * digest-ийг гаднаас бэлдэж өгнө — текст бус бинар баримтад тохиромжтой.
+   */
+  async digestByEtsi(id, digestB64, interactions, opts) {
+    const raw = await this.http.post(`/signature/notification/etsi/${encodeURIComponent(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));
+    return this.parse(raw);
+  }
+  /** Текстийн SHA-256 digest-ийг дотроо тооцоод push sign (богино текст баримтад тохиромжтой). */
+  async textByEtsi(id, text, interactions, opts) {
+    return this.digestByEtsi(id, sha256Base64(text), interactions, opts);
+  }
+};
+
+// src/session.ts
+var SERVER_POLL_MS = 3e4;
+var MAX_WAIT_MS = 15e4;
+function asRecord(v) {
+  return v && typeof v === "object" ? v : {};
+}
+function str(v) {
+  return v != null ? String(v) : null;
+}
+function parseSessionResult(raw) {
+  const r = asRecord(raw);
+  const result = asRecord(r.result);
+  const sig = asRecord(r.signature);
+  const cert = asRecord(r.cert);
+  return {
+    state: String(r.state ?? ""),
+    endResult: str(result.endResult),
+    documentNumber: str(result.documentNumber),
+    certificateDerB64: str(cert.value),
+    certificateLevel: str(cert.certificateLevel),
+    signatureValueB64: str(sig.value),
+    signatureAlgorithm: str(sig.signatureAlgorithm),
+    signatureProtocol: str(r.signatureProtocol ?? sig.signatureProtocol),
+    serverRandom: str(sig.serverRandom),
+    userChallenge: str(sig.userChallenge),
+    flowType: str(sig.flowType),
+    signatureAlgorithmParameters: parseSigParams(sig.signatureAlgorithmParameters),
+    interactionTypeUsed: str(r.interactionTypeUsed),
+    onBehalfOf: parseOrg(r.onBehalfOf)
+  };
+}
+function parseSigParams(raw) {
+  const p = asRecord(raw);
+  const hash = str(p.hashAlgorithm);
+  if (!hash) return null;
+  const mgf = asRecord(p.maskGenAlgorithm);
+  return {
+    hashAlgorithm: hash,
+    maskGenAlgorithm: mgf.algorithm ? { algorithm: String(mgf.algorithm), parameters: { hashAlgorithm: String(asRecord(mgf.parameters).hashAlgorithm ?? hash) } } : void 0,
+    saltLength: p.saltLength != null ? Number(p.saltLength) : void 0,
+    trailerField: str(p.trailerField) ?? void 0
+  };
+}
+function parseOrg(raw) {
+  const o = asRecord(raw);
+  const etsi = str(o.orgEtsi);
+  if (!etsi) return null;
+  return {
+    orgEtsi: etsi,
+    orgName: str(o.orgName),
+    role: str(o.role),
+    rightType: str(o.rightType)
+  };
+}
+var SessionApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Нэг удаагийн long-poll. serverPollMs хүртэл хүлээнэ. */
+  async poll(sessionId, serverPollMs = SERVER_POLL_MS) {
+    const raw = await this.http.get(
+      `/session/${encodeURIComponent(sessionId)}?timeoutMs=${serverPollMs}`,
+      serverPollMs + 1e4
+      // HTTP timeout нь серверийн poll-оос урт
+    );
+    return parseSessionResult(raw);
+  }
+  /**
+   * COMPLETE болтол давтаж poll хийнэ. maxWaitMs дуустал хүлээгээд гараагүй бол сүүлчийн
+   * (RUNNING) үр дүнг буцаана — дуудагч endResult==null-ийг TIMEOUT мэт боловсруулна.
+   */
+  async waitForResult(sessionId, opts) {
+    const deadline = Date.now() + (opts?.maxWaitMs ?? MAX_WAIT_MS);
+    const pollMs = opts?.serverPollMs ?? SERVER_POLL_MS;
+    let last = { state: "RUNNING" };
+    while (Date.now() < deadline) {
+      const remaining = deadline - Date.now();
+      last = await this.poll(sessionId, Math.max(1e3, Math.min(pollMs, remaining)));
+      if (last.state === "COMPLETE") return last;
+    }
+    return last;
+  }
+};
+
+// src/validator.ts
+import { X509Certificate, constants, createHash as createHash2, publicDecrypt, verify } from "crypto";
+var ResponseValidator = class {
+  anchors;
+  intermediates;
+  requiredLevel;
+  skew;
+  allowUntrusted;
+  revocation;
+  revocationMode;
+  constructor(trust = {}) {
+    this.anchors = (trust.trustAnchorsPem ?? []).map((p) => new X509Certificate(p));
+    this.intermediates = (trust.intermediatesPem ?? []).map((p) => new 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";
+  }
+  // ── нийтийн API ──
+  /**
+   * Auth session-ийн хариуг бүрэн шалгаж, баталгаажсан иргэнийг буцаана.
+   * @param acsp — session эхлүүлэхэд SDK-ийн буцаасан `acsp` контекст (RP хадгалсан).
+   */
+  validateAuth(result, acsp) {
+    const leaf = this.precheck(result, "ACSP_V2");
+    const { serverRandom, userChallenge, flowType, interactionTypeUsed } = result;
+    if (!serverRandom || Buffer.from(serverRandom, "base64").length < 18) throw new ValidationError("serverRandom \u0430\u043B\u0433\u0430/\u0431\u043E\u0433\u0438\u043D\u043E");
+    if (!userChallenge || !/^[A-Za-z0-9_-]{43}$/.test(userChallenge)) throw new ValidationError("userChallenge \u0431\u0443\u0440\u0443\u0443 \u0445\u044D\u043B\u0431\u044D\u0440\u0442\u044D\u0439");
+    if (!flowType || !acsp.flowTypes.includes(flowType)) {
+      throw new ValidationError(`flowType ${flowType} \u043D\u044C \u0441\u0430\u043D\u0430\u043B \u0431\u043E\u043B\u0433\u043E\u0441\u043E\u043D \u0443\u0440\u0441\u0433\u0430\u043B\u0434 \u0431\u0430\u0439\u0445\u0433\u04AF\u0439`);
+    }
+    if (!interactionTypeUsed) throw new ValidationError("interactionTypeUsed \u0430\u043B\u0433\u0430");
+    const { alg, hash } = this.algorithmOf(result, acsp.signatureAlgorithm, acsp.hashAlgorithm);
+    const payload = buildAcspV2Payload({
+      serverRandom,
+      rpChallenge: acsp.rpChallenge,
+      userChallenge,
+      relyingPartyName: acsp.relyingPartyName,
+      brokeredRpName: acsp.brokeredRpName,
+      interactions: acsp.interactions,
+      interactionTypeUsed,
+      initialCallbackUrl: acsp.initialCallbackUrl,
+      flowType
+    });
+    if (!verifyPayloadSignature(payload, result.signatureValueB64, leaf.publicKey, alg, hash)) {
+      throw new ValidationError("Auth \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 ACSP_V2 payload-\u0442\u043E\u0439 \u0442\u0430\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439 (\u0445\u0443\u0443\u0440\u0430\u043C\u0447 \u0445\u0430\u0440\u0438\u0443 \u0431\u0430\u0439\u0436 \u0431\u043E\u043B\u0437\u043E\u0448\u0433\u04AF\u0439)");
+    }
+    return {
+      documentNumber: result.documentNumber,
+      certificate: leaf,
+      subject: leaf.subject,
+      certificateLevel: String(result.certificateLevel ?? "")
+    };
+  }
+  /**
+   * Sign session-ийн хариуг бүрэн шалгаж, баталгаажсан гарын үсгийг буцаана.
+   * @param hashAlgorithm — digest-ийг үүсгэсэн hash (хүсэлтэд илгээсэнтэй ижил; default SHA-256).
+   */
+  validateSign(result, digestB64, hashAlgorithm = "SHA-256") {
+    const leaf = this.precheck(result, "RAW_DIGEST_SIGNATURE");
+    const digest = Buffer.from(digestB64, "base64");
+    const { alg, hash } = this.algorithmOf(result, 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");
+    if (!verifyPrehashedSignature(digest, result.signatureValueB64, leaf.publicKey, alg, hash)) {
+      throw new ValidationError("\u0413\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 \u04E9\u0433\u0441\u04E9\u043D digest-\u0442\u044D\u0439 \u0442\u0430\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439");
+    }
+    return {
+      documentNumber: result.documentNumber,
+      signatureValueB64: result.signatureValueB64,
+      signatureAlgorithm: result.signatureAlgorithm,
+      certificate: leaf,
+      subject: leaf.subject
+    };
+  }
+  /**
+   * Хариуны signatureAlgorithm + hashAlgorithm-ийг RP-ийн хүссэнтэй тулгана (downgrade хаалт).
+   * ecdsa-with-SHA256 (хуучин cert) хүссэн rsassa-pss-ийн оронд ирэхийг зөвшөөрнө — SHA-256-аар л.
+   */
+  algorithmOf(result, wantAlg, wantHash) {
+    const alg = result.signatureAlgorithm ?? "";
+    let hash;
+    if (alg === "rsassa-pss") {
+      hash = String(result.signatureAlgorithmParameters?.hashAlgorithm ?? "");
+      const mgf = result.signatureAlgorithmParameters?.maskGenAlgorithm?.parameters?.hashAlgorithm;
+      if (mgf && mgf !== hash) throw new ValidationError("MGF1 hash \u043D\u044C hashAlgorithm-\u0430\u0430\u0441 \u04E9\u04E9\u0440");
+      if (result.signatureAlgorithmParameters?.saltLength != null && result.signatureAlgorithmParameters.saltLength !== hashLen(hash)) {
+        throw new ValidationError("saltLength \u2260 hLen");
+      }
+    } else if (/^sha(256|384|512)WithRSAEncryption$/.test(alg)) {
+      hash = "SHA-" + alg.slice(3, 6);
+    } else if (alg === "ecdsa-with-SHA256") {
+      hash = "SHA-256";
+    } else {
+      throw new ValidationError(`\u0414\u044D\u043C\u0436\u0438\u0433\u0434\u044D\u044D\u0433\u04AF\u0439 signatureAlgorithm: ${alg}`);
+    }
+    if (wantAlg && alg !== wantAlg && alg !== "ecdsa-with-SHA256") {
+      throw new ValidationError(`signatureAlgorithm ${alg} \u2260 \u0445\u04AF\u0441\u0441\u044D\u043D ${wantAlg}`);
+    }
+    if (hash !== wantHash) throw new ValidationError(`hashAlgorithm ${hash} \u2260 \u0445\u04AF\u0441\u0441\u044D\u043D ${wantHash}`);
+    return { alg, hash };
+  }
+  // ── дотоод ──
+  /** state/endResult, cert байгаа эсэх, chain, validity, certLevel — нийтлэг шалгалт. */
+  precheck(result, protocol) {
+    if (result.state !== "COMPLETE") throw new ValidationError(`Session \u0434\u0443\u0443\u0441\u0430\u0430\u0433\u04AF\u0439 (state=${result.state})`);
+    if (result.endResult !== "OK") throw new SessionFailedError(result.endResult ?? "UNKNOWN");
+    if (result.signatureProtocol && result.signatureProtocol !== protocol) {
+      throw new ValidationError(`signatureProtocol ${result.signatureProtocol} \u2260 ${protocol}`);
+    }
+    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 X509Certificate(Buffer.from(result.certificateDerB64, "base64"));
+    this.checkValidity(leaf);
+    this.checkLevel(String(result.certificateLevel ?? ""));
+    if (this.anchors.length === 0) {
+      if (!this.allowUntrusted) {
+        throw new ValidationError(
+          "Trust anchor \u0442\u043E\u0445\u0438\u0440\u0443\u0443\u043B\u0430\u0430\u0433\u04AF\u0439 \u2014 \u0438\u0442\u0433\u044D\u043B\u0446\u044D\u043B \u0448\u0430\u043B\u0433\u0430\u0445 \u0431\u043E\u043B\u043E\u043C\u0436\u0433\u04AF\u0439 (production-\u0434 trustAnchorsPem \u04E9\u0433, \u044D\u0441\u0432\u044D\u043B allowUntrusted=true)"
+        );
+      }
+    } else {
+      this.verifyChain(leaf);
+    }
+    return leaf;
+  }
+  checkValidity(cert) {
+    const now = Date.now();
+    const from = Date.parse(cert.validFrom);
+    const to = Date.parse(cert.validTo);
+    if (!Number.isNaN(from) && now + this.skew < from) throw new ValidationError("\u0413\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0445\u04AF\u0447\u0438\u043D\u0442\u044D\u0439 \u0431\u043E\u043B\u043E\u043E\u0433\u04AF\u0439 \u0431\u0430\u0439\u043D\u0430");
+    if (!Number.isNaN(to) && now - this.skew > to) throw new ValidationError("\u0413\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");
+  }
+  checkLevel(level) {
+    const rank = { ADVANCED: 1, QUALIFIED: 2, QSCD: 3 };
+    const got = rank[level] ?? 0;
+    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;
+      }
+      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");
+  }
+  /** leaf-ийн шууд issuer-ийг trust pool-оос буцаана (revocation шалгагчид issuer хэрэгтэй). */
+  findIssuer(leaf) {
+    return [...this.intermediates, ...this.anchors].find(
+      (c) => isCa(c) && leaf.checkIssued(c) && leaf.verify(c.publicKey)
+    );
+  }
+  /**
+   * checkRevocation — тохируулсан RevocationChecker hook-оор cert-ийн revoke төлвийг
+   * шалгана. revocation тохируулаагүй бол no-op (true буцаана). "revoked" үед, мөн
+   * hard-fail горимд "unknown" үед ValidationError шиднэ. validateAuth/Sign-ийн дараа
+   * дуудна (тэдгээр нь sync; revocation нь сүлжээ I/O тул async).
+   */
+  async checkRevocation(cert) {
+    if (!this.revocation) return;
+    const status = await this.revocation(cert, this.findIssuer(cert));
+    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") {
+      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)");
+    }
+  }
+};
+function verifyPayloadSignature(payload, sigB64, key, alg, hash) {
+  const sig = Buffer.from(sigB64, "base64");
+  const h = nodeHash(hash);
+  if (alg === "rsassa-pss") {
+    return verify(h, payload, { key, padding: constants.RSA_PKCS1_PSS_PADDING, saltLength: hashLen(hash) }, sig);
+  }
+  if (alg === "ecdsa-with-SHA256") return verify(h, payload, { key, dsaEncoding: "der" }, sig);
+  return verify(h, payload, { key, padding: constants.RSA_PKCS1_PADDING }, sig);
+}
+function verifyPrehashedSignature(digest, sigB64, key, alg, hash) {
+  const sig = Buffer.from(sigB64, "base64");
+  if (alg === "ecdsa-with-SHA256") return ecdsaP256VerifyPrehashed(digest, sig, key);
+  const modBits = key.asymmetricKeyDetails?.modulusLength ?? 0;
+  if (!modBits || sig.length !== Math.ceil(modBits / 8)) return false;
+  let em;
+  try {
+    em = publicDecrypt({ key, padding: constants.RSA_NO_PADDING }, sig);
+  } catch {
+    return false;
+  }
+  if (alg === "rsassa-pss") return emsaPssVerify(digest, em, modBits - 1, hash);
+  const prefix = DIGEST_INFO[hash];
+  if (!prefix) return false;
+  const t = Buffer.concat([prefix, digest]);
+  const expected = Buffer.concat([Buffer.from([0, 1]), Buffer.alloc(em.length - t.length - 3, 255), Buffer.from([0]), t]);
+  return em.length === expected.length && em.equals(expected);
+}
+var P256 = {
+  p: 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffffn,
+  n: 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n,
+  b: 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604bn,
+  gx: 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296n,
+  gy: 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5n
+};
+var mod = (a, m) => (a % m + m) % m;
+function inv(a, m) {
+  let [g, x, y, u] = [mod(a, m), 1n, 0n, m];
+  while (g !== 0n) {
+    const q = u / g;
+    [u, g, y, x] = [g, u - q * g, x, y - q * x];
+  }
+  return mod(y, m);
+}
+function ptAdd(P, Q) {
+  if (!P) return Q;
+  if (!Q) return P;
+  const { p } = P256;
+  let l;
+  if (P[0] === Q[0]) {
+    if (mod(P[1] + Q[1], p) === 0n) return null;
+    l = mod((3n * P[0] * P[0] - 3n) * inv(2n * P[1], p), p);
+  } else {
+    l = mod((Q[1] - P[1]) * inv(Q[0] - P[0], p), p);
+  }
+  const x = mod(l * l - P[0] - Q[0], p);
+  return [x, mod(l * (P[0] - x) - P[1], p)];
+}
+function ptMul(k, P) {
+  let R = null;
+  for (let b = P; k > 0n; k >>= 1n, b = ptAdd(b, b)) if (k & 1n) R = ptAdd(R, b);
+  return R;
+}
+function derInts(sig) {
+  if (sig[0] !== 48 || sig[1] !== sig.length - 2) return null;
+  let i = 2;
+  const out = [];
+  for (let k = 0; k < 2; k++) {
+    if (sig[i] !== 2) return null;
+    const len = sig[i + 1] ?? 0;
+    out.push(BigInt("0x" + (sig.subarray(i + 2, i + 2 + len).toString("hex") || "0")));
+    i += 2 + len;
+  }
+  return i === sig.length ? [out[0], out[1]] : null;
+}
+function ecdsaP256VerifyPrehashed(digest, sig, key) {
+  if (key.asymmetricKeyDetails?.namedCurve !== "prime256v1") return false;
+  const jwk = key.export({ format: "jwk" });
+  if (!jwk.x || !jwk.y) return false;
+  const Q = [BigInt("0x" + Buffer.from(jwk.x, "base64url").toString("hex")), BigInt("0x" + Buffer.from(jwk.y, "base64url").toString("hex"))];
+  const rs = derInts(sig);
+  if (!rs) return false;
+  const [r, sv] = rs;
+  const { n } = P256;
+  if (r <= 0n || r >= n || sv <= 0n || sv >= n) return false;
+  const z = BigInt("0x" + digest.subarray(0, 32).toString("hex"));
+  const w = inv(sv, n);
+  const R = ptAdd(ptMul(mod(z * w, n), [P256.gx, P256.gy]), ptMul(mod(r * w, n), Q));
+  return R !== null && mod(R[0], n) === r;
+}
+var DIGEST_INFO = {
+  "SHA-256": Buffer.from("3031300d060960864801650304020105000420", "hex"),
+  "SHA-384": Buffer.from("3041300d060960864801650304020205000430", "hex"),
+  "SHA-512": Buffer.from("3051300d060960864801650304020305000440", "hex")
+};
+function mgf1(hash, seed, length) {
+  const out = [];
+  for (let i = 0, n = 0; n < length; i++, n += hashLen(hash)) {
+    const c = Buffer.alloc(4);
+    c.writeUInt32BE(i, 0);
+    out.push(createHash2(nodeHash(hash)).update(seed).update(c).digest());
+  }
+  return Buffer.concat(out).subarray(0, length);
+}
+function emsaPssVerify(mHash, em, emBits, hash) {
+  const hLen = hashLen(hash);
+  const sLen = hLen;
+  const emLen = Math.ceil(emBits / 8);
+  if (em.length > emLen) {
+    if (!em.subarray(0, em.length - emLen).every((b) => b === 0)) return false;
+    em = em.subarray(em.length - emLen);
+  }
+  if (emLen < hLen + sLen + 2 || em[emLen - 1] !== 188) return false;
+  const maskedDB = em.subarray(0, emLen - hLen - 1);
+  const h = em.subarray(emLen - hLen - 1, emLen - 1);
+  const topBits = 8 * emLen - emBits;
+  if (topBits > 0 && (maskedDB[0] ?? 0) >> 8 - topBits !== 0) return false;
+  const db = Buffer.from(maskedDB);
+  const mask = mgf1(hash, h, db.length);
+  for (let i = 0; i < db.length; i++) db[i] = (db[i] ?? 0) ^ (mask[i] ?? 0);
+  if (topBits > 0) db[0] = (db[0] ?? 0) & 255 >> topBits;
+  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 = createHash2(nodeHash(hash)).update(Buffer.alloc(8)).update(mHash).update(salt).digest();
+  return h.equals(h2);
+}
+function isCa(cert) {
+  return cert.ca === true;
+}
+
+// src/client.ts
+var EidClient = class {
+  auth;
+  sign;
+  session;
+  validator;
+  constructor(cfg) {
+    if (!cfg.baseUrl) throw new Error("EidClient: baseUrl \u0448\u0430\u0430\u0440\u0434\u043B\u0430\u0433\u0430\u0442\u0430\u0439");
+    if (!cfg.credentials?.apiSecret) throw new Error("EidClient: credentials.apiSecret \u0448\u0430\u0430\u0440\u0434\u043B\u0430\u0433\u0430\u0442\u0430\u0439");
+    const base = cfg.baseUrl.replace(/\/+$/, "") + "/v3";
+    const http = new Http({
+      baseUrl: base,
+      apiSecret: cfg.credentials.apiSecret,
+      timeoutMs: cfg.timeoutMs,
+      dispatcher: cfg.dispatcher,
+      fetchImpl: cfg.fetchImpl
+    });
+    const level = cfg.defaultCertificateLevel ?? "QUALIFIED";
+    this.auth = new AuthApi(http, cfg.credentials, { certificateLevel: level });
+    this.sign = new SignApi(http, cfg.credentials, { certificateLevel: level });
+    this.session = new SessionApi(http);
+    this.validator = new ResponseValidator(cfg.trust ?? {});
+  }
+};
+export {
+  ApiError,
+  AuthApi,
+  AuthenticationError,
+  EidClient,
+  EidError,
+  ForbiddenError,
+  Http,
+  NetworkError,
+  ResponseValidator,
+  SessionApi,
+  SessionFailedError,
+  SignApi,
+  ValidationError,
+  acspV2Digest,
+  buildAcspV2Payload,
+  interactionsToBase64,
+  parseSessionResult,
+  randomChallenge,
+  sha256Base64,
+  verifyPayloadSignature,
+  verifyPrehashedSignature
+};