@zoralabs/protocol-sdk 0.5.17 → 0.7.0

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

@@ -0,0 +1,247 @@
+import { Address } from "viem";
+import {
+  httpClient as defaultHttpClient,
+  IHttpClient,
+} from "../apis/http-api-base";
+import { NetworkConfig, networkConfigByChain } from "src/apis/chain-constants";
+import { GenericTokenIdTypes } from "src/types";
+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]) {
+    throw new Error(`chain id ${chainId} network not configured `);
+  }
+  return networkConfigByChain[chainId]!;
+};
+
+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;
+
+  constructor(chainId: number, httpClient?: IHttpClient) {
+    this.httpClient = httpClient || defaultHttpClient;
+    this.networkConfig = getApiNetworkConfigForChain(chainId);
+  }
+
+  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,
+    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;
+    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,
+        }),
+      );
+  }
+
+  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,
+  };
+}

package/src/mint/types.ts

@@ -0,0 +1,239 @@
+import { Account, Address } from "viem";
+import {
+  GenericTokenIdTypes,
+  SimulateContractParametersWithAccount,
+} from "src/types";
+
+export type MintParameters<MintType> = {
+  /** Type of the collection to be minted. */
+  mintType: MintType;
+};
+
+export type Erc1155MintParameters = MintParameters<"1155"> & {
+  /** Token id to mint */
+  tokenId: GenericTokenIdTypes;
+};
+
+export type Erc721MintParameters = MintParameters<"721">;
+
+export type OnChainMintParameters =
+  | Erc1155MintParameters
+  | Erc721MintParameters;
+
+export type PremintMintParameters = MintParameters<"premint"> & {
+  /** uid of the Premint to mint */
+  uid: number;
+};
+
+export type MintType = "1155" | "721" | "premint";
+
+export type MintTypes =
+  | Erc1155MintParameters
+  | Erc721MintParameters
+  | PremintMintParameters;
+
+export type GetMintParameters = MintTypes & {
+  /** Address of the contract that the item belongs to */
+  tokenContract: Address;
+  preferredSaleType?: SaleType;
+};
+
+export type GetMintsOfContractParameters = {
+  /** Address of the contract to get the tokens of */
+  tokenContract: Address;
+  preferredSaleType?: SaleType;
+};
+
+export const isOnChainMint = (mint: MintTypes): mint is OnChainMintParameters =>
+  mint.mintType !== "premint";
+
+export const is1155Mint = (mint: MintTypes): mint is Erc1155MintParameters =>
+  mint.mintType === "1155";
+
+export type MintParametersBase = {
+  /** Account to execute the mint */
+  minterAccount: Account | Address;
+  /** Quantity of tokens to mint. Defaults to 1 */
+  quantityToMint: number | bigint;
+  /** Comment to add to the mint */
+  mintComment?: string;
+  /** Address to receive the mint referral reward */
+  mintReferral?: Address;
+  /** Address to receive the minted tokens. Defaults to the minting account */
+  mintRecipient?: Address;
+  /** If this is a premint, the address to get the first minter reward */
+  firstMinter?: Address;
+};
+
+export type MakeMintParametersArgumentsBase = MintParametersBase & {
+  /** Premint contract address */
+  tokenContract: Address;
+};
+
+export type Make1155MintArguments = MakeMintParametersArgumentsBase &
+  Erc1155MintParameters & {
+    preferredSaleType?: SaleType;
+  };
+
+export type Make721MintArguments = MakeMintParametersArgumentsBase &
+  Erc721MintParameters & {
+    preferredSaleType?: SaleType;
+  };
+
+export type MakePremintMintParametersArguments =
+  MakeMintParametersArgumentsBase &
+    PremintMintParameters & {
+      /** Account to receive first minter reward, if this mint brings the premint onchain */
+      firstMinter?: Address;
+    };
+
+export type MakeMintParametersArguments =
+  | Make1155MintArguments
+  | Make721MintArguments
+  | MakePremintMintParametersArguments;
+
+export type GetMintCostsParameters = {
+  /** Address of token contract/collection to get the mint costs for */
+  collection: Address;
+  /** Quantity of tokens that will be minted */
+  quantityMinted: number | bigint;
+} & MintTypes;
+
+export type SaleType = "fixedPrice" | "erc20" | "premint";
+
+type SaleStrategy<T extends SaleType> = {
+  saleType: T;
+  pricePerToken: bigint;
+  maxTokensPerAddress: bigint;
+};
+
+type FixedPriceSaleStrategy = SaleStrategy<"fixedPrice"> & {
+  address: Address;
+  saleStart: string;
+  saleEnd: string;
+};
+
+type ERC20SaleStrategy = SaleStrategy<"erc20"> & {
+  address: Address;
+  saleStart: string;
+  saleEnd: string;
+  currency: Address;
+};
+
+type PremintSaleStrategy = SaleStrategy<"premint"> & {
+  duration: bigint;
+};
+
+export type SaleStrategies =
+  | FixedPriceSaleStrategy
+  | ERC20SaleStrategy
+  | PremintSaleStrategy;
+
+export type OnchainSalesStrategies = FixedPriceSaleStrategy | ERC20SaleStrategy;
+
+export function isErc20SaleStrategy(
+  salesConfig: FixedPriceSaleStrategy | ERC20SaleStrategy | PremintSaleStrategy,
+): salesConfig is ERC20SaleStrategy {
+  return salesConfig.saleType === "erc20";
+}
+
+export type ContractInfo = {
+  /** Address of the contract */
+  address: Address;
+  /** Contract metadata uri */
+  URI: string;
+  /** Contract name */
+  name: string;
+};
+
+export type MintableBase = {
+  /** The contract the mintable belongs to */
+  contract: ContractInfo;
+  /** Token metadata URI */
+  tokenURI: string;
+  /** Price in eth to mint 1 item */
+  mintFeePerQuantity: bigint;
+  /** Creator of the mintable item */
+  creator: Address;
+  /** Maximum total number of items that can be minted */
+  maxSupply: bigint;
+  /** Total number of items minted so far */
+  totalMinted: bigint;
+};
+
+export type OnchainMintable = MintableBase & {
+  mintType: "721" | "1155";
+  tokenId?: bigint;
+  contractVersion: string;
+};
+
+export type PremintMintable = MintableBase & {
+  mintType: "premint";
+  uid: number;
+};
+
+export type OnchainSalesConfigAndTokenInfo = {
+  salesConfig: FixedPriceSaleStrategy | ERC20SaleStrategy;
+} & OnchainMintable;
+
+export type PremintSalesConfigAndTokenInfo = {
+  salesConfig: PremintSaleStrategy;
+} & PremintMintable;
+
+export type SalesConfigAndTokenInfo =
+  | OnchainSalesConfigAndTokenInfo
+  | PremintMintable;
+
+export interface IOnchainMintGetter {
+  getMintable(params: {
+    tokenAddress: Address;
+    tokenId?: GenericTokenIdTypes;
+    preferredSaleType?: SaleType;
+  }): Promise<OnchainSalesConfigAndTokenInfo>;
+
+  getContractMintable(params: {
+    tokenAddress: Address;
+  }): Promise<OnchainSalesConfigAndTokenInfo[]>;
+
+  getContractPremintTokenIds(params: {
+    tokenAddress: Address;
+  }): Promise<{ tokenId: BigInt; uid: number }[]>;
+}
+
+export type MintCosts = {
+  /** The total of the mint fee, in eth */
+  mintFee: bigint;
+  /** If it is a paid or erc20 mint, the total price of the paid or erc20 mint in eth or erc20 value correspondingly. */
+  totalPurchaseCost: bigint;
+  /** If it is an erc20 mint, the erc20 address */
+  totalPurchaseCostCurrency?: Address;
+  /** The total cost in eth (mint fee + purchase cost) to mint */
+  totalCostEth: bigint;
+};
+
+export type Erc20Approval = {
+  /** ERC20 token address that must be approved */
+  erc20: Address;
+  /** Quantity of ERC20 that must be approved */
+  quantity: bigint;
+  /** Address that must be approved to transfer to */
+  approveTo: Address;
+};
+
+export type PrepareMintReturn = {
+  /** Prepared parameters to execute the mint transaction */
+  parameters: SimulateContractParametersWithAccount;
+  /** If an erc20 approval is necessary, information for the erc20 approval */
+  erc20Approval?: Erc20Approval;
+  /** Cost breakdown to mint the quantity of tokens */
+  costs: MintCosts;
+};
+
+export type PrepareMint = (params: MintParametersBase) => PrepareMintReturn;
+
+export type MintableReturn = {
+  /** Token information */
+  token: SalesConfigAndTokenInfo;
+  /** Function that takes a quantity of items to mint and returns a prepared transaction and the costs to mint that quantity */
+  prepareMint: PrepareMint;
+};

