@codex-data/sdk 0.6.2 → 1.0.0-rc1

package/src/scripts/generateGraphql.ts

@@ -0,0 +1,236 @@
+import fs from "fs";
+import * as gql from "gql-query-builder";
+import VariableOptions from "gql-query-builder/build/VariableOptions";
+import { mkdirp } from "mkdirp";
+import path from "path";
+
+type SchemaTypeDefinition = {
+  kind:
+    | "NON_NULL"
+    | "SCALAR"
+    | "LIST"
+    | "OBJECT"
+    | "INPUT_OBJECT"
+    | "ENUM"
+    | "UNION"
+    | undefined
+    | null;
+  name?: string | null;
+  ofType?: SchemaTypeDefinition | null;
+  isDeprecated?: boolean | null;
+};
+
+type SchemaType = {
+  name: string;
+  description?: string | null;
+  type: SchemaTypeDefinition;
+  isDeprecated?: boolean | null;
+  fields?: SchemaType[];
+};
+
+type Fields = Array<string | { [key: string]: Fields }>;
+
+function capitalize(str: string) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export const getLeafType = (
+  type: SchemaTypeDefinition,
+  allTypes: SchemaType[],
+  result: Fields,
+  currentName: string,
+  level = 0,
+): Fields => {
+  if (level > 8 || !type?.kind || type.kind === "UNION" || type.isDeprecated)
+    return result;
+
+  // If it's a scalar, return the name
+  if (type.kind === "SCALAR" || type.kind === "ENUM")
+    return [...result, currentName!];
+
+  // If it's an object resolve it.
+  if (type.kind === "OBJECT") {
+    // For each of the fields of the subtype, resolve them
+    const subType = allTypes.find((t) => t.name === type.name);
+    const subTypeLeaves = (subType?.fields ?? [])
+      .filter((t) => !t.isDeprecated)
+      .map((f: SchemaType) =>
+        getLeafType(f.type, allTypes, [], f.name, level + 1),
+      )
+      .flat();
+    return [
+      ...result,
+      ...(level === 0 ? subTypeLeaves : [{ [currentName]: subTypeLeaves }]),
+    ];
+  }
+
+  // If it's a list, resolve the first object type
+  if (type.kind === "LIST")
+    return getLeafType(type.ofType!, allTypes, [...result], currentName, level);
+
+  // If it's required, resolve the first object type
+  if (type.kind === "NON_NULL")
+    return getLeafType(type.ofType!, allTypes, [...result], currentName, level);
+
+  throw new Error(`Unknown type ${type.name} ${type.kind}`);
+};
+
+export const getLeafArgs = (
+  type: SchemaTypeDefinition,
+  result: VariableOptions,
+): VariableOptions => {
+  if (
+    type.kind === "NON_NULL" &&
+    ["INPUT_OBJECT", "SCALAR", "OBJECT", "ENUM"].includes(
+      type.ofType?.kind as string,
+    )
+  )
+    return { ...result, type: `${type.ofType!.name!}!` };
+
+  // If it's a scalar, return the name
+  if (
+    type.kind === "SCALAR" ||
+    type.kind === "OBJECT" ||
+    type.kind === "ENUM" ||
+    type.kind === "INPUT_OBJECT"
+  )
+    return { ...result, type: type.name!, value: null };
+
+  // If it's a list, resolve the first object type
+  if (type.kind === "LIST")
+    return getLeafArgs(type.ofType!, { ...result, list: true });
+
+  // If it's required, resolve the first object type
+  if (type.kind === "NON_NULL")
+    return getLeafArgs(type.ofType!, { ...result, required: true });
+
+  throw new Error(`Unknown type ${type.name} ${type.kind}`);
+};
+
+export function parseVariables(args: SchemaType[]) {
+  const parsedVariables = args.reduce(
+    (acc: VariableOptions, arg: SchemaType) => {
+      return {
+        ...acc,
+        [arg.name]: getLeafArgs(arg.type, {}),
+      };
+    },
+    {},
+  );
+  return parsedVariables;
+}
+
+/**
+ * Runs a query against the currently published graphql schema,
+ * and generates a query ts file for query.
+ */
+async function run() {
+  console.log("Generating...");
+
+  // Fetch schema from remote
+  const res = await fetch(`https://graph.codex.io/schema/latest.json`, {
+    method: "GET",
+  });
+  const schemaJson = await res.json();
+
+  const types = schemaJson.__schema.types;
+  const mutationType = types.find(
+    (type: SchemaType) => type.name === "Mutation",
+  );
+  const queryType = types.find((type: SchemaType) => type.name === "Query");
+  const subscriptionType = types.find(
+    (type: SchemaType) => type.name === "Subscription",
+  );
+
+  for (const field of mutationType.fields) {
+    const args = field.args;
+    const parsedVariables = parseVariables(args);
+    const parsedFields = getLeafType(field.type, types, [], "").filter(Boolean);
+
+    const mutationBuilderObject = gql.mutation({
+      operation: field.name,
+      variables: Object.keys(parsedVariables).length
+        ? parsedVariables
+        : undefined,
+      fields: parsedFields.length ? parsedFields : undefined,
+    });
+    console.log(`Writing mutation: ${field.name}.graphql`);
+    const mutationsFolderPath = path.join(
+      __dirname,
+      "..",
+      "resources",
+      "generated_mutations",
+    );
+    await mkdirp(mutationsFolderPath);
+    fs.writeFileSync(
+      path.join(mutationsFolderPath, `${capitalize(field.name)}.graphql`),
+      `mutation ${capitalize(field.name)}${mutationBuilderObject.query
+        .toString()
+        .slice("mutation ".length)}`,
+    );
+  }
+
+  for (const field of subscriptionType.fields) {
+    const args = field.args;
+    const parsedVariables = parseVariables(args);
+    const parsedFields = getLeafType(field.type, types, [], "").filter(Boolean);
+
+    const subscriptionBuilderObject = gql.subscription({
+      operation: field.name,
+      variables: Object.keys(parsedVariables).length
+        ? parsedVariables
+        : undefined,
+      fields: parsedFields.length ? parsedFields : undefined,
+    });
+    console.log(`Writing subscription: ${field.name}.graphql`);
+    const subscriptionsFolderPath = path.join(
+      __dirname,
+      "..",
+      "resources",
+      "generated_subscriptions",
+    );
+    await mkdirp(subscriptionsFolderPath);
+    fs.writeFileSync(
+      path.join(subscriptionsFolderPath, `${capitalize(field.name)}.graphql`),
+      `subscription ${capitalize(field.name)}${subscriptionBuilderObject.query
+        .toString()
+        .slice("subscription ".length)}`,
+    );
+  }
+
+  for (const field of queryType.fields) {
+    if (field.isDeprecated) {
+      console.log("Skipping deprecated field", field.name);
+      continue;
+    }
+
+    const args = field.args;
+    const parsedVariables = parseVariables(args);
+    const parsedFields = getLeafType(field.type, types, [], "").filter(Boolean);
+
+    const queryBuilderObject = gql.query({
+      operation: field.name,
+      variables: Object.keys(parsedVariables).length
+        ? parsedVariables
+        : undefined,
+      fields: parsedFields.length ? parsedFields : undefined,
+    });
+    console.log(`Writing query: ${field.name}.graphql`);
+
+    const queriesFolderPath = path.join(
+      __dirname,
+      "..",
+      "resources",
+      "generated_queries",
+    );
+    await mkdirp(queriesFolderPath);
+    fs.writeFileSync(
+      path.join(queriesFolderPath, `${capitalize(field.name)}.graphql`),
+      `query ${capitalize(field.name)}${queryBuilderObject.query
+        .toString()
+        .slice("query ".length)}`,
+    );
+  }
+}
+
+run().then(() => process.exit());

