From 83eb5bc20cb1abd079493b94bceea16837b94688 Mon Sep 17 00:00:00 2001
From: sirpy <hadar@gooddollar.org>
Date: Thu, 8 Oct 2026 16:30:58 +0300
Subject: [PATCH 1/2] feat: add Reown existing wallet login

---
 .env.example                                  |   1 +
 config.ts                                     |   3 +
 package.json                                  |   2 +
 src/login/context/SessionContext/storage.ts   |  23 +++
 src/login/hooks/login.ts                      |   4 +
 src/login/reown.ts                            | 160 ++++++++++++++++++
 src/login/types.ts                            |   7 +-
 .../GoodDollar/components/Claim/ClaimView.tsx |   6 +-
 src/sections/Login/components/Goodwallet.tsx  |  14 +-
 src/sections/Login/components/LoginButton.tsx |  20 +++
 src/sections/Login/useDefaultLoginMethod.ts   |   6 +
 src/translations/translations/da.ts           |   1 +
 src/translations/translations/en.ts           |   1 +
 src/translations/types.ts                     |   1 +
 yarn.lock                                     |  22 +++
 15 files changed, 265 insertions(+), 6 deletions(-)
 create mode 100644 src/login/reown.ts

diff --git a/.env.example b/.env.example
index 64a1486..9f80935 100644
--- a/.env.example
+++ b/.env.example
@@ -67,6 +67,7 @@ NEXT_PUBLIC_GOODDOLLAR_FEED_URL=https://feed-dev.gooddollar.org/api/ceramic-feed
 NEXT_PUBLIC_LOGIN_PWLESS_ENABLED=true
 NEXT_PUBLIC_LOGIN_GOOGLE_ENABLED=true
 NEXT_PUBLIC_LOGIN_FACEBOOK_ENABLED=false
+NEXT_PUBLIC_LOGIN_EXISTING_WALLET_ENABLED=true
 
 # Test login (dev only — never enable in production).
 NEXT_PUBLIC_TEST_LOGIN_ENABLED=false
