# Aave Simple Earn Vault Data

Fetch a single vault, list vaults, and read a user’s vault positions, history, and activity.

## Vault Data Structure

Aave Simple Earn Vault data describes ERC-4626 compliant yield-bearing vaults:

- Vault identification (address, owner, share token details)
- Reserve information (underlying asset, yield strategy)
- Fee structure (performance fees, accumulated revenue, fee recipients)
- Vault metrics (total balance, user shares)

> [!NOTE]
> Include a user address to also get the user’s vault shares
> (`userShares.shares`) and their underlying balance (`userShares.balance`).

<tabgroup>
<tab label="TypeScript">

The following TypeScript interfaces illustrate the core Vault type and its related types:

```ts title="Vault"
interface Vault {
  address: EvmAddress;
  owner: EvmAddress;
  shareName: string;
  shareSymbol: string;
  usedReserve: Reserve;
  fee: PercentValue;
  totalFeeRevenue: TokenAmount;
  balance: TokenAmount;
  feesBalance: TokenAmount;
  chainId: ChainId;
  userShares?: UserVaultShares;
  recipients?: VaultFeesRecipientsConfiguration;
}
```

```ts title="VaultFeesRecipientsConfiguration"
interface VaultFeesRecipientsConfiguration {
  address: EvmAddress;
  entries: VaultFeesRecipientSplit[];
}
```

```ts title="VaultFeesRecipientSplit"
interface VaultFeesRecipientSplit {
  address: EvmAddress;
  split: PercentValue;
  isAaveLabs: boolean;
}
```

```ts title="UserVaultShares"
interface UserVaultShares {
  shares: TokenAmount;
  balance: TokenAmount;
}
```

```ts title="Reserve"
interface Reserve {
  market: MarketInfo;
  underlyingToken: Currency;
  aToken: Currency;
  vToken: Currency;
  acceptsNative?: NativeCurrency;
  size: TokenAmount;
  usdExchangeRate: BigDecimal;
  usdOracleAddress: EvmAddress;
  isFrozen: boolean;
  isPaused: boolean;
  flashLoanEnabled: boolean;
  supplyInfo: ReserveSupplyInfo;
  borrowInfo?: ReserveBorrowInfo;
  isolationModeConfig?: ReserveIsolationModeConfig; // deprecated in Aave V3.7
  eModeInfo: EmodeReserveInfo[];
  userState?: ReserveUserState;
}
```

</tab>
<tab label="GraphQL">

The following GraphQL fragments illustrate the core Vault type and its related types:

```graphql title="Vault"
fragment Vault on Vault {
  __typename
  address
  owner
  shareName
  shareSymbol
  usedReserve {
    ...Reserve
  }
  fee {
    ...PercentValue
  }
  totalFeeRevenue {
    ...TokenAmount
  }
  balance {
    ...TokenAmount
  }
  feesBalance {
    ...TokenAmount
  }
  chainId
  userShares {
    ...UserVaultShares
  }
  recipients {
    ...VaultFeesRecipientsConfiguration
  }
}
```

```graphql title="UserVaultShares"
fragment UserVaultShares on UserVaultShares {
  __typename
  shares {
    ...TokenAmount
  }
  balance {
    ...TokenAmount
  }
}
```

```graphql title="VaultFeesRecipientsConfiguration"
fragment VaultFeesRecipientsConfiguration on VaultFeesRecipientsConfiguration {
  __typename
  address
  entries {
    ...VaultFeesRecipientSplit
  }
}
```

```graphql title="VaultFeesRecipientSplit"
fragment VaultFeesRecipientSplit on VaultFeesRecipientSplit {
  __typename
  address
  split {
    ...PercentValue
  }
  isAaveLabs
}
```

