omnipay-reactnative-sdk 1.2.2-beta.3 → 1.2.2-beta.6

package/ios/OmnipayLivenessModule.m

@@ -0,0 +1,554 @@
+#import "OmnipayLivenessModule.h"
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+// Challenge constants
+static NSString *const CHALLENGE_SMILE = @"smile";
+static NSString *const CHALLENGE_BLINK = @"blink";
+static NSString *const CHALLENGE_TURN_LEFT = @"turnLeft";
+static NSString *const CHALLENGE_TURN_RIGHT = @"turnRight";
+
+// Detection thresholds
+static const CGFloat HEAD_TURN_THRESHOLD = 15.0;
+static const NSInteger BLINK_FRAMES_THRESHOLD = 3;
+
+@implementation OmnipayLivenessModule
+
+RCT_EXPORT_MODULE(OmnipayLivenessModule)
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        [self initializeDetection];
+    }
+    return self;
+}
+
+- (void)initializeDetection {
+    self.headTurnThreshold = HEAD_TURN_THRESHOLD;
+    self.blinkFramesThreshold = BLINK_FRAMES_THRESHOLD;
+    self.challengeTimeoutSeconds = 10.0; // Default timeout
+    
+    // Initialize video data output queue
+    self.videoDataOutputQueue = dispatch_queue_create("videoDataOutputQueue", DISPATCH_QUEUE_SERIAL);
+    
+    // Initialize Vision requests
+    self.faceDetectionRequest = [[VNDetectFaceRectanglesRequest alloc] initWithCompletionHandler:^(VNRequest *request, NSError *error) {
+        if (error) {
+            RCTLogError(@"Face detection error: %@", error.localizedDescription);
+            return;
+        }
+        [self processFaceDetectionResults:request.results];
+    }];
+    
+    self.faceLandmarksRequest = [[VNDetectFaceLandmarksRequest alloc] initWithCompletionHandler:^(VNRequest *request, NSError *error) {
+        if (error) {
+            RCTLogError(@"Face landmarks error: %@", error.localizedDescription);
+            return;
+        }
+        [self processFaceLandmarksResults:request.results];
+    }];
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[
+        @"onChallengeStart",
+        @"onChallengeSuccess", 
+        @"onChallengeFailure",
+        @"onAllChallengesComplete",
+        @"onScreenshotCaptured",
+        @"onDetectionFailed",
+        @"onDetectionComplete"
+    ];
+}
+
+RCT_EXPORT_METHOD(isSupported:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    // Check if Vision framework is available and camera is available
+    BOOL isSupported = [VNDetectFaceRectanglesRequest class] != nil && 
+                      [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo] != nil;
+    resolve(@(isSupported));
+}
+
+RCT_EXPORT_METHOD(startLivenessDetection:(NSDictionary *)config
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    
+    if (self.isDetectionRunning) {
+        reject(@"DETECTION_RUNNING", @"Detection is already running", nil);
+        return;
+    }
+    
+    // Parse configuration
+    [self parseConfig:config];
+    
+    // Request camera permission
+    [AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo completionHandler:^(BOOL granted) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            if (!granted) {
+                reject(@"CAMERA_PERMISSION", @"Camera permission denied", nil);
+                return;
+            }
+            
+            NSError *error;
+            if ([self setupCameraSession:&error]) {
+                [self startCameraSession];
+                self.isDetectionRunning = YES;
+                [self startNextChallenge];
+                resolve(nil);
+            } else {
+                reject(@"CAMERA_SETUP_ERROR", error.localizedDescription ?: @"Failed to setup camera", error);
+            }
+        });
+    }];
+}
+
+RCT_EXPORT_METHOD(stopDetection:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    [self stopLivenessDetection];
+    resolve(nil);
+}
+
+- (void)parseConfig:(NSDictionary *)config {
+    // Parse challenges
+    NSArray *challengesArray = config[@"challenges"];
+    if (challengesArray && challengesArray.count > 0) {
+        self.challenges = challengesArray;
+    } else {
+        // Default challenges
+        self.challenges = @[CHALLENGE_SMILE, CHALLENGE_BLINK, CHALLENGE_TURN_LEFT, CHALLENGE_TURN_RIGHT];
+    }
+    
+    // Parse timeout
+    NSNumber *timeout = config[@"challengeTimeout"];
+    if (timeout) {
+        self.challengeTimeoutSeconds = timeout.doubleValue;
+    }
+    
+    self.currentChallengeIndex = 0;
+}
+
+- (BOOL)setupCameraSession:(NSError **)error {
+    // Create capture session
+    self.captureSession = [[AVCaptureSession alloc] init];
+    self.captureSession.sessionPreset = AVCaptureSessionPresetMedium;
+    
+    // Get front camera
+    AVCaptureDevice *frontCamera = nil;
+    NSArray *devices = [AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo];
+    for (AVCaptureDevice *device in devices) {
+        if (device.position == AVCaptureDevicePositionFront) {
+            frontCamera = device;
+            break;
+        }
+    }
+    
+    if (!frontCamera) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"OmnipayLiveness" 
+                                         code:1001 
+                                     userInfo:@{NSLocalizedDescriptionKey: @"Front camera not available"}];
+        }
+        return NO;
+    }
+    
+    // Create device input
+    NSError *inputError;
+    AVCaptureDeviceInput *deviceInput = [AVCaptureDeviceInput deviceInputWithDevice:frontCamera error:&inputError];
+    if (!deviceInput) {
+        if (error) *error = inputError;
+        return NO;
+    }
+    
+    if (![self.captureSession canAddInput:deviceInput]) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"OmnipayLiveness" 
+                                         code:1002 
+                                     userInfo:@{NSLocalizedDescriptionKey: @"Cannot add device input"}];
+        }
+        return NO;
+    }
+    [self.captureSession addInput:deviceInput];
+    
+    // Create video data output
+    self.videoDataOutput = [[AVCaptureVideoDataOutput alloc] init];
+    self.videoDataOutput.videoSettings = @{(NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA)};
+    [self.videoDataOutput setSampleBufferDelegate:self queue:self.videoDataOutputQueue];
+    
+    if (![self.captureSession canAddOutput:self.videoDataOutput]) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"OmnipayLiveness" 
+                                         code:1003 
+                                     userInfo:@{NSLocalizedDescriptionKey: @"Cannot add video data output"}];
+        }
+        return NO;
+    }
+    [self.captureSession addOutput:self.videoDataOutput];
+    
+    // Create photo output for final screenshot
+    self.photoOutput = [[AVCapturePhotoOutput alloc] init];
+    if ([self.captureSession canAddOutput:self.photoOutput]) {
+        [self.captureSession addOutput:self.photoOutput];
+    }
+    
+    return YES;
+}
+
+- (void)startCameraSession {
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        [self.captureSession startRunning];
+    });
+}
+
+- (void)startNextChallenge {
+    if (self.currentChallengeIndex >= self.challenges.count) {
+        return;
+    }
+    
+    self.currentChallenge = self.challenges[self.currentChallengeIndex];
+    self.challengeStartTime = [[NSDate date] timeIntervalSince1970];
+    self.challengeCompleted = NO;
+    
+    // Reset blink detection state
+    if ([self.currentChallenge isEqualToString:CHALLENGE_BLINK]) {
+        self.blinkCounter = 0;
+        self.eyesClosedFrames = 0;
+        self.previousEyeOpenState = YES;
+    }
+    
+    // Emit challenge start event
+    [self sendEventWithName:@"onChallengeStart" body:@{@"challenge": self.currentChallenge}];
+}
+
+#pragma mark - AVCaptureVideoDataOutputSampleBufferDelegate
+
+- (void)captureOutput:(AVCaptureOutput *)output 
+didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer 
+       fromConnection:(AVCaptureConnection *)connection {
+    
+    if (!self.isDetectionRunning || !self.currentChallenge) {
+        return;
+    }
+    
+    // Check timeout
+    NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
+    if (currentTime - self.challengeStartTime > self.challengeTimeoutSeconds) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [self onChallengeFailure:@"Challenge timeout"];
+        });
+        return;
+    }
+    
+    if (self.challengeCompleted) {
+        return;
+    }
+    
+    // Convert sample buffer to CIImage
+    CVImageBufferRef imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+    if (!imageBuffer) return;
+    
+    CIImage *ciImage = [CIImage imageWithCVImageBuffer:imageBuffer];
+    
+    // Create Vision image request handler
+    VNImageRequestHandler *imageRequestHandler = [[VNImageRequestHandler alloc] initWithCIImage:ciImage options:@{}];
+    
+    NSError *error;
+    if ([self.currentChallenge isEqualToString:CHALLENGE_SMILE] || 
+        [self.currentChallenge isEqualToString:CHALLENGE_TURN_LEFT] || 
+        [self.currentChallenge isEqualToString:CHALLENGE_TURN_RIGHT]) {
+        
+        // Use face landmarks for smile and head pose detection
+        [imageRequestHandler performRequests:@[self.faceLandmarksRequest] error:&error];
+    } else {
+        // Use basic face detection for blink detection
+        [imageRequestHandler performRequests:@[self.faceDetectionRequest, self.faceLandmarksRequest] error:&error];
+    }
+    
+    if (error) {
+        RCTLogError(@"Vision request error: %@", error.localizedDescription);
+    }
+}
+
+- (void)processFaceDetectionResults:(NSArray<VNFaceObservation *> *)results {
+    if (results.count == 0) {
+        return; // No face detected
+    }
+    
+    VNFaceObservation *face = results.firstObject;
+    [self processFaceObservation:face];
+}
+
+- (void)processFaceLandmarksResults:(NSArray<VNFaceObservation *> *)results {
+    if (results.count == 0) {
+        return; // No face detected
+    }
+    
+    VNFaceObservation *face = results.firstObject;
+    [self processFaceObservation:face];
+}
+
+- (void)processFaceObservation:(VNFaceObservation *)face {
+    if ([self.currentChallenge isEqualToString:CHALLENGE_SMILE]) {
+        [self checkSmile:face];
+    } else if ([self.currentChallenge isEqualToString:CHALLENGE_BLINK]) {
+        [self checkBlink:face];
+    } else if ([self.currentChallenge isEqualToString:CHALLENGE_TURN_LEFT]) {
+        [self checkHeadTurn:face targetYaw:-self.headTurnThreshold];
+    } else if ([self.currentChallenge isEqualToString:CHALLENGE_TURN_RIGHT]) {
+        [self checkHeadTurn:face targetYaw:self.headTurnThreshold];
+    }
+}
+
+- (void)checkSmile:(VNFaceObservation *)face {
+    if (!face.landmarks) return;
+    
+    // Simplified smile detection based on mouth landmarks
+    VNFaceLandmarkRegion2D *outerLips = face.landmarks.outerLips;
+    if (outerLips && outerLips.pointCount > 0) {
+        // Basic smile detection - check if mouth corners are raised
+        // This is a simplified implementation
+        CGPoint *points = (CGPoint *)outerLips.normalizedPoints;
+        
+        // Get mouth corner points (approximate indices)
+        if (outerLips.pointCount >= 12) {
+            CGPoint leftCorner = points[0];
+            CGPoint rightCorner = points[6];
+            CGPoint topLip = points[3];
+            CGPoint bottomLip = points[9];
+            
+            // Simple smile detection: corners higher than center
+            CGFloat mouthHeight = topLip.y - bottomLip.y;
+            CGFloat cornerElevation = (leftCorner.y + rightCorner.y) / 2.0 - bottomLip.y;
+            
+            if (cornerElevation > mouthHeight * 0.3) { // Smile threshold
+                dispatch_async(dispatch_get_main_queue(), ^{
+                    [self onChallengeSuccess];
+                });
+            }
+        }
+    }
+}
+
+- (void)checkBlink:(VNFaceObservation *)face {
+    if (!face.landmarks) return;
+    
+    // Check eye landmarks for blink detection
+    VNFaceLandmarkRegion2D *leftEye = face.landmarks.leftEye;
+    VNFaceLandmarkRegion2D *rightEye = face.landmarks.rightEye;
+    
+    if (leftEye && rightEye && leftEye.pointCount > 0 && rightEye.pointCount > 0) {
+        // Simplified blink detection based on eye aspect ratio
+        BOOL eyesOpen = [self areEyesOpen:leftEye rightEye:rightEye];
+        
+        if (!eyesOpen) {
+            self.eyesClosedFrames++;
+        } else {
+            if (self.eyesClosedFrames >= self.blinkFramesThreshold && !self.previousEyeOpenState) {
+                self.blinkCounter++;
+                if (self.blinkCounter >= 1) { // Single blink required
+                    dispatch_async(dispatch_get_main_queue(), ^{
+                        [self onChallengeSuccess];
+                    });
+                }
+            }
+            self.eyesClosedFrames = 0;
+        }
+        
+        self.previousEyeOpenState = eyesOpen;
+    }
+}
+
+- (BOOL)areEyesOpen:(VNFaceLandmarkRegion2D *)leftEye rightEye:(VNFaceLandmarkRegion2D *)rightEye {
+    // Calculate eye aspect ratio for both eyes
+    CGFloat leftEAR = [self calculateEyeAspectRatio:leftEye];
+    CGFloat rightEAR = [self calculateEyeAspectRatio:rightEye];
+    
+    // Average eye aspect ratio
+    CGFloat averageEAR = (leftEAR + rightEAR) / 2.0;
+    
+    // Threshold for eye open/closed state
+    return averageEAR > 0.2; // Adjust threshold as needed
+}
+
+- (CGFloat)calculateEyeAspectRatio:(VNFaceLandmarkRegion2D *)eye {
+    if (eye.pointCount < 6) return 1.0; // Default to open
+    
+    CGPoint *points = (CGPoint *)eye.normalizedPoints;
+    
+    // Simplified eye aspect ratio calculation
+    // Get approximate top, bottom, left, right points
+    CGFloat minY = points[0].y, maxY = points[0].y;
+    CGFloat minX = points[0].x, maxX = points[0].x;
+    
+    for (int i = 1; i < eye.pointCount; i++) {
+        if (points[i].y < minY) minY = points[i].y;
+        if (points[i].y > maxY) maxY = points[i].y;
+        if (points[i].x < minX) minX = points[i].x;
+        if (points[i].x > maxX) maxX = points[i].x;
+    }
+    
+    CGFloat height = maxY - minY;
+    CGFloat width = maxX - minX;
+    
+    return width > 0 ? height / width : 1.0;
+}
+
+- (void)checkHeadTurn:(VNFaceObservation *)face targetYaw:(CGFloat)targetYaw {
+    // Vision framework provides yaw directly
+    CGFloat yaw = face.yaw ? face.yaw.floatValue * 180.0 / M_PI : 0.0; // Convert to degrees
+    
+    if (targetYaw < 0) { // Turn left
+        if (yaw < targetYaw) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                [self onChallengeSuccess];
+            });
+        }
+    } else { // Turn right
+        if (yaw > targetYaw) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                [self onChallengeSuccess];
+            });
+        }
+    }
+}
+
+- (void)onChallengeSuccess {
+    if (self.challengeCompleted) return;
+    
+    self.challengeCompleted = YES;
+    NSTimeInterval duration = ([[NSDate date] timeIntervalSince1970] - self.challengeStartTime) * 1000; // Convert to ms
+    
+    // Create challenge result
+    NSDictionary *result = @{
+        @"challenge": self.currentChallenge,
+        @"success": @YES,
+        @"duration": @(duration),
+        @"confidence": @(0.9) // Mock confidence
+    };
+    
+    // Emit challenge success event
+    [self sendEventWithName:@"onChallengeSuccess" body:@{
+        @"challenge": self.currentChallenge,
+        @"result": result
+    }];
+    
+    // Move to next challenge or complete
+    self.currentChallengeIndex++;
+    if (self.currentChallengeIndex < self.challenges.count) {
+        // Delay before next challenge
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+            [self startNextChallenge];
+        });
+    } else {
+        // All challenges completed
+        [self onAllChallengesComplete];
+    }
+}
+
+- (void)onChallengeFailure:(NSString *)reason {
+    if (self.challengeCompleted) return;
+    
+    self.challengeCompleted = YES;
+    
+    [self sendEventWithName:@"onChallengeFailure" body:@{
+        @"challenge": self.currentChallenge,
+        @"reason": reason
+    }];
+    
+    // Stop detection
+    [self stopLivenessDetection];
+    
+    [self sendEventWithName:@"onDetectionFailed" body:@{@"reason": reason}];
+}
+
+- (void)onAllChallengesComplete {
+    [self sendEventWithName:@"onAllChallengesComplete" body:nil];
+    
+    // Capture final screenshot
+    [self captureScreenshot];
+}
+
+- (void)captureScreenshot {
+    if (!self.photoOutput) {
+        [self sendDetectionResult:NO screenshot:nil failureReason:@"Failed to capture screenshot"];
+        return;
+    }
+    
+    AVCapturePhotoSettings *settings = [AVCapturePhotoSettings photoSettings];
+    
+    [self.photoOutput capturePhotoWithSettings:settings delegate:(id<AVCapturePhotoCaptureDelegate>)self];
+}
+
+#pragma mark - AVCapturePhotoCaptureDelegate
+
+- (void)captureOutput:(AVCapturePhotoOutput *)output 
+didFinishProcessingPhoto:(AVCapturePhoto *)photo 
+                error:(NSError *)error API_AVAILABLE(ios(11.0)) {
+    
+    if (error) {
+        RCTLogError(@"Photo capture error: %@", error.localizedDescription);
+        [self sendDetectionResult:NO screenshot:nil failureReason:@"Screenshot capture failed"];
+        return;
+    }
+    
+    NSData *imageData = [photo fileDataRepresentation];
+    if (imageData) {
+        NSString *base64String = [imageData base64EncodedStringWithOptions:0];
+        NSString *base64Image = [NSString stringWithFormat:@"data:image/jpeg;base64,%@", base64String];
+        
+        [self sendEventWithName:@"onScreenshotCaptured" body:@{@"screenshot": base64Image}];
+        [self sendDetectionResult:YES screenshot:base64Image failureReason:nil];
+    } else {
+        [self sendDetectionResult:NO screenshot:nil failureReason:@"Failed to process screenshot"];
+    }
+}
+
+- (void)sendDetectionResult:(BOOL)success screenshot:(NSString *)screenshot failureReason:(NSString *)failureReason {
+    [self stopLivenessDetection];
+    
+    NSMutableDictionary *result = [NSMutableDictionary dictionary];
+    result[@"success"] = @(success);
+    
+    if (screenshot) {
+        result[@"screenshot"] = screenshot;
+    }
+    
+    if (failureReason) {
+        result[@"failureReason"] = failureReason;
+    }
+    
+    // Create mock challenge results
+    NSMutableArray *challengeResults = [NSMutableArray array];
+    for (NSInteger i = 0; i < self.currentChallengeIndex; i++) {
+        NSDictionary *challengeResult = @{
+            @"challenge": self.challenges[i],
+            @"success": @YES,
+            @"duration": @(2000), // Mock duration
+            @"confidence": @(0.9)
+        };
+        [challengeResults addObject:challengeResult];
+    }
+    result[@"challengeResults"] = challengeResults;
+    result[@"totalDuration"] = @(([[NSDate date] timeIntervalSince1970] - self.challengeStartTime) * 1000);
+    
+    [self sendEventWithName:@"onDetectionComplete" body:result];
+}
+
+- (void)stopLivenessDetection {
+    self.isDetectionRunning = NO;
+    self.currentChallenge = nil;
+    self.currentChallengeIndex = 0;
+    self.challengeCompleted = NO;
+    
+    if (self.captureSession && self.captureSession.isRunning) {
+        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+            [self.captureSession stopRunning];
+        });
+    }
+}
+
+@end 