diff --git a/config.ts b/config.ts
index 07f586c..a4fd6df 100644
--- a/config.ts
+++ b/config.ts
@@ -54,6 +54,7 @@ type EnabledLoginOptions = {
   google: boolean
   facebook: boolean
   pwless: boolean
+  existingWallet: boolean
   testLogin: {
     enabled: boolean
     masterSeed: string
@@ -66,6 +67,8 @@ const enabledLoginOptions: EnabledLoginOptions = {
   google: process.env.NEXT_PUBLIC_LOGIN_GOOGLE_ENABLED === "true",
   facebook: process.env.NEXT_PUBLIC_LOGIN_FACEBOOK_ENABLED === "true",
   pwless: process.env.NEXT_PUBLIC_LOGIN_PWLESS_ENABLED === "true",
+  existingWallet:
+    process.env.NEXT_PUBLIC_LOGIN_EXISTING_WALLET_ENABLED === "true",
   testLogin: {
     masterSeed: process.env.NEXT_PUBLIC_TEST_LOGIN_MASTER_SEED as string,
     userName: process.env.NEXT_PUBLIC_TEST_LOGIN_USER_NAME as string,
diff --git a/package.json b/package.json
index 22ac58a..33f1951 100644
--- a/package.json
+++ b/package.json
@@ -39,6 +39,8 @@
     "@lottiefiles/react-lottie-player": "^3.6.0",
     "@neondatabase/serverless": "^1.1.0",
     "@react-hookz/web": "^25.2.0",
+    "@reown/appkit": "1.8.23",
+    "@reown/appkit-adapter-ethers": "1.8.23",
     "@reown/walletkit": "^1.5.6",
     "@sentry/nextjs": "^10.56.0",
     "@solana-name-service/sns-sdk-kit": "^0.10.0",
diff --git a/src/login/context/SessionContext/storage.ts b/src/login/context/SessionContext/storage.ts
index 9a0db9e..e753390 100644
--- a/src/login/context/SessionContext/storage.ts
+++ b/src/login/context/SessionContext/storage.ts
@@ -2,6 +2,7 @@ import type { Jsonify } from "type-fest"
 import { proxy, ref } from "valtio"
 
 import { getPrivateKeySession } from "@/login/adapters/privatekey"
+import { disconnectReown, getReownSession } from "@/login/reown"
 import type { Addresses, ISigner, ISignerSession } from "@/login/types"
 import { resetWalletConnectDialogs } from "@/sections/WalletConnect/store/walletConnectDialogStore"
 
@@ -37,6 +38,21 @@ const fromJSON = async (
         profileImage,
       )
     }
+    case "REOWN": {
+      const { authProvider, address } = sessionJSON
+      if (!address) {
+        return null
+      }
+
+      return await getReownSession(
+        "localStorage",
+        authProvider ?? "existing_wallet",
+        {
+          interactive: false,
+          expectedAddress: address,
+        },
+      )
+    }
   }
   return null
 }
@@ -79,7 +95,14 @@ export const setSession = (session: ISignerSession | null) => {
 
 export const logout = () => {
   resetWalletConnectDialogs()
+  const previousSession = sessionState.session
   setSession(null)
+
+  if (previousSession?.type === "REOWN") {
+    disconnectReown().catch((error) => {
+      console.error("Failed to disconnect Reown session", error)
+    })
+  }
 }
 
 if (typeof window !== "undefined") {
diff --git a/src/login/hooks/login.ts b/src/login/hooks/login.ts
index d6f453d..60bdbd3 100644
--- a/src/login/hooks/login.ts
+++ b/src/login/hooks/login.ts
@@ -5,6 +5,7 @@ import type {
 } from "@toruslabs/customauth"
 
 import { getPrivateKeySession } from "../adapters/privatekey"
+import { getReownSession } from "../reown"
 import {
   getTorusSession,
   type TorusNetwork,
@@ -54,6 +55,9 @@ export const useTorusLogin = (
   web3authClientId: string,
 ) => useLogin(async () => getTorusSession(network, web3authClientId))
 
+export const useReownLogin = () =>
+  useLogin(async () => getReownSession("direct", "existing_wallet"))
+
 const useLogin = (
   connectSession: () => Promise<ISignerSession>,
 ): (() => Promise<void>) => {
diff --git a/src/login/reown.ts b/src/login/reown.ts
new file mode 100644
index 0000000..1bd30b2
--- /dev/null
+++ b/src/login/reown.ts
@@ -0,0 +1,160 @@
+import { createAppKit } from "@reown/appkit"
+import { base, celo, fuse, mainnet, xdc } from "@reown/appkit/networks"
+import { EthersAdapter } from "@reown/appkit-adapter-ethers"
+import { BrowserProvider, type Eip1193Provider } from "ethers"
+
+import manifest from "@/app/manifest"
+import { config } from "@/config"
+
+import type { ISigner, ISignerSession } from "./types"
+
+type GetReownSessionOptions = {
+  interactive?: boolean
+  expectedAddress?: string
+}
+
+let appKitInstance: ReturnType<typeof createAppKit> | undefined
+
+const getMetadata = () => {
+  const { name, description, icons } = manifest()
+  const url =
+    typeof window !== "undefined" ? window.location.origin : "http://localhost"
+
+  return {
+    name: name ?? "GoodWallet",
+    description:
+      description ?? "Claim UBI and exchange cryptocurrencies with GoodWallet",
+    url,
+    icons: (icons ?? []).map((icon) => `${url}${icon.src}`),
+  }
+}
+
+const getAppKit = async () => {
+  if (typeof window === "undefined") {
+    throw new Error("Reown login is only available in browser")
+  }
+
+  if (!config.walletConnectEnabled) {
+    throw new Error("WalletConnect is not configured")
+  }
+
+  if (!appKitInstance) {
+    appKitInstance = createAppKit({
+      adapters: [new EthersAdapter()],
+      projectId: config.walletConnectProjectId,
+      metadata: getMetadata(),
+      networks: [celo, fuse, mainnet, base, xdc],
+      defaultNetwork: celo,
+    })
+  }
+
+  await appKitInstance.ready()
+  return appKitInstance
+}
+
+const waitForConnectedAddress = async (
+  appKit: ReturnType<typeof createAppKit>,
+  timeoutMs = 120000,
+): Promise<string | null> => {
+  const currentAddress = appKit.getAddress("eip155")
+  if (currentAddress) {
+    return currentAddress
+  }
+
+  return await new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      unsubscribe()
+      resolve(null)
+    }, timeoutMs)
+
+    const unsubscribe = appKit.subscribeAccount((state) => {
+      if (state.isConnected && state.address) {
+        clearTimeout(timeout)
+        unsubscribe()
+        resolve(state.address)
+      }
+    }, "eip155")
+  })
+}
+
+const connectAddress = async (
+  appKit: ReturnType<typeof createAppKit>,
+  interactive: boolean,
+) => {
+  const connectedAddress = await waitForConnectedAddress(
+    appKit,
+    interactive ? 1000 : 15000,
+  )
+  if (connectedAddress) {
+    return connectedAddress
+  }
+
+  if (!interactive) {
+    return null
+  }
+
+  const connected = waitForConnectedAddress(appKit)
+  await appKit.open({ view: "Connect", namespace: "eip155" })
+  return await connected
+}
+
+export const getReownSession = async (
+  sessionOrigin: string,
+  authProvider: string,
+  options: GetReownSessionOptions = {},
+): Promise<ISignerSession> => {
+  const { interactive = true, expectedAddress } = options
+  const appKit = await getAppKit()
+  const connectedAddress = await connectAddress(appKit, interactive)
+
+  if (!connectedAddress) {
+    throw new Error("Wallet connection was not completed")
+  }
+
+  if (
+    expectedAddress &&
+    connectedAddress.toLowerCase() !== expectedAddress.toLowerCase()
+  ) {
+    throw new Error("Connected wallet does not match the previous session")
+  }
+
+  const walletProvider = appKit.getProvider<Eip1193Provider>("eip155")
+  if (!walletProvider) {
+    throw new Error("Connected provider not available")
+  }
+
+  const provider = new BrowserProvider(walletProvider)
+  const signer = await provider.getSigner(connectedAddress)
+
+  const session: ISignerSession = {
+    type: "REOWN",
+    sessionOrigin,
+    authProvider,
+    address: connectedAddress,
+    userName: connectedAddress,
+    signer: {
+      EVM: {
+        address: connectedAddress,
+        signMessage: (message: Parameters<typeof signer.signMessage>[0]) =>
+          signer.signMessage(message),
+        signTransaction: (tx: Parameters<typeof signer.signTransaction>[0]) =>
+          signer.signTransaction(tx),
+        signTypedData: (
+          domain: Parameters<typeof signer.signTypedData>[0],
+          types: Parameters<typeof signer.signTypedData>[1],
+          value: Parameters<typeof signer.signTypedData>[2],
+        ) => signer.signTypedData(domain, types, value),
+      },
+    } as unknown as ISigner,
+  }
+
+  return session
+}
+
+export const disconnectReown = async (): Promise<void> => {
+  if (!appKitInstance) {
+    return
+  }
+
+  await appKitInstance.disconnect("eip155")
+}
diff --git a/src/login/types.ts b/src/login/types.ts
index aec5ea2..f6eb438 100644
--- a/src/login/types.ts
+++ b/src/login/types.ts
@@ -61,7 +61,7 @@ export type ISignerSession = {
   authProvider?: string
   userName?: string
   profileImage?: string
-} & (IBrowserSession | IPrivateKeySession)
+} & (IBrowserSession | IPrivateKeySession | IReownSession)
 
 type IBrowserSession = {
   type: "BROWSER"
@@ -71,3 +71,8 @@ type IPrivateKeySession = {
   type: "PRIVATE_KEY"
   masterSeed: string
 }
+
+type IReownSession = {
+  type: "REOWN"
+  address: string
+}
diff --git a/src/sections/GoodDollar/components/Claim/ClaimView.tsx b/src/sections/GoodDollar/components/Claim/ClaimView.tsx
index c38d9ec..b8e6472 100644
--- a/src/sections/GoodDollar/components/Claim/ClaimView.tsx
+++ b/src/sections/GoodDollar/components/Claim/ClaimView.tsx
@@ -552,12 +552,10 @@ function ClaimViewContent() {
           if (!signer) {
             throw new Error("No signer provided")
           }
-          if (!userName) {
-            throw new Error("No userName provided")
-          }
+
           const link = await generateGoodIDLink(
             signer.EVM,
-            userName,
+            userName ?? "",
             invitedChainId,
           )
           window.open(link, "_self")
diff --git a/src/sections/Login/components/Goodwallet.tsx b/src/sections/Login/components/Goodwallet.tsx
index 7ff121b..bdb3ed8 100644
--- a/src/sections/Login/components/Goodwallet.tsx
+++ b/src/sections/Login/components/Goodwallet.tsx
@@ -12,6 +12,7 @@ import { postMessageToReactNative } from "@/utils/messageReactNative"
 
 import { useDefaultLoginMethod } from "../useDefaultLoginMethod"
 import {
+  ExistingWalletLoginButton,
   FacebookLoginButton,
   GoogleLoginButton,
   PrivateKeyLoginButton,
@@ -29,11 +30,14 @@ export default function LoginDefault() {
   const loginTranslations = translations.login
 
   const btns = useMemo(() => {
-    const { google, facebook, pwless, testLogin } = config.enabledLoginOptions
+    const { google, facebook, pwless, existingWallet, testLogin } =
+      config.enabledLoginOptions
 
     const isFacebookDefault = defaultLoginMethod.value === "facebook"
     const isGoogleDefault = defaultLoginMethod.value === "google"
     const isPwlessDefault = defaultLoginMethod.value === "pwless"
+    const isExistingWalletDefault =
+      defaultLoginMethod.value === "existingwallet"
     const isTestLoginDefault = defaultLoginMethod.value === "testlogin"
 
     return [
@@ -55,6 +59,14 @@ export default function LoginDefault() {
         isDefault: isPwlessDefault,
         isEnabled: pwless,
       },
+      {
+        method: "existingWallet",
+        element: (
+          <ExistingWalletLoginButton isDefault={isExistingWalletDefault} />
+        ),
+        isDefault: isExistingWalletDefault,
+        isEnabled: existingWallet,
+      },
       {
         method: "testLogin",
         element: (
diff --git a/src/sections/Login/components/LoginButton.tsx b/src/sections/Login/components/LoginButton.tsx
index 4204ae6..20343ea 100644
--- a/src/sections/Login/components/LoginButton.tsx
+++ b/src/sections/Login/components/LoginButton.tsx
@@ -8,6 +8,7 @@ import { config } from "@/config"
 import {
   Captcha,
   usePKeyLogin,
+  useReownLogin,
   useTriggerTorusAggregateLogin,
   useTriggerTorusLogin,
 } from "@/login"
@@ -116,3 +117,22 @@ export const PrivateKeyLoginButton: FC<{
     />
   )
 }
+
+export const ExistingWalletLoginButton: FC<{ isDefault?: boolean }> = ({
+  isDefault,
+}) => {
+  const { locale, translations } = useTranslation()
+  const onClick = useReownLogin()
+
+  return (
+    <Button
+      variant={isDefault ? "solid" : "outlined"}
+      full
+      text={translations.login.existingWallet}
+      onClick={() => {
+        saveLocaleToSession(locale)
+        onClick()
+      }}
+    />
+  )
+}
diff --git a/src/sections/Login/useDefaultLoginMethod.ts b/src/sections/Login/useDefaultLoginMethod.ts
index de8781e..6dc97c0 100644
--- a/src/sections/Login/useDefaultLoginMethod.ts
+++ b/src/sections/Login/useDefaultLoginMethod.ts
@@ -30,6 +30,12 @@ export const useDefaultLoginMethod = () => {
     if (transformedValue === "master_seed") {
       transformedValue = "testlogin"
     }
+    if (
+      transformedValue === "existing_wallet" ||
+      transformedValue === "existing-wallet"
+    ) {
+      transformedValue = "existingwallet"
+    }
     if (transformedValue && acceptableLoginMethods.includes(transformedValue)) {
       defaultLoginMethod.set(transformedValue)
     }
diff --git a/src/translations/translations/da.ts b/src/translations/translations/da.ts
index 281586c..56d1d85 100644
--- a/src/translations/translations/da.ts
+++ b/src/translations/translations/da.ts
@@ -32,6 +32,7 @@ const da: TypedTranslations = {
     google: "Fortsæt ved Google",
     facebook: "Fortsæt ved Facebook",
     pwdless: "Fortsæt via SMS-kode",
+    existingWallet: "Connect Wallet",
     legalText: {
       preText: "Ved at logge ind og fortsætte, accepterer du vores",
       terms: "Vilkår for brug",
diff --git a/src/translations/translations/en.ts b/src/translations/translations/en.ts
index 42bc059..afadba9 100644
--- a/src/translations/translations/en.ts
+++ b/src/translations/translations/en.ts
@@ -33,6 +33,7 @@ const en: TypedTranslations = {
     google: "Continue with Google",
     facebook: "Continue with Facebook",
     pwdless: "Continue via SMS code",
+    existingWallet: "Connect Wallet",
     legalText: {
       preText: "By signing in and entering, you're accepting our",
       terms: "Terms of use",
diff --git a/src/translations/types.ts b/src/translations/types.ts
index e14760b..0b4b577 100644
--- a/src/translations/types.ts
+++ b/src/translations/types.ts
@@ -6,6 +6,7 @@ export type LoginTranslations = {
   google: string
   facebook: string
   pwdless: string
+  existingWallet: string
   legalText: {
     preText: string
     terms: string
diff --git a/yarn.lock b/yarn.lock
index 3ca3fe7..83debba 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2056,6 +2056,26 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@reown/appkit-adapter-ethers@npm:1.8.23":
+  version: 1.8.23
+  resolution: "@reown/appkit-adapter-ethers@npm:1.8.23"
+  dependencies:
+    "@reown/appkit": "npm:1.8.23"
+    "@reown/appkit-common": "npm:1.8.23"
+    "@reown/appkit-controllers": "npm:1.8.23"
+    "@reown/appkit-polyfills": "npm:1.8.23"
+    "@reown/appkit-scaffold-ui": "npm:1.8.23"
+    "@reown/appkit-utils": "npm:1.8.23"
+    "@reown/appkit-wallet": "npm:1.8.23"
+    "@walletconnect/universal-provider": "npm:2.23.7"
+    valtio: "npm:2.1.7"
+  peerDependencies:
+    "@ethersproject/sha2": 5.8.0
+    ethers: ">=6"
+  checksum: 10c0/91846406c98fec02d68796df650f8929635032b6197b1a7fbdf1fb58519fc225e33de134b4d8f1f37405ab20c9da8c227ebe77de684a88f088cb16ad1887ddd6
+  languageName: node
+  linkType: hard
+
 "@reown/appkit-adapter-wagmi@npm:^1.8.22":
   version: 1.8.23
   resolution: "@reown/appkit-adapter-wagmi@npm:1.8.23"
@@ -10062,6 +10082,8 @@ __metadata:
     "@neondatabase/serverless": "npm:^1.1.0"
     "@playwright/test": "npm:1.61.1"
     "@react-hookz/web": "npm:^25.2.0"
+    "@reown/appkit": "npm:1.8.23"
+    "@reown/appkit-adapter-ethers": "npm:1.8.23"
     "@reown/walletkit": "npm:^1.5.6"
     "@sentry/nextjs": "npm:^10.56.0"
     "@solana-name-service/sns-sdk-kit": "npm:^0.10.0"

From 1fee3b6fe0a43ad6d48bbcabe3bf8f10a2d4f56b Mon Sep 17 00:00:00 2001
From: sirpy <hadar@gooddollar.org>
Date: Sun, 11 Oct 2026 12:37:29 +0300
Subject: [PATCH 2/2] fix: Reown wallet follow-ups - EVM-only UI,
 wallet-submitted txs, session lifecycle (not reviewed)

---
 src/chain/chains.ts                           |  15 +
 src/ethers-utils/utils.test.ts                |  87 +++++
 src/ethers-utils/utils.ts                     |  60 ++++
 src/hooks/useTokenBalances/index.ts           |  20 +-
 .../useTokenBalances/stores/amountsStore.ts   |  18 +-
 src/login/context/SessionContext/storage.ts   |  72 +++-
 src/login/hooks/context.ts                    |  14 +-
 src/login/reown.ts                            | 320 ++++++++++++++----
 src/login/types.ts                            |  11 +-
 .../GoodDollar/components/Claim/ClaimView.tsx |   3 +-
 src/sections/Home/components/ProfileCard.tsx  |   4 +-
 src/sections/Login/components/Goodwallet.tsx  |  34 +-
 src/sections/Login/components/LoginButton.tsx |  51 ++-
 src/sections/Options/OptionsView.tsx          |   2 +-
 src/sections/Receive/ReceiveView.tsx          |  18 +-
 .../SendConfirmDialog/BTCDialogDetails.tsx    |   3 +-
 .../SendConfirmDialog/SVMDialogDetails.tsx    |   3 +-
 src/sections/Swap/lifiStore.ts                |  61 +++-
 .../SessionProposalDialog.tsx                 |   4 +-
 .../requests/EIP155RequestHandlerUtil.ts      |  15 +-
 .../WalletConnect/requests/RequestHandler.ts  | 148 ++++----
 .../WalletConnect/store/walletConnectStore.ts |  25 +-
 .../WalletConnect/utils/WalletWrapper.test.ts |  38 +++
 .../WalletConnect/utils/WalletWrapper.ts      |   8 +
 src/stores/transactionHistoryStore.ts         |   4 +-
 src/translations/translations/da.ts           |  10 +-
 src/translations/translations/en.ts           |   8 +
 src/translations/types.ts                     |   5 +
 .../RestrictedEip1193Provider.test.ts         |  22 ++
 .../provider/RestrictedEip1193Provider.ts     |   6 +
 30 files changed, 874 insertions(+), 215 deletions(-)
 create mode 100644 src/sections/WalletConnect/utils/WalletWrapper.test.ts

diff --git a/src/chain/chains.ts b/src/chain/chains.ts
index 1df2f74..c9cb4a9 100644
--- a/src/chain/chains.ts
+++ b/src/chain/chains.ts
@@ -13,6 +13,7 @@ import {
 } from "viem/chains"
 
 import { config } from "@/config"
+import type { Addresses } from "@/login/types"
 
 import {
   BASE_CHAIN_ID,
@@ -448,6 +449,20 @@ export const AVAILABLE_CHAINS_IDS = Array.from(AVAILABLE_CHAINS.values())
   .sort((a, b) => b.tvl - a.tvl)
   .map((c) => c.id)
 
+// Chains the session can use, i.e. it holds an address for the chain family.
+export const isChainAvailableForAddresses = (
+  chainId: number,
+  addresses: Addresses | undefined,
+) => {
+  const family = AVAILABLE_CHAINS.get(chainId)?.family
+  return !!family && !!addresses?.has(family)
+}
+
+export const getAvailableChainIds = (addresses: Addresses | undefined) =>
+  AVAILABLE_CHAINS_IDS.filter((chainId) =>
+    isChainAvailableForAddresses(chainId, addresses),
+  )
+
 export const getChainName = (chainId: number): string => {
   const chain = AVAILABLE_CHAINS.get(chainId)
 
diff --git a/src/ethers-utils/utils.test.ts b/src/ethers-utils/utils.test.ts
index 86c12f6..3f4225a 100644
--- a/src/ethers-utils/utils.test.ts
+++ b/src/ethers-utils/utils.test.ts
@@ -8,6 +8,7 @@ const {
   mockAcquire,
   mockRelease,
   mockBroadcastTransaction,
+  mockGetTransaction,
   mockGetTransactionCount,
   mockSubmitReferral,
   mockSetDivviMarked,
@@ -15,6 +16,7 @@ const {
   mockAcquire: vi.fn(),
   mockRelease: vi.fn(),
   mockBroadcastTransaction: vi.fn(),
+  mockGetTransaction: vi.fn(),
   mockGetTransactionCount: vi.fn(),
   mockSubmitReferral: vi.fn(),
   mockSetDivviMarked: vi.fn(),
@@ -32,6 +34,7 @@ vi.mock("async-await-mutex-lock", () => ({
 vi.mock("./ethersProviders", () => ({
   getEthersProvider: vi.fn(() => ({
     broadcastTransaction: mockBroadcastTransaction,
+    getTransaction: mockGetTransaction,
     getTransactionCount: mockGetTransactionCount,
   })),
 }))
@@ -366,4 +369,88 @@ describe("ethers-utils", () => {
       expect(mockRelease).toHaveBeenCalledWith(request.chainId)
     })
   })
+
+  // ── external wallet (submitTransaction) ───────────────────────────────
+
+  describe("external wallet", () => {
+    const createWalletSigner = () => ({
+      ...createSigner(),
+      submitTransaction: vi.fn().mockResolvedValue(TX_HASH),
+    })
+
+    let walletSigner: ReturnType<typeof createWalletSigner>
+
+    beforeEach(() => {
+      walletSigner = createWalletSigner()
+      mockGetTransaction.mockResolvedValue(txResponse)
+    })
+
+    it("sendTx submits through the wallet without signing, locking, or broadcasting", async () => {
+      request = createRequest({ data: "0xcalldata" })
+
+      const result = await sendTx(
+        walletSigner as never,
+        DEFAULT_GAS_LIMIT,
+        request,
+        options,
+      )
+
+      expect(result.hash).toBe(TX_HASH)
+      expect(walletSigner.submitTransaction).toHaveBeenCalledWith({
+        ...request,
+        from: walletSigner.address,
+        gasLimit: DEFAULT_GAS_LIMIT,
+      })
+      expect(walletSigner.signTransaction).not.toHaveBeenCalled()
+      expect(mockAcquire).not.toHaveBeenCalled()
+      expect(mockBroadcastTransaction).not.toHaveBeenCalled()
+      expect(mockGetTransactionCount).not.toHaveBeenCalled()
+      await expect(result.trxMinedPromise).resolves.toEqual({ hash: TX_HASH })
+      expect(mockGetTransaction).toHaveBeenCalledWith(TX_HASH)
+    })
+
+    it("sendTx does not pass wallet-managed fees or nonce", async () => {
+      await sendTx(walletSigner as never, DEFAULT_GAS_LIMIT, request, options)
+
+      const submitted = walletSigner.submitTransaction.mock.calls[0][0]
+      expect(submitted).not.toHaveProperty("nonce")
+      expect(submitted).not.toHaveProperty("gasPrice")
+      expect(submitted).not.toHaveProperty("maxFeePerGas")
+    })
+
+    it("sendTxWaitForMining returns the response and receipt and keeps divvi tracking", async () => {
+      request = createRequest({ data: "0xcalldata_DIVVI_SUFFIX" })
+
+      const result = await sendTxWaitForMining(
+        walletSigner as never,
+        DEFAULT_GAS_LIMIT,
+        request,
+        options,
+      )
+
+      expect(result.txResponse.hash).toBe(TX_HASH)
+      expect(result.txReceipt).toEqual({ hash: TX_HASH })
+      expect(mockBroadcastTransaction).not.toHaveBeenCalled()
+      expect(mockSubmitReferral).toHaveBeenCalledWith({
+        txHash: TX_HASH,
+        chainId: request.chainId,
+      })
+    })
+
+    it("propagates wallet rejection", async () => {
+      walletSigner.submitTransaction.mockRejectedValue(
+        new Error("User rejected"),
+      )
+
+      await expect(
+        sendTxWaitForMining(
+          walletSigner as never,
+          DEFAULT_GAS_LIMIT,
+          request,
+          options,
+        ),
+      ).rejects.toThrow("User rejected")
+      expect(mockBroadcastTransaction).not.toHaveBeenCalled()
+    })
+  })
 })
diff --git a/src/ethers-utils/utils.ts b/src/ethers-utils/utils.ts
index cb49dfd..10cad07 100644
--- a/src/ethers-utils/utils.ts
+++ b/src/ethers-utils/utils.ts
@@ -48,6 +48,37 @@ export const encodeMethodCall = async (
   return { contractAddress, data }
 }
 const replacementFeeMultipler = BigInt(2)
+const SUBMITTED_TX_POLL_MS = 1500
+const SUBMITTED_TX_MAX_ATTEMPTS = 40
+
+const getSubmittedTransaction = async (
+  provider: AbstractProvider,
+  hash: string,
+): Promise<TransactionResponse> => {
+  for (let attempt = 0; attempt < SUBMITTED_TX_MAX_ATTEMPTS; attempt++) {
+    const txResponse = await provider.getTransaction(hash)
+    if (txResponse) return txResponse
+    await new Promise((resolve) => setTimeout(resolve, SUBMITTED_TX_POLL_MS))
+  }
+  throw new Error(`Transaction ${hash} was not found on chain`)
+}
+
+// The wallet picks nonce and fees and broadcasts once; we only track the hash.
+const submitWithWallet = async (
+  submit: NonNullable<EVMSigner["submitTransaction"]>,
+  signer: EVMSigner,
+  gasLimit: bigint,
+  broadcastRequest: BroadcastRequest,
+) => {
+  const hash = await submit({
+    ...broadcastRequest,
+    from: signer.address,
+    gasLimit,
+  })
+  const provider = getEthersProvider(broadcastRequest.chainId)
+  return { hash, txResponse: getSubmittedTransaction(provider, hash) }
+}
+
 export const sendTx = async (
   signer: EVMSigner,
   gasLimit: bigint,
@@ -58,6 +89,19 @@ export const sendTx = async (
   hash: string
   trxMinedPromise: Promise<TransactionReceipt | null>
 }> => {
+  if (signer.submitTransaction) {
+    const { hash, txResponse } = await submitWithWallet(
+      signer.submitTransaction,
+      signer,
+      gasLimit,
+      broadcastRequest,
+    )
+    const trxMinedPromise = txResponse.then((trx) =>
+      waitForMinedStatus(trx, broadcastRequest, signer),
+    )
+    return { hash, trxMinedPromise }
+  }
+
   const from = signer.address
   const provider = getEthersProvider(broadcastRequest.chainId)
   await lock.acquire(broadcastRequest.chainId)
@@ -85,6 +129,22 @@ export const sendTxWaitForMining = async (
   broadcastOptions: BroadcastOptions,
   usePendingNonce: boolean = false,
 ): Promise<BroadcastResult> => {
+  if (signer.submitTransaction) {
+    const submitted = await submitWithWallet(
+      signer.submitTransaction,
+      signer,
+      gasLimit,
+      broadcastRequest,
+    )
+    const txResponse = await submitted.txResponse
+    const txReceipt = await waitForMinedStatus(
+      txResponse,
+      broadcastRequest,
+      signer,
+    )
+    return { txResponse, txReceipt }
+  }
+
   const from = signer.address
   const provider = getEthersProvider(broadcastRequest.chainId)
   await lock.acquire(broadcastRequest.chainId)
diff --git a/src/hooks/useTokenBalances/index.ts b/src/hooks/useTokenBalances/index.ts
index c5c8007..06fe7ca 100644
--- a/src/hooks/useTokenBalances/index.ts
+++ b/src/hooks/useTokenBalances/index.ts
@@ -1,8 +1,9 @@
 "use client"
 
-import { useCallback } from "react"
+import { useCallback, useMemo } from "react"
 import { useSnapshot } from "valtio"
 
+import { isChainAvailableForAddresses } from "@/chain/chains"
 import { sessionState } from "@/login/context/SessionContext/storage"
 import type { Prices, Tokens } from "@/tokens/types"
 
@@ -57,8 +58,23 @@ export function useTokenBalances(): {
     [tokens, addresses],
   )
 
+  // Hide chains the session has no address for (e.g. non-EVM on connected wallets).
+  const availableTokens = useMemo(() => {
+    const source = tokensStore.tokens
+    if (!tokens || !source || !addresses) return tokens
+    const entries = Array.from(source).filter(([chainId]) =>
+      isChainAvailableForAddresses(chainId, addresses),
+    )
+    if (entries.length === source.size) return tokens
+    const filtered: Tokens = Object.assign(new Map(entries), {
+      getBy: source.getBy,
+      getNativeBy: source.getNativeBy,
+    })
+    return filtered
+  }, [tokens, addresses])
+
   return {
-    tokens,
+    tokens: availableTokens,
     prices,
     balances,
     isLoading,
diff --git a/src/hooks/useTokenBalances/stores/amountsStore.ts b/src/hooks/useTokenBalances/stores/amountsStore.ts
index dda7471..30f3594 100644
--- a/src/hooks/useTokenBalances/stores/amountsStore.ts
+++ b/src/hooks/useTokenBalances/stores/amountsStore.ts
@@ -3,6 +3,7 @@ import { imap } from "itertools"
 import { proxy } from "valtio"
 import { proxyMap, subscribeKey } from "valtio/utils"
 
+import { isChainAvailableForAddresses } from "@/chain/chains"
 import { getChainProvider } from "@/chain/provider/provider"
 import { sessionState } from "@/login/context/SessionContext/storage"
 import type { Addresses } from "@/login/types"
@@ -59,12 +60,15 @@ export const refreshAmounts = async (
     if (chainId === "all") {
       const promises = imap(
         tokens.entries(),
-        async ([chainId, tokensOfChain]) =>
-          getAmountsForChain(tokensOfChain, addresses, chainId).then(
-            (amounts) => {
-              amountsStore.amounts.set(chainId, amounts)
-            },
-          ),
+        async ([chainId, tokensOfChain]) => {
+          if (!isChainAvailableForAddresses(chainId, addresses)) return
+          const amounts = await getAmountsForChain(
+            tokensOfChain,
+            addresses,
+            chainId,
+          )
+          amountsStore.amounts.set(chainId, amounts)
+        },
       )
       const r = await Promise.allSettled(promises)
       //Log errors, if any
@@ -73,7 +77,7 @@ export const refreshAmounts = async (
       )
     } else {
       const tokensOfChain = tokens.get(chainId)
-      if (tokensOfChain) {
+      if (tokensOfChain && isChainAvailableForAddresses(chainId, addresses)) {
         const amountsForChain = await getAmountsForChain(
           tokensOfChain,
           addresses,
diff --git a/src/login/context/SessionContext/storage.ts b/src/login/context/SessionContext/storage.ts
index e753390..fa855b0 100644
--- a/src/login/context/SessionContext/storage.ts
+++ b/src/login/context/SessionContext/storage.ts
@@ -2,7 +2,11 @@ import type { Jsonify } from "type-fest"
 import { proxy, ref } from "valtio"
 
 import { getPrivateKeySession } from "@/login/adapters/privatekey"
-import { disconnectReown, getReownSession } from "@/login/reown"
+import {
+  disconnectReown,
+  getReownSession,
+  watchReownAccount,
+} from "@/login/reown"
 import type { Addresses, ISigner, ISignerSession } from "@/login/types"
 import { resetWalletConnectDialogs } from "@/sections/WalletConnect/store/walletConnectDialogStore"
 
@@ -57,26 +61,39 @@ const fromJSON = async (
   return null
 }
 
+export type ReconnectReason = "accountChanged" | "restoreFailed"
+
 type SessionState = {
   session: null | ISignerSession
   addresses?: Addresses
   isLoading: boolean
+  reconnectReason?: ReconnectReason
 }
 
 export const sessionState = proxy<SessionState>({
   session: null,
   addresses: undefined,
   isLoading: true,
+  reconnectReason: undefined,
 })
 
+// Bumped on every session change so stale async restores are dropped.
+let sessionVersion = 0
+let stopAccountWatch: (() => void) | undefined
+
 export const setSession = (session: ISignerSession | null) => {
+  sessionVersion++
+  stopAccountWatch?.()
+  stopAccountWatch = undefined
+
   sessionState.session = session && ref(session)
   if (session) {
     const addressMap = new Map<keyof ISigner, string>()
     for (const [key, value] of Object.entries(session.signer)) {
-      addressMap.set(key as keyof ISigner, value.address)
+      if (value) addressMap.set(key as keyof ISigner, value.address)
     }
     sessionState.addresses = addressMap
+    sessionState.reconnectReason = undefined
   } else {
     sessionState.addresses = undefined
   }
@@ -91,25 +108,62 @@ export const setSession = (session: ISignerSession | null) => {
   }
 
   sessionState.isLoading = false
+
+  if (session?.type === "REOWN") {
+    stopAccountWatch = watchReownAccount(session.address, () =>
+      endSession("accountChanged"),
+    )
+  }
+}
+
+const disconnectDappSessions = async () => {
+  const { disconnectAllWalletConnectSessions } = await import(
+    "@/sections/WalletConnect/store/walletConnectStore"
+  )
+  await disconnectAllWalletConnectSessions()
 }
 
-export const logout = () => {
+const endSession = (reconnectReason?: ReconnectReason) => {
   resetWalletConnectDialogs()
   const previousSession = sessionState.session
   setSession(null)
+  sessionState.reconnectReason = reconnectReason
 
   if (previousSession?.type === "REOWN") {
+    disconnectDappSessions().catch((error) => {
+      console.error("Failed to disconnect WalletConnect sessions", error)
+    })
     disconnectReown().catch((error) => {
       console.error("Failed to disconnect Reown session", error)
     })
   }
 }
 
+export const logout = () => endSession()
+
+const getStoredSessionType = () => {
+  try {
+    const stored = localStorage.getItem(SIGNER_SESSION_KEY)
+    return stored ? (JSON.parse(stored) as { type?: string }).type : undefined
+  } catch {
+    return undefined
+  }
+}
+
+const restoreSession = async () => {
+  const version = sessionVersion
+  try {
+    const session = await getSessionFromLocalStorage()
+    if (version === sessionVersion) setSession(session)
+  } catch (e) {
+    console.error("error getting persisted session", e)
+    if (version !== sessionVersion) return
+    const wasReown = getStoredSessionType() === "REOWN"
+    setSession(null)
+    if (wasReown) sessionState.reconnectReason = "restoreFailed"
+  }
+}
+
 if (typeof window !== "undefined") {
-  getSessionFromLocalStorage()
-    .then(setSession)
-    .catch((e) => {
-      console.error("error getting persisted session", e)
-      setSession(null)
-    })
+  restoreSession()
 }
diff --git a/src/login/hooks/context.ts b/src/login/hooks/context.ts
index db71aa9..d86657f 100644
--- a/src/login/hooks/context.ts
+++ b/src/login/hooks/context.ts
@@ -2,6 +2,7 @@ import { useSnapshot } from "valtio"
 
 import {
   logout,
+  type ReconnectReason,
   sessionState,
   setSession,
 } from "../context/SessionContext/storage"
@@ -10,11 +11,20 @@ import type { Addresses, ISignerSession } from "../types"
 export type ISessionContext = Partial<ISignerSession> & {
   addresses?: Addresses
   isLoading: boolean
+  reconnectReason?: ReconnectReason
   logout?: () => void
   setSession(session: ISignerSession): void
 }
 
 export const useSessionContext = (): ISessionContext => {
-  const { session, addresses, isLoading } = useSnapshot(sessionState)
-  return { ...session, addresses, isLoading, setSession, logout }
+  const { session, addresses, isLoading, reconnectReason } =
+    useSnapshot(sessionState)
+  return {
+    ...session,
+    addresses,
+    isLoading,
+    reconnectReason,
+    setSession,
+    logout,
+  }
 }
diff --git a/src/login/reown.ts b/src/login/reown.ts
index 1bd30b2..4b1b887 100644
--- a/src/login/reown.ts
+++ b/src/login/reown.ts
@@ -1,19 +1,35 @@
-import { createAppKit } from "@reown/appkit"
-import { base, celo, fuse, mainnet, xdc } from "@reown/appkit/networks"
+import { type CreateAppKit, createAppKit } from "@reown/appkit"
 import { EthersAdapter } from "@reown/appkit-adapter-ethers"
-import { BrowserProvider, type Eip1193Provider } from "ethers"
+import {
+  BrowserProvider,
+  type Eip1193Provider,
+  type TransactionRequest,
+} from "ethers"
 
 import manifest from "@/app/manifest"
+import { CELO_CHAIN_ID } from "@/chain/chain-ids"
+import { AVAILABLE_EVM_CHAINS } from "@/chain/chains"
+import type { Chain } from "@/chain/types"
 import { config } from "@/config"
 
-import type { ISigner, ISignerSession } from "./types"
+import type { ISignerSession } from "./types"
 
 type GetReownSessionOptions = {
   interactive?: boolean
   expectedAddress?: string
 }
 
-let appKitInstance: ReturnType<typeof createAppKit> | undefined
+type AppKit = ReturnType<typeof createAppKit>
+
+export class ReownConnectionCancelledError extends Error {
+  constructor() {
+    super("Wallet connection was cancelled")
+    this.name = "ReownConnectionCancelledError"
+  }
+}
+
+let appKitPromise: Promise<AppKit> | undefined
+let appKitInstance: AppKit | undefined
 
 const getMetadata = () => {
   const { name, description, icons } = manifest()
@@ -29,7 +45,41 @@ const getMetadata = () => {
   }
 }
 
-const getAppKit = async () => {
+type AppKitNetwork = CreateAppKit["networks"][number]
+
+// Plain fields only: AppKit bundles its own viem, so fee/formatter types differ.
+const toAppKitNetwork = ({
+  id,
+  name,
+  nativeCurrency,
+  rpcUrls,
+  blockExplorers,
+  testnet,
+}: Chain): AppKitNetwork => ({
+  id,
+  name,
+  nativeCurrency,
+  rpcUrls,
+  blockExplorers,
+  testnet,
+})
+
+const getNetworks = () => {
+  const [first, ...rest] = Array.from(AVAILABLE_EVM_CHAINS.values()).map(
+    toAppKitNetwork,
+  )
+  if (!first) {
+    throw new Error("No EVM networks available")
+  }
+  const networks: CreateAppKit["networks"] = [first, ...rest]
+  return {
+    networks,
+    defaultNetwork:
+      networks.find((network) => network.id === CELO_CHAIN_ID) ?? first,
+  }
+}
+
+const getAppKit = async (): Promise<AppKit> => {
   if (typeof window === "undefined") {
     throw new Error("Reown login is only available in browser")
   }
@@ -38,66 +88,167 @@ const getAppKit = async () => {
     throw new Error("WalletConnect is not configured")
   }
 
-  if (!appKitInstance) {
-    appKitInstance = createAppKit({
+  appKitPromise ??= (async () => {
+    appKitInstance ??= createAppKit({
       adapters: [new EthersAdapter()],
       projectId: config.walletConnectProjectId,
       metadata: getMetadata(),
-      networks: [celo, fuse, mainnet, base, xdc],
-      defaultNetwork: celo,
+      ...getNetworks(),
     })
-  }
+    await appKitInstance.ready()
+    return appKitInstance
+  })().catch((error) => {
+    // Allow a later attempt to retry initialization.
+    appKitPromise = undefined
+    throw error
+  })
 
-  await appKitInstance.ready()
-  return appKitInstance
+  return appKitPromise
 }
 
-const waitForConnectedAddress = async (
-  appKit: ReturnType<typeof createAppKit>,
-  timeoutMs = 120000,
+type WaitOptions = {
+  timeoutMs: number
+  cancelOnModalClose?: boolean
+  signal?: AbortSignal
+}
+
+const MODAL_CLOSE_GRACE_MS = 1500
+
+const waitForConnectedAddress = (
+  appKit: AppKit,
+  { timeoutMs, cancelOnModalClose = false, signal }: WaitOptions,
 ): Promise<string | null> => {
   const currentAddress = appKit.getAddress("eip155")
   if (currentAddress) {
-    return currentAddress
-  }
-
-  return await new Promise((resolve) => {
-    const timeout = setTimeout(() => {
-      unsubscribe()
-      resolve(null)
-    }, timeoutMs)
-
-    const unsubscribe = appKit.subscribeAccount((state) => {
-      if (state.isConnected && state.address) {
-        clearTimeout(timeout)
-        unsubscribe()
-        resolve(state.address)
-      }
-    }, "eip155")
+    return Promise.resolve(currentAddress)
+  }
+
+  return new Promise((resolve, reject) => {
+    let settled = false
+    const cleanups: Array<() => void> = []
+    const track = (cleanup: () => void) => {
+      if (settled) cleanup()
+      else cleanups.push(cleanup)
+    }
+    const finish = (settle: () => void) => {
+      if (settled) return
+      settled = true
+      for (const cleanup of cleanups) cleanup()
+      settle()
+    }
+
+    const timeout = setTimeout(() => finish(() => resolve(null)), timeoutMs)
+    track(() => clearTimeout(timeout))
+
+    track(
+      appKit.subscribeAccount((state) => {
+        const address = state.address
+        if (state.isConnected && address) {
+          finish(() => resolve(address))
+        }
+      }, "eip155"),
+    )
+
+    if (cancelOnModalClose) {
+      let wasOpen = false
+      track(
+        appKit.subscribeState((state) => {
+          if (state.open) {
+            wasOpen = true
+            return
+          }
+          if (!wasOpen) return
+          // The account update can land shortly after the modal closes.
+          const grace = setTimeout(() => {
+            const address = appKit.getAddress("eip155")
+            finish(() =>
+              address
+                ? resolve(address)
+                : reject(new ReownConnectionCancelledError()),
+            )
+          }, MODAL_CLOSE_GRACE_MS)
+          track(() => clearTimeout(grace))
+        }),
+      )
+    }
+
+    if (signal) {
+      const onAbort = () => finish(() => reject(signal.reason))
+      signal.addEventListener("abort", onAbort, { once: true })
+      track(() => signal.removeEventListener("abort", onAbort))
+    }
   })
 }
 
-const connectAddress = async (
-  appKit: ReturnType<typeof createAppKit>,
-  interactive: boolean,
-) => {
-  const connectedAddress = await waitForConnectedAddress(
-    appKit,
-    interactive ? 1000 : 15000,
-  )
-  if (connectedAddress) {
-    return connectedAddress
+const connectAddress = async (appKit: AppKit, interactive: boolean) => {
+  const restoredAddress = await waitForConnectedAddress(appKit, {
+    timeoutMs: interactive ? 1000 : 15000,
+  })
+  if (restoredAddress || !interactive) {
+    return restoredAddress
   }
 
-  if (!interactive) {
-    return null
+  const controller = new AbortController()
+  const connected = waitForConnectedAddress(appKit, {
+    timeoutMs: 120000,
+    cancelOnModalClose: true,
+    signal: controller.signal,
+  })
+  try {
+    await appKit.open({ view: "Connect", namespace: "eip155" })
+  } catch (error) {
+    connected.catch(() => undefined)
+    controller.abort(error)
+    throw error
   }
-
-  const connected = waitForConnectedAddress(appKit)
-  await appKit.open({ view: "Connect", namespace: "eip155" })
   return await connected
 }
 
+const isSameAddress = (a?: string, b?: string) =>
+  !!a && !!b && a.toLowerCase() === b.toLowerCase()
+
+const getWalletSigner = async (appKit: AppKit, address: string) => {
+  if (!isSameAddress(appKit.getAddress("eip155"), address)) {
+    throw new Error("Connected wallet account changed. Please reconnect.")
+  }
+  const walletProvider = appKit.getProvider<Eip1193Provider>("eip155")
+  if (!walletProvider) {
+    throw new Error("Connected provider not available")
+  }
+  // A fresh provider avoids ethers "network changed" errors after switching.
+  return await new BrowserProvider(walletProvider, "any").getSigner(address)
+}
+
+const ensureChain = async (
+  appKit: AppKit,
+  chainId: bigint | number | string | null | undefined,
+) => {
+  if (chainId === null || chainId === undefined) return
+  const targetChainId = Number(chainId)
+  if (Number(appKit.getChainId()) === targetChainId) return
+
+  const chain = AVAILABLE_EVM_CHAINS.get(targetChainId)
+  if (!chain) {
+    throw new Error(`Chain ${targetChainId} is not supported`)
+  }
+  await appKit.switchNetwork(toAppKitNetwork(chain), { throwOnFailure: true })
+  if (Number(appKit.getChainId()) !== targetChainId) {
+    throw new Error(`Please switch your wallet to ${chain.name}`)
+  }
+}
+
+const submitTransaction = async (
+  appKit: AppKit,
+  address: string,
+  tx: TransactionRequest,
+): Promise<string> => {
+  await ensureChain(appKit, tx.chainId)
+  const signer = await getWalletSigner(appKit, address)
+  // The wallet owns nonce and fee selection for transactions it submits.
+  const { nonce: _nonce, ...request } = tx
+  return await signer.sendUncheckedTransaction(request)
+}
+
 export const getReownSession = async (
   sessionOrigin: string,
   authProvider: string,
@@ -111,22 +262,15 @@ export const getReownSession = async (
     throw new Error("Wallet connection was not completed")
   }
 
-  if (
-    expectedAddress &&
-    connectedAddress.toLowerCase() !== expectedAddress.toLowerCase()
-  ) {
+  if (expectedAddress && !isSameAddress(connectedAddress, expectedAddress)) {
     throw new Error("Connected wallet does not match the previous session")
   }
 
-  const walletProvider = appKit.getProvider<Eip1193Provider>("eip155")
-  if (!walletProvider) {
+  if (!appKit.getProvider<Eip1193Provider>("eip155")) {
     throw new Error("Connected provider not available")
   }
 
-  const provider = new BrowserProvider(walletProvider)
-  const signer = await provider.getSigner(connectedAddress)
-
-  const session: ISignerSession = {
+  return {
     type: "REOWN",
     sessionOrigin,
     authProvider,
@@ -135,20 +279,60 @@ export const getReownSession = async (
     signer: {
       EVM: {
         address: connectedAddress,
-        signMessage: (message: Parameters<typeof signer.signMessage>[0]) =>
-          signer.signMessage(message),
-        signTransaction: (tx: Parameters<typeof signer.signTransaction>[0]) =>
-          signer.signTransaction(tx),
-        signTypedData: (
-          domain: Parameters<typeof signer.signTypedData>[0],
-          types: Parameters<typeof signer.signTypedData>[1],
-          value: Parameters<typeof signer.signTypedData>[2],
-        ) => signer.signTypedData(domain, types, value),
+        signMessage: async (message) =>
+          (await getWalletSigner(appKit, connectedAddress)).signMessage(
+            message,
+          ),
+        signTypedData: async (domain, types, value) => {
+          await ensureChain(appKit, domain.chainId)
+          return (
+            await getWalletSigner(appKit, connectedAddress)
+          ).signTypedData(domain, types, value)
+        },
+        signTransaction: async () => {
+          throw new Error("Connected wallets cannot sign raw transactions")
+        },
+        submitTransaction: (tx) =>
+          submitTransaction(appKit, connectedAddress, tx),
       },
-    } as unknown as ISigner,
+    },
+  }
+}
+
+// EIP-1193 provider of the connected wallet, switched to chainId when given.
+export const getReownEip1193Provider = async (
+  address: string,
+  chainId?: number,
+) => {
+  const appKit = await getAppKit()
+  await ensureChain(appKit, chainId)
+  if (!isSameAddress(appKit.getAddress("eip155"), address)) {
+    throw new Error("Connected wallet account changed. Please reconnect.")
+  }
+  const provider = appKit.getProvider<Eip1193Provider>("eip155")
+  if (!provider) {
+    throw new Error("Connected provider not available")
   }
+  return { provider, chainId: Number(appKit.getChainId()) }
+}
 
-  return session
+// Calls onChange when the wallet switches account or disconnects.
+export const watchReownAccount = (
+  address: string,
+  onChange: () => void,
+): (() => void) => {
+  if (!appKitInstance) {
+    return () => undefined
+  }
+  return appKitInstance.subscribeAccount((state) => {
+    if (state.status === "connecting" || state.status === "reconnecting") {
+      return
+    }
+    const changed = state.isConnected
+      ? !isSameAddress(state.address, address)
+      : state.status === "disconnected"
+    if (changed) onChange()
+  }, "eip155")
 }
 
 export const disconnectReown = async (): Promise<void> => {
diff --git a/src/login/types.ts b/src/login/types.ts
index f6eb438..18c7df8 100644
--- a/src/login/types.ts
+++ b/src/login/types.ts
@@ -1,5 +1,5 @@
 import type * as bitcoin from "bitcoinjs-lib"
-import type { Signer } from "ethers/providers"
+import type { Signer, TransactionRequest } from "ethers/providers"
 import type { KeyPairSigner, Transaction as SolanaTransaction } from "gill"
 import type { Transaction } from "xrpl"
 
@@ -13,7 +13,10 @@ export type EVMSigner = Pick<
   Signer,
   "signTransaction" | "signMessage" | "signTypedData"
 > &
-  Address
+  Address & {
+    // Set for external wallets that broadcast themselves; returns the tx hash.
+    submitTransaction?: (tx: TransactionRequest) => Promise<string>
+  }
 
 export type BTCSigner = {
   signPsbt: (psbt: bitcoin.Psbt) => Promise<string>
@@ -40,10 +43,10 @@ export type XRPSigner = {
 export type ISigner = {
   EVM: EVMSigner
 
-  BTC: BTCSigner
+  BTC?: BTCSigner
   BTC_TESTNET?: BTCSigner
 
-  DOGE: BTCSigner
+  DOGE?: BTCSigner
   DOGE_TESTNET?: BTCSigner
 
   SOLANA?: SVMSigner
diff --git a/src/sections/GoodDollar/components/Claim/ClaimView.tsx b/src/sections/GoodDollar/components/Claim/ClaimView.tsx
index b8e6472..f9825f4 100644
--- a/src/sections/GoodDollar/components/Claim/ClaimView.tsx
+++ b/src/sections/GoodDollar/components/Claim/ClaimView.tsx
@@ -555,7 +555,8 @@ function ClaimViewContent() {
 
           const link = await generateGoodIDLink(
             signer.EVM,
-            userName ?? "",
+            // Connected-wallet sessions only have an address, not a name.
+            type === "REOWN" ? "" : (userName ?? ""),
             invitedChainId,
           )
           window.open(link, "_self")
diff --git a/src/sections/Home/components/ProfileCard.tsx b/src/sections/Home/components/ProfileCard.tsx
index 939792f..ab8b870 100644
--- a/src/sections/Home/components/ProfileCard.tsx
+++ b/src/sections/Home/components/ProfileCard.tsx
@@ -7,7 +7,7 @@ import { Box, Button, createToast, Drawer, Icon } from "ui"
 
 import { AnalyticsEventTypes } from "@/analytics/types"
 import { useAnalytics } from "@/analytics/useAnalytics"
-import { AVAILABLE_CHAINS, AVAILABLE_CHAINS_IDS } from "@/chain/chains"
+import { AVAILABLE_CHAINS, getAvailableChainIds } from "@/chain/chains"
 import { formatTokenValue } from "@/components/Utils/tokenFormat"
 import { useSessionContext } from "@/login"
 import {
@@ -149,7 +149,7 @@ export const ProfileCard = ({
         onClose={() => setIsBottomSliderOpen(false)}
       >
         <Box vertical gap="none" scroll>
-          {AVAILABLE_CHAINS_IDS.map((chainId) => {
+          {getAvailableChainIds(addresses).map((chainId) => {
             return (
               <ChainSelectorSliderRow
                 key={chainId}
diff --git a/src/sections/Login/components/Goodwallet.tsx b/src/sections/Login/components/Goodwallet.tsx
index bdb3ed8..cd8d5da 100644
--- a/src/sections/Login/components/Goodwallet.tsx
+++ b/src/sections/Login/components/Goodwallet.tsx
@@ -7,6 +7,7 @@ import { Button, Icon } from "ui"
 
 import { useTranslation } from "translations"
 import { config } from "@/config"
+import { useSessionContext } from "@/login"
 import { isDeltaMobile } from "@/utils/getClientEnvironment"
 import { postMessageToReactNative } from "@/utils/messageReactNative"
 
@@ -22,23 +23,28 @@ import { Onboarding } from "./Onboarding"
 
 export default function LoginDefault() {
   const { translations } = useTranslation()
+  const { reconnectReason } = useSessionContext()
   const [showOthers, setShowOthers] = useState(false)
   const { defaultLoginMethod } = useDefaultLoginMethod()
   const showWelcomeDialog = useLocalStorageValue<boolean>("ShowWelcomeDialog", {
     defaultValue: true,
   })
   const loginTranslations = translations.login
+  const isExistingWalletEnabled =
+    config.enabledLoginOptions.existingWallet && config.walletConnectEnabled
+  const showReconnect = !!reconnectReason && isExistingWalletEnabled
+  const defaultMethod = showReconnect
+    ? "existingwallet"
+    : defaultLoginMethod.value
 
   const btns = useMemo(() => {
-    const { google, facebook, pwless, existingWallet, testLogin } =
-      config.enabledLoginOptions
+    const { google, facebook, pwless, testLogin } = config.enabledLoginOptions
 
-    const isFacebookDefault = defaultLoginMethod.value === "facebook"
-    const isGoogleDefault = defaultLoginMethod.value === "google"
-    const isPwlessDefault = defaultLoginMethod.value === "pwless"
-    const isExistingWalletDefault =
-      defaultLoginMethod.value === "existingwallet"
-    const isTestLoginDefault = defaultLoginMethod.value === "testlogin"
+    const isFacebookDefault = defaultMethod === "facebook"
+    const isGoogleDefault = defaultMethod === "google"
+    const isPwlessDefault = defaultMethod === "pwless"
+    const isExistingWalletDefault = defaultMethod === "existingwallet"
+    const isTestLoginDefault = defaultMethod === "testlogin"
 
     return [
       {
@@ -65,7 +71,7 @@ export default function LoginDefault() {
           <ExistingWalletLoginButton isDefault={isExistingWalletDefault} />
         ),
         isDefault: isExistingWalletDefault,
-        isEnabled: existingWallet,
+        isEnabled: isExistingWalletEnabled,
       },
       {
         method: "testLogin",
@@ -82,7 +88,7 @@ export default function LoginDefault() {
           testLogin.enabled && testLogin.masterSeed && testLogin.userName,
       },
     ]
-  }, [defaultLoginMethod.value])
+  }, [defaultMethod, isExistingWalletEnabled])
 
   if (showWelcomeDialog.value)
     return (
@@ -121,6 +127,14 @@ export default function LoginDefault() {
               {loginTranslations.signinText}
             </h2>
 
+            {showReconnect && (
+              <p role="status" className="text-center">
+                {reconnectReason === "accountChanged"
+                  ? loginTranslations.existingWalletAccountChanged
+                  : loginTranslations.existingWalletRestoreFailed}
+              </p>
+            )}
+
             {/* Default method */}
             {btns.find((btn) => btn.isEnabled && btn.isDefault)?.element}
 
diff --git a/src/sections/Login/components/LoginButton.tsx b/src/sections/Login/components/LoginButton.tsx
index 20343ea..48fa9bc 100644
--- a/src/sections/Login/components/LoginButton.tsx
+++ b/src/sections/Login/components/LoginButton.tsx
@@ -1,7 +1,7 @@
 "use client"
 
-import type { FC } from "react"
-import { Button } from "ui"
+import { type FC, useState } from "react"
+import { Button, useToast } from "ui"
 
 import { localeKey, useTranslation } from "translations"
 import { config } from "@/config"
@@ -12,6 +12,7 @@ import {
   useTriggerTorusAggregateLogin,
   useTriggerTorusLogin,
 } from "@/login"
+import { ReownConnectionCancelledError } from "@/login/reown"
 
 const { env, torus } = config
 const { network, web3AuthClientId, providers, captchaKey } = torus
@@ -122,17 +123,43 @@ export const ExistingWalletLoginButton: FC<{ isDefault?: boolean }> = ({
   isDefault,
 }) => {
   const { locale, translations } = useTranslation()
-  const onClick = useReownLogin()
+  const { createToast } = useToast()
+  const connect = useReownLogin()
+  const [isConnecting, setIsConnecting] = useState(false)
+
+  const onClick = async () => {
+    if (isConnecting) return
+    saveLocaleToSession(locale)
+    setIsConnecting(true)
+    try {
+      await connect()
+    } catch (error) {
+      const cancelled = error instanceof ReownConnectionCancelledError
+      if (!cancelled) console.error("Existing wallet login failed", error)
+      createToast({
+        message: cancelled
+          ? translations.login.existingWalletCancelled
+          : translations.login.existingWalletFailed,
+        status: "error",
+        autoClose: true,
+      })
+    } finally {
+      setIsConnecting(false)
+    }
+  }
 
   return (
-    <Button
-      variant={isDefault ? "solid" : "outlined"}
-      full
-      text={translations.login.existingWallet}
-      onClick={() => {
-        saveLocaleToSession(locale)
-        onClick()
-      }}
-    />
+    <div className="flex flex-col gap-2">
+      <Button
+        variant={isDefault ? "solid" : "outlined"}
+        full
+        text={translations.login.existingWallet}
+        loading={isConnecting}
+        onClick={onClick}
+      />
+      <p className="text-center text-xs opacity-70">
+        {translations.login.evmOnlyNotice}
+      </p>
+    </div>
   )
 }
diff --git a/src/sections/Options/OptionsView.tsx b/src/sections/Options/OptionsView.tsx
index b7dac64..582f3dd 100644
--- a/src/sections/Options/OptionsView.tsx
+++ b/src/sections/Options/OptionsView.tsx
@@ -26,7 +26,7 @@ export default function OptionsView() {
   const [expanded, setExpanded] = useState(false)
   const [selectedChainType, setSelectedChainType] = useState<keyof ISigner>()
   const handleCopyPrivateKey = async () => {
-    if (!selectedChainType) return
+    if (!selectedChainType || type !== "PRIVATE_KEY") return
     const session = await getSessionFromLocalStorage()
     if (!session || session.type !== "PRIVATE_KEY") return
 
diff --git a/src/sections/Receive/ReceiveView.tsx b/src/sections/Receive/ReceiveView.tsx
index 13e47d6..b6310e2 100644
--- a/src/sections/Receive/ReceiveView.tsx
+++ b/src/sections/Receive/ReceiveView.tsx
@@ -6,31 +6,30 @@ import { Box, Button, Drawer, Icon, Text } from "ui"
 import { useTranslation } from "translations"
 import {
   AVAILABLE_CHAINS,
-  AVAILABLE_CHAINS_IDS,
+  getAvailableChainIds,
   getChainName,
 } from "@/chain/chains"
 import { setBottomSheetProps } from "@/components/Snippet/BottomSheet/bottomSheetStore"
 import { ChainIcon } from "@/components/Typo/ChainIcon"
 import { truncateString } from "@/components/Utils/format"
 import { useSessionContext } from "@/login"
+import { canShare } from "@/utils/share"
 
 import { ChainSelectorSliderRow } from "../Home/components/ActivityHistory/ChainSelectorSliderRow"
 import { QRCodeWithLogo } from "./components/QRCodeWithLogo"
 import styles from "./ReceiveView.module.css"
 
-const chainIds = AVAILABLE_CHAINS_IDS
-
-import { canShare } from "@/utils/share"
-
 export default function ReceiveView() {
   const { translations } = useTranslation()
   const receiveTranslations = translations.receive
   setBottomSheetProps({ title: receiveTranslations.title })
   const [isBottomSliderOpen, setIsBottomSliderOpen] = useState(false)
 
-  const { addresses } = useSessionContext()
+  const { addresses, type } = useSessionContext()
+  const chainIds = getAvailableChainIds(addresses)
 
-  const [currentChain, setCurrentChain] = useState(chainIds[0])
+  const [selectedChain, setCurrentChain] = useState<number>()
+  const currentChain = selectedChain ?? chainIds[0]
   const chain = AVAILABLE_CHAINS.get(currentChain)
   const currentSignerAddress = chain && addresses?.get(chain.family)
 
@@ -62,6 +61,11 @@ export default function ReceiveView() {
         />
 
         <Text style="16-400">{receiveTranslations.scan}</Text>
+        {type === "REOWN" && (
+          <Text style="14-400" color="text-secondary">
+            {translations.login.evmOnlyNotice}
+          </Text>
+        )}
       </Box>
 
       <Box elevation="high">
diff --git a/src/sections/Send/components/SendConfirmDialog/BTCDialogDetails.tsx b/src/sections/Send/components/SendConfirmDialog/BTCDialogDetails.tsx
index a579c76..fe9c4fb 100644
--- a/src/sections/Send/components/SendConfirmDialog/BTCDialogDetails.tsx
+++ b/src/sections/Send/components/SendConfirmDialog/BTCDialogDetails.tsx
@@ -65,7 +65,8 @@ export const BTCDialogDetails = ({
           const signers = sessionSnap.signer
           const signer = signers[chainProvider.family]
           if (!signer) {
-            throw new Error("Signer not found")
+            // e.g. connected EVM-only wallets; leave the form invalid.
+            return
           }
 
           const amountSats = parseUnits(amountInCrypto, selectedToken.decimals)
diff --git a/src/sections/Send/components/SendConfirmDialog/SVMDialogDetails.tsx b/src/sections/Send/components/SendConfirmDialog/SVMDialogDetails.tsx
index 01bec16..8c3ab1f 100644
--- a/src/sections/Send/components/SendConfirmDialog/SVMDialogDetails.tsx
+++ b/src/sections/Send/components/SendConfirmDialog/SVMDialogDetails.tsx
@@ -57,7 +57,8 @@ export const SVMDialogDetails = ({
           const signers = sessionSnap.signer
           const signer = signers[chainProvider.family]
           if (!signer) {
-            throw new Error("Signer not found")
+            // e.g. connected EVM-only wallets; leave the form invalid.
+            return
           }
 
           const createTransaction = async () => {
diff --git a/src/sections/Swap/lifiStore.ts b/src/sections/Swap/lifiStore.ts
index 397633c..baa0543 100644
--- a/src/sections/Swap/lifiStore.ts
+++ b/src/sections/Swap/lifiStore.ts
@@ -13,7 +13,7 @@ import {
 import type { SDKClient, SDKProvider } from "@lifi/sdk"
 import { proxy, ref } from "valtio"
 import { subscribeKey } from "valtio/utils"
-import { createWalletClient, http } from "viem"
+import { createWalletClient, custom, type Hex, http } from "viem"
 import {
   base,
   bsc,
@@ -27,7 +27,8 @@ import {
 
 import { config } from "@/config"
 import { sessionState } from "@/login/context/SessionContext/storage"
-import type { ISigner } from "@/login/types"
+import { getReownEip1193Provider } from "@/login/reown"
+import type { EVMSigner, ISigner } from "@/login/types"
 
 import { bitcoinAdapter } from "./adapters/bitcoinWalletAdapter"
 import { createSolanaWallet } from "./adapters/solanaWalletAdapter"
@@ -65,6 +66,45 @@ const getLifiRpcUrls = () => {
   return rpcUrls
 }
 
+// External wallets sign and broadcast through their own provider.
+const getExternalWalletClient = async (signer: EVMSigner, chainId?: number) => {
+  const { provider, chainId: activeChainId } = await getReownEip1193Provider(
+    signer.address,
+    chainId,
+  )
+  return createWalletClient({
+    account: signer.address as Hex,
+    chain: chains.find((chain) => chain.id === activeChainId),
+    transport: custom(provider),
+  })
+}
+
+const getEvmProviderOptions = (signer: EVMSigner) => {
+  if (signer.submitTransaction) {
+    return {
+      getWalletClient: () => getExternalWalletClient(signer),
+      switchChain: (chainId: number) =>
+        getExternalWalletClient(signer, chainId),
+    }
+  }
+
+  const account = getViemAccount(signer)
+  const walletClient = createWalletClient({
+    account,
+    chain: mainnet,
+    transport: http(config.rpcUrls[mainnet.id]),
+  })
+  return {
+    getWalletClient: async () => walletClient,
+    switchChain: async (chainId: number) =>
+      createWalletClient({
+        account,
+        chain: chains.find((chain) => chain.id == chainId),
+        transport: http(config.rpcUrls[chainId]),
+      }),
+  }
+}
+
 const initializeLifi = async (signer: ISigner | undefined) => {
   if (!signer) {
     lifiState.isInitialized = false
@@ -86,23 +126,8 @@ const initializeLifi = async (signer: ISigner | undefined) => {
       import("@lifi/sdk-provider-bitcoin"),
     ])
 
-    const account = getViemAccount(signer.EVM)
-    const walletClient = createWalletClient({
-      account,
-      chain: mainnet,
-      transport: http(config.rpcUrls[mainnet.id]),
-    })
-
     const providers: SDKProvider[] = [
-      EthereumProvider({
-        getWalletClient: async () => walletClient,
-        switchChain: async (chainId) =>
-          createWalletClient({
-            account,
-            chain: chains.find((chain) => chain.id == chainId),
-            transport: http(config.rpcUrls[chainId]),
-          }),
-      }),
+      EthereumProvider(getEvmProviderOptions(signer.EVM)),
     ]
     if (signer.SOLANA) {
       const wallet = createSolanaWallet(signer.SOLANA)
diff --git a/src/sections/WalletConnect/components/WalletConnectDialog/SessionProposalDialog.tsx b/src/sections/WalletConnect/components/WalletConnectDialog/SessionProposalDialog.tsx
index d060816..4200a3c 100644
--- a/src/sections/WalletConnect/components/WalletConnectDialog/SessionProposalDialog.tsx
+++ b/src/sections/WalletConnect/components/WalletConnectDialog/SessionProposalDialog.tsx
@@ -2,7 +2,7 @@ import type { ProposalTypes, SignClientTypes } from "@walletconnect/types"
 import { Icon, Text } from "ui"
 
 import { useTranslation } from "translations"
-import { AVAILABLE_CHAINS, AVAILABLE_CHAINS_IDS } from "@/chain/chains"
+import { AVAILABLE_CHAINS, isChainAvailableForAddresses } from "@/chain/chains"
 import { ChainIcon } from "@/components/Typo/ChainIcon"
 import { truncateString } from "@/components/Utils/format"
 import { type Addresses, useSessionContext } from "@/login"
@@ -56,7 +56,7 @@ export const SessionProposalDialog = ({ sessionProposal }: Props) => {
   )
   const optionalChainIds: number[] = extractChainIds(
     sessionProposal.params.optionalNamespaces,
-  ).filter((chainId) => AVAILABLE_CHAINS_IDS.includes(chainId))
+  ).filter((chainId) => isChainAvailableForAddresses(chainId, addresses))
 
   const listOfChainIds = [...requiredChainIds, ...optionalChainIds]
 
diff --git a/src/sections/WalletConnect/requests/EIP155RequestHandlerUtil.ts b/src/sections/WalletConnect/requests/EIP155RequestHandlerUtil.ts
index c61ed48..17af1a1 100644
--- a/src/sections/WalletConnect/requests/EIP155RequestHandlerUtil.ts
+++ b/src/sections/WalletConnect/requests/EIP155RequestHandlerUtil.ts
@@ -4,7 +4,6 @@ import {
 } from "@walletconnect/jsonrpc-utils"
 import type { SignClientTypes } from "@walletconnect/types"
 import { getSdkError } from "@walletconnect/utils"
-import type { AbstractSigner } from "ethers"
 
 import { getEthersProvider } from "ethers-utils"
 
@@ -14,6 +13,7 @@ import {
   getSignParamsMessage,
   getSignTypedDataParamsData,
 } from "../utils/HelperUtils"
+import type { WalletWrapper } from "../utils/WalletWrapper"
 
 type RequestEventArgs = Omit<
   SignClientTypes.EventArguments["session_request"],
@@ -21,7 +21,7 @@ type RequestEventArgs = Omit<
 >
 
 export async function approveEIP155Request(
-  wallet: AbstractSigner,
+  wallet: WalletWrapper,
   requestEvent: RequestEventArgs,
 ) {
   const { params, id } = requestEvent
@@ -74,15 +74,16 @@ export async function approveEIP155Request(
     case EIP155_SIGNING_METHODS.ETH_SEND_TRANSACTION:
       try {
         //ChainId of format e.g. eip155:1 for Ethereum Mainnet
-        const provider = getEthersProvider(Number(chainId.split(":")[1]))
+        const internalChainId = Number(chainId.split(":")[1])
+        const provider = getEthersProvider(internalChainId)
         const sendTransaction = request.params[0]
         if (sendTransaction.gas && !sendTransaction.gasLimit) {
           sendTransaction.gasLimit = sendTransaction.gas
         }
-        const connectedWallet = wallet.connect(provider)
-        const hash = await connectedWallet.sendTransaction(sendTransaction)
-        const receipt = typeof hash === "string" ? hash : hash?.hash // TODO improve interface
-        return formatJsonRpcResult(id, receipt)
+        const hash = await wallet
+          .connect(provider)
+          .sendTransactionHash({ ...sendTransaction, chainId: internalChainId })
+        return formatJsonRpcResult(id, hash)
       } catch (error) {
         console.error(error)
         const message =
diff --git a/src/sections/WalletConnect/requests/RequestHandler.ts b/src/sections/WalletConnect/requests/RequestHandler.ts
index 6133bf2..3707213 100644
--- a/src/sections/WalletConnect/requests/RequestHandler.ts
+++ b/src/sections/WalletConnect/requests/RequestHandler.ts
@@ -10,7 +10,7 @@ import {
 
 import { AnalyticsEventTypes } from "@/analytics/types"
 import { captureEvent } from "@/analytics/useAnalytics"
-import { AVAILABLE_CHAINS, AVAILABLE_CHAINS_IDS } from "@/chain/chains"
+import { AVAILABLE_CHAINS } from "@/chain/chains"
 import { getChainProvider } from "@/chain/provider/provider"
 import type { ISigner } from "@/login/types"
 import { getCloseAfterWCAction } from "@/utils/reownAppKitWrapper"
@@ -32,64 +32,81 @@ import { approveEIP155Request } from "./EIP155RequestHandlerUtil"
 import { approveEIP5792Request } from "./EIP5792RequestHandlerUtil"
 import { approveSolanaRequest } from "./SolanaRequestHandlerUtil"
 
-const getSupportedNamespaces = (signer: ISigner) => {
-  const solanaChains: string[] = []
-  const solanaAccounts: string[] = []
+// External wallets broadcast themselves, so raw-signing methods are not offered.
+const RAW_SIGNING_METHODS = new Set<string>([
+  EIP155_SIGNING_METHODS.ETH_SIGN_TRANSACTION,
+  EIP155_SIGNING_METHODS.ETH_SEND_RAW_TRANSACTION,
+])
 
-  for (const [internalChainId, walletConnectChainId] of SOLANA_CHAINS) {
-    solanaChains.push(walletConnectChainId)
-    const chain = AVAILABLE_CHAINS.get(internalChainId)
-    if (!chain) {
-      throw new Error(
-        `Chain with id ${internalChainId} not found in AVAILABLE_CHAINS`,
-      )
-    }
-    const address = signer[chain.family]?.address
-    if (!address) {
-      throw new Error(`Address for chain ${chain.name} not found in addresses`)
-    }
-    solanaAccounts.push(`${walletConnectChainId}:${address}`)
-  }
+const isExternalWallet = (signer: ISigner) => !!signer.EVM.submitTransaction
 
-  const bitcoinAccounts: string[] = []
-  bitcoinAccounts.push(`${BIP122_MAINNET_CAIP2}:${signer.BTC.address}`)
-  if (signer.BTC_TESTNET) {
-    bitcoinAccounts.push(
-      `${BIP122_TESTNET_CAIP2}:${signer.BTC_TESTNET.address}`,
-    )
-  }
+const getEip155Methods = (signer: ISigner) =>
+  Object.values(EIP155_SIGNING_METHODS).filter(
+    (method) => !isExternalWallet(signer) || !RAW_SIGNING_METHODS.has(method),
+  )
+
+type SupportedNamespace = {
+  chains: string[]
+  methods: string[]
+  events: string[]
+  accounts: string[]
+}
 
-  return {
+const getSupportedNamespaces = (signer: ISigner) => {
+  const namespaces: Record<string, SupportedNamespace> = {
     eip155: {
       chains: EIP155_CHAINS,
-      methods: Object.values(EIP155_SIGNING_METHODS),
+      methods: getEip155Methods(signer),
       events: ["accountsChanged", "chainChanged"],
       accounts: EIP155_CHAINS.map((chain) => `${chain}:${signer.EVM.address}`),
     },
-    solana: {
+  }
+
+  const solanaChains: string[] = []
+  const solanaAccounts: string[] = []
+  for (const [internalChainId, walletConnectChainId] of SOLANA_CHAINS) {
+    const chain = AVAILABLE_CHAINS.get(internalChainId)
+    const address = chain && signer[chain.family]?.address
+    if (!address) continue
+    solanaChains.push(walletConnectChainId)
+    solanaAccounts.push(`${walletConnectChainId}:${address}`)
+  }
+  if (solanaAccounts.length > 0) {
+    namespaces.solana = {
       chains: solanaChains,
       methods: Object.values(SOLANA_SIGNING_METHODS),
       events: [],
       accounts: solanaAccounts,
-    },
-    bip122: {
+    }
+  }
+
+  if (signer.BTC) {
+    const bitcoinAccounts = [`${BIP122_MAINNET_CAIP2}:${signer.BTC.address}`]
+    if (signer.BTC_TESTNET) {
+      bitcoinAccounts.push(
+        `${BIP122_TESTNET_CAIP2}:${signer.BTC_TESTNET.address}`,
+      )
+    }
+    namespaces.bip122 = {
       chains: Array.from(BIP122_CHAINS.values()),
       methods: Object.values(BIP122_SIGNING_METHODS),
       events: [],
       accounts: bitcoinAccounts,
-    },
+    }
   }
+
+  return namespaces
 }
 
 export const setupListeners = (
-  signer: ISigner,
+  getSigner: () => ISigner,
   walletConnectInstance: WalletKit,
   refreshSessions: () => void,
 ) => {
-  const evmWalletWrapper = new WalletWrapper(signer.EVM)
   const onSessionProposal = async (
     proposal: SignClientTypes.EventArguments["session_proposal"],
   ) => {
+    const signer = getSigner()
     const requiredChainIds: string[] = []
     const optionalChainIds: string[] = []
     const methods: string[] = []
@@ -105,7 +122,8 @@ export const setupListeners = (
     const safeIsChainSupported = (chainId: string) => {
       try {
         const internalChainId = getInternalChainId(chainId)
-        return AVAILABLE_CHAINS_IDS.includes(internalChainId)
+        const family = AVAILABLE_CHAINS.get(internalChainId)?.family
+        return !!family && !!signer[family]
       } catch {
         return false
       }
@@ -118,12 +136,15 @@ export const setupListeners = (
     )
 
     if (nonSupportedChains.length > 0 || supportedChains.length === 0) {
+      const walletNote = isExternalWallet(signer)
+        ? "Connected wallets support EVM networks only. "
+        : ""
       openWalletConnectDialog({
         type: "error",
         errorText:
           supportedChains.length === 0
-            ? `No supported chain found in request`
-            : `Chains not supported: ${nonSupportedChains}`,
+            ? `${walletNote}No supported chain found in request`
+            : `${walletNote}Chains not supported: ${nonSupportedChains}`,
         acceptBtnText: "Ok",
       })
       captureEvent({
@@ -188,21 +209,26 @@ export const setupListeners = (
     closeWindowAfterWCRequestFullfilled()
   }
 
-  const supportedMethods = new Map<
-    string,
-    "eip155" | "solana" | "bip122" | "eip5792"
-  >()
-  for (const method of Object.values(EIP155_SIGNING_METHODS)) {
-    supportedMethods.set(method, "eip155")
-  }
-  for (const method of Object.values(SOLANA_SIGNING_METHODS)) {
-    supportedMethods.set(method, "solana")
-  }
-  for (const method of Object.values(BIP122_SIGNING_METHODS)) {
-    supportedMethods.set(method, "bip122")
-  }
-  for (const method of Object.values(EIP5792_METHODS)) {
-    supportedMethods.set(method, "eip5792")
+  const getSupportedMethods = (signer: ISigner) => {
+    const supportedMethods = new Map<
+      string,
+      "eip155" | "solana" | "bip122" | "eip5792"
+    >()
+    for (const method of getEip155Methods(signer)) {
+      supportedMethods.set(method, "eip155")
+    }
+    for (const method of Object.values(SOLANA_SIGNING_METHODS)) {
+      supportedMethods.set(method, "solana")
+    }
+    for (const method of Object.values(BIP122_SIGNING_METHODS)) {
+      supportedMethods.set(method, "bip122")
+    }
+    if (!isExternalWallet(signer)) {
+      for (const method of Object.values(EIP5792_METHODS)) {
+        supportedMethods.set(method, "eip5792")
+      }
+    }
+    return supportedMethods
   }
 
   const onSessionRequest = async (
@@ -215,7 +241,8 @@ export const setupListeners = (
     let responseStatus: "accepted" | "rejected" | "error" = "accepted"
 
     try {
-      const type = supportedMethods.get(request.method)
+      const signer = getSigner()
+      const type = getSupportedMethods(signer).get(request.method)
       if (!type) {
         throw new Error(`The method ${request.method} is not supported`)
       }
@@ -239,7 +266,10 @@ export const setupListeners = (
           response = await approveEIP5792Request(requestEvent)
           break
         case "eip155":
-          response = await approveEIP155Request(evmWalletWrapper, requestEvent)
+          response = await approveEIP155Request(
+            new WalletWrapper(signer.EVM),
+            requestEvent,
+          )
           break
         case "solana": {
           const internalChainId = getInternalChainId(chainId)
@@ -258,7 +288,7 @@ export const setupListeners = (
         }
         case "bip122": {
           response = await approveBIP122Request(
-            getSignerForBip122ChainId(chainId),
+            getSignerForBip122ChainId(signer, chainId),
             requestEvent,
           )
           break
@@ -292,10 +322,13 @@ export const setupListeners = (
     }
   }
 
-  const getSignerForBip122ChainId = (chainId: string) => {
+  const getSignerForBip122ChainId = (signer: ISigner, chainId: string) => {
     switch (chainId) {
       case BIP122_MAINNET_CAIP2:
-        return signer.BTC
+        if (signer.BTC) {
+          return signer.BTC
+        }
+        throw new Error("BTC signer not available")
       case BIP122_TESTNET_CAIP2:
         if (signer.BTC_TESTNET) {
           return signer.BTC_TESTNET
@@ -309,10 +342,11 @@ export const setupListeners = (
   const onSessionAuthenticate = async (
     authRequest: SignClientTypes.EventArguments["session_authenticate"],
   ) => {
+    const evmWalletWrapper = new WalletWrapper(getSigner().EVM)
     const authPayload = populateAuthPayload({
       authPayload: authRequest?.params?.authPayload,
       chains: EIP155_CHAINS,
-      methods: Object.values(EIP155_SIGNING_METHODS),
+      methods: getEip155Methods(getSigner()),
     })
 
     const address = evmWalletWrapper.address
diff --git a/src/sections/WalletConnect/store/walletConnectStore.ts b/src/sections/WalletConnect/store/walletConnectStore.ts
index 5226d3b..d5138f4 100644
--- a/src/sections/WalletConnect/store/walletConnectStore.ts
+++ b/src/sections/WalletConnect/store/walletConnectStore.ts
@@ -1,6 +1,7 @@
 import WalletKit from "@reown/walletkit"
 import { Core } from "@walletconnect/core"
 import type { SessionTypes } from "@walletconnect/types"
+import { getSdkError } from "@walletconnect/utils"
 import { proxy, ref } from "valtio"
 
 import manifest from "@/app/manifest"
@@ -19,10 +20,18 @@ type WalletConnectState = {
   refreshSessions: () => void
 }
 
+// Listeners resolve the signer per request so a reconnected session is used.
+let activeSigner: ISigner | undefined
+const getActiveSigner = () => {
+  if (!activeSigner) throw new Error("No active wallet session")
+  return activeSigner
+}
+
 const initializeWalletConnect = async (signer: ISigner) => {
   if (!config.walletConnectEnabled) {
     return
   }
+  activeSigner = signer
   if (!walletConnectState.walletConnectInstance) {
     walletConnectState.walletConnectInstance = "initializing"
     if (typeof window !== "undefined") {
@@ -50,7 +59,7 @@ const initializeWalletConnect = async (signer: ISigner) => {
       core,
       metadata,
     })
-    setupListeners(signer, wallet, refreshSessions)
+    setupListeners(getActiveSigner, wallet, refreshSessions)
     const wcUri = getWCUri()
 
     if (wcUri) {
@@ -78,3 +87,17 @@ export const walletConnectState = proxy<WalletConnectState>({
   initializeWalletConnect,
   refreshSessions,
 })
+
+export const disconnectAllWalletConnectSessions = async () => {
+  const wallet = walletConnectState.walletConnectInstance
+  if (!wallet || wallet === "initializing") return
+  await Promise.allSettled(
+    Object.values(wallet.getActiveSessions()).map((session) =>
+      wallet.disconnectSession({
+        topic: session.topic,
+        reason: getSdkError("USER_DISCONNECTED"),
+      }),
+    ),
+  )
+  refreshSessions()
+}
diff --git a/src/sections/WalletConnect/utils/WalletWrapper.test.ts b/src/sections/WalletConnect/utils/WalletWrapper.test.ts
new file mode 100644
index 0000000..553457f
--- /dev/null
+++ b/src/sections/WalletConnect/utils/WalletWrapper.test.ts
@@ -0,0 +1,38 @@
+import type { Provider, TransactionResponse } from "ethers"
+import { describe, expect, it, vi } from "vitest"
+
+import { WalletWrapper } from "./WalletWrapper"
+
+const address = "0x1111111111111111111111111111111111111111"
+const tx = { to: address, value: BigInt(1), chainId: 1 }
+
+const createSigner = () => ({
+  address,
+  signMessage: vi.fn(),
+  signTypedData: vi.fn(),
+  signTransaction: vi.fn(async () => "0xraw"),
+})
+
+describe("WalletWrapper.sendTransactionHash", () => {
+  it("submits through external wallets and returns the wallet hash", async () => {
+    const submitTransaction = vi.fn(async () => "0xwallethash")
+    const signer = { ...createSigner(), submitTransaction }
+
+    const hash = await new WalletWrapper(signer).sendTransactionHash(tx)
+
+    expect(hash).toBe("0xwallethash")
+    expect(submitTransaction).toHaveBeenCalledWith({ ...tx, from: address })
+    expect(signer.signTransaction).not.toHaveBeenCalled()
+  })
+
+  it("signs and broadcasts locally for local-key signers", async () => {
+    const signer = createSigner()
+    const wrapper = new WalletWrapper(signer, {} as Provider)
+    const sendTransaction = vi
+      .spyOn(wrapper, "sendTransaction")
+      .mockResolvedValue({ hash: "0xlocalhash" } as TransactionResponse)
+
+    await expect(wrapper.sendTransactionHash(tx)).resolves.toBe("0xlocalhash")
+    expect(sendTransaction).toHaveBeenCalledWith(tx)
+  })
+})
diff --git a/src/sections/WalletConnect/utils/WalletWrapper.ts b/src/sections/WalletConnect/utils/WalletWrapper.ts
index 9fcaec5..39bf8d2 100644
--- a/src/sections/WalletConnect/utils/WalletWrapper.ts
+++ b/src/sections/WalletConnect/utils/WalletWrapper.ts
@@ -34,6 +34,14 @@ export class WalletWrapper extends AbstractSigner {
     return this.#signer.signTransaction(tx)
   }
 
+  // External wallets broadcast themselves; local keys sign and broadcast here.
+  async sendTransactionHash(tx: TransactionRequest): Promise<string> {
+    if (this.#signer.submitTransaction) {
+      return await this.#signer.submitTransaction({ ...tx, from: this.address })
+    }
+    return (await this.sendTransaction(tx)).hash
+  }
+
   signMessage(message: string | Uint8Array): Promise<string> {
     return this.#signer.signMessage(message)
   }
diff --git a/src/stores/transactionHistoryStore.ts b/src/stores/transactionHistoryStore.ts
index b47ecc0..be1de42 100644
--- a/src/stores/transactionHistoryStore.ts
+++ b/src/stores/transactionHistoryStore.ts
@@ -1,7 +1,7 @@
 import { proxy } from "valtio"
 import { proxyMap } from "valtio/utils"
 
-import { AVAILABLE_CHAINS_IDS } from "@/chain/chains"
+import { getAvailableChainIds } from "@/chain/chains"
 import { getChainProvider } from "@/chain/provider/provider"
 import type { Tx } from "@/hooks/useLedger/types"
 import type { Addresses } from "@/login"
@@ -61,7 +61,7 @@ const refreshHistory = async (addresses: Addresses | undefined) => {
 }
 
 const refreshAllChains = async (addresses: Addresses) => {
-  const promises = AVAILABLE_CHAINS_IDS.map((chainId) =>
+  const promises = getAvailableChainIds(addresses).map((chainId) =>
     refreshHistorySingleChain(addresses, chainId),
   )
   await Promise.allSettled(promises)
diff --git a/src/translations/translations/da.ts b/src/translations/translations/da.ts
index 56d1d85..fb15986 100644
--- a/src/translations/translations/da.ts
+++ b/src/translations/translations/da.ts
@@ -32,7 +32,15 @@ const da: TypedTranslations = {
     google: "Fortsæt ved Google",
     facebook: "Fortsæt ved Facebook",
     pwdless: "Fortsæt via SMS-kode",
-    existingWallet: "Connect Wallet",
+    existingWallet: "Forbind wallet",
+    existingWalletCancelled: "Forbindelsen til din wallet blev annulleret",
+    existingWalletFailed: "Kunne ikke forbinde din wallet. Prøv igen",
+    existingWalletAccountChanged:
+      "Din wallet-konto er ændret. Forbind din wallet igen",
+    existingWalletRestoreFailed:
+      "Vi kunne ikke genoprette forbindelsen til din wallet. Forbind din wallet igen",
+    evmOnlyNotice:
+      "Forbundne wallets understøtter kun EVM-netværk. Bitcoin, Dogecoin, Solana og XRP er ikke tilgængelige.",
     legalText: {
       preText: "Ved at logge ind og fortsætte, accepterer du vores",
       terms: "Vilkår for brug",
diff --git a/src/translations/translations/en.ts b/src/translations/translations/en.ts
index afadba9..7dba58c 100644
--- a/src/translations/translations/en.ts
+++ b/src/translations/translations/en.ts
@@ -34,6 +34,14 @@ const en: TypedTranslations = {
     facebook: "Continue with Facebook",
     pwdless: "Continue via SMS code",
     existingWallet: "Connect Wallet",
+    existingWalletCancelled: "Wallet connection was cancelled",
+    existingWalletFailed: "Could not connect your wallet. Please try again",
+    existingWalletAccountChanged:
+      "Your wallet account changed. Please connect your wallet again",
+    existingWalletRestoreFailed:
+      "We couldn't reconnect your wallet. Please connect your wallet again",
+    evmOnlyNotice:
+      "Connected wallets support EVM networks only. Bitcoin, Dogecoin, Solana and XRP are not available.",
     legalText: {
       preText: "By signing in and entering, you're accepting our",
       terms: "Terms of use",
diff --git a/src/translations/types.ts b/src/translations/types.ts
index 0b4b577..00da2b3 100644
--- a/src/translations/types.ts
+++ b/src/translations/types.ts
@@ -7,6 +7,11 @@ export type LoginTranslations = {
   facebook: string
   pwdless: string
   existingWallet: string
+  existingWalletCancelled: string
+  existingWalletFailed: string
+  existingWalletAccountChanged: string
+  existingWalletRestoreFailed: string
+  evmOnlyNotice: string
   legalText: {
     preText: string
     terms: string
diff --git a/src/widgets/provider/RestrictedEip1193Provider.test.ts b/src/widgets/provider/RestrictedEip1193Provider.test.ts
index 3800dba..06764c8 100644
--- a/src/widgets/provider/RestrictedEip1193Provider.test.ts
+++ b/src/widgets/provider/RestrictedEip1193Provider.test.ts
@@ -178,6 +178,28 @@ describe("RestrictedEip1193Provider", () => {
     })
   })
 
+  it("submits approved transactions through external wallets instead of raw broadcast", async () => {
+    const submitTransaction = vi.fn(async () => "0xwallethash")
+    const { provider, rpcRequest, requestWalletApproval } = createProvider({
+      signer: { ...signer, submitTransaction },
+    })
+    await expect(
+      provider.request({
+        method: "eth_sendTransaction",
+        params: [{ from: address, chainId: 1, to: address, value: BigInt(1) }],
+      }),
+    ).resolves.toBe("0xwallethash")
+    expect(requestWalletApproval).toHaveBeenCalled()
+    expect(submitTransaction).toHaveBeenCalledWith(
+      expect.objectContaining({ from: address, to: address }),
+    )
+    expect(signer.signTransaction).not.toHaveBeenCalled()
+    expect(rpcRequest).not.toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ method: "eth_sendRawTransaction" }),
+    )
+  })
+
   it("keeps signing disabled until the Wallet explicitly approves it", async () => {
     const { provider } = createProvider({ requestWalletApproval: undefined })
     await expect(
diff --git a/src/widgets/provider/RestrictedEip1193Provider.ts b/src/widgets/provider/RestrictedEip1193Provider.ts
index dce1439..54a2392 100644
--- a/src/widgets/provider/RestrictedEip1193Provider.ts
+++ b/src/widgets/provider/RestrictedEip1193Provider.ts
@@ -372,6 +372,12 @@ export class RestrictedEip1193Provider {
       approvalParams,
       context,
     )
+    if (context.signer.submitTransaction) {
+      return await context.signer.submitTransaction({
+        ...populatedRequest,
+        from: context.account,
+      })
+    }
     const rawTransaction =
       await context.signer.signTransaction(populatedRequest)
     this.#assertSigningContext(context)