```graphql title="Reserve"
fragment Reserve on Reserve {
  __typename
  market {
    ...MarketInfo
  }
  underlyingToken {
    ...Currency
  }
  aToken {
    ...Currency
  }
  vToken {
    ...Currency
  }
  acceptsNative {
    ...NativeCurrency
  }
  size {
    ...TokenAmount
  }
  usdExchangeRate
  usdOracleAddress
  isFrozen
  isPaused
  flashLoanEnabled
  supplyInfo {
    ...ReserveSupplyInfo
  }
  borrowInfo {
    ...ReserveBorrowInfo
  }
  isolationModeConfig {
    ...ReserveIsolationModeConfig
  }
  eModeInfo {
    ...EmodeReserveInfo
  }
  userState {
    ...ReserveUserState
  }
}
```

```graphql title="Common"
fragment TokenAmount on TokenAmount {
  __typename
  usdPerToken
  amount {
    ...DecimalValue
  }
  usd
}

fragment DecimalValue on DecimalValue {
  __typename
  raw
  decimals
  value
}

fragment Currency on Currency {
  __typename
  address
  imageUrl
  name
  symbol
  decimals
  chainId
}

fragment PercentValue on PercentValue {
  __typename
  raw
  decimals
  value
  formatted
}
```

</tab>
</tabgroup>
## Fetching a Single Vault

Retrieve detailed information about a specific vault including underlying reserve and user shares.

Use the `useVault` hook in React, the `vault` action in TypeScript, or the `vault` query in GraphQL to fetch detailed information about a specific vault.

<tabgroup>
<tab label="React">

```ts title="Loading State"
const { data, loading, error } = useVault({
  by: VaultRequestBy,
  chainId: ChainId,
  user: EvmAddress | undefined,
});
```

```ts title="React Suspense"
const { data } = useVault({
  by: VaultRequestBy,
  chainId: ChainId,
  user: EvmAddress | undefined,
  suspense: true,
});
```

</tab>
<tab label="TypeScript">

```ts title="Vault By Address/ChainId"
import { evmAddress, chainId } from "@aave/client";
import { vault } from "@aave/client/actions";

import { client } from "./client";

const result = await vault(client, {
  by: {
    address: evmAddress("0x1234567890abcdef1234567890abcdef12345678"),
  },
  chainId: chainId(1),
  user: evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"),
});

if (result.isErr()) {
  console.error(result.error);
} else {
  // result.value: Vault | null
  console.log(result.value);
}
```

```ts title="Vault By Transaction Hash"
import { chainId } from "@aave/client";
import { vault } from "@aave/client/actions";

import { client } from "./client";

const result = await vault(client, {
  by: {
    txHash:
      "0xeef2ffc57b99ce887edd8362c6d57e5c7a4d8c8a9b2c3d4e5f6789abc123def4",
  },
  chainId: chainId(1),
});

if (result.isErr()) {
  console.error(result.error);
} else {
  // result.value: Vault | null
  console.log(result.value);
}
```

```ts title="client.ts"
import { AaveClient } from "@aave/client";

export const client = AaveClient.create();
```

</tab>
<tab label="GraphQL">

```graphql title="Query"
query {
  vault(
    request: {
      by: {
        address: "0x1234567890abcdef1234567890abcdef12345678"

        # OR
        # txHash: "0xeef2ffc57b99ce887edd…"
      }
      chainId: 1
      user: "0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"
    }
  ) {
    address
    owner
    shareName
    shareSymbol
    fee {
      raw
      decimals
      value
      formatted
    }
    totalFeeRevenue {
      amount {
        value
      }
      usd
    }
    balance {
      amount {
        value
      }
      usd
    }
    feesBalance {
      amount {
        value
      }
      usd
    }
    usedReserve {
      underlyingToken {
        symbol
        name
        address
      }
      supplyInfo {
        apy {
          value
        }
      }
    }
    userShares {
      shares {
        amount {
          value
        }
        usd
      }
      balance {
        amount {
          value
        }
        usd
      }
    }
  }
}
```

