cr feedback. final pass

transphorm · transphorm · commit 955f02c48ee1 · 2025-10-09T02:54:07.000-07:00
diff --git a/app/src/navigation/index.tsx b/app/src/navigation/index.tsx
@@ -48,7 +48,29 @@ const AppNavigation = createNativeStackNavigator({
   screens: navigationScreens,
 });
 
-export type RootStackParamList = StaticParamList<typeof AppNavigation>;
+type BaseRootStackParamList = StaticParamList<typeof AppNavigation>;
+
+// Explicitly declare route params that are not inferred from initialParams
+export type RootStackParamList = Omit<
+  BaseRootStackParamList,
+  'ComingSoon' | 'IDPicker' | 'AadhaarUpload' | 'AadhaarUploadError'
+> & {
+  ComingSoon: {
+    countryCode: string;
+    documentCategory?: string;
+  };
+  IDPicker: {
+    countryCode: string;
+    documentTypes: string[];
+  };
+  AadhaarUpload: {
+    countryCode: string;
+  };
+  AadhaarUploadError: {
+    errorType: string;
+  };
+};
+
 export type RootStackScreenProps<T extends keyof RootStackParamList> =
   NativeStackScreenProps<RootStackParamList, T>;
 
diff --git a/app/src/providers/selfClientProvider.tsx b/app/src/providers/selfClientProvider.tsx
@@ -28,12 +28,6 @@ import { useSettingStore } from '@/stores/settingStore';
 import analytics from '@/utils/analytics';
 
 type GlobalCrypto = { crypto?: { subtle?: Crypto['subtle'] } };
-
-type RouteParams<RouteName extends keyof RootStackParamList> = Extract<
-  RootStackParamList[RouteName],
-  object
->;
-
 /**
  * Provides a configured Self SDK client instance to all descendants.
  *
@@ -42,20 +36,24 @@ type RouteParams<RouteName extends keyof RootStackParamList> = Extract<
  * - `fetch`/`WebSocket` for network communication
  * - Web Crypto hashing with a stub signer
  */
-const navigateIfReady = <
-  RouteName extends keyof RootStackParamList,
-  Params extends RootStackParamList[RouteName],
->(
-  ...args: undefined extends Params
-    ? [route: RouteName, params?: Params]
-    : [route: RouteName, params: Params]
-) => {
+function navigateIfReady<RouteName extends keyof RootStackParamList>(
+  route: RouteName,
+  ...args: undefined extends RootStackParamList[RouteName]
+    ? [params?: RootStackParamList[RouteName]]
+    : [params: RootStackParamList[RouteName]]
+): void {
   if (navigationRef.isReady()) {
-    const [route, params] = args;
-    // @ts-expect-error-next-line
-    navigationRef.navigate(route, params);
+    const params = args[0];
+    if (params !== undefined) {
+      (navigationRef.navigate as (r: RouteName, p: typeof params) => void)(
+        route,
+        params,
+      );
+    } else {
+      navigationRef.navigate(route as never);
+    }
   }
-};
+}
 
 export const SelfClientProvider = ({ children }: PropsWithChildren) => {
   const config = useMemo(() => ({}), []);
@@ -165,10 +163,13 @@ export const SelfClientProvider = ({ children }: PropsWithChildren) => {
         countryCode: string | null;
         documentCategory: string | null;
       }) => {
-        navigateIfReady('ComingSoon', {
-          countryCode,
-          documentCategory,
-        } as never);
+        // Only navigate if we have a valid country code
+        if (countryCode) {
+          navigateIfReady('ComingSoon', {
+            countryCode,
+            documentCategory: documentCategory ?? undefined,
+          });
+        }
       },
     );
 