package/src/mint/utils.ts

@@ -0,0 +1,14 @@
+import * as semver from "semver";
+export const contractSupportsNewMintFunction = (
+  contractVersion?: string | null,
+) => {
+  if (!contractVersion) {
+    return false;
+  }
+
+  // Try force-convert version format to semver format
+  const semVerContractVersion = semver.coerce(contractVersion)?.raw;
+  if (!semVerContractVersion) return false;
+
+  return semver.gte(semVerContractVersion, "2.9.0");
+};

package/src/mints/mints-contracts.test.ts

@@ -77,7 +77,7 @@ const setupContractUsingPremint = async ({
   contractConfig.contractName = "Testing contract for MINTS";
 
   const contractAddress = await getPremintCollectionAddress({
-    collection: contractConfig,
+    contract: contractConfig,
     publicClient,
   });
 

package/src/mints/mints-contracts.ts

@@ -12,7 +12,7 @@ import {
   PremintConfigV2,
 } from "@zoralabs/protocol-deployments";
 import { ContractCreationConfig } from "src/preminter";
-import { makeSimulateContractParamaters } from "src/utils";
+import { makeContractParameters } from "src/utils";
 import {
   Account,
   Address,
@@ -53,7 +53,7 @@ export const mintWithEthParams = ({
   pricePerMint: bigint;
   account: Address | Account;
 }) =>
-  makeSimulateContractParamaters({
+  makeContractParameters({
     abi: zoraMintsManagerImplConfig.abi,
     address: zoraMintsManagerImplConfig.address[chainId],
     functionName: "mintWithEth",
@@ -152,7 +152,7 @@ export function collectWithMintsParams({
     mintArguments,
   });
 
-  return makeSimulateContractParamaters({
+  return makeContractParameters({
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",
@@ -416,7 +416,7 @@ export function collectPremintV2WithMintsParams({
     ...rest,
   });
 
-  return makeSimulateContractParamaters({
+  return makeContractParameters({
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",