@trustchex/react-native-sdk 1.500.2 → 1.501.1

package/android/src/main/java/com/trustchex/reactnativesdk/GeolocationModule.kt

@@ -0,0 +1,159 @@
+package com.trustchex.reactnativesdk
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.location.Location
+import android.location.LocationListener
+import android.location.LocationManager
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import java.util.Locale
+
+/**
+ * One-shot coarse geolocation for the MASAK Tebliğ No. 32 Article 4/C(1)(e)
+ * technical-data requirement, using the system [LocationManager] — no
+ * third-party module. The host app must declare ACCESS_COARSE_LOCATION and have
+ * been granted it at runtime (RN handles the runtime request via
+ * PermissionsAndroid); otherwise this resolves to null.
+ *
+ * Everything is fail-soft: missing permission, no provider, an error, or a
+ * timeout all resolve to null (rounded "lat,lng" otherwise) so the verification
+ * flow proceeds — the backend treats a missing fix as "not provided".
+ */
+class GeolocationModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private val handler = Handler(Looper.getMainLooper())
+
+  override fun getName(): String = NAME
+
+  @ReactMethod
+  fun getCoarseLocation(timeoutMs: Double, promise: Promise) {
+    var settled = false
+    var manager: LocationManager? = null
+    var listener: LocationListener? = null
+    var timeoutRunnable: Runnable? = null
+
+    fun finish(value: String?) {
+      if (!settled) {
+        settled = true
+        timeoutRunnable?.let { handler.removeCallbacks(it) }
+        // Stop the live single-update so the radio/listener isn't left running
+        // after we've resolved (e.g. on timeout).
+        val l = listener
+        val m = manager
+        if (l != null && m != null) {
+          try {
+            m.removeUpdates(l)
+          } catch (e: Exception) {
+            // ignore
+          }
+        }
+        listener = null
+        promise.resolve(value)
+      }
+    }
+
+    val granted = reactContext.checkSelfPermission(
+      Manifest.permission.ACCESS_COARSE_LOCATION
+    ) == PackageManager.PERMISSION_GRANTED ||
+      reactContext.checkSelfPermission(
+        Manifest.permission.ACCESS_FINE_LOCATION
+      ) == PackageManager.PERMISSION_GRANTED
+    if (!granted) {
+      finish(null)
+      return
+    }
+
+    val locationManager =
+      reactContext.getSystemService(Context.LOCATION_SERVICE) as? LocationManager
+    if (locationManager == null) {
+      finish(null)
+      return
+    }
+    manager = locationManager
+
+    handler.post {
+      // A recent cached fix is a valid coarse answer and avoids waiting on the
+      // radio. An OLD one is not — submitting a stale coordinate as the
+      // "current" verification location would be wrong, so it is bounded by
+      // recency and otherwise ignored (matching iOS, which returns nil rather
+      // than a stale fix).
+      format(recentLastKnown(locationManager))?.let {
+        finish(it)
+        return@post
+      }
+
+      // Fail-soft timeout so a never-returning fix can't hang the flow. On
+      // timeout we resolve null (no fresh fix) — never a stale last-known.
+      val timeout = Runnable { finish(null) }
+      timeoutRunnable = timeout
+      handler.postDelayed(timeout, timeoutMs.toLong())
+
+      val provider = when {
+        locationManager.isProviderEnabledSafe(LocationManager.NETWORK_PROVIDER) ->
+          LocationManager.NETWORK_PROVIDER
+        locationManager.isProviderEnabledSafe(LocationManager.GPS_PROVIDER) ->
+          LocationManager.GPS_PROVIDER
+        else -> null
+      }
+      if (provider == null) {
+        finish(null)
+        return@post
+      }
+
+      val l = LocationListener { location -> finish(format(location)) }
+      listener = l
+      try {
+        locationManager.requestSingleUpdate(provider, l, Looper.getMainLooper())
+      } catch (e: Exception) {
+        finish(null)
+      }
+    }
+  }
+
+  /** Last-known fix, accepted only when newer than [MAX_AGE_MS]. */
+  private fun recentLastKnown(manager: LocationManager): Location? {
+    val location = try {
+      manager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER)
+        ?: manager.getLastKnownLocation(LocationManager.GPS_PROVIDER)
+    } catch (e: SecurityException) {
+      null
+    } catch (e: Exception) {
+      null
+    } ?: return null
+    val ageMs = SystemClock.elapsedRealtimeNanos() / 1_000_000 -
+      location.elapsedRealtimeNanos / 1_000_000
+    return if (ageMs in 0..MAX_AGE_MS) location else null
+  }
+
+  private fun format(location: Location?): String? {
+    if (location == null) return null
+    // Round to ~3 decimals (~110 m) — coarse, per privacy guidance. Force
+    // Locale.US so the decimal separator is always '.' — a comma-decimal locale
+    // (tr, de, ...) would otherwise corrupt the "lat,lng" contract.
+    val lat = String.format(Locale.US, "%.3f", location.latitude)
+    val lng = String.format(Locale.US, "%.3f", location.longitude)
+    return "$lat,$lng"
+  }
+
+  private fun LocationManager.isProviderEnabledSafe(provider: String): Boolean {
+    return try {
+      isProviderEnabled(provider)
+    } catch (e: Exception) {
+      false
+    }
+  }
+
+  companion object {
+    const val NAME = "GeolocationModule"
+    /** Accept a cached fix only when it is at most this old (2 minutes). */
+    private const val MAX_AGE_MS = 2 * 60 * 1000L
+  }
+}

