🐝Wasabee DEX ABI

special terms

• factory: a factory is a contract that creates pools, and global variables are stored in the factory entity.

• whitelisted tokens: tokens that are manually added to the platform by the hpot team, usually tokens with a large market cap and high liquidity.

• untracked: Untracked means that the trade amount is not traded with our platform whitelisted tokens (e.g. Honey, USDC, etc.).

navigation

• Global Variables

• Token

  • Account Holding Token

• Pool

  • Pool Hour Data

  • Pool Day Data

  • Pool Week Data

  • Pool Month Data

  • Mints

  • Burns

  • Swaps

  • Collects

  • Ticks

  • Positions

• Vaults

  • vault Shares

  • vault Deposits

  • vault Withdraws

  • vault Approvals

  • vault Affiliates

  • vault Hysteresis

  • vault Collect Fees

  • Max Total Supply

  • Vault Ownership Transferred

  • Vault Rebalance

  • Vault Set Twap Period

  • Vault Transfer

• Pot2Pump

  • Participant

  • Participant Transaction History

  • DepositRaisedToken

  • Refund

  • ClaimLp

• Account

  • Account Holding Token

• Transaction

  • Mint

  • Burn

  • Swap

  • Collect

  • Flash

  • Deposit

  • Withdraw

  • DepositRaisedToken

  • Refund

  • ClaimLp

highlighted usage of queries

• pot2pump newly launched

• pot2pump near success launch

• pot2pump trending launch

• user active positions

• get pool by token pair

• get account vault shares

1. Global Variables

global variables are stored in the factory entity.

factory fields:

• id(string): the address of the factory.

• poolCount(BigInt): the number of pools created by the factory.

• txCount(BigInt): the number of transactions executed with hpot products.

• totalVolumeUSD(BigDecimal): the total volume of the factory in USD.

• totalVolumeMatic(BigDecimal): the total volume of the factory in Matic.

• totalFeesUSD(BigDecimal): the total fees gained by the factory in USD.

• totalFeesMatic(BigDecimal): the total fees gained by the factory in Matic.

• untrackedVolumeUSD(BigDecimal): the untracked volume of the factory in USD.

• totalValueLockedUSD(BigDecimal): the total value locked of the factory in USD.

• totalValueLockedMatic(BigDecimal): the total value locked of the factory in Matic.

• accountCount(BigInt): the number of accounts that have interacted with hpot products.

example query to get global variables:

query {
  factories {
    id
    poolCount
    txCount
    totalVolumeUSD
    totalVolumeMatic
    totalFeesUSD
    totalFeesMatic
    untrackedVolumeUSD
    totalValueLockedUSD
    totalValueLockedMatic
    accountCount
  }
}

2. Pool

pool fields:

• id(string): the address of the pool.

• token0(token entity): the entity of the first token in the pool.

• token1(token entity): the entity of the second token in the pool.

• createdAtTimestamp(BigInt): the timestamp of the pool creation.

• createdAtBlockNumber(BigInt): the block number of the pool creation.

• plugin(string): the address of the plugin of the pool.

• fee(int): current fee percentage of the pool.

• liquidity(BigDecimal): the liquidity of the pool.

• token0Price(BigDecimal): the price of token0 in the pool.

• token1Price(BigDecimal): the price of token1 in the pool.

• tick(int): current tick of the pool.

• volumeToken0(BigDecimal): the total volume of token0 in the pool.

• volumeToken1(BigDecimal): the total volume of token1 in the pool.

• volumeUSD(BigDecimal): the total volume of the pool in USD.

• untrackedVolumeUSD(BigDecimal): the untracked volume of the pool in USD.

• feesUSD(BigDecimal): the total fees gained by the pool in USD.

• tickSpacing(int): the tick spacing of the pool.

• untrackedFeesUSD(BigDecimal): the total untracked fees of the pool in USD.

• txCount(BigInt): the number of transactions executed with the pool.

• collectedFeesToken0(BigDecimal): the collected fees of token0 in the pool.

• collectedFeesToken1(BigDecimal): the collected fees of token1 in the pool.

• collectedFeesUSD(BigDecimal): the collected fees of the pool in USD.

• totalValueLockedToken0(BigDecimal): the total value locked of token0 in the pool.

• totalValueLockedToken1(BigDecimal): the total value locked of token1 in the pool.

• feesToken0(BigDecimal): the fees of token0 gained by the pool.

• feesToken1(BigDecimal): the fees of token1 gained by the pool.

• totalValueLockedMatic(BigDecimal): the total value locked of the pool in Matic.

• totalValueLockedUSD(BigDecimal): the total value locked of the pool in USD.

• totalValueLockedUSDUntracked(BigDecimal): the total value locked of the pool in USD(untracked).

• searchString(string): the search string of the pool, combination of token0 and token1 symbols and pool address in lowercase.

