anza-xyz/wallet-adapter

const [publicKey, setPublicKey] = useState(() => adapter?.publicKey ?? null);
const [connected, setConnected] = useState(() => adapter?.connected ?? false);

connected and publicKey are read from the adapter only once, at mount. When the selected adapter changes, the listener effect (lines 122-160) resets them to disconnected and never reads the new adapter's real state. WalletProvider deliberately does not disconnect the mobile wallet adapter when the user switches to another wallet (lines 87-96). If the user then switches back, the context reports connected = false while adapter.connected is true. handleConnect returns early at line 255 (wallet?.adapter.connected), so the Connect button does nothing, and every sign call throws "not connected". The user is stuck until the page is reloaded.

At the start of the adapter effect, set the state from the adapter: setPublicKey(adapter.publicKey); setConnected(adapter.connected);. Do not let the cleanup's forced reset override that state.

publicKey = await getPublicKey(transport, this._derivationPath);
} catch (error: any) {
    throw new WalletPublicKeyError(error?.message, error);

The HID transport opened at line 81 is neither saved nor closed when reading the public key fails. A very common cause is the Solana app not being open on the device. disconnect() cannot reach the transport, and the device stays claimed by the page, so the user's retry can fail until they reload. Trezor (packages/wallets/trezor/src/adapter.ts:96-122) has the same problem: wallet.init() succeeds, but dispose() is never called when solanaGetPublicKey fails, so a retry can trip over the already-initialised connector.

In the failure paths, release the handle before rethrowing: await transport.close().catch(() => {}) for Ledger and await wallet.dispose() for Trezor. A try/finally that releases the handle unless connect succeeded also works.

await connection.confirmTransaction({ blockhash, lastValidBlockHeight, signature });
notify('success', 'Transaction successful!', signature);

confirmTransaction does not throw when a transaction lands but fails. It resolves with value.err set. The example ignores the result, so a failed transaction is shown as a success. The example exists to be copied, and integrators who copy it will show users false confirmations of payments or actions. The same pattern is in SendLegacyTransaction.tsx, SendV0Transaction.tsx and RequestAirdrop.tsx.

Keep the result: const { value } = await connection.confirmTransaction(...). If value.err is set, throw, or show an error, before announcing success.

return (await wallet.signTransaction(transaction)) || transaction;

If the wallet resolves with no value, the caller gets back the transaction it passed in, which may be unsigned. The failure then shows up much later as a confusing RPC signature error instead of a sign error. This fallback exists for wallets that sign in place, but it does not check that a signature was actually added. The same fallback is in about 25 adapters, including signAllTransactions (for example solflare, coinbase, torus, trust, mathwallet).

If the wallet returns nothing, check that the expected signer's signature is present on the input, and throw WalletSignTransactionError if it is not. Put this check in one shared helper in the base package.

const interval =
    // TODO: #334 Replace with idle callback strategy.
    setInterval(detectAndDispose, 1000);

scopePollingDetectionStrategy stops the timer only when the wallet is detected, and it returns no handle. For each wallet the user does not have, the interval runs for the life of the page and keeps the adapter instance alive. An app that lists many adapters runs that many timers. An app that builds adapters more than once, for example per render or when a memo recomputes, leaks one more timer per adapter each time.

Return a dispose function and expose it, for example as destroy(), on adapters. Cap the polling with a timeout or backoff, or implement the idle-callback strategy the TODO mentions. Where wallets support wallet-standard registration events, use those instead.

wallet.off('disconnect', this._disconnected);

connect() attaches both disconnect and accountChanged (lines 148-149), and creates a new SDK instance each time. disconnect() removes both listeners (lines 166-167), but _disconnected removes only the first. After the wallet disconnects on its own and the user reconnects, the orphaned old instance can still fire accountChanged. That overwrites _publicKey and emits connect with a key that does not belong to the current session, so the app shows one account while signing with another.

Add wallet.off('accountChanged', this._accountChanged); to _disconnected, as the Phantom adapter does.

if (!getIsMobile(adaptersWithStandardAdapters)) {

getIsMobile reads each adapter's readyState, which changes later through detection. The memo at line 72 and the effect at line 146 depend only on the adapter array, so a readiness change after the first render does not re-evaluate the environment. Today this is mostly hidden: in-app browsers are WebViews, and those are treated as desktop anyway. It becomes a real defect as soon as detection timing changes.

Derive the environment from the wallets state, which tracks readyState, or include the readiness values in the dependency list.

isConnectingRef.current = false;
setConnecting(false);

The ref and the state are written together at six places (lines 127, 139, 181, 191, 260, 268), sometimes in opposite order, and isDisconnectingRef/setDisconnecting follow the same pattern. A future edit that updates one copy and misses the other will produce a provider that refuses to connect or shows a spinner forever.

Add one small setter, for example setConnectingState(value), that updates both copies, and use it at every site. Do the same for disconnecting.

const state = useState<T>(() => {

The state is read from storage only once. If the localStorageKey prop changes, the effect at line 52 writes the previous key's in-memory value under the new key and overwrites whatever was stored there.

Re-read storage when key changes, for example by tracking the last key in a ref and reinitialising. Alternatively, document that the key must not change, or key the provider so it remounts.

if (this.connected || this.connecting) return;

A caller that awaits connect() during an in-flight connect continues immediately, while publicKey is still null. The same early return is in about 34 adapters, and in the provider (packages/core/react/src/WalletProviderBase.tsx:255 for connect, :274 for disconnect).

Keep the pending promise, for example this._connectPromise ??= this._doConnect().finally(() => (this._connectPromise = undefined)), and return it to concurrent callers. This is best done once in the base adapter, with the same approach in the provider.

signature = await sendTransaction(transaction, connection, { minContextSlot });

The buttons are disabled only when no wallet is connected. A double click starts two send or sign requests, which can produce two transactions. The same pattern is in SendLegacyTransaction, SendV0Transaction, SignTransaction and RequestAirdrop.

Track a busy flag, return early or disable the button while a request is pending, and clear the flag in finally.

if (wallet) {
    ...
    this.emit('disconnect');

Every adapter re-implements the same connect, disconnect and sign wrappers: the error mapping, the emit-then-rethrow, the _connecting flag in finally, and listener wiring. The copies are no longer identical. Huobi, Trezor, TokenPocket and HyperPay emit disconnect only when a wallet is held, while Phantom, Ledger, Torus and Sky always emit it. Findings 2, 7 and 13 are all examples of a fix that has to be repeated in dozens of places.

Move the shared lifecycle into protected helpers or a template method on the base adapter, so each adapter supplies only its wallet-specific calls.

<h1 className="wallet-adapter-modal-title">Connect a wallet on Solana to continue</h1>

Apps cannot localise or reword the modal. The sibling BaseWalletMultiButton already accepts a labels prop, so the UI package handles text in two inconsistent ways.

Add a labels prop to WalletModal (title, "More/Less options", "Already have a wallet?") and use the current English text as the defaults.

if (typeof window !== 'undefined' && window.Buffer === undefined) {
    (window as any).Buffer = Buffer;
}

Identical polyfills/Buffer.ts and polyfills/index.ts files are in coin98, keystone, ledger and trezor. Any change to the guard must be made four times, and the copies can drift.

Keep the polyfill once, in the base package or a small shared module, and import it from the four adapters.

if (data && data.origin === 'mathwallet_internal' && data.type === 'lockStatusChanged' && !data.payload) {
    this._disconnected();

The handler checks only fields inside the message body, which any sender controls. It does not check event.source or event.origin. Any embedded cross-origin frame, such as an ad or a third-party widget, can post this object to the parent window and force the user's wallet session to disconnect at will.

Before acting, require event.source === window and event.origin === window.location.origin.

return keyring.signMessage(publicKey, message);

Without await, a rejected signing promise skips both catch blocks. The caller gets the raw, unwrapped error, and the adapter never emits error, so the provider's onError handler is never called. The catch at line 142 also uses the wrong error class (WalletSignTransactionError).

Use return await keyring.signMessage(publicKey, message);, and throw WalletSignMessageError in the catch.

config = { commitment: 'confirmed' },
}) => {
    const connection = useMemo(() => new Connection(endpoint, config), [endpoint, config]);

When config is omitted, which is the common case, the default object is new on each render, so the memo never hits. Every re-render of the provider's parent builds a new Connection and a new context value. All consumers that depend on connection re-render and re-run their effects: they refetch and re-subscribe.

Hoist the default into a module constant (const DEFAULT_CONFIG: ConnectionConfig = { commitment: 'confirmed' }) and memoise the context value.

const input: SolanaSignInInput = {
    domain: window.location.host,

The example builds the sign-in input in the browser and verifies it in the browser, with no server-issued nonce, issuedAt or expiration. Developers who copy it get a sign-in whose signed message can be replayed. SignMessage.tsx uses a static message in the same way.

Have the server issue the input, with a nonce and an expiry. Verify the signature on the server and consume the nonce. At minimum, add a comment in the example saying this is a client-only demo.

await wallet.connect();
} catch (error: any) {
    throw new WalletConnectionError(error?.message, error);

Browser wallets refuse to connect, or fail silently, on non-localhost http: origins. The adapter forwards whatever opaque error the wallet raises, or none at all, so developers lose time diagnosing it. A search of all adapter sources for isSecureContext, location.protocol and http:// found no origin check.

Before calling wallet.connect(), check window.isSecureContext, or the protocol and host. If the origin is not secure, throw a WalletConnectionError that says an HTTPS origin is required.

if (value) return JSON.parse(value) as T;

The default keys walletName (WalletProvider.tsx:48) and autoConnect (example AutoConnectProvider.tsx:17) have no namespace. Any other script on the same origin can write them, and the parsed value is cast without a type check. A foreign value in walletName silently picks no wallet, or the wrong one.

Namespace the default keys, for example solana-wallet-adapter:walletName. Check the parsed type (a string or null for the wallet name, a boolean for auto-connect) and fall back to the default if it does not match.

console.error(constructMissingProviderErrorMessage('call', 'setVisible'));

useWallet.ts and useWalletModal.tsx each build their own message for this case. With only two copies this is acceptable. It becomes worth sharing if a third context needs the same message.

Nothing is needed now. If the pattern recurs, extract a shared helper.