react-native-shield-fraud-plugin 1.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2023 shield.com
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,161 @@
+# React Native Shield Fraud Plugin
+
+React Native Plugin for Shield Fraud (www.shield.com)
+
+React Native Shield Fraud Plugin helps developers to assess malicious activities performed on mobile devices and return risk intelligence based on user's behaviour. It collects device's fingerprint, social metrics and network information. 
+
+There are four steps to getting started with the SHIELD SDK:
+
+1. [Integrate the SDK](#integrate-the-sdk)
+
+2. [Initialize the SDK](#initialize-the-sdk)
+
+3. [Get Session ID](#get-session-id)
+
+4. [Get Device Results](#get-device-results)
+
+5. [Send Custom Attributes](#send-custom-attributes)
+
+
+### Integrate the SDK
+
+This package can be installed in two ways, you can choose a way depends on your need.
+
+**NPM:**
+```
+npm install react-native-shield-fraud-plugin
+```
+**OR**
+
+**YARN:**
+```
+yarn add react-native-shield-fraud-plugin
+```
+
+**Note**: We make continuous enhancements to our fraud library and detection capabilities which includes new functionalities, bug fixes and security updates. We recommend updating to the latest SDK version to protect against rapidly evolving fraud risks.
+
+You can refer to the Changelog to see more details about our updates.
+
+### Initialize the SDK
+
+The SDK initialization should be configured at the earliest of the App Lifecycle to ensure successful generation and processing of the device fingerprint. SDK is to be initialised only once and will throw an exception if it is initialised more than once.
+
+
+You need both the SHIELD_SITE_ID and SHIELD_SECRET_KEY to initialize the SDK. You can locate them at the top of the page.
+
+You can initialize the SDK by calling it inside UseEffect() 
+
+```
+const config: Config = {
+   siteID: 'SHIELD_SITE_ID',
+   secretKey: 'SHIELD_SECRET_KEY'
+};
+
+useEffect(() => {
+    ShieldFraud.initShield(config)
+}
+```
+
+`Config` has these **optional** parameters:
+
+1. `logLevel` Set your log level to debug, info or none. | Receives high-level information about how the SDK processes network requests, responses or error information during SDK integration. Default log level is none. 
+2. `environmentInfo` Set your environment info to prod, dev or staging. Default environment info is prod.
+3. `blockedDialog` Set your dialog for the blocked dialog both title and body or you can send it as null as well 
+
+Note: You can check whether Shield SDK is ready or not by using isSDKready function
+
+```
+ShieldFraud.isSDKready(async (isReady: boolean) => {
+  if (isReady) {
+    // Shield is Ready: Do your implementation
+  }
+}
+```
+
+### Get Session ID
+Session ID is the unique identifier of a user’s app session and acts as a point of reference when retrieving the device result for that session.
+
+
+Session ID follows the OS lifecycle management, in-line with industry best practice. This means that a user’s session is active for as long as the device maintains it, unless the user terminates the app or the device runs out of memory and has to kill the app.
+
+If you would like to retrieve device results using the backend API, it is important that you store the Session ID on your system. You will need to call the SHIELD backend API using this Session ID.
+
+```
+ShieldFraud.isSDKready(async (isReady: boolean) => {
+    if (isReady) {
+        const sessionID = await ShieldFraud.getSessionId(); // Fetch session ID using await
+        console.log('session id: ', sessionID);
+    }
+}
+```
+
+### Get Device Results
+SHIELD provides you actionable device intelligence which you can retrieve from the SDK, via the `Optimized Listener` or `Customized Pull method`. You can also retrieve results via the backend API.
+
+*Warning: Only 1 method of obtaining device results **(Optimized Listener or Customized Pull)** can be in effect at any point in time.*
+
+#### Retrieve device results via Optimized Listener
+
+##### SHIELD recommends the Optimized Listener method to reduce number of API calls. #####
+
+Our SDK will capture an initial device fingerprint upon SDK initialization and return an additional set of device intelligence ONLY if the device fingerprint changes along one session. This ensures a truly optimized end to end protection of your ecosystem.
+
+You can register a callback if you would like to be notified in the event that the device attributes change during the session (for example, a user activates a malicious tool a moment after launching the page).
+
+Add an additional parameter during intialization in order to register a callback. 
+
+For example - ShieldFraud.initShield(config, **callbacks**);
+ ```
+ const callbacks: ShieldCallback = {
+  onSuccess: (data) => {
+    // Handle success event here
+    console.log('Success:', data);
+  },
+  onFailure: (error) => {
+    // Handle failure event here
+    console.log('Error:', error);
+  },
+};
+
+const config: Config = {
+  siteID: 'SHIELD_SITE_ID',
+  secretKey: 'SHIELD_SECRET_KEY'
+};
+
+ShieldFraud.initShield(config, callbacks);
+ ```
+
+#### Retrieve device results via Customized Pull
+You can retrieve device results via Customized Pull at specific user checkpoints or activities, such as account registration, login, or checkout. This is to ensure that there is adequate time to generate a device fingerprint.
+
+```
+ShieldFraud.isSDKready(async (isReady: boolean) => {
+  if (isReady) {
+    ShieldFraud.getLatestDeviceResult()
+      .then((result: object) => {
+        // Handle success with the result object
+        console.log('Received latest device result:', result);
+      })
+      .catch((error: object) => {
+        // Handle error with the error object
+        console.log('Error retrieving device result:', error);
+      });
+  }
+});
+```
+
+It is possible that getLatestDeviceResult returns null if the device result retrieval is unsuccessful. 
+
+### Send Custom Attributes
+
+Use the sendAttributes function to sent event-based attributes such as user_id or activity_id for enhanced analytics. This function accepts two parameters:screenName where the function is triggered, and data to provide any custom fields in key, value pairs.
+
+```
+ShieldFraud.isSDKready(async (isReady: boolean) => {
+    if (isReady) {
+        ShieldFraud.sendAttributes('Screen_Name', { key1: 'value1', key2: 'value2' });
+    }
+}
+```
+
+

package/android/build.gradle

@@ -0,0 +1,85 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:4.1.3"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+
+
+def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["ShieldFraudPlugin_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ShieldFraudPlugin_" + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+
+  if (isNewArchitectureEnabled()) {
+    react {
+      jsRootDir = file("../src/")
+      libraryName = "ShieldFraudPlugin"
+      codegenJavaPackageName = "com.shieldfraudplugin"
+    }
+  }
+}
+
+rootProject.allprojects {
+  repositories {
+  mavenCentral()
+  google()
+  maven {
+    url "https://cashshield-sdk.s3.amazonaws.com/release/"
+  }
+  }
+}
+
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation 'com.shield.android:shield-fraud:1.6.+'
+}
+

package/android/gradle.properties

@@ -0,0 +1,5 @@
+ShieldFraudPlugin_kotlinVersion=1.7.0
+ShieldFraudPlugin_minSdkVersion=21
+ShieldFraudPlugin_targetSdkVersion=31
+ShieldFraudPlugin_compileSdkVersion=31
+ShieldFraudPlugin_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,5 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.shieldfraudplugin">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+</manifest>

package/android/src/main/java/com/shieldfraudplugin/ShieldFraudPluginModule.java

@@ -0,0 +1,190 @@
+package com.shieldfraudplugin;
+
+import android.app.Activity;
+
+import androidx.annotation.NonNull;
+
+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 com.facebook.react.module.annotations.ReactModule;
+
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.shield.android.BlockedDialog;
+import com.shield.android.Shield;
+import com.shield.android.ShieldCallback;
+import com.shield.android.ShieldException;
+
+import org.json.JSONObject;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+@ReactModule(name = ShieldFraudPluginModule.NAME)
+public class ShieldFraudPluginModule extends ReactContextBaseJavaModule implements ShieldCallback<JSONObject> {
+  public static final String NAME = "ShieldFraudPlugin";
+  private final ReactApplicationContext reactContext;
+
+  public ShieldFraudPluginModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    this.reactContext = reactContext;
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+  private boolean isShieldInitialized() {
+    try {
+      return Shield.getInstance() != null;
+    } catch (IllegalStateException e) {
+      return false;
+    }
+  }
+
+  @ReactMethod
+  public void initShield(String siteID, String secretKey, Boolean isOptimizedListener, ReadableMap blockedDialog, Integer logLevel, Integer environment) {
+    if (isShieldInitialized()) {
+      return;
+    }
+    Activity currentActivity = getCurrentActivity();
+    if (currentActivity != null) {
+      Shield.Builder builder = new Shield.Builder(currentActivity, siteID, secretKey)
+              .setAutoBlockDialog(getBlockedDialogFromReadableMap(blockedDialog));
+
+      if (isOptimizedListener) {
+        builder.registerDeviceShieldCallback(this);
+      }
+
+      String environmentString = getEnvironmentStringFromInteger(environment);
+      builder.setEnvironment(environmentString);
+
+      Shield.LogLevel logLevelEnum = getLogLevelEnumFromInteger(logLevel);
+      builder.setLogLevel(logLevelEnum);
+
+      Shield shield = builder.build();
+      Shield.setSingletonInstance(shield);
+      System.out.println("SHIELD:: Init Done");
+    }
+  }
+
+  private BlockedDialog getBlockedDialogFromReadableMap(ReadableMap blockedDialog) {
+    if (blockedDialog != null) {
+      String title = blockedDialog.hasKey("title") ? blockedDialog.getString("title") : null;
+      String body = blockedDialog.hasKey("body") ? blockedDialog.getString("body") : null;
+      return new BlockedDialog(title, body);
+    }
+    return null;
+  }
+
+  private String getEnvironmentStringFromInteger(Integer environment) {
+    String environmentString;
+    switch (environment) {
+      case 1:
+        environmentString = Shield.ENVIRONMENT_DEV;
+        break;
+      case 2:
+        environmentString = Shield.ENVIRONMENT_STAGING;
+        break;
+      default:
+        environmentString = Shield.ENVIRONMENT_PROD;
+        break;
+    }
+    return environmentString;
+  }
+
+  private Shield.LogLevel getLogLevelEnumFromInteger(Integer logLevel) {
+    Shield.LogLevel logLevelEnum;
+    switch (logLevel) {
+      case 1:
+        logLevelEnum = Shield.LogLevel.NONE;
+        break;
+      case 2:
+        logLevelEnum = Shield.LogLevel.INFO;
+        break;
+      case 3:
+        logLevelEnum = Shield.LogLevel.DEBUG;
+        break;
+      default:
+        logLevelEnum = Shield.LogLevel.VERBOSE;
+        break;
+    }
+    return logLevelEnum;
+  }
+
+  @ReactMethod
+  public void setDeviceResultStateListener(Callback callback) {
+    Shield.getInstance().setDeviceResultStateListener(new Shield.DeviceResultStateListener() {
+      @Override
+      public void isReady() {
+        // Invoke the callback when the device is ready
+        callback.invoke();
+      }
+    });
+  }
+
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public String getSessionId() {
+    System.out.println("SHIELD:: GetSession Id");
+    return Shield.getInstance().getSessionId();
+  }
+
+  @Override
+  public void onSuccess(@Nullable JSONObject jsonObject) {
+    if (jsonObject != null) {
+      reactContext
+              .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+              .emit("success", jsonObject.toString());
+    }
+  }
+
+  @Override
+  public void onFailure(@Nullable ShieldException e) {
+    if (e != null) {
+      reactContext
+              .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+              .emit("error", e.getLocalizedMessage());
+    }
+
+  }
+
+  @ReactMethod
+  public void sendAttributes(String screenName, ReadableMap json) {
+    HashMap<String,String> data =new HashMap<String,String>();
+    for (Map.Entry<String, Object> entry : json.toHashMap().entrySet()) {
+      data.put(entry.getKey(), (String) entry.getValue());
+    }
+    Shield.getInstance().setDeviceResultStateListener(new Shield.DeviceResultStateListener(){
+      // check whether device fingerprinting is completed
+      @Override
+      public void isReady() {
+        Shield.getInstance().sendAttributes(screenName, data);
+        System.out.println("the attribteus are sent to the server");
+      }
+    });
+  }
+
+  @ReactMethod
+  public void getLatestDeviceResult(Callback successCallback, Callback errorCallback) {
+        if (Shield.getInstance().getLatestDeviceResult() != null) {
+          JSONObject deviceResult = Shield.getInstance().getLatestDeviceResult();
+          successCallback.invoke(deviceResult.toString());
+        } else {
+          ShieldException error = Shield.getInstance().getResponseError();
+          String errorMessage = "unknown error";
+          if (error != null) {
+            errorMessage = error.getMessage();
+          }
+          errorCallback.invoke(errorMessage);
+        }
+      }
+}

package/android/src/main/java/com/shieldfraudplugin/ShieldFraudPluginPackage.java

@@ -0,0 +1,28 @@
+package com.shieldfraudplugin;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class ShieldFraudPluginPackage implements ReactPackage {
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    modules.add(new ShieldFraudPluginModule(reactContext));
+    return modules;
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/ios/Podfile

@@ -0,0 +1,10 @@
+# Uncomment the next line to define a global platform for your project
+platform :ios, '11.0'
+
+target 'ShieldFraudPlugin' do
+  # Comment the next line if you don't want to use dynamic frameworks
+  use_frameworks!
+  
+  # Pods for ShieldFraudPlugin
+  pod 'ShieldFraud'
+end

package/ios/Podfile.lock

@@ -0,0 +1,16 @@
+PODS:
+  - ShieldFraud (1.5.24)
+
+DEPENDENCIES:
+  - ShieldFraud
+
+SPEC REPOS:
+  trunk:
+    - ShieldFraud
+
+SPEC CHECKSUMS:
+  ShieldFraud: 83c34e06aca03c764534c25c9e19752ae1837acc
+
+PODFILE CHECKSUM: a5054f2edb3e213ae2ca7daafb855d17cf61674c
+
+COCOAPODS: 1.11.3

package/ios/Pods/Manifest.lock

@@ -0,0 +1,16 @@
+PODS:
+  - ShieldFraud (1.5.24)
+
+DEPENDENCIES:
+  - ShieldFraud
+
+SPEC REPOS:
+  trunk:
+    - ShieldFraud
+
+SPEC CHECKSUMS:
+  ShieldFraud: 83c34e06aca03c764534c25c9e19752ae1837acc
+
+PODFILE CHECKSUM: a5054f2edb3e213ae2ca7daafb855d17cf61674c
+
+COCOAPODS: 1.11.3