@nokinc-flur/sdk 2.4.0 → 2.5.0

package/dist/index.cjs

@@ -48,6 +48,7 @@ __export(index_exports, {
   CONSUMER_OAC_QR_PREFIX: () => CONSUMER_OAC_QR_PREFIX,
   CONSUMER_OFFLINE_CLAIM_SUBMIT_GRACE_MS: () => CONSUMER_OFFLINE_CLAIM_SUBMIT_GRACE_MS,
   CONSUMER_PAYMENT_REQUEST_DOMAIN: () => CONSUMER_PAYMENT_REQUEST_DOMAIN,
+  CONSUMER_REVOCATION_DOMAIN: () => CONSUMER_REVOCATION_DOMAIN,
   CONSUMER_SETTLEMENT_DOMAIN: () => CONSUMER_SETTLEMENT_DOMAIN,
   CONSUMER_SETTLEMENT_RECEIPT_QR_PREFIX: () => CONSUMER_SETTLEMENT_RECEIPT_QR_PREFIX,
   CUSTODIAL_MODES: () => CUSTODIAL_MODES,
@@ -145,6 +146,7 @@ __export(index_exports, {
   RECEIPT_CHANNELS: () => RECEIPT_CHANNELS,
   RECEIPT_KINDS: () => RECEIPT_KINDS,
   REPLAY_WINDOW_MS: () => REPLAY_WINDOW_MS,
+  REVOCATION_LIST_MAX_ENTRIES: () => REVOCATION_LIST_MAX_ENTRIES,
   ReceiptArtifactSchema: () => ReceiptArtifactSchema,
   ReceiptPayloadSchema: () => ReceiptPayloadSchema,
   ReceiptSchema: () => ReceiptSchema,
@@ -153,12 +155,14 @@ __export(index_exports, {
   RedemptionSchema: () => RedemptionSchema,
   RegisterDeviceKeyP256InputSchema: () => RegisterDeviceKeyP256InputSchema,
   ReversalRecordArtifactSchema: () => ReversalRecordArtifactSchema,
+  RevocationListSchema: () => RevocationListSchema,
   RevokeDeviceKeyInputSchema: () => RevokeDeviceKeyInputSchema,
   SETTLEMENT_SCHEDULES: () => SETTLEMENT_SCHEDULES,
   SettleResponseSchema: () => SettleResponseSchema,
   SettlementRecordArtifactSchema: () => SettlementRecordArtifactSchema,
   SettlementSchema: () => SettlementSchema,
   SignedConsumerOACSchema: () => SignedConsumerOACSchema,
+  SignedRevocationListSchema: () => SignedRevocationListSchema,
   StatementArtifactSchema: () => StatementArtifactSchema,
   UpsertMerchantProfileInputSchema: () => UpsertMerchantProfileInputSchema,
   UpsertPartnerProfileInputSchema: () => UpsertPartnerProfileInputSchema,
@@ -239,6 +243,7 @@ __export(index_exports, {
   isConsumerPaymentRequestExpired: () => isConsumerPaymentRequestExpired,
   isHardenedArtifactType: () => isHardenedArtifactType,
   isKnownArtifactType: () => isKnownArtifactType,
+  isOacRevoked: () => isOacRevoked,
   isPassWithinValidity: () => isPassWithinValidity,
   moneyMinorToNumber: () => moneyMinorToNumber,
   normalizeE164: () => normalizeE164,
@@ -246,6 +251,7 @@ __export(index_exports, {
   parseNQR: () => parseNQR,
   parseQR: () => parseQR,
   readTLV: () => readTLV,
+  revocationListSigningPayload: () => revocationListSigningPayload,
   routingHint: () => routingHint,
   signArtifact: () => signArtifact,
   signAuthorization: () => signAuthorization,
@@ -272,6 +278,7 @@ __export(index_exports, {
   verifyReceipt: () => verifyReceipt,
   verifyRedemption: () => verifyRedemption,
   verifyRequestHMAC: () => verifyRequestHMAC,
+  verifyRevocationList: () => verifyRevocationList,
   writeTLV: () => writeTLV
 });
 module.exports = __toCommonJS(index_exports);
@@ -3233,76 +3240,142 @@ function createAccountsClient(opts) {
 }
 
 // src/me-offline/client.ts
+var import_zod14 = require("zod");
+
+// src/me-offline/revocation.ts
 var import_zod13 = require("zod");
-var Sha256Hex = import_zod13.z.string().regex(/^[0-9a-f]{64}$/);
 var Base64Std3 = import_zod13.z.string().regex(/^[A-Za-z0-9+/]+={0,2}$/);
-var ClaimNonce = import_zod13.z.string().min(8).max(128).refine((value) => !value.includes("|"), {
+var CONSUMER_REVOCATION_DOMAIN = "flur:consumer-offline:v1:revocation";
+var REVOCATION_LIST_MAX_ENTRIES = 1e5;
+var RevocationListSchema = import_zod13.z.object({
+  issuerId: import_zod13.z.string().min(1).max(64),
+  /**
+   * Monotonic snapshot counter. A device MUST NOT replace a pinned list with
+   * one carrying a lower sequence — this defeats a downgrade/rollback attack
+   * that replays an older list to resurrect a revoked credential.
+   */
+  sequence: import_zod13.z.number().int().nonnegative(),
+  issuedAtMs: import_zod13.z.number().int().nonnegative(),
+  /**
+   * Freshness bound. After this instant the list is considered stale and the
+   * verifier treats it as untrustworthy (fail-closed), forcing a re-pin.
+   * Optional so the issuer may publish a list without a hard expiry.
+   */
+  notAfterMs: import_zod13.z.number().int().positive().optional(),
+  /** OAC ids that are revoked AND not yet past their own validity window. */
+  revokedOacIds: import_zod13.z.array(import_zod13.z.string().uuid()).max(REVOCATION_LIST_MAX_ENTRIES)
+});
+var SignedRevocationListSchema = import_zod13.z.object({
+  list: RevocationListSchema,
+  /** ASN.1 DER ECDSA P-256 issuer signature over the signing payload, base64. */
+  issuerSig: Base64Std3.min(16).max(2048),
+  /** Issuer's P-256 public key as SubjectPublicKeyInfo DER, base64. */
+  issuerPublicKeySpkiB64: Base64Std3.min(64).max(4096)
+});
+function revocationListSigningPayload(list) {
+  const payload = {
+    domain: CONSUMER_REVOCATION_DOMAIN,
+    issuerId: list.issuerId,
+    sequence: list.sequence,
+    issuedAtMs: list.issuedAtMs,
+    revokedOacIds: list.revokedOacIds
+  };
+  if (list.notAfterMs !== void 0) payload.notAfterMs = list.notAfterMs;
+  return payload;
+}
+function verifyRevocationList(signed, trustedKeys, options = {}) {
+  const parsed = SignedRevocationListSchema.safeParse(signed);
+  if (!parsed.success) return { ok: false, reason: "malformed" };
+  const list = parsed.data.list;
+  const nowMs = options.nowMs ?? Date.now();
+  const pinned = trustedKeys.filter(
+    (k) => k.issuerId === list.issuerId && (k.notBeforeMs === void 0 || nowMs >= k.notBeforeMs) && (k.notAfterMs === void 0 || nowMs <= k.notAfterMs)
+  );
+  if (pinned.length === 0) return { ok: false, reason: "untrusted_issuer" };
+  const signingBytes = canonicalJSONBytes(revocationListSigningPayload(list));
+  const signatureOk = pinned.some(
+    (k) => verifyIssuerP256(signingBytes, parsed.data.issuerSig, k.publicKeySpkiB64)
+  );
+  if (!signatureOk) return { ok: false, reason: "signature_invalid" };
+  if (list.notAfterMs !== void 0 && nowMs > list.notAfterMs) {
+    return { ok: false, reason: "stale" };
+  }
+  return { ok: true, list, revokedOacIds: new Set(list.revokedOacIds) };
+}
+function isOacRevoked(oacId, revokedOacIds) {
+  return revokedOacIds.has(oacId);
+}
+
+// src/me-offline/client.ts
+var Sha256Hex = import_zod14.z.string().regex(/^[0-9a-f]{64}$/);
+var Base64Std4 = import_zod14.z.string().regex(/^[A-Za-z0-9+/]+={0,2}$/);
+var ClaimNonce = import_zod14.z.string().min(8).max(128).refine((value) => !value.includes("|"), {
   message: "nonce must not contain |"
 });
 var ACCOUNT_FUNDED_OAC_MAX_TTL_MS = 1e3 * 60 * 60 * 24;
-var IssuerTrustKeySchema = import_zod13.z.object({
-  issuerId: import_zod13.z.string().min(1).max(128),
-  alg: import_zod13.z.literal("p256"),
-  publicKeySpkiB64: Base64Std3.min(64).max(4096),
-  notBeforeMs: import_zod13.z.number().int().nonnegative().optional(),
-  notAfterMs: import_zod13.z.number().int().positive().optional()
+var IssuerTrustKeySchema = import_zod14.z.object({
+  issuerId: import_zod14.z.string().min(1).max(128),
+  alg: import_zod14.z.literal("p256"),
+  publicKeySpkiB64: Base64Std4.min(64).max(4096),
+  notBeforeMs: import_zod14.z.number().int().nonnegative().optional(),
+  notAfterMs: import_zod14.z.number().int().positive().optional()
 });
-var IssuerTrustBundleSchema = import_zod13.z.object({
-  keys: import_zod13.z.array(IssuerTrustKeySchema).min(1)
+var IssuerTrustBundleSchema = import_zod14.z.object({
+  keys: import_zod14.z.array(IssuerTrustKeySchema).min(1)
 });
 var CONSUMER_OFFLINE_CLAIM_SUBMIT_GRACE_MS = 1e3 * 60 * 60 * 24;
-var AttestationSecurityLevelSchema = import_zod13.z.enum([
+var AttestationSecurityLevelSchema = import_zod14.z.enum([
   "STRONGBOX",
   "TEE",
   "SECURE_ENCLAVE",
   "SOFTWARE"
 ]);
-var DeviceKeyAlgSchema = import_zod13.z.literal("p256");
-var RegisterDeviceKeyP256InputSchema = import_zod13.z.object({
-  deviceId: import_zod13.z.string().min(1).max(128),
+var DeviceKeyAlgSchema = import_zod14.z.literal("p256");
+var RegisterDeviceKeyP256InputSchema = import_zod14.z.object({
+  deviceId: import_zod14.z.string().min(1).max(128),
   /** P-256 SubjectPublicKeyInfo DER, base64. */
-  publicKeySpkiB64: Base64Std3.min(64).max(4096),
+  publicKeySpkiB64: Base64Std4.min(64).max(4096),
   /** Base64 of the server-issued enrollment challenge string. */
-  challengeB64: Base64Std3.min(8).max(1024),
+  challengeB64: Base64Std4.min(8).max(1024),
   /** iOS App Attest payload or Android X.509 Key Attestation chain. */
-  attestationChainB64: import_zod13.z.array(Base64Std3.min(16).max(16384)).min(1).max(16),
+  attestationChainB64: import_zod14.z.array(Base64Std4.min(16).max(16384)).min(1).max(16),
   securityLevel: AttestationSecurityLevelSchema
 });
-var P256EnrollmentChallengeInputSchema = import_zod13.z.object({
-  deviceId: import_zod13.z.string().min(1).max(128)
+var P256EnrollmentChallengeInputSchema = import_zod14.z.object({
+  deviceId: import_zod14.z.string().min(1).max(128)
 });
-var P256EnrollmentChallengeResultSchema = import_zod13.z.object({
-  challenge: import_zod13.z.string().min(16),
-  expiresAtMs: import_zod13.z.number().int().positive()
+var P256EnrollmentChallengeResultSchema = import_zod14.z.object({
+  challenge: import_zod14.z.string().min(16),
+  expiresAtMs: import_zod14.z.number().int().positive()
 });
-var DeviceKeyRecordSchema = import_zod13.z.object({
-  id: import_zod13.z.string().uuid(),
-  userId: import_zod13.z.string().uuid(),
-  deviceId: import_zod13.z.string(),
+var DeviceKeyRecordSchema = import_zod14.z.object({
+  id: import_zod14.z.string().uuid(),
+  userId: import_zod14.z.string().uuid(),
+  deviceId: import_zod14.z.string(),
   /** Always 'p256' on the consumer offline rail. Field retained for forward-compat. */
   alg: DeviceKeyAlgSchema.default("p256"),
   /** P-256 SubjectPublicKeyInfo DER, base64. */
-  publicKeySpkiB64: Base64Std3.nullable().default(null),
+  publicKeySpkiB64: Base64Std4.nullable().default(null),
   securityLevel: AttestationSecurityLevelSchema.nullable().default(null),
-  hardwareBacked: import_zod13.z.boolean().default(false),
-  attestedAtMs: import_zod13.z.number().int().nonnegative().nullable().default(null),
-  createdAtMs: import_zod13.z.number().int().nonnegative(),
-  revokedAtMs: import_zod13.z.number().int().nonnegative().nullable()
+  hardwareBacked: import_zod14.z.boolean().default(false),
+  attestedAtMs: import_zod14.z.number().int().nonnegative().nullable().default(null),
+  createdAtMs: import_zod14.z.number().int().nonnegative(),
+  revokedAtMs: import_zod14.z.number().int().nonnegative().nullable()
 });
-var ConsumerOACSchema = import_zod13.z.object({
-  oacId: import_zod13.z.string().uuid(),
-  issuerId: import_zod13.z.string().min(1).max(64),
-  userId: import_zod13.z.string().uuid(),
-  deviceId: import_zod13.z.string().min(1).max(128),
+var ConsumerOACSchema = import_zod14.z.object({
+  oacId: import_zod14.z.string().uuid(),
+  issuerId: import_zod14.z.string().min(1).max(64),
+  userId: import_zod14.z.string().uuid(),
+  deviceId: import_zod14.z.string().min(1).max(128),
   /**
    * Always 'p256'. Required on the wire (backend always emits it).
    * Kept as a literal so input/output infer identically and the schema
    * can be nested inside other response shapes without Zod input/output
    * divergence under tsup DTS bundling.
    */
-  alg: import_zod13.z.literal("p256"),
+  alg: import_zod14.z.literal("p256"),
   /** P-256 SubjectPublicKeyInfo DER, base64. */
-  devicePubkeySpkiB64: Base64Std3.min(64).max(4096),
+  devicePubkeySpkiB64: Base64Std4.min(64).max(4096),
   /**
    * Per-transaction / cumulative offline spend ceilings. Zero is valid and
    * denotes an identity-only OAC: the credential proves who the holder is and
@@ -3310,104 +3383,104 @@ var ConsumerOACSchema = import_zod13.z.object({
    * no offline spend authority (every claim against it routes to REVIEW).
    * Issued to zero-balance wallets so they can still be paid offline.
    */
-  perTxCapKobo: import_zod13.z.number().int().nonnegative(),
-  cumulativeCapKobo: import_zod13.z.number().int().nonnegative(),
-  currency: import_zod13.z.string().length(3),
-  validFromMs: import_zod13.z.number().int().nonnegative(),
-  validUntilMs: import_zod13.z.number().int().nonnegative(),
-  counterSeed: import_zod13.z.number().int().nonnegative(),
-  issuedAtMs: import_zod13.z.number().int().nonnegative(),
+  perTxCapKobo: import_zod14.z.number().int().nonnegative(),
+  cumulativeCapKobo: import_zod14.z.number().int().nonnegative(),
+  currency: import_zod14.z.string().length(3),
+  validFromMs: import_zod14.z.number().int().nonnegative(),
+  validUntilMs: import_zod14.z.number().int().nonnegative(),
+  counterSeed: import_zod14.z.number().int().nonnegative(),
+  issuedAtMs: import_zod14.z.number().int().nonnegative(),
   /**
    * Issuer-attested identity folded into the OAC so a single signed
    * credential serves both Tier B offline-verifiable identity and offline
    * spend authority. Verified offline against a pinned issuer key; the
    * backend remains authoritative at settlement.
    */
-  phoneE164: import_zod13.z.string().regex(/^\+[1-9]\d{7,14}$/),
-  displayName: import_zod13.z.string().min(1).max(64)
+  phoneE164: import_zod14.z.string().regex(/^\+[1-9]\d{7,14}$/),
+  displayName: import_zod14.z.string().min(1).max(64)
 });
-var SignedConsumerOACSchema = import_zod13.z.object({
+var SignedConsumerOACSchema = import_zod14.z.object({
   oac: ConsumerOACSchema,
   /** ASN.1 DER ECDSA P-256 issuer signature, base64. */
-  issuerSig: Base64Std3.min(16).max(2048),
+  issuerSig: Base64Std4.min(16).max(2048),
   /** Issuer's P-256 public key as SubjectPublicKeyInfo DER, base64. */
-  issuerPublicKeySpkiB64: Base64Std3.min(64).max(4096)
+  issuerPublicKeySpkiB64: Base64Std4.min(64).max(4096)
 });
 var OACRecordSchema = SignedConsumerOACSchema.extend({
-  currentOfflineSpentKobo: import_zod13.z.number().int().nonnegative(),
-  status: import_zod13.z.enum(["active", "superseded", "expired", "revoked"]),
-  supersededAtMs: import_zod13.z.number().int().nonnegative().nullable(),
-  revokedAtMs: import_zod13.z.number().int().nonnegative().nullable()
+  currentOfflineSpentKobo: import_zod14.z.number().int().nonnegative(),
+  status: import_zod14.z.enum(["active", "superseded", "expired", "revoked"]),
+  supersededAtMs: import_zod14.z.number().int().nonnegative().nullable(),
+  revokedAtMs: import_zod14.z.number().int().nonnegative().nullable()
 });
-var IssueAccountOacInputSchema = import_zod13.z.object({
-  deviceId: import_zod13.z.string().min(1).max(128),
-  perTxCapKobo: import_zod13.z.number().int().positive().optional(),
-  cumulativeCapKobo: import_zod13.z.number().int().positive().optional(),
-  ttlMs: import_zod13.z.number().int().min(6e4).max(ACCOUNT_FUNDED_OAC_MAX_TTL_MS).optional()
+var IssueAccountOacInputSchema = import_zod14.z.object({
+  deviceId: import_zod14.z.string().min(1).max(128),
+  perTxCapKobo: import_zod14.z.number().int().positive().optional(),
+  cumulativeCapKobo: import_zod14.z.number().int().positive().optional(),
+  ttlMs: import_zod14.z.number().int().min(6e4).max(ACCOUNT_FUNDED_OAC_MAX_TTL_MS).optional()
 });
-var OfflineStatusResultSchema = import_zod13.z.object({
+var OfflineStatusResultSchema = import_zod14.z.object({
   active: OACRecordSchema.nullable()
 });
-var ConsumerPaymentClaimSchema = import_zod13.z.object({
+var ConsumerPaymentClaimSchema = import_zod14.z.object({
   /** Always 'p256'. Retained for forward-compat and as an explicit domain marker. */
-  alg: import_zod13.z.literal("p256").default("p256"),
-  oacId: import_zod13.z.string().uuid(),
+  alg: import_zod14.z.literal("p256").default("p256"),
+  oacId: import_zod14.z.string().uuid(),
   encounterId: Sha256Hex.optional(),
-  payerUserId: import_zod13.z.string().uuid(),
-  payeeUserId: import_zod13.z.string().uuid(),
-  payerDeviceId: import_zod13.z.string().min(1).max(128),
+  payerUserId: import_zod14.z.string().uuid(),
+  payeeUserId: import_zod14.z.string().uuid(),
+  payerDeviceId: import_zod14.z.string().min(1).max(128),
   payerNonce: ClaimNonce,
   payeeNonce: ClaimNonce,
-  amountKobo: import_zod13.z.number().int().positive(),
-  currency: import_zod13.z.string().length(3).default("NGN"),
-  occurredAtMs: import_zod13.z.number().int().nonnegative(),
-  completedAtMs: import_zod13.z.number().int().nonnegative().optional(),
-  contextId: import_zod13.z.string().max(128).optional(),
-  requestId: import_zod13.z.string().uuid().optional(),
-  requestMode: import_zod13.z.enum(["fixed", "editable"]).optional(),
-  requestTakerUserId: import_zod13.z.string().uuid().optional(),
-  requestAmountKobo: import_zod13.z.number().int().positive().optional(),
-  requestCurrency: import_zod13.z.string().length(3).optional(),
-  requestReference: import_zod13.z.string().max(128).nullable().optional(),
-  requestCreatedAtMs: import_zod13.z.number().int().nonnegative().optional(),
-  requestExpiresAtMs: import_zod13.z.number().int().positive().optional(),
-  requestNonce: import_zod13.z.string().min(8).max(128).optional(),
-  requestTakerDeviceId: import_zod13.z.string().min(1).max(128).nullable().optional(),
-  requestTakerPubkeySpkiB64: Base64Std3.min(64).max(4096).optional(),
-  requestTakerSignatureDerB64: Base64Std3.min(16).max(2048).optional(),
-  payerPubkeySpkiB64: Base64Std3.min(64).max(4096),
-  payerSignatureDerB64: Base64Std3.min(16).max(2048),
-  payeePubkeySpkiB64: Base64Std3.min(64).max(4096).optional(),
-  payeeSignatureDerB64: Base64Std3.min(16).max(2048).optional()
+  amountKobo: import_zod14.z.number().int().positive(),
+  currency: import_zod14.z.string().length(3).default("NGN"),
+  occurredAtMs: import_zod14.z.number().int().nonnegative(),
+  completedAtMs: import_zod14.z.number().int().nonnegative().optional(),
+  contextId: import_zod14.z.string().max(128).optional(),
+  requestId: import_zod14.z.string().uuid().optional(),
+  requestMode: import_zod14.z.enum(["fixed", "editable"]).optional(),
+  requestTakerUserId: import_zod14.z.string().uuid().optional(),
+  requestAmountKobo: import_zod14.z.number().int().positive().optional(),
+  requestCurrency: import_zod14.z.string().length(3).optional(),
+  requestReference: import_zod14.z.string().max(128).nullable().optional(),
+  requestCreatedAtMs: import_zod14.z.number().int().nonnegative().optional(),
+  requestExpiresAtMs: import_zod14.z.number().int().positive().optional(),
+  requestNonce: import_zod14.z.string().min(8).max(128).optional(),
+  requestTakerDeviceId: import_zod14.z.string().min(1).max(128).nullable().optional(),
+  requestTakerPubkeySpkiB64: Base64Std4.min(64).max(4096).optional(),
+  requestTakerSignatureDerB64: Base64Std4.min(16).max(2048).optional(),
+  payerPubkeySpkiB64: Base64Std4.min(64).max(4096),
+  payerSignatureDerB64: Base64Std4.min(16).max(2048),
+  payeePubkeySpkiB64: Base64Std4.min(64).max(4096).optional(),
+  payeeSignatureDerB64: Base64Std4.min(16).max(2048).optional()
 });
-var ConsumerSettlementSchema = import_zod13.z.object({
-  settlementId: import_zod13.z.string().uuid(),
+var ConsumerSettlementSchema = import_zod14.z.object({
+  settlementId: import_zod14.z.string().uuid(),
   settlementKey: Sha256Hex,
   encounterId: Sha256Hex,
-  oacId: import_zod13.z.string().uuid(),
-  payerUserId: import_zod13.z.string().uuid(),
-  payeeUserId: import_zod13.z.string().uuid(),
-  amountKobo: import_zod13.z.number().int().positive(),
-  currency: import_zod13.z.string().length(3),
-  status: import_zod13.z.enum(["SETTLED", "REVIEW"]),
-  reviewReason: import_zod13.z.string().nullable(),
-  ledgerRef: import_zod13.z.string().nullable(),
+  oacId: import_zod14.z.string().uuid(),
+  payerUserId: import_zod14.z.string().uuid(),
+  payeeUserId: import_zod14.z.string().uuid(),
+  amountKobo: import_zod14.z.number().int().positive(),
+  currency: import_zod14.z.string().length(3),
+  status: import_zod14.z.enum(["SETTLED", "REVIEW"]),
+  reviewReason: import_zod14.z.string().nullable(),
+  ledgerRef: import_zod14.z.string().nullable(),
   /** ASN.1 DER ECDSA P-256 issuer signature, base64. */
-  issuerSig: Base64Std3.min(16).max(2048),
+  issuerSig: Base64Std4.min(16).max(2048),
   /** Canonical millisecond timestamp signed into the settlement receipt. */
-  issuedAtMs: import_zod13.z.number().int().nonnegative(),
+  issuedAtMs: import_zod14.z.number().int().nonnegative(),
   /** Compatibility alias for API consumers that predate issuedAtMs. */
-  createdAtMs: import_zod13.z.number().int().nonnegative().optional()
+  createdAtMs: import_zod14.z.number().int().nonnegative().optional()
 });
-var ConsumerSettleResultSchema = import_zod13.z.object({
+var ConsumerSettleResultSchema = import_zod14.z.object({
   settlement: ConsumerSettlementSchema,
   encounterId: Sha256Hex,
-  replayed: import_zod13.z.boolean()
+  replayed: import_zod14.z.boolean()
 });
-var RevokeDeviceKeyInputSchema = import_zod13.z.object({
-  deviceId: import_zod13.z.string().min(1).max(128),
+var RevokeDeviceKeyInputSchema = import_zod14.z.object({
+  deviceId: import_zod14.z.string().min(1).max(128),
   /** Step-up token from /api/v1/auth/send/verify with purpose='offline_revoke'. */
-  sendAuthToken: import_zod13.z.string().min(16)
+  sendAuthToken: import_zod14.z.string().min(16)
 });
 function createMeOfflineClient(opts) {
   const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
@@ -3440,7 +3513,7 @@ function createMeOfflineClient(opts) {
     }
     return parser(raw);
   }
-  const deviceKeyItems = import_zod13.z.object({ items: import_zod13.z.array(DeviceKeyRecordSchema) });
+  const deviceKeyItems = import_zod14.z.object({ items: import_zod14.z.array(DeviceKeyRecordSchema) });
   return {
     issueP256EnrollmentChallenge: (input) => call(
       "POST",
@@ -3498,6 +3571,12 @@ function createMeOfflineClient(opts) {
       "/v1/issuer/keys",
       void 0,
       (raw) => IssuerTrustBundleSchema.parse(raw)
+    ),
+    getRevocations: () => call(
+      "GET",
+      "/v1/issuer/revocations",
+      void 0,
+      (raw) => SignedRevocationListSchema.parse(raw)
     )
   };
 }
@@ -3644,26 +3723,26 @@ function verifyClaimSignature(input) {
 }
 
 // src/me-offline/request.ts
-var import_zod14 = require("zod");
-var Base64Std4 = import_zod14.z.string().regex(/^[A-Za-z0-9+/]+={0,2}$/);
+var import_zod15 = require("zod");
+var Base64Std5 = import_zod15.z.string().regex(/^[A-Za-z0-9+/]+={0,2}$/);
 var CONSUMER_PAYMENT_REQUEST_DOMAIN = "flur:consumer-offline:v1:request";
-var ConsumerPaymentRequestEnvelopeSchema = import_zod14.z.object({
-  requestId: import_zod14.z.string().uuid(),
-  mode: import_zod14.z.enum(["fixed", "editable"]),
-  takerUserId: import_zod14.z.string().uuid(),
-  amountKobo: import_zod14.z.number().int().positive(),
-  currency: import_zod14.z.string().length(3).default("NGN"),
-  reference: import_zod14.z.string().max(128).nullable().default(null),
-  createdAtMs: import_zod14.z.number().int().nonnegative(),
-  expiresAtMs: import_zod14.z.number().int().positive(),
-  nonce: import_zod14.z.string().min(8).max(128),
-  takerDeviceId: import_zod14.z.string().min(1).max(128).nullable().default(null),
-  takerPubkeySpkiB64: Base64Std4.min(64).max(4096).optional(),
-  takerSignatureDerB64: Base64Std4.min(16).max(2048).optional()
+var ConsumerPaymentRequestEnvelopeSchema = import_zod15.z.object({
+  requestId: import_zod15.z.string().uuid(),
+  mode: import_zod15.z.enum(["fixed", "editable"]),
+  takerUserId: import_zod15.z.string().uuid(),
+  amountKobo: import_zod15.z.number().int().positive(),
+  currency: import_zod15.z.string().length(3).default("NGN"),
+  reference: import_zod15.z.string().max(128).nullable().default(null),
+  createdAtMs: import_zod15.z.number().int().nonnegative(),
+  expiresAtMs: import_zod15.z.number().int().positive(),
+  nonce: import_zod15.z.string().min(8).max(128),
+  takerDeviceId: import_zod15.z.string().min(1).max(128).nullable().default(null),
+  takerPubkeySpkiB64: Base64Std5.min(64).max(4096).optional(),
+  takerSignatureDerB64: Base64Std5.min(16).max(2048).optional()
 }).superRefine((value, ctx) => {
   if (value.expiresAtMs <= value.createdAtMs) {
     ctx.addIssue({
-      code: import_zod14.z.ZodIssueCode.custom,
+      code: import_zod15.z.ZodIssueCode.custom,
       path: ["expiresAtMs"],
       message: "expiresAtMs must be greater than createdAtMs"
     });
@@ -3674,21 +3753,21 @@ var ConsumerPaymentRequestEnvelopeSchema = import_zod14.z.object({
   if (value.mode === "fixed" || hasSignature) {
     if (!value.takerDeviceId) {
       ctx.addIssue({
-        code: import_zod14.z.ZodIssueCode.custom,
+        code: import_zod15.z.ZodIssueCode.custom,
         path: ["takerDeviceId"],
         message: "signed requests require takerDeviceId"
       });
     }
     if (!value.takerPubkeySpkiB64) {
       ctx.addIssue({
-        code: import_zod14.z.ZodIssueCode.custom,
+        code: import_zod15.z.ZodIssueCode.custom,
         path: ["takerPubkeySpkiB64"],
         message: "signed requests require takerPubkeySpkiB64"
       });
     }
     if (!value.takerSignatureDerB64) {
       ctx.addIssue({
-        code: import_zod14.z.ZodIssueCode.custom,
+        code: import_zod15.z.ZodIssueCode.custom,
         path: ["takerSignatureDerB64"],
         message: "signed requests require takerSignatureDerB64"
       });
@@ -3859,7 +3938,7 @@ function base64UrlDecodeUtf8(input) {
 }
 
 // src/me-offline/oac.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 var CONSUMER_OAC_DOMAIN = "flur:consumer-offline:v1:oac";
 function consumerOacSigningPayload(oac) {
   return { domain: CONSUMER_OAC_DOMAIN, ...oac };
@@ -3885,6 +3964,9 @@ function verifyOacOffline(signed, trustedKeys, options = {}) {
   }
   if (nowMs < oac.validFromMs) return { ok: false, reason: "not_yet_valid" };
   if (nowMs >= oac.validUntilMs) return { ok: false, reason: "expired" };
+  if (options.revokedOacIds?.has(oac.oacId)) {
+    return { ok: false, reason: "revoked" };
+  }
   return {
     ok: true,
     oac,
@@ -3902,13 +3984,13 @@ var CONSUMER_OAC_QR_PREFIX = "FLUROAC1.";
 function isConsumerOacQR(value) {
   return value.startsWith(CONSUMER_OAC_QR_PREFIX);
 }
-var OacPresentmentRequestSchema = import_zod15.z.object({
+var OacPresentmentRequestSchema = import_zod16.z.object({
   /** Requested amount in minor units (kobo). */
-  amountMinor: import_zod15.z.number().int().positive().max(1e12).optional(),
+  amountMinor: import_zod16.z.number().int().positive().max(1e12).optional(),
   /** Purpose/intent code (mirrors the NIBSS intent vocabulary). */
-  intent: import_zod15.z.string().min(1).max(32).optional(),
+  intent: import_zod16.z.string().min(1).max(32).optional(),
   /** Free-text reference / note. */
-  reference: import_zod15.z.string().min(1).max(64).optional()
+  reference: import_zod16.z.string().min(1).max(64).optional()
 }).strict();
 function encodeConsumerOacQR(signed, request) {
   const parsed = SignedConsumerOACSchema.parse(signed);
@@ -4242,14 +4324,14 @@ function base64UrlToBytes(input) {
 }
 
 // src/partner-funding/client.ts
-var import_zod16 = require("zod");
-var MinorString = import_zod16.z.string().regex(/^-?\d+$/);
-var PositiveMinor = import_zod16.z.union([
-  import_zod16.z.number().int().positive(),
-  import_zod16.z.string().regex(/^[1-9]\d{0,18}$/)
+var import_zod17 = require("zod");
+var MinorString = import_zod17.z.string().regex(/^-?\d+$/);
+var PositiveMinor = import_zod17.z.union([
+  import_zod17.z.number().int().positive(),
+  import_zod17.z.string().regex(/^[1-9]\d{0,18}$/)
 ]);
-var Currency = import_zod16.z.string().trim().length(3).transform((v) => v.toUpperCase());
-var Metadata = import_zod16.z.record(import_zod16.z.unknown());
+var Currency = import_zod17.z.string().trim().length(3).transform((v) => v.toUpperCase());
+var Metadata = import_zod17.z.record(import_zod17.z.unknown());
 var PARTNER_KINDS = ["bank", "merchant"];
 var CUSTODIAL_MODES = ["agent_of_bank", "flur_virtual_pool"];
 var PARTNER_PROFILE_STATUSES = [
@@ -4276,126 +4358,126 @@ var WITHDRAWAL_STATES = [
   "failed",
   "reversed"
 ];
-var PartnerProfileSchema = import_zod16.z.object({
-  partnerAccountId: import_zod16.z.string().uuid(),
-  kind: import_zod16.z.enum(PARTNER_KINDS),
-  custodialMode: import_zod16.z.enum(CUSTODIAL_MODES),
-  displayName: import_zod16.z.string(),
-  bankCode: import_zod16.z.string().nullable(),
-  poolAccountNumber: import_zod16.z.string().nullable(),
-  status: import_zod16.z.enum(PARTNER_PROFILE_STATUSES),
+var PartnerProfileSchema = import_zod17.z.object({
+  partnerAccountId: import_zod17.z.string().uuid(),
+  kind: import_zod17.z.enum(PARTNER_KINDS),
+  custodialMode: import_zod17.z.enum(CUSTODIAL_MODES),
+  displayName: import_zod17.z.string(),
+  bankCode: import_zod17.z.string().nullable(),
+  poolAccountNumber: import_zod17.z.string().nullable(),
+  status: import_zod17.z.enum(PARTNER_PROFILE_STATUSES),
   metadata: Metadata,
-  createdAtMs: import_zod16.z.number().int().nonnegative(),
-  updatedAtMs: import_zod16.z.number().int().nonnegative()
+  createdAtMs: import_zod17.z.number().int().nonnegative(),
+  updatedAtMs: import_zod17.z.number().int().nonnegative()
 });
-var UpsertPartnerProfileInputSchema = import_zod16.z.object({
-  kind: import_zod16.z.enum(PARTNER_KINDS),
-  custodialMode: import_zod16.z.enum(CUSTODIAL_MODES),
-  displayName: import_zod16.z.string().trim().min(1).max(200),
-  bankCode: import_zod16.z.string().trim().min(1).max(64).optional(),
-  poolAccountNumber: import_zod16.z.string().trim().min(1).max(64).optional(),
+var UpsertPartnerProfileInputSchema = import_zod17.z.object({
+  kind: import_zod17.z.enum(PARTNER_KINDS),
+  custodialMode: import_zod17.z.enum(CUSTODIAL_MODES),
+  displayName: import_zod17.z.string().trim().min(1).max(200),
+  bankCode: import_zod17.z.string().trim().min(1).max(64).optional(),
+  poolAccountNumber: import_zod17.z.string().trim().min(1).max(64).optional(),
   metadata: Metadata.optional()
 });
-var PartnerFundingEventInputSchema = import_zod16.z.object({
-  externalRef: import_zod16.z.string().trim().min(8).max(128),
-  direction: import_zod16.z.enum(PARTNER_FUNDING_DIRECTIONS).optional(),
-  userId: import_zod16.z.string().uuid().optional(),
-  accountId: import_zod16.z.string().uuid().optional(),
+var PartnerFundingEventInputSchema = import_zod17.z.object({
+  externalRef: import_zod17.z.string().trim().min(8).max(128),
+  direction: import_zod17.z.enum(PARTNER_FUNDING_DIRECTIONS).optional(),
+  userId: import_zod17.z.string().uuid().optional(),
+  accountId: import_zod17.z.string().uuid().optional(),
   amountMinor: PositiveMinor,
   currency: Currency,
-  fundingSource: import_zod16.z.string().trim().min(1).max(64).optional(),
+  fundingSource: import_zod17.z.string().trim().min(1).max(64).optional(),
   providerMetadata: Metadata.optional()
 });
-var PartnerFundingSchema = import_zod16.z.object({
-  fundingId: import_zod16.z.string().uuid(),
-  partnerId: import_zod16.z.string().uuid(),
-  accountId: import_zod16.z.string().uuid(),
-  userId: import_zod16.z.string().uuid().nullable(),
-  direction: import_zod16.z.enum(PARTNER_FUNDING_DIRECTIONS),
-  currency: import_zod16.z.string(),
+var PartnerFundingSchema = import_zod17.z.object({
+  fundingId: import_zod17.z.string().uuid(),
+  partnerId: import_zod17.z.string().uuid(),
+  accountId: import_zod17.z.string().uuid(),
+  userId: import_zod17.z.string().uuid().nullable(),
+  direction: import_zod17.z.enum(PARTNER_FUNDING_DIRECTIONS),
+  currency: import_zod17.z.string(),
   amountMinor: MinorString,
-  externalRef: import_zod16.z.string(),
-  status: import_zod16.z.enum(PARTNER_FUNDING_STATUSES),
-  fundingSource: import_zod16.z.string(),
-  ledgerRef: import_zod16.z.string(),
+  externalRef: import_zod17.z.string(),
+  status: import_zod17.z.enum(PARTNER_FUNDING_STATUSES),
+  fundingSource: import_zod17.z.string(),
+  ledgerRef: import_zod17.z.string(),
   providerMetadata: Metadata,
-  createdAtMs: import_zod16.z.number().int().nonnegative(),
-  updatedAtMs: import_zod16.z.number().int().nonnegative()
+  createdAtMs: import_zod17.z.number().int().nonnegative(),
+  updatedAtMs: import_zod17.z.number().int().nonnegative()
 });
-var IngestFundingResultSchema = import_zod16.z.object({
+var IngestFundingResultSchema = import_zod17.z.object({
   funding: PartnerFundingSchema,
-  replayed: import_zod16.z.boolean()
+  replayed: import_zod17.z.boolean()
 });
-var PayoutDestinationSchema = import_zod16.z.object({
-  destinationId: import_zod16.z.string().uuid(),
-  accountId: import_zod16.z.string().uuid(),
-  partnerId: import_zod16.z.string().uuid(),
-  bankCode: import_zod16.z.string(),
-  accountNumber: import_zod16.z.string(),
-  accountName: import_zod16.z.string(),
-  status: import_zod16.z.enum(PAYOUT_DESTINATION_STATUSES),
-  verifiedAtMs: import_zod16.z.number().int().nonnegative().nullable(),
+var PayoutDestinationSchema = import_zod17.z.object({
+  destinationId: import_zod17.z.string().uuid(),
+  accountId: import_zod17.z.string().uuid(),
+  partnerId: import_zod17.z.string().uuid(),
+  bankCode: import_zod17.z.string(),
+  accountNumber: import_zod17.z.string(),
+  accountName: import_zod17.z.string(),
+  status: import_zod17.z.enum(PAYOUT_DESTINATION_STATUSES),
+  verifiedAtMs: import_zod17.z.number().int().nonnegative().nullable(),
   metadata: Metadata,
-  createdAtMs: import_zod16.z.number().int().nonnegative(),
-  updatedAtMs: import_zod16.z.number().int().nonnegative()
+  createdAtMs: import_zod17.z.number().int().nonnegative(),
+  updatedAtMs: import_zod17.z.number().int().nonnegative()
 });
-var CreatePayoutDestinationInputSchema = import_zod16.z.object({
-  partnerId: import_zod16.z.string().uuid(),
-  bankCode: import_zod16.z.string().trim().min(1).max(32),
-  accountNumber: import_zod16.z.string().trim().min(4).max(64),
-  accountName: import_zod16.z.string().trim().min(1).max(200),
+var CreatePayoutDestinationInputSchema = import_zod17.z.object({
+  partnerId: import_zod17.z.string().uuid(),
+  bankCode: import_zod17.z.string().trim().min(1).max(32),
+  accountNumber: import_zod17.z.string().trim().min(4).max(64),
+  accountName: import_zod17.z.string().trim().min(1).max(200),
   metadata: Metadata.optional()
 });
-var ListPayoutDestinationsResultSchema = import_zod16.z.object({
-  items: import_zod16.z.array(PayoutDestinationSchema)
+var ListPayoutDestinationsResultSchema = import_zod17.z.object({
+  items: import_zod17.z.array(PayoutDestinationSchema)
 });
-var WithdrawalSchema = import_zod16.z.object({
-  withdrawalId: import_zod16.z.string().uuid(),
-  accountId: import_zod16.z.string().uuid(),
-  userId: import_zod16.z.string().uuid(),
-  partnerId: import_zod16.z.string().uuid(),
-  destinationId: import_zod16.z.string().uuid(),
-  currency: import_zod16.z.string(),
+var WithdrawalSchema = import_zod17.z.object({
+  withdrawalId: import_zod17.z.string().uuid(),
+  accountId: import_zod17.z.string().uuid(),
+  userId: import_zod17.z.string().uuid(),
+  partnerId: import_zod17.z.string().uuid(),
+  destinationId: import_zod17.z.string().uuid(),
+  currency: import_zod17.z.string(),
   amountMinor: MinorString,
-  state: import_zod16.z.enum(WITHDRAWAL_STATES),
-  idempotencyKey: import_zod16.z.string(),
-  providerRef: import_zod16.z.string().nullable(),
-  lastError: import_zod16.z.string().nullable(),
-  ledgerRef: import_zod16.z.string(),
-  reverseLedgerRef: import_zod16.z.string().nullable(),
+  state: import_zod17.z.enum(WITHDRAWAL_STATES),
+  idempotencyKey: import_zod17.z.string(),
+  providerRef: import_zod17.z.string().nullable(),
+  lastError: import_zod17.z.string().nullable(),
+  ledgerRef: import_zod17.z.string(),
+  reverseLedgerRef: import_zod17.z.string().nullable(),
   metadata: Metadata,
-  createdAtMs: import_zod16.z.number().int().nonnegative(),
-  updatedAtMs: import_zod16.z.number().int().nonnegative()
+  createdAtMs: import_zod17.z.number().int().nonnegative(),
+  updatedAtMs: import_zod17.z.number().int().nonnegative()
 });
-var CreateWithdrawalInputSchema = import_zod16.z.object({
-  destinationId: import_zod16.z.string().uuid(),
+var CreateWithdrawalInputSchema = import_zod17.z.object({
+  destinationId: import_zod17.z.string().uuid(),
   amountMinor: PositiveMinor,
   currency: Currency,
-  idempotencyKey: import_zod16.z.string().trim().min(8).max(128),
+  idempotencyKey: import_zod17.z.string().trim().min(8).max(128),
   metadata: Metadata.optional()
 });
-var CreateWithdrawalResultSchema = import_zod16.z.object({
+var CreateWithdrawalResultSchema = import_zod17.z.object({
   withdrawal: WithdrawalSchema,
-  replayed: import_zod16.z.boolean()
+  replayed: import_zod17.z.boolean()
 });
-var PayoutEventInputSchema = import_zod16.z.object({
-  externalRef: import_zod16.z.string().trim().min(8).max(128),
-  withdrawalId: import_zod16.z.string().uuid().optional(),
-  state: import_zod16.z.enum(["submitted", "processing", "paid", "failed"]),
-  providerRef: import_zod16.z.string().trim().min(1).max(128).optional(),
-  failureCode: import_zod16.z.string().trim().max(64).optional(),
-  failureMessage: import_zod16.z.string().trim().max(512).optional(),
+var PayoutEventInputSchema = import_zod17.z.object({
+  externalRef: import_zod17.z.string().trim().min(8).max(128),
+  withdrawalId: import_zod17.z.string().uuid().optional(),
+  state: import_zod17.z.enum(["submitted", "processing", "paid", "failed"]),
+  providerRef: import_zod17.z.string().trim().min(1).max(128).optional(),
+  failureCode: import_zod17.z.string().trim().max(64).optional(),
+  failureMessage: import_zod17.z.string().trim().max(512).optional(),
   providerMetadata: Metadata.optional()
 });
-var RecordPayoutEventResultSchema = import_zod16.z.object({
+var RecordPayoutEventResultSchema = import_zod17.z.object({
   withdrawal: WithdrawalSchema,
-  replayed: import_zod16.z.boolean()
+  replayed: import_zod17.z.boolean()
 });
-var ReconciliationReportSchema = import_zod16.z.object({
-  partnerId: import_zod16.z.string().uuid(),
-  currency: import_zod16.z.string(),
-  fromMs: import_zod16.z.number().int().nonnegative(),
-  toMs: import_zod16.z.number().int().nonnegative(),
+var ReconciliationReportSchema = import_zod17.z.object({
+  partnerId: import_zod17.z.string().uuid(),
+  currency: import_zod17.z.string(),
+  fromMs: import_zod17.z.number().int().nonnegative(),
+  toMs: import_zod17.z.number().int().nonnegative(),
   fundingsCreditMinor: MinorString,
   fundingsDebitMinor: MinorString,
   withdrawalsPaidMinor: MinorString,
@@ -4404,7 +4486,7 @@ var ReconciliationReportSchema = import_zod16.z.object({
   expectedReserveBalanceMinor: MinorString,
   actualReserveBalanceMinor: MinorString,
   imbalanceMinor: MinorString,
-  generatedAtMs: import_zod16.z.number().int().nonnegative()
+  generatedAtMs: import_zod17.z.number().int().nonnegative()
 });
 function createPartnerFundingClient(partner) {
   return {
@@ -4556,19 +4638,19 @@ function createPartnerProfileAdminClient(opts) {
 }
 
 // src/artifacts/envelope.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 var FLUR_ARTIFACT_URI_SCHEME = "flur";
 var FLUR_ARTIFACT_VERSION = 1;
 var FLUR_ARTIFACT_URI_PREFIX = `${FLUR_ARTIFACT_URI_SCHEME}://v${FLUR_ARTIFACT_VERSION}/`;
 var ArtifactTypeRe = /^[a-z][a-z0-9_]{1,63}$/;
-var ArtifactHeaderSchema = import_zod17.z.object({
-  v: import_zod17.z.literal(FLUR_ARTIFACT_VERSION),
-  t: import_zod17.z.string().regex(ArtifactTypeRe, "invalid artifact type"),
-  iss: import_zod17.z.string().min(1).max(128),
-  kid: import_zod17.z.string().min(1).max(128),
-  iat: import_zod17.z.number().int().nonnegative(),
-  exp: import_zod17.z.number().int().positive().optional(),
-  nonce: import_zod17.z.string().min(8).max(64).regex(/^[A-Za-z0-9_-]+$/, "nonce must be url-safe")
+var ArtifactHeaderSchema = import_zod18.z.object({
+  v: import_zod18.z.literal(FLUR_ARTIFACT_VERSION),
+  t: import_zod18.z.string().regex(ArtifactTypeRe, "invalid artifact type"),
+  iss: import_zod18.z.string().min(1).max(128),
+  kid: import_zod18.z.string().min(1).max(128),
+  iat: import_zod18.z.number().int().nonnegative(),
+  exp: import_zod18.z.number().int().positive().optional(),
+  nonce: import_zod18.z.string().min(8).max(64).regex(/^[A-Za-z0-9_-]+$/, "nonce must be url-safe")
 });
 var FlurArtifactError = class extends Error {
   constructor(message, code) {
@@ -4707,7 +4789,7 @@ function verifyArtifactSignature(decoded, publicKeySpkiB64, options = {}) {
 }
 
 // src/artifacts/types.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 var ARTIFACT_TYPES = {
   OFFLINE_PAYMENT_AUTHORIZATION: "offline_payment_authorization",
   RECEIPT: "receipt",
@@ -4722,32 +4804,32 @@ var ARTIFACT_TYPES = {
   PASS: "pass",
   IDENTITY: "identity"
 };
-var HexString = (length) => import_zod18.z.string().regex(
+var HexString = (length) => import_zod19.z.string().regex(
   new RegExp(`^[0-9a-fA-F]{${length * 2}}$`),
   `expected ${length}-byte hex string`
 );
-var OfflinePaymentAuthorizationArtifactSchema = import_zod18.z.object({
+var OfflinePaymentAuthorizationArtifactSchema = import_zod19.z.object({
   authorization: OfflinePaymentAuthorizationSchema
 });
-var ReceiptArtifactSchema = import_zod18.z.object({
-  receiptId: import_zod18.z.string().min(1).max(64),
-  paymentReference: import_zod18.z.string().min(1).max(64),
-  payerUserId: import_zod18.z.string().min(1).max(64).optional(),
-  payeeUserId: import_zod18.z.string().min(1).max(64),
-  amountKobo: import_zod18.z.number().int().positive(),
-  currency: import_zod18.z.literal("NGN"),
-  channel: import_zod18.z.enum(["online", "offline_reconciled", "pay_link", "nqr"]),
-  settledAtMs: import_zod18.z.number().int().positive(),
-  ledgerTxnId: import_zod18.z.string().min(1).max(64).optional(),
-  memo: import_zod18.z.string().max(140).optional(),
+var ReceiptArtifactSchema = import_zod19.z.object({
+  receiptId: import_zod19.z.string().min(1).max(64),
+  paymentReference: import_zod19.z.string().min(1).max(64),
+  payerUserId: import_zod19.z.string().min(1).max(64).optional(),
+  payeeUserId: import_zod19.z.string().min(1).max(64),
+  amountKobo: import_zod19.z.number().int().positive(),
+  currency: import_zod19.z.literal("NGN"),
+  channel: import_zod19.z.enum(["online", "offline_reconciled", "pay_link", "nqr"]),
+  settledAtMs: import_zod19.z.number().int().positive(),
+  ledgerTxnId: import_zod19.z.string().min(1).max(64).optional(),
+  memo: import_zod19.z.string().max(140).optional(),
   hashChainPrev: HexString(32).optional()
 });
-var ShortId = import_zod18.z.string().min(1).max(64);
-var PositiveInt = import_zod18.z.number().int().positive();
-var NonNegativeInt = import_zod18.z.number().int().nonnegative();
-var Currency2 = import_zod18.z.literal("NGN");
-var Memo = import_zod18.z.string().max(140);
-var NqrPaymentRequestArtifactSchema = import_zod18.z.object({
+var ShortId = import_zod19.z.string().min(1).max(64);
+var PositiveInt = import_zod19.z.number().int().positive();
+var NonNegativeInt = import_zod19.z.number().int().nonnegative();
+var Currency2 = import_zod19.z.literal("NGN");
+var Memo = import_zod19.z.string().max(140);
+var NqrPaymentRequestArtifactSchema = import_zod19.z.object({
   requestId: ShortId,
   payeeUserId: ShortId,
   amountKobo: PositiveInt.optional(),
@@ -4755,7 +4837,7 @@ var NqrPaymentRequestArtifactSchema = import_zod18.z.object({
   memo: Memo.optional(),
   expiresAtMs: PositiveInt.optional()
 });
-var PaymentIntentArtifactSchema = import_zod18.z.object({
+var PaymentIntentArtifactSchema = import_zod19.z.object({
   intentId: ShortId,
   payerUserId: ShortId,
   payeeUserId: ShortId,
@@ -4764,7 +4846,7 @@ var PaymentIntentArtifactSchema = import_zod18.z.object({
   idempotencyKey: ShortId,
   createdAtMs: PositiveInt
 });
-var OfflineClaimArtifactSchema = import_zod18.z.object({
+var OfflineClaimArtifactSchema = import_zod19.z.object({
   claimId: ShortId,
   authorizationId: ShortId,
   payeeUserId: ShortId,
@@ -4773,10 +4855,10 @@ var OfflineClaimArtifactSchema = import_zod18.z.object({
   claimedAtMs: PositiveInt,
   paymentReference: ShortId.optional()
 });
-var SettlementRecordArtifactSchema = import_zod18.z.object({
+var SettlementRecordArtifactSchema = import_zod19.z.object({
   settlementId: ShortId,
   ledgerTxnId: ShortId,
-  sourceRefType: import_zod18.z.enum([
+  sourceRefType: import_zod19.z.enum([
     "offline_authorization",
     "offline_claim",
     "transfer",
@@ -4787,12 +4869,12 @@ var SettlementRecordArtifactSchema = import_zod18.z.object({
   currency: Currency2,
   settledAtMs: PositiveInt
 });
-var ReversalRecordArtifactSchema = import_zod18.z.object({
+var ReversalRecordArtifactSchema = import_zod19.z.object({
   reversalId: ShortId,
   originalTxnId: ShortId,
   amountKobo: PositiveInt,
   currency: Currency2,
-  reason: import_zod18.z.enum([
+  reason: import_zod19.z.enum([
     "user_dispute",
     "fraud",
     "duplicate",
@@ -4802,7 +4884,7 @@ var ReversalRecordArtifactSchema = import_zod18.z.object({
   reversedAtMs: PositiveInt,
   memo: Memo.optional()
 });
-var LedgerJournalEntryArtifactSchema = import_zod18.z.object({
+var LedgerJournalEntryArtifactSchema = import_zod19.z.object({
   entryId: ShortId,
   journalId: ShortId,
   debitAccountId: ShortId,
@@ -4813,13 +4895,13 @@ var LedgerJournalEntryArtifactSchema = import_zod18.z.object({
   refType: ShortId.optional(),
   refId: ShortId.optional()
 });
-var StatementArtifactSchema = import_zod18.z.object({
+var StatementArtifactSchema = import_zod19.z.object({
   statementId: ShortId,
   userId: ShortId,
   periodStartMs: PositiveInt,
   periodEndMs: PositiveInt,
-  openingBalanceKobo: import_zod18.z.number().int(),
-  closingBalanceKobo: import_zod18.z.number().int(),
+  openingBalanceKobo: import_zod19.z.number().int(),
+  closingBalanceKobo: import_zod19.z.number().int(),
   transactionCount: NonNegativeInt,
   currency: Currency2,
   hashChainPrev: HexString(32).optional()
@@ -4827,16 +4909,16 @@ var StatementArtifactSchema = import_zod18.z.object({
   message: "periodEndMs must be greater than periodStartMs",
   path: ["periodEndMs"]
 });
-var PassArtifactSchema = import_zod18.z.object({
+var PassArtifactSchema = import_zod19.z.object({
   passId: ShortId,
   holderId: ShortId,
-  category: import_zod18.z.enum(["membership", "ticket", "loyalty", "access", "voucher"]),
-  title: import_zod18.z.string().min(1).max(120),
+  category: import_zod19.z.enum(["membership", "ticket", "loyalty", "access", "voucher"]),
+  title: import_zod19.z.string().min(1).max(120),
   validFromMs: PositiveInt,
   validUntilMs: PositiveInt.optional(),
-  metadata: import_zod18.z.record(
-    import_zod18.z.string().min(1).max(64),
-    import_zod18.z.union([import_zod18.z.string().max(280), import_zod18.z.number(), import_zod18.z.boolean()])
+  metadata: import_zod19.z.record(
+    import_zod19.z.string().min(1).max(64),
+    import_zod19.z.union([import_zod19.z.string().max(280), import_zod19.z.number(), import_zod19.z.boolean()])
   ).optional()
 }).refine(
   (v) => v.validUntilMs === void 0 || v.validUntilMs > v.validFromMs,
@@ -4845,10 +4927,10 @@ var PassArtifactSchema = import_zod18.z.object({
     path: ["validUntilMs"]
   }
 );
-var IdentityArtifactSchema = import_zod18.z.object({
+var IdentityArtifactSchema = import_zod19.z.object({
   attestationId: ShortId,
   subjectId: ShortId,
-  claimType: import_zod18.z.enum([
+  claimType: import_zod19.z.enum([
     "phone_verified",
     "email_verified",
     "bvn_verified",
@@ -4987,6 +5069,7 @@ function createOfflinePaymentAuthorizationArtifactUri(input) {
   CONSUMER_OAC_QR_PREFIX,
   CONSUMER_OFFLINE_CLAIM_SUBMIT_GRACE_MS,
   CONSUMER_PAYMENT_REQUEST_DOMAIN,
+  CONSUMER_REVOCATION_DOMAIN,
   CONSUMER_SETTLEMENT_DOMAIN,
   CONSUMER_SETTLEMENT_RECEIPT_QR_PREFIX,
   CUSTODIAL_MODES,
@@ -5084,6 +5167,7 @@ function createOfflinePaymentAuthorizationArtifactUri(input) {
   RECEIPT_CHANNELS,
   RECEIPT_KINDS,
   REPLAY_WINDOW_MS,
+  REVOCATION_LIST_MAX_ENTRIES,
   ReceiptArtifactSchema,
   ReceiptPayloadSchema,
   ReceiptSchema,
@@ -5092,12 +5176,14 @@ function createOfflinePaymentAuthorizationArtifactUri(input) {
   RedemptionSchema,
   RegisterDeviceKeyP256InputSchema,
   ReversalRecordArtifactSchema,
+  RevocationListSchema,
   RevokeDeviceKeyInputSchema,
   SETTLEMENT_SCHEDULES,
   SettleResponseSchema,
   SettlementRecordArtifactSchema,
   SettlementSchema,
   SignedConsumerOACSchema,
+  SignedRevocationListSchema,
   StatementArtifactSchema,
   UpsertMerchantProfileInputSchema,
   UpsertPartnerProfileInputSchema,
@@ -5178,6 +5264,7 @@ function createOfflinePaymentAuthorizationArtifactUri(input) {
   isConsumerPaymentRequestExpired,
   isHardenedArtifactType,
   isKnownArtifactType,
+  isOacRevoked,
   isPassWithinValidity,
   moneyMinorToNumber,
   normalizeE164,
@@ -5185,6 +5272,7 @@ function createOfflinePaymentAuthorizationArtifactUri(input) {
   parseNQR,
   parseQR,
   readTLV,
+  revocationListSigningPayload,
   routingHint,
   signArtifact,
   signAuthorization,
@@ -5211,6 +5299,7 @@ function createOfflinePaymentAuthorizationArtifactUri(input) {
   verifyReceipt,
   verifyRedemption,
   verifyRequestHMAC,
+  verifyRevocationList,
   writeTLV
 });
 //# sourceMappingURL=index.cjs.map