• aprPercentage(BigDecimal): the APR percentage of the pool(untracked).

• liquidityProviderCount(BigInt): the number of liquidity providers in the pool.

• vaults(vaults entity): the vaults entity of the pool.

• Time range data:

  • poolHourData( poolHourData entity): the hourly data entities of the pool.

  • poolDayData(poolDayData entity): the daily data entities of the pool.

  • poolWeekData(poolWeekData entity): the weekly data entities of the pool.

  • poolMonthData(poolMonthData entity): the monthly data entities of the pool.

• events:

  • mints(mints entity): the mints transaction entities of the pool.

  • burns(burns entity): the burns transaction entities of the pool.

  • swaps(swaps entity): the swaps transaction entities of the pool.

  • collects(collects entity): the collects transaction entities of the pool.

  • ticks(ticks entity): the ticks entities of the pool.

Example query to get detailed pool data:

query {
  pools {
    id
    token0 {
      id
      symbol
      name
      decimals
    }
    token1 {
      id
      symbol
      name
      decimals
    }
    fee
    liquidity
    token0Price
    token1Price
    tick
    volumeToken0
    volumeToken1
    volumeUSD
    untrackedVolumeUSD
    feesUSD
    tickSpacing
    untrackedFeesUSD
    txCount
    collectedFeesToken0
    collectedFeesToken1
    collectedFeesUSD
    totalValueLockedToken0
    totalValueLockedToken1
    feesToken0
    feesToken1
    totalValueLockedMatic
    totalValueLockedUSD
    totalValueLockedUSDUntracked
    liquidityProviderCount
    poolHourData(orderBy: periodStartUnix, orderDirection: desc, first: 24) {
      id
      periodStartUnix
      volumeToken0
      volumeToken1
      volumeUSD
      untrackedVolumeUSD
      feesUSD
      txCount
      aprPercentage
    }
    poolDayData(orderBy: date, orderDirection: desc, first: 7) {
      id
      date
      volumeToken0
      volumeToken1
      volumeUSD
      untrackedVolumeUSD
      feesUSD
      txCount
      aprPercentage
    }
    poolWeekData(orderBy: week, orderDirection: desc, first: 4) {
      id
      week
      volumeToken0
      volumeToken1
      volumeUSD
      untrackedVolumeUSD
      feesUSD
      txCount
      aprPercentage
    }
    poolMonthData(orderBy: month, orderDirection: desc, first: 12) {
      id
      month
      volumeToken0
      volumeToken1
      volumeUSD
      untrackedVolumeUSD
      feesUSD
      txCount
      aprPercentage
    }
    mints(orderBy: timestamp, orderDirection: desc, first: 10) {
      id
      timestamp
      amount0
      amount1
      amountUSD
    }
    burns(orderBy: timestamp, orderDirection: desc, first: 10) {
      id
      timestamp
      amount0
      amount1
      amountUSD
    }
    swaps(orderBy: timestamp, orderDirection: desc, first: 10) {
      id
      timestamp
      amount0
      amount1
      amountUSD
      sender
      recipient
    }
  }
}

get pool by token pair query

# @param token0: token0 address
# @param token1: token1 address
query PoolsByTokenPair($token0: ID!, $token1: ID!) {
  pools(where: { token0_: { id: $token0 }, token1_: { id: $token1 } }) {
    ...PoolFields
  }
}

3. Pool Hour Data

poolHourData fields:

• id(string): the id of the pool hour data

• periodStartUnix(BigInt): the timestamp of the pool hour data

• volumeToken0(BigInt): the volume of token0 in the pool hour data

• volumeToken1(BigInt): the volume of token1 in the pool hour data

• volumeUSD(BigInt): the volume of the pool in USD in the pool hour data

• untrackedVolumeUSD(BigInt): the untracked volume of the pool in USD in the pool hour data

• feesUSD(BigInt): the fees of the pool in USD in the pool hour data

• txCount(BigInt): the number of transactions executed with the pool in the pool hour data

• aprPercentage(BigDecimal): average apr of this pool hour data

• pool(entity): the pool entity of the pool hour data

Example query to get pool hour data:

query {
  poolHourData(orderBy: periodStartUnix, orderDirection: desc, first: 24) {
    id
    periodStartUnix
    volumeToken0
    volumeToken1
    volumeUSD
    untrackedVolumeUSD
    feesUSD
    txCount
    aprPercentage
  }
}

4. Pool Day Data

poolDayData fields:

• id(string): the id of the pool day data

• date(BigInt): the timestamp of the pool day data

• volumeToken0(BigInt): the volume of token0 in the pool day data

• volumeToken1(BigInt): the volume of token1 in the pool day data

• volumeUSD(BigInt): the volume of the pool in USD in the pool day data

