LP API Reference

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

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)