@multiplatform.one/web3 7.17.0 → 7.19.0

package/src/clients/solana.ts

@@ -0,0 +1,465 @@
+import {
+  AccountRole,
+  address,
+  appendTransactionMessageInstruction,
+  compileTransaction,
+  createSolanaRpc,
+  createTransactionMessage,
+  getBase58Decoder,
+  getBase58Encoder,
+  getBase64EncodedWireTransaction,
+  getTransactionDecoder,
+  getTransactionEncoder,
+  pipe,
+  setTransactionMessageFeePayer,
+  setTransactionMessageLifetimeUsingBlockhash,
+  type Address,
+  type Instruction,
+  type Rpc,
+  type Signature,
+  type SolanaRpcApi,
+  type Transaction,
+} from "@solana/kit";
+import type { WalletAdapter } from "../connectkit/adapters/types";
+import type { SolanaChain } from "./solanaMessage";
+import { UnsupportedClientMethodError, type ChainClient, type ClientCapability } from "./types";
+import {
+  getSolanaWallets,
+  SolanaSignAndSendTransaction,
+  SolanaSignMessage,
+  SolanaSignTransaction,
+  StandardConnect,
+  type SolanaSignAndSendTransactionFeature,
+  type SolanaSignMessageFeature,
+  type SolanaSignTransactionFeature,
+  type StandardConnectFeature,
+  type StandardWallet,
+  type StandardWalletAccount,
+} from "./walletStandard";
+
+export type { SolanaChain, SolanaCluster } from "./solanaMessage";
+
+export const solanaRpcUrls: Record<SolanaChain, string> = {
+  "solana:mainnet": "https://api.mainnet-beta.solana.com",
+  "solana:devnet": "https://api.devnet.solana.com",
+  "solana:testnet": "https://api.testnet.solana.com",
+  "solana:localnet": "http://127.0.0.1:8899",
+};
+
+/** Guess the cluster from an RPC URL, so a devnet `solanaRpcUrl` does not ask the wallet to sign for mainnet. */
+export function solanaChainFromRpcUrl(rpcUrl?: string): SolanaChain {
+  if (!rpcUrl) return "solana:mainnet";
+  if (/devnet/i.test(rpcUrl)) return "solana:devnet";
+  if (/testnet/i.test(rpcUrl)) return "solana:testnet";
+  if (/\/\/(localhost|127\.0\.0\.1|10\.0\.2\.2|\[::1\])[:/]/i.test(rpcUrl))
+    return "solana:localnet";
+  return "solana:mainnet";
+}
+
+/**
+ * The byte-level wallet a Solana client drives. Messages and transactions cross
+ * as raw bytes (wire-format transactions), so the same client runs over the
+ * Wallet Standard on web today and a deeplink wallet later.
+ */
+export interface SolanaSigner {
+  readonly address: string;
+  /** Returns the 64-byte ed25519 signature. */
+  signMessage(message: Uint8Array): Promise<Uint8Array>;
+  /** Returns the signed wire transaction. */
+  signTransaction(transaction: Uint8Array): Promise<Uint8Array>;
+  /** Returns the 64-byte transaction signature. Optional: without it the client signs, then sends over its own RPC. */
+  signAndSendTransaction?(transaction: Uint8Array): Promise<Uint8Array>;
+}
+
+export interface SolanaClientConfig {
+  signer: SolanaSigner;
+  /** JSON-RPC endpoint, usually `Web3Config.solanaRpcUrl`. Defaults to the chain's public endpoint. */
+  rpcUrl?: string;
+  /** A ready kit RPC client; wins over `rpcUrl`. */
+  rpc?: Rpc<SolanaRpcApi>;
+  /** Defaults to the cluster `rpcUrl` points at. */
+  chain?: SolanaChain;
+}
+
+/**
+ * A sent transaction. `lastValidBlockHeight` is known when the client saw the
+ * blockhash (transferSol, or a kit transaction carrying its lifetime), and is
+ * what lets confirmTransaction tell "expired, safe to retry" from "still pending".
+ */
+export interface SolanaSubmission {
+  signature: Signature;
+  lastValidBlockHeight?: bigint;
+}
+
+export type SolanaConfirmationFailure = "failed" | "expired" | "timeout";
+
+/**
+ * confirmTransaction's failure. `mayStillLand` is the part a caller acts on:
+ * resending while it is true can pay twice.
+ */
+export class SolanaConfirmationError extends Error {
+  readonly mayStillLand: boolean;
+  constructor(
+    readonly signature: Signature,
+    readonly reason: SolanaConfirmationFailure,
+    detail: string,
+  ) {
+    const mayStillLand = reason === "timeout";
+    super(
+      `solana transaction ${signature} ${detail}; ${
+        mayStillLand
+          ? "it may still land, so do not resend it until its blockhash expires"
+          : "it will not land, so it is safe to retry"
+      }`,
+    );
+    this.name = "SolanaConfirmationError";
+    this.mayStillLand = mayStillLand;
+  }
+}
+
+export interface SolanaConfirmOptions {
+  commitment?: "confirmed" | "finalized";
+  /** Overrides the submission's. With it, failure waits for the blockhash to expire, however long that takes. */
+  lastValidBlockHeight?: bigint;
+  /** Only used without a lastValidBlockHeight; that failure says the transaction may still land. */
+  timeoutMs?: number;
+  pollMs?: number;
+}
+
+export interface SolanaClient extends ChainClient<"solana"> {
+  readonly address: Address;
+  readonly chainId: SolanaChain;
+  readonly rpc: Rpc<SolanaRpcApi>;
+  readonly signer: SolanaSigner;
+  /** Signs the UTF-8 bytes of a string (or raw bytes); returns the base58 signature. */
+  signMessage(message: string | Uint8Array): Promise<string>;
+  signTransaction(transaction: Transaction | Uint8Array): Promise<Transaction>;
+  /** The wallet signs and broadcasts when it can (Phantom asks for this); otherwise sign, then send over `rpc`. */
+  signAndSendTransaction(transaction: Transaction | Uint8Array): Promise<SolanaSubmission>;
+  /** Broadcasts an already signed transaction over `rpc`. */
+  sendTransaction(transaction: Transaction | Uint8Array): Promise<SolanaSubmission>;
+  /**
+   * Resolves once the transaction reaches `commitment`. Rejects with
+   * SolanaConfirmationError: `failed` (it landed and errored), `expired` (block
+   * height passed lastValidBlockHeight without it, safe to retry) or `timeout`
+   * (no lastValidBlockHeight to judge by, so it may still land).
+   */
+  confirmTransaction(
+    submission: SolanaSubmission | Signature,
+    options?: SolanaConfirmOptions,
+  ): Promise<void>;
+  /** Lamports held by `owner`, the connected address by default. */
+  getBalance(owner?: string): Promise<bigint>;
+  /** Builds a System Program transfer, signs and sends it, and returns its lastValidBlockHeight. */
+  transferSol(args: { to: string; lamports: bigint }): Promise<SolanaSubmission>;
+}
+
+const capabilities: readonly ClientCapability[] = [
+  "signMessage",
+  "signTransaction",
+  "signAndSendTransaction",
+  "sendTransaction",
+];
+
+const systemProgram = address("11111111111111111111111111111111");
+const maxU64 = 0xffffffffffffffffn;
+
+/** System Program `Transfer` (instruction index 2, then the lamports as a little-endian u64). */
+export function transferSolInstruction(from: Address, to: Address, lamports: bigint): Instruction {
+  if (lamports < 0n || lamports > maxU64) {
+    throw new RangeError(`lamports must fit a u64, got ${lamports}`);
+  }
+  const data = new Uint8Array(12);
+  data[0] = 2;
+  let value = lamports;
+  for (let i = 4; i < 12; i++) {
+    data[i] = Number(value & 0xffn);
+    value >>= 8n;
+  }
+  return {
+    programAddress: systemProgram,
+    accounts: [
+      { address: from, role: AccountRole.WRITABLE_SIGNER },
+      { address: to, role: AccountRole.WRITABLE },
+    ],
+    data,
+  };
+}
+
+const toWire = (transaction: Transaction | Uint8Array): Uint8Array =>
+  transaction instanceof Uint8Array
+    ? transaction
+    : Uint8Array.from(getTransactionEncoder().encode(transaction));
+
+const fromWire = (bytes: Uint8Array): Transaction => getTransactionDecoder().decode(bytes);
+
+const toSignature = (bytes: Uint8Array): Signature => getBase58Decoder().decode(bytes) as Signature;
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const lastValidBlockHeightOf = (transaction: Transaction | Uint8Array): bigint | undefined => {
+  if (transaction instanceof Uint8Array) return undefined;
+  const lifetime = (transaction as { lifetimeConstraint?: { lastValidBlockHeight?: bigint } })
+    .lifetimeConstraint;
+  return lifetime?.lastValidBlockHeight;
+};
+
+type SignatureStatus = {
+  err: unknown;
+  confirmationStatus: "processed" | "confirmed" | "finalized" | null;
+} | null;
+
+const reached = (status: SignatureStatus, commitment: "confirmed" | "finalized") =>
+  status?.confirmationStatus === "finalized" ||
+  (commitment === "confirmed" && status?.confirmationStatus === "confirmed");
+
+export function solanaClient(config: SolanaClientConfig): SolanaClient {
+  const { signer } = config;
+  const chain = config.chain ?? solanaChainFromRpcUrl(config.rpcUrl);
+  const rpc: Rpc<SolanaRpcApi> =
+    config.rpc ?? (createSolanaRpc(config.rpcUrl ?? solanaRpcUrls[chain]) as Rpc<SolanaRpcApi>);
+  const owner = address(signer.address);
+
+  const signTransaction = async (transaction: Transaction | Uint8Array) =>
+    fromWire(await signer.signTransaction(toWire(transaction)));
+
+  const broadcast = (transaction: Transaction | Uint8Array): Promise<Signature> => {
+    const tx = transaction instanceof Uint8Array ? fromWire(transaction) : transaction;
+    return rpc.sendTransaction(getBase64EncodedWireTransaction(tx), { encoding: "base64" }).send();
+  };
+
+  const sendTransaction = async (
+    transaction: Transaction | Uint8Array,
+  ): Promise<SolanaSubmission> => ({
+    signature: await broadcast(transaction),
+    lastValidBlockHeight: lastValidBlockHeightOf(transaction),
+  });
+
+  const signAndSendTransaction = async (
+    transaction: Transaction | Uint8Array,
+  ): Promise<SolanaSubmission> => {
+    const lastValidBlockHeight = lastValidBlockHeightOf(transaction);
+    const wire = toWire(transaction);
+    if (signer.signAndSendTransaction) {
+      try {
+        const signature = toSignature(await signer.signAndSendTransaction(wire));
+        return { signature, lastValidBlockHeight };
+      } catch (error) {
+        if (!(error instanceof UnsupportedClientMethodError)) throw error;
+      }
+    }
+    return { signature: await broadcast(await signer.signTransaction(wire)), lastValidBlockHeight };
+  };
+
+  const statusOf = async (signature: Signature): Promise<SignatureStatus> => {
+    const { value } = await rpc
+      .getSignatureStatuses([signature], { searchTransactionHistory: true })
+      .send();
+    const status = value[0] as SignatureStatus;
+    if (status?.err) {
+      throw new SolanaConfirmationError(
+        signature,
+        "failed",
+        `failed on chain: ${JSON.stringify(status.err, (_, v) => (typeof v === "bigint" ? `${v}` : v))}`,
+      );
+    }
+    return status;
+  };
+
+  return {
+    family: "solana",
+    address: owner,
+    chainId: chain,
+    capabilities,
+    rpc,
+    signer,
+    async signMessage(message) {
+      const bytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+      return getBase58Decoder().decode(await signer.signMessage(bytes));
+    },
+    signTransaction,
+    signAndSendTransaction,
+    sendTransaction,
+    async confirmTransaction(submission, options = {}) {
+      const { signature, lastValidBlockHeight: submitted } =
+        typeof submission === "string" ? { signature: submission } : submission;
+      const {
+        commitment = "confirmed",
+        lastValidBlockHeight = submitted,
+        timeoutMs = 90_000,
+        pollMs = 500,
+      } = options;
+      const deadline = Date.now() + timeoutMs;
+      for (;;) {
+        if (reached(await statusOf(signature), commitment)) return;
+        if (lastValidBlockHeight !== undefined) {
+          const height = await rpc.getBlockHeight({ commitment }).send();
+          if (height > lastValidBlockHeight) {
+            // It can no longer be included, but it may have been in the last valid block.
+            const status = await statusOf(signature);
+            if (reached(status, commitment)) return;
+            if (!status) {
+              throw new SolanaConfirmationError(
+                signature,
+                "expired",
+                `expired: block height ${height} passed ${lastValidBlockHeight}`,
+              );
+            }
+          }
+        } else if (Date.now() > deadline) {
+          throw new SolanaConfirmationError(
+            signature,
+            "timeout",
+            `not ${commitment} after ${timeoutMs}ms`,
+          );
+        }
+        await sleep(pollMs);
+      }
+    },
+    async getBalance(target) {
+      const { value } = await rpc.getBalance(target ? address(target) : owner).send();
+      return value;
+    },
+    async transferSol({ to, lamports }) {
+      const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+      const message = pipe(
+        createTransactionMessage({ version: 0 }),
+        (m) => setTransactionMessageFeePayer(owner, m),
+        (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),
+        (m) =>
+          appendTransactionMessageInstruction(
+            transferSolInstruction(owner, address(to), lamports),
+            m,
+          ),
+      );
+      const { signature } = await signAndSendTransaction(compileTransaction(message));
+      return { signature, lastValidBlockHeight: latestBlockhash.lastValidBlockHeight };
+    },
+  };
+}
+
+function walletFeature<T>(wallet: StandardWallet, name: string): T {
+  const feature = wallet.features[name] as T | undefined;
+  if (!feature) {
+    throw new UnsupportedClientMethodError("solana", name, `${wallet.name} does not implement it`);
+  }
+  return feature;
+}
+
+/** A SolanaSigner over one Wallet Standard wallet account (Phantom, Solflare, Backpack on web). */
+export function standardSolanaSigner(
+  wallet: StandardWallet,
+  account: StandardWalletAccount,
+  chain: SolanaChain = "solana:mainnet",
+): SolanaSigner {
+  const signer: SolanaSigner = {
+    address: account.address,
+    async signMessage(message) {
+      const feature = walletFeature<SolanaSignMessageFeature>(wallet, SolanaSignMessage);
+      const [output] = await feature.signMessage({ account, message });
+      return output.signature;
+    },
+    async signTransaction(transaction) {
+      const feature = walletFeature<SolanaSignTransactionFeature>(wallet, SolanaSignTransaction);
+      const [output] = await feature.signTransaction({ account, transaction, chain });
+      return output.signedTransaction;
+    },
+  };
+  if (wallet.features[SolanaSignAndSendTransaction]) {
+    signer.signAndSendTransaction = async (transaction) => {
+      const feature = walletFeature<SolanaSignAndSendTransactionFeature>(
+        wallet,
+        SolanaSignAndSendTransaction,
+      );
+      const [output] = await feature.signAndSendTransaction({ account, transaction, chain });
+      return output.signature;
+    };
+  }
+  return signer;
+}
+
+/** The Wallet Standard signer for a wallet that already holds `owner`, or null. */
+export function findSolanaSigner(owner: string, chain?: SolanaChain): SolanaSigner | null {
+  for (const wallet of getSolanaWallets()) {
+    const account = wallet.accounts.find((a) => a.address === owner);
+    if (account) return standardSolanaSigner(wallet, account, chain);
+  }
+  return null;
+}
+
+/**
+ * Connect a Wallet Standard Solana wallet without the modal. `wallet` picks one
+ * by name (case-insensitive); otherwise the first registered one is used.
+ */
+export async function connectSolanaWallet(
+  options: { wallet?: string; chain?: SolanaChain; silent?: boolean } = {},
+): Promise<SolanaSigner> {
+  const wallets = getSolanaWallets();
+  const wallet = options.wallet
+    ? wallets.find((w) => w.name.toLowerCase() === options.wallet?.toLowerCase())
+    : wallets[0];
+  if (!wallet) {
+    throw new Error(
+      options.wallet
+        ? `No Solana wallet named ${options.wallet} is installed`
+        : "No Solana wallet found. Install Phantom, Solflare or Backpack.",
+    );
+  }
+  const { accounts } = await walletFeature<StandardConnectFeature>(wallet, StandardConnect).connect(
+    { silent: options.silent },
+  );
+  const chain = options.chain ?? "solana:mainnet";
+  const account = accounts.find((a) => a.chains.includes(chain)) ?? accounts[0];
+  if (!account) throw new Error(`${wallet.name} returned no Solana account`);
+  return standardSolanaSigner(wallet, account, chain);
+}
+
+const utf8 = (bytes: Uint8Array): string | null => {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * The signer behind a wallet connected through the modal's injected Solana
+ * adapter. Text messages go through the adapter exactly as login always has;
+ * transactions and non-text messages go through the Wallet Standard wallet
+ * holding the same address.
+ */
+export function injectedSolanaSigner(
+  adapter: Pick<WalletAdapter, "address" | "signMessage">,
+  chain?: SolanaChain,
+): SolanaSigner {
+  const owner = adapter.address;
+  if (!owner) throw new Error("injectedSolanaSigner: connect a Solana wallet first");
+  const standard = (method: string): SolanaSigner => {
+    const signer = findSolanaSigner(owner, chain);
+    if (!signer) {
+      throw new UnsupportedClientMethodError(
+        "solana",
+        method,
+        `no Wallet Standard wallet holds ${owner}; connect Phantom, Solflare or Backpack`,
+      );
+    }
+    return signer;
+  };
+  return {
+    address: owner,
+    async signMessage(message) {
+      const text = utf8(message);
+      if (text === null) return standard("signMessage").signMessage(message);
+      return Uint8Array.from(getBase58Encoder().encode(await adapter.signMessage(text)));
+    },
+    signTransaction: async (transaction) =>
+      standard("signTransaction").signTransaction(transaction),
+    async signAndSendTransaction(transaction) {
+      const signer = standard("signAndSendTransaction");
+      if (!signer.signAndSendTransaction) {
+        throw new UnsupportedClientMethodError("solana", "signAndSendTransaction");
+      }
+      return signer.signAndSendTransaction(transaction);
+    },
+  };
+}

package/src/clients/solanaMessage.ts

@@ -0,0 +1,34 @@
+import type { WalletAdapter } from "../connectkit/adapters/types";
+import type { ChainClient, ClientCapability } from "./types";
+
+export type SolanaCluster = "mainnet" | "devnet" | "testnet" | "localnet";
+/** The Wallet Standard chain id a wallet signs for. */
+export type SolanaChain = `solana:${SolanaCluster}`;
+
+/**
+ * A Solana wallet that only signs messages, over the modal's adapter. It needs
+ * no @solana/kit, which is why sign-in uses it: the full client (transactions,
+ * RPC) is `useSolanaClient()` from `@multiplatform.one/web3/solana`.
+ */
+export interface SolanaMessageClient extends ChainClient<"solana"> {
+  readonly address: string;
+  readonly chainId: SolanaChain;
+  /** base58 ed25519 signature over the UTF-8 message. */
+  signMessage(message: string): Promise<string>;
+}
+
+const capabilities: readonly ClientCapability[] = ["signMessage"];
+
+export function solanaMessageClient(
+  adapter: Pick<WalletAdapter, "address" | "signMessage">,
+  chain: SolanaChain = "solana:mainnet",
+): SolanaMessageClient {
+  if (!adapter.address) throw new Error("solanaMessageClient: connect a Solana wallet first");
+  return {
+    family: "solana",
+    address: adapter.address,
+    chainId: chain,
+    capabilities,
+    signMessage: (message) => adapter.signMessage(message),
+  };
+}

package/src/clients/sui.ts

@@ -0,0 +1,42 @@
+import type { WalletAdapter } from "../connectkit/adapters/types";
+import { UnsupportedClientMethodError, type ChainClient, type ClientCapability } from "./types";
+
+type MessageAdapter = Pick<WalletAdapter, "address" | "signMessage">;
+
+const txTodo =
+  "needs @mysten/sui's Transaction plus the wallet's sui:signTransaction / sui:signAndExecuteTransaction features";
+
+/**
+ * Sui client. Message signing only, over the connected Sui adapter. The
+ * transaction methods are the shape the transaction work will fill in; until
+ * then they reject with UnsupportedClientMethodError.
+ */
+export interface SuiClient extends ChainClient<"sui"> {
+  readonly address: string;
+  readonly chainId: "sui:mainnet";
+  /** Sui's serialized signature (flag || signature || public key), base64. */
+  signMessage(message: string): Promise<string>;
+  /** Not implemented yet: will take a built transaction and return `{ bytes, signature }`. */
+  signTransaction(transaction: unknown): Promise<never>;
+  /** Not implemented yet: will return the executed transaction digest. */
+  signAndExecuteTransaction(transaction: unknown): Promise<never>;
+}
+
+const capabilities: readonly ClientCapability[] = ["signMessage"];
+
+export function suiClient(adapter: MessageAdapter): SuiClient {
+  if (!adapter.address) throw new Error("suiClient: connect a Sui wallet first");
+  return {
+    family: "sui",
+    address: adapter.address,
+    chainId: "sui:mainnet",
+    capabilities,
+    signMessage: (message) => adapter.signMessage(message),
+    signTransaction: async () => {
+      throw new UnsupportedClientMethodError("sui", "signTransaction", txTodo);
+    },
+    signAndExecuteTransaction: async () => {
+      throw new UnsupportedClientMethodError("sui", "signAndExecuteTransaction", txTodo);
+    },
+  };
+}

package/src/clients/types.ts

@@ -0,0 +1,40 @@
+import type { Ecosystem } from "@multiplatform.one/connectkit";
+
+/** Who signs: the four wallet ecosystems, plus a GPG key. */
+export type ClientFamily = Ecosystem | "gpg";
+
+export type ClientCapability =
+  | "signMessage"
+  | "signTransaction"
+  | "sendTransaction"
+  | "signAndSendTransaction"
+  | "writeContract";
+
+/**
+ * The shape every per-chain client shares. `signMessage` returns the family's
+ * native signature encoding, which is what the Keycloak verifiers take as the
+ * login `username`: EVM 0x hex, Solana base58, Sui base64 serialized signature,
+ * Bitcoin base64 BIP-322, GPG the armored signature followed by the armored
+ * public key.
+ */
+export interface ChainClient<F extends ClientFamily = ClientFamily> {
+  readonly family: F;
+  /** Chain-native address. Null for GPG, whose identity arrives with the signature. */
+  readonly address: string | null;
+  /** EVM numeric chain id, or a CAIP-2 style id (`solana:mainnet`, `sui:mainnet`, `bitcoin`). */
+  readonly chainId?: number | string;
+  readonly capabilities: readonly ClientCapability[];
+  signMessage(message: string): Promise<string>;
+}
+
+/** A client method the family does not implement yet. */
+export class UnsupportedClientMethodError extends Error {
+  constructor(
+    readonly family: ClientFamily,
+    readonly method: string,
+    detail?: string,
+  ) {
+    super(`${family} client: ${method} is not supported${detail ? ` (${detail})` : ""}`);
+    this.name = "UnsupportedClientMethodError";
+  }
+}

package/src/clients/useSolanaClient.ts

@@ -0,0 +1,31 @@
+import { useContext, useMemo } from "react";
+import { useAccount } from "wagmi";
+import { Web3ConfigContext } from "../providers/walletConfig";
+import { connectorAdapter } from "./adapter";
+import {
+  injectedSolanaSigner,
+  solanaChainFromRpcUrl,
+  solanaClient,
+  type SolanaChain,
+  type SolanaClient,
+} from "./solana";
+
+/**
+ * The connected Solana wallet as an mpo Solana client: message signing through
+ * the modal's adapter, transactions through the Wallet Standard wallet holding
+ * the same address, reads and sends over `Web3Config.solanaRpcUrl`.
+ */
+export function useSolanaClient(
+  options: { rpcUrl?: string; chain?: SolanaChain } = {},
+): SolanaClient | undefined {
+  const { connector, address } = useAccount();
+  const config = useContext(Web3ConfigContext);
+  const rpcUrl = options.rpcUrl ?? config?.solanaRpcUrl;
+  const chain = options.chain ?? solanaChainFromRpcUrl(rpcUrl);
+  return useMemo(() => {
+    const adapter = connectorAdapter(connector, "solana");
+    if (!adapter?.address) return undefined;
+    return solanaClient({ signer: injectedSolanaSigner(adapter, chain), rpcUrl, chain });
+    // address is a dependency so an account switch inside one connector rebuilds the client
+  }, [connector, address, rpcUrl, chain]);
+}