@p2pdotme/sdk 1.2.5 → 1.2.7

package/dist/zkkyc.cjs

@@ -30,12 +30,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/zkkyc/index.ts
 var zkkyc_exports = {};
 __export(zkkyc_exports, {
+  BVN_OTP_METHODS: () => BVN_OTP_METHODS,
   DEFAULT_RECLAIM_PROVIDER_IDS: () => DEFAULT_RECLAIM_PROVIDER_IDS,
   RECLAIM_APP_LINKS: () => RECLAIM_APP_LINKS,
   SIMPLE_KYC_DEFAULT_TENANT: () => SIMPLE_KYC_DEFAULT_TENANT,
   SOCIAL_PLATFORM_NAMES: () => SOCIAL_PLATFORM_NAMES,
   ZK_PASSPORT_APP_LINKS: () => ZK_PASSPORT_APP_LINKS,
   ZkkycError: () => ZkkycError,
+  createBvnFlow: () => createBvnFlow,
   createReclaimFlow: () => createReclaimFlow,
   createSimpleKycFlow: () => createSimpleKycFlow,
   createZkPassportFlow: () => createZkPassportFlow,
@@ -188,6 +190,20 @@ var ZodSimpleKycSubmitParamsSchema = import_zod2.z.object({
     message: "signature must be a hex string"
   })
 });
+var ZodBvnSubmitParamsSchema = import_zod2.z.object({
+  /** Per-(tenant, identity) Sybil nullifier (bytes32 hex). */
+  nullifier: import_zod2.z.string().refine((v) => /^0x[a-fA-F0-9]{64}$/.test(v), {
+    message: "nullifier must be a bytes32 hex string"
+  }),
+  /** Remaining limit in micro-USDC (part of the signed struct). */
+  limit: import_zod2.z.bigint(),
+  /** Attestation expiry (unix seconds). */
+  expiry: import_zod2.z.bigint(),
+  /** 65-byte secp256k1 signature (hex). */
+  signature: import_zod2.z.string().refine((v) => /^0x[a-fA-F0-9]+$/.test(v), {
+    message: "signature must be a hex string"
+  })
+});
 
 // src/contracts/abis/index.ts
 var import_viem2 = require("viem");
@@ -992,6 +1008,38 @@ var reputationManagerAbi = [
     outputs: [{ internalType: "bool", name: "", type: "bool" }],
     stateMutability: "view",
     type: "function"
+  },
+  // ── BVN (Nigerian Bank Verification Number) attestation ─────────────────
+  { inputs: [], name: "BvnSignerNotSet", type: "error" },
+  { inputs: [], name: "BvnAttestationExpired", type: "error" },
+  { inputs: [], name: "BvnNullifierAlreadySpent", type: "error" },
+  { inputs: [], name: "BvnAlreadyVerified", type: "error" },
+  { inputs: [], name: "BvnInvalidSignature", type: "error" },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "nullifier", type: "bytes32" },
+      { internalType: "uint256", name: "limit", type: "uint256" },
+      { internalType: "uint256", name: "expiry", type: "uint256" },
+      { internalType: "bytes", name: "signature", type: "bytes" }
+    ],
+    name: "submitBvnAttestation",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "bvnRp",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "", type: "address" }],
+    name: "bvnVerified",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
   }
 ];
 
@@ -1108,6 +1156,33 @@ function prepareSubmitKycAttestation(reputationManagerAddress, params) {
     )()
   );
 }
