diff --git a/app/_layout.tsx b/app/_layout.tsx
index e16237ebd..4241d3520 100644
--- a/app/_layout.tsx
+++ b/app/_layout.tsx
@@ -3,21 +3,20 @@ import "expo-webauthn";
 import FontAwesome from "@expo/vector-icons/FontAwesome";
 import InterBold from "@tamagui/font-inter/otf/Inter-Bold.otf";
 import Inter from "@tamagui/font-inter/otf/Inter-Medium.otf";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { type FontSource, useFonts } from "expo-font";
 import { Slot, SplashScreen } from "expo-router";
 import { StatusBar } from "expo-status-bar";
-import React, { useEffect } from "react";
+import React, { useEffect, useState } from "react";
 import * as Sentry from "sentry-expo";
 import { TamaguiProvider } from "tamagui";
 import { TextEncoder } from "text-encoding";
-import { WagmiConfig, configureChains, createConfig } from "wagmi";
-import { alchemyProvider } from "wagmi/providers/alchemy";
-import { publicProvider } from "wagmi/providers/public";
+import { WagmiProvider, createConfig, http } from "wagmi";
 
 import metadata from "../package.json";
 import tamaguiConfig from "../tamagui.config";
-import AlchemyConnector from "../utils/AlchemyConnector";
-import { alchemyAPIKey, chain } from "../utils/constants";
+import alchemyConnector from "../utils/alchemyConnector";
+import { chain, httpURL } from "../utils/constants";
 
 export { ErrorBoundary } from "expo-router";
 
@@ -35,11 +34,12 @@ Sentry.init({
   autoSessionTracking: true,
 });
 
