@multiplatform.one/web3 7.18.0 → 7.20.0

package/src/clients/walletStandard.ts

@@ -0,0 +1,87 @@
+// Minimal Wallet Standard plumbing for Solana: the registry handshake and the
+// feature shapes the client calls. Structural types instead of @wallet-standard/*
+// so the page bundle carries no extra package; Phantom, Solflare and Backpack all
+// register this way.
+
+export interface StandardWalletAccount {
+  readonly address: string;
+  readonly publicKey: Uint8Array;
+  readonly chains: readonly string[];
+  readonly features: readonly string[];
+}
+
+export interface StandardWallet {
+  readonly name: string;
+  readonly icon?: string;
+  readonly chains: readonly string[];
+  readonly accounts: readonly StandardWalletAccount[];
+  readonly features: Readonly<Record<string, unknown>>;
+}
+
+export const SolanaSignMessage = "solana:signMessage";
+export const SolanaSignTransaction = "solana:signTransaction";
+export const SolanaSignAndSendTransaction = "solana:signAndSendTransaction";
+export const StandardConnect = "standard:connect";
+
+export interface SolanaSignMessageFeature {
+  signMessage(
+    ...inputs: { account: StandardWalletAccount; message: Uint8Array }[]
+  ): Promise<{ signedMessage: Uint8Array; signature: Uint8Array }[]>;
+}
+
+export interface SolanaSignTransactionFeature {
+  signTransaction(
+    ...inputs: { account: StandardWalletAccount; transaction: Uint8Array; chain?: string }[]
+  ): Promise<{ signedTransaction: Uint8Array }[]>;
+}
+
+export interface SolanaSignAndSendTransactionFeature {
+  signAndSendTransaction(
+    ...inputs: {
+      account: StandardWalletAccount;
+      transaction: Uint8Array;
+      chain: string;
+      options?: { commitment?: "processed" | "confirmed" | "finalized"; skipPreflight?: boolean };
+    }[]
+  ): Promise<{ signature: Uint8Array }[]>;
+}
+
+export interface StandardConnectFeature {
+  connect(input?: { silent?: boolean }): Promise<{ accounts: readonly StandardWalletAccount[] }>;
+}
+
+/**
+ * Every wallet registered with the Wallet Standard right now. Wallets answer
+ * `app-ready` synchronously, so this can be called again to pick up late ones.
+ */
+export function getStandardWallets(): StandardWallet[] {
+  if (typeof window === "undefined") return [];
+  const wallets: StandardWallet[] = [];
+  const api = {
+    register: (...registered: StandardWallet[]) => {
+      wallets.push(...registered);
+      return () => {};
+    },
+  };
+  const onRegister = (event: Event) => {
+    try {
+      ((event as CustomEvent).detail as (a: typeof api) => void)(api);
+    } catch {
+      // a wallet that throws during registration is simply not offered
+    }
+  };
+  window.addEventListener("wallet-standard:register-wallet", onRegister);
+  try {
+    window.dispatchEvent(new CustomEvent("wallet-standard:app-ready", { detail: api }));
+  } finally {
+    window.removeEventListener("wallet-standard:register-wallet", onRegister);
+  }
+  return [...new Set(wallets)];
+}
+
+/** Wallets that can sign Solana transactions. */
+export function getSolanaWallets(): StandardWallet[] {
+  return getStandardWallets().filter(
+    (wallet) => wallet.features[SolanaSignTransaction] && wallet.features[StandardConnect],
+  );
+}

package/src/connectkit/adapters/SolanaAdapter.ts

@@ -9,7 +9,7 @@
 // base64(message); message is the SIWS text; address == base58 ed25519 pubkey.
 //
 // (A future system-browser / Mobile-Wallet-Adapter path — the Solana analogue
-// of WalletConnect — would be a separate adapter, same as the Ethereum gap.)
+// of a relay — would be a separate adapter, same as the Ethereum gap.)
 
 import type { SignInMessageOptions, WalletAdapter, WalletAddress } from "./types";
 

package/src/connectkit/adapters/discover.ts

