diff --git a/app/+html.tsx b/app/+html.tsx
index eb12d94c8..b3e51b4bf 100644
--- a/app/+html.tsx
+++ b/app/+html.tsx
@@ -1,3 +1,4 @@
+// @ts-expect-error -- missing types
 import { ScrollViewStyleReset } from "expo-router/html";
 import React, { type ReactNode } from "react";
 
diff --git a/app/_layout.tsx b/app/_layout.tsx
index e16237ebd..f4059234d 100644
--- a/app/_layout.tsx
+++ b/app/_layout.tsx
@@ -1,8 +1,11 @@
 import "expo-webauthn";
 
+import { AlchemyProvider } from "@alchemy/aa-alchemy";
 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 { reconnect } from "@wagmi/core";
 import { type FontSource, useFonts } from "expo-font";
 import { Slot, SplashScreen } from "expo-router";
 import { StatusBar } from "expo-status-bar";
@@ -10,14 +13,13 @@ import React, { useEffect } 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, custom } from "wagmi";
 
 import metadata from "../package.json";
 import tamaguiConfig from "../tamagui.config";
-import AlchemyConnector from "../utils/AlchemyConnector";
+import alchemyConnector from "../utils/alchemyConnector";
 import { alchemyAPIKey, chain } from "../utils/constants";
+import handleError from "../utils/handleError";
 
 export { ErrorBoundary } from "expo-router";
 
@@ -35,11 +37,13 @@ Sentry.init({
   autoSessionTracking: true,
 });
 
