@valifysolutions/react-native-vidvdigitalcontract 1.1.0

package/README.md

@@ -0,0 +1,240 @@
+# VIDV Digital Contract — React Native Plugin
+
+A React Native bridge for the **VIDV Digital Contract** native SDK. Identical functionality,
+API design, and flow to the Flutter plugin (`VIDVDigitalContractFlutter`).
+
+---
+
+## Requirements
+
+| Platform | Minimum version |
+|----------|----------------|
+| iOS      | 13.0           |
+| Android  | API 24 (7.0)   |
+| React Native | ≥ 0.70   |
+
+---
+
+## Installation
+
+```sh
+# npm
+npm install vidv-digital-contract-react-native
+
+# yarn
+yarn add vidv-digital-contract-react-native
+```
+
+### Android — repository credentials
+
+The native SDK is hosted on Valify's private Artifactory. Add the repository to your
+**project-level** `build.gradle` (or `settings.gradle` for newer React Native templates):
+
+```groovy
+repositories {
+    maven {
+        credentials {
+            username "sdk"
+            password "sdk123456"
+        }
+        url "https://www.valifystage.com/artifactory/libs-release/"
+    }
+    maven { url "https://jitpack.io" }
+    maven { url "https://developer.huawei.com/repo/" }
+}
+```
+
+### Android — manifest entries
+
+Add the following to your app's `AndroidManifest.xml`. Both the main activity and the
+SDK host activity **must share the same `taskAffinity`** so the flow returns correctly:
+
+```xml
+<activity
+    android:name=".MainActivity"
+    android:taskAffinity="com.yourapp.example"
+    android:launchMode="singleTop"
+    ... />
+
+<!-- Required SDK host activity -->
+<activity
+    android:name="me.vidv.vidvdigitalcontractsdk.VIDVDigitalContractHostActivity"
+    android:exported="true"
+    android:taskAffinity="com.yourapp.example"
+    android:documentLaunchMode="never"
+    android:excludeFromRecents="true"
+    tools:replace="android:taskAffinity,android:documentLaunchMode,android:excludeFromRecents" />
+```
+
+Also add packaging exclusions in `app/build.gradle`:
+
+```groovy
+packagingOptions {
+    pickFirst 'META-INF/versions/9/OSGI-INF/MANIFEST.MF'
+}
+```
+
+### iOS — CocoaPods
+
+```sh
+cd ios && pod install
+```
+
+The plugin's podspec depends on `VIDVDigitalContract ~> 1.1.0`. Make sure your team has
+access to the CocoaPods source for this pod, or point your Podfile to the private spec repo.
+
+---
+
+## Usage
+
+```ts
+import { startDigitalContract } from 'vidv-digital-contract-react-native';
+import type { DigitalContractResponse } from 'vidv-digital-contract-react-native';
+
+async function launch() {
+  const response: DigitalContractResponse = await startDigitalContract({
+    vidvBaseUrl:            'https://www.valifystage.com/',
+    dcBaseUrl:              'https://valify.staging.knfrm.com/',
+    bundleKey:              '<your-bundle-key>',
+    vidvAccessToken:        '<vidv-oauth-token>',
+    dcAccessToken:          '<dc-auth-token>',
+    tenantId:               '<tenant-id>',
+    userReferenceId:        'user-123',
+    language:               'en',          // 'en' or 'ar'
+    templateVersionId:      2,
+    contractExpiryMinutes:  30,
+    contractData:           JSON.stringify([
+      { field_id: '1', value: 'John' },
+      { field_id: '2', value: 'Doe' },
+    ]),
+    allowHandSignature:     false,         // optional
+  });
+
+  switch (response.state) {
+    case 'SUCCESS':
+      console.log('Contract signed!', response.result);
+      break;
+    case 'FAILURE':
+      console.warn('Service failure', response.result);
+      break;
+    case 'ERROR':
+      console.error('Builder error', response.result);
+      break;
+    case 'EXIT':
+      console.log('User exited', response.result);
+      break;
+  }
+}
+```
+
+---
+
+## API
+
+### `startDigitalContract(config)`
+
+Returns `Promise<DigitalContractResponse>`.
+
+#### `DigitalContractConfig`
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `vidvBaseUrl` | `string` | ✓ | VIDV backend base URL |
+| `dcBaseUrl` | `string` | ✓ | Digital Contract backend base URL |
+| `bundleKey` | `string` | ✓ | Your integration bundle key |
+| `vidvAccessToken` | `string` | ✓ | OAuth token from VIDV (`/api/o/token/`) |
+| `dcAccessToken` | `string` | ✓ | Auth token from DC (`/api/v1/auth-token`) |
+| `tenantId` | `string` | ✓ | Tenant ID returned with DC token |
+| `userReferenceId` | `string` | ✓ | Your internal user identifier |
+| `language` | `'en' \| 'ar'` | ✓ | UI language |
+| `templateVersionId` | `number` | ✓ | Contract template version (> 0) |
+| `contractExpiryMinutes` | `number` | ✓ | Session expiry in minutes (> 0) |
+| `contractData` | `string` | ✓ | JSON array of `{field_id, value}` objects |
+| `allowHandSignature` | `boolean` | — | Enable hand-signature capture |
+
+#### `DigitalContractResponse`
+
+```ts
+{
+  state:  'SUCCESS' | 'ERROR' | 'FAILURE' | 'EXIT';
+  result: {
+    // SUCCESS
+    data?: { contractID?: string; iframeURL?: string; contractStatus?: string };
+
+    // ERROR (builder validation)
+    code?: string | number;
+    message?: string;
+
+    // FAILURE (service error)
+    code?: string | number;
+    message?: string;
+    data?: DigitalContractData;
+    sdkError?: { errorCode?: string | number; message?: string };
+
+    // EXIT (user cancelled)
+    step?: string;
+    data?: DigitalContractData;
+  };
+}
+```
+
+---
+
+## Token fetching
+
+Tokens are **not** fetched by the plugin — your app must obtain them before calling
+`startDigitalContract`.
+
+### VIDV token (OAuth password grant)
+
+```ts
+const res = await fetch(`${vidvBaseUrl}/api/o/token/`, {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+  body: `username=...&password=...&client_id=...&client_secret=...&grant_type=password`,
+});
+const { access_token } = await res.json();
+```
+
+### DC token (HMAC-SHA256 authenticated)
+
+```ts
+import CryptoJS from 'crypto-js';
+
+const body   = JSON.stringify({ username, password, client_id, client_secret });
+const hmac   = CryptoJS.HmacSHA256(body, secretKey).toString(CryptoJS.enc.Hex);
+
+const res = await fetch(`${dcBaseUrl}/api/v1/auth-token`, {
+  method:  'POST',
+  headers: { 'Content-Type': 'application/json', hmac },
+  body,
+});
+const { data: { token, tenant_id } } = await res.json();
+```
+
+---
+
+## Example app
+
+A complete demo app is located in `example/`. It mirrors the Flutter example app exactly.
+
+```sh
+cd example
+yarn install
+
+# iOS
+cd ios && pod install && cd ..
+yarn ios
+
+# Android
+yarn android
+```
+
+---
+
+## Native SDK versions
+
+| Platform | SDK | Version |
+|----------|-----|---------|
+| Android  | `com.vidv:vidvdigitalcontractsdk` | `1.2.1` |
+| iOS      | `VIDVDigitalContract` (CocoaPod) | `~> 1.1.0` |

