Merge pull request #6678 from WalletConnect/feat/sui-tvf

feat: extending tvf

Author: ganchoradkov

.changeset/modern-plums-do.md

@@ -0,0 +1,12 @@
+---
+"@walletconnect/sign-client": patch
+"@walletconnect/utils": patch
+"@walletconnect/core": patch
+"@walletconnect/react-native-compat": patch
+"@walletconnect/types": patch
+"@walletconnect/ethereum-provider": patch
+"@walletconnect/signer-connection": patch
+"@walletconnect/universal-provider": patch
+---
+
+Extended TVF to cover more chains

package-lock.json

@@ -146,6 +146,7 @@ export const ENGINE_QUEUE_STATES: { idle: "IDLE"; active: "ACTIVE" } = {
 };
 
 export const TVF_METHODS = {
+  // evm
   eth_sendTransaction: {
     key: "",
   },
@@ -156,6 +157,7 @@ export const TVF_METHODS = {
     key: "",
   },
 
+  // solana
   solana_signTransaction: {
     key: "signature",
   },
@@ -165,4 +167,67 @@ export const TVF_METHODS = {
   solana_signAndSendTransaction: {
     key: "signature",
   },
+
+  // sui
+  sui_signAndExecuteTransaction: {
+    key: "digest",
+  },
+  sui_signTransaction: {
+    key: "",
+  },
+
+  // hedera
+  hedera_signAndExecuteTransaction: {
+    key: "transactionId",
+  },
+  hedera_executeTransaction: {
+    key: "transactionId",
+  },
+
+  // near
+  near_signTransaction: {
+    key: "",
+  },
+  near_signTransactions: {
+    key: "",
+  },
+
+  // tron
+  tron_signTransaction: {
+    key: "txID",
+  },
+
+  // xrpl
+  xrpl_signTransaction: {
+    key: "",
+  },
+
+  xrpl_signTransactionFor: {
+    key: "",
+  },
+
+  // algorand
+  algo_signTxn: {
+    key: "",
+  },
+
+  // bitcoin
+  sendTransfer: {
+    key: "txid",
+  },
+
+  // stacks
+  stacks_stxTransfer: {
+    key: "txId",
+  },
+
+  // polkadot
+  polkadot_signTransaction: {
+    key: "",
+  },
+
+  // cosmos
+  cosmos_signDirect: {
+    key: "",
+  },
 };

packages/sign-client/src/constants/engine.ts

@@ -99,7 +99,12 @@ import {
   isTestRun,
   isValidArray,
   extractSolanaTransactionId,
+  getSuiDigest,
   mergeRequiredAndOptionalNamespaces,
+  getNearTransactionIdFromSignedTransaction,
+  getAlgorandTransactionId,
+  buildSignedExtrinsicHash,
+  getSignDirectHash,
 } from "@walletconnect/utils";
 import EventEmmiter from "events";
 import {
@@ -651,7 +656,6 @@ export class Engine extends IEngine {
       },
       chainId,
     };
-    const shouldSetTVF = this.shouldSetTVF(protocolMethod, protocolRequestParams);
 
     return await Promise.all([
       new Promise<void>(async (resolve) => {
@@ -663,9 +667,7 @@ export class Engine extends IEngine {
           params: protocolRequestParams,
           expiry,
           throwOnFailedPublish: true,
-          ...(shouldSetTVF && {
-            tvf: this.getTVFParams(clientRpcId, protocolRequestParams),
-          }),
+          tvf: this.getTVFParams(clientRpcId, protocolRequestParams),
         }).catch((error) => reject(error));
         this.client.events.emit("session_request_sent", {
           topic,
@@ -1584,9 +1586,7 @@ export class Engine extends IEngine {
       record = await this.client.core.history.get(topic, id);
       const request = record.request;
       try {
-        if (this.shouldSetTVF(request.method as JsonRpcTypes.WcMethod, request.params)) {
-          tvf = this.getTVFParams(id, request.params, result);
-        }
+        tvf = this.getTVFParams(id, request.params, result);
       } catch (error) {
         this.client.logger.warn(`sendResult() -> getTVFParams() failed`, error);
       }
@@ -3111,39 +3111,26 @@ export class Engine extends IEngine {
     }
   };
 
-  private shouldSetTVF = (
-    protocolMethod: JsonRpcTypes.WcMethod,
-    params: JsonRpcTypes.RequestParams["wc_sessionRequest"],
-  ) => {
-    if (!params) return false;
-    if (protocolMethod !== "wc_sessionRequest") return false;
-    const { request } = params;
-    return Object.keys(TVF_METHODS).includes(request.method);
-  };
-
   private getTVFParams = (
     id: number,
     params: JsonRpcTypes.RequestParams["wc_sessionRequest"],
     result?: any,
   ) => {
+    const tvf: RelayerTypes.ITVF = {
+      correlationId: id,
+      rpcMethods: [params.request.method],
+      chainId: params.chainId,
+    };
     try {
-      const requestMethod = params.request.method;
-      const txHashes = this.extractTxHashesFromResult(requestMethod, result);
-      const tvf: RelayerTypes.ITVF = {
-        correlationId: id,
-        rpcMethods: [requestMethod],
-        chainId: params.chainId,
-        ...(this.isValidContractData(params.request.params) && {
-          // initially only get contractAddresses from EVM txs
-          contractAddresses: [params.request.params?.[0]?.to],
-        }),
-        txHashes,
-      };
-      return tvf;
+      const txHashes = this.extractTxHashesFromResult(params.request, result);
+      tvf.txHashes = txHashes;
+      tvf.contractAddresses = this.isValidContractData(params.request.params)
+        ? [params.request.params?.[0]?.to]
+        : [];
     } catch (e) {
       this.client.logger.warn("Error getting TVF params", e);
     }
-    return {};
+    return tvf;
   };
 
   private isValidContractData = (params: any) => {
@@ -3161,9 +3148,51 @@ export class Engine extends IEngine {
     return false;
   };
 
-  private extractTxHashesFromResult = (method: string, result: any): string[] => {
+  private extractTxHashesFromResult = (
+    request: JsonRpcTypes.RequestParams["wc_sessionRequest"]["request"],
+    result: any,
+  ): string[] => {
     try {
+      if (!result) return [];
+
+      const method = request.method;
       const methodConfig = TVF_METHODS[method as keyof typeof TVF_METHODS];
+
+      if (method === "sui_signTransaction") {
+        return [getSuiDigest(result.transactionBytes)];
+      }
+
+      if (method === "near_signTransaction") {
+        return [getNearTransactionIdFromSignedTransaction(result)];
+      }
+
+      if (method === "near_signTransactions") {
+        return result.map((tx: any) => getNearTransactionIdFromSignedTransaction(tx));
+      }
+
+      if (method === "xrpl_signTransactionFor" || method === "xrpl_signTransaction") {
+        return [result.tx_json?.hash];
+      }
+
+      if (method === "polkadot_signTransaction") {
+        return [
+          buildSignedExtrinsicHash({
+            transaction: request.params.transactionPayload,
+            signature: result.signature,
+          }),
+        ];
+      }
+
+      if (method === "algo_signTxn") {
+        return isValidArray(result)
+          ? result.map((tx: any) => getAlgorandTransactionId(tx))
+          : [getAlgorandTransactionId(result)];
+      }
+
+      if (method === "cosmos_signDirect") {
+        return [getSignDirectHash(result)];
+      }
+
       // result = 0x...
       if (typeof result === "string") {
         return [result];