```json title="Response"
{
  "data": {
    "vault": {
      "address": "0x1234567890abcdef1234567890abcdef12345678",
      "owner": "0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234",
      "shareName": "Aave USDC Vault Shares",
      "shareSymbol": "avUSDC",
      "fee": {
        "raw": "100000000000000000000000000",
        "decimals": 27,
        "value": "0.1",
        "formatted": "10.0"
      },
      "totalFeeRevenue": {
        "amount": {
          "value": "150.25"
        },
        "usd": "150.25"
      },
      "balance": {
        "amount": {
          "value": "50000.0"
        },
        "usd": "50000.0"
      },
      "feesBalance": {
        "amount": {
          "value": "100.00"
        },
        "usd": "100.00"
      },
      "usedReserve": {
        "underlyingToken": {
          "symbol": "USDC",
          "name": "USD Coin",
          "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
        },
        "supplyInfo": {
          "apy": {
            "value": "0.045"
          }
        }
      },
      "userShares": {
        "shares": {
          "amount": {
            "value": "1000.0"
          },
          "usd": "1025.5"
        },
        "balance": {
          "amount": {
            "value": "1025.5"
          },
          "usd": "1025.5"
        }
      }
    }
  }
}
```

</tab>
</tabgroup>
In React, fetch a specific vault by address.

<tabgroup>
<tab label="React">

```tsx title="An Ethereum Vault"
import { useVault, evmAddress, chainId } from "@aave/react";

// …

const { data, loading, error } = useVault({
  by: {
    address: evmAddress("0x1234567890abcdef1234567890abcdef12345678"),
  },
  chainId: chainId(1),
});

if (loading) {
  return Loading vault…;
}

if (error) {
  return Error: {error.message};
}

if (!data) {
  return Vault not found;
}

// data: Vault
```

</tab>
</tabgroup>
Include a user address to get user-specific vault data like shares owned.

<tabgroup>
<tab label="React">

```tsx title="With User State"
import { useVault, evmAddress, chainId } from "@aave/react";

// …

const { data, loading, error } = useVault({
  by: {
    address: evmAddress("0x1234567890abcdef1234567890abcdef12345678"),
  },
  chainId: chainId(1),
  user: evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"),
});
```

</tab>
<tab label="TypeScript">

```ts title="With User State"
import { evmAddress, chainId } from "@aave/client";
import { vault } from "@aave/client/actions";

import { client } from "./client";

const result = await vault(client, {
  by: {
    address: evmAddress("0x1234567890abcdef1234567890abcdef12345678"),
  },
  chainId: chainId(1),
  user: evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"), // Include user for userShares data
});
```

</tab>
</tabgroup>
## Listing Available Vaults

Fetch multiple vaults with filtering and pagination support.

Use the `useVaults` hook in React, the `vaults` action in TypeScript, or the `vaults` query in GraphQL to fetch paginated vaults based on filter criteria.

<tabgroup>
<tab label="React">

```ts title="Loading State"
const { data, error, loading } = useVaults({
  criteria: VaultsRequestFilterCriteria,
  pageSize: PageSize | undefined,
  user: EvmAddress | undefined,
  cursor: Cursor | undefined,
});
```

```ts title="React Suspense"
const { data } = useVaults({
  criteria: VaultsRequestFilterCriteria,
  pageSize: PageSize | undefined,
  user: EvmAddress | undefined,
  cursor: Cursor | undefined,
  suspense: true,
});
```

```ts title="VaultsRequestFilterCriteria"
interface VaultsRequestFilterCriteria {
  /** Filter by specific vault addresses */
  vaults?: VaultInput[];
  /** Filter by owner addresses */
  ownedBy?: EvmAddress[];
}

interface VaultInput {
  /** The address of the vault */
  address: EvmAddress;
  /** The chain id the vault is on */
  chainId: ChainId;
}
```

</tab>
<tab label="TypeScript">

```ts title="Vaults By Owner"
import { evmAddress, PageSize } from "@aave/client";
import { vaults } from "@aave/client/actions";

import { client } from "./client";

const result = await vaults(client, {
  criteria: {
    ownedBy: [evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234")],
  },
  pageSize: PageSize.Ten,
});

if (result.isErr()) {
  console.error(result.error);
} else {
  // result.value: PaginatedVaultsResult
  console.log(result.value);
}
```

