From ec678f6bec846a66645a88b1316bf79a18f95494 Mon Sep 17 00:00:00 2001 From: Jack Date: Tue, 14 Nov 2023 12:17:59 +0000 Subject: [PATCH] feat: support sepolia network (#12) --- docs/config.md | 2 +- packages/config/src/index.ts | 4 +- packages/constants/src/addresses.ts | 12 + packages/constants/src/networks.ts | 4 +- packages/constants/src/subgraph.ts | 9 +- packages/constants/src/urls.ts | 12 +- packages/constants/src/values.ts | 8 +- .../assets/fetchUserHoldings/fetchErc1155s.ts | 71 +- .../assets/fetchUserHoldings/fetchErc721s.ts | 62 +- .../fetchUserHoldings/fetchNonstandards.ts | 11 +- .../src/assets/fetchUserHoldings/types.ts | 2 +- packages/core/src/prices/common.ts | 2 +- packages/core/src/prices/priceVaultBuy.ts | 12 +- packages/core/src/prices/priceVaultSwap.ts | 9 +- packages/react/src/contexts/nftx.tsx | 4 +- .../subgraph/src/createQuery/createQuery.ts | 3 +- packages/subgraph/src/querySubgraph.ts | 1 - packages/types/1155-sepolia.codegen.yml | 19 + packages/types/721-sepolia.codegen.yml | 19 + packages/types/package.json | 2 +- packages/types/src/subgraph/1155-sepolia.ts | 937 ++++++++++++++++++ packages/types/src/subgraph/721-sepolia.ts | 925 +++++++++++++++++ packages/types/src/subgraph/index.ts | 2 + .../types/src/subgraph/nftx-v3-uniswap.ts | 204 ++++ .../src/prices/__tests__/premiums.test.ts | 9 +- packages/utils/src/prices/premiums.ts | 15 +- packages/utils/src/web3/getChainConstant.ts | 8 +- 27 files changed, 2323 insertions(+), 45 deletions(-) create mode 100644 packages/types/1155-sepolia.codegen.yml create mode 100644 packages/types/721-sepolia.codegen.yml create mode 100644 packages/types/src/subgraph/1155-sepolia.ts create mode 100644 packages/types/src/subgraph/721-sepolia.ts diff --git a/docs/config.md b/docs/config.md index 955c3b41..bd02db67 100644 --- a/docs/config.md +++ b/docs/config.md @@ -22,7 +22,7 @@ config.configure({ ERC721_SUBGRAPH: 'custom-subgraph-endpoint', }, urls: { - ALCHEMY_URL: 'custom-alchemy-url', + NFTX_API_URL: 'custom-url', }, contracts: { multicall: false, diff --git a/packages/config/src/index.ts b/packages/config/src/index.ts index fbd8ee43..43d07b2c 100644 --- a/packages/config/src/index.ts +++ b/packages/config/src/index.ts @@ -5,7 +5,6 @@ import { NON_STANDARD_SUBGRAPH, NFTX_APR_URL, Network, - ALCHEMY_URL, NFTX_API_URL, NFTX_ROUTER_URL, NFTX_UNISWAP_SUBGRAPH, @@ -40,7 +39,6 @@ export interface Config { urls: { NFTX_ROUTER_URL: Record; NFTX_APR_URL: Record; - ALCHEMY_URL: Record; NFTX_API_URL: string; }; /** Contract configuration options */ @@ -103,12 +101,12 @@ const defaultConfig: Config = { urls: { NFTX_ROUTER_URL, NFTX_APR_URL, - ALCHEMY_URL, NFTX_API_URL, }, contracts: { ethPrice: { [Network.Goerli]: '2500000000', // $2.5k + [Network.Sepolia]: '2000000000', // $2k }, }, diff --git a/packages/constants/src/addresses.ts b/packages/constants/src/addresses.ts index ad568468..3e386699 100644 --- a/packages/constants/src/addresses.ts +++ b/packages/constants/src/addresses.ts @@ -19,6 +19,7 @@ export const WETH_TOKEN = { [Network.Mainnet]: a('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'), [Network.Arbitrum]: a('0x82af49447d8a07e3bd95bd0d56f35241523fbab1'), [Network.Goerli]: a('0xb4fbf271143f4fbf7b91a5ded31805e42b2208d6'), + [Network.Sepolia]: a('0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14'), }; /** The address for USDC across networks */ @@ -26,6 +27,7 @@ export const USDC = { [Network.Mainnet]: a('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'), [Network.Arbitrum]: a('0xff970a61a04b1ca14834a43f5de4533ebddb5cc8'), [Network.Goerli]: a('0x2f3a40a3db8a7e3d09b0adfefbce4f6f81927557'), + [Network.Sepolia]: a('0x2C032Aa43D119D7bf4Adc42583F1f94f3bf3023a'), }; export const OPENSEA_COLLECTION = a( @@ -35,35 +37,42 @@ export const OPENSEA_COLLECTION = a( /** Zap specifically for creating new vaults */ export const CREATE_VAULT_ZAP = { [Network.Goerli]: a('0xFA7d98Ec2b046e636c45A0291F931b94a5a1CA59'), + [Network.Sepolia]: a('0x50f69c6556338965bf77C16ADb462Fdb5bE01C09'), }; /** Perform buy/sell/swaps */ export const MARKETPLACE_ZAP = { [Network.Goerli]: a('0x5A40C0288d23E83a23bb16C29B790F7e49e49ee6'), + [Network.Sepolia]: a('0x5Af324A8c90966Bef28386A67c6bE0A16aA03c19'), }; /** Stake NFTs or vTokens for xNFTs */ export const INVENTORY_STAKING = { [Network.Goerli]: a('0xEf771a17e6970d8B4b208a76e94F175277554230'), + [Network.Sepolia]: a('0xfBFf0635f7c5327FD138E1EBa72BD9877A6a7C1C'), }; /** AMM Router (Universal Router / nftxUniversalRouter) */ export const NFTX_ROUTER = { [Network.Goerli]: a('0xF7c4FC5C2e30258e1E4d1197fc63aeDE371508f3'), + [Network.Sepolia]: a('0x12156cCA1958B6591CC49EaE03a5553458a4b424'), }; /** Staking / Liquidity / Pools (NftxRouter) */ export const POOL_ROUTER = { [Network.Goerli]: a('0xb95e2Fb1eDA32BbFbDaE2463BB3E64bb3E1E41D5'), + [Network.Sepolia]: a('0xD36ece08F76c50EC3F01db65BBc5Ef5Aa5fbE849'), }; export const NONFUNGIBLE_POSITION_MANAGER = { [Network.Goerli]: a('0xaEC6537206e8e590603399c714c39947680f1181'), + [Network.Sepolia]: a('0x55BDc76262B1e6e791D0636A0bC61cee23CDFa87'), }; /** The permit2 contract, needs an approval signature because the UniversalRouter only transfers tokens from user via Permit2 */ export const PERMIT2 = { [Network.Goerli]: a('0x000000000022d473030f116ddee9f6b43ac78ba3'), + [Network.Sepolia]: a('0x000000000022d473030f116ddee9f6b43ac78ba3'), }; /** ENS Address */ @@ -71,12 +80,15 @@ export const ENS_REGISTRAR = { [Network.Mainnet]: a('0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85'), [Network.Arbitrum]: a('0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85'), [Network.Goerli]: a('0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85'), + [Network.Sepolia]: a('0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85'), }; export const AMM_FACTORY = { [Network.Goerli]: a('0xf25081B098c5929A26F562aa2502795fE89BC73f'), + [Network.Sepolia]: a('0xDD2dce9C403f93c10af1846543870D065419E70b'), }; export const VAULT_FACTORY = { [Network.Goerli]: a('0x1d552A0e6c2f680872C4a88b1e7def05F1858dF0'), + [Network.Sepolia]: a('0x31C56CaF49125043e80B4d3C7f8734f949d8178C'), }; diff --git a/packages/constants/src/networks.ts b/packages/constants/src/networks.ts index f37f8e4c..b23e1e2a 100644 --- a/packages/constants/src/networks.ts +++ b/packages/constants/src/networks.ts @@ -1,6 +1,6 @@ export enum Network { Mainnet = 1, - Rinkeby = 4, - Arbitrum = 42161, + Arbitrum = 42_161, Goerli = 5, + Sepolia = 11_155_111, } diff --git a/packages/constants/src/subgraph.ts b/packages/constants/src/subgraph.ts index 8216b91a..519aa037 100644 --- a/packages/constants/src/subgraph.ts +++ b/packages/constants/src/subgraph.ts @@ -47,6 +47,8 @@ export const ERC721_SUBGRAPH = { [Network.Arbitrum]: `${SHARED_PROXY_ROOT}/quantumlyy/eip721-subgraph-arbitrum`, [Network.Goerli]: 'https://api.thegraph.com/subgraphs/name/nftx-project/eip721-looksrare-goerli', + [Network.Sepolia]: + 'https://api.thegraph.com/subgraphs/name/nftx-project/721-sepolia-data-nexus', }; export const ERC1155_SUBGRAPH = { @@ -54,6 +56,8 @@ export const ERC1155_SUBGRAPH = { [Network.Arbitrum]: `${SHARED_PROXY_ROOT}/quantumlyy/eip1155-subgraph-arbitrum`, [Network.Goerli]: 'https://api.thegraph.com/subgraphs/name/nftx-project/eip1155-looksrare-goerli', + [Network.Sepolia]: + 'https://api.thegraph.com/subgraphs/name/nftx-project/1155-sepolia-data-nexus', }; export const NFTX_SUBGRAPH_MAINNET_URLS = { @@ -80,11 +84,14 @@ export const NFTX_SUBGRAPH = { NFTX_SUBGRAPH_MAINNET_URLS.SHARED, ], [Network.Arbitrum]: `${SHARED_ROOT}/nftx-project/nftx-v2-arbitrum`, - // [Network.Goerli]: `${SHARED_ROOT}/nftx-project/nftx-v2-1-goerli`, [Network.Goerli]: 'https://api.thegraph.com/subgraphs/name/gundamdweeb/nftx-v3-vaults', + [Network.Sepolia]: + 'https://api.thegraph.com/subgraphs/name/nftx-project/nftx-v3-vaults-sepolia', }; export const NFTX_UNISWAP_SUBGRAPH = { [Network.Goerli]: `https://api.thegraph.com/subgraphs/name/gundamdweeb/nftx-amm`, + [Network.Sepolia]: + 'https://api.thegraph.com/subgraphs/name/nftx-project/nftx-v3-amm-sepolia', }; diff --git a/packages/constants/src/urls.ts b/packages/constants/src/urls.ts index 59e50a17..6a5afc5f 100644 --- a/packages/constants/src/urls.ts +++ b/packages/constants/src/urls.ts @@ -1,27 +1,21 @@ import { Network } from './networks'; export const NFTX_ROUTER_URL = { - [Network.Goerli]: - 'https://lmw8qdcm7e.execute-api.eu-central-1.amazonaws.com/prod/quote', + [Network.Goerli]: 'https://api.nftx.xyz/v3/eth-goerli/quote', + [Network.Sepolia]: 'https://api.nftx.xyz/v3/eth-sepolia/quote', }; export const NFTX_APR_URL = { [Network.Mainnet]: 'https://data.nftx.xyz/vaultaprs', - [Network.Rinkeby]: 'https://data.nftx.xyz/vaultaprs', [Network.Arbitrum]: 'https://data.nftx.xyz/vaultaprs', [Network.Goerli]: 'https://data.nftx.xyz/vaultaprs', }; -export const ALCHEMY_URL = { - [Network.Mainnet]: 'https://eth-mainnet.g.alchemy.com', - [Network.Goerli]: 'https://eth-goerli.g.alchemy.com', - [Network.Arbitrum]: 'https://arb-mainnet.g.alchemy.com', -}; - export const NFTX_API_URL = 'https://api-v3.nftx.xyz'; export const RESERVOIR_URL = { [Network.Mainnet]: 'https://api.reservoir.tools', [Network.Goerli]: 'https://api-goerli.reservoir.tools', [Network.Arbitrum]: 'https://api-arbitrum.reservoir.tools', + [Network.Sepolia]: 'https://api-sepolia.reservoir.tools', }; diff --git a/packages/constants/src/values.ts b/packages/constants/src/values.ts index 5db7bb2f..84f3f22f 100644 --- a/packages/constants/src/values.ts +++ b/packages/constants/src/values.ts @@ -1,5 +1,11 @@ +import { Network } from './networks'; + export const WeiPerEther = 1000000000000000000n; export const Zero = 0n; export const MaxUint256 = 115792089237316195423570985008687907853269984665640564039457584007913129639935n; -export const PREMIUM_DURATION = 36000; + +export const PREMIUM_DURATION = { + [Network.Goerli]: 36000, // 10 hours + [Network.Sepolia]: 3600, // 1 hour +}; diff --git a/packages/core/src/assets/fetchUserHoldings/fetchErc1155s.ts b/packages/core/src/assets/fetchUserHoldings/fetchErc1155s.ts index fc9dfcab..26206077 100644 --- a/packages/core/src/assets/fetchUserHoldings/fetchErc1155s.ts +++ b/packages/core/src/assets/fetchUserHoldings/fetchErc1155s.ts @@ -1,6 +1,6 @@ import config from '@nftx/config'; -import { gql, querySubgraph } from '@nftx/subgraph'; -import type { Address } from '@nftx/types'; +import { createQuery, gql, querySubgraph } from '@nftx/subgraph'; +import type { Address, ERC1155Sepolia, TokenId } from '@nftx/types'; import { getChainConstant } from '@nftx/utils'; import { createCursor, parseCursor } from './cursor'; import { parseEther } from 'viem'; @@ -80,7 +80,7 @@ const makeFetchErc1155sMainnet = const holdings = balances.map((x) => { return { assetAddress: x.contract.id, - tokenId: BigInt(x.token.identifier).toString(), + tokenId: BigInt(x.token.identifier).toString() as TokenId, quantity: Number(x.value) < 1 ? parseEther(x.value) : BigInt(x.value), }; }); @@ -88,6 +88,58 @@ const makeFetchErc1155sMainnet = return [holdings, createCursor('1155', nextId)] as const; }; +const makeFetchErc1155sSepolia = + ({ querySubgraph }: { querySubgraph: QuerySubgraph }) => + async ({ + lastId, + network, + userAddress, + }: { + network: number; + lastId: string; + userAddress: Address; + }) => { + let holdings: Array = []; + let nextId: string | undefined; + + const q = createQuery(); + + const query = q.account.id(userAddress).select((s) => [ + s.holdings( + q.holdings + .first(1000) + .orderBy('id') + .orderDirection('asc') + .where((w) => [w.id.gt(lastId)]) + .select((s) => [ + s.id, + s.balance, + s.token((t) => [t.identifier, t.collection((c) => [c.id])]), + ]) + ), + ]); + + const data = await querySubgraph({ + url: getChainConstant(config.subgraph.ERC1155_SUBGRAPH, network), + query, + }); + + if (data?.account?.holdings?.length) { + holdings = data.account.holdings.map((x) => { + return { + assetAddress: x.token.collection.id as Address, + tokenId: BigInt(x.token.identifier).toString() as TokenId, + quantity: BigInt(x.balance || '1'), + }; + }); + } + if (data?.account?.holdings?.length === 1000) { + nextId = data.account.holdings[data.account.holdings.length - 1].id; + } + + return [holdings, nextId] as const; + }; + const makeFetchErc1155sGoerli = ({ querySubgraph }: { querySubgraph: QuerySubgraph }) => async ({ @@ -144,7 +196,7 @@ const makeFetchErc1155sGoerli = holdings = data.owners[0].tokens.map((x) => { return { assetAddress: x.collection.id, - tokenId: x.tokenID, + tokenId: BigInt(x.tokenID).toString() as TokenId, }; }); } @@ -161,16 +213,19 @@ const makeFetchErc1155sArbitrum = makeFetchErc1155sMainnet; type FetchErc1155sMainnet = ReturnType; type FetchErc1155sGoerli = ReturnType; type FetchErc1155sArbitrum = ReturnType; +type FetchErc1155sSepolia = ReturnType; const makeFetchErc1155s = ({ fetchErc1155sArbitrum, fetchErc1155sGoerli, fetchErc1155sMainnet, + fetchErc1155sSepolia, }: { fetchErc1155sMainnet: FetchErc1155sMainnet; fetchErc1155sGoerli: FetchErc1155sGoerli; fetchErc1155sArbitrum: FetchErc1155sArbitrum; + fetchErc1155sSepolia: FetchErc1155sSepolia; }) => async ({ userAddress, @@ -203,6 +258,13 @@ const makeFetchErc1155s = userAddress, }); break; + case Network.Sepolia: + [holdings, nextId] = await fetchErc1155sSepolia({ + lastId, + network, + userAddress, + }); + break; case Network.Arbitrum: [holdings, nextId] = await fetchErc1155sArbitrum({ lastId, @@ -224,4 +286,5 @@ export default makeFetchErc1155s({ fetchErc1155sArbitrum: makeFetchErc1155sArbitrum({ querySubgraph }), fetchErc1155sGoerli: makeFetchErc1155sGoerli({ querySubgraph }), fetchErc1155sMainnet: makeFetchErc1155sMainnet({ querySubgraph }), + fetchErc1155sSepolia: makeFetchErc1155sSepolia({ querySubgraph }), }); diff --git a/packages/core/src/assets/fetchUserHoldings/fetchErc721s.ts b/packages/core/src/assets/fetchUserHoldings/fetchErc721s.ts index f383fe4c..a786a5e4 100644 --- a/packages/core/src/assets/fetchUserHoldings/fetchErc721s.ts +++ b/packages/core/src/assets/fetchUserHoldings/fetchErc721s.ts @@ -1,7 +1,7 @@ -import type { Address } from '@nftx/types'; +import { Address, ERC721Sepolia, TokenId } from '@nftx/types'; import { createCursor, parseCursor } from './cursor'; import { Network } from '@nftx/constants'; -import { buildWhere, gql, querySubgraph } from '@nftx/subgraph'; +import { buildWhere, createQuery, gql, querySubgraph } from '@nftx/subgraph'; import { getChainConstant } from '@nftx/utils'; import config from '@nftx/config'; import type { Holding } from './types'; @@ -72,7 +72,7 @@ const makeFetchErc721sMainnet = holdings = data.account.tokens.map((x) => { return { assetAddress: x.contract.id, - tokenId: x.identifier, + tokenId: BigInt(x.identifier).toString() as TokenId, }; }); } @@ -83,6 +83,47 @@ const makeFetchErc721sMainnet = return [holdings, nextId] as const; }; +const makeFetchErc721sSepolia = + ({ querySubgraph }: { querySubgraph: QuerySubgraph }) => + async ({ + network, + lastId, + userAddress, + }: { + network: number; + lastId: string; + userAddress: Address; + }) => { + let holdings: Holding[] = []; + let nextId: string | undefined; + + const query = createQuery() + .tokens.where((w) => [w.owner.is(userAddress), w.id.gt(lastId)]) + .orderBy('id') + .orderDirection('asc') + .first(1000) + .select((s) => [s.id, s.collection((c) => [c.id]), s.identifier]); + + const data = await querySubgraph({ + url: getChainConstant(config.subgraph.ERC721_SUBGRAPH, network), + query, + }); + + if (data?.tokens?.length) { + holdings = data.tokens.map((x) => { + return { + assetAddress: x.collection.id as Address, + tokenId: BigInt(x.identifier).toString() as TokenId, + }; + }); + } + if (data?.tokens?.length === 1000) { + nextId = data.tokens[data.tokens.length - 1].id; + } + + return [holdings, nextId] as const; + }; + const makeFetchErc721sGoerli = ({ querySubgraph }: { querySubgraph: QuerySubgraph }) => async ({ @@ -139,7 +180,7 @@ const makeFetchErc721sGoerli = holdings = data.owners[0].tokens.map((x) => { return { assetAddress: x.collection.id, - tokenId: x.tokenID, + tokenId: BigInt(x.tokenID).toString() as TokenId, }; }); } @@ -206,7 +247,7 @@ const makeFetchErc721sArbitrum = if (data?.account?.tokens?.length) { holdings = data.account.tokens.map((x) => ({ assetAddress: x.contract.id, - tokenId: x.identifier, + tokenId: BigInt(x.identifier).toString() as TokenId, })); } if (data?.account?.tokens?.length === 1000) { @@ -219,16 +260,19 @@ const makeFetchErc721sArbitrum = type FetchErc721sMainnet = ReturnType; type FetchErc721sGoerli = ReturnType; type FetchErc721sArbitrum = ReturnType; +type FetchErc721sSepolia = ReturnType; const makeFetchErc721s = ({ fetchErc721sArbitrum, fetchErc721sGoerli, fetchErc721sMainnet, + fetchErc721sSepolia, }: { fetchErc721sMainnet: FetchErc721sMainnet; fetchErc721sGoerli: FetchErc721sGoerli; fetchErc721sArbitrum: FetchErc721sArbitrum; + fetchErc721sSepolia: FetchErc721sSepolia; }) => async ({ userAddress, @@ -261,6 +305,13 @@ const makeFetchErc721s = userAddress, }); break; + case Network.Sepolia: + [holdings, nextId] = await fetchErc721sSepolia({ + lastId, + network, + userAddress, + }); + break; case Network.Arbitrum: [holdings, nextId] = await fetchErc721sArbitrum({ lastId, @@ -282,4 +333,5 @@ export default makeFetchErc721s({ fetchErc721sMainnet: makeFetchErc721sMainnet({ querySubgraph }), fetchErc721sGoerli: makeFetchErc721sGoerli({ querySubgraph }), fetchErc721sArbitrum: makeFetchErc721sArbitrum({ querySubgraph }), + fetchErc721sSepolia: makeFetchErc721sSepolia({ querySubgraph }), }); diff --git a/packages/core/src/assets/fetchUserHoldings/fetchNonstandards.ts b/packages/core/src/assets/fetchUserHoldings/fetchNonstandards.ts index e60b7447..f42755da 100644 --- a/packages/core/src/assets/fetchUserHoldings/fetchNonstandards.ts +++ b/packages/core/src/assets/fetchUserHoldings/fetchNonstandards.ts @@ -35,6 +35,15 @@ const makeFetchNonStandards = const { lastId } = parseCursor('nonstandard', cursor); + const url = getChainConstant( + config.subgraph.NON_STANDARD_SUBGRAPH, + network + ); + if (url == null) { + // Network doesn't support non-standard + return { holdings: [], cursor: createCursor('nonstandard', undefined) }; + } + const query = gql` { account(id: $userAddress) { @@ -53,7 +62,7 @@ const makeFetchNonStandards = `; const data = await querySubgraph({ - url: getChainConstant(config.subgraph.NON_STANDARD_SUBGRAPH, network), + url, query, variables: { lastId, userAddress }, }); diff --git a/packages/core/src/assets/fetchUserHoldings/types.ts b/packages/core/src/assets/fetchUserHoldings/types.ts index 099e7279..7eab3ba3 100644 --- a/packages/core/src/assets/fetchUserHoldings/types.ts +++ b/packages/core/src/assets/fetchUserHoldings/types.ts @@ -2,6 +2,6 @@ import type { Address } from '@nftx/types'; export type Holding = { assetAddress: Address; - tokenId: string; + tokenId: `${number}`; quantity?: bigint; }; diff --git a/packages/core/src/prices/common.ts b/packages/core/src/prices/common.ts index a8f9b2e4..3257b29e 100644 --- a/packages/core/src/prices/common.ts +++ b/packages/core/src/prices/common.ts @@ -111,7 +111,7 @@ const makeFetchPremiumPrice = vaultId: string; }): Promise<[vToken: bigint, price: bigint]> => { const now = Math.floor(Date.now() / 1000); - const premiumThreshold = now - PREMIUM_DURATION; + const premiumThreshold = now - getChainConstant(PREMIUM_DURATION, network); if (holding.dateAdded < premiumThreshold) { return [Zero, Zero]; diff --git a/packages/core/src/prices/priceVaultBuy.ts b/packages/core/src/prices/priceVaultBuy.ts index 9c48a17a..efeeb9bc 100644 --- a/packages/core/src/prices/priceVaultBuy.ts +++ b/packages/core/src/prices/priceVaultBuy.ts @@ -24,11 +24,13 @@ const getIndexedPrice = ({ tokenIds, vault, now, + network, }: { vault: Pick; tokenIds: TokenId[] | [TokenId, number][]; holdings: Pick[]; now: number; + network: number; }) => { // We store the prices for buying up to 5 NFTs // so we can save ourselves from having to make additional calls/calculations @@ -44,6 +46,7 @@ const getIndexedPrice = ({ tokenIds, vTokenToEth, now, + network, }); return { @@ -90,6 +93,7 @@ const getRoughPrice = async ({ tokenIds, vTokenToEth, now, + network, }); const price = vTokenPrice + feePrice + premiumPrice; @@ -168,7 +172,13 @@ export const makePriceVaultBuy = } if (bypassIndexedPrice !== true && totalTokenIds <= 5) { - const result = getIndexedPrice({ holdings, tokenIds, vault, now }); + const result = getIndexedPrice({ + holdings, + tokenIds, + vault, + now, + network, + }); if (result) { return result; } diff --git a/packages/core/src/prices/priceVaultSwap.ts b/packages/core/src/prices/priceVaultSwap.ts index 16fc9b27..96183688 100644 --- a/packages/core/src/prices/priceVaultSwap.ts +++ b/packages/core/src/prices/priceVaultSwap.ts @@ -23,11 +23,13 @@ const getIndexedPrice = ({ tokenIds, vault, now, + network, }: { holdings: Pick[]; tokenIds: TokenId[] | [TokenId, number][]; vault: Pick; now: number; + network: number; }) => { const totalTokenIds = getTotalTokenIds(tokenIds); const { vTokenToEth } = vault; @@ -40,6 +42,7 @@ const getIndexedPrice = ({ tokenIds, vTokenToEth, now, + network, }); return { @@ -53,11 +56,13 @@ const getRoughPrice = ({ holdings, vault, now, + network, }: { holdings: Pick[]; buyTokenIds: TokenId[] | [TokenId, number][]; vault: Pick; now: number; + network: number; }) => { const totalTokenIds = getTotalTokenIds(buyTokenIds); const { vTokenToEth } = vault; @@ -73,6 +78,7 @@ const getRoughPrice = ({ tokenIds: buyTokenIds, vTokenToEth, now, + network, }); const price = feePrice + premiumPrice; @@ -158,13 +164,14 @@ export const makePriceVaultSwap = tokenIds: buyTokenIds, vault, now, + network, }); if (result) { return result; } } - return getRoughPrice({ holdings, buyTokenIds, vault, now }); + return getRoughPrice({ holdings, buyTokenIds, vault, now, network }); }; const priceVaultSwap = makePriceVaultSwap({ quoteVaultSwap }); diff --git a/packages/react/src/contexts/nftx.tsx b/packages/react/src/contexts/nftx.tsx index 6f889d95..280b3516 100644 --- a/packages/react/src/contexts/nftx.tsx +++ b/packages/react/src/contexts/nftx.tsx @@ -9,7 +9,7 @@ import * as core from 'nftx.js'; import { EventsProvider } from './events'; import { Network, Provider, Signer } from 'nftx.js'; import { createPublicClient, http } from 'viem'; -import { arbitrum, mainnet, goerli } from 'viem/chains'; +import { arbitrum, mainnet, goerli, sepolia } from 'viem/chains'; const getDefaultProvider = (network: number) => { const chain = (() => { @@ -18,6 +18,8 @@ const getDefaultProvider = (network: number) => { return arbitrum; case Network.Goerli: return goerli; + case Network.Sepolia: + return sepolia; case Network.Mainnet: default: return mainnet; diff --git a/packages/subgraph/src/createQuery/createQuery.ts b/packages/subgraph/src/createQuery/createQuery.ts index a402eb8e..f6cc81a7 100644 --- a/packages/subgraph/src/createQuery/createQuery.ts +++ b/packages/subgraph/src/createQuery/createQuery.ts @@ -1,3 +1,4 @@ +import { normalizeIfAddress } from '../utils'; import type { Select, SelectFieldPrimitives } from './createSelect'; import createSelect from './createSelect'; import type { Where, WhereStatements } from './createWhere'; @@ -117,7 +118,7 @@ const stringify = (args: { output.push('orderDirection: ', args.orderDirection, '\n'); } if (args.id) { - output.push('id: ', `"${args.id}"`, '\n'); + output.push('id: ', `"${normalizeIfAddress(args.id)}"`, '\n'); } // Where if (w) { diff --git a/packages/subgraph/src/querySubgraph.ts b/packages/subgraph/src/querySubgraph.ts index 55ca15b7..a090bba7 100644 --- a/packages/subgraph/src/querySubgraph.ts +++ b/packages/subgraph/src/querySubgraph.ts @@ -1,4 +1,3 @@ -import config from '@nftx/config'; import { type GraphQueryString, interpolateQuery } from './utils'; import { query as sendQuery } from '@nftx/utils'; import { UnknownError } from '@nftx/errors'; diff --git a/packages/types/1155-sepolia.codegen.yml b/packages/types/1155-sepolia.codegen.yml new file mode 100644 index 00000000..01c62ca6 --- /dev/null +++ b/packages/types/1155-sepolia.codegen.yml @@ -0,0 +1,19 @@ +schema: https://api.thegraph.com/subgraphs/name/nftx-project/1155-sepolia-data-nexus +generates: + ./src/subgraph/1155-sepolia.ts: + config: + useTypeImports: true + strictScalars: true + scalars: + Bytes: + input: string + output: string + BigInt: + input: string + output: string + BigDecimal: + input: string + output: string + Int8: string|number + plugins: + - typescript diff --git a/packages/types/721-sepolia.codegen.yml b/packages/types/721-sepolia.codegen.yml new file mode 100644 index 00000000..89127a50 --- /dev/null +++ b/packages/types/721-sepolia.codegen.yml @@ -0,0 +1,19 @@ +schema: https://api.thegraph.com/subgraphs/name/nftx-project/721-sepolia-data-nexus +generates: + ./src/subgraph/721-sepolia.ts: + config: + useTypeImports: true + strictScalars: true + scalars: + Bytes: + input: string + output: string + BigInt: + input: string + output: string + BigDecimal: + input: string + output: string + Int8: string|number + plugins: + - typescript diff --git a/packages/types/package.json b/packages/types/package.json index 58d9284a..dd77bf69 100644 --- a/packages/types/package.json +++ b/packages/types/package.json @@ -19,7 +19,7 @@ "scripts": { "lint": "eslint --fix -c ../../.eslintrc.js --ext ts,tsx src && tsc --noEmit", "test": "echo \"no tests\"", - "codegen": "graphql-codegen -c nftx-v3.codegen.yml && graphql-codegen -c nftx-v3-uniswap.codegen.yml", + "codegen": "graphql-codegen -c nftx-v3.codegen.yml && graphql-codegen -c nftx-v3-uniswap.codegen.yml && graphql-codegen -c 721-sepolia.codegen.yml && graphql-codegen -c 1155-sepolia.codegen.yml", "build": "rm -rf dist && tsc -d --outDir dist/ts --emitDeclarationOnly && mkdir dist/cjs && echo \"module.exports = {}\" > dist/cjs/index.js", "prepublishOnly": "yarn build && yarn codegen" }, diff --git a/packages/types/src/subgraph/1155-sepolia.ts b/packages/types/src/subgraph/1155-sepolia.ts new file mode 100644 index 00000000..d5364b97 --- /dev/null +++ b/packages/types/src/subgraph/1155-sepolia.ts @@ -0,0 +1,937 @@ +export type Maybe = T | null; +export type InputMaybe = Maybe; +export type Exact = { [K in keyof T]: T[K] }; +export type MakeOptional = Omit & { [SubKey in K]?: Maybe }; +export type MakeMaybe = Omit & { [SubKey in K]: Maybe }; +export type MakeEmpty = { [_ in K]?: never }; +export type Incremental = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never }; +/** All built-in and custom scalars, mapped to their actual values */ +export type Scalars = { + ID: { input: string; output: string; } + String: { input: string; output: string; } + Boolean: { input: boolean; output: boolean; } + Int: { input: number; output: number; } + Float: { input: number; output: number; } + BigDecimal: { input: string; output: string; } + BigInt: { input: string; output: string; } + Bytes: { input: string; output: string; } + Int8: { input: string|number; output: string|number; } +}; + +export type Account = { + __typename?: 'Account'; + /** Represents the NFT's owned by the account */ + holdings: Array; + /** the wallet address */ + id: Scalars['ID']['output']; + /** The transfers originating from this account */ + transfersFrom: Array; + /** The transfers recevied by this account */ + transfersTo: Array; +}; + + +export type AccountHoldingsArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + + +export type AccountTransfersFromArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + + +export type AccountTransfersToArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + +export type Account_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + holdings_?: InputMaybe; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + or?: InputMaybe>>; + transfersFrom_?: InputMaybe; + transfersTo_?: InputMaybe; +}; + +export enum Account_OrderBy { + Holdings = 'holdings', + Id = 'id', + TransfersFrom = 'transfersFrom', + TransfersTo = 'transfersTo' +} + +export type BlockChangedFilter = { + number_gte: Scalars['Int']['input']; +}; + +export type Block_Height = { + hash?: InputMaybe; + number?: InputMaybe; + number_gte?: InputMaybe; +}; + +/** replaces TokenRegistry */ +export type Collection = { + __typename?: 'Collection'; + /** M:M relationship for Accounts and Collections */ + collectionHoldings: Array; + /** The address of the collection */ + id: Scalars['ID']['output']; + /** The name of the collection */ + name?: Maybe; + /** The symbol for the collection */ + symbol?: Maybe; + /** Tokens for the collection */ + tokens: Array; +}; + + +/** replaces TokenRegistry */ +export type CollectionCollectionHoldingsArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + + +/** replaces TokenRegistry */ +export type CollectionTokensArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + +/** Account level holding for an collection */ +export type CollectionHolding = { + __typename?: 'CollectionHolding'; + /** Address of the account */ + account: Account; + /** Count of NFT's owned in a collection by the Address */ + balance: Scalars['BigInt']['output']; + /** token Id */ + collection: Collection; + /** Collection Id - Account ID */ + id: Scalars['ID']['output']; +}; + +export type CollectionHolding_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + account?: InputMaybe; + account_?: InputMaybe; + account_contains?: InputMaybe; + account_contains_nocase?: InputMaybe; + account_ends_with?: InputMaybe; + account_ends_with_nocase?: InputMaybe; + account_gt?: InputMaybe; + account_gte?: InputMaybe; + account_in?: InputMaybe>; + account_lt?: InputMaybe; + account_lte?: InputMaybe; + account_not?: InputMaybe; + account_not_contains?: InputMaybe; + account_not_contains_nocase?: InputMaybe; + account_not_ends_with?: InputMaybe; + account_not_ends_with_nocase?: InputMaybe; + account_not_in?: InputMaybe>; + account_not_starts_with?: InputMaybe; + account_not_starts_with_nocase?: InputMaybe; + account_starts_with?: InputMaybe; + account_starts_with_nocase?: InputMaybe; + and?: InputMaybe>>; + balance?: InputMaybe; + balance_gt?: InputMaybe; + balance_gte?: InputMaybe; + balance_in?: InputMaybe>; + balance_lt?: InputMaybe; + balance_lte?: InputMaybe; + balance_not?: InputMaybe; + balance_not_in?: InputMaybe>; + collection?: InputMaybe; + collection_?: InputMaybe; + collection_contains?: InputMaybe; + collection_contains_nocase?: InputMaybe; + collection_ends_with?: InputMaybe; + collection_ends_with_nocase?: InputMaybe; + collection_gt?: InputMaybe; + collection_gte?: InputMaybe; + collection_in?: InputMaybe>; + collection_lt?: InputMaybe; + collection_lte?: InputMaybe; + collection_not?: InputMaybe; + collection_not_contains?: InputMaybe; + collection_not_contains_nocase?: InputMaybe; + collection_not_ends_with?: InputMaybe; + collection_not_ends_with_nocase?: InputMaybe; + collection_not_in?: InputMaybe>; + collection_not_starts_with?: InputMaybe; + collection_not_starts_with_nocase?: InputMaybe; + collection_starts_with?: InputMaybe; + collection_starts_with_nocase?: InputMaybe; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + or?: InputMaybe>>; +}; + +export enum CollectionHolding_OrderBy { + Account = 'account', + AccountId = 'account__id', + Balance = 'balance', + Collection = 'collection', + CollectionId = 'collection__id', + CollectionName = 'collection__name', + CollectionSymbol = 'collection__symbol', + Id = 'id' +} + +export type Collection_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + collectionHoldings_?: InputMaybe; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + name?: InputMaybe; + name_contains?: InputMaybe; + name_contains_nocase?: InputMaybe; + name_ends_with?: InputMaybe; + name_ends_with_nocase?: InputMaybe; + name_gt?: InputMaybe; + name_gte?: InputMaybe; + name_in?: InputMaybe>; + name_lt?: InputMaybe; + name_lte?: InputMaybe; + name_not?: InputMaybe; + name_not_contains?: InputMaybe; + name_not_contains_nocase?: InputMaybe; + name_not_ends_with?: InputMaybe; + name_not_ends_with_nocase?: InputMaybe; + name_not_in?: InputMaybe>; + name_not_starts_with?: InputMaybe; + name_not_starts_with_nocase?: InputMaybe; + name_starts_with?: InputMaybe; + name_starts_with_nocase?: InputMaybe; + or?: InputMaybe>>; + symbol?: InputMaybe; + symbol_contains?: InputMaybe; + symbol_contains_nocase?: InputMaybe; + symbol_ends_with?: InputMaybe; + symbol_ends_with_nocase?: InputMaybe; + symbol_gt?: InputMaybe; + symbol_gte?: InputMaybe; + symbol_in?: InputMaybe>; + symbol_lt?: InputMaybe; + symbol_lte?: InputMaybe; + symbol_not?: InputMaybe; + symbol_not_contains?: InputMaybe; + symbol_not_contains_nocase?: InputMaybe; + symbol_not_ends_with?: InputMaybe; + symbol_not_ends_with_nocase?: InputMaybe; + symbol_not_in?: InputMaybe>; + symbol_not_starts_with?: InputMaybe; + symbol_not_starts_with_nocase?: InputMaybe; + symbol_starts_with?: InputMaybe; + symbol_starts_with_nocase?: InputMaybe; + tokens_?: InputMaybe; +}; + +export enum Collection_OrderBy { + CollectionHoldings = 'collectionHoldings', + Id = 'id', + Name = 'name', + Symbol = 'symbol', + Tokens = 'tokens' +} + +/** Account level holding for an NFT */ +export type Holding = { + __typename?: 'Holding'; + /** Address of the account */ + account: Account; + /** Count of NFT's owned by the Address */ + balance: Scalars['BigInt']['output']; + /** Account Id - Token Id */ + id: Scalars['ID']['output']; + /** token Id */ + token: Token; +}; + +export type Holding_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + account?: InputMaybe; + account_?: InputMaybe; + account_contains?: InputMaybe; + account_contains_nocase?: InputMaybe; + account_ends_with?: InputMaybe; + account_ends_with_nocase?: InputMaybe; + account_gt?: InputMaybe; + account_gte?: InputMaybe; + account_in?: InputMaybe>; + account_lt?: InputMaybe; + account_lte?: InputMaybe; + account_not?: InputMaybe; + account_not_contains?: InputMaybe; + account_not_contains_nocase?: InputMaybe; + account_not_ends_with?: InputMaybe; + account_not_ends_with_nocase?: InputMaybe; + account_not_in?: InputMaybe>; + account_not_starts_with?: InputMaybe; + account_not_starts_with_nocase?: InputMaybe; + account_starts_with?: InputMaybe; + account_starts_with_nocase?: InputMaybe; + and?: InputMaybe>>; + balance?: InputMaybe; + balance_gt?: InputMaybe; + balance_gte?: InputMaybe; + balance_in?: InputMaybe>; + balance_lt?: InputMaybe; + balance_lte?: InputMaybe; + balance_not?: InputMaybe; + balance_not_in?: InputMaybe>; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + or?: InputMaybe>>; + token?: InputMaybe; + token_?: InputMaybe; + token_contains?: InputMaybe; + token_contains_nocase?: InputMaybe; + token_ends_with?: InputMaybe; + token_ends_with_nocase?: InputMaybe; + token_gt?: InputMaybe; + token_gte?: InputMaybe; + token_in?: InputMaybe>; + token_lt?: InputMaybe; + token_lte?: InputMaybe; + token_not?: InputMaybe; + token_not_contains?: InputMaybe; + token_not_contains_nocase?: InputMaybe; + token_not_ends_with?: InputMaybe; + token_not_ends_with_nocase?: InputMaybe; + token_not_in?: InputMaybe>; + token_not_starts_with?: InputMaybe; + token_not_starts_with_nocase?: InputMaybe; + token_starts_with?: InputMaybe; + token_starts_with_nocase?: InputMaybe; +}; + +export enum Holding_OrderBy { + Account = 'account', + AccountId = 'account__id', + Balance = 'balance', + Id = 'id', + Token = 'token', + TokenId = 'token__id', + TokenIdentifier = 'token__identifier', + TokenTotalSupply = 'token__totalSupply' +} + +/** Defines the order direction, either ascending or descending */ +export enum OrderDirection { + Asc = 'asc', + Desc = 'desc' +} + +export type Query = { + __typename?: 'Query'; + /** Access to subgraph metadata */ + _meta?: Maybe<_Meta_>; + account?: Maybe; + accounts: Array; + collection?: Maybe; + collectionHolding?: Maybe; + collectionHoldings: Array; + collections: Array; + holding?: Maybe; + holdings: Array; + token?: Maybe; + tokens: Array; + transfer?: Maybe; + transfers: Array; +}; + + +export type Query_MetaArgs = { + block?: InputMaybe; +}; + + +export type QueryAccountArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryAccountsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type QueryCollectionArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryCollectionHoldingArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryCollectionHoldingsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type QueryCollectionsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type QueryHoldingArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryHoldingsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type QueryTokenArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryTokensArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type QueryTransferArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryTransfersArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + +export type Subscription = { + __typename?: 'Subscription'; + /** Access to subgraph metadata */ + _meta?: Maybe<_Meta_>; + account?: Maybe; + accounts: Array; + collection?: Maybe; + collectionHolding?: Maybe; + collectionHoldings: Array; + collections: Array; + holding?: Maybe; + holdings: Array; + token?: Maybe; + tokens: Array; + transfer?: Maybe; + transfers: Array; +}; + + +export type Subscription_MetaArgs = { + block?: InputMaybe; +}; + + +export type SubscriptionAccountArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionAccountsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type SubscriptionCollectionArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionCollectionHoldingArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionCollectionHoldingsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type SubscriptionCollectionsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type SubscriptionHoldingArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionHoldingsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type SubscriptionTokenArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionTokensArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type SubscriptionTransferArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionTransfersArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + +export type Token = { + __typename?: 'Token'; + /** The collection address */ + collection: Collection; + /** M:M relationship for Accounts and Collections */ + holdings: Array; + /** Ethereum / Collection Addrress - Token Id */ + id: Scalars['ID']['output']; + /** The id of the NFT */ + identifier: Scalars['BigInt']['output']; + /** Total Supply of Tokens */ + totalSupply: Scalars['BigInt']['output']; + /** Transfers involving this token */ + transfers: Array; +}; + + +export type TokenHoldingsArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + + +export type TokenTransfersArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + +export type Token_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + collection?: InputMaybe; + collection_?: InputMaybe; + collection_contains?: InputMaybe; + collection_contains_nocase?: InputMaybe; + collection_ends_with?: InputMaybe; + collection_ends_with_nocase?: InputMaybe; + collection_gt?: InputMaybe; + collection_gte?: InputMaybe; + collection_in?: InputMaybe>; + collection_lt?: InputMaybe; + collection_lte?: InputMaybe; + collection_not?: InputMaybe; + collection_not_contains?: InputMaybe; + collection_not_contains_nocase?: InputMaybe; + collection_not_ends_with?: InputMaybe; + collection_not_ends_with_nocase?: InputMaybe; + collection_not_in?: InputMaybe>; + collection_not_starts_with?: InputMaybe; + collection_not_starts_with_nocase?: InputMaybe; + collection_starts_with?: InputMaybe; + collection_starts_with_nocase?: InputMaybe; + holdings_?: InputMaybe; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + identifier?: InputMaybe; + identifier_gt?: InputMaybe; + identifier_gte?: InputMaybe; + identifier_in?: InputMaybe>; + identifier_lt?: InputMaybe; + identifier_lte?: InputMaybe; + identifier_not?: InputMaybe; + identifier_not_in?: InputMaybe>; + or?: InputMaybe>>; + totalSupply?: InputMaybe; + totalSupply_gt?: InputMaybe; + totalSupply_gte?: InputMaybe; + totalSupply_in?: InputMaybe>; + totalSupply_lt?: InputMaybe; + totalSupply_lte?: InputMaybe; + totalSupply_not?: InputMaybe; + totalSupply_not_in?: InputMaybe>; + transfers_?: InputMaybe; +}; + +export enum Token_OrderBy { + Collection = 'collection', + CollectionId = 'collection__id', + CollectionName = 'collection__name', + CollectionSymbol = 'collection__symbol', + Holdings = 'holdings', + Id = 'id', + Identifier = 'identifier', + TotalSupply = 'totalSupply', + Transfers = 'transfers' +} + +export type Transfer = { + __typename?: 'Transfer'; + /** Block Number */ + blockNumber: Scalars['BigInt']['output']; + /** The collection address */ + collection: Collection; + /** Block Number and Event Id in which the transfers event occured */ + id: Scalars['ID']['output']; + /** The receiver address */ + receiverAddress: Account; + /** The sender address */ + senderAddress: Account; + /** Timestamp for block */ + timestamp: Scalars['BigInt']['output']; + /** The collection addrress - The token id */ + token: Token; + /** Transaction hash in which the transfer event occured */ + transaction: Scalars['Bytes']['output']; +}; + +export type Transfer_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + blockNumber?: InputMaybe; + blockNumber_gt?: InputMaybe; + blockNumber_gte?: InputMaybe; + blockNumber_in?: InputMaybe>; + blockNumber_lt?: InputMaybe; + blockNumber_lte?: InputMaybe; + blockNumber_not?: InputMaybe; + blockNumber_not_in?: InputMaybe>; + collection?: InputMaybe; + collection_?: InputMaybe; + collection_contains?: InputMaybe; + collection_contains_nocase?: InputMaybe; + collection_ends_with?: InputMaybe; + collection_ends_with_nocase?: InputMaybe; + collection_gt?: InputMaybe; + collection_gte?: InputMaybe; + collection_in?: InputMaybe>; + collection_lt?: InputMaybe; + collection_lte?: InputMaybe; + collection_not?: InputMaybe; + collection_not_contains?: InputMaybe; + collection_not_contains_nocase?: InputMaybe; + collection_not_ends_with?: InputMaybe; + collection_not_ends_with_nocase?: InputMaybe; + collection_not_in?: InputMaybe>; + collection_not_starts_with?: InputMaybe; + collection_not_starts_with_nocase?: InputMaybe; + collection_starts_with?: InputMaybe; + collection_starts_with_nocase?: InputMaybe; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + or?: InputMaybe>>; + receiverAddress?: InputMaybe; + receiverAddress_?: InputMaybe; + receiverAddress_contains?: InputMaybe; + receiverAddress_contains_nocase?: InputMaybe; + receiverAddress_ends_with?: InputMaybe; + receiverAddress_ends_with_nocase?: InputMaybe; + receiverAddress_gt?: InputMaybe; + receiverAddress_gte?: InputMaybe; + receiverAddress_in?: InputMaybe>; + receiverAddress_lt?: InputMaybe; + receiverAddress_lte?: InputMaybe; + receiverAddress_not?: InputMaybe; + receiverAddress_not_contains?: InputMaybe; + receiverAddress_not_contains_nocase?: InputMaybe; + receiverAddress_not_ends_with?: InputMaybe; + receiverAddress_not_ends_with_nocase?: InputMaybe; + receiverAddress_not_in?: InputMaybe>; + receiverAddress_not_starts_with?: InputMaybe; + receiverAddress_not_starts_with_nocase?: InputMaybe; + receiverAddress_starts_with?: InputMaybe; + receiverAddress_starts_with_nocase?: InputMaybe; + senderAddress?: InputMaybe; + senderAddress_?: InputMaybe; + senderAddress_contains?: InputMaybe; + senderAddress_contains_nocase?: InputMaybe; + senderAddress_ends_with?: InputMaybe; + senderAddress_ends_with_nocase?: InputMaybe; + senderAddress_gt?: InputMaybe; + senderAddress_gte?: InputMaybe; + senderAddress_in?: InputMaybe>; + senderAddress_lt?: InputMaybe; + senderAddress_lte?: InputMaybe; + senderAddress_not?: InputMaybe; + senderAddress_not_contains?: InputMaybe; + senderAddress_not_contains_nocase?: InputMaybe; + senderAddress_not_ends_with?: InputMaybe; + senderAddress_not_ends_with_nocase?: InputMaybe; + senderAddress_not_in?: InputMaybe>; + senderAddress_not_starts_with?: InputMaybe; + senderAddress_not_starts_with_nocase?: InputMaybe; + senderAddress_starts_with?: InputMaybe; + senderAddress_starts_with_nocase?: InputMaybe; + timestamp?: InputMaybe; + timestamp_gt?: InputMaybe; + timestamp_gte?: InputMaybe; + timestamp_in?: InputMaybe>; + timestamp_lt?: InputMaybe; + timestamp_lte?: InputMaybe; + timestamp_not?: InputMaybe; + timestamp_not_in?: InputMaybe>; + token?: InputMaybe; + token_?: InputMaybe; + token_contains?: InputMaybe; + token_contains_nocase?: InputMaybe; + token_ends_with?: InputMaybe; + token_ends_with_nocase?: InputMaybe; + token_gt?: InputMaybe; + token_gte?: InputMaybe; + token_in?: InputMaybe>; + token_lt?: InputMaybe; + token_lte?: InputMaybe; + token_not?: InputMaybe; + token_not_contains?: InputMaybe; + token_not_contains_nocase?: InputMaybe; + token_not_ends_with?: InputMaybe; + token_not_ends_with_nocase?: InputMaybe; + token_not_in?: InputMaybe>; + token_not_starts_with?: InputMaybe; + token_not_starts_with_nocase?: InputMaybe; + token_starts_with?: InputMaybe; + token_starts_with_nocase?: InputMaybe; + transaction?: InputMaybe; + transaction_contains?: InputMaybe; + transaction_gt?: InputMaybe; + transaction_gte?: InputMaybe; + transaction_in?: InputMaybe>; + transaction_lt?: InputMaybe; + transaction_lte?: InputMaybe; + transaction_not?: InputMaybe; + transaction_not_contains?: InputMaybe; + transaction_not_in?: InputMaybe>; +}; + +export enum Transfer_OrderBy { + BlockNumber = 'blockNumber', + Collection = 'collection', + CollectionId = 'collection__id', + CollectionName = 'collection__name', + CollectionSymbol = 'collection__symbol', + Id = 'id', + ReceiverAddress = 'receiverAddress', + ReceiverAddressId = 'receiverAddress__id', + SenderAddress = 'senderAddress', + SenderAddressId = 'senderAddress__id', + Timestamp = 'timestamp', + Token = 'token', + TokenId = 'token__id', + TokenIdentifier = 'token__identifier', + TokenTotalSupply = 'token__totalSupply', + Transaction = 'transaction' +} + +export type _Block_ = { + __typename?: '_Block_'; + /** The hash of the block */ + hash?: Maybe; + /** The block number */ + number: Scalars['Int']['output']; + /** Integer representation of the timestamp stored in blocks for the chain */ + timestamp?: Maybe; +}; + +/** The type for the top-level _meta field */ +export type _Meta_ = { + __typename?: '_Meta_'; + /** + * Information about a specific subgraph block. The hash of the block + * will be null if the _meta field has a block constraint that asks for + * a block number. It will be filled if the _meta field has no block constraint + * and therefore asks for the latest block + * + */ + block: _Block_; + /** The deployment ID */ + deployment: Scalars['String']['output']; + /** If `true`, the subgraph encountered indexing errors at some past block */ + hasIndexingErrors: Scalars['Boolean']['output']; +}; + +export enum _SubgraphErrorPolicy_ { + /** Data will be returned even if the subgraph has indexing errors */ + Allow = 'allow', + /** If the subgraph has indexing errors, data will be omitted. The default. */ + Deny = 'deny' +} diff --git a/packages/types/src/subgraph/721-sepolia.ts b/packages/types/src/subgraph/721-sepolia.ts new file mode 100644 index 00000000..37c95511 --- /dev/null +++ b/packages/types/src/subgraph/721-sepolia.ts @@ -0,0 +1,925 @@ +export type Maybe = T | null; +export type InputMaybe = Maybe; +export type Exact = { [K in keyof T]: T[K] }; +export type MakeOptional = Omit & { [SubKey in K]?: Maybe }; +export type MakeMaybe = Omit & { [SubKey in K]: Maybe }; +export type MakeEmpty = { [_ in K]?: never }; +export type Incremental = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never }; +/** All built-in and custom scalars, mapped to their actual values */ +export type Scalars = { + ID: { input: string; output: string; } + String: { input: string; output: string; } + Boolean: { input: boolean; output: boolean; } + Int: { input: number; output: number; } + Float: { input: number; output: number; } + BigDecimal: { input: string; output: string; } + BigInt: { input: string; output: string; } + Bytes: { input: string; output: string; } + Int8: { input: string|number; output: string|number; } +}; + +export type BlockChangedFilter = { + number_gte: Scalars['Int']['input']; +}; + +export type Block_Height = { + hash?: InputMaybe; + number?: InputMaybe; + number_gte?: InputMaybe; +}; + +/** Defines the order direction, either ascending or descending */ +export enum OrderDirection { + Asc = 'asc', + Desc = 'desc' +} + +export type Query = { + __typename?: 'Query'; + /** Access to subgraph metadata */ + _meta?: Maybe<_Meta_>; + account?: Maybe; + accounts: Array; + collection?: Maybe; + collections: Array; + contract?: Maybe; + contracts: Array; + holding?: Maybe; + holdings: Array; + token?: Maybe; + tokens: Array; + transfer?: Maybe; + transfers: Array; +}; + + +export type Query_MetaArgs = { + block?: InputMaybe; +}; + + +export type QueryAccountArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryAccountsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type QueryCollectionArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryCollectionsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type QueryContractArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryContractsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type QueryHoldingArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryHoldingsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type QueryTokenArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryTokensArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type QueryTransferArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type QueryTransfersArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + +export type Subscription = { + __typename?: 'Subscription'; + /** Access to subgraph metadata */ + _meta?: Maybe<_Meta_>; + account?: Maybe; + accounts: Array; + collection?: Maybe; + collections: Array; + contract?: Maybe; + contracts: Array; + holding?: Maybe; + holdings: Array; + token?: Maybe; + tokens: Array; + transfer?: Maybe; + transfers: Array; +}; + + +export type Subscription_MetaArgs = { + block?: InputMaybe; +}; + + +export type SubscriptionAccountArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionAccountsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type SubscriptionCollectionArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionCollectionsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type SubscriptionContractArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionContractsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type SubscriptionHoldingArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionHoldingsArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type SubscriptionTokenArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionTokensArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + + +export type SubscriptionTransferArgs = { + block?: InputMaybe; + id: Scalars['ID']['input']; + subgraphError?: _SubgraphErrorPolicy_; +}; + + +export type SubscriptionTransfersArgs = { + block?: InputMaybe; + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + subgraphError?: _SubgraphErrorPolicy_; + where?: InputMaybe; +}; + +export type _Block_ = { + __typename?: '_Block_'; + /** The hash of the block */ + hash?: Maybe; + /** The block number */ + number: Scalars['Int']['output']; + /** Integer representation of the timestamp stored in blocks for the chain */ + timestamp?: Maybe; +}; + +/** The type for the top-level _meta field */ +export type _Meta_ = { + __typename?: '_Meta_'; + /** + * Information about a specific subgraph block. The hash of the block + * will be null if the _meta field has a block constraint that asks for + * a block number. It will be filled if the _meta field has no block constraint + * and therefore asks for the latest block + * + */ + block: _Block_; + /** The deployment ID */ + deployment: Scalars['String']['output']; + /** If `true`, the subgraph encountered indexing errors at some past block */ + hasIndexingErrors: Scalars['Boolean']['output']; +}; + +export enum _SubgraphErrorPolicy_ { + /** Data will be returned even if the subgraph has indexing errors */ + Allow = 'allow', + /** If the subgraph has indexing errors, data will be omitted. The default. */ + Deny = 'deny' +} + +export type Account = { + __typename?: 'account'; + /** M:M relationship for Accounts and Collections */ + holdings: Array; + /** the wallet address */ + id: Scalars['ID']['output']; + /** The NFTs owned by this account */ + tokens: Array; + /** The transfers originating from this account */ + transfersFrom: Array; + /** The transfers recevied by this account */ + transfersTo: Array; +}; + + +export type AccountHoldingsArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + + +export type AccountTokensArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + + +export type AccountTransfersFromArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + + +export type AccountTransfersToArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + +export type Account_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + holdings_?: InputMaybe; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + or?: InputMaybe>>; + tokens_?: InputMaybe; + transfersFrom_?: InputMaybe; + transfersTo_?: InputMaybe; +}; + +export enum Account_OrderBy { + Holdings = 'holdings', + Id = 'id', + Tokens = 'tokens', + TransfersFrom = 'transfersFrom', + TransfersTo = 'transfersTo' +} + +/** replaces TokenRegistry */ +export type Collection = { + __typename?: 'collection'; + /** M:M relationship for Accounts and Collections */ + holdings: Array; + /** The address of the collection */ + id: Scalars['ID']['output']; + /** The name of the collection */ + name?: Maybe; + /** The symbol for the collection */ + symbol?: Maybe; + /** Tokens for the collection */ + tokens: Array; + /** Total Supply of Tokens */ + totalSupply?: Maybe; +}; + + +/** replaces TokenRegistry */ +export type CollectionHoldingsArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + + +/** replaces TokenRegistry */ +export type CollectionTokensArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + +export type Collection_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + holdings_?: InputMaybe; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + name?: InputMaybe; + name_contains?: InputMaybe; + name_contains_nocase?: InputMaybe; + name_ends_with?: InputMaybe; + name_ends_with_nocase?: InputMaybe; + name_gt?: InputMaybe; + name_gte?: InputMaybe; + name_in?: InputMaybe>; + name_lt?: InputMaybe; + name_lte?: InputMaybe; + name_not?: InputMaybe; + name_not_contains?: InputMaybe; + name_not_contains_nocase?: InputMaybe; + name_not_ends_with?: InputMaybe; + name_not_ends_with_nocase?: InputMaybe; + name_not_in?: InputMaybe>; + name_not_starts_with?: InputMaybe; + name_not_starts_with_nocase?: InputMaybe; + name_starts_with?: InputMaybe; + name_starts_with_nocase?: InputMaybe; + or?: InputMaybe>>; + symbol?: InputMaybe; + symbol_contains?: InputMaybe; + symbol_contains_nocase?: InputMaybe; + symbol_ends_with?: InputMaybe; + symbol_ends_with_nocase?: InputMaybe; + symbol_gt?: InputMaybe; + symbol_gte?: InputMaybe; + symbol_in?: InputMaybe>; + symbol_lt?: InputMaybe; + symbol_lte?: InputMaybe; + symbol_not?: InputMaybe; + symbol_not_contains?: InputMaybe; + symbol_not_contains_nocase?: InputMaybe; + symbol_not_ends_with?: InputMaybe; + symbol_not_ends_with_nocase?: InputMaybe; + symbol_not_in?: InputMaybe>; + symbol_not_starts_with?: InputMaybe; + symbol_not_starts_with_nocase?: InputMaybe; + symbol_starts_with?: InputMaybe; + symbol_starts_with_nocase?: InputMaybe; + tokens_?: InputMaybe; + totalSupply?: InputMaybe; + totalSupply_gt?: InputMaybe; + totalSupply_gte?: InputMaybe; + totalSupply_in?: InputMaybe>; + totalSupply_lt?: InputMaybe; + totalSupply_lte?: InputMaybe; + totalSupply_not?: InputMaybe; + totalSupply_not_in?: InputMaybe>; +}; + +export enum Collection_OrderBy { + Holdings = 'holdings', + Id = 'id', + Name = 'name', + Symbol = 'symbol', + Tokens = 'tokens', + TotalSupply = 'totalSupply' +} + +export type Contract = { + __typename?: 'contract'; + asERC721?: Maybe; + id: Scalars['ID']['output']; +}; + +export type Contract_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + asERC721?: InputMaybe; + asERC721_?: InputMaybe; + asERC721_contains?: InputMaybe; + asERC721_contains_nocase?: InputMaybe; + asERC721_ends_with?: InputMaybe; + asERC721_ends_with_nocase?: InputMaybe; + asERC721_gt?: InputMaybe; + asERC721_gte?: InputMaybe; + asERC721_in?: InputMaybe>; + asERC721_lt?: InputMaybe; + asERC721_lte?: InputMaybe; + asERC721_not?: InputMaybe; + asERC721_not_contains?: InputMaybe; + asERC721_not_contains_nocase?: InputMaybe; + asERC721_not_ends_with?: InputMaybe; + asERC721_not_ends_with_nocase?: InputMaybe; + asERC721_not_in?: InputMaybe>; + asERC721_not_starts_with?: InputMaybe; + asERC721_not_starts_with_nocase?: InputMaybe; + asERC721_starts_with?: InputMaybe; + asERC721_starts_with_nocase?: InputMaybe; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + or?: InputMaybe>>; +}; + +export enum Contract_OrderBy { + AsErc721 = 'asERC721', + AsErc721Id = 'asERC721__id', + AsErc721Name = 'asERC721__name', + AsErc721Symbol = 'asERC721__symbol', + AsErc721TotalSupply = 'asERC721__totalSupply', + Id = 'id' +} + +export type Holding = { + __typename?: 'holding'; + /** Address of the account */ + account?: Maybe; + /** Address of the NFT Collection */ + collection?: Maybe; + /** Account Id - Collection Id */ + id: Scalars['ID']['output']; + /** Count of NFT's owned in a collection by the Address */ + tokenCount: Scalars['Int']['output']; +}; + +export type Holding_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + account?: InputMaybe; + account_?: InputMaybe; + account_contains?: InputMaybe; + account_contains_nocase?: InputMaybe; + account_ends_with?: InputMaybe; + account_ends_with_nocase?: InputMaybe; + account_gt?: InputMaybe; + account_gte?: InputMaybe; + account_in?: InputMaybe>; + account_lt?: InputMaybe; + account_lte?: InputMaybe; + account_not?: InputMaybe; + account_not_contains?: InputMaybe; + account_not_contains_nocase?: InputMaybe; + account_not_ends_with?: InputMaybe; + account_not_ends_with_nocase?: InputMaybe; + account_not_in?: InputMaybe>; + account_not_starts_with?: InputMaybe; + account_not_starts_with_nocase?: InputMaybe; + account_starts_with?: InputMaybe; + account_starts_with_nocase?: InputMaybe; + and?: InputMaybe>>; + collection?: InputMaybe; + collection_?: InputMaybe; + collection_contains?: InputMaybe; + collection_contains_nocase?: InputMaybe; + collection_ends_with?: InputMaybe; + collection_ends_with_nocase?: InputMaybe; + collection_gt?: InputMaybe; + collection_gte?: InputMaybe; + collection_in?: InputMaybe>; + collection_lt?: InputMaybe; + collection_lte?: InputMaybe; + collection_not?: InputMaybe; + collection_not_contains?: InputMaybe; + collection_not_contains_nocase?: InputMaybe; + collection_not_ends_with?: InputMaybe; + collection_not_ends_with_nocase?: InputMaybe; + collection_not_in?: InputMaybe>; + collection_not_starts_with?: InputMaybe; + collection_not_starts_with_nocase?: InputMaybe; + collection_starts_with?: InputMaybe; + collection_starts_with_nocase?: InputMaybe; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + or?: InputMaybe>>; + tokenCount?: InputMaybe; + tokenCount_gt?: InputMaybe; + tokenCount_gte?: InputMaybe; + tokenCount_in?: InputMaybe>; + tokenCount_lt?: InputMaybe; + tokenCount_lte?: InputMaybe; + tokenCount_not?: InputMaybe; + tokenCount_not_in?: InputMaybe>; +}; + +export enum Holding_OrderBy { + Account = 'account', + AccountId = 'account__id', + Collection = 'collection', + CollectionId = 'collection__id', + CollectionName = 'collection__name', + CollectionSymbol = 'collection__symbol', + CollectionTotalSupply = 'collection__totalSupply', + Id = 'id', + TokenCount = 'tokenCount' +} + +export type Token = { + __typename?: 'token'; + /** The collection address */ + collection: Collection; + /** Ethereum / Collection Addrress - Token Id */ + id: Scalars['ID']['output']; + /** The id of the NFT */ + identifier: Scalars['BigInt']['output']; + /** The address the currently owns the token */ + owner?: Maybe; + /** Transfers involving this token */ + transfers: Array; +}; + + +export type TokenTransfersArgs = { + first?: InputMaybe; + orderBy?: InputMaybe; + orderDirection?: InputMaybe; + skip?: InputMaybe; + where?: InputMaybe; +}; + +export type Token_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + collection?: InputMaybe; + collection_?: InputMaybe; + collection_contains?: InputMaybe; + collection_contains_nocase?: InputMaybe; + collection_ends_with?: InputMaybe; + collection_ends_with_nocase?: InputMaybe; + collection_gt?: InputMaybe; + collection_gte?: InputMaybe; + collection_in?: InputMaybe>; + collection_lt?: InputMaybe; + collection_lte?: InputMaybe; + collection_not?: InputMaybe; + collection_not_contains?: InputMaybe; + collection_not_contains_nocase?: InputMaybe; + collection_not_ends_with?: InputMaybe; + collection_not_ends_with_nocase?: InputMaybe; + collection_not_in?: InputMaybe>; + collection_not_starts_with?: InputMaybe; + collection_not_starts_with_nocase?: InputMaybe; + collection_starts_with?: InputMaybe; + collection_starts_with_nocase?: InputMaybe; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + identifier?: InputMaybe; + identifier_gt?: InputMaybe; + identifier_gte?: InputMaybe; + identifier_in?: InputMaybe>; + identifier_lt?: InputMaybe; + identifier_lte?: InputMaybe; + identifier_not?: InputMaybe; + identifier_not_in?: InputMaybe>; + or?: InputMaybe>>; + owner?: InputMaybe; + owner_?: InputMaybe; + owner_contains?: InputMaybe; + owner_contains_nocase?: InputMaybe; + owner_ends_with?: InputMaybe; + owner_ends_with_nocase?: InputMaybe; + owner_gt?: InputMaybe; + owner_gte?: InputMaybe; + owner_in?: InputMaybe>; + owner_lt?: InputMaybe; + owner_lte?: InputMaybe; + owner_not?: InputMaybe; + owner_not_contains?: InputMaybe; + owner_not_contains_nocase?: InputMaybe; + owner_not_ends_with?: InputMaybe; + owner_not_ends_with_nocase?: InputMaybe; + owner_not_in?: InputMaybe>; + owner_not_starts_with?: InputMaybe; + owner_not_starts_with_nocase?: InputMaybe; + owner_starts_with?: InputMaybe; + owner_starts_with_nocase?: InputMaybe; + transfers_?: InputMaybe; +}; + +export enum Token_OrderBy { + Collection = 'collection', + CollectionId = 'collection__id', + CollectionName = 'collection__name', + CollectionSymbol = 'collection__symbol', + CollectionTotalSupply = 'collection__totalSupply', + Id = 'id', + Identifier = 'identifier', + Owner = 'owner', + OwnerId = 'owner__id', + Transfers = 'transfers' +} + +export type Transfer = { + __typename?: 'transfer'; + /** Block Number */ + blockNumber: Scalars['Int']['output']; + /** The collection address */ + collection: Collection; + /** Block Number and Event Id in which the transfers event occured */ + id: Scalars['ID']['output']; + /** The receiver address */ + receiverAddress?: Maybe; + /** The sender address */ + senderAddress?: Maybe; + /** Timestamp for block */ + timestamp: Scalars['Int']['output']; + /** The collection addrress - The token id */ + token: Token; + /** Transaction hash in which the transfer event occured */ + transaction: Scalars['Bytes']['output']; +}; + +export type Transfer_Filter = { + /** Filter for the block changed event. */ + _change_block?: InputMaybe; + and?: InputMaybe>>; + blockNumber?: InputMaybe; + blockNumber_gt?: InputMaybe; + blockNumber_gte?: InputMaybe; + blockNumber_in?: InputMaybe>; + blockNumber_lt?: InputMaybe; + blockNumber_lte?: InputMaybe; + blockNumber_not?: InputMaybe; + blockNumber_not_in?: InputMaybe>; + collection?: InputMaybe; + collection_?: InputMaybe; + collection_contains?: InputMaybe; + collection_contains_nocase?: InputMaybe; + collection_ends_with?: InputMaybe; + collection_ends_with_nocase?: InputMaybe; + collection_gt?: InputMaybe; + collection_gte?: InputMaybe; + collection_in?: InputMaybe>; + collection_lt?: InputMaybe; + collection_lte?: InputMaybe; + collection_not?: InputMaybe; + collection_not_contains?: InputMaybe; + collection_not_contains_nocase?: InputMaybe; + collection_not_ends_with?: InputMaybe; + collection_not_ends_with_nocase?: InputMaybe; + collection_not_in?: InputMaybe>; + collection_not_starts_with?: InputMaybe; + collection_not_starts_with_nocase?: InputMaybe; + collection_starts_with?: InputMaybe; + collection_starts_with_nocase?: InputMaybe; + id?: InputMaybe; + id_gt?: InputMaybe; + id_gte?: InputMaybe; + id_in?: InputMaybe>; + id_lt?: InputMaybe; + id_lte?: InputMaybe; + id_not?: InputMaybe; + id_not_in?: InputMaybe>; + or?: InputMaybe>>; + receiverAddress?: InputMaybe; + receiverAddress_?: InputMaybe; + receiverAddress_contains?: InputMaybe; + receiverAddress_contains_nocase?: InputMaybe; + receiverAddress_ends_with?: InputMaybe; + receiverAddress_ends_with_nocase?: InputMaybe; + receiverAddress_gt?: InputMaybe; + receiverAddress_gte?: InputMaybe; + receiverAddress_in?: InputMaybe>; + receiverAddress_lt?: InputMaybe; + receiverAddress_lte?: InputMaybe; + receiverAddress_not?: InputMaybe; + receiverAddress_not_contains?: InputMaybe; + receiverAddress_not_contains_nocase?: InputMaybe; + receiverAddress_not_ends_with?: InputMaybe; + receiverAddress_not_ends_with_nocase?: InputMaybe; + receiverAddress_not_in?: InputMaybe>; + receiverAddress_not_starts_with?: InputMaybe; + receiverAddress_not_starts_with_nocase?: InputMaybe; + receiverAddress_starts_with?: InputMaybe; + receiverAddress_starts_with_nocase?: InputMaybe; + senderAddress?: InputMaybe; + senderAddress_?: InputMaybe; + senderAddress_contains?: InputMaybe; + senderAddress_contains_nocase?: InputMaybe; + senderAddress_ends_with?: InputMaybe; + senderAddress_ends_with_nocase?: InputMaybe; + senderAddress_gt?: InputMaybe; + senderAddress_gte?: InputMaybe; + senderAddress_in?: InputMaybe>; + senderAddress_lt?: InputMaybe; + senderAddress_lte?: InputMaybe; + senderAddress_not?: InputMaybe; + senderAddress_not_contains?: InputMaybe; + senderAddress_not_contains_nocase?: InputMaybe; + senderAddress_not_ends_with?: InputMaybe; + senderAddress_not_ends_with_nocase?: InputMaybe; + senderAddress_not_in?: InputMaybe>; + senderAddress_not_starts_with?: InputMaybe; + senderAddress_not_starts_with_nocase?: InputMaybe; + senderAddress_starts_with?: InputMaybe; + senderAddress_starts_with_nocase?: InputMaybe; + timestamp?: InputMaybe; + timestamp_gt?: InputMaybe; + timestamp_gte?: InputMaybe; + timestamp_in?: InputMaybe>; + timestamp_lt?: InputMaybe; + timestamp_lte?: InputMaybe; + timestamp_not?: InputMaybe; + timestamp_not_in?: InputMaybe>; + token?: InputMaybe; + token_?: InputMaybe; + token_contains?: InputMaybe; + token_contains_nocase?: InputMaybe; + token_ends_with?: InputMaybe; + token_ends_with_nocase?: InputMaybe; + token_gt?: InputMaybe; + token_gte?: InputMaybe; + token_in?: InputMaybe>; + token_lt?: InputMaybe; + token_lte?: InputMaybe; + token_not?: InputMaybe; + token_not_contains?: InputMaybe; + token_not_contains_nocase?: InputMaybe; + token_not_ends_with?: InputMaybe; + token_not_ends_with_nocase?: InputMaybe; + token_not_in?: InputMaybe>; + token_not_starts_with?: InputMaybe; + token_not_starts_with_nocase?: InputMaybe; + token_starts_with?: InputMaybe; + token_starts_with_nocase?: InputMaybe; + transaction?: InputMaybe; + transaction_contains?: InputMaybe; + transaction_gt?: InputMaybe; + transaction_gte?: InputMaybe; + transaction_in?: InputMaybe>; + transaction_lt?: InputMaybe; + transaction_lte?: InputMaybe; + transaction_not?: InputMaybe; + transaction_not_contains?: InputMaybe; + transaction_not_in?: InputMaybe>; +}; + +export enum Transfer_OrderBy { + BlockNumber = 'blockNumber', + Collection = 'collection', + CollectionId = 'collection__id', + CollectionName = 'collection__name', + CollectionSymbol = 'collection__symbol', + CollectionTotalSupply = 'collection__totalSupply', + Id = 'id', + ReceiverAddress = 'receiverAddress', + ReceiverAddressId = 'receiverAddress__id', + SenderAddress = 'senderAddress', + SenderAddressId = 'senderAddress__id', + Timestamp = 'timestamp', + Token = 'token', + TokenId = 'token__id', + TokenIdentifier = 'token__identifier', + Transaction = 'transaction' +} diff --git a/packages/types/src/subgraph/index.ts b/packages/types/src/subgraph/index.ts index 56ae4ccf..2d9484c9 100644 --- a/packages/types/src/subgraph/index.ts +++ b/packages/types/src/subgraph/index.ts @@ -1,2 +1,4 @@ export * as NftxV3Uniswap from './nftx-v3-uniswap'; export * as NftxV3 from './nftx-v3'; +export * as ERC1155Sepolia from './1155-sepolia'; +export * as ERC721Sepolia from './721-sepolia'; diff --git a/packages/types/src/subgraph/nftx-v3-uniswap.ts b/packages/types/src/subgraph/nftx-v3-uniswap.ts index 3c2a3a56..bf983af6 100644 --- a/packages/types/src/subgraph/nftx-v3-uniswap.ts +++ b/packages/types/src/subgraph/nftx-v3-uniswap.ts @@ -550,6 +550,7 @@ export enum Deposit_OrderBy { PositionHashOpened = 'position__hashOpened', PositionId = 'position__id', PositionLiquidity = 'position__liquidity', + PositionLiquidityEth = 'position__liquidityETH', PositionLiquidityTokenType = 'position__liquidityTokenType', PositionLiquidityUsd = 'position__liquidityUSD', PositionLockedUntil = 'position__lockedUntil', @@ -559,6 +560,7 @@ export enum Deposit_OrderBy { PositionWithdrawCount = 'position__withdrawCount', Protocol = 'protocol', ProtocolRegenesis = 'protocol___regenesis', + ProtocolActiveLiquidityEth = 'protocol__activeLiquidityETH', ProtocolActiveLiquidityUsd = 'protocol__activeLiquidityUSD', ProtocolCumulativePositionCount = 'protocol__cumulativePositionCount', ProtocolCumulativeProtocolSideRevenueUsd = 'protocol__cumulativeProtocolSideRevenueUSD', @@ -567,6 +569,7 @@ export enum Deposit_OrderBy { ProtocolCumulativeUniqueLPs = 'protocol__cumulativeUniqueLPs', ProtocolCumulativeUniqueTraders = 'protocol__cumulativeUniqueTraders', ProtocolCumulativeUniqueUsers = 'protocol__cumulativeUniqueUsers', + ProtocolCumulativeVolumeEth = 'protocol__cumulativeVolumeETH', ProtocolCumulativeVolumeUsd = 'protocol__cumulativeVolumeUSD', ProtocolId = 'protocol__id', ProtocolLastSnapshotDayId = 'protocol__lastSnapshotDayID', @@ -580,8 +583,10 @@ export enum Deposit_OrderBy { ProtocolSchemaVersion = 'protocol__schemaVersion', ProtocolSlug = 'protocol__slug', ProtocolSubgraphVersion = 'protocol__subgraphVersion', + ProtocolTotalLiquidityEth = 'protocol__totalLiquidityETH', ProtocolTotalLiquidityUsd = 'protocol__totalLiquidityUSD', ProtocolTotalPoolCount = 'protocol__totalPoolCount', + ProtocolTotalValueLockedEth = 'protocol__totalValueLockedETH', ProtocolTotalValueLockedUsd = 'protocol__totalValueLockedUSD', ProtocolType = 'protocol__type', ProtocolUncollectedProtocolSideValueUsd = 'protocol__uncollectedProtocolSideValueUSD', @@ -596,6 +601,8 @@ export type DexAmmProtocol = Protocol & { __typename?: 'DexAmmProtocol'; /** This is a boolean to indicate whether or not the pools have been instantiated the were initialized before Optimism regenesis */ _regenesis: Scalars['Boolean']['output']; + /** All liquidity in ETH that is active. Will be equal to totalLiquidity except for in concentrated liquidity - where activeLiquidity is all liquidity positions that contain the pools current tick. */ + activeLiquidityETH: Scalars['BigDecimal']['output']; /** All liquidity in USD that is active. Will be equal to totalLiquidity except for in concentrated liquidity - where activeLiquidity is all liquidity positions that contain the pools current tick. */ activeLiquidityUSD: Scalars['BigDecimal']['output']; /** Total number of positions (open and closed) */ @@ -612,6 +619,8 @@ export type DexAmmProtocol = Protocol & { cumulativeUniqueTraders: Scalars['Int']['output']; /** Number of cumulative unique users */ cumulativeUniqueUsers: Scalars['Int']['output']; + /** All historical volume in ETH */ + cumulativeVolumeETH: Scalars['BigDecimal']['output']; /** All historical volume in USD */ cumulativeVolumeUSD: Scalars['BigDecimal']['output']; /** Daily usage metrics for this protocol */ @@ -646,10 +655,14 @@ export type DexAmmProtocol = Protocol & { slug: Scalars['String']['output']; /** Version of the subgraph implementation, in SemVer format (e.g. 1.0.0) */ subgraphVersion: Scalars['String']['output']; + /** The sum of all active and non-active liquidity in ETH for this pool. */ + totalLiquidityETH: Scalars['BigDecimal']['output']; /** The sum of all active and non-active liquidity in USD for this pool. */ totalLiquidityUSD: Scalars['BigDecimal']['output']; /** Total number of pools */ totalPoolCount: Scalars['Int']['output']; + /** Current TVL (Total Value Locked) of the entire protocol in ETH */ + totalValueLockedETH: Scalars['BigDecimal']['output']; /** Current TVL (Total Value Locked) of the entire protocol */ totalValueLockedUSD: Scalars['BigDecimal']['output']; /** The type of protocol (e.g. DEX, Lending, Yield, etc) */ @@ -703,6 +716,14 @@ export type DexAmmProtocol_Filter = { _regenesis_in?: InputMaybe>; _regenesis_not?: InputMaybe; _regenesis_not_in?: InputMaybe>; + activeLiquidityETH?: InputMaybe; + activeLiquidityETH_gt?: InputMaybe; + activeLiquidityETH_gte?: InputMaybe; + activeLiquidityETH_in?: InputMaybe>; + activeLiquidityETH_lt?: InputMaybe; + activeLiquidityETH_lte?: InputMaybe; + activeLiquidityETH_not?: InputMaybe; + activeLiquidityETH_not_in?: InputMaybe>; activeLiquidityUSD?: InputMaybe; activeLiquidityUSD_gt?: InputMaybe; activeLiquidityUSD_gte?: InputMaybe; @@ -768,6 +789,14 @@ export type DexAmmProtocol_Filter = { cumulativeUniqueUsers_lte?: InputMaybe; cumulativeUniqueUsers_not?: InputMaybe; cumulativeUniqueUsers_not_in?: InputMaybe>; + cumulativeVolumeETH?: InputMaybe; + cumulativeVolumeETH_gt?: InputMaybe; + cumulativeVolumeETH_gte?: InputMaybe; + cumulativeVolumeETH_in?: InputMaybe>; + cumulativeVolumeETH_lt?: InputMaybe; + cumulativeVolumeETH_lte?: InputMaybe; + cumulativeVolumeETH_not?: InputMaybe; + cumulativeVolumeETH_not_in?: InputMaybe>; cumulativeVolumeUSD?: InputMaybe; cumulativeVolumeUSD_gt?: InputMaybe; cumulativeVolumeUSD_gte?: InputMaybe; @@ -933,6 +962,14 @@ export type DexAmmProtocol_Filter = { subgraphVersion_not_starts_with_nocase?: InputMaybe; subgraphVersion_starts_with?: InputMaybe; subgraphVersion_starts_with_nocase?: InputMaybe; + totalLiquidityETH?: InputMaybe; + totalLiquidityETH_gt?: InputMaybe; + totalLiquidityETH_gte?: InputMaybe; + totalLiquidityETH_in?: InputMaybe>; + totalLiquidityETH_lt?: InputMaybe; + totalLiquidityETH_lte?: InputMaybe; + totalLiquidityETH_not?: InputMaybe; + totalLiquidityETH_not_in?: InputMaybe>; totalLiquidityUSD?: InputMaybe; totalLiquidityUSD_gt?: InputMaybe; totalLiquidityUSD_gte?: InputMaybe; @@ -949,6 +986,14 @@ export type DexAmmProtocol_Filter = { totalPoolCount_lte?: InputMaybe; totalPoolCount_not?: InputMaybe; totalPoolCount_not_in?: InputMaybe>; + totalValueLockedETH?: InputMaybe; + totalValueLockedETH_gt?: InputMaybe; + totalValueLockedETH_gte?: InputMaybe; + totalValueLockedETH_in?: InputMaybe>; + totalValueLockedETH_lt?: InputMaybe; + totalValueLockedETH_lte?: InputMaybe; + totalValueLockedETH_not?: InputMaybe; + totalValueLockedETH_not_in?: InputMaybe>; totalValueLockedUSD?: InputMaybe; totalValueLockedUSD_gt?: InputMaybe; totalValueLockedUSD_gte?: InputMaybe; @@ -981,6 +1026,7 @@ export type DexAmmProtocol_Filter = { export enum DexAmmProtocol_OrderBy { Regenesis = '_regenesis', + ActiveLiquidityEth = 'activeLiquidityETH', ActiveLiquidityUsd = 'activeLiquidityUSD', CumulativePositionCount = 'cumulativePositionCount', CumulativeProtocolSideRevenueUsd = 'cumulativeProtocolSideRevenueUSD', @@ -989,6 +1035,7 @@ export enum DexAmmProtocol_OrderBy { CumulativeUniqueLPs = 'cumulativeUniqueLPs', CumulativeUniqueTraders = 'cumulativeUniqueTraders', CumulativeUniqueUsers = 'cumulativeUniqueUsers', + CumulativeVolumeEth = 'cumulativeVolumeETH', CumulativeVolumeUsd = 'cumulativeVolumeUSD', DailyUsageMetrics = 'dailyUsageMetrics', FinancialMetrics = 'financialMetrics', @@ -1006,8 +1053,10 @@ export enum DexAmmProtocol_OrderBy { SchemaVersion = 'schemaVersion', Slug = 'slug', SubgraphVersion = 'subgraphVersion', + TotalLiquidityEth = 'totalLiquidityETH', TotalLiquidityUsd = 'totalLiquidityUSD', TotalPoolCount = 'totalPoolCount', + TotalValueLockedEth = 'totalValueLockedETH', TotalValueLockedUsd = 'totalValueLockedUSD', Type = 'type', UncollectedProtocolSideValueUsd = 'uncollectedProtocolSideValueUSD', @@ -1016,6 +1065,8 @@ export enum DexAmmProtocol_OrderBy { export type FinancialsDailySnapshot = { __typename?: 'FinancialsDailySnapshot'; + /** All liquidity in ETH that is active. Will be equal to totalLiquidity except for in concentrated liquidity - where activeLiquidity is all liquidity positions that contain the pools current tick. */ + activeLiquidityETH: Scalars['BigDecimal']['output']; /** All liquidity in USD that is active. Will be equal to totalLiquidity except for in concentrated liquidity - where activeLiquidity is all liquidity positions that contain the pools current tick. */ activeLiquidityUSD: Scalars['BigDecimal']['output']; /** Block number of when this snapshot was taken/last modified (May be taken after interval has passed) */ @@ -1026,6 +1077,8 @@ export type FinancialsDailySnapshot = { cumulativeSupplySideRevenueUSD: Scalars['BigDecimal']['output']; /** All revenue generated by the protocol. e.g. 0.30% of swap fee in Sushiswap, all yield generated by Yearn. */ cumulativeTotalRevenueUSD: Scalars['BigDecimal']['output']; + /** All historical trade volume in ETH */ + cumulativeVolumeETH: Scalars['BigDecimal']['output']; /** All historical trade volume in USD */ cumulativeVolumeUSD: Scalars['BigDecimal']['output']; /** Gross revenue for the protocol (revenue claimed by protocol). Examples: AMM protocol fee (Sushi’s 0.05%). OpenSea 10% sell fee. */ @@ -1034,6 +1087,8 @@ export type FinancialsDailySnapshot = { dailySupplySideRevenueUSD: Scalars['BigDecimal']['output']; /** All revenue generated by the protocol. e.g. 0.30% of swap fee in Sushiswap, all yield generated by Yearn. */ dailyTotalRevenueUSD: Scalars['BigDecimal']['output']; + /** All trade volume occurred in a given day, in ETH */ + dailyVolumeETH: Scalars['BigDecimal']['output']; /** All trade volume occurred in a given day, in USD */ dailyVolumeUSD: Scalars['BigDecimal']['output']; /** Number of days since Unix epoch time */ @@ -1046,9 +1101,13 @@ export type FinancialsDailySnapshot = { protocolControlledValueUSD?: Maybe; /** Timestamp of when this snapshot was taken/last modified (May be taken after interval has passed) */ timestamp: Scalars['BigInt']['output']; + /** The sum of all active and non-active liquidity in ETH for this pool. */ + totalLiquidityETH: Scalars['BigDecimal']['output']; /** The sum of all active and non-active liquidity in USD for this pool. */ totalLiquidityUSD: Scalars['BigDecimal']['output']; /** Current TVL (Total Value Locked) of the entire protocol */ + totalValueLockedETH: Scalars['BigDecimal']['output']; + /** Current TVL (Total Value Locked) of the entire protocol */ totalValueLockedUSD: Scalars['BigDecimal']['output']; /** All protocol-side value locking in USD that remains uncollected and unused in the protocol. */ uncollectedProtocolSideValueUSD: Scalars['BigDecimal']['output']; @@ -1059,6 +1118,14 @@ export type FinancialsDailySnapshot = { export type FinancialsDailySnapshot_Filter = { /** Filter for the block changed event. */ _change_block?: InputMaybe; + activeLiquidityETH?: InputMaybe; + activeLiquidityETH_gt?: InputMaybe; + activeLiquidityETH_gte?: InputMaybe; + activeLiquidityETH_in?: InputMaybe>; + activeLiquidityETH_lt?: InputMaybe; + activeLiquidityETH_lte?: InputMaybe; + activeLiquidityETH_not?: InputMaybe; + activeLiquidityETH_not_in?: InputMaybe>; activeLiquidityUSD?: InputMaybe; activeLiquidityUSD_gt?: InputMaybe; activeLiquidityUSD_gte?: InputMaybe; @@ -1100,6 +1167,14 @@ export type FinancialsDailySnapshot_Filter = { cumulativeTotalRevenueUSD_lte?: InputMaybe; cumulativeTotalRevenueUSD_not?: InputMaybe; cumulativeTotalRevenueUSD_not_in?: InputMaybe>; + cumulativeVolumeETH?: InputMaybe; + cumulativeVolumeETH_gt?: InputMaybe; + cumulativeVolumeETH_gte?: InputMaybe; + cumulativeVolumeETH_in?: InputMaybe>; + cumulativeVolumeETH_lt?: InputMaybe; + cumulativeVolumeETH_lte?: InputMaybe; + cumulativeVolumeETH_not?: InputMaybe; + cumulativeVolumeETH_not_in?: InputMaybe>; cumulativeVolumeUSD?: InputMaybe; cumulativeVolumeUSD_gt?: InputMaybe; cumulativeVolumeUSD_gte?: InputMaybe; @@ -1132,6 +1207,14 @@ export type FinancialsDailySnapshot_Filter = { dailyTotalRevenueUSD_lte?: InputMaybe; dailyTotalRevenueUSD_not?: InputMaybe; dailyTotalRevenueUSD_not_in?: InputMaybe>; + dailyVolumeETH?: InputMaybe; + dailyVolumeETH_gt?: InputMaybe; + dailyVolumeETH_gte?: InputMaybe; + dailyVolumeETH_in?: InputMaybe>; + dailyVolumeETH_lt?: InputMaybe; + dailyVolumeETH_lte?: InputMaybe; + dailyVolumeETH_not?: InputMaybe; + dailyVolumeETH_not_in?: InputMaybe>; dailyVolumeUSD?: InputMaybe; dailyVolumeUSD_gt?: InputMaybe; dailyVolumeUSD_gte?: InputMaybe; @@ -1196,6 +1279,14 @@ export type FinancialsDailySnapshot_Filter = { timestamp_lte?: InputMaybe; timestamp_not?: InputMaybe; timestamp_not_in?: InputMaybe>; + totalLiquidityETH?: InputMaybe; + totalLiquidityETH_gt?: InputMaybe; + totalLiquidityETH_gte?: InputMaybe; + totalLiquidityETH_in?: InputMaybe>; + totalLiquidityETH_lt?: InputMaybe; + totalLiquidityETH_lte?: InputMaybe; + totalLiquidityETH_not?: InputMaybe; + totalLiquidityETH_not_in?: InputMaybe>; totalLiquidityUSD?: InputMaybe; totalLiquidityUSD_gt?: InputMaybe; totalLiquidityUSD_gte?: InputMaybe; @@ -1204,6 +1295,14 @@ export type FinancialsDailySnapshot_Filter = { totalLiquidityUSD_lte?: InputMaybe; totalLiquidityUSD_not?: InputMaybe; totalLiquidityUSD_not_in?: InputMaybe>; + totalValueLockedETH?: InputMaybe; + totalValueLockedETH_gt?: InputMaybe; + totalValueLockedETH_gte?: InputMaybe; + totalValueLockedETH_in?: InputMaybe>; + totalValueLockedETH_lt?: InputMaybe; + totalValueLockedETH_lte?: InputMaybe; + totalValueLockedETH_not?: InputMaybe; + totalValueLockedETH_not_in?: InputMaybe>; totalValueLockedUSD?: InputMaybe; totalValueLockedUSD_gt?: InputMaybe; totalValueLockedUSD_gte?: InputMaybe; @@ -1231,21 +1330,25 @@ export type FinancialsDailySnapshot_Filter = { }; export enum FinancialsDailySnapshot_OrderBy { + ActiveLiquidityEth = 'activeLiquidityETH', ActiveLiquidityUsd = 'activeLiquidityUSD', BlockNumber = 'blockNumber', CumulativeProtocolSideRevenueUsd = 'cumulativeProtocolSideRevenueUSD', CumulativeSupplySideRevenueUsd = 'cumulativeSupplySideRevenueUSD', CumulativeTotalRevenueUsd = 'cumulativeTotalRevenueUSD', + CumulativeVolumeEth = 'cumulativeVolumeETH', CumulativeVolumeUsd = 'cumulativeVolumeUSD', DailyProtocolSideRevenueUsd = 'dailyProtocolSideRevenueUSD', DailySupplySideRevenueUsd = 'dailySupplySideRevenueUSD', DailyTotalRevenueUsd = 'dailyTotalRevenueUSD', + DailyVolumeEth = 'dailyVolumeETH', DailyVolumeUsd = 'dailyVolumeUSD', Day = 'day', Id = 'id', Protocol = 'protocol', ProtocolControlledValueUsd = 'protocolControlledValueUSD', ProtocolRegenesis = 'protocol___regenesis', + ProtocolActiveLiquidityEth = 'protocol__activeLiquidityETH', ProtocolActiveLiquidityUsd = 'protocol__activeLiquidityUSD', ProtocolCumulativePositionCount = 'protocol__cumulativePositionCount', ProtocolCumulativeProtocolSideRevenueUsd = 'protocol__cumulativeProtocolSideRevenueUSD', @@ -1254,6 +1357,7 @@ export enum FinancialsDailySnapshot_OrderBy { ProtocolCumulativeUniqueLPs = 'protocol__cumulativeUniqueLPs', ProtocolCumulativeUniqueTraders = 'protocol__cumulativeUniqueTraders', ProtocolCumulativeUniqueUsers = 'protocol__cumulativeUniqueUsers', + ProtocolCumulativeVolumeEth = 'protocol__cumulativeVolumeETH', ProtocolCumulativeVolumeUsd = 'protocol__cumulativeVolumeUSD', ProtocolId = 'protocol__id', ProtocolLastSnapshotDayId = 'protocol__lastSnapshotDayID', @@ -1267,14 +1371,18 @@ export enum FinancialsDailySnapshot_OrderBy { ProtocolSchemaVersion = 'protocol__schemaVersion', ProtocolSlug = 'protocol__slug', ProtocolSubgraphVersion = 'protocol__subgraphVersion', + ProtocolTotalLiquidityEth = 'protocol__totalLiquidityETH', ProtocolTotalLiquidityUsd = 'protocol__totalLiquidityUSD', ProtocolTotalPoolCount = 'protocol__totalPoolCount', + ProtocolTotalValueLockedEth = 'protocol__totalValueLockedETH', ProtocolTotalValueLockedUsd = 'protocol__totalValueLockedUSD', ProtocolType = 'protocol__type', ProtocolUncollectedProtocolSideValueUsd = 'protocol__uncollectedProtocolSideValueUSD', ProtocolUncollectedSupplySideValueUsd = 'protocol__uncollectedSupplySideValueUSD', Timestamp = 'timestamp', + TotalLiquidityEth = 'totalLiquidityETH', TotalLiquidityUsd = 'totalLiquidityUSD', + TotalValueLockedEth = 'totalValueLockedETH', TotalValueLockedUsd = 'totalValueLockedUSD', UncollectedProtocolSideValueUsd = 'uncollectedProtocolSideValueUSD', UncollectedSupplySideValueUsd = 'uncollectedSupplySideValueUSD' @@ -1480,6 +1588,8 @@ export type LiquidityPoolDailySnapshot = { __typename?: 'LiquidityPoolDailySnapshot'; /** All liquidity `k` that is active. Will be equal to totalLiquidity except for in concentrated liquidity - where activeLiquidity is all liquidity positions that contain the pools current tick. */ activeLiquidity: Scalars['BigInt']['output']; + /** All liquidity in ETH that is active. Will be equal to totalLiquidity except for in concentrated liquidity - where activeLiquidity is all liquidity positions that contain the pools current tick. */ + activeLiquidityETH: Scalars['BigDecimal']['output']; /** All liquidity in USD that is active. Will be equal to totalLiquidity except for in concentrated liquidity - where activeLiquidity is all liquidity positions that contain the pools current tick. */ activeLiquidityUSD: Scalars['BigDecimal']['output']; /** Block number of when this snapshot was taken/last modified (May be taken after interval has passed) */ @@ -1500,6 +1610,8 @@ export type LiquidityPoolDailySnapshot = { cumulativeVolumeByTokenAmount: Array; /** All trade volume, in USD. The ordering should be the same as the pool's `inputTokens` field. */ cumulativeVolumeByTokenUSD: Array; + /** All historical trade volume occurred in this pool, in ETH */ + cumulativeVolumeETH: Scalars['BigDecimal']['output']; /** All historical trade volume occurred in this pool, in USD */ cumulativeVolumeUSD: Scalars['BigDecimal']['output']; /** Total number of withdrawals (remove liquidity) */ @@ -1572,6 +1684,14 @@ export type LiquidityPoolDailySnapshot_Filter = { /** Filter for the block changed event. */ _change_block?: InputMaybe; activeLiquidity?: InputMaybe; + activeLiquidityETH?: InputMaybe; + activeLiquidityETH_gt?: InputMaybe; + activeLiquidityETH_gte?: InputMaybe; + activeLiquidityETH_in?: InputMaybe>; + activeLiquidityETH_lt?: InputMaybe; + activeLiquidityETH_lte?: InputMaybe; + activeLiquidityETH_not?: InputMaybe; + activeLiquidityETH_not_in?: InputMaybe>; activeLiquidityUSD?: InputMaybe; activeLiquidityUSD_gt?: InputMaybe; activeLiquidityUSD_gte?: InputMaybe; @@ -1656,6 +1776,14 @@ export type LiquidityPoolDailySnapshot_Filter = { cumulativeVolumeByTokenUSD_not?: InputMaybe>; cumulativeVolumeByTokenUSD_not_contains?: InputMaybe>; cumulativeVolumeByTokenUSD_not_contains_nocase?: InputMaybe>; + cumulativeVolumeETH?: InputMaybe; + cumulativeVolumeETH_gt?: InputMaybe; + cumulativeVolumeETH_gte?: InputMaybe; + cumulativeVolumeETH_in?: InputMaybe>; + cumulativeVolumeETH_lt?: InputMaybe; + cumulativeVolumeETH_lte?: InputMaybe; + cumulativeVolumeETH_not?: InputMaybe; + cumulativeVolumeETH_not_in?: InputMaybe>; cumulativeVolumeUSD?: InputMaybe; cumulativeVolumeUSD_gt?: InputMaybe; cumulativeVolumeUSD_gte?: InputMaybe; @@ -1939,6 +2067,7 @@ export type LiquidityPoolDailySnapshot_Filter = { export enum LiquidityPoolDailySnapshot_OrderBy { ActiveLiquidity = 'activeLiquidity', + ActiveLiquidityEth = 'activeLiquidityETH', ActiveLiquidityUsd = 'activeLiquidityUSD', BlockNumber = 'blockNumber', ClosedPositionCount = 'closedPositionCount', @@ -1949,6 +2078,7 @@ export enum LiquidityPoolDailySnapshot_OrderBy { CumulativeTotalRevenueUsd = 'cumulativeTotalRevenueUSD', CumulativeVolumeByTokenAmount = 'cumulativeVolumeByTokenAmount', CumulativeVolumeByTokenUsd = 'cumulativeVolumeByTokenUSD', + CumulativeVolumeEth = 'cumulativeVolumeETH', CumulativeVolumeUsd = 'cumulativeVolumeUSD', CumulativeWithdrawCount = 'cumulativeWithdrawCount', DailyDepositCount = 'dailyDepositCount', @@ -2005,6 +2135,7 @@ export enum LiquidityPoolDailySnapshot_OrderBy { PositionCount = 'positionCount', Protocol = 'protocol', ProtocolRegenesis = 'protocol___regenesis', + ProtocolActiveLiquidityEth = 'protocol__activeLiquidityETH', ProtocolActiveLiquidityUsd = 'protocol__activeLiquidityUSD', ProtocolCumulativePositionCount = 'protocol__cumulativePositionCount', ProtocolCumulativeProtocolSideRevenueUsd = 'protocol__cumulativeProtocolSideRevenueUSD', @@ -2013,6 +2144,7 @@ export enum LiquidityPoolDailySnapshot_OrderBy { ProtocolCumulativeUniqueLPs = 'protocol__cumulativeUniqueLPs', ProtocolCumulativeUniqueTraders = 'protocol__cumulativeUniqueTraders', ProtocolCumulativeUniqueUsers = 'protocol__cumulativeUniqueUsers', + ProtocolCumulativeVolumeEth = 'protocol__cumulativeVolumeETH', ProtocolCumulativeVolumeUsd = 'protocol__cumulativeVolumeUSD', ProtocolId = 'protocol__id', ProtocolLastSnapshotDayId = 'protocol__lastSnapshotDayID', @@ -2026,8 +2158,10 @@ export enum LiquidityPoolDailySnapshot_OrderBy { ProtocolSchemaVersion = 'protocol__schemaVersion', ProtocolSlug = 'protocol__slug', ProtocolSubgraphVersion = 'protocol__subgraphVersion', + ProtocolTotalLiquidityEth = 'protocol__totalLiquidityETH', ProtocolTotalLiquidityUsd = 'protocol__totalLiquidityUSD', ProtocolTotalPoolCount = 'protocol__totalPoolCount', + ProtocolTotalValueLockedEth = 'protocol__totalValueLockedETH', ProtocolTotalValueLockedUsd = 'protocol__totalValueLockedUSD', ProtocolType = 'protocol__type', ProtocolUncollectedProtocolSideValueUsd = 'protocol__uncollectedProtocolSideValueUSD', @@ -2116,6 +2250,8 @@ export type LiquidityPoolHourlySnapshot = { __typename?: 'LiquidityPoolHourlySnapshot'; /** All liquidity `k` that is active. Will be equal to totalLiquidity except for in concentrated liquidity - where activeLiquidity is all liquidity positions that contain the pools current tick. */ activeLiquidity: Scalars['BigInt']['output']; + /** All liquidity in ETH that is active. Will be equal to totalLiquidity except for in concentrated liquidity - where activeLiquidity is all liquidity positions that contain the pools current tick. */ + activeLiquidityETH: Scalars['BigDecimal']['output']; /** All liquidity in USD that is active. Will be equal to totalLiquidity except for in concentrated liquidity - where activeLiquidity is all liquidity positions that contain the pools current tick. */ activeLiquidityUSD: Scalars['BigDecimal']['output']; /** Block number of when this snapshot was taken/last modified (May be taken after interval has passed) */ @@ -2136,6 +2272,8 @@ export type LiquidityPoolHourlySnapshot = { cumulativeVolumeByTokenAmount: Array; /** All trade volume, in USD. The ordering should be the same as the pool's `inputTokens` field. */ cumulativeVolumeByTokenUSD: Array; + /** All historical trade volume occurred in this pool, in ETH */ + cumulativeVolumeETH: Scalars['BigDecimal']['output']; /** All historical trade volume occurred in this pool, in USD */ cumulativeVolumeUSD: Scalars['BigDecimal']['output']; /** Total number of withdrawals (remove liquidity) */ @@ -2208,6 +2346,14 @@ export type LiquidityPoolHourlySnapshot_Filter = { /** Filter for the block changed event. */ _change_block?: InputMaybe; activeLiquidity?: InputMaybe; + activeLiquidityETH?: InputMaybe; + activeLiquidityETH_gt?: InputMaybe; + activeLiquidityETH_gte?: InputMaybe; + activeLiquidityETH_in?: InputMaybe>; + activeLiquidityETH_lt?: InputMaybe; + activeLiquidityETH_lte?: InputMaybe; + activeLiquidityETH_not?: InputMaybe; + activeLiquidityETH_not_in?: InputMaybe>; activeLiquidityUSD?: InputMaybe; activeLiquidityUSD_gt?: InputMaybe; activeLiquidityUSD_gte?: InputMaybe; @@ -2292,6 +2438,14 @@ export type LiquidityPoolHourlySnapshot_Filter = { cumulativeVolumeByTokenUSD_not?: InputMaybe>; cumulativeVolumeByTokenUSD_not_contains?: InputMaybe>; cumulativeVolumeByTokenUSD_not_contains_nocase?: InputMaybe>; + cumulativeVolumeETH?: InputMaybe; + cumulativeVolumeETH_gt?: InputMaybe; + cumulativeVolumeETH_gte?: InputMaybe; + cumulativeVolumeETH_in?: InputMaybe>; + cumulativeVolumeETH_lt?: InputMaybe; + cumulativeVolumeETH_lte?: InputMaybe; + cumulativeVolumeETH_not?: InputMaybe; + cumulativeVolumeETH_not_in?: InputMaybe>; cumulativeVolumeUSD?: InputMaybe; cumulativeVolumeUSD_gt?: InputMaybe; cumulativeVolumeUSD_gte?: InputMaybe; @@ -2575,6 +2729,7 @@ export type LiquidityPoolHourlySnapshot_Filter = { export enum LiquidityPoolHourlySnapshot_OrderBy { ActiveLiquidity = 'activeLiquidity', + ActiveLiquidityEth = 'activeLiquidityETH', ActiveLiquidityUsd = 'activeLiquidityUSD', BlockNumber = 'blockNumber', ClosedPositionCount = 'closedPositionCount', @@ -2585,6 +2740,7 @@ export enum LiquidityPoolHourlySnapshot_OrderBy { CumulativeTotalRevenueUsd = 'cumulativeTotalRevenueUSD', CumulativeVolumeByTokenAmount = 'cumulativeVolumeByTokenAmount', CumulativeVolumeByTokenUsd = 'cumulativeVolumeByTokenUSD', + CumulativeVolumeEth = 'cumulativeVolumeETH', CumulativeVolumeUsd = 'cumulativeVolumeUSD', CumulativeWithdrawCount = 'cumulativeWithdrawCount', Hour = 'hour', @@ -2641,6 +2797,7 @@ export enum LiquidityPoolHourlySnapshot_OrderBy { PositionCount = 'positionCount', Protocol = 'protocol', ProtocolRegenesis = 'protocol___regenesis', + ProtocolActiveLiquidityEth = 'protocol__activeLiquidityETH', ProtocolActiveLiquidityUsd = 'protocol__activeLiquidityUSD', ProtocolCumulativePositionCount = 'protocol__cumulativePositionCount', ProtocolCumulativeProtocolSideRevenueUsd = 'protocol__cumulativeProtocolSideRevenueUSD', @@ -2649,6 +2806,7 @@ export enum LiquidityPoolHourlySnapshot_OrderBy { ProtocolCumulativeUniqueLPs = 'protocol__cumulativeUniqueLPs', ProtocolCumulativeUniqueTraders = 'protocol__cumulativeUniqueTraders', ProtocolCumulativeUniqueUsers = 'protocol__cumulativeUniqueUsers', + ProtocolCumulativeVolumeEth = 'protocol__cumulativeVolumeETH', ProtocolCumulativeVolumeUsd = 'protocol__cumulativeVolumeUSD', ProtocolId = 'protocol__id', ProtocolLastSnapshotDayId = 'protocol__lastSnapshotDayID', @@ -2662,8 +2820,10 @@ export enum LiquidityPoolHourlySnapshot_OrderBy { ProtocolSchemaVersion = 'protocol__schemaVersion', ProtocolSlug = 'protocol__slug', ProtocolSubgraphVersion = 'protocol__subgraphVersion', + ProtocolTotalLiquidityEth = 'protocol__totalLiquidityETH', ProtocolTotalLiquidityUsd = 'protocol__totalLiquidityUSD', ProtocolTotalPoolCount = 'protocol__totalPoolCount', + ProtocolTotalValueLockedEth = 'protocol__totalValueLockedETH', ProtocolTotalValueLockedUsd = 'protocol__totalValueLockedUSD', ProtocolType = 'protocol__type', ProtocolUncollectedProtocolSideValueUsd = 'protocol__uncollectedProtocolSideValueUSD', @@ -3204,6 +3364,7 @@ export enum LiquidityPool_OrderBy { Positions = 'positions', Protocol = 'protocol', ProtocolRegenesis = 'protocol___regenesis', + ProtocolActiveLiquidityEth = 'protocol__activeLiquidityETH', ProtocolActiveLiquidityUsd = 'protocol__activeLiquidityUSD', ProtocolCumulativePositionCount = 'protocol__cumulativePositionCount', ProtocolCumulativeProtocolSideRevenueUsd = 'protocol__cumulativeProtocolSideRevenueUSD', @@ -3212,6 +3373,7 @@ export enum LiquidityPool_OrderBy { ProtocolCumulativeUniqueLPs = 'protocol__cumulativeUniqueLPs', ProtocolCumulativeUniqueTraders = 'protocol__cumulativeUniqueTraders', ProtocolCumulativeUniqueUsers = 'protocol__cumulativeUniqueUsers', + ProtocolCumulativeVolumeEth = 'protocol__cumulativeVolumeETH', ProtocolCumulativeVolumeUsd = 'protocol__cumulativeVolumeUSD', ProtocolId = 'protocol__id', ProtocolLastSnapshotDayId = 'protocol__lastSnapshotDayID', @@ -3225,8 +3387,10 @@ export enum LiquidityPool_OrderBy { ProtocolSchemaVersion = 'protocol__schemaVersion', ProtocolSlug = 'protocol__slug', ProtocolSubgraphVersion = 'protocol__subgraphVersion', + ProtocolTotalLiquidityEth = 'protocol__totalLiquidityETH', ProtocolTotalLiquidityUsd = 'protocol__totalLiquidityUSD', ProtocolTotalPoolCount = 'protocol__totalPoolCount', + ProtocolTotalValueLockedEth = 'protocol__totalValueLockedETH', ProtocolTotalValueLockedUsd = 'protocol__totalValueLockedUSD', ProtocolType = 'protocol__type', ProtocolUncollectedProtocolSideValueUsd = 'protocol__uncollectedProtocolSideValueUSD', @@ -3314,6 +3478,8 @@ export type Position = { id: Scalars['Bytes']['output']; /** total position liquidity */ liquidity: Scalars['BigInt']['output']; + /** total position liquidity in ETH */ + liquidityETH: Scalars['BigDecimal']['output']; /** Token that is to represent ownership of liquidity */ liquidityToken?: Maybe; /** Type of token used to track liquidity */ @@ -3589,6 +3755,7 @@ export enum PositionSnapshot_OrderBy { PositionHashOpened = 'position__hashOpened', PositionId = 'position__id', PositionLiquidity = 'position__liquidity', + PositionLiquidityEth = 'position__liquidityETH', PositionLiquidityTokenType = 'position__liquidityTokenType', PositionLiquidityUsd = 'position__liquidityUSD', PositionLockedUntil = 'position__lockedUntil', @@ -3715,6 +3882,14 @@ export type Position_Filter = { id_not_contains?: InputMaybe; id_not_in?: InputMaybe>; liquidity?: InputMaybe; + liquidityETH?: InputMaybe; + liquidityETH_gt?: InputMaybe; + liquidityETH_gte?: InputMaybe; + liquidityETH_in?: InputMaybe>; + liquidityETH_lt?: InputMaybe; + liquidityETH_lte?: InputMaybe; + liquidityETH_not?: InputMaybe; + liquidityETH_not_in?: InputMaybe>; liquidityToken?: InputMaybe; liquidityTokenType?: InputMaybe; liquidityTokenType_in?: InputMaybe>; @@ -3885,6 +4060,7 @@ export enum Position_OrderBy { HashOpened = 'hashOpened', Id = 'id', Liquidity = 'liquidity', + LiquidityEth = 'liquidityETH', LiquidityToken = 'liquidityToken', LiquidityTokenType = 'liquidityTokenType', LiquidityTokenEthPricePool = 'liquidityToken___ethPricePool', @@ -4006,6 +4182,8 @@ export type Protocol = { subgraphVersion: Scalars['String']['output']; /** Total number of pools */ totalPoolCount: Scalars['Int']['output']; + /** Current TVL (Total Value Locked) of the entire protocol in ETH */ + totalValueLockedETH: Scalars['BigDecimal']['output']; /** Current TVL (Total Value Locked) of the entire protocol */ totalValueLockedUSD: Scalars['BigDecimal']['output']; /** The type of protocol (e.g. DEX, Lending, Yield, etc) */ @@ -4215,6 +4393,14 @@ export type Protocol_Filter = { totalPoolCount_lte?: InputMaybe; totalPoolCount_not?: InputMaybe; totalPoolCount_not_in?: InputMaybe>; + totalValueLockedETH?: InputMaybe; + totalValueLockedETH_gt?: InputMaybe; + totalValueLockedETH_gte?: InputMaybe; + totalValueLockedETH_in?: InputMaybe>; + totalValueLockedETH_lt?: InputMaybe; + totalValueLockedETH_lte?: InputMaybe; + totalValueLockedETH_not?: InputMaybe; + totalValueLockedETH_not_in?: InputMaybe>; totalValueLockedUSD?: InputMaybe; totalValueLockedUSD_gt?: InputMaybe; totalValueLockedUSD_gte?: InputMaybe; @@ -4246,6 +4432,7 @@ export enum Protocol_OrderBy { Slug = 'slug', SubgraphVersion = 'subgraphVersion', TotalPoolCount = 'totalPoolCount', + TotalValueLockedEth = 'totalValueLockedETH', TotalValueLockedUsd = 'totalValueLockedUSD', Type = 'type' } @@ -5686,6 +5873,7 @@ export enum Swap_OrderBy { PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD', Protocol = 'protocol', ProtocolRegenesis = 'protocol___regenesis', + ProtocolActiveLiquidityEth = 'protocol__activeLiquidityETH', ProtocolActiveLiquidityUsd = 'protocol__activeLiquidityUSD', ProtocolCumulativePositionCount = 'protocol__cumulativePositionCount', ProtocolCumulativeProtocolSideRevenueUsd = 'protocol__cumulativeProtocolSideRevenueUSD', @@ -5694,6 +5882,7 @@ export enum Swap_OrderBy { ProtocolCumulativeUniqueLPs = 'protocol__cumulativeUniqueLPs', ProtocolCumulativeUniqueTraders = 'protocol__cumulativeUniqueTraders', ProtocolCumulativeUniqueUsers = 'protocol__cumulativeUniqueUsers', + ProtocolCumulativeVolumeEth = 'protocol__cumulativeVolumeETH', ProtocolCumulativeVolumeUsd = 'protocol__cumulativeVolumeUSD', ProtocolId = 'protocol__id', ProtocolLastSnapshotDayId = 'protocol__lastSnapshotDayID', @@ -5707,8 +5896,10 @@ export enum Swap_OrderBy { ProtocolSchemaVersion = 'protocol__schemaVersion', ProtocolSlug = 'protocol__slug', ProtocolSubgraphVersion = 'protocol__subgraphVersion', + ProtocolTotalLiquidityEth = 'protocol__totalLiquidityETH', ProtocolTotalLiquidityUsd = 'protocol__totalLiquidityUSD', ProtocolTotalPoolCount = 'protocol__totalPoolCount', + ProtocolTotalValueLockedEth = 'protocol__totalValueLockedETH', ProtocolTotalValueLockedUsd = 'protocol__totalValueLockedUSD', ProtocolType = 'protocol__type', ProtocolUncollectedProtocolSideValueUsd = 'protocol__uncollectedProtocolSideValueUSD', @@ -6726,6 +6917,7 @@ export enum UsageMetricsDailySnapshot_OrderBy { Id = 'id', Protocol = 'protocol', ProtocolRegenesis = 'protocol___regenesis', + ProtocolActiveLiquidityEth = 'protocol__activeLiquidityETH', ProtocolActiveLiquidityUsd = 'protocol__activeLiquidityUSD', ProtocolCumulativePositionCount = 'protocol__cumulativePositionCount', ProtocolCumulativeProtocolSideRevenueUsd = 'protocol__cumulativeProtocolSideRevenueUSD', @@ -6734,6 +6926,7 @@ export enum UsageMetricsDailySnapshot_OrderBy { ProtocolCumulativeUniqueLPs = 'protocol__cumulativeUniqueLPs', ProtocolCumulativeUniqueTraders = 'protocol__cumulativeUniqueTraders', ProtocolCumulativeUniqueUsers = 'protocol__cumulativeUniqueUsers', + ProtocolCumulativeVolumeEth = 'protocol__cumulativeVolumeETH', ProtocolCumulativeVolumeUsd = 'protocol__cumulativeVolumeUSD', ProtocolId = 'protocol__id', ProtocolLastSnapshotDayId = 'protocol__lastSnapshotDayID', @@ -6747,8 +6940,10 @@ export enum UsageMetricsDailySnapshot_OrderBy { ProtocolSchemaVersion = 'protocol__schemaVersion', ProtocolSlug = 'protocol__slug', ProtocolSubgraphVersion = 'protocol__subgraphVersion', + ProtocolTotalLiquidityEth = 'protocol__totalLiquidityETH', ProtocolTotalLiquidityUsd = 'protocol__totalLiquidityUSD', ProtocolTotalPoolCount = 'protocol__totalPoolCount', + ProtocolTotalValueLockedEth = 'protocol__totalValueLockedETH', ProtocolTotalValueLockedUsd = 'protocol__totalValueLockedUSD', ProtocolType = 'protocol__type', ProtocolUncollectedProtocolSideValueUsd = 'protocol__uncollectedProtocolSideValueUSD', @@ -6903,6 +7098,7 @@ export enum UsageMetricsHourlySnapshot_OrderBy { Id = 'id', Protocol = 'protocol', ProtocolRegenesis = 'protocol___regenesis', + ProtocolActiveLiquidityEth = 'protocol__activeLiquidityETH', ProtocolActiveLiquidityUsd = 'protocol__activeLiquidityUSD', ProtocolCumulativePositionCount = 'protocol__cumulativePositionCount', ProtocolCumulativeProtocolSideRevenueUsd = 'protocol__cumulativeProtocolSideRevenueUSD', @@ -6911,6 +7107,7 @@ export enum UsageMetricsHourlySnapshot_OrderBy { ProtocolCumulativeUniqueLPs = 'protocol__cumulativeUniqueLPs', ProtocolCumulativeUniqueTraders = 'protocol__cumulativeUniqueTraders', ProtocolCumulativeUniqueUsers = 'protocol__cumulativeUniqueUsers', + ProtocolCumulativeVolumeEth = 'protocol__cumulativeVolumeETH', ProtocolCumulativeVolumeUsd = 'protocol__cumulativeVolumeUSD', ProtocolId = 'protocol__id', ProtocolLastSnapshotDayId = 'protocol__lastSnapshotDayID', @@ -6924,8 +7121,10 @@ export enum UsageMetricsHourlySnapshot_OrderBy { ProtocolSchemaVersion = 'protocol__schemaVersion', ProtocolSlug = 'protocol__slug', ProtocolSubgraphVersion = 'protocol__subgraphVersion', + ProtocolTotalLiquidityEth = 'protocol__totalLiquidityETH', ProtocolTotalLiquidityUsd = 'protocol__totalLiquidityUSD', ProtocolTotalPoolCount = 'protocol__totalPoolCount', + ProtocolTotalValueLockedEth = 'protocol__totalValueLockedETH', ProtocolTotalValueLockedUsd = 'protocol__totalValueLockedUSD', ProtocolType = 'protocol__type', ProtocolUncollectedProtocolSideValueUsd = 'protocol__uncollectedProtocolSideValueUSD', @@ -7269,6 +7468,7 @@ export enum Withdraw_OrderBy { PositionHashOpened = 'position__hashOpened', PositionId = 'position__id', PositionLiquidity = 'position__liquidity', + PositionLiquidityEth = 'position__liquidityETH', PositionLiquidityTokenType = 'position__liquidityTokenType', PositionLiquidityUsd = 'position__liquidityUSD', PositionLockedUntil = 'position__lockedUntil', @@ -7278,6 +7478,7 @@ export enum Withdraw_OrderBy { PositionWithdrawCount = 'position__withdrawCount', Protocol = 'protocol', ProtocolRegenesis = 'protocol___regenesis', + ProtocolActiveLiquidityEth = 'protocol__activeLiquidityETH', ProtocolActiveLiquidityUsd = 'protocol__activeLiquidityUSD', ProtocolCumulativePositionCount = 'protocol__cumulativePositionCount', ProtocolCumulativeProtocolSideRevenueUsd = 'protocol__cumulativeProtocolSideRevenueUSD', @@ -7286,6 +7487,7 @@ export enum Withdraw_OrderBy { ProtocolCumulativeUniqueLPs = 'protocol__cumulativeUniqueLPs', ProtocolCumulativeUniqueTraders = 'protocol__cumulativeUniqueTraders', ProtocolCumulativeUniqueUsers = 'protocol__cumulativeUniqueUsers', + ProtocolCumulativeVolumeEth = 'protocol__cumulativeVolumeETH', ProtocolCumulativeVolumeUsd = 'protocol__cumulativeVolumeUSD', ProtocolId = 'protocol__id', ProtocolLastSnapshotDayId = 'protocol__lastSnapshotDayID', @@ -7299,8 +7501,10 @@ export enum Withdraw_OrderBy { ProtocolSchemaVersion = 'protocol__schemaVersion', ProtocolSlug = 'protocol__slug', ProtocolSubgraphVersion = 'protocol__subgraphVersion', + ProtocolTotalLiquidityEth = 'protocol__totalLiquidityETH', ProtocolTotalLiquidityUsd = 'protocol__totalLiquidityUSD', ProtocolTotalPoolCount = 'protocol__totalPoolCount', + ProtocolTotalValueLockedEth = 'protocol__totalValueLockedETH', ProtocolTotalValueLockedUsd = 'protocol__totalValueLockedUSD', ProtocolType = 'protocol__type', ProtocolUncollectedProtocolSideValueUsd = 'protocol__uncollectedProtocolSideValueUSD', diff --git a/packages/utils/src/prices/__tests__/premiums.test.ts b/packages/utils/src/prices/__tests__/premiums.test.ts index 7990e177..4e9011ab 100644 --- a/packages/utils/src/prices/__tests__/premiums.test.ts +++ b/packages/utils/src/prices/__tests__/premiums.test.ts @@ -1,6 +1,7 @@ import { WeiPerEther, Zero } from '@nftx/constants'; import { estimatePremiumPrice } from '../premiums'; import { formatEther } from 'viem'; +import { Network } from '@nftx/constants'; let holding: { dateAdded: number }; let vTokenToEth: bigint; @@ -11,7 +12,13 @@ beforeEach(() => { now = Date.now() / 1000; holding = { dateAdded: 0 }; vTokenToEth = WeiPerEther; - run = () => estimatePremiumPrice({ holding, vTokenToEth, now }); + run = () => + estimatePremiumPrice({ + holding, + vTokenToEth, + now, + network: Network.Goerli, + }); }); describe('when holding is older than 10 hours', () => { diff --git a/packages/utils/src/prices/premiums.ts b/packages/utils/src/prices/premiums.ts index 497dd389..9d671b1a 100644 --- a/packages/utils/src/prices/premiums.ts +++ b/packages/utils/src/prices/premiums.ts @@ -1,26 +1,30 @@ import { PREMIUM_DURATION, WeiPerEther, Zero } from '@nftx/constants'; import { TokenId } from '@nftx/types'; import { getExactTokenIds } from '../tokenIdUtils'; +import { getChainConstant } from '../web3'; export const estimatePremiumPrice = ({ + network, holding, vTokenToEth, now, }: { + network: number; holding: { dateAdded: number } | undefined; vTokenToEth: bigint; now: number; }): [vToken: bigint, price: bigint] => { - const premiumThreshold = now - PREMIUM_DURATION; + const premiumDuration = getChainConstant(PREMIUM_DURATION, network, 0); + const premiumThreshold = now - premiumDuration; if (!holding || holding.dateAdded < premiumThreshold) { return [Zero, Zero]; } const maxPremium = 5 * 10 ** 18; // 5 vTokens - const timeStep = 60 * 60; // 1 hour - // const endValue = maxPremium * 2 ** (-PREMIUM_DURATION / timeStep) - const endValue = 4882812500000000; + const timeStep = 60 * 60; + const endValue = maxPremium * 2 ** (-premiumDuration / timeStep); + // const endValue = 4882812500000000; const elapsed = now - holding.dateAdded; const p = maxPremium * 2 ** (-elapsed / timeStep) - endValue; @@ -37,11 +41,13 @@ export const estimateTotalPremiumPrice = ({ tokenIds, vTokenToEth, now, + network, }: { tokenIds: TokenId[] | [TokenId, number][]; holdings: { dateAdded: number; tokenId: TokenId }[]; vTokenToEth: bigint; now: number; + network: number; }): [vToken: bigint, price: bigint] => { return getExactTokenIds(tokenIds).reduce( (total, tokenId) => { @@ -50,6 +56,7 @@ export const estimateTotalPremiumPrice = ({ holding, vTokenToEth, now, + network, }); return [total[0] + premium[0], total[1] + premium[1]] as [bigint, bigint]; }, diff --git a/packages/utils/src/web3/getChainConstant.ts b/packages/utils/src/web3/getChainConstant.ts index f2924331..10f93861 100644 --- a/packages/utils/src/web3/getChainConstant.ts +++ b/packages/utils/src/web3/getChainConstant.ts @@ -1,12 +1,10 @@ -import { Network } from '@nftx/constants'; - -/** Takes an network/value key pair and returns the value for the current network */ +/** Takes a network/value key pair and returns the value for the current network */ const getChainConstant = ( obj: Record, network: number, - fallback: T = obj[Network.Mainnet] + fallback?: T ): T => { - return obj[network] ?? fallback; + return obj[network] ?? (fallback as T); }; export default getChainConstant;