@nokinc-flur/sdk 1.0.4 → 1.0.5

package/dist/index.cjs

@@ -26,6 +26,16 @@ __export(index_exports, {
   AccountMembershipSchema: () => AccountMembershipSchema,
   AccountSchema: () => AccountSchema,
   ApiCredentialPublicSchema: () => ApiCredentialPublicSchema,
+  ConsumerOACRecordSchema: () => OACRecordSchema,
+  ConsumerOACSchema: () => ConsumerOACSchema,
+  ConsumerPaymentClaimSchema: () => ConsumerPaymentClaimSchema,
+  ConsumerSettleResultSchema: () => ConsumerSettleResultSchema,
+  ConsumerSettlementSchema: () => ConsumerSettlementSchema,
+  DeviceKeyRecordSchema: () => DeviceKeyRecordSchema,
+  DisableOfflineInputSchema: () => DisableOfflineInputSchema,
+  DisableOfflineResultSchema: () => DisableOfflineResultSchema,
+  EnableOfflineInputSchema: () => EnableOfflineInputSchema,
+  EnableOfflineResultSchema: () => EnableOfflineResultSchema,
   FIELD: () => FIELD,
   FlurApiError: () => FlurApiError,
   FlurCapExceededError: () => FlurCapExceededError,
@@ -33,6 +43,7 @@ __export(index_exports, {
   FlurError: () => FlurError,
   FlurExpiredError: () => FlurExpiredError,
   FlurReplayError: () => FlurReplayError,
+  IssueOACInputSchema: () => IssueOACInputSchema,
   MEMBERSHIP_ROLES: () => MEMBERSHIP_ROLES,
   MintedApiCredentialSchema: () => MintedApiCredentialSchema,
   NGN_CURRENCY_CODE: () => NGN_CURRENCY_CODE,
@@ -42,8 +53,11 @@ __export(index_exports, {
   OAC_DEFAULT_CUMULATIVE_KOBO: () => OAC_DEFAULT_CUMULATIVE_KOBO,
   OAC_DEFAULT_PER_TX_KOBO: () => OAC_DEFAULT_PER_TX_KOBO,
   OAC_DEFAULT_VALIDITY_MS: () => OAC_DEFAULT_VALIDITY_MS,
+  OfflineHoldRecordSchema: () => OfflineHoldRecordSchema,
   OfflinePaymentAuthorizationSchema: () => OfflinePaymentAuthorizationSchema,
   OfflinePaymentRequestSchema: () => OfflinePaymentRequestSchema,
+  OfflineStateResultSchema: () => OfflineStateResultSchema,
+  OfflineStatusResultSchema: () => OfflineStatusResultSchema,
   OfflineTokenSchema: () => OfflineTokenSchema,
   PARTNER_SCOPES: () => PARTNER_SCOPES,
   PASS_KINDS: () => PASS_KINDS,
@@ -59,8 +73,11 @@ __export(index_exports, {
   ReceiptPayloadSchema: () => ReceiptPayloadSchema,
   ReceiptSchema: () => ReceiptSchema,
   RedemptionSchema: () => RedemptionSchema,
+  RegisterDeviceKeyInputSchema: () => RegisterDeviceKeyInputSchema,
+  RevokeDeviceKeyInputSchema: () => RevokeDeviceKeyInputSchema,
   SettleResponseSchema: () => SettleResponseSchema,
   SettlementSchema: () => SettlementSchema,
+  SignedConsumerOACSchema: () => SignedConsumerOACSchema,
   bodySha256Hex: () => bodySha256Hex,
   buildAuthorization: () => buildAuthorization,
   buildOAC: () => buildOAC,
@@ -79,6 +96,7 @@ __export(index_exports, {
   createApiCredentialsAdminClient: () => createApiCredentialsAdminClient,
   createFlurPartnerClient: () => createFlurPartnerClient,
   createHmacFetch: () => createHmacFetch,
+  createMeOfflineClient: () => createMeOfflineClient,
   createOfflineSettlementsClient: () => createOfflineSettlementsClient,
   createPassesClient: () => createPassesClient,
   createReceiptsClient: () => createReceiptsClient,
@@ -169,7 +187,9 @@ var OnboardingCompleteResponseSchema = import_zod.z.object({
   sessionToken: import_zod.z.string().min(1),
   userId: UuidSchema,
   restricted: import_zod.z.boolean(),
-  risk_reasons: import_zod.z.array(import_zod.z.enum(["SIM_SWAP_RECENT", "ROAMING", "CARRIER_CHANGED"])),
+  risk_reasons: import_zod.z.array(
+    import_zod.z.enum(["SIM_SWAP_RECENT", "ROAMING", "CARRIER_CHANGED"])
+  ),
   stepUpRequired: import_zod.z.boolean().optional(),
   riskStatus: import_zod.z.enum(["ok", "unavailable"]).optional()
 });
@@ -222,9 +242,11 @@ var RegisterSendDeviceKeyRequestSchema = import_zod.z.object({
   deviceId: import_zod.z.string().min(3),
   publicKey: import_zod.z.string().min(32)
 });
+var SEND_AUTH_PURPOSES = ["send_money", "offline_revoke"];
 var SendChallengeRequestSchema = import_zod.z.object({
   userId: UuidSchema,
-  deviceId: import_zod.z.string().min(3)
+  deviceId: import_zod.z.string().min(3),
+  purpose: import_zod.z.enum(SEND_AUTH_PURPOSES).optional()
 });
 var SendChallengeResponseSchema = import_zod.z.object({
   challengeId: UuidSchema,
@@ -524,10 +546,20 @@ var FlurClient = class {
     this.getExtraHeaders = opts.getExtraHeaders;
   }
   async health() {
-    return this.requestJson("/health", { method: "GET" }, void 0, HealthResponseSchema);
+    return this.requestJson(
+      "/health",
+      { method: "GET" },
+      void 0,
+      HealthResponseSchema
+    );
   }
   async welcome() {
-    return this.requestJson("/welcome", { method: "GET" }, void 0, WelcomeResponseSchema);
+    return this.requestJson(
+      "/welcome",
+      { method: "GET" },
+      void 0,
+      WelcomeResponseSchema
+    );
   }
   async onboardingStart(input) {
     return this.requestJson(
@@ -672,24 +704,33 @@ var FlurClient = class {
   }
   async registerBiometricDeviceKey(input) {
     const publicKey = await input.signer.getOrCreateKeyPair(input.deviceId);
-    return this.registerSendDeviceKey({
-      userId: input.userId,
-      deviceId: input.deviceId,
-      publicKey
-    }, { accessToken: input.accessToken });
+    return this.registerSendDeviceKey(
+      {
+        userId: input.userId,
+        deviceId: input.deviceId,
+        publicKey
+      },
+      { accessToken: input.accessToken }
+    );
   }
   async authorizeSendWithBiometric(input) {
-    const challenge = await this.createSendChallenge({
-      userId: input.userId,
-      deviceId: input.deviceId
-    }, { accessToken: input.accessToken });
+    const challenge = await this.createSendChallenge(
+      {
+        userId: input.userId,
+        deviceId: input.deviceId
+      },
+      { accessToken: input.accessToken }
+    );
     const signature = await input.signer.sign(challenge.nonce);
-    return this.verifySendChallenge({
-      userId: input.userId,
-      deviceId: input.deviceId,
-      challengeId: challenge.challengeId,
-      signature
-    }, { accessToken: input.accessToken });
+    return this.verifySendChallenge(
+      {
+        userId: input.userId,
+        deviceId: input.deviceId,
+        challengeId: challenge.challengeId,
+        signature
+      },
+      { accessToken: input.accessToken }
+    );
   }
   async resolveRecipient(input, options) {
     return this.requestJson(
@@ -854,7 +895,12 @@ var FlurClient = class {
         ...init2.headers,
         ...extraHeaders
       };
-      const res = await this.fetchImpl(url, { ...init2, headers: finalHeaders, body, signal: controller.signal });
+      const res = await this.fetchImpl(url, {
+        ...init2,
+        headers: finalHeaders,
+        body,
+        signal: controller.signal
+      });
       if (!res.ok) throw await mapToFlurError(res);
       const payload = await res.json();
       if (!responseSchema) return payload;
@@ -862,9 +908,13 @@ var FlurClient = class {
         return responseSchema.parse(payload);
       } catch (err) {
         if (err instanceof import_zod3.z.ZodError) {
-          throw new FlurError("SDK contract validation failed", "INVALID_REQUEST", {
-            details: err.flatten()
-          });
+          throw new FlurError(
+            "SDK contract validation failed",
+            "INVALID_REQUEST",
+            {
+              details: err.flatten()
+            }
+          );
         }
         throw err;
       }
@@ -873,7 +923,9 @@ var FlurClient = class {
         throw new FlurError("Request timed out", "TIMEOUT");
       }
       if (err instanceof FlurError) throw err;
-      throw new FlurError("Network error", "NETWORK_ERROR", { details: String(err) });
+      throw new FlurError("Network error", "NETWORK_ERROR", {
+        details: String(err)
+      });
     } finally {
       clearTimeout(t);
     }
@@ -883,7 +935,10 @@ function getSecureRandomUuid() {
   if (typeof globalThis.crypto?.randomUUID === "function") {
     return globalThis.crypto.randomUUID();
   }
-  throw new FlurError("Secure UUID generator unavailable; provide idempotencyKey", "INVALID_REQUEST");
+  throw new FlurError(
+    "Secure UUID generator unavailable; provide idempotencyKey",
+    "INVALID_REQUEST"
+  );
 }
 
 // src/nqr/fields.ts
@@ -2634,6 +2689,260 @@ function createApiCredentialsAdminClient(opts) {
     )
   };
 }
+
+// src/me-offline/client.ts
+var import_zod12 = require("zod");
+var Hex64 = import_zod12.z.string().regex(/^[0-9a-f]{64}$/i);
+var HexAny = import_zod12.z.string().regex(/^[0-9a-f]+$/i);
+var Sha256Hex = import_zod12.z.string().regex(/^[0-9a-f]{64}$/i);
+var RegisterDeviceKeyInputSchema = import_zod12.z.object({
+  deviceId: import_zod12.z.string().min(1).max(128),
+  publicKeyHex: Hex64
+});
+var DeviceKeyRecordSchema = import_zod12.z.object({
+  id: import_zod12.z.string().uuid(),
+  userId: import_zod12.z.string().uuid(),
+  deviceId: import_zod12.z.string(),
+  publicKeyHex: Hex64,
+  createdAtMs: import_zod12.z.number().int().nonnegative(),
+  revokedAtMs: import_zod12.z.number().int().nonnegative().nullable()
+});
+var ConsumerOACSchema = import_zod12.z.object({
+  oacId: import_zod12.z.string().uuid(),
+  issuerId: import_zod12.z.string().min(1).max(64),
+  userId: import_zod12.z.string().uuid(),
+  deviceId: import_zod12.z.string().min(1).max(128),
+  devicePubkeyHex: Hex64,
+  perTxCapKobo: import_zod12.z.number().int().positive(),
+  cumulativeCapKobo: import_zod12.z.number().int().positive(),
+  currency: import_zod12.z.string().length(3),
+  validFromMs: import_zod12.z.number().int().nonnegative(),
+  validUntilMs: import_zod12.z.number().int().nonnegative(),
+  counterSeed: import_zod12.z.number().int().nonnegative(),
+  issuedAtMs: import_zod12.z.number().int().nonnegative()
+});
+var SignedConsumerOACSchema = import_zod12.z.object({
+  oac: ConsumerOACSchema,
+  issuerSig: HexAny,
+  issuerPublicKeyHex: Hex64
+});
+var OACRecordSchema = SignedConsumerOACSchema.extend({
+  currentOfflineSpentKobo: import_zod12.z.number().int().nonnegative(),
+  status: import_zod12.z.enum([
+    "active",
+    "superseded",
+    "expired",
+    "revoked",
+    "disabling",
+    "draining",
+    "closed"
+  ]),
+  supersededAtMs: import_zod12.z.number().int().nonnegative().nullable(),
+  revokedAtMs: import_zod12.z.number().int().nonnegative().nullable(),
+  holdId: import_zod12.z.string().uuid().nullable().optional()
+});
+var IssueOACInputSchema = import_zod12.z.object({
+  deviceId: import_zod12.z.string().min(1).max(128),
+  perTxCapKobo: import_zod12.z.number().int().positive().optional(),
+  cumulativeCapKobo: import_zod12.z.number().int().positive().optional(),
+  ttlMs: import_zod12.z.number().int().min(6e4).max(1e3 * 60 * 60 * 24 * 7).optional(),
+  spendableOnlineKobo: import_zod12.z.number().int().nonnegative().optional()
+});
+var EnableOfflineInputSchema = import_zod12.z.object({
+  deviceId: import_zod12.z.string().min(1).max(128),
+  amountKobo: import_zod12.z.number().int().positive(),
+  perTxCapKobo: import_zod12.z.number().int().positive().optional(),
+  ttlMs: import_zod12.z.number().int().min(6e4).max(1e3 * 60 * 60 * 24 * 7).optional(),
+  installId: import_zod12.z.string().min(1).max(128),
+  partnerId: import_zod12.z.string().min(1).max(64).optional()
+});
+var DisableOfflineInputSchema = import_zod12.z.object({
+  deviceId: import_zod12.z.string().min(1).max(128),
+  installId: import_zod12.z.string().min(1).max(128).optional(),
+  claims: import_zod12.z.array(import_zod12.z.unknown()).max(256).optional()
+});
+var OfflineHoldRecordSchema = import_zod12.z.object({
+  holdId: import_zod12.z.string().uuid(),
+  userId: import_zod12.z.string().uuid(),
+  deviceId: import_zod12.z.string(),
+  partnerId: import_zod12.z.string(),
+  adapterKind: import_zod12.z.string(),
+  externalHoldRef: import_zod12.z.string().nullable(),
+  amountKobo: import_zod12.z.number().int().nonnegative(),
+  capturedKobo: import_zod12.z.number().int().nonnegative(),
+  releasedKobo: import_zod12.z.number().int().nonnegative(),
+  remainingKobo: import_zod12.z.number().int().nonnegative(),
+  currency: import_zod12.z.string().length(3),
+  status: import_zod12.z.enum([
+    "placing",
+    "active",
+    "disabling",
+    "draining",
+    "closed",
+    "revoked",
+    "failed"
+  ]),
+  installId: import_zod12.z.string().nullable(),
+  drainDeadlineMs: import_zod12.z.number().int().nonnegative(),
+  disableRequestedAtMs: import_zod12.z.number().int().nonnegative().nullable(),
+  createdAtMs: import_zod12.z.number().int().nonnegative(),
+  closedAtMs: import_zod12.z.number().int().nonnegative().nullable(),
+  isTrusted: import_zod12.z.boolean().optional()
+});
+var EnableOfflineResultSchema = import_zod12.z.object({
+  hold: OfflineHoldRecordSchema,
+  oac: OACRecordSchema
+});
+var DisableOfflineResultSchema = import_zod12.z.object({
+  hold: OfflineHoldRecordSchema,
+  trusted: import_zod12.z.boolean(),
+  settledClaims: import_zod12.z.number().int().nonnegative()
+});
+var OfflineStatusResultSchema = import_zod12.z.object({
+  hold: OfflineHoldRecordSchema.nullable(),
+  active: OACRecordSchema.nullable()
+});
+var OfflineStateResultSchema = import_zod12.z.object({
+  active: OACRecordSchema.nullable()
+});
+var ConsumerPaymentClaimSchema = import_zod12.z.object({
+  oacId: import_zod12.z.string().uuid(),
+  encounterId: Sha256Hex.optional(),
+  payerUserId: import_zod12.z.string().uuid(),
+  payeeUserId: import_zod12.z.string().uuid(),
+  payerDeviceId: import_zod12.z.string().min(1).max(128),
+  payerNonce: import_zod12.z.string().min(8).max(128),
+  payeeNonce: import_zod12.z.string().min(8).max(128),
+  amountKobo: import_zod12.z.number().int().positive(),
+  currency: import_zod12.z.string().length(3).default("NGN"),
+  occurredAtMs: import_zod12.z.number().int().nonnegative(),
+  completedAtMs: import_zod12.z.number().int().nonnegative().optional(),
+  contextId: import_zod12.z.string().max(128).optional(),
+  payerPubkeyHex: Hex64,
+  payerSignature: HexAny,
+  payeePubkeyHex: Hex64.optional(),
+  payeeSignature: HexAny.optional()
+});
+var ConsumerSettlementSchema = import_zod12.z.object({
+  settlementId: import_zod12.z.string().uuid(),
+  settlementKey: Sha256Hex,
+  encounterId: Sha256Hex,
+  oacId: import_zod12.z.string().uuid(),
+  payerUserId: import_zod12.z.string().uuid(),
+  payeeUserId: import_zod12.z.string().uuid(),
+  amountKobo: import_zod12.z.number().int().positive(),
+  currency: import_zod12.z.string().length(3),
+  status: import_zod12.z.enum(["SETTLED", "REVIEW"]),
+  reviewReason: import_zod12.z.string().nullable(),
+  ledgerRef: import_zod12.z.string().nullable(),
+  issuerSig: HexAny,
+  createdAtMs: import_zod12.z.number().int().nonnegative()
+});
+var ConsumerSettleResultSchema = import_zod12.z.object({
+  settlement: ConsumerSettlementSchema,
+  encounterId: Sha256Hex,
+  replayed: import_zod12.z.boolean()
+});
+var RevokeDeviceKeyInputSchema = import_zod12.z.object({
+  deviceId: import_zod12.z.string().min(1).max(128),
+  /** Step-up token from /api/v1/auth/send/verify with purpose='offline_revoke'. */
+  sendAuthToken: import_zod12.z.string().min(16)
+});
+function createMeOfflineClient(opts) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("createMeOfflineClient: no fetch implementation available");
+  }
+  const baseUrl = opts.baseUrl.replace(/\/$/, "");
+  async function call(method, path, body, parser) {
+    const init2 = {
+      method,
+      headers: {
+        "content-type": "application/json",
+        accept: "application/json"
+      }
+    };
+    if (body !== void 0) init2.body = JSON.stringify(body);
+    const resp = await fetchImpl(`${baseUrl}${path}`, init2);
+    const text = await resp.text();
+    let raw = void 0;
+    if (text) {
+      try {
+        raw = JSON.parse(text);
+      } catch {
+      }
+    }
+    if (!resp.ok) {
+      const code = raw && typeof raw === "object" && "code" in raw && typeof raw.code === "string" ? raw.code : `http_${resp.status}`;
+      const message = raw && typeof raw === "object" && "message" in raw && typeof raw.message === "string" ? raw.message : `request failed with status ${resp.status}`;
+      throw new FlurApiError(resp.status, code, message, raw);
+    }
+    return parser(raw);
+  }
+  const deviceKeyItems = import_zod12.z.object({ items: import_zod12.z.array(DeviceKeyRecordSchema) });
+  return {
+    registerDeviceKey: (input) => call(
+      "POST",
+      "/v1/me/offline/keys",
+      RegisterDeviceKeyInputSchema.parse(input),
+      (raw) => DeviceKeyRecordSchema.parse(raw)
+    ),
+    listDeviceKeys: () => call(
+      "GET",
+      "/v1/me/offline/keys",
+      void 0,
+      (raw) => deviceKeyItems.parse(raw)
+    ),
+    revokeDeviceKey: (input) => call(
+      "POST",
+      "/v1/me/offline/keys/revoke",
+      RevokeDeviceKeyInputSchema.parse(input),
+      () => void 0
+    ),
+    enable: (input) => call(
+      "POST",
+      "/v1/me/offline/enable",
+      EnableOfflineInputSchema.parse(input),
+      (raw) => EnableOfflineResultSchema.parse(raw)
+    ),
+    refresh: (input) => call(
+      "POST",
+      "/v1/me/offline/refresh",
+      IssueOACInputSchema.parse(input),
+      (raw) => OACRecordSchema.parse(raw)
+    ),
+    disable: (input) => call(
+      "POST",
+      "/v1/me/offline/disable",
+      DisableOfflineInputSchema.parse(input),
+      (raw) => DisableOfflineResultSchema.parse(raw)
+    ),
+    getStatus: (deviceId) => {
+      const qs = deviceId ? `?deviceId=${encodeURIComponent(deviceId)}` : "";
+      return call(
+        "GET",
+        `/v1/me/offline/status${qs}`,
+        void 0,
+        (raw) => OfflineStatusResultSchema.parse(raw)
+      );
+    },
+    getState: (deviceId) => {
+      const qs = deviceId ? `?deviceId=${encodeURIComponent(deviceId)}` : "";
+      return call(
+        "GET",
+        `/v1/me/offline/state${qs}`,
+        void 0,
+        (raw) => OfflineStateResultSchema.parse(raw)
+      );
+    },
+    submitClaim: (claim) => call(
+      "POST",
+      "/v1/me/offline/claims",
+      ConsumerPaymentClaimSchema.parse(claim),
+      (raw) => ConsumerSettleResultSchema.parse(raw)
+    )
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCOUNT_STATUSES,
@@ -2642,6 +2951,16 @@ function createApiCredentialsAdminClient(opts) {
   AccountMembershipSchema,
   AccountSchema,
   ApiCredentialPublicSchema,
+  ConsumerOACRecordSchema,
+  ConsumerOACSchema,
+  ConsumerPaymentClaimSchema,
+  ConsumerSettleResultSchema,
+  ConsumerSettlementSchema,
+  DeviceKeyRecordSchema,
+  DisableOfflineInputSchema,
+  DisableOfflineResultSchema,
+  EnableOfflineInputSchema,
+  EnableOfflineResultSchema,
   FIELD,
   FlurApiError,
   FlurCapExceededError,
@@ -2649,6 +2968,7 @@ function createApiCredentialsAdminClient(opts) {
   FlurError,
   FlurExpiredError,
   FlurReplayError,
+  IssueOACInputSchema,
   MEMBERSHIP_ROLES,
   MintedApiCredentialSchema,
   NGN_CURRENCY_CODE,
@@ -2658,8 +2978,11 @@ function createApiCredentialsAdminClient(opts) {
   OAC_DEFAULT_CUMULATIVE_KOBO,
   OAC_DEFAULT_PER_TX_KOBO,
   OAC_DEFAULT_VALIDITY_MS,
+  OfflineHoldRecordSchema,
   OfflinePaymentAuthorizationSchema,
   OfflinePaymentRequestSchema,
+  OfflineStateResultSchema,
+  OfflineStatusResultSchema,
   OfflineTokenSchema,
   PARTNER_SCOPES,
   PASS_KINDS,
@@ -2675,8 +2998,11 @@ function createApiCredentialsAdminClient(opts) {
   ReceiptPayloadSchema,
   ReceiptSchema,
   RedemptionSchema,
+  RegisterDeviceKeyInputSchema,
+  RevokeDeviceKeyInputSchema,
   SettleResponseSchema,
   SettlementSchema,
+  SignedConsumerOACSchema,
   bodySha256Hex,
   buildAuthorization,
   buildOAC,
@@ -2695,6 +3021,7 @@ function createApiCredentialsAdminClient(opts) {
   createApiCredentialsAdminClient,
   createFlurPartnerClient,
   createHmacFetch,
+  createMeOfflineClient,
   createOfflineSettlementsClient,
   createPassesClient,
   createReceiptsClient,