package/android/src/main/java/com/trustchex/reactnativesdk/TrustchexSDKPackage.kt

@@ -19,6 +19,7 @@ class TrustchexSDKPackage : BaseReactPackage() {
       "MLKitModule" -> MLKitModule(reactContext)
       "OpenCVModule" -> OpenCVModule(reactContext)
       ImageDecoderModule.NAME -> ImageDecoderModule(reactContext)
+      GeolocationModule.NAME -> GeolocationModule(reactContext)
       else -> null
     }
   }
@@ -86,6 +87,17 @@ class TrustchexSDKPackage : BaseReactPackage() {
                       false // isTurboModule
               )
 
+      // Coarse geolocation module (MASAK 4/C(1)(e))
+      moduleInfos[GeolocationModule.NAME] =
+              ReactModuleInfo(
+                      GeolocationModule.NAME,
+                      GeolocationModule.NAME,
+                      false, // canOverrideExistingModule
+                      false, // needsEagerInit
+                      false, // isCxxModule
+                      false // isTurboModule
+              )
+
       moduleInfos
     }
   }

package/ios/Permission/CoarseLocationProvider.swift

@@ -0,0 +1,111 @@
+import CoreLocation
+
+/// One-shot coarse geolocation for the MASAK Tebliğ No. 32 Article 4/C(1)(e)
+/// technical-data requirement, using the system Core Location framework — no
+/// third-party module. Requests when-in-use authorization (the host app must
+/// declare `NSLocationWhenInUseUsageDescription`), takes a single
+/// reduced-accuracy fix, and returns "lat,lng" rounded to ~3 decimals (~110 m),
+/// or nil.
+///
+/// Everything is fail-soft: denied permission, disabled services, an error, or a
+/// timeout all resolve to nil so the verification flow proceeds — the backend
+/// treats a missing fix as "not provided".
+final class CoarseLocationProvider: NSObject, CLLocationManagerDelegate {
+  private let manager = CLLocationManager()
+  private var completion: ((String?) -> Void)?
+  private var timeoutWork: DispatchWorkItem?
+  private var finished = false
+
+  /// Request a single coarse fix. The completion is always called exactly once,
+  /// on the main thread, with "lat,lng" or nil.
+  func requestOnce(timeoutMs: Int, completion: @escaping (String?) -> Void) {
+    self.completion = completion
+
+    guard CLLocationManager.locationServicesEnabled() else {
+      finish(nil)
+      return
+    }
+
+    manager.delegate = self
+    manager.desiredAccuracy = kCLLocationAccuracyKilometer
+    if #available(iOS 14.0, *) {
+      manager.desiredAccuracy = kCLLocationAccuracyReduced
+    }
+
+    // Fail-soft timeout so a never-returning fix can't hang the flow.
+    let work = DispatchWorkItem { [weak self] in self?.finish(nil) }
+    timeoutWork = work
+    DispatchQueue.main.asyncAfter(
+      deadline: .now() + .milliseconds(timeoutMs),
+      execute: work
+    )
+
+    let status: CLAuthorizationStatus
+    if #available(iOS 14.0, *) {
+      status = manager.authorizationStatus
+    } else {
+      status = CLLocationManager.authorizationStatus()
+    }
+    handle(status: status)
+  }
+
+  private func handle(status: CLAuthorizationStatus) {
+    switch status {
+    case .notDetermined:
+      manager.requestWhenInUseAuthorization()
+    case .authorizedWhenInUse, .authorizedAlways:
+      manager.requestLocation()
+    default:
+      finish(nil) // denied / restricted
+    }
+  }
+
+  // MARK: CLLocationManagerDelegate
+
+  @available(iOS 14.0, *)
+  func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+    handle(status: manager.authorizationStatus)
+  }
+
+  func locationManager(
+    _ manager: CLLocationManager,
+    didChangeAuthorization status: CLAuthorizationStatus
+  ) {
+    // iOS 13 path (the iOS 14 delegate above supersedes this when available).
+    if #available(iOS 14.0, *) { return }
+    handle(status: status)
+  }
+
+  func locationManager(
+    _ manager: CLLocationManager,
+    didUpdateLocations locations: [CLLocation]
+  ) {
+    guard let coordinate = locations.last?.coordinate else {
+      finish(nil)
+      return
+    }
+    // Round to ~3 decimals (~110 m) — coarse, per privacy guidance.
+    let lat = String(format: "%.3f", coordinate.latitude)
+    let lng = String(format: "%.3f", coordinate.longitude)
+    finish("\(lat),\(lng)")
+  }
+
+  func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+    finish(nil)
+  }
+
+  private func finish(_ value: String?) {
+    guard !finished else { return }
+    finished = true
+    timeoutWork?.cancel()
+    timeoutWork = nil
+    manager.delegate = nil
+    let completion = self.completion
+    self.completion = nil
+    if Thread.isMainThread {
+      completion?(value)
+    } else {
+      DispatchQueue.main.async { completion?(value) }
+    }
+  }
+}

