diff --git a/dapp/.env b/dapp/.env
index 6fa402df3..9c3c6c2af 100644
--- a/dapp/.env
+++ b/dapp/.env
@@ -13,7 +13,5 @@ VITE_REFERRAL=123
 # TODO: Pass this value as an environment variable during the build process.
 VITE_DEFENDER_RELAYER_WEBHOOK_URL="https://api.defender.openzeppelin.com/actions/a0d6d2e2-ce9c-4619-aa2b-6c874fe97af7/runs/webhook/b1f17c89-8230-46e3-866f-a3213887974c/Sbddsy54cJ6sPg2bLPyuHJ"
 
-VITE_ACRE_SUBGRAPH_URL="https://api.studio.thegraph.com/query/73600/acre/version/latest"
-
 # TODO: Set this env variable in CI.
 VITE_TBTC_API_ENDPOINT=""
diff --git a/dapp/ledger-manifest-testnet.json b/dapp/ledger-manifest-testnet.json
index 15e34dba5..12238b7e1 100644
--- a/dapp/ledger-manifest-testnet.json
+++ b/dapp/ledger-manifest-testnet.json
@@ -23,7 +23,8 @@
     "account.list",
     "message.sign",
     "transaction.sign",
-    "transaction.signAndBroadcast"
+    "transaction.signAndBroadcast",
+    "bitcoin.getXPub"
   ],
   "domains": ["http://*"],
   "type": "walletApp"
