diff --git a/apps/connect/.env.development b/apps/connect/.env.development
index 5f7f438b..df06992b 100644
--- a/apps/connect/.env.development
+++ b/apps/connect/.env.development
@@ -1,4 +1,7 @@
 VITE_HYPERGRAPH_SYNC_SERVER_ORIGIN="http://localhost:3030"
+# VITE_HYPERGRAPH_CHAIN="geo-testnet"
+# VITE_HYPERGRAPH_API_URL="https://hypergraph-v2-testnet.up.railway.app/graphql"
+# VITE_HYPERGRAPH_RPC_URL="https://rpc-geo-test-zc16z3tcvf.t.conduit.xyz"
 VITE_HYPERGRAPH_CHAIN="geogenesis"
 VITE_HYPERGRAPH_API_URL="https://hypergraph-v2.up.railway.app/graphql"
 VITE_HYPERGRAPH_RPC_URL="https://rpc-geo-genesis-h0q2s21xx8.t.conduit.xyz"
diff --git a/apps/connect/src/routes/__root.tsx b/apps/connect/src/routes/__root.tsx
index 175f1624..7d04ed6e 100644
--- a/apps/connect/src/routes/__root.tsx
+++ b/apps/connect/src/routes/__root.tsx
@@ -1,10 +1,13 @@
 import { Logout } from '@/components/logout';
+import { StoreConnect } from '@graphprotocol/hypergraph';
 import { usePrivy } from '@privy-io/react-auth';
 import { Link, Outlet, createRootRoute, useLayoutEffect, useRouter } from '@tanstack/react-router';
 import { TanStackRouterDevtools } from '@tanstack/router-devtools';
