@p2pdotme/sdk 1.2.1 → 1.2.2

package/dist/zkkyc.cjs

@@ -32,12 +32,15 @@ var zkkyc_exports = {};
 __export(zkkyc_exports, {
   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,
   createReclaimFlow: () => createReclaimFlow,
+  createSimpleKycFlow: () => createSimpleKycFlow,
   createZkPassportFlow: () => createZkPassportFlow,
-  createZkkyc: () => createZkkyc
+  createZkkyc: () => createZkkyc,
+  resumeSimpleKycFlow: () => resumeSimpleKycFlow
 });
 module.exports = __toCommonJS(zkkyc_exports);
 
@@ -169,6 +172,20 @@ var ZodZkPassportRegisterParamsSchema = import_zod2.z.object({
   params: ZodSolidityVerifierParametersSchema,
   isIDCard: import_zod2.z.boolean()
 });
+var ZodSimpleKycSubmitParamsSchema = 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");
@@ -947,6 +964,32 @@ var reputationManagerAbi = [
     outputs: [],
     stateMutability: "nonpayable",
     type: "function"
+  },
+  {
+    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: "submitKycAttestation",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "kycRp",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "", type: "address" }],
+    name: "kycVerified",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
   }
 ];
 
@@ -1036,6 +1079,33 @@ function prepareSubmitAnonAadharProof(reputationManagerAddress, params) {
     )()
   );
 }
