@walletconnect/react-native-compat 2.17.2-canary-rcnt-1 → 2.17.2-canary-ca-0

package/android/build.gradle

@@ -109,6 +109,10 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation 'net.java.dev.jna:jna:5.12.1@aar'
+  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0'  // Latest stable version
+  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.0' // For Dispatchers.Main
+  implementation 'com.google.code.gson:gson:2.9.0'
 }
 
 if (isNewArchitectureEnabled()) {

package/android/src/main/java/com/walletconnect/reactnativemodule/RNWalletConnectModuleModule.kt

@@ -4,6 +4,21 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.Promise
 import android.content.pm.PackageManager
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import uniffi.uniffi_yttrium.ChainAbstractionClient
+import kotlinx.coroutines.*
+import com.facebook.react.bridge.ReadableMap
+import uniffi.uniffi_yttrium.FfiAddress
+import uniffi.uniffi_yttrium.FfiBytes
+import uniffi.uniffi_yttrium.Ffiu64
+import uniffi.uniffi_yttrium.InitTransaction
+import uniffi.uniffi_yttrium.*
+import uniffi.yttrium.*
+import kotlin.jvm.internal.Intrinsics.Kotlin
+import com.facebook.react.bridge.Arguments
+import com.google.gson.Gson
+import com.google.gson.JsonObject
+import com.google.gson.JsonElement
 
 class RNWalletConnectModuleModule internal constructor(context: ReactApplicationContext) :
   RNWalletConnectModuleSpec(context) {
@@ -49,6 +64,147 @@ class RNWalletConnectModuleModule internal constructor(context: ReactApplication
     }
   }
 
+
+
+// ------------------------------ Yttrium Chain Abstraction ------------------------------
+
+  @ReactMethod
+  override fun checkRoute(params: ReadableMap, promise: Promise){
+    System.out.println("checkRoute: Hello from YttriumModule")
+  
+    GlobalScope.launch(Dispatchers.Main) {
+      try {
+        var projectId = params.getString("projectId") as String 
+        val transactionMap = params.getMap("transaction")
+        var client = ChainAbstractionClient(projectId)
+
+        if (transactionMap != null) {
+          // Extract values from the nested transaction map
+          val chainId = transactionMap.getString("chainId") ?: ""
+          val txData = transactionMap.getString("data") ?: ""
+          val from = transactionMap.getString("from") ?: ""
+          val gas = transactionMap.getString("gas") ?: "0"
+          val gasPrice = transactionMap.getString("gasPrice") ?: "0"
+          val maxFeePerGas = transactionMap.getString("maxFeePerGas") ?: "0"
+          val maxPriorityFeePerGas = transactionMap.getString("maxPriorityFeePerGas") ?: "0"
+          val nonce = transactionMap.getString("nonce") ?: "0"
+          val to = transactionMap.getString("to") ?: ""
+          val value = transactionMap.getString("value") ?: "0"
+
+          val tx = InitTransaction(from, to, value, gas, gasPrice, txData, nonce, maxFeePerGas, maxPriorityFeePerGas, chainId)
+          val result = client.route(tx)
+          System.out.println("checkRoute: result: ")
+          System.out.println(result)
+          when (result) {
+            is RouteResponse.Success -> {
+              when (result.v1) {
+                is RouteResponseSuccess.Available -> {
+                  val gson = Gson()
+                  val jsonElement: JsonElement = gson.toJsonTree(result.v1.v1)
+                  val response = JsonObject()
+                  response.addProperty("status", "available")
+                  response.add("data", jsonElement)
+                  promise.resolve(gson.toJson(response))
+                }
+                is RouteResponseSuccess.NotRequired -> {
+                  val response = JsonObject()
+                  response.addProperty("status", "not_required")
+                  val gson = Gson()
+                  promise.resolve("not_required")
+                }
+              }
+            }
+            is RouteResponse.Error -> {
+              System.out.println(result.v1.error.toString())
+              when (result.v1.error.toString()) {
+                "NO_ROUTES_AVAILABLE" -> {
+                  val response = JsonObject()
+                  response.addProperty("status", "error")
+                  response.addProperty("reason", "noRoutesAvailable")
+                  val gson = Gson()
+                  promise.resolve(gson.toJson(response))
+                }
+                "INSUFFICIENT_FUNDS" -> {
+                    val response = JsonObject()
+                  response.addProperty("status", "error")
+                  response.addProperty("reason", "insufficientFunds")
+                  val gson = Gson()
+                  promise.resolve(gson.toJson(response))
+                }
+                "INSUFFICIENT_GAS_FUNDS" -> {
+                    val response = JsonObject()
+                  response.addProperty("status", "error")
+                  response.addProperty("reason", "insufficientGasFunds")
+                  val gson = Gson()
+                  promise.resolve(gson.toJson(response))
+                }
+              }
+            }
+          }
+
+        }
+        // Resolve the promise with the result
+      } catch (e: Exception) {
+        // In case of an error, reject the promise
+        promise.reject("ERROR", "Yttrium checkRoute Error:" + e.message, e)
+      }
+    }
+  }
+
+  @ReactMethod
+  override fun checkStatus(params: ReadableMap, promise: Promise){
+    System.out.println("checkStatus: Hello from YttriumModule address")
+
+    GlobalScope.launch(Dispatchers.Main) {
+      try {
+
+        var projectId = params.getString("projectId") as String
+        var orchestrationId = params.getString("orchestrationId") as String
+        var client = ChainAbstractionClient(projectId)
+
+        when (val result = client.status(orchestrationId)) {
+            is StatusResponse.Completed -> {
+                when(result.v1) {
+                  is StatusResponseCompleted -> {
+                    val response = JsonObject()
+                    response.addProperty("status", "completed")
+                    response.addProperty("createdAt", result.v1.createdAt.toString())
+                    val gson = Gson()
+                    promise.resolve(gson.toJson(response))
+                  }
+                }
+            }
+            is StatusResponse.Error -> {
+              when(result.v1) {
+                is StatusResponseError -> {
+                  val response = JsonObject()
+                  response.addProperty("status", "error")
+                  response.addProperty("createdAt", result.v1.createdAt.toString())
+                  response.addProperty("reason", result.v1.error.toString())
+                  val gson = Gson()
+                  promise.resolve(gson.toJson(response))
+                }
+              }
+            }
+            is StatusResponse.Pending -> {
+              when(result.v1) {
+                is StatusResponsePending -> {
+                  val response = JsonObject()
+                  response.addProperty("status", "pending")
+                  response.addProperty("createdAt", result.v1.createdAt.toString())
+                  response.addProperty("checkIn", result.v1.checkIn.toString())
+                  val gson = Gson()
+                  promise.resolve(gson.toJson(response))
+                }
+              }
+            }
+          }
+      } catch (e: Exception) {
+        // In case of an error, reject the promise
+        promise.reject("ERROR", "Yttrium checkStatus Error:" + e.message, e)
+      }
+    }
+  }
   companion object {
     const val NAME = "RNWalletConnectModule"
   }