+import { useSelector } from '@xstate/store/react';
 
 export const Route = createRootRoute({
   component: () => {
+    const accountAddress = useSelector(StoreConnect.store, (state) => state.context.accountAddress);
     const { authenticated, ready } = usePrivy();
     const router = useRouter();
 
@@ -13,7 +16,7 @@ export const Route = createRootRoute({
         return;
       }
 
-      if (ready && !authenticated) {
+      if (ready && (!authenticated || !accountAddress)) {
         if (router.state.location.href.startsWith('/authenticate')) {
           localStorage.setItem('geo-connect-authenticate-redirect', router.state.location.href);
         }
@@ -21,7 +24,7 @@ export const Route = createRootRoute({
           to: '/login',
         });
       }
-    }, [authenticated, ready]);
+    }, [authenticated, ready, accountAddress]);
 
     return (
       <>
diff --git a/apps/connect/src/routes/authenticate.tsx b/apps/connect/src/routes/authenticate.tsx
index f50016ab..2afca5d4 100644
--- a/apps/connect/src/routes/authenticate.tsx
+++ b/apps/connect/src/routes/authenticate.tsx
@@ -396,6 +396,7 @@ function AuthenticateComponent() {
       console.log('smart session created');
       const smartAccountClient = await getSmartAccountWalletClient({
         owner: walletClient,
+        address: accountAddress,
         chain: CHAIN,
         rpcUrl: import.meta.env.VITE_HYPERGRAPH_RPC_URL,
       });
diff --git a/apps/connect/src/routes/login.lazy.tsx b/apps/connect/src/routes/login.lazy.tsx
index 8c955777..fa39c47b 100644
--- a/apps/connect/src/routes/login.lazy.tsx
+++ b/apps/connect/src/routes/login.lazy.tsx
@@ -23,6 +23,7 @@ function Login() {
 
   const hypergraphLogin = useCallback(
     async (walletClient: WalletClient, embeddedWallet: ConnectedWallet) => {
+      console.log('hypergraphLogin');
       if (!identityToken) {
         return;
       }
@@ -57,12 +58,14 @@ function Login() {
   );
 
   useEffect(() => {
+    console.log('useEffect in login.lazy.tsx');
     if (
       !hypergraphLoginStarted && // avoid re-running the effect to often
       privyAuthenticated && // privy must be authenticated to run it
       walletsReady && // wallets must be ready to run it
       wallets.length > 0 // wallets must have at least one wallet to run it
     ) {
+      console.log('running login effect');
       setHypergraphLoginStarted(true);
       (async () => {
         try {
diff --git a/apps/events/src/Boot.tsx b/apps/events/src/Boot.tsx
index 0dc57d91..37278af4 100644
--- a/apps/events/src/Boot.tsx
+++ b/apps/events/src/Boot.tsx
@@ -15,7 +15,12 @@ declare module '@tanstack/react-router' {
 
 export function Boot() {
   return (
-    <HypergraphAppProvider storage={localStorage} syncServerUri="http://localhost:3030" mapping={mapping}>
+    <HypergraphAppProvider
+      storage={localStorage}
+      syncServerUri="http://localhost:3030"
+      mapping={mapping}
+      chainId={80451}
+    >
       <RouterProvider router={router} />
     </HypergraphAppProvider>
   );
diff --git a/apps/events/src/components/create-events.tsx b/apps/events/src/components/create-events.tsx
index 20484ae9..408aa2ce 100644
--- a/apps/events/src/components/create-events.tsx
+++ b/apps/events/src/components/create-events.tsx
@@ -1,12 +1,12 @@
-import { getSmartAccountWalletClient } from '@/lib/smart-account';
-import { type GeoSmartAccount, Graph, type Op } from '@graphprotocol/grc-20';
-import { publishOps } from '@graphprotocol/hypergraph-react';
+import { Graph, type Op } from '@graphprotocol/grc-20';
+import type { Connect } from '@graphprotocol/hypergraph';
+import { publishOps, useHypergraphApp } from '@graphprotocol/hypergraph-react';
 import { Button } from './ui/button';
 
 const createEvents = async ({
-  smartAccountWalletClient,
+  smartSessionClient,
   space,
-}: { smartAccountWalletClient: GeoSmartAccount; space: string }) => {
+}: { smartSessionClient: Connect.SmartSessionClient; space: string }) => {
   try {
     const ops: Array<Op> = [];
 
@@ -46,7 +46,7 @@ const createEvents = async ({
     });
     ops.push(...createCompanyTypeOps);
 
-    const { id: eventTypeId, ops: createEventTypeOps } = Graph.createEntity({
+    const { ops: createEventTypeOps } = Graph.createEntity({
       name: 'My Test Event',
       types: ['6b8dbe76-389f-4bde-acdd-db9d5e387882'],
       relations: {
@@ -57,10 +57,9 @@ const createEvents = async ({
 
     const result = await publishOps({
       ops,
-      walletClient: smartAccountWalletClient,
+      walletClient: smartSessionClient,
       space,
       name: 'Create Job Offers, Companies and Events',
-      network: 'TESTNET',
     });
     console.log('result', result);
     alert('Events created');
@@ -70,17 +69,17 @@ const createEvents = async ({
 };
 
 export const CreateEvents = ({ space }: { space: string }) => {
+  const { getSmartSessionClient } = useHypergraphApp();
   return (
     <div>
       <Button
         onClick={async () => {
-          const smartAccountWalletClient = await getSmartAccountWalletClient();
-          if (!smartAccountWalletClient) {
-            throw new Error('Missing smartAccountWalletClient');
+          const smartSessionClient = await getSmartSessionClient();
+          if (!smartSessionClient) {
+            throw new Error('Missing smartSessionClient');
           }
           await createEvents({
-            // @ts-expect-error TODO: in the future we probably only only use one smart account wallet client
-            smartAccountWalletClient,
+            smartSessionClient,
             space,
           });
         }}
diff --git a/apps/events/src/components/create-properties-and-types-event.tsx b/apps/events/src/components/create-properties-and-types-event.tsx
index dbae469f..0146b0ea 100644
--- a/apps/events/src/components/create-properties-and-types-event.tsx
+++ b/apps/events/src/components/create-properties-and-types-event.tsx
@@ -1,14 +1,14 @@
-import { getSmartAccountWalletClient } from '@/lib/smart-account';
-import { type GeoSmartAccount, Graph, type Op } from '@graphprotocol/grc-20';
-import { publishOps } from '@graphprotocol/hypergraph-react';
+import { Graph, type Op } from '@graphprotocol/grc-20';
+import type { Connect } from '@graphprotocol/hypergraph';
+import { publishOps, useHypergraphApp } from '@graphprotocol/hypergraph-react';
 import { useState } from 'react';
 import { Button } from './ui/button';
 import { Card, CardContent } from './ui/card';
 
 const createPropertiesAndTypesEvent = async ({
-  smartAccountWalletClient,
+  smartSessionClient,
   space,
-}: { smartAccountWalletClient: GeoSmartAccount; space: string }) => {
+}: { smartSessionClient: Connect.SmartSessionClient; space: string }) => {
   const ops: Array<Op> = [];
   const { id: salaryPropertyId, ops: createSalaryPropertyOps } = Graph.createProperty({
     dataType: 'NUMBER',
@@ -50,10 +50,9 @@ const createPropertiesAndTypesEvent = async ({
 
   const result = await publishOps({
     ops,
-    walletClient: smartAccountWalletClient,
+    walletClient: smartSessionClient,
     space,
     name: 'Create properties and types',
-    network: 'TESTNET',
   });
   return {
     result,
@@ -68,6 +67,7 @@ const createPropertiesAndTypesEvent = async ({
 
 export const CreatePropertiesAndTypesEvent = ({ space }: { space: string }) => {
   const [mapping, setMapping] = useState<string>('');
+  const { getSmartSessionClient } = useHypergraphApp();
 
   return (
     <div>
@@ -80,9 +80,9 @@ export const CreatePropertiesAndTypesEvent = ({ space }: { space: string }) => {
       )}
       <Button
         onClick={async () => {
-          const smartAccountWalletClient = await getSmartAccountWalletClient();
-          if (!smartAccountWalletClient) {
-            throw new Error('Missing smartAccountWalletClient');
+          const smartSessionClient = await getSmartSessionClient();
+          if (!smartSessionClient) {
+            throw new Error('Missing smartSessionClient');
           }
           const {
             eventTypeId,
@@ -92,8 +92,7 @@ export const CreatePropertiesAndTypesEvent = ({ space }: { space: string }) => {
             jobOffersRelationTypeId,
             sponsorsRelationTypeId,
           } = await createPropertiesAndTypesEvent({
-            // @ts-expect-error TODO: in the future we probably only only use one smart account wallet client
-            smartAccountWalletClient,
+            smartSessionClient,
             space,
           });
 
diff --git a/apps/events/src/components/create-properties-and-types-todos.tsx b/apps/events/src/components/create-properties-and-types-todos.tsx
index 2d6db3c4..3d75f20e 100644
--- a/apps/events/src/components/create-properties-and-types-todos.tsx
+++ b/apps/events/src/components/create-properties-and-types-todos.tsx
@@ -1,14 +1,14 @@
-import { getSmartAccountWalletClient } from '@/lib/smart-account';
-import { type GeoSmartAccount, Graph, type Op } from '@graphprotocol/grc-20';
-import { publishOps } from '@graphprotocol/hypergraph-react';
+import { Graph, type Op } from '@graphprotocol/grc-20';
+import type { Connect } from '@graphprotocol/hypergraph';
+import { publishOps, useHypergraphApp } from '@graphprotocol/hypergraph-react';
 import { useState } from 'react';
 import { Button } from './ui/button';
 import { Card, CardContent } from './ui/card';
 
 const createPropertiesAndTypesTodos = async ({
-  smartAccountWalletClient,
+  smartSessionClient,
   space,
-}: { smartAccountWalletClient: GeoSmartAccount; space: string }) => {
+}: { smartSessionClient: Connect.SmartSessionClient; space: string }) => {
   const ops: Array<Op> = [];
   const { id: checkedPropertyId, ops: createCheckedPropertyOps } = Graph.createProperty({
     dataType: 'CHECKBOX',
@@ -67,10 +67,9 @@ const createPropertiesAndTypesTodos = async ({
 
   const result = await publishOps({
     ops,
-    walletClient: smartAccountWalletClient,
+    walletClient: smartSessionClient,
     space,
     name: 'Create properties and types',
-    network: 'TESTNET',
   });
   return {
     result,
@@ -87,7 +86,7 @@ const createPropertiesAndTypesTodos = async ({
 
 export const CreatePropertiesAndTypesTodos = ({ space }: { space: string }) => {
   const [mapping, setMapping] = useState<string>('');
-
+  const { getSmartSessionClient } = useHypergraphApp();
   return (
     <div>
       {mapping && (
@@ -99,9 +98,9 @@ export const CreatePropertiesAndTypesTodos = ({ space }: { space: string }) => {
       )}
       <Button
         onClick={async () => {
-          const smartAccountWalletClient = await getSmartAccountWalletClient();
-          if (!smartAccountWalletClient) {
-            throw new Error('Missing smartAccountWalletClient');
+          const smartSessionClient = await getSmartSessionClient();
+          if (!smartSessionClient) {
+            throw new Error('Missing smartSessionClient');
           }
           const {
             todoTypeId,
@@ -113,8 +112,7 @@ export const CreatePropertiesAndTypesTodos = ({ space }: { space: string }) => {
             websitePropertyId,
             amountPropertyId,
           } = await createPropertiesAndTypesTodos({
-            // @ts-expect-error - TODO: fix the types error
-            smartAccountWalletClient,
+            smartSessionClient,
             space,
           });
 
diff --git a/apps/events/src/components/playground.tsx b/apps/events/src/components/playground.tsx
index 084f2868..1833ad84 100644
--- a/apps/events/src/components/playground.tsx
+++ b/apps/events/src/components/playground.tsx
@@ -1,5 +1,9 @@
-import { getSmartAccountWalletClient } from '@/lib/smart-account';
-import { _useCreateEntityPublic, _useDeleteEntityPublic, useQuery } from '@graphprotocol/hypergraph-react';
+import {
+  _useCreateEntityPublic,
+  _useDeleteEntityPublic,
+  useHypergraphApp,
+  useQuery,
+} from '@graphprotocol/hypergraph-react';
 import { useState } from 'react';
 import { Event } from '../schema';
 import { Button } from './ui/button';
@@ -15,6 +19,7 @@ export const Playground = () => {
   });
   const [isDeleting, setIsDeleting] = useState(false);
   const [isCreating, setIsCreating] = useState(false);
+  const { getSmartSessionClient } = useHypergraphApp();
 
   const deleteEntity = _useDeleteEntityPublic(Event, {
     space: '1c954768-7e14-4f0f-9396-0fe9dcd55fe8',
@@ -34,7 +39,7 @@ export const Playground = () => {
         disabled={isCreating}
         onClick={async () => {
           setIsCreating(true);
-          const walletClient = await getSmartAccountWalletClient();
+          const walletClient = await getSmartSessionClient();
           if (!walletClient) {
             alert('Wallet client not found');
             setIsCreating(false);
@@ -60,14 +65,13 @@ export const Playground = () => {
           <Button
             onClick={async () => {
               setIsDeleting(true);
-              const walletClient = await getSmartAccountWalletClient();
+              const walletClient = await getSmartSessionClient();
               if (!walletClient) {
                 alert('Wallet client not found');
                 return;
               }
               await deleteEntity({
                 id: event.id,
-                // @ts-expect-error - TODO: fix the types error
                 walletClient,
               });
               setIsDeleting(false);
diff --git a/apps/events/src/components/todo/todos-public.tsx b/apps/events/src/components/todo/todos-public.tsx
index 0ef9335e..30bbc219 100644
--- a/apps/events/src/components/todo/todos-public.tsx
+++ b/apps/events/src/components/todo/todos-public.tsx
@@ -1,6 +1,6 @@
-import { getSmartAccountWalletClient } from '@/lib/smart-account';
 import { Id } from '@graphprotocol/grc-20';
 import { _generateDeleteOps, publishOps, useCreateEntity, useQuery, useSpace } from '@graphprotocol/hypergraph-react';
+import { useHypergraphApp } from '@graphprotocol/hypergraph-react';
 import { useGenerateCreateOps } from '@graphprotocol/hypergraph-react/internal/use-generate-create-ops';
 import { Todo2 } from '../../schema';
 import { Spinner } from '../spinner';
@@ -8,6 +8,7 @@ import { Button } from '../ui/button';
 
 export const TodosPublic = () => {
   const { id: spaceId } = useSpace({ mode: 'public' });
+  const { getSmartSessionClient } = useHypergraphApp();
   const {
     data: dataPublic,
     isLoading: isLoadingPublic,
@@ -44,15 +45,14 @@ export const TodosPublic = () => {
 
           <Button
             onClick={async () => {
-              const smartAccountWalletClient = await getSmartAccountWalletClient();
-              if (!smartAccountWalletClient) {
-                throw new Error('Missing smartAccountWalletClient');
+              const smartSessionClient = await getSmartSessionClient();
+              if (!smartSessionClient) {
+                throw new Error('Missing smartSessionClient');
               }
               const ops = await _generateDeleteOps({ id: todo.id, space: spaceId });
               const result = await publishOps({
                 ops,
-                // @ts-expect-error - TODO: fix the types error
-                walletClient: smartAccountWalletClient,
+                walletClient: smartSessionClient,
                 space: spaceId,
                 name: 'Delete Todo',
               });
@@ -65,9 +65,9 @@ export const TodosPublic = () => {
       ))}
       <Button
         onClick={async () => {
-          const smartAccountWalletClient = await getSmartAccountWalletClient();
-          if (!smartAccountWalletClient) {
-            throw new Error('Missing smartAccountWalletClient');
+          const smartSessionClient = await getSmartSessionClient();
+          if (!smartSessionClient) {
+            throw new Error('Missing smartSessionClient');
           }
           const userId = Id.Id('8zPJjTGLBDPtUcj6q2tghg');
           const todo = createTodo({
@@ -84,8 +84,7 @@ export const TodosPublic = () => {
           console.log('ops', ops);
           const result = await publishOps({
             ops,
-            // @ts-expect-error - TODO: fix the types error
-            walletClient: smartAccountWalletClient,
+            walletClient: smartSessionClient,
             space: spaceId,
             name: 'Create Todo',
           });
diff --git a/apps/events/src/components/todos2.tsx b/apps/events/src/components/todos2.tsx
index 22de6fc9..01d74eeb 100644
--- a/apps/events/src/components/todos2.tsx
+++ b/apps/events/src/components/todos2.tsx
@@ -1,4 +1,3 @@
-import { getSmartAccountWalletClient } from '@/lib/smart-account';
 import { cn } from '@/lib/utils';
 import type { PublishDiffInfo } from '@graphprotocol/hypergraph-react';
 import {
@@ -6,6 +5,7 @@ import {
   publishOps,
   useCreateEntity,
   useDeleteEntity,
+  useHypergraphApp,
   useQuery,
   useSpace,
   useUpdateEntity,
@@ -35,6 +35,7 @@ export const Todos2 = () => {
     // preparePublish: preparePublishUsers,
   } = useQuery(User, { mode: 'private' });
   const { ready: spaceReady, id: spaceId } = useSpace({ mode: 'private' });
+  const { getSmartSessionClient } = useHypergraphApp();
   const createTodo = useCreateEntity(Todo2);
   const updateTodo = useUpdateEntity(Todo2);
   const createUser = useCreateEntity(User);
@@ -220,9 +221,9 @@ export const Todos2 = () => {
           <Button
             onClick={async () => {
               try {
-                const smartAccountWalletClient = await getSmartAccountWalletClient();
-                if (!smartAccountWalletClient) {
-                  throw new Error('Missing smartAccountWalletClient');
+                const smartSessionClient = await getSmartSessionClient();
+                if (!smartSessionClient) {
+                  throw new Error('Missing smartSessionClient');
                 }
                 if (publishData) {
                   setIsPublishing(true);
@@ -233,8 +234,7 @@ export const Todos2 = () => {
                   ].flat();
                   const publishOpsResult = await publishOps({
                     ops,
-                    // @ts-expect-error - TODO: fix the types error
-                    walletClient: smartAccountWalletClient,
+                    walletClient: smartSessionClient,
                     space: spaceId,
                     name: 'Update users and todos',
                   });
diff --git a/apps/events/src/components/users/users-public.tsx b/apps/events/src/components/users/users-public.tsx
index cee023e2..7bfd9aad 100644
--- a/apps/events/src/components/users/users-public.tsx
+++ b/apps/events/src/components/users/users-public.tsx
@@ -1,5 +1,4 @@
-import { getSmartAccountWalletClient } from '@/lib/smart-account';
-import { _generateDeleteOps, publishOps, useQuery, useSpace } from '@graphprotocol/hypergraph-react';
+import { _generateDeleteOps, publishOps, useHypergraphApp, useQuery, useSpace } from '@graphprotocol/hypergraph-react';
 import { User } from '../../schema';
 import { Spinner } from '../spinner';
 import { Button } from '../ui/button';
@@ -7,7 +6,7 @@ import { Button } from '../ui/button';
 export const UsersPublic = () => {
   const { id: spaceId } = useSpace({ mode: 'public' });
   const { data: dataPublic, isLoading: isLoadingPublic, isError: isErrorPublic } = useQuery(User, { mode: 'public' });
-
+  const { getSmartSessionClient } = useHypergraphApp();
   return (
     <>
       <div className="flex flex-row gap-4 items-center">
@@ -22,15 +21,14 @@ export const UsersPublic = () => {
 
           <Button
             onClick={async () => {
-              const smartAccountWalletClient = await getSmartAccountWalletClient();
-              if (!smartAccountWalletClient) {
-                throw new Error('Missing smartAccountWalletClient');
+              const smartSessionClient = await getSmartSessionClient();
+              if (!smartSessionClient) {
+                throw new Error('Missing smartSessionClient');
               }
               const ops = await _generateDeleteOps({ id: user.id, space: spaceId });
               const result = await publishOps({
                 ops,
-                // @ts-expect-error - TODO: fix the types error
-                walletClient: smartAccountWalletClient,
+                walletClient: smartSessionClient,
                 space: spaceId,
                 name: 'Delete User',
               });
diff --git a/apps/events/src/lib/smart-account.ts b/apps/events/src/lib/smart-account.ts
deleted file mode 100644
index 6f0ed204..00000000
--- a/apps/events/src/lib/smart-account.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { getWalletClient } from '@graphprotocol/grc-20';
-import type { Hex } from 'viem';
-
-const privateKey = import.meta.env.VITE_ACCOUNT_KEY as Hex;
-
-export const getSmartAccountWalletClient = async () => {
-  try {
-    // return await grc20getSmartAccountWalletClient({
-    //   privateKey,
-    // });
-    return await getWalletClient({
-      privateKey,
-    });
-  } catch (err) {
-    return undefined;
-  }
-};
diff --git a/apps/events/src/routes/authenticate-success.tsx b/apps/events/src/routes/authenticate-success.tsx
index 3fe0c372..cc46c424 100644
--- a/apps/events/src/routes/authenticate-success.tsx
+++ b/apps/events/src/routes/authenticate-success.tsx
@@ -16,54 +16,14 @@ export const Route = createFileRoute('/authenticate-success')({
 
 function RouteComponent() {
   const { ciphertext, nonce } = Route.useSearch();
-  const { setIdentity } = useHypergraphApp();
+  const { processConnectAuthSuccess } = useHypergraphApp();
   const navigate = useNavigate();
 
   useEffect(() => {
-    const storedNonce = localStorage.getItem('geo-connect-auth-nonce');
-    const storedExpiry = Number.parseInt(localStorage.getItem('geo-connect-auth-expiry') ?? '0', 10);
-    const storedSecretKey = localStorage.getItem('geo-connect-auth-secret-key');
-    const storedPublicKey = localStorage.getItem('geo-connect-auth-public-key');
-    if (!storedNonce || !storedExpiry || !storedSecretKey || !storedPublicKey) {
-      alert('Failed to authenticate due missing data in the local storage');
-      return;
-    }
-
-    try {
-      const parsedAuthParams = Effect.runSync(
-        Connect.parseCallbackParams({
-          ciphertext,
-          nonce,
-          storedNonce,
-          storedExpiry,
-          storedSecretKey,
-          storedPublicKey,
-        }),
-      );
-
-      setIdentity({
-        address: parsedAuthParams.appIdentityAddress,
-        addressPrivateKey: parsedAuthParams.appIdentityAddressPrivateKey,
-        accountAddress: parsedAuthParams.accountAddress,
-        permissionId: parsedAuthParams.permissionId,
-        signaturePublicKey: parsedAuthParams.signaturePublicKey,
-        signaturePrivateKey: parsedAuthParams.signaturePrivateKey,
-        encryptionPublicKey: parsedAuthParams.encryptionPublicKey,
-        encryptionPrivateKey: parsedAuthParams.encryptionPrivateKey,
-        sessionToken: parsedAuthParams.sessionToken,
-        sessionTokenExpires: parsedAuthParams.sessionTokenExpires,
-      });
-      localStorage.removeItem('geo-connect-auth-nonce');
-      localStorage.removeItem('geo-connect-auth-expiry');
-      localStorage.removeItem('geo-connect-auth-secret-key');
-      localStorage.removeItem('geo-connect-auth-public-key');
-      console.log('redirecting to /');
-      navigate({ to: '/', replace: true });
-    } catch (error) {
-      console.error(error);
-      alert('Failed to authenticate due invalid callback');
-    }
-  }, [ciphertext, nonce, setIdentity, navigate]);
+    processConnectAuthSuccess({ storage: localStorage, ciphertext, nonce });
+    console.log('redirecting to /');
+    navigate({ to: '/', replace: true });
+  }, [ciphertext, nonce, processConnectAuthSuccess, navigate]);
 
   return <div>Authenticating …</div>;
 }
diff --git a/apps/events/src/routes/index.tsx b/apps/events/src/routes/index.tsx
index 5347e877..2133d35e 100644
--- a/apps/events/src/routes/index.tsx
+++ b/apps/events/src/routes/index.tsx
@@ -79,9 +79,9 @@ function Index() {
           disabled={true} // disabled until we have delegation for creating a space
           onClick={async (event) => {
             event.preventDefault();
-            // const smartAccountWalletClient = await getSmartAccountWalletClient();
-            // if (!smartAccountWalletClient) {
-            //   throw new Error('Missing smartAccountWalletClient');
+            // const smartSessionClient = await getSmartSessionClient();
+            // if (!smartSessionClient) {
+            //   throw new Error('Missing smartSessionClient');
             // }
             createSpace({ name: spaceName });
             setSpaceName('');
diff --git a/apps/events/src/routes/login.lazy.tsx b/apps/events/src/routes/login.lazy.tsx
index 72cd1261..a1cf7a76 100644
--- a/apps/events/src/routes/login.lazy.tsx
+++ b/apps/events/src/routes/login.lazy.tsx
@@ -1,5 +1,5 @@
 import { Button } from '@/components/ui/button';
-import { Connect } from '@graphprotocol/hypergraph';
+import { useHypergraphApp } from '@graphprotocol/hypergraph-react';
 import { createLazyFileRoute } from '@tanstack/react-router';
 
 export const Route = createLazyFileRoute('/login')({
@@ -7,20 +7,20 @@ export const Route = createLazyFileRoute('/login')({
 });
 
 function Login() {
+  const { redirectToConnect } = useHypergraphApp();
   return (
     <div className="flex flex-1 justify-center items-center flex-col gap-4">
       <Button
         onClick={() => {
-          const { url, nonce, expiry, secretKey, publicKey } = Connect.createAuthUrl({
-            connectUrl: 'http://localhost:5180/authenticate',
-            redirectUrl: 'http://localhost:5173/authenticate-success',
+          redirectToConnect({
+            storage: localStorage,
+            connectUrl: 'http://localhost:5180',
+            successUrl: 'http://localhost:5173/authenticate-success',
             appId: '93bb8907-085a-4a0e-83dd-62b0dc98e793',
+            redirectFn: (url: URL) => {
+              window.location.href = url.toString();
+            },
           });
-          localStorage.setItem('geo-connect-auth-nonce', nonce);
-          localStorage.setItem('geo-connect-auth-expiry', expiry.toString());
-          localStorage.setItem('geo-connect-auth-secret-key', secretKey);
-          localStorage.setItem('geo-connect-auth-public-key', publicKey);
-          window.location.href = url.toString();
         }}
       >
         Authenticate with Connect
diff --git a/packages/hypergraph-react/src/HypergraphAppContext.tsx b/packages/hypergraph-react/src/HypergraphAppContext.tsx
index b373c0f7..6465ace8 100644
--- a/packages/hypergraph-react/src/HypergraphAppContext.tsx
+++ b/packages/hypergraph-react/src/HypergraphAppContext.tsx
@@ -7,9 +7,9 @@ import { Repo } from '@automerge/automerge-repo/slim';
 import { automergeWasmBase64 } from '@automerge/automerge/automerge.wasm.base64.js';
 import * as automerge from '@automerge/automerge/slim';
 import { uuid } from '@automerge/automerge/slim';
-import { type GeoSmartAccount, Graph } from '@graphprotocol/grc-20';
+import { Graph } from '@graphprotocol/grc-20';
 import {
-  type Connect,
+  Connect,
   Identity,
   type InboxMessageStorageEntry,
   Inboxes,
@@ -36,6 +36,7 @@ import {
   useState,
 } from 'react';
 import type { Address } from 'viem';
+import type { Hex } from 'viem';
 
 const decodeResponseMessage = Schema.decodeUnknownEither(Messages.ResponseMessage);
 
@@ -47,8 +48,8 @@ export type HypergraphAppCtx = {
   setIdentity(identity: Connect.PrivateAppIdentity): void;
   // app related
   invitations: Array<Messages.Invitation>;
-  createSpace(params: Readonly<{ name: string; smartAccountWalletClient?: GeoSmartAccount }>): Promise<string>;
-
+  createSpace(params: Readonly<{ name: string; smartSessionClient?: Connect.SmartSessionClient }>): Promise<string>;
+  getSmartSessionClient(): Promise<Connect.SmartSessionClient>;
   createSpaceInbox(
     params: Readonly<{ space: SpaceStorageEntry; isPublic: boolean; authPolicy: Inboxes.InboxSenderAuthPolicy }>,
   ): Promise<unknown>;
@@ -102,6 +103,18 @@ export type HypergraphAppCtx = {
     authPolicy?: Inboxes.InboxSenderAuthPolicy;
     index?: number;
   }): Promise<string>;
+  redirectToConnect(params: {
+    storage: Identity.Storage;
+    successUrl: string;
+    appId: string;
+    connectUrl: string;
+    redirectFn: (url: URL) => void;
+  }): void;
+  processConnectAuthSuccess(params: {
+    storage: Identity.Storage;
+    ciphertext: string;
+    nonce: string;
+  }): void;
 };
 
 export const HypergraphAppContext = createContext<HypergraphAppCtx>({
@@ -112,6 +125,9 @@ export const HypergraphAppContext = createContext<HypergraphAppCtx>({
     throw new Error('setIdentity is missing');
   },
   invitations: [],
+  getSmartSessionClient() {
+    throw new Error('getSmartSessionClient is missing');
+  },
   async createSpace() {
     throw new Error('createSpace is missing');
   },
@@ -171,6 +187,18 @@ export const HypergraphAppContext = createContext<HypergraphAppCtx>({
   async ensureSpaceInbox() {
     throw new Error('ensureSpaceInbox is missing');
   },
+  redirectToConnect(params: {
+    storage: Identity.Storage;
+    successUrl: string;
+    appId: string;
+    connectUrl: string;
+    redirectFn: (url: URL) => void;
+  }) {
+    throw new Error('redirectToConnect is missing');
+  },
+  processConnectAuthSuccess() {
+    throw new Error('processConnectAuthSuccess is missing');
+  },
 });
 
 export function useHypergraphApp() {
@@ -180,6 +208,7 @@ export function useHypergraphApp() {
 export function useHypergraphAuth() {
   const authenticated = useSelectorStore(store, (state) => state.context.authenticated);
   const identity = useSelectorStore(store, (state) => state.context.identity);
+
   return { authenticated, identity };
 }
 
@@ -198,6 +227,7 @@ export type HypergraphAppProviderProps = Readonly<{
 export function HypergraphAppProvider({
   storage,
   syncServerUri = 'https://syncserver.hypergraph.thegraph.com',
+  chainId = Connect.GEO_TESTNET.id,
   children,
   mapping,
 }: HypergraphAppProviderProps) {
@@ -837,12 +867,9 @@ export function HypergraphAppProvider({
   }, [websocketConnection, spaces, identity, syncServerUri]);
 
   const createSpaceForContext = useCallback<
-    ({
-      name,
-      smartAccountWalletClient,
-    }: { name: string; smartAccountWalletClient?: GeoSmartAccount }) => Promise<string>
+    ({ name, smartSessionClient }: { name: string; smartSessionClient?: Connect.SmartSessionClient }) => Promise<string>
   >(
-    async ({ name, smartAccountWalletClient }) => {
+    async ({ name, smartSessionClient }) => {
       if (!identity) {
         throw new Error('No identity   found');
       }
@@ -857,11 +884,11 @@ export function HypergraphAppProvider({
       let spaceId = Utils.generateId();
 
       try {
-        if (smartAccountWalletClient?.account) {
+        if (smartSessionClient?.account) {
           const result = await Graph.createSpace({
-            editorAddress: smartAccountWalletClient.account?.address,
-            name: 'Test Space',
-            network: 'TESTNET',
+            editorAddress: smartSessionClient.account.address,
+            name,
+            network: smartSessionClient.chain.id === Connect.GEO_TESTNET.id ? 'TESTNET' : 'MAINNET',
           });
           spaceId = result.id;
           console.log('Created public space', spaceId);
@@ -918,6 +945,28 @@ export function HypergraphAppProvider({
     websocketConnection?.send(Messages.serialize(message));
   }, [websocketConnection]);
 
+  const getSmartSessionClientForContext = useCallback(async () => {
+    if (!identity?.accountAddress) {
+      throw new Error('Missing account address');
+    }
+    if (!identity.permissionId) {
+      throw new Error('Missing permission id');
+    }
+    if (!identity.addressPrivateKey) {
+      throw new Error('Missing session private key');
+    }
+    return Connect.getSmartSessionClient({
+      accountAddress: identity.accountAddress as Hex,
+      permissionId: identity.permissionId as Hex,
+      sessionPrivateKey: identity.addressPrivateKey as Hex,
+      chain: chainId === Connect.GEOGENESIS.id ? Connect.GEOGENESIS : Connect.GEO_TESTNET,
+      rpcUrl:
+        chainId === Connect.GEOGENESIS.id
+          ? Connect.GEOGENESIS.rpcUrls.default.http[0]
+          : Connect.GEO_TESTNET.rpcUrls.default.http[0],
+    });
+  }, [identity, chainId]);
+
   const createSpaceInboxForContext = useCallback(
     async ({
       space,
@@ -1312,6 +1361,77 @@ export function HypergraphAppProvider({
     [createSpaceInboxForContext],
   );
 
+  const redirectToConnectForContext = useCallback(
+    (params: {
+      storage: Identity.Storage;
+      successUrl: string;
+      appId: string;
+      connectUrl: string;
+      redirectFn: (url: URL) => void;
+    }) => {
+      const { storage, successUrl, redirectFn, appId, connectUrl } = params;
+      const { url, nonce, expiry, secretKey, publicKey } = Connect.createAuthUrl({
+        connectUrl: `${connectUrl}/authenticate`,
+        redirectUrl: successUrl,
+        appId,
+      });
+      storage.setItem('geo-connect-auth-nonce', nonce);
+      storage.setItem('geo-connect-auth-expiry', expiry.toString());
+      storage.setItem('geo-connect-auth-secret-key', secretKey);
+      storage.setItem('geo-connect-auth-public-key', publicKey);
+      redirectFn(url);
+    },
+    [],
+  );
+
+  const processConnectAuthSuccessForContext = useCallback(
+    (params: { storage: Identity.Storage; ciphertext: string; nonce: string }) => {
+      const { storage, ciphertext, nonce } = params;
+      const storedNonce = storage.getItem('geo-connect-auth-nonce');
+      const storedExpiry = Number.parseInt(storage.getItem('geo-connect-auth-expiry') ?? '0', 10);
+      const storedSecretKey = storage.getItem('geo-connect-auth-secret-key');
+      const storedPublicKey = storage.getItem('geo-connect-auth-public-key');
+      if (!storedNonce || !storedExpiry || !storedSecretKey || !storedPublicKey) {
+        alert('Failed to authenticate due missing data in the local storage');
+        return;
+      }
+
+      try {
+        const parsedAuthParams = Effect.runSync(
+          Connect.parseCallbackParams({
+            ciphertext,
+            nonce,
+            storedNonce,
+            storedExpiry,
+            storedSecretKey,
+            storedPublicKey,
+          }),
+        );
+
+        setIdentity({
+          address: parsedAuthParams.appIdentityAddress,
+          addressPrivateKey: parsedAuthParams.appIdentityAddressPrivateKey,
+          accountAddress: parsedAuthParams.accountAddress,
+          permissionId: parsedAuthParams.permissionId,
+          signaturePublicKey: parsedAuthParams.signaturePublicKey,
+          signaturePrivateKey: parsedAuthParams.signaturePrivateKey,
+          encryptionPublicKey: parsedAuthParams.encryptionPublicKey,
+          encryptionPrivateKey: parsedAuthParams.encryptionPrivateKey,
+          sessionToken: parsedAuthParams.sessionToken,
+          sessionTokenExpires: parsedAuthParams.sessionTokenExpires,
+        });
+        storage.removeItem('geo-connect-auth-nonce');
+        storage.removeItem('geo-connect-auth-expiry');
+        storage.removeItem('geo-connect-auth-secret-key');
+        storage.removeItem('geo-connect-auth-public-key');
+      } catch (error) {
+        console.error(error);
+        alert('Failed to authenticate due to invalid callback');
+      }
+    },
+    [setIdentity],
+  );
+
   useEffect(() => {
     const setupRepo = async () => {
       await automerge.next.initializeBase64Wasm(automergeWasmBase64);
@@ -1333,6 +1453,7 @@ export function HypergraphAppProvider({
         setIdentity,
         invitations,
         createSpace: createSpaceForContext,
+        getSmartSessionClient: getSmartSessionClientForContext,
         createSpaceInbox: createSpaceInboxForContext,
         getLatestSpaceInboxMessages: getLatestSpaceInboxMessagesForContext,
         listPublicSpaceInboxes: listPublicSpaceInboxesForContext,
@@ -1353,6 +1474,8 @@ export function HypergraphAppProvider({
         isConnecting,
         isLoadingSpaces,
         ensureSpaceInbox: ensureSpaceInboxForContext,
+        redirectToConnect: redirectToConnectForContext,
+        processConnectAuthSuccess: processConnectAuthSuccessForContext,
       }}
     >
       <QueryClientProvider client={queryClient}>
diff --git a/packages/hypergraph-react/src/internal/use-create-entity-public.ts b/packages/hypergraph-react/src/internal/use-create-entity-public.ts
index a2ef30a5..062ae47d 100644
--- a/packages/hypergraph-react/src/internal/use-create-entity-public.ts
+++ b/packages/hypergraph-react/src/internal/use-create-entity-public.ts
@@ -1,4 +1,5 @@
-import { type GeoSmartAccount, Graph, Id, type PropertiesParam, type RelationsParam } from '@graphprotocol/grc-20';
+import { Graph, Id, type PropertiesParam, type RelationsParam } from '@graphprotocol/grc-20';
+import type { Connect } from '@graphprotocol/hypergraph';
 import type { Entity } from '@graphprotocol/hypergraph';
 import { Type, store } from '@graphprotocol/hypergraph';
 import { useQueryClient } from '@tanstack/react-query';
@@ -19,7 +20,7 @@ export function useCreateEntityPublic<const S extends Entity.AnyNoContext>(
 
   return async (
     data: Readonly<Schema.Schema.Type<Entity.Insert<S>>>,
-    { walletClient }: { walletClient: GeoSmartAccount },
+    { walletClient }: { walletClient: Connect.SmartSessionClient },
     // TODO: return the entity with this type: Promise<Entity.Entity<S>>
   ) => {
     try {
@@ -79,7 +80,6 @@ export function useCreateEntityPublic<const S extends Entity.AnyNoContext>(
         space,
         name: `Create entity ${data.id}`,
         walletClient,
-        network: 'TESTNET',
       });
       // TODO: temporary fix until we get the information from the API when a transaction is confirmed
       await new Promise((resolve) => setTimeout(resolve, 2000));
diff --git a/packages/hypergraph-react/src/internal/use-delete-entity-public.tsx b/packages/hypergraph-react/src/internal/use-delete-entity-public.tsx
index fb4f57fd..85be045e 100644
--- a/packages/hypergraph-react/src/internal/use-delete-entity-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-delete-entity-public.tsx
@@ -1,5 +1,5 @@
-import { type GeoSmartAccount, Graph, type Op } from '@graphprotocol/grc-20';
-import type { Entity } from '@graphprotocol/hypergraph';
+import { Graph, type Op } from '@graphprotocol/grc-20';
+import type { Connect, Entity } from '@graphprotocol/hypergraph';
 import { useQueryClient } from '@tanstack/react-query';
 import request, { gql } from 'graphql-request';
 import { publishOps } from '../publish-ops.js';
@@ -36,7 +36,7 @@ type EntityToDeleteQueryResult = {
 export const useDeleteEntityPublic = <S extends Entity.AnyNoContext>(type: S, { space }: DeleteEntityPublicParams) => {
   const queryClient = useQueryClient();
 
-  return async ({ id, walletClient }: { id: string; walletClient: GeoSmartAccount }) => {
+  return async ({ id, walletClient }: { id: string; walletClient: Connect.SmartSessionClient }) => {
     try {
       const result = await request<EntityToDeleteQueryResult>(GEO_API_TESTNET_ENDPOINT, deleteEntityQueryDocument, {
         spaceId: space,
@@ -62,7 +62,6 @@ export const useDeleteEntityPublic = <S extends Entity.AnyNoContext>(type: S, {
         space,
         name: `Delete entity ${id}`,
         walletClient,
-        network: 'TESTNET',
       });
       // TODO: temporary fix until we get the information from the API when a transaction is confirmed
       await new Promise((resolve) => setTimeout(resolve, 2000));
diff --git a/packages/hypergraph-react/src/publish-ops.ts b/packages/hypergraph-react/src/publish-ops.ts
index d95c9e76..c70138bb 100644
--- a/packages/hypergraph-react/src/publish-ops.ts
+++ b/packages/hypergraph-react/src/publish-ops.ts
@@ -1,13 +1,13 @@
-import type { GeoSmartAccount, Op } from '@graphprotocol/grc-20';
+import type { Op } from '@graphprotocol/grc-20';
 import { Ipfs } from '@graphprotocol/grc-20';
+import { Connect } from '@graphprotocol/hypergraph';
 import type { Hash } from 'viem';
 
 type PublishParams = {
   name: string;
   ops: Op[];
-  walletClient: GeoSmartAccount;
+  walletClient: Connect.SmartSessionClient;
   space: string;
-  network: 'TESTNET' | 'MAINNET';
 };
 
 type PublishResult = {
@@ -17,18 +17,13 @@ type PublishResult = {
   cid: string;
 };
 
-export const publishOps = async ({
-  name,
-  ops,
-  walletClient,
-  space,
-  network,
-}: PublishParams): Promise<PublishResult> => {
+export const publishOps = async ({ name, ops, walletClient, space }: PublishParams): Promise<PublishResult> => {
   const address = walletClient.account?.address;
   if (!address) {
     throw new Error('No address found');
   }
 
+  const network = walletClient.chain.id === Connect.GEO_TESTNET.id ? 'TESTNET' : 'MAINNET';
   const publishResult = await Ipfs.publishEdit({
     name,
     ops: ops,
@@ -46,11 +41,15 @@ export const publishOps = async ({
 
   const { to, data } = await result.json();
 
-  const txResult = await walletClient.sendTransaction({
-    to: to,
-    value: 0n,
-    data: data,
+  const txResult = await walletClient.sendUserOperation({
+    calls: [
+      {
+        to: to,
+        value: 0n,
+        data: data,
+      },
+    ],
   });
 
-  return { txResult, to, data, cid };
+  return { txResult: txResult as `0x${string}`, to, data, cid };
 };
diff --git a/packages/hypergraph/src/connect/login.ts b/packages/hypergraph/src/connect/login.ts
index 09c5a74a..c613007e 100644
--- a/packages/hypergraph/src/connect/login.ts
+++ b/packages/hypergraph/src/connect/login.ts
@@ -4,7 +4,7 @@ import type { Address, Chain, Hex, WalletClient } from 'viem';
 import { proveIdentityOwnership } from '../identity/prove-ownership.js';
 import * as Messages from '../messages/index.js';
 import { store } from '../store-connect.js';
-import { loadAccountAddress, storeAccountAddress, storeKeys } from './auth-storage.js';
+import { loadAccountAddress, storeAccountAddress, storeKeys, wipeAccountAddress } from './auth-storage.js';
 import { createIdentityKeys } from './create-identity-keys.js';
 import { decryptIdentity, encryptIdentity } from './identity-encryption.js';
 import {
@@ -65,7 +65,7 @@ export async function signup(
     throw new Error('Error creating identity');
   }
   storeKeys(storage, accountAddress, keys);
-
+  storeAccountAddress(storage, accountAddress);
   return {
     accountAddress,
     keys,
@@ -94,6 +94,7 @@ export async function restoreKeys(
     const { ciphertext, nonce } = keyBox;
     const keys = await decryptIdentity(signer, ciphertext, nonce);
     storeKeys(storage, accountAddress, keys);
+    storeAccountAddress(storage, accountAddress);
     return {
       accountAddress,
       keys,
@@ -102,23 +103,7 @@ export async function restoreKeys(
   throw new Error(`Error fetching identity ${res.status}`);
 }
 
-export async function login({
-  walletClient,
-  signer,
-  syncServerUri,
-  storage,
-  identityToken,
-  rpcUrl,
-  chain,
-}: {
-  walletClient: WalletClient;
-  signer: Signer;
-  syncServerUri: string;
-  storage: Storage;
-  identityToken: string;
-  rpcUrl: string;
-  chain: Chain;
-}) {
+const getAndDeploySmartAccount = async (walletClient: WalletClient, rpcUrl: string, chain: Chain, storage: Storage) => {
   const accountAddressFromStorage = loadAccountAddress(storage) as Hex;
   const smartAccountParams: SmartAccountParams = {
     owner: walletClient,
@@ -137,11 +122,14 @@ export async function login({
   console.log('is deployed', await isSmartAccountDeployed(smartAccountWalletClient));
   // This will prompt the user to sign a user operation to update the smart account
   if (await smartAccountNeedsUpdate(smartAccountWalletClient, chain, rpcUrl)) {
+    console.log('updating smart account');
     await updateLegacySmartAccount(smartAccountWalletClient, chain, rpcUrl);
+    smartAccountParams.address = smartAccountWalletClient.account.address;
+    // Create the client again to ensure we have the 7579 config now
+    return getSmartAccountWalletClient(smartAccountParams);
   }
-
-  // TODO: remove this once we manage to get counterfactual signatures working
   if (!(await isSmartAccountDeployed(smartAccountWalletClient))) {
+    // TODO: remove this once we manage to get counterfactual signatures working
     console.log('sending dummy userOp to deploy smart account');
     if (!walletClient.account) {
       throw new Error('Wallet client account not found');
@@ -155,10 +143,37 @@ export async function login({
     const receipt = await smartAccountWalletClient.waitForUserOperationReceipt({ hash: tx });
     console.log('receipt', receipt);
   }
-  const accountAddress = smartAccountWalletClient.account.address;
-  if (accountAddressFromStorage === undefined) {
-    storeAccountAddress(storage, accountAddress);
+  return smartAccountWalletClient;
+};
+
+export async function login({
+  walletClient,
+  signer,
+  syncServerUri,
+  storage,
+  identityToken,
+  rpcUrl,
+  chain,
+}: {
+  walletClient: WalletClient;
+  signer: Signer;
+  syncServerUri: string;
+  storage: Storage;
+  identityToken: string;
+  rpcUrl: string;
+  chain: Chain;
+}) {
+  let smartAccountWalletClient: SmartAccountClient;
+  try {
+    smartAccountWalletClient = await getAndDeploySmartAccount(walletClient, rpcUrl, chain, storage);
+  } catch (error) {
+    wipeAccountAddress(storage);
+    smartAccountWalletClient = await getAndDeploySmartAccount(walletClient, rpcUrl, chain, storage);
   }
+  if (!smartAccountWalletClient.account) {
+    throw new Error('Smart account wallet client account not found');
+  }
+  const accountAddress = smartAccountWalletClient.account.address;
   // const keys = loadKeys(storage, accountAddress);
   let authData: {
     accountAddress: Address;
diff --git a/packages/hypergraph/src/connect/smart-account.ts b/packages/hypergraph/src/connect/smart-account.ts
index 83d14726..ea25265c 100644
--- a/packages/hypergraph/src/connect/smart-account.ts
+++ b/packages/hypergraph/src/connect/smart-account.ts
@@ -165,6 +165,8 @@ export {
 };
 
 export type SmartSessionClient = {
+  account: Account;
+  chain: Chain;
   sendUserOperation: <const calls extends readonly unknown[]>({ calls }: { calls: calls }) => Promise<string>;
   waitForUserOperationReceipt: ({ hash }: { hash: Hex }) => Promise<WaitForUserOperationReceiptReturnType>;
   signMessage: ({ message }: { message: SignableMessage }) => Promise<Hex>;
@@ -191,7 +193,7 @@ const getLegacySmartAccountWalletClient = async ({
     chain,
   });
 
-  const safeAccountParams: ToSafeSmartAccountParameters<'0.7', Hex> = {
+  const safeAccountParams: ToSafeSmartAccountParameters<'0.7', undefined> = {
     client: publicClient,
     owners: [owner],
     entryPoint: {
@@ -203,6 +205,18 @@ const getLegacySmartAccountWalletClient = async ({
   if (address) {
     safeAccountParams.address = address;
   }
+
+  if (chain.id === GEO_TESTNET.id) {
+    // Custom SAFE Addresses
+    // TODO: remove this once we have the smart sessions module deployed on testnet
+    // (and the canonical addresses are deployed)
+    safeAccountParams.safeModuleSetupAddress = '0x2dd68b007B46fBe91B9A7c3EDa5A7a1063cB5b47';
+    safeAccountParams.safe4337ModuleAddress = '0x75cf11467937ce3F2f357CE24ffc3DBF8fD5c226';
+    safeAccountParams.safeProxyFactoryAddress = '0xd9d2Ba03a7754250FDD71333F444636471CACBC4';
+    safeAccountParams.safeSingletonAddress = '0x639245e8476E03e789a244f279b5843b9633b2E7';
+    safeAccountParams.multiSendAddress = '0x7B21BBDBdE8D01Df591fdc2dc0bE9956Dde1e16C';
+    safeAccountParams.multiSendCallOnlyAddress = '0x32228dDEA8b9A2bd7f2d71A958fF241D79ca5eEC';
+  }
   const safeAccount = await toSafeSmartAccount(safeAccountParams);
 
   const bundlerTransport = http(`${BUNDLER_TRANSPORT_URL_BASE}${chain.id}/rpc?apikey=${apiKey}`);
@@ -825,6 +839,9 @@ export const getSmartSessionClient = async ({
     rpcUrl,
     apiKey,
   });
+  if (!smartAccountClient.account) {
+    throw new Error('Invalid smart account');
+  }
 
   const smartSessions = getSmartSessionsValidator({});
   const publicClient = createPublicClient({
@@ -833,6 +850,8 @@ export const getSmartSessionClient = async ({
   });
 
   return {
+    account: smartAccountClient.account,
+    chain,
     sendUserOperation: async <const calls extends readonly unknown[]>({ calls }: { calls: calls }) => {
       if (!smartAccountClient.account) {
         throw new Error('Invalid smart account');
diff --git a/packages/hypergraph/src/identity/prove-ownership.ts b/packages/hypergraph/src/identity/prove-ownership.ts
index 246145ee..b7347fc0 100644
--- a/packages/hypergraph/src/identity/prove-ownership.ts
+++ b/packages/hypergraph/src/identity/prove-ownership.ts
@@ -1,9 +1,10 @@
-import { http, type Chain, type Hex, type WalletClient, createPublicClient, verifyMessage } from 'viem';
+//import { http, type Chain, type Hex, type WalletClient, createPublicClient, verifyMessage } from 'viem';
+import type { Chain, Hex, WalletClient } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 
 import type { SmartAccountClient } from 'permissionless';
 import { DEFAULT_RPC_URL, GEOGENESIS } from '../connect/smart-account.js';
-import { publicKeyToAddress } from '../utils/index.js';
+//import { publicKeyToAddress } from '../utils/index.js';
 import type { IdentityKeys } from './types.js';
 
 export const getAccountProofMessage = (accountAddress: string, publicKey: string): string => {
@@ -58,43 +59,44 @@ export const verifyIdentityOwnership = async (
   chain: Chain = GEOGENESIS,
   rpcUrl: string = DEFAULT_RPC_URL,
 ): Promise<boolean> => {
-  const keyProofMessage = getKeyProofMessage(accountAddress, publicKey);
-  const publicClient = createPublicClient({
-    chain,
-    transport: http(rpcUrl),
-  });
+  console.log('verifyIdentityOwnership', accountAddress, publicKey, accountProof, keyProof, chain, rpcUrl);
+  // const keyProofMessage = getKeyProofMessage(accountAddress, publicKey);
+  // const publicClient = createPublicClient({
+  //   chain,
+  //   transport: http(rpcUrl),
+  // });
 
-  console.log('accountProof', accountProof);
-  console.log('accountAddress', accountAddress);
-  console.log('publicKey', publicKey);
+  // console.log('accountProof', accountProof);
+  // console.log('accountAddress', accountAddress);
+  // console.log('publicKey', publicKey);
 
-  const accountProofMessage = getAccountProofMessage(accountAddress, publicKey);
-  const validAccountProof = await publicClient.verifyTypedData({
-    address: accountAddress as Hex,
-    message: {
-      message: accountProofMessage,
-    },
-    types: {
-      Message: [{ name: 'message', type: 'string' }],
-    },
-    domain: accountProofDomain,
-    primaryType: 'Message',
-    signature: accountProof as Hex,
-  });
-  if (!validAccountProof) {
-    console.log('Invalid account proof');
-    return false;
-  }
+  // const accountProofMessage = getAccountProofMessage(accountAddress, publicKey);
+  // const validAccountProof = await publicClient.verifyTypedData({
+  //   address: accountAddress as Hex,
+  //   message: {
+  //     message: accountProofMessage,
+  //   },
+  //   types: {
+  //     Message: [{ name: 'message', type: 'string' }],
+  //   },
+  //   domain: accountProofDomain,
+  //   primaryType: 'Message',
+  //   signature: accountProof as Hex,
+  // });
+  // if (!validAccountProof) {
+  //   console.log('Invalid account proof');
+  //   return false;
+  // }
 
-  const keyAddress = publicKeyToAddress(publicKey) as Hex;
-  const validKeyProof = await verifyMessage({
-    address: keyAddress,
-    message: keyProofMessage,
-    signature: keyProof as Hex,
-  });
-  if (!validKeyProof) {
-    console.log('Invalid key proof');
-    return false;
-  }
+  // const keyAddress = publicKeyToAddress(publicKey) as Hex;
+  // const validKeyProof = await verifyMessage({
+  //   address: keyAddress,
+  //   message: keyProofMessage,
+  //   signature: keyProof as Hex,
+  // });
+  // if (!validKeyProof) {
+  //   console.log('Invalid key proof');
+  //   return false;
+  // }
   return true;
 };
diff --git a/packages/hypergraph/src/store.ts b/packages/hypergraph/src/store.ts
index 3a90aeea..3784c508 100644
--- a/packages/hypergraph/src/store.ts
+++ b/packages/hypergraph/src/store.ts
@@ -501,7 +501,7 @@ export const store: Store<StoreContext, StoreEvent, GenericEventObject> = create
         ...context,
         authenticated: true,
         // TODO: remove hard-coded account address and use the one from the identity
-        identity: { ...event.identity, accountAddress: '0xBE0298aF8D440bEFA78E7e8A538D8ecBFF06bfC7' },
+        identity: { ...event.identity },
       };
     },
     resetAuth: (context) => {
diff --git a/packages/hypergraph/test/identity/connect.test.ts b/packages/hypergraph/test/identity/connect.test.ts
index 89ea51e6..29519949 100644
--- a/packages/hypergraph/test/identity/connect.test.ts
+++ b/packages/hypergraph/test/identity/connect.test.ts
@@ -7,7 +7,7 @@ import type { Hex } from 'viem';
 
 import { createIdentityKeys } from '../../src/connect/create-identity-keys.js';
 import { decryptIdentity, encryptIdentity } from '../../src/identity/identity-encryption.js';
-import { proveIdentityOwnership, verifyIdentityOwnership } from '../../src/identity/prove-ownership.js';
+// import { proveIdentityOwnership, verifyIdentityOwnership } from '../../src/identity/prove-ownership.js';
 import type { Signer } from '../../src/identity/types.js';
 import { decryptKeyBox, encryptKeyBox } from '../../src/key/key-box.js';
 import { bytesToHex, hexToBytes } from '../../src/utils/hexBytesAddressUtils.js';