package/ios/Permission/PermissionModule.m

@@ -14,6 +14,10 @@ RCT_EXTERN_METHOD(checkCameraPermission:(RCTPromiseResolveBlock)resolve
 RCT_EXTERN_METHOD(checkMicrophonePermission:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(getCoarseLocation:(nonnull NSNumber *)timeoutMs
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
 + (BOOL)requiresMainQueueSetup
 {
   return YES;

package/ios/Permission/PermissionModule.swift

@@ -1,9 +1,29 @@
 import React
 import AVFoundation
+import CoreLocation
 
 @objc(PermissionModule)
 class PermissionModule: NSObject {
-  
+
+  // Each in-flight one-shot request is retained until it completes, so
+  // overlapping calls don't release one another's provider mid-flight.
+  private var locationProviders: [ObjectIdentifier: CoarseLocationProvider] = [:]
+
+  /// MASAK Tebliğ 32 Art. 4/C(1)(e): one-shot coarse geolocation via the system
+  /// Core Location framework — no third-party module. Resolves "lat,lng"
+  /// rounded to ~3 decimals (~110 m) or nil; never rejects (fail-soft).
+  @objc(getCoarseLocation:resolver:withRejecter:)
+  func getCoarseLocation(timeoutMs: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      let provider = CoarseLocationProvider()
+      self.locationProviders[ObjectIdentifier(provider)] = provider
+      provider.requestOnce(timeoutMs: timeoutMs.intValue) { [weak self] coordinate in
+        self?.locationProviders[ObjectIdentifier(provider)] = nil
+        resolve(coordinate)
+      }
+    }
+  }
+
   @objc(requestCameraPermission:withRejecter:)
   func requestCameraPermission(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     DispatchQueue.main.async {

package/lib/module/Screens/Dynamic/AddressCaptureScreen.js

@@ -0,0 +1,230 @@
+"use strict";
+
+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 } from "../../Shared/Components/TrustchexCamera.js";
+import NavigationManager from "../../Shared/Components/NavigationManager.js";
+import AppContext from "../../Shared/Contexts/AppContext.js";
+import StyledButton from "../../Shared/Components/StyledButton.js";
+import { useStatusBarWhiteBackground } from "../../Shared/Libs/status-bar.utils.js";
+import { useScreenTracking, trackVerificationStart, trackVerificationComplete } from "../../Shared/Libs/analytics.utils.js";
+import { useKeepAwake } from "../../Shared/Libs/native-keep-awake.utils.js";
+
+/**
+ * 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).
+ */
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const AddressCaptureScreen = () => {
+  useKeepAwake();
+  useStatusBarWhiteBackground();
+  useScreenTracking('address_capture');
+  const appContext = useContext(AppContext);
+  const navigationManagerRef = useRef(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(chipAddress);
+  const [fromChip] = useState(!!chipAddress);
+  const [proofImage, setProofImage] = useState();
+  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 => {
+    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 /*#__PURE__*/_jsxs(SafeAreaView, {
+      style: styles.cameraContainer,
+      children: [/*#__PURE__*/_jsx(TrustchexCamera, {
+        style: styles.camera,
+        includeBase64: true,
+        onFrameAvailable: e => onFrameAvailable(e.nativeEvent.frame)
+      }), /*#__PURE__*/_jsxs(View, {
+        style: [styles.cameraControls, {
+          paddingBottom: insets.bottom + 16
+        }],
+        children: [/*#__PURE__*/_jsx(Text, {
+          style: styles.cameraHint,
+          children: t('addressCaptureScreen.proofCameraHint')
+        }), /*#__PURE__*/_jsx(StyledButton, {
+          onPress: () => captureNextFrame.current = true,
+          children: t('addressCaptureScreen.capture')
+        }), /*#__PURE__*/_jsx(TouchableOpacity, {
+          onPress: () => setIsCameraOpen(false),
+          children: /*#__PURE__*/_jsx(Text, {
+            style: styles.cancel,
+            children: t('general.cancel')
+          })
+        })]
+      })]
+    });
+  }
+  return /*#__PURE__*/_jsxs(SafeAreaView, {
+    style: styles.container,
+    children: [/*#__PURE__*/_jsxs(ScrollView, {
+      contentContainerStyle: [styles.content, {
+        paddingBottom: insets.bottom + 24
+      }],
+      keyboardShouldPersistTaps: "handled",
+      children: [/*#__PURE__*/_jsx(Text, {
+        style: styles.title,
+        children: t('addressCaptureScreen.title')
+      }), /*#__PURE__*/_jsx(Text, {
+        style: styles.subtitle,
+        children: t('addressCaptureScreen.subtitle')
+      }), fromChip ? /*#__PURE__*/_jsx(Text, {
+        style: styles.chipHint,
+        children: t('addressCaptureScreen.prefilledFromChip')
+      }) : null, /*#__PURE__*/_jsx(Text, {
+        style: styles.label,
+        children: t('addressCaptureScreen.addressLabel')
+      }), /*#__PURE__*/_jsx(TextInput, {
+        style: styles.input,
+        value: addressText,
+        onChangeText: setAddressText,
+        placeholder: t('addressCaptureScreen.addressPlaceholder'),
+        multiline: true,
+        textAlignVertical: "top"
+      }), /*#__PURE__*/_jsx(Text, {
+        style: styles.label,
+        children: t('addressCaptureScreen.proofLabel')
+      }), /*#__PURE__*/_jsx(Text, {
+        style: styles.proofHint,
+        children: t('addressCaptureScreen.proofHint')
+      }), proofImage ? /*#__PURE__*/_jsx(Image, {
+        source: {
+          uri: `data:image/jpeg;base64,${proofImage}`
+        },
+        style: styles.proofPreview,
+        resizeMode: "cover"
+      }) : null, /*#__PURE__*/_jsx(StyledButton, {
+        onPress: () => setIsCameraOpen(true),
+        children: proofImage ? t('addressCaptureScreen.retakeProof') : t('addressCaptureScreen.captureProof')
+      })]
+    }), /*#__PURE__*/_jsx(View, {
+      style: [styles.footer, {
+        paddingBottom: insets.bottom + 12
+      }],
+      children: /*#__PURE__*/_jsx(StyledButton, {
+        disabled: !canContinue,
+        onPress: onContinue,
+        children: t('general.continue')
+      })
+    }), /*#__PURE__*/_jsx(NavigationManager, {
+      ref: navigationManagerRef
+    })]
+  });
+};
+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/lib/module/Screens/Dynamic/ContractAcceptanceScreen.js

@@ -9,6 +9,7 @@ import AppContext from "../../Shared/Contexts/AppContext.js";
 import { getI18n, useTranslation } from 'react-i18next';
 import StyledButton from "../../Shared/Components/StyledButton.js";
 import NativeDeviceInfo from "../../Shared/Libs/native-device-info.utils.js";
+import { captureCoarseGeolocation } from "../../Shared/Libs/geolocation.utils.js";
 import { speakWithDebounce } from "../../Shared/Libs/tts.utils.js";
 import { useStatusBarWhiteBackground } from "../../Shared/Libs/status-bar.utils.js";
 import { trackFunnelStep, useScreenTracking, trackConsentGiven, trackVerificationStart, trackVerificationComplete, trackError } from "../../Shared/Libs/analytics.utils.js";
@@ -141,6 +142,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/lib/module/Screens/Dynamic/IdentityDocumentEIDScanningScreen.js

@@ -9,6 +9,7 @@ import AppContext from "../../Shared/Contexts/AppContext.js";
 import IdentityDocumentCamera from "../../Shared/Components/IdentityDocumentCamera.js";
 import { useTranslation } from 'react-i18next';
 import { trackFunnelStep, useScreenTracking, trackVerificationStart, trackVerificationComplete } from "../../Shared/Libs/analytics.utils.js";
+import { isCountryAllowed } from "../../Shared/Libs/country-allow.js";
 import { useKeepAwake } from "../../Shared/Libs/native-keep-awake.utils.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const IdentityDocumentEIDScanningScreen = () => {
@@ -79,6 +80,12 @@ 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) {
@@ -89,6 +96,25 @@ const IdentityDocumentEIDScanningScreen = () => {
             }
             appContext.identificationInfo.scannedDocument.dataSource = '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 = mimeType;
             appContext.identificationInfo.scannedDocument.mrzText ||= idBackSideData?.mrzText || passportData?.mrzText;
@@ -96,16 +122,13 @@ const IdentityDocumentEIDScanningScreen = () => {
             appContext.identificationInfo.scannedDocument.backImage ||= idBackSideData?.image;
             appContext.identificationInfo.scannedDocument.barcodeValue ||= idBackSideData?.barcodeValue;
             appContext.identificationInfo.scannedDocument.documentType = mrzFields.documentCode === 'I' ? 'ID' : mrzFields.documentCode === 'P' ? 'PASSPORT' : 'UNKNOWN';
-            if (allowedCountries && allowedCountries.length > 0) {
-              const countryCode = mrzFields.issuingState;
-              if (!allowedCountries.includes(countryCode)) {
-                // 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) {
               const documentCode = mrzFields.documentCode;