From c17c9099857ba669e82f663b236e6ff655f1398e Mon Sep 17 00:00:00 2001
From: Cesare Naldi <naldi.cesare@gmail.com>
Date: Thu, 5 Oct 2023 14:22:03 +0200
Subject: [PATCH] First pass at new useLogin hook

---
 examples/web/src/App.tsx                      |  31 +-
 examples/web/src/HomePage.tsx                 |  22 +-
 examples/web/src/Layout.tsx                   |  12 +
 examples/web/src/LogInPage.tsx                |  91 +++
 .../web/src/components/auth/LoginButton.tsx   |   6 +
 examples/web/src/components/auth/index.tsx    |   1 +
 examples/web/src/components/header/Header.tsx |   5 +-
 .../src/apollo/cache/__helpers__/mocks.ts     |  33 +-
 .../api-bindings/src/apollo/cache/session.ts  |  83 +--
 .../src/lens/__helpers__/queries.ts           |  37 +
 .../src/lens/graphql/generated.ts             |  25 +-
 .../src/lens/graphql/transaction.graphql      |   2 +
 packages/domain/src/entities/Transactions.ts  |   7 +
 .../authentication/__helpers__/mocks.ts       |   8 +
 .../src/use-cases/profile/IProfileGateway.ts  |   7 -
 .../domain/src/use-cases/profile/index.ts     |   1 -
 .../adapters/AccessTokenStorage.ts            |  67 ++
 .../src/authentication/adapters/AuthApi.ts    |  62 ++
 .../authentication/adapters/Credentials.ts    |  61 ++
 .../adapters/CredentialsExpiryController.ts   |  21 +
 .../adapters/CredentialsFactory.ts            |  48 ++
 .../adapters/CredentialsGateway.ts            |  23 +
 .../adapters/CredentialsStorage.ts            |  69 ++
 .../authentication/adapters/LoginPresenter.ts |  43 ++
 .../adapters/__helpers__/mocks.ts             |   8 +
 .../__tests__/CredentialsFactory.spec.ts      | 111 +++
 .../__tests__/CredentialsGateway.spec.ts      |  41 ++
 .../adapters/useLoginController.ts            |  29 +
 packages/react/src/authentication/index.ts    |   1 +
 packages/react/src/authentication/useLogin.ts |   7 +
 packages/react/src/config.ts                  |   8 +-
 packages/react/src/helpers/tasks.ts           |  64 ++
 packages/react/src/index.ts                   |   1 +
 .../src/polls/adapters/SnapshotVoteFactory.ts | 232 +++++++
 .../src/polls/adapters/SnapshotVoteRelayer.ts |  44 ++
 .../src/polls/adapters/__helpers__/mocks.ts   |   8 +
 .../__tests__/SnapshotVoteFactory.spec.ts     | 284 ++++++++
 .../__tests__/SnapshotVoteRelayer.spec.ts     |  99 +++
 packages/react/src/polls/adapters/types.ts    |  77 +++
 .../profile/adapters/IProfileCacheManager.ts  |  10 +
 .../infrastructure/ProfileCacheManager.ts     |  69 ++
 packages/react/src/shared.tsx                 |  74 +-
 .../adapters/ITransactionFactory.ts           |  45 ++
 .../ISerializableTransactionFactory.ts        |  46 ++
 .../PendingTransactionGateway.ts              | 209 ++++++
 .../PendingTransactionGateway.spec.ts         | 297 ++++++++
 .../PendingTransactionGateway/index.ts        |   6 +
 .../SelfFundedProtocolTransactionRequest.ts   |  16 +
 .../adapters/__helpers__/mocks.ts             |  97 +++
 .../schemas/__tests__/Erc20Amount.spec.ts     |  25 +
 .../schemas/__tests__/formatters.spec.ts      |  57 ++
 .../schemas/__tests__/validators.spec.ts      | 653 ++++++++++++++++++
 .../transactions/adapters/schemas/common.ts   |  62 ++
 .../transactions/adapters/schemas/erc20.ts    |  16 +
 .../adapters/schemas/formatters.ts            | 102 +++
 .../transactions/adapters/schemas/profiles.ts | 122 ++++
 .../adapters/schemas/publications.ts          | 408 +++++++++++
 .../adapters/schemas/transactions.ts          | 166 +++++
 .../adapters/schemas/validators.ts            |  70 ++
 .../infrastructure/TransactionFactory.ts      | 310 +++++++++
 .../infrastructure/TransactionObserver.ts     | 164 +++++
 .../infrastructure/__helpers__/mocks.ts       |  85 +++
 .../__tests__/TransactionFactory.spec.ts      | 218 ++++++
 .../__tests__/TransactionObserver.spec.ts     | 342 +++++++++
 .../src/wallet/adapters/ConcreteWallet.ts     | 324 +++++++++
 .../src/wallet/adapters/IProviderFactory.ts   |  10 +
 .../src/wallet/adapters/WalletFactory.ts      |  22 +
 .../src/wallet/adapters/WalletGateway.ts      |  62 ++
 .../src/wallet/adapters/__helpers__/mocks.ts  | 136 ++++
 .../adapters/__tests__/ConcreteWallet.spec.ts | 376 ++++++++++
 .../adapters/__tests__/WalletGateway.spec.ts  |  74 ++
 packages/react/src/wallet/adapters/errors.ts  |  11 +
 .../wallet/infrastructure/ProviderFactory.ts  |  32 +
 .../wallet/infrastructure/SignerFactory.ts    | 109 +++
 .../wallet/infrastructure/WalletStorage.ts    |  11 +
 .../infrastructure/__helpers__/mocks.ts       |  36 +
 .../__tests__/ProviderFactory.spec.ts         |  58 ++
 .../__tests__/SignerFactory.spec.ts           | 156 +++++
 78 files changed, 6716 insertions(+), 149 deletions(-)
 create mode 100644 examples/web/src/Layout.tsx
 create mode 100644 examples/web/src/LogInPage.tsx
 create mode 100644 examples/web/src/components/auth/LoginButton.tsx
 create mode 100644 examples/web/src/components/auth/index.tsx
 delete mode 100644 packages/domain/src/use-cases/profile/IProfileGateway.ts
 create mode 100644 packages/react/src/authentication/adapters/AccessTokenStorage.ts
 create mode 100644 packages/react/src/authentication/adapters/AuthApi.ts
 create mode 100644 packages/react/src/authentication/adapters/Credentials.ts
 create mode 100644 packages/react/src/authentication/adapters/CredentialsExpiryController.ts
 create mode 100644 packages/react/src/authentication/adapters/CredentialsFactory.ts
 create mode 100644 packages/react/src/authentication/adapters/CredentialsGateway.ts
 create mode 100644 packages/react/src/authentication/adapters/CredentialsStorage.ts
 create mode 100644 packages/react/src/authentication/adapters/LoginPresenter.ts
 create mode 100644 packages/react/src/authentication/adapters/__helpers__/mocks.ts
 create mode 100644 packages/react/src/authentication/adapters/__tests__/CredentialsFactory.spec.ts
 create mode 100644 packages/react/src/authentication/adapters/__tests__/CredentialsGateway.spec.ts
 create mode 100644 packages/react/src/authentication/adapters/useLoginController.ts
 create mode 100644 packages/react/src/authentication/index.ts
 create mode 100644 packages/react/src/authentication/useLogin.ts
 create mode 100644 packages/react/src/helpers/tasks.ts
 create mode 100644 packages/react/src/polls/adapters/SnapshotVoteFactory.ts
 create mode 100644 packages/react/src/polls/adapters/SnapshotVoteRelayer.ts
 create mode 100644 packages/react/src/polls/adapters/__helpers__/mocks.ts
 create mode 100644 packages/react/src/polls/adapters/__tests__/SnapshotVoteFactory.spec.ts
 create mode 100644 packages/react/src/polls/adapters/__tests__/SnapshotVoteRelayer.spec.ts
 create mode 100644 packages/react/src/polls/adapters/types.ts
 create mode 100644 packages/react/src/profile/adapters/IProfileCacheManager.ts
 create mode 100644 packages/react/src/profile/infrastructure/ProfileCacheManager.ts
 create mode 100644 packages/react/src/transactions/adapters/ITransactionFactory.ts
 create mode 100644 packages/react/src/transactions/adapters/PendingTransactionGateway/ISerializableTransactionFactory.ts
 create mode 100644 packages/react/src/transactions/adapters/PendingTransactionGateway/PendingTransactionGateway.ts
 create mode 100644 packages/react/src/transactions/adapters/PendingTransactionGateway/__tests__/PendingTransactionGateway.spec.ts
 create mode 100644 packages/react/src/transactions/adapters/PendingTransactionGateway/index.ts
 create mode 100644 packages/react/src/transactions/adapters/SelfFundedProtocolTransactionRequest.ts
 create mode 100644 packages/react/src/transactions/adapters/__helpers__/mocks.ts
 create mode 100644 packages/react/src/transactions/adapters/schemas/__tests__/Erc20Amount.spec.ts
 create mode 100644 packages/react/src/transactions/adapters/schemas/__tests__/formatters.spec.ts
 create mode 100644 packages/react/src/transactions/adapters/schemas/__tests__/validators.spec.ts
 create mode 100644 packages/react/src/transactions/adapters/schemas/common.ts
 create mode 100644 packages/react/src/transactions/adapters/schemas/erc20.ts
 create mode 100644 packages/react/src/transactions/adapters/schemas/formatters.ts
 create mode 100644 packages/react/src/transactions/adapters/schemas/profiles.ts
 create mode 100644 packages/react/src/transactions/adapters/schemas/publications.ts
 create mode 100644 packages/react/src/transactions/adapters/schemas/transactions.ts
 create mode 100644 packages/react/src/transactions/adapters/schemas/validators.ts
 create mode 100644 packages/react/src/transactions/infrastructure/TransactionFactory.ts
 create mode 100644 packages/react/src/transactions/infrastructure/TransactionObserver.ts
 create mode 100644 packages/react/src/transactions/infrastructure/__helpers__/mocks.ts
 create mode 100644 packages/react/src/transactions/infrastructure/__tests__/TransactionFactory.spec.ts
 create mode 100644 packages/react/src/transactions/infrastructure/__tests__/TransactionObserver.spec.ts
 create mode 100644 packages/react/src/wallet/adapters/ConcreteWallet.ts
 create mode 100644 packages/react/src/wallet/adapters/IProviderFactory.ts
 create mode 100644 packages/react/src/wallet/adapters/WalletFactory.ts
 create mode 100644 packages/react/src/wallet/adapters/WalletGateway.ts
 create mode 100644 packages/react/src/wallet/adapters/__helpers__/mocks.ts
 create mode 100644 packages/react/src/wallet/adapters/__tests__/ConcreteWallet.spec.ts
 create mode 100644 packages/react/src/wallet/adapters/__tests__/WalletGateway.spec.ts
 create mode 100644 packages/react/src/wallet/adapters/errors.ts
 create mode 100644 packages/react/src/wallet/infrastructure/ProviderFactory.ts
 create mode 100644 packages/react/src/wallet/infrastructure/SignerFactory.ts
 create mode 100644 packages/react/src/wallet/infrastructure/WalletStorage.ts
 create mode 100644 packages/react/src/wallet/infrastructure/__helpers__/mocks.ts
 create mode 100644 packages/react/src/wallet/infrastructure/__tests__/ProviderFactory.spec.ts
 create mode 100644 packages/react/src/wallet/infrastructure/__tests__/SignerFactory.spec.ts

diff --git a/examples/web/src/App.tsx b/examples/web/src/App.tsx
index 4a185a5a09..26c2e09162 100644
--- a/examples/web/src/App.tsx
+++ b/examples/web/src/App.tsx
@@ -1,4 +1,5 @@
 import { LensConfig, LensProvider, development } from '@lens-protocol/react';
+import { bindings as wagmiBindings } from '@lens-protocol/wagmi';
 import { XMTPProvider } from '@xmtp/react-sdk';
 import { Toaster } from 'react-hot-toast';
 import { Route, BrowserRouter as Router, Routes } from 'react-router-dom';
@@ -7,8 +8,9 @@ import { polygonMumbai } from 'wagmi/chains';
 import { InjectedConnector } from 'wagmi/connectors/injected';
 import { publicProvider } from 'wagmi/providers/public';
 
-import { Home } from './HomePage';
-import { Breadcrumbs } from './components/Breadcrumbs';
+import { HomePage } from './HomePage';
+import { Layout } from './Layout';
+import { LogInPage } from './LogInPage';
 import { GenericErrorBoundary } from './components/GenericErrorBoundary';
 import { ErrorMessage } from './components/error/ErrorMessage';
 import { Header } from './components/header/Header';