package/src/sdk/Mutation.ts

@@ -1,15 +1,24 @@
-import { DeleteWebhooksInput } from "../resources/graphql";
+// THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT IT DIRECTLY
 import {
+  CreateApiTokensDocument,
+  CreateApiTokensMutationVariables,
   CreateWebhooksDocument,
-  CreateWebhooksInput,
+  CreateWebhooksMutationVariables,
+  DeleteApiTokenDocument,
+  DeleteApiTokenMutationVariables,
   DeleteWebhooksDocument,
+  DeleteWebhooksMutationVariables,
 } from "./generated/graphql";
 import { Codex } from "./index";
 
 export class Mutation {
   constructor(private sdk: Codex) {}
-  createWebhooks = async (vars: { input: CreateWebhooksInput }) =>
+  createWebhooks = async (vars: CreateWebhooksMutationVariables) =>
     this.sdk.mutation(CreateWebhooksDocument, vars);
-  deleteWebhooks = async (vars: { input: DeleteWebhooksInput }) =>
+  deleteApiToken = async (vars: DeleteApiTokenMutationVariables) =>
+    this.sdk.mutation(DeleteApiTokenDocument, vars);
+  createApiTokens = async (vars: CreateApiTokensMutationVariables) =>
+    this.sdk.mutation(CreateApiTokensDocument, vars);
+  deleteWebhooks = async (vars: DeleteWebhooksMutationVariables) =>
     this.sdk.mutation(DeleteWebhooksDocument, vars);
 }

