judokit-react-native 4.4.0 → 5.0.1

package/JudoKit-ReactNative.podspec

@@ -15,7 +15,7 @@ Pod::Spec.new do |s|
   s.source       = { :git => "https://github.com/Judopay/JudoKit-ReactNative.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm}"
-  s.dependency "JudoKit-iOS", "4.0.5"
+  s.dependency "JudoKit-iOS", "5.0.2"
 
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
   # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.

package/README.md

@@ -29,7 +29,7 @@ judoKit
   .invokeTransaction(JudoTransactionType.Payment, {
     judoId: '123456',
     amount: {
-      value: '1.5',
+      value: '1.50',
       currency: 'GBP',
     },
     reference: {
@@ -69,7 +69,7 @@ const judoKit = new JudoPay(authorization);
 
 function App(): React.JSX.Element {
   const invokeJudoKit = () => {
-    const amount: JudoAmount = {value: '1.5', currency: 'GBP'};
+    const amount: JudoAmount = {value: '1.50', currency: 'GBP'};
     const reference: JudoReference = {
       paymentReference: 'your-payment-reference',
       consumerReference: 'your-consumer-reference',

package/android/build.gradle

@@ -1,6 +1,11 @@
 buildscript {
-  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
-  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["JudoKitReactNative_kotlinVersion"]
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['JudoKitReactNative_' + name]
+  }
+
+  ext.getExtOrIntegerDefault = { name ->
+    return getExtOrDefault(name).toInteger()
+  }
 
   repositories {
     google()
@@ -8,44 +13,44 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.4.0"
+    classpath "com.android.tools.build:gradle:8.7.2"
     // noinspection DifferentKotlinGradleVersion
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
   }
 }
 
 def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+  // To opt-in for the New Architecture, you can either:
+  // - Set `newArchEnabled` to true inside the `gradle.properties` file
+  // - Invoke gradle with `-newArchEnabled=true`
+  // - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
+  return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+def reactNativeArchitectures() {
+  def value = project.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : [
+    "armeabi-v7a",
+    "x86",
+    "x86_64",
+    "arm64-v8a"
+  ]
 }
 
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
 
 if (isNewArchitectureEnabled()) {
-  apply plugin: "com.facebook.react"
-}
-
-def getExtOrDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["JudoKitReactNative_" + name]
-}
-
-def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["JudoKitReactNative_" + name]).toInteger()
-}
-
-def supportsNamespace() {
-  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
-  def major = parsed[0].toInteger()
-  def minor = parsed[1].toInteger()
-
-  // Namespace support was added in 7.3.0
-  return (major == 7 && minor >= 3) || major >= 8
+  apply plugin: 'com.facebook.react'
 }
 
 android {
-  if (supportsNamespace()) {
+  def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
+  if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
     namespace "com.judopay.judokit.reactnative"
-
+    buildFeatures {
+      buildConfig true
+    }
     sourceSets {
       main {
         manifest.srcFile "src/main/AndroidManifestNew.xml"
@@ -55,10 +60,23 @@ android {
 
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
+  // Used to override the NDK path/version on internal CI or by allowing
+  // users to customize the NDK path/version from their root project (e.g. for M1 support)
+  if (rootProject.hasProperty("ndkPath")) {
+    ndkPath rootProject.ext.ndkPath
+  }
+  if (rootProject.hasProperty("ndkVersion")) {
+    ndkVersion rootProject.ext.ndkVersion
+  }
+
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
 
+    ndk {
+      abiFilters (*reactNativeArchitectures())
+    }
   }
 
   buildTypes {
@@ -75,21 +93,45 @@ android {
     sourceCompatibility JavaVersion.VERSION_1_8
     targetCompatibility JavaVersion.VERSION_1_8
   }
+
+  sourceSets.main {
+    java {
+      if (isNewArchitectureEnabled()) {
+        srcDirs += [
+          "src/newarch/java",
+          // Codegen specs
+          "generated/java",
+          "generated/jni"
+        ]
+      } else {
+        srcDirs += [
+          "src/oldarch/java"
+        ]
+      }
+    }
+  }
 }
 
 repositories {
   mavenCentral()
+  maven {
+    // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+    url "$rootDir/../node_modules/react-native/android"
+  }
   google()
 }
 
-def kotlin_version = getExtOrDefault("kotlinVersion")
-def judokit_android_version = getExtOrDefault("judoKitAndroidVersion")
-
 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 "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation "com.judopay:judokit-android:$judokit_android_version"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:${getExtOrDefault('kotlinVersion')}"
+  implementation "com.judopay:judokit-android:${getExtOrDefault('judoKitAndroidVersion')}"
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "JudoKitReactNative"
+    codegenJavaPackageName = "com.judopay.judokit.reactnative"
+  }
 }

package/android/gradle.properties

@@ -1,6 +1,6 @@
-JudoKitReactNative_kotlinVersion=1.9.23
-JudoKitReactNative_minSdkVersion=23
-JudoKitReactNative_targetSdkVersion=34
-JudoKitReactNative_compileSdkVersion=34
-JudoKitReactNative_ndkversion=26.1.10909125
-JudoKitReactNative_judoKitAndroidVersion=4.3.8.0.1
+JudoKitReactNative_kotlinVersion=2.1.21
+JudoKitReactNative_minSdkVersion=24
+JudoKitReactNative_targetSdkVersion=35
+JudoKitReactNative_compileSdkVersion=35
+JudoKitReactNative_ndkversion=27.1.12297006
+JudoKitReactNative_judoKitAndroidVersion=5.0.2

package/android/src/main/java/com/judopay/judokit/reactnative/Helpers.kt

@@ -45,10 +45,14 @@ import com.judopay.judokit.android.model.typeId
 private const val TRANSACTION_TYPE_PAYMENT = "payment"
 private const val TRANSACTION_TYPE_PRE_AUTH = "preauth"
 
-@Deprecated("Register Card functionality has been deprecated. Please use Check Card feature instead.")
+@Deprecated(
+  "Register Card functionality has been deprecated. Please use Check Card feature instead.",
+)
 private const val TRANSACTION_TYPE_REGISTER = "register"
 
-@Deprecated("Register Card functionality has been deprecated. Please use Check Card feature instead.")
+@Deprecated(
+  "Register Card functionality has been deprecated. Please use Check Card feature instead.",
+)
 private const val TRANSACTION_TYPE_REGISTER_CARD = "registercard"
 private const val TRANSACTION_TYPE_SAVE_CARD = "save"
 private const val TRANSACTION_TYPE_CHECK_CARD = "checkcard"
@@ -123,7 +127,9 @@ internal fun getPaymentMethodsConfiguration(options: ReadableMap): Judo {
 internal fun getMappedType(type: String?): Int {
   val typeInLowercase = type?.lowercase()
   val typeValue =
-    TransactionType.values().firstOrNull { it.typeAsStrings?.contains(typeInLowercase) ?: false }
+    TransactionType.values().firstOrNull {
+      it.typeAsStrings?.contains(typeInLowercase) ?: false
+    }
 
   return typeValue?.value ?: TransactionType.UNKNOWN.value
 }
@@ -187,11 +193,7 @@ internal fun getJudoConfigurationForApiService(options: ReadableMap): Judo {
       .setCurrency(Currency.GBP)
       .build()
 
-  val reference =
-    Reference
-      .Builder()
-      .setConsumerReference("reference")
-      .build()
+  val reference = Reference.Builder().setConsumerReference("reference").build()
 
   return Judo
     .Builder(PaymentWidgetType.CARD_PAYMENT)
@@ -231,7 +233,6 @@ internal fun getJudoConfiguration(
       .setReference(reference)
       .setSupportedCardNetworks(cardNetworks)
       .setPaymentMethods(paymentMethods)
-      .setUiConfiguration(uiConfiguration)
       .setPrimaryAccountDetails(primaryAccountDetails)
       .setGooglePayConfiguration(googlePayConfiguration)
       .setInitialRecurringPayment(options.isInitialRecurringPayment)
@@ -248,6 +249,10 @@ internal fun getJudoConfiguration(
       .setAddress(address)
       .setSubProductInfo(getSubProductInfo(options))
 
+  if (uiConfiguration != null) {
+    builder.setUiConfiguration(uiConfiguration)
+  }
+
   if (type.isTokenPayment) {
     val cardHolderName = options.cardholderName?.ifBlank { null }
     val securityCode = options.securityCode?.ifBlank { null }
@@ -273,7 +278,9 @@ internal fun getJudoConfiguration(
 }
 
 internal fun getRecommendationConfiguration(options: ReadableMap): RecommendationConfiguration? =
-  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1 && options.recommendationConfiguration != null) {
+  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1 &&
+    options.recommendationConfiguration != null
+  ) {
     RecommendationConfiguration
       .Builder()
       .setUrl(options.recommendationURL)
@@ -315,7 +322,9 @@ internal fun getNetworkTimeout(options: ReadableMap): NetworkTimeout? {
 }
 
 internal fun getChallengeRequestIndicator(options: ReadableMap): ChallengeRequestIndicator? =
-  ChallengeRequestIndicator.values().firstOrNull { it.value == options.challengeRequestIndicator }
+  ChallengeRequestIndicator.values().firstOrNull {
+    it.value == options.challengeRequestIndicator
+  }
 
 internal fun getScaExemption(options: ReadableMap): ScaExemption? = ScaExemption.values().firstOrNull { it.value == options.scaExemption }
 
@@ -385,9 +394,7 @@ internal fun getReference(options: ReadableMap): Reference? {
   val metadataMap = options.metadata
   metadataMap?.let {
     val bundle = Bundle()
-    metadataMap.toHashMap().forEach {
-      bundle.putString(it.key, it.value.toString())
-    }
+    metadataMap.toHashMap().forEach { bundle.putString(it.key, it.value.toString()) }
     builder = builder.setMetaData(bundle)
   }
 
@@ -455,7 +462,6 @@ internal fun getPaymentMethods(options: ReadableMap): Array<PaymentMethod>? {
 
   val cardPaymentValue = 1
   val googlePaymentValue = 1 shl 2
-  val idealPaymentValue = 1 shl 3
   val allPaymentValues = 1 shl 5
 
   options.paymentMethodValue?.let {
@@ -469,10 +475,6 @@ internal fun getPaymentMethods(options: ReadableMap): Array<PaymentMethod>? {
       paymentMethods?.add(PaymentMethod.GOOGLE_PAY)
     }
 
-    if (it and idealPaymentValue == idealPaymentValue) {
-      // noop
-    }
-
     if (it and allPaymentValues == allPaymentValues) {
       return PaymentMethod.values()
     }
@@ -498,7 +500,9 @@ internal fun getUIConfiguration(options: ReadableMap): UiConfiguration? {
     options.isAVSEnabled?.let { setAvsEnabled(it) }
     options.shouldPaymentMethodsDisplayAmount?.let { setShouldPaymentMethodsDisplayAmount(it) }
     options.shouldPaymentButtonDisplayAmount?.let { setShouldPaymentButtonDisplayAmount(it) }
-    options.shouldPaymentMethodsVerifySecurityCode?.let { setShouldPaymentMethodsVerifySecurityCode(it) }
+    options.shouldPaymentMethodsVerifySecurityCode?.let {
+      setShouldPaymentMethodsVerifySecurityCode(it)
+    }
   }
 
   return builder.build()

package/android/src/main/java/com/judopay/judokit/reactnative/JudoActivityEventListener.kt

@@ -20,7 +20,7 @@ class JudoActivityEventListener : BaseActivityEventListener() {
   internal var transactionPromise: Promise? = null
 
   override fun onActivityResult(
-    activity: Activity?,
+    activity: Activity,
     requestCode: Int,
     resultCode: Int,
     data: Intent?,

package/android/src/main/java/com/judopay/judokit/reactnative/{JudoKitReactNativeModule.kt → JudoKitReactNativeModuleImpl.kt}

@@ -1,9 +1,8 @@
 package com.judopay.judokit.reactnative
 
+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.judopay.judokit.android.Judo
 import com.judopay.judokit.android.api.factory.JudoApiServiceFactory
@@ -14,65 +13,60 @@ import retrofit2.Call
 import retrofit2.Callback
 import retrofit2.Response
 
-const val REQUEST_FAILED_MESSAGE = "The request was unsuccessful."
-const val MODULE_NAME = "JudoKitReactNative"
-
-class JudoKitReactNativeModule internal constructor(
+class JudoKitReactNativeModuleImpl(
   private val reactContext: ReactApplicationContext,
-) : ReactContextBaseJavaModule(reactContext) {
-  override fun getName() = MODULE_NAME
-
+) {
   private val listener = JudoActivityEventListener()
 
   init {
     reactContext.addActivityEventListener(listener)
   }
 
-  @ReactMethod
   fun invokeTransaction(
+    currentActivity: Activity?,
     options: ReadableMap,
     promise: Promise,
   ) {
     try {
       val judo = getTransactionConfiguration(options)
-      startJudoActivity(judo, promise)
+      startJudoActivity(currentActivity, judo, promise)
     } catch (error: Exception) {
       promise.reject(JUDO_PROMISE_REJECTION_CODE, error.localizedMessage, error)
     }
   }
 
-  @ReactMethod
   fun invokeGooglePay(
+    currentActivity: Activity?,
     options: ReadableMap,
     promise: Promise,
   ) {
     try {
       val judo = getGoogleTransactionConfiguration(options)
-      startJudoActivity(judo, promise)
+      startJudoActivity(currentActivity, judo, promise)
     } catch (error: Exception) {
       promise.reject(JUDO_PROMISE_REJECTION_CODE, error.localizedMessage, error)
     }
   }
 
-  @ReactMethod
   fun invokePaymentMethodScreen(
+    currentActivity: Activity?,
     options: ReadableMap,
     promise: Promise,
   ) {
     try {
       val judo = getPaymentMethodsConfiguration(options)
-      startJudoActivity(judo, promise)
+      startJudoActivity(currentActivity, judo, promise)
     } catch (error: Exception) {
       promise.reject(JUDO_PROMISE_REJECTION_CODE, error.localizedMessage, error)
     }
   }
 
-  @ReactMethod
   fun performTokenTransaction(
+    currentActivity: Activity?,
     options: ReadableMap,
     promise: Promise,
   ) {
-    if (options.cardToken == null) {
+    if (options.cardToken.isNullOrEmpty()) {
       promise.reject(
         JUDO_PROMISE_REJECTION_CODE,
         "No card token provided, please make sure you provide it when invoking performTokenTransaction.",
@@ -82,13 +76,12 @@ class JudoKitReactNativeModule internal constructor(
 
     try {
       val judo = getTokenTransactionConfiguration(options)
-      startJudoActivity(judo, promise)
+      startJudoActivity(currentActivity, judo, promise)
     } catch (error: Exception) {
       promise.reject(JUDO_PROMISE_REJECTION_CODE, error.localizedMessage, error)
     }
   }
 
-  @ReactMethod
   fun fetchTransactionDetails(
     options: ReadableMap,
     promise: Promise,
@@ -99,7 +92,7 @@ class JudoKitReactNativeModule internal constructor(
 
       val service = JudoApiServiceFactory.create(reactContext, judo)
 
-      val fetchTransactionDetailsCallback =
+      service.fetchTransactionWithReceiptId(receiptId).enqueue(
         object : Callback<JudoApiCallResult<Receipt>> {
           override fun onResponse(
             call: Call<JudoApiCallResult<Receipt>>,
@@ -112,7 +105,10 @@ class JudoKitReactNativeModule internal constructor(
                   val judoResult = receipt.toJudoResult()
                   promise.resolve(getMappedResult(judoResult))
                 } else {
-                  promise.reject(JUDO_PROMISE_REJECTION_CODE, REQUEST_FAILED_MESSAGE)
+                  promise.reject(
+                    JUDO_PROMISE_REJECTION_CODE,
+                    REQUEST_FAILED_MESSAGE,
+                  )
                 }
               }
 
@@ -122,7 +118,10 @@ class JudoKitReactNativeModule internal constructor(
               }
 
               else -> {
-                promise.reject(JUDO_PROMISE_REJECTION_CODE, REQUEST_FAILED_MESSAGE)
+                promise.reject(
+                  JUDO_PROMISE_REJECTION_CODE,
+                  REQUEST_FAILED_MESSAGE,
+                )
               }
             }
           }
@@ -133,22 +132,39 @@ class JudoKitReactNativeModule internal constructor(
           ) {
             promise.reject(JUDO_PROMISE_REJECTION_CODE, throwable.localizedMessage, throwable)
           }
-        }
-
-      service
-        .fetchTransactionWithReceiptId(receiptId)
-        .enqueue(fetchTransactionDetailsCallback)
+        },
+      )
     } catch (error: Exception) {
       promise.reject(JUDO_PROMISE_REJECTION_CODE, error.localizedMessage, error)
     }
   }
 
+  fun isApplePayAvailableWithConfiguration(
+    params: ReadableMap,
+    promise: Promise,
+  ) = promise.reject(JUDO_PROMISE_REJECTION_CODE, APPLE_PAY_UNSUPPORTED)
+
+  fun invokeApplePay(
+    params: ReadableMap,
+    promise: Promise,
+  ) = promise.reject(JUDO_PROMISE_REJECTION_CODE, APPLE_PAY_UNSUPPORTED)
+
   private fun startJudoActivity(
-    configuration: Judo,
+    currentActivity: Activity?,
+    judo: Judo,
     promise: Promise,
-  ) = currentActivity?.let {
-    listener.transactionPromise = promise
-    val intent = configuration.toJudoActivityIntent(it)
-    it.startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
+  ) {
+    currentActivity?.let {
+      listener.transactionPromise = promise
+      val intent = judo.toJudoActivityIntent(it)
+      it.startActivityForResult(intent, JUDO_PAYMENT_WIDGET_REQUEST_CODE)
+    } ?: promise.reject(JUDO_PROMISE_REJECTION_CODE, "No current activity available")
+  }
+
+  companion object {
+    const val REQUEST_FAILED_MESSAGE = "The request was unsuccessful."
+    const val JUDO_PROMISE_REJECTION_CODE = "JUDO_ERROR"
+    const val APPLE_PAY_UNSUPPORTED = "Apple Pay is not supported on Android."
+    const val NAME = "JudoKitReactNative"
   }
 }

package/android/src/newarch/java/com/judopay/judokit/reactnative/JudoKitReactNativeModule.kt

@@ -0,0 +1,62 @@
+package com.judopay.judokit.reactnative
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = JudoKitReactNativeModuleImpl.NAME)
+class JudoKitReactNativeModule(
+  reactContext: ReactApplicationContext,
+) : NativeJudoKitReactNativeModuleSpec(reactContext) {
+  private val moduleImpl = JudoKitReactNativeModuleImpl(reactContext)
+
+  override fun invokeTransaction(
+    options: ReadableMap,
+    promise: Promise,
+  ) {
+    moduleImpl.invokeTransaction(currentActivity, options, promise)
+  }
+
+  override fun invokeGooglePay(
+    options: ReadableMap,
+    promise: Promise,
+  ) {
+    moduleImpl.invokeGooglePay(currentActivity, options, promise)
+  }
+
+  override fun invokePaymentMethodScreen(
+    options: ReadableMap,
+    promise: Promise,
+  ) {
+    moduleImpl.invokePaymentMethodScreen(currentActivity, options, promise)
+  }
+
+  override fun performTokenTransaction(
+    options: ReadableMap,
+    promise: Promise,
+  ) {
+    moduleImpl.performTokenTransaction(currentActivity, options, promise)
+  }
+
+  override fun fetchTransactionDetails(
+    options: ReadableMap,
+    promise: Promise,
+  ) {
+    moduleImpl.fetchTransactionDetails(options, promise)
+  }
+
+  override fun isApplePayAvailableWithConfiguration(
+    params: ReadableMap,
+    promise: Promise,
+  ) {
+    moduleImpl.isApplePayAvailableWithConfiguration(params, promise)
+  }
+
+  override fun invokeApplePay(
+    params: ReadableMap,
+    promise: Promise,
+  ) {
+    moduleImpl.invokeApplePay(params, promise)
+  }
+}

package/android/src/newarch/java/com/judopay/judokit/reactnative/JudoKitReactNativePackage.kt

@@ -0,0 +1,38 @@
+package com.judopay.judokit.reactnative
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class JudoKitReactNativePackage : BaseReactPackage() {
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext,
+  ): NativeModule? =
+    if (name == JudoKitReactNativeModuleImpl.NAME) {
+      JudoKitReactNativeModule(reactContext)
+    } else {
+      null
+    }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    val moduleList: Array<Class<out NativeModule?>> = arrayOf(JudoKitReactNativeModule::class.java)
+    val reactModuleInfoMap: MutableMap<String, ReactModuleInfo> = HashMap()
+    for (moduleClass in moduleList) {
+      val reactModule = moduleClass.getAnnotation(ReactModule::class.java) ?: continue
+      reactModuleInfoMap[reactModule.name] =
+        ReactModuleInfo(
+          reactModule.name,
+          moduleClass.name,
+          true,
+          reactModule.needsEagerInit,
+          reactModule.isCxxModule,
+          BuildConfig.IS_NEW_ARCHITECTURE_ENABLED,
+        )
+    }
+    return ReactModuleInfoProvider { reactModuleInfoMap }
+  }
+}

package/android/src/oldarch/java/com/judopay/judokit/reactnative/JudoKitReactNativeModule.kt

@@ -0,0 +1,55 @@
+package com.judopay.judokit.reactnative
+
+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
+
+class JudoKitReactNativeModule(
+  reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+  private val moduleImpl = JudoKitReactNativeModuleImpl(reactContext)
+
+  override fun getName() = JudoKitReactNativeModuleImpl.NAME
+
+  @ReactMethod
+  fun invokeTransaction(
+    options: ReadableMap,
+    promise: Promise,
+  ) {
+    moduleImpl.invokeTransaction(currentActivity, options, promise)
+  }
+
+  @ReactMethod
+  fun invokeGooglePay(
+    options: ReadableMap,
+    promise: Promise,
+  ) {
+    moduleImpl.invokeGooglePay(currentActivity, options, promise)
+  }
+
+  @ReactMethod
+  fun invokePaymentMethodScreen(
+    options: ReadableMap,
+    promise: Promise,
+  ) {
+    moduleImpl.invokePaymentMethodScreen(currentActivity, options, promise)
+  }
+
+  @ReactMethod
+  fun performTokenTransaction(
+    options: ReadableMap,
+    promise: Promise,
+  ) {
+    moduleImpl.performTokenTransaction(currentActivity, options, promise)
+  }
+
+  @ReactMethod
+  fun fetchTransactionDetails(
+    options: ReadableMap,
+    promise: Promise,
+  ) {
+    moduleImpl.fetchTransactionDetails(options, promise)
+  }
+}

package/ios/JudoKitReactNative.h

@@ -25,13 +25,12 @@
 static const NSErrorDomain _Nonnull RNJudoErrorDomain = @"com.judopay.react-native.error-domain";
 
 #ifdef RCT_NEW_ARCH_ENABLED
-#import "RNJudoKitReactNativeSpec.h"
+#import <JudoKitReactNativeSpec/JudoKitReactNativeSpec.h>
+@interface JudoKitReactNative : NativeJudoKitReactNativeModuleSpecBase <NativeJudoKitReactNativeModuleSpec>
 
-@interface JudoKitReactNative : NSObject <NativeJudoKitReactNativeSpec>
 #else
 #import <React/RCTBridgeModule.h>
-
 @interface JudoKitReactNative : NSObject <RCTBridgeModule>
-#endif
 
+#endif
 @end