• untrackedVolumeUSD(BigInt): the untracked volume of the pool in USD in the pool day data

• feesUSD(BigInt): the fees of the pool in USD in the pool day data

• txCount(BigInt): the number of transactions executed with the pool in the pool day data

• aprPercentage(BigDecimal): average apr of this pool day data

• pool(pool entity): the pool entity of the pool day data

example query to get pool day data:

query {
  poolDayData(orderBy: date, orderDirection: desc, first: 7) {
    id
    date
    volumeToken0
    volumeToken1
    volumeUSD
    untrackedVolumeUSD
    feesUSD
    txCount
    aprPercentage
  }
}

5. Pool Week Data

poolWeekData fields:

• id(string): the id of the pool week data

• week(BigInt): the timestamp of the pool week data

• volumeToken0(BigInt): the volume of token0 in the pool week data

• volumeToken1(BigInt): the volume of token1 in the pool week data

• volumeUSD(BigInt): the volume of the pool in USD in the pool week data

• untrackedVolumeUSD(BigInt): the untracked volume of the pool in USD in the pool week data

• feesUSD(BigInt): the fees of the pool in USD in the pool week data

• txCount(BigInt): the number of transactions executed with the pool in the pool week data

• aprPercentage(BigDecimal): average apr of this pool week data

• pool(pool entity): the pool entity of the pool week data

example query to get pool week data:

query {
  poolWeekData(orderBy: week, orderDirection: desc, first: 4) {
    id
    week
    volumeToken0
    volumeToken1
    volumeUSD
    untrackedVolumeUSD
    feesUSD
    txCount
    aprPercentage
  }
}

6. Pool Month Data

poolMonthData fields:

• id(string): the id of the pool month data

• month(BigInt): the timestamp of the pool month data

• volumeToken0(BigInt): the volume of token0 in the pool month data

• volumeToken1(BigInt): the volume of token1 in the pool month data

• volumeUSD(BigInt): the volume of the pool in USD in the pool month data

• untrackedVolumeUSD(BigInt): the untracked volume of the pool in USD in the pool month data

• feesUSD(BigInt): the fees of the pool in USD in the pool month data

• txCount(BigInt): the number of transactions executed with the pool in the pool month data

• aprPercentage(BigDecimal): average apr of this pool month data

• pool(pool entity): the pool entity of the pool month data

example query to get pool month data:

query {
  poolMonthData(orderBy: month, orderDirection: desc, first: 12) {
    id
    month
    volumeToken0
    volumeToken1
    volumeUSD
    untrackedVolumeUSD
    feesUSD
    txCount
    aprPercentage
  }
}

7. Mints

mints fields:

• id(string): the id of the mint transaction

• transaction(transaction entity): the transaction entity of the mint transaction

• timestamp(BigInt): the timestamp of the mint transaction

• pool(pool entity): the pool entity of the mint transaction

• amount(BigInt): liquidity minted

• amount0(BigDecimal): amount of token0 minted

• amount1(BigDecimal): amount of token1 minted

• amountUSD(BigDecimal): amount of liquidity minted in USD

• token0(token entity): the token0 entity of the pool

• token1(token entity): the token1 entity of the pool

• tickLower(int): the tick lower of the minted position

• tickUpper(int): the tick upper of the minted position

• owner(address): owner of the minted position

• origin(string): the EOA that initiated the txn

example query to get mints:

query {
  mints(orderBy: timestamp, orderDirection: desc, first: 10) {
    id
    timestamp
    amount0
    amount1
    amountUSD
  }
}

8. Burns

burns fields:

• id(string): the id of the burn transaction

• transaction(transaction entity): the transaction entity of the burn transaction

• timestamp(BigInt): the timestamp of the burn transaction

• pool(pool entity): the pool entity of the burn transaction

• amount(BigInt): liquidity burned

• amount0(BigDecimal): amount of token0 burned

• amount1(BigDecimal): amount of token1 burned

• amountUSD(BigDecimal): amount of liquidity burned in USD

• token0(token entity): the token0 entity of the pool

• token1(token entity): the token1 entity of the pool

• tickLower(int): the tick lower of the burned position

• tickUpper(int): the tick upper of the burned position

• owner(address): owner of the burned position

• origin(string): the EOA that initiated the txn

example query to get burns:

query {
  burns(orderBy: timestamp, orderDirection: desc, first: 10) {
    id
    timestamp
    amount0
    amount1
    amountUSD
  }
}

9. Swaps

swaps fields:

• id(string): the id of the swap transaction

• transaction(transaction entity): the transaction entity of the swap transaction

• timestamp(BigInt): the timestamp of the swap transaction

• pool(pool entity): the pool entity of the swap transaction

• amount0(BigDecimal): amount of token0 swapped

• amount1(BigDecimal): amount of token1 swapped

