@walletconnect/react-native-compat 2.18.1-canary-exp-3 → 2.18.1-canary-ca-2

package/android/build.gradle

@@ -5,15 +5,25 @@ buildscript {
   repositories {
     google()
     mavenCentral()
+    maven { url 'https://jitpack.io' }
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:7.2.1"
+    classpath "com.android.tools.build:gradle:8.5.1"
     // noinspection DifferentKotlinGradleVersion
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }
 }
 
+allprojects {
+  repositories {
+    google()
+    mavenCentral()
+    maven { url 'https://jitpack.io' }
+  }
+}
+
+
 def isNewArchitectureEnabled() {
   return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
@@ -109,6 +119,11 @@ 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'
+  implementation 'com.github.reown-com:yttrium:0.8.19'
 }
 
 if (isNewArchitectureEnabled()) {

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

@@ -3,7 +3,17 @@ package com.walletconnect.reactnativemodule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
 import android.content.pm.PackageManager
+import uniffi.uniffi_yttrium.ChainAbstractionClient
+import uniffi.yttrium.PrepareResponse
+import kotlinx.coroutines.*
+import uniffi.uniffi_yttrium.*
+import uniffi.yttrium.*
+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 +59,242 @@ class RNWalletConnectModuleModule internal constructor(context: ReactApplication
     }
   }
 
