Liquidity Provider (LP) API

Query and subscribe to liquidity pool data including vaults, deposits, withdrawals, and revenue tracking.

Table of Contents

• LP API Reference

  • Table of Contents

  • Queries

    • vaults

    • deposits

    • depositHistory

    • withdrawRequests

    • epochDurationDays

    • epochDurationHours

  • Subscriptions

    • lpVaults

    • lpDeposits

    • lpDepositHistory

    • lpWithdrawRequests

  • Types Reference

    • LpVault

    • LpDeposit

    • LpDepositHistoryItem

    • LpWithdrawRequest

    • RevenueInfo

  • Calculations

    • Deposit Value

    • Estimated Withdrawal Value

    • Time Until Withdrawal

    • APY Calculation

Queries

vaults

List all liquidity vaults with their metrics.

Signature:

vaults(
  where: LpVaultsFilter
  limit: Int
  offset: Int
  order_by: LpVaultsOrder
  order_desc: Boolean
): [LpVault!]!

Parameters:

• where: Filter object (optional)

  • address: Filter by vault address

• limit: Max results

• offset: Skip results

• order_by: Sort by address

• order_desc: Sort descending

Returns: Array of LpVault objects

Example - Get All Vaults:

query GetAllVaults {
  lp {
    vaults {
      address
      collateralDenom
      collateralToken {
        symbol
        name
        logoUrl
        decimals
      }
      tvl
      sharePrice
      apy
      availableAssets
      currentEpoch
      epochStart
      sharesDenom
      sharesERC20
      collateralERC20
      revenueInfo {
        RevenueCumulative
        NetProfit
        TraderLosses
        ClosedPnl
        CurrentEpochPositiveOpenPnl
        Liabilities
        Rewards
      }
    }
  }
}

Example - Get Specific Vault:

query GetVault($address: String!) {
  lp {
    vaults(where: { address: $address }) {
      address
      tvl
      sharePrice
      apy
      availableAssets
    }
  }
}

Key Fields Explained:

• tvl: Total value locked in the vault

• sharePrice: Current value of one vault share

• apy: Annual percentage yield (annualized return)

• availableAssets: Assets not currently in open positions

• currentEpoch: Current epoch number

• epochStart: Unix timestamp when current epoch started

Use Cases:

• Display vault list with metrics

• Compare vault performance

• Show available liquidity

• Calculate potential returns

---

deposits

Get user deposits in vaults.

Signature:

deposits(
  where: LpDepositsFilter
  limit: Int
  offset: Int
  order_by: LpDepositsOrder
  order_desc: Boolean
): [LpDeposit!]!

Parameters:

• where: Filter object (optional)

  • depositor: Filter by depositor address

  • vault: Filter by vault address

• limit: Max results

• offset: Skip results

• order_by: Sort by depositor or vault

• order_desc: Sort descending

Returns: Array of LpDeposit objects

Example - Get User Deposits:

query GetUserDeposits($user: String!) {
  lp {
    deposits(where: { depositor: $user }) {
      depositor
      shares
      vault {
        address
        collateralToken { symbol }
        sharePrice
        tvl
        apy
      }
    }
  }
}

Example - Calculate Deposit Value:

query CalculateDepositValue($user: String!) {
  lp {
    deposits(where: { depositor: $user }) {
      shares
      vault {
        sharePrice
        collateralToken {
          symbol
          decimals
        }
      }
    }
  }
}

To calculate value:

const value = (shares * sharePrice) / (10 ** decimals)

Use Cases:

• Display user's LP positions

• Calculate total deposited value

• Track share ownership

• Portfolio management

---

depositHistory

Get historical deposit and withdrawal events.

Signature:

depositHistory(
  where: LpDepositHistoryFilter
  limit: Int
  offset: Int
  order_by: LpDepositHistoryOrder
  order_desc: Boolean
): [LpDepositHistoryItem!]!

Parameters:

• where: Filter object (optional)

  • depositor: Filter by depositor address

  • vault: Filter by vault address

• limit: Max results

• offset: Skip results

• order_by: Sort by depositor, sequence, or vault

• order_desc: Sort descending

Returns: Array of LpDepositHistoryItem objects

Example - Get Deposit History:

query GetDepositHistory($user: String!) {
  lp {
    depositHistory(
      where: { depositor: $user }
      order_by: sequence
      order_desc: true
      limit: 50
    ) {
      id
      depositor
      amount
      shares
      isWithdraw
      vault {
        address
        collateralToken { symbol }
      }
      block {
        block
        block_ts
      }
    }
  }
}

Example - Filter Vault History:

query GetVaultHistory($vaultAddress: String!) {
  lp {
    depositHistory(
      where: { vault: $vaultAddress }
      order_by: sequence
      order_desc: true
      limit: 100
    ) {
      depositor
      amount
      shares
      isWithdraw
      block { block_ts }
    }
  }
}

Key Fields:

• isWithdraw: true for withdrawals, false for deposits

• amount: Amount of collateral deposited/withdrawn

• shares: Shares minted (deposit) or burned (withdrawal)

Use Cases:

• Build activity timeline

• Track deposit/withdrawal events

• Audit vault operations

• Calculate historical returns

---

withdrawRequests

Get pending withdrawal requests.

Signature:

withdrawRequests(
  where: LpWithdrawRequestsFilter
  limit: Int
  offset: Int
  order_by: LpWithdrawRequestsOrder
  order_desc: Boolean
): [LpWithdrawRequest!]!

Parameters:

• where: Filter object (optional)

  • depositor: Filter by depositor address

  • vault: Filter by vault address

• limit: Max results

• offset: Skip results