-const { publicClient, webSocketPublicClient } = configureChains(
-  [chain],
-  [alchemyAPIKey ? alchemyProvider({ apiKey: alchemyAPIKey }) : publicProvider()],
-);
-const wagmiConfig = createConfig({ connectors: [new AlchemyConnector()], publicClient, webSocketPublicClient });
+const wagmiConfig = createConfig({
+  chains: [chain],
+  connectors: [alchemyConnector()],
+  transports: { [chain.id]: http(httpURL) },
+});
+const queryClient = new QueryClient();
 
 export default function RootLayout() {
   const [loaded, error] = useFonts({
@@ -47,24 +47,28 @@ export default function RootLayout() {
     InterBold: InterBold as FontSource,
     ...FontAwesome.font,
   });
+  const [mounted, setMounted] = useState(false);
 
   useEffect(() => {
     if (error) throw error;
   }, [error]);
 
   useEffect(() => {
+    setMounted(true);
     if (loaded) SplashScreen.hideAsync().catch(() => {});
   }, [loaded]);
 
-  if (!loaded) return;
+  if (!loaded || !mounted) return;
 
   return (
     <>
       <StatusBar translucent={false} />
       <TamaguiProvider config={tamaguiConfig}>
-        <WagmiConfig config={wagmiConfig}>
-          <Slot />
-        </WagmiConfig>
+        <WagmiProvider config={wagmiConfig}>
+          <QueryClientProvider client={queryClient}>
+            <Slot />
+          </QueryClientProvider>
+        </WagmiProvider>
       </TamaguiProvider>
     </>
   );
diff --git a/app/index.tsx b/app/index.tsx
index 4f3ff44f9..d7f5e02e3 100644
--- a/app/index.tsx
+++ b/app/index.tsx
@@ -4,7 +4,7 @@ import { deviceName } from "expo-device";
 import React, { useCallback } from "react";
 import { Button, Spinner, Text, XStack, YStack } from "tamagui";
 import { UAParser } from "ua-parser-js";
-import { useAccount, useConnect, useDisconnect, usePrepareSendTransaction, useSendTransaction } from "wagmi";
+import { useAccount, useConnect, useDisconnect, useSendTransaction } from "wagmi";
 
 import base64URLEncode from "../utils/base64URLEncode";
 import { rpId, turnkeyAPIPublicKey, turnkeyAPIPrivateKey, turnkeyOrganizationId } from "../utils/constants";
@@ -14,13 +14,12 @@ import handleError from "../utils/handleError";
 export default function Home() {
   const {
     connect,
-    isLoading: isConnecting,
+    isPending: isConnecting,
     connectors: [connector],
   } = useConnect();
   const { address } = useAccount();
   const { disconnect } = useDisconnect();
-  const { config: sendConfig } = usePrepareSendTransaction({ to: "0xE72185a9f4Ce3500d6dC7CCDCfC64cf66D823bE8" });
-  const { sendTransaction, data: txHash, isLoading: isSending } = useSendTransaction(sendConfig);
+  const { sendTransaction, data: txHash, isPending: isSending } = useSendTransaction();
 
   const createAccount = useCallback(() => {
     const name = `exactly, ${new Date().toISOString()}`;
@@ -81,6 +80,7 @@ export default function Home() {
   }, []);
 
   const connectAccount = useCallback(() => {
+    if (!connector) throw new Error("no connector");
     connect({ connector });
   }, [connect, connector]);
 
@@ -89,7 +89,7 @@ export default function Home() {
   }, [disconnect]);
 
   const send = useCallback(() => {
-    sendTransaction?.();
+    sendTransaction({ to: "0xE72185a9f4Ce3500d6dC7CCDCfC64cf66D823bE8" });
   }, [sendTransaction]);
 
   return (
@@ -97,7 +97,7 @@ export default function Home() {
       <YStack flex={1} alignItems="center" space>
         <Text textAlign="center">{txHash}</Text>
         <Button onPress={createAccount}>create</Button>
-        <Button disabled={isConnecting} onPress={address ? disconnectAccount : connectAccount}>
+        <Button disabled={!connector || isConnecting} onPress={address ? disconnectAccount : connectAccount}>
           {isConnecting ? <Spinner size="small" /> : address ?? "connect"}
         </Button>
         <Button disabled={!address || isSending} onPress={send}>
diff --git a/babel.config.js b/babel.config.js
index ee89e8ab1..79f273003 100644
--- a/babel.config.js
+++ b/babel.config.js
@@ -6,6 +6,7 @@ module.exports = function (api) {
     plugins: [
       "expo-router/babel",
       "transform-inline-environment-variables",
+      ["@babel/plugin-transform-private-methods", { loose: true }],
       ["@tamagui/babel-plugin", { components: ["tamagui"], config: "tamagui.config.ts", logTimings: true }],
     ],
   };
diff --git a/bun.lockb b/bun.lockb
index b395ffbd6..1a3f11721 100755
Binary files a/bun.lockb and b/bun.lockb differ
diff --git a/package.json b/package.json
index 6d2fbaa5a..660619560 100644
--- a/package.json
+++ b/package.json
@@ -24,8 +24,9 @@
     "@alchemy/aa-core": "^1.2.0",
     "@expo/vector-icons": "^13.0.0",
     "@react-native-async-storage/async-storage": "1.18.2",
-    "@sentry/react-native": "^5.14.0",
+    "@sentry/react-native": "^5.14.1",
     "@tamagui/config": "^1.79.1",
+    "@tanstack/react-query": "^5.8.4",
     "@turnkey/api-key-stamper": "^0.2.0",
     "@turnkey/http": "^2.3.1",
     "@turnkey/viem": "^0.3.4",
@@ -55,12 +56,13 @@
     "tamagui": "^1.79.1",
     "text-encoding": "^0.7.0",
     "ua-parser-js": "^1.0.37",
-    "viem": "^1.19.7",
-    "wagmi": "^1.4.7",
+    "viem": "^2.0.0-beta.6",
+    "wagmi": "^2.0.0-beta.5",
     "zustand": "^4.4.6"
   },
   "devDependencies": {
     "@babel/core": "^7.23.3",
+    "@babel/plugin-transform-private-methods": "^7.23.3",
     "@tamagui/babel-plugin": "^1.79.1",
     "@types/babel__core": "^7.20.5",
     "@types/eslint": "^8.44.7",
diff --git a/utils/AlchemyConnector.ts b/utils/AlchemyConnector.ts
deleted file mode 100644
index 520618680..000000000
--- a/utils/AlchemyConnector.ts
+++ /dev/null
@@ -1,153 +0,0 @@
-import { getDefaultLightAccountFactoryAddress, LightSmartContractAccount } from "@alchemy/aa-accounts";
-import { AlchemyProvider, type AlchemyProviderConfig } from "@alchemy/aa-alchemy";
-import { LocalAccountSigner } from "@alchemy/aa-core";
-import AsyncStorage from "@react-native-async-storage/async-storage";
-import { ApiKeyStamper } from "@turnkey/api-key-stamper";
-import { TurnkeyClient } from "@turnkey/http";
-import { createAccount } from "@turnkey/viem";
-import { WebauthnStamper } from "@turnkey/webauthn-stamper";
-import { Connector, normalizeChainId } from "@wagmi/connectors";
-import { createWalletClient, custom, getAddress } from "viem";
-
-import {
-  alchemyAPIKey,
-  alchemyGasPolicyId,
-  chain,
-  rpId,
-  turnkeyAPIPrivateKey,
-  turnkeyAPIPublicKey,
-  turnkeyOrganizationId,
-} from "../utils/constants";
-
-export default class AlchemyConnector extends Connector<
-  AlchemyProvider,
-  {
-    provider: AlchemyProviderConfig;
-    paymaster: Parameters<typeof AlchemyProvider.prototype.withAlchemyGasManager>[0];
-  }
-> {
-  readonly id = "alchemy";
-  readonly name = "Alchemy";
-  readonly ready = true;
-
-  #provider?: AlchemyProvider;
-  #account?: LightSmartContractAccount;
-  #turnkeyClient?: TurnkeyClient;
-
-  constructor() {
-    super({
-      chains: [chain],
-      options: { provider: { apiKey: alchemyAPIKey, chain }, paymaster: { policyId: alchemyGasPolicyId } },
-    });
-  }
-
-  async connect({ chainId }: { chainId?: number } = {}) {
-    if (chainId && chainId !== chain.id) throw new Error("unsupported chain");
-
-    const provider = await this.getProvider();
-    provider.on("accountsChanged", this.onAccountsChanged);
-    provider.on("chainChanged", this.onChainChanged);
-    provider.on("disconnect", this.onDisconnect);
-    this.emit("message", { type: "connecting" });
-
-    let signWith: string;
-    let subOrganizationId: string;
-    try {
-      const json = await AsyncStorage.getItem("account.store");
-      if (!json) throw new Error("no store");
-      const store = JSON.parse(json) as { signWith?: string; subOrganizationId?: string };
-      if (!store.signWith || !store.subOrganizationId) throw new Error("no account");
-      signWith = store.signWith;
-      subOrganizationId = store.subOrganizationId;
-    } catch {
-      const { organizationId } = await this.getTurnkeyClient().getWhoami({ organizationId: turnkeyOrganizationId });
-      const client = new TurnkeyClient(
-        { baseUrl: "https://api.turnkey.com" },
-        new ApiKeyStamper({ apiPublicKey: turnkeyAPIPublicKey, apiPrivateKey: turnkeyAPIPrivateKey }),
-      );
-      const {
-        wallets: [wallet],
-      } = await client.getWallets({ organizationId });
-      if (!wallet) throw new Error("no wallet");
-      const { accounts } = await client.getWalletAccounts({ organizationId, walletId: wallet.walletId });
-      const account = accounts.find(({ curve }) => curve === "CURVE_SECP256K1");
-      if (!account) throw new Error("no ethereum account");
-      signWith = account.address;
-      subOrganizationId = organizationId;
-    }
-
-    const owner = new LocalAccountSigner(
-      await createAccount({
-        client: this.getTurnkeyClient(),
-        organizationId: subOrganizationId,
-        ethereumAddress: signWith,
-        signWith,
-      }),
-    );
-    this.#account = provider.connect(
-      (rpcClient) =>
-        new LightSmartContractAccount({
-          factoryAddress: getDefaultLightAccountFactoryAddress(chain),
-          rpcClient,
-          chain,
-          owner,
-        }),
-    ).account;
-    provider.withAlchemyGasManager(this.options.paymaster);
-    return { account: getAddress(await this.#account.getAddress()), chain: { id: chain.id, unsupported: false } };
-  }
-
-  async getWalletClient({ chainId }: { chainId?: number } = {}) {
-    if (chainId && chainId !== chain.id) throw new Error("unsupported chain");
-    const [provider, account] = await Promise.all([this.getProvider(), this.getAccount()]);
-    return createWalletClient({ account, chain, transport: custom(provider) });
-  }
-
-  disconnect() {
-    this.#provider?.disconnect();
-    this.#provider?.removeListener("accountsChanged", this.onAccountsChanged);
-    this.#provider?.removeListener("chainChanged", this.onChainChanged);
-    this.#provider?.removeListener("disconnect", this.onDisconnect);
-    this.#account = undefined;
-    return Promise.resolve();
-  }
-
-  getChainId() {
-    return Promise.resolve(chain.id);
-  }
-
-  getAccount() {
-    if (!this.#account) throw new Error("not connected");
-    return this.#account.getAddress();
-  }
-
-  isAuthorized() {
-    return Promise.resolve(!!this.#account);
-  }
-
-  getProvider() {
-    this.#provider ??= new AlchemyProvider(this.options.provider);
-    return Promise.resolve(this.#provider);
-  }
-
-  protected getTurnkeyClient() {
-    this.#turnkeyClient ??= new TurnkeyClient({ baseUrl: "https://api.turnkey.com" }, new WebauthnStamper({ rpId }));
-    return this.#turnkeyClient;
-  }
-
-  protected onAccountsChanged = (accounts: string[]) => {
-    if (accounts[0]) this.emit("change", { account: getAddress(accounts[0]) });
-    else this.emit("disconnect");
-  };
-
-  protected onChainChanged = (chainId: number | string) => {
-    const id = normalizeChainId(chainId);
-    const unsupported = this.isChainUnsupported(id);
-    this.emit("change", { chain: { id, unsupported } });
-  };
-
-  protected onDisconnect = () => {
-    this.#account = undefined;
-    this.emit("disconnect");
-  };
-}
diff --git a/utils/alchemyConnector.ts b/utils/alchemyConnector.ts
new file mode 100644
index 000000000..c89b99010
--- /dev/null
+++ b/utils/alchemyConnector.ts
@@ -0,0 +1,130 @@
+import { getDefaultLightAccountFactoryAddress, LightSmartContractAccount } from "@alchemy/aa-accounts";
+import { AlchemyProvider } from "@alchemy/aa-alchemy";
+import { LocalAccountSigner } from "@alchemy/aa-core";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { ApiKeyStamper } from "@turnkey/api-key-stamper";
+import { TurnkeyClient } from "@turnkey/http";
+import { createAccount } from "@turnkey/viem";
+import { WebauthnStamper } from "@turnkey/webauthn-stamper";
+import { getAddress, SwitchChainError } from "viem";
+import { ChainNotConfiguredError, createConnector, normalizeChainId } from "wagmi";
+
+import handleError from "./handleError";
+import {
+  alchemyAPIKey,
+  alchemyGasPolicyId,
+  chain,
+  rpId,
+  turnkeyAPIPrivateKey,
+  turnkeyAPIPublicKey,
+  turnkeyOrganizationId,
+} from "../utils/constants";
+
+export default function alchemyConnector() {
+  let account: LightSmartContractAccount | undefined;
+  let turnkeyClient: TurnkeyClient | undefined;
+  let alchemyProvider: AlchemyProvider | undefined;
+
+  return createConnector<AlchemyProvider, { getTurnkeyClient: () => TurnkeyClient }>((config) => ({
+    id: "alchemy",
+    name: "Alchemy",
+    async connect({ chainId } = {}) {
+      if (chainId && chainId !== chain.id) throw new SwitchChainError(new ChainNotConfiguredError());
+      const provider = await this.getProvider();
+      provider.on("accountsChanged", this.onAccountsChanged);
+      provider.on("chainChanged", this.onChainChanged);
+      provider.on("disconnect", this.onDisconnect);
+
+      let signWith: string;
+      let subOrganizationId: string;
+      try {
+        const json = await AsyncStorage.getItem("account.store");
+        if (!json) throw new Error("no store");
+        const store = JSON.parse(json) as { signWith?: string; subOrganizationId?: string };
+        if (!store.signWith || !store.subOrganizationId) throw new Error("no account");
+        signWith = store.signWith;
+        subOrganizationId = store.subOrganizationId;
+      } catch {
+        const { organizationId } = await this.getTurnkeyClient().getWhoami({ organizationId: turnkeyOrganizationId });
+        const client = new TurnkeyClient(
+          { baseUrl: "https://api.turnkey.com" },
+          new ApiKeyStamper({ apiPublicKey: turnkeyAPIPublicKey, apiPrivateKey: turnkeyAPIPrivateKey }),
+        );
+        const {
+          wallets: [wallet],
+        } = await client.getWallets({ organizationId });
+        if (!wallet) throw new Error("no wallet");
+        const { accounts } = await client.getWalletAccounts({ organizationId, walletId: wallet.walletId });
+        const walletAccount = accounts.find(({ curve }) => curve === "CURVE_SECP256K1");
+        if (!walletAccount) throw new Error("no ethereum account");
+        signWith = walletAccount.address;
+        subOrganizationId = organizationId;
+      }
+
+      const owner = new LocalAccountSigner(
+        await createAccount({
+          client: this.getTurnkeyClient(),
+          organizationId: subOrganizationId,
+          ethereumAddress: signWith,
+          signWith,
+        }),
+      );
+      account = provider.connect(
+        (rpcClient) =>
+          new LightSmartContractAccount({
+            factoryAddress: getDefaultLightAccountFactoryAddress(chain),
+            rpcClient,
+            chain,
+            owner,
+          }),
+      ).account;
+      provider.withAlchemyGasManager({ policyId: alchemyGasPolicyId });
+      return { accounts: [getAddress(await account.getAddress())], chainId: chain.id };
+    },
+    disconnect() {
+      account = undefined;
+      alchemyProvider?.disconnect();
+      alchemyProvider?.removeListener("accountsChanged", this.onAccountsChanged);
+      alchemyProvider?.removeListener("chainChanged", this.onChainChanged);
+      alchemyProvider?.removeListener("disconnect", this.onDisconnect);
+      return Promise.resolve();
+    },
+    async getAccounts() {
+      return account ? [getAddress(await account.getAddress())] : [];
+    },
+    getChainId() {
+      return Promise.resolve(chain.id);
+    },
+    getProvider() {
+      alchemyProvider ??= new AlchemyProvider({ apiKey: alchemyAPIKey, chain });
+      return Promise.resolve(alchemyProvider);
+    },
+    isAuthorized() {
+      return Promise.resolve(!!account);
+    },
+    switchChain({ chainId }) {
+      if (chainId !== chain.id) throw new SwitchChainError(new ChainNotConfiguredError());
+      return Promise.resolve(chain);
+    },
+    onAccountsChanged(accounts) {
+      if (accounts.length === 0) this.onDisconnect();
+      else config.emitter.emit("change", { accounts: accounts.map((a) => getAddress(a)) });
+    },
+    onChainChanged(chainId) {
+      config.emitter.emit("change", { chainId: normalizeChainId(chainId) });
+    },
+    onDisconnect(error) {
+      config.emitter.emit("disconnect");
+      account = undefined;
+      alchemyProvider?.disconnect();
+      alchemyProvider?.removeListener("accountsChanged", this.onAccountsChanged);
+      alchemyProvider?.removeListener("chainChanged", this.onChainChanged);
+      alchemyProvider?.removeListener("disconnect", this.onDisconnect);
+      handleError(error);
+    },
+    getTurnkeyClient() {
+      turnkeyClient ??= new TurnkeyClient({ baseUrl: "https://api.turnkey.com" }, new WebauthnStamper({ rpId }));
+      return turnkeyClient;
+    },
+  }));
+}
diff --git a/utils/constants.ts b/utils/constants.ts
index bdcb96281..6c66c7ba7 100644
--- a/utils/constants.ts
+++ b/utils/constants.ts
@@ -15,3 +15,6 @@ export const alchemyGasPolicyId = process.env.EXPO_PUBLIC_ALCHEMY_GAS_POLICY_ID;
 export const turnkeyAPIPublicKey = process.env.EXPO_PUBLIC_TURNKEY_API_PUBLIC_KEY;
 export const turnkeyAPIPrivateKey = process.env.EXPO_PUBLIC_TURNKEY_API_PRIVATE_KEY;
 export const turnkeyOrganizationId = process.env.EXPO_PUBLIC_TURNKEY_ORGANIZATION_ID;
+
+export const httpURL = `https://eth-goerli.g.alchemy.com/v2/${alchemyAPIKey}`;
+export const wsURL = `wss://eth-goerli.g.alchemy.com/v2/${alchemyAPIKey}`;