@zoralabs/protocol-sdk 0.6.0 → 0.7.0

package/src/mint/subgraph-mint-getter.ts

@@ -5,39 +5,23 @@ import {
 } from "../apis/http-api-base";
 import { NetworkConfig, networkConfigByChain } from "src/apis/chain-constants";
 import { GenericTokenIdTypes } from "src/types";
-import { IMintGetter, SalesConfigAndTokenInfo, SaleType } from "./types";
-import { NFT_SALE_QUERY } from "src/constants";
-
-type FixedPriceSaleStrategyResult = {
-  address: Address;
-  pricePerToken: string;
-  saleEnd: string;
-  saleStart: string;
-  maxTokensPerAddress: string;
-};
-
-type ERC20SaleStrategyResult = FixedPriceSaleStrategyResult & {
-  currency: Address;
-};
-
-type SalesStrategyResult =
-  | {
-      type: "FIXED_PRICE";
-      fixedPrice: FixedPriceSaleStrategyResult;
-    }
-  | {
-      type: "ERC_20_MINTER";
-      erc20Minter: ERC20SaleStrategyResult;
-    };
-
-type TokenQueryResult = {
-  tokenId?: string;
-  salesStrategies?: SalesStrategyResult[];
-  contract: {
-    mintFeePerQuantity: "string";
-    salesStrategies: SalesStrategyResult[];
-  };
-};
+import {
+  IOnchainMintGetter,
+  SaleType,
+  OnchainMintable,
+  OnchainSalesConfigAndTokenInfo,
+  OnchainSalesStrategies,
+  isErc20SaleStrategy,
+} from "./types";
+import { querySubgraphWithRetries } from "src/utils";
+import {
+  buildContractTokensQuery,
+  buildNftTokenSalesQuery,
+  buildPremintsOfContractQuery,
+  ISubgraphQuery,
+  SalesStrategyResult,
+  TokenQueryResult,
+} from "./subgraph-queries";
 
 export const getApiNetworkConfigForChain = (chainId: number): NetworkConfig => {
   if (!networkConfigByChain[chainId]) {
@@ -46,7 +30,83 @@ export const getApiNetworkConfigForChain = (chainId: number): NetworkConfig => {
   return networkConfigByChain[chainId]!;
 };
 
-export class SubgraphMintGetter implements IMintGetter {
+function parseSalesConfig(
+  targetStrategy: SalesStrategyResult,
+): OnchainSalesStrategies {
+  if (targetStrategy.type === "FIXED_PRICE")
+    return {
+      saleType: "fixedPrice",
+      ...targetStrategy.fixedPrice,
+      maxTokensPerAddress: BigInt(
+        targetStrategy.fixedPrice.maxTokensPerAddress,
+      ),
+      pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken),
+    };
+
+  if (targetStrategy.type === "ERC_20_MINTER") {
+    return {
+      saleType: "erc20",
+      ...targetStrategy.erc20Minter,
+      maxTokensPerAddress: BigInt(
+        targetStrategy.erc20Minter.maxTokensPerAddress,
+      ),
+      pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken),
+    };
+  }
+
+  throw new Error("Unknown saleType");
+}
+
+function getSaleEnd(a: SalesStrategyResult) {
+  return BigInt(
+    a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd,
+  );
+}
+
+function getTargetStrategy({
+  tokenId,
+  preferredSaleType,
+  token,
+}: {
+  tokenId?: GenericTokenIdTypes;
+  preferredSaleType?: SaleType;
+  token: TokenQueryResult;
+}) {
+  const allStrategies =
+    (typeof tokenId !== "undefined"
+      ? token.salesStrategies
+      : token.contract.salesStrategies) || [];
+
+  const saleStrategies = allStrategies.sort((a, b) =>
+    getSaleEnd(a) > getSaleEnd(b) ? 1 : -1,
+  );
+
+  let targetStrategy: SalesStrategyResult | undefined;
+
+  if (!preferredSaleType) {
+    targetStrategy = saleStrategies[0];
+    if (!targetStrategy) {
+      throw new Error("Cannot find sale strategy");
+    }
+  } else {
+    const mappedSaleType =
+      preferredSaleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
+    targetStrategy = saleStrategies.find(
+      (strategy: SalesStrategyResult) => strategy.type === mappedSaleType,
+    );
+    if (!targetStrategy) {
+      const targetStrategy = saleStrategies.find(
+        (strategy: SalesStrategyResult) =>
+          strategy.type === "FIXED_PRICE" || strategy.type === "ERC_20_MINTER",
+      );
+      if (!targetStrategy) throw new Error("Cannot find valid sale strategy");
+      return targetStrategy;
+    }
+  }
+
+  return targetStrategy;
+}
+export class SubgraphMintGetter implements IOnchainMintGetter {
   httpClient: IHttpClient;
   networkConfig: NetworkConfig;
 
@@ -55,100 +115,133 @@ export class SubgraphMintGetter implements IMintGetter {
     this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
 
-  async getSalesConfigAndTokenInfo({
+  async querySubgraphWithRetries<T>({
+    query,
+    variables,
+    parseResponseData,
+  }: ISubgraphQuery<T>) {
+    const responseData = await querySubgraphWithRetries({
+      httpClient: this.httpClient,
+      subgraphUrl: this.networkConfig.subgraphUrl,
+      query,
+      variables,
+    });
+
+    return parseResponseData(responseData);
+  }
+
+  getMintable: IOnchainMintGetter["getMintable"] = async ({
     tokenAddress,
     tokenId,
-    saleType,
+    preferredSaleType: saleType,
+  }) => {
+    const token = await this.querySubgraphWithRetries(
+      buildNftTokenSalesQuery({
+        tokenId,
+        tokenAddress,
+      }),
+    );
+
+    if (!token) {
+      throw new Error("Cannot find token");
+    }
+
+    return parseTokenQueryResult({
+      token,
+      tokenId,
+      preferredSaleType: saleType,
+    });
+  };
+
+  async getContractMintable({
+    tokenAddress,
+    preferredSaleType,
   }: {
     tokenAddress: Address;
-    tokenId?: GenericTokenIdTypes;
-    saleType?: SaleType;
-  }): Promise<SalesConfigAndTokenInfo> {
-    const { retries, post } = this.httpClient;
-    return retries(async () => {
-      const response = await post<any>(this.networkConfig.subgraphUrl, {
-        query: NFT_SALE_QUERY,
-        variables: {
-          id:
-            tokenId !== undefined
-              ? // Generic Token ID types all stringify down to the base numeric equivalent.
-                `${tokenAddress.toLowerCase()}-${tokenId}`
-              : `${tokenAddress.toLowerCase()}-0`,
-        },
-      });
-
-      const token = response.data?.zoraCreateToken as TokenQueryResult;
-
-      if (!token) {
-        throw new Error("Cannot find a token to mint");
-      }
-
-      const allStrategies =
-        (typeof tokenId !== "undefined"
-          ? token.salesStrategies
-          : token.contract.salesStrategies) || [];
-
-      const saleStrategies = allStrategies.sort((a, b) =>
-        BigInt(
-          a.type === "ERC_20_MINTER"
-            ? a.erc20Minter.saleEnd
-            : a.fixedPrice.saleEnd,
-        ) >
-        BigInt(
-          b.type === "FIXED_PRICE"
-            ? b.fixedPrice.saleEnd
-            : b.erc20Minter.saleEnd,
-        )
-          ? 1
-          : -1,
+    preferredSaleType?: SaleType;
+  }) {
+    const tokens = await this.querySubgraphWithRetries(
+      buildContractTokensQuery({
+        tokenAddress,
+      }),
+    );
+
+    if (!tokens) return [];
+
+    return tokens
+      .filter((x) => x.tokenId !== "0")
+      .map((token) =>
+        parseTokenQueryResult({
+          token,
+          tokenId: token.tokenId,
+          preferredSaleType,
+        }),
       );
+  }
 
-      let targetStrategy: SalesStrategyResult | undefined;
-
-      if (!saleType) {
-        targetStrategy = saleStrategies[0];
-        if (!targetStrategy) {
-          throw new Error("Cannot find sale strategy");
-        }
-      } else {
-        const mappedSaleType =
-          saleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
-        targetStrategy = saleStrategies.find(
-          (strategy: SalesStrategyResult) => strategy.type === mappedSaleType,
-        );
-        if (!targetStrategy) {
-          throw new Error(`Cannot find sale strategy for ${mappedSaleType}`);
-        }
-      }
-
-      if (targetStrategy.type === "FIXED_PRICE") {
-        return {
-          salesConfig: {
-            saleType: "fixedPrice",
-            ...targetStrategy.fixedPrice,
-            maxTokensPerAddress: BigInt(
-              targetStrategy.fixedPrice.maxTokensPerAddress,
-            ),
-            pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken),
-          },
-          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity),
-        };
-      }
-      if (targetStrategy.type === "ERC_20_MINTER") {
-        return {
-          salesConfig: {
-            saleType: "erc20",
-            ...targetStrategy.erc20Minter,
-            maxTokensPerAddress: BigInt(
-              targetStrategy.erc20Minter.maxTokensPerAddress,
-            ),
-            pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken),
-          },
-          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity),
-        };
-      }
-
-      throw new Error("Invalid saleType");
-    });
+  async getContractPremintTokenIds({
+    tokenAddress,
+  }: {
+    tokenAddress: Address;
+  }) {
+    const premints = await this.querySubgraphWithRetries(
+      buildPremintsOfContractQuery({
+        tokenAddress,
+      }),
+    );
+
+    return (
+      premints?.map((premint) => ({
+        tokenId: BigInt(premint.tokenId),
+        uid: +premint.uid,
+      })) || []
+    );
   }
 }
