diff --git a/apps/web/src/components/ConnectWalletsFlow.vue b/apps/web/src/components/ConnectWalletsFlow.vue
index 45e331ddc..5a554081c 100644
--- a/apps/web/src/components/ConnectWalletsFlow.vue
+++ b/apps/web/src/components/ConnectWalletsFlow.vue
@@ -13,7 +13,14 @@ import useWallets from "@/composables/wallets"
 import useWalletConnect from "@/composables/walletConnectV2"
 // import useWallets from '@/composables/wallets'
 
-type UserAuthFlowState = "select_provider" | "select_address" | "loading" | "success" | "add_account" | "confirm_signage_with_existing_secondary" | "connection_failed"
+type UserAuthFlowState = 
+  "select_provider"
+  | "select_address" 
+  | "loading" 
+  | "success" 
+  | "add_account" 
+  | "confirm_signage_with_existing_secondary" 
+  | "connection_failed"
 
 const supportedWalletProviders = [
     "MetaMask",
@@ -29,8 +36,8 @@ const { login, loginWithSecondaryAddress } = useAuth()
 const { requiredNetwork } = useEnvironment()
 const { browserProvidersList, getEthersAddressesWithBalances } = useEthers()
 const { convertString, formatEthersCasimir, trimAndLowercaseAddress } = useFormat()
-const { getLedgerAddress } = useLedger()
-const { getTrezorAddress } = useTrezor()
+const { getEthersLedgerAddresses } = useLedger()
+const { getEthersTrezorAddresses } = useTrezor()
 const { user } = useUser()
 const { detectActiveNetwork, switchEthersNetwork } = useWallets()
 const { connectWalletConnectV2 } = useWalletConnect()
@@ -50,7 +57,7 @@ const props = defineProps({
 
 const flowState = ref<UserAuthFlowState>("select_provider")
 const errorMessage = ref(false)
-const errorMassageText = ref("Something went wrong, please try again later.")
+const errorMessageText = ref("Something went wrong, please try again later.")
 const walletProviderAddresses = ref([] as CryptoAddress[])
 const selectProviderLoading = ref(false)
 const selectedProvider = ref(null as ProviderString | null)
@@ -78,7 +85,7 @@ async function handleConfirmCreateAccountWithExistingSecondary() {
     } else if (response === "Selected address is not active address in wallet") {
         flowState.value = "select_address"
         errorMessage.value = true
-        errorMassageText.value = "Address selected is not active."
+        errorMessageText.value = "Address selected is not active."
     } else if (response === "Error in userAuthState") {
         flowState.value = "connection_failed"
         setTimeout(() => {
@@ -87,7 +94,7 @@ async function handleConfirmCreateAccountWithExistingSecondary() {
         }, 1000)
     } else {
         errorMessage.value = true
-        errorMassageText.value = "Something went wrong, please try again later."
+        errorMessageText.value = "Something went wrong, please try again later."
     }
 }
 
@@ -95,10 +102,13 @@ async function handleConfirmCreateAccountWithExistingSecondary() {
  * Checks if user is adding an account or logging in
  * @param address 
 */
-async function selectAddress(address: string, pathIndex: number): Promise<void> {
+async function selectAddress(address: string, pathIndex?: number): Promise<void> {
     selectedAddress.value = address
     flowState.value = "loading"
-    const loginCredentials: LoginCredentials = { provider: selectedProvider.value as ProviderString, address, currency: "ETH", pathIndex }
+    const loginCredentials: LoginCredentials = 
+      pathIndex !== undefined ? 
+          { provider: selectedProvider.value as ProviderString, address, currency: "ETH", pathIndex } : 
+          { provider: selectedProvider.value as ProviderString, address, currency: "ETH" }
     const response = await login(loginCredentials)
     if (response === "Successfully logged in" || response === "Successfully added account to user") {
         flowState.value = "success"
@@ -109,7 +119,7 @@ async function selectAddress(address: string, pathIndex: number): Promise<void>
     } else if (response === "Address already exists on this account") {
         flowState.value = "select_address"
         errorMessage.value = true
-        errorMassageText.value = "Address selected is already connected to your account."
+        errorMessageText.value = "Address selected is already connected to your account."
     } else if (
         response === "Address already exists as a primary address on another account" ||
         response === "Address already exists as a secondary address on another account"
@@ -118,7 +128,7 @@ async function selectAddress(address: string, pathIndex: number): Promise<void>
     } else if (response === "Selected address is not active address in wallet") {
         flowState.value = "select_address"
         errorMessage.value = true
-        errorMassageText.value = "Address selected is not active."
+        errorMessageText.value = "Address selected is not active."
     } else if (response === "Error in userAuthState") {
         flowState.value = "connection_failed"
         setTimeout(() => {
@@ -127,7 +137,7 @@ async function selectAddress(address: string, pathIndex: number): Promise<void>
         }, 1500)
     } else {
         errorMessage.value = true
-        errorMassageText.value = "Something went wrong, please try again later."
+        errorMessageText.value = "Something went wrong, please try again later."
     }
 }
 
@@ -136,7 +146,7 @@ async function selectAddress(address: string, pathIndex: number): Promise<void>
  * @param provider 
  * @param currency 
 */
-async function selectProvider(provider: ProviderString, currency: Currency = "ETH"): Promise<void> {
+async function selectProvider(provider: ProviderString): Promise<void> {
     console.clear()
     try {
         selectedProvider.value = provider
@@ -144,10 +154,12 @@ async function selectProvider(provider: ProviderString, currency: Currency = "ET
     
         // Hard Goerli Check
         // TODO: Make this dynamic
-        const activeNetwork = await detectActiveNetwork(selectedProvider.value as ProviderString)
-        if (activeNetwork !== 5) {
-            await switchEthersNetwork(selectedProvider.value, "0x5")
-            return window.location.reload()
+        if (provider !== "WalletConnect") {
+            const activeNetwork = await detectActiveNetwork(selectedProvider.value as ProviderString)
+            if (activeNetwork !== 5) {
+                await switchEthersNetwork(selectedProvider.value, "0x5")
+                return window.location.reload()
+            }
         }
 
         if (provider === "WalletConnect") {
@@ -156,19 +168,42 @@ async function selectProvider(provider: ProviderString, currency: Currency = "ET
         } else if (browserProvidersList.includes(provider)) {
             walletProviderAddresses.value = await getEthersAddressesWithBalances(provider) as CryptoAddress[]
         } else if (provider === "Ledger") {
-            walletProviderAddresses.value = await getLedgerAddress[currency]() as CryptoAddress[]
+            walletProviderAddresses.value = await getEthersLedgerAddresses() as CryptoAddress[]
         } else if (provider === "Trezor") {
-            walletProviderAddresses.value = await getTrezorAddress[currency]() as CryptoAddress[]
+            walletProviderAddresses.value = await getEthersTrezorAddresses() as CryptoAddress[]
         } else {
             throw new Error("Provider not supported")
         }
+        errorMessage.value = false
+        errorMessageText.value = ""
         selectProviderLoading.value = false
         flowState.value = "select_address"
     } catch (error: any) {
         errorMessage.value = true
-        errorMassageText.value = "Something went wrong, please try again later."
-        selectProviderLoading.value = false
-        throw new Error(`Error selecting provider: ${error.message}`)
+        if (provider === "Ledger") {
+            const { message, name, statusCode } = error
+            if (
+                message === "Ledger device: UNKNOWN_ERROR (0x6511)" 
+              && name === "TransportStatusError" 
+              && statusCode === 25873
+            ) {
+                errorMessageText.value = "Unlock your Ledger and open Ethereum Goerli app."
+                selectProviderLoading.value = false
+            }
+        } else if (provider === "Trezor") {
+            if (error.message.includes("Trezor Suite is not open")) {
+                errorMessageText.value = "Open your Trezor Suite desktop app."
+                selectProviderLoading.value = false
+            } else {
+                console.log("Error in selectProvider :>> ", error)
+                errorMessageText.value = "Something went wrong with your Trezor connection, please try again later."
+                selectProviderLoading.value = false
+            }
+        } else {
+            console.log("error in selectProvider in ConnectWalletsFlow.vue :>> ", error)
+            errorMessageText.value = "Something went wrong, please try again later."
+            selectProviderLoading.value = false
+        }
     }
 }
 
@@ -230,7 +265,7 @@ onUnmounted(() => {
           <button
             class="connect_wallet_btn_provider relative"
             :disabled="selectProviderLoading"
-            @click="selectProvider(walletProvider, 'ETH')"
+            @click="selectProvider(walletProvider)"
           >
             <div :class="selectedProvider === walletProvider && selectProviderLoading ? 'loading' : 'hidden'" />
             <img
@@ -260,7 +295,7 @@ onUnmounted(() => {
       </div>
       <div class="h-15 w-full text-[11px] font-[500] mb-5 text-decline">
         <span v-show="errorMessage">
-          Something went wrong, please try again later.
+          {{ errorMessageText }}
         </span>
       </div>
       <div>
@@ -336,7 +371,11 @@ onUnmounted(() => {
           <button
             class="connect_wallet_btn"
             :disabled="checkIfAddressIsUsed(act)"
-            @click="selectAddress(trimAndLowercaseAddress(act.address), pathIndex)"
+            @click="
+              selectedProvider === 'Ledger' || selectedProvider === 'Trezor' ?
+                selectAddress(trimAndLowercaseAddress(act.address), pathIndex) :
+                selectAddress(trimAndLowercaseAddress(act.address), undefined)
+            "
           >
             <div>
               {{ convertString(act.address) }}
@@ -350,7 +389,7 @@ onUnmounted(() => {
 
       <div class="h-15 w-full text-[11px] font-[500] mb-5 text-decline">
         <span v-show="errorMessage">
-          {{ errorMassageText }}
+          {{ errorMessageText }}
         </span>
       </div>
       <div>
@@ -639,4 +678,4 @@ onUnmounted(() => {
   letter-spacing: -0.01em;
   color: #667085;
 }
-</style>
\ No newline at end of file
+</style>@/composables/eventBus
\ No newline at end of file
diff --git a/apps/web/src/composables/auth.ts b/apps/web/src/composables/auth.ts
index 343c21595..6f745bf96 100644
--- a/apps/web/src/composables/auth.ts
+++ b/apps/web/src/composables/auth.ts
@@ -6,6 +6,7 @@ import useLedger from "@/composables/ledger"
 import useTrezor from "@/composables/trezor"
 import useUser from "@/composables/user"
 import useWalletConnect from "@/composables/walletConnectV2"
+import useWallets from "@/composables/wallets"
 import {
     Account,
     ApiResponse,
@@ -15,11 +16,12 @@ import {
 } from "@casimir/types"
 
 const { usersUrl } = useEnvironment()
-const { browserProvidersList, detectActiveEthersWalletAddress, loginWithEthers } = useEthers()
+const { browserProvidersList, loginWithEthers } = useEthers()
 const { loginWithLedger } = useLedger()
 const { loginWithTrezor } = useTrezor()
 const { setUser, user } = useUser()
-const { loginWithWalletConnectV2, initializeWalletConnect, uninitializeWalletConnect } = useWalletConnect()
+const { disconnectWalletConnect, loginWithWalletConnectV2, initializeWalletConnect, uninitializeWalletConnect } = useWalletConnect()
+const { detectActiveWalletAddress } = useWallets()
 
 const initializedAuthComposable = ref(false)
 const loadingSessionLogin = ref(false)
@@ -32,16 +34,17 @@ export default function useAuth() {
         provider,
         address,
         currency,
+        pathIndex
     }: {
     provider: string;
     address: string;
     currency: string;
+    pathIndex?: number;
   }) {
-        const userAccountExists = user.value?.accounts?.some(
-            (account: Account | any) =>
-                account?.address === address &&
-        account?.walletProvider === provider &&
-        account?.currency === currency
+        const userAccountExists = user.value?.accounts?.some((account: Account | any) =>
+            account?.address === address &&
+            account?.walletProvider === provider &&
+            account?.currency === currency
         )
         if (userAccountExists) return "Account already exists for this user"
         const account = {
@@ -50,6 +53,7 @@ export default function useAuth() {
             currency: currency || "ETH",
             ownerAddress: user?.value?.address.toLowerCase() as string,
             walletProvider: provider,
+            pathIndex
         }
 
         const requestOptions = {
@@ -75,16 +79,6 @@ export default function useAuth() {
         }
     }
 
-    async function detectActiveWalletAddress(providerString: ProviderString) {
-        if (browserProvidersList.includes(providerString)) {
-            return await detectActiveEthersWalletAddress(providerString)
-        } else {
-            alert(
-                "detectActiveWalletAddress not yet implemented for this wallet provider"
-            )
-        }
-    }
-
     async function getUser() {
         try {
             const requestOptions = {
@@ -177,17 +171,18 @@ export default function useAuth() {
                 // If no, cancel/do nothing
 
                 const hardwareWallet = provider === "Ledger" || provider === "Trezor"
-                const browserWallet = browserProvidersList.includes(
-          provider as ProviderString
-                )
-                if (hardwareWallet) {
+                const browserWallet = browserProvidersList.includes(provider as ProviderString)
+
+                if (provider === "WalletConnect") {
+                    await loginWithProvider(loginCredentials as LoginCredentials)
+                    await getUser()
+                    return "Successfully logged in"
+                } else if (hardwareWallet) {
                     await loginWithProvider(loginCredentials as LoginCredentials)
                     await getUser()
                     return "Successfully logged in"
                 } else if (browserWallet) {
-                    const activeAddress = await detectActiveWalletAddress(
-            provider as ProviderString
-                    )
+                    const activeAddress = await detectActiveWalletAddress(provider as ProviderString)
                     if (activeAddress === address) {
                         await loginWithProvider({
                             provider: provider as ProviderString,
@@ -203,6 +198,7 @@ export default function useAuth() {
                 }
             }
         } catch (error: any) {
+            console.log("Error in userAuthState :>> ", error)
             return "Error in userAuthState"
         }
     }
@@ -282,7 +278,8 @@ export default function useAuth() {
     async function logout() {
         try {
             loadingSessionLogout.value = true
-            await Session.signOut()
+            const promises = [disconnectWalletConnect(), Session.signOut()]
+            await Promise.all(promises)
             setUser(undefined)
             loadingSessionLogout.value = false
         } catch (error) {
diff --git a/apps/web/src/composables/ledger.ts b/apps/web/src/composables/ledger.ts
index 350c9b48f..89b4ad999 100644
--- a/apps/web/src/composables/ledger.ts
+++ b/apps/web/src/composables/ledger.ts
@@ -12,16 +12,8 @@ export default function useLedger() {
     const { ethereumUrl, ledgerType, speculosUrl } = useEnvironment()
     const { getGasPriceAndLimit } = useEthers()
 
-    // function getBitcoinLedgerSigner() {
-    //   const options = {
-    //     type: ledgerType,
-    //     baseURL: speculosUrl
-    //   }
-    //   return new BitcoinLedgerSigner(options)
-    // }
-
     function getEthersLedgerSigner(pathIndex?: number) {
-        const path = pathIndex ? `m/44'/60'/0'/0/${pathIndex}` : "m/44'/60'/0'/0/0"
+        const path = pathIndex ? `m/44'/60'/${pathIndex}'/0/0` : "m/44'/60'/0'/0/0"
         const options = {
             provider: new ethers.providers.JsonRpcProvider(ethereumUrl),
             type: ledgerType,
@@ -31,50 +23,16 @@ export default function useLedger() {
         return new EthersLedgerSigner(options)
     }
 
-    const getLedgerAddress = {
-    // 'BTC': getBitcoinLedgerAddress,
-        "ETH": getEthersLedgerAddresses,
-        "IOTX": () => {
-            return new Promise((resolve, reject) => {
-                console.log("IOTX is not yet supported on Ledger")
-                resolve("IOTX is not yet supported on Ledger")
-            }) as Promise<string>
-        },
-        "SOL": () => {
-            return new Promise((resolve, reject) => {
-                console.log("SOL is not yet supported on Ledger")
-                resolve("SOL is not yet supported on Ledger")
-            }) as Promise<string>
-        },
-        "": () => {
-            return new Promise((resolve, reject) => {
-                console.log("No currency selected")
-                resolve("No currency selected")
-            }) as Promise<string>
-        },
-        "USD": () => {
-            return new Promise((resolve, reject) => {
-                console.log("USD is not yet supported on Ledger")
-                resolve("USD is not yet supported on Ledger")
-            }) as Promise<string>
-        }
-    }
-
-    // async function getBitcoinLedgerAddress() {
-    //   const signer = getBitcoinLedgerSigner()
-    //   return await signer.getAddress()
-    // }
-
     async function getEthersLedgerAddresses(): Promise<Array<CryptoAddress>> {
         const signer = getEthersLedgerSigner()
         return await signer.getAddresses() as Array<CryptoAddress>
     }
 
     async function loginWithLedger(loginCredentials: LoginCredentials) {
-    // ETH Mainnet: 0x8222ef172a2117d1c4739e35234e097630d94376
-    // ETH Goerli 1: 0x8222Ef172A2117D1C4739E35234E097630D94376
-    // ETH Goerli 2: 0x8ed535c94DC22218D74A77593228cbb1B7FF6D13
-    // Derivation path m/44\'/60\'/0\'/0/1: 0x1a16ae0F5cf84CaE346a1D586d00366bBA69bccc
+        // ETH Mainnet: 0x8222ef172a2117d1c4739e35234e097630d94376
+        // ETH Goerli 1: 0x8222Ef172A2117D1C4739E35234E097630D94376
+        // ETH Goerli 2: 0x8ed535c94DC22218D74A77593228cbb1B7FF6D13
+        // Derivation path m/44\'/60\'/0\'/0/1: 0x1a16ae0F5cf84CaE346a1D586d00366bBA69bccc
         const { provider, address, currency, pathIndex } = loginCredentials
         try {
             const message = await createSiweMessage(address, "Sign in with Ethereum to the app.")
@@ -85,7 +43,8 @@ export default function useLedger() {
                 currency,
                 message, 
                 provider, 
-                signedMessage
+                signedMessage,
+                pathIndex
             })
         } catch (err) {
             console.log("Error logging in: ", err)
@@ -122,19 +81,14 @@ export default function useLedger() {
             const { message } = messageRequest
             const signer = getEthersLedgerSigner()
             return await signer.signMessage(message)
-        } /*else if ( messageRequest.currency === 'BTC') {
-      const { message } = messageRequest
-      const signer = getBitcoinLedgerSigner()
-      return await signer.signMessage(message)
-    } */else {
+        } else {
             return ""
         }
     }
 
     return {
-    // getBitcoinLedgerSigner,
+        getEthersLedgerAddresses,
         getEthersLedgerSigner,
-        getLedgerAddress,
         loginWithLedger,
         signLedgerMessage,
         sendLedgerTransaction,
diff --git a/apps/web/src/composables/staking.ts b/apps/web/src/composables/staking.ts
index 8fe7aa757..0e1aa9b16 100644
--- a/apps/web/src/composables/staking.ts
+++ b/apps/web/src/composables/staking.ts
@@ -22,6 +22,7 @@ const { getWalletConnectSignerV2 } = useWalletConnectV2()
 const stakingComposableInitialized = ref(false)
 const awaitingStakeOrWithdrawConfirmation = ref(false)
 const userStakeDetails = ref<Array<StakeDetails>>([])
+const stakeWithdrawError = ref("")
 
 let baseManager: CasimirManager
 let eigenManager: CasimirManager
@@ -46,7 +47,8 @@ export default function useStaking() {
         }
     }
 
-    async function deposit({ amount, walletProvider, type }: { amount: string, walletProvider: ProviderString, type: "default" | "eigen" }) {
+    async function deposit({ amount, walletProvider, type, pathIndex }: { amount: string, walletProvider: ProviderString, type: "default" | "eigen", pathIndex: number | undefined}) {
+        stakeWithdrawError.value = ""
         try {
             const activeNetwork = await detectActiveNetwork(walletProvider)
             if (activeNetwork !== 5) {
@@ -60,7 +62,7 @@ export default function useStaking() {
             } else if (walletProvider === "WalletConnect") {
                 signer = await getWalletConnectSignerV2()
             } else if (walletProvider === "Ledger") {
-                signer = getEthersLedgerSigner()
+                signer = getEthersLedgerSigner(pathIndex)
             } else if (walletProvider === "Trezor") {
                 signer = getEthersTrezorSigner()
             } else {
@@ -76,8 +78,14 @@ export default function useStaking() {
             const confirmation = await result.wait(1)
             if (confirmation) awaitingStakeOrWithdrawConfirmation.value = false
             return confirmation
-        } catch (err) {
-            console.error(`There was an error in deposit function: ${JSON.stringify(err)}`)
+        } catch (err: any) {
+            console.error(`Error in deposit function: ${JSON.stringify(err)}`)
+            if (err.message.includes("denied by the user")) {
+                stakeWithdrawError.value = "Transaction denied by the user"
+                console.log("Transaction denied by the user")
+            } else {
+                stakeWithdrawError.value = err.message
+            }
             awaitingStakeOrWithdrawConfirmation.value = false
             return false
         }
@@ -175,6 +183,7 @@ export default function useStaking() {
 
     async function withdraw({ amount, walletProvider, type }: { amount: string, walletProvider: ProviderString, type: "default" | "eigen" }) {
         try {
+            stakeWithdrawError.value = ""
             const activeNetwork = await detectActiveNetwork(walletProvider)
             if (activeNetwork !== 5) {
                 await switchEthersNetwork(walletProvider, "0x5")
@@ -201,8 +210,9 @@ export default function useStaking() {
             const confirmation = await result.wait(1)
             if (confirmation) awaitingStakeOrWithdrawConfirmation.value = false
             return confirmation
-        } catch (err) {
+        } catch (err: any) {
             console.error(`There was an error in withdraw function: ${JSON.stringify(err)}`)
+            stakeWithdrawError.value = err.reason
             awaitingStakeOrWithdrawConfirmation.value = false
             return false
         }
@@ -210,6 +220,7 @@ export default function useStaking() {
 
     return {
         awaitingStakeOrWithdrawConfirmation: readonly(awaitingStakeOrWithdrawConfirmation),
+        stakeWithdrawError: readonly(stakeWithdrawError),
         stakingComposableInitialized,
         userStakeDetails,
         initializeStakingComposable,
diff --git a/apps/web/src/composables/trezor.ts b/apps/web/src/composables/trezor.ts
index e76ffd3cb..9a9278972 100644
--- a/apps/web/src/composables/trezor.ts
+++ b/apps/web/src/composables/trezor.ts
@@ -7,66 +7,26 @@ import { LoginCredentials, MessageRequest, TransactionRequest } from "@casimir/t
 
 const { createSiweMessage, signInWithEthereum } = useSiwe()
 
-const trezorPath = "m/44'/60'/0'/0/0"
-
 export default function useTrezor() {
     const { ethereumUrl } = useEnvironment()
     const { getGasPriceAndLimit } = useEthers()
 
-    // TODO: Implement this:
-    function getBitcoinTrezorSigner() {
-        return alert("Not implemented yet")
-    // const options = {
-    //     path: trezorPath
-    // }
-    // return new BitcoinTrezorSigner(options)
-    }
-
     function getEthersTrezorSigner(): EthersTrezorSigner {
-        const options = {
-            provider: new ethers.providers.JsonRpcProvider(ethereumUrl),
-            path: trezorPath
-        }
-        return new EthersTrezorSigner(options)
-    }
-
-    const getTrezorAddress = {
-        "BTC": () => {
-            return new Promise((resolve, reject) => {
-                console.log("BTC is not yet supported on Trezor")
-                resolve("BTC is not yet supported on Trezor")
-            }) as Promise<string>
-        },
-        "ETH": getEthersTrezorAddresses,
-        "IOTX": () => {
-            return new Promise((resolve, reject) => {
-                console.log("IOTX is not yet supported on Trezor")
-                resolve("IOTX is not yet supported on Trezor")
-            }) as Promise<string>
-        },
-        "SOL": () => {
-            return new Promise((resolve, reject) => {
-                console.log("SOL is not yet supported on Trezor")
-                resolve("SOL is not yet supported on Trezor")
-            }) as Promise<string>
-        },
-        "": () => {
-            return new Promise((resolve, reject) => {
-                console.log("No currency selected")
-                resolve("No currency selected")
-            }) as Promise<string>
-        },
-        "USD": () => {
-            return new Promise((resolve, reject) => {
-                console.log("USD is not yet supported on Trezor")
-                resolve("USD is not yet supported on Trezor")
-            }) as Promise<string>
+        try {
+            const options = {
+                provider: new ethers.providers.JsonRpcProvider(ethereumUrl),
+            }
+            // This is working when Trezor Suite is not opened
+            return new EthersTrezorSigner(options)
+        } catch (error: any) {
+            console.log(`Error in getEthersTrezorSigner: ${error}`)
+            throw new Error(error)
         }
     }
 
     async function getEthersTrezorAddresses() {
         const signer = getEthersTrezorSigner()
-        return await signer.getAddresses()
+        return await signer.getAddresses() // This error logs here: POST http://127.0.0.1:21325/ net::ERR_CONNECTION_REFUSED
     }
 
     async function loginWithTrezor(loginCredentials: LoginCredentials) {
@@ -121,8 +81,8 @@ export default function useTrezor() {
     }
 
     return { 
+        getEthersTrezorAddresses, 
         getEthersTrezorSigner, 
-        getTrezorAddress, 
         loginWithTrezor, 
         sendTrezorTransaction, 
         signTrezorMessage
diff --git a/apps/web/src/composables/user.ts b/apps/web/src/composables/user.ts
index 41bb039db..a48600c32 100644
--- a/apps/web/src/composables/user.ts
+++ b/apps/web/src/composables/user.ts
@@ -1,5 +1,5 @@
 import { readonly, ref, watch } from "vue"
-import { UserWithAccountsAndOperators } from "@casimir/types"
+import { Account, ProviderString, UserWithAccountsAndOperators } from "@casimir/types"
 import useEnvironment from "@/composables/environment"
 import { ethers } from "ethers"
 
@@ -16,6 +16,12 @@ export default function useUser() {
         })
     }
 
+    function getPathIndex(provider: ProviderString, address: string) {
+        const { accounts } = user.value as UserWithAccountsAndOperators
+        const target = accounts.find((account: Account) => account.walletProvider === provider && account.address === address)
+        return target?.pathIndex
+    }
+
     function setUser(newUserValue: UserWithAccountsAndOperators | undefined) {
         user.value = newUserValue
     }
@@ -57,6 +63,7 @@ export default function useUser() {
     return {
         user: readonly(user),
         initializeUserComposable,
+        getPathIndex,
         setUser,
         updateUserAgreement,
     }
diff --git a/apps/web/src/composables/walletConnectV2.ts b/apps/web/src/composables/walletConnectV2.ts
index 724700a91..5d248d116 100644
--- a/apps/web/src/composables/walletConnectV2.ts
+++ b/apps/web/src/composables/walletConnectV2.ts
@@ -6,11 +6,13 @@ import { PairingTypes, SessionTypes } from "@walletconnect/types"
 import useSiwe from "@/composables/siwe"
 import useEthers from "@/composables/ethers"
 import useEnvironment from "@/composables/environment"
+import useUser from "@/composables/user"
 import { CryptoAddress, LoginCredentials } from "@casimir/types"
 
 const { createSiweMessage, signInWithEthereum } = useSiwe()
 const { walletConnectProjectId } = useEnvironment()
 const { getEthersBalance } = useEthers()
+const { user } = useUser()
 
 let cleanupFunctions: Array<any> = [] // TODO: Potentially fix type here.
 const accounts = ref<Array<string>>([])
@@ -47,7 +49,6 @@ export default function useWalletConnectV2() {
             web3Modal.value?.closeModal()
             const connectedAddress = _accounts[0].toLowerCase().trim() as string
             const connectedAddressBalance = (await getEthersBalance(connectedAddress)).toString()
-
             return [{ address: connectedAddress as string, balance: connectedAddressBalance }]
         } catch (error) {
             console.error("Failed to connect:", error)
@@ -89,7 +90,7 @@ export default function useWalletConnectV2() {
         web3Provider.value = ethersProviderInstance
     }
 
-    async function disconnect() {
+    async function disconnectWalletConnect() {
         if (!ethereumProvider.value) {
             throw new Error("ethereumProvider is not initialized")
         }
@@ -106,11 +107,11 @@ export default function useWalletConnectV2() {
 
     async function initializeWalletConnect() {
         if (componentIsMounted.value) return
-        // if (import.meta.env.MODE === "development") console.log("initializing wallet connect")
+        if (import.meta.env.MODE === "development") console.log("initializing wallet connect")
         componentIsMounted.value = true
 
         // Check for persisted sessions & Subscribe to provider events
-        if (ethereumProvider.value) {
+        if (ethereumProvider.value && user.value) {
             _subscribeToProviderEvents()
             subscribedToProviderEvents.value = true
             await _checkForPersistedSession()
@@ -139,8 +140,6 @@ export default function useWalletConnectV2() {
   
     async function signWalletConnectMessage(message: string) : Promise<string> {
         try {
-            console.log("got to signWalletConnectMessage")
-            console.log("message :>> ", message)
             const signer = await web3Provider.value?.getSigner()
             return await signer?.signMessage(message) as string
         } catch (err) {
@@ -160,6 +159,10 @@ export default function useWalletConnectV2() {
         if (ethereumProvider.value?.session) {
             const _session = ethereumProvider.value?.session
             console.log("RESTORED SESSION:", _session)
+            if (!user.value) {
+                await disconnectWalletConnect()
+                return
+            }
             await _onSessionConnected(_session)
             return _session
         }
@@ -237,11 +240,12 @@ export default function useWalletConnectV2() {
     }
 
     return {
+        web3Provider,
         connectWalletConnectV2,
+        disconnectWalletConnect,
         getWalletConnectSignerV2,
         initializeWalletConnect,
         loginWithWalletConnectV2,
-        uninitializeWalletConnect,
-        web3Provider
+        uninitializeWalletConnect
     }
 }
\ No newline at end of file
diff --git a/apps/web/src/composables/wallets.ts b/apps/web/src/composables/wallets.ts
index d7a05cada..a91228a50 100644
--- a/apps/web/src/composables/wallets.ts
+++ b/apps/web/src/composables/wallets.ts
@@ -1,9 +1,11 @@
 import { ref, readonly } from "vue"
 import { ProviderString } from "@casimir/types"
 import useEthers from "@/composables/ethers"
+import useWalletConnectV2 from "@/composables/walletConnectV2"
 
 const installedWallets = ref([] as ProviderString[])
-const { browserProvidersList, getBrowserProvider } = useEthers()
+const { browserProvidersList, detectActiveEthersWalletAddress, getBrowserProvider } = useEthers()
+const { web3Provider } = useWalletConnectV2()
 
 export default function useWallets() {
     async function detectActiveNetwork(providerString: ProviderString): Promise<number> {
@@ -13,9 +15,7 @@ export default function useWallets() {
                 const chainId = parseInt(await provider.request({ method: "eth_chainId" }), 16)
                 return chainId
             } else if (providerString === "WalletConnect") {
-                const provider = getBrowserProvider(providerString)
-                const chainId = parseInt(await provider.request({ method: "eth_chainId" }), 16)
-                return chainId
+                return web3Provider.value.provider.chainId
             } else if (providerString === "Ledger") {
                 // TODO: Determine if there is a way to implement with Ledger or if have to rely on selected network on device
                 return await new Promise(resolve => resolve(5))
@@ -30,6 +30,16 @@ export default function useWallets() {
             return await new Promise(resolve => resolve(0))
         }
     }
+
+    async function detectActiveWalletAddress(providerString: ProviderString) {
+        if (browserProvidersList.includes(providerString)) {
+            return await detectActiveEthersWalletAddress(providerString)
+        } else {
+            alert(
+                "detectActiveWalletAddress not yet implemented for this wallet provider"
+            )
+        }
+    }
       
     
     async function detectInstalledWalletProviders() {
@@ -86,6 +96,7 @@ export default function useWallets() {
     return {
         installedWallets: readonly(installedWallets),
         detectActiveNetwork,
+        detectActiveWalletAddress,
         detectInstalledWalletProviders,
         switchEthersNetwork
     }
diff --git a/apps/web/src/layouts/default-layout.vue b/apps/web/src/layouts/default-layout.vue
index 809677580..7d157652f 100644
--- a/apps/web/src/layouts/default-layout.vue
+++ b/apps/web/src/layouts/default-layout.vue
@@ -195,8 +195,8 @@ const toggleModal = (showModal: boolean) => {
               >
                 <div class="green_dot mr-8" />
                 <img
-                  :src="`${user.walletProvider.toLocaleLowerCase()}.svg`"
-                  :alt="`${user.walletProvider.toLocaleLowerCase()} Icon`"
+                  :src="`${user?.walletProvider.toLocaleLowerCase()}.svg`"
+                  :alt="`${user?.walletProvider.toLocaleLowerCase()} Icon`"
                   class="h-[26px] mr-6"
                 > 
                 <div>{{ convertString(user.address) }}</div>
@@ -219,6 +219,7 @@ const toggleModal = (showModal: boolean) => {
               class="flex align-center items-center py-4 w-full cursor-default"
             >
               <img
+                v-if="user"
                 :src="`${user?.walletProvider.toLocaleLowerCase()}.svg`"
                 :alt="`${user?.walletProvider.toLocaleLowerCase()} Icon`"
                 class="h-[26px] mr-6"
diff --git a/apps/web/src/main.ts b/apps/web/src/main.ts
index de2ff292b..7d2beb7ee 100644
--- a/apps/web/src/main.ts
+++ b/apps/web/src/main.ts
@@ -8,17 +8,6 @@ import { SuperTokensWebJSConfig } from "./sessions.config"
 
 SuperTokens.init(SuperTokensWebJSConfig)
 
-// const originalFetch = window.fetch
-// let fetchCallCount = 0
-// window.fetch = async (...args) => {
-//     const url = args[0]
-//     if (url === "https://goerli.infura.io/v3/46a379ac6895489f812f33beb726b03b" || url === "http://127.0.0.1:8545")  {
-//         fetchCallCount++
-//         console.log(`Fetch call count: ${fetchCallCount}`)
-//     }
-//     return originalFetch(...args)
-// }
-
 const app = createApp(App)
 app.use(router)
 app.mount("#app")
\ No newline at end of file
diff --git a/apps/web/src/pages/operators/Operator.vue b/apps/web/src/pages/operators/Operator.vue
index eef0d7428..4d807d0bf 100644
--- a/apps/web/src/pages/operators/Operator.vue
+++ b/apps/web/src/pages/operators/Operator.vue
@@ -5,14 +5,13 @@ import { ProviderString } from "@casimir/types"
 import useAuth from "@/composables/auth"
 import useContracts from "@/composables/contracts"
 import useEnvironment from "@/composables/environment"
-// import useEthers from '@/composables/ethers'
 import useFormat from "@/composables/format"
 import useOperators from "@/composables/operators"
 import useUser from "@/composables/user"
+import useWallets from "@/composables/wallets"
 
 const { loadingSessionLogin } = useAuth()
 const { docsUrl } = useEnvironment()
-// const { detectActiveWalletAddress } = useEthers()
 const { contractsAreInitialized } = useContracts()
 const { convertString } = useFormat()
 const {
@@ -25,6 +24,7 @@ const {
     loadingAddOperator
 } = useOperators()
 const { user } = useUser()
+const { detectActiveWalletAddress } = useWallets()
 
 // Form inputs
 const selectedWallet = ref<{ address: string, walletProvider: ProviderString }>({ address: "", walletProvider: "" })
@@ -285,10 +285,10 @@ async function submitRegisterOperatorForm() {
     const selectedAddress = selectedWallet.value.address
     const selectedProvider = selectedWallet.value.walletProvider
 
-    // const activeAddress = await detectActiveWalletAddress(selectedProvider)
-    // if (activeAddress !== selectedAddress) {
-    //   return alert(`The account you selected is not the same as the one that is active in your ${selectedProvider} wallet. Please open your browser extension and select the account that you want to log in with.`)
-    // }
+    const activeAddress = await detectActiveWalletAddress(selectedProvider)
+    if (activeAddress !== selectedAddress) {
+        return alert(`The account you selected is not the same as the one that is active in your ${selectedProvider} wallet. Please open your ${selectedProvider} browser extension and select the account you want to use.`)
+    }
 
     try {
         await registerOperatorWithCasimir({
diff --git a/apps/web/src/pages/overview/components/Staking.vue b/apps/web/src/pages/overview/components/Staking.vue
index 6e44e18bb..bcbb72ce8 100644
--- a/apps/web/src/pages/overview/components/Staking.vue
+++ b/apps/web/src/pages/overview/components/Staking.vue
@@ -3,18 +3,22 @@ import { computed, ref, onMounted, watch } from "vue"
 import { FormattedWalletOption, ProviderString, StakeDetails } from "@casimir/types"
 import VueFeather from "vue-feather"
 import useEnvironment from "@/composables/environment"
+import useEthers from "@/composables/ethers"
 import useStaking from "@/composables/staking"
 import useFormat from "@/composables/format"
 import usePrice from "@/composables/price"
 import useUser from "@/composables/user"
+import useWallets from "@/composables/wallets"
 import { ethers } from "ethers"
 import TermsOfService from "@/components/TermsOfService.vue"
 
+const { browserProvidersList } = useEthers()
 const { batchProvider } = useEnvironment()
-const { stakingComposableInitialized, userStakeDetails, deposit, withdraw, getWithdrawableBalance } = useStaking()
+const { stakeWithdrawError, stakingComposableInitialized, userStakeDetails, deposit, withdraw, getWithdrawableBalance } = useStaking()
 const { convertString, formatEthersCasimir, formatEthersCasimirStaking, parseEthersCasimir } = useFormat()
 const { getCurrentPrice } = usePrice()
-const { user, updateUserAgreement } = useUser()
+const { user, getPathIndex, updateUserAgreement } = useUser()
+const { detectActiveWalletAddress } = useWallets()
 
 // Staking Component Refs
 const addressBalance = ref<string | null>(null)
@@ -114,15 +118,10 @@ function toggleEstimatedAPY() {
 
 function selectAmountInput() {
     const inputElement = document.getElementById("amount_input") as HTMLInputElement
-
     if (inputElement) {
-
         inputElement.setSelectionRange(0, inputElement.value.length)
-
-        // For mobile devices
-        inputElement.select()
+        inputElement.select() // For mobile devices
     }
-
 }
 
 function aggregateAddressesByProvider() {
@@ -219,22 +218,28 @@ function handleInputOnAmountToStakeOrWithdraw(event: any) {
 }
 
 async function handleStake() {
+    let pathIndex = undefined
     stakeButtonText.value = "Staking..."
-
-    // const activeAddress = await detectActiveWalletAddress(selectedStakingProvider.value)
-    // if (activeAddress !== selectedWalletAddress.value) {
-    //   formattedAmountToStakeOrWithdraw.value = ''
-    //   return alert(`The account you selected is not the same as the one that is active in your ${selectedStakingProvider.value} wallet. Please open your browser extension and select the account that you want to log in with.`)
-    // }
     eigenIsToggled.value = false
-    const result = await deposit({
+
+    // TODO: @DemogorGod - Should we check for active wallet here or in the staking.ts composable?
+    if (browserProvidersList.includes(selectedWalletAddress.value as string)) {
+        const activeAddress = await detectActiveWalletAddress(selectedStakingProvider.value)
+        if (activeAddress !== selectedWalletAddress.value) {
+            formattedAmountToStakeOrWithdraw.value = 0
+            stakeButtonText.value = "Stake"
+            return alert(`The account you selected is not the same as the one that is active in your ${selectedStakingProvider.value} wallet. Please open your ${selectedStakingProvider.value} browser extension select the account you want to use to stake.`)
+        }
+    } else {
+        pathIndex = getPathIndex(selectedStakingProvider.value, selectedWalletAddress.value as string)
+    }
+    const depositPayload = {
         amount: formattedAmountToStakeOrWithdraw.value.toString(),
         walletProvider: selectedStakingProvider.value,
-        type: stakeType.value
-    })
-
-    if (result === false) stakeButtonText.value = "User Rejected Signature"
-    else stakeButtonText.value = "Staked!"
+        type: stakeType.value,
+        pathIndex: pathIndex !== undefined ? pathIndex : undefined
+    }
+    const result = await deposit(depositPayload)
 
     setTimeout(() => {
         stakeButtonText.value = "Stake"
@@ -242,17 +247,19 @@ async function handleStake() {
     }, 1000)
 
     if (result) alert("Your Stake Has Been Deposited!")
-    else alert("Your Stake Action Has Failed, Please Try Again Later!")
 }
 
 async function handleWithdraw() {
     stakeButtonText.value = "Withdrawing..."
     selectedOperatorGroupStakeDetails.value = undefined
-    // const activeAddress = await detectActiveWalletAddress(selectedStakingProvider.value)
-    // if (activeAddress !== selectedWalletAddress.value) {
-    //   formattedAmountToStakeOrWithdraw.value = ''
-    //   return alert(`The account you selected is not the same as the one that is active in your ${selectedStakingProvider.value} wallet. Please open your browser extension and select the account that you want to log in with.`)
-    // }
+
+    // TODO: @DemogorGod - Should we check for active wallet here or in the staking.ts composable?
+    const activeAddress = await detectActiveWalletAddress(selectedStakingProvider.value)
+    if (activeAddress !== selectedWalletAddress.value) {
+        formattedAmountToStakeOrWithdraw.value = 0
+        stakeButtonText.value = "Withdraw"
+        return alert(`The account you selected is not the same as the one that is active in your ${selectedStakingProvider.value} wallet. Please open your ${selectedStakingProvider.value} browser extension select the account you want to use to withdraw.`)
+    }
 
     const withdrawableBalance = await getWithdrawableBalance({
         walletProvider: selectedStakingProvider.value,
@@ -281,7 +288,6 @@ async function handleWithdraw() {
     }, 1000)
 
     if (confirmation) alert("Your Stake Has Been Withdrawn!")
-    else alert("Your Stake Action Has Failed, Please Try Again Later!")
 }
 
 watch(formattedWalletOptions, async () => {
@@ -338,6 +344,22 @@ watch(selectedWalletAddress, async () => {
     }
 })
 
+watch(stakeWithdrawError, () => {
+    if (stakeWithdrawError.value === "") return
+    if (stakeWithdrawError.value === "user rejected transaction") {
+        alert("User rejected transaction. Try again and confirm signature.")
+        setTimeout(() => {
+            stakeOrWithdraw.value === "stake" ? stakeButtonText.value = "Stake" : stakeButtonText.value = "Withdraw"
+        }, 2000)
+    } else {
+        // TODO: Determine other errors to handle and handle here.
+        alert("Stake failed. Try again later.")
+        setTimeout(() => {
+            stakeOrWithdraw.value === "stake" ? stakeButtonText.value = "Stake" : stakeButtonText.value = "Withdraw"
+        }, 2000)
+    }
+})
+
 watch(user, async () => {
     if (user.value?.id) {
         aggregateAddressesByProvider()
diff --git a/common/data/src/schemas/account.schema.json b/common/data/src/schemas/account.schema.json
index 3364753e0..5307e84e7 100644
--- a/common/data/src/schemas/account.schema.json
+++ b/common/data/src/schemas/account.schema.json
@@ -24,6 +24,10 @@
             "type": "serial",
             "description": "The account ID (PK)"
         },
+        "path_index": {
+            "type": "integer",
+            "description": "The account path index (typically used for HD wallets)"
+        },
         "snapshots": {
             "type": "array",
             "description": "The account snapshots",
@@ -60,6 +64,7 @@
     },
     "uniqueFields": [
         "address",
+        "path_index",
         "user_id",
         "wallet_provider"
     ],
diff --git a/common/types/src/interfaces/Account.ts b/common/types/src/interfaces/Account.ts
index 650dce46d..1c42ce00f 100644
--- a/common/types/src/interfaces/Account.ts
+++ b/common/types/src/interfaces/Account.ts
@@ -17,6 +17,8 @@ export interface Account {
     // snapshots?: BalanceSnapshot[]
     /** The account transactions */
     // transactions?: Transaction[]
+    /** The pathIndex of the user's HD Wallet */
+    pathIndex?: number
     /** The user id associated with the account */
     userId: string
     /** The wallet provider which helps us show user breakdown and connect when signing or sending TXs */
diff --git a/common/wallets/src/providers/ledger.ts b/common/wallets/src/providers/ledger.ts
index 80583d762..973e2a849 100644
--- a/common/wallets/src/providers/ledger.ts
+++ b/common/wallets/src/providers/ledger.ts
@@ -1,3 +1,4 @@
+/* eslint-disable max-len */
 import { ethers } from "ethers"
 // import Btc from '@ledgerhq/hw-app-btc'
 import Eth, { ledgerService } from "@ledgerhq/hw-app-eth"
@@ -223,38 +224,42 @@ export class EthersLedgerSigner extends ethers.Signer {
         return ethers.utils.joinSignature(signature)
     }
 
-    async signTransaction(transaction: ethers.providers.TransactionRequest): Promise<string> {
-        const tx = await ethers.utils.resolveProperties(transaction)
+    async signTransaction(tx: ethers.providers.TransactionRequest): Promise<string> {
+        const resolvedTx = await ethers.utils.resolveProperties(tx)
+        
         const baseTx: ethers.utils.UnsignedTransaction = {
-            chainId: (tx.chainId || undefined),
-            data: (tx.data || undefined),
-            gasLimit: (tx.gasLimit || undefined),
-            gasPrice: (tx.gasPrice || undefined),
-            nonce: (tx.nonce ? ethers.BigNumber.from(tx.nonce).toNumber() : undefined),
-            to: (tx.to || undefined),
-            value: (tx.value || undefined),
-            type: (tx.type || undefined)
+            chainId: (resolvedTx.chainId || 1),
+            data: (resolvedTx.data || undefined),
+            gasLimit: (resolvedTx.gasLimit || undefined),
+            maxFeePerGas: (resolvedTx.maxFeePerGas || undefined),
+            maxPriorityFeePerGas: (resolvedTx.maxPriorityFeePerGas || undefined),
+            nonce: (resolvedTx.nonce ? ethers.BigNumber.from(resolvedTx.nonce).toNumber() : 0),
+            to: (resolvedTx.to || undefined),
+            value: (resolvedTx.value || undefined),
+            type: (resolvedTx.type || undefined)
         }
-
-        const unsignedTx = ethers.utils.serializeTransaction(baseTx).substring(2)
+    
+        const unsignedTx = ethers.utils.serializeTransaction(baseTx).substring(2) // Do we have to do this step?
         const resolution = await ledgerService.resolveTransaction(unsignedTx, {}, {})
         const signature = await this.retry((eth) => eth.signTransaction(this.path, unsignedTx, resolution))
-
-        return ethers.utils.serializeTransaction(baseTx, {
+    
+        const result = ethers.utils.serializeTransaction(baseTx, {
             v: ethers.BigNumber.from("0x" + signature.v).toNumber(),
             r: ("0x" + signature.r),
             s: ("0x" + signature.s),
         })
+        return result
     }
 
     // Populates all fields in a transaction, signs it and sends it to the network
-    async sendTransaction(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>)
+    async sendTransaction(tx: ethers.utils.Deferrable<ethers.providers.TransactionRequest>)
         : Promise<ethers.providers.TransactionResponse> 
     {
         this._checkProvider("sendTransaction")
-        const tx = await this.populateTransaction(transaction)
-        const signedTx = await this.signTransaction(tx)
-        return await (this.provider as ethers.providers.JsonRpcProvider).sendTransaction(signedTx)
+        const populatedTx = await this.populateTransaction(tx)
+        const signedTx = await this.signTransaction(populatedTx)
+        const result = await (this.provider as ethers.providers.JsonRpcProvider).sendTransaction(signedTx)
+        return result
     }
 
     connect(provider: ethers.providers.Provider): ethers.Signer {
diff --git a/common/wallets/src/providers/trezor.ts b/common/wallets/src/providers/trezor.ts
index 25ec5633d..250883bcf 100644
--- a/common/wallets/src/providers/trezor.ts
+++ b/common/wallets/src/providers/trezor.ts
@@ -32,7 +32,7 @@ export class EthersTrezorSigner extends ethers.Signer {
     }
 
     async getAddress(): Promise<string> {
-        const { payload } = await this.eth.ethereumGetAddress({ path: this.path })
+        const { payload } = await this.eth.ethereumGetAddress({ path: this.path, showOnTrezor: false })
         const { address } = payload as Address
         return ethers.utils.getAddress(address)
     }
@@ -40,29 +40,30 @@ export class EthersTrezorSigner extends ethers.Signer {
     async getAddresses(): Promise<Array<CryptoAddress>> {
         const trezorAddresses = []
         const bundle = []
-        for (let i = 0; i < 5; i++) {
-            // TODO: Figure out how to access Goerli derivation paths
-            // m/coin_type'/account_index'/external_chain_index'/address_index/change_index
-            // const path = `m/44'/60'/${i}'/0/0` // Mainnet
-            // const path = `m/44'/1'/${i}'/0/0` // Ropsten
-            const path = `m/44'/60'/${i}'/0/0` // Goerli?
+        for (let i = 0; i < 2; i++) {
+            const path = `m/44'/60'/0'/0/${i}`
             bundle.push({ path, showOnTrezor: false })
         }
         const { payload } = await this.eth.ethereumGetAddress({ bundle }) as any
-        
+        if (payload.error) {
+            if (payload.code === "Transport_Missing") {
+                throw new Error("Trezor Suite is not open")
+            } else if (payload.error === "session not found") {
+                throw new Error("There was an error connecting to Trezor. Please try again.")
+            } else {
+                throw new Error(`Error from Trezor: ${payload.error}`)
+            }
+        }
+    
         for (let i = 0; i < payload.length; i++) {
             const { address } = payload[i]
-            // TODO: Replace with our own provider depending on environment
             const provider = new ethers.providers.JsonRpcProvider("https://goerli.infura.io/v3/4e8acb4e58bb4cb9978ac4a22f3326a7")
             const modifiedAddress = address.toLowerCase().trim()
             const balance = await provider.getBalance(modifiedAddress)
             const ethBalance = ethers.utils.formatEther(balance)
-            // if (parseFloat(ethBalance) > 0) trezorAddresses.push({ address, balance: ethBalance, index: i.toString() }) // TODO: Uncomment this line; it is currently commented out for testing
-            trezorAddresses.push(
-                { address, balance: ethBalance, pathIndex: i.toString() }
-            ) // TODO: Remove this line; it is currently for testing
+            trezorAddresses.push({ address, balance: ethBalance, pathIndex: i.toString() })
         }
-        return trezorAddresses.length ? trezorAddresses : [] 
+        return trezorAddresses.length ? trezorAddresses : []
     }
 
     async signMessage(message: ethers.utils.Bytes | string): Promise<string> {
diff --git a/services/users/src/providers/db.ts b/services/users/src/providers/db.ts
index f8391ae06..1d8cbc1e3 100644
--- a/services/users/src/providers/db.ts
+++ b/services/users/src/providers/db.ts
@@ -30,7 +30,7 @@ export default function useDB() {
     async function addAccount(account: Account, createdAt?: string) : Promise<Account> {
         try {
             if (!createdAt) createdAt = new Date().toISOString()
-            const { address, currency, userId, walletProvider } = account
+            const { address, currency, pathIndex, userId, walletProvider } = account
     
             // Check if the account already exists for the user
             const checkText = "SELECT * FROM accounts WHERE user_id = $1 AND address = $2;"
@@ -43,12 +43,18 @@ export default function useDB() {
             }
     
             // Proceed to add the account
-            const text = "INSERT INTO accounts (address, currency, user_id, wallet_provider, created_at) VALUES ($1, $2, $3, $4, $5) RETURNING *;"
-            const params = [address,
-                currency,
-                userId,
-                walletProvider,
-                createdAt]
+            let text = "INSERT INTO accounts (address, currency, user_id, wallet_provider, created_at"
+            const params = [address, currency, userId, walletProvider, createdAt]
+            console.log("pathIndex :>> ", pathIndex)
+            if (pathIndex !== undefined) {
+                text += ", path_index"
+                params.push(pathIndex.toString())
+            }
+    
+            text += ") VALUES ("
+            text += params.map((_, index) => `$${index + 1}`).join(", ") // This will generate $1, $2, ..., $N based on the parameters
+            text += ") RETURNING *;"
+    
             const rows = await postgres.query(text, params)
             const accountAdded = rows[0]
             const accountId = accountAdded.id
@@ -57,7 +63,8 @@ export default function useDB() {
         } catch (error: any) {
             throw new Error("There was an error adding the account to the database: " + error.message)
         }
-    }    
+    }
+      
 
     /**
      * Adds operator to operator table
@@ -175,6 +182,7 @@ export default function useDB() {
                             'balance', a.balance,
                             'currency', a.currency,
                             'created_at', a.created_at,
+                            'path_index', a.path_index,
                             'updated_at', a.updated_at,
                             'user_id', a.user_id,
                             'wallet_provider', a.wallet_provider,
@@ -227,6 +235,7 @@ export default function useDB() {
                             'balance', a.balance,
                             'currency', a.currency,
                             'created_at', a.created_at,
+                            'path_index', a.path_index,
                             'updated_at', a.updated_at,
                             'user_id', a.user_id,
                             'wallet_provider', a.wallet_provider,
diff --git a/services/users/src/providers/ethers.ts b/services/users/src/providers/ethers.ts
index dbc48cb49..47ab26581 100644
--- a/services/users/src/providers/ethers.ts
+++ b/services/users/src/providers/ethers.ts
@@ -1,5 +1,5 @@
 import { ethers } from "ethers"
-import { LoginCredentials } from "@casimir/types"
+import { SignInWithEthereumCredentials } from "@casimir/types"
 
 export default function useEthers() {
 
@@ -21,11 +21,11 @@ export default function useEthers() {
     /**
      * Verifies a user's login attempt with an address, message and signed message
      * 
-     * @param {LoginCredentials} loginCredentials - The user's address, message and signed message 
+     * @param {SignInWithEthereumCredentials} SignInWithEthereumCredentials - The user's address, message and signed message 
      * @returns {boolean} - The response from the login request
      */
-    function verifyMessageSignature(loginCredentials: LoginCredentials): boolean {
-        const { address, message, signedMessage } = loginCredentials
+    function verifyMessageSignature(SignInWithEthereumCredentials: SignInWithEthereumCredentials): boolean {
+        const { address, message, signedMessage } = SignInWithEthereumCredentials
         try {
             if (!address.length || !message.length || !signedMessage.length) {
                 return false
diff --git a/services/users/src/routes/auth.ts b/services/users/src/routes/auth.ts
index 90339f262..67ef6781d 100644
--- a/services/users/src/routes/auth.ts
+++ b/services/users/src/routes/auth.ts
@@ -36,7 +36,7 @@ router.post("/login", async (req: express.Request, res: express.Response) => {
     try {
         const { body } = req
         const loginCredentials = body
-        const { provider, address, currency, message, signedMessage } = loginCredentials
+        const { provider, address, currency, message, signedMessage, pathIndex } = loginCredentials
         const { parsedDomain, parsedNonce } = parseMessage(message)
         const verifyDomain = parsedDomain ? verifyMessageDomain(parsedDomain) : false
         const verifyNonce = parsedNonce ? await verifyMessageNonce(address, parsedNonce) : false
@@ -62,6 +62,7 @@ router.post("/login", async (req: express.Request, res: express.Response) => {
                     address,
                     currency,
                     walletProvider: provider,
+                    pathIndex,
                 } as Account
 
                 const addUserResult = await addUser(newUser, account)
diff --git a/services/users/src/routes/user.ts b/services/users/src/routes/user.ts
index b90619fd7..75001ec23 100644
--- a/services/users/src/routes/user.ts
+++ b/services/users/src/routes/user.ts
@@ -46,7 +46,6 @@ router.post("/add-sub-account", verifySession(), async (req: SessionRequest, res
         const userId = id.toString()
         const userSessionId = req.session?.getUserId()
         const validatedUserId = validateUserId(userSessionId, userId)
-        console.log("validatedUserId :>> ", validatedUserId)
         if (!validatedUserId) {
             res.setHeader("Content-Type", "application/json")
             res.status(200)