+
+
+// ------------------------------ Yttrium Chain Abstraction ------------------------------
+
+  private var prepareAvailableResultsMap: MutableMap<String, PrepareResponseAvailable> = mutableMapOf()
+  private var prepareDetailedAvailableResultsMap: MutableMap<String, UiFields> = mutableMapOf()
+  private lateinit var client: ChainAbstractionClient
+
+  @OptIn(DelicateCoroutinesApi::class)
+  @ReactMethod
+  override fun initialize(params: ReadableMap, promise: Promise){
+    GlobalScope.launch(Dispatchers.Main) {
+      try {
+        var projectId = params.getString("projectId") as String
+        var sdkVersion = params.getString("sdkVersion") as String
+        var url = params.getString("url") as String
+
+        client = ChainAbstractionClient(projectId, PulseMetadata(url= url, bundleId = "test",  packageName = "test package", sdkVersion= sdkVersion, sdkPlatform = "mobile"))
+        promise.resolve(true)
+      } catch (e: Exception) {
+        // In case of an error, reject the promise
+        promise.reject("ERROR", "Yttrium initialize Error:" + e.message, e)
+      }
+    }
+  }
+
+  @ReactMethod
+  override fun prepare(params: ReadableMap, promise: Promise){
+    System.out.println("checkRoute: Hello from YttriumModule")
+    GlobalScope.launch(Dispatchers.Main) {
+      try {
+        val transactionMap = params.getMap("transaction")
+
+        if(transactionMap === null) {
+          throw Error("no params")
+        }
+          // Extract values from the nested transaction map
+          val chainId = transactionMap.getString("chainId") ?: ""
+          val input = transactionMap.getString("input") ?: ""
+          val from = transactionMap.getString("from") ?: ""
+          val to = transactionMap.getString("to") ?: ""
+          val value = transactionMap.getString("value") ?: "0"
+          val result = client.prepare(chainId = chainId, from = from, Call(
+            to= to,
+            value = value,
+            input = input
+          ))
+
+          when(result) {
+            is PrepareResponse.Success -> {
+              when (result.v1) {
+                is PrepareResponseSuccess.Available -> {
+                  val availableResult = (result.v1 as PrepareResponseSuccess.Available).v1;
+                  prepareAvailableResultsMap[availableResult.orchestrationId] = availableResult;
+                }
+
+                is PrepareResponseSuccess.NotRequired -> {
+                  println("not required")
+                }
+              }
+            }
+            is PrepareResponse.Error -> {
+              println("prepare error: ")
+              println(result.v1.error)
+            }
+          }
+          println("checkRoute: result: ")
+          println(result)
+
+          val gson = Gson()
+          val jsonResult = gson.toJson(result)
+          promise.resolve(jsonResult)
+      } catch (e: Exception) {
+        // In case of an error, reject the promise
+        promise.reject("ERROR", "Yttrium checkRoute Error:" + e.message, e)
+      }
+    }
+  }
+
+  @ReactMethod
+  override fun prepareDetailed(params: ReadableMap, promise: Promise){
+    System.out.println("prepareDetailed: Hello from YttriumModule")
+    GlobalScope.launch(Dispatchers.Main) {
+      try {
+        val transactionMap = params.getMap("transaction")
+
+        if(transactionMap === null) {
+          throw Error("no params")
+        }
+        // Extract values from the nested transaction map
+        val chainId = transactionMap.getString("chainId") ?: ""
+        val input = transactionMap.getString("input") ?: ""
+        val from = transactionMap.getString("from") ?: ""
+        val to = transactionMap.getString("to") ?: ""
+        val value = transactionMap.getString("value") ?: "0"
+        val result = client.prepareDetailed(chainId = chainId, from = from, Call(
+          to= to,
+          value = value,
+          input = input
+        ), Currency.USD)
+
+
+        println("prepareDetailed: result: ")
+        println(result)
+
+        when(result) {
+          is PrepareDetailedResponse.Success -> {
+            when (result.v1) {
+              is PrepareDetailedResponseSuccess.Available -> {
+                val availableResult = (result.v1 as PrepareDetailedResponseSuccess.Available).v1
+                prepareDetailedAvailableResultsMap[availableResult.routeResponse.orchestrationId] = availableResult
+              }
+              is PrepareDetailedResponseSuccess.NotRequired -> {
+                println("prepareDetailed NotRequired: ")
+              }
+            }
+          }
+          is PrepareDetailedResponse.Error -> {
+            println("prepareDetailed error: ")
+            println(result.v1.error)
+          }
+        }
+
+        val gson = Gson()
+        val jsonResult = gson.toJson(result)
+        promise.resolve(jsonResult)
+      } catch (e: Exception) {
+        // In case of an error, reject the promise
+        promise.reject("ERROR", "Yttrium checkRoute Error:" + e.message, e)
+      }
+    }
+  }
+
+  @ReactMethod
+  override fun status(params: ReadableMap, promise: Promise){
+    System.out.println("checkStatus: Hello from YttriumModule address")
+
+    GlobalScope.launch(Dispatchers.Main) {
+      try {
+        var orchestrationId = params.getString("orchestrationId") as String
+        val result = client.status(orchestrationId)
+        println("checkRoute: status: ")
+        println(result)
+
+        val gson = Gson()
+        val jsonResult = gson.toJson(result)
+        promise.resolve(jsonResult)
+      } 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 orchestrationId = params.getString("orchestrationId") as String
+
+        val availableResult = prepareAvailableResultsMap[orchestrationId]
+        val uiFields = availableResult.let {
+          if (it != null) {
+            client.getUiFields(it, 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 tokenAddress = params.getString("tokenAddress") as String
+        val ownerAddress = params.getString("ownerAddress") as String
+        val chainId = params.getString("chainId") as String
+        val result = client.erc20TokenBalance(chainId = chainId, token = tokenAddress, owner = 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)
+      }
+    }
+  }
+
+  private fun getListOfStrings(params: ReadableMap, key: String): List<String> {
+    val readableArray: ReadableArray? = params.getArray(key)
+    return readableArray?.toArrayList()?.map { it as String } ?: emptyList()
+  }
+
+  @ReactMethod
+  override fun execute(params: ReadableMap, promise: Promise){
+    System.out.println("getERC20Balance: Hello from YttriumModule address")
+
+    GlobalScope.launch(Dispatchers.Main) {
+      try {
+        val orchestrationId = params.getString("orchestrationId") as String
+        val bridgeSignedTransactions = getListOfStrings(params, "bridgeSignedTransactions")
+        val initialSignedTransaction = params.getString("initialSignedTransaction") as String
+
+
+        val prepareDetailedResult = prepareDetailedAvailableResultsMap[orchestrationId]
+        
+        val result =
+          prepareDetailedResult?.let {
+            client.execute(
+              uiFields = it,
+              routeTxnSigs = bridgeSignedTransactions,
+              initialTxnSig = initialSignedTransaction,
+            )
+          }
+
+        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)
+      }
+    }
+  }
+
+
   companion object {
     const val NAME = "RNWalletConnectModule"
   }

package/android/src/oldarch/RNWalletConnectModuleSpec.kt

@@ -3,15 +3,25 @@ package com.walletconnect.reactnativemodule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableMap
 
 abstract class RNWalletConnectModuleSpec internal constructor(context: ReactApplicationContext) :
   ReactContextBaseJavaModule(context) {
 
   abstract fun isAppInstalled(packageName: String?, promise: Promise);
+  abstract fun initialize(params: ReadableMap, promise: Promise);
+  abstract fun prepare(params: ReadableMap, promise: Promise);
+  abstract fun prepareDetailed(params: ReadableMap, promise: Promise);
+  abstract fun status(params: ReadableMap, promise: Promise);
+  abstract fun getBridgeDetails(params: ReadableMap, promise: Promise);
+  abstract fun getERC20Balance(params: ReadableMap, promise: Promise);
+  abstract fun execute(params: ReadableMap, promise: Promise);
+
   protected abstract fun getTypedExportedConstants(): Map<String, String>
 
   override fun getConstants(): Map<String, String> {
     val constants: Map<String, String> = getTypedExportedConstants()
     return constants
   }
+
 }

package/index.js

@@ -1,3 +1,4 @@
+import { NativeModules } from "react-native";
 import { getApplicationModule } from "./module";
 
 // Polyfill TextEncode / TextDecode
@@ -75,3 +76,9 @@ if (typeof global?.Application === "undefined") {
     console.error("react-native-compat: Application module is not available");
   }
 }