package/src/sdk/Query.ts

@@ -1,65 +1,280 @@
+// THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT IT DIRECTLY
 import {
+  ApiTokenDocument,
+  ApiTokenQueryVariables,
+  ApiTokensDocument,
+  ApiTokensQueryVariables,
+  BalancesDocument,
+  BalancesQueryVariables,
+  ChartUrlsDocument,
+  ChartUrlsQueryVariables,
   FilterExchangesDocument,
   FilterExchangesQueryVariables,
+  FilterNftCollectionsDocument,
+  FilterNftCollectionsQueryVariables,
+  FilterNftParallelAssetsDocument,
+  FilterNftParallelAssetsQueryVariables,
+  FilterNftPoolCollectionsDocument,
+  FilterNftPoolCollectionsQueryVariables,
+  FilterNftPoolsDocument,
+  FilterNftPoolsQueryVariables,
   FilterPairsDocument,
   FilterPairsQueryVariables,
   FilterTokensDocument,
   FilterTokensQueryVariables,
   GetBarsDocument,
+  GetBarsQueryVariables,
+  GetCommunityNotesDocument,
+  GetCommunityNotesQueryVariables,
+  GetDetailedNftStatsDocument,
+  GetDetailedNftStatsQueryVariables,
+  GetDetailedPairsStatsDocument,
+  GetDetailedPairsStatsQueryVariables,
   GetDetailedPairStatsDocument,
+  GetDetailedPairStatsQueryVariables,
+  GetEventLabelsDocument,
+  GetEventLabelsQueryVariables,
+  GetExchangesDocument,
+  GetExchangesQueryVariables,
+  GetLatestPairsDocument,
+  GetLatestPairsQueryVariables,
+  GetLatestTokensDocument,
+  GetLatestTokensQueryVariables,
   GetNetworksDocument,
+  GetNetworksQueryVariables,
+  GetNetworkStatsDocument,
+  GetNetworkStatsQueryVariables,
   GetNetworkStatusDocument,
-  GetSparklinesDocument,
-  GetSparklinesQueryVariables,
+  GetNetworkStatusQueryVariables,
+  GetNftAssetsDocument,
+  GetNftAssetsQueryVariables,
+  GetNftCollectionMetadataDocument,
+  GetNftCollectionMetadataQueryVariables,
+  GetNftContractsDocument,
+  GetNftContractsQueryVariables,
+  GetNftEventsDocument,
+  GetNftEventsQueryVariables,
+  GetNftPoolCollectionDocument,
+  GetNftPoolCollectionQueryVariables,
+  GetNftPoolCollectionsByExchangeDocument,
+  GetNftPoolCollectionsByExchangeQueryVariables,
+  GetNftPoolDocument,
+  GetNftPoolEventsDocument,
+  GetNftPoolEventsQueryVariables,
+  GetNftPoolQueryVariables,
+  GetNftPoolsByCollectionAndExchangeDocument,
+  GetNftPoolsByCollectionAndExchangeQueryVariables,
+  GetNftPoolsByOwnerDocument,
+  GetNftPoolsByOwnerQueryVariables,
+  GetNftPoolStatsDocument,
+  GetNftPoolStatsQueryVariables,
+  GetParallelAssetsDocument,
+  GetParallelAssetsQueryVariables,
+  GetParallelCardChangesDocument,
+  GetParallelCardChangesQueryVariables,
+  GetPrimePoolAssetsDocument,
+  GetPrimePoolAssetsQueryVariables,
+  GetPrimePoolEventsDocument,
+  GetPrimePoolEventsQueryVariables,
+  GetPrimePoolsDocument,
+  GetPrimePoolsQueryVariables,
+  GetSimulateTokenContractResultsDocument,
+  GetSimulateTokenContractResultsQueryVariables,
   GetSymbolDocument,
   GetSymbolQueryVariables,
-  GetTokenPriceDocument,
-  GetTokensDocument,
+  GetTokenCountDocument,
+  GetTokenCountQueryVariables,
+  GetTokenEventsDocument,
+  GetTokenEventsQueryVariables,
+  GetTokenInfoDocument,
+  GetTokenInfoQueryVariables,
+  GetTokenPricesDocument,
+  GetTokenPricesQueryVariables,
+  GetTokensInfoDocument,
+  GetTokensInfoQueryVariables,
+  GetUniV3TicksDocument,
+  GetUniV3TicksQueryVariables,
   GetWebhooksDocument,
+  GetWebhooksQueryVariables,
+  HoldersDocument,
+  HoldersQueryVariables,
+  LiquidityLocksDocument,
+  LiquidityLocksQueryVariables,
+  LiquidityMetadataDocument,
+  LiquidityMetadataQueryVariables,
+  ListFavoriteTokensDocument,
+  ListFavoriteTokensQueryVariables,
   ListPairsForTokenDocument,
   ListPairsForTokenQueryVariables,
+  ListPairsWithMetadataForTokenDocument,
+  ListPairsWithMetadataForTokenQueryVariables,
   ListTopTokensDocument,
-  PairEventsDocument,
-  PairEventsQueryVariables,
-  QueryGetBarsArgs,
-  QueryGetDetailedPairStatsArgs,
-  QueryGetNetworkStatusArgs,
-  QueryGetTokenPricesArgs,
-  QueryGetWebhooksArgs,
-  QueryListTopTokensArgs,
-  QueryTokenArgs,
+  ListTopTokensQueryVariables,
+  NftHoldersDocument,
+  NftHoldersQueryVariables,
+  PairMetadataDocument,
+  PairMetadataQueryVariables,
+  PrimeBalanceDocument,
+  PrimeBalanceQueryVariables,
+  PrimeHoldersDocument,
+  PrimeHoldersQueryVariables,
+  SearchNftsDocument,
+  SearchNftsQueryVariables,
+  TokenDocument,
+  TokenLifecycleEventsDocument,
+  TokenLifecycleEventsQueryVariables,
+  TokenQueryVariables,
+  TokensDocument,
+  TokenSparklinesDocument,
+  TokenSparklinesQueryVariables,
+  TokensQueryVariables,
+  WalletNftCollectionAssetsDocument,
+  WalletNftCollectionAssetsQueryVariables,
+  WalletNftCollectionsDocument,
+  WalletNftCollectionsQueryVariables,
 } from "./generated/graphql";
 import { Codex } from "./index";
 
 export class Query {
   constructor(private sdk: Codex) {}
-  pairEvents = async (vars: PairEventsQueryVariables) =>
-    this.sdk.query(PairEventsDocument, vars);
-  sparklines = async (vars: GetSparklinesQueryVariables) =>
-    this.sdk.query(GetSparklinesDocument, vars);
-  token = async (vars: QueryTokenArgs) =>
-    this.sdk.query(GetTokensDocument, vars);
-  price = async (vars: QueryGetTokenPricesArgs) =>
-    this.sdk.query(GetTokenPriceDocument, vars);
-  detailedPairStats = async (vars: QueryGetDetailedPairStatsArgs) =>
-    this.sdk.query(GetDetailedPairStatsDocument, vars);
-  bars = async (vars: QueryGetBarsArgs) =>
-    this.sdk.query(GetBarsDocument, vars);
-  topTokens = async (vars: QueryListTopTokensArgs) =>
-    this.sdk.query(ListTopTokensDocument, vars);
-  filterTokens = async (vars: FilterTokensQueryVariables) =>
-    this.sdk.query(FilterTokensDocument, vars);
+  getLatestPairs = async (vars: GetLatestPairsQueryVariables) =>
+    this.sdk.query(GetLatestPairsDocument, vars);
+  token = async (vars: TokenQueryVariables) =>
+    this.sdk.query(TokenDocument, vars);
+  getNftPoolStats = async (vars: GetNftPoolStatsQueryVariables) =>
+    this.sdk.query(GetNftPoolStatsDocument, vars);
+  liquidityMetadata = async (vars: LiquidityMetadataQueryVariables) =>
+    this.sdk.query(LiquidityMetadataDocument, vars);
+  primeHolders = async (vars: PrimeHoldersQueryVariables) =>
+    this.sdk.query(PrimeHoldersDocument, vars);
+  filterNftPoolCollections = async (
+    vars: FilterNftPoolCollectionsQueryVariables,
+  ) => this.sdk.query(FilterNftPoolCollectionsDocument, vars);
+  getNetworks = async (vars: GetNetworksQueryVariables) =>
+    this.sdk.query(GetNetworksDocument, vars);
+  searchNfts = async (vars: SearchNftsQueryVariables) =>
+    this.sdk.query(SearchNftsDocument, vars);
+  getSimulateTokenContractResults = async (
+    vars: GetSimulateTokenContractResultsQueryVariables,
+  ) => this.sdk.query(GetSimulateTokenContractResultsDocument, vars);
+  filterNftPools = async (vars: FilterNftPoolsQueryVariables) =>
+    this.sdk.query(FilterNftPoolsDocument, vars);
+  getTokenEvents = async (vars: GetTokenEventsQueryVariables) =>
+    this.sdk.query(GetTokenEventsDocument, vars);
+  balances = async (vars: BalancesQueryVariables) =>
+    this.sdk.query(BalancesDocument, vars);
+  getDetailedPairsStats = async (vars: GetDetailedPairsStatsQueryVariables) =>
+    this.sdk.query(GetDetailedPairsStatsDocument, vars);
+  getNftEvents = async (vars: GetNftEventsQueryVariables) =>
+    this.sdk.query(GetNftEventsDocument, vars);
+  getNftPoolsByCollectionAndExchange = async (
+    vars: GetNftPoolsByCollectionAndExchangeQueryVariables,
+  ) => this.sdk.query(GetNftPoolsByCollectionAndExchangeDocument, vars);
+  getNftPoolCollectionsByExchange = async (
+    vars: GetNftPoolCollectionsByExchangeQueryVariables,
+  ) => this.sdk.query(GetNftPoolCollectionsByExchangeDocument, vars);
+  walletNftCollections = async (vars: WalletNftCollectionsQueryVariables) =>
+    this.sdk.query(WalletNftCollectionsDocument, vars);
   filterPairs = async (vars: FilterPairsQueryVariables) =>
     this.sdk.query(FilterPairsDocument, vars);
-  listPairsForToken = async (vars: ListPairsForTokenQueryVariables) =>
-    this.sdk.query(ListPairsForTokenDocument, vars);
+  filterTokens = async (vars: FilterTokensQueryVariables) =>
+    this.sdk.query(FilterTokensDocument, vars);
+  getNftCollectionMetadata = async (
+    vars: GetNftCollectionMetadataQueryVariables,
+  ) => this.sdk.query(GetNftCollectionMetadataDocument, vars);
+  getTokenCount = async (vars: GetTokenCountQueryVariables) =>
+    this.sdk.query(GetTokenCountDocument, vars);
+  getParallelAssets = async (vars: GetParallelAssetsQueryVariables) =>
+    this.sdk.query(GetParallelAssetsDocument, vars);
+  getNftPoolCollection = async (vars: GetNftPoolCollectionQueryVariables) =>
+    this.sdk.query(GetNftPoolCollectionDocument, vars);
+  getNftPoolsByOwner = async (vars: GetNftPoolsByOwnerQueryVariables) =>
+    this.sdk.query(GetNftPoolsByOwnerDocument, vars);
+  getLatestTokens = async (vars: GetLatestTokensQueryVariables) =>
+    this.sdk.query(GetLatestTokensDocument, vars);
+  walletNftCollectionAssets = async (
+    vars: WalletNftCollectionAssetsQueryVariables,
+  ) => this.sdk.query(WalletNftCollectionAssetsDocument, vars);
+  getTokenInfo = async (vars: GetTokenInfoQueryVariables) =>
+    this.sdk.query(GetTokenInfoDocument, vars);
+  getEventLabels = async (vars: GetEventLabelsQueryVariables) =>
+    this.sdk.query(GetEventLabelsDocument, vars);
+  getUniV3Ticks = async (vars: GetUniV3TicksQueryVariables) =>
+    this.sdk.query(GetUniV3TicksDocument, vars);
+  getSymbol = async (vars: GetSymbolQueryVariables) =>
+    this.sdk.query(GetSymbolDocument, vars);
+  getPrimePoolEvents = async (vars: GetPrimePoolEventsQueryVariables) =>
+    this.sdk.query(GetPrimePoolEventsDocument, vars);
+  getNftPool = async (vars: GetNftPoolQueryVariables) =>
+    this.sdk.query(GetNftPoolDocument, vars);
   filterExchanges = async (vars: FilterExchangesQueryVariables) =>
     this.sdk.query(FilterExchangesDocument, vars);
-  symbol = async (vars: GetSymbolQueryVariables) =>
-    this.sdk.query(GetSymbolDocument, vars);
-  networks = async () => this.sdk.query(GetNetworksDocument);
-  networkStatus = async (vars: QueryGetNetworkStatusArgs) =>
-    this.sdk.query(GetNetworkStatusDocument, vars);
-  getWebhooks = async (vars: QueryGetWebhooksArgs) =>
+  getPrimePools = async (vars: GetPrimePoolsQueryVariables) =>
+    this.sdk.query(GetPrimePoolsDocument, vars);
+  chartUrls = async (vars: ChartUrlsQueryVariables) =>
+    this.sdk.query(ChartUrlsDocument, vars);
+  apiToken = async (vars: ApiTokenQueryVariables) =>
+    this.sdk.query(ApiTokenDocument, vars);
+  holders = async (vars: HoldersQueryVariables) =>
+    this.sdk.query(HoldersDocument, vars);
+  tokens = async (vars: TokensQueryVariables) =>
+    this.sdk.query(TokensDocument, vars);
+  liquidityLocks = async (vars: LiquidityLocksQueryVariables) =>
+    this.sdk.query(LiquidityLocksDocument, vars);
+  tokenSparklines = async (vars: TokenSparklinesQueryVariables) =>
+    this.sdk.query(TokenSparklinesDocument, vars);
+  primeBalance = async (vars: PrimeBalanceQueryVariables) =>
+    this.sdk.query(PrimeBalanceDocument, vars);
+  nftHolders = async (vars: NftHoldersQueryVariables) =>
+    this.sdk.query(NftHoldersDocument, vars);
+  listPairsForToken = async (vars: ListPairsForTokenQueryVariables) =>
+    this.sdk.query(ListPairsForTokenDocument, vars);
+  getDetailedPairStats = async (vars: GetDetailedPairStatsQueryVariables) =>
+    this.sdk.query(GetDetailedPairStatsDocument, vars);
+  filterNftCollections = async (vars: FilterNftCollectionsQueryVariables) =>
+    this.sdk.query(FilterNftCollectionsDocument, vars);
+  getWebhooks = async (vars: GetWebhooksQueryVariables) =>
     this.sdk.query(GetWebhooksDocument, vars);
+  getPrimePoolAssets = async (vars: GetPrimePoolAssetsQueryVariables) =>
+    this.sdk.query(GetPrimePoolAssetsDocument, vars);
+  getNetworkStats = async (vars: GetNetworkStatsQueryVariables) =>
+    this.sdk.query(GetNetworkStatsDocument, vars);
+  apiTokens = async (vars: ApiTokensQueryVariables) =>
+    this.sdk.query(ApiTokensDocument, vars);
+  getNftAssets = async (vars: GetNftAssetsQueryVariables) =>
+    this.sdk.query(GetNftAssetsDocument, vars);
+  getCommunityNotes = async (vars: GetCommunityNotesQueryVariables) =>
+    this.sdk.query(GetCommunityNotesDocument, vars);
+  getNftContracts = async (vars: GetNftContractsQueryVariables) =>
+    this.sdk.query(GetNftContractsDocument, vars);
+  getParallelCardChanges = async (vars: GetParallelCardChangesQueryVariables) =>
+    this.sdk.query(GetParallelCardChangesDocument, vars);
+  pairMetadata = async (vars: PairMetadataQueryVariables) =>
+    this.sdk.query(PairMetadataDocument, vars);
+  listFavoriteTokens = async (vars: ListFavoriteTokensQueryVariables) =>
+    this.sdk.query(ListFavoriteTokensDocument, vars);
+  getNetworkStatus = async (vars: GetNetworkStatusQueryVariables) =>
+    this.sdk.query(GetNetworkStatusDocument, vars);
+  getDetailedNftStats = async (vars: GetDetailedNftStatsQueryVariables) =>
+    this.sdk.query(GetDetailedNftStatsDocument, vars);
+  getTokensInfo = async (vars: GetTokensInfoQueryVariables) =>
+    this.sdk.query(GetTokensInfoDocument, vars);
+  filterNftParallelAssets = async (
+    vars: FilterNftParallelAssetsQueryVariables,
+  ) => this.sdk.query(FilterNftParallelAssetsDocument, vars);
+  listPairsWithMetadataForToken = async (
+    vars: ListPairsWithMetadataForTokenQueryVariables,
+  ) => this.sdk.query(ListPairsWithMetadataForTokenDocument, vars);
+  getTokenPrices = async (vars: GetTokenPricesQueryVariables) =>
+    this.sdk.query(GetTokenPricesDocument, vars);
+  tokenLifecycleEvents = async (vars: TokenLifecycleEventsQueryVariables) =>
+    this.sdk.query(TokenLifecycleEventsDocument, vars);
+  getExchanges = async (vars: GetExchangesQueryVariables) =>
+    this.sdk.query(GetExchangesDocument, vars);
+  getNftPoolEvents = async (vars: GetNftPoolEventsQueryVariables) =>
+    this.sdk.query(GetNftPoolEventsDocument, vars);
+  listTopTokens = async (vars: ListTopTokensQueryVariables) =>
+    this.sdk.query(ListTopTokensDocument, vars);
+  getBars = async (vars: GetBarsQueryVariables) =>
+    this.sdk.query(GetBarsDocument, vars);
 }