```ts title="Vaults By Address/ChainId"
import { evmAddress, chainId, PageSize } from "@aave/client";
import { vaults } from "@aave/client/actions";

import { client } from "./client";

const result = await vaults(client, {
  criteria: {
    vaults: [
      {
        address: evmAddress("0x1234567890abcdef1234567890abcdef12345678"),
        chainId: chainId(1),
      },
    ],
  },
  pageSize: PageSize.Ten,
});

if (result.isErr()) {
  console.error(result.error);
} else {
  // result.value.items: Vault[]
  // result.value.pageInfo.next: Cursor | null
  // result.value.pageInfo.prev: Cursor | null
  console.log(result.value);
}
```

```ts title="client.ts"
import { AaveClient } from "@aave/client";

export const client = AaveClient.create();
```

</tab>
<tab label="GraphQL">

```graphql title="Query"
query {
  vaults(
    request: {
      criteria: {
        ownedBy: ["0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"]

        # OR
        # vaults: [
        #   {
        #     address: "0x1234567890abcdef1234567890abcdef12345678",
        #     chainId: 1,
        #   },
        # ],
      }
      pageSize: TEN
      user: "0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"
    }
  ) {
    items {
      address
      owner
      shareName
      shareSymbol
      fee {
        raw
        decimals
        value
        formatted
      }
      totalFeeRevenue {
        amount {
          value
        }
        usd
      }
      balance {
        amount {
          value
        }
        usd
      }
      feesBalance {
        amount {
          value
        }
        usd
      }
      chainId
    }
    pageInfo {
      next
      prev
    }
  }
}
```

```json title="Response"
{
  "data": {
    "vaults": {
      "items": [
        {
          "address": "0x1234567890abcdef1234567890abcdef12345678",
          "owner": "0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234",
          "shareName": "Aave USDC Vault Shares",
          "shareSymbol": "avUSDC",
          "fee": {
            "raw": "100000000000000000000000000",
            "decimals": 27,
            "value": "0.1",
            "formatted": "10.0"
          },
          "totalFeeRevenue": {
            "amount": {
              "value": "150.25"
            },
            "usd": "150.25"
          },
          "balance": {
            "amount": {
              "value": "50000.0"
            },
            "usd": "50000.0"
          },
          "feesBalance": {
            "amount": {
              "value": "100.00"
            },
            "usd": "100.00"
          },
          "chainId": 1
        }
      ],
      "pageInfo": {
        "next": null,
        "prev": null
      }
    }
  }
}
```

</tab>
</tabgroup>
In React, fetch vaults owned by a specific address.

<tabgroup>
<tab label="React">

```tsx title="Owned Vaults"
import { useVaults, evmAddress, PageSize } from "@aave/react";

// …

const { data, error, loading } = useVaults({
  criteria: {
    ownedBy: [evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234")],
  },
  pageSize: PageSize.Ten,
});

if (loading) {
  return Loading…;
}

if (error) {
  return {error.message};
}

// data.items: Vault[]
// data.pageInfo.next: Cursor | null
// data.pageInfo.prev: Cursor | null
```

</tab>
</tabgroup>
Include a user address to get user-specific vault data like shares owned.

<tabgroup>
<tab label="React">

```tsx title="With User State"
import { useVaults, evmAddress, PageSize } from "@aave/react";

// …

const { data, loading, error } = useVaults({
  criteria: {
    ownedBy: [evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234")],
  },
  pageSize: PageSize.Ten,
  user: evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"),
});
```

</tab>
<tab label="TypeScript">

```ts title="With User State"
import { evmAddress, PageSize } from "@aave/client";
import { vaults } from "@aave/client/actions";

import { client } from "./client";

const result = await vaults(client, {
  criteria: {
    ownedBy: [evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234")],
  },
  pageSize: PageSize.Ten,
  user: evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"), // Include user for userShares data
});
```

</tab>
</tabgroup>
## User Vault Positions

Track user vault positions and shares across Aave Simple Earn Vaults.

Use the `useUserVaults` hook in React, the `userVaults` action in TypeScript, or the `userVaults` query in GraphQL to fetch paginated vaults that a user has shares in.

<tabgroup>
<tab label="React">

