Add supporting Versioned Transaction signing

packages/walletconnect-solana/package.json

@@ -25,7 +25,7 @@
         "package": "shx echo '{ \"type\": \"commonjs\" }' > lib/cjs/package.json"
     },
     "devDependencies": {
-        "@solana/web3.js": "^1.52.0",
+        "@solana/web3.js": "^1.63.0",
         "@types/node-fetch": "^2.6.2",
         "@types/pino": "6.3.11",
         "@walletconnect/types": "^2.4.5",
@@ -38,6 +38,6 @@
         "bs58": "^5.0.0"
     },
     "peerDependencies": {
-        "@solana/web3.js": "^1.52.0"
+        "@solana/web3.js": "^1.63.0"
     }
 }

packages/walletconnect-solana/src/adapter.ts

@@ -1,5 +1,4 @@
-import type { Transaction } from '@solana/web3.js';
-import { PublicKey } from '@solana/web3.js';
+import { Transaction, VersionedTransaction, PublicKey } from '@solana/web3.js';
 import QRCodeModal from '@walletconnect/qrcode-modal';
 import WalletConnectClient from '@walletconnect/sign-client';
 import type { EngineTypes, SessionTypes, SignClientTypes } from '@walletconnect/types';
@@ -36,6 +35,9 @@ const getConnectParams = (chainId: WalletConnectChainID): EngineTypes.FindParams
     },
 });
 
+const isVersionedTransaction = (transaction: Transaction | VersionedTransaction): transaction is VersionedTransaction =>
+    'version' in transaction;
+
 export class WalletConnectWallet {
     private _client: WalletConnectClient | undefined;
     private _session: SessionTypes.Struct | undefined;
@@ -115,16 +117,56 @@ export class WalletConnectWallet {
         }
     }
 
-    async signTransaction(transaction: Transaction): Promise<Transaction> {
+    async signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T> {
+        if (this._client && this._session) {
+            let rawTransaction: string;
+            let legacyTransaction: Transaction | undefined;
+
+            if (isVersionedTransaction(transaction)) {
+                rawTransaction = Buffer.from(transaction.serialize()).toString('base64');
+                if (transaction.version === 'legacy') {
+                    // Build Transaction for legacy sign transaction request format
+                    legacyTransaction = Transaction.from(transaction.serialize());
+                }
+            } else {
+                rawTransaction = transaction
+                    .serialize({
+                        requireAllSignatures: false,
+                        verifySignatures: false,
+                    })
+                    .toString('base64');
+                legacyTransaction = transaction;
+            }
+
+            const signature = await this._signTransaction(rawTransaction, legacyTransaction);
+            transaction.addSignature(this.publicKey, Buffer.from(base58.decode(signature)));
+            return transaction;
+        } else {
+            throw new ClientNotInitializedError();
+        }
+    }
+
+    private async _signTransaction(
+        rawTransaction: string,
+        legacyTransaction?: Transaction | undefined
+    ): Promise<string> {
         if (this._client && this._session) {
             const { signature } = await this._client.request<{ signature: string }>({
                 chainId: this._network,
                 topic: this._session.topic,
-                request: { method: WalletConnectRPCMethods.signTransaction, params: { ...transaction } },
+                request: {
+                    method: WalletConnectRPCMethods.signTransaction,
+                    params: {
+                        // Passing ...legacyTransaction is deprecated.
+                        // All new clients should rely on transaction parameter.
+                        // The future versions will stop passing ...legacyTransaction.
+                        ...legacyTransaction,
+                        // New base64-encoded serialized transaction request parameter
+                        transaction: rawTransaction,
+                    },
+                },
             });
-            transaction.addSignature(this.publicKey, Buffer.from(base58.decode(signature)));
-
-            return transaction;
+            return signature;
         } else {
             throw new ClientNotInitializedError();
         }