• order_by: Sort by depositor, unlock_epoch, or vault

• order_desc: Sort descending

Returns: Array of LpWithdrawRequest objects

Example - Get User Withdrawals:

query GetWithdrawRequests($user: String!) {
  lp {
    withdrawRequests(where: { depositor: $user }) {
      depositor
      shares
      status
      unlockEpoch
      autoRedeem
      vault {
        address
        collateralToken { symbol }
        currentEpoch
        sharePrice
      }
    }
  }
}

Example - Check Withdrawal Status:

query CheckWithdrawalReady($user: String!) {
  lp {
    withdrawRequests(where: { depositor: $user }) {
      shares
      unlockEpoch
      autoRedeem
      vault {
        currentEpoch
        sharePrice
      }
    }
  }
}

To check if ready:

const isReady = vault.currentEpoch >= unlockEpoch
const estimatedValue = (shares * vault.sharePrice) / (10 ** decimals)

Key Fields:

• status: Withdrawal request status

• unlockEpoch: Epoch when withdrawal becomes available

• autoRedeem: If true, automatically redeemed when unlocked

Use Cases:

• Display pending withdrawals

• Calculate withdrawal timing

• Show estimated withdrawal value

• Notify when ready

---

epochDurationDays

Get epoch duration in days.

Signature:

epochDurationDays: Int!

Example:

query GetEpochDuration {
  lp {
    epochDurationDays
    epochDurationHours
  }
}

---

epochDurationHours

Get epoch duration in hours.

Signature:

epochDurationHours: Int!

---

Subscriptions

Subscribe to real-time LP data updates.

lpVaults

Subscribe to all vault updates.

Signature:

subscription {
  lpVaults: [LpVault!]!
}

Example:

subscription WatchVaults {
  lpVaults {
    address
    tvl
    sharePrice
    apy
    availableAssets
    currentEpoch
  }
}

Use Cases:

• Real-time TVL tracking

• Live APY updates

• Monitor available liquidity

• Track epoch changes

---

lpDeposits

Subscribe to user deposit updates.

Signature:

subscription {
  lpDeposits(where: SubLpDepositsFilter!): [LpDeposit!]!
}

Example:

subscription WatchUserDeposits($user: String!) {
  lpDeposits(where: { depositor: $user }) {
    depositor
    shares
    vault {
      address
      sharePrice
    }
  }
}

Use Cases:

• Update user portfolio in real-time

• Track share balance changes

• Monitor position value

---

lpDepositHistory

Subscribe to deposit/withdrawal events.

Signature:

subscription {
  lpDepositHistory(where: SubLpDepositHistoryFilter!): [LpDepositHistoryItem!]!
}

Example:

subscription WatchDepositEvents($user: String!, $vault: String!) {
  lpDepositHistory(where: { depositor: $user, vault: $vault }) {
    id
    amount
    shares
    isWithdraw
    block { block_ts }
  }
}

Use Cases:

• Real-time activity feed

• Instant transaction notifications

• Live history updates

---

lpWithdrawRequests

Subscribe to withdrawal request updates.

Signature:

subscription {
  lpWithdrawRequests(where: SubLpWithdrawRequestsFilter!): [LpWithdrawRequest!]!
}

Example:

subscription WatchWithdrawals($user: String!, $vault: String!) {
  lpWithdrawRequests(where: { depositor: $user, vault: $vault }) {
    shares
    status
    unlockEpoch
    vault {
      currentEpoch
    }
  }
}

Use Cases:

• Notify when withdrawal ready

• Track withdrawal status

• Update UI when unlocked

---

Types Reference

LpVault

type LpVault {
  address: String!
  collateralDenom: String!
  collateralToken: Token!
  collateralERC20: String!
  sharesDenom: String!
  sharesERC20: String!
  tvl: Int!
  sharePrice: Float!
  apy: Float
  availableAssets: Int!
  currentEpoch: Int!
  epochStart: Int!
  revenueInfo: RevenueInfo!
}

LpDeposit

type LpDeposit {
  depositor: String!
  shares: Int!
  vault: LpVault!
}

LpDepositHistoryItem

type LpDepositHistoryItem {
  id: Int!
  depositor: String!
  amount: Int!
  shares: Int!
  isWithdraw: Boolean!
  vault: LpVault!
  block: Block!
}

LpWithdrawRequest

type LpWithdrawRequest {
  depositor: String!
  shares: Int!
  status: String!
  unlockEpoch: Int!
  autoRedeem: Boolean!
  vault: LpVault!
}

RevenueInfo

Tracks vault revenue and performance.

type RevenueInfo {
  RevenueCumulative: Int!              # Total revenue earned
  NetProfit: Int!                       # Current net profit
  TraderLosses: Int!                    # Profits from trader losses
  ClosedPnl: Int!                       # Realized PnL from closed positions
  CurrentEpochPositiveOpenPnl: Int!     # Current epoch unrealized gains
  Liabilities: Int!                     # Current liabilities (trader profits)
  Rewards: Int!                         # Rewards received
}

---

Calculations

Deposit Value

// Calculate current value of deposit
const depositValue = (shares * sharePrice) / (10 ** decimals)

Estimated Withdrawal Value

// For pending withdrawal
const estimatedValue = (shares * currentSharePrice) / (10 ** decimals)

Time Until Withdrawal

// Calculate epochs remaining
const epochsRemaining = unlockEpoch - currentEpoch

// Calculate time remaining (assuming epoch duration)
const hoursRemaining = epochsRemaining * epochDurationHours

APY Calculation

APY is calculated from historical revenue:

// Simplified APY calculation
const apy = (revenueInfo.NetProfit / tvl) * (365 / epochDurationDays)