```ts title="Loading State"
const { data, loading, error } = useUserVaults({
  user: EvmAddress,
  filters: UserVaultsFilter | undefined,
  orderBy: UserVaultsOrderBy | undefined,
  pageSize: PageSize | undefined,
  cursor: Cursor | undefined,
});
```

```ts title="React Suspense"
const { data } = useUserVaults({
  user: EvmAddress,
  filters: UserVaultsFilter | undefined,
  orderBy: UserVaultsOrderBy | undefined,
  pageSize: PageSize | undefined,
  cursor: Cursor | undefined,
  suspense: true,
});
```

</tab>
<tab label="TypeScript">

```ts title="userVaults"
import { evmAddress, PageSize, OrderDirection } from "@aave/client";
import { userVaults } from "@aave/client/actions";

import { client } from "./client";

const result = await userVaults(client, {
  user: evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"),
  orderBy: { shares: OrderDirection.Desc },
  pageSize: PageSize.Ten,
});

if (result.isErr()) {
  console.error("User vaults error:", result.error);
} else {
  // result.value.items: Vault[]
  // result.value.pageInfo.next: Cursor | null
  // result.value.pageInfo.prev: Cursor | null
  console.log(result.value);
}
```

```ts title="client.ts"
import { AaveClient } from "@aave/client";

export const client = AaveClient.create();
```

</tab>
<tab label="GraphQL">

```graphql title="Query"
query {
  userVaults(
    request: {
      user: "0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"
      orderBy: { shares: DESC }
      pageSize: FIFTY
    }
  ) {
    items {
      address
      shareName
      shareSymbol
      usedReserve {
        underlyingToken {
          symbol
          name
        }
      }
      userShares {
        shares {
          amount {
            value
          }
          usd
        }
        balance {
          amount {
            value
          }
          usd
        }
      }
    }
    pageInfo {
      next
      prev
    }
  }
}
```

```json title="Response"
{
  "data": {
    "userVaults": {
      "items": [
        {
          "address": "0x1234567890abcdef1234567890abcdef12345678",
          "shareName": "Aave USDC Vault Shares",
          "shareSymbol": "avUSDC",
          "usedReserve": {
            "underlyingToken": {
              "symbol": "USDC",
              "name": "USD Coin"
            }
          },
          "userShares": {
            "shares": {
              "amount": {
                "value": "1000.0"
              },
              "usd": "1025.5"
            },
            "balance": {
              "amount": {
                "value": "1025.5"
              },
              "usd": "1025.5"
            }
          }
        }
      ],
      "pageInfo": {
        "next": null,
        "prev": null
      }
    }
  }
}
```

</tab>
</tabgroup>
In React, fetch user vaults ordered by shares amount.

<tabgroup>
<tab label="React">

```tsx title="User Vaults"
import {
  useUserVaults,
  evmAddress,
  PageSize,
  OrderDirection,
} from "@aave/react";

// …

const { data, error, loading } = useUserVaults({
  user: evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"),
  orderBy: { shares: OrderDirection.Desc },
  pageSize: PageSize.Fifty,
});

if (error) {
  return Error: {error.message};
}

if (loading) {
  return Loading positions…;
}

// data.items: Vault[]
// data.pageInfo.next: Cursor | null
// data.pageInfo.prev: Cursor | null
```

</tab>
</tabgroup>
## User Vault Transaction History

Track user vault transaction history.

Use the `useVaultUserTransactionHistory` hook in React, the `vaultUserTransactionHistory` action in TypeScript, or the `vaultUserTransactionHistory` query in GraphQL to fetch a paginated user’s vault transaction history.

<tabgroup>
<tab label="React">

```ts title="Loading State"
const { data, loading, error } = useVaultUserTransactionHistory({
  user: EvmAddress,
  vault: EvmAddress,
  chainId: ChainId,
  filters: VaultUserHistoryAction | undefined,
  orderBy: VaultUserTransactionHistoryOrderBy | undefined,
  pageSize: PageSize | undefined,
  cursor: Cursor | undefined,
});
```

