diff --git a/cspell-config/cspell-misc.txt b/cspell-config/cspell-misc.txt
index 4890947e..b7033af1 100644
--- a/cspell-config/cspell-misc.txt
+++ b/cspell-config/cspell-misc.txt
@@ -9,6 +9,7 @@ Nuxt
 nuxtjs
 testid
 vueuse
+ethereum
 
 // examples/bank-demo
 ctap
@@ -25,4 +26,3 @@ usdc
 // examples/nft-quest
 Fren
 fren
-trxn
diff --git a/examples/demo-app/pages/index.vue b/examples/demo-app/pages/index.vue
index 5e98fca0..0cb77221 100644
--- a/examples/demo-app/pages/index.vue
+++ b/examples/demo-app/pages/index.vue
@@ -40,7 +40,7 @@
 </template>
 
 <script lang="ts" setup>
-import { disconnect, getBalance, watchAccount, sendTransaction, createConfig, connect, reconnect, type GetBalanceReturnType } from "@wagmi/core";
+import { disconnect, getBalance, watchAccount, sendTransaction, createConfig, connect, reconnect, waitForTransactionReceipt, type GetBalanceReturnType } from "@wagmi/core";
 import { zksyncSsoConnector } from "zksync-sso/connector";
 import { zksyncInMemoryNode } from "@wagmi/core/chains";
 import { createWalletClient, http, parseEther, type Address } from "viem";
@@ -142,15 +142,17 @@ const sendTokens = async () => {
   errorMessage.value = "";
   isSendingEth.value = true;
   try {
-    await sendTransaction(wagmiConfig, {
+    const transactionHash = await sendTransaction(wagmiConfig, {
       to: testTransferTarget,
       value: parseEther("0.1"),
-      gas: 100_000_000n,
     });
 
     balance.value = await getBalance(wagmiConfig, {
       address: address.value,
     });
+
+    const receipt = await waitForTransactionReceipt(wagmiConfig, { hash: transactionHash });
+    if (receipt.status === "reverted") throw new Error("Transaction reverted");
   } catch (error) {
     // eslint-disable-next-line no-console
     console.error("Transaction failed:", error);
diff --git a/examples/nft-quest/composables/useMintNft.ts b/examples/nft-quest/composables/useMintNft.ts
index 9848c642..bd630811 100644
--- a/examples/nft-quest/composables/useMintNft.ts
+++ b/examples/nft-quest/composables/useMintNft.ts
@@ -1,5 +1,5 @@
-import { estimateGas, waitForTransactionReceipt, writeContract } from "@wagmi/core";
-import { type Address, encodeFunctionData } from "viem";
+import { waitForTransactionReceipt, writeContract } from "@wagmi/core";
+import type { Address } from "viem";
 import { getGeneralPaymasterInput } from "viem/zksync";
 
 export const useMintNft = async (_address: MaybeRef<Address>) => {
@@ -10,24 +10,11 @@ export const useMintNft = async (_address: MaybeRef<Address>) => {
     const { wagmiConfig } = storeToRefs(useConnectorStore());
 
     const mintingForAddress = address.value;
-    const data = encodeFunctionData({
-      abi: nftAbi,
-      functionName: "mint",
-      args: [address.value],
-    });
-
-    const estimatedGas = await estimateGas(wagmiConfig.value, {
-      to: runtimeConfig.public.contracts.nft as Address,
-      chainId: runtimeConfig.public.chain.id,
-      data,
-    });
-
     const transactionHash = await writeContract(wagmiConfig.value, {
       address: runtimeConfig.public.contracts.nft as Address,
       abi: nftAbi,
       functionName: "mint",
       args: [mintingForAddress],
-      gas: estimatedGas + (estimatedGas / 100n * 25n), // gas may be underestimated
       paymaster: runtimeConfig.public.contracts.paymaster as Address,
       paymasterInput: getGeneralPaymasterInput({ innerInput: "0x" }),
     });
diff --git a/examples/nft-quest/nuxt.config.ts b/examples/nft-quest/nuxt.config.ts
index 55129665..f810e018 100644
--- a/examples/nft-quest/nuxt.config.ts
+++ b/examples/nft-quest/nuxt.config.ts
@@ -102,4 +102,14 @@ export default defineNuxtConfig({
       },
     },
   },
+
+  vite: {
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: "modern", // Fix warning: "The legacy JS API is deprecated and will be removed in Dart Sass 2.0.0"
+        },
+      },
+    },
+  },
 });