-const { publicClient, webSocketPublicClient } = configureChains(
-  [chain],
-  [alchemyAPIKey ? alchemyProvider({ apiKey: alchemyAPIKey }) : publicProvider()],
-);
-const wagmiConfig = createConfig({ connectors: [new AlchemyConnector()], publicClient, webSocketPublicClient });
+const provider = new AlchemyProvider({ apiKey: alchemyAPIKey, chain });
+const wagmiConfig = createConfig({
+  chains: [chain],
+  connectors: [alchemyConnector(provider)],
+  transports: { [chain.id]: custom(provider) },
+});
+const queryClient = new QueryClient();
 
 export default function RootLayout() {
   const [loaded, error] = useFonts({
@@ -53,6 +57,7 @@ export default function RootLayout() {
   }, [error]);
 
   useEffect(() => {
+    reconnect(wagmiConfig).catch(handleError);
     if (loaded) SplashScreen.hideAsync().catch(() => {});
   }, [loaded]);
 
@@ -62,9 +67,11 @@ export default function RootLayout() {
     <>
       <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..23649efdd 100644
--- a/app/index.tsx
+++ b/app/index.tsx
@@ -4,23 +4,22 @@ 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";
+import { rpId, turnkeyAPIPrivateKey, turnkeyAPIPublicKey, turnkeyOrganizationId } from "../utils/constants";
 import generateRandomBuffer from "../utils/generateRandomBuffer";
 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/app/pomelo+api.ts b/app/pomelo+api.ts
index b4ecba92b..43adfb3a0 100644
--- a/app/pomelo+api.ts
+++ b/app/pomelo+api.ts
@@ -1,18 +1,15 @@
-import { configureChains, createConfig, fetchBlockNumber } from "@wagmi/core";
-import { alchemyProvider } from "@wagmi/core/providers/alchemy";
-import { publicProvider } from "@wagmi/core/providers/public";
+import { createConfig, getBlockNumber, http } from "@wagmi/core";
 import { type ExpoRequest, ExpoResponse } from "expo-router/server";
 
 import { alchemyAPIKey, chain } from "../utils/constants";
 
-const { publicClient, webSocketPublicClient } = configureChains(
-  [chain],
-  [alchemyAPIKey ? alchemyProvider({ apiKey: alchemyAPIKey }) : publicProvider()],
-);
-createConfig({ publicClient, webSocketPublicClient });
+const httpConfig = createConfig({
+  chains: [chain],
+  transports: { [chain.id]: http(`${chain.rpcUrls.alchemy.http[0]}/${alchemyAPIKey}`) },
+});
 
 // eslint-disable-next-line import/prefer-default-export
 export async function GET(_: ExpoRequest) {
-  const blockNumber = await fetchBlockNumber();
+  const blockNumber = await getBlockNumber(httpConfig);
   return ExpoResponse.json(Number(blockNumber));
 }
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..f713fab19 100755
Binary files a/bun.lockb and b/bun.lockb differ
diff --git a/package.json b/package.json
index 6d2fbaa5a..5ae2130e6 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..0ad543915
--- /dev/null
+++ b/utils/alchemyConnector.ts
@@ -0,0 +1,137 @@
+import { getDefaultLightAccountFactoryAddress, LightSmartContractAccount } from "@alchemy/aa-accounts";
+import type { 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 {
+  alchemyGasPolicyId,
+  chain,
+  rpId,
+  turnkeyAPIPrivateKey,
+  turnkeyAPIPublicKey,
+  turnkeyOrganizationId,
+} from "../utils/constants";
+
+export default function alchemyConnector(provider: AlchemyProvider) {
+  let account: LightSmartContractAccount | undefined;
+  let turnkeyClient: TurnkeyClient | undefined;
+
+  return createConnector<
+    AlchemyProvider,
+    {
+      getAccount: (signWith: string, subOrganizationId: string) => Promise<LightSmartContractAccount>;
+      getTurnkeyClient: () => TurnkeyClient;
+    }
+  >((config) => ({
+    id: "alchemy",
+    name: "Alchemy",
+    async connect({ chainId, isReconnecting } = {}) {
+      if (chainId && chainId !== chain.id) throw new SwitchChainError(new ChainNotConfiguredError());
+      provider.on("accountsChanged", this.onAccountsChanged);
+      provider.on("chainChanged", this.onChainChanged);
+      provider.on("disconnect", this.onDisconnect);
+
+      let signWith: string;
+      let subOrganizationId: string;
+      try {
+        if (!isReconnecting) throw new Error("new connection");
+        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;
+        AsyncStorage.setItem("account.store", JSON.stringify({ signWith, subOrganizationId })).catch(handleError);
+      }
+
+      account = await this.getAccount(signWith, subOrganizationId);
+      return { accounts: [getAddress(await account.getAddress())], chainId: chain.id };
+    },
+    disconnect() {
+      account = undefined;
+      provider.disconnect();
+      provider.removeListener("accountsChanged", this.onAccountsChanged);
+      provider.removeListener("chainChanged", this.onChainChanged);
+      provider.removeListener("disconnect", this.onDisconnect);
+      return Promise.resolve();
+    },
+    async getAccounts() {
+      return account ? [getAddress(await account.getAddress())] : [];
+    },
+    getChainId() {
+      return Promise.resolve(chain.id);
+    },
+    getProvider() {
+      return Promise.resolve(provider);
+    },
+    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;
+      provider.removeListener("accountsChanged", this.onAccountsChanged);
+      provider.removeListener("chainChanged", this.onChainChanged);
+      provider.removeListener("disconnect", this.onDisconnect);
+      handleError(error);
+    },
+    async getAccount(signWith: string, subOrganizationId: string) {
+      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 account;
+    },
+    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..9d2c509d7 100644
--- a/utils/constants.ts
+++ b/utils/constants.ts
@@ -1,7 +1,6 @@
+import { goerli } from "@wagmi/core/chains";
 import { Platform } from "react-native";
 
-export { goerli as chain } from "@wagmi/core/chains";
-
 export const rpId = __DEV__ && Platform.OS === "web" ? "localhost" : "exactly.app";
 
 if (!process.env.EXPO_PUBLIC_ALCHEMY_API_KEY) throw new Error("missing alchemy api key");
@@ -15,3 +14,21 @@ 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 chain = {
+  ...goerli,
+  fees: undefined,
+  network: "goerli",
+  rpcUrls: {
+    ...goerli.rpcUrls,
+    public: {
+      http: ["https://rpc.ankr.com/eth_goerli"],
+    },
+    alchemy: {
+      http: ["https://eth-goerli.g.alchemy.com/v2"],
+      webSocket: ["wss://eth-goerli.g.alchemy.com/v2"],
+    },
+  },
+};
+
+export const auditorAddress = "0xB957a4Aa46F859b14C745b8356c28B8361319fAB";