• amountUSD(BigDecimal): amount of liquidity swapped in USD

• token0(token entity): the token0 entity of the pool

• token1(token entity): the token1 entity of the pool

• sender(address): the sender of the swap transaction

• recipient(address): the recipient of the swap transaction

example query to get swaps:

query {
  swaps(orderBy: timestamp, orderDirection: desc, first: 10) {
    id
    timestamp
    amount0
    amount1
    amountUSD
  }
}

10. Collects

• id(string): the id of the collect transaction

• transaction(transaction entity): the transaction entity of the collect transaction

• timestamp(BigInt): the timestamp of the collect transaction

• pool(pool entity): the pool entity of the collect transaction

• amount0(BigDecimal): amount of token0 collected

• amount1(BigDecimal): amount of token1 collected

• amountUSD(BigDecimal): amount of liquidity collected in USD

• token0(token entity): the token0 entity of the pool

• token1(token entity): the token1 entity of the pool

• tickLower(int): the tick lower of the collected position

• tickUpper(int): the tick upper of the collected position

• owner(address): owner of the collected position

example query to get collects:

query {
  collects(orderBy: timestamp, orderDirection: desc, first: 10) {
    id
    timestamp
    amount0
    amount1
    amountUSD
  }
}

11. Ticks

tick fields:

• id(string): the id of the tick

• poolAddress(string): the address of the pool

• tickIdx(BigInt): the index of the tick

• pool(pool entity): the pool entity of the tick

• liquidityGross(BigInt): the gross liquidity of the tick

• liquidityNet(BigInt): the net liquidity of the tick

• price0(BigDecimal): the price of token0 in the tick

• price1(BigDecimal): the price of token1 in the tick

example query to get ticks:

query {
  ticks(orderBy: tickIdx, orderDirection: asc, first: 10) {
    id
    poolAddress
    tickIdx
    liquidityGross
    liquidityNet
    price0
    price1
  }
}

12. Vaults

the entity for vault is ichiVault, this is developed from by aquabera team

vaults fields:

• id(string): the address of the vault

• sender(address): the sender of the vault

• tokenA(address): the address of the first token in the vault

• allowTokenA(boolean): whether the first token is allowed to deposit

• tokenB(address): the address of the second token in the vault

• allowTokenB(boolean): whether the second token is allowed to deposit

• count(BigInt): the number of vaults that have been created to date, can be see as index of this vault

• holdersCount(int): the number of holders have hold shares in this vault

• pool(pool entity): the pool entity of the vault

• totalShares(BigDecimal): the total number of shares in the vault, this could be used to calculate token amount and user amount

• searchString(string): the search string of the vault, combination of token0 and token1 symbols and pool address in lowercase

• entities: the entities of the vault

  • vaultShares(vaultShares entity): the vault shares entity of the vault

  • vaultDeposits(vaultDeposits entity): the vault deposits entity of the vault

  • vaultWithdraws(vaultWithdraws entity): the vault withdraws entity of the vault

  • vaultApprovals(vaultApprovals entity): the vault approvals entity of the vault

  • vaultAffiliates(vaultAffiliates entity): the vault affiliates entity of the vault

  • vaultHysteresis(vaultHysteresis entity): the vault hysteresis entity of the vault

  • vaultCollectFees(vaultCollectFees entity): the vault collect fees entity of the vault

  • maxTotalSupply(maxTotalSupply entity): the max total supply entity of the vault

  • vaultOwnershipTransferred(vaultOwnershipTransferred entity): the vault ownership transferred entity of the vault

  • vaultRebalance(vaultRebalance entity): the vault rebalance entity of the vault

  • vaultSetTwapPeriod(vaultSetTwapPeriod entity): the vault set twap period entity of the vault

    • vaultTransfer(vaultTransfer entity): the vault transfer entity of the vault

example query to get vaults:

query {
  ichiVaults {
    id
    sender
    tokenA
    allowTokenA
    tokenB
    allowTokenB
    count
    holdersCount
    totalShares
    searchString
  }
}

13. Token

token fields:

• id(string): the address of the token

• symbol(string): token symbol

• name(string): token name

• decimals(BigInt): token decimals

• totalSupply(BigInt): total supply of the token

• volume(BigDecimal): volume in token units

• volumeUSD(BigDecimal): volume in derived USD

• untrackedVolumeUSD(BigDecimal): volume in USD even on pools with less reliable USD values

• feesUSD(BigDecimal): fees in USD

• txCount(BigInt): transactions across all pools that include this token

• poolCount(BigInt): number of pools containing this token

• totalValueLocked(BigDecimal): liquidity across all pools in token units

• totalValueLockedUSD(BigDecimal): liquidity across all pools in derived USD

• totalValueLockedUSDUntracked(BigDecimal): TVL derived in USD untracked