+
+// iOS uses Yttrium, Android uses RNWalletConnectModule
+global.yttrium = NativeModules.Yttrium || NativeModules.RNWalletConnectModule;
+
+// eslint-disable-next-line no-console
+console.log("RN yttrium", global.yttrium);

package/ios/Yttrium-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/ios/Yttrium.mm

@@ -0,0 +1,35 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(Yttrium, NSObject)
+
+//RCT_EXTERN_METHOD(multiply:(float)a withB:(float)b
+//                 withResolver:(RCTPromiseResolveBlock)resolve
+//                 withRejecter:(RCTPromiseRejectBlock)reject)
+//
+RCT_EXTERN_METHOD(status:(id)params
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(prepare:(id)params
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getBridgeDetails:(id)params
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getERC20Balance:(id)params
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(estimateFees:(id)params
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/Yttrium.swift

@@ -0,0 +1,304 @@
+import YttriumWrapper
+
+
+@objc(Yttrium)
+class Yttrium: NSObject {
+    
+    @objc
+    func status(_ 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 convertRouteResponseAvailableToDictionary(_ routeResponse: RouteResponseAvailable) -> [String: Any] {
+        func transactionToDictionary(_ transaction: YttriumWrapper.Transaction) -> [String: Any] {
+            return [
+                "chainId": transaction.chainId,
+                "from": transaction.from,
+                "to": transaction.to,
+                "value": transaction.value,
+                "input": transaction.input,
+                "gasLimit": transaction.gasLimit,
+                "nonce": transaction.nonce
+            ]
+        }
+
+        func fundingMetadataToDictionary(_ metadata: YttriumWrapper.FundingMetadata) -> [String: Any] {
+            return [
+                "chainId": metadata.chainId,
+                "tokenContract": metadata.tokenContract,
+                "symbol": metadata.symbol,
+                "amount": metadata.amount,
+                "bridgingFee": metadata.bridgingFee,
+                "decimals": metadata.decimals
+            ]
+        }
+
+        func initialTransactionMetadataToDictionary(_ metadata: YttriumWrapper.InitialTransactionMetadata) -> [String: Any] {
+            return [
+                "transferTo": metadata.transferTo,
+                "amount": metadata.amount,
+                "tokenContract": metadata.tokenContract,
+                "symbol": metadata.symbol,
+                "decimals": metadata.decimals
+            ]
+        }
+
+        func metadataToDictionary(_ metadata: YttriumWrapper.Metadata) -> [String: Any] {
+            return [
+                "fundingFrom": metadata.fundingFrom.map { fundingMetadataToDictionary($0) },
+                "initialTransaction": initialTransactionMetadataToDictionary(metadata.initialTransaction),
+                "checkIn": metadata.checkIn
+            ]
+        }
+
+        return [
+            "orchestrationId": routeResponse.orchestrationId,
+            "initialTransaction": transactionToDictionary(routeResponse.initialTransaction),
+            "transactions": routeResponse.transactions.map { transactionToDictionary($0) },
+            "metadata": metadataToDictionary(routeResponse.metadata)
+        ]
+    }
+    
+    private var availableResponseDictionary: [String: RouteResponseAvailable] = [:]
+    
+    @objc
+    func prepare(_ params: Any, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        print("checkRoute called with", params)
+        let dict = params as? [String: Any]
+        
+        if let transactionData = dict?["transaction"] as? [String: String],
+            let from = transactionData["from"] ?? "" as Optional,
+            let chainId = transactionData["chainId"] ?? "" as Optional,
+            let data = transactionData["data"] ?? "" as Optional,
+            let value = transactionData["value"] ?? "" as Optional,
+            let to = transactionData["to"] ?? "" as Optional,
+            let projectId = dict?["projectId"] as? String {
+            
+            let client = ChainAbstractionClient.init(projectId: projectId)
+            print("created client, checking route...")
+            Task {
+                do {
+                    let transaction = InitialTransaction.init(chainId: chainId, from: from, to: to, value: value, input: data)
+                    
+                    let routeResponseSuccess = try await client.prepare(initialTransaction: transaction)
+                    print("result", routeResponseSuccess)
+                    
+                    switch routeResponseSuccess {
+                    case let .success(routeResponse):
+                        switch routeResponse {
+                        case let .available(availableResponse):
+                            
+                            availableResponseDictionary[availableResponse.orchestrationId] = 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("available result", availableResponse)
+                            //                          print("ui_fields_json", routesDetails)
+                          let responseDict = convertRouteResponseAvailableToDictionary(availableResponse)
+                            print("parsed result dictionary", responseDict)
+                          resolve(["status": "available", "data": 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)
+                }
+            }
+        }
+    }
+    
+    func convertUiFieldsToDictionary(_ uiFields: UiFields) -> [String: Any] {
+        func feeEstimatedTransactionToDictionary(_ transaction: YttriumWrapper.FeeEstimatedTransaction) -> [String: Any] {
+            return [
+                "chainId": transaction.chainId,
+                "from": transaction.from,
+                "to": transaction.to,
+                "value": transaction.value,
+                "input": transaction.input,
+                "gasLimit": transaction.gasLimit,
+                "nonce": transaction.nonce,
+                "maxFeePerGas": transaction.maxFeePerGas,
+                "maxPriorityFeePerGas": transaction.maxPriorityFeePerGas
+            ]
+        }
+
+        func amountToDictionary(_ amount: YttriumWrapper.Amount) -> [String: Any] {
+            return [
+                "symbol": amount.symbol,
+                "amount": amount.amount,
+                "unit": amount.unit,
+                "formatted": amount.formatted,
+                "formattedAlt": amount.formattedAlt
+            ]
+        }
+
+        func transactionFeeToDictionary(_ fee: YttriumWrapper.TransactionFee) -> [String: Any] {
+            return [
+                "fee": amountToDictionary(fee.fee),
+                "localFee": amountToDictionary(fee.localFee)
+            ]
+        }
+
+        func txnDetailsToDictionary(_ txnDetails: YttriumWrapper.TxnDetails) -> [String: Any] {
+            return [
+                "transaction": feeEstimatedTransactionToDictionary(txnDetails.transaction),
+                "fee": transactionFeeToDictionary(txnDetails.fee)
+            ]
+        }
+
+        return [
+            "route": uiFields.route.map { txnDetailsToDictionary($0) },
+            "localRouteTotal": amountToDictionary(uiFields.localRouteTotal),
+            "bridge": uiFields.bridge.map { transactionFeeToDictionary($0) },
+            "localBridgeTotal": amountToDictionary(uiFields.localBridgeTotal),
+            "initial": txnDetailsToDictionary(uiFields.initial),
+            "localTotal": amountToDictionary(uiFields.localTotal)
+        ]
+    }
+    
+    @objc
+    func getBridgeDetails(_ params: Any, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        print("getBridgeDetails called with", params)
+        let dict = params as? [String: String]
+        
+        if  let orchestrationId = dict?["orchestrationId"] ?? "" as Optional,
+            let projectId = dict?["projectId"] as? String {
+            
+            let client = ChainAbstractionClient.init(projectId: projectId)
+            print("created client, getting UI fields...")
+            Task {
+                do {
+                    
+                    let availableResponse = availableResponseDictionary[orchestrationId]!
+                    let uiFields = try await client.getUiFields(routeResponse: availableResponse, currency: Currency.usd)
+                    let uiFIeldsDict = convertUiFieldsToDictionary(uiFields)
+                    print("getBridgeDetails result", uiFields)
+                    resolve(uiFIeldsDict)
+                } catch {
+                    print("Error occurred: \(error)")
+                    print(error)
+                    reject("yttrium err", "yttrium_err getBridgeDetails", error)
+                }
+            }
+        }
+    }
+    
+    @objc
+    func getERC20Balance(_ params: Any, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        print("getERC20Balance called with", params)
+        let dict = params as? [String: String]
+        
+        if  let tokenAddress = dict?["tokenAddress"] ?? "" as Optional,
+            let ownerAddress = dict?["ownerAddress"] ?? "" as Optional,
+            let chainId = dict?["chainId"] ?? "" as Optional,
+            let projectId = dict?["projectId"] as? String {
+            
+            let client = ChainAbstractionClient.init(projectId: projectId)
+            Task {
+                do {
+                    let balance = try await client.erc20TokenBalance(chainId: chainId, token: tokenAddress, owner: ownerAddress)
+                    print("getERC20Balance result", balance)
+                    resolve(balance)
+                } catch {
+                    print("Error occurred: \(error)")
+                    print(error)
+                    reject("yttrium err", "yttrium_err getERC20Balance", error)
+                }
+            }
+        }
+    }
+    
+    @objc
+    func estimateFees(_ params: Any, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        print("getERC20Balance called with", params)
+        let dict = params as? [String: String]
+        
+        if let chainId = dict?["chainId"] ?? "" as Optional,
+            let projectId = dict?["projectId"] as? String {
+            
+            let client = ChainAbstractionClient.init(projectId: projectId)
+            Task {
+                do {
+                    let fees = try await client.estimateFees(chainId: chainId)
+                    print("estimateFees result", fees)
+                    resolve(["maxFeePerGas": fees.maxFeePerGas, "maxPriorityFeePerGas": fees.maxPriorityFeePerGas])
+                } catch {
+                    print("Error occurred: \(error)")
+                    print(error)
+                    reject("yttrium err", "yttrium_err estimateFees", error)
+                }
+            }
+        }
+    }
+    
+}

package/package.json

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

package/react-native-compat.podspec

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