@trustchex/react-native-sdk 1.500.2 → 1.501.0

package/lib/typescript/src/Translation/Resources/tr.d.ts

@@ -10,6 +10,8 @@ declare const _default: {
     'verificationSessionCheckScreen.or': string;
     'general.warning': string;
     'general.error': string;
+    'general.continue': string;
+    'general.cancel': string;
     'general.yes': string;
     'general.no': string;
     'general.letsGo': string;
@@ -24,6 +26,7 @@ declare const _default: {
     'termsOfUseAndDataPrivacyScreen.acceptAndContinue': string;
     'resultScreen.submitting': string;
     'resultScreen.submissionFailed': string;
+    'resultScreen.sessionTerminated': string;
     'resultScreen.submissionFailedTitle': string;
     'resultScreen.submissionFailedRetryHint': string;
     'resultScreen.retrySubmission': string;
@@ -90,10 +93,23 @@ declare const _default: {
     'eidScannerScreen.nfcAuthFailed': string;
     'eidScannerScreen.nfcTagLost': string;
     'eidScannerScreen.nfcTimeout': string;
+    'addressCaptureScreen.title': string;
+    'addressCaptureScreen.subtitle': string;
+    'addressCaptureScreen.prefilledFromChip': string;
+    'addressCaptureScreen.addressLabel': string;
+    'addressCaptureScreen.addressPlaceholder': string;
+    'addressCaptureScreen.proofLabel': string;
+    'addressCaptureScreen.proofHint': string;
+    'addressCaptureScreen.captureProof': string;
+    'addressCaptureScreen.retakeProof': string;
+    'addressCaptureScreen.proofCameraHint': string;
+    'addressCaptureScreen.capture': string;
     'eidScannerScreen.faceImageNotFound': string;
     'eidScannerScreen.documentCode': string;
     'eidScannerScreen.nationality': string;
     'eidScannerScreen.personalNumber': string;
+    'eidScannerScreen.address': string;
+    'eidScannerScreen.location': string;
     'eidScannerScreen.documentNumber': string;
     'eidScannerScreen.name': string;
     'eidScannerScreen.surname': string;

package/lib/typescript/src/Translation/Resources/tr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/tr.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBA4SE"}
+{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../../../../src/Translation/Resources/tr.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAiUE"}

package/lib/typescript/src/Trustchex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Trustchex.d.ts","sourceRoot":"","sources":["../../../src/Trustchex.tsx"],"names":[],"mappings":"AAAA,OAAO,KAMN,MAAM,OAAO,CAAC;AAKf,OAAO,gCAAgC,CAAC;AAmBxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAe5E,UAAU,iBAAiB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,cAAc;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,MAAM,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACtD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpE,iGAAiG;IACjG,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gGAAgG;IAChG,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AASD,QAAA,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,cAAc,CAwQvC,CAAC;AAWF,eAAe,SAAS,CAAC"}
+{"version":3,"file":"Trustchex.d.ts","sourceRoot":"","sources":["../../../src/Trustchex.tsx"],"names":[],"mappings":"AAAA,OAAO,KAMN,MAAM,OAAO,CAAC;AAKf,OAAO,gCAAgC,CAAC;AAoBxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAe5E,UAAU,iBAAiB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,cAAc;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,MAAM,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACtD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpE,iGAAiG;IACjG,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gGAAgG;IAChG,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AASD,QAAA,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,cAAc,CA4QvC,CAAC;AAWF,eAAe,SAAS,CAAC"}

package/lib/typescript/src/version.d.ts

@@ -1,2 +1,2 @@
-export declare const SDK_VERSION = "1.500.2";
+export declare const SDK_VERSION = "1.501.0";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trustchex/react-native-sdk",
-  "version": "1.500.2",
+  "version": "1.501.0",
   "description": "Trustchex mobile app react native SDK for android or ios devices",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/Screens/Dynamic/AddressCaptureScreen.tsx

@@ -0,0 +1,196 @@
+import React, { useContext, useEffect, useRef, useState } from 'react';
+import {
+  SafeAreaView,
+  View,
+  Text,
+  TextInput,
+  StyleSheet,
+  ScrollView,
+  Image,
+  TouchableOpacity,
+} from 'react-native';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import { useTranslation } from 'react-i18next';
+import {
+  TrustchexCamera,
+  type Frame,
+} from '../../Shared/Components/TrustchexCamera';
+import NavigationManager, {
+  type NavigationManagerRef,
+} from '../../Shared/Components/NavigationManager';
+import AppContext from '../../Shared/Contexts/AppContext';
+import StyledButton from '../../Shared/Components/StyledButton';
+import { useStatusBarWhiteBackground } from '../../Shared/Libs/status-bar.utils';
+import {
+  useScreenTracking,
+  trackVerificationStart,
+  trackVerificationComplete,
+} from '../../Shared/Libs/analytics.utils';
+import { useKeepAwake } from '../../Shared/Libs/native-keep-awake.utils';
+
+/**
+ * ADDRESS_CAPTURE step (MASAK Tebliğ No. 32 Article 4/C(1)(d)). The user confirms
+ * their address — pre-filled from the chip's DG11 address when available — and
+ * captures a proof document (residence cert / utility bill ≤3 months / public-
+ * authority doc). The address is verified later by an operator (manual review).
+ */
+const AddressCaptureScreen = () => {
+  useKeepAwake();
+  useStatusBarWhiteBackground();
+  useScreenTracking('address_capture');
+
+  const appContext = useContext(AppContext);
+  const navigationManagerRef = useRef<NavigationManagerRef>(null);
+  const { t } = useTranslation();
+  const insets = useSafeAreaInsets();
+
+  // Pre-fill from the chip's DG11 address when the NFC read provided one.
+  const chipAddress =
+    appContext.lastDocumentRead?.document.address ?? '';
+  const [addressText, setAddressText] = useState<string>(chipAddress);
+  const [fromChip] = useState<boolean>(!!chipAddress);
+
+  const [proofImage, setProofImage] = useState<string | undefined>();
+  const [isCameraOpen, setIsCameraOpen] = useState(false);
+  const captureNextFrame = useRef(false);
+
+  // Whether the proof document is required is configurable per workflow step.
+  const proofRequired =
+    appContext.currentWorkflowStep?.data?.addressProofRequired !== false;
+
+  useEffect(() => {
+    trackVerificationStart('ADDRESS_CAPTURE');
+  }, []);
+
+  const onFrameAvailable = (frame: Frame) => {
+    if (!captureNextFrame.current) return;
+    const b64 = frame.base64Image;
+    if (b64) {
+      captureNextFrame.current = false;
+      setProofImage(b64);
+      setIsCameraOpen(false);
+    }
+  };
+
+  const canContinue =
+    addressText.trim().length > 0 && (!proofRequired || !!proofImage);
+
+  const onContinue = () => {
+    appContext.identificationInfo.address = {
+      addressText: addressText.trim(),
+      fromChip,
+      proofImage,
+      proofImageMimeType: proofImage ? 'image/jpeg' : undefined,
+    };
+    trackVerificationComplete('ADDRESS_CAPTURE', true, 1);
+    navigationManagerRef.current?.navigateToNextStep();
+  };
+
+  if (isCameraOpen) {
+    return (
+      <SafeAreaView style={styles.cameraContainer}>
+        <TrustchexCamera
+          style={styles.camera}
+          includeBase64
+          onFrameAvailable={(e) => onFrameAvailable(e.nativeEvent.frame)}
+        />
+        <View style={[styles.cameraControls, { paddingBottom: insets.bottom + 16 }]}>
+          <Text style={styles.cameraHint}>
+            {t('addressCaptureScreen.proofCameraHint')}
+          </Text>
+          <StyledButton onPress={() => (captureNextFrame.current = true)}>
+            {t('addressCaptureScreen.capture')}
+          </StyledButton>
+          <TouchableOpacity onPress={() => setIsCameraOpen(false)}>
+            <Text style={styles.cancel}>{t('general.cancel')}</Text>
+          </TouchableOpacity>
+        </View>
+      </SafeAreaView>
+    );
+  }
+
+  return (
+    <SafeAreaView style={styles.container}>
+      <ScrollView
+        contentContainerStyle={[styles.content, { paddingBottom: insets.bottom + 24 }]}
+        keyboardShouldPersistTaps="handled"
+      >
+        <Text style={styles.title}>{t('addressCaptureScreen.title')}</Text>
+        <Text style={styles.subtitle}>{t('addressCaptureScreen.subtitle')}</Text>
+
+        {fromChip ? (
+          <Text style={styles.chipHint}>
+            {t('addressCaptureScreen.prefilledFromChip')}
+          </Text>
+        ) : null}
+
+        <Text style={styles.label}>{t('addressCaptureScreen.addressLabel')}</Text>
+        <TextInput
+          style={styles.input}
+          value={addressText}
+          onChangeText={setAddressText}
+          placeholder={t('addressCaptureScreen.addressPlaceholder')}
+          multiline
+          textAlignVertical="top"
+        />
+
+        <Text style={styles.label}>{t('addressCaptureScreen.proofLabel')}</Text>
+        <Text style={styles.proofHint}>{t('addressCaptureScreen.proofHint')}</Text>
+        {proofImage ? (
+          <Image
+            source={{ uri: `data:image/jpeg;base64,${proofImage}` }}
+            style={styles.proofPreview}
+            resizeMode="cover"
+          />
+        ) : null}
+        <StyledButton onPress={() => setIsCameraOpen(true)}>
+          {proofImage
+            ? t('addressCaptureScreen.retakeProof')
+            : t('addressCaptureScreen.captureProof')}
+        </StyledButton>
+      </ScrollView>
+
+      <View style={[styles.footer, { paddingBottom: insets.bottom + 12 }]}>
+        <StyledButton disabled={!canContinue} onPress={onContinue}>
+          {t('general.continue')}
+        </StyledButton>
+      </View>
+
+      <NavigationManager ref={navigationManagerRef} />
+    </SafeAreaView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#FFFFFF' },
+  content: { padding: 20 },
+  title: { fontSize: 22, fontWeight: '700', color: '#111', marginBottom: 8 },
+  subtitle: { fontSize: 15, color: '#555', marginBottom: 16 },
+  chipHint: { fontSize: 13, color: '#2E7D32', marginBottom: 12 },
+  label: { fontSize: 14, fontWeight: '600', color: '#222', marginTop: 16, marginBottom: 6 },
+  input: {
+    borderWidth: 1,
+    borderColor: '#CCC',
+    borderRadius: 8,
+    padding: 12,
+    minHeight: 88,
+    fontSize: 15,
+    color: '#111',
+  },
+  proofHint: { fontSize: 13, color: '#777', marginBottom: 10 },
+  proofPreview: {
+    width: '100%',
+    height: 180,
+    borderRadius: 8,
+    marginBottom: 12,
+    backgroundColor: '#EEE',
+  },
+  footer: { paddingHorizontal: 20, paddingTop: 8, backgroundColor: '#FFFFFF' },
+  cameraContainer: { flex: 1, backgroundColor: '#000' },
+  camera: { flex: 1 },
+  cameraControls: { paddingHorizontal: 20, gap: 12, backgroundColor: '#000' },
+  cameraHint: { color: '#FFF', textAlign: 'center', marginBottom: 8 },
+  cancel: { color: '#FFF', textAlign: 'center', marginTop: 8, fontSize: 15 },
+});
+
+export default AddressCaptureScreen;

package/src/Screens/Dynamic/ContractAcceptanceScreen.tsx

@@ -15,6 +15,7 @@ import AppContext from '../../Shared/Contexts/AppContext';
 import { getI18n, useTranslation } from 'react-i18next';
 import StyledButton from '../../Shared/Components/StyledButton';
 import NativeDeviceInfo from '../../Shared/Libs/native-device-info.utils';
+import { captureCoarseGeolocation } from '../../Shared/Libs/geolocation.utils';
 import { speakWithDebounce } from '../../Shared/Libs/tts.utils';
 import { useStatusBarWhiteBackground } from '../../Shared/Libs/status-bar.utils';
 import {
@@ -174,6 +175,17 @@ const ContractAcceptanceScreen = () => {
               consent.contractIds.push(acceptedContractId);
               consent.deviceInfo = await generateHumanReadableIdentifier();
 
+              // MASAK 4/C(1)(e): when the workflow step opts in via
+              // collectGeolocation, capture coarse geolocation alongside the
+              // technical data. Fail-soft — a denied permission or missing
+              // module yields null and does not block.
+              if (appContext.currentWorkflowStep?.data?.collectGeolocation) {
+                // Mark that geolocation was REQUIRED so the server can raise a
+                // suspicion signal (4/C(1)(e)) when it comes back null (denied).
+                consent.geolocationExpected = true;
+                consent.geolocation = await captureCoarseGeolocation();
+              }
+
               // Update the context with the new device info
               appContext.identificationInfo.consent = consent;
             }

package/src/Screens/Dynamic/IdentityDocumentEIDScanningScreen.tsx

@@ -17,6 +17,7 @@ import {
   trackVerificationStart,
   trackVerificationComplete,
 } from '../../Shared/Libs/analytics.utils';
+import { isCountryAllowed } from '../../Shared/Libs/country-allow';
 import { useKeepAwake } from '../../Shared/Libs/native-keep-awake.utils';
 
 const IdentityDocumentEIDScanningScreen = () => {
@@ -56,7 +57,7 @@ const IdentityDocumentEIDScanningScreen = () => {
   const [allowedDocumentTypes, setAllowedDocumentTypes] = useState<
     ('I' | 'P')[] | null
   >(null);
-  const [allowedCountries, setAllowedCountries] = useState<'TUR'[] | null>(
+  const [allowedCountries, setAllowedCountries] = useState<string[] | null>(
     null
   );
 
@@ -105,6 +106,16 @@ const IdentityDocumentEIDScanningScreen = () => {
             dateOfBirth={dateOfBirth}
             dateOfExpiry={dateOfExpiry}
             documentType={documentType}
+            vizMrzFields={
+              // The printed/VIZ MRZ from the EID step's own camera scan. For a
+              // passport it's on the data page (passportData); for a TD1 ID card
+              // the MRZ is on the BACK (idBackSideData), so it must be included
+              // — without it, ID-card scans had no VIZ source and hard-blocked.
+              passportData?.mrzFields ??
+              idBackSideData?.mrzFields ??
+              idFrontSideData?.mrzFields ??
+              appContext.identificationInfo.scannedDocument?.mrzFields
+            }
             onScanSuccess={(mrzFields, faceImage, mimeType) => {
               if (mrzFields && faceImage && mimeType) {
                 if (!appContext.identificationInfo.scannedDocument) {
@@ -118,6 +129,33 @@ const IdentityDocumentEIDScanningScreen = () => {
                   'EID';
                 appContext.identificationInfo.scannedDocument.mrzFields =
                   mrzFields;
+                // Preserve the printed/VIZ MRZ separately (mrzFields above is
+                // the chip read) and record the chip↔VIZ verdict, so the
+                // backend can re-derive the authoritative match (MASAK 4/C).
+                appContext.identificationInfo.scannedDocument.vizMrzFields =
+                  passportData?.mrzFields ??
+                  idBackSideData?.mrzFields ??
+                  idFrontSideData?.mrzFields;
+                appContext.identificationInfo.scannedDocument.chipVizMatch =
+                  appContext.lastDocumentRead?.chipVizMatch;
+                // Passive Auth artifacts for server-side verification.
+                appContext.identificationInfo.scannedDocument.paSodBase64 =
+                  appContext.lastDocumentRead?.passiveAuth?.sodBase64 ?? null;
+                appContext.identificationInfo.scannedDocument.paIntegrityStatus =
+                  appContext.lastDocumentRead?.passiveAuth?.integrityStatus ??
+                  null;
+                // MASAK 4/C(1)(d): if the chip's DG11 carried an address and no
+                // address was captured otherwise, seed it from the chip so it is
+                // sent to the backend (fromChip=true). A later ADDRESS_CAPTURE
+                // step can still let the user confirm/edit it.
+                const chipAddress =
+                  appContext.lastDocumentRead?.document.address;
+                if (chipAddress && !appContext.identificationInfo.address) {
+                  appContext.identificationInfo.address = {
+                    addressText: chipAddress,
+                    fromChip: true,
+                  };
+                }
                 appContext.identificationInfo.scannedDocument.faceImage =
                   faceImage;
                 appContext.identificationInfo.scannedDocument.faceImageMimeType =
@@ -137,19 +175,13 @@ const IdentityDocumentEIDScanningScreen = () => {
                       ? 'PASSPORT'
                       : 'UNKNOWN';
 
-                if (allowedCountries && allowedCountries.length > 0) {
-                  const countryCode = mrzFields.issuingState;
-                  if (!allowedCountries.includes(countryCode as 'TUR')) {
-                    // Workflow validation - user's document country not in allowed list
-                    // Expected behavior, not a bug
-                    Alert.alert(
-                      t('general.error'),
-                      t('general.countryNotAllowed')
-                    );
-                    appContext.onError?.(t('general.countryNotAllowed'));
-                    navigationManagerRef.current?.reset();
-                    return;
-                  }
+                if (!isCountryAllowed(mrzFields.issuingState, allowedCountries)) {
+                  // Workflow validation - user's document country not in allowed list
+                  // Expected behavior, not a bug
+                  Alert.alert(t('general.error'), t('general.countryNotAllowed'));
+                  appContext.onError?.(t('general.countryNotAllowed'));
+                  navigationManagerRef.current?.reset();
+                  return;
                 }
 
                 if (allowedDocumentTypes && allowedDocumentTypes.length > 0) {

package/src/Screens/Dynamic/IdentityDocumentScanningScreen.tsx

@@ -2,6 +2,7 @@ import React, { useContext, useEffect, useState } from 'react';
 
 import type { MRZFields } from '../../Shared/Types/mrzFields';
 import { buildDocumentName } from '../../Shared/Libs/mrzTransliteration';
+import { isCountryAllowed } from '../../Shared/Libs/country-allow';
 import { normalizeFromMRZFields } from '../../Shared/Libs/documentDataNormalizer';
 import { Alert, SafeAreaView, StyleSheet, View } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
@@ -36,7 +37,7 @@ const IdentityDocumentScanningScreen = () => {
   const [allowedDocumentTypes, setAllowedDocumentTypes] = useState<
     ('I' | 'P')[] | null
   >(null);
-  const [allowedCountries, setAllowedCountries] = useState<'TUR'[] | null>(
+  const [allowedCountries, setAllowedCountries] = useState<string[] | null>(
     null
   );
 
@@ -100,16 +101,13 @@ const IdentityDocumentScanningScreen = () => {
             ? 'PASSPORT'
             : 'UNKNOWN';
 
-      if (allowedCountries && allowedCountries.length > 0) {
-        const countryCode = mrzFields.issuingState;
-        if (!allowedCountries.includes(countryCode as 'TUR')) {
-          // Workflow validation - user's document country not in allowed list
-          // Expected behavior, not a bug
-          Alert.alert(t('general.error'), t('general.countryNotAllowed'));
-          appContext.onError?.(t('general.countryNotAllowed'));
-          navigationManagerRef.current?.reset();
-          return;
-        }
+      if (!isCountryAllowed(mrzFields.issuingState, allowedCountries)) {
+        // Workflow validation - user's document country not in allowed list
+        // Expected behavior, not a bug
+        Alert.alert(t('general.error'), t('general.countryNotAllowed'));
+        appContext.onError?.(t('general.countryNotAllowed'));
+        navigationManagerRef.current?.reset();
+        return;
       }
 
       if (allowedDocumentTypes && allowedDocumentTypes.length > 0) {

package/src/Screens/Static/ResultScreen.tsx

@@ -94,6 +94,8 @@ const ResultScreen = () => {
     document: false,
     media: false,
     verbalConsentVideos: false,
+    address: false,
+    passiveAuth: false,
   });
   const [shouldShowDemoData, setShouldShowDemoData] = useState(false);
   const [deviceIdentifier, setDeviceIdentifier] = useState<string>('');
@@ -251,15 +253,65 @@ const ResultScreen = () => {
         JSON.stringify(appContext.identificationInfo.consent),
         sessionKey
       );
+      const response = await httpClient.post<
+        { terminate?: boolean; reason?: string | null },
+        { encryptedData: string; nonce: string }
+      >(`${apiUrl}/identifications/${identificationId}/consents`, {
+        encryptedData,
+        nonce,
+      });
+      // MASAK 4/C(1)(e): the server risk-evaluates the technical data and may
+      // instruct us to terminate the process. Honor it by aborting the flow.
+      if (response?.terminate) {
+        throw Object.assign(new Error('session terminated'), {
+          sessionTerminated: true,
+          terminateReason: response.reason ?? undefined,
+        });
+      }
+    },
+    [apiUrl, appContext.identificationInfo.consent]
+  );
+
+  // MASAK 4/C(1)(d): submit the captured address. The proof document image is
+  // uploaded separately as ADDRESS_PROOF_DOCUMENT media.
+  const submitIdentificationAddress = useCallback(
+    async (identificationId: string, sessionKey: string) => {
+      const address = appContext.identificationInfo.address;
+      if (!address?.addressText) return;
+      const { encryptedData, nonce } = encryptWithAes(
+        JSON.stringify({
+          addressText: address.addressText,
+          fromChip: address.fromChip,
+        }),
+        sessionKey
+      );
       await httpClient.post(
-        `${apiUrl}/identifications/${identificationId}/consents`,
-        {
-          encryptedData,
-          nonce,
-        }
+        `${apiUrl}/identifications/${identificationId}/address`,
+        { encryptedData, nonce }
       );
     },
-    [apiUrl, appContext.identificationInfo.consent]
+    [apiUrl, appContext.identificationInfo.address]
+  );
+
+  // MASAK 4/C(1)(b),(c): submit EF.SOD for server-side Passive Authentication
+  // (signature + CSCA chaining). Only when the eID step ran with passiveAuth.
+  const submitPassiveAuth = useCallback(
+    async (identificationId: string, sessionKey: string) => {
+      const sd = appContext.identificationInfo.scannedDocument;
+      if (!sd?.paSodBase64) return;
+      const { encryptedData, nonce } = encryptWithAes(
+        JSON.stringify({
+          sodBase64: sd.paSodBase64,
+          integrityStatus: sd.paIntegrityStatus ?? null,
+        }),
+        sessionKey
+      );
+      await httpClient.post(
+        `${apiUrl}/identifications/${identificationId}/passive-auth`,
+        { encryptedData, nonce }
+      );
+    },
+    [apiUrl, appContext.identificationInfo.scannedDocument]
   );
 
   const submitIdentificationDocument = useCallback(
@@ -287,6 +339,8 @@ const ResultScreen = () => {
         gender: getGenderEnumType(rawMrzFields.sex),
         number: rawMrzFields.documentNumber,
         country: rawMrzFields.issuingState,
+        // Raw ICAO nationality (for the MASAK 4/C(3) risky-country block).
+        nationality: rawMrzFields.nationality,
         barcodeValue: scannedDocument.barcodeValue,
         personalNumber: rawMrzFields.personalNumber || rawMrzFields.optional1,
         birthDate: mrzUtils.convertMRZDateToISODate(rawMrzFields.birthDate),
@@ -408,6 +462,12 @@ const ResultScreen = () => {
           await writeTempImage('DOCUMENT_HOLOGRAM_IMAGE.jpg', hologramImage);
         }
 
+        // MASAK 4/C(1)(d): the address proof document, when captured.
+        const addressProof = appContext.identificationInfo.address?.proofImage;
+        if (addressProof && addressProof !== '') {
+          await writeTempImage('ADDRESS_PROOF_DOCUMENT.jpg', addressProof);
+        }
+
         if (livenessDetection) {
           for (const instruction of livenessDetection.instructions) {
             if (instruction.photo !== '') {
@@ -587,6 +647,16 @@ const ResultScreen = () => {
         }
         setProgress(30);
 
+        if (
+          !completedSteps.current.address &&
+          appContext.identificationInfo.address?.addressText
+        ) {
+          await runWithRetry(() =>
+            submitIdentificationAddress(identificationId, sessionKey)
+          );
+          completedSteps.current.address = true;
+        }
+
         if (!alreadyUploaded) {
           const scannedIdentityDocument = identificationInfo.scannedDocument;
           if (
@@ -603,6 +673,16 @@ const ResultScreen = () => {
             );
             completedSteps.current.document = true;
           }
+
+          if (
+            !completedSteps.current.passiveAuth &&
+            scannedIdentityDocument?.paSodBase64
+          ) {
+            await runWithRetry(() =>
+              submitPassiveAuth(identificationId, sessionKey)
+            );
+            completedSteps.current.passiveAuth = true;
+          }
           setProgress(40);
 
           if (!completedSteps.current.media) {
@@ -656,6 +736,19 @@ const ResultScreen = () => {
         setIsSubmitting(false);
         setProgress(0);
 
+        // MASAK 4/C(1)(e): the server terminated the session on a risk signal.
+        // This is terminal, not recoverable — surface it and stop, with no
+        // retry affordance (re-submitting can't change the decision).
+        if (
+          error &&
+          typeof error === 'object' &&
+          (error as { sessionTerminated?: boolean }).sessionTerminated
+        ) {
+          appContext.onError?.(t('resultScreen.sessionTerminated'));
+          setSubmitFailed(true);
+          return;
+        }
+
         // Track verification failure
         const errorMessage =
           error instanceof Error ? error.message : 'Unknown error';
@@ -694,6 +787,8 @@ const ResultScreen = () => {
       finishIdentification,
       submitIdentificationDocument,
       submitIdentificationConsent,
+      submitIdentificationAddress,
+      submitPassiveAuth,
       t,
       appContext,
     ]