```ts title="React Suspense"
const { data } = useVaultUserTransactionHistory({
  user: EvmAddress,
  vault: EvmAddress,
  chainId: ChainId,
  filters: VaultUserHistoryAction | undefined,
  orderBy: VaultUserTransactionHistoryOrderBy | undefined,
  pageSize: PageSize | undefined,
  cursor: Cursor | undefined,
  suspense: true,
});
```

</tab>
<tab label="TypeScript">

```ts title="vaultUserTransactionHistory"
import { evmAddress, chainId, PageSize, OrderDirection } from "@aave/client";
import { vaultUserTransactionHistory } from "@aave/client/actions";

import { client } from "./client";

const result = await vaultUserTransactionHistory(client, {
  user: evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"),
  vault: evmAddress("0x1234567890abcdef1234567890abcdef12345678"),
  chainId: chainId(1),
  orderBy: { date: OrderDirection.Desc },
  pageSize: PageSize.Ten,
});

if (result.isErr()) {
  console.error("User vault transactions error:", result.error);
} else {
  // result.value.items: VaultUserTransactionHistoryItem[]
  // result.value.pageInfo.next: Cursor | null
  // result.value.pageInfo.prev: Cursor | null
  console.log(result.value);
}
```

```ts title="client.ts"
import { AaveClient } from "@aave/client";

export const client = AaveClient.create();
```

</tab>
<tab label="GraphQL">

```graphql title="Query"
query {
  vaultUserTransactionHistory(
    request: {
      user: "0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"
      vault: "0x1234567890abcdef1234567890abcdef12345678"
      chainId: 1
      orderBy: { date: DESC }
      pageSize: FIFTY
    }
  ) {
    items {
      ... on VaultUserDepositItem {
        asset {
          usd
          usdPerToken
          amount {
            raw
            decimals
            value
          }
        }
        shares {
          usd
          usdPerToken
          amount {
            raw
            decimals
            value
          }
        }
        blockExplorerUrl
        txHash
        timestamp
      }
      ... on VaultUserWithdrawItem {
        asset {
          usd
          usdPerToken
          amount {
            raw
            decimals
            value
          }
        }
        shares {
          usd
          usdPerToken
          amount {
            raw
            decimals
            value
          }
        }
        blockExplorerUrl
        txHash
        timestamp
      }
    }
    pageInfo {
      next
      prev
    }
  }
}
```

```json title="Response"
{
  "data": {
    "vaultUserTransactionHistory": {
      "items": [
        {
          "asset": {
            "usd": "1000.0",
            "usdPerToken": "1.0",
            "amount": {
              "raw": "1000000000",
              "decimals": 6,
              "value": "1000.0"
            }
          },
          "shares": {
            "usd": "1000.0",
            "usdPerToken": "1.0",
            "amount": {
              "raw": "1000000000",
              "decimals": 6,
              "value": "1000.0"
            }
          },
          "blockExplorerUrl": "https://etherscan.io/tx/0xeef2ffc57b99ce887edd8362c6d57e5c7a4d8c8a9b2c3d4e5f6789abc123def4",
          "txHash": "0xeef2ffc57b99ce887edd8362c6d57e5c7a4d8c8a9b2c3d4e5f6789abc123def4",
          "timestamp": "2021-01-01T00:00:00Z"
        }
      ],
      "pageInfo": {
        "next": null,
        "prev": null
      }
    }
  }
}
```

</tab>
</tabgroup>
In React, fetch user vault transaction history ordered by date.

<tabgroup>
<tab label="React">

```tsx title="User Vault Transactions"
import {
  useVaultUserTransactionHistory,
  evmAddress,
  chainId,
  PageSize,
  OrderDirection,
} from "@aave/react";

// …

const { data, error, loading } = useVaultUserTransactionHistory({
  user: evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"),
  vault: evmAddress("0x1234567890abcdef1234567890abcdef12345678"),
  chainId: chainId(1),
  orderBy: { date: OrderDirection.Desc },
  pageSize: PageSize.Fifty,
});

if (error) {
  return Error: {error.message};
}

if (loading) {
  return Loading transactions…;
}

// data.items: VaultUserTransactionHistoryItem[]
// data.pageInfo.next: Cursor | null
// data.pageInfo.prev: Cursor | null
```