@@ -41,6 +43,7 @@ const config = createConfig({
 const lensConfig: LensConfig = {
   environment: development,
   storage: localStorage(),
+  bindings: wagmiBindings(),
 };
 
 export function App() {
@@ -51,21 +54,23 @@ export function App() {
           <Router>
             <Header />
             <main>
-              <Breadcrumbs />
               <GenericErrorBoundary fallback={ErrorMessage}>
                 <Routes>
-                  <Route index element={<Home />} />
+                  <Route index element={<HomePage />} />
+                  <Route path="/login" element={<LogInPage />} />
 
-                  <Route path="/publications">
-                    <Route index element={<PublicationsPage />} />
-                    <Route path="usePublication" element={<UsePublication />} />
-                    <Route path="usePublications" element={<UsePublications />} />
-                  </Route>
+                  <Route element={<Layout />}>
+                    <Route path="/publications">
+                      <Route index element={<PublicationsPage />} />
+                      <Route path="usePublication" element={<UsePublication />} />
+                      <Route path="usePublications" element={<UsePublications />} />
+                    </Route>
 
-                  <Route path="/profiles">
-                    <Route index element={<ProfilesPage />} />
-                    <Route path="useProfile" element={<UseProfile />} />
-                    <Route path="useProfiles" element={<UseProfiles />} />
+                    <Route path="/profiles">
+                      <Route index element={<ProfilesPage />} />
+                      <Route path="useProfile" element={<UseProfile />} />
+                      <Route path="useProfiles" element={<UseProfiles />} />
+                    </Route>
                   </Route>
                 </Routes>
               </GenericErrorBoundary>
diff --git a/examples/web/src/HomePage.tsx b/examples/web/src/HomePage.tsx
index 14f42042b0..24932ffa01 100644
--- a/examples/web/src/HomePage.tsx
+++ b/examples/web/src/HomePage.tsx
@@ -2,19 +2,15 @@ import { Link } from 'react-router-dom';
 
 import { CATEGORIES } from './config';
 
-export function Home() {
+export function HomePage() {
   return (
-    <>
-      <h1>Home</h1>
-
-      <div>
-        {CATEGORIES.map(({ path, label }) => (
-          <article key={path}>
-            <h2>{label}</h2>
-            <Link to={path}>View</Link>
-          </article>
-        ))}
-      </div>
-    </>
+    <div>
+      {CATEGORIES.map(({ path, label }) => (
+        <article key={path}>
+          <h2>{label}</h2>
+          <Link to={path}>View</Link>
+        </article>
+      ))}
+    </div>
   );
 }
diff --git a/examples/web/src/Layout.tsx b/examples/web/src/Layout.tsx
new file mode 100644
index 0000000000..39649831f7
--- /dev/null
+++ b/examples/web/src/Layout.tsx
@@ -0,0 +1,12 @@
+import { Outlet } from 'react-router-dom';
+
+import { Breadcrumbs } from './components/Breadcrumbs';
+
+export function Layout() {
+  return (
+    <>
+      <Breadcrumbs />
+      <Outlet />
+    </>
+  );
+}
diff --git a/examples/web/src/LogInPage.tsx b/examples/web/src/LogInPage.tsx
new file mode 100644
index 0000000000..255000226b
--- /dev/null
+++ b/examples/web/src/LogInPage.tsx
@@ -0,0 +1,91 @@
+import { ProfileId, useLogin, useProfiles } from '@lens-protocol/react';
+import toast from 'react-hot-toast';
+import { useNavigate } from 'react-router-dom';
+import { useAccount, useConnect } from 'wagmi';
+import { InjectedConnector } from 'wagmi/connectors/injected';
+
+import { ErrorMessage } from './components/error/ErrorMessage';
+import { Loading } from './components/loading/Loading';
+import { never } from './utils';
+
+function ProfilesList({ owner }: { owner: string }) {
+  const navigate = useNavigate();
+  const { execute: login, isPending: isLoginPending } = useLogin();
+  const { data: profiles, error, loading } = useProfiles({ where: { ownedBy: [owner] } });
+
+  const onSubmit = async (event: React.FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+
+    const form = event.currentTarget;
+    const formData = new FormData(form);
+
+    const profileId = (formData.get('id') as string) ?? never();
+
+    const result = await login({
+      address: owner,
+      profileId: profileId as ProfileId,
+    });
+
+    if (result.isSuccess()) {
+      toast.success(`Welcome ${String(result.value.handle)}`);
+      return navigate('/');
+    }
+
+    toast.error(result.error.message);
+  };
+
+  if (loading) {
+    return <Loading />;
+  }
+
+  if (error) {
+    return <ErrorMessage error={error} />;
+  }
+
+  if (profiles.length === 0) {
+    return <p>No profiles on this wallet.</p>;
+  }
+
+  return (
+    <form onSubmit={onSubmit}>
+      <fieldset>
+        <legend>Which Profile you want to log-in with?</legend>
+
+        {profiles.map((profile, idx) => (
+          <label key={profile.id}>
+            <input
+              disabled={isLoginPending}
+              type="radio"
+              defaultChecked={idx === 0}
+              name="id"
+              value={profile.id}
+            />
+            {profile.handle}
+          </label>
+        ))}
+
+        <div>
+          <button disabled={isLoginPending} type="submit">
+            Continue
+          </button>
+        </div>
+      </fieldset>
+    </form>
+  );
+}
+
+export function LogInPage() {
+  const { address, isDisconnected } = useAccount();
+
+  const { connect } = useConnect({
+    connector: new InjectedConnector(),
+  });
+
+  return (
+    <div>
+      {isDisconnected && <button onClick={() => connect()}>Connect first</button>}
+
+      {address && <ProfilesList owner={address} />}
+    </div>
+  );
+}
diff --git a/examples/web/src/components/auth/LoginButton.tsx b/examples/web/src/components/auth/LoginButton.tsx
new file mode 100644
index 0000000000..3f6ab9f3d9
--- /dev/null
+++ b/examples/web/src/components/auth/LoginButton.tsx
@@ -0,0 +1,6 @@
+import { Link } from 'react-router-dom';
+
+// TODO render log out button once useSession is implemented
+export function LoginButton() {
+  return <Link to="/login">Log in</Link>;
+}
diff --git a/examples/web/src/components/auth/index.tsx b/examples/web/src/components/auth/index.tsx
new file mode 100644
index 0000000000..076da3b467
--- /dev/null
+++ b/examples/web/src/components/auth/index.tsx
@@ -0,0 +1 @@
+export * from './LoginButton';
diff --git a/examples/web/src/components/header/Header.tsx b/examples/web/src/components/header/Header.tsx
index 0ce7c1b628..89a159acb9 100644
--- a/examples/web/src/components/header/Header.tsx
+++ b/examples/web/src/components/header/Header.tsx
@@ -1,6 +1,7 @@
 import { NavLink } from 'react-router-dom';
 
 import { CATEGORIES } from '../../config';
+import { LoginButton } from '../auth';
 
 export function Header() {
   return (
@@ -25,7 +26,9 @@ export function Header() {
             justifyContent: 'space-between',
             gap: '1rem',
           }}
-        ></div>
+        >
+          <LoginButton />
+        </div>
       </div>
 
       <nav>
diff --git a/packages/api-bindings/src/apollo/cache/__helpers__/mocks.ts b/packages/api-bindings/src/apollo/cache/__helpers__/mocks.ts
index 0d0418d798..0bfde1db31 100644
--- a/packages/api-bindings/src/apollo/cache/__helpers__/mocks.ts
+++ b/packages/api-bindings/src/apollo/cache/__helpers__/mocks.ts
@@ -1,22 +1,12 @@
-import { ApolloCache, NormalizedCacheObject, ReactiveVar } from '@apollo/client';
+import { ApolloCache, NormalizedCacheObject } from '@apollo/client';
 import { faker } from '@faker-js/faker';
-import { mockCreatePostRequest, mockWalletData } from '@lens-protocol/domain/mocks';
-import { ProfileIdentifier, WalletData } from '@lens-protocol/domain/use-cases/lifecycle';
+import { mockCreatePostRequest, mockSessionData } from '@lens-protocol/domain/mocks';
 import { AnyTransactionRequest } from '@lens-protocol/domain/use-cases/transactions';
 
 import { createLensCache } from '../createLensCache';
-import {
-  authenticatedProfile,
-  authenticatedWallet,
-  notAuthenticated,
-  updateSession,
-} from '../session';
+import { authenticated, notAuthenticated, updateSession } from '../session';
 import { TransactionState, TxStatus } from '../transactions';
 
-export type MockCacheConfiguration = {
-  activeWalletVar?: ReactiveVar<WalletData | null>;
-};
-
 export function mockLensCache(): ApolloCache<NormalizedCacheObject> {
   return createLensCache();
 }
@@ -32,17 +22,16 @@ export function mockTransactionState<T extends AnyTransactionRequest>(
   };
 }
 
-export function simulateAuthenticatedWallet(wallet = mockWalletData()) {
-  updateSession(authenticatedWallet(wallet));
-}
-
-export function simulateAuthenticatedProfile(
-  profile: ProfileIdentifier,
-  wallet = mockWalletData(),
-) {
-  updateSession(authenticatedProfile(wallet, profile));
+/**
+ * @deprecated flagged as possibly not needed
+ */
+export function simulateAuthenticated(data = mockSessionData()) {
+  updateSession(authenticated(data));
 }
 
+/**
+ * @deprecated flagged as possibly not needed
+ */
 export function simulateNotAuthenticated() {
   updateSession(notAuthenticated());
 }
diff --git a/packages/api-bindings/src/apollo/cache/session.ts b/packages/api-bindings/src/apollo/cache/session.ts
index a814bd5019..e1a421434b 100644
--- a/packages/api-bindings/src/apollo/cache/session.ts
+++ b/packages/api-bindings/src/apollo/cache/session.ts
@@ -1,25 +1,15 @@
 import { makeVar, useReactiveVar } from '@apollo/client';
-import { ProfileIdentifier, WalletData } from '@lens-protocol/domain/use-cases/lifecycle';
-
-export enum SessionType {
-  Anonymous = 'ANONYMOUS',
-  JustWallet = 'JUST_WALLET',
-  WithProfile = 'WITH_PROFILE',
-}
+import { SessionData } from '@lens-protocol/domain/src/use-cases/authentication';
 
 /**
  * @experimental
  */
-class NotAuthenticatedSession<TWallet, TProfile> {
-  readonly type = SessionType.Anonymous;
-
-  isAuthenticated(): this is
-    | AuthenticatedWalletSession<TWallet, TProfile>
-    | AuthenticatedProfileSession<TWallet, TProfile> {
+class NotAuthenticatedSession {
+  isAuthenticated(): this is AuthenticatedProfileSession {
     return false;
   }
 
-  isNotAuthenticated(): this is NotAuthenticatedSession<TWallet, TProfile> {
+  isNotAuthenticated(): this is NotAuthenticatedSession {
     return true;
   }
 }
@@ -27,77 +17,34 @@ class NotAuthenticatedSession<TWallet, TProfile> {
 /**
  * @experimental
  */
-class AuthenticatedWalletSession<TWallet, TProfile> {
-  readonly type = SessionType.JustWallet;
+class AuthenticatedProfileSession {
+  constructor(readonly data: SessionData) {}
 
-  constructor(readonly wallet: TWallet) {}
-
-  isAuthenticated(): this is
-    | AuthenticatedWalletSession<TWallet, TProfile>
-    | AuthenticatedProfileSession<TWallet, TProfile> {
+  isAuthenticated(): this is AuthenticatedProfileSession {
     return true;
   }
 
-  isNotAuthenticated(): this is NotAuthenticatedSession<TWallet, TProfile> {
+  isNotAuthenticated(): this is NotAuthenticatedSession {
     return false;
   }
 }
 
-/**
- * @experimental
- */
-class AuthenticatedProfileSession<TWallet, TProfile> {
-  readonly type = SessionType.WithProfile;
-
-  constructor(readonly wallet: TWallet, readonly profile: TProfile) {}
-
-  isAuthenticated(): this is
-    | AuthenticatedWalletSession<TWallet, TProfile>
-    | AuthenticatedProfileSession<TWallet, TProfile> {
-    return true;
-  }
-
-  isNotAuthenticated(): this is NotAuthenticatedSession<TWallet, TProfile> {
-    return false;
-  }
-}
-
-export type { NotAuthenticatedSession, AuthenticatedWalletSession, AuthenticatedProfileSession };
+export type { NotAuthenticatedSession, AuthenticatedProfileSession };
 
 export function notAuthenticated() {
-  return new NotAuthenticatedSession<never, never>();
+  return new NotAuthenticatedSession();
 }
 
-export function authenticatedWallet<T extends WalletData>(wallet: T) {
-  return new AuthenticatedWalletSession<T, never>(wallet);
-}
-
-export function authenticatedProfile<
-  TWallet extends WalletData,
-  TProfile extends ProfileIdentifier,
->(wallet: TWallet, profile: TProfile) {
-  return new AuthenticatedProfileSession(wallet, profile);
-}
-
-export function authenticatedWith<TWallet extends WalletData, TProfile extends ProfileIdentifier>(
-  wallet: TWallet,
-  profile: TProfile | null,
-) {
-  if (profile === null) {
-    return authenticatedWallet(wallet);
-  }
-  return authenticatedProfile(wallet, profile);
+export function authenticated(data: SessionData) {
+  return new AuthenticatedProfileSession(data);
 }
 
 /**
  * @experimental
  */
-export type Session<TWallet extends WalletData, TProfile extends ProfileIdentifier> =
-  | NotAuthenticatedSession<never, never>
-  | AuthenticatedWalletSession<TWallet, never>
-  | AuthenticatedProfileSession<TWallet, TProfile>;
+export type Session = NotAuthenticatedSession | AuthenticatedProfileSession;
 
-const sessionVar = makeVar<Session<WalletData, ProfileIdentifier> | null>(null);
+const sessionVar = makeVar<Session | null>(null);
 
 export function getSession() {
   return sessionVar();
@@ -111,6 +58,6 @@ export function resetSession() {
   sessionVar(null);
 }
 
-export function updateSession(session: Session<WalletData, ProfileIdentifier>) {
+export function updateSession(session: Session) {
   sessionVar(session);
 }
diff --git a/packages/api-bindings/src/lens/__helpers__/queries.ts b/packages/api-bindings/src/lens/__helpers__/queries.ts
index dd15752c97..0d6f2b65b1 100644
--- a/packages/api-bindings/src/lens/__helpers__/queries.ts
+++ b/packages/api-bindings/src/lens/__helpers__/queries.ts
@@ -1,5 +1,6 @@
 import { MockedResponse } from '@apollo/client/testing';
 import { faker } from '@faker-js/faker';
+import { mockTransactionHash } from '@lens-protocol/domain/mocks';
 
 import { Cursor } from '../Cursor';
 import {
@@ -14,6 +15,11 @@ import {
   PublicationsData,
   PublicationsDocument,
   PublicationsVariables,
+  LensTransactionStatusData,
+  LensTransactionStatusRequest,
+  LensTransactionStatusDocument,
+  LensTransactionResult,
+  LensTransactionStatusType,
 } from '../graphql/generated';
 import { AnyPublication } from '../utils';
 import { mockPaginatedResultInfo } from './fragments';
@@ -109,3 +115,34 @@ export function mockProfilesResponse({
     },
   };
 }
+
+export function mockLensTransactionStatusDataResponse({
+  request,
+  result,
+}: {
+  request: LensTransactionStatusRequest;
+  result: LensTransactionResult | null;
+}): MockedResponse<LensTransactionStatusData> {
+  return {
+    request: {
+      query: LensTransactionStatusDocument,
+      variables: { request },
+    },
+    result: {
+      data: { result },
+    },
+  };
+}
+
+export function mockLensTransactionResult(
+  overrides?: Partial<LensTransactionResult>,
+): LensTransactionResult {
+  return {
+    extraInfo: null,
+    reason: null,
+    status: LensTransactionStatusType.Processing,
+    txHash: mockTransactionHash(),
+    ...overrides,
+    __typename: 'LensTransactionResult',
+  };
+}
diff --git a/packages/api-bindings/src/lens/graphql/generated.ts b/packages/api-bindings/src/lens/graphql/generated.ts
index 3f93929049..c0c449a573 100644
--- a/packages/api-bindings/src/lens/graphql/generated.ts
+++ b/packages/api-bindings/src/lens/graphql/generated.ts
@@ -270,6 +270,8 @@ export type DegreesOfSeparationReferenceModuleInput = {
   degreesOfSeparation: Scalars['Int'];
   mirrorsRestricted: Scalars['Boolean'];
   quotesRestricted: Scalars['Boolean'];
+  /** You can set the degree to follow someone elses graph, if you leave blank it use your profile */
+  sourceProfileId?: InputMaybe<Scalars['ProfileId']>;
 };
 
 export type DismissRecommendedProfilesRequest = {
@@ -491,6 +493,10 @@ export type InviteRequest = {
   secret: Scalars['String'];
 };
 
+export type LastLoggedInProfileRequest = {
+  for: Scalars['EvmAddress'];
+};
+
 export type LegacyCollectRequest = {
   on: Scalars['PublicationId'];
   referrer?: InputMaybe<Scalars['PublicationId']>;
@@ -775,6 +781,7 @@ export type NotificationWhere = {
 
 export type OnchainCommentRequest = {
   commentOn: Scalars['PublicationId'];
+  /** If your using an unknown reference modules you need to pass this in. `followerOnlyReferenceModule` and `degreesOfSeparationReferenceModule` is handled automatically for you and if you supply this on publications with those settings it will be ignored */
   commentOnReferenceModuleData?: InputMaybe<Scalars['BlockchainData']>;
   contentURI: Scalars['URI'];
   openActionModules?: InputMaybe<Array<OpenActionModuleInput>>;
@@ -786,6 +793,7 @@ export type OnchainMirrorRequest = {
   /** You can add information like app on a mirror or tracking stuff */
   metadataURI?: InputMaybe<Scalars['URI']>;
   mirrorOn: Scalars['PublicationId'];
+  /** If your using an unknown reference modules you need to pass this in. `followerOnlyReferenceModule` and `degreesOfSeparationReferenceModule` is handled automatically for you and if you supply this on publications with those settings it will be ignored */
   mirrorReferenceModuleData?: InputMaybe<Scalars['BlockchainData']>;
   referrers?: InputMaybe<Array<OnchainReferrer>>;
 };
@@ -800,6 +808,7 @@ export type OnchainQuoteRequest = {
   contentURI: Scalars['URI'];
   openActionModules?: InputMaybe<Array<OpenActionModuleInput>>;
   quoteOn: Scalars['PublicationId'];
+  /** If your using an unknown reference modules you need to pass this in. `followerOnlyReferenceModule` and `degreesOfSeparationReferenceModule` is handled automatically for you and if you supply this on publications with those settings it will be ignored */
   quoteOnReferenceModuleData?: InputMaybe<Scalars['BlockchainData']>;
   referenceModule?: InputMaybe<ReferenceModuleInput>;
   referrers?: InputMaybe<Array<OnchainReferrer>>;
@@ -3660,6 +3669,7 @@ export type SearchProfilesData = {
 };
 
 export type LensTransactionResult = {
+  __typename: 'LensTransactionResult';
   status: LensTransactionStatusType;
   txHash: string;
   reason: LensTransactionFailureType | null;
@@ -3672,7 +3682,12 @@ export type TxIdToTxHashVariables = Exact<{
 
 export type TxIdToTxHashData = { result: string | null };
 
-export type RelayQueueResult = { key: RelayRoleKey; queue: number; relay: NetworkAddress };
+export type RelayQueueResult = {
+  __typename: 'RelayQueueResult';
+  key: RelayRoleKey;
+  queue: number;
+  relay: NetworkAddress;
+};
 
 export type RelayQueuesVariables = Exact<{ [key: string]: never }>;
 
@@ -6979,6 +6994,7 @@ export const FragmentPublicationRevenue = /*#__PURE__*/ gql`
 `;
 export const FragmentLensTransactionResult = /*#__PURE__*/ gql`
   fragment LensTransactionResult on LensTransactionResult {
+    __typename
     status
     txHash
     reason
@@ -6987,6 +7003,7 @@ export const FragmentLensTransactionResult = /*#__PURE__*/ gql`
 `;
 export const FragmentRelayQueueResult = /*#__PURE__*/ gql`
   fragment RelayQueueResult on RelayQueueResult {
+    __typename
     key
     relay {
       ...NetworkAddress
@@ -12373,6 +12390,7 @@ export type DegreesOfSeparationReferenceModuleSettingsKeySpecifier = (
   | 'degreesOfSeparation'
   | 'mirrorsRestricted'
   | 'quotesRestricted'
+  | 'sourceProfileId'
   | DegreesOfSeparationReferenceModuleSettingsKeySpecifier
 )[];
 export type DegreesOfSeparationReferenceModuleSettingsFieldPolicy = {
@@ -12381,6 +12399,7 @@ export type DegreesOfSeparationReferenceModuleSettingsFieldPolicy = {
   degreesOfSeparation?: FieldPolicy<any> | FieldReadFunction<any>;
   mirrorsRestricted?: FieldPolicy<any> | FieldReadFunction<any>;
   quotesRestricted?: FieldPolicy<any> | FieldReadFunction<any>;
+  sourceProfileId?: FieldPolicy<any> | FieldReadFunction<any>;
 };
 export type DoesFollowResultKeySpecifier = (
   | 'followerProfileId'
@@ -14141,6 +14160,7 @@ export type PublicationOperationsKeySpecifier = (
   | 'canComment'
   | 'canDecrypt'
   | 'canMirror'
+  | 'canQuote'
   | 'hasActed'
   | 'hasBookmarked'
   | 'hasMirrored'
@@ -14155,6 +14175,7 @@ export type PublicationOperationsFieldPolicy = {
   canComment?: FieldPolicy<any> | FieldReadFunction<any>;
   canDecrypt?: FieldPolicy<any> | FieldReadFunction<any>;
   canMirror?: FieldPolicy<any> | FieldReadFunction<any>;
+  canQuote?: FieldPolicy<any> | FieldReadFunction<any>;
   hasActed?: FieldPolicy<any> | FieldReadFunction<any>;
   hasBookmarked?: FieldPolicy<any> | FieldReadFunction<any>;
   hasMirrored?: FieldPolicy<any> | FieldReadFunction<any>;
@@ -14215,6 +14236,7 @@ export type QueryKeySpecifier = (
   | 'following'
   | 'generateModuleCurrencyApprovalData'
   | 'invitedProfiles'
+  | 'lastLoggedInProfile'
   | 'lensTransactionStatus'
   | 'momokaSubmitters'
   | 'momokaSummary'
@@ -14280,6 +14302,7 @@ export type QueryFieldPolicy = {
   following?: FieldPolicy<any> | FieldReadFunction<any>;
   generateModuleCurrencyApprovalData?: FieldPolicy<any> | FieldReadFunction<any>;
   invitedProfiles?: FieldPolicy<any> | FieldReadFunction<any>;
+  lastLoggedInProfile?: FieldPolicy<any> | FieldReadFunction<any>;
   lensTransactionStatus?: FieldPolicy<any> | FieldReadFunction<any>;
   momokaSubmitters?: FieldPolicy<any> | FieldReadFunction<any>;
   momokaSummary?: FieldPolicy<any> | FieldReadFunction<any>;
diff --git a/packages/api-bindings/src/lens/graphql/transaction.graphql b/packages/api-bindings/src/lens/graphql/transaction.graphql
index 0972661886..c24b4c9338 100644
--- a/packages/api-bindings/src/lens/graphql/transaction.graphql
+++ b/packages/api-bindings/src/lens/graphql/transaction.graphql
@@ -1,4 +1,5 @@
 fragment LensTransactionResult on LensTransactionResult {
+  __typename
   status
   txHash
   reason
@@ -10,6 +11,7 @@ query TxIdToTxHash($for: TxId!) {
 }
 
 fragment RelayQueueResult on RelayQueueResult {
+  __typename
   key
   relay {
     ...NetworkAddress
diff --git a/packages/domain/src/entities/Transactions.ts b/packages/domain/src/entities/Transactions.ts
index 66237f328f..5df2005468 100644
--- a/packages/domain/src/entities/Transactions.ts
+++ b/packages/domain/src/entities/Transactions.ts
@@ -90,6 +90,9 @@ export enum TransactionEvent {
   SETTLED = 'SETTLED',
 }
 
+/**
+ * @deprecated delete this
+ */
 export enum ProxyActionStatus {
   MINTING = 'MINTING',
   TRANSFERRING = 'TRANSFERRING',
@@ -115,6 +118,9 @@ export abstract class NativeTransaction<T extends AnyTransactionRequestModel> {
   abstract waitNextEvent(): PromiseResult<TransactionEvent, TransactionError>;
 }
 
+/**
+ * @deprecated delete this
+ */
 export abstract class ProxyTransaction<T extends ProtocolTransactionRequestModel> {
   abstract get chainType(): ChainType;
   abstract get id(): string;
@@ -140,6 +146,7 @@ export type Transaction<T extends AnyTransactionRequestModel> =
 
 /**
  * The reason why a transaction failed.
+ * @deprecated delete this, not very used after all
  */
 export enum TransactionErrorReason {
   /**
diff --git a/packages/domain/src/use-cases/authentication/__helpers__/mocks.ts b/packages/domain/src/use-cases/authentication/__helpers__/mocks.ts
index 4e0365f6fc..396b2c72a3 100644
--- a/packages/domain/src/use-cases/authentication/__helpers__/mocks.ts
+++ b/packages/domain/src/use-cases/authentication/__helpers__/mocks.ts
@@ -6,6 +6,7 @@ import { Wallet } from '../../../entities';
 import { mockProfileId, mockWallet } from '../../../entities/__helpers__/mocks';
 import { ActiveWallet } from '../ActiveWallet';
 import { LoginRequest } from '../Login';
+import { SessionData } from '../SessionData';
 
 export function mockLoginRequest(): LoginRequest {
   return {
@@ -21,3 +22,10 @@ export function mockActiveWallet({ wallet = mockWallet() }: { wallet?: Wallet }
 
   return activeWallet;
 }
+
+export function mockSessionData(): SessionData {
+  return {
+    address: mockEvmAddress(),
+    profileId: mockProfileId(),
+  };
+}
diff --git a/packages/domain/src/use-cases/profile/IProfileGateway.ts b/packages/domain/src/use-cases/profile/IProfileGateway.ts
deleted file mode 100644
index d25a7d3134..0000000000
--- a/packages/domain/src/use-cases/profile/IProfileGateway.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { Profile } from '../../entities';
-
-export interface IProfileGateway {
-  getAllProfilesByOwnerAddress(address: string): Promise<Profile[]>;
-
-  getProfileById(id: string): Promise<Profile | null>;
-}
diff --git a/packages/domain/src/use-cases/profile/index.ts b/packages/domain/src/use-cases/profile/index.ts
index e50d5cbef9..eb643a67e3 100644
--- a/packages/domain/src/use-cases/profile/index.ts
+++ b/packages/domain/src/use-cases/profile/index.ts
@@ -1,6 +1,5 @@
 export * from './CreateProfile';
 export * from './FollowProfiles';
-export * from './IProfileGateway';
 export * from './ProveNftOwnership';
 export * from './UnfollowProfile';
 export * from './UpdateDispatcherConfig';
diff --git a/packages/react/src/authentication/adapters/AccessTokenStorage.ts b/packages/react/src/authentication/adapters/AccessTokenStorage.ts
new file mode 100644
index 0000000000..2b31659324
--- /dev/null
+++ b/packages/react/src/authentication/adapters/AccessTokenStorage.ts
@@ -0,0 +1,67 @@
+import { IAccessTokenStorage } from '@lens-protocol/api-bindings';
+import { CredentialsExpiredError } from '@lens-protocol/domain/use-cases/authentication';
+import { Deferred } from '@lens-protocol/shared-kernel';
+
+import { AuthApi } from './AuthApi';
+import { Credentials } from './Credentials';
+import { Callback, ICredentialsExpiryEmitter } from './CredentialsExpiryController';
+import { CredentialsStorage } from './CredentialsStorage';
+
+export class AccessTokenStorage implements IAccessTokenStorage, ICredentialsExpiryEmitter {
+  private isRefreshing = false;
+  private pendingRequests: Deferred<void>[] = [];
+
+  private listeners: Set<Callback> = new Set();
+
+  constructor(
+    private readonly authApi: AuthApi,
+    private readonly credentialsStorage: CredentialsStorage,
+  ) {}
+
+  onExpiry(callback: Callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+
+  getAccessToken(): string | null {
+    return this.credentialsStorage.getAccessToken();
+  }
+
+  async refreshToken(): Promise<void> {
+    if (this.isRefreshing) {
+      const deferredPromise = new Deferred<void>();
+      this.pendingRequests.push(deferredPromise);
+      return deferredPromise.promise;
+    }
+
+    this.isRefreshing = true;
+    const credentials = await this.credentialsStorage.get();
+
+    if (credentials && credentials.canRefresh()) {
+      await this.refreshCredentials(credentials);
+      this.isRefreshing = false;
+      return;
+    }
+
+    this.rejectPendingRequests();
+    this.isRefreshing = false;
+    this.emitExpiryEvent();
+    throw new CredentialsExpiredError();
+  }
+
+  private async refreshCredentials(credentials: Credentials) {
+    const newCredentials = await this.authApi.refreshCredentials(credentials.refreshToken);
+    await this.credentialsStorage.set(newCredentials);
+    this.pendingRequests.map((request) => request.resolve());
+    this.pendingRequests = [];
+  }
+
+  private rejectPendingRequests() {
+    this.pendingRequests.map((request) => request.reject(new CredentialsExpiredError()));
+    this.pendingRequests = [];
+  }
+
+  private emitExpiryEvent() {
+    this.listeners.forEach((callback) => callback());
+  }
+}
diff --git a/packages/react/src/authentication/adapters/AuthApi.ts b/packages/react/src/authentication/adapters/AuthApi.ts
new file mode 100644
index 0000000000..a7762285f0
--- /dev/null
+++ b/packages/react/src/authentication/adapters/AuthApi.ts
@@ -0,0 +1,62 @@
+import {
+  AuthAuthenticateDocument,
+  AuthAuthenticateData,
+  AuthAuthenticateVariables,
+  AuthChallengeDocument,
+  AuthChallengeData,
+  AuthChallengeVariables,
+  AuthRefreshDocument,
+  AuthRefreshData,
+  AuthRefreshVariables,
+  SafeApolloClient,
+  AuthChallenge,
+  ChallengeRequest,
+  SignedAuthChallenge,
+} from '@lens-protocol/api-bindings';
+
+import { Credentials } from './Credentials';
+
+export type Challenge = {
+  id: string;
+  text: string;
+};
+
+export class AuthApi {
+  constructor(private apolloClient: SafeApolloClient) {}
+
+  async generateChallenge(request: ChallengeRequest): Promise<AuthChallenge> {
+    const result = await this.apolloClient.query<AuthChallengeData, AuthChallengeVariables>({
+      query: AuthChallengeDocument,
+      variables: { request },
+      // challenge to sign should be always a new one
+      fetchPolicy: 'network-only',
+    });
+
+    return {
+      id: result.data.result.id,
+      text: result.data.result.text,
+    };
+  }
+
+  async generateCredentials(request: SignedAuthChallenge): Promise<Credentials> {
+    const result = await this.apolloClient.mutate<AuthAuthenticateData, AuthAuthenticateVariables>({
+      mutation: AuthAuthenticateDocument,
+      variables: { request },
+    });
+
+    const { accessToken, refreshToken } = result.data.result;
+
+    return new Credentials(accessToken, refreshToken);
+  }
+
+  async refreshCredentials(refreshToken: string): Promise<Credentials> {
+    const result = await this.apolloClient.mutate<AuthRefreshData, AuthRefreshVariables>({
+      mutation: AuthRefreshDocument,
+      variables: { request: { refreshToken } },
+    });
+
+    const { accessToken: newAccessToken, refreshToken: newRefreshToken } = result.data.result;
+
+    return new Credentials(newAccessToken, newRefreshToken);
+  }
+}
diff --git a/packages/react/src/authentication/adapters/Credentials.ts b/packages/react/src/authentication/adapters/Credentials.ts
new file mode 100644
index 0000000000..fad25c6a01
--- /dev/null
+++ b/packages/react/src/authentication/adapters/Credentials.ts
@@ -0,0 +1,61 @@
+import { ICredentials, ProfileId } from '@lens-protocol/domain/entities';
+import { DateUtils, EvmAddress, invariant, InvariantError } from '@lens-protocol/shared-kernel';
+import jwtDecode, { JwtPayload } from 'jwt-decode';
+import isObject from 'lodash/isObject.js';
+
+type ParsedJwt = {
+  id: ProfileId;
+  evmAddress: EvmAddress;
+};
+
+function assertIdInJwt(decodedJwt: unknown): asserts decodedJwt is ParsedJwt {
+  if (isObject(decodedJwt) && !['id', 'evmAddress'].every((key) => key in decodedJwt)) {
+    throw new InvariantError('Invalid JWT format.');
+  }
+}
+
+// Threshold in seconds that will mark token as expired even it's still valid
+// Adds some time for all communications that's required to refresh tokens
+const TOKEN_EXP_THRESHOLD = DateUtils.secondsToMs(3);
+
+export class Credentials implements ICredentials {
+  readonly address: EvmAddress;
+  readonly profileId: ProfileId;
+
+  constructor(readonly accessToken: string | null, readonly refreshToken: string) {
+    const decodedRefreshToken = jwtDecode<JwtPayload>(refreshToken);
+
+    assertIdInJwt(decodedRefreshToken);
+
+    this.address = decodedRefreshToken.evmAddress;
+    this.profileId = decodedRefreshToken.id;
+  }
+
+  canRefresh(): boolean {
+    const now = Date.now();
+    const tokenExpDate = this.getTokenExpDate(this.refreshToken);
+
+    return now < tokenExpDate - TOKEN_EXP_THRESHOLD;
+  }
+
+  isExpired(): boolean {
+    const accessToken = this.accessToken;
+
+    if (!accessToken) {
+      return true;
+    }
+
+    const now = Date.now();
+    const tokenExpDate = this.getTokenExpDate(accessToken);
+
+    return now >= tokenExpDate - TOKEN_EXP_THRESHOLD;
+  }
+
+  private getTokenExpDate(token: string) {
+    const decodedToken = jwtDecode<JwtPayload>(token);
+
+    invariant(decodedToken.exp, 'Exp date should be provided by JWT token');
+
+    return DateUtils.secondsToMs(decodedToken.exp);
+  }
+}
diff --git a/packages/react/src/authentication/adapters/CredentialsExpiryController.ts b/packages/react/src/authentication/adapters/CredentialsExpiryController.ts
new file mode 100644
index 0000000000..b2aa8b8b25
--- /dev/null
+++ b/packages/react/src/authentication/adapters/CredentialsExpiryController.ts
@@ -0,0 +1,21 @@
+import { Logout, LogoutReason } from '@lens-protocol/domain/src/use-cases/authentication/Logout';
+
+export type Callback = () => void;
+
+export interface ICredentialsExpiryEmitter {
+  onExpiry(callback: Callback): void;
+}
+
+export class CredentialsExpiryController {
+  constructor(readonly logout: Logout) {}
+
+  subscribe(tokenExpiryEmitter: ICredentialsExpiryEmitter) {
+    tokenExpiryEmitter.onExpiry(() => {
+      void this.onTokenExpired();
+    });
+  }
+
+  private async onTokenExpired(): Promise<void> {
+    await this.logout.execute(LogoutReason.CREDENTIALS_EXPIRED);
+  }
+}
diff --git a/packages/react/src/authentication/adapters/CredentialsFactory.ts b/packages/react/src/authentication/adapters/CredentialsFactory.ts
new file mode 100644
index 0000000000..9706bb394e
--- /dev/null
+++ b/packages/react/src/authentication/adapters/CredentialsFactory.ts
@@ -0,0 +1,48 @@
+import { ProfileId, Wallet } from '@lens-protocol/domain/entities';
+import {
+  ICredentialsIssuer,
+  LoginError,
+  CredentialsExpiredError,
+  ICredentialsRenewer,
+} from '@lens-protocol/domain/use-cases/authentication';
+import { failure, PromiseResult, success } from '@lens-protocol/shared-kernel';
+
+import { AuthApi } from './AuthApi';
+import { Credentials } from './Credentials';
+
+export class CredentialsFactory implements ICredentialsIssuer, ICredentialsRenewer {
+  constructor(private auth: AuthApi) {}
+
+  async renewCredentials(
+    credentials: Credentials,
+  ): PromiseResult<Credentials, CredentialsExpiredError> {
+    if (!credentials.canRefresh()) {
+      return failure(new CredentialsExpiredError());
+    }
+    const newCredentials = await this.auth.refreshCredentials(credentials.refreshToken);
+    return success(newCredentials);
+  }
+
+  async issueCredentials(
+    forProfile: ProfileId,
+    signedBy: Wallet,
+  ): PromiseResult<Credentials, LoginError> {
+    const challenge = await this.auth.generateChallenge({
+      for: forProfile,
+      signedBy: signedBy.address,
+    });
+
+    const result = await signedBy.signMessage(challenge.text);
+
+    if (result.isFailure()) {
+      return failure(result.error);
+    }
+
+    const credentials = await this.auth.generateCredentials({
+      id: challenge.id,
+      signature: result.value,
+    });
+
+    return success(credentials);
+  }
+}
diff --git a/packages/react/src/authentication/adapters/CredentialsGateway.ts b/packages/react/src/authentication/adapters/CredentialsGateway.ts
new file mode 100644
index 0000000000..48b1b88f8e
--- /dev/null
+++ b/packages/react/src/authentication/adapters/CredentialsGateway.ts
@@ -0,0 +1,23 @@
+import {
+  ICredentialsWriter,
+  ICredentialsReader,
+} from '@lens-protocol/domain/use-cases/authentication';
+import { IStorage } from '@lens-protocol/storage';
+
+import { Credentials } from './Credentials';
+
+export class CredentialsGateway implements ICredentialsWriter, ICredentialsReader {
+  constructor(private readonly credentialsStorage: IStorage<Credentials>) {}
+
+  async getCredentials() {
+    return this.credentialsStorage.get();
+  }
+
+  async save(credentials: Credentials) {
+    await this.credentialsStorage.set(credentials);
+  }
+
+  async invalidate() {
+    await this.credentialsStorage.reset();
+  }
+}
diff --git a/packages/react/src/authentication/adapters/CredentialsStorage.ts b/packages/react/src/authentication/adapters/CredentialsStorage.ts
new file mode 100644
index 0000000000..5a746a2264
--- /dev/null
+++ b/packages/react/src/authentication/adapters/CredentialsStorage.ts
@@ -0,0 +1,69 @@
+import {
+  BaseStorageSchema,
+  IStorage,
+  IStorageProvider,
+  Storage,
+  StorageSubscriber,
+  StorageSubscription,
+} from '@lens-protocol/storage';
+import { z } from 'zod';
+
+import { Credentials } from './Credentials';
+
+const AuthData = z.object({
+  refreshToken: z.string(),
+});
+
+type AuthData = z.infer<typeof AuthData>;
+
+/**
+ * Stores auth credentials.
+ * Access token is kept in memory.
+ * Refresh token is persisted permanently.
+ */
+export class CredentialsStorage implements IStorage<Credentials> {
+  refreshTokenStorage: IStorage<AuthData>;
+  accessToken: string | null = null;
+
+  constructor(storageProvider: IStorageProvider, namespace: string) {
+    const authStorageSchema = new BaseStorageSchema(`lens.${namespace}.credentials`, AuthData);
+    this.refreshTokenStorage = Storage.createForSchema(authStorageSchema, storageProvider);
+  }
+
+  async set({ accessToken, refreshToken }: Credentials): Promise<void> {
+    this.accessToken = accessToken;
+
+    await this.refreshTokenStorage.set({ refreshToken });
+  }
+
+  async get(): Promise<Credentials | null> {
+    const refreshToken = await this.getRefreshToken();
+
+    if (!refreshToken) {
+      return null;
+    }
+
+    const accessToken = this.getAccessToken();
+
+    return new Credentials(accessToken, refreshToken);
+  }
+
+  async reset(): Promise<void> {
+    this.accessToken = null;
+    await this.refreshTokenStorage.reset();
+  }
+
+  subscribe(_: StorageSubscriber<Credentials>): StorageSubscription {
+    throw new Error('Method not implemented.');
+  }
+
+  getAccessToken(): string | null {
+    return this.accessToken;
+  }
+
+  private async getRefreshToken(): Promise<string | null> {
+    const result = await this.refreshTokenStorage.get();
+
+    return result?.refreshToken ?? null;
+  }
+}
diff --git a/packages/react/src/authentication/adapters/LoginPresenter.ts b/packages/react/src/authentication/adapters/LoginPresenter.ts
new file mode 100644
index 0000000000..238703f379
--- /dev/null
+++ b/packages/react/src/authentication/adapters/LoginPresenter.ts
@@ -0,0 +1,43 @@
+import { authenticated, Profile, updateSession } from '@lens-protocol/api-bindings';
+import {
+  ILoginPresenter,
+  LoginError,
+  SessionData,
+} from '@lens-protocol/domain/use-cases/authentication';
+import {
+  Deferred,
+  failure,
+  invariant,
+  PromiseResult,
+  Result,
+  success,
+} from '@lens-protocol/shared-kernel';
+
+import { IProfileCacheManager } from '../../profile/adapters/IProfileCacheManager';
+
+export class LoginPresenter implements ILoginPresenter {
+  private deferredResult = new Deferred<Result<Profile, LoginError>>();
+
+  constructor(private readonly profileCacheManager: IProfileCacheManager) {}
+
+  async present(result: Result<SessionData, LoginError>) {
+    if (result.isFailure()) {
+      this.deferredResult.resolve(failure(result.error));
+      return;
+    }
+
+    const { profileId } = result.value;
+    const profile = await this.profileCacheManager.fetchProfile(profileId);
+
+    invariant(profile, 'Profile not found');
+
+    updateSession(authenticated(result.value));
+
+    this.deferredResult.resolve(success(profile));
+    return;
+  }
+
+  asResult(): PromiseResult<Profile, LoginError> {
+    return this.deferredResult.promise;
+  }
+}
diff --git a/packages/react/src/authentication/adapters/__helpers__/mocks.ts b/packages/react/src/authentication/adapters/__helpers__/mocks.ts
new file mode 100644
index 0000000000..39cf329d1c
--- /dev/null
+++ b/packages/react/src/authentication/adapters/__helpers__/mocks.ts
@@ -0,0 +1,8 @@
+import { Credentials } from '../Credentials';
+
+export function mockCredentials(): Credentials {
+  return new Credentials(
+    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjB4MzMiLCJldm1BZGRyZXNzIjoiMHhEOWVDYkRmMzIyQTkzNGY5OWQ4NTI2OGQ1MDZDMDc5OTk3ZUE1NGU3Iiwicm9sZSI6Im5vcm1hbCIsImlhdCI6MTY5NjQ0MjMwNCwiZXhwIjoxNjk2NDQ0MTA0fQ.JHeQNtBpQ0SyMqNOk1D-_RTyHO1LL6Ll0kdNIaPIeqo',
+    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjB4MzMiLCJldm1BZGRyZXNzIjoiMHhEOWVDYkRmMzIyQTkzNGY5OWQ4NTI2OGQ1MDZDMDc5OTk3ZUE1NGU3Iiwicm9sZSI6Im5vcm1hbCIsImlhdCI6MTY5NjQ0MjMwNCwiZXhwIjoxNjk2NDQ0MTA0fQ.JHeQNtBpQ0SyMqNOk1D-_RTyHO1LL6Ll0kdNIaPIeqo',
+  );
+}
diff --git a/packages/react/src/authentication/adapters/__tests__/CredentialsFactory.spec.ts b/packages/react/src/authentication/adapters/__tests__/CredentialsFactory.spec.ts
new file mode 100644
index 0000000000..c8de7a6179
--- /dev/null
+++ b/packages/react/src/authentication/adapters/__tests__/CredentialsFactory.spec.ts
@@ -0,0 +1,111 @@
+import { faker } from '@faker-js/faker';
+import {
+  PendingSigningRequestError,
+  UserRejectedError,
+  WalletConnectionError,
+  WalletConnectionErrorReason,
+} from '@lens-protocol/domain/entities';
+import { mockProfileId, mockSignature, mockWallet } from '@lens-protocol/domain/mocks';
+import { CredentialsExpiredError } from '@lens-protocol/domain/use-cases/authentication';
+import { failure, success } from '@lens-protocol/shared-kernel';
+import { mock } from 'jest-mock-extended';
+import { when } from 'jest-when';
+
+import { AuthApi, Challenge } from '../AuthApi';
+import { Credentials } from '../Credentials';
+import { CredentialsFactory } from '../CredentialsFactory';
+import { mockCredentials } from '../__helpers__/mocks';
+
+const challenge: Challenge = {
+  id: faker.datatype.uuid(),
+  text: 'Challenge to sign from backend',
+};
+const signature = mockSignature();
+const credentials = mockCredentials();
+
+function setupTestScenario() {
+  const wallet = mockWallet();
+  const authApi = mock<AuthApi>();
+  const credentialsFactory = new CredentialsFactory(authApi);
+
+  return {
+    authApi,
+    credentialsFactory,
+    wallet,
+  };
+}
+
+describe(`Given an instance of the ${CredentialsFactory.name} class`, () => {
+  const profileId = mockProfileId();
+
+  describe(`when the "${CredentialsFactory.prototype.issueCredentials.name}" method is invoked`, () => {
+    it('should return new credentials for a certain wallet', async () => {
+      const { credentialsFactory, authApi, wallet } = setupTestScenario();
+
+      when(authApi.generateChallenge)
+        .calledWith({ for: profileId, signedBy: wallet.address })
+        .mockResolvedValue(challenge);
+      when(wallet.signMessage).calledWith(challenge.text).mockResolvedValue(success(signature));
+      when(authApi.generateCredentials)
+        .calledWith({ id: challenge.id, signature })
+        .mockResolvedValue(credentials);
+
+      const result = await credentialsFactory.issueCredentials(profileId, wallet);
+
+      expect(result.unwrap()).toEqual(credentials);
+    });
+
+    it.each([
+      {
+        ErrorCtor: UserRejectedError,
+        error: new UserRejectedError(),
+      },
+      {
+        ErrorCtor: WalletConnectionError,
+        error: new WalletConnectionError(WalletConnectionErrorReason.WRONG_ACCOUNT),
+      },
+      {
+        ErrorCtor: PendingSigningRequestError,
+        error: new PendingSigningRequestError(),
+      },
+    ])(
+      `should fail with $ErrorCtor.name if the challenge signing fails with it`,
+      async ({ ErrorCtor, error }) => {
+        const { credentialsFactory, authApi, wallet } = setupTestScenario();
+
+        when(authApi.generateChallenge).mockResolvedValue(challenge);
+        when(wallet.signMessage).mockResolvedValue(failure(error));
+
+        const result = await credentialsFactory.issueCredentials(profileId, wallet);
+
+        expect(() => result.unwrap()).toThrow(ErrorCtor);
+      },
+    );
+  });
+
+  describe(`when the "${CredentialsFactory.prototype.renewCredentials.name}" method is invoked`, () => {
+    it('should return the new credentials', async () => {
+      const newCredentials = mockCredentials();
+      const { credentialsFactory, authApi } = setupTestScenario();
+
+      when(authApi.refreshCredentials)
+        .calledWith(credentials.refreshToken)
+        .mockResolvedValue(newCredentials);
+
+      const result = await credentialsFactory.renewCredentials(credentials);
+
+      expect(result.unwrap()).toEqual(newCredentials);
+    });
+
+    it(`should fail with ${CredentialsExpiredError.name} if the credentials cant be refreshed`, async () => {
+      const { credentialsFactory } = setupTestScenario();
+
+      const credentials = mock<Credentials>({
+        canRefresh: () => false,
+      });
+
+      const result = await credentialsFactory.renewCredentials(credentials);
+      expect(() => result.unwrap()).toThrow(CredentialsExpiredError);
+    });
+  });
+});
diff --git a/packages/react/src/authentication/adapters/__tests__/CredentialsGateway.spec.ts b/packages/react/src/authentication/adapters/__tests__/CredentialsGateway.spec.ts
new file mode 100644
index 0000000000..4ba50e03f5
--- /dev/null
+++ b/packages/react/src/authentication/adapters/__tests__/CredentialsGateway.spec.ts
@@ -0,0 +1,41 @@
+import { mockStorage } from '@lens-protocol/storage/mocks';
+
+import { Credentials } from '../Credentials';
+import { CredentialsGateway } from '../CredentialsGateway';
+import { mockCredentials } from '../__helpers__/mocks';
+
+const credentials = mockCredentials();
+
+const setupGateway = () => {
+  const storage = mockStorage<Credentials>();
+  return new CredentialsGateway(storage);
+};
+
+describe(`Given an instance of the ${CredentialsGateway.name}`, () => {
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe(`when "${CredentialsGateway.prototype.save.name}" method is invoked`, () => {
+    it('should store the credentials in the underlying storage so they can be retrieve later on', async () => {
+      const gateway = setupGateway();
+
+      await gateway.save(credentials);
+
+      const result = await gateway.getCredentials();
+      expect(result).toEqual(credentials);
+    });
+  });
+
+  describe(`when "${CredentialsGateway.prototype.invalidate.name}" method is invoked`, () => {
+    it(`should clear the credentials in the underlying storage`, async () => {
+      const gateway = setupGateway();
+
+      await gateway.save(credentials);
+      await gateway.invalidate();
+
+      const result = await gateway.getCredentials();
+      expect(result).toBe(null);
+    });
+  });
+});
diff --git a/packages/react/src/authentication/adapters/useLoginController.ts b/packages/react/src/authentication/adapters/useLoginController.ts
new file mode 100644
index 0000000000..04f590ff2b
--- /dev/null
+++ b/packages/react/src/authentication/adapters/useLoginController.ts
@@ -0,0 +1,29 @@
+import { Login, LoginRequest } from '@lens-protocol/domain/use-cases/authentication';
+
+import { useSharedDependencies } from '../../shared';
+import { LoginPresenter } from './LoginPresenter';
+
+export function useLoginController() {
+  const {
+    credentialsFactory,
+    credentialsGateway,
+    profileCacheManager,
+    walletFactory,
+    walletGateway,
+  } = useSharedDependencies();
+
+  return async (request: LoginRequest) => {
+    const presenter = new LoginPresenter(profileCacheManager);
+    const login = new Login(
+      walletFactory,
+      walletGateway,
+      credentialsFactory,
+      credentialsGateway,
+      presenter,
+    );
+
+    await login.execute(request);
+
+    return presenter.asResult();
+  };
+}
diff --git a/packages/react/src/authentication/index.ts b/packages/react/src/authentication/index.ts
new file mode 100644
index 0000000000..2aa12e28ce
--- /dev/null
+++ b/packages/react/src/authentication/index.ts
@@ -0,0 +1 @@
+export * from './useLogin';
diff --git a/packages/react/src/authentication/useLogin.ts b/packages/react/src/authentication/useLogin.ts
new file mode 100644
index 0000000000..c59e76f8b5
--- /dev/null
+++ b/packages/react/src/authentication/useLogin.ts
@@ -0,0 +1,7 @@
+import { useAsyncTask } from '../helpers/tasks';
+import { useLoginController } from './adapters/useLoginController';
+
+export function useLogin() {
+  const login = useLoginController();
+  return useAsyncTask(login);
+}
diff --git a/packages/react/src/config.ts b/packages/react/src/config.ts
index a64a235c59..b591a6c6fc 100644
--- a/packages/react/src/config.ts
+++ b/packages/react/src/config.ts
@@ -4,6 +4,12 @@ import { IObservableStorageProvider, IStorageProvider } from '@lens-protocol/sto
 
 import { EnvironmentConfig } from './environments';
 import { MediaTransformsConfig } from './mediaTransforms';
+import { IProviderBinding, GetProvider } from './wallet/infrastructure/ProviderFactory';
+import { ISignerBinding, GetSigner } from './wallet/infrastructure/SignerFactory';
+
+export type { GetProvider, GetSigner };
+
+export interface IBindings extends ISignerBinding, IProviderBinding {}
 
 /**
  * `<LensProvider>` configuration
@@ -12,7 +18,7 @@ export type LensConfig = {
   /**
    * Provides integration with the ethers.js Signer and Provider
    */
-  // bindings: IBindings;
+  bindings: IBindings;
   /**
    * The environment to use. See {@link production}, {@link development}, and {@link sandbox}
    */
diff --git a/packages/react/src/helpers/tasks.ts b/packages/react/src/helpers/tasks.ts
new file mode 100644
index 0000000000..44dd8c795c
--- /dev/null
+++ b/packages/react/src/helpers/tasks.ts
@@ -0,0 +1,64 @@
+import { IEquatableError, PromiseResult, UnknownObject } from '@lens-protocol/shared-kernel';
+import { useCallback, useState } from 'react';
+
+/**
+ * An async task is a function that can be executed multiple times and that can be in a pending state.
+ *
+ * @internal
+ */
+export type AsyncTask<
+  TValue,
+  TError extends IEquatableError,
+  TInput extends UnknownObject = never,
+> = (input: TInput) => PromiseResult<TValue, TError>;
+
+/**
+ * An async task React Hook is a tiny wrapper around an async task that provides a way to
+ * determine when the task is running and also provide access the last error that occurred
+ * during the execution of the task.
+ */
+export type UseAsyncTask<
+  TValue,
+  TError extends IEquatableError,
+  TInput extends UnknownObject = never,
+> = {
+  error: TError | undefined;
+  execute: AsyncTask<TValue, TError, TInput>;
+  isPending: boolean;
+};
+
+/**
+ * @internal
+ */
+export function useAsyncTask<
+  TValue,
+  TError extends IEquatableError,
+  TInput extends UnknownObject = never,
+>(handler: AsyncTask<TValue, TError, TInput>): UseAsyncTask<TValue, TError, TInput> {
+  const [isPending, setIsPending] = useState(false);
+  const [error, setError] = useState<TError | undefined>(undefined);
+
+  return {
+    error,
+    execute: useCallback(
+      async (input: TInput) => {
+        setError(undefined);
+        setIsPending(true);
+
+        try {
+          const result = await handler(input);
+
+          if (result.isFailure()) {
+            setError(result.error);
+          }
+
+          return result;
+        } finally {
+          setIsPending(false);
+        }
+      },
+      [handler],
+    ),
+    isPending,
+  };
+}
diff --git a/packages/react/src/index.ts b/packages/react/src/index.ts
index ef743ebeeb..75d8f36922 100644
--- a/packages/react/src/index.ts
+++ b/packages/react/src/index.ts
@@ -6,6 +6,7 @@ export * from './LensProvider';
 /**
  * Hooks
  */
+export * from './authentication';
 export * from './profile';
 export * from './publication';
 
diff --git a/packages/react/src/polls/adapters/SnapshotVoteFactory.ts b/packages/react/src/polls/adapters/SnapshotVoteFactory.ts
new file mode 100644
index 0000000000..d5804cae7b
--- /dev/null
+++ b/packages/react/src/polls/adapters/SnapshotVoteFactory.ts
@@ -0,0 +1,232 @@
+import {
+  SafeApolloClient,
+  GetSnapshotProposalDocument,
+  SnapshotSpaceId,
+  GetSnapshotProposalData,
+  GetSnapshotProposalVariables,
+  SnapshotProposal,
+  SnapshotVotingSystem,
+} from '@lens-protocol/api-bindings';
+import { TypedData } from '@lens-protocol/blockchain-bindings';
+import { AppId, Wallet, IUnsignedVote, PollId } from '@lens-protocol/domain/entities';
+import {
+  CreateUnsignedVoteRequest,
+  IUnsignedVoteFactory,
+  VoteChoice,
+} from '@lens-protocol/domain/use-cases/polls';
+import { invariant, InvariantError, never } from '@lens-protocol/shared-kernel';
+import { getAddress } from 'ethers/lib/utils';
+
+import { vote2Types, voteArray2Types, voteString2Types } from './types';
+
+export class UnsignedVote implements IUnsignedVote {
+  constructor(readonly pollId: PollId, readonly typedData: TypedData) {}
+}
+
+type Message = {
+  app: string;
+  choice: number | number[] | string;
+  from: string;
+  metadata: string;
+  proposal: string;
+  reason: string;
+  space: string;
+  timestamp: number;
+};
+
+function createTypedData({
+  message,
+  types,
+}: {
+  message: Partial<Message>;
+  types: typeof vote2Types | typeof voteArray2Types;
+}): TypedData {
+  return {
+    domain: {
+      name: 'snapshot',
+      version: '0.1.4',
+    },
+    types,
+    message: {
+      reason: '',
+      app: '',
+      metadata: '{}',
+      timestamp: parseInt((Date.now() / 1e3).toFixed()),
+      ...message,
+    },
+  };
+}
+
+function isNumber(value: unknown): value is number {
+  return typeof value === 'number';
+}
+
+function validateSingleChoice(
+  request: { choice: VoteChoice },
+  proposal: SnapshotProposal,
+): asserts request is { choice: number } {
+  invariant(isNumber(request.choice), 'Choice must be an number');
+  invariant(request.choice >= 0, 'Choice is a 0-based index, it must be a positive number');
+  invariant(
+    request.choice < proposal.choices.length,
+    'Choice is a 0-based index, it must be less than the number of choices',
+  );
+}
+
+function singleChoiceTypedData(
+  proposal: SnapshotProposal,
+  choice: number,
+  voter: Wallet,
+  appId?: AppId,
+): TypedData {
+  return createTypedData({
+    message: {
+      app: appId ?? '',
+      choice: choice + 1,
+      from: getAddress(voter.address),
+      proposal: proposal.id,
+      space: proposal.space?.id ?? never(),
+    },
+    types: vote2Types,
+  });
+}
+
+function isNumberArray(value: unknown): value is number[] {
+  return Array.isArray(value) && value.every(isNumber);
+}
+
+function validateMultipleChoice(
+  request: { choice: VoteChoice },
+  proposal: SnapshotProposal,
+): asserts request is { choice: number[] } {
+  invariant(isNumberArray(request.choice), 'Choice must be an array of numbers');
+  invariant(request.choice.length > 0, 'Choice must contain at least one choice');
+  invariant(
+    request.choice.length <= proposal.choices.length,
+    'Choice must contain at most the number of choices',
+  );
+  invariant(
+    request.choice.every((c) => c >= 0),
+    'Choice is a 0-based index, it must be a positive number',
+  );
+  invariant(
+    request.choice.every((c) => c < proposal.choices.length),
+    'Choice is a 0-based index, it must be less than the number of choices',
+  );
+}
+
+function multipleChoiceTypedData(
+  proposal: SnapshotProposal,
+  choice: number[],
+  voter: Wallet,
+  appId?: AppId,
+): TypedData {
+  return createTypedData({
+    message: {
+      app: appId ?? '',
+      choice: choice.map((c) => c + 1),
+      from: getAddress(voter.address),
+      proposal: proposal.id,
+      space: proposal.space?.id ?? never(),
+    },
+    types: voteArray2Types,
+  });
+}
+
+function serializeWeightedChoice(choice: number[]): string {
+  const map = choice.reduce((acc, value, idx) => {
+    if (value > 0) {
+      acc[idx + 1] = value;
+    }
+    return acc;
+  }, {} as { [key: number]: number });
+  return JSON.stringify(map);
+}
+
+function validateWeightedChoice(
+  request: { choice: VoteChoice },
+  proposal: SnapshotProposal,
+): asserts request is { choice: number[] } {
+  invariant(isNumberArray(request.choice), 'Choice must be an array of numbers');
+  invariant(
+    request.choice.length === proposal.choices.length,
+    'Choice must specify a value for each proposal choice',
+  );
+  invariant(
+    request.choice.every((c) => c >= 0),
+    'Choice is a 0-based index, it must be a positive number',
+  );
+}
+
+function weightedChoiceTypedData(
+  proposal: SnapshotProposal,
+  choice: number[],
+  voter: Wallet,
+  appId?: AppId,
+): TypedData {
+  return createTypedData({
+    message: {
+      app: appId ?? '',
+      choice: serializeWeightedChoice(choice),
+      from: getAddress(voter.address),
+      proposal: proposal.id,
+      space: proposal.space?.id ?? never(),
+    },
+    types: voteString2Types,
+  });
+}
+
+function resolveTypedData(
+  proposal: SnapshotProposal,
+  request: CreateUnsignedVoteRequest,
+  appId?: AppId,
+): TypedData {
+  switch (proposal.type) {
+    case SnapshotVotingSystem.BASIC:
+    case SnapshotVotingSystem.SINGLE_CHOICE:
+      validateSingleChoice(request, proposal);
+      return singleChoiceTypedData(proposal, request.choice, request.voter, appId);
+
+    case SnapshotVotingSystem.APPROVAL:
+    case SnapshotVotingSystem.RANKED_CHOICE:
+      validateMultipleChoice(request, proposal);
+      return multipleChoiceTypedData(proposal, request.choice, request.voter, appId);
+
+    case SnapshotVotingSystem.QUADRATIC:
+    case SnapshotVotingSystem.WEIGHTED:
+      validateWeightedChoice(request, proposal);
+      return weightedChoiceTypedData(proposal, request.choice, request.voter, appId);
+
+    default:
+      throw new InvariantError(`Unsupported voting system: ${String(proposal.type)}`);
+  }
+}
+
+export class SnapshotVoteFactory implements IUnsignedVoteFactory {
+  constructor(
+    private readonly client: SafeApolloClient,
+    private readonly spaceId: SnapshotSpaceId,
+    private readonly appId?: AppId,
+  ) {}
+
+  async createUnsignedVote(request: CreateUnsignedVoteRequest): Promise<UnsignedVote> {
+    const result = await this.client.query<GetSnapshotProposalData, GetSnapshotProposalVariables>({
+      query: GetSnapshotProposalDocument,
+      variables: {
+        spaceId: this.spaceId,
+        proposalId: request.pollId,
+        includeVotes: false,
+        voterAddress: '0x000',
+      },
+    });
+
+    const proposal = result.data.proposal;
+    invariant(proposal !== null, 'Proposal not found');
+    invariant(
+      proposal.privacy !== 'shutter',
+      'Proposal with shutter privacy are not supported at this time',
+    );
+
+    return new UnsignedVote(request.pollId, resolveTypedData(proposal, request, this.appId));
+  }
+}
diff --git a/packages/react/src/polls/adapters/SnapshotVoteRelayer.ts b/packages/react/src/polls/adapters/SnapshotVoteRelayer.ts
new file mode 100644
index 0000000000..17bc9059bf
--- /dev/null
+++ b/packages/react/src/polls/adapters/SnapshotVoteRelayer.ts
@@ -0,0 +1,44 @@
+import { TypedData } from '@lens-protocol/blockchain-bindings';
+import { ISignedVote } from '@lens-protocol/domain/entities';
+import { IPollVoteRelayer } from '@lens-protocol/domain/use-cases/polls';
+import { EvmAddress, Url } from '@lens-protocol/shared-kernel';
+
+export interface ISnapshotVote extends ISignedVote {
+  voter: EvmAddress;
+  data: TypedData;
+}
+
+export class SnapshotRelayError extends Error {
+  name = 'SnapshotRelayError' as const;
+}
+
+export class SnapshotVoteRelayer implements IPollVoteRelayer {
+  constructor(private readonly sequencer: Url) {}
+
+  async relay({ data, pollId, signature, voter }: ISnapshotVote): Promise<void> {
+    const envelope = {
+      address: voter,
+      data,
+      sig: signature,
+    };
+
+    const response = await fetch(this.sequencer, {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(envelope),
+    });
+
+    if (!response.ok) {
+      throw new SnapshotRelayError(
+        `Failed to relay snapshot vote for proposal: ${pollId}\n\n` +
+          `${JSON.stringify(data, null, 2)
+            .split(`\n`)
+            .map((line) => `  ${line}`)
+            .join('\n')}`,
+      );
+    }
+  }
+}
diff --git a/packages/react/src/polls/adapters/__helpers__/mocks.ts b/packages/react/src/polls/adapters/__helpers__/mocks.ts
new file mode 100644
index 0000000000..dc89439362
--- /dev/null
+++ b/packages/react/src/polls/adapters/__helpers__/mocks.ts
@@ -0,0 +1,8 @@
+import { TypedData } from '@lens-protocol/blockchain-bindings';
+import { mockPollId } from '@lens-protocol/domain/mocks';
+
+import { UnsignedVote } from '../SnapshotVoteFactory';
+
+export function mockUnsignedVote({ typedData }: { typedData: TypedData }): UnsignedVote {
+  return new UnsignedVote(mockPollId(), typedData);
+}
diff --git a/packages/react/src/polls/adapters/__tests__/SnapshotVoteFactory.spec.ts b/packages/react/src/polls/adapters/__tests__/SnapshotVoteFactory.spec.ts
new file mode 100644
index 0000000000..266258489f
--- /dev/null
+++ b/packages/react/src/polls/adapters/__tests__/SnapshotVoteFactory.spec.ts
@@ -0,0 +1,284 @@
+import {
+  SnapshotProposal,
+  SnapshotSpaceId,
+  SnapshotVotingSystem,
+} from '@lens-protocol/api-bindings';
+import {
+  mockGetSnapshotProposalDataResponse,
+  mockSnapshotApolloClient,
+  mockSnapshotProposal,
+} from '@lens-protocol/api-bindings/mocks';
+import { AppId, PollId } from '@lens-protocol/domain/entities';
+import { mockAppId, mockCreateUnsignedVoteRequest, mockWallet } from '@lens-protocol/domain/mocks';
+import { InvariantError, never } from '@lens-protocol/shared-kernel';
+import { mockEvmAddress } from '@lens-protocol/shared-kernel/mocks';
+import { getAddress } from 'ethers/lib/utils';
+
+import { SnapshotVoteFactory, UnsignedVote } from '../SnapshotVoteFactory';
+import { vote2Types, voteArray2Types, voteString2Types } from '../types';
+
+function setupTestScenario({ appId, proposal }: { appId?: AppId; proposal: SnapshotProposal }) {
+  const client = mockSnapshotApolloClient([mockGetSnapshotProposalDataResponse({ proposal })]);
+
+  return new SnapshotVoteFactory(client, (proposal.space?.id ?? never()) as SnapshotSpaceId, appId);
+}
+
+describe(`Given an instance of the ${SnapshotVoteFactory.name}`, () => {
+  const voter = mockWallet({
+    // ensures `from` has EIP-55 checksum
+    address: mockEvmAddress().toLowerCase(),
+  });
+
+  const appId = mockAppId();
+
+  describe.each([
+    {
+      proposal: mockSnapshotProposal({
+        type: SnapshotVotingSystem.SINGLE_CHOICE,
+      }),
+    },
+    {
+      proposal: mockSnapshotProposal({
+        type: SnapshotVotingSystem.BASIC,
+      }),
+    },
+  ])(
+    `when the ${SnapshotVoteFactory.prototype.createUnsignedVote.name} method is invoked for a proposal w/ "$proposal.type" voting system`,
+    ({ proposal }) => {
+      it(`should create an instance of ${UnsignedVote.name} w/ the expected EIP-712 typed data"`, async () => {
+        const request = mockCreateUnsignedVoteRequest({
+          pollId: proposal.id as PollId,
+          choice: 0,
+          voter,
+        });
+        const factory = setupTestScenario({ appId, proposal });
+
+        const vote = await factory.createUnsignedVote(request);
+
+        const expectedTypedData = {
+          domain: {
+            name: expect.any(String),
+            version: expect.any(String),
+          },
+          types: vote2Types,
+          message: {
+            choice: 1,
+            reason: '',
+            proposal: proposal.id,
+            space: proposal.space?.id ?? never(),
+            app: appId,
+            metadata: '{}',
+            from: getAddress(voter.address),
+            timestamp: expect.any(Number),
+          },
+        };
+        expect(vote).toBeInstanceOf(UnsignedVote);
+        expect(vote.typedData).toMatchObject(expectedTypedData);
+      });
+
+      it.each([
+        {
+          choice: [0],
+          description: 'not a number',
+        },
+        {
+          choice: -1,
+          description: 'less than 0',
+        },
+        {
+          choice: proposal.choices.length,
+          description: 'greater than the number of choices',
+        },
+      ])(
+        `should throw an ${InvariantError.name} if the "choice" is $description`,
+        async ({ choice }) => {
+          const request = mockCreateUnsignedVoteRequest({
+            pollId: proposal.id as PollId,
+            choice,
+            voter,
+          });
+          const factory = setupTestScenario({ proposal });
+
+          await expect(factory.createUnsignedVote(request)).rejects.toThrow(InvariantError);
+        },
+      );
+    },
+  );
+
+  describe.each([
+    {
+      proposal: mockSnapshotProposal({
+        type: SnapshotVotingSystem.APPROVAL,
+        choices: ['a', 'b', 'c'],
+      }),
+    },
+    {
+      proposal: mockSnapshotProposal({
+        type: SnapshotVotingSystem.RANKED_CHOICE,
+        choices: ['a', 'b', 'c'],
+      }),
+    },
+  ])(
+    `when the ${SnapshotVoteFactory.prototype.createUnsignedVote.name} method is invoked for a proposal w/ "$proposal.type" voting system`,
+    ({ proposal }) => {
+      it(`should create an instance of ${UnsignedVote.name} w/ the expected EIP-712 typed data"`, async () => {
+        const request = mockCreateUnsignedVoteRequest({
+          pollId: proposal.id as PollId,
+          choice: [0, 1],
+          voter,
+        });
+        const factory = setupTestScenario({ appId, proposal });
+
+        const vote = await factory.createUnsignedVote(request);
+
+        const expectedTypedData = {
+          domain: {
+            name: expect.any(String),
+            version: expect.any(String),
+          },
+          types: voteArray2Types,
+          message: {
+            choice: [1, 2],
+            reason: '',
+            proposal: proposal.id,
+            space: proposal.space?.id ?? never(),
+            app: appId,
+            metadata: '{}',
+            from: getAddress(voter.address),
+            timestamp: expect.any(Number),
+          },
+        };
+        expect(vote).toBeInstanceOf(UnsignedVote);
+        expect(vote.typedData).toMatchObject(expectedTypedData);
+      });
+
+      it.each([
+        {
+          choice: 0,
+          description: 'is not an array of numbers',
+        },
+        {
+          choice: [],
+          description: 'is an empty array',
+        },
+        {
+          choice: [-1, 0],
+          description: 'contains negative numbers',
+        },
+        {
+          choice: [0, 1, 2, 3, 4, 5],
+          description: 'contains more choices than the proposal has',
+        },
+        {
+          choice: [0, 1, 1000],
+          description: 'contains choices that are greater than the number of choices',
+        },
+      ])(
+        `should throw an ${InvariantError.name} if the "choice" $description`,
+        async ({ choice }) => {
+          const request = mockCreateUnsignedVoteRequest({
+            pollId: proposal.id as PollId,
+            choice,
+            voter,
+          });
+          const factory = setupTestScenario({ proposal });
+
+          await expect(factory.createUnsignedVote(request)).rejects.toThrow(InvariantError);
+        },
+      );
+    },
+  );
+
+  describe.each([
+    {
+      proposal: mockSnapshotProposal({
+        type: SnapshotVotingSystem.QUADRATIC,
+        choices: ['a', 'b', 'c'],
+      }),
+    },
+    {
+      proposal: mockSnapshotProposal({
+        type: SnapshotVotingSystem.WEIGHTED,
+        choices: ['a', 'b', 'c'],
+      }),
+    },
+  ])(
+    `when the ${SnapshotVoteFactory.prototype.createUnsignedVote.name} method is invoked for a proposal w/ "$proposal.type" voting system`,
+    ({ proposal }) => {
+      it(`should create an instance of ${UnsignedVote.name} w/ the expected EIP-712 typed data"`, async () => {
+        const request = mockCreateUnsignedVoteRequest({
+          pollId: proposal.id as PollId,
+          choice: [0, 1, 0],
+          voter,
+        });
+        const factory = setupTestScenario({ appId, proposal });
+
+        const vote = await factory.createUnsignedVote(request);
+
+        const expectedTypedData = {
+          domain: {
+            name: expect.any(String),
+            version: expect.any(String),
+          },
+          types: voteString2Types,
+          message: {
+            choice: JSON.stringify({ 2: 1 }),
+            reason: '',
+            proposal: proposal.id,
+            space: proposal.space?.id ?? never(),
+            app: appId,
+            metadata: '{}',
+            from: getAddress(voter.address),
+            timestamp: expect.any(Number),
+          },
+        };
+        expect(vote).toBeInstanceOf(UnsignedVote);
+        expect(vote.typedData).toMatchObject(expectedTypedData);
+      });
+
+      it.each([
+        {
+          choice: 0,
+          description: 'is not an array of numbers',
+        },
+        {
+          choice: [0],
+          description: 'is shorter than the number of choices',
+        },
+        {
+          choice: [-1, 0, 0],
+          description: 'contains negative numbers',
+        },
+      ])(
+        `should throw an ${InvariantError.name} if the "choice" $description`,
+        async ({ choice }) => {
+          const request = mockCreateUnsignedVoteRequest({
+            pollId: proposal.id as PollId,
+            choice,
+            voter,
+          });
+          const factory = setupTestScenario({ proposal });
+
+          await expect(factory.createUnsignedVote(request)).rejects.toThrow(InvariantError);
+        },
+      );
+    },
+  );
+
+  describe(`when the proposal has "privacy" set to "shutter"`, () => {
+    it(`should throw an ${InvariantError.name}`, async () => {
+      const proposal = mockSnapshotProposal({
+        type: SnapshotVotingSystem.QUADRATIC,
+        privacy: 'shutter',
+      });
+      const request = mockCreateUnsignedVoteRequest({
+        pollId: proposal.id as PollId,
+        choice: 0,
+        voter,
+      });
+      const factory = setupTestScenario({ appId, proposal });
+
+      await expect(factory.createUnsignedVote(request)).rejects.toThrow(InvariantError);
+    });
+  });
+});
diff --git a/packages/react/src/polls/adapters/__tests__/SnapshotVoteRelayer.spec.ts b/packages/react/src/polls/adapters/__tests__/SnapshotVoteRelayer.spec.ts
new file mode 100644
index 0000000000..4e98501e0e
--- /dev/null
+++ b/packages/react/src/polls/adapters/__tests__/SnapshotVoteRelayer.spec.ts
@@ -0,0 +1,99 @@
+/*
+ * @jest-environment node
+ */
+
+import { faker } from '@faker-js/faker';
+import { mock32BytesHexString, mockEvmAddress } from '@lens-protocol/shared-kernel/mocks';
+import { when } from 'jest-when';
+
+import { production } from '../../../environments';
+import { mockSignedVote } from '../../../wallet/adapters/__helpers__/mocks';
+import { SnapshotRelayError, SnapshotVoteRelayer } from '../SnapshotVoteRelayer';
+
+const sequencer = production.snapshot.sequencer;
+
+function createHttpJsonResponse(
+  status: number,
+  body: unknown,
+  headers: Record<string, string> = {},
+): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      ...headers,
+      'Content-Type': 'application/json',
+    },
+  });
+}
+
+function createSuccessfulResponse() {
+  return createHttpJsonResponse(
+    200,
+    JSON.stringify({
+      id: mock32BytesHexString(),
+      ipfs: faker.random.alphaNumeric(10),
+      relayer: {
+        address: mockEvmAddress(),
+        receipt: faker.datatype.hexadecimal({ length: 65 }),
+      },
+    }),
+  );
+}
+
+function createFailedRequest() {
+  return createHttpJsonResponse(
+    500,
+    `<!DOCTYPE html><html>...`, // properly wrong to prove robustness
+  );
+}
+
+function setupTestScenario() {
+  const snapshotVoteRelayer = new SnapshotVoteRelayer(production.snapshot.sequencer);
+  return snapshotVoteRelayer;
+}
+
+describe(`Given an instance of the ${SnapshotVoteRelayer.name}`, () => {
+  describe(`when calling "${SnapshotVoteRelayer.prototype.relay.name}" method`, () => {
+    const signedVote = mockSignedVote();
+
+    beforeAll(() => {
+      jest.spyOn(global, 'fetch');
+    });
+
+    afterAll(() => {
+      jest.mocked(fetch).mockRestore();
+    });
+
+    it('should send the expected data envelope to the snapshot sequencer', async () => {
+      when(fetch).mockResolvedValue(createSuccessfulResponse());
+
+      const snapshotVoteRelayer = setupTestScenario();
+
+      await snapshotVoteRelayer.relay(signedVote);
+
+      expect(fetch).toBeCalledWith(
+        sequencer,
+        expect.objectContaining({
+          method: 'POST',
+          headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            address: signedVote.voter,
+            data: signedVote.data,
+            sig: signedVote.signature,
+          }),
+        }),
+      );
+    });
+
+    it(`should throw an ${SnapshotRelayError.name} in case of failed request`, async () => {
+      when(fetch).mockResolvedValue(createFailedRequest());
+
+      const snapshotVoteRelayer = setupTestScenario();
+
+      await expect(snapshotVoteRelayer.relay(signedVote)).rejects.toThrowError(SnapshotRelayError);
+    });
+  });
+});
diff --git a/packages/react/src/polls/adapters/types.ts b/packages/react/src/polls/adapters/types.ts
new file mode 100644
index 0000000000..061b589ea6
--- /dev/null
+++ b/packages/react/src/polls/adapters/types.ts
@@ -0,0 +1,77 @@
+export const voteTypes = {
+  Vote: [
+    { name: 'from', type: 'address' },
+    { name: 'space', type: 'string' },
+    { name: 'timestamp', type: 'uint64' },
+    { name: 'proposal', type: 'string' },
+    { name: 'choice', type: 'uint32' },
+    { name: 'reason', type: 'string' },
+    { name: 'app', type: 'string' },
+    { name: 'metadata', type: 'string' },
+  ],
+};
+
+export const voteArrayTypes = {
+  Vote: [
+    { name: 'from', type: 'address' },
+    { name: 'space', type: 'string' },
+    { name: 'timestamp', type: 'uint64' },
+    { name: 'proposal', type: 'string' },
+    { name: 'choice', type: 'uint32[]' },
+    { name: 'reason', type: 'string' },
+    { name: 'app', type: 'string' },
+    { name: 'metadata', type: 'string' },
+  ],
+};
+
+export const voteStringTypes = {
+  Vote: [
+    { name: 'from', type: 'address' },
+    { name: 'space', type: 'string' },
+    { name: 'timestamp', type: 'uint64' },
+    { name: 'proposal', type: 'string' },
+    { name: 'choice', type: 'string' },
+    { name: 'reason', type: 'string' },
+    { name: 'app', type: 'string' },
+    { name: 'metadata', type: 'string' },
+  ],
+};
+
+export const vote2Types = {
+  Vote: [
+    { name: 'from', type: 'address' },
+    { name: 'space', type: 'string' },
+    { name: 'timestamp', type: 'uint64' },
+    { name: 'proposal', type: 'bytes32' },
+    { name: 'choice', type: 'uint32' },
+    { name: 'reason', type: 'string' },
+    { name: 'app', type: 'string' },
+    { name: 'metadata', type: 'string' },
+  ],
+};
+
+export const voteArray2Types = {
+  Vote: [
+    { name: 'from', type: 'address' },
+    { name: 'space', type: 'string' },
+    { name: 'timestamp', type: 'uint64' },
+    { name: 'proposal', type: 'bytes32' },
+    { name: 'choice', type: 'uint32[]' },
+    { name: 'reason', type: 'string' },
+    { name: 'app', type: 'string' },
+    { name: 'metadata', type: 'string' },
+  ],
+};
+
+export const voteString2Types = {
+  Vote: [
+    { name: 'from', type: 'address' },
+    { name: 'space', type: 'string' },
+    { name: 'timestamp', type: 'uint64' },
+    { name: 'proposal', type: 'bytes32' },
+    { name: 'choice', type: 'string' },
+    { name: 'reason', type: 'string' },
+    { name: 'app', type: 'string' },
+    { name: 'metadata', type: 'string' },
+  ],
+};
diff --git a/packages/react/src/profile/adapters/IProfileCacheManager.ts b/packages/react/src/profile/adapters/IProfileCacheManager.ts
new file mode 100644
index 0000000000..cbcd954123
--- /dev/null
+++ b/packages/react/src/profile/adapters/IProfileCacheManager.ts
@@ -0,0 +1,10 @@
+import { Profile } from '@lens-protocol/api-bindings';
+import { ProfileId } from '@lens-protocol/domain/entities';
+
+export interface IProfileCacheManager {
+  fetchProfile(id: ProfileId): Promise<Profile | null>;
+
+  refreshProfile(id: ProfileId): Promise<Profile>;
+
+  updateProfile(id: ProfileId, updateFn: (current: Profile) => Profile): void;
+}
diff --git a/packages/react/src/profile/infrastructure/ProfileCacheManager.ts b/packages/react/src/profile/infrastructure/ProfileCacheManager.ts
new file mode 100644
index 0000000000..c28d883239
--- /dev/null
+++ b/packages/react/src/profile/infrastructure/ProfileCacheManager.ts
@@ -0,0 +1,69 @@
+import { FetchPolicy } from '@apollo/client';
+import {
+  FragmentProfile,
+  Profile,
+  ProfileData,
+  ProfileDocument,
+  ProfileVariables,
+  SafeApolloClient,
+} from '@lens-protocol/api-bindings';
+import { ProfileId } from '@lens-protocol/domain/entities';
+import { never } from '@lens-protocol/shared-kernel';
+
+import { mediaTransformConfigToQueryVariables, MediaTransformsConfig } from '../../mediaTransforms';
+import { IProfileCacheManager } from '../adapters/IProfileCacheManager';
+
+export class ProfileCacheManager implements IProfileCacheManager {
+  constructor(
+    private readonly client: SafeApolloClient,
+    private readonly mediaTransforms: MediaTransformsConfig,
+  ) {}
+
+  async fetchProfile(id: ProfileId) {
+    return this.request(id, 'cache-first');
+  }
+
+  async refreshProfile(id: ProfileId) {
+    const profile = await this.request(id, 'network-only');
+
+    return profile ?? never();
+  }
+
+  updateProfile(id: string, updateFn: (current: Profile) => Profile): void {
+    const identifier =
+      this.client.cache.identify({ __typename: 'Profile', id }) ??
+      never('Profile identifier not found');
+
+    const profile = this.client.cache.readFragment<Profile>({
+      id: identifier,
+      fragmentName: 'Profile',
+      fragment: FragmentProfile,
+    });
+
+    if (profile) {
+      const updated = updateFn(profile);
+
+      this.client.cache.writeFragment<Profile>({
+        id: identifier,
+        fragmentName: 'Profile',
+        fragment: FragmentProfile,
+        data: updated,
+      });
+    }
+  }
+
+  private async request(id: ProfileId, fetchPolicy: FetchPolicy) {
+    const { data } = await this.client.query<ProfileData, ProfileVariables>({
+      query: ProfileDocument,
+      variables: {
+        request: {
+          forProfileId: id,
+        },
+        ...mediaTransformConfigToQueryVariables(this.mediaTransforms),
+      },
+      fetchPolicy,
+    });
+
+    return data.result;
+  }
+}
diff --git a/packages/react/src/shared.tsx b/packages/react/src/shared.tsx
index c20033ae36..36b90787d0 100644
--- a/packages/react/src/shared.tsx
+++ b/packages/react/src/shared.tsx
@@ -1,33 +1,39 @@
-import { createLensApolloClient, SafeApolloClient } from '@lens-protocol/api-bindings';
-import { AppId } from '@lens-protocol/domain/entities';
-import { ILogger, invariant } from '@lens-protocol/shared-kernel';
+import { createAuthApolloClient, createLensApolloClient } from '@lens-protocol/api-bindings';
+import { invariant } from '@lens-protocol/shared-kernel';
 import React, { ReactNode, useContext } from 'react';
 
 import { ConsoleLogger } from './ConsoleLogger';
+import { AccessTokenStorage } from './authentication/adapters/AccessTokenStorage';
+import { AuthApi } from './authentication/adapters/AuthApi';
+import { CredentialsFactory } from './authentication/adapters/CredentialsFactory';
+import { CredentialsGateway } from './authentication/adapters/CredentialsGateway';
+import { CredentialsStorage } from './authentication/adapters/CredentialsStorage';
 import { LensConfig } from './config';
-import { EnvironmentConfig } from './environments';
-import { defaultMediaTransformsConfig, MediaTransformsConfig } from './mediaTransforms';
+import { defaultMediaTransformsConfig } from './mediaTransforms';
+import { ProfileCacheManager } from './profile/infrastructure/ProfileCacheManager';
+import { TransactionFactory } from './transactions/infrastructure/TransactionFactory';
+import { TransactionObserver } from './transactions/infrastructure/TransactionObserver';
+import { WalletFactory } from './wallet/adapters/WalletFactory';
+import { WalletGateway } from './wallet/adapters/WalletGateway';
+import { ProviderFactory } from './wallet/infrastructure/ProviderFactory';
+import { SignerFactory } from './wallet/infrastructure/SignerFactory';
+import { createWalletStorage } from './wallet/infrastructure/WalletStorage';
 
-export type SharedDependencies = {
-  apolloClient: SafeApolloClient;
-  appId?: AppId;
-  environment: EnvironmentConfig;
-  logger: ILogger;
-  mediaTransforms: MediaTransformsConfig;
-};
-
-export function createSharedDependencies(config: LensConfig): SharedDependencies {
+export function createSharedDependencies(config: LensConfig) {
   const logger = config.logger ?? new ConsoleLogger();
   const mediaTransforms = config.mediaTransforms ?? defaultMediaTransformsConfig;
 
-  const accessTokenStorage = {
-    getAccessToken() {
-      return '';
-    },
-    refreshToken() {
-      return Promise.resolve();
-    },
-  };
+  // auth api
+  const anonymousApolloClient = createAuthApolloClient({
+    backendURL: config.environment.backend,
+    logger,
+  });
+  const authApi = new AuthApi(anonymousApolloClient);
+
+  // storages
+  const credentialsStorage = new CredentialsStorage(config.storage, config.environment.name);
+  const accessTokenStorage = new AccessTokenStorage(authApi, credentialsStorage);
+  const walletStorage = createWalletStorage(config.storage, config.environment.name);
 
   // apollo client
   const apolloClient = createLensApolloClient({
@@ -38,15 +44,39 @@ export function createSharedDependencies(config: LensConfig): SharedDependencies
     contentMatchers: [config.environment.snapshot.matcher],
   });
 
+  // infrastructure
+  const signerFactory = new SignerFactory(config.bindings, config.environment.chains);
+  const providerFactory = new ProviderFactory(config.bindings, config.environment.chains);
+  const transactionObserver = new TransactionObserver(
+    providerFactory,
+    apolloClient,
+    config.environment.timings,
+  );
+
+  // common adapters
+  const transactionFactory = new TransactionFactory(transactionObserver);
+  const credentialsFactory = new CredentialsFactory(authApi);
+  const credentialsGateway = new CredentialsGateway(credentialsStorage);
+  const profileCacheManager = new ProfileCacheManager(apolloClient, mediaTransforms);
+  const walletFactory = new WalletFactory(signerFactory, transactionFactory);
+  const walletGateway = new WalletGateway(walletStorage, walletFactory);
+
   return {
     apolloClient,
     appId: config.appId,
+    credentialsFactory,
+    credentialsGateway,
     environment: config.environment,
     logger,
     mediaTransforms,
+    profileCacheManager,
+    walletFactory,
+    walletGateway,
   };
 }
 
+export type SharedDependencies = ReturnType<typeof createSharedDependencies>;
+
 const SharedDependenciesContext = React.createContext<SharedDependencies | null>(null);
 
 type SharedDependenciesProviderProps = {
diff --git a/packages/react/src/transactions/adapters/ITransactionFactory.ts b/packages/react/src/transactions/adapters/ITransactionFactory.ts
new file mode 100644
index 0000000000..da303e51f2
--- /dev/null
+++ b/packages/react/src/transactions/adapters/ITransactionFactory.ts
@@ -0,0 +1,45 @@
+import {
+  AnyTransactionRequestModel,
+  MetaTransaction,
+  NativeTransaction,
+  Nonce,
+  JustProtocolRequest,
+  DataTransaction,
+} from '@lens-protocol/domain/entities';
+import { ChainType } from '@lens-protocol/shared-kernel';
+
+export type NativeTransactionData<T extends AnyTransactionRequestModel> = {
+  chainType: ChainType;
+  id: string;
+  indexingId?: string;
+  request: T;
+  txHash: string;
+};
+
+export type MetaTransactionData<T extends AnyTransactionRequestModel> = {
+  chainType: ChainType;
+  id: string;
+  indexingId: string;
+  nonce: Nonce;
+  request: T;
+  txHash: string;
+};
+
+export type DataTransactionData<T extends AnyTransactionRequestModel> = {
+  id: string;
+  request: T;
+};
+
+export interface ITransactionFactory<Supported extends AnyTransactionRequestModel> {
+  createMetaTransaction<T extends JustProtocolRequest<Supported>>(
+    init: MetaTransactionData<T>,
+  ): MetaTransaction<T>;
+
+  createNativeTransaction<T extends Supported>(
+    init: NativeTransactionData<T>,
+  ): NativeTransaction<T>;
+
+  createDataTransaction<T extends JustProtocolRequest<Supported>>(
+    init: DataTransactionData<T>,
+  ): DataTransaction<T>;
+}
diff --git a/packages/react/src/transactions/adapters/PendingTransactionGateway/ISerializableTransactionFactory.ts b/packages/react/src/transactions/adapters/PendingTransactionGateway/ISerializableTransactionFactory.ts
new file mode 100644
index 0000000000..916d73d401
--- /dev/null
+++ b/packages/react/src/transactions/adapters/PendingTransactionGateway/ISerializableTransactionFactory.ts
@@ -0,0 +1,46 @@
+import {
+  DataTransaction,
+  MetaTransaction,
+  NativeTransaction,
+} from '@lens-protocol/domain/entities';
+import {
+  ProtocolTransactionRequest,
+  AnyTransactionRequest,
+} from '@lens-protocol/domain/use-cases/transactions';
+
+import {
+  DataTransactionData,
+  ITransactionFactory,
+  MetaTransactionData,
+  NativeTransactionData,
+} from '../ITransactionFactory';
+
+export interface ISerializableMetaTransaction<T extends ProtocolTransactionRequest>
+  extends MetaTransaction<T> {
+  toTransactionData(): MetaTransactionData<T>;
+}
+
+export interface ISerializableNativeTransaction<T extends AnyTransactionRequest>
+  extends NativeTransaction<T> {
+  toTransactionData(): NativeTransactionData<T>;
+}
+
+export interface ISerializableDataTransaction<T extends ProtocolTransactionRequest>
+  extends DataTransaction<T> {
+  toTransactionData(): DataTransactionData<T>;
+}
+
+export interface ISerializableTransactionFactory
+  extends ITransactionFactory<AnyTransactionRequest> {
+  createMetaTransaction<T extends ProtocolTransactionRequest>(
+    init: MetaTransactionData<T>,
+  ): ISerializableMetaTransaction<T>;
+
+  createNativeTransaction<T extends AnyTransactionRequest>(
+    init: NativeTransactionData<T>,
+  ): ISerializableNativeTransaction<T>;
+
+  createDataTransaction<T extends ProtocolTransactionRequest>(
+    init: DataTransactionData<T>,
+  ): ISerializableDataTransaction<T>;
+}
diff --git a/packages/react/src/transactions/adapters/PendingTransactionGateway/PendingTransactionGateway.ts b/packages/react/src/transactions/adapters/PendingTransactionGateway/PendingTransactionGateway.ts
new file mode 100644
index 0000000000..5cddac5765
--- /dev/null
+++ b/packages/react/src/transactions/adapters/PendingTransactionGateway/PendingTransactionGateway.ts
@@ -0,0 +1,209 @@
+import {
+  MetaTransaction,
+  NativeTransaction,
+  JustProtocolRequest,
+  TransactionKind,
+  DataTransaction,
+} from '@lens-protocol/domain/entities';
+import {
+  IMetaTransactionNonceGateway,
+  IPendingTransactionGateway,
+  NewTransactionsSubscriber,
+  AnyTransactionRequest,
+} from '@lens-protocol/domain/use-cases/transactions';
+import { assertNever, invariant } from '@lens-protocol/shared-kernel';
+import { IStorage } from '@lens-protocol/storage';
+import differenceBy from 'lodash/differenceBy.js';
+
+import {
+  TransactionSchema,
+  TransactionStorageSchema,
+  TransactionType,
+} from '../schemas/transactions';
+import {
+  ISerializableDataTransaction,
+  ISerializableMetaTransaction,
+  ISerializableNativeTransaction,
+  ISerializableTransactionFactory,
+} from './ISerializableTransactionFactory';
+
+const lensHubTransactionKinds = [
+  TransactionKind.COLLECT_PUBLICATION,
+  TransactionKind.CREATE_COMMENT,
+  TransactionKind.CREATE_POST,
+  TransactionKind.FOLLOW_PROFILES,
+  TransactionKind.MIRROR_PUBLICATION,
+  TransactionKind.UPDATE_DISPATCHER_CONFIG,
+  TransactionKind.UPDATE_PROFILE_IMAGE,
+  TransactionKind.UPDATE_FOLLOW_POLICY,
+];
+
+const lensPeripheryTransactionKinds = [TransactionKind.UPDATE_PROFILE_DETAILS];
+
+const transactionKindToFilterGroup: { [k in TransactionKind]: TransactionKind[] } = {
+  [TransactionKind.COLLECT_PUBLICATION]: lensHubTransactionKinds,
+  [TransactionKind.CREATE_COMMENT]: lensHubTransactionKinds,
+  [TransactionKind.CREATE_POST]: lensHubTransactionKinds,
+  [TransactionKind.FOLLOW_PROFILES]: lensHubTransactionKinds,
+  [TransactionKind.MIRROR_PUBLICATION]: lensHubTransactionKinds,
+  [TransactionKind.UPDATE_DISPATCHER_CONFIG]: lensHubTransactionKinds,
+  [TransactionKind.UPDATE_PROFILE_IMAGE]: lensHubTransactionKinds,
+  [TransactionKind.UPDATE_FOLLOW_POLICY]: lensHubTransactionKinds,
+
+  [TransactionKind.UPDATE_PROFILE_DETAILS]: lensPeripheryTransactionKinds,
+
+  [TransactionKind.APPROVE_MODULE]: [],
+  [TransactionKind.CREATE_PROFILE]: [],
+  [TransactionKind.UNFOLLOW_PROFILE]: [],
+};
+
+function isSerializableMetaTransaction<T extends AnyTransactionRequest>(
+  tx: ISerializableTransaction<T>,
+): tx is ISerializableMetaTransaction<JustProtocolRequest<T>> {
+  return tx instanceof MetaTransaction;
+}
+
+type ISerializableTransaction<T extends AnyTransactionRequest> =
+  | ISerializableNativeTransaction<T>
+  | ISerializableMetaTransaction<JustProtocolRequest<T>>
+  | ISerializableDataTransaction<JustProtocolRequest<T>>;
+
+function toTransactionSchema(
+  tx: ISerializableTransaction<AnyTransactionRequest>,
+): TransactionSchema {
+  if (tx instanceof MetaTransaction) {
+    return {
+      type: TransactionType.Meta,
+      ...tx.toTransactionData(),
+    };
+  }
+
+  if (tx instanceof NativeTransaction) {
+    return {
+      type: TransactionType.Native,
+      ...tx.toTransactionData(),
+    };
+  }
+
+  if (tx instanceof DataTransaction) {
+    return {
+      type: TransactionType.Data,
+      ...tx.toTransactionData(),
+    };
+  }
+
+  assertNever(tx, 'Transaction type not supported');
+}
+
+export class PendingTransactionGateway
+  implements IPendingTransactionGateway<AnyTransactionRequest>, IMetaTransactionNonceGateway
+{
+  private cache?: ISerializableTransaction<AnyTransactionRequest>[];
+
+  constructor(
+    private readonly storage: IStorage<TransactionStorageSchema>,
+    private readonly transactionFactory: ISerializableTransactionFactory,
+  ) {}
+
+  async save(tx: ISerializableTransaction<AnyTransactionRequest>): Promise<void> {
+    const transactions = await this.getAll();
+    const newTransactions = [...transactions];
+
+    const idx = transactions.findIndex((entry) => entry.id === tx.id);
+    if (idx > -1) {
+      newTransactions.splice(idx, 1, tx);
+      await this.update(newTransactions);
+      return;
+    }
+
+    if (tx instanceof MetaTransaction) {
+      const expectedNonce = await this.getNextMetaTransactionNonceFor(tx.request.kind);
+
+      if (expectedNonce) {
+        invariant(
+          expectedNonce === tx.nonce,
+          `Nonce mismatch, was expecting ${expectedNonce}, got ${tx.nonce}`,
+        );
+      }
+    }
+
+    newTransactions.unshift(tx);
+    await this.update(newTransactions);
+  }
+
+  async remove(id: string): Promise<void> {
+    const transactions = await this.getAll();
+    await this.update(transactions.filter((tx) => tx.id !== id));
+  }
+
+  async getAll(): Promise<readonly ISerializableTransaction<AnyTransactionRequest>[]> {
+    if (this.cache) {
+      return this.cache.slice();
+    }
+    const data = await this.storage.get();
+
+    if (data === null) {
+      return [];
+    }
+
+    return data.map((entry) => this.toEntity(entry));
+  }
+
+  async getNextMetaTransactionNonceFor(kind: TransactionKind) {
+    const all = await this.getAll();
+
+    if (all.length === 0) {
+      return undefined;
+    }
+
+    const metaTransactions = all.filter(isSerializableMetaTransaction);
+    if (metaTransactions.length === 0) {
+      return undefined;
+    }
+
+    if (kind in transactionKindToFilterGroup) {
+      const filter = transactionKindToFilterGroup[kind];
+      const firstOfKind = metaTransactions.find((tx) => filter.includes(tx.request.kind));
+
+      return firstOfKind ? firstOfKind.nonce + 1 : undefined;
+    }
+    return undefined;
+  }
+
+  subscribe(subscriber: NewTransactionsSubscriber<AnyTransactionRequest>): void {
+    this.storage.subscribe(async (newData, oldData) => {
+      if (newData === null) {
+        return;
+      }
+      const updatedTransactions = newData.map((entry) => this.toEntity(entry));
+      const previousTransactions = oldData?.map((entry) => this.toEntity(entry)) ?? [];
+
+      const newTransaction = differenceBy(updatedTransactions, previousTransactions, (tx) => tx.id);
+
+      if (newTransaction.length > 0) {
+        subscriber(newTransaction);
+      }
+    });
+  }
+
+  private async update(
+    transactions: ISerializableTransaction<AnyTransactionRequest>[],
+  ): Promise<void> {
+    this.cache = transactions;
+    const data = transactions.map(toTransactionSchema);
+    await this.storage.set(data);
+  }
+
+  private toEntity(data: TransactionSchema): ISerializableTransaction<AnyTransactionRequest> {
+    switch (data.type) {
+      case TransactionType.Meta:
+        return this.transactionFactory.createMetaTransaction(data);
+      case TransactionType.Native:
+        return this.transactionFactory.createNativeTransaction(data);
+      case TransactionType.Data:
+        return this.transactionFactory.createDataTransaction(data);
+      default:
+        assertNever(data, 'Transaction type not supported');
+    }
+  }
+}
diff --git a/packages/react/src/transactions/adapters/PendingTransactionGateway/__tests__/PendingTransactionGateway.spec.ts b/packages/react/src/transactions/adapters/PendingTransactionGateway/__tests__/PendingTransactionGateway.spec.ts
new file mode 100644
index 0000000000..a741f01659
--- /dev/null
+++ b/packages/react/src/transactions/adapters/PendingTransactionGateway/__tests__/PendingTransactionGateway.spec.ts
@@ -0,0 +1,297 @@
+import { MetaTransaction, TransactionKind } from '@lens-protocol/domain/entities';
+import {
+  mockCreateProfileRequest,
+  mockUnconstrainedFollowRequest,
+  mockUnfollowRequest,
+  mockUpdateDispatcherConfigRequest,
+  mockUpdateFollowPolicyRequest,
+  mockUpdateOffChainProfileImageRequest,
+  mockUpdateProfileDetailsRequest,
+  mockCreateCommentRequest,
+  mockCreateMirrorRequest,
+  mockCreatePostRequest,
+  mockFreeCollectRequest,
+  mockTokenAllowanceRequest,
+} from '@lens-protocol/domain/mocks';
+import { AnyTransactionRequest } from '@lens-protocol/domain/use-cases/transactions';
+import { InvariantError } from '@lens-protocol/shared-kernel';
+import { IStorage, Storage } from '@lens-protocol/storage';
+import { mockStorage } from '@lens-protocol/storage/mocks';
+
+import { TransactionFactory } from '../../../infrastructure/TransactionFactory';
+import {
+  mockITransactionFactory,
+  mockMetaTransactionData,
+  mockNativeTransactionData,
+} from '../../__helpers__/mocks';
+import { TransactionStorageSchema } from '../../schemas/transactions';
+import { PendingTransactionGateway } from '../PendingTransactionGateway';
+
+function setupPendingTransactionGateway({
+  factory = mockITransactionFactory(),
+  storage = mockStorage<TransactionStorageSchema>(),
+}: {
+  factory?: TransactionFactory;
+  storage?: IStorage<TransactionStorageSchema>;
+}) {
+  return new PendingTransactionGateway(storage, factory);
+}
+
+type TransactionRequest = {
+  [K in TransactionKind]: Extract<AnyTransactionRequest, { kind: K }>;
+};
+
+const requests: TransactionRequest = {
+  [TransactionKind.APPROVE_MODULE]: mockTokenAllowanceRequest(),
+  [TransactionKind.COLLECT_PUBLICATION]: mockFreeCollectRequest(),
+  [TransactionKind.CREATE_COMMENT]: mockCreateCommentRequest(),
+  [TransactionKind.CREATE_POST]: mockCreatePostRequest(),
+  [TransactionKind.FOLLOW_PROFILES]: mockUnconstrainedFollowRequest(),
+  [TransactionKind.MIRROR_PUBLICATION]: mockCreateMirrorRequest(),
+  [TransactionKind.UPDATE_FOLLOW_POLICY]: mockUpdateFollowPolicyRequest(),
+  [TransactionKind.UPDATE_PROFILE_DETAILS]: mockUpdateProfileDetailsRequest(),
+  [TransactionKind.UPDATE_PROFILE_IMAGE]: mockUpdateOffChainProfileImageRequest(),
+  [TransactionKind.CREATE_PROFILE]: mockCreateProfileRequest(),
+  [TransactionKind.UNFOLLOW_PROFILE]: mockUnfollowRequest(),
+  [TransactionKind.UPDATE_DISPATCHER_CONFIG]: mockUpdateDispatcherConfigRequest(),
+};
+
+const lensHubTransactionKinds = [
+  TransactionKind.COLLECT_PUBLICATION,
+  TransactionKind.CREATE_COMMENT,
+  TransactionKind.CREATE_POST,
+  TransactionKind.FOLLOW_PROFILES,
+  TransactionKind.MIRROR_PUBLICATION,
+  TransactionKind.UPDATE_DISPATCHER_CONFIG,
+  TransactionKind.UPDATE_FOLLOW_POLICY,
+  TransactionKind.UPDATE_PROFILE_IMAGE,
+] as const;
+
+const lensPeripheryTransactionKinds = [TransactionKind.UPDATE_PROFILE_DETAILS] as const;
+
+describe(`Given an instance of the ${PendingTransactionGateway.name}`, () => {
+  const factory = mockITransactionFactory();
+
+  describe(`when the "${PendingTransactionGateway.prototype.save.name}" method is invoked`, () => {
+    const request = mockCreatePostRequest();
+
+    it(`should save in memory all the given Transaction alongside existing ones`, async () => {
+      const gateway = setupPendingTransactionGateway({ factory });
+
+      const init = mockMetaTransactionData({ request });
+      const tx = factory.createMetaTransaction(init);
+
+      await gateway.save(tx);
+
+      const actual = await gateway.getAll();
+      expect(actual).toEqual([tx]);
+    });
+
+    it('should update the existing tx if provided a second time', async () => {
+      const gateway = setupPendingTransactionGateway({ factory });
+
+      const init = mockMetaTransactionData({ request });
+      const tx = factory.createMetaTransaction(init);
+
+      await gateway.save(tx);
+      await gateway.save(tx);
+
+      const actual = await gateway.getAll();
+      expect(actual).toEqual([tx]);
+    });
+
+    it(`should throw an ${InvariantError.name} in case of ${MetaTransaction.name} with Nonce out of sequence`, async () => {
+      const initTx1 = mockMetaTransactionData({ request });
+      const tx1 = factory.createMetaTransaction(initTx1);
+
+      const gateway = setupPendingTransactionGateway({ factory });
+      await gateway.save(tx1);
+
+      const initTx2 = mockMetaTransactionData({ request, nonce: initTx1.nonce + 4002 });
+      const tx2 = factory.createMetaTransaction(initTx2);
+
+      await expect(() => gateway.save(tx2)).rejects.toThrow(InvariantError);
+    });
+  });
+
+  describe(`when the "${PendingTransactionGateway.prototype.remove.name}" method is invoked`, () => {
+    const request = mockCreatePostRequest();
+    const init = mockMetaTransactionData({ request });
+    const tx = factory.createMetaTransaction(init);
+
+    it(`should remove the Transaction for the given Id`, async () => {
+      const gateway = setupPendingTransactionGateway({ factory });
+      await gateway.save(tx);
+
+      await gateway.remove(tx.id);
+
+      const actual = await gateway.getAll();
+      expect(actual).toEqual([]);
+    });
+  });
+
+  describe(`when the underlying ${Storage.name} emits new data`, () => {
+    const request = mockCreatePostRequest();
+    const init = mockNativeTransactionData({ request });
+    const tx = factory.createNativeTransaction(init);
+    const mainStorage = mockStorage<TransactionStorageSchema>();
+    const mainGateway = setupPendingTransactionGateway({ factory, storage: mainStorage });
+
+    beforeAll(async () => {
+      await mainGateway.save(tx);
+    });
+
+    it('should emit new transactions', async () => {
+      const secondaryStorage = mockStorage<TransactionStorageSchema>();
+      const underTestGateway = setupPendingTransactionGateway({
+        factory,
+        storage: secondaryStorage,
+      });
+
+      const transactionsData = await mainStorage.get();
+      const subscriber = jest.fn();
+      underTestGateway.subscribe(subscriber);
+      secondaryStorage.simulateUpdate(transactionsData, null);
+
+      expect(subscriber).toHaveBeenCalledWith([
+        expect.objectContaining({
+          id: tx.id,
+        }),
+      ]);
+    });
+
+    it('should not emit in case of updated transactions only', async () => {
+      const underTestGateway = setupPendingTransactionGateway({
+        factory,
+        storage: mainStorage,
+      });
+
+      const transactionsData = await mainStorage.get();
+      const subscriber = jest.fn();
+      underTestGateway.subscribe(subscriber);
+      mainStorage.simulateUpdate(transactionsData, transactionsData);
+
+      expect(subscriber).not.toHaveBeenCalled();
+    });
+
+    it('should not emit in case of cleared storage event', async () => {
+      const storage = mockStorage<TransactionStorageSchema>();
+      const underTestGateway = setupPendingTransactionGateway({
+        factory,
+        storage,
+      });
+
+      const subscriber = jest.fn();
+      underTestGateway.subscribe(subscriber);
+      const transactionsData = await mainStorage.get();
+      storage.simulateUpdate(null, transactionsData);
+
+      expect(subscriber).not.toHaveBeenCalled();
+    });
+  });
+
+  describe(`when the "${PendingTransactionGateway.prototype.getNextMetaTransactionNonceFor.name}" method is invoked`, () => {
+    const request = mockCreatePostRequest();
+
+    it('should return undefined if empty', async () => {
+      const gateway = setupPendingTransactionGateway({ factory });
+
+      const nonce = await gateway.getNextMetaTransactionNonceFor(request.kind);
+
+      expect(nonce).toBeUndefined();
+    });
+
+    it(`should return undefined if no ${MetaTransaction.name}s are present`, async () => {
+      const init = mockNativeTransactionData({ request });
+      const tx = factory.createNativeTransaction(init);
+      const gateway = setupPendingTransactionGateway({ factory });
+      await gateway.save(tx);
+
+      const nonce = await gateway.getNextMetaTransactionNonceFor(TransactionKind.CREATE_POST);
+
+      expect(nonce).toBeUndefined();
+    });
+
+    describe('for a TransactionKind corresponding to a protocol method exposed on the LensHub.sol contract', () => {
+      it(`should compute the next Nonce based on the most recent ${MetaTransaction.name} exposed from the same contract`, async () => {
+        const gateway = setupPendingTransactionGateway({ factory });
+
+        for (let idx = 0; idx < lensHubTransactionKinds.length; idx++) {
+          const kind = lensHubTransactionKinds[idx];
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          const init = mockMetaTransactionData({ request: requests[kind!], nonce: idx });
+          const tx = factory.createMetaTransaction(init);
+
+          await gateway.save(tx);
+
+          expect(await gateway.getNextMetaTransactionNonceFor(TransactionKind.CREATE_POST)).toBe(
+            tx.nonce + 1,
+          );
+        }
+      });
+
+      it(`should not be affected by ${MetaTransaction.name} for methods exposed on LensPeriphery.sol contract`, async () => {
+        const request = mockUpdateProfileDetailsRequest();
+        const gateway = setupPendingTransactionGateway({ factory });
+        const init = mockMetaTransactionData({ request });
+        const tx = factory.createMetaTransaction(init);
+        await gateway.save(tx);
+
+        const nonce = await gateway.getNextMetaTransactionNonceFor(TransactionKind.CREATE_POST);
+
+        expect(nonce).toBeUndefined();
+      });
+    });
+
+    describe('for a TransactionKind corresponding to a protocol method exposed on the LensPeriphery.sol contract', () => {
+      it(`should compute the next Nonce based on the most recent ${MetaTransaction.name} exposed from the same contract`, async () => {
+        const gateway = setupPendingTransactionGateway({ factory });
+
+        for (let idx = 0; idx < lensPeripheryTransactionKinds.length; idx++) {
+          const kind = lensPeripheryTransactionKinds[idx];
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          const init = mockMetaTransactionData({ request: requests[kind!], nonce: idx });
+          const tx = factory.createMetaTransaction(init);
+
+          await gateway.save(tx);
+
+          expect(
+            await gateway.getNextMetaTransactionNonceFor(TransactionKind.UPDATE_PROFILE_DETAILS),
+          ).toBe(tx.nonce + 1);
+        }
+      });
+
+      it(`should not be affected by ${MetaTransaction.name} for methods exposed on LensHub.sol contract`, async () => {
+        const request = mockCreatePostRequest();
+        const gateway = setupPendingTransactionGateway({ factory });
+        const init = mockMetaTransactionData({ request });
+        const tx = factory.createMetaTransaction(init);
+        await gateway.save(tx);
+
+        const nonce = await gateway.getNextMetaTransactionNonceFor(
+          TransactionKind.UPDATE_PROFILE_DETAILS,
+        );
+
+        expect(nonce).toBeUndefined();
+      });
+    });
+
+    describe(`for ${TransactionKind.UNFOLLOW_PROFILE} meta-tx`, () => {
+      const request = mockUnfollowRequest();
+      const init = mockMetaTransactionData({ request });
+      const tx = factory.createMetaTransaction(init);
+
+      it(`should always return undefined cause the burn method is on Follow NFT contract
+            and keeping accurate tracking of nonces is more complex and not worth it`, async () => {
+        const gateway = setupPendingTransactionGateway({ factory });
+        await gateway.save(tx);
+
+        const nonce = await gateway.getNextMetaTransactionNonceFor(
+          TransactionKind.UNFOLLOW_PROFILE,
+        );
+
+        expect(nonce).toBeUndefined();
+      });
+    });
+  });
+});
diff --git a/packages/react/src/transactions/adapters/PendingTransactionGateway/index.ts b/packages/react/src/transactions/adapters/PendingTransactionGateway/index.ts
new file mode 100644
index 0000000000..ff1ba39bad
--- /dev/null
+++ b/packages/react/src/transactions/adapters/PendingTransactionGateway/index.ts
@@ -0,0 +1,6 @@
+export type {
+  ISerializableTransactionFactory,
+  ISerializableMetaTransaction,
+  ISerializableNativeTransaction,
+} from './ISerializableTransactionFactory';
+export { PendingTransactionGateway } from './PendingTransactionGateway';
diff --git a/packages/react/src/transactions/adapters/SelfFundedProtocolTransactionRequest.ts b/packages/react/src/transactions/adapters/SelfFundedProtocolTransactionRequest.ts
new file mode 100644
index 0000000000..0b05597b38
--- /dev/null
+++ b/packages/react/src/transactions/adapters/SelfFundedProtocolTransactionRequest.ts
@@ -0,0 +1,16 @@
+import { ProtocolTransactionRequestModel } from '@lens-protocol/domain/entities';
+import { Brand, Distribute, EvmAddress } from '@lens-protocol/shared-kernel';
+
+export type Data = Brand<string, 'Data'>;
+
+/**
+ * @internal
+ * @privateRemarks intentionally not exported
+ */
+type RawTransactionDetails = {
+  contractAddress: EvmAddress;
+  encodedData: Data;
+};
+
+export type SelfFundedProtocolTransactionRequest<T extends ProtocolTransactionRequestModel> =
+  Distribute<T, RawTransactionDetails>;
diff --git a/packages/react/src/transactions/adapters/__helpers__/mocks.ts b/packages/react/src/transactions/adapters/__helpers__/mocks.ts
new file mode 100644
index 0000000000..84ebf67f4f
--- /dev/null
+++ b/packages/react/src/transactions/adapters/__helpers__/mocks.ts
@@ -0,0 +1,97 @@
+import { faker } from '@faker-js/faker';
+import { TypedData } from '@lens-protocol/blockchain-bindings';
+import {
+  AnyTransactionRequestModel,
+  ProtocolTransactionRequestModel,
+} from '@lens-protocol/domain/entities';
+import {
+  mockAnyTransactionRequestModel,
+  mockNonce,
+  mockProtocolTransactionRequestModel,
+  mockTransactionHash,
+} from '@lens-protocol/domain/mocks';
+import { ChainType } from '@lens-protocol/shared-kernel';
+import { mockEvmAddress } from '@lens-protocol/shared-kernel/mocks';
+import { mock } from 'jest-mock-extended';
+
+import { ITransactionObserver, TransactionFactory } from '../../infrastructure/TransactionFactory';
+import { MetaTransactionData, NativeTransactionData } from '../ITransactionFactory';
+import {
+  Data,
+  SelfFundedProtocolTransactionRequest,
+} from '../SelfFundedProtocolTransactionRequest';
+
+export function mockITransactionFactory(
+  transactionObserver: ITransactionObserver = mock<ITransactionObserver>(),
+) {
+  // we create a TransactionFactory instance so to minimize the amount of mocking required,
+  // although consumers can still rely solely on the ITransactionFactory interface
+  return new TransactionFactory(transactionObserver);
+}
+
+export function mockTypedData(): TypedData {
+  return {
+    types: {
+      CreateProfileWithSig: [{ name: 'foo', type: 'string' }],
+    },
+    domain: {
+      name: 'none',
+      version: '1',
+      chainId: 1,
+      verifyingContract: mockEvmAddress(),
+    },
+    message: {
+      nonce: 0,
+    },
+  };
+}
+
+export function mockMetaTransactionData<T extends ProtocolTransactionRequestModel>({
+  request = mockProtocolTransactionRequestModel() as T,
+  ...others
+}: Partial<MetaTransactionData<T>> = {}): MetaTransactionData<T> {
+  return {
+    chainType: ChainType.ETHEREUM,
+    id: faker.datatype.uuid(),
+    indexingId: faker.datatype.uuid(),
+    nonce: mockNonce(),
+    request,
+    txHash: mockTransactionHash(),
+    ...others,
+  };
+}
+
+export function mockNativeTransactionData<T extends AnyTransactionRequestModel>({
+  request = mockAnyTransactionRequestModel() as T,
+  ...others
+}: Partial<NativeTransactionData<T>> = {}): NativeTransactionData<T> {
+  return {
+    chainType: ChainType.ETHEREUM,
+    id: faker.datatype.uuid(),
+    request,
+    txHash: mockTransactionHash(),
+    ...others,
+  };
+}
+
+export function mockNativeTransactionDataWithIndexingId<
+  T extends AnyTransactionRequestModel,
+>(): Required<NativeTransactionData<T>> {
+  return {
+    chainType: ChainType.ETHEREUM,
+    id: faker.datatype.uuid(),
+    indexingId: faker.datatype.uuid(),
+    request: mockAnyTransactionRequestModel() as T,
+    txHash: mockTransactionHash(),
+  };
+}
+
+export function mockSelfFundedProtocolTransactionRequest<
+  TRequest extends ProtocolTransactionRequestModel,
+>(): SelfFundedProtocolTransactionRequest<TRequest> {
+  return {
+    contractAddress: mockEvmAddress(),
+    encodedData: faker.datatype.hexadecimal({ length: 32 }) as Data,
+    ...mockAnyTransactionRequestModel(),
+  } as SelfFundedProtocolTransactionRequest<TRequest>;
+}
diff --git a/packages/react/src/transactions/adapters/schemas/__tests__/Erc20Amount.spec.ts b/packages/react/src/transactions/adapters/schemas/__tests__/Erc20Amount.spec.ts
new file mode 100644
index 0000000000..517ad2b766
--- /dev/null
+++ b/packages/react/src/transactions/adapters/schemas/__tests__/Erc20Amount.spec.ts
@@ -0,0 +1,25 @@
+import { mockDaiAmount } from '@lens-protocol/shared-kernel/mocks';
+
+import { Erc20AmountInstanceSchema, SerializedErc20AmountSchema } from '../common';
+
+describe(`Given the Erc20Amount schemas`, () => {
+  const amount = mockDaiAmount(1);
+
+  describe(`when parsing a value with SerializedErc20AmountSchema`, () => {
+    it('should be able return the expected Erc20Amount instance', () => {
+      const serialized = JSON.parse(JSON.stringify(amount)) as object;
+
+      const parsed = SerializedErc20AmountSchema.parse(serialized);
+
+      expect(parsed.eq(amount)).toBe(true);
+    });
+  });
+
+  describe(`when parsing a value with Erc20AmountInstanceSchema`, () => {
+    it('should verify instances of Erc20Amount', () => {
+      const parsed = Erc20AmountInstanceSchema.parse(amount);
+
+      expect(parsed.eq(amount)).toBe(true);
+    });
+  });
+});
diff --git a/packages/react/src/transactions/adapters/schemas/__tests__/formatters.spec.ts b/packages/react/src/transactions/adapters/schemas/__tests__/formatters.spec.ts
new file mode 100644
index 0000000000..f881bbff1f
--- /dev/null
+++ b/packages/react/src/transactions/adapters/schemas/__tests__/formatters.spec.ts
@@ -0,0 +1,57 @@
+import { SafeParseError, SafeParseReturnType, z } from 'zod';
+
+import { formatZodError } from '../formatters';
+
+function assertZodError(
+  result: SafeParseReturnType<unknown, unknown>,
+): asserts result is SafeParseError<unknown> {
+  if (result.success) {
+    throw new Error('Expected an error');
+  }
+}
+
+describe(`Given the schema formatters`, () => {
+  describe(`when using the "${formatZodError.name}" function`, () => {
+    const Schema = z.object({
+      number: z.number().optional(),
+      required: z.string(),
+      empty: z.array(z.string()).nonempty(),
+      array: z.array(z.string()),
+      union: z.union([
+        z.string(),
+        z.number(),
+        z.object({
+          required: z.string(),
+        }),
+      ]),
+      tuple: z.tuple([z.string(), z.number()]),
+    });
+
+    it('should generate the expected message', () => {
+      const result = Schema.safeParse({
+        number: 'not a number',
+        empty: [],
+        array: ['1', 2, '3'],
+        union: true,
+        tuple: [42, 'not a string'],
+      });
+      assertZodError(result);
+
+      expect(formatZodError(result.error)).toMatchInlineSnapshot(`
+        "fix the following issues
+        · "number": Expected number, received string
+        · "required": Required
+        · "empty": Array must contain at least 1 element(s)
+        · "array[1]": Expected string, received number
+        · "union" expected to match one of the following groups:
+        		· "union": Expected string, received boolean
+        	OR:
+        		· "union": Expected number, received boolean
+        	OR:
+        		· "union": Expected object, received boolean
+        · "tuple[0]": Expected string, received number
+        · "tuple[1]": Expected number, received string"
+      `);
+    });
+  });
+});
diff --git a/packages/react/src/transactions/adapters/schemas/__tests__/validators.spec.ts b/packages/react/src/transactions/adapters/schemas/__tests__/validators.spec.ts
new file mode 100644
index 0000000000..e0d93c49c7
--- /dev/null
+++ b/packages/react/src/transactions/adapters/schemas/__tests__/validators.spec.ts
@@ -0,0 +1,653 @@
+import { faker } from '@faker-js/faker';
+import {
+  AddressOwnershipCriterion,
+  CollectPublicationCriterion,
+  DecryptionCriteriaType,
+  Erc20OwnershipCriterion,
+  FollowProfileCriterion,
+  NftContractType,
+  NftOwnershipCriterion,
+  ProfileOwnershipCriterion,
+  TransactionKind,
+} from '@lens-protocol/domain/entities';
+import {
+  mockAddressOwnershipCriterion,
+  mockCollectPublicationCriterion,
+  mockCollectThisPublicationCriterion,
+  mockCreatePostRequest,
+  mockFollowProfileCriterion,
+  mockNftOwnershipCriterion,
+  mockProfileId,
+  mockProfileOwnershipCriterion,
+  mockPublicationId,
+} from '@lens-protocol/domain/mocks';
+import { FollowPolicyType } from '@lens-protocol/domain/use-cases/profile';
+import {
+  CollectPolicyType,
+  ContentFocus,
+  ReferencePolicyType,
+} from '@lens-protocol/domain/use-cases/publications';
+import { mockEvmAddress } from '@lens-protocol/shared-kernel/mocks';
+
+import {
+  validateCreateCommentRequest,
+  validateCreatePostRequest,
+  validateTokenAllowanceRequest,
+  validateUpdateFollowPolicyRequest,
+  validateUpdateProfileDetailsRequest,
+} from '../validators';
+
+describe(`Given the validator helpers`, () => {
+  describe(`when testing the "validateCreatePostRequest" on a request`, () => {
+    describe('with invalid "NftOwnershipCriterion" criteria for "decryptionCriteria"', () => {
+      it('should provide an actionable error message', () => {
+        expect(() =>
+          validateCreatePostRequest(
+            mockCreatePostRequest({
+              decryptionCriteria: {
+                type: DecryptionCriteriaType.AND,
+                and: [
+                  {
+                    type: DecryptionCriteriaType.NFT_OWNERSHIP,
+                  } as NftOwnershipCriterion,
+                  {
+                    type: DecryptionCriteriaType.NFT_OWNERSHIP,
+                    contractAddress: mockEvmAddress(),
+                    chainId: 1,
+                    contractType: NftContractType.Erc721,
+                    tokenIds: [],
+                  },
+                  {
+                    type: DecryptionCriteriaType.NFT_OWNERSHIP,
+                    contractAddress: mockEvmAddress(),
+                    chainId: 1,
+                    contractType: NftContractType.Erc721,
+                    tokenIds: Array.from({ length: 31 }, faker.datatype.hexadecimal),
+                  },
+                ],
+              },
+            }),
+          ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "decryptionCriteria.and[0].contractAddress": Required
+          · "decryptionCriteria.and[0].chainId": Required
+          · "decryptionCriteria.and[0].contractType": Required
+          · "decryptionCriteria.and[1].tokenIds": Array must contain at least 1 element(s)
+          · "decryptionCriteria.and[2].tokenIds": Array must contain at most 30 element(s)"
+        `);
+      });
+    });
+
+    describe('with invalid "Erc20OwnershipCriterion" criteria for "decryptionCriteria"', () => {
+      it('should provide an actionable error message', () => {
+        expect(() =>
+          validateCreatePostRequest(
+            mockCreatePostRequest({
+              decryptionCriteria: {
+                type: DecryptionCriteriaType.ERC20_OWNERSHIP,
+              } as Erc20OwnershipCriterion,
+            }),
+          ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "decryptionCriteria.amount": value not instance of Amount<Erc20>
+          · "decryptionCriteria.condition": Required"
+        `);
+      });
+    });
+
+    describe('with invalid "AddressOwnershipCriterion" criteria for "decryptionCriteria"', () => {
+      it('should provide an actionable error message', () => {
+        expect(() =>
+          validateCreatePostRequest(
+            mockCreatePostRequest({
+              decryptionCriteria: {
+                type: DecryptionCriteriaType.ADDRESS_OWNERSHIP,
+              } as AddressOwnershipCriterion,
+            }),
+          ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "decryptionCriteria.address": Required"
+        `);
+      });
+    });
+
+    describe('with invalid "ProfileOwnershipCriterion" criteria for "decryptionCriteria"', () => {
+      it('should provide an actionable error message', () => {
+        expect(() =>
+          validateCreatePostRequest(
+            mockCreatePostRequest({
+              decryptionCriteria: {
+                type: DecryptionCriteriaType.PROFILE_OWNERSHIP,
+              } as ProfileOwnershipCriterion,
+            }),
+          ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "decryptionCriteria.profileId": Required"
+        `);
+      });
+    });
+
+    describe('with invalid "FollowProfileCriterion" criteria for "decryptionCriteria"', () => {
+      it('should provide an actionable error message', () => {
+        expect(() =>
+          validateCreatePostRequest(
+            mockCreatePostRequest({
+              decryptionCriteria: {
+                type: DecryptionCriteriaType.FOLLOW_PROFILE,
+              } as FollowProfileCriterion,
+            }),
+          ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "decryptionCriteria.profileId": Required"
+        `);
+      });
+    });
+
+    describe('with invalid "CollectPublicationCriterion" criteria for "decryptionCriteria"', () => {
+      it('should provide an actionable error message', () => {
+        expect(() =>
+          validateCreatePostRequest(
+            mockCreatePostRequest({
+              decryptionCriteria: {
+                type: DecryptionCriteriaType.COLLECT_PUBLICATION,
+              } as CollectPublicationCriterion,
+            }),
+          ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "decryptionCriteria.publicationId": Required"
+        `);
+      });
+    });
+
+    describe('with invalid "AndCriterion" criteria for "decryptionCriteria"', () => {
+      it('should provide an actionable error message for not enough criteria', () => {
+        expect(() =>
+          validateCreatePostRequest(
+            mockCreatePostRequest({
+              decryptionCriteria: {
+                type: DecryptionCriteriaType.AND,
+                and: [mockCollectThisPublicationCriterion()],
+              },
+            }),
+          ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "decryptionCriteria.and": Array must contain at least 2 element(s)"
+        `);
+      });
+
+      it('should provide an actionable error message for duplicated criteria', () => {
+        expect(() =>
+          validateCreatePostRequest(
+            mockCreatePostRequest({
+              decryptionCriteria: {
+                type: DecryptionCriteriaType.AND,
+                and: [mockCollectThisPublicationCriterion(), mockCollectThisPublicationCriterion()],
+              },
+            }),
+          ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "decryptionCriteria.and": Must be an array of unique criteria"
+        `);
+      });
+
+      it('should provide an actionable error message for too many criteria', () => {
+        expect(() =>
+          validateCreatePostRequest(
+            mockCreatePostRequest({
+              decryptionCriteria: {
+                type: DecryptionCriteriaType.AND,
+                and: [
+                  mockCollectThisPublicationCriterion(),
+                  mockCollectPublicationCriterion(),
+                  mockNftOwnershipCriterion(),
+                  mockAddressOwnershipCriterion(),
+                  mockProfileOwnershipCriterion(),
+                  mockFollowProfileCriterion(),
+                ],
+              },
+            }),
+          ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "decryptionCriteria.and": Array must contain at most 5 element(s)"
+        `);
+      });
+    });
+
+    describe('with invalid "OrCriterion" criteria for "decryptionCriteria"', () => {
+      it('should provide an actionable error message for not enough criteria', () => {
+        expect(() =>
+          validateCreatePostRequest(
+            mockCreatePostRequest({
+              decryptionCriteria: {
+                type: DecryptionCriteriaType.OR,
+                or: [mockCollectThisPublicationCriterion()],
+              },
+            }),
+          ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "decryptionCriteria.or": Array must contain at least 2 element(s)"
+        `);
+      });
+
+      it('should provide an actionable error message for duplicated criteria', () => {
+        expect(() =>
+          validateCreatePostRequest(
+            mockCreatePostRequest({
+              decryptionCriteria: {
+                type: DecryptionCriteriaType.OR,
+                or: [mockCollectThisPublicationCriterion(), mockCollectThisPublicationCriterion()],
+              },
+            }),
+          ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "decryptionCriteria.or": Must be an array of unique criteria"
+        `);
+      });
+
+      it('should provide an actionable error message for too many criteria', () => {
+        expect(() =>
+          validateCreatePostRequest(
+            mockCreatePostRequest({
+              decryptionCriteria: {
+                type: DecryptionCriteriaType.OR,
+                or: [
+                  mockCollectThisPublicationCriterion(),
+                  mockCollectPublicationCriterion(),
+                  mockNftOwnershipCriterion(),
+                  mockAddressOwnershipCriterion(),
+                  mockProfileOwnershipCriterion(),
+                  mockFollowProfileCriterion(),
+                ],
+              },
+            }),
+          ),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "decryptionCriteria.or": Array must contain at most 5 element(s)"
+        `);
+      });
+    });
+
+    describe('with invalid "collect" policy', () => {
+      it('should provide an actionable error message', () => {
+        expect(() =>
+          validateCreatePostRequest({
+            contentFocus: ContentFocus.TEXT_ONLY,
+            content: '',
+            collect: {
+              type: CollectPolicyType.CHARGE,
+              fee: '1',
+            },
+            delegate: false,
+            locale: 'en',
+            kind: TransactionKind.CREATE_POST,
+            offChain: false,
+            profileId: mockProfileId(),
+            reference: {
+              type: ReferencePolicyType.ANYONE,
+            },
+          }),
+        ).toThrowErrorMatchingInlineSnapshot(`
+                  "fix the following issues
+                  · "collect" expected to match one of the following groups:
+                  		· "collect.fee": value not instance of Amount<Erc20>
+                  		· "collect.followersOnly": Required
+                  		· "collect.metadata": Required
+                  		· "collect.mirrorReward": Required
+                  		· "collect.recipient": Required
+                  		· "collect.timeLimited": Required
+                  	OR:
+                  		· "collect.fee": value not instance of Amount<Erc20>
+                  		· "collect.followersOnly": Required
+                  		· "collect.metadata": Required
+                  		· "collect.mirrorReward": Required
+                  		· "collect.recipients": Required
+                  	OR:
+                  		· "collect.fee": value not instance of Amount<Erc20>
+                  		· "collect.followersOnly": Required
+                  		· "collect.metadata": Required
+                  		· "collect.mirrorReward": Required
+                  		· "collect.recipient": Required
+                  		· "collect.vault": Required
+                  	OR:
+                  		· "collect.fee": value not instance of Amount<Erc20>
+                  		· "collect.followersOnly": Required
+                  		· "collect.metadata": Required
+                  		· "collect.mirrorReward": Required
+                  		· "collect.recipient": Required
+                  		· "collect.depositToAave": Invalid literal value, expected true
+                  	OR:
+                  		· "collect.type": Invalid literal value, expected "FREE"
+                  		· "collect.metadata": Required
+                  		· "collect.followersOnly": Required
+                  	OR:
+                  		· "collect.type": Invalid literal value, expected "NO_COLLECT""
+              `);
+      });
+    });
+
+    describe('with invalid "collect.metadata" for collectable publications', () => {
+      it('should provide an actionable error message in case of "collect.metadata" misconfiguration', () => {
+        expect(() =>
+          validateCreatePostRequest({
+            contentFocus: ContentFocus.TEXT_ONLY,
+            content: '',
+            collect: {
+              type: CollectPolicyType.FREE,
+              metadata: {},
+            },
+            delegate: false,
+            locale: 'en',
+            kind: TransactionKind.CREATE_POST,
+            offChain: false,
+            profileId: mockProfileId(),
+            reference: {
+              type: ReferencePolicyType.ANYONE,
+            },
+          }),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "collect" expected to match one of the following groups:
+          		· "collect.type": Invalid literal value, expected "CHARGE"
+          		· "collect.fee": value not instance of Amount<Erc20>
+          		· "collect.followersOnly": Required
+          		· "collect.mirrorReward": Required
+          		· "collect.recipient": Required
+          		· "collect.timeLimited": Required
+          	OR:
+          		· "collect.type": Invalid literal value, expected "CHARGE"
+          		· "collect.fee": value not instance of Amount<Erc20>
+          		· "collect.followersOnly": Required
+          		· "collect.mirrorReward": Required
+          		· "collect.recipients": Required
+          	OR:
+          		· "collect.type": Invalid literal value, expected "CHARGE"
+          		· "collect.fee": value not instance of Amount<Erc20>
+          		· "collect.followersOnly": Required
+          		· "collect.mirrorReward": Required
+          		· "collect.recipient": Required
+          		· "collect.vault": Required
+          	OR:
+          		· "collect.type": Invalid literal value, expected "CHARGE"
+          		· "collect.fee": value not instance of Amount<Erc20>
+          		· "collect.followersOnly": Required
+          		· "collect.mirrorReward": Required
+          		· "collect.recipient": Required
+          		· "collect.depositToAave": Invalid literal value, expected true
+          	OR:
+          		· "collect.followersOnly": Required
+          	OR:
+          		· "collect.type": Invalid literal value, expected "NO_COLLECT""
+        `);
+      });
+    });
+
+    describe('with invalid "attributes"', () => {
+      it('should provide an actionable error message', () => {
+        expect(() =>
+          validateCreatePostRequest({
+            attributes: {},
+            contentFocus: ContentFocus.TEXT_ONLY,
+            content: '',
+            collect: {
+              type: CollectPolicyType.NO_COLLECT,
+            },
+            delegate: false,
+            locale: 'en',
+            kind: TransactionKind.CREATE_POST,
+            offChain: false,
+            profileId: mockProfileId(),
+            reference: {
+              type: ReferencePolicyType.ANYONE,
+            },
+          }),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "attributes": Expected array, received object"
+        `);
+      });
+    });
+
+    describe('with invalid "image"', () => {
+      it('should provide an actionable error message', () => {
+        expect(() =>
+          validateCreatePostRequest({
+            contentFocus: ContentFocus.TEXT_ONLY,
+            content: '',
+            collect: {
+              type: CollectPolicyType.NO_COLLECT,
+            },
+            delegate: false,
+            image: {},
+            locale: 'en',
+            kind: TransactionKind.CREATE_POST,
+            offChain: false,
+            profileId: mockProfileId(),
+            reference: {
+              type: ReferencePolicyType.ANYONE,
+            },
+          }),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "image.mimeType": Required
+          · "image.url": Required"
+        `);
+      });
+    });
+
+    describe('with invalid "name"', () => {
+      it('should provide an actionable error message', () => {
+        expect(() =>
+          validateCreatePostRequest({
+            contentFocus: ContentFocus.TEXT_ONLY,
+            content: '',
+            collect: {
+              type: CollectPolicyType.NO_COLLECT,
+            },
+            delegate: false,
+            name: 42, // <<<<<<
+            locale: 'en',
+            kind: TransactionKind.CREATE_POST,
+            offChain: false,
+            profileId: mockProfileId(),
+            reference: {
+              type: ReferencePolicyType.ANYONE,
+            },
+          }),
+        ).toThrowErrorMatchingInlineSnapshot(`
+          "fix the following issues
+          · "name": Expected string, received number"
+        `);
+      });
+    });
+
+    describe('with invalid "attributes"', () => {
+      it('should provide an actionable error message', () => {
+        expect(() =>
+          validateCreatePostRequest({
+            contentFocus: ContentFocus.TEXT_ONLY,
+            content: '',
+            collect: {
+              type: CollectPolicyType.NO_COLLECT,
+            },
+            delegate: false,
+            locale: 'en',
+            kind: TransactionKind.CREATE_POST,
+            offChain: false,
+            profileId: mockProfileId(),
+            reference: {
+              type: ReferencePolicyType.DEGREES_OF_SEPARATION,
+            },
+          }),
+        ).toThrowErrorMatchingInlineSnapshot(`
+                  "fix the following issues
+                  · "reference.params": Required"
+              `);
+      });
+    });
+  });
+
+  describe(`when testing the "validateCreateCommentRequest"`, () => {
+    it('should provide an actionable error message in case of "collect" policy misconfiguration', () => {
+      expect(() =>
+        validateCreateCommentRequest({
+          contentFocus: ContentFocus.TEXT_ONLY,
+          content: '',
+          collect: {
+            type: CollectPolicyType.CHARGE,
+            fee: '1',
+          },
+          delegate: false,
+          locale: 'en',
+          kind: TransactionKind.CREATE_COMMENT,
+          offChain: false,
+          profileId: mockProfileId(),
+          publicationId: mockPublicationId(),
+          reference: {
+            type: ReferencePolicyType.ANYONE,
+          },
+        }),
+      ).toThrowErrorMatchingInlineSnapshot(`
+        "fix the following issues
+        · "collect" expected to match one of the following groups:
+        		· "collect.fee": value not instance of Amount<Erc20>
+        		· "collect.followersOnly": Required
+        		· "collect.metadata": Required
+        		· "collect.mirrorReward": Required
+        		· "collect.recipient": Required
+        		· "collect.timeLimited": Required
+        	OR:
+        		· "collect.fee": value not instance of Amount<Erc20>
+        		· "collect.followersOnly": Required
+        		· "collect.metadata": Required
+        		· "collect.mirrorReward": Required
+        		· "collect.recipients": Required
+        	OR:
+        		· "collect.fee": value not instance of Amount<Erc20>
+        		· "collect.followersOnly": Required
+        		· "collect.metadata": Required
+        		· "collect.mirrorReward": Required
+        		· "collect.recipient": Required
+        		· "collect.vault": Required
+        	OR:
+        		· "collect.fee": value not instance of Amount<Erc20>
+        		· "collect.followersOnly": Required
+        		· "collect.metadata": Required
+        		· "collect.mirrorReward": Required
+        		· "collect.recipient": Required
+        		· "collect.depositToAave": Invalid literal value, expected true
+        	OR:
+        		· "collect.type": Invalid literal value, expected "FREE"
+        		· "collect.metadata": Required
+        		· "collect.followersOnly": Required
+        	OR:
+        		· "collect.type": Invalid literal value, expected "NO_COLLECT""
+      `);
+    });
+
+    it('should provide an actionable error message in case of "reference" policy misconfiguration', () => {
+      expect(() =>
+        validateCreateCommentRequest({
+          contentFocus: ContentFocus.TEXT_ONLY,
+          content: '',
+          collect: {
+            type: CollectPolicyType.NO_COLLECT,
+          },
+          delegate: false,
+          locale: 'en',
+          kind: TransactionKind.CREATE_COMMENT,
+          offChain: false,
+          profileId: mockProfileId(),
+          publicationId: mockPublicationId(),
+          reference: {
+            type: ReferencePolicyType.DEGREES_OF_SEPARATION,
+          },
+        }),
+      ).toThrowErrorMatchingInlineSnapshot(`
+        "fix the following issues
+        · "reference.params": Required"
+        `);
+    });
+  });
+
+  describe(`when testing the "validateTokenAllowanceRequest"`, () => {
+    it('should provide an actionable error message in case of misuse', () => {
+      expect(() =>
+        validateTokenAllowanceRequest({
+          amount: 42,
+          kind: TransactionKind.APPROVE_MODULE,
+        }),
+      ).toThrowErrorMatchingInlineSnapshot(`
+        "fix the following issues
+        · "amount": value not instance of Amount<Erc20>
+        · "spender": Required
+        · "limit": Required"
+        `);
+    });
+  });
+
+  describe(`when testing the "validateUpdateFollowPolicyRequest"`, () => {
+    it('should provide an actionable error message in case of misuse', () => {
+      expect(() =>
+        validateUpdateFollowPolicyRequest({
+          kind: TransactionKind.UPDATE_FOLLOW_POLICY,
+          policy: {
+            type: FollowPolicyType.CHARGE,
+            amount: 42,
+          },
+          profileId: mockProfileId(),
+        }),
+      ).toThrowErrorMatchingInlineSnapshot(`
+        "fix the following issues
+        · "policy.amount": value not instance of Amount<Erc20>
+        · "policy.recipient": Required"
+      `);
+    });
+  });
+
+  describe(`when testing the "validateUpdateProfileDetailsRequest"`, () => {
+    it('should provide an actionable error message in case of misuse', () => {
+      expect(() =>
+        validateUpdateProfileDetailsRequest({
+          attributes: {
+            foo: new RegExp('foo'),
+          },
+          bio: 42,
+          coverPicture: null,
+          delegate: false,
+          kind: TransactionKind.UPDATE_PROFILE_DETAILS,
+          policy: {
+            type: FollowPolicyType.CHARGE,
+            amount: 42,
+          },
+          profileId: mockProfileId(),
+        }),
+      ).toThrowErrorMatchingInlineSnapshot(`
+        "fix the following issues
+        · "attributes.foo" expected to match one of the following groups:
+        		· "attributes.foo": Expected boolean, received object
+        	OR:
+        		· "attributes.foo": Invalid date
+        	OR:
+        		· "attributes.foo": Expected number, received object
+        	OR:
+        		· "attributes.foo": Expected string, received object
+        	OR:
+        		· "attributes.foo": Expected null, received object
+        · "bio": Expected string, received number
+        · "name": Required"
+      `);
+    });
+  });
+});
diff --git a/packages/react/src/transactions/adapters/schemas/common.ts b/packages/react/src/transactions/adapters/schemas/common.ts
new file mode 100644
index 0000000000..b059f50423
--- /dev/null
+++ b/packages/react/src/transactions/adapters/schemas/common.ts
@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import { ProfileId, PublicationId, Signature } from '@lens-protocol/domain/entities';
+import {
+  Amount,
+  BigDecimal,
+  ChainType,
+  Erc20,
+  erc20,
+  Erc20Amount,
+  Kind,
+  UnknownObject,
+} from '@lens-protocol/shared-kernel';
+import { z } from 'zod';
+
+import { profileId, publicationId } from '../../../utils';
+
+const Erc20Schema: z.Schema<Erc20, z.ZodTypeDef, UnknownObject> = z
+  .object({
+    kind: z.literal(Kind.ERC20),
+    name: z.string(),
+    decimals: z.number(),
+    symbol: z.string(),
+    address: z.string(),
+    chainType: z.nativeEnum(ChainType),
+  })
+  .transform((value) => erc20(value));
+
+/**
+ * The type annotation here to reduce the likelihood of incurring in the TS7056 error down the line:
+ * ```
+ * error TS7056: The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed.
+ * ```
+ */
+export const SerializedErc20AmountSchema: z.Schema<Erc20Amount, z.ZodTypeDef, UnknownObject> = z
+  .object({
+    asset: Erc20Schema,
+    value: z.string(),
+  })
+  .transform((value) => Amount.erc20(value.asset, value.value));
+
+export const ProfileIdSchema: z.Schema<ProfileId, z.ZodTypeDef, string> = z
+  .string()
+  .transform(profileId);
+
+export const PublicationIdSchema: z.Schema<PublicationId, z.ZodTypeDef, string> = z
+  .string()
+  .transform(publicationId);
+
+// Checky workaround to private constructor
+const AmountCtor = Amount.ether(0).constructor as new (
+  asset: Erc20,
+  value: BigDecimal,
+) => Erc20Amount;
+
+export const Erc20AmountInstanceSchema: z.Schema<Erc20Amount, z.ZodTypeDef, Erc20Amount> =
+  z.instanceof(AmountCtor, { message: 'value not instance of Amount<Erc20>' });
+
+export type Erc20AmountSchema = z.Schema<Erc20Amount, z.ZodTypeDef, unknown>;
+
+export const SignatureSchema: z.Schema<Signature, z.ZodTypeDef, string> = z
+  .string()
+  .transform((value) => value as Signature);
diff --git a/packages/react/src/transactions/adapters/schemas/erc20.ts b/packages/react/src/transactions/adapters/schemas/erc20.ts
new file mode 100644
index 0000000000..af41760b8d
--- /dev/null
+++ b/packages/react/src/transactions/adapters/schemas/erc20.ts
@@ -0,0 +1,16 @@
+import { TransactionKind } from '@lens-protocol/domain/entities';
+import { TokenAllowanceLimit } from '@lens-protocol/domain/use-cases/wallets';
+import { z } from 'zod';
+
+import { Erc20AmountSchema } from './common';
+
+export function tokenAllowanceRequestSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return z.object({
+    amount: amountSchema,
+    spender: z.string(),
+    limit: z.nativeEnum(TokenAllowanceLimit),
+    kind: z.literal(TransactionKind.APPROVE_MODULE),
+  });
+}
diff --git a/packages/react/src/transactions/adapters/schemas/formatters.ts b/packages/react/src/transactions/adapters/schemas/formatters.ts
new file mode 100644
index 0000000000..aee01751c7
--- /dev/null
+++ b/packages/react/src/transactions/adapters/schemas/formatters.ts
@@ -0,0 +1,102 @@
+// Heavily customized and simplified version of https://www.npmjs.com/package/zod-validation-error
+
+import { assertNonEmptyArray, hasAtLeastOne, NonEmptyArray } from '@lens-protocol/shared-kernel';
+import { z } from 'zod';
+
+const maxIssuesInMessage = 99;
+const issueSeparator = '\n';
+const prefix = '· ';
+
+function escapeQuotes(str: string): string {
+  return str.replace(/"/g, '\\"');
+}
+
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#identifiers
+ */
+const identifierRegex = /[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/u;
+
+function formatPath(path: NonEmptyArray<string | number>): string {
+  if (path.length === 1) {
+    return path[0].toString();
+  }
+
+  return path.reduce<string>((acc, item) => {
+    // handle numeric indices
+    if (typeof item === 'number') {
+      return acc + '[' + item.toString() + ']';
+    }
+
+    // handle quoted values
+    if (item.includes('"')) {
+      return acc + '["' + escapeQuotes(item) + '"]';
+    }
+
+    // handle special characters
+    if (!identifierRegex.test(item)) {
+      return acc + '["' + item + '"]';
+    }
+
+    // handle normal values
+    const separator = acc.length === 0 ? '' : '.';
+    return acc + separator + item;
+  }, '');
+}
+
+function formatZozInvalidUnionIssue(issue: z.ZodInvalidUnionIssue): string {
+  const groups = issue.unionErrors.reduce<string[]>((acc, zodError) => {
+    const newIssues = zodError.issues
+      .map((nested) => {
+        if (hasAtLeastOne(nested.path)) {
+          return `\t\t${prefix}"${formatPath(nested.path)}": ${nested.message}`;
+        }
+        return issue.message;
+      })
+      .join(issueSeparator);
+
+    if (!acc.includes(newIssues)) {
+      acc.push(newIssues);
+    }
+
+    return acc;
+  }, []);
+
+  const path = Array.isArray(issue.path) ? issue.path : [issue.path];
+  assertNonEmptyArray(path);
+
+  return (
+    `${prefix}"${formatPath(path)}" expected to match one of the following groups:\n` +
+    `${groups.join(`${issueSeparator}\tOR:${issueSeparator}`)}`
+  );
+}
+
+function formatZodIssue(issue: z.ZodIssue): string {
+  if (issue.code === z.ZodIssueCode.invalid_union) {
+    return formatZozInvalidUnionIssue(issue);
+  }
+
+  if (hasAtLeastOne(issue.path)) {
+    return `${prefix}"${formatPath(issue.path)}": ${issue.message}`;
+  }
+
+  return issue.message;
+}
+
+export function formatZodError(zodError: z.ZodError): string {
+  const reason = zodError.errors
+    // limit max number of issues printed in the reason section
+    .slice(0, maxIssuesInMessage)
+    // format error message
+    .map((issue) => formatZodIssue(issue))
+    // concat as string
+    .join(issueSeparator);
+
+  if (reason.length === 0) {
+    return (
+      'invalid argument, it was not possible to determine a more detailed reason.\n' +
+      'Check the input you provided and try again.'
+    );
+  }
+
+  return `fix the following issues\n${reason}`;
+}
diff --git a/packages/react/src/transactions/adapters/schemas/profiles.ts b/packages/react/src/transactions/adapters/schemas/profiles.ts
new file mode 100644
index 0000000000..f00d250684
--- /dev/null
+++ b/packages/react/src/transactions/adapters/schemas/profiles.ts
@@ -0,0 +1,122 @@
+import { TransactionKind } from '@lens-protocol/domain/entities';
+import { FollowPolicyType } from '@lens-protocol/domain/use-cases/profile';
+import { z } from 'zod';
+
+import {
+  Erc20AmountSchema,
+  ProfileIdSchema,
+  SerializedErc20AmountSchema,
+  SignatureSchema,
+} from './common';
+
+export const CreateProfileRequestSchema = z.object({
+  handle: z.string(),
+  kind: z.literal(TransactionKind.CREATE_PROFILE),
+});
+
+const FollowRequestFeeSchema = z.object({
+  amount: SerializedErc20AmountSchema,
+  contractAddress: z.string(),
+  recipient: z.string(),
+});
+
+export const UnconstrainedFollowRequestSchema = z.object({
+  followerAddress: z.string(),
+  profileId: ProfileIdSchema,
+  kind: z.literal(TransactionKind.FOLLOW_PROFILES),
+});
+
+export const PaidFollowRequestSchema = z.object({
+  followerAddress: z.string(),
+  profileId: ProfileIdSchema,
+  kind: z.literal(TransactionKind.FOLLOW_PROFILES),
+  fee: FollowRequestFeeSchema,
+});
+
+export const ProfileOwnerFollowRequestSchema = z.object({
+  followerAddress: z.string(),
+  profileId: ProfileIdSchema,
+  kind: z.literal(TransactionKind.FOLLOW_PROFILES),
+  followerProfileId: z.string(),
+});
+
+export const UnfollowRequestSchema = z.object({
+  profileId: ProfileIdSchema,
+  kind: z.literal(TransactionKind.UNFOLLOW_PROFILE),
+});
+
+export const UpdateDispatcherConfigRequestSchema = z.object({
+  profileId: ProfileIdSchema,
+  enabled: z.boolean(),
+  kind: z.literal(TransactionKind.UPDATE_DISPATCHER_CONFIG),
+});
+
+function chargeFollowPolicyConfigSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return z.object({
+    type: z.literal(FollowPolicyType.CHARGE),
+    amount: amountSchema,
+    recipient: z.string(),
+  });
+}
+
+const AnyoneFollowPolicyConfigSchema = z.object({
+  type: z.literal(FollowPolicyType.ANYONE),
+});
+
+const OnlyProfileOwnersFollowPolicyConfigSchema = z.object({
+  type: z.literal(FollowPolicyType.ONLY_PROFILE_OWNERS),
+});
+
+const NoOneFollowPolicyConfigSchema = z.object({
+  type: z.literal(FollowPolicyType.NO_ONE),
+});
+
+export function updateFollowPolicyRequestSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return z.object({
+    profileId: ProfileIdSchema,
+    policy: z.discriminatedUnion('type', [
+      chargeFollowPolicyConfigSchema(amountSchema),
+      AnyoneFollowPolicyConfigSchema,
+      OnlyProfileOwnersFollowPolicyConfigSchema,
+      NoOneFollowPolicyConfigSchema,
+    ]),
+    kind: z.literal(TransactionKind.UPDATE_FOLLOW_POLICY),
+  });
+}
+
+const PartialAttributesUpdateSchema = z.record(
+  z.union([z.boolean(), z.coerce.date(), z.number(), z.string(), z.null()]),
+);
+
+export const UpdateProfileDetailsRequestSchema = z.object({
+  attributes: PartialAttributesUpdateSchema.optional(),
+  bio: z.string().nullable().optional(),
+  coverPicture: z.string().nullable().optional(),
+  name: z.string(),
+  profileId: ProfileIdSchema,
+  kind: z.literal(TransactionKind.UPDATE_PROFILE_DETAILS),
+  delegate: z.boolean(),
+});
+
+const NftOwnershipSignatureSchema = z.object({
+  id: z.string(),
+  signature: SignatureSchema,
+});
+
+export const UpdateNftProfileImageRequestSchema = z.object({
+  kind: z.literal(TransactionKind.UPDATE_PROFILE_IMAGE),
+  profileId: ProfileIdSchema,
+  signature: NftOwnershipSignatureSchema,
+  delegate: z.boolean(),
+});
+
+export const UpdateOffChainProfileImageRequestSchema = z.object({
+  url: z.string(),
+  kind: z.literal(TransactionKind.UPDATE_PROFILE_IMAGE),
+  profileId: ProfileIdSchema,
+  delegate: z.boolean(),
+});
diff --git a/packages/react/src/transactions/adapters/schemas/publications.ts b/packages/react/src/transactions/adapters/schemas/publications.ts
new file mode 100644
index 0000000000..32bbe85c03
--- /dev/null
+++ b/packages/react/src/transactions/adapters/schemas/publications.ts
@@ -0,0 +1,408 @@
+import {
+  AppId,
+  DecryptionCriteriaType,
+  Erc20ComparisonOperator,
+  NftContractType,
+  TransactionKind,
+} from '@lens-protocol/domain/entities';
+import {
+  SupportedFileType,
+  CollectPolicyType,
+  CollectType,
+  ContentFocus,
+  MetadataAttributeDisplayType,
+  ReferencePolicyType,
+  ContentWarning,
+  ImageType,
+} from '@lens-protocol/domain/use-cases/publications';
+import { z } from 'zod';
+
+import { appId } from '../../../utils';
+import {
+  Erc20AmountSchema,
+  SerializedErc20AmountSchema,
+  ProfileIdSchema,
+  PublicationIdSchema,
+} from './common';
+
+const NftOwnershipCriterionSchema = z.object({
+  type: z.literal(DecryptionCriteriaType.NFT_OWNERSHIP),
+  contractAddress: z.string(),
+  chainId: z.number(),
+  contractType: z.nativeEnum(NftContractType),
+  tokenIds: z.array(z.string()).min(1).max(30).optional(),
+});
+
+function erc20OwnershipCriterionSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return z.object({
+    type: z.literal(DecryptionCriteriaType.ERC20_OWNERSHIP),
+    amount: amountSchema,
+    condition: z.nativeEnum(Erc20ComparisonOperator),
+  });
+}
+
+const AddressOwnershipCriterionSchema = z.object({
+  type: z.literal(DecryptionCriteriaType.ADDRESS_OWNERSHIP),
+  address: z.string(),
+});
+
+const ProfileOwnershipCriterionSchema = z.object({
+  type: z.literal(DecryptionCriteriaType.PROFILE_OWNERSHIP),
+  profileId: ProfileIdSchema,
+});
+
+const FollowOwnershipCriterionSchema = z.object({
+  type: z.literal(DecryptionCriteriaType.FOLLOW_PROFILE),
+  profileId: ProfileIdSchema,
+});
+
+const CollectPublicationCriterionSchema = z.object({
+  type: z.literal(DecryptionCriteriaType.COLLECT_PUBLICATION),
+  publicationId: PublicationIdSchema,
+});
+
+const CollectThisPublicationCriterionSchema = z.object({
+  type: z.literal(DecryptionCriteriaType.COLLECT_THIS_PUBLICATION),
+});
+
+function simpleCriterionSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return z.discriminatedUnion('type', [
+    NftOwnershipCriterionSchema,
+    erc20OwnershipCriterionSchema(amountSchema),
+    AddressOwnershipCriterionSchema,
+    ProfileOwnershipCriterionSchema,
+    FollowOwnershipCriterionSchema,
+    CollectPublicationCriterionSchema,
+    CollectThisPublicationCriterionSchema,
+  ]);
+}
+
+function unique(items: Array<unknown>) {
+  return new Set(items.map((item) => JSON.stringify(item))).size === items.length;
+}
+
+function orCriterionSchema<TAmountSchema extends Erc20AmountSchema>(amountSchema: TAmountSchema) {
+  return z.object({
+    type: z.literal(DecryptionCriteriaType.OR),
+    or: z.array(simpleCriterionSchema(amountSchema)).min(2).max(5).refine(unique, {
+      message: 'Must be an array of unique criteria',
+    }),
+  });
+}
+
+function andCriterionSchema<TAmountSchema extends Erc20AmountSchema>(amountSchema: TAmountSchema) {
+  return z.object({
+    type: z.literal(DecryptionCriteriaType.AND),
+    and: z.array(simpleCriterionSchema(amountSchema)).min(2).max(5).refine(unique, {
+      message: 'Must be an array of unique criteria',
+    }),
+  });
+}
+
+function decryptionCriteriaSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return z
+    .discriminatedUnion('type', [
+      orCriterionSchema(amountSchema),
+      andCriterionSchema(amountSchema),
+      NftOwnershipCriterionSchema,
+      erc20OwnershipCriterionSchema(amountSchema),
+      AddressOwnershipCriterionSchema,
+      ProfileOwnershipCriterionSchema,
+      FollowOwnershipCriterionSchema,
+      CollectPublicationCriterionSchema,
+      CollectThisPublicationCriterionSchema,
+    ])
+    .optional();
+}
+
+const MetadataAttributeSchema = z.discriminatedUnion('displayType', [
+  z.object({
+    displayType: z.literal(MetadataAttributeDisplayType.Date),
+    value: z.coerce.date(),
+    traitType: z.string(),
+  }),
+  z.object({
+    displayType: z.literal(MetadataAttributeDisplayType.Number),
+    value: z.number(),
+    traitType: z.string(),
+  }),
+  z.object({
+    displayType: z.literal(MetadataAttributeDisplayType.String),
+    value: z.string(),
+    traitType: z.string(),
+  }),
+]);
+
+const NftMetadataSchema = z.object({
+  name: z.string().optional(),
+  description: z.string().optional(),
+  attributes: z.array(MetadataAttributeSchema).optional(),
+  externalUrl: z.string().optional(),
+  image: z.string().optional(),
+  imageMimeType: z.nativeEnum(ImageType).optional(),
+});
+
+const RecipientWithSplitSchema = z.object({
+  recipient: z.string(),
+  split: z.number(),
+});
+
+function aaveChargeCollectPolicyConfigSchema<TAmountSchema extends Erc20AmountSchema>(
+  feeSchema: TAmountSchema,
+) {
+  return z.object({
+    type: z.literal(CollectPolicyType.CHARGE),
+    fee: feeSchema,
+    followersOnly: z.boolean(),
+    metadata: NftMetadataSchema,
+    mirrorReward: z.number(),
+    collectLimit: z.number().optional(),
+
+    recipient: z.string(),
+    depositToAave: z.literal(true),
+    endTimestamp: z.number().optional(),
+  });
+}
+
+function vaultChargeCollectPolicyConfigSchema<TAmountSchema extends Erc20AmountSchema>(
+  feeSchema: TAmountSchema,
+) {
+  return z.object({
+    type: z.literal(CollectPolicyType.CHARGE),
+    fee: feeSchema,
+    followersOnly: z.boolean(),
+    metadata: NftMetadataSchema,
+    mirrorReward: z.number(),
+    collectLimit: z.number().optional(),
+
+    recipient: z.string(),
+    vault: z.string(),
+    endTimestamp: z.number().optional(),
+  });
+}
+
+function multirecipientChargeCollectPolicyConfigSchema<TAmountSchema extends Erc20AmountSchema>(
+  feeSchema: TAmountSchema,
+) {
+  return z.object({
+    type: z.literal(CollectPolicyType.CHARGE),
+    fee: feeSchema,
+    followersOnly: z.boolean(),
+    metadata: NftMetadataSchema,
+    mirrorReward: z.number(),
+    collectLimit: z.number().optional(),
+
+    recipients: z.array(RecipientWithSplitSchema),
+    endTimestamp: z.number().optional(),
+  });
+}
+
+function simpleChargeCollectPolicyConfigSchema<TAmountSchema extends Erc20AmountSchema>(
+  feeSchema: TAmountSchema,
+) {
+  return z.object({
+    type: z.literal(CollectPolicyType.CHARGE),
+    fee: feeSchema,
+    followersOnly: z.boolean(),
+    metadata: NftMetadataSchema,
+    mirrorReward: z.number(),
+    collectLimit: z.number().optional(),
+
+    recipient: z.string(),
+    timeLimited: z.boolean(),
+  });
+}
+
+const FreeCollectPolicyConfigSchema = z.object({
+  type: z.literal(CollectPolicyType.FREE),
+  metadata: NftMetadataSchema,
+  followersOnly: z.boolean(),
+});
+
+const NoCollectPolicyConfigSchema = z.object({
+  type: z.literal(CollectPolicyType.NO_COLLECT),
+});
+
+function collectPolicyConfigSchema<TAmountSchema extends Erc20AmountSchema>(
+  feeSchema: TAmountSchema,
+) {
+  return z.union([
+    simpleChargeCollectPolicyConfigSchema(feeSchema),
+    multirecipientChargeCollectPolicyConfigSchema(feeSchema),
+    vaultChargeCollectPolicyConfigSchema(feeSchema),
+    aaveChargeCollectPolicyConfigSchema(feeSchema),
+    FreeCollectPolicyConfigSchema,
+    NoCollectPolicyConfigSchema,
+  ]);
+}
+
+const MediaObjectSchema = z.object({
+  altTag: z.string().optional(),
+  cover: z.string().optional(),
+  mimeType: z.nativeEnum(SupportedFileType),
+  url: z.string(),
+});
+
+const MetadataImageSchema = z.object({
+  mimeType: z.nativeEnum(ImageType),
+  url: z.string(),
+});
+
+const AnyoneReferencePolicyConfigSchema = z.object({
+  type: z.literal(ReferencePolicyType.ANYONE),
+});
+
+const DegreesOfSeparationReferencePolicyConfigSchema = z.object({
+  type: z.literal(ReferencePolicyType.DEGREES_OF_SEPARATION),
+  params: z.object({
+    commentsRestricted: z.boolean(),
+    mirrorsRestricted: z.boolean(),
+    degreesOfSeparation: z.number(),
+  }),
+});
+
+const FollowersOnlyReferencePolicyConfigSchema = z.object({
+  type: z.literal(ReferencePolicyType.FOLLOWERS_ONLY),
+});
+
+const ReferencePolicyConfigSchema = z.discriminatedUnion('type', [
+  AnyoneReferencePolicyConfigSchema,
+  DegreesOfSeparationReferencePolicyConfigSchema,
+  FollowersOnlyReferencePolicyConfigSchema,
+]);
+
+const AppIdSchema: z.Schema<AppId, z.ZodTypeDef, string> = z.any().transform(appId);
+
+function createCommonPublicationRequestSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return z.object({
+    appId: AppIdSchema.optional(),
+    attributes: z.array(MetadataAttributeSchema).optional(),
+    collect: collectPolicyConfigSchema(amountSchema),
+    contentWarning: z.nativeEnum(ContentWarning).optional(),
+    decryptionCriteria: decryptionCriteriaSchema(amountSchema),
+    delegate: z.boolean(),
+    image: MetadataImageSchema.optional(),
+    name: z.string().optional(),
+    locale: z.string(),
+    offChain: z.boolean(),
+    profileId: ProfileIdSchema,
+    reference: ReferencePolicyConfigSchema,
+    tags: z.array(z.string()).optional(),
+  });
+}
+
+function createBasePostRequestSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return createCommonPublicationRequestSchema(amountSchema).extend({
+    kind: z.literal(TransactionKind.CREATE_POST),
+  });
+}
+
+export function createTextualPostRequestSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return createBasePostRequestSchema(amountSchema).extend({
+    content: z.string(),
+    contentFocus: z.enum([ContentFocus.ARTICLE, ContentFocus.LINK, ContentFocus.TEXT_ONLY]),
+    media: z.array(MediaObjectSchema).optional(),
+  });
+}
+
+export function createMediaPostRequestSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return createBasePostRequestSchema(amountSchema).extend({
+    content: z.string().optional(),
+    contentFocus: z.enum([ContentFocus.AUDIO, ContentFocus.IMAGE, ContentFocus.VIDEO]),
+    media: z.array(MediaObjectSchema),
+  });
+}
+
+export function createEmbedPostRequestSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return createBasePostRequestSchema(amountSchema).extend({
+    animationUrl: z.string(),
+    content: z.string().optional(),
+    contentFocus: z.enum([ContentFocus.EMBED]),
+    media: z.array(MediaObjectSchema).optional(),
+  });
+}
+
+function createBaseCommentRequestSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return createCommonPublicationRequestSchema(amountSchema).extend({
+    publicationId: PublicationIdSchema,
+    kind: z.literal(TransactionKind.CREATE_COMMENT),
+  });
+}
+
+export function createTextualCommentRequestSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return createBaseCommentRequestSchema(amountSchema).extend({
+    content: z.string(),
+    contentFocus: z.enum([ContentFocus.ARTICLE, ContentFocus.LINK, ContentFocus.TEXT_ONLY]),
+    media: z.array(MediaObjectSchema).optional(),
+  });
+}
+
+export function createMediaCommentRequestSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return createBaseCommentRequestSchema(amountSchema).extend({
+    content: z.string().optional(),
+    contentFocus: z.enum([ContentFocus.AUDIO, ContentFocus.IMAGE, ContentFocus.VIDEO]),
+    media: z.array(MediaObjectSchema),
+  });
+}
+
+export function createEmbedCommentRequestSchema<TAmountSchema extends Erc20AmountSchema>(
+  amountSchema: TAmountSchema,
+) {
+  return createBaseCommentRequestSchema(amountSchema).extend({
+    animationUrl: z.string(),
+    content: z.string().optional(),
+    contentFocus: z.enum([ContentFocus.EMBED]),
+    media: z.array(MediaObjectSchema).optional(),
+  });
+}
+
+export const CreateMirrorRequestSchema = z.object({
+  profileId: ProfileIdSchema,
+  publicationId: PublicationIdSchema,
+  kind: z.literal(TransactionKind.MIRROR_PUBLICATION),
+  delegate: z.boolean(),
+  offChain: z.boolean(),
+});
+
+const BaseCollectRequestSchema = z.object({
+  kind: z.literal(TransactionKind.COLLECT_PUBLICATION),
+  profileId: ProfileIdSchema,
+  publicationId: PublicationIdSchema,
+});
+
+export const FreeCollectRequestSchema = BaseCollectRequestSchema.extend({
+  type: z.literal(CollectType.FREE),
+  followerOnly: z.boolean(),
+});
+
+const CollectFeeSchema = z.object({
+  amount: SerializedErc20AmountSchema,
+  contractAddress: z.string(),
+});
+
+export const PaidCollectRequestSchema = BaseCollectRequestSchema.extend({
+  type: z.literal(CollectType.PAID),
+  fee: CollectFeeSchema,
+});
diff --git a/packages/react/src/transactions/adapters/schemas/transactions.ts b/packages/react/src/transactions/adapters/schemas/transactions.ts
new file mode 100644
index 0000000000..410fa9d5c0
--- /dev/null
+++ b/packages/react/src/transactions/adapters/schemas/transactions.ts
@@ -0,0 +1,166 @@
+import {
+  AnyTransactionRequest,
+  ProtocolTransactionRequest,
+} from '@lens-protocol/domain/use-cases/transactions';
+import { ChainType, UnknownObject } from '@lens-protocol/shared-kernel';
+import { z } from 'zod';
+
+import { SerializedErc20AmountSchema } from './common';
+import { tokenAllowanceRequestSchema } from './erc20';
+import {
+  CreateProfileRequestSchema,
+  PaidFollowRequestSchema,
+  ProfileOwnerFollowRequestSchema,
+  UnconstrainedFollowRequestSchema,
+  UnfollowRequestSchema,
+  UpdateDispatcherConfigRequestSchema,
+  updateFollowPolicyRequestSchema,
+  UpdateNftProfileImageRequestSchema,
+  UpdateOffChainProfileImageRequestSchema,
+  UpdateProfileDetailsRequestSchema,
+} from './profiles';
+import {
+  createEmbedCommentRequestSchema,
+  createEmbedPostRequestSchema,
+  createMediaCommentRequestSchema,
+  createMediaPostRequestSchema,
+  CreateMirrorRequestSchema,
+  createTextualCommentRequestSchema,
+  createTextualPostRequestSchema,
+  FreeCollectRequestSchema,
+  PaidCollectRequestSchema,
+} from './publications';
+
+// the repetition of the schemas compared to AnyTransactionRequestSchema
+// is intentional due to https://github.com/colinhacks/zod/issues/2106
+const ProtocolTransactionRequestSchema: z.Schema<
+  ProtocolTransactionRequest,
+  z.ZodTypeDef,
+  UnknownObject
+> = z.union([
+  // CollectRequest schemas
+  FreeCollectRequestSchema,
+  PaidCollectRequestSchema,
+
+  // FollowRequest schemas
+  PaidFollowRequestSchema,
+  ProfileOwnerFollowRequestSchema,
+  UnconstrainedFollowRequestSchema,
+
+  // CreatePostRequest schemas
+  createEmbedPostRequestSchema(SerializedErc20AmountSchema),
+  createMediaPostRequestSchema(SerializedErc20AmountSchema),
+  createTextualPostRequestSchema(SerializedErc20AmountSchema),
+
+  // CreateCommentRequest schemas
+  createEmbedCommentRequestSchema(SerializedErc20AmountSchema),
+  createMediaCommentRequestSchema(SerializedErc20AmountSchema),
+  createTextualCommentRequestSchema(SerializedErc20AmountSchema),
+
+  CreateMirrorRequestSchema,
+
+  CreateProfileRequestSchema,
+
+  UnfollowRequestSchema,
+
+  UpdateDispatcherConfigRequestSchema,
+
+  updateFollowPolicyRequestSchema(SerializedErc20AmountSchema),
+
+  UpdateProfileDetailsRequestSchema,
+
+  // UpdateProfileImageRequest schemas
+  UpdateNftProfileImageRequestSchema,
+  UpdateOffChainProfileImageRequestSchema,
+]);
+
+// the repetition of the schemas compared to ProtocolTransactionRequestSchema
+// is intentional due to https://github.com/colinhacks/zod/issues/2106
+const AnyTransactionRequestSchema: z.Schema<AnyTransactionRequest, z.ZodTypeDef, UnknownObject> =
+  z.union([
+    tokenAllowanceRequestSchema(SerializedErc20AmountSchema),
+
+    // CollectRequest schemas
+    FreeCollectRequestSchema,
+    PaidCollectRequestSchema,
+
+    // FollowRequest schemas
+    PaidFollowRequestSchema,
+    ProfileOwnerFollowRequestSchema,
+    UnconstrainedFollowRequestSchema,
+
+    // CreatePostRequest schemas
+    createEmbedPostRequestSchema(SerializedErc20AmountSchema),
+    createMediaPostRequestSchema(SerializedErc20AmountSchema),
+    createTextualPostRequestSchema(SerializedErc20AmountSchema),
+
+    // CreateCommentRequest schemas
+    createEmbedCommentRequestSchema(SerializedErc20AmountSchema),
+    createMediaCommentRequestSchema(SerializedErc20AmountSchema),
+    createTextualCommentRequestSchema(SerializedErc20AmountSchema),
+
+    CreateMirrorRequestSchema,
+
+    CreateProfileRequestSchema,
+
+    UnfollowRequestSchema,
+
+    UpdateDispatcherConfigRequestSchema,
+
+    updateFollowPolicyRequestSchema(SerializedErc20AmountSchema),
+
+    UpdateProfileDetailsRequestSchema,
+
+    // UpdateProfileImageRequest schemas
+    UpdateNftProfileImageRequestSchema,
+    UpdateOffChainProfileImageRequestSchema,
+  ]);
+
+export enum TransactionType {
+  Native,
+  Meta,
+  Data,
+}
+
+const MetaTransactionSchema = z.object({
+  type: z.literal(TransactionType.Meta),
+  chainType: z.nativeEnum(ChainType),
+  id: z.string(),
+  indexingId: z.string(),
+  txHash: z.string(),
+  nonce: z.number(),
+  request: ProtocolTransactionRequestSchema,
+});
+
+type MetaTransactionSchema = z.infer<typeof MetaTransactionSchema>;
+
+const NativeTransactionSchema = z.object({
+  type: z.literal(TransactionType.Native),
+  chainType: z.nativeEnum(ChainType),
+  id: z.string(),
+  indexingId: z.string().optional(),
+  txHash: z.string(),
+  request: AnyTransactionRequestSchema,
+});
+
+type NativeTransactionSchema = z.infer<typeof NativeTransactionSchema>;
+
+const DataTransactionSchema = z.object({
+  type: z.literal(TransactionType.Data),
+  id: z.string(),
+  request: ProtocolTransactionRequestSchema,
+});
+
+type DataTransactionSchema = z.infer<typeof DataTransactionSchema>;
+
+export const TransactionSchema = z.discriminatedUnion('type', [
+  MetaTransactionSchema,
+  NativeTransactionSchema,
+  DataTransactionSchema,
+]);
+
+export type TransactionSchema = z.infer<typeof TransactionSchema>;
+
+export const TransactionStorageSchema = z.array(TransactionSchema);
+
+export type TransactionStorageSchema = z.infer<typeof TransactionStorageSchema>;
diff --git a/packages/react/src/transactions/adapters/schemas/validators.ts b/packages/react/src/transactions/adapters/schemas/validators.ts
new file mode 100644
index 0000000000..afb975c1f8
--- /dev/null
+++ b/packages/react/src/transactions/adapters/schemas/validators.ts
@@ -0,0 +1,70 @@
+import {
+  UpdateFollowPolicyRequest,
+  UpdateProfileDetailsRequest,
+} from '@lens-protocol/domain/use-cases/profile';
+import {
+  CreateCommentRequest,
+  CreatePostRequest,
+} from '@lens-protocol/domain/use-cases/publications';
+import { TokenAllowanceRequest } from '@lens-protocol/domain/use-cases/wallets';
+import { never } from '@lens-protocol/shared-kernel';
+import { z } from 'zod';
+
+import { Erc20AmountInstanceSchema } from './common';
+import { tokenAllowanceRequestSchema } from './erc20';
+import { formatZodError } from './formatters';
+import { updateFollowPolicyRequestSchema, UpdateProfileDetailsRequestSchema } from './profiles';
+import {
+  createEmbedCommentRequestSchema,
+  createEmbedPostRequestSchema,
+  createMediaCommentRequestSchema,
+  createMediaPostRequestSchema,
+  createTextualCommentRequestSchema,
+  createTextualPostRequestSchema,
+} from './publications';
+
+export type Validator<T> = (request: unknown) => asserts request is T;
+
+type InferShape<T extends z.ZodType<unknown>> = T extends z.ZodType<infer R> ? R : never;
+
+function createRequestValidator<T extends z.ZodType<unknown>>(schema: T) {
+  return (request: unknown): asserts request is InferShape<T> => {
+    const result = schema.safeParse(request);
+
+    if (result.success) return;
+
+    never(formatZodError(result.error));
+  };
+}
+
+const CreatePostRequestSchema = z.discriminatedUnion('contentFocus', [
+  createEmbedPostRequestSchema(Erc20AmountInstanceSchema),
+  createMediaPostRequestSchema(Erc20AmountInstanceSchema),
+  createTextualPostRequestSchema(Erc20AmountInstanceSchema),
+]);
+
+export const validateCreatePostRequest: Validator<CreatePostRequest> =
+  createRequestValidator(CreatePostRequestSchema);
+
+const CreateCommentRequestSchema = z.discriminatedUnion('contentFocus', [
+  createEmbedCommentRequestSchema(Erc20AmountInstanceSchema),
+  createMediaCommentRequestSchema(Erc20AmountInstanceSchema),
+  createTextualCommentRequestSchema(Erc20AmountInstanceSchema),
+]);
+
+export const validateCreateCommentRequest: Validator<CreateCommentRequest> = createRequestValidator(
+  CreateCommentRequestSchema,
+);
+
+const TokenAllowanceRequestSchema = tokenAllowanceRequestSchema(Erc20AmountInstanceSchema);
+
+export const validateTokenAllowanceRequest: Validator<TokenAllowanceRequest> =
+  createRequestValidator(TokenAllowanceRequestSchema);
+
+const UpdateFollowPolicyRequestSchema = updateFollowPolicyRequestSchema(Erc20AmountInstanceSchema);
+
+export const validateUpdateFollowPolicyRequest: Validator<UpdateFollowPolicyRequest> =
+  createRequestValidator(UpdateFollowPolicyRequestSchema);
+
+export const validateUpdateProfileDetailsRequest: Validator<UpdateProfileDetailsRequest> =
+  createRequestValidator(UpdateProfileDetailsRequestSchema);
diff --git a/packages/react/src/transactions/infrastructure/TransactionFactory.ts b/packages/react/src/transactions/infrastructure/TransactionFactory.ts
new file mode 100644
index 0000000000..f5b8bfbde4
--- /dev/null
+++ b/packages/react/src/transactions/infrastructure/TransactionFactory.ts
@@ -0,0 +1,310 @@
+import {
+  DataTransaction,
+  MetaTransaction,
+  NativeTransaction,
+  Nonce,
+  ProtocolTransactionKinds,
+  TransactionError,
+  TransactionEvent,
+  TransactionKind,
+} from '@lens-protocol/domain/entities';
+import {
+  ProtocolTransactionRequest,
+  AnyTransactionRequest,
+} from '@lens-protocol/domain/use-cases/transactions';
+import { ChainType, failure, PromiseResult, success, XOR } from '@lens-protocol/shared-kernel';
+
+import {
+  DataTransactionData,
+  MetaTransactionData,
+  NativeTransactionData,
+} from '../adapters/ITransactionFactory';
+import {
+  ISerializableMetaTransaction,
+  ISerializableNativeTransaction,
+  ISerializableTransactionFactory,
+} from '../adapters/PendingTransactionGateway';
+import { ISerializableDataTransaction } from '../adapters/PendingTransactionGateway/ISerializableTransactionFactory';
+
+export type IndexingEvent = {
+  indexed: boolean;
+  txHash: string;
+};
+export type ConfirmationRequest = {
+  txHash: string;
+  chainType: ChainType;
+};
+
+export type IndexingEventRequest = XOR<{ txHash: string }, { indexingId: string }>;
+
+export interface ITransactionObserver {
+  waitForConfirmation(request: ConfirmationRequest): PromiseResult<void, TransactionError>;
+
+  waitForNextIndexingEvent(
+    request: IndexingEventRequest,
+  ): PromiseResult<IndexingEvent, TransactionError>;
+}
+
+type StateUpdate<T> = {
+  event: TransactionEvent;
+  state: T;
+};
+
+type StateReducer<T> = (state: T) => PromiseResult<StateUpdate<T>, TransactionError>;
+
+type MetaTransactionState<T extends AnyTransactionRequest> = {
+  chainType: ChainType;
+  id: string;
+  indexingId: string;
+  nonce: Nonce;
+  request: T;
+  txHash: string;
+};
+
+class SerializableMetaTransaction<T extends ProtocolTransactionRequest>
+  extends MetaTransaction<T>
+  implements ISerializableMetaTransaction<T>
+{
+  constructor(
+    private state: MetaTransactionState<T>,
+    private readonly reduce: StateReducer<MetaTransactionState<T>>,
+  ) {
+    super();
+  }
+
+  toTransactionData(): MetaTransactionData<T> {
+    return {
+      chainType: this.state.chainType,
+      id: this.state.id,
+      indexingId: this.state.indexingId,
+      nonce: this.state.nonce,
+      request: this.state.request,
+      txHash: this.state.txHash,
+    };
+  }
+
+  get chainType(): ChainType {
+    return this.state.chainType;
+  }
+
+  get id(): string {
+    return this.state.id;
+  }
+
+  get request(): T {
+    return this.state.request;
+  }
+
+  get nonce(): Nonce {
+    return this.state.nonce;
+  }
+
+  get hash(): string {
+    return this.state.txHash;
+  }
+
+  async waitNextEvent(): PromiseResult<TransactionEvent, TransactionError> {
+    const result = await this.reduce(this.state);
+
+    if (result.isSuccess()) {
+      this.state = result.value.state;
+      return success(result.value.event);
+    }
+    return failure(result.error);
+  }
+}
+
+type NativeTransactionState<T extends AnyTransactionRequest> = {
+  chainType: ChainType;
+  id: string;
+  indexingId?: string;
+  request: T;
+  txHash: string;
+};
+
+class SerializableNativeTransaction<T extends AnyTransactionRequest>
+  extends NativeTransaction<T>
+  implements ISerializableNativeTransaction<T>
+{
+  constructor(
+    private state: NativeTransactionState<T>,
+    private readonly reduce: StateReducer<NativeTransactionState<T>>,
+  ) {
+    super();
+  }
+
+  toTransactionData(): NativeTransactionData<T> {
+    return {
+      chainType: this.state.chainType,
+      id: this.state.id,
+      indexingId: this.state.indexingId,
+      request: this.state.request,
+      txHash: this.state.txHash,
+    };
+  }
+
+  get nonce(): number {
+    throw new Error('Method not implemented.');
+  }
+
+  get chainType(): ChainType {
+    return this.state.chainType;
+  }
+
+  get id(): string {
+    return this.state.id;
+  }
+
+  get request(): T {
+    return this.state.request;
+  }
+
+  get hash(): string {
+    return this.state?.txHash;
+  }
+
+  async waitNextEvent(): PromiseResult<TransactionEvent, TransactionError> {
+    const result = await this.reduce(this.state);
+
+    if (result.isSuccess()) {
+      this.state = result.value.state;
+      return success(result.value.event);
+    }
+    return failure(result.error);
+  }
+}
+
+class SerializableDataTransaction<T extends ProtocolTransactionRequest>
+  extends DataTransaction<T>
+  implements ISerializableDataTransaction<T>
+{
+  constructor(readonly id: string, readonly request: T) {
+    super();
+  }
+
+  async waitNextEvent(): PromiseResult<TransactionEvent, TransactionError> {
+    return success(TransactionEvent.SETTLED);
+  }
+
+  toTransactionData(): DataTransactionData<T> {
+    return {
+      id: this.id,
+      request: this.request,
+    };
+  }
+}
+
+export class TransactionFactory implements ISerializableTransactionFactory {
+  constructor(private readonly transactionObserver: ITransactionObserver) {}
+
+  createMetaTransaction<T extends ProtocolTransactionRequest>(init: MetaTransactionData<T>) {
+    return new SerializableMetaTransaction(
+      {
+        chainType: init.chainType,
+        id: init.id,
+        indexingId: init.indexingId,
+        nonce: init.nonce,
+        request: init.request,
+        txHash: init.txHash,
+      },
+      this.createProtocolCallStateReducer(),
+    );
+  }
+
+  createNativeTransaction<T extends AnyTransactionRequest>(init: NativeTransactionData<T>) {
+    if (init.indexingId) {
+      return new SerializableNativeTransaction(
+        {
+          chainType: init.chainType,
+          id: init.id,
+          indexingId: init.indexingId,
+          request: init.request,
+          txHash: init.txHash,
+        },
+        this.createProtocolCallStateReducer(),
+      );
+    }
+
+    if ((ProtocolTransactionKinds as ReadonlyArray<TransactionKind>).includes(init.request.kind)) {
+      return new SerializableNativeTransaction(
+        {
+          chainType: init.chainType,
+          id: init.id,
+          request: init.request,
+          txHash: init.txHash,
+        },
+        this.createProtocolCallStateReducer(),
+      );
+    }
+    return new SerializableNativeTransaction(
+      {
+        chainType: init.chainType,
+        id: init.id,
+        request: init.request,
+        txHash: init.txHash,
+      },
+      this.createPureBlockchainStateReducer(),
+    );
+  }
+
+  createDataTransaction<T extends ProtocolTransactionRequest>(
+    init: DataTransactionData<T>,
+  ): ISerializableDataTransaction<T> {
+    return new SerializableDataTransaction(init.id, init.request);
+  }
+
+  private createProtocolCallStateReducer<
+    T extends AnyTransactionRequest,
+    S extends MetaTransactionState<T> | NativeTransactionState<T>,
+  >(): StateReducer<S> {
+    return async (state) => {
+      const request = state.indexingId
+        ? { indexingId: state.indexingId }
+        : { txHash: state.txHash };
+
+      const indexingEventResult = await this.transactionObserver.waitForNextIndexingEvent(request);
+
+      if (indexingEventResult.isFailure()) {
+        return failure(indexingEventResult.error);
+      }
+
+      if (indexingEventResult.value.indexed) {
+        return success({
+          event: TransactionEvent.SETTLED,
+          state: {
+            ...state,
+            txHash: indexingEventResult.value.txHash,
+          },
+        });
+      }
+      return success({
+        event: TransactionEvent.UPGRADED,
+        state: {
+          ...state,
+          txHash: indexingEventResult.value.txHash,
+        },
+      });
+    };
+  }
+
+  private createPureBlockchainStateReducer<
+    T extends AnyTransactionRequest,
+    S extends NativeTransactionState<T>,
+  >(): StateReducer<S> {
+    return async (state) => {
+      const result = await this.transactionObserver.waitForConfirmation({
+        txHash: state.txHash,
+        chainType: state.chainType,
+      });
+
+      if (result.isFailure()) {
+        return failure(result.error);
+      }
+
+      return success({
+        event: TransactionEvent.SETTLED,
+        state,
+      });
+    };
+  }
+}
diff --git a/packages/react/src/transactions/infrastructure/TransactionObserver.ts b/packages/react/src/transactions/infrastructure/TransactionObserver.ts
new file mode 100644
index 0000000000..8d13959ab9
--- /dev/null
+++ b/packages/react/src/transactions/infrastructure/TransactionObserver.ts
@@ -0,0 +1,164 @@
+import {
+  SafeApolloClient,
+  LensTransactionStatusDocument,
+  LensTransactionStatusData,
+  LensTransactionStatusVariables,
+  LensTransactionFailureType,
+  LensTransactionStatusType,
+} from '@lens-protocol/api-bindings';
+import { TransactionError, TransactionErrorReason } from '@lens-protocol/domain/entities';
+import {
+  failure,
+  InvariantError,
+  never,
+  PromiseResult,
+  Result,
+  success,
+} from '@lens-protocol/shared-kernel';
+
+import { IProviderFactory } from '../../wallet/adapters/IProviderFactory';
+import {
+  ConfirmationRequest,
+  IndexingEvent,
+  IndexingEventRequest,
+  ITransactionObserver,
+} from './TransactionFactory';
+
+const ONE_SECOND = 1000; // ms
+
+/**
+ * The transaction observer timings
+ *
+ * @internal
+ */
+export type TransactionObserverTimings = {
+  pollingInterval: number; // ms // TODO move this definition closer to EnvironmentConfig, not used by TransactionObserver
+  maxMiningWaitTime: number; // ms
+  maxIndexingWaitTime: number; // ms
+};
+
+function delay(waitInMs: number) {
+  return new Promise((resolve) => setTimeout(resolve, waitInMs));
+}
+
+function resolveTransactionErrorReason(reason: LensTransactionFailureType) {
+  switch (reason) {
+    case LensTransactionFailureType.Reverted:
+      return TransactionErrorReason.REVERTED;
+    default:
+      return TransactionErrorReason.UNKNOWN;
+  }
+}
+
+export class TransactionObserver implements ITransactionObserver {
+  constructor(
+    private readonly providerFactory: IProviderFactory,
+    private readonly apolloClient: SafeApolloClient,
+    private readonly timings: TransactionObserverTimings,
+  ) {}
+
+  async waitForConfirmation(request: ConfirmationRequest): PromiseResult<void, TransactionError> {
+    const provider = await this.providerFactory.createProvider({ chainType: request.chainType });
+    const startedAt = Date.now();
+
+    while (Date.now() - startedAt <= this.timings.maxMiningWaitTime) {
+      const txResponse = await provider.getTransaction(request.txHash);
+
+      if (txResponse === null) {
+        await delay(ONE_SECOND);
+        continue;
+      }
+      try {
+        await Promise.race([
+          txResponse.wait(1),
+
+          delay(this.timings.maxMiningWaitTime).then(() => {
+            throw new TransactionError(TransactionErrorReason.MINING_TIMEOUT);
+          }),
+        ]);
+        return success();
+      } catch (e) {
+        if (e instanceof TransactionError) {
+          return failure(e);
+        }
+        throw e;
+      }
+    }
+    return failure(new TransactionError(TransactionErrorReason.MINING_TIMEOUT));
+  }
+
+  async waitForNextIndexingEvent(
+    request: IndexingEventRequest,
+  ): PromiseResult<IndexingEvent, TransactionError> {
+    const startedAt = Date.now();
+    const observable = this.apolloClient.poll<
+      LensTransactionStatusData,
+      LensTransactionStatusVariables
+    >({
+      query: LensTransactionStatusDocument,
+      variables: {
+        request: request.indexingId
+          ? {
+              forTxId: request.indexingId,
+            }
+          : {
+              forTxHash: request.txHash,
+            },
+      },
+    });
+    let previousTxHash: string | null = null;
+
+    return new Promise<Result<IndexingEvent, TransactionError>>((resolve, reject) => {
+      const subscription = observable.subscribe({
+        next: async ({ result }) => {
+          if (request.indexingId && result === null) {
+            subscription.unsubscribe();
+
+            reject(new InvariantError(`Transaction ${String(request.indexingId)} not found`));
+          }
+
+          if (result === null) {
+            return;
+          }
+
+          if (result.status === LensTransactionStatusType.Failed) {
+            subscription.unsubscribe();
+            resolve(
+              failure(
+                new TransactionError(
+                  resolveTransactionErrorReason(result.reason ?? never(`Missing reason`)),
+                ),
+              ),
+            );
+            return;
+          }
+
+          if (previousTxHash === null) {
+            previousTxHash = result.txHash;
+          }
+
+          if (
+            previousTxHash !== result.txHash ||
+            result.status === LensTransactionStatusType.Complete
+          ) {
+            subscription.unsubscribe();
+            resolve(
+              success({
+                indexed: result.status === LensTransactionStatusType.Complete,
+                txHash: result.txHash,
+              }),
+            );
+            return;
+          }
+
+          if (Date.now() - startedAt > this.timings.maxIndexingWaitTime) {
+            subscription.unsubscribe();
+
+            resolve(failure(new TransactionError(TransactionErrorReason.INDEXING_TIMEOUT)));
+          }
+        },
+        error: reject,
+      });
+    });
+  }
+}
diff --git a/packages/react/src/transactions/infrastructure/__helpers__/mocks.ts b/packages/react/src/transactions/infrastructure/__helpers__/mocks.ts
new file mode 100644
index 0000000000..2705ae8988
--- /dev/null
+++ b/packages/react/src/transactions/infrastructure/__helpers__/mocks.ts
@@ -0,0 +1,85 @@
+import { TransactionError } from '@lens-protocol/domain/entities';
+import {
+  ChainType,
+  failure,
+  invariant,
+  never,
+  PromiseResult,
+  Result,
+  success,
+} from '@lens-protocol/shared-kernel';
+
+import {
+  ConfirmationRequest,
+  IndexingEvent,
+  IndexingEventRequest,
+  ITransactionObserver,
+} from '../TransactionFactory';
+
+type WaitForConfirmationInstructions = {
+  txHash: string;
+  chainType: ChainType;
+  result: Result<void, TransactionError>;
+};
+
+type WaitForNextIndexingEventInstructions = {
+  request: IndexingEventRequest;
+  events: Array<IndexingEvent | TransactionError>;
+};
+
+type MockedTransactionObserverInstructions =
+  | WaitForConfirmationInstructions
+  | WaitForNextIndexingEventInstructions;
+
+export class MockedTransactionObserver implements ITransactionObserver {
+  private constructor(private readonly instructions: MockedTransactionObserverInstructions) {}
+
+  async waitForConfirmation({
+    txHash,
+    chainType,
+  }: ConfirmationRequest): PromiseResult<void, TransactionError> {
+    if (!('txHash' in this.instructions)) {
+      throw new Error('Method not implemented.');
+    }
+    invariant(txHash === this.instructions.txHash, 'txHash mismatch');
+    invariant(chainType === this.instructions.chainType, 'chainType mismatch');
+
+    return this.instructions.result;
+  }
+
+  async waitForNextIndexingEvent(
+    request: IndexingEventRequest,
+  ): PromiseResult<IndexingEvent, TransactionError> {
+    if (!('events' in this.instructions)) {
+      throw new Error('Method not implemented.');
+    }
+    invariant(
+      JSON.stringify(request) === JSON.stringify(this.instructions.request),
+      'Indexing event request mismatch',
+    );
+
+    const item = this.instructions.events.shift();
+
+    invariant(item, 'Indexing events sequence is empty');
+
+    if (item instanceof TransactionError) {
+      return failure(item);
+    }
+
+    if ('indexed' in item) {
+      return success(item);
+    }
+
+    never(`Unexpected item in indexing events sequence`);
+  }
+
+  static withIndexingEventSequence(
+    instructions: WaitForNextIndexingEventInstructions,
+  ): MockedTransactionObserver {
+    return new MockedTransactionObserver(instructions);
+  }
+
+  static withExecutedOutcome(instructions: WaitForConfirmationInstructions) {
+    return new MockedTransactionObserver(instructions);
+  }
+}
diff --git a/packages/react/src/transactions/infrastructure/__tests__/TransactionFactory.spec.ts b/packages/react/src/transactions/infrastructure/__tests__/TransactionFactory.spec.ts
new file mode 100644
index 0000000000..304d4b9c6d
--- /dev/null
+++ b/packages/react/src/transactions/infrastructure/__tests__/TransactionFactory.spec.ts
@@ -0,0 +1,218 @@
+import {
+  MetaTransaction,
+  NativeTransaction,
+  ProtocolTransactionKinds,
+  TransactionError,
+  TransactionErrorReason,
+  TransactionEvent,
+  TransactionKind,
+} from '@lens-protocol/domain/entities';
+import { mockTransactionHash, mockAnyTransactionRequestModel } from '@lens-protocol/domain/mocks';
+import {
+  ProtocolTransactionRequest,
+  AnyTransactionRequest,
+} from '@lens-protocol/domain/use-cases/transactions';
+import { success } from '@lens-protocol/shared-kernel';
+import { mock } from 'jest-mock-extended';
+
+import {
+  mockMetaTransactionData,
+  mockNativeTransactionData,
+  mockNativeTransactionDataWithIndexingId,
+} from '../../adapters/__helpers__/mocks';
+import { IndexingEvent, ITransactionObserver, TransactionFactory } from '../TransactionFactory';
+import { MockedTransactionObserver } from '../__helpers__/mocks';
+
+function mockIndexingEvent(overrides?: Partial<IndexingEvent>): IndexingEvent {
+  return {
+    indexed: false,
+    txHash: mockTransactionHash(),
+    ...overrides,
+  };
+}
+
+function setupTransactionFactory({
+  observer = mock<ITransactionObserver>(),
+}: { observer?: ITransactionObserver } = {}) {
+  return new TransactionFactory(observer);
+}
+
+describe(`Given an instance of the ${TransactionFactory.name}`, () => {
+  describe(`and a ${MetaTransaction.name} instance created via MetaTransactionData<T>`, () => {
+    const init = mockMetaTransactionData<ProtocolTransactionRequest>();
+
+    describe(`when invoking the "waitNextEvent" method`, () => {
+      it(`should
+          - resolve with Success<TransactionEvent.${TransactionEvent.UPGRADED}> as the txHash changes while not yet indexed
+          - and update the tx hash`, async () => {
+        const indexingEvent = mockIndexingEvent({ indexed: false });
+        const observer = MockedTransactionObserver.withIndexingEventSequence({
+          request: {
+            indexingId: init.indexingId,
+          },
+          events: [indexingEvent],
+        });
+        const factory = setupTransactionFactory({ observer });
+
+        const transaction = factory.createMetaTransaction(init);
+
+        const result = await transaction.waitNextEvent();
+
+        expect(result.unwrap()).toBe(TransactionEvent.UPGRADED);
+        expect(transaction.hash).toEqual(indexingEvent.txHash);
+      });
+
+      it(`should:
+          - resolve with Success<TransactionEvent.${TransactionEvent.SETTLED}> as soon as indexed by the BE
+          - and update the tx hash if changed`, async () => {
+        const indexingEvent = mockIndexingEvent({ indexed: true });
+        const observer = MockedTransactionObserver.withIndexingEventSequence({
+          request: {
+            indexingId: init.indexingId,
+          },
+          events: [indexingEvent],
+        });
+        const factory = setupTransactionFactory({ observer });
+
+        const transaction = factory.createMetaTransaction(init);
+
+        const result = await transaction.waitNextEvent();
+
+        expect(result.unwrap()).toBe(TransactionEvent.SETTLED);
+        expect(transaction.hash).toEqual(indexingEvent.txHash);
+      });
+
+      it(`should forward any ${TransactionError.name} from the ITransactionObserver`, async () => {
+        const error = new TransactionError(TransactionErrorReason.MINING_TIMEOUT);
+        const observer = MockedTransactionObserver.withIndexingEventSequence({
+          request: {
+            indexingId: init.indexingId,
+          },
+          events: [error],
+        });
+        const factory = setupTransactionFactory({ observer });
+
+        const transaction = factory.createMetaTransaction(init);
+
+        const result = await transaction.waitNextEvent();
+
+        expect(() => result.unwrap()).toThrow(error);
+      });
+    });
+  });
+
+  describe(`and a ${NativeTransaction.name} instance created via NativeTransactionData<T>`, () => {
+    describe(`with "indexingId"`, () => {
+      const init = mockNativeTransactionDataWithIndexingId<AnyTransactionRequest>();
+
+      describe(`when invoking the "waitNextEvent" method`, () => {
+        it(`should
+            - resolve with Success<TransactionEvent.${TransactionEvent.UPGRADED}> as the txHash changes while not yet indexed
+            - and update the tx hash`, async () => {
+          const indexingEvent = mockIndexingEvent({ indexed: false });
+          const observer = MockedTransactionObserver.withIndexingEventSequence({
+            request: {
+              indexingId: init.indexingId,
+            },
+            events: [indexingEvent],
+          });
+          const factory = setupTransactionFactory({ observer });
+
+          const transaction = factory.createNativeTransaction(init);
+          const result = await transaction.waitNextEvent();
+
+          expect(result.unwrap()).toBe(TransactionEvent.UPGRADED);
+          expect(transaction.hash).toEqual(indexingEvent.txHash);
+        });
+
+        it(`should:
+            - resolve with Success<TransactionEvent.${TransactionEvent.SETTLED}> as soon as indexed by the BE
+            - and update the tx hash if changed`, async () => {
+          const indexingEvent = mockIndexingEvent({ indexed: true });
+          const observer = MockedTransactionObserver.withIndexingEventSequence({
+            request: {
+              indexingId: init.indexingId,
+            },
+            events: [indexingEvent],
+          });
+          const factory = setupTransactionFactory({ observer });
+
+          const transaction = factory.createNativeTransaction(init);
+          const result = await transaction.waitNextEvent();
+
+          expect(result.unwrap()).toBe(TransactionEvent.SETTLED);
+          expect(transaction.hash).toEqual(indexingEvent.txHash);
+        });
+
+        it(`should forward any ${TransactionError.name} from the ITransactionObserver`, async () => {
+          const error = new TransactionError(TransactionErrorReason.MINING_TIMEOUT);
+          const observer = MockedTransactionObserver.withIndexingEventSequence({
+            request: {
+              indexingId: init.indexingId,
+            },
+            events: [error],
+          });
+          const factory = setupTransactionFactory({ observer });
+
+          const transaction = factory.createNativeTransaction(init);
+          const result = await transaction.waitNextEvent();
+
+          expect(() => result.unwrap()).toThrow(error);
+        });
+      });
+    });
+
+    describe(`with NO "indexingId"`, () => {
+      describe.each(ProtocolTransactionKinds)(
+        `and the transaction request is for an "%s" transaction`,
+        (kind) => {
+          describe(`when invoking the "waitNextEvent" method`, () => {
+            const init = mockNativeTransactionData({
+              request: mockAnyTransactionRequestModel({ kind }) as AnyTransactionRequest,
+            });
+
+            it(`should resolve with Success<TransactionEvent.SETTLED> as soon as indexed by the BE`, async () => {
+              const indexingEvent = mockIndexingEvent({ indexed: true });
+              const observer = MockedTransactionObserver.withIndexingEventSequence({
+                request: {
+                  txHash: init.txHash,
+                },
+                events: [indexingEvent],
+              });
+              const factory = setupTransactionFactory({ observer });
+
+              const transaction = factory.createNativeTransaction(init);
+              const result = await transaction.waitNextEvent();
+
+              expect(result.unwrap()).toBe(TransactionEvent.SETTLED);
+            });
+          });
+        },
+      );
+
+      describe(`and the transaction request is for an "${TransactionKind.APPROVE_MODULE}" transaction`, () => {
+        describe(`when invoking the "waitNextEvent" method`, () => {
+          const init = mockNativeTransactionData({
+            request: mockAnyTransactionRequestModel({
+              kind: TransactionKind.APPROVE_MODULE,
+            }) as AnyTransactionRequest,
+          });
+
+          it(`should resolve with Success<TransactionEvent.SETTLED> as soon as the transaction is executed`, async () => {
+            const observer = MockedTransactionObserver.withExecutedOutcome({
+              txHash: init.txHash,
+              chainType: init.chainType,
+              result: success(),
+            });
+            const factory = setupTransactionFactory({ observer });
+
+            const transaction = factory.createNativeTransaction(init);
+            const result = await transaction.waitNextEvent();
+
+            expect(result.unwrap()).toBe(TransactionEvent.SETTLED);
+          });
+        });
+      });
+    });
+  });
+});
diff --git a/packages/react/src/transactions/infrastructure/__tests__/TransactionObserver.spec.ts b/packages/react/src/transactions/infrastructure/__tests__/TransactionObserver.spec.ts
new file mode 100644
index 0000000000..c0b8f5343f
--- /dev/null
+++ b/packages/react/src/transactions/infrastructure/__tests__/TransactionObserver.spec.ts
@@ -0,0 +1,342 @@
+/**
+ * @jest-environment node
+ */
+
+import { faker } from '@faker-js/faker';
+import {
+  LensTransactionFailureType,
+  LensTransactionStatusType,
+  SafeApolloClient,
+} from '@lens-protocol/api-bindings';
+import {
+  mockLensApolloClient,
+  mockLensTransactionStatusDataResponse,
+  mockLensTransactionResult,
+} from '@lens-protocol/api-bindings/mocks';
+import { TransactionError, TransactionErrorReason } from '@lens-protocol/domain/entities';
+import { mockTransactionHash } from '@lens-protocol/domain/mocks';
+import { ChainType, InvariantError } from '@lens-protocol/shared-kernel';
+import { MockProvider } from 'ethereum-waffle';
+import { providers, utils, Wallet } from 'ethers';
+import { mock } from 'jest-mock-extended';
+
+import { mockIProviderFactory } from '../../../wallet/adapters/__helpers__/mocks';
+import { TransactionObserver, TransactionObserverTimings } from '../TransactionObserver';
+
+const chainType = ChainType.POLYGON;
+
+function setupTransactionObserver({
+  apolloClient = mock<SafeApolloClient>(),
+  timings = {
+    pollingInterval: 1,
+    maxIndexingWaitTime: 1000,
+    maxMiningWaitTime: 1000,
+  },
+  provider = mock<providers.JsonRpcProvider>(),
+}: {
+  apolloClient?: SafeApolloClient;
+  timings?: TransactionObserverTimings;
+  provider?: providers.JsonRpcProvider;
+}) {
+  const providerFactory = mockIProviderFactory({
+    chainType,
+    provider,
+  });
+  return new TransactionObserver(providerFactory, apolloClient, timings);
+}
+
+async function createBlockchainTransaction(provider: MockProvider) {
+  const [walletFrom, walletTo] = provider.getWallets() as [Wallet, Wallet];
+  const txResponse = await walletFrom.sendTransaction({
+    to: walletTo.address,
+    from: walletFrom.address,
+    value: utils.parseEther('1'),
+  });
+  return txResponse.hash;
+}
+
+describe(`Given an instance of the ${TransactionObserver.name}`, () => {
+  describe(`when invoking ${TransactionObserver.prototype.waitForConfirmation.name} with a tx hash`, () => {
+    it('should succeed if the tx is mined within a reasonable time', async () => {
+      const provider = new MockProvider();
+      const transaction = setupTransactionObserver({
+        provider,
+      });
+
+      const txHash = await createBlockchainTransaction(provider);
+      const result = await transaction.waitForConfirmation({ txHash, chainType });
+
+      expect(result.isSuccess()).toBe(true);
+    }, 15_000);
+
+    it(`should fail with ${TransactionError.name}[reason: ${TransactionErrorReason.MINING_TIMEOUT}] if the tx is not found within a reasonable time`, async () => {
+      const provider = new MockProvider();
+
+      const transaction = setupTransactionObserver({
+        provider,
+      });
+      const txHash = mockTransactionHash();
+      const result = await transaction.waitForConfirmation({ txHash, chainType });
+
+      expect(() => result.unwrap()).toThrow(TransactionError);
+      expect(result.isFailure() && result.error.reason).toBe(TransactionErrorReason.MINING_TIMEOUT);
+    }, 15_000);
+
+    // This test is temporarily skipped because the previous strategy to test stale tx does not work with the new version of Ganache
+    it.skip(`should fail with ${TransactionError.name}[reason: ${TransactionErrorReason.MINING_TIMEOUT}] if the tx is found but not mined within a reasonable time`, async () => {
+      const provider = new MockProvider({
+        ganacheOptions: {
+          miner: {
+            blockTime: 60, // seconds // this used to be enough to simulate a stale tx
+          },
+        },
+      });
+      const transaction = setupTransactionObserver({
+        timings: {
+          pollingInterval: 1,
+          maxMiningWaitTime: 1000, // ms
+          maxIndexingWaitTime: 120_000, // ms
+        },
+        provider,
+      });
+
+      const txHash = await createBlockchainTransaction(provider);
+      const result = await transaction.waitForConfirmation({ txHash, chainType });
+
+      expect(() => result.unwrap()).toThrow(TransactionError);
+      expect(result.isFailure() && result.error.reason).toBe(TransactionErrorReason.MINING_TIMEOUT);
+    }, 15_000);
+  });
+
+  describe(`when invoking ${TransactionObserver.prototype.waitForNextIndexingEvent.name}`, () => {
+    describe(`with a tx hash`, () => {
+      const txHash = mockTransactionHash();
+
+      it('should succeed with indexed=true if the tx has been indexed by the BE', async () => {
+        const responses = [
+          mockLensTransactionStatusDataResponse({
+            request: { forTxHash: txHash },
+            result: null, // simulates a tx not reached the nodes used by the indexer to monitor on-chain events
+          }),
+          mockLensTransactionStatusDataResponse({
+            request: { forTxHash: txHash },
+            result: mockLensTransactionResult({
+              status: LensTransactionStatusType.Complete,
+              txHash,
+            }),
+          }),
+        ];
+        const apolloClient = mockLensApolloClient(responses);
+        const transaction = setupTransactionObserver({
+          apolloClient,
+        });
+
+        const event = await transaction.waitForNextIndexingEvent({ txHash });
+        expect(event.unwrap()).toEqual({
+          indexed: true,
+          txHash,
+        });
+      });
+
+      it(`should fail with ${TransactionError.name}[reason: ${TransactionErrorReason.REVERTED}] if the tx gets reverted`, async () => {
+        const apolloClient = mockLensApolloClient([
+          mockLensTransactionStatusDataResponse({
+            request: { forTxHash: txHash },
+            result: mockLensTransactionResult({
+              status: LensTransactionStatusType.Failed,
+              reason: LensTransactionFailureType.Reverted,
+            }),
+          }),
+        ]);
+        const transaction = setupTransactionObserver({
+          apolloClient,
+        });
+
+        const result = await transaction.waitForNextIndexingEvent({ txHash });
+
+        expect(() => result.unwrap()).toThrow(TransactionError);
+        expect(result.isFailure() && result.error.reason).toBe(TransactionErrorReason.REVERTED);
+      });
+
+      it(`should fail with ${TransactionError.name}[reason: ${TransactionErrorReason.INDEXING_TIMEOUT}] if the tx is not indexed within a reasonable time`, async () => {
+        const txHash = mockTransactionHash();
+        const apolloClient = mockLensApolloClient([
+          mockLensTransactionStatusDataResponse({
+            request: { forTxHash: txHash },
+            result: mockLensTransactionResult({
+              status: LensTransactionStatusType.Processing,
+            }),
+          }),
+        ]);
+
+        const transaction = setupTransactionObserver({
+          apolloClient,
+          timings: {
+            pollingInterval: 1,
+            maxMiningWaitTime: 1000, // ms
+            maxIndexingWaitTime: 1, // ms
+          },
+        });
+        const result = await transaction.waitForNextIndexingEvent({ txHash });
+
+        expect(() => result.unwrap()).toThrow(TransactionError);
+        expect(result.isFailure() && result.error.reason).toBe(
+          TransactionErrorReason.INDEXING_TIMEOUT,
+        );
+      });
+    });
+
+    describe(`with an tx ID`, () => {
+      const txId = faker.datatype.uuid();
+
+      it('should succeed with indexed=true if the tx has been indexed by the BE', async () => {
+        const txHash = mockTransactionHash();
+        const responses = [
+          mockLensTransactionStatusDataResponse({
+            request: { forTxId: txId },
+            result: mockLensTransactionResult({
+              status: LensTransactionStatusType.Complete,
+              txHash,
+            }),
+          }),
+        ];
+        const apolloClient = mockLensApolloClient(responses);
+        const transaction = setupTransactionObserver({
+          apolloClient,
+        });
+
+        const event = await transaction.waitForNextIndexingEvent({ indexingId: txId });
+        expect(event.unwrap()).toEqual({
+          indexed: true,
+          txHash,
+        });
+      });
+
+      it('should succeed with any new txHash if the it changes before being indexed', async () => {
+        const upgradedTxHash = mockTransactionHash();
+        const responses = [
+          mockLensTransactionStatusDataResponse({
+            request: { forTxId: txId },
+            result: mockLensTransactionResult({
+              status: LensTransactionStatusType.Processing,
+              txHash: mockTransactionHash(),
+            }),
+          }),
+          mockLensTransactionStatusDataResponse({
+            request: { forTxId: txId },
+            result: mockLensTransactionResult({
+              status: LensTransactionStatusType.Processing,
+              txHash: upgradedTxHash,
+            }),
+          }),
+        ];
+        const apolloClient = mockLensApolloClient(responses);
+        const transaction = setupTransactionObserver({
+          apolloClient,
+        });
+
+        const event = await transaction.waitForNextIndexingEvent({ indexingId: txId });
+        expect(event.unwrap()).toEqual({
+          indexed: false,
+          txHash: upgradedTxHash,
+        });
+      });
+
+      it('should succeed return any new txHash also as the tx is flagged as indexed by the BE', async () => {
+        const initialTxHash = mockTransactionHash();
+        const upgradedTxHash = mockTransactionHash();
+        const responses = [
+          mockLensTransactionStatusDataResponse({
+            request: { forTxId: txId },
+            result: mockLensTransactionResult({
+              status: LensTransactionStatusType.Processing,
+              txHash: initialTxHash,
+            }),
+          }),
+          mockLensTransactionStatusDataResponse({
+            request: { forTxId: txId },
+            result: mockLensTransactionResult({
+              status: LensTransactionStatusType.Complete,
+              txHash: upgradedTxHash,
+            }),
+          }),
+        ];
+        const apolloClient = mockLensApolloClient(responses);
+        const transaction = setupTransactionObserver({
+          apolloClient,
+        });
+
+        const event = await transaction.waitForNextIndexingEvent({ indexingId: txId });
+        expect(event.unwrap()).toEqual({
+          indexed: true,
+          txHash: upgradedTxHash,
+        });
+      });
+
+      it(`should fail with an ${InvariantError.name} if the tx is not found`, async () => {
+        const responses = [
+          mockLensTransactionStatusDataResponse({
+            request: { forTxId: txId },
+            result: null,
+          }),
+        ];
+        const apolloClient = mockLensApolloClient(responses);
+        const transaction = setupTransactionObserver({
+          apolloClient,
+        });
+
+        await expect(() =>
+          transaction.waitForNextIndexingEvent({ indexingId: txId }),
+        ).rejects.toThrow(InvariantError);
+      });
+
+      it(`should fail with ${TransactionError.name}[reason: ${TransactionErrorReason.REVERTED}] if the tx gets reverted`, async () => {
+        const apolloClient = mockLensApolloClient([
+          mockLensTransactionStatusDataResponse({
+            request: { forTxId: txId },
+            result: mockLensTransactionResult({
+              status: LensTransactionStatusType.Failed,
+              reason: LensTransactionFailureType.Reverted,
+            }),
+          }),
+        ]);
+        const transaction = setupTransactionObserver({
+          apolloClient,
+        });
+
+        const result = await transaction.waitForNextIndexingEvent({ indexingId: txId });
+
+        expect(() => result.unwrap());
+        expect(result.isFailure() && result.error.reason).toBe(TransactionErrorReason.REVERTED);
+      });
+
+      it(`should fail with ${TransactionError.name}[reason: ${TransactionErrorReason.INDEXING_TIMEOUT}] if the tx is not indexed within a reasonable time`, async () => {
+        const txHash = mockTransactionHash();
+        const apolloClient = mockLensApolloClient([
+          mockLensTransactionStatusDataResponse({
+            request: { forTxId: txId },
+            result: mockLensTransactionResult({
+              status: LensTransactionStatusType.Processing,
+              txHash,
+            }),
+          }),
+        ]);
+
+        const transaction = setupTransactionObserver({
+          apolloClient,
+          timings: {
+            pollingInterval: 1,
+            maxMiningWaitTime: 1000, // ms
+            maxIndexingWaitTime: 1, // ms
+          },
+        });
+        const result = await transaction.waitForNextIndexingEvent({ indexingId: txId });
+
+        expect(() => result.unwrap()).toThrow(TransactionError);
+        expect(result.isFailure() && result.error.reason).toBe(
+          TransactionErrorReason.INDEXING_TIMEOUT,
+        );
+      });
+    });
+  });
+});
diff --git a/packages/react/src/wallet/adapters/ConcreteWallet.ts b/packages/react/src/wallet/adapters/ConcreteWallet.ts
new file mode 100644
index 0000000000..5fe7907950
--- /dev/null
+++ b/packages/react/src/wallet/adapters/ConcreteWallet.ts
@@ -0,0 +1,324 @@
+import { TypedDataSigner } from '@ethersproject/abstract-signer';
+import { TransactionRequest } from '@ethersproject/providers';
+import { TypedData } from '@lens-protocol/blockchain-bindings';
+import {
+  InsufficientGasError,
+  Wallet,
+  WalletConnectionError,
+  UserRejectedError,
+  PendingSigningRequestError,
+  ISignedProtocolCall,
+  IUnsignedProtocolCall,
+  UnsignedTransaction,
+  NativeTransaction,
+  ProtocolTransactionRequestModel,
+  AnyTransactionRequestModel,
+  Signature,
+  ISignedVote,
+  PollId,
+} from '@lens-protocol/domain/entities';
+import { AnyTransactionRequest } from '@lens-protocol/domain/use-cases/transactions';
+import {
+  ChainType,
+  EvmAddress,
+  failure,
+  invariant,
+  matic,
+  PromiseResult,
+  success,
+} from '@lens-protocol/shared-kernel';
+import { errors, Signer } from 'ethers';
+import { getAddress } from 'ethers/lib/utils';
+import { z } from 'zod';
+
+import { UnsignedVote } from '../../polls/adapters/SnapshotVoteFactory';
+import { ISnapshotVote } from '../../polls/adapters/SnapshotVoteRelayer';
+import { ITransactionFactory } from '../../transactions/adapters/ITransactionFactory';
+import { SelfFundedProtocolTransactionRequest } from '../../transactions/adapters/SelfFundedProtocolTransactionRequest';
+import { assertErrorObjectWithCode } from './errors';
+
+export type RequiredSigner = Signer & TypedDataSigner;
+
+export type CreateSignerConfig = {
+  address: EvmAddress;
+  chainType?: ChainType;
+};
+
+export interface ISignerFactory {
+  createSigner(config: CreateSignerConfig): PromiseResult<RequiredSigner, WalletConnectionError>;
+}
+
+export const WalletDataSchema = z.object({
+  address: z.string(),
+});
+
+export type WalletDataSchema = z.infer<typeof WalletDataSchema>;
+
+export class UnsignedProtocolCall<T extends ProtocolTransactionRequestModel>
+  implements IUnsignedProtocolCall<T>
+{
+  private constructor(
+    readonly id: string,
+    readonly request: T,
+    readonly typedData: TypedData,
+    readonly fallback: SelfFundedProtocolTransactionRequest<T>,
+  ) {}
+
+  get nonce() {
+    invariant(typeof this.typedData.message.nonce === 'number', 'Nonce is not defined');
+    return this.typedData.message.nonce;
+  }
+
+  static create<T extends ProtocolTransactionRequestModel>({
+    id,
+    request,
+    typedData,
+    fallback,
+  }: {
+    id: string;
+    request: T;
+    typedData: TypedData;
+    fallback: SelfFundedProtocolTransactionRequest<T>;
+  }): UnsignedProtocolCall<T> {
+    return new UnsignedProtocolCall(id, request, typedData, fallback);
+  }
+}
+
+export class SignedProtocolCall<T extends ProtocolTransactionRequestModel>
+  implements ISignedProtocolCall<T>
+{
+  private constructor(
+    readonly id: string,
+    readonly request: T,
+    readonly signature: Signature,
+    readonly nonce: number,
+    readonly fallback: SelfFundedProtocolTransactionRequest<T>,
+  ) {}
+
+  static create<T extends ProtocolTransactionRequestModel>({
+    unsignedCall,
+    signature,
+  }: {
+    unsignedCall: UnsignedProtocolCall<T>;
+    signature: string;
+  }): SignedProtocolCall<T> {
+    return new SignedProtocolCall(
+      unsignedCall.id,
+      unsignedCall.request,
+      signature as Signature,
+      unsignedCall.nonce,
+      unsignedCall.fallback,
+    );
+  }
+}
+
+export class SignedVote implements ISnapshotVote {
+  constructor(
+    readonly pollId: PollId,
+    readonly signature: Signature,
+    readonly data: TypedData,
+    readonly voter: EvmAddress,
+  ) {}
+}
+
+export interface ITransactionRequest {
+  get transactionRequest(): TransactionRequest;
+}
+
+export class ConcreteWallet extends Wallet {
+  private signingInProgress = false;
+
+  private constructor(
+    address: EvmAddress,
+    private readonly signerFactory: ISignerFactory,
+    private readonly transactionFactory: ITransactionFactory<AnyTransactionRequestModel>,
+  ) {
+    super(address);
+  }
+
+  async signProtocolCall<T extends ProtocolTransactionRequestModel>(
+    unsignedCall: UnsignedProtocolCall<T>,
+  ): PromiseResult<
+    ISignedProtocolCall<T>,
+    PendingSigningRequestError | UserRejectedError | WalletConnectionError
+  > {
+    const result = await this.signerFactory.createSigner({
+      address: this.address,
+      chainType: ChainType.POLYGON,
+    });
+
+    if (result.isFailure()) {
+      return failure(result.error);
+    }
+
+    if (this.signingInProgress) {
+      return failure(new PendingSigningRequestError());
+    }
+    this.signingInProgress = true;
+
+    const signer = result.value;
+    try {
+      const signature = await signer._signTypedData(
+        unsignedCall.typedData.domain,
+        unsignedCall.typedData.types,
+        unsignedCall.typedData.message,
+      );
+
+      const signedCall = SignedProtocolCall.create({ unsignedCall, signature });
+      return success(signedCall);
+    } catch (err) {
+      assertErrorObjectWithCode<errors>(err);
+
+      if (err.code === errors.ACTION_REJECTED) {
+        return failure(new UserRejectedError());
+      }
+
+      throw err;
+    } finally {
+      this.signingInProgress = false;
+    }
+  }
+
+  async signMessage(
+    message: string,
+  ): PromiseResult<
+    Signature,
+    PendingSigningRequestError | WalletConnectionError | UserRejectedError
+  > {
+    const result = await this.signerFactory.createSigner({
+      address: this.address,
+    });
+
+    if (result.isFailure()) {
+      return failure(result.error);
+    }
+
+    if (this.signingInProgress) {
+      return failure(new PendingSigningRequestError());
+    }
+    this.signingInProgress = true;
+
+    const signer = result.value;
+    try {
+      const signature = await signer.signMessage(message);
+      return success(signature as Signature);
+    } catch (err) {
+      assertErrorObjectWithCode<errors>(err);
+
+      if (err.code === errors.ACTION_REJECTED) {
+        return failure(new UserRejectedError());
+      }
+      throw err;
+    } finally {
+      this.signingInProgress = false;
+    }
+  }
+
+  async sendTransaction<T extends AnyTransactionRequestModel>(
+    unsignedTransaction: UnsignedTransaction<T> & ITransactionRequest,
+  ): PromiseResult<
+    NativeTransaction<T>,
+    InsufficientGasError | PendingSigningRequestError | UserRejectedError | WalletConnectionError
+  > {
+    const result = await this.signerFactory.createSigner({
+      address: this.address,
+      chainType: unsignedTransaction.chainType,
+    });
+
+    if (result.isFailure()) {
+      return failure(result.error);
+    }
+
+    if (this.signingInProgress) {
+      return failure(new PendingSigningRequestError());
+    }
+    this.signingInProgress = true;
+
+    const signer = result.value;
+    try {
+      const response = await signer.sendTransaction(unsignedTransaction.transactionRequest);
+
+      const transaction = this.transactionFactory.createNativeTransaction({
+        chainType: unsignedTransaction.chainType,
+        id: unsignedTransaction.id,
+        request: unsignedTransaction.request,
+        txHash: response.hash,
+      });
+
+      return success(transaction);
+    } catch (err) {
+      assertErrorObjectWithCode<errors>(err);
+
+      switch (err.code) {
+        case errors.ACTION_REJECTED:
+          return failure(new UserRejectedError(err.message));
+        case errors.INSUFFICIENT_FUNDS:
+          return failure(new InsufficientGasError(matic()));
+      }
+
+      throw err;
+    } finally {
+      this.signingInProgress = false;
+    }
+  }
+
+  async signVote(
+    unsignedVote: UnsignedVote,
+  ): PromiseResult<
+    ISignedVote,
+    WalletConnectionError | PendingSigningRequestError | UserRejectedError
+  > {
+    const result = await this.signerFactory.createSigner({
+      address: this.address,
+    });
+
+    if (result.isFailure()) {
+      return failure(result.error);
+    }
+
+    if (this.signingInProgress) {
+      return failure(new PendingSigningRequestError());
+    }
+    this.signingInProgress = true;
+
+    const signer = result.value;
+    try {
+      const signature = await signer._signTypedData(
+        unsignedVote.typedData.domain,
+        unsignedVote.typedData.types,
+        unsignedVote.typedData.message,
+      );
+
+      const signedVote = new SignedVote(
+        unsignedVote.pollId,
+        signature as Signature,
+        unsignedVote.typedData,
+        getAddress(this.address),
+      );
+      return success(signedVote);
+    } catch (err) {
+      assertErrorObjectWithCode<errors>(err);
+
+      if (err.code === errors.ACTION_REJECTED) {
+        return failure(new UserRejectedError());
+      }
+      throw err;
+    } finally {
+      this.signingInProgress = false;
+    }
+  }
+
+  toWalletData(): WalletDataSchema {
+    return {
+      address: this.address,
+    };
+  }
+
+  static create(
+    address: EvmAddress,
+    signerFactory: ISignerFactory,
+    transactionFactory: ITransactionFactory<AnyTransactionRequest>,
+  ) {
+    return new ConcreteWallet(address, signerFactory, transactionFactory);
+  }
+}
diff --git a/packages/react/src/wallet/adapters/IProviderFactory.ts b/packages/react/src/wallet/adapters/IProviderFactory.ts
new file mode 100644
index 0000000000..8a6f19b32c
--- /dev/null
+++ b/packages/react/src/wallet/adapters/IProviderFactory.ts
@@ -0,0 +1,10 @@
+import { ChainType } from '@lens-protocol/shared-kernel';
+import { providers } from 'ethers';
+
+export type CreateProviderConfig = {
+  chainType: ChainType;
+};
+
+export interface IProviderFactory {
+  createProvider(config: CreateProviderConfig): Promise<providers.JsonRpcProvider>;
+}
diff --git a/packages/react/src/wallet/adapters/WalletFactory.ts b/packages/react/src/wallet/adapters/WalletFactory.ts
new file mode 100644
index 0000000000..dcf46ea090
--- /dev/null
+++ b/packages/react/src/wallet/adapters/WalletFactory.ts
@@ -0,0 +1,22 @@
+import { IWalletFactory } from '@lens-protocol/domain/use-cases/authentication';
+import { AnyTransactionRequest } from '@lens-protocol/domain/use-cases/transactions';
+import { EvmAddress } from '@lens-protocol/shared-kernel';
+
+import { ITransactionFactory } from '../../transactions/adapters/ITransactionFactory';
+import { ConcreteWallet, ISignerFactory, WalletDataSchema } from './ConcreteWallet';
+import { IWalletUnmarshaller } from './WalletGateway';
+
+export class WalletFactory implements IWalletUnmarshaller, IWalletFactory {
+  constructor(
+    private readonly signerFactory: ISignerFactory,
+    private readonly transactionFactory: ITransactionFactory<AnyTransactionRequest>,
+  ) {}
+
+  async create(address: EvmAddress): Promise<ConcreteWallet> {
+    return ConcreteWallet.create(address, this.signerFactory, this.transactionFactory);
+  }
+
+  rehydrate(data: WalletDataSchema) {
+    return ConcreteWallet.create(data.address, this.signerFactory, this.transactionFactory);
+  }
+}
diff --git a/packages/react/src/wallet/adapters/WalletGateway.ts b/packages/react/src/wallet/adapters/WalletGateway.ts
new file mode 100644
index 0000000000..6db0bb44ca
--- /dev/null
+++ b/packages/react/src/wallet/adapters/WalletGateway.ts
@@ -0,0 +1,62 @@
+import { IResettableWalletGateway } from '@lens-protocol/domain/src/use-cases/authentication/Logout';
+import {
+  IReadableWalletGateway,
+  IWritableWalletGateway,
+} from '@lens-protocol/domain/use-cases/authentication';
+import { EvmAddress, never } from '@lens-protocol/shared-kernel';
+import { IStorage } from '@lens-protocol/storage';
+import { z } from 'zod';
+
+import { ConcreteWallet, WalletDataSchema } from './ConcreteWallet';
+
+export interface IWalletUnmarshaller {
+  rehydrate(data: WalletDataSchema): ConcreteWallet;
+}
+
+export const WalletStorageSchema = z.array(WalletDataSchema);
+
+export type WalletStorageSchema = z.infer<typeof WalletStorageSchema>;
+
+export class WalletGateway
+  implements IReadableWalletGateway, IResettableWalletGateway, IWritableWalletGateway
+{
+  private inMemoryCache: Record<EvmAddress, ConcreteWallet> = {};
+
+  constructor(
+    private readonly storage: IStorage<WalletStorageSchema>,
+    private readonly factory: IWalletUnmarshaller,
+  ) {}
+
+  async getByAddress(address: EvmAddress): Promise<ConcreteWallet | null> {
+    if (this.inMemoryCache[address]) {
+      return this.inMemoryCache[address] ?? never();
+    }
+    const wallets = await this.getAll();
+    const wallet = wallets.find((w) => w.address === address) ?? null;
+
+    if (wallet) {
+      this.inMemoryCache[address] = wallet;
+    }
+    return wallet;
+  }
+
+  async reset(): Promise<void> {
+    await this.storage.reset();
+  }
+
+  async save(wallet: ConcreteWallet): Promise<void> {
+    const wallets = await this.getAll();
+
+    this.inMemoryCache[wallet.address] = wallet;
+    await this.storage.set(wallets.concat([wallet]).map((w) => w.toWalletData()));
+  }
+
+  private async getAll(): Promise<ConcreteWallet[]> {
+    const data = await this.storage.get();
+
+    if (data === null) {
+      return [];
+    }
+    return data.map((d) => this.factory.rehydrate(d));
+  }
+}
diff --git a/packages/react/src/wallet/adapters/__helpers__/mocks.ts b/packages/react/src/wallet/adapters/__helpers__/mocks.ts
new file mode 100644
index 0000000000..84e11d11c9
--- /dev/null
+++ b/packages/react/src/wallet/adapters/__helpers__/mocks.ts
@@ -0,0 +1,136 @@
+import { TransactionRequest } from '@ethersproject/providers';
+import { faker } from '@faker-js/faker';
+import { TypedData } from '@lens-protocol/blockchain-bindings';
+import {
+  AnyTransactionRequestModel,
+  ProtocolTransactionRequestModel,
+  UnsignedTransaction,
+  WalletConnectionError,
+} from '@lens-protocol/domain/entities';
+import {
+  mockAnyTransactionRequestModel,
+  mockPollId,
+  mockSignature,
+} from '@lens-protocol/domain/mocks';
+import { ChainType, EvmAddress, Result } from '@lens-protocol/shared-kernel';
+import { mockEvmAddress } from '@lens-protocol/shared-kernel/mocks';
+import { providers } from 'ethers';
+import { mock } from 'jest-mock-extended';
+import { when } from 'jest-when';
+
+import { ITransactionFactory } from '../../../transactions/adapters/ITransactionFactory';
+import {
+  mockSelfFundedProtocolTransactionRequest,
+  mockTypedData,
+} from '../../../transactions/adapters/__helpers__/mocks';
+import {
+  ConcreteWallet,
+  ISignerFactory,
+  ITransactionRequest,
+  SignedVote,
+  UnsignedProtocolCall,
+} from '../ConcreteWallet';
+import { IProviderFactory } from '../IProviderFactory';
+
+export function mockConcreteWallet() {
+  return ConcreteWallet.create(
+    mockEvmAddress(),
+    mock<ISignerFactory>(),
+    mock<ITransactionFactory<AnyTransactionRequestModel>>(),
+  );
+}
+
+class ErrorWithCode<T extends number | string> extends Error {
+  name = 'ErrorWithCode' as const;
+
+  constructor(readonly code: T) {
+    super();
+  }
+}
+
+export function mockErrorWithCode<T extends number | string>(code: T) {
+  return new ErrorWithCode(code);
+}
+
+export function mockUnsignedProtocolCall<T extends ProtocolTransactionRequestModel>({
+  typedData,
+  request,
+}: {
+  typedData: TypedData;
+  request: T;
+}) {
+  return UnsignedProtocolCall.create({
+    id: faker.datatype.uuid(),
+    request,
+    typedData,
+    fallback: mockSelfFundedProtocolTransactionRequest<T>(),
+  });
+}
+
+class MockedUnsignedTransactionRequest<T extends AnyTransactionRequestModel>
+  extends UnsignedTransaction<T>
+  implements ITransactionRequest
+{
+  constructor(chainType: ChainType, request: T, readonly transactionRequest: TransactionRequest) {
+    super(faker.datatype.uuid(), chainType, request);
+  }
+}
+
+export function mockUnsignedTransactionRequest({
+  chainType,
+  txRequest,
+}: {
+  chainType: ChainType;
+  txRequest: TransactionRequest;
+}) {
+  return new MockedUnsignedTransactionRequest(
+    chainType,
+    mockAnyTransactionRequestModel(),
+    txRequest,
+  );
+}
+
+type MockedISignerFactoryConfig = {
+  address: EvmAddress;
+  chainType?: ChainType;
+  signerResult: Result<providers.JsonRpcSigner, WalletConnectionError>;
+};
+
+export function mockISignerFactory({
+  signerResult,
+  ...config
+}: MockedISignerFactoryConfig): ISignerFactory {
+  const factory = mock<ISignerFactory>();
+
+  when(factory.createSigner)
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    .calledWith(expect.objectContaining(config))
+    .mockResolvedValue(signerResult);
+
+  return factory;
+}
+
+export function mockSignedVote(): SignedVote {
+  return new SignedVote(mockPollId(), mockSignature(), mockTypedData(), mockEvmAddress());
+}
+
+type MockedIProviderFactoryConfig = {
+  chainType: ChainType;
+  provider: providers.JsonRpcProvider;
+};
+
+export function mockIProviderFactory({
+  chainType,
+  provider,
+}: MockedIProviderFactoryConfig): IProviderFactory {
+  const factory = mock<IProviderFactory>();
+
+  when(factory.createProvider)
+    .calledWith(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      expect.objectContaining({ chainType }),
+    )
+    .mockResolvedValue(provider);
+
+  return factory;
+}
diff --git a/packages/react/src/wallet/adapters/__tests__/ConcreteWallet.spec.ts b/packages/react/src/wallet/adapters/__tests__/ConcreteWallet.spec.ts
new file mode 100644
index 0000000000..720cb606d7
--- /dev/null
+++ b/packages/react/src/wallet/adapters/__tests__/ConcreteWallet.spec.ts
@@ -0,0 +1,376 @@
+/*
+ * @jest-environment node
+ */
+
+/* eslint-disable @typescript-eslint/unbound-method */
+import {
+  NativeTransaction,
+  UnsignedTransaction,
+  InsufficientGasError,
+  WalletConnectionError,
+  WalletConnectionErrorReason,
+  UserRejectedError,
+  PendingSigningRequestError,
+} from '@lens-protocol/domain/entities';
+import { mockProtocolTransactionRequestModel, mockSignature } from '@lens-protocol/domain/mocks';
+import { ChainType, failure, success } from '@lens-protocol/shared-kernel';
+import { mockEvmAddress } from '@lens-protocol/shared-kernel/mocks';
+import { MockProvider } from 'ethereum-waffle';
+import { errors, providers, utils, Wallet } from 'ethers';
+import { mock } from 'jest-mock-extended';
+import { when } from 'jest-when';
+
+import { UnsignedVote } from '../../../polls/adapters/SnapshotVoteFactory';
+import { mockUnsignedVote } from '../../../polls/adapters/__helpers__/mocks';
+import {
+  mockITransactionFactory,
+  mockTypedData,
+} from '../../../transactions/adapters/__helpers__/mocks';
+import {
+  ConcreteWallet,
+  ISignerFactory,
+  SignedVote,
+  UnsignedProtocolCall,
+} from '../ConcreteWallet';
+import {
+  mockErrorWithCode,
+  mockISignerFactory,
+  mockUnsignedProtocolCall,
+  mockUnsignedTransactionRequest,
+} from '../__helpers__/mocks';
+
+const address = mockEvmAddress();
+const chainType = ChainType.POLYGON;
+
+function setupWalletInstance({ signerFactory }: { signerFactory: ISignerFactory }) {
+  const transactionFactory = mockITransactionFactory();
+  return ConcreteWallet.create(
+    {
+      address,
+    },
+    signerFactory,
+    transactionFactory,
+  );
+}
+
+describe(`Given an instance of ${ConcreteWallet.name}`, () => {
+  describe(`when signing an ${UnsignedProtocolCall.name}`, () => {
+    const typedData = mockTypedData();
+    const request = mockProtocolTransactionRequestModel();
+    const unsignedCall = mockUnsignedProtocolCall({ typedData, request });
+    const signature = mockSignature();
+
+    it(`should resolve with a ISignedProtocolCall instance`, async () => {
+      const signer = mock<providers.JsonRpcSigner>();
+      when(signer._signTypedData)
+        .calledWith(typedData.domain, typedData.types, typedData.message)
+        .mockResolvedValue(signature);
+
+      const signerFactory = mockISignerFactory({
+        address,
+        chainType: ChainType.POLYGON,
+        signerResult: success(signer),
+      });
+
+      const wallet = setupWalletInstance({ signerFactory });
+      const result = await wallet.signProtocolCall(unsignedCall);
+
+      expect(result.unwrap()).toEqual({
+        id: unsignedCall.id,
+        nonce: unsignedCall.nonce,
+        request,
+        signature,
+        fallback: unsignedCall.fallback,
+      });
+    });
+
+    it(`should fail with ${PendingSigningRequestError.name} in case of existing signing request`, async () => {
+      const signer = mock<providers.JsonRpcSigner>();
+      when(signer._signTypedData)
+        .calledWith(typedData.domain, typedData.types, typedData.message)
+        .mockResolvedValue(signature);
+
+      const signerFactory = mockISignerFactory({
+        address,
+        signerResult: success(signer),
+      });
+
+      const wallet = setupWalletInstance({ signerFactory });
+
+      void wallet.signProtocolCall(unsignedCall); // previous signing request
+      const result = await wallet.signProtocolCall(unsignedCall);
+
+      expect(() => result.unwrap()).toThrow(PendingSigningRequestError);
+    });
+
+    it(`should fail with ${UserRejectedError.name} in case the user refuse the operation`, async () => {
+      const signer = mock<providers.JsonRpcSigner>();
+      when(signer._signTypedData).mockRejectedValue(mockErrorWithCode(errors.ACTION_REJECTED));
+
+      const signerFactory = mockISignerFactory({
+        address,
+        signerResult: success(signer),
+      });
+
+      const wallet = setupWalletInstance({ signerFactory });
+      const result = await wallet.signProtocolCall(unsignedCall);
+
+      expect(() => result.unwrap()).toThrow(UserRejectedError);
+    });
+
+    it(`should forward any ${WalletConnectionError.name}`, async () => {
+      const error = new WalletConnectionError(WalletConnectionErrorReason.INCORRECT_CHAIN);
+      const signerFactory = mockISignerFactory({
+        address,
+        signerResult: failure(error),
+      });
+
+      const wallet = setupWalletInstance({ signerFactory });
+      const result = await wallet.signProtocolCall(unsignedCall);
+
+      expect(() => result.unwrap()).toThrow(error);
+    });
+  });
+
+  describe('when signing a message', () => {
+    const message = 'Sign this message from backend';
+    const signature = mockSignature();
+
+    it(`should use the user's wallet to sign the message and return the signature`, async () => {
+      const signer = mock<providers.JsonRpcSigner>();
+      when(signer.signMessage).calledWith(message).mockResolvedValue(signature);
+
+      const signerFactory = mockISignerFactory({
+        address,
+        signerResult: success(signer),
+      });
+      const wallet = setupWalletInstance({ signerFactory });
+
+      const result = await wallet.signMessage(message);
+
+      expect(signer.signMessage).toHaveBeenCalledWith(message);
+      expect(result.unwrap()).toBe(signature);
+    });
+
+    it(`should fail with ${PendingSigningRequestError.name} in case of existing signing request`, async () => {
+      const signer = mock<providers.JsonRpcSigner>();
+      when(signer.signMessage).calledWith(message).mockResolvedValue(signature);
+
+      const signerFactory = mockISignerFactory({
+        address,
+        signerResult: success(signer),
+      });
+      const wallet = setupWalletInstance({ signerFactory });
+
+      void wallet.signMessage(message); // previous signing request
+      const result = await wallet.signMessage(message);
+
+      expect(() => result.unwrap()).toThrow(PendingSigningRequestError);
+    });
+
+    it(`should fail with ${UserRejectedError.name} if the user cancels the challenge message signing`, async () => {
+      const signer = mock<providers.JsonRpcSigner>();
+      when(signer.signMessage)
+        .calledWith(message)
+        .mockRejectedValue(mockErrorWithCode(errors.ACTION_REJECTED));
+
+      const signerFactory = mockISignerFactory({
+        address,
+        signerResult: success(signer),
+      });
+      const wallet = setupWalletInstance({ signerFactory });
+
+      const result = await wallet.signMessage(message);
+
+      expect(() => result.unwrap()).toThrow(UserRejectedError);
+    });
+  });
+
+  describe(`when sending a ${UnsignedTransaction.name}`, () => {
+    it(`should:
+        - use the user's wallet to sign and send the transaction
+        - resolve with with a ${NativeTransaction.name}`, async () => {
+      const provider = new MockProvider();
+      const [sender, receiver] = provider.getWallets() as [Wallet, Wallet];
+      const txRequest = await sender.populateTransaction({
+        from: sender.address,
+        to: receiver.address,
+        value: utils.parseEther('1'),
+      });
+      const signerFactory = mockISignerFactory({
+        address,
+        chainType,
+        signerResult: success(provider.getSigner()),
+      });
+      const wallet = setupWalletInstance({ signerFactory });
+      const receiverBalanceBefore = await receiver.getBalance();
+
+      const unsignedTransaction = mockUnsignedTransactionRequest({ chainType, txRequest });
+      const result = await wallet.sendTransaction(unsignedTransaction);
+
+      const receiverBalanceAfter = await receiver.getBalance();
+      expect(receiverBalanceAfter.gt(receiverBalanceBefore)).toBe(true);
+
+      expect(result.unwrap()).toBeInstanceOf(NativeTransaction);
+      expect(result.unwrap()).toEqual(
+        expect.objectContaining({
+          chainType,
+          hash: expect.any(String),
+          id: unsignedTransaction.id,
+          request: unsignedTransaction.request,
+        }),
+      );
+    }, 15_000);
+
+    it(`should fail with ${PendingSigningRequestError.name} in case of existing signing request`, async () => {
+      const provider = new MockProvider();
+      const [sender, receiver] = provider.getWallets() as [Wallet, Wallet];
+      const txRequest = await sender.populateTransaction({
+        from: sender.address,
+        to: receiver.address,
+        value: utils.parseEther('1'),
+      });
+      const signerFactory = mockISignerFactory({
+        address,
+        chainType,
+        signerResult: success(provider.getSigner()),
+      });
+      const wallet = setupWalletInstance({ signerFactory });
+
+      const unsignedTransaction = mockUnsignedTransactionRequest({ chainType, txRequest });
+      void wallet.sendTransaction(unsignedTransaction); // previous signing request
+      const result = await wallet.sendTransaction(unsignedTransaction);
+
+      expect(() => result.unwrap()).toThrow(PendingSigningRequestError);
+    });
+
+    it(`should fail with ${InsufficientGasError.name} in case the wallet does not have enough Matic/Ether`, async () => {
+      const signer = mock<providers.JsonRpcSigner>();
+      when(signer.sendTransaction).mockRejectedValue(mockErrorWithCode(errors.INSUFFICIENT_FUNDS));
+
+      const signerFactory = mockISignerFactory({
+        address,
+        chainType,
+        signerResult: success(signer),
+      });
+      const wallet = setupWalletInstance({ signerFactory });
+
+      const unsignedTransaction = mockUnsignedTransactionRequest({ chainType, txRequest: {} });
+      const result = await wallet.sendTransaction(unsignedTransaction);
+
+      expect(() => result.unwrap()).toThrow(InsufficientGasError);
+    });
+
+    it(`should fail with ${UserRejectedError.name} in case the user refuse the operation`, async () => {
+      const signer = mock<providers.JsonRpcSigner>();
+
+      when(signer.sendTransaction).mockRejectedValue(mockErrorWithCode(errors.ACTION_REJECTED));
+
+      const signerFactory = mockISignerFactory({
+        address,
+        chainType,
+        signerResult: success(signer),
+      });
+      const wallet = setupWalletInstance({ signerFactory });
+
+      const unsignedTransaction = mockUnsignedTransactionRequest({
+        chainType,
+        txRequest: {},
+      });
+      const result = await wallet.sendTransaction(unsignedTransaction);
+
+      expect(() => result.unwrap()).toThrow(UserRejectedError);
+    });
+
+    it(`should fail with ${WalletConnectionError.name} in case the ISignerFactory fails with it`, async () => {
+      const signerFactory = mockISignerFactory({
+        address,
+        chainType,
+        signerResult: failure(
+          new WalletConnectionError(WalletConnectionErrorReason.INCORRECT_CHAIN),
+        ),
+      });
+      const wallet = setupWalletInstance({ signerFactory });
+
+      const unsignedTransaction = mockUnsignedTransactionRequest({
+        chainType,
+        txRequest: {},
+      });
+      const result = await wallet.sendTransaction(unsignedTransaction);
+
+      expect(() => result.unwrap()).toThrow(WalletConnectionError);
+    });
+  });
+
+  describe(`when signing a ${UnsignedVote.name}`, () => {
+    const typedData = mockTypedData();
+    const unsignedVote = mockUnsignedVote({ typedData });
+    const signature = mockSignature();
+
+    it(`should use the user's wallet to sign the message and return the ${SignedVote.name}`, async () => {
+      const signer = mock<providers.JsonRpcSigner>();
+      when(signer._signTypedData)
+        .calledWith(typedData.domain, typedData.types, typedData.message)
+        .mockResolvedValue(signature);
+
+      const signerFactory = mockISignerFactory({
+        address,
+        signerResult: success(signer),
+      });
+
+      const wallet = setupWalletInstance({ signerFactory });
+      const result = await wallet.signVote(unsignedVote);
+
+      expect(result.unwrap()).toBeInstanceOf(SignedVote);
+      expect(result.unwrap()).toEqual({
+        pollId: unsignedVote.pollId,
+        data: unsignedVote.typedData,
+        signature,
+        voter: address,
+      });
+    });
+
+    it(`should fail with ${PendingSigningRequestError.name} in case of existing signing request`, async () => {
+      const signer = mock<providers.JsonRpcSigner>();
+      when(signer._signTypedData).mockResolvedValue(signature);
+
+      const signerFactory = mockISignerFactory({
+        address,
+        signerResult: success(signer),
+      });
+      const wallet = setupWalletInstance({ signerFactory });
+
+      void wallet.signVote(unsignedVote);
+      const result = await wallet.signVote(unsignedVote);
+
+      expect(() => result.unwrap()).toThrow(PendingSigningRequestError);
+    });
+
+    it(`should fail with ${UserRejectedError.name} if the user cancels the challenge message signing`, async () => {
+      const signer = mock<providers.JsonRpcSigner>();
+      when(signer._signTypedData).mockRejectedValue(mockErrorWithCode(errors.ACTION_REJECTED));
+
+      const signerFactory = mockISignerFactory({
+        address,
+        signerResult: success(signer),
+      });
+      const wallet = setupWalletInstance({ signerFactory });
+
+      const result = await wallet.signVote(unsignedVote);
+
+      expect(() => result.unwrap()).toThrow(UserRejectedError);
+    });
+
+    it(`should fail with ${WalletConnectionError.name} in case the ISignerFactory fails with it`, async () => {
+      const signerFactory = mockISignerFactory({
+        address,
+        signerResult: failure(new WalletConnectionError(WalletConnectionErrorReason.WRONG_ACCOUNT)),
+      });
+      const wallet = setupWalletInstance({ signerFactory });
+
+      const result = await wallet.signVote(unsignedVote);
+
+      expect(() => result.unwrap()).toThrow(WalletConnectionError);
+    });
+  });
+});
diff --git a/packages/react/src/wallet/adapters/__tests__/WalletGateway.spec.ts b/packages/react/src/wallet/adapters/__tests__/WalletGateway.spec.ts
new file mode 100644
index 0000000000..44ba892e17
--- /dev/null
+++ b/packages/react/src/wallet/adapters/__tests__/WalletGateway.spec.ts
@@ -0,0 +1,74 @@
+import { Wallet } from '@lens-protocol/domain/entities';
+import { IStorage } from '@lens-protocol/storage';
+import { mockStorage } from '@lens-protocol/storage/mocks';
+import { mock } from 'jest-mock-extended';
+
+import { mockITransactionFactory } from '../../../transactions/adapters/__helpers__/mocks';
+import { ISignerFactory } from '../ConcreteWallet';
+import { WalletFactory } from '../WalletFactory';
+import { WalletGateway, WalletStorageSchema } from '../WalletGateway';
+import { mockConcreteWallet } from '../__helpers__/mocks';
+
+function setupWalletGateway({ storage }: { storage: IStorage<WalletStorageSchema> }) {
+  const signerFactory = mock<ISignerFactory>();
+  const transactionFactory = mockITransactionFactory();
+  const walletFactory = new WalletFactory(signerFactory, transactionFactory);
+  return new WalletGateway(storage, walletFactory);
+}
+
+describe(`Given an instance of the ${WalletGateway.name}`, () => {
+  describe(`when "${WalletGateway.prototype.getByAddress.name}" method is invoked`, () => {
+    it(`should retrieve the ${Wallet.name} instance by address`, async () => {
+      const wallet1 = mockConcreteWallet();
+      const wallet2 = mockConcreteWallet();
+      const storage = mockStorage<WalletStorageSchema>([wallet1, wallet2]);
+
+      const gateway = setupWalletGateway({ storage });
+
+      const actual = await gateway.getByAddress(wallet2.address);
+
+      expect(actual).toBeInstanceOf(Wallet);
+      expect(actual?.address).toEqual(wallet2.address);
+    });
+
+    it(`should cache the ${Wallet.name} instance in an in-memory cache for subsequent calls`, async () => {
+      const wallet1 = mockConcreteWallet();
+      const wallet2 = mockConcreteWallet();
+      const storage = mockStorage<WalletStorageSchema>([wallet1, wallet2]);
+
+      const gateway = setupWalletGateway({ storage });
+
+      expect(await gateway.getByAddress(wallet2.address)).toBe(
+        await gateway.getByAddress(wallet2.address),
+      );
+    });
+  });
+
+  describe(`when "${WalletGateway.prototype.reset.name}" method is invoked`, () => {
+    it(`should remove all the ${Wallet.name} entities from the underlying storage provider`, async () => {
+      const wallet1 = mockConcreteWallet();
+      const wallet2 = mockConcreteWallet();
+      const storage = mockStorage<WalletStorageSchema>([wallet1, wallet2]);
+
+      const gateway = setupWalletGateway({ storage });
+
+      await gateway.reset();
+
+      expect(await gateway.getByAddress(wallet1.address)).toBeNull();
+      expect(await gateway.getByAddress(wallet2.address)).toBeNull();
+    });
+  });
+
+  describe(`when "${WalletGateway.prototype.save.name}" method is invoked`, () => {
+    it(`should cache the ${Wallet.name} instance in an in-memory cache to support subsequent reads`, async () => {
+      const newWallet = mockConcreteWallet();
+      const storage = mockStorage<WalletStorageSchema>([]);
+
+      const gateway = setupWalletGateway({ storage });
+
+      await gateway.save(newWallet);
+
+      expect(await gateway.getByAddress(newWallet.address)).toBe(newWallet);
+    });
+  });
+});
diff --git a/packages/react/src/wallet/adapters/errors.ts b/packages/react/src/wallet/adapters/errors.ts
new file mode 100644
index 0000000000..07b4af8931
--- /dev/null
+++ b/packages/react/src/wallet/adapters/errors.ts
@@ -0,0 +1,11 @@
+type ErrorShape<T> = {
+  code: T;
+  message: string;
+  stack: string;
+};
+
+export function assertErrorObjectWithCode<T>(error: unknown): asserts error is ErrorShape<T> {
+  if (!Object.prototype.hasOwnProperty.call(error, 'code')) {
+    throw error;
+  }
+}
diff --git a/packages/react/src/wallet/infrastructure/ProviderFactory.ts b/packages/react/src/wallet/infrastructure/ProviderFactory.ts
new file mode 100644
index 0000000000..ab45116891
--- /dev/null
+++ b/packages/react/src/wallet/infrastructure/ProviderFactory.ts
@@ -0,0 +1,32 @@
+import { ChainType, invariant, never } from '@lens-protocol/shared-kernel';
+import { providers } from 'ethers';
+
+import { ChainConfigRegistry } from '../../chains';
+import { IProviderFactory } from '../adapters/IProviderFactory';
+
+export type GetProvider = (config: { chainId: number }) => Promise<providers.JsonRpcProvider>;
+
+export interface IProviderBinding {
+  getProvider: GetProvider;
+}
+
+export class ProviderFactory implements IProviderFactory {
+  constructor(
+    private readonly bindings: IProviderBinding,
+    private readonly chains: ChainConfigRegistry,
+  ) {}
+
+  async createProvider(config: { chainType: ChainType }): Promise<providers.JsonRpcProvider> {
+    const chainId = this.chains[config.chainType]?.chainId ?? never('Unable to determine chainId');
+    const provider = await this.bindings.getProvider({ chainId });
+
+    const network = await provider.getNetwork();
+
+    invariant(
+      network.chainId === chainId,
+      `Invalid chainId. Expected ${chainId} but got ${network.chainId}`,
+    );
+
+    return provider;
+  }
+}
diff --git a/packages/react/src/wallet/infrastructure/SignerFactory.ts b/packages/react/src/wallet/infrastructure/SignerFactory.ts
new file mode 100644
index 0000000000..4e407dcc65
--- /dev/null
+++ b/packages/react/src/wallet/infrastructure/SignerFactory.ts
@@ -0,0 +1,109 @@
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { AddEthereumChainParameter, isTheSameAddress } from '@lens-protocol/blockchain-bindings';
+import { WalletConnectionError, WalletConnectionErrorReason } from '@lens-protocol/domain/entities';
+import { ChainType, failure, PromiseResult, success } from '@lens-protocol/shared-kernel';
+import { errors, utils } from 'ethers';
+
+import { ChainConfigRegistry } from '../../chains';
+import { CreateSignerConfig, ISignerFactory, RequiredSigner } from '../adapters/ConcreteWallet';
+import { assertErrorObjectWithCode } from '../adapters/errors';
+
+export type GetSigner = (config: { chainId?: number }) => Promise<RequiredSigner>;
+
+export interface ISignerBinding {
+  getSigner: GetSigner;
+}
+
+export type SignerFactoryConfig = {
+  getSigner: GetSigner;
+  chains: ChainConfigRegistry;
+};
+
+export class SignerFactory implements ISignerFactory {
+  constructor(
+    private readonly bindings: ISignerBinding,
+    private readonly chains: ChainConfigRegistry,
+  ) {}
+
+  async createSigner({
+    address,
+    chainType,
+  }: CreateSignerConfig): PromiseResult<RequiredSigner, WalletConnectionError> {
+    const chainId = chainType ? this.chains[chainType].chainId : undefined;
+    const signer = await this.bindings.getSigner({ chainId });
+
+    const signerAddress = await signer.getAddress();
+
+    if (!isTheSameAddress(address, signerAddress)) {
+      return failure(new WalletConnectionError(WalletConnectionErrorReason.WRONG_ACCOUNT));
+    }
+
+    if (chainType) {
+      try {
+        const signerChainId = await signer.getChainId();
+        if (signerChainId !== chainId) {
+          const chainConfig = this.createAddEthereumChainParameter(chainType);
+
+          await this.addChain(signer, chainConfig);
+
+          const result = await this.switchChain(signer, chainConfig);
+
+          if (result.isFailure()) {
+            return failure(result.error);
+          }
+        }
+      } catch (err) {
+        assertErrorObjectWithCode<errors>(err);
+
+        if (err.code === errors.UNSUPPORTED_OPERATION) {
+          return failure(new WalletConnectionError(WalletConnectionErrorReason.INCORRECT_CHAIN));
+        }
+      }
+    }
+    return success(signer);
+  }
+
+  private createAddEthereumChainParameter(chainType: ChainType): AddEthereumChainParameter {
+    const chainConfig = this.chains[chainType];
+    return {
+      chainId: utils.hexValue(chainConfig.chainId),
+      chainName: chainConfig.name,
+      nativeCurrency: {
+        name: chainConfig.nativeCurrency.name,
+        symbol: chainConfig.nativeCurrency.symbol,
+        decimals: chainConfig.nativeCurrency.decimals,
+      },
+      rpcUrls: [chainConfig.rpcUrl],
+      blockExplorerUrls: [chainConfig.blockExplorer],
+    };
+  }
+
+  private async addChain(signer: RequiredSigner, chainConfig: AddEthereumChainParameter) {
+    try {
+      if (signer.provider && signer.provider instanceof JsonRpcProvider) {
+        await signer.provider.send('wallet_addEthereumChain', [chainConfig]);
+      }
+    } catch {
+      // noop
+    }
+  }
+
+  private async switchChain(
+    signer: RequiredSigner,
+    chainConfig: AddEthereumChainParameter,
+  ): PromiseResult<void, WalletConnectionError> {
+    try {
+      if (signer.provider && signer.provider instanceof JsonRpcProvider) {
+        await signer.provider.send('wallet_switchEthereumChain', [
+          { chainId: utils.hexValue(chainConfig.chainId) },
+        ]);
+
+        return success();
+      }
+    } catch {
+      // noop
+    }
+
+    return failure(new WalletConnectionError(WalletConnectionErrorReason.INCORRECT_CHAIN));
+  }
+}
diff --git a/packages/react/src/wallet/infrastructure/WalletStorage.ts b/packages/react/src/wallet/infrastructure/WalletStorage.ts
new file mode 100644
index 0000000000..f6eccc75ea
--- /dev/null
+++ b/packages/react/src/wallet/infrastructure/WalletStorage.ts
@@ -0,0 +1,11 @@
+import { BaseStorageSchema, IStorageProvider, Storage } from '@lens-protocol/storage';
+
+import { WalletStorageSchema } from '../adapters/WalletGateway';
+
+export function createWalletStorage(storageProvider: IStorageProvider, namespace: string) {
+  const walletStorageDataSchema = new BaseStorageSchema(
+    `lens.${namespace}.wallets`,
+    WalletStorageSchema,
+  );
+  return Storage.createForSchema(walletStorageDataSchema, storageProvider);
+}
diff --git a/packages/react/src/wallet/infrastructure/__helpers__/mocks.ts b/packages/react/src/wallet/infrastructure/__helpers__/mocks.ts
new file mode 100644
index 0000000000..df16040a1f
--- /dev/null
+++ b/packages/react/src/wallet/infrastructure/__helpers__/mocks.ts
@@ -0,0 +1,36 @@
+import { Networkish } from '@ethersproject/providers';
+import { ChainType } from '@lens-protocol/shared-kernel';
+import { providers } from 'ethers';
+import { mock } from 'jest-mock-extended';
+import { when } from 'jest-when';
+
+import { production } from '../../../environments';
+import { RequiredSigner } from '../../../wallet/adapters/ConcreteWallet';
+import { ISignerBinding } from '../SignerFactory';
+
+export class VoidJsonRpcProvider extends providers.JsonRpcProvider {
+  constructor(network: Networkish) {
+    super('', network);
+    this.send = jest.fn();
+  }
+}
+
+export function mockISignerBinding({
+  chainType,
+  signer,
+}: {
+  chainType?: ChainType;
+  signer: RequiredSigner;
+}): ISignerBinding {
+  const bindings = mock<ISignerBinding>();
+
+  if (chainType) {
+    when(bindings.getSigner)
+      .calledWith({ chainId: production.chains[chainType].chainId })
+      .mockResolvedValue(signer);
+  } else {
+    when(bindings.getSigner).mockResolvedValue(signer);
+  }
+
+  return bindings;
+}
diff --git a/packages/react/src/wallet/infrastructure/__tests__/ProviderFactory.spec.ts b/packages/react/src/wallet/infrastructure/__tests__/ProviderFactory.spec.ts
new file mode 100644
index 0000000000..174bdcf476
--- /dev/null
+++ b/packages/react/src/wallet/infrastructure/__tests__/ProviderFactory.spec.ts
@@ -0,0 +1,58 @@
+import { ChainType, InvariantError } from '@lens-protocol/shared-kernel';
+import { providers, utils } from 'ethers';
+import { mock } from 'jest-mock-extended';
+import { when } from 'jest-when';
+
+import { production } from '../../../environments';
+import { IProviderBinding, ProviderFactory } from '../ProviderFactory';
+import { VoidJsonRpcProvider } from '../__helpers__/mocks';
+
+function setupTestScenario({
+  provider,
+  chainType,
+}: {
+  provider: providers.JsonRpcProvider;
+  chainType: ChainType;
+}) {
+  const bindings = mock<IProviderBinding>();
+
+  when(bindings.getProvider)
+    .calledWith({ chainId: production.chains[chainType].chainId })
+    .mockResolvedValue(provider);
+
+  const providerFactory = new ProviderFactory(bindings, production.chains);
+
+  return { providerFactory };
+}
+
+describe(`Given an instance of the ${ProviderFactory.name}`, () => {
+  describe(`when invoking the ${ProviderFactory.prototype.createProvider.name} method`, () => {
+    const chainType = ChainType.POLYGON;
+
+    it('should retrieve the signer via the ISignerBinding', async () => {
+      const provider = new VoidJsonRpcProvider('matic');
+      const { providerFactory } = setupTestScenario({ provider, chainType });
+
+      when(provider.send)
+        .calledWith('eth_chainId', [])
+        .mockResolvedValue(utils.hexlify(production.chains[chainType].chainId));
+
+      const result = await providerFactory.createProvider({ chainType });
+
+      expect(result).toBe(provider);
+    });
+
+    it(`should throw an ${InvariantError.name} in case the provider is not connected to the desired chain`, async () => {
+      const provider = new VoidJsonRpcProvider('homestead');
+      const { providerFactory } = setupTestScenario({ provider, chainType });
+
+      when(provider.send)
+        .calledWith('eth_chainId', [])
+        .mockResolvedValue(utils.hexlify(production.chains[ChainType.ETHEREUM].chainId));
+
+      await expect(providerFactory.createProvider({ chainType })).rejects.toThrowError(
+        InvariantError,
+      );
+    });
+  });
+});
diff --git a/packages/react/src/wallet/infrastructure/__tests__/SignerFactory.spec.ts b/packages/react/src/wallet/infrastructure/__tests__/SignerFactory.spec.ts
new file mode 100644
index 0000000000..f12a7063f1
--- /dev/null
+++ b/packages/react/src/wallet/infrastructure/__tests__/SignerFactory.spec.ts
@@ -0,0 +1,156 @@
+import { WalletConnectionError, WalletConnectionErrorReason } from '@lens-protocol/domain/entities';
+import { ChainType } from '@lens-protocol/shared-kernel';
+import { mockEvmAddress } from '@lens-protocol/shared-kernel/mocks';
+import { errors, Wallet, logger, providers, utils, VoidSigner } from 'ethers';
+import { when } from 'jest-when';
+
+import { production } from '../../../environments';
+import { RequiredSigner } from '../../adapters/ConcreteWallet';
+import { SignerFactory } from '../SignerFactory';
+import { mockISignerBinding, VoidJsonRpcProvider } from '../__helpers__/mocks';
+
+const address = mockEvmAddress();
+
+function setupTestScenario({
+  signer,
+  chainType,
+}: {
+  signer: RequiredSigner;
+  chainType?: ChainType;
+}) {
+  const bindings = mockISignerBinding({ chainType, signer });
+
+  const signerFactory = new SignerFactory(bindings, production.chains);
+
+  return { signerFactory };
+}
+
+class VoidSignerWithJsonRpcProvider extends VoidSigner implements RequiredSigner {
+  declare provider: providers.JsonRpcProvider;
+
+  constructor(
+    address: string,
+    provider: providers.JsonRpcProvider = new VoidJsonRpcProvider('homestead'),
+  ) {
+    super(address, provider);
+  }
+}
+
+describe(`Given an instance of the ${SignerFactory.name}`, () => {
+  describe(`when invoking the ${SignerFactory.prototype.createSigner.name} method`, () => {
+    it('should retrieve the signer via the ISignerBinding', async () => {
+      const signer = new VoidSignerWithJsonRpcProvider(address);
+      const { signerFactory } = setupTestScenario({ signer });
+
+      const result = await signerFactory.createSigner({ address });
+
+      expect(result.unwrap()).toBe(signer);
+    });
+
+    it(`should fail with ${WalletConnectionError.name}(${WalletConnectionErrorReason.WRONG_ACCOUNT}) in case of address mismatch`, async () => {
+      const signer = new VoidSignerWithJsonRpcProvider(mockEvmAddress());
+      const { signerFactory } = setupTestScenario({ signer });
+
+      const result = await signerFactory.createSigner({ address });
+
+      const error = new WalletConnectionError(WalletConnectionErrorReason.WRONG_ACCOUNT);
+      expect(() => result.unwrap()).toThrowError(error);
+    });
+
+    describe('with a specified chain', () => {
+      const chainType = ChainType.POLYGON;
+
+      it('should add the desired chain configuration in a best effort fashion', async () => {
+        const provider = new VoidJsonRpcProvider('homestead');
+        const signer = new VoidSignerWithJsonRpcProvider(address, provider);
+        const { signerFactory } = setupTestScenario({ signer, chainType });
+
+        when(provider.send)
+          .calledWith('eth_chainId', [])
+          .mockResolvedValue(utils.hexlify(production.chains[ChainType.ETHEREUM].chainId))
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+          .calledWith('wallet_addEthereumChain', expect.anything())
+          .mockRejectedValue(logger.makeError('Not implemented', errors.NOT_IMPLEMENTED, {}));
+
+        await signerFactory.createSigner({ address, chainType });
+
+        expect(provider.send).toBeCalledWith('wallet_addEthereumChain', [
+          expect.objectContaining({
+            chainId: utils.hexlify(production.chains[chainType].chainId),
+          }),
+        ]);
+      });
+
+      it('should switch to the desired chain', async () => {
+        const provider = new VoidJsonRpcProvider('homestead');
+        const signer = new VoidSignerWithJsonRpcProvider(address, provider);
+        const { signerFactory } = setupTestScenario({ signer, chainType });
+
+        when(provider.send)
+          .calledWith('eth_chainId', [])
+          .mockResolvedValue(utils.hexlify(production.chains[ChainType.ETHEREUM].chainId));
+
+        await signerFactory.createSigner({ address, chainType });
+
+        expect(provider.send).toBeCalledWith('wallet_switchEthereumChain', [
+          {
+            chainId: utils.hexlify(production.chains[chainType].chainId),
+          },
+        ]);
+      });
+
+      it(`should fail with ${WalletConnectionError.name}(${WalletConnectionErrorReason.INCORRECT_CHAIN}) in case it fails to switch to the desired chain`, async () => {
+        const provider = new VoidJsonRpcProvider('homestead');
+        const signer = new VoidSignerWithJsonRpcProvider(address, provider);
+        const { signerFactory } = setupTestScenario({ signer, chainType });
+
+        when(provider.send)
+          .calledWith('eth_chainId', [])
+          .mockResolvedValue(utils.hexlify(production.chains[ChainType.ETHEREUM].chainId))
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+          .calledWith('wallet_switchEthereumChain', expect.anything())
+          .mockRejectedValue(logger.makeError('Not implemented', errors.NOT_IMPLEMENTED, {}));
+
+        const result = await signerFactory.createSigner({ address, chainType });
+
+        const error = new WalletConnectionError(WalletConnectionErrorReason.INCORRECT_CHAIN);
+        expect(() => result.unwrap()).toThrowError(error);
+      });
+    });
+
+    describe('with a wallet address', () => {
+      // This is the private key of the `@jsisthebest.test` profile
+      // It's a public private key so anyone can modify the profile
+      // For your own convenience change to the private key of a new wallet
+      const testWalletPrivateKey =
+        '6c434da5e5c0e3a8e0db5cf835d23e04c7592037854f0700c26836be7581c68c';
+
+      it('should retrieve the signer', async () => {
+        const wallet = new Wallet(testWalletPrivateKey);
+
+        const { signerFactory } = setupTestScenario({ signer: wallet });
+
+        const result = await signerFactory.createSigner({ address: wallet.address });
+
+        expect(result.unwrap()).toBe(wallet);
+      });
+
+      it(`should fail with ${WalletConnectionError.name}(${WalletConnectionErrorReason.INCORRECT_CHAIN}) since it cannot switch chains`, async () => {
+        const wallet = new Wallet(testWalletPrivateKey);
+
+        const { signerFactory } = setupTestScenario({
+          signer: wallet,
+          chainType: ChainType.POLYGON,
+        });
+
+        const result = await signerFactory.createSigner({
+          address: wallet.address,
+          chainType: ChainType.POLYGON,
+        });
+
+        const error = new WalletConnectionError(WalletConnectionErrorReason.INCORRECT_CHAIN);
+        expect(() => result.unwrap()).toThrowError(error);
+      });
+    });
+  });
+});