@walletconnect/react-native-compat 2.17.2-canary-ca-5 → 2.17.2-canary-ca-7

package/android/build.gradle

@@ -123,7 +123,7 @@ dependencies {
   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'
-  implementation 'com.github.reown-com:yttrium:0.4.2'
+  implementation("com.github.reown-com:yttrium:0.4.11")
 }
 
 if (isNewArchitectureEnabled()) {

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

@@ -7,7 +7,6 @@ import android.content.pm.PackageManager
 import uniffi.uniffi_yttrium.ChainAbstractionClient
 import kotlinx.coroutines.*
 import com.facebook.react.bridge.ReadableMap
-import uniffi.uniffi_yttrium.InitTransaction
 import uniffi.uniffi_yttrium.*
 import uniffi.yttrium.*
 import com.google.gson.Gson
@@ -62,10 +61,12 @@ class RNWalletConnectModuleModule internal constructor(context: ReactApplication
 
 // ------------------------------ Yttrium Chain Abstraction ------------------------------
 
+  private var availableResponseMap: MutableMap<String, RouteResponseAvailable> = mutableMapOf()
+
+
   @ReactMethod
-  override fun checkRoute(params: ReadableMap, promise: Promise){
+  override fun prepare(params: ReadableMap, promise: Promise){
     System.out.println("checkRoute: Hello from YttriumModule")
-  
     GlobalScope.launch(Dispatchers.Main) {
       try {
         var projectId = params.getString("projectId") as String 
@@ -77,34 +78,23 @@ class RNWalletConnectModuleModule internal constructor(context: ReactApplication
           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)
+          val tx = InitialTransaction(chainId, from, to, value, txData)
+          val result = client.prepare(tx)
           System.out.println("checkRoute: result: ")
           System.out.println(result)
           when (result) {
-            is RouteResponse.Success -> {
+            is PrepareResponse.Success -> {
               when (result.v1) {
                 is RouteResponseSuccess.Available -> {
                   val availableResult = (result.v1 as RouteResponseSuccess.Available).v1
-                  val transaction = Transaction(from, to, value, gas, txData, nonce, chainId, gasPrice, maxFeePerGas, maxPriorityFeePerGas)
-                  val uiFields = client.getRouteUiFields(availableResult, transaction, Currency.USD)
+                  availableResponseMap[availableResult.orchestrationId] = availableResult
                   val gson = Gson()
                   val routesJson: JsonElement = gson.toJsonTree(availableResult)
-                  val routesDetailsJson: JsonElement = gson.toJsonTree(uiFields)
-                  val dataObject = JsonObject()
-                  dataObject.add("routes", routesJson)
-                  dataObject.add("routesDetails", routesDetailsJson)
                   val response = JsonObject()
                   response.addProperty("status", "available")
-                  response.add("data", dataObject)
+                  response.add("data", routesJson)
                   promise.resolve(gson.toJson(response))
                 }
                 is RouteResponseSuccess.NotRequired -> {
@@ -115,7 +105,7 @@ class RNWalletConnectModuleModule internal constructor(context: ReactApplication
                 }
               }
             }
-            is RouteResponse.Error -> {
+            is PrepareResponse.Error -> {
               System.out.println(result.v1.error.toString())
               when (result.v1.error.toString()) {
                 "NO_ROUTES_AVAILABLE" -> {
@@ -153,7 +143,7 @@ class RNWalletConnectModuleModule internal constructor(context: ReactApplication
   }
 
   @ReactMethod
-  override fun checkStatus(params: ReadableMap, promise: Promise){
+  override fun status(params: ReadableMap, promise: Promise){
     System.out.println("checkStatus: Hello from YttriumModule address")
 
     GlobalScope.launch(Dispatchers.Main) {
@@ -164,48 +154,118 @@ class RNWalletConnectModuleModule internal constructor(context: ReactApplication
         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.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.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))
-                }
+          }
+
+          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)
       }
     }
   }
+
+  @ReactMethod
+  override fun getBridgeDetails(params: ReadableMap, promise: Promise){
+    System.out.println("getFulfilmentDetails: Hello from YttriumModule address")
+
+    GlobalScope.launch(Dispatchers.Main) {
+      try {
+
+        val projectId = params.getString("projectId") as String
+        val orchestrationId = params.getString("orchestrationId") as String
+        val client = ChainAbstractionClient(projectId)
+
+        val availableResult = availableResponseMap[orchestrationId] as RouteResponseAvailable
+        val uiFields = client.getUiFields(availableResult, Currency.USD)
+        val gson = Gson()
+        val resultJson: JsonElement = gson.toJsonTree(uiFields)
+        promise.resolve(gson.toJson(resultJson))
+      } catch (e: Exception) {
+        // In case of an error, reject the promise
+        promise.reject("ERROR", "Yttrium getFulfilmentDetails Error:" + e.message, e)
+      }
+    }
+  }
+
+  @ReactMethod
+  override fun getERC20Balance(params: ReadableMap, promise: Promise){
+    System.out.println("getERC20Balance: Hello from YttriumModule address")
+
+    GlobalScope.launch(Dispatchers.Main) {
+      try {
+
+        val projectId = params.getString("projectId") as String
+        val tokenAddress = params.getString("tokenAddress") as String
+        val ownerAddress = params.getString("ownerAddress") as String
+        val chainId = params.getString("chainId") as String
+        val client = ChainAbstractionClient(projectId)
+        val result = client.erc20TokenBalance(chainId, tokenAddress, ownerAddress)
+        val gson = Gson()
+        val resultJson: JsonElement = gson.toJsonTree(result)
+        promise.resolve(gson.toJson(resultJson))
+      } catch (e: Exception) {
+        // In case of an error, reject the promise
+        promise.reject("ERROR", "Yttrium getERC20Balance Error:" + e.message, e)
+      }
+    }
+  }
+
+  @ReactMethod
+  override fun estimateFees(params: ReadableMap, promise: Promise){
+    System.out.println("estimateFees: Hello from YttriumModule address")
+
+    GlobalScope.launch(Dispatchers.Main) {
+      try {
+
+        val projectId = params.getString("projectId") as String
+        val chainId = params.getString("chainId") as String
+        val client = ChainAbstractionClient(projectId)
+        val result = client.estimateFees(chainId)
+        val gson = Gson()
+        val resultJson: JsonElement = gson.toJsonTree(result)
+        promise.resolve(gson.toJson(resultJson))
+      } catch (e: Exception) {
+        // In case of an error, reject the promise
+        promise.reject("ERROR", "Yttrium estimateFees Error:" + e.message, e)
+      }
+    }
+  }
+
   companion object {
     const val NAME = "RNWalletConnectModule"
   }

package/android/src/oldarch/RNWalletConnectModuleSpec.kt

@@ -9,8 +9,12 @@ abstract class RNWalletConnectModuleSpec internal constructor(context: ReactAppl
   ReactContextBaseJavaModule(context) {
 
   abstract fun isAppInstalled(packageName: String?, promise: Promise);
-  abstract fun checkRoute(params: ReadableMap, promise: Promise);
-  abstract fun checkStatus(params: ReadableMap, promise: Promise);
+  abstract fun prepare(params: ReadableMap, promise: Promise);
+  abstract fun status(params: ReadableMap, promise: Promise);
+  abstract fun getBridgeDetails(params: ReadableMap, promise: Promise);
+  abstract fun estimateFees(params: ReadableMap, promise: Promise);
+  abstract fun getERC20Balance(params: ReadableMap, promise: Promise);
+
   protected abstract fun getTypedExportedConstants(): Map<String, String>
 
   override fun getConstants(): Map<String, String> {

package/index.js

@@ -78,42 +78,7 @@ if (typeof global?.Application === "undefined") {
 }
 
 // iOS uses Yttrium, Android uses RNWalletConnectModule
-const yttrium = NativeModules.Yttrium || NativeModules.RNWalletConnectModule;
-
-export async function checkRoute(params) {
-  if (!yttrium) {
-    throw new Error("RN Yttrium is not correctly linked");
-  }
-
-  const result = await yttrium?.checkRoute(params);
-  return parseResult(result);
-}
-
-export async function checkStatus(params) {
-  if (!yttrium) {
-    throw new Error("RN Yttrium is not correctly linked");
-  }
-
-  const result = await yttrium?.checkStatus(params);
-  return parseResult(result);
-}
-
-function parseResult(result) {
-  if (typeof result === "undefined") return;
-
-  // iOS returns parsed JSON object, while Android returns stringified
-  if (typeof result === "string") {
-    try {
-      return JSON.parse(result);
-    } catch (e) {}
-  }
-  return result;
-}
-
-global.yttrium = {
-  checkRoute,
-  checkStatus,
-};
+global.yttrium = NativeModules.Yttrium || NativeModules.RNWalletConnectModule;
 
 // eslint-disable-next-line no-console
 console.log("RN yttrium", global.yttrium);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@walletconnect/react-native-compat",
   "description": "Shims for WalletConnect Protocol in React Native Projects",
-  "version": "2.17.2-canary-ca-5",
+  "version": "2.17.2-canary-ca-7",
   "author": "WalletConnect, Inc. <walletconnect.com>",
   "homepage": "https://github.com/walletconnect/walletconnect-monorepo/",
   "license": "Apache-2.0",