package/android/build.gradle

@@ -0,0 +1,59 @@
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath "com.android.tools.build:gradle:8.1.4"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.24"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    compileSdkVersion 35
+    namespace "com.vidv.digitalcontract"
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+        freeCompilerArgs += ["-Xskip-metadata-version-check"]
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs += 'src/main/kotlin'
+        }
+    }
+
+    defaultConfig {
+        minSdkVersion 24
+        targetSdkVersion 34
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+    maven {
+        credentials {
+            username "sdk"
+            password "sdk123456"
+        }
+        url "https://www.valifystage.com/artifactory/libs-release/"
+    }
+    maven { url "https://jitpack.io" }
+    maven { url "https://developer.huawei.com/repo/" }
+}
+
+dependencies {
+    implementation "com.facebook.react:react-native:+"
+    implementation "com.vidv:vidvdigitalcontractsdk:1.2.3"
+    implementation "com.google.code.gson:gson:2.11.0"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.vidv.digitalcontract">
+</manifest>

package/android/src/main/kotlin/com/vidv/digitalcontract/VIDVDigitalContractModule.kt

@@ -0,0 +1,111 @@
+package com.vidv.digitalcontract
+
+import android.app.Activity
+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.bridge.ReadableMap
+import com.google.gson.Gson
+import me.vidv.vidvdigitalcontractsdk.sdk.VIDVDigitalContractConfig
+import me.vidv.vidvdigitalcontractsdk.sdk.VIDVDigitalContractData
+import me.vidv.vidvdigitalcontractsdk.sdk.VIDVDigitalContractListener
+import me.vidv.vidvdigitalcontractsdk.sdk.VIDVDigitalContractResponse
+
+class VIDVDigitalContractModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    private val gson = Gson()
+    private var pendingPromise: Promise? = null
+
+    override fun getName(): String = "VIDVDigitalContract"
+
+    @ReactMethod
+    fun startDigitalContract(args: ReadableMap, promise: Promise) {
+        if (pendingPromise != null) {
+            promise.reject("ALREADY_RUNNING", "Another Digital Contract flow is in progress.")
+            return
+        }
+        val activity: Activity? = currentActivity
+        if (activity == null) {
+            promise.reject("NO_ACTIVITY", "Plugin is not attached to an Activity.")
+            return
+        }
+        val argsMap: Map<String, Any?> = args.toHashMap()
+        pendingPromise = promise
+        try {
+            startSDK(activity, argsMap)
+        } catch (t: Throwable) {
+            pendingPromise?.reject("START_ERROR", t.message)
+            pendingPromise = null
+        }
+    }
+
+    private fun numberFromArg(value: Any?): Int? = when (value) {
+        is Int -> value
+        is Long -> value.toInt()
+        is Double -> value.toInt()
+        is String -> value.toIntOrNull()
+        else -> null
+    }
+
+    private fun startSDK(activity: Activity, args: Map<String, Any?>) {
+        val builder = VIDVDigitalContractConfig.Builder()
+            .setVIDVBaseUrl(args["vidv_base_url"] as String)
+            .setDCBaseUrl(args["dc_base_url"] as String)
+            .setVIDVAccessToken(args["vidv_access_token"] as String)
+            .setDCAccessToken(args["dc_access_token"] as String)
+            .setBundleKey(args["bundle_key"] as String)
+            .setTenantId(args["tenant_id"] as String)
+            .setUserReferenceId(args["user_reference_id"] as String)
+            .setLanguage(args["language"] as String)
+            .setTemplateVersionId(numberFromArg(args["template_version_id"]) ?: 0)
+            .setExpiryMinutes(numberFromArg(args["contract_expiry_minutes"]) ?: 0)
+            .setContractData(args["contract_data"] as String)
+
+        if ((args["allow_hand_signature"] as? Boolean) == true) {
+            builder.setAllowHandSignature(true)
+        }
+
+        builder.start(activity, object : VIDVDigitalContractListener {
+            override fun onDigitalContractResult(result: VIDVDigitalContractResponse) {
+                when (result) {
+                    is VIDVDigitalContractResponse.Success -> sendJson(
+                        "SUCCESS",
+                        mapOf("data" to serializeData(result.data))
+                    )
+                    is VIDVDigitalContractResponse.BuilderError -> sendJson(
+                        "ERROR",
+                        mapOf("code" to result.code, "message" to result.message)
+                    )
+                    is VIDVDigitalContractResponse.ServiceFailure -> sendJson(
+                        "FAILURE",
+                        mapOf(
+                            "code" to result.code,
+                            "message" to result.message,
+                        )
+                    )
+                    is VIDVDigitalContractResponse.Exit -> sendJson(
+                        "EXIT",
+                        mapOf("data" to serializeData(result.data))
+                    )
+                }
+            }
+        })
+    }
+
+    private fun serializeData(data: VIDVDigitalContractData?): Map<String, Any?>? {
+        if (data == null) return null
+        return mapOf(
+            "contractID" to data.contractId,
+            "iframeURL" to data.iframeURL,
+            "contractStatus" to data.contractStatus
+        )
+    }
+
+    private fun sendJson(state: String, result: Any) {
+        val payload = mapOf("state" to state, "result" to result)
+        pendingPromise?.resolve(gson.toJson(payload))
+        pendingPromise = null
+    }
+}

