@reclaimprotocol/inapp-rn-sdk 0.1.3

package/src/ReclaimVerificationPlatformChannel.ts

@@ -0,0 +1,245 @@
+import type { EventSubscription } from "react-native";
+import NativeReclaimInappModule from "./specs/NativeInappRnSdk";
+import * as NativeReclaimInappModuleTypes from "./specs/NativeInappRnSdk";
+
+/**
+ * This namespace provides types involved in initiating and managing the verification process
+ * for proving claims about user data through various providers.
+ */
+export namespace ReclaimVerificationApi {
+    /**
+     * 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;
+
+    /**
+     * Represents a request for a verification attempt.
+     *
+     * You can create a request using the [ReclaimVerification.Request] constructor or the [ReclaimVerification.Request.fromManifestMetaData] factory method.
+     */
+    export type Request = NativeReclaimInappModuleTypes.Request;
+
+    /**
+     * Contains the proof and response data after verification
+     */
+    export type Response = NativeReclaimInappModuleTypes.Response;
+
+    export namespace Overrides {
+        export type ProviderInformation = NativeReclaimInappModuleTypes.ProviderInformation;
+        export type FeatureOptions = NativeReclaimInappModuleTypes.FeatureOptions;
+        export interface LogConsumer {
+            /**
+             * Handler for consuming logs exported from the SDK.
+             * Defaults to false.
+             */
+            onLogs?: (logJsonString: String, cancel: () => void) => void;
+
+            /**
+             * When enabled, logs are sent to reclaim that can be used to help you.
+             * Defaults to true.
+             */
+            canSdkCollectTelemetry?: boolean;
+
+            /**
+             * Defaults to enabled when not in release mode.
+             */
+            canSdkPrintLogs?: boolean;
+        }
+        export interface SessionManagement {
+            onLog: (event: NativeReclaimInappModuleTypes.SessionLogEvent) => void;
+            onSessionCreateRequest: (event: NativeReclaimInappModuleTypes.SessionCreateRequestEvent) => Promise<boolean>;
+            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
+    }
+
+    export enum ExceptionType {
+        Cancelled = "Cancelled",
+        Dismissed = "Dismissed",
+        SessionExpired = "SessionExpired",
+        Failed = "Failed",
+    }
+
+    export class ReclaimVerificationException extends Error {
+        readonly innerError: Error
+        readonly type: ExceptionType
+        readonly sessionId: string
+        readonly "didSubmitManualVerification": boolean
+        readonly "reason": string
+
+        constructor(
+            message: string,
+            innerError: Error,
+            type: ExceptionType,
+            sessionId: string,
+            didSubmitManualVerification: boolean,
+            reason: string
+        ) {
+            super(message);
+            this.innerError = innerError;
+            this.type = type;
+            this.sessionId = sessionId;
+            this.didSubmitManualVerification = didSubmitManualVerification;
+            this.reason = reason;
+        }
+
+        private static fromTypeName(name: string): ExceptionType {
+            switch (name) {
+                case "cancelled":
+                case "org.reclaimprotocol.inapp_sdk.ReclaimVerification.ReclaimVerificationException.Cancelled":
+                    return ExceptionType.Cancelled;
+                case "dismissed":
+                case "org.reclaimprotocol.inapp_sdk.ReclaimVerification.ReclaimVerificationException.Dismissed":
+                    return ExceptionType.Dismissed;
+                case "sessionExpired":
+                case "org.reclaimprotocol.inapp_sdk.ReclaimVerification.ReclaimVerificationException.SessionExpired":
+                    return ExceptionType.SessionExpired;
+                case "failed":
+                case "org.reclaimprotocol.inapp_sdk.ReclaimVerification.ReclaimVerificationException.Failed":
+                    return ExceptionType.Failed;
+            }
+            return ExceptionType.Failed;
+        }
+
+        static fromError(error: Error, sessionIdHint: string): ReclaimVerificationException {
+            if (Object.hasOwn(error, 'userInfo')) {
+                // From native, we send information about error in userInfo
+                let unTypedError = (error as unknown as any);
+                let userInfo = unTypedError.userInfo;
+                if (userInfo) {
+                    let type = ReclaimVerificationApi.ReclaimVerificationException.fromTypeName(unTypedError.userInfo.errorType);
+                    let maybeSessionId = unTypedError?.userInfo?.sessionId
+                    return new ReclaimVerificationException(
+                        error.message,
+                        error,
+                        type,
+                        (typeof maybeSessionId === 'string' && maybeSessionId)
+                            ? maybeSessionId : sessionIdHint,
+                        unTypedError?.userInfo?.didSubmitManualVerification ?? false,
+                        unTypedError?.userInfo?.reason ?? ""
+                    );
+                }
+            }
+            return new ReclaimVerificationException(
+                error.message,
+                error,
+                ReclaimVerificationApi.ExceptionType.Failed,
+                sessionIdHint,
+                false,
+                ""
+            );
+        }
+    }
+}
+
+export class ReclaimVerificationPlatformChannel {
+    async startVerification(request: ReclaimVerificationApi.Request): Promise<ReclaimVerificationApi.Response> {
+        try {
+            return await NativeReclaimInappModule.startVerification(request);
+        } catch (error) {
+            console.info({
+                error
+            })
+            if (error instanceof Error) {
+                throw ReclaimVerificationApi.ReclaimVerificationException.fromError(error, request.session?.sessionId ?? "");
+            }
+            throw error
+        }
+    }
+
+    async startVerificationFromUrl(requestUrl: string): Promise<ReclaimVerificationApi.Response> {
+        try {
+            return await NativeReclaimInappModule.startVerificationFromUrl(requestUrl);
+        } catch (error) {
+            console.info({
+                error
+            })
+            if (error instanceof Error) {
+                throw ReclaimVerificationApi.ReclaimVerificationException.fromError(error, "");
+            }
+            throw error
+        }
+    }
+
+    async ping(): Promise<boolean> {
+        return await NativeReclaimInappModule.ping();
+    }
+
+    private previousLogSubscription: EventSubscription | null = null;
+    private previousSessionManagementCancelCallback: null | (() => void) = null;
+
+    setOverrides({
+        provider,
+        featureOptions,
+        logConsumer,
+        sessionManagement,
+        appInfo
+    }: ReclaimVerificationApi.OverrideConfig) {
+        this.previousLogSubscription?.remove()
+        this.previousLogSubscription = null;
+        let callback = this.previousSessionManagementCancelCallback;
+        if (callback != null) {
+            callback();
+        }
+        this.previousSessionManagementCancelCallback = null;
+
+        let logConsumerRequest = logConsumer == null ? undefined : {
+            enableLogHandler: logConsumer?.onLogs != null,
+            canSdkCollectTelemetry: logConsumer?.canSdkCollectTelemetry,
+            canSdkPrintLogs: logConsumer?.canSdkPrintLogs
+        }
+        const onLogsListener = logConsumer?.onLogs;
+        if (onLogsListener != null) {
+            const cancel = () => {
+                this.previousLogSubscription?.remove();
+                this.previousLogSubscription = null;
+            };
+            this.previousLogSubscription = NativeReclaimInappModule.onLogs((arg) => {
+                onLogsListener(arg, cancel);
+            })
+        }
+
+        let sessionManagementRequest = sessionManagement == null ? undefined : {
+            // A handler is provided, so we don't let SDK manage sessions
+            enableSdkSessionManagement: false
+        }
+        if (sessionManagement != null) {
+            let sessionCreateSubscription = NativeReclaimInappModule.onSessionCreateRequest(async (event) => {
+                const replyId = event.replyId;
+                let result = await sessionManagement.onSessionCreateRequest(event);
+                NativeReclaimInappModule.reply(replyId, result);
+            });
+            let sessionUpdateSubscription = NativeReclaimInappModule.onSessionUpdateRequest(async (event) => {
+                const replyId = event.replyId;
+                let result = await sessionManagement.onSessionUpdateRequest(event);
+                NativeReclaimInappModule.reply(replyId, result);
+            });
+            let sessionLogsSubscription = NativeReclaimInappModule.onSessionLogs((event) => {
+                sessionManagement.onLog(event);
+            });
+            const cancel = () => {
+                sessionCreateSubscription.remove()
+                sessionUpdateSubscription.remove()
+                sessionLogsSubscription.remove()
+            }
+            this.previousSessionManagementCancelCallback = cancel;
+        }
+
+        NativeReclaimInappModule.setOverrides({
+            provider,
+            featureOptions,
+            logConsumer: logConsumerRequest,
+            sessionManagement: sessionManagementRequest,
+            appInfo
+        });
+    }
+}

package/src/index.tsx

@@ -0,0 +1,32 @@
+import { ReclaimVerificationPlatformChannel, type ReclaimVerificationApi } from './ReclaimVerificationPlatformChannel';
+export { ReclaimVerificationPlatformChannel, ReclaimVerificationApi } from './ReclaimVerificationPlatformChannel';
+export type { ReclaimVerificationApi as ReclaimVerificationApiType } from './ReclaimVerificationPlatformChannel';
+
+export class ReclaimVerification {
+  public channel: ReclaimVerificationPlatformChannel;
+
+  private static defaultChannel: ReclaimVerificationPlatformChannel | null = null;
+
+  public constructor(channel?: ReclaimVerificationPlatformChannel) {
+    if (channel) {
+      this.channel = channel;
+    } else {
+      if (ReclaimVerification.defaultChannel == null) {
+        ReclaimVerification.defaultChannel = new ReclaimVerificationPlatformChannel();
+      }
+      this.channel = ReclaimVerification.defaultChannel;
+    }
+  }
+
+  public async startVerification(request: ReclaimVerificationApi.Request): Promise<ReclaimVerificationApi.Response> {
+    return this.channel.startVerification(request);
+  }
+
+  public async ping(): Promise<boolean> {
+    return this.channel.ping();
+  }
+
+  public setOverrides(overrides: ReclaimVerificationApi.OverrideConfig) {
+    this.channel.setOverrides(overrides);
+  }
+}

package/src/specs/NativeInappRnSdk.ts

@@ -0,0 +1,313 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
+
+export interface SessionInformation {
+  /**
+   * The timestamp of the session creation.
+   *
+   * Represented as a string from number of milliseconds since
+   * the "Unix epoch" 1970-01-01T00:00:00Z (UTC).
+   *
+   * This value is independent of the time zone.
+   *
+   * This value is at most 8,640,000,000,000,000ms (100,000,000 days) from the Unix epoch.
+   */
+  timestamp: string;
+
+  /**
+   * Unique identifier for the verification session
+   */
+  sessionId: string;
+
+  /**
+   * Cryptographic signature to validate the session
+   */
+  signature: string;
+}
+/**
+   * Represents a request for a verification attempt.
+   *
+   * You can create a request using the [ReclaimVerification.Request] constructor or the [ReclaimVerification.Request.fromManifestMetaData] factory method.
+   */
+export interface Request {
+  /**
+   * The Reclaim application ID for the verification process.
+   * If not provided, the appId will be fetched from:
+   * - the `AndroidManifest.xml` metadata along with secret on android:
+   * 
+   * ```xml
+   * <meta-data android:name="org.reclaimprotocol.inapp_sdk.APP_ID"
+   *            android:value="YOUR_RECLAIM_APP_ID" />
+   * ```
+   * 
+   * - the `ReclaimInAppSDKParam.ReclaimAppId` in Info.plist along with secret on iOS:
+   * 
+   * ```xml
+   * <key>ReclaimInAppSDKParam</key>
+   * <dict>
+   *    <key>ReclaimAppId</key>
+   *    <string>YOUR_RECLAIM_APP_ID</string>
+   *    <key>ReclaimAppSecret</key>
+   *    <string>YOUR_RECLAIM_APP_SECRET</string>
+   * </dict>
+   * ```
+   */
+  appId: string;
+
+  /**
+   * The Reclaim application secret for the verification process.
+   * If not provided, the secret will be fetched from:
+   * - the `AndroidManifest.xml` metadata along with appId on android:
+   * 
+   * ```xml
+   * <meta-data android:name="org.reclaimprotocol.inapp_sdk.APP_SECRET"
+   *            android:value="YOUR_RECLAIM_APP_SECRET" />
+   * ```
+   * 
+   * - the `ReclaimInAppSDKParam.ReclaimAppSecret` in Info.plist along with appId on iOS:
+   * 
+   * ```xml
+   * <key>ReclaimInAppSDKParam</key>
+   * <dict>
+   *    <key>ReclaimAppId</key>
+   *    <string>YOUR_RECLAIM_APP_ID</string>
+   *    <key>ReclaimAppSecret</key>
+   *    <string>YOUR_RECLAIM_APP_SECRET</string>
+   * </dict>
+   * ```
+   */
+  secret: string;
+
+  /**
+   * The identifier for the Reclaim data provider to use in verification
+   */
+  providerId: string;
+
+  /**
+   * Optional session information. If nil, SDK generates new session details.
+   */
+  session?: SessionInformation | null; // Allow null as well
+
+  /**
+   * Additional data to associate with the verification attempt
+   */
+  contextString?: string; // Optional
+
+  /**
+   * Key-value pairs for prefilling claim creation variables
+   */
+  parameters?: { [key: string]: string }; // Use index signature for Map
+
+  /**
+   * Whether to hide the landing page of the verification process. When false, shows an introductory page with claims to be proven.
+   */
+  hideLanding?: boolean; // Optional
+
+  /**
+   * Whether to automatically submit the proof after generation.
+   */
+  autoSubmit?: boolean; // Optional
+
+  acceptAiProviders?: boolean; // Optional
+  webhookUrl?: string | null; // Optional and nullable
+}
+
+/**
+ * Contains the proof and response data after verification
+ */
+export interface Response {
+  /**
+   * The session ID for the verification attempt
+   */
+  sessionId: string;
+
+  /**
+   * Whether the proof was submitted manually
+   */
+  didSubmitManualVerification: boolean;
+
+  /**
+   * The list of proofs generated during the verification attempt
+   */
+  proofs: { [key: string]: any }[]; // Array of dictionaries
+  // proofs: string[]; // Array of dictionaries
+}
+
+export interface ProviderInformation {
+  url?: string;
+  jsonString?: string;
+}
+
+/**
+* Interface representing Feature Options.
+*/
+export interface FeatureOptions {
+  /**
+   * Whether to persist a cookie.
+   * Optional, defaults to null.
+   */
+  cookiePersist?: boolean | null;
+
+  /**
+   * Whether to allow a single reclaim request.
+   * Optional, defaults to null.
+   */
+  singleReclaimRequest?: boolean | null;
+
+  /**
+   * Idle time threshold (in milliseconds?) for triggering manual verification.
+   * Optional, defaults to null.
+   */
+  idleTimeThresholdForManualVerificationTrigger?: number | null;
+
+  /**
+   * Session timeout (in milliseconds?) for triggering manual verification.
+   * Optional, defaults to null.
+   */
+  sessionTimeoutForManualVerificationTrigger?: number | null;
+
+  /**
+   * URL for the Attestor Browser RPC.
+   * Optional, defaults to null.
+   */
+  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.
+   */
+  isAIFlowEnabled?: boolean | null;
+}
+
+export interface LogConsumer {
+  /**
+   * Handler for consuming logs exported from the SDK.
+   * Defaults to false.
+   */
+  enableLogHandler: boolean;
+
+  /**
+   * When enabled, logs are sent to reclaim that can be used to help you.
+   * Defaults to true.
+   */
+  canSdkCollectTelemetry?: boolean;
+
+  /**
+   * Defaults to enabled when not in release mode.
+   */
+  canSdkPrintLogs?: boolean;
+}
+
+/**
+ * Interface representing Reclaim App Information.
+ */
+export interface ReclaimAppInfo {
+  /**
+   * The name of the application.
+   */
+  appName: string;
+
+  /**
+   * The URL of the application's image.
+   */
+  appImageUrl: string;
+
+  /**
+   * Whether the reclaim is recurring.
+   * Optional, defaults to false.
+   */
+  isRecurring?: boolean;
+}
+
+export interface SessionManagement {
+  /**
+   * Whether to enable SDK session management.
+   * Optional, defaults to true.
+   * 
+   * When false, a handler must be provided. We'll not let SDK manage sessions in this case.
+   */
+  enableSdkSessionManagement?: boolean;
+}
+
+export interface SessionLogEvent {
+  /**
+   * The app ID for the verification attempt
+   */
+  appId: string;
+  /**
+   * The provider ID for the verification attempt
+   */
+  providerId: string;
+  /**
+   * The session ID for the verification attempt
+   */
+  sessionId: string;
+  /**
+   * The type of log event
+   */
+  logType: string;
+}
+
+export interface SessionCreateRequestEvent {
+  /**
+   * The app ID for the verification attempt
+   */
+  appId: string;
+  /**
+   * The provider ID for the verification attempt
+   */
+  providerId: string;
+  /**
+   * The session ID for the verification attempt
+   */
+  sessionId: string;
+  /**
+   * internal
+   */
+  readonly replyId: string;
+}
+
+export interface SessionUpdateRequestEvent {
+  /**
+   * The session ID for the verification attempt
+  */
+  sessionId: string;
+  /**
+   * The status type of this session event
+   */
+  status: string;
+  /**
+   * internal
+   */
+  readonly replyId: string;
+}
+
+export interface Overrides {
+  provider?: ProviderInformation | null,
+  featureOptions?: FeatureOptions | null,
+  logConsumer?: LogConsumer | null,
+  sessionManagement?: SessionManagement | null,
+  appInfo?: ReclaimAppInfo | null
+}
+
+export interface Spec extends TurboModule {
+  startVerification(request: Request): Promise<Response>;
+  startVerificationFromUrl(requestUrl: string): Promise<Response>;
+  setOverrides(overrides: Overrides): Promise<void>;
+  reply(replyId: string, reply: boolean): void;
+  ping(): Promise<boolean>;
+
+  readonly onLogs: EventEmitter<string>
+  readonly onSessionLogs: EventEmitter<SessionLogEvent>
+  readonly onSessionCreateRequest: EventEmitter<SessionCreateRequestEvent>
+  readonly onSessionUpdateRequest: EventEmitter<SessionUpdateRequestEvent>
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('InappRnSdk');