+
+function parseTokenQueryResult({
+  token,
+  tokenId,
+  preferredSaleType,
+}: {
+  token: TokenQueryResult;
+  tokenId?: GenericTokenIdTypes;
+  preferredSaleType?: SaleType;
+}): OnchainSalesConfigAndTokenInfo {
+  const targetStrategy = getTargetStrategy({
+    tokenId,
+    preferredSaleType: preferredSaleType,
+    token,
+  });
+
+  const tokenInfo = parseTokenInfo(token);
+
+  const salesConfig = parseSalesConfig(targetStrategy);
+
+  if (isErc20SaleStrategy(salesConfig)) {
+    tokenInfo.mintFeePerQuantity = 0n;
+  }
+
+  return {
+    ...tokenInfo,
+    salesConfig,
+  };
+}
+
+function parseTokenInfo(token: TokenQueryResult): OnchainMintable {
+  return {
+    contract: {
+      address: token.contract.address,
+      name: token.contract.name,
+      URI: token.contract.contractURI,
+    },
+    tokenURI: token.uri,
+    tokenId: token.tokenId ? BigInt(token.tokenId) : undefined,
+    mintType: token.tokenStandard === "ERC721" ? "721" : "1155",
+    creator: token.creator,
+    totalMinted: BigInt(token.totalMinted),
+    maxSupply: BigInt(token.maxSupply),
+    mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity),
+    contractVersion: token.contract.contractVersion,
+  };
+}

