@codex-data/sdk 1.0.1 → 1.0.3

package/dist/resources/graphql.ts

@@ -93,6 +93,13 @@ export type AddUserAchievementInput = {
   userId: Scalars['String']['input'];
 };
 
+export enum AddressType {
+  Evm = 'EVM',
+  Sol = 'SOL',
+  Tron = 'TRON'
+}
+
+/** The recurrence of the webhook. Can be `INDEFINITE` or `ONCE`. */
 export enum AlertRecurrence {
   Indefinite = 'INDEFINITE',
   Once = 'ONCE'
@@ -320,20 +327,32 @@ export type CommunityNotesResponse = {
   items: Array<CommunityNote>;
 };
 
+/** Comparison operators. */
 export type ComparisonOperator = {
   __typename?: 'ComparisonOperator';
+  /** Equal to. */
   eq?: Maybe<Scalars['String']['output']>;
+  /** Greater than. */
   gt?: Maybe<Scalars['String']['output']>;
+  /** Greater than or equal to. */
   gte?: Maybe<Scalars['String']['output']>;
+  /** Less than. */
   lt?: Maybe<Scalars['String']['output']>;
+  /** Less than or equal to. */
   lte?: Maybe<Scalars['String']['output']>;
 };
 
+/** Input for comparison operators. */
 export type ComparisonOperatorInput = {
+  /** Equal to. */
   eq?: InputMaybe<Scalars['String']['input']>;
+  /** Greater than. */
   gt?: InputMaybe<Scalars['String']['input']>;
+  /** Greater than or equal. */
   gte?: InputMaybe<Scalars['String']['input']>;
+  /** Less than. */
   lt?: InputMaybe<Scalars['String']['input']>;
+  /** Less than or equal. */
   lte?: InputMaybe<Scalars['String']['input']>;
 };
 
@@ -380,90 +399,156 @@ export type CreateApiTokensInput = {
   requestLimit?: InputMaybe<Scalars['String']['input']>;
 };
 
+/** Input for creating an NFT event webhook. */
 export type CreateNftEventWebhookArgs = {
+  /** The recurrence of the webhook. Can be `INDEFINITE` or `ONCE`. */
   alertRecurrence: AlertRecurrence;
+  /** An optional bucket ID (max 64 characters). Can be used to query for subgroups of webhooks (useful if you have a large number of webhooks). */
   bucketId?: InputMaybe<Scalars['String']['input']>;
+  /** An optional bucket sort key (max 64 characters). Can be used to query for subgroups of webhooks (useful if you have a large number of webhooks). */
   bucketSortkey?: InputMaybe<Scalars['String']['input']>;
+  /** The url to which the webhook message should be sent. */
   callbackUrl: Scalars['String']['input'];
+  /** The conditions which must be met in order for the webhook to send a message. */
   conditions: NftEventWebhookConditionInput;
+  /** If enabled, new webhooks won't be created if a webhook with the same parameters already exists. If callbackUrl, conditions, publishingType, and alertRecurrence all match, then we return the existing webhook. */
   deduplicate?: InputMaybe<Scalars['Boolean']['input']>;
+  /** A webhook group ID (max 64 characters). Can be used to group webhooks so that their messages are kept in order as a group rather than by individual webhook. */
   groupId?: InputMaybe<Scalars['String']['input']>;
+  /** The name of the webhook (max 128 characters). */
   name: Scalars['String']['input'];
+  /** The type of publishing for the webhook. If not set, it defaults to `SINGLE`. */
   publishingType?: InputMaybe<PublishingType>;
+  /** The settings for retrying failed webhook messages. */
   retrySettings?: InputMaybe<RetrySettingsInput>;
+  /** A string value to hash along with `deduplicationId` using SHA-256. Included in the webhook message for added security. */
   securityToken: Scalars['String']['input'];
 };
 
+/** Input for creating NFT event webhooks. */
 export type CreateNftEventWebhooksInput = {
+  /** A list of NFT event webhooks to create. */
   webhooks: Array<CreateNftEventWebhookArgs>;
 };
 
+/** Input for creating a price webhook. */
 export type CreatePriceWebhookArgs = {
+  /** The recurrence of the webhook. Can be `INDEFINITE` or `ONCE`. */
   alertRecurrence: AlertRecurrence;
+  /** An optional bucket ID (max 64 characters). Can be used to query for subgroups of webhooks (useful if you have a large number of webhooks). */
   bucketId?: InputMaybe<Scalars['String']['input']>;
+  /** An optional bucket sort key (max 64 characters). Can be used to query for subgroups of webhooks (useful if you have a large number of webhooks). */
   bucketSortkey?: InputMaybe<Scalars['String']['input']>;
+  /** The url to which the webhook message should be sent. */
   callbackUrl: Scalars['String']['input'];
+  /** The conditions which must be met in order for the webhook to send a message. */
   conditions: PriceEventWebhookConditionInput;
+  /** If enabled, new webhooks won't be created if a webhook with the same parameters already exists. If callbackUrl, conditions, publishingType, and alertRecurrence all match, then we return the existing webhook. */
   deduplicate?: InputMaybe<Scalars['Boolean']['input']>;
+  /** A webhook group ID (max 64 characters). Can be used to group webhooks so that their messages are kept in order as a group rather than by individual webhook. */
   groupId?: InputMaybe<Scalars['String']['input']>;
+  /** The name of the webhook (max 128 characters). */
   name: Scalars['String']['input'];
+  /** The type of publishing for the webhook. If not set, it defaults to `SINGLE`. */
   publishingType?: InputMaybe<PublishingType>;
+  /** The settings for retrying failed webhook messages. */
   retrySettings?: InputMaybe<RetrySettingsInput>;
+  /** A string value to hash along with `deduplicationId` using SHA-256. Included in the webhook message for added security. */
   securityToken: Scalars['String']['input'];
 };
 
+/** Input for creating price webhooks. */
 export type CreatePriceWebhooksInput = {
+  /** A list of price webhooks to create. */
   webhooks: Array<CreatePriceWebhookArgs>;
 };
 
+/** Input for creating a Raw Transaction webhook. */
 export type CreateRawTransactionWebhookArgs = {
+  /** The recurrence of the webhook. Can be `INDEFINITE` or `ONCE`. */
   alertRecurrence: AlertRecurrence;
+  /** An optional bucket ID (max 64 characters). Can be used to query for subgroups of webhooks (useful if you have a large number of webhooks). */
   bucketId?: InputMaybe<Scalars['String']['input']>;
+  /** An optional bucket sort key (max 64 characters). Can be used to query for subgroups of webhooks (useful if you have a large number of webhooks). */
   bucketSortkey?: InputMaybe<Scalars['String']['input']>;
+  /** The url to which the webhook message should be sent. */
   callbackUrl: Scalars['String']['input'];
+  /** The conditions which must be met in order for the webhook to send a message. */
   conditions: RawTransactionWebhookConditionInput;
+  /** If enabled, new webhooks won't be created if a webhook with the same parameters already exists. If callbackUrl, conditions, publishingType, and alertRecurrence all match, then we return the existing webhook. */
   deduplicate?: InputMaybe<Scalars['Boolean']['input']>;
+  /** A webhook group ID (max 64 characters). Can be used to group webhooks so that their messages are kept in order as a group rather than by individual webhook. */
   groupId?: InputMaybe<Scalars['String']['input']>;
+  /** The name of the webhook (max 128 characters). */
   name: Scalars['String']['input'];
+  /** The type of publishing for the webhook. If not set, it defaults to `SINGLE`. */
   publishingType?: InputMaybe<PublishingType>;
+  /** The settings for retrying failed webhook messages. */
   retrySettings?: InputMaybe<RetrySettingsInput>;
+  /** A string value to hash along with `deduplicationId` using SHA-256. Included in the webhook message for added security. */
   securityToken: Scalars['String']['input'];
 };
 
+/** Input for creating Raw Transaction webhooks. */
 export type CreateRawTransactionWebhooksInput = {
+  /** A list of Raw Transaction webhooks to create. */
   webhooks: Array<CreateRawTransactionWebhookArgs>;
 };
 
+/** Input for creating a token pair event webhook. */
 export type CreateTokenPairEventWebhookArgs = {
+  /** The recurrence of the webhook. Can be `INDEFINITE` or `ONCE`. */
   alertRecurrence: AlertRecurrence;
+  /** An optional bucket ID (max 64 characters). Can be used to query for subgroups of webhooks (useful if you have a large number of webhooks). */
   bucketId?: InputMaybe<Scalars['String']['input']>;
+  /** An optional bucket sort key (max 64 characters). Can be used to query for subgroups of webhooks (useful if you have a large number of webhooks). */
   bucketSortkey?: InputMaybe<Scalars['String']['input']>;
+  /** The url to which the webhook message should be sent. */
   callbackUrl: Scalars['String']['input'];
+  /** The conditions which must be met in order for the webhook to send a message. */
   conditions: TokenPairEventWebhookConditionInput;
+  /** If enabled, new webhooks won't be created if a webhook with the same parameters already exists. If callbackUrl, conditions, publishingType, and alertRecurrence all match, then we return the existing webhook. */
   deduplicate?: InputMaybe<Scalars['Boolean']['input']>;
+  /** A webhook group ID (max 64 characters). Can be used to group webhooks so that their messages are kept in order as a group rather than by individual webhook. */
   groupId?: InputMaybe<Scalars['String']['input']>;
+  /** The name of the webhook (max 128 characters). */
   name: Scalars['String']['input'];
+  /** The type of publishing for the webhook. If not set, it defaults to `SINGLE`. */
   publishingType?: InputMaybe<PublishingType>;
+  /** The settings for retrying failed webhook messages. */
   retrySettings?: InputMaybe<RetrySettingsInput>;
+  /** A string value to hash along with `deduplicationId` using SHA-256. Included in the webhook message for added security. */
   securityToken: Scalars['String']['input'];
 };
 
+/** Input for creating token pair event webhooks. */
 export type CreateTokenPairEventWebhooksInput = {
+  /** A list of token pair event webhooks to create. */
   webhooks: Array<CreateTokenPairEventWebhookArgs>;
 };
 
+/** Input for creating webhooks. */
 export type CreateWebhooksInput = {
+  /** Input for creating NFT event webhooks. */
   nftEventWebhooksInput?: InputMaybe<CreateNftEventWebhooksInput>;
+  /** Input for creating price webhooks. */
   priceWebhooksInput?: InputMaybe<CreatePriceWebhooksInput>;
+  /** Input for creating raw transaction webhooks. */
   rawTransactionWebhooksInput?: InputMaybe<CreateRawTransactionWebhooksInput>;
+  /** Input for creating token pair event webhooks. */
   tokenPairEventWebhooksInput?: InputMaybe<CreateTokenPairEventWebhooksInput>;
 };
 
+/** Result returned by `createWebhooks`. */
 export type CreateWebhooksOutput = {
   __typename?: 'CreateWebhooksOutput';
+  /** The list of NFT event webhooks that were created. */
   nftEventWebhooks: Array<Maybe<Webhook>>;
+  /** The list of price webhooks that were created. */
   priceWebhooks: Array<Maybe<Webhook>>;
+  /** The list of raw transaction webhooks that were created. */
   rawTransactionWebhooks: Array<Maybe<Webhook>>;
+  /** The list of token pair event webhooks that were created. */
   tokenPairEventWebhooks: Array<Maybe<Webhook>>;
 };
 
@@ -484,12 +569,16 @@ export type CurrencyBarData = {
   usd: IndividualBarData;
 };
 
+/** Input for deleting webhooks. */
 export type DeleteWebhooksInput = {
+  /** A list of webhook IDs to delete. */
   webhookIds: Array<Scalars['String']['input']>;
 };
 
+/** Result returned by `deleteWebhooks`. */
 export type DeleteWebhooksOutput = {
   __typename?: 'DeleteWebhooksOutput';
+  /** The list of webhook IDs that were deleted. */
   deletedIds?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
 };
 
@@ -850,12 +939,16 @@ export type Event = {
   quoteToken?: Maybe<QuoteToken>;
   /** The unix timestamp for when the transaction occurred. */
   timestamp: Scalars['Int']['output'];
+  /** The address of the event's token0. */
+  token0Address?: Maybe<Scalars['String']['output']>;
   /** The updated price of `token0` in USD, calculated after the transaction. */
   token0PoolValueUsd?: Maybe<Scalars['String']['output']>;
   /** The price of `token0` paid/received in USD, including any fees. */
   token0SwapValueUsd?: Maybe<Scalars['String']['output']>;
   /** The price of `token0` paid/received in the network's base token, including fees. */
   token0ValueBase?: Maybe<Scalars['String']['output']>;
+  /** The address of the event's token1. */
+  token1Address?: Maybe<Scalars['String']['output']>;
   /** The updated price of `token1` in USD, calculated after the transaction. */
   token1PoolValueUsd?: Maybe<Scalars['String']['output']>;
   /** The price of `token1` paid/received in USD, including any fees. */
@@ -1307,9 +1400,12 @@ export type GetTokensInfoInput = {
   networkId: Scalars['Int']['input'];
 };
 
+/** Response returned by `getWebhooks`. */
 export type GetWebhooksResponse = {
   __typename?: 'GetWebhooksResponse';
+  /** A cursor for use in pagination. */
   cursor?: Maybe<Scalars['String']['output']>;
+  /** A list of webhooks belonging to a user. */
   items?: Maybe<Array<Maybe<Webhook>>>;
 };
 
@@ -1345,6 +1441,8 @@ export type HoldersResponse = {
   items: Array<Balance>;
   /** Status of holder. Disabled if on unsupported network or there is insufficient holder data. */
   status: HoldersStatus;
+  /** What percentage of the total supply do the top 10 holders hold */
+  top10HoldersPercent?: Maybe<Scalars['Float']['output']>;
 };
 
 export enum HoldersSortAttribute {
@@ -1396,12 +1494,16 @@ export type IndividualBarData = {
   volumeNativeToken: Scalars['String']['output'];
 };
 
+/** Integer equals condition. */
 export type IntEqualsCondition = {
   __typename?: 'IntEqualsCondition';
+  /** The integer to equal. */
   eq: Scalars['Int']['output'];
 };
 
+/** Input for integer equals condition. */
 export type IntEqualsConditionInput = {
+  /** The integer to equal. */
   eq: Scalars['Int']['input'];
 };
 
@@ -1692,12 +1794,20 @@ export type MakerEventConnection = {
 };
 
 export type MakerEventsQueryInput = {
+  /** The specific event type to filter by. */
+  eventType?: InputMaybe<EventType>;
   /** The specific wallet address to filter by. */
   maker: Scalars['String']['input'];
   /** The network ID to filter by. */
-  networkId: Scalars['Int']['input'];
-  /** The token of interest. Can be `token0` or `token1`. */
+  networkId?: InputMaybe<Scalars['Int']['input']>;
+  /** The total amount of `quoteToken` involved in the swap in USD (`amountNonLiquidityToken` x `priceUsd`). */
+  priceUsdTotal?: InputMaybe<NumberFilter>;
+  /** docs: hide */
   quoteToken?: InputMaybe<QuoteToken>;
+  /** The time range to filter by. */
+  timestamp?: InputMaybe<EventQueryTimestampInput>;
+  /** The token involved in the event. */
+  tokenAddress?: InputMaybe<Scalars['String']['input']>;
 };
 
 /** The status for a network supported on Defined. */
@@ -1748,9 +1858,11 @@ export type Mutation = {
   __typename?: 'Mutation';
   /** Create a new set of short-lived api access tokens */
   createApiTokens: Array<ApiToken>;
+  /** Create price, raw transaction, token/pair event, and NFT event webhooks. */
   createWebhooks: CreateWebhooksOutput;
   /** Delete a single short-lived api access token by id */
   deleteApiToken: Scalars['String']['output'];
+  /** Delete multiple webhooks. */
   deleteWebhooks?: Maybe<DeleteWebhooksOutput>;
 };
 
@@ -2901,12 +3013,16 @@ export type NftEvent = {
   transactionIndex: Scalars['Int']['output'];
 };
 
+/** NFT marketplaces for a webhook to listen on. */
 export type NftEventFillSourceCondition = {
   __typename?: 'NftEventFillSourceCondition';
+  /** The list of NFT marketplaces. */
   oneOf: Array<WebhookNftEventFillSource>;
 };
 
+/** Input for NFT event fill source condition. */
 export type NftEventFillSourceConditionInput = {
+  /** The list of NFT marketplace to equal. */
   oneOf: Array<WebhookNftEventFillSource>;
 };
 
@@ -2982,37 +3098,61 @@ export enum NftEventTradeItemType {
   Token = 'TOKEN'
 }
 
+/** An NFT event type for a webhook to listen for. */
 export type NftEventTypeCondition = {
   __typename?: 'NftEventTypeCondition';
+  /** The NFT event type. */
   eq: WebhookNftEventType;
 };
 
+/** Input for NFT event type. */
 export type NftEventTypeConditionInput = {
+  /** The NFT event type to equal. */
   eq: WebhookNftEventType;
 };
 
+/** Webhook conditions for an NFT event. */
 export type NftEventWebhookCondition = {
   __typename?: 'NftEventWebhookCondition';
+  /** The NFT collection contract address the webhook is listening for. */
   contractAddress?: Maybe<StringEqualsCondition>;
+  /** The NFT event type the webhook is listening for. */
   eventType?: Maybe<NftEventTypeCondition>;
+  /** The exchange contract address the webhook is listening for. */
   exchangeAddress?: Maybe<StringEqualsCondition>;
+  /** The NFT marketplaces the webhook is listening on. */
   fillSource?: Maybe<NftEventFillSourceCondition>;
+  /** Option to ignore all nft transfer events */
   ignoreTransfers?: Maybe<Scalars['Boolean']['output']>;
+  /** The base token price the webhook is listening for. */
   individualBaseTokenPrice?: Maybe<ComparisonOperator>;
+  /** The maker wallet address the webhook is listening for. */
   maker?: Maybe<StringEqualsCondition>;
+  /** The list of network IDs the webhook is listening on. */
   networkId?: Maybe<OneOfNumberCondition>;
+  /** The token contract address the webhook is listening for. */
   tokenAddress?: Maybe<StringEqualsCondition>;
+  /** The token ID the webhook is listening for. */
   tokenId?: Maybe<StringEqualsCondition>;
 };
 
+/** Input conditions for an NFT event webhook. */
 export type NftEventWebhookConditionInput = {
+  /** The NFT collection contract address to listen for. */
   contractAddress?: InputMaybe<StringEqualsConditionInput>;
+  /** The NFT event type to listen for. */
   eventType?: InputMaybe<NftEventTypeConditionInput>;
+  /** The exchange contract address to listen for. */
   exchangeAddress?: InputMaybe<StringEqualsConditionInput>;
+  /** The NFT marketplaces to listen for. */
   fillSource?: InputMaybe<NftEventFillSourceConditionInput>;
+  /** Option to ignore all nft transfer events */
   ignoreTransfers?: InputMaybe<Scalars['Boolean']['input']>;
+  /** The maker wallet address to listen for. */
   maker?: InputMaybe<StringEqualsConditionInput>;
+  /** A list of network IDs to listen on. */
   networkId?: InputMaybe<OneOfNumberConditionInput>;
+  /** The token ID to listen for. */
   tokenId?: InputMaybe<StringEqualsConditionInput>;
 };
 
@@ -4439,12 +4579,16 @@ export type OnUnconfirmedBarsUpdated = {
   timestamp: Scalars['Int']['output'];
 };
 
+/** Integer list condition. */
 export type OneOfNumberCondition = {
   __typename?: 'OneOfNumberCondition';
+  /** The list of integers. */
   oneOf: Array<Scalars['Int']['output']>;
 };
 
+/** Input for integer list condition. */
 export type OneOfNumberConditionInput = {
+  /** The list of integers. */
   oneOf: Array<Scalars['Int']['input']>;
 };
 
@@ -4766,6 +4910,8 @@ export type PairFilters = {
 
 export type PairMetadata = {
   __typename?: 'PairMetadata';
+  enhancedToken0?: Maybe<EnhancedToken>;
+  enhancedToken1?: Maybe<EnhancedToken>;
   exchangeId?: Maybe<Scalars['String']['output']>;
   fee?: Maybe<Scalars['Int']['output']>;
   highPrice1?: Maybe<Scalars['String']['output']>;
@@ -5248,16 +5394,28 @@ export type Price = {
   timestamp: Scalars['Int']['output'];
 };
 
+/** Webhook conditions for a price event. */
 export type PriceEventWebhookCondition = {
   __typename?: 'PriceEventWebhookCondition';
+  /** The network ID the webhook is listening on. */
   networkId: IntEqualsCondition;
+  /** The pair contract address the webhook is listening for. */
+  pairAddress?: Maybe<StringEqualsCondition>;
+  /** The price condition that must be met in order for the webhook to send. */
   priceUsd: ComparisonOperator;
+  /** The token contract address the webhook is listening for. */
   tokenAddress: StringEqualsCondition;
 };
 
+/** Input conditions for a price event webhook. */
 export type PriceEventWebhookConditionInput = {
+  /** The network ID to listen on. */
   networkId: IntEqualsConditionInput;
+  /** The contract address of the pair to listen for. */
+  pairAddress?: InputMaybe<StringEqualsConditionInput>;
+  /** The price conditions to listen for. */
   priceUsd: ComparisonOperatorInput;
+  /** The contract address of the token to listen for. */
   tokenAddress: StringEqualsConditionInput;
 };
 
@@ -5765,6 +5923,7 @@ export type Query = {
   apiToken: ApiToken;
   /** Get all active short-lived api tokens for this api key */
   apiTokens: Array<ApiToken>;
+  backfillWalletState: Scalars['Boolean']['output'];
   /** Returns list of token balances that a wallet has */
   balances: BalancesResponse;
   /** Returns a URL for a pair chart. */
@@ -5850,6 +6009,7 @@ export type Query = {
   getTokenCount: Scalars['String']['output'];
   /** Returns transactions for a pair. */
   getTokenEvents?: Maybe<EventConnection>;
+  /** Returns a list of token events for a given maker. */
   getTokenEventsForMaker?: Maybe<MakerEventConnection>;
   /** Returns metadata for a given token. */
   getTokenInfo?: Maybe<TokenInfo>;
@@ -5859,6 +6019,7 @@ export type Query = {
   getTokensInfo?: Maybe<Array<Maybe<TokenInfo>>>;
   /** Returns tick data for a given Uniswap V3-style pool. */
   getUniV3Ticks?: Maybe<UniV3TickConnection>;
+  /** Returns a user's list of webhooks. */
   getWebhooks?: Maybe<GetWebhooksResponse>;
   /** Returns list of wallets that hold a given token, ordered by holdings descending. Also has the unique count of holders for that token */
   holders: HoldersResponse;
@@ -5897,6 +6058,8 @@ export type Query = {
   tokenSparklines: Array<TokenSparkline>;
   /** Find a list of tokens by their addresses & network id, with pagination. */
   tokens: Array<Maybe<EnhancedToken>>;
+  /** What percent of the total supply do the top 10 holders of a token hold */
+  top10HoldersPercent?: Maybe<Scalars['Float']['output']>;
   /** Returns list of NFT assets held by a given wallet for a single collection. */
   walletNftCollectionAssets: WalletNftCollectionAssetsResponse;
   /** Returns list of collections and quantity of NFTs held by a given wallet. */
@@ -6399,6 +6562,11 @@ export type QueryTokensArgs = {
 };
 
 
+export type QueryTop10HoldersPercentArgs = {
+  tokenId: Scalars['String']['input'];
+};
+
+
 export type QueryWalletNftCollectionAssetsArgs = {
   input: WalletNftCollectionAssetsInput;
 };
@@ -6466,24 +6634,40 @@ export type RawNftAssetData = {
   imageUrl?: Maybe<Scalars['String']['output']>;
 };
 
+/** Webhook conditions for a raw transaction. */
 export type RawTransactionWebhookCondition = {
   __typename?: 'RawTransactionWebhookCondition';
+  /** The from address to listen for. */
   from?: Maybe<StringEqualsCondition>;
+  /** Do not trigger the webhook if the raw transaction is handled by the NftEvent webhook. */
   ignoreNftEvents?: Maybe<Scalars['Boolean']['output']>;
+  /** Do not trigger the webhook if the raw transaction is handled by the TokenPairEvent webhook. */
   ignoreTokenPairEvents?: Maybe<Scalars['Boolean']['output']>;
+  /** Trigger the webhook if the  contains or doesn't contain the specified string. */
   input?: Maybe<StringContainsCondition>;
+  /** A list of network IDs to listen on. */
   networkId?: Maybe<OneOfNumberCondition>;
+  /** The to address to listen for. */
   to?: Maybe<StringEqualsCondition>;
+  /** Trigger the webhook if either the to or the from address matches. */
   toOrFrom?: Maybe<StringEqualsCondition>;
 };
 
+/** Input conditions for a Raw Transaction webhook. */
 export type RawTransactionWebhookConditionInput = {
+  /** The from address to listen for. */
   from?: InputMaybe<StringEqualsConditionInput>;
+  /** Do not trigger the webhook if the raw transaction is handled by the NftEvent webhook. */
   ignoreNftEvents?: InputMaybe<Scalars['Boolean']['input']>;
+  /** Do not trigger the webhook if the raw transaction is handled by the TokenPairEvent webhook. */
   ignoreTokenPairEvents?: InputMaybe<Scalars['Boolean']['input']>;
+  /** Trigger the webhook if the input contains or doesn't contain the specified string. */
   input?: InputMaybe<StringContainsConditionInput>;
+  /** A list of network IDs to listen on. */
   networkId?: InputMaybe<OneOfNumberConditionInput>;
+  /** The to address to listen for. */
   to?: InputMaybe<StringEqualsConditionInput>;
+  /** Trigger the webhook if either the to or the from address matches. */
   toOrFrom?: InputMaybe<StringEqualsConditionInput>;
 };
 
@@ -6550,18 +6734,28 @@ export type ResolutionBarData = {
   r720?: Maybe<CurrencyBarData>;
 };
 
+/** Config for retrying failed webhook messages */
 export type RetrySettings = {
   __typename?: 'RetrySettings';
+  /** The maximum number of times the webhook will retry sending a message */
   maxRetries?: Maybe<Scalars['Int']['output']>;
+  /** The maximum time in seconds that the webhook will wait before retrying a failed message */
   maxRetryDelay?: Maybe<Scalars['Int']['output']>;
+  /** The maximum time in seconds that the webhook will retry sending a message */
   maxTimeElapsed?: Maybe<Scalars['Int']['output']>;
+  /** The minimum time in seconds that the webhook will wait before retrying a failed message */
   minRetryDelay?: Maybe<Scalars['Int']['output']>;
 };
 
+/** Config input for retrying failed webhook messages */
 export type RetrySettingsInput = {
+  /** The maximum number of times the webhook will retry sending a message */
   maxRetries?: InputMaybe<Scalars['Int']['input']>;
+  /** The maximum time in seconds that the webhook will wait before retrying a failed message */
   maxRetryDelay?: InputMaybe<Scalars['Int']['input']>;
+  /** The maximum time in seconds that the webhook will retry sending a message */
   maxTimeElapsed?: InputMaybe<Scalars['Int']['input']>;
+  /** The minimum time in seconds that the webhook will wait before retrying a failed message */
   minRetryDelay?: InputMaybe<Scalars['Int']['input']>;
 };
 
@@ -6866,23 +7060,33 @@ export type StatsFilter = {
   previous?: InputMaybe<NumberFilter>;
 };
 
+/** String contains condition. */
 export type StringContainsCondition = {
   __typename?: 'StringContainsCondition';
+  /** A list of substrings included within the string. */
   contains?: Maybe<Array<Scalars['String']['output']>>;
+  /** A list of substrings not included within the string. */
   notContains?: Maybe<Array<Scalars['String']['output']>>;
 };
 
+/** Input for string contains condition. */
 export type StringContainsConditionInput = {
+  /** A list of substrings to be included within the string. */
   contains?: InputMaybe<Array<Scalars['String']['input']>>;
+  /** A list of substrings not to be included within the string. */
   notContains?: InputMaybe<Array<Scalars['String']['input']>>;
 };
 
+/** String equals condition. */
 export type StringEqualsCondition = {
   __typename?: 'StringEqualsCondition';
+  /** The string to equal. */
   eq: Scalars['String']['output'];
 };
 
+/** Input for string equals condition. */
 export type StringEqualsConditionInput = {
+  /** The string to equal. */
   eq: Scalars['String']['input'];
 };
 
@@ -7052,6 +7256,26 @@ export type SubscriptionOnUnconfirmedEventsCreatedArgs = {
   quoteToken?: InputMaybe<QuoteToken>;
 };
 
+export type SuiNetworkConfig = {
+  __typename?: 'SuiNetworkConfig';
+  baseTokenAddress: Scalars['String']['output'];
+  baseTokenSymbol: Scalars['String']['output'];
+  color?: Maybe<Scalars['String']['output']>;
+  defaultPairAddress: Scalars['String']['output'];
+  defaultPairQuoteToken: QuoteToken;
+  enabled: Scalars['Boolean']['output'];
+  id: Scalars['ID']['output'];
+  mainnet: Scalars['Boolean']['output'];
+  name: Scalars['String']['output'];
+  networkIconUrl: Scalars['String']['output'];
+  networkId: Scalars['Int']['output'];
+  networkName: Scalars['String']['output'];
+  networkShortName: Scalars['String']['output'];
+  newTokensEnabled?: Maybe<Scalars['Boolean']['output']>;
+  stableCoinAddresses?: Maybe<Array<Scalars['String']['output']>>;
+  wrappedBaseTokenSymbol: Scalars['String']['output'];
+};
+
 /** Event data for a token swap event. */
 export type SwapEventData = {
   __typename?: 'SwapEventData';
@@ -7435,6 +7659,8 @@ export type TokenFilters = {
   marketCap?: InputMaybe<NumberFilter>;
   /** The list of network IDs to filter by. Applied in conjunction with `exchangeId` filter using an OR condition. When used together, the query returns results that match either the specified exchanges or the specified network. */
   network?: InputMaybe<Array<InputMaybe<Scalars['Int']['input']>>>;
+  /** docs: hide */
+  notableHolderCount?: InputMaybe<NumberFilter>;
   /** Filter potential Scams */
   potentialScam?: InputMaybe<Scalars['Boolean']['input']>;
   /** The token price in USD. */
@@ -7610,6 +7836,7 @@ export enum TokenOfInterest {
   Token1 = 'token1'
 }
 
+/** Token pair event types. */
 export enum TokenPairEventType {
   Burn = 'BURN',
   Buy = 'BUY',
@@ -7621,33 +7848,53 @@ export enum TokenPairEventType {
   Sync = 'SYNC'
 }
 
+/** Webhook condition for token pair event type. */
 export type TokenPairEventTypeCondition = {
   __typename?: 'TokenPairEventTypeCondition';
+  /** The list of token pair event types. */
   oneOf: Array<TokenPairEventType>;
 };
 
+/** Input for token pair event type condition. */
 export type TokenPairEventTypeConditionInput = {
+  /** The list of token event types to equal. */
   oneOf: Array<TokenPairEventType>;
 };
 
+/** Webhook conditions for a token pair event. */
 export type TokenPairEventWebhookCondition = {
   __typename?: 'TokenPairEventWebhookCondition';
+  /** The event type the webhook is listening for. */
   eventType?: Maybe<TokenPairEventTypeCondition>;
+  /** The exchange contract address the webhook is listening for. */
   exchangeAddress?: Maybe<StringEqualsCondition>;
+  /** The maker wallet address the webhook is listening for. */
   maker?: Maybe<StringEqualsCondition>;
+  /** The list of network IDs the webhook is listening on. */
   networkId?: Maybe<OneOfNumberCondition>;
+  /** The pair contract address the webhook is listening for. */
   pairAddress?: Maybe<StringEqualsCondition>;
+  /** The swap values the webhook is listening for. */
   swapValue?: Maybe<ComparisonOperator>;
+  /** The token contract address the webhook is listening for. */
   tokenAddress?: Maybe<StringEqualsCondition>;
 };
 
+/** Input conditions for a token pair event webhook. */
 export type TokenPairEventWebhookConditionInput = {
+  /** The token event type to listen for. */
   eventType?: InputMaybe<TokenPairEventTypeConditionInput>;
+  /** The exchange contract address to listen for. */
   exchangeAddress?: InputMaybe<StringEqualsConditionInput>;
+  /** The maker wallet address to listen for. */
   maker?: InputMaybe<StringEqualsConditionInput>;
+  /** A list of network IDs to listen on. */
   networkId?: InputMaybe<OneOfNumberConditionInput>;
+  /** The pair contract address to listen for. */
   pairAddress?: InputMaybe<StringEqualsConditionInput>;
+  /** The swap values to listen for. */
   swapValue?: InputMaybe<ComparisonOperatorInput>;
+  /** The token contract address to listen for. */
   tokenAddress?: InputMaybe<StringEqualsConditionInput>;
 };
 
@@ -7690,6 +7937,7 @@ export enum TokenRankingAttribute {
   Low12 = 'low12',
   Low24 = 'low24',
   MarketCap = 'marketCap',
+  NotableHolderCount = 'notableHolderCount',
   PriceUsd = 'priceUSD',
   SellCount1 = 'sellCount1',
   SellCount4 = 'sellCount4',
@@ -8016,25 +8264,41 @@ export type WashtradeLabelForEvent = {
   label: Scalars['String']['output'];
 };
 
+/** Metadata for a webhook. */
 export type Webhook = {
   __typename?: 'Webhook';
+  /** The recurrence of the webhook. Can be `INDEFINITE` or `ONCE`. */
   alertRecurrence: AlertRecurrence;
+  /** An optional bucket ID (max 64 characters). Can be used to query for subgroups of webhooks (useful if you have a large number of webhooks). */
   bucketId?: Maybe<Scalars['String']['output']>;
+  /** An optional bucket sort key (max 64 characters). Can be used to query for subgroups of webhooks (useful if you have a large number of webhooks). */
   bucketSortkey?: Maybe<Scalars['String']['output']>;
+  /** The url to which the webhook message should be sent. */
   callbackUrl: Scalars['String']['output'];
+  /** The conditions which must be met in order for the webhook to send a message. */
   conditions: WebhookCondition;
+  /** The unix timestamp for the time the webhook was created. */
   created: Scalars['Int']['output'];
+  /** The webhook group ID used to group webhooks together for ordered message sending. */
   groupId?: Maybe<Scalars['String']['output']>;
+  /** The ID of the webhook. */
   id: Scalars['String']['output'];
+  /** The given name of the webhook. */
   name: Scalars['String']['output'];
+  /** The type of publishing for the webhook. If not set, it defaults to `SINGLE`. */
   publishingType?: Maybe<PublishingType>;
+  /** The settings for retrying failed webhook messages. */
   retrySettings?: Maybe<RetrySettings>;
+  /** The status of the webhook. Can be `ACTIVE` or `INACTIVE`. */
   status: Scalars['String']['output'];
+  /** The type of webhook. Can be `PRICE_EVENT`, `NFT_EVENT`, or `TOKEN_PAIR_EVENT`. */
   webhookType: WebhookType;
 };
 
+/** Webhook conditions that must be met for each webhook type. */
 export type WebhookCondition = NftEventWebhookCondition | PriceEventWebhookCondition | RawTransactionWebhookCondition | TokenPairEventWebhookCondition;
 
+/** NFT marketplace names. */
 export enum WebhookNftEventFillSource {
   Blur = 'BLUR',
   Coinbase = 'COINBASE',
@@ -8053,12 +8317,14 @@ export enum WebhookNftEventFillSource {
   Soundxyz = 'SOUNDXYZ'
 }
 
+/** NFT event types. */
 export enum WebhookNftEventType {
   Mint = 'MINT',
   Sale = 'SALE',
   Transfer = 'TRANSFER'
 }
 
+/** The type of webhook. */
 export enum WebhookType {
   NftEvent = 'NFT_EVENT',
   PriceEvent = 'PRICE_EVENT',