@@ -19,7 +19,7 @@ export interface WalletEntry {
 /**
  * Detect the non-EVM wallets present in the page (Solana / Sui / Bitcoin). EVM
  * wallets are intentionally NOT returned here — they are handled natively by
- * wagmi's EIP-6963 / Coinbase / WalletConnect connectors. One entry per
+ * wagmi's EIP-6963 / Coinbase / MetaMask connectors. One entry per
  * (ecosystem, primary wallet); each carries a ready wallet adapter.
  */
 export function discoverWallets(): WalletEntry[] {

package/src/connectkit/components/Common/ConnectorList/index.tsx

@@ -9,7 +9,6 @@ import {
   isCoinbaseWalletConnector,
   isMetaMaskConnector,
   isPortoConnector,
-  isWalletConnectConnector,
   resolveListEntries,
   useModalState,
   useScreenRegistry,
@@ -25,7 +24,6 @@ import {
   RecentlyUsedTag,
 } from "./styles";
 
-import { useWeb3 } from "../../contexts/web3";
 import { WalletProps, useWallets } from "../../../wallets/useWallets";
 import { useLastConnector } from "../../../hooks/useLastConnector";
 import { setConnectIntent } from "../../../siwe/connectIntent";
@@ -62,13 +60,12 @@ const ConnectorList = () => {
 
   const filteredWallets = wallets.filter((wallet) => wallet.id !== aaveAccountConnector?.id);
 
-  const walletsToDisplay =
-    context.options?.hideRecentBadge || lastConnectorId === "walletConnect" // do not hoist walletconnect to top of list
-      ? filteredWallets
-      : [
-          ...filteredWallets.filter((wallet) => lastConnectorId === wallet.connector.id),
-          ...filteredWallets.filter((wallet) => lastConnectorId !== wallet.connector.id),
-        ];
+  const walletsToDisplay = context.options?.hideRecentBadge
+    ? filteredWallets
+    : [
+        ...filteredWallets.filter((wallet) => lastConnectorId === wallet.connector.id),
+        ...filteredWallets.filter((wallet) => lastConnectorId !== wallet.connector.id),
+      ];
 
   // Group by brand name (first-seen order preserved).
   const groups: WalletGroup[] = [];
@@ -205,63 +202,36 @@ const ConnectorItem = ({
   isRecent?: boolean;
   labelOverride?: string;
 }) => {
-  const {
-    connect: { getUri },
-  } = useWeb3();
-  const uri = getUri();
   const isMobile = useIsMobile();
   const context = useContext();
 
   const { connect } = useConnect();
 
-  let deeplink =
-    !isMetaMaskConnector(wallet.connector.id) && // metaMaskSDK deep-links via the SDK's connect(), never via WalletConnect
-    ((!wallet.isInstalled && isMobile) || (wallet.shouldDeeplinkDesktop && !isMobile))
-      ? wallet.getWalletConnectDeeplink?.(uri ?? "")
-      : undefined;
-
-  const redirectToMoreWallets = isMobile && isWalletConnectConnector(wallet.id);
   // Safari requires opening popup on user gesture, so we connect immediately here.
-  // metaMaskSDK on mobile must also connect inside the tap gesture so the SDK's
-  // app deeplink isn't blocked by the browser's user-activation rules.
+  // MetaMask on mobile must also connect inside the tap gesture so its app
+  // deeplink isn't blocked by the browser's user-activation rules.
   const shouldConnectImmediately =
     ((detectBrowser() === "safari" || detectBrowser() === "ios") &&
       (isCoinbaseWalletConnector(wallet.connector.id) || isPortoConnector(wallet.connector.id))) ||
     (isMobile && isMetaMaskConnector(wallet.connector.id));
 
-  if (redirectToMoreWallets || shouldConnectImmediately) deeplink = undefined; // mobile redirects to more wallets page
-
   return (
     <ConnectorButton
       type="button"
-      as={deeplink ? "a" : undefined}
-      href={deeplink ? deeplink : undefined}
       disabled={context.route !== routes.CONNECTORS}
-      onClick={
-        deeplink
-          ? undefined
-          : () => {
-              if (redirectToMoreWallets) {
-                context.setRoute(routes.MOBILECONNECTORS);
-              } else {
-                if (shouldConnectImmediately) {
-                  // Mobile deeplinks out to the wallet app and comes back through a
-                  // page remount, so record the intent to continue into signing before
-                  // we lose all in-memory state (see connectIntent).
-                  setConnectIntent();
-                  connect({ connector: wallet?.connector });
-                }
-                context.setRoute(routes.CONNECT);
-                context.setConnector({ id: wallet.id });
-              }
-            }
-      }
+      onClick={() => {
+        if (shouldConnectImmediately) {
+          // Mobile deeplinks out to the wallet app and comes back through a
+          // page remount, so record the intent to continue into signing before
+          // we lose all in-memory state (see connectIntent).
+          setConnectIntent();
+          connect({ connector: wallet?.connector });
+        }
+        context.setRoute(routes.CONNECT);
+        context.setConnector({ id: wallet.id });
+      }}
     >
-      <ConnectorIcon
-        data-small={wallet.iconShouldShrink}
-        data-shape={wallet.iconShape}
-        data-background={redirectToMoreWallets}
-      >
+      <ConnectorIcon data-small={wallet.iconShouldShrink} data-shape={wallet.iconShape}>
         {wallet.iconConnector ?? wallet.icon}
       </ConnectorIcon>
       <ConnectorLabel>

package/src/connectkit/components/ConnectModal/ConnectUsing.tsx

@@ -1,80 +1,29 @@
 import { AnimatePresence, motion } from "framer-motion";
-import { useEffect, useState } from "react";
 
 import { useContext, contentVariants, Alert } from "@multiplatform.one/connectkit";
 import { useWallet } from "../../wallets/useWallets";
 
 import ConnectWithInjector from "./ConnectWithInjector";
-import ConnectWithQRCode from "./ConnectWithQRCode";
-
-const states = {
-  QRCODE: "qrcode",
-  INJECTOR: "injector",
-};
 
 const ConnectUsing = () => {
   const context = useContext();
   const wallet = useWallet(context.connector.id);
 
-  // If cannot be scanned, display injector flow, which if extension is not installed will show CTA to install it.
-  // wallet non-EVM wallets are always injected/extension (no WalletConnect URI) → never QR.
-  const isQrCode =
-    (wallet?.ecosystem ?? "evm") === "evm" &&
-    !wallet?.isInstalled &&
-    wallet?.getWalletConnectDeeplink;
-
-  const [status, setStatus] = useState(isQrCode ? states.QRCODE : states.INJECTOR);
-
-  useEffect(() => {
-    // if no provider, change to qrcode
-    const checkProvider = async () => {
-      const res = await wallet?.connector.getProvider();
-      if (!res) {
-        setStatus(states.QRCODE);
-        setTimeout(context.triggerResize, 10); // delay required here for modal to resize
-      }
-    };
-    if (status === states.INJECTOR && (wallet?.ecosystem ?? "evm") === "evm") checkProvider();
-  }, []);
-
   if (!wallet) return <Alert>Connector not found {context.connector.id}</Alert>;
 
+  // Every connector runs its own flow: an extension, a wallet app deeplink, or the
+  // wallet SDK's own popup or QR. An unavailable one shows the install call to action.
   return (
     <AnimatePresence>
-      {status === states.QRCODE && (
-        <motion.div
-          key={states.QRCODE}
-          initial={"initial"}
-          animate={"animate"}
-          exit={"exit"}
-          variants={contentVariants}
-        >
-          <ConnectWithQRCode
-            switchConnectMethod={(id?: string) => {
-              //if (id) setId(id);
-              setStatus(states.INJECTOR);
-              setTimeout(context.triggerResize, 10); // delay required here for modal to resize
-            }}
-          />
-        </motion.div>
-      )}
-      {status === states.INJECTOR && (
-        <motion.div
-          key={states.INJECTOR}
-          initial={"initial"}
-          animate={"animate"}
-          exit={"exit"}
-          variants={contentVariants}
-        >
-          <ConnectWithInjector
-            switchConnectMethod={(id?: string) => {
-              //if (id) setId(id);
-              setStatus(states.QRCODE);
-              setTimeout(context.triggerResize, 10); // delay required here for modal to resize
-            }}
-          />
-        </motion.div>
-      )}
+      <motion.div
+        key="injector"
+        initial={"initial"}
+        animate={"animate"}
+        exit={"exit"}
+        variants={contentVariants}
+      >
+        <ConnectWithInjector />
+      </motion.div>
     </AnimatePresence>
   );
 };

package/src/connectkit/components/ConnectModal/ConnectWithInjector/index.tsx

@@ -26,7 +26,6 @@ import {
   CustomQRCode,
   detectBrowser,
   isMetaMaskConnector,
-  isWalletConnectConnector,
   useIsMobile,
   useLocales,
   useContext,
@@ -81,9 +80,8 @@ const contentVariants: Variants = {
 };
 
 const ConnectWithInjector: React.FC<{
-  switchConnectMethod: (id?: string) => void;
   forceState?: typeof states;
-}> = ({ switchConnectMethod, forceState }) => {
+}> = ({ forceState }) => {
   const { connect } = useConnect({
     mutation: {
       onMutate: (connector?: any) => {
@@ -147,11 +145,11 @@ const ConnectWithInjector: React.FC<{
 
   const [showTryAgainTooltip, setShowTryAgainTooltip] = useState(false);
 
-  // The MetaMask SDK's mobile deeplink (metamask://connect/mwp?p=...), captured
+  // MetaMask Connect's mobile deeplink (metamask://connect/mwp?p=...), captured
   // from its display_uri event so we can offer it as a real tap target (see the
-  // CONNECTING render below). If the SDK never emits the event — e.g. it threw
-  // during init — this stays undefined and no tap target renders, so the modal
-  // sits on "Open <wallet>" forever; that failure mode is upstream of here.
+  // CONNECTING render below). If it never emits the event — e.g. it threw during
+  // init — this stays undefined and no tap target renders, so the modal sits on
+  // "Open <wallet>" forever; that failure mode is upstream of here.
   const [sdkDeeplink, setSdkDeeplink] = useState<string | undefined>(undefined);
   useEffect(() => {
     const connector = wallet?.connector;
@@ -178,7 +176,7 @@ const ConnectWithInjector: React.FC<{
 
   const browser = detectBrowser();
   const isMobile = useIsMobile();
-  // Tauri (and similar) shells: MetaMask SDK runs headless and emits display_uri;
+  // Tauri (and similar) shells: MetaMask Connect runs headless and emits display_uri;
   // render that URI as a QR here. Mobile keeps the anchor-tap deeplink path.
   const showEmbeddedDesktopMetaMaskQr =
     !isMobile &&
@@ -273,22 +271,6 @@ const ConnectWithInjector: React.FC<{
     );
   }
 
-  // TODO: Make this more generic
-  if (isWalletConnectConnector(wallet?.connector.id)) {
-    return (
-      <PageContent>
-        <Container>
-          <ModalHeading>Invalid State</ModalHeading>
-          <ModalContent>
-            <Alert>
-              WalletConnect does not have an injection flow. This state should never happen.
-            </Alert>
-          </ModalContent>
-        </Container>
-      </PageContent>
-    );
-  }
-
   return (
     <PageContent>
       <Container>
@@ -385,22 +367,6 @@ const ConnectWithInjector: React.FC<{
                   </ModalH1>
                   <ModalBody>{locales.injectionScreen_failed_p}</ModalBody>
                 </ModalContent>
-
-                {/* Reason: Coinbase Wallet does not expose a QRURI when extension is installed */}
-                {/*
-                {wallet?.getWalletConnectDeeplink &&
-                  wallet.id !== 'coinbaseWalletSDK' && (
-                    <>
-                      <OrDivider />
-                      <Button
-                        icon={<Scan />}
-                        onClick={() => switchConnectMethod(id)}
-                      >
-                        {locales.scanTheQRCode}
-                      </Button>
-                    </>
-                  )}
-                   */}
               </Content>
             )}
             {status === states.REJECTED && (
@@ -415,22 +381,6 @@ const ConnectWithInjector: React.FC<{
                   <ModalH1>{locales.injectionScreen_rejected_h1}</ModalH1>
                   <ModalBody>{locales.injectionScreen_rejected_p}</ModalBody>
                 </ModalContent>
-
-                {/* Reason: Coinbase Wallet does not expose a QRURI when extension is installed */}
-                {/*
-                {wallet?.getWalletConnectDeeplink &&
-                  wallet.id !== 'coinbaseWalletSDK' && (
-                    <>
-                      <OrDivider />
-                      <Button
-                        icon={<Scan />}
-                        onClick={() => switchConnectMethod(id)}
-                      >
-                        {locales.scanTheQRCode}
-                      </Button>
-                    </>
-                  )}
-                   */}
               </Content>
             )}
             {(status === states.CONNECTING || status === states.EXPIRING) && (
@@ -479,15 +429,15 @@ const ConnectWithInjector: React.FC<{
                 {showEmbeddedDesktopMetaMaskQr && (
                   <CustomQRCode value={deeplink} image={walletInfo.icon} imagePosition="center" />
                 )}
-                {/* The SDK auto-opens its deeplink, but browsers drop external-
-                    protocol navigations whose user activation expired while the
-                    SDK did its async setup (chunk import + relay round-trip) —
+                {/* MetaMask Connect auto-opens its deeplink, but browsers drop external-
+                    protocol navigations whose user activation expired while it
+                    did its async setup (chunk import + relay round-trip) —
                     silently, on slow networks especially. And a JS navigation
                     (location.href) to a universal link NEVER app-switches on
                     iOS: WebKit only follows universal links into the app from a
                     genuine same-tab anchor tap; JS-set locations land on the
                     metamask.app.link web fallback instead (observed inside
-                    ASWebAuthenticationSession). So once the SDK emits
+                    ASWebAuthenticationSession). So once it emits
                     display_uri we render it as a REAL anchor — same-tab,
                     because auth sheets can't open new tabs. */}
                 {isMobile && isMetaMaskConnector(wallet?.connector.id) && deeplink && (
@@ -557,16 +507,6 @@ const ConnectWithInjector: React.FC<{
                       <ModalH1>{locales.injectionScreen_install_h1}</ModalH1>
                       <ModalBody>{locales.injectionScreen_install_p}</ModalBody>
                     </ModalContent>
-                    {/**
-                    {(wallet.getWalletConnectDeeplink &&
-                    (!wallet.isInstalled && extensionUrl)) && <OrDivider />}
-
-                    {wallet.getWalletConnectDeeplink && (
-                      <Button icon={<Scan />} onClick={switchConnectMethod}>
-                        {locales.scanTheQRCode}
-                      </Button>
-                    )}
-                    */}
                     {!wallet.isInstalled && extensionUrl && (
                       <Button href={extensionUrl} icon={<BrowserIcon />}>
                         {locales.installTheExtension}

package/src/connectkit/components/ConnectModal/demo.tsx

@@ -17,11 +17,9 @@ import ConnectUsing from "./ConnectUsing";
 import DownloadApp from "../Pages/DownloadApp";
 import Profile from "../Pages/Profile";
 import SwitchNetworks from "../Pages/SwitchNetworks";
-import MobileConnectors from "../Pages/MobileConnectors";
 import SignInWithEthereum from "../Pages/SignInWithEthereum";
 
 import { ConnectKitButton } from "../ConnectButton";
-import { getAppName } from "../../defaultConfig";
 import { ConnectKitThemeProvider, styled, useModalState } from "@multiplatform.one/connectkit";
 import { keyframes } from "styled-components";
 import { Web3ContextProvider } from "../contexts/web3";
@@ -135,7 +133,6 @@ const ConnectModal: React.FC<{
     about: <About />,
     download: <DownloadApp />,
     connectors: <Connectors />,
-    mobileConnectors: <MobileConnectors />,
     connect: <ConnectUsing />,
     profile: <Profile closeModal={() => setIsOpen(false)} />,
     switchNetworks: <SwitchNetworks />,
@@ -203,23 +200,8 @@ const ConnectModal: React.FC<{
     }
   }, [isConnected]);
 
-  /* When pulling data into WalletConnect, it prioritises the og:title tag over the title tag */
-  useEffect(() => {
-    const appName = getAppName();
-    if (!appName || (!open && !inline)) return;
-
-    const title = document.createElement("meta");
-    title.setAttribute("property", "og:title");
-    title.setAttribute("content", appName);
-    document.head.prepend(title);
-
-    return () => {
-      document.head.removeChild(title);
-    };
-  }, [open, inline]);
-
   return (
-    <Web3ContextProvider enabled={isOpen}>
+    <Web3ContextProvider>
       <ConnectKitThemeProvider theme={theme} customTheme={customTheme} mode={mode}>
         <Container ref={ref}>
           {inline && onClose && (

package/src/connectkit/components/contexts/web3/index.tsx

@@ -8,13 +8,9 @@ import { Address, Chain } from "viem";
 import { useAccount } from "wagmi";
 
 import { useChains } from "../../../hooks/useChains";
-import { useWalletConnectUri } from "../../../hooks/connectors/useWalletConnectUri";
 import { useChainIsSupported } from "../../../hooks/useChainIsSupported";
 
 type Web3Context = {
-  connect: {
-    getUri: (id?: string) => string;
-  };
   dapp: {
     chains: Chain[];
   };
@@ -26,36 +22,18 @@ type Web3Context = {
 };
 
 const Web3Context = React.createContext({
-  connect: {
-    getUri: () => "",
-  },
   dapp: {
     chains: [],
   },
   account: undefined,
 } as Web3Context);
 
-export const Web3ContextProvider = ({
-  enabled,
-  children,
-}: {
-  enabled?: boolean;
-  children: React.ReactNode;
-}) => {
-  const { uri: walletConnectUri } = useWalletConnectUri({
-    enabled,
-  });
-
+export const Web3ContextProvider = ({ children }: { children: React.ReactNode }) => {
   const { address: currentAddress, chain } = useAccount();
   const chainIsSupported = useChainIsSupported(chain?.id);
   const chains = useChains();
 
   const value = {
-    connect: {
-      getUri: (id?: string) => {
-        return walletConnectUri;
-      },
-    },
     dapp: {
       chains,
     },

package/src/connectkit/connectors/aaveAccountConnector.spec.ts

@@ -0,0 +1,87 @@
+// @vitest-environment happy-dom
+import { createConfig, createStorage, http } from "@wagmi/core";
+import { mainnet } from "viem/chains";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { providerBuilt } = vi.hoisted(() => ({ providerBuilt: vi.fn() }));
+
+// The real module's constructor mounts Aave's iframe and starts AaveAccountSdk.connect().
+// Its own aaveAccountConnector() builds that provider as soon as it is called, which
+// is what the pre-fix defaultConnectors used.
+vi.mock("@aave/account", async () => {
+  const { injected } = await import("@wagmi/connectors/injected");
+  class EthereumProvider {
+    constructor(options?: unknown) {
+      providerBuilt(options);
+    }
+    request = vi.fn(async ({ method }: { method: string }) =>
+      method === "eth_chainId" ? "0x1" : ["0x0000000000000000000000000000000000000001"],
+    );
+    on = vi.fn();
+    removeListener = vi.fn();
+  }
+  return {
+    EthereumProvider,
+    aaveAccountConnector: (options?: unknown) => {
+      const provider = new EthereumProvider(options);
+      return injected({
+        shimDisconnect: false,
+        target: () => ({
+          id: "aaveAccountProvider",
+          name: "Aave Account",
+          provider: provider as never,
+        }),
+      });
+    },
+  };
+});
+vi.mock("@metamask/connect-evm", () => ({ createEVMClient: vi.fn(() => new Promise(() => {})) }));
+
+import getDefaultConfig from "../defaultConfig";
+import { aaveAccountConnector, aaveAccountConnectorId } from "./aaveAccountConnector";
+
+const memory = () => {
+  const store = new Map<string, string>();
+  return {
+    getItem: (key: string) => store.get(key) ?? null,
+    setItem: (key: string, value: string) => void store.set(key, value),
+    removeItem: (key: string) => void store.delete(key),
+  };
+};
+
+describe("Aave Account connector", () => {
+  beforeEach(() => providerBuilt.mockClear());
+
+  it("is off by default in getDefaultConfig", () => {
+    const config = createConfig(getDefaultConfig({ appName: "test", chains: [mainnet] }));
+    expect(config.connectors.some((c) => c.id === aaveAccountConnectorId)).toBe(false);
+  });
+
+  it("builds no Aave provider when a config opts in, until the user connects", async () => {
+    const config = createConfig({
+      ...getDefaultConfig({ appName: "test", chains: [mainnet], enableAaveAccount: true }),
+      storage: createStorage({ storage: memory() }),
+    });
+    const aave = config.connectors.find((c) => c.id === aaveAccountConnectorId)!;
+    expect(aave).toBeDefined();
+    expect(await aave.getProvider()).toBeUndefined();
+    expect(await aave.isAuthorized()).toBe(false);
+    expect(providerBuilt).not.toHaveBeenCalled();
+
+    await aave.connect();
+    expect(providerBuilt).toHaveBeenCalledOnce();
+  });
+
+  it("builds the provider to reconnect when Aave Account was the last connector", async () => {
+    const storage = createStorage({ storage: memory() });
+    await storage.setItem("recentConnectorId", aaveAccountConnectorId);
+    const config = createConfig({
+      chains: [mainnet],
+      connectors: [aaveAccountConnector()],
+      transports: { [mainnet.id]: http() },
+      storage,
+    });
+    expect(await config.connectors[0].getProvider()).toBeDefined();
+    expect(providerBuilt).toHaveBeenCalledOnce();
+  });
+});