Merge pull request #21 from reclaimprotocol/cascading-proofs-feature

Added Support for Cascading Providers in the verifyProof method

Author: Kushal7788

README.md

@@ -88,7 +88,12 @@ function App() {
             setProofs(proofs)
           } else if (proofs && typeof proofs !== 'string') {
             // When using the default callback url, we get a proof
-            console.log('Proof received:', proofs?.claimData.context)
+            if (Array.isArray(proofs)) {
+              // when using the cascading providers, providers having more than one proof will return an array of proofs
+              console.log(JSON.stringify(proofs.map(p => p.claimData.context)))
+            } else {
+              console.log('Proof received:', proofs?.claimData.context)
+            }
             setProofs(proofs)
           }
       },

example/src/app/page.tsx

@@ -34,23 +34,22 @@ export default function Home() {
       const proofRequest = await ReclaimProofRequest.init(
         process.env.NEXT_PUBLIC_RECLAIM_APP_ID!,
         process.env.NEXT_PUBLIC_RECLAIM_APP_SECRET!,
-        '5eb7f8b3-cbe8-4001-848e-cb161e53fe60', // providerId
-        // Uncomment the following line to enable logging and AI providers
-        // { log: true, acceptAiProviders: true }
+        process.env.NEXT_PUBLIC_RECLAIM_PROVIDER_ID!,
+        { log: true }
       )
       setReclaimProofRequest(proofRequest)
 
       // Add context to the proof request (optional)
       proofRequest.addContext('0x00000000000', 'Example context message')
 
       // Set parameters for the proof request (if needed)
-      // proofRequest.setParams({ email: "test@example.com", userName: "testUser" })
+      // proofRequest.setParams({ key: "value" })
 
       // Set a redirect URL (if needed)
-      // proofRequest.setRedirectUrl('https://example.com/redirect')
+      // proofRequest.setRedirectUrl('your-redirect-url')
 
       // Set a custom app callback URL (if needed)
-      // proofRequest.setAppCallbackUrl('https://your-website.com/callback')
+      // proofRequest.setAppCallbackUrl('your-callback-url')
 
       // Uncomment the following line to log the proof request and to get the Json String
       // console.log('Proof request initialized:', proofRequest.toJsonString())
@@ -76,15 +75,19 @@ export default function Home() {
 
       // Start the verification session
       await reclaimProofRequest.startSession({
-        onSuccess: async (proof: Proof | string | undefined) => {
+        onSuccess: async (proof: Proof | Proof[] | string | undefined) => {
           if (proof && typeof proof === 'string') {
             // When using a custom callback url, the proof is returned to the callback url and we get a message instead of a proof
             console.log('SDK Message:', proof)
             setExtracted(proof)
           } else if (proof && typeof proof !== 'string') {
             // When using the default callback url, we get a proof
-            console.log('Proof received:', proof?.claimData.context)
-            setExtracted(JSON.stringify(proof?.claimData.context))
+            console.log('Proof received:', proof)
+            if (Array.isArray(proof)) {
+              setExtracted(JSON.stringify(proof.map(p => p.claimData.context)))
+            } else {
+              setExtracted(JSON.stringify(proof?.claimData.context))
+            }
           }
         },
         onError: (error: Error) => {

src/Reclaim.ts

@@ -41,8 +41,21 @@ const logger = loggerModule.logger
 
 const sdkVersion = require('../package.json').version;
 
+// Implementation
+export async function verifyProof(proofOrProofs: Proof | Proof[]): Promise<boolean> {
+    // If input is an array of proofs
+    if (Array.isArray(proofOrProofs)) {
+        for (const proof of proofOrProofs) {
+            const isVerified = await verifyProof(proof);
+            if (!isVerified) {
+                return false;
+            }
+        }
+        return true;
+    }
 
-export async function verifyProof(proof: Proof): Promise<boolean> {
+    // Single proof verification logic
+    const proof = proofOrProofs;
     if (!proof.signatures.length) {
         throw new SignatureNotFoundError('No signatures')
     }
@@ -492,14 +505,17 @@ export class ReclaimProofRequest {
 
                 if (isDefaultCallbackUrl) {
                     if (statusUrlResponse.session.proofs && statusUrlResponse.session.proofs.length > 0) {
-                        const proof = statusUrlResponse.session.proofs[0];
-                        const verified = await verifyProof(proof);
+                        const proofs = statusUrlResponse.session.proofs;
+                        const verified = await verifyProof(proofs);
                         if (!verified) {
-                            logger.info(`Proof not verified: ${JSON.stringify(proof)}`);
+                            logger.info(`Proofs not verified: ${JSON.stringify(proofs)}`);
                             throw new ProofNotVerifiedError();
                         }
-                        if (onSuccess) {
-                            onSuccess(proof);
+                        // check if the proofs array has only one proof then send the proofs in onSuccess 
+                        if (proofs.length === 1) {
+                            onSuccess(proofs[0]);
+                        } else {
+                            onSuccess(proofs);
                         }
                         this.clearInterval();
                     }

src/utils/types.ts

@@ -26,7 +26,7 @@ export type StartSessionParams = {
   onError: OnError;
 };
 
-export type OnSuccess = (proof?: Proof | string) => void;
+export type OnSuccess = (proof?: Proof | Proof[] | string) => void;
 export type OnError = (error: Error) => void;
 
 export type ProofRequestOptions = {