diff --git a/dapp/src/components/TransactionModal/ActiveStakingStep/DepositBTCModal.tsx b/dapp/src/components/TransactionModal/ActiveStakingStep/DepositBTCModal.tsx
index 51f44bc03..6f29d5952 100644
--- a/dapp/src/components/TransactionModal/ActiveStakingStep/DepositBTCModal.tsx
+++ b/dapp/src/components/TransactionModal/ActiveStakingStep/DepositBTCModal.tsx
@@ -34,7 +34,7 @@ export default function DepositBTCModal() {
   const fetchDeposits = useFetchDeposits()
 
   const onStakeBTCSuccess = useCallback(() => {
-    fetchDeposits()
+    logPromiseFailure(fetchDeposits())
     dispatch(setStatus(PROCESS_STATUSES.SUCCEEDED))
   }, [dispatch, fetchDeposits])
 
diff --git a/dapp/src/components/TransactionModal/ActiveStakingStep/StakingErrorModal/index.tsx b/dapp/src/components/TransactionModal/ActiveStakingStep/StakingErrorModal/index.tsx
index 0272f7182..fa5e86a52 100644
--- a/dapp/src/components/TransactionModal/ActiveStakingStep/StakingErrorModal/index.tsx
+++ b/dapp/src/components/TransactionModal/ActiveStakingStep/StakingErrorModal/index.tsx
@@ -21,7 +21,7 @@ export default function StakingErrorModal() {
   const [isServerError, setIsServerError] = useState(false)
 
   const onStakeBTCSuccess = useCallback(() => {
-    fetchDeposits()
+    logPromiseFailure(fetchDeposits())
     dispatch(setStatus(PROCESS_STATUSES.SUCCEEDED))
   }, [dispatch, fetchDeposits])
 
diff --git a/dapp/src/components/shared/ActivitiesList/ActivitiesListItem.tsx b/dapp/src/components/shared/ActivitiesList/ActivitiesListItem.tsx
index 73403a4ed..5f1c2da51 100644
--- a/dapp/src/components/shared/ActivitiesList/ActivitiesListItem.tsx
+++ b/dapp/src/components/shared/ActivitiesList/ActivitiesListItem.tsx
@@ -25,17 +25,19 @@ type ActivitiesListItemProps = Omit<AlertProps, "status"> &
 function ActivitiesListItem(props: ActivitiesListItemProps) {
   const { amount, status, txHash, type, handleDismiss, ...restProps } = props
 
+  const isCompleted = status === "completed"
+
   return (
     <Alert as={HStack} variant="process" {...restProps}>
       <AlertIcon
         color="brand.400"
-        as={status === "completed" ? LoadingSpinnerSuccessIcon : Spinner}
+        as={isCompleted ? LoadingSpinnerSuccessIcon : Spinner}
       />
 
       <VStack flex={1} spacing={0} align="stretch">
         <HStack justify="space-between" as={AlertTitle}>
           <Text as="span">
-            {status === "completed"
+            {isCompleted
               ? `${type === "withdraw" ? "Unstaking" : "Staking"} completed`
               : `${type === "withdraw" ? "Unstaking" : "Staking"}...`}
           </Text>
@@ -43,7 +45,7 @@ function ActivitiesListItem(props: ActivitiesListItemProps) {
           <CurrencyBalance amount={amount} currency="bitcoin" />
         </HStack>
         <HStack justify="space-between" as={AlertDescription}>
-          {status === "completed" ? (
+          {isCompleted ? (
             <Button
               variant="link"
               fontSize="sm"
diff --git a/dapp/src/hooks/sdk/useFetchDeposits.ts b/dapp/src/hooks/sdk/useFetchDeposits.ts
index 051cda597..54570285e 100644
--- a/dapp/src/hooks/sdk/useFetchDeposits.ts
+++ b/dapp/src/hooks/sdk/useFetchDeposits.ts
@@ -1,27 +1,26 @@
 import { useCallback } from "react"
 import { setActivities } from "#/store/wallet"
-import { logPromiseFailure, subgraphAPI } from "#/utils"
+import { useAcreContext } from "#/acre-react/hooks"
+import { Activity } from "#/types"
+import { DepositStatus } from "@acre-btc/sdk"
 import { useAppDispatch } from "../store/useAppDispatch"
-import { useWalletContext } from "../useWalletContext"
-
-// TODO: Use the correct function from SDK
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const calculateEthAddress = (btcAddress: string) =>
-  "0x45e2e415989477ea5450e440405f6ac858019e6b"
 
 export function useFetchDeposits() {
   const dispatch = useAppDispatch()
-  const { btcAccount } = useWalletContext()
+  const { acre } = useAcreContext()
 
-  const fetchDeposits = useCallback(async () => {
-    if (!btcAccount) return
+  return useCallback(async () => {
+    if (!acre) return
 
-    // TODO: Use function from the SDK.
-    const ethAddress = calculateEthAddress(btcAccount.address)
-    const result = await subgraphAPI.fetchActivityData(ethAddress)
+    const result: Activity[] = (await acre.staking.getDeposits()).map(
+      (deposit) => ({
+        ...deposit,
+        status:
+          deposit.status === DepositStatus.Finalized ? "completed" : "pending",
+        type: "deposit",
+      }),
+    )
 
     dispatch(setActivities(result))
-  }, [btcAccount, dispatch])
-
-  return useCallback(() => logPromiseFailure(fetchDeposits()), [fetchDeposits])
+  }, [acre, dispatch])
 }
diff --git a/dapp/src/hooks/sdk/useInitDataFromSdk.ts b/dapp/src/hooks/sdk/useInitDataFromSdk.ts
index caefc6398..ab7f36c13 100644
--- a/dapp/src/hooks/sdk/useInitDataFromSdk.ts
+++ b/dapp/src/hooks/sdk/useInitDataFromSdk.ts
@@ -1,10 +1,11 @@
 import { useEffect } from "react"
 import { useInterval } from "@chakra-ui/react"
 import { ONE_MINUTE_IN_SECONDS, ONE_SEC_IN_MILLISECONDS } from "#/constants"
+import { logPromiseFailure } from "#/utils"
+import { useWalletContext } from "../useWalletContext"
 import { useFetchBTCBalance } from "./useFetchBTCBalance"
 import { useFetchMinDepositAmount } from "./useFetchMinDepositAmount"
 import { useFetchDeposits } from "./useFetchDeposits"
-import { useWalletContext } from "../useWalletContext"
 
 const INTERVAL_TIME = ONE_SEC_IN_MILLISECONDS * ONE_MINUTE_IN_SECONDS * 30
 
@@ -14,11 +15,11 @@ export function useInitDataFromSdk() {
 
   useEffect(() => {
     if (btcAccount) {
-      fetchDeposits()
+      logPromiseFailure(fetchDeposits())
     }
   }, [btcAccount, fetchDeposits])
 
   useFetchBTCBalance()
   useFetchMinDepositAmount()
-  useInterval(fetchDeposits, INTERVAL_TIME)
+  useInterval(() => logPromiseFailure(fetchDeposits()), INTERVAL_TIME)
 }
diff --git a/dapp/src/types/activity.ts b/dapp/src/types/activity.ts
index eac056622..e55bc5c67 100644
--- a/dapp/src/types/activity.ts
+++ b/dapp/src/types/activity.ts
@@ -18,8 +18,8 @@ export type Activity = {
   timestamp: number
   txHash: string
   amount: bigint
+  status: Exclude<ActivityInfoStatus, "syncing">
   type: "deposit" | "withdraw"
-  status: "completed" | "pending"
 }
 
 export type ActivitiesByIds = {
diff --git a/dapp/src/types/index.ts b/dapp/src/types/index.ts
index 3e2a9719f..78494ddc4 100644
--- a/dapp/src/types/index.ts
+++ b/dapp/src/types/index.ts
@@ -17,5 +17,4 @@ export * from "./core"
 export * from "./fee"
 export * from "./modal"
 export * from "./navigation"
-export * from "./subgraphAPI"
 export * from "./form"
diff --git a/dapp/src/types/subgraphAPI.ts b/dapp/src/types/subgraphAPI.ts
deleted file mode 100644
index 7beb65517..000000000
--- a/dapp/src/types/subgraphAPI.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export type ActivityDataResponse = {
-  id: string
-  bitcoinTransactionId: string
-  amountToDeposit: string
-  events: { timestamp: string; type: "Initialized" | "Finalized" }[]
-}
diff --git a/dapp/src/utils/index.ts b/dapp/src/utils/index.ts
index 4927e12d8..6df508ec4 100644
--- a/dapp/src/utils/index.ts
+++ b/dapp/src/utils/index.ts
@@ -9,5 +9,4 @@ export * from "./promise"
 export * from "./exchangeApi"
 export * from "./verifyDepositAddress"
 export * from "./json"
-export * from "./subgraphAPI"
 export * from "./activities"
diff --git a/dapp/src/utils/subgraphAPI.ts b/dapp/src/utils/subgraphAPI.ts
deleted file mode 100644
index e3f4bb50d..000000000
--- a/dapp/src/utils/subgraphAPI.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import axios from "axios"
-import { Activity, ActivityDataResponse } from "#/types"
-
-const ACRE_SUBGRAPH_URL = import.meta.env.VITE_ACRE_SUBGRAPH_URL
-
-const mapToActivity = (activityData: ActivityDataResponse): Activity => {
-  const {
-    id,
-    bitcoinTransactionId: txHash,
-    amountToDeposit,
-    events,
-  } = activityData
-
-  const status = events.some(({ type }) => type === "Finalized")
-    ? "completed"
-    : "pending"
-
-  const timestamp = parseInt(events[0].timestamp, 10)
-
-  return {
-    id,
-    txHash,
-    timestamp,
-    amount: BigInt(amountToDeposit),
-    type: "deposit",
-    status,
-  }
-}
-
-// TODO: Fetch transactions for withdrawals
-/**
- * Returns the activities for a given account.
- * @param account The Ethereum address for which the activities will be fetched.
- */
-async function fetchActivityData(account: string): Promise<Activity[]> {
-  const response = await axios.post<{
-    errors?: unknown
-    data: { activityDatas: ActivityDataResponse[] }
-  }>(ACRE_SUBGRAPH_URL, {
-    query: `query {
-            activityDatas(
-              where: {depositOwner_: {id: "${account}"}}
-            ) {
-              id
-              bitcoinTransactionId
-              events {
-                timestamp,
-                type
-              }
-              ... on Deposit {
-                amountToDeposit
-              }
-            }
-          }`,
-  })
-
-  if (response.data && response.data.errors) {
-    const errorMsg = "Failed to fetch data from Acre subgraph API."
-    console.error(errorMsg, response.data.errors)
-    throw new Error(errorMsg)
-  }
-
-  return response.data.data.activityDatas.map(mapToActivity)
-}
-
-export const subgraphAPI = {
-  fetchActivityData,
-}
diff --git a/dapp/src/vite-env.d.ts b/dapp/src/vite-env.d.ts
index efe1127b6..2269a081a 100644
--- a/dapp/src/vite-env.d.ts
+++ b/dapp/src/vite-env.d.ts
@@ -5,7 +5,6 @@ interface ImportMetaEnv {
   readonly VITE_ETH_HOSTNAME_HTTP: string
   readonly VITE_REFERRAL: number
   readonly VITE_TBTC_API_ENDPOINT: string
-  readonly VITE_ACRE_SUBGRAPH_URL: string
   readonly VITE_TBTC_API_ENDPOINT: string
 }
 
diff --git a/sdk/src/acre.ts b/sdk/src/acre.ts
index b30a5af46..4c074a39a 100644
--- a/sdk/src/acre.ts
+++ b/sdk/src/acre.ts
@@ -7,6 +7,7 @@ import Tbtc from "./modules/tbtc"
 import { VoidSigner } from "./lib/utils"
 import { BitcoinProvider, BitcoinNetwork } from "./lib/bitcoin"
 import { getChainIdByNetwork } from "./lib/ethereum/network"
+import AcreSubgraphApi from "./lib/api/AcreSubgraphApi"
 
 class Acre {
   readonly #tbtc: Tbtc
@@ -19,21 +20,26 @@ class Acre {
 
   public readonly staking: StakingModule
 
+  readonly #acreSubgraph: AcreSubgraphApi
+
   private constructor(
     contracts: AcreContracts,
     bitcoinProvider: BitcoinProvider,
     orangeKit: OrangeKitSdk,
     tbtc: Tbtc,
+    acreSubgraphApi: AcreSubgraphApi,
   ) {
     this.contracts = contracts
     this.#tbtc = tbtc
     this.#orangeKit = orangeKit
+    this.#acreSubgraph = acreSubgraphApi
     this.#bitcoinProvider = bitcoinProvider
     this.staking = new StakingModule(
       this.contracts,
       this.#bitcoinProvider,
       this.#orangeKit,
       this.#tbtc,
+      this.#acreSubgraph,
     )
   }
 
@@ -76,8 +82,12 @@ class Acre {
       tbtcApiUrl,
       contracts.bitcoinDepositor,
     )
+    const subgraph = new AcreSubgraphApi(
+      // TODO: Set correct url based on the network
+      "https://api.studio.thegraph.com/query/73600/acre/version/latest",
+    )
 
-    return new Acre(contracts, bitcoinProvider, orangeKit, tbtc)
+    return new Acre(contracts, bitcoinProvider, orangeKit, tbtc, subgraph)
   }
 }
 
diff --git a/sdk/src/index.ts b/sdk/src/index.ts
index aa6eb58a0..526aa4936 100644
--- a/sdk/src/index.ts
+++ b/sdk/src/index.ts
@@ -3,6 +3,7 @@ export * from "./lib/contracts"
 export * from "./lib/eip712-signer"
 export * from "./lib/ethereum"
 export * from "./lib/utils"
+export { DepositStatus } from "./lib/api/TbtcApi"
 
 export * from "./modules/staking"
 
diff --git a/sdk/src/lib/api/AcreSubgraphApi.ts b/sdk/src/lib/api/AcreSubgraphApi.ts
new file mode 100644
index 000000000..0713516b9
--- /dev/null
+++ b/sdk/src/lib/api/AcreSubgraphApi.ts
@@ -0,0 +1,145 @@
+import { ChainIdentifier } from "@keep-network/tbtc-v2.ts"
+import HttpApi from "./HttpApi"
+import { DepositStatus } from "./TbtcApi"
+
+/**
+ * Represents the response data returned form the Acre Subgraph from query that
+ * finds all deposits for a given depositor.
+ */
+type DepositDataResponse = {
+  data: {
+    deposits: {
+      /**
+       * Unique deposit identifier represented as
+       * `keccak256(bitcoinFundingTxHash | fundingOutputIndex)`.
+       */
+      id: string
+      /**
+       * Bitcoin transaction hash (or transaction ID) in the same byte order as
+       * used by the Bitcoin block explorers.
+       */
+      bitcoinTransactionId: string
+      /**
+       * Amount of tBTC tokens deposited to stBTC vault - it's equal to
+       * `bridgedAmount - depositorFee` (without the stBTC deposit fee).
+       */
+      amountToDeposit: string
+      /**
+       * Amount of Bitcoin funding transaction.
+       */
+      initialDepositAmount: string
+      /**
+       * Events associated with a given deposit.
+       */
+      events: { type: "Initialized" | "Finalized"; timestamp: string }[]
+    }[]
+  }
+}
+
+/**
+ * Represents the formatted deposit.
+ */
+type Deposit = {
+  /**
+   * Unique deposit identifier represented as `keccak256(bitcoinFundingTxHash |
+   * fundingOutputIndex)`.
+   */
+  depositKey: string
+  /**
+   * Bitcoin transaction hash (or transaction ID) in the same byte order as used
+   * by the Bitcoin block explorers.
+   */
+  txHash: string
+  /**
+   * Amount of Bitcoin funding transaction.
+   */
+  initialAmount: bigint
+  /**
+   * Amount of tBTC tokens deposited to stBTC vault - it's equal to
+   * `bridgedAmount - depositorFee` (without the stBTC deposit fee).
+   */
+  amountToDeposit: bigint
+  /**
+   * Status of the deposit.
+   */
+  status: DepositStatus
+  /**
+   * Timestamp when the deposit was initialized.
+   */
+  timestamp: number
+}
+
+export function buildGetDepositsByOwnerQuery(owner: ChainIdentifier) {
+  return `
+  query {
+    deposits(
+          where: {depositOwner_: {id: "0x${owner.identifierHex}"}}
+      ) {
+          id
+          bitcoinTransactionId
+          initialDepositAmount
+          events(orderBy: timestamp, orderDirection: asc) {
+            timestamp
+            type
+          }
+          amountToDeposit
+      }
+  }`
+}
+
+/**
+ * Class for integration with Acre Subgraph.
+ */
+export default class AcreSubgraphApi extends HttpApi {
+  /**
+   * @param depositOwnerId The deposit owner id as EVM-chain identifier.
+   * @returns All deposits for a given depositor. Returns only initialized or
+   *          finalized deposits that exist on-chain. They do not included
+   *          queued deposits stored by the tBTC API.
+   */
+  async getDepositsByOwner(
+    depositOwnerId: ChainIdentifier,
+  ): Promise<Deposit[]> {
+    const query = buildGetDepositsByOwnerQuery(depositOwnerId)
+    const response = await this.postRequest(
+      "",
+      { query },
+      { credentials: undefined },
+    )
+
+    if (!response.ok) {
+      throw new Error(
+        `Could not get deposits by deposit owner: ${response.status}`,
+      )
+    }
+
+    const responseData = (await response.json()) as DepositDataResponse
+
+    return responseData.data.deposits.map((deposit) => {
+      const {
+        bitcoinTransactionId: txHash,
+        amountToDeposit,
+        initialDepositAmount,
+        events,
+        id,
+      } = deposit
+
+      // The subgraph indexes only initialized or finalized deposits.
+      const status = events.some(({ type }) => type === "Finalized")
+        ? DepositStatus.Finalized
+        : DepositStatus.Initialized
+
+      const timestamp = parseInt(events[0].timestamp, 10)
+
+      return {
+        depositKey: id,
+        txHash,
+        initialAmount: BigInt(initialDepositAmount),
+        amountToDeposit: BigInt(amountToDeposit ?? 0),
+        type: "deposit",
+        status,
+        timestamp,
+      }
+    })
+  }
+}
diff --git a/sdk/src/lib/api/TbtcApi.ts b/sdk/src/lib/api/TbtcApi.ts
index a64c3b9fa..41db5f53f 100644
--- a/sdk/src/lib/api/TbtcApi.ts
+++ b/sdk/src/lib/api/TbtcApi.ts
@@ -1,6 +1,32 @@
-import { BitcoinTxHash, BitcoinTxOutpoint } from "@keep-network/tbtc-v2.ts"
+import {
+  BitcoinTxHash,
+  BitcoinTxOutpoint,
+  ChainIdentifier,
+} from "@keep-network/tbtc-v2.ts"
 import HttpApi from "./HttpApi"
 
+/**
+ * Represents the Deposit entity returned by the tBTC API.
+ */
+type Deposit = {
+  id: string
+  createdAt: number
+  outputIndex: number
+  owner: string
+  receipt: {
+    blindingFactor: string
+    depositor: string
+    extraData: string
+    refundLocktime: string
+    refundPublicKeyHash: string
+    walletPublicKeyHash: string
+  }
+  referral: number
+  status: DepositStatus
+  txHash: string
+  initialAmount: string
+}
+
 /**
  * Represents a class for integration with tBTC API.
  */
@@ -51,6 +77,23 @@ export default class TbtcApi extends HttpApi {
       },
     }
   }
+
+  /**
+   * @param depositOwner Depositor as EVM-chain identifier.
+   * @returns All owner deposits, including queued deposits.
+   */
+  async getDepositsByOwner(depositOwner: ChainIdentifier): Promise<Deposit[]> {
+    const response = await this.getRequest(
+      `deposits/${depositOwner.identifierHex}`,
+    )
+
+    if (!response.ok)
+      throw new Error(`Failed to fetch deposits: ${response.status}`)
+
+    const responseData = (await response.json()) as Deposit[]
+
+    return responseData
+  }
 }
 
 /**
diff --git a/sdk/src/modules/staking/index.ts b/sdk/src/modules/staking/index.ts
index fa019d62c..cc9b18547 100644
--- a/sdk/src/modules/staking/index.ts
+++ b/sdk/src/modules/staking/index.ts
@@ -5,6 +5,8 @@ import { StakeInitialization } from "./stake-initialization"
 import { fromSatoshi, toSatoshi } from "../../lib/utils"
 import Tbtc from "../tbtc"
 import { BitcoinProvider } from "../../lib/bitcoin/providers"
+import AcreSubgraphApi from "../../lib/api/AcreSubgraphApi"
+import { DepositStatus } from "../../lib/api/TbtcApi"
 
 export { DepositReceipt } from "../tbtc"
 
@@ -17,6 +19,34 @@ export type DepositFee = {
   total: bigint
 }
 
+/**
+ * Represents the deposit data.
+ */
+export type Deposit = {
+  /**
+   * Unique deposit identifier represented as
+   * `keccak256(bitcoinFundingTxHash | fundingOutputIndex)`.
+   */
+  id: string
+  /**
+   * Bitcoin transaction hash (or transaction ID) in the same byte order as
+   * used by the Bitcoin block explorers.
+   */
+  txHash: string
+  /**
+   * Amount of Bitcoin funding transaction.
+   */
+  amount: bigint
+  /**
+   * Status of the deposit.
+   */
+  status: DepositStatus
+  /**
+   * Timestamp when the deposit was initialized.
+   */
+  timestamp: number
+}
+
 /**
  * Module exposing features related to the staking.
  */
@@ -41,16 +71,23 @@ class StakingModule {
    */
   readonly #orangeKit: OrangeKitSdk
 
+  /**
+   * Acre subgraph api.
+   */
+  readonly #acreSubgraphApi: AcreSubgraphApi
+
   constructor(
     _contracts: AcreContracts,
     _bitcoinProvider: BitcoinProvider,
     _orangeKit: OrangeKitSdk,
     _tbtc: Tbtc,
+    acreSubgraphApi: AcreSubgraphApi,
   ) {
     this.#contracts = _contracts
     this.#bitcoinProvider = _bitcoinProvider
     this.#tbtc = _tbtc
     this.#orangeKit = _orangeKit
+    this.#acreSubgraphApi = acreSubgraphApi
   }
 
   /**
@@ -155,6 +192,47 @@ class StakingModule {
     const value = await this.#contracts.bitcoinDepositor.minDepositAmount()
     return toSatoshi(value)
   }
+
+  /**
+   * @returns All deposits associated with the Bitcoin address that returns the
+   *          Bitcoin Provider. They include all deposits: queued, initialized
+   *          and finalized.
+   */
+  async getDeposits(): Promise<Deposit[]> {
+    const bitcoinAddress = await this.#bitcoinProvider.getAddress()
+
+    const depositOwnerEvmAddress = EthereumAddress.from(
+      await this.#orangeKit.predictAddress(bitcoinAddress),
+    )
+
+    const subgraphData = await this.#acreSubgraphApi.getDepositsByOwner(
+      depositOwnerEvmAddress,
+    )
+
+    const initializedOrFinalizedDepositsMap = new Map(
+      subgraphData.map((data) => [data.depositKey, data]),
+    )
+
+    const tbtcData = await this.#tbtc.getDepositsByOwner(depositOwnerEvmAddress)
+
+    return tbtcData.map((deposit) => {
+      const depositFromSubgraph = initializedOrFinalizedDepositsMap.get(
+        deposit.depositKey,
+      )
+
+      const amount = toSatoshi(
+        depositFromSubgraph?.initialAmount ?? deposit.initialAmount,
+      )
+
+      return {
+        id: deposit.depositKey,
+        txHash: deposit.txHash,
+        amount,
+        status: deposit.status,
+        timestamp: deposit.timestamp,
+      }
+    })
+  }
 }
 
 export { StakingModule, StakeInitialization }
diff --git a/sdk/src/modules/staking/stake-initialization.ts b/sdk/src/modules/staking/stake-initialization.ts
index 8e5db6be7..b49be302f 100644
--- a/sdk/src/modules/staking/stake-initialization.ts
+++ b/sdk/src/modules/staking/stake-initialization.ts
@@ -143,9 +143,9 @@ class StakeInitialization {
    * @returns Transaction hash of the stake initiation transaction.
    */
   async stake(options = { retries: 5, backoffStepMs: 5_000 }): Promise<string> {
-    if (!this.#signedMessage) {
-      throw new Error("Sign message first")
-    }
+    // if (!this.#signedMessage) {
+    //   throw new Error("Sign message first")
+    // }
 
     await this.#tbtcDeposit.waitForFunding(options)
 
diff --git a/sdk/src/modules/tbtc/Tbtc.ts b/sdk/src/modules/tbtc/Tbtc.ts
index 6e0782c79..371165f1c 100644
--- a/sdk/src/modules/tbtc/Tbtc.ts
+++ b/sdk/src/modules/tbtc/Tbtc.ts
@@ -1,11 +1,15 @@
 import { ChainIdentifier, TBTC as TbtcSdk } from "@keep-network/tbtc-v2.ts"
 
-import TbtcApi from "../../lib/api/TbtcApi"
+import { ethers } from "ethers"
+import TbtcApi, { DepositStatus } from "../../lib/api/TbtcApi"
 import { BitcoinDepositor } from "../../lib/contracts"
 import { EthereumNetwork } from "../../lib/ethereum"
+import {
+  Hex,
+  IEthereumSignerCompatibleWithEthersV5 as EthereumSignerCompatibleWithEthersV5,
+} from "../../lib/utils"
 
 import Deposit from "./Deposit"
-import { IEthereumSignerCompatibleWithEthersV5 as EthereumSignerCompatibleWithEthersV5 } from "../../lib/utils"
 
 /**
  * Represents the tBTC module.
@@ -111,4 +115,34 @@ export default class Tbtc {
 
     return new Deposit(this.#tbtcApi, tbtcDeposit, revealData)
   }
+
+  /**
+   * @param depositOwner Depositor as EVM-chain identifier.
+   * @returns All owner deposits, including queued deposits.
+   */
+  async getDepositsByOwner(depositOwner: ChainIdentifier): Promise<
+    {
+      txHash: string
+      depositKey: string
+      initialAmount: bigint
+      status: DepositStatus
+      timestamp: number
+    }[]
+  > {
+    const deposits = await this.#tbtcApi.getDepositsByOwner(depositOwner)
+
+    return deposits.map((deposit) => ({
+      status: deposit.status,
+      initialAmount: BigInt(deposit.initialAmount),
+      depositKey: ethers.solidityPackedKeccak256(
+        ["bytes32", "uint32"],
+        [
+          Hex.from(deposit.txHash).reverse().toPrefixedString(),
+          deposit.outputIndex,
+        ],
+      ),
+      txHash: deposit.txHash,
+      timestamp: deposit.createdAt,
+    }))
+  }
 }
diff --git a/sdk/test/data/deposit.ts b/sdk/test/data/deposit.ts
index 39d55bb6b..568072d06 100644
--- a/sdk/test/data/deposit.ts
+++ b/sdk/test/data/deposit.ts
@@ -2,7 +2,10 @@ import { BitcoinTxHash, EthereumAddress, Hex } from "@keep-network/tbtc-v2.ts"
 import type { ChainIdentifier } from "../../src/lib/contracts"
 
 import type { DepositReceipt } from "../../src/modules/tbtc"
-import type { SaveRevealRequest } from "../lib/api/TbtcApi"
+import {
+  DepositStatus,
+  type SaveRevealRequest,
+} from "../../src/lib/api/TbtcApi"
 
 const depositTestData: {
   depositOwner: ChainIdentifier
@@ -56,4 +59,51 @@ const fundingUtxo: {
   outputIndex: 1,
 }
 
-export { depositTestData, receiptTestData, revealTestData, fundingUtxo }
+const tbtcApiDeposits = [
+  {
+    id: "ca9e0aa1-e817-4ebd-987e-22192c9d587f",
+    txHash: "1e0d6554a501ba5b0924ca81d65e1a917dcf0eca8b1fab5447bdb8aff6e079f9",
+    outputIndex: 0,
+    initialAmount: "1000000000000000",
+    receipt: {
+      depositor: "2f86fe8c5683372db667e6f6d88dcb6d55a81286",
+      blindingFactor: "9218e55872c69e7f",
+      walletPublicKeyHash: "ebef9a6ea7e6d946fc566fb0660b3c841fbd8e74",
+      refundPublicKeyHash: "970a1068ba42cc8c5a09e7d98918a3ed4d7692c0",
+      refundLocktime: "a618a967",
+      extraData:
+        "f462886f898aff2702d51674aed7c0fe05999dad007b00000000000000000000",
+    },
+    owner: "f462886f898aff2702d51674aed7c0fe05999dad",
+    referral: 123,
+    status: DepositStatus.Finalized,
+    createdAt: 1715807188,
+  },
+  {
+    id: "00aae4da-989b-46d2-bc2d-cbb234b819d9",
+    txHash: "99299f05458a0a31b1e34a375bf688bff0f488797c4171e657f62fe83e656d15",
+    outputIndex: 0,
+    initialAmount: "1100000000000000",
+    receipt: {
+      depositor: "2f86fe8c5683372db667e6f6d88dcb6d55a81286",
+      blindingFactor: "4d25ab061ae21369",
+      walletPublicKeyHash: "ebef9a6ea7e6d946fc566fb0660b3c841fbd8e74",
+      refundPublicKeyHash: "970a1068ba42cc8c5a09e7d98918a3ed4d7692c0",
+      refundLocktime: "4ec6a967",
+      extraData:
+        "f462886f898aff2702d51674aed7c0fe05999dad007b00000000000000000000",
+    },
+    owner: "f462886f898aff2702d51674aed7c0fe05999dad",
+    referral: 123,
+    status: DepositStatus.Finalized,
+    createdAt: 1715851724,
+  },
+]
+
+export {
+  depositTestData,
+  receiptTestData,
+  revealTestData,
+  fundingUtxo,
+  tbtcApiDeposits,
+}
diff --git a/sdk/test/lib/api/acre-subgraph.test.ts b/sdk/test/lib/api/acre-subgraph.test.ts
new file mode 100644
index 000000000..f47d6c687
--- /dev/null
+++ b/sdk/test/lib/api/acre-subgraph.test.ts
@@ -0,0 +1,114 @@
+import { EthereumAddress } from "@keep-network/tbtc-v2.ts"
+import { ethers } from "ethers"
+import AcreSubgraphApi, {
+  buildGetDepositsByOwnerQuery,
+} from "../../../src/lib/api/AcreSubgraphApi"
+import { DepositStatus } from "../../../src/lib/api/TbtcApi"
+
+const subgraphData = {
+  data: {
+    deposits: [
+      {
+        id: "0x35a0ef1f1b41e5dbe56f5c02c9902ca4317f587e352d9fc8859af4e569b80c1f",
+        bitcoinTransactionId:
+          "6349459ccb07419a7184577adf7a992216a214792e45ad2a689127d14c7a4cb9",
+        initialDepositAmount: "1200000000000000",
+        events: [
+          {
+            timestamp: "1714058004",
+            type: "Initialized",
+          },
+        ],
+        amountToDeposit: null,
+      },
+      {
+        id: "0x73661e3ee3c6c30988800e5fedc081f29c6540505383fcfcd172fd10f3a73139",
+        bitcoinTransactionId:
+          "6bca75ba55334c25064e7bf5333a3b39ed5bb73fb17e73ea9e55e6294e3fbf65",
+        initialDepositAmount: "1040000000000000",
+        events: [
+          {
+            timestamp: "1715856144",
+            type: "Initialized",
+          },
+          {
+            timestamp: "1715860572",
+            type: "Finalized",
+          },
+        ],
+        amountToDeposit: "536361040000000",
+      },
+    ],
+  },
+}
+
+const expectedDepositData = [
+  {
+    depositKey:
+      "0x35a0ef1f1b41e5dbe56f5c02c9902ca4317f587e352d9fc8859af4e569b80c1f",
+    txHash: "6349459ccb07419a7184577adf7a992216a214792e45ad2a689127d14c7a4cb9",
+    initialAmount: BigInt("1200000000000000"),
+    amountToDeposit: BigInt(0),
+    type: "deposit",
+    status: DepositStatus.Initialized,
+    timestamp: 1714058004,
+  },
+  {
+    depositKey:
+      "0x73661e3ee3c6c30988800e5fedc081f29c6540505383fcfcd172fd10f3a73139",
+    txHash: "6bca75ba55334c25064e7bf5333a3b39ed5bb73fb17e73ea9e55e6294e3fbf65",
+    initialAmount: BigInt("1040000000000000"),
+    amountToDeposit: BigInt("536361040000000"),
+    type: "deposit",
+    status: DepositStatus.Finalized,
+    timestamp: 1715856144,
+  },
+]
+
+describe("Acre Subgraph API", () => {
+  const subgraphApiUrl = " https://subgraph.test"
+  const subgraph = new AcreSubgraphApi(subgraphApiUrl)
+
+  describe("getDepositsByOwner", () => {
+    const depositOwnerId = EthereumAddress.from(
+      ethers.Wallet.createRandom().address,
+    )
+    const spyOnFetch = jest.spyOn(global, "fetch").mockImplementationOnce(() =>
+      // @ts-expect-error We only mock fields/methods used in the code.
+      Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(subgraphData),
+      }),
+    )
+
+    const mockedURLObject = {} as URL
+    const spyOnURL = jest
+      .spyOn(global, "URL")
+      .mockReturnValueOnce(mockedURLObject)
+
+    const query = buildGetDepositsByOwnerQuery(depositOwnerId)
+
+    let result: Awaited<ReturnType<AcreSubgraphApi["getDepositsByOwner"]>>
+
+    beforeAll(async () => {
+      result = await subgraph.getDepositsByOwner(depositOwnerId)
+    })
+
+    it("should create the URL object", () => {
+      expect(spyOnURL).toHaveBeenCalledWith("", subgraphApiUrl)
+    })
+
+    it("should send POST request", () => {
+      expect(spyOnFetch).toHaveBeenCalledWith(mockedURLObject, {
+        method: "POST",
+        body: JSON.stringify({ query }),
+        credentials: undefined,
+        headers: { "Content-Type": "application/json" },
+      })
+    })
+
+    it("should return correct data", () => {
+      expect(result).toStrictEqual(expectedDepositData)
+    })
+  })
+})
diff --git a/sdk/test/lib/api/tbtc-api.test.ts b/sdk/test/lib/api/tbtc-api.test.ts
new file mode 100644
index 000000000..a807c58e4
--- /dev/null
+++ b/sdk/test/lib/api/tbtc-api.test.ts
@@ -0,0 +1,50 @@
+import { EthereumAddress } from "@keep-network/tbtc-v2.ts"
+import { ethers } from "ethers"
+import TbtcApi from "../../../src/lib/api/TbtcApi"
+import { tbtcApiDeposits } from "../../data/deposit"
+
+describe("tTBC API", () => {
+  const tbtcApiUrl = " https://tbtc-api.test/"
+  const tbtcApi = new TbtcApi(tbtcApiUrl)
+
+  describe("getDepositsByOwner", () => {
+    const depositOwnerId = EthereumAddress.from(
+      ethers.Wallet.createRandom().address,
+    )
+    const spyOnFetch = jest.spyOn(global, "fetch").mockImplementationOnce(() =>
+      // @ts-expect-error We only mock fields/methods used in the code.
+      Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(tbtcApiDeposits),
+      }),
+    )
+
+    const mockedURLObject = {} as URL
+    const spyOnURL = jest
+      .spyOn(global, "URL")
+      .mockReturnValueOnce(mockedURLObject)
+
+    let result: Awaited<ReturnType<TbtcApi["getDepositsByOwner"]>>
+
+    beforeAll(async () => {
+      result = await tbtcApi.getDepositsByOwner(depositOwnerId)
+    })
+
+    it("should create the URL object", () => {
+      expect(spyOnURL).toHaveBeenCalledWith(
+        `deposits/${depositOwnerId.identifierHex}`,
+        tbtcApiUrl,
+      )
+    })
+
+    it("should send GET request", () => {
+      expect(spyOnFetch).toHaveBeenCalledWith(mockedURLObject, {
+        credentials: "include",
+      })
+    })
+
+    it("should return correct data", () => {
+      expect(result).toStrictEqual(tbtcApiDeposits)
+    })
+  })
+})
diff --git a/sdk/test/modules/staking.test.ts b/sdk/test/modules/staking.test.ts
index e70a42be0..4abe14287 100644
--- a/sdk/test/modules/staking.test.ts
+++ b/sdk/test/modules/staking.test.ts
@@ -8,6 +8,7 @@ import {
   EthereumAddress,
   DepositFees,
   DepositFee,
+  DepositStatus,
 } from "../../src"
 import * as satoshiConverter from "../../src/lib/utils/satoshi-converter"
 import { MockAcreContracts } from "../utils/mock-acre-contracts"
@@ -15,6 +16,7 @@ import { MockOrangeKitSdk } from "../utils/mock-orangekit"
 import { MockTbtc } from "../utils/mock-tbtc"
 import { DepositReceipt } from "../../src/modules/tbtc"
 import { MockBitcoinProvider } from "../utils/mock-bitcoin-provider"
+import AcreSubgraphApi from "../../src/lib/api/AcreSubgraphApi"
 
 const stakingModuleData: {
   initializeDeposit: {
@@ -106,11 +108,19 @@ describe("Staking", () => {
   const bitcoinProvider = new MockBitcoinProvider()
   const orangeKit = new MockOrangeKitSdk()
   const tbtc = new MockTbtc()
+  const acreSubgraph = new AcreSubgraphApi("test")
+
+  const { bitcoinDepositorAddress, predictedEthereumDepositorAddress } =
+    stakingModuleData.initializeDeposit
 
   bitcoinProvider.getAddress.mockResolvedValue(
     stakingModuleData.initializeDeposit.bitcoinDepositorAddress,
   )
 
+  orangeKit.predictAddress = jest
+    .fn()
+    .mockResolvedValue(`0x${predictedEthereumDepositorAddress.identifierHex}`)
+
   const staking: StakingModule = new StakingModule(
     contracts,
     bitcoinProvider,
@@ -118,16 +128,12 @@ describe("Staking", () => {
     // 'MockOrangeKitSdk' but required in type 'OrangeKitSdk'.
     orangeKit,
     tbtc,
+    acreSubgraph,
   )
 
   describe("initializeStake", () => {
-    const {
-      mockedDepositBTCAddress,
-      bitcoinDepositorAddress,
-      predictedEthereumDepositorAddress,
-      referral,
-      extraData,
-    } = stakingModuleData.initializeDeposit
+    const { mockedDepositBTCAddress, referral, extraData } =
+      stakingModuleData.initializeDeposit
     // TODO: Rename to `depositor`.
     const staker = predictedEthereumDepositorAddress
 
@@ -169,12 +175,6 @@ describe("Staking", () => {
 
           tbtc.initiateDeposit = jest.fn().mockReturnValue(mockedDeposit)
 
-          orangeKit.predictAddress = jest
-            .fn()
-            .mockResolvedValue(
-              `0x${predictedEthereumDepositorAddress.identifierHex}`,
-            )
-
           result = await staking.initializeStake(
             referral,
             bitcoinRecoveryAddress,
@@ -296,13 +296,13 @@ describe("Staking", () => {
               )
             })
 
-            describe("when the message has not been signed yet", () => {
-              it("should throw an error", async () => {
-                await expect(result.stake()).rejects.toThrow(
-                  "Sign message first",
-                )
-              })
-            })
+            // describe("when the message has not been signed yet", () => {
+            //   it("should throw an error", async () => {
+            //     await expect(result.stake()).rejects.toThrow(
+            //       "Sign message first",
+            //     )
+            //   })
+            // })
 
             describe("when message has already been signed", () => {
               let depositId: string
@@ -464,4 +464,97 @@ describe("Staking", () => {
       })
     })
   })
+
+  describe("getDeposits", () => {
+    const finalizedDeposit = {
+      subgraph: {
+        depositKey:
+          "0x73661e3ee3c6c30988800e5fedc081f29c6540505383fcfcd172fd10f3a73139",
+        txHash:
+          "6bca75ba55334c25064e7bf5333a3b39ed5bb73fb17e73ea9e55e6294e3fbf65",
+        initialAmount: BigInt("1040000000000000"),
+        amountToDeposit: BigInt("536361040000000"),
+        type: "deposit",
+        status: DepositStatus.Finalized,
+        timestamp: 1715807188,
+      },
+      tbtc: {
+        depositKey:
+          "0x73661e3ee3c6c30988800e5fedc081f29c6540505383fcfcd172fd10f3a73139",
+        txHash:
+          "6bca75ba55334c25064e7bf5333a3b39ed5bb73fb17e73ea9e55e6294e3fbf65",
+        initialAmount: BigInt("1040000000000000"),
+        status: DepositStatus.Finalized,
+        timestamp: 1715807188,
+      },
+    }
+
+    const queuedDeposit = {
+      txHash:
+        "96c40dcd6ef25bd27f926dc396bb8f8e7365b4746870e2d186ff001d6693a3ff",
+      depositKey:
+        "0xc6c428b14cf7c3116603b355ad3ddf029ea5119a2699090c80f99b68dd40fea4",
+      outputIndex: 0,
+      initialAmount: BigInt("1050000000000000"),
+      status: DepositStatus.Queued,
+      timestamp: 1715851724,
+    }
+
+    const spyOnSubgraphGetDeposits = jest
+      .spyOn(acreSubgraph, "getDepositsByOwner")
+      .mockResolvedValueOnce([finalizedDeposit.subgraph])
+
+    const expectedDeposits = [
+      {
+        id: queuedDeposit.depositKey,
+        txHash: queuedDeposit.txHash,
+        amount: 105000n,
+        status: DepositStatus.Queued,
+        timestamp: 1715851724,
+      },
+      {
+        id: finalizedDeposit.subgraph.depositKey,
+        txHash: finalizedDeposit.subgraph.txHash,
+        amount: 104000n,
+        status: DepositStatus.Finalized,
+        timestamp: 1715807188,
+      },
+    ]
+
+    let result: Awaited<ReturnType<StakingModule["getDeposits"]>>
+
+    beforeAll(async () => {
+      tbtc.getDepositsByOwner = jest
+        .fn()
+        .mockResolvedValue([queuedDeposit, finalizedDeposit.tbtc])
+
+      result = await staking.getDeposits()
+    })
+
+    it("should get the bitcoin address from bitcoin provider", () => {
+      expect(bitcoinProvider.getAddress).toHaveBeenCalled()
+    })
+
+    it("should get Ethereum depositor owner address", () => {
+      expect(orangeKit.predictAddress).toHaveBeenCalledWith(
+        bitcoinDepositorAddress,
+      )
+    })
+
+    it("should get deposits from subgraph", () => {
+      expect(spyOnSubgraphGetDeposits).toHaveBeenCalledWith(
+        predictedEthereumDepositorAddress,
+      )
+    })
+
+    it("should get deposits from tbtc module", () => {
+      expect(tbtc.getDepositsByOwner).toHaveBeenCalledWith(
+        predictedEthereumDepositorAddress,
+      )
+    })
+
+    it("should return correct data", () => {
+      expect(result).toStrictEqual(expectedDeposits)
+    })
+  })
 })
diff --git a/sdk/test/modules/tbtc/Tbtc.test.ts b/sdk/test/modules/tbtc/Tbtc.test.ts
index 5af2f3eca..59f34f2c0 100644
--- a/sdk/test/modules/tbtc/Tbtc.test.ts
+++ b/sdk/test/modules/tbtc/Tbtc.test.ts
@@ -1,11 +1,16 @@
 import {
+  EthereumAddress,
   EthereumNetwork,
   TBTC as TbtcSdk,
   Deposit as TbtcSdkDeposit,
 } from "@keep-network/tbtc-v2.ts"
 
-import { ZeroAddress, Provider } from "ethers"
-import { IEthereumSignerCompatibleWithEthersV5, VoidSigner } from "../../../src"
+import { ZeroAddress, Provider, ethers } from "ethers"
+import {
+  IEthereumSignerCompatibleWithEthersV5,
+  VoidSigner,
+  Hex,
+} from "../../../src"
 import Deposit from "../../../src/modules/tbtc/Deposit"
 import TbtcApi from "../../../src/lib/api/TbtcApi"
 
@@ -14,6 +19,7 @@ import {
   depositTestData,
   receiptTestData,
   revealTestData,
+  tbtcApiDeposits,
 } from "../../data/deposit"
 import { MockAcreContracts } from "../../utils/mock-acre-contracts"
 
@@ -53,6 +59,9 @@ describe("Tbtc", () => {
   const tbtcSdk: TbtcSdk = new MockTbtcSdk()
 
   const { bitcoinDepositor } = new MockAcreContracts()
+  const tbtcApi: TbtcApi = new TbtcApi(tbtcApiUrl)
+
+  const tbtc = new Tbtc(tbtcApi, tbtcSdk, bitcoinDepositor)
 
   describe("initialize", () => {
     const mockedSigner: IEthereumSignerCompatibleWithEthersV5 =
@@ -110,14 +119,6 @@ describe("Tbtc", () => {
   })
 
   describe("initiateDeposit", () => {
-    const tbtcApi: TbtcApi = new TbtcApi(tbtcApiUrl)
-
-    let tbtc: Tbtc
-
-    beforeAll(() => {
-      tbtc = new Tbtc(tbtcApi, tbtcSdk, bitcoinDepositor)
-    })
-
     describe("when Bitcoin address is empty", () => {
       it("should throw an error", async () => {
         const emptyBitcoinRecoveryAddress = ""
@@ -187,4 +188,75 @@ describe("Tbtc", () => {
       })
     })
   })
+
+  describe("getDepositsByOwner", () => {
+    const depositOwner = EthereumAddress.from(
+      ethers.Wallet.createRandom().address,
+    )
+    const spyOnSolidityPackedKeccak256 = jest.spyOn(
+      ethers,
+      "solidityPackedKeccak256",
+    )
+
+    let result: Awaited<ReturnType<Tbtc["getDepositsByOwner"]>>
+
+    beforeAll(async () => {
+      jest
+        .spyOn(tbtcApi, "getDepositsByOwner")
+        .mockResolvedValueOnce(tbtcApiDeposits)
+
+      result = await tbtc.getDepositsByOwner(depositOwner)
+    })
+
+    it("should get deposits from tbtc api", () => {
+      expect(tbtcApi.getDepositsByOwner).toHaveBeenCalledWith(depositOwner)
+    })
+
+    it("should add a deposit key to each deposit", () => {
+      const deposit1 = tbtcApiDeposits[0]
+      const deposit2 = tbtcApiDeposits[1]
+
+      expect(spyOnSolidityPackedKeccak256).toHaveBeenCalledTimes(2)
+      expect(spyOnSolidityPackedKeccak256).toHaveBeenNthCalledWith(
+        1,
+        ["bytes32", "uint32"],
+        [
+          Hex.from(deposit1.txHash).reverse().toPrefixedString(),
+          deposit1.outputIndex,
+        ],
+      )
+      expect(spyOnSolidityPackedKeccak256).toHaveBeenNthCalledWith(
+        2,
+        ["bytes32", "uint32"],
+        [
+          Hex.from(deposit2.txHash).reverse().toPrefixedString(),
+          deposit2.outputIndex,
+        ],
+      )
+    })
+
+    it("should return correct data", () => {
+      const deposit1 = tbtcApiDeposits[0]
+      const deposit2 = tbtcApiDeposits[1]
+
+      expect(result).toStrictEqual([
+        {
+          status: deposit1.status,
+          initialAmount: BigInt(deposit1.initialAmount),
+          depositKey:
+            "0x9d7edf34dd3a687437ec637f7495cde408846d1308b5ca0ade907b06c07f0be7",
+          txHash: deposit1.txHash,
+          timestamp: deposit1.createdAt,
+        },
+        {
+          status: deposit2.status,
+          initialAmount: BigInt(deposit2.initialAmount),
+          depositKey:
+            "0xcc465e44028f920712f67e48da2e2f6d1e28dacfa7d1e4c7c73cfec250c499d6",
+          txHash: deposit2.txHash,
+          timestamp: deposit2.createdAt,
+        },
+      ])
+    })
+  })
 })