• derivedMatic(BigDecimal): derived price in Matic

• derivedUSD(BigDecimal): derived price in USD

• initialUSD(BigDecimal): initial price in USD

• priceChange24h(BigDecimal): 24 hour price change

• priceChange24hPercentage(BigDecimal): 24 hour price change percentage

• whitelistPools(pool entity): pools token is in that are white listed for USD pricing

• marketCap(BigDecimal): derived market cap by total supply and derived price

• holderCount(BigInt): number of holders of this token

• entities:

  • tokenHourData(tokenHourData entity): hourly data for this token

  • tokenDayData(tokenDayData entity): daily data for this token

  • holders(holders entity): holders of this token

example query to get token data:

query {
  tokens {
    id
    symbol
    name
    decimals
    totalSupply
    volume
    volumeUSD
    untrackedVolumeUSD
    feesUSD
    txCount
    poolCount
    totalValueLocked
    totalValueLockedUSD
    totalValueLockedUSDUntracked
    derivedMatic
    derivedUSD
    marketCap
    holderCount
  }
}

14. Vault Shares

vaultShare fields:

• id(string): unique identifier for the vault share

• user(account entity): the account that owns the shares

• vault(vault entity): reference to the vault

• vaultShareBalance(BigDecimal): balance of shares owned by the user

example query to get vault shares:

query {
  vaultShares {
    id
    user {
      id
    }
    vault {
      id
    }
    vaultShareBalance
  }
}

get account vault shares query

# @param accountId: account address
query AccountVaultShares($AccountId: ID!) {
  vaultShares(where: { user_: { id: $AccountId }, vaultShareBalance_gt: 0 }) {
    ...VaultSharesField
    id
  }
}

15. Vault Deposits

vaultDeposit fields:

• id(string): unique identifier for the deposit

• vault(IchiVault): reference to the vault

• sender(Bytes): address of the transaction signer

• to(Bytes): recipient address of the minted LP tokens

• shares(BigInt): quantity of LP tokens minted

• amount0(BigInt): amount of token0 deposited

• amount1(BigInt): amount of token1 deposited

• tick(Int): current price tick

• createdAtTimestamp(BigInt): timestamp of deposit

• sqrtPrice(BigInt): square root of price at deposit time

• totalAmount0(BigInt): total token0 in vault after deposit

• totalAmount1(BigInt): total token1 in vault after deposit

• totalAmount0BeforeEvent(BigInt): total token0 before deposit

• totalAmount1BeforeEvent(BigInt): total token1 before deposit

• totalSupply(BigInt): total supply of LP tokens

example query to get vault deposits:

query {
  vaultDeposits {
    id
    vault {
      id
    }
    sender
    shares
    amount0
    amount1
    createdAtTimestamp
  }
}

16. Vault Withdraws

vaultWithdraw fields:

• id(string): unique identifier for the withdrawal

• vault(IchiVault): reference to the vault

• sender(Bytes): address of the transaction signer

• to(Bytes): recipient address of withdrawn tokens

• shares(BigInt): quantity of LP tokens burned

• amount0(BigInt): amount of token0 withdrawn

• amount1(BigInt): amount of token1 withdrawn

• tick(Int): current price tick

• createdAtTimestamp(BigInt): timestamp of withdrawal

• sqrtPrice(BigInt): square root of price at withdrawal time

• totalAmount0(BigInt): total token0 in vault after withdrawal

• totalAmount1(BigInt): total token1 in vault after withdrawal

• totalAmount0BeforeEvent(BigInt): total token0 before withdrawal

• totalAmount1BeforeEvent(BigInt): total token1 before withdrawal

• totalSupply(BigInt): total supply of LP tokens

example query to get vault withdrawals:

query {
  vaultWithdraws {
    id
    vault {
      id
    }
    sender
    shares
    amount0
    amount1
    createdAtTimestamp
  }
}

17. Vault Approvals

vaultApproval fields:

• id(string): unique identifier (transaction hash + log index)

• vault(IchiVault): reference to the vault

• owner(Bytes): address of the owner of the spender account

• spender(Bytes): address for which the allowance is being set

• value(BigInt): the new allowance amount

example query to get vault approvals:

query {
  vaultApprovals {
    id
    vault {
      id
    }
    owner
    spender
    value
  }
}

18. Vault Affiliates

vaultAffiliate fields:

• id(string): unique identifier (transaction hash + log index)

• vault(IchiVault): reference to the vault

• sender(Bytes): address of the transaction signer

• affiliate(Bytes): address of the new affiliate that will receive trading fee split

example query to get vault affiliates:

query {
  vaultAffiliates {
    id
    vault {
      id
    }
    sender
    affiliate
  }
}

19. Vault Hysteresis

vaultHysteresis fields:

• id(string): unique identifier (transaction hash + log index)

• vault(IchiVault): reference to the vault