package/android/src/main/kotlin/com/vidv/digitalcontract/VIDVDigitalContractPackage.kt

@@ -0,0 +1,14 @@
+package com.vidv.digitalcontract
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class VIDVDigitalContractPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        listOf(VIDVDigitalContractModule(reactContext))
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+        emptyList()
+}

package/ios/VIDVDigitalContractModule.m

@@ -0,0 +1,16 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(VIDVDigitalContract, VIDVDigitalContractModule, NSObject)
+
+RCT_EXTERN_METHOD(
+  startDigitalContract:(NSDictionary *)args
+  resolve:(RCTPromiseResolveBlock)resolve
+  rejecter:(RCTPromiseRejectBlock)reject
+)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+@end

package/ios/VIDVDigitalContractModule.swift

@@ -0,0 +1,156 @@
+import Foundation
+import UIKit
+import VIDVDigitalContract
+
+// Swift-native type aliases that match the ObjC RCTPromise block signatures.
+// Using these instead of RCTPromiseResolveBlock/RCTPromiseRejectBlock avoids
+// a compile failure when React-Core is not imported as a Swift module
+// (i.e. when use_frameworks! is NOT used, which is the common RN setup).
+ typealias Resolve = (Any?) -> Void
+ typealias Reject  = (String, String, Error?) -> Void
+
+@objc(VIDVDigitalContractModule)
+class VIDVDigitalContractModule: NSObject {
+
+    private static var pendingResolve: Resolve?
+    private static var pendingReject:  Reject?
+    private static var delegateHolder  = DigitalContractDelegateHolder()
+
+    // The selector name must exactly match the RCT_EXTERN_METHOD declaration in .m
+    @objc(startDigitalContract:resolve:rejecter:)
+    func startDigitalContract(
+        _ args: NSDictionary,
+        resolve: @escaping Resolve,
+        rejecter reject: @escaping Reject
+    ) {
+        guard Self.pendingResolve == nil else {
+            reject("ALREADY_RUNNING", "Another Digital Contract flow is in progress.", nil)
+            return
+        }
+
+        guard let argsDict = args as? [String: Any] else {
+            reject("INVALID_ARGS", "Arguments must be a map.", nil)
+            return
+        }
+
+        // Store callbacks before dispatching to main thread
+        Self.pendingResolve = resolve
+        Self.pendingReject  = reject
+
+        Self.delegateHolder.onResult = { json in
+            Self.pendingResolve?(json)
+            Self.pendingResolve = nil
+            Self.pendingReject  = nil
+        }
+        Self.delegateHolder.onError = { code, message in
+            Self.pendingReject?(code, message, nil)
+            Self.pendingResolve = nil
+            Self.pendingReject  = nil
+        }
+
+        // All UIKit access (topViewController + builder.start) must be on the main thread
+        DispatchQueue.main.async {
+            guard let rootVC = Self.topViewController() else {
+                Self.pendingReject?("NO_VIEW_CONTROLLER", "No view controller to present from.", nil)
+                Self.pendingResolve = nil
+                Self.pendingReject  = nil
+                return
+            }
+            Self.startSDK(from: rootVC, args: argsDict, delegate: Self.delegateHolder)
+        }
+    }
+
+    private static func intFrom(_ value: Any?) -> Int? {
+        switch value {
+        case let n as Int:    return n
+        case let n as Int64:  return Int(n)
+        case let n as Double: return Int(n)
+        case let s as String: return Int(s)
+        default:              return nil
+        }
+    }
+
+    private static func startSDK(
+        from viewController: UIViewController,
+        args: [String: Any],
+        delegate: VIDVDigitalContractDelegate
+    ) {
+        var builder = VIDVDigitalContractBuilder()
+            .setVIDVBaseUrl(args["vidv_base_url"] as! String)
+            .setDCBaseUrl(args["dc_base_url"] as! String)
+            .setVIDVAccessToken(args["vidv_access_token"] as! String)
+            .setDcAccessToken(args["dc_access_token"] as! String)
+            .setBundleKey(args["bundle_key"] as! String)
+            .setTenantId(args["tenant_id"] as! String)
+            .setUserReferenceId(args["user_reference_id"] as! String)
+            .setLanguage(args["language"] as! String)
+            .setTempleteVersionId(intFrom(args["template_version_id"]) ?? 0)
+            .setContractExpiryMinutes(intFrom(args["contract_expiry_minutes"]) ?? 0)
+            .contractData(args["contract_data"] as! String)
+
+        if args["allow_hand_signature"] as? Bool == true {
+            builder = builder.allowHandSignature(true)
+        }
+
+        builder.start(viewController, delegate: delegate)
+    }
+
+    private static func topViewController() -> UIViewController? {
+        let scenes = UIApplication.shared.connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+        let window = scenes.flatMap { $0.windows }.first { $0.isKeyWindow }
+        var top = window?.rootViewController
+        while let presented = top?.presentedViewController {
+            top = presented
+        }
+        return top
+    }
+}
+
+// MARK: - Delegate holder
+
+private final class DigitalContractDelegateHolder: NSObject, VIDVDigitalContractDelegate {
+    var onResult: ((String) -> Void)?
+    var onError:  ((String, String) -> Void)?
+
+    func onContractResult(_ result: ContractResult) {
+        switch result {
+        case .success(let data):
+            onResult?(jsonEnvelope(state: "SUCCESS", body: ["data": serializeData(data) as Any]))
+
+        case .builderError(let code, let message):
+            onResult?(jsonEnvelope(state: "ERROR", body: ["code": code, "message": message]))
+
+        case .serviceFailure(let message, let sdkError):
+            var body: [String: Any] = ["message": message]
+            if let sdkError = sdkError {
+                body["sdkError"] = [
+                    "errorCode": sdkError.errorCode as Any,
+                    "message":   sdkError.message   as Any,
+                ]
+            }
+            onResult?(jsonEnvelope(state: "FAILURE", body: body))
+
+        case .exit(let data):
+            onResult?(jsonEnvelope(state: "EXIT", body: ["data": serializeData(data) as Any]))
+        }
+    }
+
+    private func serializeData(_ data: VIDVDigitalContractResult?) -> [String: Any]? {
+        guard let data = data else { return nil }
+        var map: [String: Any] = [:]
+        if let contractId    = data.contractId    { map["contractID"]     = contractId    }
+        if let iframeURL     = data.iframeURL     { map["iframeURL"]      = iframeURL     }
+        if let contractStatus = data.contractStatus { map["contractStatus"] = contractStatus }
+        return map.isEmpty ? nil : map
+    }
+
+    private func jsonEnvelope(state: String, body: [String: Any]) -> String {
+        let payload: [String: Any] = ["state": state, "result": body]
+        guard let data = try? JSONSerialization.data(withJSONObject: payload),
+              let json = String(data: data, encoding: .utf8) else {
+            return "{\"state\":\"\(state)\",\"result\":{}}"
+        }
+        return json
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@valifysolutions/react-native-vidvdigitalcontract",
+  "version": "1.1.0",
+  "description": "React Native plugin for the VIDV Digital Contract SDK",
+  "main": "src/index",
+  "types": "src/index",
+  "files": [
+  "src",
+  "android",
+  "ios",
+  "vidvdigitalcontract-react-native.podspec",
+  "react-native.config.js",
+  "!android/build",
+  "!android/.gradle",
+  "!ios/build",
+  "!**/__tests__"
+],
+  "scripts": {
+    "example": "yarn --cwd example",
+    "typescript": "tsc --noEmit"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "vidv",
+    "digital-contract"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/valify/VIDVDigitalContract-ReactNative.git"
+  },
+  "author": "Valify",
+  "license": "MIT",
+  "dependencies": {
+    "@babel/runtime": "^7.20.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.70.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "react": "18.2.0",
+    "react-native": "0.73.6",
+    "typescript": "^5.0.0"
+  }
+}

package/react-native.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        packageImportPath: 'import com.vidv.digitalcontract.VIDVDigitalContractPackage;',
+        packageInstance: 'new VIDVDigitalContractPackage()',
+      },
+      ios: {},
+    },
+  },
+};