+function prepareSubmitKycAttestation(reputationManagerAddress, params) {
+  return validate(
+    ZodSimpleKycSubmitParamsSchema,
+    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: "submitKycAttestation",
+          args: [
+            validated.nullifier,
+            validated.limit,
+            validated.expiry,
+            validated.signature
+          ]
+        })
+      }),
+      (error) => new ZkkycError("Failed to encode submitKycAttestation", {
+        code: "ENCODE_ERROR",
+        cause: error
+      })
+    )()
+  );
+}
 function prepareZkPassportRegister(reputationManagerAddress, params) {
   return validate(
     ZodZkPassportRegisterParamsSchema,
@@ -1083,7 +1153,8 @@ function createZkkyc(config) {
   return {
     prepareSocialVerify: (params) => prepareSocialVerify(reputationManagerAddress, params),
     prepareSubmitAnonAadharProof: (params) => prepareSubmitAnonAadharProof(reputationManagerAddress, params),
-    prepareZkPassportRegister: (params) => prepareZkPassportRegister(reputationManagerAddress, params)
+    prepareZkPassportRegister: (params) => prepareZkPassportRegister(reputationManagerAddress, params),
+    prepareSubmitKycAttestation: (params) => prepareSubmitKycAttestation(reputationManagerAddress, params)
   };
 }
 
@@ -1093,7 +1164,8 @@ var DEFAULT_RECLAIM_PROVIDER_IDS = {
   github: "033f0c06-2eb3-48c8-894c-5599c3356d1c",
   x: "aad95818-f726-4a34-be97-8d1f47631b03",
   instagram: "7e5b59a9-56c5-490c-a169-82a443f9b507",
-  facebook: "2701510b-c835-4820-84f0-d9e74569656b"
+  facebook: "2701510b-c835-4820-84f0-d9e74569656b",
+  binance: "7e40c007-f432-4d47-ac00-3e0762f8a7a0"
 };
 var ZK_PASSPORT_APP_LINKS = {
   IOS: "https://apps.apple.com/us/app/zkpassport/id6477371975",
@@ -1102,6 +1174,7 @@ var ZK_PASSPORT_APP_LINKS = {
 var RECLAIM_APP_LINKS = {
   ANDROID: "https://play.google.com/store/apps/details?id=org.reclaimprotocol.app"
 };
+var SIMPLE_KYC_DEFAULT_TENANT = "p2p-reputation";
 
 // src/zkkyc/orchestrators/reclaim.ts
 var import_neverthrow3 = require("neverthrow");
@@ -1112,7 +1185,8 @@ var SOCIAL_PLATFORM_NAMES = {
   github: "GitHub",
   x: "X",
   instagram: "Instagram",
-  facebook: "Facebook"
+  facebook: "Facebook",
+  binance: "Binance"
 };
 
 // src/zkkyc/orchestrators/reclaim.ts
@@ -1142,12 +1216,19 @@ function createReclaimFlow(params) {
       } = params;
       const socialName = SOCIAL_PLATFORM_NAMES[platform];
       const providerId = providerIds[platform];
+      let reclaimProofRequest = null;
       let sessionId;
+      let requestUrl = "";
       if (existingSessionId) {
         sessionId = existingSessionId;
       } else {
-        const reclaimProofRequest = await ReclaimProofRequest.init(appId, appSecret, providerId, {
-          launchOptions: { canUseDeferredDeepLinksFlow: true }
+        reclaimProofRequest = await ReclaimProofRequest.init(appId, appSecret, providerId, {
+          launchOptions: {
+            canUseDeferredDeepLinksFlow: true,
+            verificationMode: "app"
+          },
+          useAppClip: true,
+          log: true
         });
         const statusUrl = reclaimProofRequest.getStatusUrl();
         sessionId = statusUrl.split("/").pop() || "";
@@ -1161,54 +1242,72 @@ function createReclaimFlow(params) {
           walletAddress,
           contextDescription ?? `Social verification for ${socialName}`
         );
-        const requestUrl = await reclaimProofRequest.getRequestUrl();
+        requestUrl = await reclaimProofRequest.getRequestUrl();
         onStatus?.({ type: "session_created", sessionId, requestUrl });
-        if (typeof window !== "undefined") {
-          reclaimProofRequest.triggerReclaimFlow();
-        }
       }
-      onStatus?.({ type: "polling_started", sessionId });
-      while (true) {
-        if (signal?.aborted) {
-          throw new ZkkycError("Reclaim polling aborted", {
-            code: "RECLAIM_POLLING_ABORTED"
-          });
+      let aborted = false;
+      const pollForProof = async () => {
+        if (reclaimProofRequest && typeof window !== "undefined") {
+          reclaimProofRequest.triggerReclaimFlow({ verificationMode: "app" });
         }
-        const response = await fetch(`${RECLAIM_SESSION_API}/${sessionId}`);
-        const data = await response.json();
-        if (data?.session?.proofs?.length > 0) {
-          const proofs = data.session.proofs;
-          onStatus?.({ type: "proof_received" });
-          if (platform === "github" && proofs.length > 0) {
-            const first = proofs[0];
-            if (first?.publicData && Object.keys(first.publicData).length === 0) {
-              throw new ZkkycError("GitHub verification eligibility criteria not met", {
-                code: "RECLAIM_PROOF_INVALID"
-              });
+        onStatus?.({ type: "polling_started", sessionId });
+        while (true) {
+          if (aborted || signal?.aborted) {
+            throw new ZkkycError("Reclaim polling aborted", {
+              code: "RECLAIM_POLLING_ABORTED"
+            });
+          }
+          const response = await fetch(`${RECLAIM_SESSION_API}/${sessionId}`);
+          const data = await response.json();
+          if (data?.session?.proofs?.length > 0) {
+            const proofs = data.session.proofs;
+            onStatus?.({ type: "proof_received" });
+            if (platform === "github" && proofs.length > 0) {
+              const first = proofs[0];
+              if (first?.publicData && Object.keys(first.publicData).length === 0) {
+                throw new ZkkycError("GitHub verification eligibility criteria not met", {
+                  code: "RECLAIM_PROOF_INVALID"
+                });
+              }
             }
+            const transformedProofs = proofs.map((proof) => transformForOnchain(proof));
+            onStatus?.({ type: "proof_transformed" });
+            return {
+              _socialName: socialName,
+              proofs: transformedProofs,
+              sessionId
+            };
           }
-          const transformedProofs = proofs.map((proof) => transformForOnchain(proof));
-          onStatus?.({ type: "proof_transformed" });
-          return {
-            _socialName: socialName,
-            proofs: transformedProofs,
-            sessionId
-          };
-        }
-        if (data?.message?.includes("Session not found")) {
-          throw new ZkkycError("Reclaim session not found", {
-            code: "RECLAIM_SESSION_NOT_FOUND",
-            context: { sessionId }
-          });
+          if (data?.message?.includes("Session not found")) {
+            throw new ZkkycError("Reclaim session not found", {
+              code: "RECLAIM_SESSION_NOT_FOUND",
+              context: { sessionId }
+            });
+          }
+          if (data?.session?.statusV2 === "PROOF_GENERATION_FAILED") {
+            throw new ZkkycError("Reclaim proof generation failed", {
+              code: "RECLAIM_PROOF_GENERATION_FAILED",
+              context: { sessionId }
+            });
+          }
+          await new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
         }
-        if (data?.session?.statusV2 === "PROOF_GENERATION_FAILED") {
-          throw new ZkkycError("Reclaim proof generation failed", {
-            code: "RECLAIM_PROOF_GENERATION_FAILED",
-            context: { sessionId }
+      };
+      const session = {
+        sessionId,
+        requestUrl,
+        start: () => import_neverthrow3.ResultAsync.fromPromise(pollForProof(), (error) => {
+          if (error instanceof ZkkycError) return error;
+          return new ZkkycError("Reclaim verification flow failed", {
+            code: "RECLAIM_INIT_FAILED",
+            cause: error
           });
+        }),
+        abort: () => {
+          aborted = true;
         }
-        await new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
-      }
+      };
+      return session;
     })(),
     (error) => {
       if (error instanceof ZkkycError) return error;
@@ -1220,10 +1319,90 @@ function createReclaimFlow(params) {
   );
 }
 
-// src/zkkyc/orchestrators/zk-passport.ts
+// src/zkkyc/orchestrators/simple-kyc.ts
 var import_neverthrow4 = require("neverthrow");
-function createZkPassportFlow(params) {
+function createSimpleKycFlow(params) {
+  const { baseUrl, walletAddress, tenant, redirectUrl, country, state, onStatus } = params;
   return import_neverthrow4.ResultAsync.fromPromise(
+    (async () => {
+      const res = await fetch(`${baseUrl}/v1/widget/public-sessions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          wallet_pubkey: walletAddress,
+          redirect_uri: redirectUrl,
+          tenant,
+          country,
+          state
+        })
+      });
+      if (!res.ok) {
+        const body = await res.text();
+        throw new ZkkycError(`simple-kyc session creation failed: ${res.status} ${body}`, {
+          code: "SIMPLE_KYC_SESSION_FAILED",
+          context: { status: res.status }
+        });
+      }
+      const data = await res.json();
+      const widgetUrl = data.widget_url;
+      onStatus?.({ type: "session_created", widgetUrl });
+      return {
+        widgetUrl,
+        redirect: () => {
+          if (typeof window !== "undefined") {
+            onStatus?.({ type: "redirecting", widgetUrl });
+            window.location.href = widgetUrl;
+          }
+        }
+      };
+    })(),
+    (error) => {
+      if (error instanceof ZkkycError) return error;
+      return new ZkkycError("simple-kyc flow failed to start", {
+        code: "SIMPLE_KYC_SESSION_FAILED",
+        cause: error
+      });
+    }
+  );
+}
+function resumeSimpleKycFlow(args) {
+  return import_neverthrow4.ResultAsync.fromPromise(
+    (async () => {
+      const res = await fetch(`${args.baseUrl}/v1/widget/attestation`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ code: args.code })
+      });
+      if (!res.ok) {
+        const body = await res.text();
+        throw new ZkkycError(`simple-kyc attestation redemption failed: ${res.status} ${body}`, {
+          code: "SIMPLE_KYC_REDEEM_FAILED",
+          context: { status: res.status }
+        });
+      }
+      const d = await res.json();
+      return {
+        nullifier: d.nullifier,
+        limit: BigInt(d.limit),
+        expiry: BigInt(d.expiry),
+        signature: d.signature,
+        identityHash: d.identity_hash
+      };
+    })(),
+    (error) => {
+      if (error instanceof ZkkycError) return error;
+      return new ZkkycError("simple-kyc attestation redemption failed", {
+        code: "SIMPLE_KYC_REDEEM_FAILED",
+        cause: error
+      });
+    }
+  );
+}
+
+// src/zkkyc/orchestrators/zk-passport.ts
+var import_neverthrow5 = require("neverthrow");
+function createZkPassportFlow(params) {
+  return import_neverthrow5.ResultAsync.fromPromise(
     (async () => {
       const mod = await import("@zkpassport/sdk").catch(() => {
         throw new ZkkycError(
@@ -1319,7 +1498,7 @@ function createZkPassportFlow(params) {
       });
       const session = {
         url,
-        result: import_neverthrow4.ResultAsync.fromPromise(resultPromise, (error) => {
+        result: import_neverthrow5.ResultAsync.fromPromise(resultPromise, (error) => {
           if (error instanceof ZkkycError) return error;
           return new ZkkycError("ZK Passport flow failed", {
             code: "ZK_PASSPORT_VERIFICATION_FAILED",
@@ -1345,11 +1524,14 @@ function createZkPassportFlow(params) {
 0 && (module.exports = {
   DEFAULT_RECLAIM_PROVIDER_IDS,
   RECLAIM_APP_LINKS,
+  SIMPLE_KYC_DEFAULT_TENANT,
   SOCIAL_PLATFORM_NAMES,
   ZK_PASSPORT_APP_LINKS,
   ZkkycError,
   createReclaimFlow,
+  createSimpleKycFlow,
   createZkPassportFlow,
-  createZkkyc
+  createZkkyc,
+  resumeSimpleKycFlow
 });
 //# sourceMappingURL=zkkyc.cjs.map