• sender(Bytes): address of the transaction signer

• hysteresis(BigInt): new hysteresis threshold in percentage

example query to get vault hysteresis:

query {
  vaultHysteresis {
    id
    vault {
      id
    }
    sender
    hysteresis
  }
}

20. Vault Collect Fees

vaultCollectFee fields:

• id(string): unique identifier (transaction hash + log index)

• vault(IchiVault): reference to the vault

• sender(Bytes): address of the CollectFees transaction signer

• tick(Int): current price tick

• createdAtTimestamp(BigInt): timestamp of fee collection

• sqrtPrice(BigInt): square root price at collection time

• feeAmount0(BigInt): collected fee amount of token0

• feeAmount1(BigInt): collected fee amount of token1

• totalAmount0(BigInt): total token0 in vault after collection

• totalAmount1(BigInt): total token1 in vault after collection

• totalSupply(BigInt): total supply of LP tokens

example query to get vault collect fees:

query {
  vaultCollectFees {
    id
    vault {
      id
    }
    sender
    feeAmount0
    feeAmount1
    createdAtTimestamp
  }
}

21. Max Total Supply

maxTotalSupply fields:

• id(string): unique identifier (transaction hash + log index)

• vault(IchiVault): reference to the vault

• totalSupply(BigInt): total supply of LP tokens

example query to get max total supply:

query {
  maxTotalSupply {
    id
    vault {
      id
    }
    totalSupply
  }
}

22. Vault Ownership Transferred

vaultOwnershipTransferred fields:

• id(string): unique identifier (transaction hash + log index)

• vault(IchiVault): reference to the vault

• from(Bytes): address of the previous owner

• to(Bytes): address of the new owner

example query to get vault ownership transferred:

query {
  vaultOwnershipTransferred {
    id
    vault {
      id
    }
    from
    to
  }
}

23. Vault Rebalance

vaultRebalance fields:

• id(string): unique identifier (transaction hash + log index)

• vault(IchiVault): reference to the vault

• sender(Bytes): address of the transaction signer

• amount0(BigInt): amount of token0 to be rebalanced

• amount1(BigInt): amount of token1 to be rebalanced

example query to get vault rebalance:

query {
  vaultRebalance {
    id
    vault {
      id
    }
    sender
    amount0
    amount1
  }
}

24. Vault Set Twap Period

vaultSetTwapPeriod fields:

• id(string): unique identifier (transaction hash + log index)

• vault(IchiVault): reference to the vault

• sender(Bytes): address of the transaction signer

• twapPeriod(BigInt): new twap period in seconds

example query to get vault set twap period:

query {
  vaultSetTwapPeriod {
    id
    vault {
      id
    }
    sender
    twapPeriod
  }
}

25. Vault Transfer

vaultTransfer fields:

• id(string): unique identifier (transaction hash + log index)

• vault(IchiVault): reference to the vault

• sender(Bytes): address of the transaction signer

• to(Bytes): address of the recipient

• amount0(BigInt): amount of token0 to be transferred

• amount1(BigInt): amount of token1 to be transferred

example query to get vault transfer:

query {
  vaultTransfer {
    id
    vault {
      id
    }
    sender
    to
    amount0
    amount1
  }
}

26. Pot2Pump

pot2Pump fields:

• id(string): token address

• launchTokenInitialPrice(BigDecimal): initial price of the launch token

• launchToken(entity): reference to the token being launched

• DepositLaunchToken(BigInt): amount of launch tokens deposited

• LaunchTokenTVLUSD(BigDecimal): total value locked in USD for launch token

• LaunchTokenMCAPUSD(BigDecimal): market cap in USD for launch token

• raisedTokenMinCap(BigInt): minimum cap for the raised token

• raisedToken(entity): reference to the token being raised

• depositRaisedTokenPercentageToMinCap(BigDecimal): percentage of raised token deposited compared to min cap

• raisedTokenReachingMinCap(Boolean): whether raised token reached minimum cap

• DepositRaisedToken(BigInt): amount of raised tokens deposited

• creator(String): address of the creator

• participantsCount(BigInt): number of participants

• totalRefundAmount(BigInt): total amount refunded

• totalClaimLpAmount(BigInt): total amount of LP tokens claimed

• createdAt(BigInt): timestamp of creation

• endTime(BigInt): timestamp of end time

• state(BigInt): current state of the Pot2Pump

• buyCount(BigInt): number of buy transactions

• sellCount(BigInt): number of sell transactions

• searchString(String): searchable string combining address and token symbols

example query to get pot2pump data:

query {
  pot2Pumps {
    id
    launchTokenInitialPrice
    launchToken {
      symbol
      name
    }
    DepositLaunchToken
    LaunchTokenTVLUSD
    LaunchTokenMCAPUSD
    raisedTokenMinCap
    raisedToken {
      symbol
      name
    }
    depositRaisedTokenPercentageToMinCap
    raisedTokenReachingMinCap
    DepositRaisedToken
    creator
    participantsCount
    totalRefundAmount
    totalClaimLpAmount
    createdAt
    endTime
    state
    buyCount
    sellCount
  }
}

pot2pump newly launched query:

# @param endTime: BigInt - timestamp of the current time
query Pot2PumpPottingNewTokens($endTime: BigInt) {
  pot2Pumps(
    first: 25
    orderBy: createdAt
    orderDirection: desc
    where: { raisedTokenReachingMinCap: false, endTime_gt: $endTime }
  ) {
    id
    launchToken {
      symbol
    }
    raisedToken {
      symbol
    }
  }
}

pot2pump near success query:

# @param endTime: BigInt - timestamp of the current time
query Pot2PumpPottingNearSuccess($endTime: BigInt) {
  pot2Pumps(
    first: 25
    orderBy: depositRaisedTokenPercentageToMinCap
    orderDirection: desc
    where: { raisedTokenReachingMinCap: false, endTime_gt: $endTime }
  ) {
    id
    launchToken {
      symbol
    }
    raisedToken {
      symbol
    }
  }
}

pot2pump trending launch query:

query Pot2PumpPottingTrending {
  pot2Pumps(
    first: 25
    orderBy: launchToken__priceChange24hPercentage
    orderDirection: desc
    where: { raisedTokenReachingMinCap: true }
  ) {
    ...Pot2PumpField
  }
}

27. Participant

participant fields:

• id(string): unique identifier

• pot2Pump(Pot2Pump): reference to the Pot2Pump

• account(Account): reference to the participant's account

• amount(BigInt): total deposit amount

• totalRefundAmount(BigInt): total amount refunded

• totalclaimLqAmount(BigInt): total amount of LP claimed (1 means claimed all, 0 means none)

• claimed(Boolean): whether participant has claimed

• refunded(Boolean): whether participant has been refunded

• createdAt(BigInt): timestamp of participation

• participantTransactionHistorys(entity): history of participant's transactions

example query to get participant data:

query {
  participants {
    id
    pot2Pump {
      id
      launchToken {
        symbol
      }
    }
    account {
      id
    }
    amount
    totalRefundAmount
    totalclaimLqAmount
    claimed
    refunded
    createdAt
  }
}

28. Participant Transaction History

participantTransactionHistory fields:

• id(string): unique identifier

• account(entity): reference to the participant's account

• pot2Pump(entity): reference to the Pot2Pump

• depositAmount(BigInt): amount deposited in transaction

• refundAmount(BigInt): amount refunded in transaction

• claimLqAmount(BigInt): amount of LP claimed in transaction (1 means all, 0 means none)

• actionType(TransactionType): type of transaction

• createdAt(BigInt): timestamp of transaction

• participant(entity): reference to the participant

example query to get transaction history:

query {
  participantTransactionHistories {
    id
    account {
      id
    }
    pot2Pump {
      id
      launchToken {
        symbol
      }
    }
    depositAmount
    refundAmount
    claimLqAmount
    actionType
    createdAt
  }
}

29. Account

account fields:

• id(string): account address

• memeTokenHoldingCount(BigInt): number of meme tokens held by this account

• holder(holdingToken entity): list of tokens held by this account

• pot2PumpLaunchCount(BigInt): number of Pot2Pump launches by this account

• participateCount(BigInt): number of Pot2Pump participations

• participant(entity): list of Pot2Pump participations

• transaction(transaction entity): list of transactions made by this account

• platformTxCount(BigInt): total number of transactions on the platform

• swapCount(BigInt): number of swap transactions

• holdingPoolCount(BigInt): number of pools the account has holdings in

• totalSpendUSD(BigDecimal): total amount spent in USD

• vaultShares(vaultShare entity): list of vault shares owned by this account

example query to get account data:

query {
  accounts {
    id
    memeTokenHoldingCount
    pot2PumpLaunchCount
    participateCount
    platformTxCount
    swapCount
    holdingPoolCount
    totalSpendUSD
    holder {
      token {
        symbol
        name
      }
      holdingValue
    }
    participant {
      pot2Pump {
        id
      }
      amount
    }
    vaultShares {
      vault {
        id
      }
      vaultShareBalance
    }
  }
}

30. Holding Token

holdingToken fields:

• id(string): account address + token address

• token(entity): reference to the token being held

• account(entity): reference to the account holding the token

• holdingValue(BigInt): amount of tokens held

example query to get holding token data:

query {
  holdingTokens {
    id
    token {
      symbol
      name
      decimals
    }
    account {
      id
    }
    holdingValue
  }
}

31. Transaction

transaction fields:

• id(string): transaction hash

