@solana/connector 0.1.9 → 0.1.10

package/README.md

@@ -606,6 +606,102 @@ const mobile = getDefaultMobileConfig({
 </AppProvider>
 ```
 
+### WalletConnect Integration
+
+Connect mobile wallets via QR code or deep link using WalletConnect. This enables users to connect wallets like Trust Wallet, Exodus, and other WalletConnect-compatible Solana wallets.
+
+**1. Install WalletConnect dependency:**
+
+```bash
+npm install @walletconnect/universal-provider
+```
+
+**2. Get a WalletConnect Cloud Project ID:**
+
+Visit [cloud.walletconnect.com](https://cloud.walletconnect.com/) and create a project to get your `projectId`.
+
+**3. Configure WalletConnect in your app:**
+
+```typescript
+import { getDefaultConfig } from '@solana/connector/headless';
+import { useState } from 'react';
+
+export function Providers({ children }: { children: React.ReactNode }) {
+    const [walletConnectUri, setWalletConnectUri] = useState<string | null>(null);
+
+    const connectorConfig = useMemo(() => {
+        return getDefaultConfig({
+            appName: 'My App',
+            appUrl: 'https://myapp.com',
+            walletConnect: {
+                enabled: true,
+                projectId: process.env.NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID!,
+                metadata: {
+                    name: 'My App',
+                    description: 'My Solana Application',
+                    url: 'https://myapp.com',
+                    icons: ['https://myapp.com/icon.png'],
+                },
+                // Handle the WalletConnect URI for QR code display
+                onDisplayUri: (uri) => {
+                    setWalletConnectUri(uri);
+                },
+                onSessionEstablished: () => {
+                    setWalletConnectUri(null);
+                },
+            },
+        });
+    }, []);
+
+    return (
+        <AppProvider connectorConfig={connectorConfig}>
+            {children}
+            {/* Render QR code modal when URI is available */}
+            {walletConnectUri && (
+                <WalletConnectQRModal
+                    uri={walletConnectUri}
+                    onClose={() => setWalletConnectUri(null)}
+                />
+            )}
+        </AppProvider>
+    );
+}
+```
+
+**4. Create a QR code modal:**
+
+```typescript
+import QRCode from 'qrcode.react'; // npm install qrcode.react
+
+function WalletConnectQRModal({ uri, onClose }: { uri: string; onClose: () => void }) {
+    return (
+        <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-50">
+            <div className="bg-white rounded-xl p-6 max-w-sm">
+                <h2 className="text-lg font-semibold mb-4">Scan with your wallet</h2>
+                <QRCode value={uri} size={256} />
+                <p className="text-sm text-gray-500 mt-4 text-center">
+                    Open your WalletConnect-compatible wallet and scan this QR code
+                </p>
+                <button onClick={onClose} className="mt-4 w-full py-2 bg-gray-100 rounded">
+                    Cancel
+                </button>
+            </div>
+        </div>
+    );
+}
+```
+
+Once enabled, "WalletConnect" appears as a wallet option in your wallet list. When selected, the `onDisplayUri` callback fires with a URI that should be displayed as a QR code for mobile wallet scanning.
+
+**Supported WalletConnect Solana methods:**
+- `solana_getAccounts` / `solana_requestAccounts` - Get connected accounts
+- `solana_signMessage` - Sign arbitrary messages
+- `solana_signTransaction` - Sign transactions
+- `solana_signAllTransactions` - Sign multiple transactions
+- `solana_signAndSendTransaction` - Sign and broadcast transactions
+
+See the [WalletConnect Solana documentation](https://docs.walletconnect.network/wallet-sdk/chain-support/solana) for more details.
+
 ---
 
 ## Security Considerations
@@ -1208,6 +1304,7 @@ Compatible with all [Wallet Standard](https://github.com/wallet-standard/wallet-
 - **Glow** - Browser extension
 - **Brave Wallet** - Built-in browser wallet
 - **Solana Mobile** - All mobile wallet adapter compatible wallets
+- **WalletConnect** - Connect any WalletConnect-compatible mobile wallet via QR code
 - **Any Wallet Standard wallet** - Full compatibility
 
 ---

package/dist/chunk-4JT24DIX.js

@@ -0,0 +1,466 @@
+'use strict';
+
+var chunk64LV76OK_js = require('./chunk-64LV76OK.js');
+var codecs = require('@solana/codecs');
+
+// src/lib/wallet/walletconnect/universal-provider.ts
+chunk64LV76OK_js.createLogger("WalletConnectProvider"); var SOLANA_METHODS = [
+  "solana_getAccounts",
+  "solana_requestAccounts",
+  "solana_signMessage",
+  "solana_signTransaction",
+  "solana_signAllTransactions",
+  "solana_signAndSendTransaction"
+], SOLANA_CAIP_CHAINS = {
+  "solana:mainnet": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  "solana:devnet": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+  "solana:testnet": "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z"
+}, ALL_SOLANA_CAIP_CHAINS = Object.values(SOLANA_CAIP_CHAINS);
+async function createWalletConnectTransport(config) {
+  let state = {
+    provider: null,
+    initialized: false,
+    connecting: false,
+    connectPromise: null,
+    cancelConnect: null
+  };
+  function hasSolanaNamespace(session) {
+    let namespaces = session?.namespaces;
+    return namespaces ? "solana" in namespaces : false;
+  }
+  async function safeCleanupPendingPairings(provider, deletePairings = false) {
+    let cleanup = provider.cleanupPendingPairings;
+    if (cleanup)
+      try {
+        await cleanup.call(provider, { deletePairings });
+      } catch {
+      }
+  }
+  function safeAbortPairingAttempt(provider) {
+    let abort = provider.abortPairingAttempt;
+    if (abort)
+      try {
+        abort.call(provider);
+      } catch {
+      }
+  }
+  async function safeDisconnectProvider(provider) {
+    try {
+      await provider.disconnect();
+    } catch {
+    }
+  }
+  async function initProvider() {
+    if (state.provider)
+      return state.provider;
+    let UniversalProvider;
+    try {
+      UniversalProvider = (await import('@walletconnect/universal-provider')).default;
+    } catch {
+      throw new Error(
+        "WalletConnect is enabled but @walletconnect/universal-provider is not installed. Please install it in your app (e.g. pnpm add @walletconnect/universal-provider)."
+      );
+    }
+    let provider = await UniversalProvider.init({
+      projectId: config.projectId,
+      metadata: config.metadata,
+      relayUrl: config.relayUrl
+    });
+    return provider.on("display_uri", (uri) => {
+      config.onDisplayUri ? config.onDisplayUri(uri) : process.env.NODE_ENV;
+    }), provider.on("session_delete", () => {
+      config.onSessionDisconnected && config.onSessionDisconnected();
+    }), state.provider = provider, state.initialized = true, provider;
+  }
+  return {
+    async connect() {
+      if (state.connectPromise) {
+        await state.connectPromise;
+        return;
+      }
+      state.connectPromise = (async () => {
+        state.connecting = true;
+        try {
+          let CANCELLED = Symbol("WALLETCONNECT_CANCELLED"), cancelResolve = null, cancelPromise = new Promise((resolve) => {
+            cancelResolve = () => resolve(CANCELLED);
+          }), isCancelled = false;
+          state.cancelConnect = () => {
+            isCancelled || (isCancelled = true, cancelResolve?.());
+          };
+          async function raceWithCancel(promise) {
+            let result = await Promise.race([
+              promise,
+              cancelPromise
+            ]);
+            if (result === CANCELLED)
+              throw new Error("Connection cancelled");
+            return result;
+          }
+          let provider = null, connectAttemptPromise = null;
+          if (provider = await raceWithCancel(initProvider()), provider.session) {
+            if (hasSolanaNamespace(provider.session)) {
+              config.onSessionEstablished && config.onSessionEstablished();
+              return;
+            }
+            await raceWithCancel(safeDisconnectProvider(provider)), await raceWithCancel(safeCleanupPendingPairings(provider, false));
+          }
+          connectAttemptPromise = provider.connect({
+            namespaces: {
+              solana: {
+                chains: [...ALL_SOLANA_CAIP_CHAINS],
+                methods: [...SOLANA_METHODS],
+                events: []
+              }
+            }
+          });
+          try {
+            await raceWithCancel(connectAttemptPromise);
+          } catch (error) {
+            throw connectAttemptPromise?.catch(() => {
+            }), error;
+          }
+          if (!provider.session)
+            throw new Error("WalletConnect: connect completed but no session was established");
+          if (!hasSolanaNamespace(provider.session))
+            throw await raceWithCancel(safeDisconnectProvider(provider)), new Error("WalletConnect: connected session does not include Solana namespace");
+          config.onSessionEstablished && config.onSessionEstablished();
+        } finally {
+          state.connecting = false, state.cancelConnect = null, state.connectPromise = null;
+        }
+      })(), await state.connectPromise;
+    },
+    async disconnect() {
+      if (state.cancelConnect)
+        try {
+          state.cancelConnect();
+        } catch {
+        }
+      if (!state.provider) {
+        config.onSessionDisconnected && config.onSessionDisconnected();
+        return;
+      }
+      state.provider.session ? await safeDisconnectProvider(state.provider) : (safeAbortPairingAttempt(state.provider), await safeCleanupPendingPairings(state.provider, false)), config.onSessionDisconnected && config.onSessionDisconnected();
+    },
+    async request(args) {
+      let provider = await initProvider();
+      if (!provider.session)
+        throw new Error("WalletConnect: no active session. Call connect() first.");
+      try {
+        return await provider.request(
+          {
+            method: args.method,
+            params: args.params
+          },
+          args.chainId
+        );
+      } catch (error) {
+        throw error;
+      }
+    },
+    isConnected() {
+      return state.provider?.session != null;
+    },
+    getSessionAccounts() {
+      if (!state.provider?.session)
+        return [];
+      let accounts = [], namespaces = state.provider.session.namespaces;
+      if (namespaces?.solana?.accounts)
+        for (let account of namespaces.solana.accounts) {
+          let parts = account.split(":");
+          if (parts.length >= 3) {
+            let address = parts.slice(2).join(":");
+            address && !accounts.includes(address) && accounts.push(address);
+          }
+        }
+      return accounts;
+    }
+  };
+}
+function createMockWalletConnectTransport(mockImplementation = {}) {
+  let connected = false;
+  return {
+    ...{
+      async connect() {
+        connected = true;
+      },
+      async disconnect() {
+        connected = false;
+      },
+      async request() {
+        throw new Error("Mock transport: request not implemented");
+      },
+      isConnected() {
+        return connected;
+      },
+      getSessionAccounts() {
+        return [];
+      }
+    },
+    ...mockImplementation
+  };
+}
+
+// src/lib/wallet/walletconnect/create-walletconnect-wallet.ts
+var WALLETCONNECT_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCAzMiAzMiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjMyIiBoZWlnaHQ9IjMyIiByeD0iOCIgZmlsbD0iIzMzOTZGRiIvPgo8cGF0aCBkPSJNOS42IDEyLjRDMTMuMSA5IDE4LjkgOSAyMi40IDEyLjRMMjIuOSAxMi45QzIzLjEgMTMuMSAyMy4xIDEzLjQgMjIuOSAxMy42TDIxLjQgMTUuMUMyMS4zIDE1LjIgMjEuMSAxNS4yIDIxIDE1LjFMMjAuMyAxNC40QzE4IDEyLjIgMTQgMTIuMiAxMS43IDE0LjRMMTEgMTUuMUMxMC45IDE1LjIgMTAuNyAxNS4yIDEwLjYgMTUuMUw5LjEgMTMuNkM4LjkgMTMuNCA4LjkgMTMuMSA5LjEgMTIuOUw5LjYgMTIuNFpNMjUuMyAxNS4yTDI2LjYgMTYuNUMyNi44IDE2LjcgMjYuOCAxNyAyNi42IDE3LjJMMjAuNyAyMy4xQzIwLjUgMjMuMyAyMC4yIDIzLjMgMjAgMjMuMUwxNS45IDE5QzE1LjggMTguOSAxNS43IDE4LjkgMTUuNiAxOUwxMS41IDIzLjFDMTEuMyAyMy4zIDExIDIzLjMgMTAuOCAyMy4xTDQuOSAxNy4yQzQuNyAxNyA0LjcgMTYuNyA0LjkgMTYuNUw2LjIgMTUuMkM2LjQgMTUgNi43IDE1IDYuOSAxNS4yTDExIDE5LjNDMTEuMSAxOS40IDExLjIgMTkuNCAxMS4zIDE5LjNMMTUuNCAxNS4yQzE1LjYgMTUgMTUuOSAxNSAxNi4xIDE1LjJMMjAuMiAxOS4zQzIwLjMgMTkuNCAyMC40IDE5LjQgMjAuNSAxOS4zTDI0LjYgMTUuMkMyNC44IDE1IDI1LjEgMTUgMjUuMyAxNS4yWiIgZmlsbD0id2hpdGUiLz4KPC9zdmc+Cg==", DEFAULT_CHAINS = ["solana:mainnet", "solana:devnet", "solana:testnet"];
+function toCaipChainId(chainId) {
+  return SOLANA_CAIP_CHAINS[chainId] || chainId;
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++)
+    binary += String.fromCharCode(bytes[i]);
+  return btoa(binary);
+}
+function base64ToBytes(base64) {
+  let binary = atob(base64), bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++)
+    bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function isLikelyBase58(str) {
+  return !/[0OIl+/=]/.test(str);
+}
+function decodeTransaction(encoded) {
+  if (isLikelyBase58(encoded)) {
+    let readonlyBytes = codecs.getBase58Encoder().encode(encoded);
+    return new Uint8Array(readonlyBytes);
+  } else
+    return base64ToBytes(encoded);
+}
+function decodeShortVecLength(data) {
+  let length = 0, size = 0;
+  for (; ; ) {
+    if (size >= data.length)
+      throw new Error("Invalid shortvec encoding: unexpected end of data");
+    let byte = data[size];
+    if (length |= (byte & 127) << size * 7, size += 1, (byte & 128) === 0)
+      break;
+    if (size > 10)
+      throw new Error("Invalid shortvec encoding: length prefix too long");
+  }
+  return { length, bytesConsumed: size };
+}
+function findSignerIndex(txBytes, signerPubkeyBase58) {
+  let { length: numSignatures, bytesConsumed: sigCountSize } = decodeShortVecLength(txBytes), messageOffset = sigCountSize + numSignatures * 64, messageBytes = txBytes.subarray(messageOffset), offset = 0;
+  messageBytes[0] === 128 && (offset = 1);
+  let numSignerAccounts = messageBytes[offset];
+  offset += 3;
+  let { length: numStaticAccounts, bytesConsumed } = decodeShortVecLength(messageBytes.subarray(offset));
+  offset += bytesConsumed;
+  let base58Decoder = codecs.getBase58Decoder();
+  for (let i = 0; i < Math.min(numStaticAccounts, numSignerAccounts); i++) {
+    let accountBytes = messageBytes.subarray(offset + i * 32, offset + (i + 1) * 32);
+    if (base58Decoder.decode(accountBytes) === signerPubkeyBase58)
+      return i;
+  }
+  return -1;
+}
+function injectSignature(txBytes, signerIndex, signatureBase58) {
+  let { bytesConsumed: sigCountSize } = decodeShortVecLength(txBytes), signatureBytes = codecs.getBase58Encoder().encode(signatureBase58);
+  if (signatureBytes.length !== 64)
+    throw new Error(`Invalid signature length: expected 64 bytes, got ${signatureBytes.length}`);
+  let result = new Uint8Array(txBytes), signatureOffset = sigCountSize + signerIndex * 64;
+  return result.set(signatureBytes, signatureOffset), result;
+}
+function toWalletAccount(account, chains) {
+  let base58Encoder = codecs.getBase58Encoder();
+  return {
+    address: account.pubkey,
+    publicKey: base58Encoder.encode(account.pubkey),
+    chains,
+    features: []
+  };
+}
+function createWalletConnectWallet(config, transport) {
+  let chains = config.defaultChain ? [config.defaultChain] : DEFAULT_CHAINS;
+  function getCurrentCaipChainId() {
+    let currentChain = config.getCurrentChain?.() || config.defaultChain || "solana:mainnet";
+    return toCaipChainId(currentChain);
+  }
+  let accounts = [], changeListeners = /* @__PURE__ */ new Set();
+  function emitChange() {
+    changeListeners.forEach((fn) => fn({ accounts }));
+  }
+  let wallet = {
+    version: "1.0.0",
+    name: "WalletConnect",
+    icon: WALLETCONNECT_ICON,
+    chains,
+    get accounts() {
+      return accounts;
+    },
+    features: {
+      // Standard connect feature
+      "standard:connect": {
+        version: "1.0.0",
+        connect: async (input) => {
+          await transport.connect();
+          let sessionAccounts = transport.getSessionAccounts();
+          if (sessionAccounts.length > 0)
+            return accounts = sessionAccounts.map((pubkey) => toWalletAccount({ pubkey }, chains)), emitChange(), { accounts };
+          let method = input?.silent ? "solana_getAccounts" : "solana_requestAccounts", result, firstError;
+          try {
+            result = await transport.request({
+              method,
+              params: {},
+              chainId: getCurrentCaipChainId()
+            });
+          } catch (error) {
+            firstError = error;
+            try {
+              let fallbackMethod = method === "solana_getAccounts" ? "solana_requestAccounts" : "solana_getAccounts";
+              result = await transport.request({
+                method: fallbackMethod,
+                params: {},
+                chainId: getCurrentCaipChainId()
+              });
+            } catch (fallbackError) {
+              let firstMessage = firstError instanceof Error ? firstError.message : String(firstError), fallbackMessage = fallbackError instanceof Error ? fallbackError.message : String(fallbackError), details = [firstMessage, fallbackMessage].filter(Boolean).join(" | ");
+              throw new Error(
+                `Failed to get accounts from WalletConnect. The wallet may not support Solana accounts.${details ? ` (Details: ${details})` : ""}`
+              );
+            }
+          }
+          return accounts = Array.isArray(result) ? result.map((acc) => toWalletAccount(acc, chains)) : [], emitChange(), { accounts };
+        }
+      },
+      // Standard disconnect feature
+      "standard:disconnect": {
+        version: "1.0.0",
+        disconnect: async () => {
+          await transport.disconnect(), accounts = [], emitChange();
+        }
+      },
+      // Standard events feature
+      "standard:events": {
+        version: "1.0.0",
+        on: (event, listener) => event !== "change" ? () => {
+        } : (changeListeners.add(listener), () => changeListeners.delete(listener))
+      },
+      // Solana sign message feature
+      "solana:signMessage": {
+        version: "1.0.0",
+        signMessage: async ({ account, message }) => {
+          let messageBase58 = codecs.getBase58Decoder().decode(message), result = await transport.request({
+            method: "solana_signMessage",
+            params: {
+              message: messageBase58,
+              pubkey: account.address
+            },
+            chainId: getCurrentCaipChainId()
+          });
+          return [{ signature: codecs.getBase58Encoder().encode(result.signature), signedMessage: message }];
+        }
+      },
+      // Solana sign transaction feature
+      "solana:signTransaction": {
+        version: "1.0.0",
+        signTransaction: async ({
+          account,
+          transaction
+        }) => {
+          let transactionBase64 = bytesToBase64(transaction), requestChainId = getCurrentCaipChainId(), result = await transport.request({
+            method: "solana_signTransaction",
+            params: {
+              transaction: transactionBase64
+            },
+            chainId: requestChainId
+          }), signedTransaction;
+          if (result.transaction)
+            signedTransaction = decodeTransaction(result.transaction);
+          else if (result.signature) {
+            let signerIndex = findSignerIndex(transaction, account.address);
+            if (signerIndex < 0)
+              throw new Error("Signer pubkey not found in transaction");
+            signedTransaction = injectSignature(transaction, signerIndex, result.signature);
+          } else
+            throw new Error("Invalid solana_signTransaction response: no signature or transaction");
+          return [{ signedTransaction }];
+        }
+      },
+      // Solana sign all transactions feature
+      "solana:signAllTransactions": {
+        version: "1.0.0",
+        signAllTransactions: async ({
+          account,
+          transactions
+        }) => {
+          let transactionsBase64 = transactions.map(bytesToBase64);
+          try {
+            return (await transport.request({
+              method: "solana_signAllTransactions",
+              params: {
+                transactions: transactionsBase64
+              },
+              chainId: getCurrentCaipChainId()
+            })).transactions.map((txEncoded) => ({
+              signedTransaction: decodeTransaction(txEncoded)
+            }));
+          } catch {
+            let signFeature = wallet.features["solana:signTransaction"];
+            return (await Promise.all(
+              transactions.map((tx) => signFeature.signTransaction({ account, transaction: tx }))
+            )).map((r) => ({ signedTransaction: r[0].signedTransaction }));
+          }
+        }
+      },
+      // Solana sign and send transaction feature
+      "solana:signAndSendTransaction": {
+        version: "1.0.0",
+        signAndSendTransaction: async ({
+          transaction,
+          options
+        }) => {
+          let transactionBase64 = bytesToBase64(transaction), result = await transport.request({
+            method: "solana_signAndSendTransaction",
+            params: {
+              transaction: transactionBase64,
+              sendOptions: options ? {
+                skipPreflight: options.skipPreflight,
+                preflightCommitment: options.preflightCommitment,
+                maxRetries: options.maxRetries,
+                minContextSlot: options.minContextSlot
+              } : void 0
+            },
+            chainId: getCurrentCaipChainId()
+          });
+          return [{ signature: codecs.getBase58Encoder().encode(result.signature) }];
+        }
+      }
+    }
+  };
+  return wallet;
+}
+
+// src/lib/wallet/walletconnect/register-walletconnect.ts
+var logger2 = chunk64LV76OK_js.createLogger("WalletConnectRegistration");
+async function registerWalletConnectWallet(config) {
+  if (typeof window > "u")
+    throw new Error("WalletConnect registration can only be done in a browser environment");
+  logger2.debug("Registering WalletConnect wallet", {
+    projectId: config.projectId.substring(0, 8) + "...",
+    defaultChain: config.defaultChain
+  });
+  let transport = await createWalletConnectTransport(config), wallet = createWalletConnectWallet(config, transport), { getWallets } = await import('@wallet-standard/app'), unregister = getWallets().register(wallet);
+  return logger2.info("WalletConnect wallet registered successfully"), {
+    wallet,
+    unregister
+  };
+}
+async function isWalletConnectAvailable() {
+  if (typeof window > "u")
+    return false;
+  try {
+    return await import('@walletconnect/universal-provider'), true;
+  } catch {
+    return false;
+  }
+}
+
+exports.createMockWalletConnectTransport = createMockWalletConnectTransport;
+exports.createWalletConnectTransport = createWalletConnectTransport;
+exports.createWalletConnectWallet = createWalletConnectWallet;
+exports.isWalletConnectAvailable = isWalletConnectAvailable;
+exports.registerWalletConnectWallet = registerWalletConnectWallet;
+//# sourceMappingURL=chunk-4JT24DIX.js.map
+//# sourceMappingURL=chunk-4JT24DIX.js.map