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

package/android/src/oldarch/RNWalletConnectModuleSpec.kt

@@ -3,11 +3,14 @@ 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 checkRoute(params: ReadableMap, promise: Promise);
+  abstract fun checkStatus(params: ReadableMap, promise: Promise);
   protected abstract fun getTypedExportedConstants(): Map<String, String>
 
   override fun getConstants(): Map<String, String> {

package/index.js

@@ -1,3 +1,4 @@
+import { NativeModules } from "react-native";
 import { getApplicationModule } from "./module";
 
 // Polyfill TextEncode / TextDecode
@@ -75,3 +76,44 @@ if (typeof global?.Application === "undefined") {
     console.error("react-native-compat: Application module is not available");
   }
 }
+
+// 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,
+};
+
+// 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,22 @@
+#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(checkStatus:(id)params
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(checkRoute:(id)params
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/Yttrium.swift

@@ -0,0 +1,154 @@
+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"
+            ]
+            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,
+    ]
+  }
+  
+  @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 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)
+          }
+          //          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-rcnt-1",
+  "version": "2.17.2-canary-ca-0",
   "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.2.22'
 
   # 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.