+function prepareSubmitBvnAttestation(reputationManagerAddress, params) {
+  return validate(
+    ZodBvnSubmitParamsSchema,
+    params,
+    (message, cause, data) => new ZkkycError(message, { code: "VALIDATION_ERROR", cause, context: { params: data } })
+  ).andThen(
+    (validated) => import_neverthrow2.Result.fromThrowable(
+      () => ({
+        to: reputationManagerAddress,
+        data: (0, import_viem3.encodeFunctionData)({
+          abi: ABIS.EXTERNAL.REPUTATION_MANAGER,
+          functionName: "submitBvnAttestation",
+          args: [
+            validated.nullifier,
+            validated.limit,
+            validated.expiry,
+            validated.signature
+          ]
+        })
+      }),
+      (error) => new ZkkycError("Failed to encode submitBvnAttestation", {
+        code: "ENCODE_ERROR",
+        cause: error
+      })
+    )()
+  );
+}
 function prepareZkPassportRegister(reputationManagerAddress, params) {
   return validate(
     ZodZkPassportRegisterParamsSchema,
@@ -1156,7 +1231,8 @@ function createZkkyc(config) {
     prepareSocialVerify: (params) => prepareSocialVerify(reputationManagerAddress, params),
     prepareSubmitAnonAadharProof: (params) => prepareSubmitAnonAadharProof(reputationManagerAddress, params),
     prepareZkPassportRegister: (params) => prepareZkPassportRegister(reputationManagerAddress, params),
-    prepareSubmitKycAttestation: (params) => prepareSubmitKycAttestation(reputationManagerAddress, params)
+    prepareSubmitKycAttestation: (params) => prepareSubmitKycAttestation(reputationManagerAddress, params),
+    prepareSubmitBvnAttestation: (params) => prepareSubmitBvnAttestation(reputationManagerAddress, params)
   };
 }
 
@@ -1177,9 +1253,149 @@ var RECLAIM_APP_LINKS = {
   ANDROID: "https://play.google.com/store/apps/details?id=org.reclaimprotocol.app"
 };
 var SIMPLE_KYC_DEFAULT_TENANT = "p2p-reputation";
+var BVN_OTP_METHODS = ["email", "phone", "phone_1", "alternate_phone"];
 
-// src/zkkyc/orchestrators/reclaim.ts
+// src/zkkyc/orchestrators/bvn.ts
 var import_neverthrow3 = require("neverthrow");
+function createBvnFlow(config) {
+  const { baseUrl, tenant } = config;
+  async function request(path, failureCode, init, parse) {
+    const response = await fetch(`${baseUrl}${path}`, init);
+    const body = await response.json().catch(() => null);
+    const envelope = body && typeof body === "object" ? body : {};
+    if (!response.ok || envelope.ok === false) {
+      const code = typeof envelope.error === "string" ? envelope.error : "request_failed";
+      const message = typeof envelope.message === "string" ? envelope.message : `BVN request failed (${response.status})`;
+      const isSessionExpired = response.status === 401 || code === "unauthorized";
+      throw new ZkkycError(message, {
+        code: isSessionExpired ? "BVN_SESSION_EXPIRED" : failureCode,
+        context: { status: response.status, backendError: code, path }
+      });
+    }
+    return parse(envelope.data);
+  }
+  function run(failureCode, fn) {
+    return import_neverthrow3.ResultAsync.fromPromise(fn(), (error) => {
+      if (error instanceof ZkkycError) return error;
+      return new ZkkycError("BVN request failed", { code: failureCode, cause: error });
+    });
+  }
+  function authHeaders(token) {
+    return { "content-type": "application/json", "x-session-token": token };
+  }
+  return {
+    onboard(params) {
+      return run(
+        "BVN_ONBOARD_FAILED",
+        () => request(
+          "/v1/onboard",
+          "BVN_ONBOARD_FAILED",
+          {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+              tenant,
+              wallet: params.walletAddress,
+              scope: params.scope ?? "identity"
+            })
+          },
+          (data) => {
+            const d = data;
+            return { sessionId: d.session_id, sessionToken: d.session_token };
+          }
+        )
+      );
+    },
+    submitBvn(session, bvn) {
+      return run(
+        "BVN_SUBMIT_FAILED",
+        () => request(
+          `/v1/sessions/${session.sessionId}/bvn`,
+          "BVN_SUBMIT_FAILED",
+          {
+            method: "POST",
+            headers: authHeaders(session.sessionToken),
+            body: JSON.stringify({ bvn })
+          },
+          (data) => data.methods
+        )
+      );
+    },
+    sendOtp(session, params) {
+      return run(
+        "BVN_OTP_SEND_FAILED",
+        () => request(
+          `/v1/sessions/${session.sessionId}/otp`,
+          "BVN_OTP_SEND_FAILED",
+          {
+            method: "POST",
+            headers: authHeaders(session.sessionToken),
+            body: JSON.stringify({
+              method: params.method,
+              ...params.method === "alternate_phone" && params.phoneNumber ? { phone_number: params.phoneNumber } : {}
+            })
+          },
+          (data) => data.sent
+        )
+      );
+    },
+    confirmOtp(session, otp) {
+      return run(
+        "BVN_OTP_CONFIRM_FAILED",
+        () => request(
+          `/v1/sessions/${session.sessionId}/otp/confirm`,
+          "BVN_OTP_CONFIRM_FAILED",
+          {
+            method: "POST",
+            headers: authHeaders(session.sessionToken),
+            body: JSON.stringify({ otp })
+          },
+          (data) => {
+            const d = data;
+            return { decision: d.decision, reason: d.reason };
+          }
+        )
+      );
+    },
+    getAttestation(session) {
+      return run(
+        "BVN_ATTESTATION_FAILED",
+        () => request(
+          `/v1/sessions/${session.sessionId}/attestation`,
+          "BVN_ATTESTATION_FAILED",
+          {
+            method: "POST",
+            headers: { "x-session-token": session.sessionToken }
+          },
+          (data) => {
+            const d = data;
+            return {
+              nullifier: d.message.nullifier,
+              limit: BigInt(d.message.limit),
+              expiry: BigInt(d.message.expiry),
+              signature: d.signature,
+              wallet: d.message.wallet
+            };
+          }
+        )
+      );
+    },
+    getAttestor() {
+      return run(
+        "BVN_ATTESTATION_FAILED",
+        () => request(
+          "/v1/attestor",
+          "BVN_ATTESTATION_FAILED",
+          void 0,
+          (data) => data
+        )
+      );
+    }
+  };
+}
+
+// src/zkkyc/orchestrators/reclaim.ts
+var import_neverthrow4 = require("neverthrow");
 
 // src/zkkyc/orchestrators/types.ts
 var SOCIAL_PLATFORM_NAMES = {
@@ -1194,7 +1410,7 @@ var SOCIAL_PLATFORM_NAMES = {
 // src/zkkyc/orchestrators/reclaim.ts
 var RECLAIM_SESSION_API = "https://api.reclaimprotocol.org/api/sdk/session";
 function createReclaimFlow(params) {
-  return import_neverthrow3.ResultAsync.fromPromise(
+  return import_neverthrow4.ResultAsync.fromPromise(
     (async () => {
       const mod = await import("@reclaimprotocol/js-sdk").catch(() => {
         throw new ZkkycError(
@@ -1298,7 +1514,7 @@ function createReclaimFlow(params) {
       const session = {
         sessionId,
         requestUrl,
-        start: () => import_neverthrow3.ResultAsync.fromPromise(pollForProof(), (error) => {
+        start: () => import_neverthrow4.ResultAsync.fromPromise(pollForProof(), (error) => {
           if (error instanceof ZkkycError) return error;
           return new ZkkycError("Reclaim verification flow failed", {
             code: "RECLAIM_INIT_FAILED",
@@ -1322,10 +1538,10 @@ function createReclaimFlow(params) {
 }
 
 // src/zkkyc/orchestrators/simple-kyc.ts
-var import_neverthrow4 = require("neverthrow");
+var import_neverthrow5 = require("neverthrow");
 function createSimpleKycFlow(params) {
   const { baseUrl, walletAddress, tenant, redirectUrl, country, state, onStatus } = params;
-  return import_neverthrow4.ResultAsync.fromPromise(
+  return import_neverthrow5.ResultAsync.fromPromise(
     (async () => {
       const res = await fetch(`${baseUrl}/v1/widget/public-sessions`, {
         method: "POST",
@@ -1368,7 +1584,7 @@ function createSimpleKycFlow(params) {
   );
 }
 function resumeSimpleKycFlow(args) {
-  return import_neverthrow4.ResultAsync.fromPromise(
+  return import_neverthrow5.ResultAsync.fromPromise(
     (async () => {
       const res = await fetch(`${args.baseUrl}/v1/widget/attestation`, {
         method: "POST",
@@ -1402,9 +1618,9 @@ function resumeSimpleKycFlow(args) {
 }
 
 // src/zkkyc/orchestrators/zk-passport.ts
-var import_neverthrow5 = require("neverthrow");
+var import_neverthrow6 = require("neverthrow");
 function createZkPassportFlow(params) {
-  return import_neverthrow5.ResultAsync.fromPromise(
+  return import_neverthrow6.ResultAsync.fromPromise(
     (async () => {
       const mod = await import("@zkpassport/sdk").catch(() => {
         throw new ZkkycError(
@@ -1500,7 +1716,7 @@ function createZkPassportFlow(params) {
       });
       const session = {
         url,
-        result: import_neverthrow5.ResultAsync.fromPromise(resultPromise, (error) => {
+        result: import_neverthrow6.ResultAsync.fromPromise(resultPromise, (error) => {
           if (error instanceof ZkkycError) return error;
           return new ZkkycError("ZK Passport flow failed", {
             code: "ZK_PASSPORT_VERIFICATION_FAILED",
@@ -1524,12 +1740,14 @@ function createZkPassportFlow(params) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BVN_OTP_METHODS,
   DEFAULT_RECLAIM_PROVIDER_IDS,
   RECLAIM_APP_LINKS,
   SIMPLE_KYC_DEFAULT_TENANT,
   SOCIAL_PLATFORM_NAMES,
   ZK_PASSPORT_APP_LINKS,
   ZkkycError,
+  createBvnFlow,
   createReclaimFlow,
   createSimpleKycFlow,
   createZkPassportFlow,