package/src/mint/subgraph-queries.ts

@@ -0,0 +1,170 @@
+import { GenericTokenIdTypes } from "src/types";
+import { Address } from "viem";
+
+export type FixedPriceSaleStrategyResult = {
+  address: Address;
+  pricePerToken: string;
+  saleEnd: string;
+  saleStart: string;
+  maxTokensPerAddress: string;
+};
+
+export type ERC20SaleStrategyResult = FixedPriceSaleStrategyResult & {
+  currency: Address;
+};
+
+export type SalesStrategyResult =
+  | {
+      type: "FIXED_PRICE";
+      fixedPrice: FixedPriceSaleStrategyResult;
+    }
+  | {
+      type: "ERC_20_MINTER";
+      erc20Minter: ERC20SaleStrategyResult;
+    };
+
+export type TokenQueryResult = {
+  tokenId?: string;
+  creator: Address;
+  uri: string;
+  totalMinted: string;
+  maxSupply: string;
+  salesStrategies?: SalesStrategyResult[];
+  tokenStandard: "ERC1155" | "ERC721";
+  contract: {
+    mintFeePerQuantity: "string";
+    salesStrategies: SalesStrategyResult[];
+    address: Address;
+    contractVersion: string;
+    contractURI: string;
+    name: string;
+  };
+};
+
+const NFT_SALE_STRATEGY_FRAGMENT = `
+fragment SaleStrategy on SalesStrategyConfig {
+  type
+  fixedPrice {
+    address
+    pricePerToken
+    saleEnd
+    saleStart
+    maxTokensPerAddress
+  }
+  erc20Minter {
+    address
+    pricePerToken
+    currency
+    saleEnd
+    saleStart
+    maxTokensPerAddress
+  }
+}`;
+
+const TOKEN_FRAGMENT = `
+fragment Token on ZoraCreateToken {
+    creator
+    tokenId
+    uri
+    totalMinted
+    maxSupply
+    tokenStandard
+    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+      ...SaleStrategy
+    }
+    contract {
+      address
+      mintFeePerQuantity
+      contractVersion
+      contractURI
+      name
+      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+        ...SaleStrategy
+      }
+    }
+}`;
+
+const FRAGMENTS = `
+${NFT_SALE_STRATEGY_FRAGMENT}
+${TOKEN_FRAGMENT}
+`;
+
+export function buildNftTokenSalesQuery({
+  tokenId,
+  tokenAddress,
+}: {
+  tokenId?: GenericTokenIdTypes;
+  tokenAddress: Address;
+}): ISubgraphQuery<TokenQueryResult> {
+  return {
+    query: `
+${FRAGMENTS}
+query ($id: ID!) {
+  zoraCreateToken(id: $id) {
+    ...Token 
+  }
+}
+`,
+    variables: {
+      id:
+        tokenId !== undefined
+          ? // Generic Token ID types all stringify down to the base numeric equivalent.
+            `${tokenAddress.toLowerCase()}-${tokenId}`
+          : `${tokenAddress.toLowerCase()}-0`,
+    },
+    parseResponseData: (responseData: any | undefined) =>
+      responseData?.zoraCreateToken,
+  };
+}
+
+export function buildContractTokensQuery({
+  tokenAddress,
+}: {
+  tokenAddress: Address;
+}): ISubgraphQuery<TokenQueryResult[]> {
+  return {
+    query: `
+${FRAGMENTS}
+query ($contract: Bytes!) {
+  zoraCreateTokens(
+     where: {address: $contract}
+  ) {
+     ...Token
+  }
+}
+`,
+    variables: {
+      contract: tokenAddress.toLowerCase(),
+    },
+    parseResponseData: (responseData: any | undefined) =>
+      responseData?.zoraCreateTokens,
+  };
+}
+
+export type ISubgraphQuery<T> = {
+  query: string;
+  variables: Record<string, any>;
+  parseResponseData: (data: any | undefined) => T | undefined;
+};
+
+export function buildPremintsOfContractQuery({
+  tokenAddress,
+}: {
+  tokenAddress: Address;
+}): ISubgraphQuery<{ uid: string; tokenId: string }[]> {
+  return {
+    query: `
+      query ($contractAddress: Bytes!) {
+        premints(where:{contractAddress:$contractAddress}) {
+          uid
+          tokenId
+        }
+      }
+    `,
+    variables: {
+      contractAddress: tokenAddress.toLowerCase(),
+    },
+    parseResponseData: (responseData: any | undefined) =>
+      responseData?.premints,
+  };
+}