package/src/index.ts

@@ -0,0 +1,60 @@
+import { NativeModules, Platform } from 'react-native';
+import type { DigitalContractResponse } from './types';
+
+export * from './types';
+
+const LINKING_ERROR =
+  `The package 'vidv-digital-contract-react-native' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo managed workflow\n';
+
+const NativeVIDVDigitalContract = NativeModules.VIDVDigitalContract
+  ? NativeModules.VIDVDigitalContract
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+/**
+ * Thin React Native wrapper around the native VIDV Digital Contract SDK
+ * (iOS `VIDVDigitalContract`, Android `vidvdigitalcontractsdk`).
+ *
+ * The native SDKs present their own UI. This module just launches that flow
+ * with the given args map and returns the SDK's terminal result.
+ *
+ * Mirrors the Flutter plugin's `VIDVDigitalContract` class exactly.
+ */
+export class VIDVDigitalContract {
+  /**
+   * Starts the native Digital Contract flow described by {@link args} and
+   * resolves with the result as a JSON string,
+   * e.g. `{"state":"SUCCESS","result":{...}}`.
+   *
+   * `state` is one of `SUCCESS`, `FAILURE`, `EXIT`, or `ERROR`.
+   *
+   * Throws (rejects) only for pre-flight failures:
+   * - `ALREADY_RUNNING` — another start() call is already in progress
+   * - `NO_ACTIVITY` (Android) — not attached to an Activity
+   * - `NO_VIEW_CONTROLLER` (iOS) — root view controller not found
+   * - `START_ERROR` (Android) — exception while building the native flow
+   */
+  async start(args: Record<string, unknown>): Promise<string | null> {
+    const json: string = await NativeVIDVDigitalContract.startDigitalContract(args);
+    return json ?? null;
+  }
+
+  /**
+   * Convenience wrapper that parses the JSON string returned by {@link start}
+   * into a typed {@link DigitalContractResponse} object.
+   */
+  async startParsed(args: Record<string, unknown>): Promise<DigitalContractResponse | null> {
+    const json = await this.start(args);
+    if (json == null) return null;
+    return JSON.parse(json) as DigitalContractResponse;
+  }
+}

package/src/types.ts

@@ -0,0 +1,40 @@
+export interface DigitalContractData {
+  contractID?: string;
+  iframeURL?: string;
+  contractStatus?: string;
+}
+
+export type DigitalContractState = 'SUCCESS' | 'ERROR' | 'FAILURE' | 'EXIT';
+
+export interface DigitalContractSuccessResult {
+  data?: DigitalContractData;
+}
+
+export interface DigitalContractErrorResult {
+  code?: string | number;
+  message?: string;
+}
+
+export interface DigitalContractFailureResult {
+  code?: string | number;
+  message?: string;
+  data?: DigitalContractData;
+  sdkError?: {
+    errorCode?: string | number;
+    message?: string;
+  };
+}
+
+export interface DigitalContractExitResult {
+  step?: string;
+  data?: DigitalContractData;
+}
+
+export interface DigitalContractResponse {
+  state: DigitalContractState;
+  result:
+    | DigitalContractSuccessResult
+    | DigitalContractErrorResult
+    | DigitalContractFailureResult
+    | DigitalContractExitResult;
+}

package/vidvdigitalcontract-react-native.podspec

@@ -0,0 +1,22 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "vidvdigitalcontract-react-native"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["repository"]["url"]
+  s.license      = package["license"]
+  s.authors      = { "Valify" => "info@valify.me" }
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => package["repository"]["url"], :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+
+  s.dependency "React-Core"
+  s.dependency "VIDVDigitalContract", "~> 1.1.4"
+
+  s.swift_version = "5.0"
+
+end