diff --git a/packages/auth-server/nuxt.config.ts b/packages/auth-server/nuxt.config.ts
index c3d19925..478fa029 100644
--- a/packages/auth-server/nuxt.config.ts
+++ b/packages/auth-server/nuxt.config.ts
@@ -57,4 +57,14 @@ export default defineNuxtConfig({
       chainId: parseInt(process.env.NUXT_PUBLIC_DEFAULT_CHAIN_ID || "") || zksyncInMemoryNode.id,
     },
   },
+
+  vite: {
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: "modern", // Fix warning: "The legacy JS API is deprecated and will be removed in Dart Sass 2.0.0"
+        },
+      },
+    },
+  },
 });
diff --git a/packages/contracts/test/PasskeyModule.ts b/packages/contracts/test/PasskeyModule.ts
index bb877c27..a7a45fae 100644
--- a/packages/contracts/test/PasskeyModule.ts
+++ b/packages/contracts/test/PasskeyModule.ts
@@ -220,9 +220,6 @@ async function rawVerify(
   const hashedData = await toHash(concat([authDataBuffer, clientDataHash]));
   const rs = unwrapEC2Signature(toBuffer(b64SignedChallange));
   const publicKeys = await getPublicKey(publicKeyEs256Bytes);
-  /* console.log("externalSignature", ethers.hexlify(hashedData));
-  console.log("rs", ethers.hexlify(rs[0]), ethers.hexlify(rs[1]));
-  console.log("pubkey xy", publicKeys); */
   return await passkeyValidator.rawVerify(hashedData, rs, publicKeys);
 }
 
