@veriff/react-native-sdk 2.7.0 → 2.10.0

package/.prettierrc.js

@@ -1,6 +1,5 @@
 module.exports = {
   bracketSpacing: true,
-  jsxBracketSameLine: true,
   singleQuote: true,
   trailingComma: 'all',
 };

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "java.configuration.updateBuildConfiguration": "automatic"
+}

package/android/build.gradle

@@ -1,155 +1,46 @@
-// android/build.gradle
+buildscript {
+    ext.safeExtGet = { prop, fallback ->
+        return rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
 
-// based on:
-//
-// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/build.gradle
-//   original location:
-//   - https://github.com/facebook/react-native/blob/0.58-stable/local-cli/templates/HelloWorld/android/build.gradle
-//
-// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/app/build.gradle
-//   original location:
-//   - https://github.com/facebook/react-native/blob/0.58-stable/local-cli/templates/HelloWorld/android/app/build.gradle
+    repositories {
+        google()
+        mavenCentral()
+    }
 
-def DEFAULT_COMPILE_SDK_VERSION = 28
-def DEFAULT_BUILD_TOOLS_VERSION = '28.0.3'
-def DEFAULT_MIN_SDK_VERSION = 21
-def DEFAULT_TARGET_SDK_VERSION = 28
+    dependencies {
+        classpath 'com.android.tools.build:gradle:7.0.4'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion', '1.6.10')}"
+    }
+}
 
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
 
 apply plugin: 'com.android.library'
-apply plugin: 'maven'
-
-buildscript {
-    // The Android Gradle plugin is only required when opening the android folder stand-alone.
-    // This avoids unnecessary downloads and potential conflicts when the library is included as a
-    // module dependency in an application project.
-    // ref: https://docs.gradle.org/current/userguide/tutorial_using_tasks.html#sec:build_script_external_dependencies
-    if (project == rootProject) {
-        repositories {
-            google()
-            jcenter()
-        }
-        dependencies {
-            classpath 'com.android.tools.build:gradle:3.4.1'
-        }
-    }
-}
-
-apply plugin: 'com.android.library'
-apply plugin: 'maven'
+apply plugin: 'kotlin-android'
+apply plugin: 'maven-publish'
 
 android {
-    compileSdkVersion safeExtGet('compileSdkVersion', DEFAULT_COMPILE_SDK_VERSION)
-    buildToolsVersion safeExtGet('buildToolsVersion', DEFAULT_BUILD_TOOLS_VERSION)
+    compileSdkVersion safeExtGet('compileSdkVersion', 31)
+    buildToolsVersion safeExtGet('buildToolsVersion', '31.0.0')
+
     defaultConfig {
-        minSdkVersion safeExtGet('minSdkVersion', DEFAULT_MIN_SDK_VERSION)
-        targetSdkVersion safeExtGet('targetSdkVersion', DEFAULT_TARGET_SDK_VERSION)
-        versionCode 1
-        versionName "1.0"
-    }
-    compileOptions {
-      sourceCompatibility JavaVersion.VERSION_1_8
-      targetCompatibility JavaVersion.VERSION_1_8
-    }
-    lintOptions {
-        abortOnError false
+        minSdkVersion safeExtGet('minSdkVersion', 21)
+        targetSdkVersion safeExtGet('targetSdkVersion', 31)
     }
 }
 
 repositories {
-    // ref: https://www.baeldung.com/maven-local-repository
     mavenLocal()
-    maven {
-        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
-        url "$rootDir/../node_modules/react-native/android"
-    }
-    maven {
-        // Android JSC is installed from npm
-        url "$rootDir/../node_modules/jsc-android/dist"
-    }
-    maven { url "https://cdn.veriff.me/android/" } //veriff
     google()
-    jcenter()
+    mavenCentral()
+    maven { url "https://cdn.veriff.me/android/" } //veriff public repo
 }
 
 dependencies {
     //noinspection GradleDynamicVersion
-    implementation 'com.facebook.react:react-native:+'  // From node_modules
-    implementation 'com.veriff:veriff-library:4.+'
-}
-
-def configureReactNativePom(def pom) {
-    def packageJson = new groovy.json.JsonSlurper().parseText(file('../package.json').text)
-
-    pom.project {
-        name packageJson.title
-        artifactId packageJson.name
-        version = packageJson.version
-        group = "com.reactlibrary"
-        description packageJson.description
-        url = "https://github.com/veriff/react-native-sdk"
-
-        licenses {
-            license {
-                name packageJson.license
-                url "https://github.com/veriff/react-native-sdk" + '/blob/master/' + packageJson.licenseFilename
-                distribution 'repo'
-            }
-        }
-
-        developers {
-            developer {
-                id packageJson.author.username
-                name packageJson.author.name
-            }
-        }
-    }
-}
-
-afterEvaluate { project ->
-    // some Gradle build hooks ref:
-    // https://www.oreilly.com/library/view/gradle-beyond-the/9781449373801/ch03.html
-    task androidJavadoc(type: Javadoc) {
-        source = android.sourceSets.main.java.srcDirs
-        classpath += files(android.bootClasspath)
-        classpath += files(project.getConfigurations().getByName('compile').asList())
-        include '**/*.java'
-    }
-
-    task androidJavadocJar(type: Jar, dependsOn: androidJavadoc) {
-        classifier = 'javadoc'
-        from androidJavadoc.destinationDir
-    }
-
-    task androidSourcesJar(type: Jar) {
-        classifier = 'sources'
-        from android.sourceSets.main.java.srcDirs
-        include '**/*.java'
-    }
-
-    android.libraryVariants.all { variant ->
-        def name = variant.name.capitalize()
-        def javaCompileTask = variant.javaCompileProvider.get()
-
-        task "jar${name}"(type: Jar, dependsOn: javaCompileTask) {
-            from javaCompileTask.destinationDir
-        }
-    }
-
-    artifacts {
-        archives androidSourcesJar
-        archives androidJavadocJar
-    }
-
-    task installArchives(type: Upload) {
-        configuration = configurations.archives
-        repositories.mavenDeployer {
-            // Deploy to react-native-event-bridge/maven, ready to publish to npm
-            repository url: "file://${projectDir}/../android/maven"
-            configureReactNativePom pom
-        }
-    }
-}
+    implementation 'com.facebook.react:react-native:+'
+    implementation 'com.veriff:veriff-library:4.6.1'
+}