• type(TransactionType): type of transaction (DEPOSIT, REFUND, CLAIM_LP, SWAP, COLLECT, MINT, BURN, INCREASE_LIQUIDITY, DECREASE_LIQUIDITY)

• account(entity): reference to the account that made the transaction

• blockNumber(BigInt): block number of the transaction

• timestamp(BigInt): timestamp of the transaction

• gasLimit(BigInt): gas limit of the transaction

• gasPrice(BigInt): gas price of the transaction

• events

  • mints (Mint entity): list of mint events in this transaction

  • burns (Burn entity): list of burn events in this transaction

  • swaps (Swap entity): list of swap events in this transaction

  • flashed (Flash entity): list of flash events in this transaction

  • collects (Collect entity): list of collect events in this transaction

  • depositRaisedTokens (DepositRaisedToken entity): list of deposit raised token events

  • refunds (Refund entity): list of refund events

  • claimLps (ClaimLp entity): list of claim LP events

example query to get transaction data:

query {
  transactions {
    id
    type
    account {
      id
    }
    blockNumber
    timestamp
    gasLimit
    gasPrice
    swaps {
      amount0
      amount1
      amountUSD
    }
    mints {
      amount0
      amount1
      amountUSD
    }
    burns {
      amount0
      amount1
      amountUSD
    }
  }
}

32. Flash

flash fields:

• id(string): transaction hash + index

• transaction(transaction entity): reference to the transaction

• timestamp(BigInt): timestamp of the flash event

• pool(Pool): reference to the pool

• sender(Bytes): address of the sender

• recipient(Bytes): address of the recipient

• amount0(BigDecimal): amount of token0 flashed

• amount1(BigDecimal): amount of token1 flashed

• amountUSD(BigDecimal): total amount in USD

• amount0Paid(BigDecimal): amount of token0 paid for flash

• amount1Paid(BigDecimal): amount of token1 paid for flash

• logIndex(BigInt): index in the transaction

example query to get flash data:

query {
  flashes {
    id
    timestamp
    pool {
      id
    }
    sender
    recipient
    amount0
    amount1
    amountUSD
    amount0Paid
    amount1Paid
  }
}

33. Refund

refund fields:

• id(string): unique identifier (transaction hash + index)

• transaction(entity): reference to the transaction

• timestamp(BigInt): timestamp of the refund

• amount(BigInt): amount being refunded

• origin(Bytes): the EOA that initiated the transaction

• logIndex(BigInt): index in the transaction

• poolAddress(Bytes): address of the pool where refund occurred

example query to get refund data:

query {
  refunds {
    id
    transaction {
      id
    }
    timestamp
    amount
    origin
    poolAddress
  }
}

34. ClaimLp

claimLp fields:

• id(string): unique identifier (transaction hash + index)

• transaction(entity): reference to the transaction

• timestamp(BigInt): timestamp of the LP claim

• amount(BigInt): amount of LP tokens claimed

• origin(Bytes): the EOA that initiated the transaction

• logIndex(BigInt): index in the transaction

• poolAddress(Bytes): address of the pool where LP was claimed

example query to get claim LP data:

query {
  claimLps {
    id
    transaction {
      id
    }
    timestamp
    amount
    origin
    poolAddress
  }
}

35. Deposit Raised Token

depositRaisedToken fields:

• id(string): unique identifier (transaction hash + index)

• transaction(entity): reference to the transaction

• timestamp(BigInt): timestamp of the deposit raised token event

• amount(BigInt): amount of tokens deposited

• logIndex(BigInt): index in the transaction

• poolAddress(Bytes): address of the pool where deposit occurred

example query to get deposit raised token data:

query {
  depositRaisedTokens {
    id
    transaction {
      id
    }
    timestamp
    amount
    poolAddress
  }
}

36. positions

position fields:

• id(string): unique identifier (transaction hash + index)

• owner(Bytes): address of the owner

• pool(pool entity): reference to the pool

• token0(token entity): reference to the token0

• token1(token entity): reference to the token1

• liquidity(BigInt): liquidity of the position

• depositedToken0(BigInt): amount of token0 deposited

• depositedToken1(BigInt): amount of token1 deposited

• withdrawnToken0(BigInt): amount of token0 withdrawn

• withdrawnToken1(BigInt): amount of token1 withdrawn

example query to get position data:

query {
  positions {
    id
    owner
    pool {
      id
    }
    token0 {
      symbol
      name
      decimals
    }
    token1 {
      symbol
      name
      decimals
    }
    liquidity
    depositedToken0
    depositedToken1
    withdrawnToken0
    withdrawnToken1
  }
}

user active positions query

# @param account: account address
query UserActivePositions($account: Bytes!) {
  positions(where: { owner: $account, liquidity_gt: 0 }) {
    ...PositionFields
  }
}