</tab>
</tabgroup>
## Vault User Activity

Return a user’s activity for a vault, including earnings breakdowns over time.

Use the `useVaultUserActivity` hook in React, the `vaultUserActivity` action in TypeScript, or the `vaultUserActivity` query in GraphQL to fetch the user’s activity for a vault.

<tabgroup>
<tab label="React">

```ts title="Loading State"
const { data, loading, error } = useVaultUserActivity({
  user: EvmAddress,
  vault: EvmAddress,
  chainId: ChainId,
  window: VaultUserActivityTimeWindow,
});
```

```ts title="React Suspense"
const { data } = useVaultUserActivity({
  user: EvmAddress,
  vault: EvmAddress,
  chainId: ChainId,
  window: VaultUserActivityTimeWindow,
  suspense: true,
});
```

</tab>
<tab label="TypeScript">

```ts title="vaultUserActivity"
import { evmAddress, chainId, VaultUserActivityTimeWindow } from "@aave/client";
import { vaultUserActivity } from "@aave/client/actions";

import { client } from "./client";

const result = await vaultUserActivity(client, {
  user: evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"),
  vault: evmAddress("0x1234567890abcdef1234567890abcdef12345678"),
  chainId: chainId(1),
  window: VaultUserActivityTimeWindow.LastWeek,
});

if (result.isErr()) {
  console.error("User vault activity error:", result.error);
} else {
  // result.value: VaultUserActivityResult
}
```

```ts title="client.ts"
import { AaveClient } from "@aave/client";

export const client = AaveClient.create();
```

</tab>
<tab label="GraphQL">

```graphql title="Query"
query {
  vaultUserActivity(
    request: {
      user: "0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"
      vault: "0x1234567890abcdef1234567890abcdef12345678"
      chainId: 1
      window: LAST_WEEK
    }
  ) {
    earned {
      usd
      usdPerToken
      amount {
        raw
        decimals
        value
      }
    }
    breakdown {
      balance {
        usd
        usdPerToken
        amount {
          raw
          decimals
          value
        }
      }
      earned {
        usd
        usdPerToken
        amount {
          raw
          decimals
          value
        }
      }
      withdrew {
        usd
        usdPerToken
        amount {
          raw
          decimals
          value
        }
      }
      deposited {
        usd
        usdPerToken
        amount {
          raw
          decimals
          value
        }
      }
      date
    }
  }
}
```

```json title="Response"
{
  "data": {
    "vaultUserActivity": {
      "earned": {
        "usd": "1000.0",
        "usdPerToken": "1.0",
        "amount": {
          "raw": "1000000000",
          "decimals": 6,
          "value": "1000.0"
        }
      },
      "breakdown": [
        {
          "balance": {
            "usd": "1000.0",
            "usdPerToken": "1.0",
            "amount": {
              "raw": "1000000000",
              "decimals": 6,
              "value": "1000.0"
            }
          },
          "earned": {
            "usd": "1000.0",
            "usdPerToken": "1.0",
            "amount": {
              "raw": "1000000000",
              "decimals": 6,
              "value": "1000.0"
            }
          },
          "withdrew": null,
          "deposited": null,
          "date": "2021-01-01T00:00:00Z"
        }
      ]
    }
  }
}
```

</tab>
</tabgroup>
In React, fetch the user’s vault activity.

<tabgroup>
<tab label="React">

```tsx title="User Vault Activity"
import {
  useVaultUserActivity,
  evmAddress,
  chainId,
  VaultUserActivityTimeWindow,
} from "@aave/react";

// …

const { data, error, loading } = useVaultUserActivity({
  user: evmAddress("0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234"),
  vault: evmAddress("0x1234567890abcdef1234567890abcdef12345678"),
  chainId: chainId(1),
  window: VaultUserActivityTimeWindow.LastWeek,
});

if (error) {
  return Error: {error.message};
}

if (loading) {
  return Loading transactions…;
}

// data: VaultUserActivityResult
```

</tab>
</tabgroup>