package/android/src/main/java/com/veriff/sdk/reactnative/ImageLoader.java

@@ -0,0 +1,119 @@
+package com.veriff.sdk.reactnative;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import com.facebook.common.references.CloseableReference;
+import com.facebook.datasource.DataSource;
+import com.facebook.drawee.backends.pipeline.Fresco;
+import com.facebook.imagepipeline.datasource.BaseBitmapDataSubscriber;
+import com.facebook.imagepipeline.image.CloseableImage;
+import com.facebook.imagepipeline.request.ImageRequest;
+import com.facebook.imagepipeline.request.ImageRequestBuilder;
+
+import java.io.IOException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+
+public class ImageLoader {
+    private static final String TAG = "ImageLoader";
+
+    private final Handler main = new Handler(Looper.getMainLooper());
+
+    public Drawable load(Context context, String url) throws IOException {
+        if (isAsyncLogoUrl(url)) {
+            Log.d(TAG, "Async image" + url);
+            return loadAsyncImage(context, url);
+        } else {
+            Log.d(TAG, "Image from resource" + url);
+            int drawableId = getDrawableId(context, url);
+            return context.getDrawable(drawableId);
+        }
+    }
+
+    private Drawable loadAsyncImage(Context context, String url) throws IOException {
+        ImageRequest request = ImageRequestBuilder.fromRequest(ImageRequest.fromUri(url)).build();
+
+        if (!Fresco.hasBeenInitialized()) {
+            Fresco.initialize(context);
+        }
+
+        DataSource<CloseableReference<CloseableImage>> source =
+                Fresco.getImagePipeline().fetchDecodedImage(request, null);
+
+        CountDownLatch imageLoadLatch = new CountDownLatch(1);
+        AtomicReference<Result> atomicResult = new AtomicReference<>(null);
+        source.subscribe(new BaseBitmapDataSubscriber() {
+            @Override
+            protected void onNewResultImpl(Bitmap bitmap) {
+                if (bitmap == null) {
+                    Log.w(TAG, "Null bitmap: " + url);
+                    atomicResult.set(new Result(new IOException("Loaded bitmap was null")));
+                } else {
+                    Log.w(TAG, "Non-Null bitmap: " + url);
+                    atomicResult.set(new Result(bitmap.copy(bitmap.getConfig(), false)));
+                }
+                imageLoadLatch.countDown();
+            }
+
+            @Override
+            protected void onFailureImpl(DataSource<CloseableReference<CloseableImage>> dataSource) {
+                Throwable failure = dataSource.getFailureCause();
+                if (failure == null) {
+                    atomicResult.set(new Result(new IOException("Provided failure cause was null")));
+                } else if (failure instanceof IOException) {
+                    atomicResult.set(new Result((IOException) failure));
+                } else {
+                    atomicResult.set(new Result(new IOException("Failed loading image", failure)));
+                }
+                imageLoadLatch.countDown();
+            }
+        }, main::post);
+
+
+        try {
+            imageLoadLatch.await();
+            Result result = atomicResult.get();
+
+            if (result.error != null) {
+                Log.w(TAG, "[ImageLoader] Loading image from [" + url + "] failed", result.error);
+                throw result.error;
+            } else {
+                Log.w(TAG, "[ImageLoader] Loading image [" + url + "] got a bitmap with size w=" + result.bitmap.getWidth() + " h=" + result.bitmap.getHeight());
+                return new BitmapDrawable(context.getResources(), result.bitmap);
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt(); // preserve interrupt status
+            throw new IOException("Interrupted while loading image");
+        }
+    }
+
+    private static int getDrawableId(Context context, String name) {
+        return context.getResources().getIdentifier(name, "drawable", context.getPackageName());
+    }
+
+    private boolean isAsyncLogoUrl(String url) {
+        return url.startsWith("https://") || url.startsWith("http://") || url.startsWith("file://");
+    }
+
+    private static class Result {
+        private final IOException error;
+
+        private final Bitmap bitmap;
+
+        private Result(IOException error) {
+            this.error = error;
+            this.bitmap = null;
+        }
+
+        private Result(Bitmap bitmap) {
+            this.error = null;
+            this.bitmap = bitmap;
+        }
+    }
+
+}

package/android/src/main/java/com/veriff/sdk/reactnative/ReactNativeExternalResources.java

@@ -0,0 +1,105 @@
+package com.veriff.sdk.reactnative;
+
+import android.content.Context;
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.veriff.Branding;
+import com.veriff.Branding.ExternalResources.Image;
+import com.veriff.Branding.ExternalResources.Lottie;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import static com.veriff.sdk.reactnative.VeriffSdkModule.TAG;
+
+public class ReactNativeExternalResources implements Branding.ExternalResources, Parcelable {
+    private final ImageLoader imageLoader = new ImageLoader();
+
+    private final Map<Image, String> imageUrls;
+    private final Map<Lottie, String> lottieJson;
+
+    protected ReactNativeExternalResources(Parcel in) {
+        imageUrls = readMapFromParcel(in, Image.values());
+        lottieJson = readMapFromParcel(in, Lottie.values());
+    }
+
+    public ReactNativeExternalResources(Map<Image, String> imageUrls, Map<Lottie, String> lottieJson) {
+        this.imageUrls = imageUrls;
+        this.lottieJson = lottieJson;
+    }
+
+    @Nullable
+    @Override
+    public Drawable loadImage(@NonNull Context context, @NonNull Image target) throws IOException {
+        String imageUrl = imageUrls.get(target);
+        if (imageUrl != null) {
+            return imageLoader.load(context, imageUrl);
+        } else {
+            return null;
+        }
+    }
+
+    @Nullable
+    @Override
+    public String getLottieJson(Context context, @NonNull Lottie target) {
+        return lottieJson.get(target);
+    }
+
+    public static final Creator<ReactNativeExternalResources> CREATOR = new Creator<ReactNativeExternalResources>() {
+        @Override
+        public ReactNativeExternalResources createFromParcel(Parcel in) {
+            return new ReactNativeExternalResources(in);
+        }
+
+        @Override
+        public ReactNativeExternalResources[] newArray(int size) {
+            return new ReactNativeExternalResources[size];
+        }
+    };
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        writeMapToParcel(dest, imageUrls);
+        writeMapToParcel(dest, lottieJson);
+    }
+
+    private <E extends Enum<E>> void writeMapToParcel(Parcel dest, Map<E, String> map) {
+        dest.writeInt(map.size());
+        for (Map.Entry<E, String> entry : map.entrySet()) {
+            dest.writeInt(entry.getKey().ordinal());
+            dest.writeString(entry.getValue());
+            Log.d(TAG, String.format("Write to parcel [%s] -> [%s]", entry.getKey().ordinal(), entry.getValue()));
+        }
+    }
+
+    public <E extends Enum<E>> Map<E, String> readMapFromParcel(Parcel in, E[] values) {
+        int count = in.readInt();
+
+        Map<E, String> map = new HashMap<>(count);
+
+        int i = 0;
+        while (i < count) {
+            i++;
+
+            int ordinal = in.readInt();
+            String value = in.readString();
+            Log.d(TAG, String.format("Read from parcel [%s] -> [%s]", ordinal, value));
+
+            E key = values[ordinal];
+            map.put(key, value);
+        }
+
+        return map;
+    }
+}