@@ -235,17 +236,19 @@ export const SelfClientProvider = ({ children }: PropsWithChildren) => {
       }
     });
     addListener(SdkEvents.PROVING_AADHAAR_UPLOAD_FAILURE, ({ errorType }) => {
-      const params: RouteParams<'AadhaarUploadError'> = {
-        errorType,
-      } as RouteParams<'AadhaarUploadError'>;
-      navigateIfReady('AadhaarUploadError', params);
+      navigateIfReady('AadhaarUploadError', { errorType });
     });
 
     addListener(
       SdkEvents.DOCUMENT_COUNTRY_SELECTED,
-      ({ countryCode, documentTypes }) => {
+      ({
+        countryCode,
+        documentTypes,
+      }: {
+        countryCode: string;
+        documentTypes: string[];
+      }) => {
         if (navigationRef.isReady()) {
-          // @ts-expect-error
           navigationRef.navigate('IDPicker', { countryCode, documentTypes });
         }
       },
@@ -262,10 +265,14 @@ export const SelfClientProvider = ({ children }: PropsWithChildren) => {
               navigationRef.navigate('DocumentOnboarding');
               break;
             case 'a':
-              navigationRef.navigate('AadhaarUpload', { countryCode } as never);
+              if (countryCode) {
+                navigationRef.navigate('AadhaarUpload', { countryCode });
+              }
               break;
             default:
-              navigationRef.navigate('ComingSoon', { countryCode } as never);
+              if (countryCode) {
+                navigationRef.navigate('ComingSoon', { countryCode });
+              }
               break;
           }
         }
diff --git a/app/src/types/elliptic.d.ts b/app/src/types/elliptic.d.ts
@@ -2,7 +2,39 @@
 // SPDX-License-Identifier: BUSL-1.1
 // NOTE: Converts to Apache-2.0 on 2029-06-11 per LICENSE.
 
+import type { Buffer } from 'buffer';
+
 declare module 'elliptic' {
-  const elliptic: unknown;
-  export = elliptic;
+  export interface KeyPair {
+    getPrivate(enc?: string): Buffer | string;
+    getPublic(compact?: boolean, enc?: string): Buffer | string | object;
+    sign(msg: Buffer | string, enc?: string, options?: object): Signature;
+    verify(
+      msg: Buffer | string,
+      signature: Signature | string | object,
+    ): boolean;
+    derive(pub: KeyPair): Buffer;
+  }
+
+  export interface Signature {
+    r: Buffer;
+    s: Buffer;
+    recoveryParam?: number;
+    toDER(enc?: string): Buffer | string;
+  }
+
+  export const curves: {
+    secp256k1: object;
+    p256: object;
+    p384: object;
+    p521: object;
+    [key: string]: object;
+  };
+
+  export class ec {
+    constructor(curve: string);
+    keyFromPrivate(priv: string | Buffer | number[], enc?: string): KeyPair;
+    keyFromPublic(pub: string | Buffer | object, enc?: string): KeyPair;
+    genKeyPair(options?: object): KeyPair;
+  }
 }
diff --git a/app/src/utils/analytics.ts b/app/src/utils/analytics.ts
@@ -187,26 +187,37 @@ const flushMixpanelEvents = async () => {
     if (__DEV__) console.log('[Mixpanel] flush skipped - NFC scanning active');
     return;
   }
+
+  // Ensure we don't drop events if the native reader isn't available
+  if (!PassportReader?.trackEvent) {
+    if (__DEV__)
+      console.warn('[Mixpanel] flush skipped - NFC module unavailable');
+    return;
+  }
+
   try {
     if (__DEV__) console.log('[Mixpanel] flush');
     // Send any queued events before flushing
     while (eventQueue.length > 0) {
       const evt = eventQueue.shift()!;
-      if (PassportReader && PassportReader.trackEvent) {
+      try {
         await Promise.resolve(
           PassportReader.trackEvent(evt.name, evt.properties),
         );
+      } catch (trackErr) {
+        // Put the event back and abort; we'll retry on the next flush
+        eventQueue.unshift(evt);
+        throw trackErr;
       }
     }
-    if (PassportReader && PassportReader.flush)
+    if (PassportReader.flush) {
       await Promise.resolve(PassportReader.flush());
+    }
+    // Only reset event count after successful send/flush
     eventCount = 0;
   } catch (err) {
     if (__DEV__) console.warn('Mixpanel flush failed', err);
-    // re-queue on failure
-    if (typeof err !== 'undefined') {
-      // no-op, events are already queued if failure happened before flush
-    }
+    // Events have been re-queued on failure, so they're not lost
   }
 };
 
diff --git a/app/src/utils/nfcScanner.ts b/app/src/utils/nfcScanner.ts
@@ -11,7 +11,6 @@ import type { NFCScanContext } from '@selfxyz/mobile-sdk-alpha';
 import { logNFCEvent } from '@/Sentry';
 import {
   type AndroidScanResponse,
-  PassportReader,
   reset,
   scan as scanDocument,
 } from '@/utils/passportReader';
@@ -94,24 +93,8 @@ const scanIOS = async (
   inputs: Inputs,
   context: Omit<NFCScanContext, 'stage'>,
 ) => {
-  // Narrow type for iOS-specific method availability
-  const iosReader = PassportReader as
-    | (typeof PassportReader & {
-        scanPassport?: (
-          passportNumber: string,
-          dateOfBirth: string,
-          dateOfExpiry: string,
-          canNumber: string,
-          useCan: boolean,
-          skipPACE: boolean,
-          skipCA: boolean,
-          extendedMode: boolean,
-          usePacePolling: boolean,
-          sessionId: string,
-        ) => unknown;
-      })
-    | null;
-  if (!iosReader?.scanPassport) {
+  // Use normalized cross-platform scan to avoid duplicated iOS code paths
+  if (!scanDocument) {
     console.warn(
       'iOS passport scanner is not available - native module failed to load',
     );
@@ -126,25 +109,24 @@ const scanIOS = async (
     );
   }
 
-  return await Promise.resolve(
-    iosReader.scanPassport(
-      inputs.passportNumber,
-      inputs.dateOfBirth,
-      inputs.dateOfExpiry,
-      inputs.canNumber ?? '',
-      inputs.useCan ?? false,
-      inputs.skipPACE ?? false,
-      inputs.skipCA ?? false,
-      inputs.extendedMode ?? false,
-      inputs.usePacePolling ?? false,
-      inputs.sessionId,
-    ),
-  );
+  return await scanDocument({
+    documentNumber: inputs.passportNumber,
+    dateOfBirth: inputs.dateOfBirth,
+    dateOfExpiry: inputs.dateOfExpiry,
+    canNumber: inputs.canNumber ?? '',
+    useCan: inputs.useCan ?? false,
+    skipPACE: inputs.skipPACE ?? false,
+    skipCA: inputs.skipCA ?? false,
+    extendedMode: inputs.extendedMode ?? false,
+    usePacePolling: inputs.usePacePolling ?? false,
+    sessionId: inputs.sessionId,
+  });
 };
 
 const handleResponseIOS = (response: unknown) => {
-  const parsed = JSON.parse(String(response));
-  const dgHashesObj = JSON.parse(parsed?.dataGroupHashes);
+  // Response is already parsed as an object by the normalized scan function
+  const parsed = response as Record<string, unknown>;
+  const dgHashesObj = JSON.parse(String(parsed?.dataGroupHashes ?? '{}'));
   const dg1HashString = dgHashesObj?.DG1?.sodHash;
   const dg1Hash = Array.from(Buffer.from(dg1HashString, 'hex'));
   const dg2HashString = dgHashesObj?.DG2?.sodHash;
@@ -164,24 +146,29 @@ const handleResponseIOS = (response: unknown) => {
   // const _encapsulatedContentDigestAlgorithm =
   //   parsed?.encapsulatedContentDigestAlgorithm;
   const documentSigningCertificate = parsed?.documentSigningCertificate;
-  const pem = JSON.parse(documentSigningCertificate).PEM.replace(/\n/g, '');
-  const eContentArray = Array.from(Buffer.from(signedAttributes, 'base64'));
+  const pem = JSON.parse(String(documentSigningCertificate)).PEM.replace(
+    /\n/g,
+    '',
+  );
+  const eContentArray = Array.from(
+    Buffer.from(String(signedAttributes), 'base64'),
+  );
   const signedEContentArray = eContentArray.map(byte =>
     byte > 127 ? byte - 256 : byte,
   );
 
   const concatenatedDataHashesArray = Array.from(
-    Buffer.from(eContentBase64, 'base64'),
+    Buffer.from(String(eContentBase64), 'base64'),
   );
   const concatenatedDataHashesArraySigned = concatenatedDataHashesArray.map(
     byte => (byte > 127 ? byte - 256 : byte),
   );
 
   const encryptedDigestArray = Array.from(
-    Buffer.from(signatureBase64, 'base64'),
+    Buffer.from(String(signatureBase64), 'base64'),
   ).map(byte => (byte > 127 ? byte - 256 : byte));
 
-  const document_type = mrz.length === 88 ? 'passport' : 'id_card';
+  const document_type = String(mrz).length === 88 ? 'passport' : 'id_card';
 
   return {
     mrz,
