@nokinc-flur/sdk 2.2.0 → 2.4.0

package/dist/index.cjs

@@ -44,6 +44,8 @@ __export(index_exports, {
   CLAIM_DOMAIN_V2: () => CLAIM_DOMAIN_V2,
   COLLECTION_INTENT_STATUSES: () => COLLECTION_INTENT_STATUSES,
   COLLECTION_PAYMENT_STATUSES: () => COLLECTION_PAYMENT_STATUSES,
+  CONSUMER_OAC_DOMAIN: () => CONSUMER_OAC_DOMAIN,
+  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_SETTLEMENT_DOMAIN: () => CONSUMER_SETTLEMENT_DOMAIN,
@@ -82,6 +84,8 @@ __export(index_exports, {
   IdentityArtifactSchema: () => IdentityArtifactSchema,
   IngestFundingResultSchema: () => IngestFundingResultSchema,
   IssueAccountOacInputSchema: () => IssueAccountOacInputSchema,
+  IssuerTrustBundleSchema: () => IssuerTrustBundleSchema,
+  IssuerTrustKeySchema: () => IssuerTrustKeySchema,
   LedgerJournalEntryArtifactSchema: () => LedgerJournalEntryArtifactSchema,
   ListPayoutDestinationsResultSchema: () => ListPayoutDestinationsResultSchema,
   MEMBERSHIP_ROLES: () => MEMBERSHIP_ROLES,
@@ -105,6 +109,7 @@ __export(index_exports, {
   OFFLINE_SMS_SETTLE_SIGNATURE_BYTES: () => OFFLINE_SMS_SETTLE_SIGNATURE_BYTES,
   OFFLINE_SMS_SETTLE_TOKEN_BYTES: () => OFFLINE_SMS_SETTLE_TOKEN_BYTES,
   OFFLINE_SMS_SETTLE_VERSION: () => OFFLINE_SMS_SETTLE_VERSION,
+  OacPresentmentRequestSchema: () => OacPresentmentRequestSchema,
   OfflineClaimArtifactSchema: () => OfflineClaimArtifactSchema,
   OfflinePaymentAuthorizationArtifactSchema: () => OfflinePaymentAuthorizationArtifactSchema,
   OfflinePaymentAuthorizationSchema: () => OfflinePaymentAuthorizationSchema,
@@ -122,9 +127,6 @@ __export(index_exports, {
   PASS_STATES: () => PASS_STATES,
   PAYLOAD_FORMAT_INDICATOR_VALUE: () => PAYLOAD_FORMAT_INDICATOR_VALUE,
   PAYOUT_DESTINATION_STATUSES: () => PAYOUT_DESTINATION_STATUSES,
-  PAY_CARD_DEFAULT_TTL_MS: () => PAY_CARD_DEFAULT_TTL_MS,
-  PAY_CARD_REFRESH_THRESHOLD_MS: () => PAY_CARD_REFRESH_THRESHOLD_MS,
-  PAY_CARD_URI_PREFIX: () => PAY_CARD_URI_PREFIX,
   POINT_OF_INITIATION: () => POINT_OF_INITIATION,
   PartnerFundingEventInputSchema: () => PartnerFundingEventInputSchema,
   PartnerFundingSchema: () => PartnerFundingSchema,
@@ -132,7 +134,6 @@ __export(index_exports, {
   PassArtifactSchema: () => PassArtifactSchema,
   PassMetadataSchema: () => PassMetadataSchema,
   PassSchema: () => PassSchema,
-  PayCardArtifactSchema: () => PayCardArtifactSchema,
   PayCollectionInputSchema: () => PayCollectionInputSchema,
   PaymentClaimSchema: () => PaymentClaimSchema,
   PaymentIntentArtifactSchema: () => PaymentIntentArtifactSchema,
@@ -171,7 +172,6 @@ __export(index_exports, {
   buildConsumerPaymentRequest: () => buildConsumerPaymentRequest,
   buildOAC: () => buildOAC,
   buildPass: () => buildPass,
-  buildPayCardSigningInput: () => buildPayCardSigningInput,
   buildPaymentRequest: () => buildPaymentRequest,
   buildReceipt: () => buildReceipt,
   buildRedemption: () => buildRedemption,
@@ -185,6 +185,7 @@ __export(index_exports, {
   computeConsumerClaimEncounterId: () => computeConsumerClaimEncounterId,
   computeEncounterId: () => computeEncounterId,
   constantTimeEqual: () => constantTimeEqual,
+  consumerOacSigningPayload: () => consumerOacSigningPayload,
   consumerPaymentRequestSigningBytes: () => consumerPaymentRequestSigningBytes,
   consumerPaymentRequestSigningPayload: () => consumerPaymentRequestSigningPayload,
   consumerSettlementSigningPayload: () => consumerSettlementSigningPayload,
@@ -205,23 +206,24 @@ __export(index_exports, {
   createPartnerFundingClient: () => createPartnerFundingClient,
   createPartnerProfileAdminClient: () => createPartnerProfileAdminClient,
   createPassesClient: () => createPassesClient,
-  createPayCardArtifactUri: () => createPayCardArtifactUri,
   createReceiptArtifactUri: () => createReceiptArtifactUri,
   createReceiptsClient: () => createReceiptsClient,
   createSoftwareP256Signer: () => createSoftwareP256Signer,
   decodeArtifactUri: () => decodeArtifactUri,
   decodeAuthorizationQR: () => decodeAuthorizationQR,
   decodeBase45: () => decodeBase45,
+  decodeConsumerOacRequest: () => decodeConsumerOacRequest,
   decodeConsumerSettlementReceiptQR: () => decodeConsumerSettlementReceiptQR,
   decodeOfflineClaimSmsMessage: () => decodeOfflineClaimSmsMessage,
   decodeOfflineSmsSettleToken: () => decodeOfflineSmsSettleToken,
-  decodePayCardArtifact: () => decodePayCardArtifact,
   decodePaymentRequestQR: () => decodePaymentRequestQR,
+  decodeUnverifiedConsumerOacQR: () => decodeUnverifiedConsumerOacQR,
   decodeUnverifiedConsumerSettlementReceiptQR: () => decodeUnverifiedConsumerSettlementReceiptQR,
   derToRawP256Signature: () => derToRawP256Signature,
   encodeArtifactUri: () => encodeArtifactUri,
   encodeAuthorizationQR: () => encodeAuthorizationQR,
   encodeBase45: () => encodeBase45,
+  encodeConsumerOacQR: () => encodeConsumerOacQR,
   encodeConsumerSettlementReceiptQR: () => encodeConsumerSettlementReceiptQR,
   encodeNQR: () => encodeNQR,
   encodeOfflineClaimSmsMessage: () => encodeOfflineClaimSmsMessage,
@@ -233,12 +235,11 @@ __export(index_exports, {
   generateDynamicQR: () => generateDynamicQR,
   generateStaticQR: () => generateStaticQR,
   init: () => init,
-  inspectPayCardFreshness: () => inspectPayCardFreshness,
+  isConsumerOacQR: () => isConsumerOacQR,
   isConsumerPaymentRequestExpired: () => isConsumerPaymentRequestExpired,
   isHardenedArtifactType: () => isHardenedArtifactType,
   isKnownArtifactType: () => isKnownArtifactType,
   isPassWithinValidity: () => isPassWithinValidity,
-  isPayCardArtifactUri: () => isPayCardArtifactUri,
   moneyMinorToNumber: () => moneyMinorToNumber,
   normalizeE164: () => normalizeE164,
   parseAmountInput: () => parseAmountInput,
@@ -264,9 +265,9 @@ __export(index_exports, {
   verifyConsumerSettlement: () => verifyConsumerSettlement,
   verifyConsumerSettlementReceiptQR: () => verifyConsumerSettlementReceiptQR,
   verifyOAC: () => verifyOAC,
+  verifyOacOffline: () => verifyOacOffline,
   verifyOfflineSmsSettleToken: () => verifyOfflineSmsSettleToken,
   verifyPass: () => verifyPass,
-  verifyPayCardArtifact: () => verifyPayCardArtifact,
   verifyPaymentRequest: () => verifyPaymentRequest,
   verifyReceipt: () => verifyReceipt,
   verifyRedemption: () => verifyRedemption,
@@ -3238,7 +3239,17 @@ 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("|"), {
   message: "nonce must not contain |"
 });
-var ACCOUNT_FUNDED_OAC_MAX_TTL_MS = 1e3 * 60 * 60 * 24 * 7;
+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 IssuerTrustBundleSchema = import_zod13.z.object({
+  keys: import_zod13.z.array(IssuerTrustKeySchema).min(1)
+});
 var CONSUMER_OFFLINE_CLAIM_SUBMIT_GRACE_MS = 1e3 * 60 * 60 * 24;
 var AttestationSecurityLevelSchema = import_zod13.z.enum([
   "STRONGBOX",
@@ -3292,13 +3303,28 @@ var ConsumerOACSchema = import_zod13.z.object({
   alg: import_zod13.z.literal("p256"),
   /** P-256 SubjectPublicKeyInfo DER, base64. */
   devicePubkeySpkiB64: Base64Std3.min(64).max(4096),
-  perTxCapKobo: import_zod13.z.number().int().positive(),
-  cumulativeCapKobo: import_zod13.z.number().int().positive(),
+  /**
+   * Per-transaction / cumulative offline spend ceilings. Zero is valid and
+   * denotes an identity-only OAC: the credential proves who the holder is and
+   * binds their device key for offline-verifiable first contact, but carries
+   * 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()
+  issuedAtMs: import_zod13.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)
 });
 var SignedConsumerOACSchema = import_zod13.z.object({
   oac: ConsumerOACSchema,
@@ -3466,6 +3492,12 @@ function createMeOfflineClient(opts) {
       `/v1/me/offline/settlements/${encodeURIComponent(idOrKey)}`,
       void 0,
       (raw) => ConsumerSettlementSchema.parse(raw)
+    ),
+    getIssuerKeys: () => call(
+      "GET",
+      "/v1/issuer/keys",
+      void 0,
+      (raw) => IssuerTrustBundleSchema.parse(raw)
     )
   };
 }
@@ -3826,13 +3858,130 @@ function base64UrlDecodeUtf8(input) {
   throw new Error("base64 decoder unavailable");
 }
 
+// src/me-offline/oac.ts
+var import_zod15 = require("zod");
+var CONSUMER_OAC_DOMAIN = "flur:consumer-offline:v1:oac";
+function consumerOacSigningPayload(oac) {
+  return { domain: CONSUMER_OAC_DOMAIN, ...oac };
+}
+function verifyOacOffline(signed, trustedKeys, options = {}) {
+  const parsed = SignedConsumerOACSchema.safeParse(signed);
+  if (!parsed.success) return { ok: false, reason: "malformed" };
+  const oacParsed = ConsumerOACSchema.safeParse(parsed.data.oac);
+  if (!oacParsed.success) return { ok: false, reason: "malformed" };
+  const oac = oacParsed.data;
+  const nowMs = options.nowMs ?? Date.now();
+  const pinned = trustedKeys.filter(
+    (k) => k.issuerId === oac.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(consumerOacSigningPayload(oac));
+  const signatureOk = pinned.some(
+    (k) => verifyIssuerP256(signingBytes, parsed.data.issuerSig, k.publicKeySpkiB64)
+  );
+  if (!signatureOk) return { ok: false, reason: "signature_invalid" };
+  if (oac.validUntilMs - oac.validFromMs > ACCOUNT_FUNDED_OAC_MAX_TTL_MS) {
+    return { ok: false, reason: "window_too_long" };
+  }
+  if (nowMs < oac.validFromMs) return { ok: false, reason: "not_yet_valid" };
+  if (nowMs >= oac.validUntilMs) return { ok: false, reason: "expired" };
+  return {
+    ok: true,
+    oac,
+    identity: {
+      oacId: oac.oacId,
+      issuerId: oac.issuerId,
+      userId: oac.userId,
+      phoneE164: oac.phoneE164,
+      displayName: oac.displayName,
+      devicePubkeySpkiB64: oac.devicePubkeySpkiB64
+    }
+  };
+}
+var CONSUMER_OAC_QR_PREFIX = "FLUROAC1.";
+function isConsumerOacQR(value) {
+  return value.startsWith(CONSUMER_OAC_QR_PREFIX);
+}
+var OacPresentmentRequestSchema = import_zod15.z.object({
+  /** Requested amount in minor units (kobo). */
+  amountMinor: import_zod15.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(),
+  /** Free-text reference / note. */
+  reference: import_zod15.z.string().min(1).max(64).optional()
+}).strict();
+function encodeConsumerOacQR(signed, request) {
+  const parsed = SignedConsumerOACSchema.parse(signed);
+  const base = `${CONSUMER_OAC_QR_PREFIX}${base64UrlEncodeUtf82(JSON.stringify(parsed))}`;
+  if (request === void 0) return base;
+  const parsedRequest = OacPresentmentRequestSchema.parse(request);
+  if (Object.keys(parsedRequest).length === 0) return base;
+  return `${base}.${base64UrlEncodeUtf82(JSON.stringify(parsedRequest))}`;
+}
+function decodeUnverifiedConsumerOacQR(value) {
+  if (!value.startsWith(CONSUMER_OAC_QR_PREFIX)) {
+    throw new Error("not a Flur consumer OAC QR");
+  }
+  const remainder = value.slice(CONSUMER_OAC_QR_PREFIX.length);
+  const encoded = remainder.split(".", 1)[0];
+  let raw;
+  try {
+    raw = JSON.parse(base64UrlDecodeUtf82(encoded));
+  } catch {
+    throw new Error("consumer OAC QR is malformed");
+  }
+  return SignedConsumerOACSchema.parse(raw);
+}
+function decodeConsumerOacRequest(value) {
+  if (!value.startsWith(CONSUMER_OAC_QR_PREFIX)) return null;
+  const remainder = value.slice(CONSUMER_OAC_QR_PREFIX.length);
+  const dot = remainder.indexOf(".");
+  if (dot < 0) return null;
+  const suffix = remainder.slice(dot + 1);
+  if (suffix.length === 0) return null;
+  try {
+    const raw = JSON.parse(base64UrlDecodeUtf82(suffix));
+    const parsed = OacPresentmentRequestSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+function base64UrlEncodeUtf82(input) {
+  const bytes = new TextEncoder().encode(input);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  const base64 = typeof btoa === "function" ? btoa(binary) : typeof Buffer !== "undefined" ? Buffer.from(bytes).toString("base64") : void 0;
+  if (!base64) throw new Error("base64 encoder unavailable");
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function base64UrlDecodeUtf82(input) {
+  const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64.padEnd(
+    base64.length + (4 - base64.length % 4) % 4,
+    "="
+  );
+  if (typeof atob === "function") {
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index++) {
+      bytes[index] = binary.charCodeAt(index);
+    }
+    return new TextDecoder().decode(bytes);
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(padded, "base64").toString("utf8");
+  }
+  throw new Error("base64 decoder unavailable");
+}
+
 // src/me-offline/sms.ts
 var import_nist3 = require("@noble/curves/nist");
 var OFFLINE_CLAIM_SMS_PREFIX = "FLURC1.";
 var CLAIM_TOKEN_RE = /(?:^|\s)(FLURC1\.[A-Za-z0-9_-]+={0,2})(?:\s|$)/;
 function encodeOfflineClaimSmsMessage(claim) {
   const parsed = ConsumerPaymentClaimSchema.parse(claim);
-  return `${OFFLINE_CLAIM_SMS_PREFIX}${base64UrlEncodeUtf82(
+  return `${OFFLINE_CLAIM_SMS_PREFIX}${base64UrlEncodeUtf83(
     JSON.stringify(parsed)
   )}`;
 }
@@ -3842,7 +3991,7 @@ function decodeOfflineClaimSmsMessage(message) {
   const encoded = token.slice(OFFLINE_CLAIM_SMS_PREFIX.length);
   let raw;
   try {
-    raw = JSON.parse(base64UrlDecodeUtf82(encoded));
+    raw = JSON.parse(base64UrlDecodeUtf83(encoded));
   } catch {
     throw new Error("offline claim QR token is malformed");
   }
@@ -4068,10 +4217,10 @@ function bytesToBase64Url(bytes) {
   }
   return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
 }
-function base64UrlEncodeUtf82(input) {
+function base64UrlEncodeUtf83(input) {
   return bytesToBase64Url(utf8(input));
 }
-function base64UrlDecodeUtf82(input) {
+function base64UrlDecodeUtf83(input) {
   return new TextDecoder().decode(base64UrlToBytes(input));
 }
 function base64UrlToBytes(input) {
@@ -4093,14 +4242,14 @@ function base64UrlToBytes(input) {
 }
 
 // src/partner-funding/client.ts
-var import_zod15 = require("zod");
-var MinorString = import_zod15.z.string().regex(/^-?\d+$/);
-var PositiveMinor = import_zod15.z.union([
-  import_zod15.z.number().int().positive(),
-  import_zod15.z.string().regex(/^[1-9]\d{0,18}$/)
+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 Currency = import_zod15.z.string().trim().length(3).transform((v) => v.toUpperCase());
-var Metadata = import_zod15.z.record(import_zod15.z.unknown());
+var Currency = import_zod16.z.string().trim().length(3).transform((v) => v.toUpperCase());
+var Metadata = import_zod16.z.record(import_zod16.z.unknown());
 var PARTNER_KINDS = ["bank", "merchant"];
 var CUSTODIAL_MODES = ["agent_of_bank", "flur_virtual_pool"];
 var PARTNER_PROFILE_STATUSES = [
@@ -4127,126 +4276,126 @@ var WITHDRAWAL_STATES = [
   "failed",
   "reversed"
 ];
-var PartnerProfileSchema = import_zod15.z.object({
-  partnerAccountId: import_zod15.z.string().uuid(),
-  kind: import_zod15.z.enum(PARTNER_KINDS),
-  custodialMode: import_zod15.z.enum(CUSTODIAL_MODES),
-  displayName: import_zod15.z.string(),
-  bankCode: import_zod15.z.string().nullable(),
-  poolAccountNumber: import_zod15.z.string().nullable(),
-  status: import_zod15.z.enum(PARTNER_PROFILE_STATUSES),
+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),
   metadata: Metadata,
-  createdAtMs: import_zod15.z.number().int().nonnegative(),
-  updatedAtMs: import_zod15.z.number().int().nonnegative()
+  createdAtMs: import_zod16.z.number().int().nonnegative(),
+  updatedAtMs: import_zod16.z.number().int().nonnegative()
 });
-var UpsertPartnerProfileInputSchema = import_zod15.z.object({
-  kind: import_zod15.z.enum(PARTNER_KINDS),
-  custodialMode: import_zod15.z.enum(CUSTODIAL_MODES),
-  displayName: import_zod15.z.string().trim().min(1).max(200),
-  bankCode: import_zod15.z.string().trim().min(1).max(64).optional(),
-  poolAccountNumber: import_zod15.z.string().trim().min(1).max(64).optional(),
+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(),
   metadata: Metadata.optional()
 });
-var PartnerFundingEventInputSchema = import_zod15.z.object({
-  externalRef: import_zod15.z.string().trim().min(8).max(128),
-  direction: import_zod15.z.enum(PARTNER_FUNDING_DIRECTIONS).optional(),
-  userId: import_zod15.z.string().uuid().optional(),
-  accountId: import_zod15.z.string().uuid().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(),
   amountMinor: PositiveMinor,
   currency: Currency,
-  fundingSource: import_zod15.z.string().trim().min(1).max(64).optional(),
+  fundingSource: import_zod16.z.string().trim().min(1).max(64).optional(),
   providerMetadata: Metadata.optional()
 });
-var PartnerFundingSchema = import_zod15.z.object({
-  fundingId: import_zod15.z.string().uuid(),
-  partnerId: import_zod15.z.string().uuid(),
-  accountId: import_zod15.z.string().uuid(),
-  userId: import_zod15.z.string().uuid().nullable(),
-  direction: import_zod15.z.enum(PARTNER_FUNDING_DIRECTIONS),
-  currency: import_zod15.z.string(),
+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(),
   amountMinor: MinorString,
-  externalRef: import_zod15.z.string(),
-  status: import_zod15.z.enum(PARTNER_FUNDING_STATUSES),
-  fundingSource: import_zod15.z.string(),
-  ledgerRef: import_zod15.z.string(),
+  externalRef: import_zod16.z.string(),
+  status: import_zod16.z.enum(PARTNER_FUNDING_STATUSES),
+  fundingSource: import_zod16.z.string(),
+  ledgerRef: import_zod16.z.string(),
   providerMetadata: Metadata,
-  createdAtMs: import_zod15.z.number().int().nonnegative(),
-  updatedAtMs: import_zod15.z.number().int().nonnegative()
+  createdAtMs: import_zod16.z.number().int().nonnegative(),
+  updatedAtMs: import_zod16.z.number().int().nonnegative()
 });
-var IngestFundingResultSchema = import_zod15.z.object({
+var IngestFundingResultSchema = import_zod16.z.object({
   funding: PartnerFundingSchema,
-  replayed: import_zod15.z.boolean()
+  replayed: import_zod16.z.boolean()
 });
-var PayoutDestinationSchema = import_zod15.z.object({
-  destinationId: import_zod15.z.string().uuid(),
-  accountId: import_zod15.z.string().uuid(),
-  partnerId: import_zod15.z.string().uuid(),
-  bankCode: import_zod15.z.string(),
-  accountNumber: import_zod15.z.string(),
-  accountName: import_zod15.z.string(),
-  status: import_zod15.z.enum(PAYOUT_DESTINATION_STATUSES),
-  verifiedAtMs: import_zod15.z.number().int().nonnegative().nullable(),
+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(),
   metadata: Metadata,
-  createdAtMs: import_zod15.z.number().int().nonnegative(),
-  updatedAtMs: import_zod15.z.number().int().nonnegative()
+  createdAtMs: import_zod16.z.number().int().nonnegative(),
+  updatedAtMs: import_zod16.z.number().int().nonnegative()
 });
-var CreatePayoutDestinationInputSchema = import_zod15.z.object({
-  partnerId: import_zod15.z.string().uuid(),
-  bankCode: import_zod15.z.string().trim().min(1).max(32),
-  accountNumber: import_zod15.z.string().trim().min(4).max(64),
-  accountName: import_zod15.z.string().trim().min(1).max(200),
+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),
   metadata: Metadata.optional()
 });
-var ListPayoutDestinationsResultSchema = import_zod15.z.object({
-  items: import_zod15.z.array(PayoutDestinationSchema)
+var ListPayoutDestinationsResultSchema = import_zod16.z.object({
+  items: import_zod16.z.array(PayoutDestinationSchema)
 });
-var WithdrawalSchema = import_zod15.z.object({
-  withdrawalId: import_zod15.z.string().uuid(),
-  accountId: import_zod15.z.string().uuid(),
-  userId: import_zod15.z.string().uuid(),
-  partnerId: import_zod15.z.string().uuid(),
-  destinationId: import_zod15.z.string().uuid(),
-  currency: import_zod15.z.string(),
+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(),
   amountMinor: MinorString,
-  state: import_zod15.z.enum(WITHDRAWAL_STATES),
-  idempotencyKey: import_zod15.z.string(),
-  providerRef: import_zod15.z.string().nullable(),
-  lastError: import_zod15.z.string().nullable(),
-  ledgerRef: import_zod15.z.string(),
-  reverseLedgerRef: import_zod15.z.string().nullable(),
+  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(),
   metadata: Metadata,
-  createdAtMs: import_zod15.z.number().int().nonnegative(),
-  updatedAtMs: import_zod15.z.number().int().nonnegative()
+  createdAtMs: import_zod16.z.number().int().nonnegative(),
+  updatedAtMs: import_zod16.z.number().int().nonnegative()
 });
-var CreateWithdrawalInputSchema = import_zod15.z.object({
-  destinationId: import_zod15.z.string().uuid(),
+var CreateWithdrawalInputSchema = import_zod16.z.object({
+  destinationId: import_zod16.z.string().uuid(),
   amountMinor: PositiveMinor,
   currency: Currency,
-  idempotencyKey: import_zod15.z.string().trim().min(8).max(128),
+  idempotencyKey: import_zod16.z.string().trim().min(8).max(128),
   metadata: Metadata.optional()
 });
-var CreateWithdrawalResultSchema = import_zod15.z.object({
+var CreateWithdrawalResultSchema = import_zod16.z.object({
   withdrawal: WithdrawalSchema,
-  replayed: import_zod15.z.boolean()
+  replayed: import_zod16.z.boolean()
 });
-var PayoutEventInputSchema = import_zod15.z.object({
-  externalRef: import_zod15.z.string().trim().min(8).max(128),
-  withdrawalId: import_zod15.z.string().uuid().optional(),
-  state: import_zod15.z.enum(["submitted", "processing", "paid", "failed"]),
-  providerRef: import_zod15.z.string().trim().min(1).max(128).optional(),
-  failureCode: import_zod15.z.string().trim().max(64).optional(),
-  failureMessage: import_zod15.z.string().trim().max(512).optional(),
+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(),
   providerMetadata: Metadata.optional()
 });
-var RecordPayoutEventResultSchema = import_zod15.z.object({
+var RecordPayoutEventResultSchema = import_zod16.z.object({
   withdrawal: WithdrawalSchema,
-  replayed: import_zod15.z.boolean()
+  replayed: import_zod16.z.boolean()
 });
-var ReconciliationReportSchema = import_zod15.z.object({
-  partnerId: import_zod15.z.string().uuid(),
-  currency: import_zod15.z.string(),
-  fromMs: import_zod15.z.number().int().nonnegative(),
-  toMs: import_zod15.z.number().int().nonnegative(),
+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(),
   fundingsCreditMinor: MinorString,
   fundingsDebitMinor: MinorString,
   withdrawalsPaidMinor: MinorString,
@@ -4255,7 +4404,7 @@ var ReconciliationReportSchema = import_zod15.z.object({
   expectedReserveBalanceMinor: MinorString,
   actualReserveBalanceMinor: MinorString,
   imbalanceMinor: MinorString,
-  generatedAtMs: import_zod15.z.number().int().nonnegative()
+  generatedAtMs: import_zod16.z.number().int().nonnegative()
 });
 function createPartnerFundingClient(partner) {
   return {
@@ -4407,19 +4556,19 @@ function createPartnerProfileAdminClient(opts) {
 }
 
 // src/artifacts/envelope.ts
-var import_zod16 = require("zod");
+var import_zod17 = 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_zod16.z.object({
-  v: import_zod16.z.literal(FLUR_ARTIFACT_VERSION),
-  t: import_zod16.z.string().regex(ArtifactTypeRe, "invalid artifact type"),
-  iss: import_zod16.z.string().min(1).max(128),
-  kid: import_zod16.z.string().min(1).max(128),
-  iat: import_zod16.z.number().int().nonnegative(),
-  exp: import_zod16.z.number().int().positive().optional(),
-  nonce: import_zod16.z.string().min(8).max(64).regex(/^[A-Za-z0-9_-]+$/, "nonce must be url-safe")
+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 FlurArtifactError = class extends Error {
   constructor(message, code) {
@@ -4558,7 +4707,7 @@ function verifyArtifactSignature(decoded, publicKeySpkiB64, options = {}) {
 }
 
 // src/artifacts/types.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 var ARTIFACT_TYPES = {
   OFFLINE_PAYMENT_AUTHORIZATION: "offline_payment_authorization",
   RECEIPT: "receipt",
@@ -4571,37 +4720,34 @@ var ARTIFACT_TYPES = {
   LEDGER_JOURNAL_ENTRY: "ledger_journal_entry",
   STATEMENT: "statement",
   PASS: "pass",
-  IDENTITY: "identity",
-  // Tier B: holder-signed identity attestation for offline trust. The
-  // envelope.iat / envelope.exp express the card's canonical lifetime.
-  PAY_CARD: "pay_card"
+  IDENTITY: "identity"
 };
-var HexString = (length) => import_zod17.z.string().regex(
+var HexString = (length) => import_zod18.z.string().regex(
   new RegExp(`^[0-9a-fA-F]{${length * 2}}$`),
   `expected ${length}-byte hex string`
 );
-var OfflinePaymentAuthorizationArtifactSchema = import_zod17.z.object({
+var OfflinePaymentAuthorizationArtifactSchema = import_zod18.z.object({
   authorization: OfflinePaymentAuthorizationSchema
 });
-var ReceiptArtifactSchema = import_zod17.z.object({
-  receiptId: import_zod17.z.string().min(1).max(64),
-  paymentReference: import_zod17.z.string().min(1).max(64),
-  payerUserId: import_zod17.z.string().min(1).max(64).optional(),
-  payeeUserId: import_zod17.z.string().min(1).max(64),
-  amountKobo: import_zod17.z.number().int().positive(),
-  currency: import_zod17.z.literal("NGN"),
-  channel: import_zod17.z.enum(["online", "offline_reconciled", "pay_link", "nqr"]),
-  settledAtMs: import_zod17.z.number().int().positive(),
-  ledgerTxnId: import_zod17.z.string().min(1).max(64).optional(),
-  memo: import_zod17.z.string().max(140).optional(),
+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(),
   hashChainPrev: HexString(32).optional()
 });
-var ShortId = import_zod17.z.string().min(1).max(64);
-var PositiveInt = import_zod17.z.number().int().positive();
-var NonNegativeInt = import_zod17.z.number().int().nonnegative();
-var Currency2 = import_zod17.z.literal("NGN");
-var Memo = import_zod17.z.string().max(140);
-var NqrPaymentRequestArtifactSchema = import_zod17.z.object({
+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({
   requestId: ShortId,
   payeeUserId: ShortId,
   amountKobo: PositiveInt.optional(),
@@ -4609,7 +4755,7 @@ var NqrPaymentRequestArtifactSchema = import_zod17.z.object({
   memo: Memo.optional(),
   expiresAtMs: PositiveInt.optional()
 });
-var PaymentIntentArtifactSchema = import_zod17.z.object({
+var PaymentIntentArtifactSchema = import_zod18.z.object({
   intentId: ShortId,
   payerUserId: ShortId,
   payeeUserId: ShortId,
@@ -4618,7 +4764,7 @@ var PaymentIntentArtifactSchema = import_zod17.z.object({
   idempotencyKey: ShortId,
   createdAtMs: PositiveInt
 });
-var OfflineClaimArtifactSchema = import_zod17.z.object({
+var OfflineClaimArtifactSchema = import_zod18.z.object({
   claimId: ShortId,
   authorizationId: ShortId,
   payeeUserId: ShortId,
@@ -4627,10 +4773,10 @@ var OfflineClaimArtifactSchema = import_zod17.z.object({
   claimedAtMs: PositiveInt,
   paymentReference: ShortId.optional()
 });
-var SettlementRecordArtifactSchema = import_zod17.z.object({
+var SettlementRecordArtifactSchema = import_zod18.z.object({
   settlementId: ShortId,
   ledgerTxnId: ShortId,
-  sourceRefType: import_zod17.z.enum([
+  sourceRefType: import_zod18.z.enum([
     "offline_authorization",
     "offline_claim",
     "transfer",
@@ -4641,12 +4787,12 @@ var SettlementRecordArtifactSchema = import_zod17.z.object({
   currency: Currency2,
   settledAtMs: PositiveInt
 });
-var ReversalRecordArtifactSchema = import_zod17.z.object({
+var ReversalRecordArtifactSchema = import_zod18.z.object({
   reversalId: ShortId,
   originalTxnId: ShortId,
   amountKobo: PositiveInt,
   currency: Currency2,
-  reason: import_zod17.z.enum([
+  reason: import_zod18.z.enum([
     "user_dispute",
     "fraud",
     "duplicate",
@@ -4656,7 +4802,7 @@ var ReversalRecordArtifactSchema = import_zod17.z.object({
   reversedAtMs: PositiveInt,
   memo: Memo.optional()
 });
-var LedgerJournalEntryArtifactSchema = import_zod17.z.object({
+var LedgerJournalEntryArtifactSchema = import_zod18.z.object({
   entryId: ShortId,
   journalId: ShortId,
   debitAccountId: ShortId,
@@ -4667,13 +4813,13 @@ var LedgerJournalEntryArtifactSchema = import_zod17.z.object({
   refType: ShortId.optional(),
   refId: ShortId.optional()
 });
-var StatementArtifactSchema = import_zod17.z.object({
+var StatementArtifactSchema = import_zod18.z.object({
   statementId: ShortId,
   userId: ShortId,
   periodStartMs: PositiveInt,
   periodEndMs: PositiveInt,
-  openingBalanceKobo: import_zod17.z.number().int(),
-  closingBalanceKobo: import_zod17.z.number().int(),
+  openingBalanceKobo: import_zod18.z.number().int(),
+  closingBalanceKobo: import_zod18.z.number().int(),
   transactionCount: NonNegativeInt,
   currency: Currency2,
   hashChainPrev: HexString(32).optional()
@@ -4681,16 +4827,16 @@ var StatementArtifactSchema = import_zod17.z.object({
   message: "periodEndMs must be greater than periodStartMs",
   path: ["periodEndMs"]
 });
-var PassArtifactSchema = import_zod17.z.object({
+var PassArtifactSchema = import_zod18.z.object({
   passId: ShortId,
   holderId: ShortId,
-  category: import_zod17.z.enum(["membership", "ticket", "loyalty", "access", "voucher"]),
-  title: import_zod17.z.string().min(1).max(120),
+  category: import_zod18.z.enum(["membership", "ticket", "loyalty", "access", "voucher"]),
+  title: import_zod18.z.string().min(1).max(120),
   validFromMs: PositiveInt,
   validUntilMs: PositiveInt.optional(),
-  metadata: import_zod17.z.record(
-    import_zod17.z.string().min(1).max(64),
-    import_zod17.z.union([import_zod17.z.string().max(280), import_zod17.z.number(), import_zod17.z.boolean()])
+  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()])
   ).optional()
 }).refine(
   (v) => v.validUntilMs === void 0 || v.validUntilMs > v.validFromMs,
@@ -4699,10 +4845,10 @@ var PassArtifactSchema = import_zod17.z.object({
     path: ["validUntilMs"]
   }
 );
-var IdentityArtifactSchema = import_zod17.z.object({
+var IdentityArtifactSchema = import_zod18.z.object({
   attestationId: ShortId,
   subjectId: ShortId,
-  claimType: import_zod17.z.enum([
+  claimType: import_zod18.z.enum([
     "phone_verified",
     "email_verified",
     "bvn_verified",
@@ -4712,12 +4858,6 @@ var IdentityArtifactSchema = import_zod17.z.object({
   claimValueHash: HexString(32),
   attestedAtMs: PositiveInt
 });
-var PayCardArtifactSchema = import_zod17.z.object({
-  userId: ShortId,
-  phoneE164: import_zod17.z.string().regex(/^\+[1-9]\d{7,14}$/, "phoneE164 must be normalised E.164"),
-  displayName: import_zod17.z.string().min(1).max(64),
-  devicePubKeySpkiB64: import_zod17.z.string().min(64).max(256).regex(/^[A-Za-z0-9+/]+=*$/, "devicePubKeySpkiB64 must be standard base64")
-});
 var ARTIFACT_BODY_SCHEMAS = {
   [ARTIFACT_TYPES.OFFLINE_PAYMENT_AUTHORIZATION]: OfflinePaymentAuthorizationArtifactSchema,
   [ARTIFACT_TYPES.RECEIPT]: ReceiptArtifactSchema,
@@ -4729,8 +4869,7 @@ var ARTIFACT_BODY_SCHEMAS = {
   [ARTIFACT_TYPES.LEDGER_JOURNAL_ENTRY]: LedgerJournalEntryArtifactSchema,
   [ARTIFACT_TYPES.STATEMENT]: StatementArtifactSchema,
   [ARTIFACT_TYPES.PASS]: PassArtifactSchema,
-  [ARTIFACT_TYPES.IDENTITY]: IdentityArtifactSchema,
-  [ARTIFACT_TYPES.PAY_CARD]: PayCardArtifactSchema
+  [ARTIFACT_TYPES.IDENTITY]: IdentityArtifactSchema
 };
 var HARDENED_ARTIFACT_TYPES = /* @__PURE__ */ new Set([
   ARTIFACT_TYPES.OFFLINE_PAYMENT_AUTHORIZATION,
@@ -4743,8 +4882,7 @@ var HARDENED_ARTIFACT_TYPES = /* @__PURE__ */ new Set([
   ARTIFACT_TYPES.LEDGER_JOURNAL_ENTRY,
   ARTIFACT_TYPES.STATEMENT,
   ARTIFACT_TYPES.PASS,
-  ARTIFACT_TYPES.IDENTITY,
-  ARTIFACT_TYPES.PAY_CARD
+  ARTIFACT_TYPES.IDENTITY
 ]);
 function isKnownArtifactType(t) {
   return Object.values(ARTIFACT_TYPES).includes(t);
@@ -4829,130 +4967,6 @@ function createOfflinePaymentAuthorizationArtifactUri(input) {
     type: ARTIFACT_TYPES.OFFLINE_PAYMENT_AUTHORIZATION
   });
 }
-
-// src/artifacts/paycard.ts
-var PAY_CARD_DEFAULT_TTL_MS = 90 * 24 * 60 * 60 * 1e3;
-var PAY_CARD_REFRESH_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1e3;
-var PAY_CARD_URI_PREFIX = `${FLUR_ARTIFACT_URI_PREFIX}${ARTIFACT_TYPES.PAY_CARD}/`;
-function createPayCardArtifactUri(input) {
-  if (input.data.userId !== input.issuer) {
-    throw new FlurArtifactError(
-      "pay_card.data.userId must equal envelope issuer",
-      "INVALID_BODY"
-    );
-  }
-  const iat = input.issuedAtSeconds ?? Math.floor(Date.now() / 1e3);
-  const exp = input.expiresAtSeconds ?? iat + Math.floor(PAY_CARD_DEFAULT_TTL_MS / 1e3);
-  return createArtifactUri({
-    type: ARTIFACT_TYPES.PAY_CARD,
-    issuer: input.issuer,
-    keyId: input.keyId,
-    privateKey: input.privateKey,
-    nonce: input.nonce,
-    issuedAtSeconds: iat,
-    expiresAtSeconds: exp,
-    data: input.data
-  });
-}
-function isPayCardArtifactUri(uri) {
-  return typeof uri === "string" && uri.startsWith(PAY_CARD_URI_PREFIX);
-}
-function decodePayCardArtifact(uri) {
-  if (!isPayCardArtifactUri(uri)) {
-    throw new FlurArtifactError(
-      `URI does not start with ${PAY_CARD_URI_PREFIX}`,
-      "INVALID_URI"
-    );
-  }
-  const decoded = decodeArtifactUri(uri);
-  if (decoded.type !== ARTIFACT_TYPES.PAY_CARD) {
-    throw new FlurArtifactError(
-      `Expected pay_card, got ${decoded.type}`,
-      "TYPE_MISMATCH"
-    );
-  }
-  const parsed = PayCardArtifactSchema.safeParse(decoded.body.data);
-  if (!parsed.success) {
-    throw new FlurArtifactError(
-      `pay_card body invalid: ${parsed.error.message}`,
-      "INVALID_BODY"
-    );
-  }
-  if (parsed.data.userId !== decoded.body.iss) {
-    throw new FlurArtifactError(
-      "pay_card.data.userId must equal envelope issuer",
-      "INVALID_BODY"
-    );
-  }
-  return {
-    body: {
-      ...decoded.body,
-      data: parsed.data
-    },
-    sig: decoded.sig,
-    decoded
-  };
-}
-function verifyPayCardArtifact(uri, publicKeySpkiB64, options = {}) {
-  if (!isPayCardArtifactUri(uri)) {
-    throw new FlurArtifactError(
-      `URI does not start with ${PAY_CARD_URI_PREFIX}`,
-      "INVALID_URI"
-    );
-  }
-  const verified = verifyArtifactUri(
-    uri,
-    publicKeySpkiB64,
-    options
-  );
-  if (verified.decoded.type !== ARTIFACT_TYPES.PAY_CARD) {
-    throw new FlurArtifactError(
-      `Expected pay_card, got ${verified.decoded.type}`,
-      "TYPE_MISMATCH"
-    );
-  }
-  if (verified.body.data.userId !== verified.body.iss) {
-    throw new FlurArtifactError(
-      "pay_card.data.userId must equal envelope issuer",
-      "INVALID_BODY"
-    );
-  }
-  return {
-    body: verified.body,
-    sig: verified.sig,
-    decoded: verified.decoded
-  };
-}
-function inspectPayCardFreshness(decoded, nowMs = Date.now()) {
-  const exp = decoded.body.exp;
-  if (exp === void 0) return "no_expiry";
-  const remainingMs = exp * 1e3 - nowMs;
-  if (remainingMs <= 0) return "expired";
-  if (remainingMs <= PAY_CARD_REFRESH_THRESHOLD_MS)
-    return "refresh_recommended";
-  return "fresh";
-}
-function buildPayCardSigningInput(input) {
-  if (input.data.userId !== input.issuer) {
-    throw new FlurArtifactError(
-      "pay_card.data.userId must equal envelope issuer",
-      "INVALID_BODY"
-    );
-  }
-  const parsedData = PayCardArtifactSchema.parse(input.data);
-  const iat = input.issuedAtSeconds ?? Math.floor(Date.now() / 1e3);
-  const exp = input.expiresAtSeconds ?? iat + Math.floor(PAY_CARD_DEFAULT_TTL_MS / 1e3);
-  const body = buildArtifactBody({
-    type: ARTIFACT_TYPES.PAY_CARD,
-    issuer: input.issuer,
-    keyId: input.keyId,
-    data: parsedData,
-    nonce: input.nonce,
-    issuedAtSeconds: iat,
-    expiresAtSeconds: exp
-  });
-  return { body, bodyBytes: canonicalJSONBytes(body) };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCOUNT_FUNDED_OAC_MAX_TTL_MS,
@@ -4969,6 +4983,8 @@ function buildPayCardSigningInput(input) {
   CLAIM_DOMAIN_V2,
   COLLECTION_INTENT_STATUSES,
   COLLECTION_PAYMENT_STATUSES,
+  CONSUMER_OAC_DOMAIN,
+  CONSUMER_OAC_QR_PREFIX,
   CONSUMER_OFFLINE_CLAIM_SUBMIT_GRACE_MS,
   CONSUMER_PAYMENT_REQUEST_DOMAIN,
   CONSUMER_SETTLEMENT_DOMAIN,
@@ -5007,6 +5023,8 @@ function buildPayCardSigningInput(input) {
   IdentityArtifactSchema,
   IngestFundingResultSchema,
   IssueAccountOacInputSchema,
+  IssuerTrustBundleSchema,
+  IssuerTrustKeySchema,
   LedgerJournalEntryArtifactSchema,
   ListPayoutDestinationsResultSchema,
   MEMBERSHIP_ROLES,
@@ -5030,6 +5048,7 @@ function buildPayCardSigningInput(input) {
   OFFLINE_SMS_SETTLE_SIGNATURE_BYTES,
   OFFLINE_SMS_SETTLE_TOKEN_BYTES,
   OFFLINE_SMS_SETTLE_VERSION,
+  OacPresentmentRequestSchema,
   OfflineClaimArtifactSchema,
   OfflinePaymentAuthorizationArtifactSchema,
   OfflinePaymentAuthorizationSchema,
@@ -5047,9 +5066,6 @@ function buildPayCardSigningInput(input) {
   PASS_STATES,
   PAYLOAD_FORMAT_INDICATOR_VALUE,
   PAYOUT_DESTINATION_STATUSES,
-  PAY_CARD_DEFAULT_TTL_MS,
-  PAY_CARD_REFRESH_THRESHOLD_MS,
-  PAY_CARD_URI_PREFIX,
   POINT_OF_INITIATION,
   PartnerFundingEventInputSchema,
   PartnerFundingSchema,
@@ -5057,7 +5073,6 @@ function buildPayCardSigningInput(input) {
   PassArtifactSchema,
   PassMetadataSchema,
   PassSchema,
-  PayCardArtifactSchema,
   PayCollectionInputSchema,
   PaymentClaimSchema,
   PaymentIntentArtifactSchema,
@@ -5096,7 +5111,6 @@ function buildPayCardSigningInput(input) {
   buildConsumerPaymentRequest,
   buildOAC,
   buildPass,
-  buildPayCardSigningInput,
   buildPaymentRequest,
   buildReceipt,
   buildRedemption,
@@ -5110,6 +5124,7 @@ function buildPayCardSigningInput(input) {
   computeConsumerClaimEncounterId,
   computeEncounterId,
   constantTimeEqual,
+  consumerOacSigningPayload,
   consumerPaymentRequestSigningBytes,
   consumerPaymentRequestSigningPayload,
   consumerSettlementSigningPayload,
@@ -5130,23 +5145,24 @@ function buildPayCardSigningInput(input) {
   createPartnerFundingClient,
   createPartnerProfileAdminClient,
   createPassesClient,
-  createPayCardArtifactUri,
   createReceiptArtifactUri,
   createReceiptsClient,
   createSoftwareP256Signer,
   decodeArtifactUri,
   decodeAuthorizationQR,
   decodeBase45,
+  decodeConsumerOacRequest,
   decodeConsumerSettlementReceiptQR,
   decodeOfflineClaimSmsMessage,
   decodeOfflineSmsSettleToken,
-  decodePayCardArtifact,
   decodePaymentRequestQR,
+  decodeUnverifiedConsumerOacQR,
   decodeUnverifiedConsumerSettlementReceiptQR,
   derToRawP256Signature,
   encodeArtifactUri,
   encodeAuthorizationQR,
   encodeBase45,
+  encodeConsumerOacQR,
   encodeConsumerSettlementReceiptQR,
   encodeNQR,
   encodeOfflineClaimSmsMessage,
@@ -5158,12 +5174,11 @@ function buildPayCardSigningInput(input) {
   generateDynamicQR,
   generateStaticQR,
   init,
-  inspectPayCardFreshness,
+  isConsumerOacQR,
   isConsumerPaymentRequestExpired,
   isHardenedArtifactType,
   isKnownArtifactType,
   isPassWithinValidity,
-  isPayCardArtifactUri,
   moneyMinorToNumber,
   normalizeE164,
   parseAmountInput,
@@ -5189,9 +5204,9 @@ function buildPayCardSigningInput(input) {
   verifyConsumerSettlement,
   verifyConsumerSettlementReceiptQR,
   verifyOAC,
+  verifyOacOffline,
   verifyOfflineSmsSettleToken,
   verifyPass,
-  verifyPayCardArtifact,
   verifyPaymentRequest,
   verifyReceipt,
   verifyRedemption,