package/android/src/main/java/com/veriff/sdk/reactnative/ReactNativeImageProvider.java

@@ -10,9 +10,6 @@ import android.os.Parcel;
 import android.os.Parcelable;
 import android.util.Log;
 
-import androidx.annotation.NonNull;
-import androidx.annotation.WorkerThread;
-
 import com.facebook.common.references.CloseableReference;
 import com.facebook.datasource.DataSource;
 import com.facebook.drawee.backends.pipeline.Fresco;
@@ -22,15 +19,12 @@ import com.facebook.imagepipeline.request.ImageRequest;
 import com.facebook.imagepipeline.request.ImageRequestBuilder;
 import com.veriff.Branding;
 
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
 import java.io.IOException;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicReference;
 
 public class ReactNativeImageProvider implements Branding.DrawableProvider, Parcelable {
-    private static final String TAG = "ReactNativeImage";
+    private static final String TAG = "ReactNativeImageProvider";
 
     private final String url;
 
@@ -44,11 +38,8 @@ public class ReactNativeImageProvider implements Branding.DrawableProvider, Parc
         this(in.readString());
     }
 
-    @NonNull
-    @NotNull
     @Override
-    @WorkerThread
-    public Drawable loadImage(@NonNull @NotNull Context context) throws IOException {
+    public Drawable loadImage(Context context) throws IOException {
         ImageRequest request = ImageRequestBuilder.fromRequest(ImageRequest.fromUri(this.url)).build();
         DataSource<CloseableReference<CloseableImage>> source =
             Fresco.getImagePipeline().fetchDecodedImage(request, null);
@@ -58,7 +49,7 @@ public class ReactNativeImageProvider implements Branding.DrawableProvider, Parc
 
         source.subscribe(new BaseBitmapDataSubscriber() {
             @Override
-            protected void onNewResultImpl(@Nullable Bitmap bitmap) {
+            protected void onNewResultImpl(Bitmap bitmap) {
                 if (bitmap == null) {
                     atomicResult.set(new Result(new IOException("Loaded bitmap was null")));
                 } else {
@@ -87,10 +78,10 @@ public class ReactNativeImageProvider implements Branding.DrawableProvider, Parc
             Result result = atomicResult.get();
 
             if (result.error != null) {
-                Log.w(TAG, "Loading image from " + this.url + " failed", result.error);
+                Log.w(TAG, "[ReactNativeImageProvider] Loading image from [" + this.url + "] failed", result.error);
                 throw result.error;
             } else {
-                Log.w(TAG, "Loading image got a bitmap with size w=" + result.bitmap.getWidth() + " h=" + result.bitmap.getHeight());
+                Log.w(TAG, "[ReactNativeImageProvider] Loading image [" + this.url + "]  got a bitmap with size w=" + result.bitmap.getWidth() + " h=" + result.bitmap.getHeight());
                 return new BitmapDrawable(context.getResources(), result.bitmap);
             }
         } catch (InterruptedException e) {
@@ -100,10 +91,8 @@ public class ReactNativeImageProvider implements Branding.DrawableProvider, Parc
     }
 
     private static class Result {
-        @Nullable
         private final IOException error;
 
-        @Nullable
         private final Bitmap bitmap;
 
         private Result(IOException error) {

package/android/src/main/java/com/veriff/sdk/reactnative/VeriffSdkModule.java

@@ -3,6 +3,7 @@ package com.veriff.sdk.reactnative;
 import android.app.Activity;
 import android.content.Context;
 import android.content.Intent;
+import android.content.res.Resources;
 import android.graphics.Color;
 import android.text.TextUtils;
 import android.util.Log;
@@ -19,15 +20,15 @@ import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.bridge.WritableMap;
 import com.veriff.Branding;
 import com.veriff.Configuration;
+import com.veriff.Font;
 import com.veriff.Result;
 import com.veriff.Result.Status;
 import com.veriff.Sdk;
 
-import java.util.HashMap;
-import java.util.Locale;
-import java.util.Map;
+import java.util.*;
 
 import com.veriff.GeneralConfig;
+import com.veriff.sdk.reactnative.mapper.ExternalResourcesMapper;
 import okhttp3.HttpUrl;
 
 import static android.app.Activity.RESULT_CANCELED;
@@ -62,7 +63,7 @@ public class VeriffSdkModule extends ReactContextBaseJavaModule {
     private static final String STATUS_ERROR = "STATUS_ERROR";
 
     private static final String DEFAULT_BASE_URL = "https://magic.veriff.me";
-    private static final String TAG = "@veriff/react-native-sdk";
+    public static final String TAG = "@veriff/RN-SDK";
     private static final String JS_NAME = "VeriffSdk";
 
     private static final int VERIFF_REQUEST_CODE = 47239;
@@ -86,8 +87,13 @@ public class VeriffSdkModule extends ReactContextBaseJavaModule {
     public static final String KEY_PRIMARY_BUTTON_BACKGROUND_COLOR = "primaryButtonBackgroundColor";
     public static final String KEY_BUTTON_CORNER_RADIUS = "buttonCornerRadius";
     private static final String KEY_CUSTOM_INTRO_SCREEN = "customIntroScreen";
+    public static final String KEY_ADVANCED_CONFIGURATIONS = "advancedConfigurations";
     private static final String KEY_RN_IMAGE_URI = "uri";
 
+    private static final String KEY_FONT = "androidFont";
+    private static final String KEY_FONT_NORMAL = "regularFontName";
+    private static final String KEY_FONT_BOLD = "boldFontName";
+
     private static final String ERROR_UNABLE_TO_ACCESS_CAMERA = "UNABLE_TO_ACCESS_CAMERA";
     private static final String ERROR_UNABLE_TO_RECORD_AUDIO = "UNABLE_TO_RECORD_AUDIO";
     private static final String ERROR_UNABLE_TO_START_CAMERA = "UNABLE_TO_START_CAMERA";
@@ -159,19 +165,19 @@ public class VeriffSdkModule extends ReactContextBaseJavaModule {
             } else {
                 sessionToken = configuration.hasKey(KEY_TOKEN) ? configuration.getString(KEY_TOKEN) : null;
                 if (TextUtils.isEmpty(sessionToken)) {
-                  promise.reject(ERROR_INVALID_ARGS, "No sessionToken in Veriff SDK configuration");
-                  return;
+                    promise.reject(ERROR_INVALID_ARGS, "No sessionToken in Veriff SDK configuration");
+                    return;
                 }
 
                 String baseUrl = null;
                 if (configuration.hasKey(KEY_BASE_URL)) {
-                  baseUrl = configuration.getString(KEY_BASE_URL);
+                    baseUrl = configuration.getString(KEY_BASE_URL);
                 }
                 if (TextUtils.isEmpty(baseUrl)) {
-                  baseUrl = DEFAULT_BASE_URL;
+                    baseUrl = DEFAULT_BASE_URL;
                 }
                 if (baseUrl.endsWith("/")) {
-                  baseUrl = baseUrl.substring(0, baseUrl.length() - 1);
+                    baseUrl = baseUrl.substring(0, baseUrl.length() - 1);
                 }
                 startUrl = baseUrl + "/v/" + sessionToken;
             }
@@ -203,11 +209,11 @@ public class VeriffSdkModule extends ReactContextBaseJavaModule {
 
                         Status status = resultCode == RESULT_CANCELED ? CANCELED : ERROR;
                         if (veriffResult != null) {
-                          status = veriffResult.getStatus();
+                            status = veriffResult.getStatus();
                         }
                         result.putString(KEY_STATUS, statusToString(status));
-                        if (veriffResult != null && veriffResult.getError() != null){
-                          result.putString(KEY_ERROR, codeToError(veriffResult.getError()));
+                        if (veriffResult != null && veriffResult.getError() != null) {
+                            result.putString(KEY_ERROR, codeToError(veriffResult.getError()));
                         }
 
                         promise.resolve(result);
@@ -255,7 +261,15 @@ public class VeriffSdkModule extends ReactContextBaseJavaModule {
                         branding.primaryButtonBackgroundColor(parseColor(brandConfig.getString(KEY_PRIMARY_BUTTON_BACKGROUND_COLOR)));
                     }
                     if (brandConfig.hasKey(KEY_BUTTON_CORNER_RADIUS)) {
-                        branding.buttonCornerRadius((float)brandConfig.getDouble(KEY_BUTTON_CORNER_RADIUS));
+                        branding.buttonCornerRadius((float) brandConfig.getDouble(KEY_BUTTON_CORNER_RADIUS));
+                    }
+                    handleExternalResources(brandConfig, branding);
+                    handleAdvancedConfigurations(brandConfig, branding);
+
+                    if (brandConfig.hasKey(KEY_FONT)) {
+                        ReadableMap srcFont = brandConfig.getMap(KEY_FONT);
+                        Font font = buildFont(activity, srcFont);
+                        branding.font(font);
                     }
                     configBuilder.branding(branding.build());
                 }
@@ -269,13 +283,47 @@ public class VeriffSdkModule extends ReactContextBaseJavaModule {
             activity.startActivityForResult(intent, VERIFF_REQUEST_CODE);
 
         } catch (Throwable t) {
-              Log.e(TAG, "starting verification failed", t);
-              promise.reject(t);
+            Log.e(TAG, "starting verification failed", t);
+            promise.reject(t);
         }
     }
 
+    private Font buildFont(Context context, ReadableMap src) {
+        int normalFont = getFontId(context, src.getString(KEY_FONT_NORMAL));
+        int boldFont = getFontId(context, src.getString(KEY_FONT_BOLD));
+
+        Log.v(TAG, String.format("Normal font: [%s], value [%s]",
+                src.getString(KEY_FONT_NORMAL), normalFont));
+
+        Log.v(TAG, String.format("Bold font: [%s], value [%s]",
+                src.getString(KEY_FONT_BOLD), boldFont));
+
+        return new Font.Builder()
+                .setNormalAndBold(normalFont, boldFont)
+                .build();
+    }
+
+
+    private void handleExternalResources(ReadableMap brandConfig, Branding.Builder branding) {
+        ExternalResourcesMapper mapper = new ExternalResourcesMapper();
+
+        branding.externalResources(mapper.map(brandConfig));
+    }
+
+    private void handleAdvancedConfigurations(ReadableMap brandConfig, Branding.Builder branding) {
+        Map<String, Object> result = new HashMap<>();
+
+        if (brandConfig.hasKey(KEY_ADVANCED_CONFIGURATIONS)) {
+            ReadableMap config = brandConfig.getMap(KEY_ADVANCED_CONFIGURATIONS);
+            result.put("customer", config.getString("customer"));
+        }
+
+        branding.advancedConfigurations(result);
+    }
+
     private void handleLogo(Context context, String key, Branding.Builder branding, ReadableMap brandConfig) {
         ReadableType type = brandConfig.getType(key);
+        Log.d(TAG, "Logo type" + type);
         if (ReadableType.String.equals(type)) {
             branding.toolbarIcon(getDrawableId(context, brandConfig.getString(key)));
         } else if (ReadableType.Map.equals(type)) {
@@ -287,15 +335,16 @@ public class VeriffSdkModule extends ReactContextBaseJavaModule {
                     if (!TextUtils.isEmpty(url)) {
                         // check if url has an async scheme
                         if (isAsyncLogoUrl(url)) {
+                            Log.d(TAG, "Async logo" + url);
                             branding.toolbarIconProvider(new ReactNativeImageProvider(url));
                         } else {
+                            Log.d(TAG, "Logo from resource" + url);
                             branding.toolbarIcon(getDrawableId(context, url));
                         }
                     } else {
                         Log.w(TAG, "Image url is empty: " + url);
                     }
                 } else {
-                    Log.w(TAG, "Provided image does not have " + KEY_RN_IMAGE_URI + " key. Keys: ");
                     for (String imageKey : image.toHashMap().keySet()) {
                         Log.w(TAG, imageKey);
                     }
@@ -304,7 +353,7 @@ public class VeriffSdkModule extends ReactContextBaseJavaModule {
                 Log.w(TAG, "Provided image is null");
             }
         } else {
-          Log.w(TAG, "Unexpected image type: " + type);
+            Log.w(TAG, "Unexpected image type: " + type);
         }
     }
 
@@ -322,12 +371,12 @@ public class VeriffSdkModule extends ReactContextBaseJavaModule {
         long color = Long.parseLong(hexcolor, 16);
         int a = 255;
         if (hexcolor.length() > 6) {
-            a = ((int)color) & 0xff;
+            a = ((int) color) & 0xff;
             color = color >>> 8;
         }
-        int r = ((int)(color >>> 16)) & 0xff;
-        int g = ((int)(color >>> 8)) & 0xff;
-        int b = ((int)(color >>> 0)) & 0xff;
+        int r = ((int) (color >>> 16)) & 0xff;
+        int g = ((int) (color >>> 8)) & 0xff;
+        int b = ((int) (color >>> 0)) & 0xff;
         return Color.argb(a, r, g, b);
     }
 
@@ -335,6 +384,10 @@ public class VeriffSdkModule extends ReactContextBaseJavaModule {
         return context.getResources().getIdentifier(name, "drawable", context.getPackageName());
     }
 
+    private static int getFontId(Context context, String name) {
+        return context.getResources().getIdentifier(name, "font", context.getPackageName());
+    }
+
     private static String codeToError(Result.Error error) {
         switch (error) {
             case UNABLE_TO_ACCESS_CAMERA:
@@ -344,17 +397,17 @@ public class VeriffSdkModule extends ReactContextBaseJavaModule {
             case UNABLE_TO_START_CAMERA:
                 return ERROR_UNABLE_TO_START_CAMERA;
             case UNSUPPORTED_SDK_VERSION:
-                  return ERROR_UNSUPPORTED_SDK_VERSION;
+                return ERROR_UNSUPPORTED_SDK_VERSION;
             case SESSION_ERROR:
-                  return ERROR_SESSION;
+                return ERROR_SESSION;
             case NETWORK_ERROR:
-                  return ERROR_NETWORK;
+                return ERROR_NETWORK;
             case SETUP_ERROR:
-                  return ERROR_SETUP;
+                return ERROR_SETUP;
             case NFC_DISABLED:
-              return ERROR_NFC_DISABLED;
+                return ERROR_NFC_DISABLED;
             case DEVICE_HAS_NO_NFC:
-              return ERROR_DEVICE_HAS_NO_NFC;
+                return ERROR_DEVICE_HAS_NO_NFC;
             case UNKNOWN_ERROR:
             default:
                 return ERROR_UNKNOWN;
@@ -362,11 +415,13 @@ public class VeriffSdkModule extends ReactContextBaseJavaModule {
     }
 
     private static String statusToString(Status status) {
-      switch (status){
-        case DONE: return STATUS_DONE;
-        case CANCELED: return STATUS_CANCELED;
-        default: return STATUS_ERROR;
-      }
+        switch (status) {
+            case DONE:
+                return STATUS_DONE;
+            case CANCELED:
+                return STATUS_CANCELED;
+            default:
+                return STATUS_ERROR;
+        }
     }
-
 }

package/android/src/main/java/com/veriff/sdk/reactnative/mapper/ExternalResourcesMapper.java

@@ -0,0 +1,114 @@
+package com.veriff.sdk.reactnative.mapper;
+
+import android.graphics.Typeface;
+import android.util.JsonWriter;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.bridge.Dynamic;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableNativeMap;
+import com.veriff.sdk.reactnative.ImageLoader;
+import com.veriff.sdk.reactnative.ReactNativeExternalResources;
+import com.veriff.Branding;
+import com.veriff.Branding.ExternalResources.Image;
+import com.veriff.Branding.ExternalResources.Lottie;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static com.veriff.sdk.reactnative.VeriffSdkModule.KEY_ADVANCED_CONFIGURATIONS;
+import static com.veriff.sdk.reactnative.VeriffSdkModule.TAG;
+
+public class ExternalResourcesMapper {
+    public ReactNativeExternalResources map(ReadableMap brandConfig) {
+        Map<Image, String> images = mapImages(brandConfig);
+        Map<Lottie, String> lottie = mapLottie(brandConfig);
+
+        if (!images.isEmpty() || !lottie.isEmpty()) {
+            return new ReactNativeExternalResources(images, lottie);
+        } else {
+            return null;
+        }
+    }
+
+    private Map<Image, String> mapImages(ReadableMap brandConfig) {
+        Map<Image, String> images = new HashMap();
+        if (brandConfig.hasKey(KEY_ADVANCED_CONFIGURATIONS)) {
+            ReadableMap config = brandConfig.getMap(KEY_ADVANCED_CONFIGURATIONS);
+
+            appendImage(config, KEY_DOCUMENT_FRONT, images, Image.DOCUMENT_FRONT);
+            appendImage(config, KEY_DOCUMENT_BACK, images, Image.DOCUMENT_BACK_END);
+            appendImage(config, KEY_BANNER_ERROR_ICON, images, Image.BANNER_ICON_ERROR);
+            appendImage(config, KEY_CAMERA_ERROR, images, Image.ERROR_CAMERA);
+            appendImage(config, KEY_MICROPHONE_ERROR, images, Image.ERROR_MICROPHONE);
+            appendImage(config, KEY_SERVER_ERROR, images, Image.ERROR_SYSTEM);
+            appendImage(config, KEY_LOCAL_ERROR, images, Image.ERROR_SYSTEM);
+            appendImage(config, KEY_NETWORK_ERROR, images, Image.ERROR_NETWORK);
+            appendImage(config, KEY_VERSION_ERROR, images, Image.ERROR_VERSION);
+            appendImage(config, KEY_UNKNOWN_ERROR, images, Image.ERROR_UNKNOWN);
+            appendImage(config, KEY_CONSENT_ICON, images, Image.CONSENT_IMAGE);
+        }
+
+        return images;
+    }
+
+    private void appendImage(
+            ReadableMap advancedConfig,
+            String configKey,
+            Map<Branding.ExternalResources.Image, String> map,
+            Branding.ExternalResources.Image mapKey
+    ) {
+        if (advancedConfig.hasKey(configKey)) {
+            ReadableMap item = advancedConfig.getMap(configKey);
+            String url = item.getString("uri");
+            if (url != null) {
+                map.put(mapKey, url);
+            }
+        }
+    }
+
+    private Map<Lottie, String> mapLottie(ReadableMap brandConfig) {
+        Map<Lottie, String> lottie = new HashMap();
+
+        if (brandConfig.hasKey(KEY_ADVANCED_CONFIGURATIONS)) {
+            ReadableMap config = brandConfig.getMap(KEY_ADVANCED_CONFIGURATIONS);
+
+            appendLottie(config, KEY_LOTTIE_PROGRESS, lottie, Lottie.PROGRESS);
+
+        }
+
+        return lottie;
+    }
+
+    private void appendLottie(
+            ReadableMap advancedConfig,
+            String configKey,
+            Map<Lottie, String> map,
+            Lottie mapKey
+    ) {
+        if (advancedConfig.hasKey(configKey)) {
+            String lottie = advancedConfig.getString(configKey);
+
+            map.put(mapKey, lottie);
+        }
+    }
+
+    private final String KEY_DOCUMENT_FRONT = "documentFrontIcon";
+    private final String KEY_DOCUMENT_BACK = "documentBackIcon";
+    private final String KEY_BANNER_ERROR_ICON = "bannerErrorIcon";
+    private final String KEY_CONSENT_ICON = "consentIcon";
+
+    private final String KEY_CAMERA_ERROR = "cameraUnavailableErrorIcon";
+    private final String KEY_MICROPHONE_ERROR = "microphoneUnavailableErrorIcon";
+    private final String KEY_SERVER_ERROR = "serverErrorIcon";
+    private final String KEY_LOCAL_ERROR = "localErrorIcon";
+    private final String KEY_NETWORK_ERROR = "networkErrorIcon";
+    private final String KEY_VERSION_ERROR = "deprecatedSDKVersionErrorIcon";
+    private final String KEY_UNKNOWN_ERROR = "unknownErrorIcon";
+
+    private final String KEY_LOTTIE_PROGRESS = "loadingAnimation";
+}

package/app.plugin.js

@@ -18,7 +18,7 @@ function getUpdatedProjectGradle(buildGradle) {
 }
 
 function withVeriffProjectGradle(expoConfig) {
-  return withProjectBuildGradle(expoConfig, config => {
+  return withProjectBuildGradle(expoConfig, (config) => {
     config.modResults.contents = getUpdatedProjectGradle(
       config.modResults.contents,
     );

package/ios/Podfile

@@ -1,40 +1,18 @@
 platform :ios, '11.0'
+install! 'cocoapods', :deterministic_uuids => false
+require_relative '../node_modules/react-native/scripts/react_native_pods'
 require_relative '../node_modules/@react-native-community/cli-platform-ios/native_modules'
 
 target 'VeriffSdk' do
   # Pods for VeriffSdk
   pod 'VeriffSDK'
+  pod 'lottie-ios'
 
-  pod 'FBLazyVector', :path => "../node_modules/react-native/Libraries/FBLazyVector"
-  pod 'FBReactNativeSpec', :path => "../node_modules/react-native/Libraries/FBReactNativeSpec"
-  pod 'RCTRequired', :path => "../node_modules/react-native/Libraries/RCTRequired"
-  pod 'RCTTypeSafety', :path => "../node_modules/react-native/Libraries/TypeSafety"
-  pod 'React', :path => '../node_modules/react-native/'
-  pod 'React-Core', :path => '../node_modules/react-native/'
-  pod 'React-CoreModules', :path => '../node_modules/react-native/React/CoreModules'
-  pod 'React-Core/DevSupport', :path => '../node_modules/react-native/'
-  pod 'React-RCTActionSheet', :path => '../node_modules/react-native/Libraries/ActionSheetIOS'
-  pod 'React-RCTAnimation', :path => '../node_modules/react-native/Libraries/NativeAnimation'
-  pod 'React-RCTBlob', :path => '../node_modules/react-native/Libraries/Blob'
-  pod 'React-RCTImage', :path => '../node_modules/react-native/Libraries/Image'
-  pod 'React-RCTLinking', :path => '../node_modules/react-native/Libraries/LinkingIOS'
-  pod 'React-RCTNetwork', :path => '../node_modules/react-native/Libraries/Network'
-  pod 'React-RCTSettings', :path => '../node_modules/react-native/Libraries/Settings'
-  pod 'React-RCTText', :path => '../node_modules/react-native/Libraries/Text'
-  pod 'React-RCTVibration', :path => '../node_modules/react-native/Libraries/Vibration'
-  pod 'React-Core/RCTWebSocket', :path => '../node_modules/react-native/'
+  config = use_native_modules!
 
-  pod 'React-cxxreact', :path => '../node_modules/react-native/ReactCommon/cxxreact'
-  pod 'React-jsi', :path => '../node_modules/react-native/ReactCommon/jsi'
-  pod 'React-jsiexecutor', :path => '../node_modules/react-native/ReactCommon/jsiexecutor'
-  pod 'React-jsinspector', :path => '../node_modules/react-native/ReactCommon/jsinspector'
-  pod 'ReactCommon/jscallinvoker', :path => "../node_modules/react-native/ReactCommon"
-  pod 'ReactCommon/turbomodule/core', :path => "../node_modules/react-native/ReactCommon"
-  pod 'Yoga', :path => '../node_modules/react-native/ReactCommon/yoga'
-
-  pod 'DoubleConversion', :podspec => '../node_modules/react-native/third-party-podspecs/DoubleConversion.podspec'
-  pod 'glog', :podspec => '../node_modules/react-native/third-party-podspecs/glog.podspec'
-  pod 'Folly', :podspec => '../node_modules/react-native/third-party-podspecs/Folly.podspec'
-
-  use_native_modules!
+  # Flags change depending on the env values.
+  flags = get_default_flags()
+  use_react_native!(
+    :path => config[:reactNativePath]
+  )
 end

package/ios/VeriffSdk.swift

@@ -1,6 +1,7 @@
 import Foundation
 import Veriff
 import UIKit
+import Lottie
 
 @objc(VeriffSdkReactWrapper)
 class VeriffSdk: NSObject {
@@ -28,7 +29,6 @@ class VeriffSdk: NSObject {
   private static let BRANDING = "branding"
   private static let LOCALE = "locale"
   private static let THEME_COLOR = "themeColor"
-  static let NAVIGATION_BAR_IMAGE = "navigationBarImage"
   static let LOGO = "logo"
   private static let BACKGROUND_COLOR = "backgroundColor"
   private static let STATUS_BAR_COLOR = "statusBarColor"
@@ -37,6 +37,8 @@ class VeriffSdk: NSObject {
   private static let PRIMARY_BUTTON_BACKGROUND_COLOR = "primaryButtonBackgroundColor"
   private static let BUTTON_CORNER_RADIUS = "buttonCornerRadius"
   private static let USE_CUSTOM_INTRO_SCREEN = "customIntroScreen"
+  private static let ADVANCED_CONFIGURATIONS = "advancedConfigurations"
+  private static let FONT = "iOSFont"
 
   private static let STATUS = "status"
   private static let ERROR = "error"
@@ -69,7 +71,7 @@ class VeriffSdk: NSObject {
     if let brandingConfig = (configuration[VeriffSdk.BRANDING] as? [String: AnyObject]) {
       let color = (brandingConfig[VeriffSdk.THEME_COLOR] as? String).map { VeriffSdk.parseColor(hexcolor: $0) }
 
-      let imageProvider = VeriffSdkImageProvider(configuration: brandingConfig)
+      let imageProvider = VeriffSdkImageProvider(imageSource: brandingConfig[VeriffSdk.LOGO])
 
       if let imageURI = brandingConfig[VeriffSdk.LOGO],
          let imageDict = imageURI as? [String: AnyObject],
@@ -97,6 +99,50 @@ class VeriffSdk: NSObject {
       branding?.secondaryTextColor = (brandingConfig[VeriffSdk.SECONDARY_TEXT_COLOR] as? String).map { VeriffSdk.parseColor(hexcolor: $0) }
       branding?.primaryButtonBackgroundColor = (brandingConfig[VeriffSdk.PRIMARY_BUTTON_BACKGROUND_COLOR] as? String).map { VeriffSdk.parseColor(hexcolor: $0) }
       branding?.buttonCornerRadius = (brandingConfig[VeriffSdk.BUTTON_CORNER_RADIUS] as? Double).map { CGFloat($0) }
+      if let rnAdvancedConfigurations = brandingConfig[VeriffSdk.ADVANCED_CONFIGURATIONS] as? [String: Any] {
+        var advancedConfigurations: [String: Any] = [:]
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "rotateToPortraitIcon"), for: "rotateToPortraitIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "rotateToLandscapeIcon"), for: "rotateToLandscapeIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "documentFrontIcon"), for: "documentFrontIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "documentBackIcon"), for: "documentBackIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "cameraUnavailableErrorIcon"), for: "cameraUnavailableErrorIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "microphoneUnavailableErrorIcon"), for: "microphoneUnavailableErrorIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "serverErrorIcon"), for: "serverErrorIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "localErrorIcon"), for: "localErrorIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "networkErrorIcon"), for: "networkErrorIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "uploadErrorIcon"), for: "uploadErrorIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "videoFailedErrorIcon"), for: "videoFailedErrorIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "deprecatedSDKVersionErrorIcon"), for: "deprecatedSDKVersionErrorIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "unknownErrorIcon"), for: "unknownErrorIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "bannerErrorIcon"), for: "bannerErrorIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations.image(for: "consentIcon"), for: "consentIcon")
+        advancedConfigurations.addValue(rnAdvancedConfigurations["customer"], for: "customer")
+        if let loadingAnimationString = rnAdvancedConfigurations["loadingAnimation"] as? String {
+            if
+              let jsonData = loadingAnimationString.data(using: .utf8),
+              let animation = try? JSONDecoder().decode(Lottie.Animation.self, from: jsonData)
+            {
+                let animationView: () -> UIView = {
+                    let animationView = Lottie.AnimationView(animation: animation)
+                    animationView.backgroundBehavior = .pauseAndRestore
+                    animationView.loopMode = .loop
+                    animationView.play(completion: nil)
+                    return animationView
+                }
+                advancedConfigurations["loadingAnimation"] = animationView
+            }
+        }
+        branding?.advancedConfigurations = advancedConfigurations
+      }
+      if
+        let font = brandingConfig[VeriffSdk.FONT] as? [String: Any],
+        let regular = font["regularFontName"] as? String,
+        let light = font["lightFontName"] as? String,
+        let semiBold = font["semiBoldFontName"] as? String,
+        let bold = font["boldFontName"] as? String
+      {
+        branding?.font = Veriff.VeriffSdk.Branding.Font(regularFontName: regular, lightFontName: light, semiBoldFontName: semiBold, boldFontName: bold)
+      }
     }
 
     if let sUrl = configuration[VeriffSdk.SESSION_URL] as? String {
@@ -212,3 +258,25 @@ extension VeriffSdk: VeriffSdkDelegate {
     self.resolve?(resultDict)
   }
 }
+
+private extension Dictionary where Key == String, Value == Any {
+  func image(for key: String) -> Any? {
+    let imageProvider = VeriffSdkImageProvider(imageSource: self[key])
+    if
+      let imageDict = self[key] as? [String: AnyObject],
+      let urlString = imageDict["uri"] as? String,
+      let url = URL(string: urlString),
+      !url.isFileURL,
+      let data = try? Data(contentsOf: url)
+    {
+      return UIImage(data: data)
+    } else {
+      return imageProvider.loadLocalAsset()
+    }
+  }
+
+  mutating func addValue(_ value: Any?, for key: String) {
+    guard let value = value else { return }
+    self[key] = value
+  }
+}

package/ios/VeriffSdkImageProvider.swift

@@ -4,15 +4,15 @@ import UIKit.UIImage
 
 @objc(VeriffSdkImageProvider)
 final class VeriffSdkImageProvider: NSObject {
-  private let configuration: [String: AnyObject]
+  private let imageSource: Any?
 
-  init(configuration: [String: AnyObject]) {
-    self.configuration = configuration
+  init(imageSource: Any?) {
+    self.imageSource = imageSource
     super.init()
   }
 
   func loadLocalAsset() -> UIImage? {
-    if let imageURI = configuration[VeriffSdk.LOGO] {
+    if let imageURI = imageSource {
       if let imageDict = imageURI as? [String: AnyObject],
          let urlString = imageDict["uri"] as? String {
         if let url = URL(string: urlString),
@@ -26,9 +26,7 @@ final class VeriffSdkImageProvider: NSObject {
         return UIImage(named: imageKey)
       }
     } else {
-      let imageKey = configuration[VeriffSdk.NAVIGATION_BAR_IMAGE]
-      let image = (imageKey as? String).flatMap { UIImage(named: $0) }
-      return image
+      return UIImage()
     }
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@veriff/react-native-sdk",
   "title": "React Native Veriff SDK",
-  "version": "2.7.0",
+  "version": "2.10.0",
   "description": "React Native SDK for Veriff identity verification",
   "main": "index.js",
   "scripts": {
@@ -25,13 +25,35 @@
   "licenseFilename": "LICENSE",
   "readmeFilename": "README.md",
   "peerDependencies": {
-    "react": "^16.8.1",
-    "react-native": ">=0.59.0-rc.0 <1.0.x"
+    "react": "*",
+    "react-native": "*"
   },
   "devDependencies": {
-    "react": "^16.8.3",
-    "react-native": "^0.59.10",
-    "@react-native-community/eslint-config": "^0.0.5",
-    "eslint": "^6.5.1"
+    "react": "18.1.0",
+    "react-native": "0.68.1",
+    "@react-native-community/eslint-config": "^3.0.1",
+    "eslint": "^7.0.0"
+  },
+  "resolutions": {
+    "ansi-regex": "^5.0.1",
+    "minimist": "^0.2.1",
+    "lodash": "^4.17.21",
+    "ua-parser-js": "^0.7.24",
+    "path-parse": "^1.0.7",
+    "tmpl": "^1.0.5",
+    "node-fetch": "^2.6.7",
+    "plist": "^3.0.4",
+    "ajv": "^6.12.3"
+  },
+  "resolutionComments": {
+    "ansi-regex": "Resolving to 5.0.1 to fix vulnerability (https://github.com/advisories/GHSA-93q8-gq69-wqmw)",
+    "minimist": "Resolving to 0.2.1 to fix vulnerability (https://www.npmjs.com/advisories/1066649)",
+    "lodash": "Resolving to 4.17.21 to fix vulnerability (https://www.npmjs.com/advisories/1065397)",
+    "ua-parser-js": "Resolving to 0.7.24 to fix vulnerability (https://www.npmjs.com/advisories/1065393)",
+    "path-parse": "Resolving to 1.0.7 to fix vulnerability (https://www.npmjs.com/advisories/1064972)",
+    "tmpl": "Resolving to 1.0.5 to fix vulnerability (https://www.npmjs.com/advisories/1064907)",
+    "node-fetch": "Resolving to 2.6.7 to fix vulnerability (https://www.npmjs.com/advisories/1064646)",
+    "plist": "Resolving to 3.0.4 to fix vulnerability (https://www.npmjs.com/advisories/1064605)",
+    "ajv": "Resolving to 6.12.3 to fix vulnerability (https://www.npmjs.com/advisories/1065159)"
   }
 }

package/react-native-sdk.podspec

@@ -20,5 +20,6 @@ Pod::Spec.new do |s|
   s.requires_arc = true
 
   s.dependency "React"
-  s.dependency "VeriffSDK", ">= 4.18.0"
+  s.dependency "VeriffSDK", ">= 4.34.0"
+  s.dependency "lottie-ios"
 end