@walletconnect/react-native-compat 2.17.2-canary-ca-4 → 2.17.2-canary-ca-6

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,42 +61,40 @@ 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 
         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)
+          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
+                  availableResponseMap[availableResult.orchestrationId] = availableResult
                   val gson = Gson()
-                  val jsonElement: JsonElement = gson.toJsonTree((result.v1 as RouteResponseSuccess.Available).v1)
+                  val routesJson: JsonElement = gson.toJsonTree(availableResult)
                   val response = JsonObject()
                   response.addProperty("status", "available")
-                  response.add("data", jsonElement)
+                  response.add("data", routesJson)
                   promise.resolve(gson.toJson(response))
                 }
                 is RouteResponseSuccess.NotRequired -> {
@@ -108,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" -> {
@@ -146,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) {
@@ -157,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/ios/Yttrium.swift

@@ -3,152 +3,215 @@ import YttriumWrapper
 
 @objc(Yttrium)
 class Yttrium: NSObject {
-  
-  @objc
-  func checkStatus(_ params: Any, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
-    print("checkStatus called with", params )
-    if let dict = params as? [String: Any],
-       let projectId = dict["projectId"] as? String,
-       let orchestrationId = dict["orchestrationId"] as? String {
-      let client = ChainAbstractionClient.init(projectId: projectId)
-      Task {
-        do {
-          let statusResponse = try await client.status(orchestrationId: orchestrationId)
-          
-          switch statusResponse {
-          case let .completed(statusResponseCompleted):
-            print("status response completed", statusResponseCompleted)
-            let responseDict: [String: Any] = [
-              "createdAt": statusResponseCompleted.createdAt,
-              "status": "completed"
+    
+    @objc
+    func checkStatus(_ params: Any, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        print("checkStatus called with", params )
+        if let dict = params as? [String: Any],
+           let projectId = dict["projectId"] as? String,
+           let orchestrationId = dict["orchestrationId"] as? String {
+            let client = ChainAbstractionClient.init(projectId: projectId)
+            Task {
+                do {
+                    let statusResponse = try await client.status(orchestrationId: orchestrationId)
+                    
+                    switch statusResponse {
+                    case let .completed(statusResponseCompleted):
+                        print("status response completed", statusResponseCompleted)
+                        let responseDict: [String: Any] = [
+                            "createdAt": statusResponseCompleted.createdAt,
+                            "status": "completed"
+                        ]
+                        resolve(responseDict)
+                    case let .error(statusResponseError):
+                        print("status response error", statusResponseError)
+                        let responseDict: [String: Any] = [
+                            "createdAt": statusResponseError.createdAt,
+                            "reason": statusResponseError.error,
+                            "status": "error"
+                        ]
+                        resolve(responseDict)
+                    case let .pending(statusResponsePending):
+                        print("status response pending", statusResponsePending)
+                        let responseDict: [String: Any] = [
+                            "createdAt": statusResponsePending.createdAt,
+                            "checkIn": statusResponsePending.checkIn,
+                            "status": "pending"
+                        ]
+                        resolve(responseDict)
+                    }
+                } catch {
+                    print("Error occurred: \(error)")
+                    print(error)
+                    reject("checkStatus err", "checkStatus", error)
+                }
+            }
+        }
+    }
+    
+    func availableResponseToDictionary(_ response: YttriumWrapper.RouteResponseAvailable) -> [String: Any] {
+        return [
+            "orchestrationId": response.orchestrationId,
+            "transactions": response.transactions.map { transaction in
+                return [
+                    "from": transaction.from,
+                    "to": transaction.to,
+                    "value": transaction.value,
+                    "gas": transaction.gas,
+                    "data": transaction.data,
+                    "nonce": transaction.nonce,
+                    "chainId": transaction.chainId,
+                    "gasPrice": transaction.gasPrice,
+                    "maxFeePerGas": transaction.maxFeePerGas,
+                    "maxPriorityFeePerGas": transaction.maxPriorityFeePerGas,
+                ]
+            },
+            "metadata": [
+                "fundingFrom": response.metadata.fundingFrom.map { funding in
+                    return [
+                        "chainId": funding.chainId,
+                        "tokenContract": funding.tokenContract,
+                        "symbol": funding.symbol,
+                        "amount": funding.amount,
+                    ]
+                }
+            ],
+            "checkIn": response.metadata.checkIn,
+        ]
+    }
+    
+    func convertRouteUiFieldsToDictionary(_ routeUiFields: RouteUiFields) -> [String: Any] {
+        func transactionToDictionary(transaction: YttriumWrapper.Transaction) -> [String: Any] {
+            return [
+                "from": transaction.from,
+                "to": transaction.to,
+                "value": transaction.value,
+                "gas": transaction.gas,
+                "data": transaction.data,
+                "nonce": transaction.nonce,
+                "chainId": transaction.chainId,
+                "gasPrice": transaction.gasPrice,
+                "maxFeePerGas": transaction.maxFeePerGas,
+                "maxPriorityFeePerGas": transaction.maxPriorityFeePerGas
             ]
-            resolve(responseDict)
-          case let .error(statusResponseError):
-            print("status response error", statusResponseError)
-            let responseDict: [String: Any] = [
-                "createdAt": statusResponseError.createdAt,
-                "reason": statusResponseError.error,
-                "status": "error"
+        }
+        
+        func estimationToDictionary(estimation: YttriumWrapper.Eip1559Estimation) -> [String: Any] {
+            return [
+                "maxFeePerGas": estimation.maxFeePerGas,
+                "maxPriorityFeePerGas": estimation.maxPriorityFeePerGas
             ]
-            resolve(responseDict)
-          case let .pending(statusResponsePending):
-            print("status response pending", statusResponsePending)
-            let responseDict: [String: Any] = [
-              "createdAt": statusResponsePending.createdAt,
-              "checkIn": statusResponsePending.checkIn,
-              "status": "pending"
+        }
+        
+        func feeToDictionary(fee: YttriumWrapper.TransactionFee) -> [String: Any] {
+            return [
+                "fee": amountToDictionary(amount: fee.fee),
+                "localFee": amountToDictionary(amount: fee.localFee)
             ]
-            resolve(responseDict)
-          }
-        } catch {
-          print("Error occurred: \(error)")
-          print(error)
-          reject("checkStatus err", "checkStatus", error)
         }
-      }
-    }
-  }
-  
-  func availableResponseToDictionary(_ response: YttriumWrapper.RouteResponseAvailable) -> [String: Any] {
-    return [
-      "orchestrationId": response.orchestrationId,
-      "transactions": response.transactions.map { transaction in
+        
+        func amountToDictionary(amount: YttriumWrapper.Amount) -> [String: Any] {
+            return [
+                "symbol": amount.symbol,
+                "amount": amount.amount,
+                "unit": amount.unit,
+                "formatted": amount.formatted,
+                "formattedAlt": amount.formattedAlt
+            ]
+        }
+        
+        func txnDetailsToDictionary(details: YttriumWrapper.TxnDetails) -> [String: Any] {
+            return [
+                "transaction": transactionToDictionary(transaction: details.transaction),
+                "estimate": estimationToDictionary(estimation: details.estimate),
+                "fee": feeToDictionary(fee: details.fee)
+            ]
+        }
+        
         return [
-          "from": transaction.from,
-          "to": transaction.to,
-          "value": transaction.value,
-          "gas": transaction.gas,
-          "data": transaction.data,
-          "nonce": transaction.nonce,
-          "chainId": transaction.chainId,
-          "gasPrice": transaction.gasPrice,
-          "maxFeePerGas": transaction.maxFeePerGas,
-          "maxPriorityFeePerGas": transaction.maxPriorityFeePerGas,
+            "route": routeUiFields.route.map { txnDetailsToDictionary(details: $0) },
+            "bridge": routeUiFields.bridge.map { feeToDictionary(fee: $0) },
+            "initial": txnDetailsToDictionary(details: routeUiFields.initial),
+            "localTotal": amountToDictionary(amount: routeUiFields.localTotal)
         ]
-      },
-      "metadata": [
-        "fundingFrom": response.metadata.fundingFrom.map { funding in
-          return [
-            "chainId": funding.chainId,
-            "tokenContract": funding.tokenContract,
-            "symbol": funding.symbol,
-            "amount": funding.amount,
-          ]
-        }
-      ],
-      "checkIn": response.metadata.checkIn,
-    ]
-  }
-  
-  @objc
-  func checkRoute(_ params: Any, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
-    print("checkRoute called with", params)
-    if let dict = params as? [String: Any],
-       let transactionData = dict["transaction"] as? [String: Any],
-       let from = transactionData["from"] as? FfiAddress,
-       let chainId = transactionData["chainId"] as? String,
-       let data = transactionData["data"] as? FfiBytes,
-       let gasPrice = transactionData["gasPrice"] as? String,
-       let gas = transactionData["gas"] as? Ffiu64,
-       let value = transactionData["value"] as? Ffiu256,
-       let to = transactionData["to"] as? FfiAddress,
-       let maxFeePerGas = transactionData["maxFeePerGas"] as? Ffiu256,
-       let maxPriorityFeePerGas = transactionData["maxPriorityFeePerGas"] as? Ffiu256,
-       let nonce = transactionData["nonce"] as? Ffiu64,
-       let projectId = dict["projectId"] as? String {
-      
-      
-      let client = ChainAbstractionClient.init(projectId: projectId)
-      print("created client, checking route...")
-      Task {
-        do {
-          let transaction = InitTransaction.init(from: from, to: to, value: value, gas: gas, gasPrice: gasPrice, data: data, nonce: nonce, maxFeePerGas: maxFeePerGas, maxPriorityFeePerGas: maxPriorityFeePerGas, chainId: chainId)
+    }
+    
+    @objc
+    func checkRoute(_ params: Any, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+      print("checkRoute called with", params)
+      if let dict = params as? [String: Any],
+         let transactionData = dict["transaction"] as? [String: Any],
+         let from = transactionData["from"] as? FfiAddress,
+         let chainId = transactionData["chainId"] as? String,
+         let data = transactionData["data"] as? FfiBytes,
+         let gasPrice = transactionData["gasPrice"] as? String,
+         let gas = transactionData["gas"] as? Ffiu64,
+         let value = transactionData["value"] as? Ffiu256,
+         let to = transactionData["to"] as? FfiAddress,
+         let maxFeePerGas = transactionData["maxFeePerGas"] as? Ffiu256,
+         let maxPriorityFeePerGas = transactionData["maxPriorityFeePerGas"] as? Ffiu256,
+         let nonce = transactionData["nonce"] as? Ffiu64,
+         let projectId = dict["projectId"] as? String {
           
-          let routeResponseSuccess = try await client.route(transaction: transaction)
-          print("result", routeResponseSuccess)
           
-          switch routeResponseSuccess {
-          case let .success(routeResponse):
-            switch routeResponse {
-            case let .available(availableResponse):
-              let responseDict = availableResponseToDictionary(availableResponse)
-              resolve(["status": "available", "data": responseDict])
-            case .notRequired(_):
-              print("not required")
-              resolve(["status": "not_required"])
-            }
-          case let .error(routeResponse):
-            switch routeResponse.error {
-            case BridgingError.insufficientFunds:
-              let responseDict: [String: Any] = [
-                "status": "error",
-                "reason": "insufficientFunds"
-              ]
-              resolve(responseDict)
-            case BridgingError.insufficientGasFunds:
-              let responseDict: [String: Any] = [
-                "status": "error",
-                "reason": "insufficientGasFunds"
-              ]
-              resolve(responseDict)
-            case BridgingError.noRoutesAvailable:
-              let responseDict: [String: Any] = [
-                "status": true,
-                "reason": "noRoutesAvailable"
-              ]
-              resolve(responseDict)
-            }
-            print(routeResponse)
-            print(routeResponse.error)
+          let client = ChainAbstractionClient.init(projectId: projectId)
+          print("created client, checking route...")
+          Task {
+              do {
+                  let transaction = InitTransaction.init(from: from, to: to, value: value, gas: gas, gasPrice: gasPrice, data: data, nonce: nonce, maxFeePerGas: maxFeePerGas, maxPriorityFeePerGas: maxPriorityFeePerGas, chainId: chainId)
+                  
+                  let routeResponseSuccess = try await client.route(transaction: transaction)
+                  print("result", routeResponseSuccess)
+                  
+                  switch routeResponseSuccess {
+                  case let .success(routeResponse):
+                      switch routeResponse {
+                      case let .available(availableResponse):
+                          let uiFields = try await client.getRouteUiFields(routeResponse: availableResponse, initialTransaction: Transaction(from: from, to: to, value: value, gas: gas, data: data, nonce: nonce, chainId: chainId, gasPrice: gasPrice, maxFeePerGas: maxFeePerGas, maxPriorityFeePerGas: maxPriorityFeePerGas), currency: Currency.usd)
+                          
+                          let routesDetails = convertRouteUiFieldsToDictionary(uiFields)
+                          
+                          print("ui_fields_json", routesDetails)
+                          let responseDict = availableResponseToDictionary(availableResponse)
+                          resolve(["status": "available", "data": [
+                              "routes": responseDict,
+                              "routesDetails": routesDetails
+                          ]])
+                      case .notRequired(_):
+                          print("not required")
+                          resolve(["status": "not_required"])
+                      }
+                  case let .error(routeResponse):
+                      switch routeResponse.error {
+                      case BridgingError.insufficientFunds:
+                          let responseDict: [String: Any] = [
+                              "status": "error",
+                              "reason": "insufficientFunds"
+                          ]
+                          resolve(responseDict)
+                      case BridgingError.insufficientGasFunds:
+                          let responseDict: [String: Any] = [
+                              "status": "error",
+                              "reason": "insufficientGasFunds"
+                          ]
+                          resolve(responseDict)
+                      case BridgingError.noRoutesAvailable:
+                          let responseDict: [String: Any] = [
+                              "status": "error",
+                              "reason": "noRoutesAvailable"
+                          ]
+                          resolve(responseDict)
+                      }
+                      print(routeResponse)
+                      print(routeResponse.error)
+                  }
+                  //          resolve(result)
+              } catch {
+                  print("Error occurred: \(error)")
+                  print(error)
+                  reject("yttrium err", "yttrium_err", error)
+              }
           }
-          //          resolve(result)
-        } catch {
-          print("Error occurred: \(error)")
-          print(error)
-          reject("yttrium err", "yttrium_err", error)
-        }
       }
     }
-    
-  }
 }

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-4",
+  "version": "2.17.2-canary-ca-6",
   "author": "WalletConnect, Inc. <walletconnect.com>",
   "homepage": "https://github.com/walletconnect/walletconnect-monorepo/",
   "license": "Apache-2.0",

package/react-native-compat.podspec

@@ -15,7 +15,7 @@ Pod::Spec.new do |s|
   s.source       = { :git => "https://github.com/walletconnect/walletconnect-monorepo.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"
-  s.dependency 'YttriumWrapper' , '0.2.22'
+  s.dependency 'YttriumWrapper' , '0.4.6'
 
   # 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.