@reclaimprotocol/inapp-rn-sdk 0.3.1 → 0.6.0

package/src/index.ts

@@ -1,11 +1,10 @@
-import * as NativeReclaimInappModuleTypes from "./specs/NativeInappRnSdk";
-import { PlatformImpl } from "./platform";
-
+import type { EventSubscription } from 'react-native';
+import NativeReclaimInappModule, * as NativeReclaimInappModuleTypes from './specs/NativeInappRnSdk';
 /**
  * [ReclaimVerification] is the main class for interacting with the Reclaim verification system.
  * It provides methods to start verification processes, manage platform configurations,
  * and handle verification options.
- * 
+ *
  * The class can be instantiated with a custom platform implementation, or will use
  * the default [PlatformImpl] if none is provided.
  */
@@ -25,7 +24,9 @@ export class ReclaimVerification {
     }
   }
 
-  public async startVerification(request: ReclaimVerification.Request): Promise<ReclaimVerification.Response> {
+  public async startVerification(
+    request: ReclaimVerification.Request
+  ): Promise<ReclaimVerification.Response> {
     return this.platform.startVerification(request);
   }
 
@@ -41,12 +42,13 @@ export class ReclaimVerification {
     return this.platform.clearAllOverrides();
   }
 
-  public setVerificationOptions(options?: ReclaimVerification.VerificationOptions | null) {
+  public setVerificationOptions(
+    options?: ReclaimVerification.VerificationOptions | null
+  ) {
     return this.platform.setVerificationOptions(options);
   }
 }
 
-
 /**
  * This namespace provides types involved in initiating and managing the verification process
  * for proving claims about user data through various providers.
@@ -56,7 +58,8 @@ export namespace ReclaimVerification {
    * Represents user's session information for a verification attempt.
    * This data class contains the necessary data to identify and validate a verification session.
    */
-  export type SessionInformation = NativeReclaimInappModuleTypes.SessionInformation;
+  export type SessionInformation =
+    NativeReclaimInappModuleTypes.SessionInformation;
 
   /**
    * Represents a request for a verification attempt.
@@ -86,12 +89,18 @@ export namespace ReclaimVerification {
     }
 
     export const isProof = (value: Record<string, any>): value is Proof => {
-      return typeof value === 'object' && value !== null && 'identifier' in value && 'signatures' in value && 'witnesses' in value;
-    }
+      return (
+        typeof value === 'object' &&
+        value !== null &&
+        'identifier' in value &&
+        'signatures' in value &&
+        'witnesses' in value
+      );
+    };
 
     export const asProofs = (proofs: Record<string, any>[]): Proof[] => {
       return proofs.filter(isProof);
-    }
+    };
 
     export interface ProviderClaimData {
       owner: string;
@@ -113,14 +122,28 @@ export namespace ReclaimVerification {
 
   export interface VerificationOptions {
     canDeleteCookiesBeforeVerificationStarts: boolean;
-    fetchAttestorAuthenticationRequest: (reclaimHttpProviderJsonString: string) => Promise<string>;
+    fetchAttestorAuthenticationRequest: (
+      reclaimHttpProviderJsonString: string
+    ) => Promise<string>;
+    claimCreationType?: 'standalone' | 'meChain'; // Optional
+    /**
+     * Whether to automatically submit the proof after generation. Defaults to true.
+     */
+    canAutoSubmit?: boolean; // Optional
+
+    /**
+     * Whether the close button is visible. Defaults to true.
+     */
+    isCloseButtonVisible?: boolean; // Optional
   }
 
   export namespace Overrides {
     export interface ProviderInformation {
       url?: string;
       jsonString?: string;
-      callback?: (request: NativeReclaimInappModuleTypes.ProviderInformationRequest) => Promise<string>;
+      callback?: (
+        request: NativeReclaimInappModuleTypes.ProviderInformationRequest
+      ) => Promise<string>;
     }
     export type FeatureOptions = NativeReclaimInappModuleTypes.FeatureOptions;
     export interface LogConsumer {
@@ -143,59 +166,70 @@ export namespace ReclaimVerification {
     }
     export interface SessionManagement {
       onLog: (event: NativeReclaimInappModuleTypes.SessionLogEvent) => void;
-      onSessionCreateRequest: (event: NativeReclaimInappModuleTypes.SessionCreateRequestEvent) => Promise<boolean>;
-      onSessionUpdateRequest: (event: NativeReclaimInappModuleTypes.SessionUpdateRequestEvent) => Promise<boolean>;
-    };
+      /**
+       * Receive request for creating a session and return a session id.
+       * @param event Receive request for creating a session and return a session id.
+       * @returns A session id.
+       */
+      onSessionCreateRequest: (
+        event: NativeReclaimInappModuleTypes.SessionCreateRequestEvent
+      ) => Promise<string>;
+      onSessionUpdateRequest: (
+        event: NativeReclaimInappModuleTypes.SessionUpdateRequestEvent
+      ) => Promise<boolean>;
+    }
     export type ReclaimAppInfo = NativeReclaimInappModuleTypes.ReclaimAppInfo;
   }
 
   export type OverrideConfig = {
-    provider?: Overrides.ProviderInformation,
-    featureOptions?: Overrides.FeatureOptions,
-    logConsumer?: Overrides.LogConsumer,
-    sessionManagement?: Overrides.SessionManagement,
-    appInfo?: Overrides.ReclaimAppInfo,
-    capabilityAccessToken?: string | null,
-  }
+    provider?: Overrides.ProviderInformation;
+    featureOptions?: Overrides.FeatureOptions;
+    logConsumer?: Overrides.LogConsumer;
+    sessionManagement?: Overrides.SessionManagement;
+    appInfo?: Overrides.ReclaimAppInfo;
+    capabilityAccessToken?: string | null;
+  };
 
   export enum ExceptionType {
-    Cancelled = "Cancelled",
-    Dismissed = "Dismissed",
-    SessionExpired = "SessionExpired",
-    Failed = "Failed",
+    Cancelled = 'Cancelled',
+    Dismissed = 'Dismissed',
+    SessionExpired = 'SessionExpired',
+    Failed = 'Failed',
   }
 
   export class ReclaimPlatformException extends Error {
-    readonly innerError: Error
-    readonly reason?: string
-    readonly details?: any
+    readonly innerError: Error;
+    readonly reason?: string;
+    readonly details?: any;
 
     constructor(message: string, innerError: Error) {
       super(message);
       this.innerError = innerError;
       this.reason = innerError.message;
       if ('userInfo' in innerError) {
-        const details: any = innerError.userInfo
-        this.details = details
+        const details: any = innerError.userInfo;
+        this.details = details;
         if ('message' in details) {
-          this.reason = details.message || this.reason
+          this.reason = details.message || this.reason;
         }
       }
     }
 
-    static isReclaimPlatformException(error: Error): error is ReclaimPlatformException {
-      return error instanceof ReclaimPlatformException
+    static isReclaimPlatformException(
+      error: Error
+    ): error is ReclaimPlatformException {
+      return error instanceof ReclaimPlatformException;
     }
   }
 
   export class ReclaimVerificationException extends Error {
-    readonly innerError: Error
-    readonly type: ExceptionType
-    readonly sessionId: string
-    readonly "didSubmitManualVerification": boolean
-    readonly "reason": string
+    readonly 'innerError': Error;
+    readonly 'type': ExceptionType;
+    readonly 'sessionId': string;
+    readonly 'didSubmitManualVerification': boolean;
+    readonly 'reason': string;
 
-    constructor(
+    'constructor'(
       message: string,
       innerError: Error,
       type: ExceptionType,
@@ -211,39 +245,46 @@ export namespace ReclaimVerification {
       this.reason = reason;
     }
 
-    private static fromTypeName(name: string): ExceptionType {
+    private static 'fromTypeName'(name: string): ExceptionType {
       switch (name) {
-        case "cancelled":
-        case "org.reclaimprotocol.inapp_sdk.ReclaimVerification.ReclaimVerificationException.Cancelled":
+        case 'cancelled':
+        case 'org.reclaimprotocol.inapp_sdk.ReclaimVerification.ReclaimVerificationException.Cancelled':
           return ExceptionType.Cancelled;
-        case "dismissed":
-        case "org.reclaimprotocol.inapp_sdk.ReclaimVerification.ReclaimVerificationException.Dismissed":
+        case 'dismissed':
+        case 'org.reclaimprotocol.inapp_sdk.ReclaimVerification.ReclaimVerificationException.Dismissed':
           return ExceptionType.Dismissed;
-        case "sessionExpired":
-        case "org.reclaimprotocol.inapp_sdk.ReclaimVerification.ReclaimVerificationException.SessionExpired":
+        case 'sessionExpired':
+        case 'org.reclaimprotocol.inapp_sdk.ReclaimVerification.ReclaimVerificationException.SessionExpired':
           return ExceptionType.SessionExpired;
-        case "failed":
-        case "org.reclaimprotocol.inapp_sdk.ReclaimVerification.ReclaimVerificationException.Failed":
+        case 'failed':
+        case 'org.reclaimprotocol.inapp_sdk.ReclaimVerification.ReclaimVerificationException.Failed':
           return ExceptionType.Failed;
       }
       return ExceptionType.Failed;
     }
 
-    static fromError(error: Error, sessionIdHint: string): ReclaimVerificationException {
+    static 'fromError'(
+      error: Error,
+      sessionIdHint: string
+    ): ReclaimVerificationException {
       if ('userInfo' in error) {
         // From native, we send information about error in userInfo
         let userInfo = error.userInfo as any;
         if (userInfo) {
-          let type = ReclaimVerification.ReclaimVerificationException.fromTypeName(userInfo.errorType);
-          let maybeSessionId = userInfo?.sessionId
+          let type =
+            ReclaimVerification.ReclaimVerificationException.fromTypeName(
+              userInfo.errorType
+            );
+          let maybeSessionId = userInfo?.sessionId;
           return new ReclaimVerificationException(
             error.message,
             error,
             type,
-            (typeof maybeSessionId === 'string' && maybeSessionId)
-              ? maybeSessionId : sessionIdHint,
+            typeof maybeSessionId === 'string' && maybeSessionId
+              ? maybeSessionId
+              : sessionIdHint,
             userInfo?.didSubmitManualVerification ?? false,
-            userInfo?.reason ?? ""
+            userInfo?.reason ?? ''
           );
         }
       }
@@ -253,26 +294,292 @@ export namespace ReclaimVerification {
         ReclaimVerification.ExceptionType.Failed,
         sessionIdHint,
         false,
-        ""
+        ''
       );
     }
 
-    static isReclaimVerificationException(error: Error): error is ReclaimVerificationException {
-      return error instanceof ReclaimVerificationException
+    static 'isReclaimVerificationException'(
+      error: Error
+    ): error is ReclaimVerificationException {
+      return error instanceof ReclaimVerificationException;
     }
   }
 
   export abstract class Platform {
-    abstract startVerification(request: ReclaimVerification.Request): Promise<ReclaimVerification.Response>
+    abstract startVerification(
+      request: ReclaimVerification.Request
+    ): Promise<ReclaimVerification.Response>;
 
-    abstract startVerificationFromUrl(requestUrl: string): Promise<ReclaimVerification.Response>
+    abstract startVerificationFromUrl(
+      requestUrl: string
+    ): Promise<ReclaimVerification.Response>;
 
-    abstract ping(): Promise<boolean>
+    abstract ping(): Promise<boolean>;
 
-    abstract setOverrides(config: ReclaimVerification.OverrideConfig): Promise<void>
+    abstract setOverrides(
+      config: ReclaimVerification.OverrideConfig
+    ): Promise<void>;
 
-    abstract clearAllOverrides(): Promise<void>
+    abstract clearAllOverrides(): Promise<void>;
+
+    abstract setVerificationOptions(
+      options?: ReclaimVerification.VerificationOptions | null
+    ): Promise<void>;
+  }
+}
 
-    abstract setVerificationOptions(options?: ReclaimVerification.VerificationOptions | null): Promise<void>
+export class PlatformImpl extends ReclaimVerification.Platform {
+  override async startVerification(
+    request: ReclaimVerification.Request
+  ): Promise<ReclaimVerification.Response> {
+    try {
+      const response =
+        await NativeReclaimInappModule.startVerification(request);
+      return {
+        ...response,
+        proofs: ReclaimVerification.ReclaimResult.asProofs(response.proofs),
+      };
+    } catch (error) {
+      console.info({
+        error,
+      });
+      if (error instanceof Error) {
+        throw ReclaimVerification.ReclaimVerificationException.fromError(
+          error,
+          request.session?.sessionId ?? ''
+        );
+      }
+      throw error;
+    }
+  }
+
+  override async startVerificationFromUrl(
+    requestUrl: string
+  ): Promise<ReclaimVerification.Response> {
+    try {
+      const response =
+        await NativeReclaimInappModule.startVerificationFromUrl(requestUrl);
+      return {
+        ...response,
+        proofs: ReclaimVerification.ReclaimResult.asProofs(response.proofs),
+      };
+    } catch (error) {
+      console.info({
+        error,
+      });
+      if (error instanceof Error) {
+        throw ReclaimVerification.ReclaimVerificationException.fromError(
+          error,
+          ''
+        );
+      }
+      throw error;
+    }
+  }
+
+  override async ping(): Promise<boolean> {
+    return await NativeReclaimInappModule.ping();
+  }
+
+  private previousSessionManagementCancelCallback: null | (() => void) = null;
+  disposeSessionManagement() {
+    let callback = this.previousSessionManagementCancelCallback;
+    if (callback != null && callback != undefined) {
+      callback();
+    }
+    this.previousSessionManagementCancelCallback = null;
+  }
+
+  private previousLogSubscription: EventSubscription | null = null;
+  disposeLogListener() {
+    this.previousLogSubscription?.remove();
+    this.previousLogSubscription = null;
+  }
+
+  private previousProviderRequestCancelCallback: null | (() => void) = null;
+  private disposeProviderRequestListener() {
+    let callback = this.previousProviderRequestCancelCallback;
+    if (callback != null && callback != undefined) {
+      callback();
+    }
+    this.previousProviderRequestCancelCallback = null;
+  }
+
+  override async setOverrides({
+    provider,
+    featureOptions,
+    logConsumer,
+    sessionManagement,
+    appInfo,
+    capabilityAccessToken,
+  }: ReclaimVerification.OverrideConfig) {
+    let providerCallback = provider?.callback;
+    let providerOverride = !provider
+      ? null
+      : {
+        url: provider?.url,
+        jsonString: provider?.jsonString,
+        canFetchProviderInformationFromHost: !!providerCallback,
+      };
+    if (providerCallback) {
+      this.disposeProviderRequestListener();
+      let providerRequestSubscription =
+        NativeReclaimInappModule.onProviderInformationRequest(async (event) => {
+          try {
+            let result = await providerCallback(event);
+            NativeReclaimInappModule.replyWithString(event.replyId, result);
+          } catch (error) {
+            console.error(error);
+            NativeReclaimInappModule.replyWithString(event.replyId, '');
+          }
+        });
+      const cancel = () => {
+        providerRequestSubscription.remove();
+      };
+      this.previousProviderRequestCancelCallback = cancel;
+    }
+
+    const onLogsListener = logConsumer?.onLogs;
+    let logConsumerRequest = !logConsumer
+      ? undefined
+      : {
+        enableLogHandler: !!onLogsListener,
+        canSdkCollectTelemetry: logConsumer?.canSdkCollectTelemetry,
+        canSdkPrintLogs: logConsumer?.canSdkPrintLogs,
+      };
+    if (onLogsListener) {
+      this.disposeLogListener();
+      const cancel = () => {
+        this.previousLogSubscription?.remove();
+        this.previousLogSubscription = null;
+      };
+      this.previousLogSubscription = NativeReclaimInappModule.onLogs((arg) => {
+        onLogsListener(arg, cancel);
+      });
+    }
+
+    let sessionManagementRequest = !sessionManagement
+      ? undefined
+      : {
+        // A handler is provided, so we don't let SDK manage sessions
+        enableSdkSessionManagement: false,
+      };
+    if (sessionManagement) {
+      this.disposeSessionManagement();
+      let sessionCreateSubscription =
+        NativeReclaimInappModule.onSessionCreateRequest(async (event) => {
+          const replyId = event.replyId;
+          try {
+            let result = await sessionManagement.onSessionCreateRequest(event);
+            NativeReclaimInappModule.replyWithString(replyId, result);
+          } catch (error) {
+            console.error(error);
+            NativeReclaimInappModule.reply(replyId, false);
+          }
+        });
+      let sessionUpdateSubscription =
+        NativeReclaimInappModule.onSessionUpdateRequest(async (event) => {
+          const replyId = event.replyId;
+          try {
+            let result = await sessionManagement.onSessionUpdateRequest(event);
+            NativeReclaimInappModule.reply(replyId, result);
+          } catch (error) {
+            console.error(error);
+            NativeReclaimInappModule.reply(replyId, false);
+          }
+        });
+      let sessionLogsSubscription = NativeReclaimInappModule.onSessionLogs(
+        (event) => {
+          try {
+            sessionManagement.onLog(event);
+          } catch (error) {
+            console.error(error);
+          }
+        }
+      );
+      const cancel = () => {
+        sessionCreateSubscription.remove();
+        sessionUpdateSubscription.remove();
+        sessionLogsSubscription.remove();
+      };
+      this.previousSessionManagementCancelCallback = cancel;
+    }
+
+    try {
+      return await NativeReclaimInappModule.setOverrides({
+        provider: providerOverride,
+        featureOptions,
+        logConsumer: logConsumerRequest,
+        sessionManagement: sessionManagementRequest,
+        appInfo,
+        capabilityAccessToken,
+      });
+    } catch (error) {
+      throw new ReclaimVerification.ReclaimPlatformException(
+        'Failed to set overrides',
+        error as Error
+      );
+    }
+  }
+
+  override async clearAllOverrides() {
+    this.disposeProviderRequestListener();
+    this.disposeLogListener();
+    this.disposeSessionManagement();
+    return NativeReclaimInappModule.clearAllOverrides();
+  }
+
+  private previousAttestorAuthRequestCancelCallback: null | (() => void) = null;
+  disposeAttestorAuthRequestListener() {
+    let callback = this.previousAttestorAuthRequestCancelCallback;
+    if (callback != null && callback != undefined) {
+      callback();
+    }
+    this.previousAttestorAuthRequestCancelCallback = null;
+  }
+
+  override async setVerificationOptions(
+    options?: ReclaimVerification.VerificationOptions | null
+  ): Promise<void> {
+    let args: NativeReclaimInappModuleTypes.VerificationOptions | null = null;
+    if (options) {
+      let canUseAttestorAuthenticationRequest =
+        options.fetchAttestorAuthenticationRequest != null;
+      args = {
+        canDeleteCookiesBeforeVerificationStarts:
+          options.canDeleteCookiesBeforeVerificationStarts,
+        canUseAttestorAuthenticationRequest:
+          canUseAttestorAuthenticationRequest,
+        claimCreationType: options.claimCreationType ?? 'standalone',
+        canAutoSubmit: options.canAutoSubmit ?? true,
+        isCloseButtonVisible: options.isCloseButtonVisible ?? true,
+      };
+      if (canUseAttestorAuthenticationRequest) {
+        this.disposeAttestorAuthRequestListener();
+        let attestorAuthRequestSubscription =
+          NativeReclaimInappModule.onReclaimAttestorAuthRequest(
+            async (event) => {
+              let result = await options.fetchAttestorAuthenticationRequest(
+                event.reclaimHttpProviderJsonString
+              );
+              NativeReclaimInappModule.replyWithString(event.replyId, result);
+            }
+          );
+        const cancel = () => {
+          attestorAuthRequestSubscription.remove();
+        };
+        this.previousAttestorAuthRequestCancelCallback = cancel;
+      }
+    }
+    try {
+      return await NativeReclaimInappModule.setVerificationOptions({
+        options: args,
+      });
+    } catch (error) {
+      throw new ReclaimVerification.ReclaimPlatformException(
+        'Failed to set verification options',
+        error as Error
+      );
+    }
   }
 }

package/src/specs/NativeInappRnSdk.ts

@@ -99,12 +99,8 @@ export interface Request {
    */
   parameters?: { [key: string]: string }; // Use index signature for Map
 
-  /**
-   * Whether to automatically submit the proof after generation.
-   */
-  autoSubmit?: boolean; // Optional
-
   acceptAiProviders?: boolean; // Optional
+
   webhookUrl?: string | null; // Optional and nullable
 }
 
@@ -168,12 +164,6 @@ export interface FeatureOptions {
    */
   attestorBrowserRpcUrl?: string | null;
 
-  /**
-   * Whether response redaction regex escaping is enabled.
-   * Optional, defaults to null.
-   */
-  isResponseRedactionRegexEscapingEnabled?: boolean | null;
-
   /**
    * Whether AI flow is enabled.
    * Optional, defaults to null.
@@ -274,9 +264,13 @@ export interface SessionCreateRequestEvent {
    */
   providerId: string;
   /**
-   * The session ID for the verification attempt
+   * The session timestamp for the verification attempt
    */
-  sessionId: string;
+  timestamp: string;
+  /**
+   * The session signature for the verification attempt
+   */
+  signature: string;
   /**
    * internal
    */
@@ -322,6 +316,21 @@ export interface ProviderInformationRequest {
 export interface VerificationOptions {
   canDeleteCookiesBeforeVerificationStarts: boolean;
   canUseAttestorAuthenticationRequest: boolean;
+
+  /**
+   * The type of claim creation to use. Defaults to 'standalone'.
+   */
+  claimCreationType: 'standalone' | 'meChain';
+
+  /**
+   * Whether to automatically submit the proof after generation. Defaults to true.
+   */
+  canAutoSubmit: boolean;
+
+  /**
+   * Whether the close button is visible. Defaults to true.
+   */
+  isCloseButtonVisible: boolean;
 }
 
 export interface VerificationOptionsOptional {