diff --git a/packages/contracts/test/SessionKeyTest.ts b/packages/contracts/test/SessionKeyTest.ts
index e03bc5fa..9463744d 100644
--- a/packages/contracts/test/SessionKeyTest.ts
+++ b/packages/contracts/test/SessionKeyTest.ts
@@ -311,7 +311,6 @@ describe("SessionKeyModule tests", function () {
       await tester.sendTxSuccess({
         to: sessionTarget,
         value: parseEther("0.01"),
-        gasLimit: 10_000_000n,
       });
       expect(await provider.getBalance(sessionTarget))
         .to.equal(parseEther("0.01"), "session target should have received the funds");
diff --git a/packages/sdk/README.md b/packages/sdk/README.md
index 247dada2..a9b8b174 100644
--- a/packages/sdk/README.md
+++ b/packages/sdk/README.md
@@ -1,3 +1,107 @@
-# zksync-sso
+# zksync-sso SDK
 
-ZKsync SSO SDK
+[![License](https://img.shields.io/badge/license-MIT-blue)](LICENSE-MIT)
+[![CI](https://github.com/matter-labs/zksync-account-sdk/actions/workflows/ci.yml/badge.svg)](https://github.com/matter-labs/zksync-account-sdk/actions/workflows/ci.yml)
+
+A user & developer friendly modular smart account implementation on ZKsync;
+simplifying user authentication, session management, and transaction processing.
+
+## Features and Goals
+
+<!-- prettier-ignore -->
+> [!CAUTION]
+> ZKsync SSO is under active development and is not yet feature
+> complete. Use it to improve your development applications and tooling. Please
+> do not use it in production environments.
+
+- 🧩 Modular smart accounts based on
+  [ERC-7579](https://eips.ethereum.org/EIPS/eip-7579#modules)
+- 🔑 Passkey authentication (no seed phrases)
+- ⏰ Sessions w/ easy configuration and management
+- 💰 Integrated paymaster support
+- ❤️‍🩹 Account recovery _(Coming Soon)_
+- 💻 Simple SDKs : JavaScript, iOS/Android _(Coming Soon)_
+- 🤝 Open-source authentication server
+- 🎓 Examples to get started quickly
+
+## Getting started
+
+Install the ZKsync SSO SDK package:
+
+```sh
+npm i zksync-sso
+```
+
+Add ZKsync SSO connector to your app (using `wagmi`):
+
+```ts
+import { zksyncSepoliaTestnet } from "viem/chains";
+import { createConfig, connect } from "@wagmi/core";
+import { zksyncSsoConnector } from "zksync-sso/connector";
+
+const ssoConnector = zksyncSsoConnector({
+  // Optional session configuration,
+  // if omitted user will have to sign every transaction via Auth Server
+  session: {
+    // Allow up to 0.1 ETH to be spend in gas fees
+    feeLimit: parseEther("0.1"),
+
+    transfers: [
+      // Allow ETH transfers of up to 0.1 ETH to specific address
+      {
+        to: "0x188bd99cd7D4d78d4E605Aeea12C17B32CC3135A",
+        valueLimit: parseEther("0.1"),
+      },
+
+      // Allow ETH transfers to specific address with a limit of 0.1 ETH per hour
+      // until the session expires
+      {
+        to: "0x188bd99cd7D4d78d4E605Aeea12C17B32CC3135A",
+        valueLimit: {
+            limit: parseEther("0.1"),
+            period: BigInt(60 * 60), // 1 hour in seconds
+        },
+      },
+    ],
+
+    // Allow calling specific smart contracts (e.g. ERC20 transfer):
+    contractCalls: [
+      {
+        address: "0xa1cf087DB965Ab02Fb3CFaCe1f5c63935815f044",
+        function: "transfer(address,uint256)",
+
+        // Optional call constraints (unconstrained otherwise):
+        constraints: [
+
+          // Only allow transfers to this address
+          {
+            index: 0,
+            condition: "Equal",
+            refValue: pad("0x6cC8cf7f6b488C58AA909B77E6e65c631c204784"),
+          },
+
+          // Transfer up to 0.2 tokens
+          {
+            index: 1,
+            limit: parseUnits("0.2", TOKEN.decimals), // Unlimited if omitted
+          },
+        ],
+      },
+    ],
+  },
+});
+
+const wagmiConfig = createConfig({
+   connectors: [ssoConnector],
+   ..., // your wagmi config https://wagmi.sh/core/api/createConfig
+});
+
+const connectWithSSO = () => {
+   connect(wagmiConfig, {
+      connector: ssoConnector,
+      chainId: zksyncSepoliaTestnet.id, // or another chain id that has SSO support
+   });
+};
+```
+
+[Find more information here in our docs.](https://docs.zksync.io/build/zksync-sso)
diff --git a/packages/sdk/prepare-package.mjs b/packages/sdk/prepare-package.mjs
index e42bb9ce..9afa3e29 100644
--- a/packages/sdk/prepare-package.mjs
+++ b/packages/sdk/prepare-package.mjs
@@ -1,20 +1,16 @@
 import { promises as fs } from "fs";
 import path from "path";
 
-// Define the path to the package.json
-const packageJsonPath = path.resolve("./package.json");
-console.log(packageJsonPath);
-
-// Get the version from environment variables
 const version = process.env.INPUT_VERSION;
 if (!version) {
   console.error("Error: INPUT_VERSION is required.");
   process.exit(1);
 }
 
+const packageJsonPath = path.resolve("./package.json");
+
 async function preparePackageJson() {
   try {
-    // Read the existing package.json
     const packageJsonData = await fs.readFile(packageJsonPath, "utf8");
     const packageJson = JSON.parse(packageJsonData);
 
diff --git a/packages/sdk/src/client-auth-server/Signer.ts b/packages/sdk/src/client-auth-server/Signer.ts
index ac0aca84..d0cd9e23 100644
--- a/packages/sdk/src/client-auth-server/Signer.ts
+++ b/packages/sdk/src/client-auth-server/Signer.ts
@@ -20,6 +20,7 @@ type Account = {
 interface SignerInterface {
   accounts: Address[];
   chain: Chain;
+  getClient(parameters?: { chainId?: number }): ZksyncSsoSessionClient;
   handshake(): Promise<Address[]>;
   request<TMethod extends Method>(request: RequestArguments<TMethod>): Promise<ExtractReturnType<TMethod>>;
   disconnect: () => Promise<void>;
@@ -83,6 +84,15 @@ export class Signer implements SignerInterface {
     }
   }
 
+  getClient(parameters?: { chainId?: number }) {
+    const chainId = parameters?.chainId || this.chain.id;
+    const chain = this.chains.find((e) => e.id === chainId);
+    if (!chain) throw new Error(`Chain with id ${chainId} is not supported`);
+
+    if (!this.walletClient) throw new Error("Wallet client is not created");
+    return this.walletClient;
+  }
+
   private get account(): Account | null {
     const account = this._account.get();
     if (!account) return null;
diff --git a/packages/sdk/src/client-auth-server/WalletProvider.ts b/packages/sdk/src/client-auth-server/WalletProvider.ts
index a4214e45..3af560ee 100644
--- a/packages/sdk/src/client-auth-server/WalletProvider.ts
+++ b/packages/sdk/src/client-auth-server/WalletProvider.ts
@@ -52,6 +52,10 @@ export class WalletProvider extends EventEmitter implements ProviderInterface {
     return this.signer.accounts.length > 0;
   }
 
+  public getClient(parameters?: { chainId?: number }) {
+    return this.signer.getClient(parameters);
+  }
+
   public async request<M extends Method>(request: RequestArguments<M>): Promise<ExtractReturnType<M>> {
     try {
       switch (request.method) {
diff --git a/packages/sdk/src/client-auth-server/interface.ts b/packages/sdk/src/client-auth-server/interface.ts
index 3b3c95fe..b96973f5 100644
--- a/packages/sdk/src/client-auth-server/interface.ts
+++ b/packages/sdk/src/client-auth-server/interface.ts
@@ -1,6 +1,7 @@
 import { EventEmitter } from "eventemitter3";
 import type { RpcSchema as RpcSchemaGeneric } from "viem";
 
+import type { ZksyncSsoSessionClient } from "../client/index.js";
 import type { ExtractParams, ExtractReturnType, Method, RpcSchema } from "./rpc.js";
 
 export interface RequestArguments<M extends Method<TSchema>, TSchema extends RpcSchemaGeneric = RpcSchema> {
@@ -26,6 +27,7 @@ interface ProviderConnectInfo {
 export interface ProviderInterface extends EventEmitter {
   request<M extends Method>(args: RequestArguments<M>): Promise<ExtractReturnType<M>>;
   disconnect(): Promise<void>;
+  getClient(parameters?: { chainId?: number }): Promise<ZksyncSsoSessionClient> | ZksyncSsoSessionClient;
   on(event: "connect", listener: (info: ProviderConnectInfo) => void): this;
   on(event: "disconnect", listener: (error: ProviderRpcError) => void): this;
   on(event: "chainChanged", listener: (chainId: string) => void): this;
diff --git a/packages/sdk/src/client/actions/sendEip712Transaction.ts b/packages/sdk/src/client/actions/sendEip712Transaction.ts
new file mode 100644
index 00000000..cc9422ae
--- /dev/null
+++ b/packages/sdk/src/client/actions/sendEip712Transaction.ts
@@ -0,0 +1,149 @@
+import { type Account, assertRequest, type AssertRequestErrorType, type Chain, type Client, type ExactPartial, type Hash, type PublicActions, type RpcSchema, type SendTransactionRequest, type Transport, type WalletActions } from "viem";
+import { parseAccount } from "viem/accounts";
+import { prepareTransactionRequest, sendRawTransaction } from "viem/actions";
+import { type ChainEIP712, type SendEip712TransactionParameters, type SendEip712TransactionReturnType, type SendTransactionParameters, zksync } from "viem/zksync";
+
+import { InvalidEip712TransactionError, type InvalidEip712TransactionErrorType } from "../utils/assertEip712Transaction.js";
+import { isEIP712Transaction } from "../utils/isEip712Transaction.js";
+
+/**
+ * Creates, signs, and sends a new EIP712 transaction to the network.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SendEip712TransactionParameters}
+ * @returns The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link SendTransactionReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { zksync } from 'viem/chains'
+ * import { sendEip712Transaction } from 'viem/zksync'
+ *
+ * const client = createWalletClient({
+ *   chain: zksync,
+ *   transport: custom(window.ethereum),
+ * })
+ * const hash = await sendEip712Transaction(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { zksync } from 'viem/chains'
+ * import { sendEip712Transaction } from 'viem/zksync'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: zksync,
+ *   transport: http(),
+ * })
+ *
+ * const hash = await sendEip712Transaction(client, {
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ */
+export async function sendEip712Transaction<
+  chain extends ChainEIP712 | undefined,
+  account extends Account | undefined,
+  const request extends SendTransactionRequest<chain, chainOverride>,
+  chainOverride extends ChainEIP712 | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: SendEip712TransactionParameters<
+    chain,
+    account,
+    chainOverride,
+    request
+  >,
+): Promise<SendEip712TransactionReturnType> {
+  const {
+    account: account_ = client.account,
+    chain = client.chain,
+    ...rest
+  } = parameters;
+
+  if (!account_)
+    throw new Error("Account not found.");
+  const account = parseAccount(account_);
+
+  assertEip712Request(parameters);
+
+  const request = await getAction(
+    client,
+    prepareTransactionRequest,
+    "prepareTransactionRequest",
+  )({
+    account,
+    chain,
+    nonceManager: account.nonceManager,
+    ...rest,
+  } as any);
+
+  const serializer = chain?.serializers?.transaction;
+  const serializedTransaction = (await account.signTransaction!(request, {
+    serializer,
+  })) as Hash;
+
+  return await getAction(
+    client,
+    sendRawTransaction,
+    "sendRawTransaction",
+  )({
+    serializedTransaction,
+  });
+}
+
+/**
+ * Retrieves and returns an action from the client (if exists), and falls
+ * back to the tree-shakable action.
+ *
+ * Useful for extracting overridden actions from a client (ie. if a consumer
+ * wants to override the `sendTransaction` implementation).
+ */
+export function getAction<
+  transport extends Transport,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  rpcSchema extends RpcSchema | undefined,
+  extended extends { [key: string]: unknown },
+  client extends Client<transport, chain, account, rpcSchema, extended>,
+  parameters,
+  returnType,
+>(
+  client: client,
+  actionFn: (_: any, parameters: parameters) => returnType,
+  // cspell:ignore minifiers
+  // Some minifiers drop `Function.prototype.name`, or replace it with short letters,
+  // meaning that `actionFn.name` will not always work. For that case, the consumer
+  // needs to pass the name explicitly.
+  name: keyof PublicActions | keyof WalletActions | (string & {}),
+): (parameters: parameters) => returnType {
+  const action_implicit = client[actionFn.name];
+  if (typeof action_implicit === "function")
+    return action_implicit as (params: parameters) => returnType;
+
+  const action_explicit = client[name];
+  if (typeof action_explicit === "function")
+    return action_explicit as (params: parameters) => returnType;
+
+  return (params) => actionFn(client, params);
+}
+
+type AssertEip712RequestParameters = ExactPartial<
+  SendTransactionParameters<typeof zksync>
+>;
+
+/** @internal */
+export type AssertEip712RequestErrorType =
+  | InvalidEip712TransactionErrorType
+  | AssertRequestErrorType;
+
+export function assertEip712Request(args: AssertEip712RequestParameters) {
+  if (!isEIP712Transaction(args as any))
+    throw new InvalidEip712TransactionError();
+  assertRequest(args as any);
+}
diff --git a/packages/sdk/src/client/clients/session.ts b/packages/sdk/src/client/clients/session.ts
index 8a51cecd..f44bb973 100644
--- a/packages/sdk/src/client/clients/session.ts
+++ b/packages/sdk/src/client/clients/session.ts
@@ -3,10 +3,30 @@ import { privateKeyToAccount } from "viem/accounts";
 
 import { encodeSession } from "../../utils/encoding.js";
 import type { SessionConfig } from "../../utils/session.js";
+import { publicActionsRewrite } from "../decorators/publicActionsRewrite.js";
 import { type ZksyncSsoSessionActions, zksyncSsoSessionActions } from "../decorators/session.js";
 import { type ZksyncSsoWalletActions, zksyncSsoWalletActions } from "../decorators/session_wallet.js";
 import { toSmartAccount } from "../smart-account.js";
 
+export const signSessionTransaction = (args: {
+  sessionKeySignedHash: Hash;
+  sessionContract: Address;
+  sessionConfig: SessionConfig;
+}) => {
+  return encodeAbiParameters(
+    [
+      { type: "bytes" },
+      { type: "address" },
+      { type: "bytes[]" },
+    ],
+    [
+      args.sessionKeySignedHash,
+      args.sessionContract,
+      [encodeSession(args.sessionConfig)], // FIXME: this is assuming there are no other hooks
+    ],
+  );
+};
+
 export function createZksyncSessionClient<
   transport extends Transport,
   chain extends Chain,
@@ -28,18 +48,11 @@ export function createZksyncSessionClient<
     sign: async ({ hash }) => {
       const sessionKeySigner = privateKeyToAccount(parameters.sessionKey);
       const hashSignature = await sessionKeySigner.sign({ hash });
-      return encodeAbiParameters(
-        [
-          { type: "bytes" },
-          { type: "address" },
-          { type: "bytes[]" },
-        ],
-        [
-          hashSignature,
-          parameters.contracts.session,
-          [encodeSession(parameters.sessionConfig)], // FIXME: this is assuming there are no other hooks
-        ],
-      );
+      return signSessionTransaction({
+        sessionKeySignedHash: hashSignature,
+        sessionContract: parameters.contracts.session,
+        sessionConfig: parameters.sessionConfig,
+      });
     },
   });
   const client = createClient<transport, chain, Account, rpcSchema>({
@@ -53,6 +66,7 @@ export function createZksyncSessionClient<
       contracts: parameters.contracts,
     }))
     .extend(publicActions)
+    .extend(publicActionsRewrite)
     .extend(zksyncSsoWalletActions)
     .extend(zksyncSsoSessionActions);
   return client;
diff --git a/packages/sdk/src/client/decorators/publicActionsRewrite.ts b/packages/sdk/src/client/decorators/publicActionsRewrite.ts
new file mode 100644
index 00000000..fd842727
--- /dev/null
+++ b/packages/sdk/src/client/decorators/publicActionsRewrite.ts
@@ -0,0 +1,52 @@
+import type { Account, Chain, Hex, PublicActions, Transport } from "viem";
+import { estimateContractGas, estimateGas, prepareTransactionRequest } from "viem/actions";
+
+import { type ClientWithZksyncSsoSessionData, signSessionTransaction } from "../clients/session.js";
+
+const emptySignature = "0x" + "1b".padStart(65 * 2, "0") as Hex;
+
+export function publicActionsRewrite<
+  transport extends Transport,
+  chain extends Chain,
+  account extends Account,
+>(
+  client: ClientWithZksyncSsoSessionData<transport, chain, account>,
+): Pick<PublicActions<transport, chain, account>, "estimateContractGas" | "estimateGas" | "prepareTransactionRequest"> {
+  return {
+    prepareTransactionRequest: async (args) => {
+      if (!("customSignature" in args)) {
+        (args as any).customSignature = signSessionTransaction({
+          sessionKeySignedHash: emptySignature,
+          sessionContract: client.contracts.session,
+          sessionConfig: client.sessionConfig,
+        });
+      }
+      const request = await prepareTransactionRequest(client, {
+        ...args,
+        type: "eip712",
+      } as any) as any;
+      return request;
+    },
+    estimateContractGas: (args) => {
+      if (!("customSignature" in args)) {
+        (args as any).customSignature = signSessionTransaction({
+          sessionKeySignedHash: emptySignature,
+          sessionContract: client.contracts.session,
+          sessionConfig: client.sessionConfig,
+        });
+      }
+      return estimateContractGas(client, args as any);
+    },
+    estimateGas: async (args) => {
+      if (!("customSignature" in args)) {
+        (args as any).customSignature = signSessionTransaction({
+          sessionKeySignedHash: emptySignature,
+          sessionContract: client.contracts.session,
+          sessionConfig: client.sessionConfig,
+        });
+      }
+      const estimated = await estimateGas(client, args);
+      return estimated;
+    },
+  };
+}
diff --git a/packages/sdk/src/client/decorators/session_wallet.ts b/packages/sdk/src/client/decorators/session_wallet.ts
index 047a46a5..5758d0b1 100644
--- a/packages/sdk/src/client/decorators/session_wallet.ts
+++ b/packages/sdk/src/client/decorators/session_wallet.ts
@@ -1,12 +1,12 @@
-import { /* decodeFunctionData, erc20Abi, getAddress, */ type Account, type Chain, type Transport, type WalletActions } from "viem";
-import { deployContract, getAddresses, getChainId, prepareTransactionRequest, sendRawTransaction, signMessage, signTypedData, writeContract } from "viem/actions";
-import { getGeneralPaymasterInput, sendEip712Transaction, sendTransaction, signTransaction } from "viem/zksync";
+import { type Account, bytesToHex, type Chain, formatTransaction, type Transport, type WalletActions } from "viem";
+import { deployContract, getAddresses, getChainId, sendRawTransaction, signMessage, signTypedData, writeContract } from "viem/actions";
+import { signTransaction, type ZksyncEip712Meta } from "viem/zksync";
 
+import { sendEip712Transaction } from "../actions/sendEip712Transaction.js";
 import type { ClientWithZksyncSsoSessionData } from "../clients/session.js";
-/* import { getTokenSpendLimit } from '../actions/session.js'; */
 
 export type ZksyncSsoWalletActions<chain extends Chain, account extends Account> = Omit<
-  WalletActions<chain, account>, "addChain" | "getPermissions" | "requestAddresses" | "requestPermissions" | "switchChain" | "watchAsset"
+  WalletActions<chain, account>, "addChain" | "getPermissions" | "requestAddresses" | "requestPermissions" | "switchChain" | "watchAsset" | "prepareTransactionRequest"
 >;
 
 export function zksyncSsoWalletActions<
@@ -18,32 +18,30 @@ export function zksyncSsoWalletActions<
     deployContract: (args) => deployContract(client, args),
     getAddresses: () => getAddresses(client),
     getChainId: () => getChainId(client),
-    prepareTransactionRequest: (args) =>
-      prepareTransactionRequest(client, args),
     sendRawTransaction: (args) => sendRawTransaction(client, args),
     sendTransaction: async (args) => {
-      const tx = client.chain.formatters?.transaction?.format(args) || args;
-      /* await verifyTransactionData({
-        value: tx.value,
-        chain: tx.chain || undefined,
-        to: tx.to || undefined,
-        data: tx.data,
-        gas: tx.gas,
-        gasPrice: tx.gasPrice,
-        maxFeePerGas: tx.maxFeePerGas,
-        maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
-      }, client); */
-      if (tx.eip712Meta) {
-        const transaction = {
-          ...tx,
-          account: client.account,
-          paymaster: tx.eip712Meta.paymasterParams.paymaster,
-          // TODO: Find permanent fix as this only works for general paymasters with no input
-          paymasterInput: getGeneralPaymasterInput({ innerInput: "0x" }),
-        };
-        return await sendEip712Transaction(client, transaction);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const unformattedTx: any = Object.assign({}, args);
+
+      if ("eip712Meta" in unformattedTx) {
+        const eip712Meta = unformattedTx.eip712Meta as ZksyncEip712Meta;
+        unformattedTx.gasPerPubdata = eip712Meta.gasPerPubdata ? BigInt(eip712Meta.gasPerPubdata) : undefined;
+        unformattedTx.factoryDeps = eip712Meta.factoryDeps;
+        unformattedTx.customSignature = eip712Meta.customSignature;
+        unformattedTx.paymaster = eip712Meta.paymasterParams?.paymaster;
+        unformattedTx.paymasterInput = eip712Meta.paymasterParams?.paymasterInput ? bytesToHex(new Uint8Array(eip712Meta.paymasterParams?.paymasterInput)) : undefined;
+        delete unformattedTx.eip712Meta;
       }
-      return await sendTransaction(client, tx);
+
+      const formatters = client.chain?.formatters;
+      const format = formatters?.transaction?.format || formatTransaction;
+
+      const tx = {
+        ...format(unformattedTx),
+        type: "eip712",
+      };
+
+      return await sendEip712Transaction(client, tx);
     },
     signMessage: (args) => signMessage(client, args),
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
diff --git a/packages/sdk/src/client/smart-account.ts b/packages/sdk/src/client/smart-account.ts
index c215a699..acb33ed1 100644
--- a/packages/sdk/src/client/smart-account.ts
+++ b/packages/sdk/src/client/smart-account.ts
@@ -41,7 +41,6 @@ export function toSmartAccount(
         ...transaction,
         from: this.address!,
         type: "eip712",
-        gas: 100_000_000n, // TODO remove when gas estimation is fixed
       } as ZksyncTransactionSerializableEIP712;
 
       const eip712DomainAndMessage = getEip712Domain(signableTransaction);
diff --git a/packages/sdk/src/connector/index.ts b/packages/sdk/src/connector/index.ts
index 4716047a..450d618d 100644
--- a/packages/sdk/src/connector/index.ts
+++ b/packages/sdk/src/connector/index.ts
@@ -10,6 +10,7 @@ import {
   UserRejectedRequestError,
 } from "viem";
 
+import { EthereumProviderError } from "../errors/errors.js";
 import { type AppMetadata, type ProviderInterface, type SessionPreferences, WalletProvider } from "../index.js";
 
 export type ZksyncSsoConnectorOptions = {
@@ -116,6 +117,10 @@ export const zksyncSsoConnector = (parameters: ZksyncSsoConnectorOptions) => {
       if (!chainId) return config.chains[0].id;
       return Number(chainId);
     },
+    async getClient(parameters) {
+      if (!walletProvider) throw new Error("Wallet provider not initialized");
+      return walletProvider.getClient(parameters);
+    },
     async getProvider() {
       if (!walletProvider) {
         walletProvider = new WalletProvider({
@@ -155,17 +160,18 @@ export const zksyncSsoConnector = (parameters: ZksyncSsoConnectorOptions) => {
       }
     },
     onAccountsChanged(accounts) {
-      if (accounts.length === 0) this.onDisconnect();
-      else config.emitter.emit("change", {
+      if (!accounts.length) return;
+      config.emitter.emit("change", {
         accounts: accounts.map((x) => getAddress(x)),
       });
     },
     onChainChanged(chain) {
       config.emitter.emit("change", { chainId: Number(chain) });
     },
-    async onDisconnect(_error) {
-      console.error("onDisconnect", _error);
+    async onDisconnect(error) {
       config.emitter.emit("disconnect");
+      if (error instanceof EthereumProviderError && error.code === 4900) return; // User initiated
+      console.error("Account disconnected", error);
     },
   }));
 };
diff --git a/packages/sdk/src/errors/errors.ts b/packages/sdk/src/errors/errors.ts
index 40af6ca7..e94ba309 100644
--- a/packages/sdk/src/errors/errors.ts
+++ b/packages/sdk/src/errors/errors.ts
@@ -149,7 +149,7 @@ class EthereumRpcError<T> extends Error {
   }
 }
 
-class EthereumProviderError<T> extends EthereumRpcError<T> {
+export class EthereumProviderError<T> extends EthereumRpcError<T> {
   /**
    * Create an Ethereum Provider JSON-RPC error.
    * `code` must be an integer in the 1000 <= 4999 range.