package/lib/commonjs/components/OmnipayProvider.js

@@ -9,11 +9,9 @@ var _reactNative = require("react-native");
 var _reactNativeWebview = _interopRequireDefault(require("react-native-webview"));
 var _functions = require("../functions");
 var _reactNativeShare = _interopRequireDefault(require("react-native-share"));
-var _asyncStorage = _interopRequireDefault(require("@react-native-async-storage/async-storage"));
 var _FaceVerification = _interopRequireDefault(require("./biometrics/FaceVerification"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-const OmnipayActivity = _reactNative.NativeModules.OmnipayActivity || {};
 let defaultValue = {
   initiateBills: () => null,
   initiateWallet: () => null
@@ -36,74 +34,15 @@ const OmnipayProvider = ({
   const isValidEnv = ['prod', 'dev'].includes(env);
   const isValidColor = color.length > 2;
   const onCloseRef = (0, _react.useRef)(undefined);
-  const [canUsePos, setCanUsePos] = (0, _react.useState)(false);
   const [showFaceVerification, setShowFaceVerification] = (0, _react.useState)(false);
   (0, _react.useEffect)(() => {
-    checkPaymentApp();
     setTimeout(() => {
       setShowFaceVerification(true);
-    }, 5000);
+    }, 4000);
   }, []);
   (0, _react.useEffect)(() => {
     visibilityRef.current = isVisible;
   }, [isVisible]);
-  (0, _react.useEffect)(() => {
-    if (canUsePos) {
-      const eventEmitter = new _reactNative.NativeEventEmitter(OmnipayActivity);
-      eventEmitter.addListener('OmnipayEvent', event => {
-        console.log('native event', event);
-      });
-    }
-  }, [canUsePos]);
-  async function checkPaymentApp() {
-    try {
-      if (_reactNative.Platform.OS === 'android') {
-        const isInstalled = await OmnipayActivity.isPackageInstalled('com.horizonpay.sample');
-        if (isInstalled) {
-          setCanUsePos(true);
-        }
-      }
-    } catch (error) {}
-  }
-  async function startPosTransaction({
-    amount,
-    purchaseType,
-    print,
-    rrn,
-    stan,
-    terminalId
-  }) {
-    try {
-      if (_reactNative.Platform.OS === 'android') {
-        let result = '';
-        if (purchaseType === 'KEY EXCHANGE') {
-          const isKeyExchanged = await _asyncStorage.default.getItem('isKeyExchanged');
-          if (!isKeyExchanged) {
-            result = await OmnipayActivity.initiateHorizonTransaction(amount, purchaseType, color, print, rrn, stan, terminalId);
-            if (terminalId && result && result.toLowerCase().includes('-message-success')) {
-              await _asyncStorage.default.setItem('isKeyExchanged', terminalId);
-            }
-            postMessage({
-              dataKey: 'onPosKeyExchanged',
-              dataValue: result
-            });
-          }
-        } else {
-          result = await OmnipayActivity.initiateHorizonTransaction(amount, purchaseType, color, print, rrn, stan, terminalId);
-          postMessage({
-            dataKey: 'onPosTransactionSuccess',
-            dataValue: result
-          });
-        }
-      }
-    } catch (error) {
-      console.log(error);
-      postMessage({
-        dataKey: 'onPosTransactionFailure',
-        dataValue: ''
-      });
-    }
-  }
   function getWebviewStyle() {
     if (!showWebview) {
       return {
@@ -166,9 +105,6 @@ const OmnipayProvider = ({
         if (dataKey === 'shareReceipt') {
           shareReceipt(dataValue);
         }
-        if (dataKey === 'startPosTransaction') {
-          startPosTransaction(JSON.parse(dataValue));
-        }
       }
     } catch (error) {}
   }
@@ -229,7 +165,7 @@ const OmnipayProvider = ({
     const isValidUserRef = !!userRef && !!userRef.trim();
     const usesNativeShare = true;
     if (isPhoneNumberValid || isValidCustomerRef || isValidUserRef) {
-      const webUrl = `${webHost}?theme=${color}&view=wallet&publicKey=${publicKey}&phoneNumber=${phoneNumber}&usesPaylater=${usesPaylater}&usesPromo=${usesPromo}&usesAirtimeData=${usesAirtimeData}&usesTransfer=${usesTransfer}&usesBills=${usesBills}&usesPos=${usesPos}&customerRef=${customerRef}&userRef=${userRef}&promoBalanceOffset=${promoBalanceOffset}&deviceId=${deviceId}&deviceName=${deviceName}&hideWalletTransfer=${hideWalletTransfer}&bvnRequired=${isBvnValidationRequired}&usesNativeShare=${usesNativeShare}&isPosEnabled=${canUsePos}&walletTab=${walletTab}&sessionId=${sessionId}&kycStatus=${kycStatus || ''}&launchPage=${launchPage}`;
+      const webUrl = `${webHost}?theme=${color}&view=wallet&publicKey=${publicKey}&phoneNumber=${phoneNumber}&usesPaylater=${usesPaylater}&usesPromo=${usesPromo}&usesAirtimeData=${usesAirtimeData}&usesTransfer=${usesTransfer}&usesBills=${usesBills}&usesPos=${usesPos}&customerRef=${customerRef}&userRef=${userRef}&promoBalanceOffset=${promoBalanceOffset}&deviceId=${deviceId}&deviceName=${deviceName}&hideWalletTransfer=${hideWalletTransfer}&bvnRequired=${isBvnValidationRequired}&usesNativeShare=${usesNativeShare}&walletTab=${walletTab}&sessionId=${sessionId}&kycStatus=${kycStatus || ''}&launchPage=${launchPage}`;
       setWebviewUrl(webUrl);
       setIsVisible(true);
       onCloseRef.current = onClose;