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

package/ios/Yttrium.mm

@@ -6,14 +6,27 @@
 //                 withResolver:(RCTPromiseResolveBlock)resolve
 //                 withRejecter:(RCTPromiseRejectBlock)reject)
 //
-RCT_EXTERN_METHOD(checkStatus:(id)params
+RCT_EXTERN_METHOD(status:(id)params
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(checkRoute:(id)params
+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;

package/ios/Yttrium.swift

@@ -5,7 +5,7 @@ import YttriumWrapper
 class Yttrium: NSObject {
     
     @objc
-    func checkStatus(_ params: Any, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    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,
@@ -49,68 +49,150 @@ class Yttrium: NSObject {
         }
     }
     
-    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] {
+    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,
-                "gas": transaction.gas,
-                "data": transaction.data,
-                "nonce": transaction.nonce,
-                "chainId": transaction.chainId,
-                "gasPrice": transaction.gasPrice,
-                "maxFeePerGas": transaction.maxFeePerGas,
-                "maxPriorityFeePerGas": transaction.maxPriorityFeePerGas
+                "input": transaction.input,
+                "gasLimit": transaction.gasLimit,
+                "nonce": transaction.nonce
             ]
         }
-        
-        func estimationToDictionary(estimation: YttriumWrapper.Eip1559Estimation) -> [String: Any] {
+
+        func fundingMetadataToDictionary(_ metadata: YttriumWrapper.FundingMetadata) -> [String: Any] {
             return [
-                "maxFeePerGas": estimation.maxFeePerGas,
-                "maxPriorityFeePerGas": estimation.maxPriorityFeePerGas
+                "chainId": metadata.chainId,
+                "tokenContract": metadata.tokenContract,
+                "symbol": metadata.symbol,
+                "amount": metadata.amount,
+                "bridgingFee": metadata.bridgingFee,
+                "decimals": metadata.decimals
             ]
         }
-        
-        func feeToDictionary(fee: YttriumWrapper.TransactionFee) -> [String: Any] {
+
+        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 [
-                "fee": amountToDictionary(amount: fee.fee),
-                "localFee": amountToDictionary(amount: fee.localFee)
+                "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]
         
-        func amountToDictionary(amount: YttriumWrapper.Amount) -> [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,
@@ -119,99 +201,104 @@ class Yttrium: NSObject {
                 "formattedAlt": amount.formattedAlt
             ]
         }
-        
-        func txnDetailsToDictionary(details: YttriumWrapper.TxnDetails) -> [String: Any] {
+
+        func transactionFeeToDictionary(_ fee: YttriumWrapper.TransactionFee) -> [String: Any] {
             return [
-                "transaction": transactionToDictionary(transaction: details.transaction),
-                "estimate": estimationToDictionary(estimation: details.estimate),
-                "fee": feeToDictionary(fee: details.fee)
+                "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": routeUiFields.route.map { txnDetailsToDictionary(details: $0) },
-            "bridge": routeUiFields.bridge.map { feeToDictionary(fee: $0) },
-            "initial": txnDetailsToDictionary(details: routeUiFields.initial),
-            "localTotal": amountToDictionary(amount: routeUiFields.localTotal)
+            "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 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)
-                  
-                  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)
-              }
-          }
-      }
+    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.17.2-canary-ca-7",
+  "version": "2.17.2-canary-ca-9",
   "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.4.6'
+  s.dependency 'YttriumWrapper' , '0.4.10'
 
   # 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.