@zoralabs/protocol-sdk 0.9.0 → 0.9.2

package/src/create/contract-setup.ts

@@ -18,52 +18,6 @@ export function new1155ContractVersion(chainId: number): string {
   return address.CONTRACT_1155_IMPL_VERSION;
 }
 
-export async function getContractInfoExistingContract({
-  publicClient,
-  contractAddress,
-}: {
-  publicClient: Pick<PublicClient, "readContract">;
-  contractAddress: Address;
-  // Account that is the creator of the contract
-}): Promise<{
-  contractVersion: string;
-  contractName: string;
-  nextTokenId: bigint;
-}> {
-  // Check if contract exists either from metadata or the static address passed in.
-  // If a static address is passed in, this fails if that contract does not exist.
-  let contractVersion: string;
-  try {
-    contractVersion = await publicClient.readContract({
-      abi: zoraCreator1155ImplABI,
-      address: contractAddress,
-      functionName: "contractVersion",
-    });
-  } catch (e: any) {
-    // This logic branch is hit if the contract doesn't exist
-    //  falling back to contractExists to false.
-    throw new Error(`Contract does not exist at ${contractAddress}`);
-  }
-
-  const nextTokenId = await publicClient.readContract({
-    address: contractAddress,
-    abi: zoraCreator1155ImplABI,
-    functionName: "nextTokenId",
-  });
-
-  const contractName = await publicClient.readContract({
-    address: contractAddress,
-    abi: zoraCreator1155ImplABI,
-    functionName: "name",
-  });
-
-  return {
-    contractVersion,
-    contractName,
-    nextTokenId,
-  };
-}
-
 export async function getDeterministicContractAddress({
   publicClient,
   account,
@@ -96,3 +50,20 @@ export async function getDeterministicContractAddress({
 
   return contractAddress;
 }
+
+export async function getNewContractMintFee({
+  publicClient,
+  chainId,
+}: {
+  publicClient: Pick<PublicClient, "readContract">;
+  chainId: number;
+}) {
+  const implAddress = contracts1155.addresses[chainId as contracts1155Address]
+    .CONTRACT_1155_IMPL as Address;
+
+  return await publicClient.readContract({
+    abi: zoraCreator1155ImplABI,
+    address: implAddress,
+    functionName: "mintFee",
+  });
+}

package/src/create/mint-from-create.ts

@@ -0,0 +1,111 @@
+import { Address, parseEther, zeroAddress } from "viem";
+import { ConcreteSalesConfig } from "./types";
+import {
+  AsyncPrepareMint,
+  MintParametersBase,
+  OnchainSalesStrategies,
+  PrepareMintReturn,
+} from "src/mint/types";
+import {
+  makePrepareMint1155TokenParams,
+  parseMintCosts,
+} from "src/mint/mint-transactions";
+import { getRequiredErc20Approvals } from "src/mint/mint-queries";
+
+async function toSalesStrategyFromSubgraph({
+  minter,
+  salesConfig,
+  getContractMintFee,
+}: {
+  minter: Address;
+  salesConfig: ConcreteSalesConfig;
+  getContractMintFee: () => Promise<bigint>;
+}): Promise<OnchainSalesStrategies> {
+  if (salesConfig.type === "timed") {
+    return {
+      saleType: "timed",
+      address: minter,
+      // for now we hardcode this
+      mintFeePerQuantity: parseEther("0.000111"),
+      saleStart: salesConfig.saleStart.toString(),
+      saleEnd: salesConfig.saleEnd.toString(),
+      // the following are not needed for now but we wanna satisfy concrete
+      erc20Z: zeroAddress,
+      mintFee: 0n,
+      pool: zeroAddress,
+      secondaryActivated: false,
+    };
+  }
+  if (salesConfig.type === "erc20Mint") {
+    return {
+      saleType: "erc20",
+      address: minter,
+      mintFeePerQuantity: 0n,
+      saleStart: salesConfig.saleStart.toString(),
+      saleEnd: salesConfig.saleEnd.toString(),
+      currency: salesConfig.currency,
+      pricePerToken: salesConfig.pricePerToken,
+      maxTokensPerAddress: salesConfig.maxTokensPerAddress,
+    };
+  }
+  const contractMintFee = await getContractMintFee();
+  if (salesConfig.type === "fixedPrice") {
+    return {
+      saleType: "fixedPrice",
+      address: minter,
+      maxTokensPerAddress: salesConfig.maxTokensPerAddress,
+      mintFeePerQuantity: contractMintFee,
+      pricePerToken: salesConfig.pricePerToken,
+      saleStart: salesConfig.saleStart.toString(),
+      saleEnd: salesConfig.saleEnd.toString(),
+    };
+  }
+  return {
+    saleType: "allowlist",
+    address: minter,
+    saleStart: salesConfig.saleStart.toString(),
+    saleEnd: salesConfig.saleEnd.toString(),
+    merkleRoot: salesConfig.presaleMerkleRoot,
+    mintFeePerQuantity: contractMintFee,
+  };
+}
+export function makeOnchainPrepareMintFromCreate({
+  contractAddress,
+  tokenId,
+  result,
+  minter,
+  getContractMintFee,
+  contractVersion,
+}: {
+  contractAddress: Address;
+  tokenId: bigint;
+  result: ConcreteSalesConfig;
+  minter: Address;
+  getContractMintFee: () => Promise<bigint>;
+  contractVersion: string;
+}): AsyncPrepareMint {
+  return async (params: MintParametersBase): Promise<PrepareMintReturn> => {
+    const subgraphSalesConfig = await toSalesStrategyFromSubgraph({
+      minter,
+      getContractMintFee,
+      salesConfig: result,
+    });
+    return {
+      parameters: makePrepareMint1155TokenParams({
+        salesConfigAndTokenInfo: {
+          salesConfig: subgraphSalesConfig,
+          contractVersion,
+        },
+        ...params,
+        tokenContract: contractAddress,
+        tokenId,
+      }),
+      costs: parseMintCosts({
+        allowListEntry: params.allowListEntry,
+        quantityToMint: BigInt(params.quantityToMint),
+        salesConfig: subgraphSalesConfig,
+      }),
+      erc20Approval: getRequiredErc20Approvals(params, subgraphSalesConfig),
+    };
+  };
+}

package/src/create/subgraph-queries.ts

@@ -0,0 +1,35 @@
+import { ISubgraphQuery } from "src/apis/subgraph-querier";
+import { Address } from "viem";
+
+export function buildContractInfoQuery({
+  contractAddress,
+}: {
+  contractAddress: Address;
+}): ISubgraphQuery<{
+  name: string;
+  contractVersion: string;
+  mintFeePerQuantity: string;
+  tokens: {
+    tokenId: Address;
+  }[];
+}> {
+  return {
+    query: `
+    query ($contractAddress: Bytes!) {
+      zoraCreateContract(id: $contractAddress) {
+        contractVersion
+        name
+        mintFeePerQuantity
+        tokens(first: 1, orderBy: tokenId, orderDirection: desc) {
+          tokenId
+        }
+      }
+    }
+    `,
+    variables: {
+      contractAddress: contractAddress.toLowerCase(),
+    },
+    parseResponseData: (responseData: any | undefined) =>
+      responseData.zoraCreateContract,
+  };
+}

package/src/create/types.ts

@@ -1,3 +1,4 @@
+import { AsyncPrepareMint } from "src/mint/types";
 import { Concrete } from "src/utils";
 import { Account, Address, Hex, SimulateContractParameters } from "viem";
 
@@ -119,6 +120,7 @@ export type CreateNew1155TokenReturn = {
   newToken: New1155Token;
   minter: Address;
   contractVersion: string;
+  prepareMint: AsyncPrepareMint;
 };
 
 export type CreateNew1155ContractAndTokenReturn = {

package/src/mint/mint-queries.ts

@@ -261,7 +261,7 @@ function parsePremint({
   throw new Error("Invalid premint config version");
 }
 
-const makeOnchainPrepareMint =
+export const makeOnchainPrepareMint =
   (result: OnchainSalesConfigAndTokenInfo): PrepareMint =>
   (params: MintParametersBase) => {
     if (!result.salesConfig) {
@@ -273,7 +273,7 @@ const makeOnchainPrepareMint =
         token: result as Concrete<OnchainSalesConfigAndTokenInfo>,
         mintParams: params,
       }),
-      erc20Approval: getRequiredErc20Approvals(params, result),
+      erc20Approval: getRequiredErc20Approvals(params, result.salesConfig),
       costs: parseMintCosts({
         salesConfig: result.salesConfig,
         quantityToMint: BigInt(params.quantityToMint),
@@ -327,15 +327,15 @@ function toPremintMintReturn({
     prepareMint: makePremintPrepareMint(mintable, mintFee, premint),
   };
 }
-function getRequiredErc20Approvals(
+export function getRequiredErc20Approvals(
   params: MintParametersBase,
-  result: OnchainSalesConfigAndTokenInfo,
+  salesConfig: OnchainSalesConfigAndTokenInfo["salesConfig"],
 ): Erc20Approval | undefined {
-  if (result.salesConfig?.saleType !== "erc20") return undefined;
+  if (salesConfig?.saleType !== "erc20") return undefined;
 
   return {
-    quantity: result.salesConfig.pricePerToken * BigInt(params.quantityToMint),
-    approveTo: result.salesConfig.address,
-    erc20: result.salesConfig.currency,
+    quantity: salesConfig.pricePerToken * BigInt(params.quantityToMint),
+    approveTo: salesConfig.address,
+    erc20: salesConfig.currency,
   };
 }

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

@@ -1,6 +1,10 @@
 import { Address } from "viem";
 import { httpClient as defaultHttpClient } from "../apis/http-api-base";
-import { ISubgraphQuerier, SubgraphQuerier } from "../apis/subgraph-querier";
+import {
+  ISubgraphQuerier,
+  ISubgraphQuery,
+  SubgraphQuerier,
+} from "../apis/subgraph-querier";
 import { NetworkConfig, networkConfigByChain } from "src/apis/chain-constants";
 import { GenericTokenIdTypes } from "src/types";
 import {
@@ -14,7 +18,6 @@ import {
   buildContractTokensQuery,
   buildNftTokenSalesQuery,
   buildPremintsOfContractQuery,
-  ISubgraphQuery,
   SalesStrategyResult,
   TokenQueryResult,
 } from "./subgraph-queries";

package/src/mint/subgraph-queries.ts

@@ -1,3 +1,4 @@
+import { ISubgraphQuery } from "src/apis/subgraph-querier";
 import { GenericTokenIdTypes } from "src/types";
 import { Address } from "viem";
 
@@ -189,13 +190,6 @@ query ($contract: Bytes!) {
       responseData?.zoraCreateTokens,
   };
 }
-
-export type ISubgraphQuery<T> = {
-  query: string;
-  variables: Record<string, any>;
-  parseResponseData: (data: any | undefined) => T | undefined;
-};
-
 export function buildPremintsOfContractQuery({
   tokenAddress,
 }: {

package/src/mint/types.ts

@@ -269,6 +269,9 @@ export type PrepareMintReturn = {
 };
 
 export type PrepareMint = (params: MintParametersBase) => PrepareMintReturn;
+export type AsyncPrepareMint = (
+  params: MintParametersBase,
+) => Promise<PrepareMintReturn>;
 
 export type MintableReturn = {
   /** Token information */

package/src/retries.ts

@@ -0,0 +1,49 @@
+async function wait(delayMs: number) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+}
+
+const retryInternal = async <T>({
+  tryFn,
+  maxTries = 3,
+  atTry,
+  linearBackoffMS = 200,
+  shouldRetryOnError = () => true,
+}: {
+  tryFn: () => T;
+  maxTries?: number;
+  atTry: number;
+  linearBackoffMS?: number;
+  shouldRetryOnError?: (err: any) => boolean;
+}): Promise<T> => {
+  try {
+    return await tryFn();
+  } catch (err: any) {
+    if (shouldRetryOnError(err)) {
+      if (atTry <= maxTries) {
+        await wait(atTry * linearBackoffMS);
+        return await retryInternal({
+          tryFn,
+          maxTries,
+          atTry: atTry + 1,
+          linearBackoffMS,
+          shouldRetryOnError,
+        });
+      }
+    }
+    throw err;
+  }
+};
+
+export const retriesGeneric = async <T>(params: {
+  tryFn: () => T;
+  maxTries?: number;
+  linearBackoffMS?: number;
+  shouldRetryOnError?: (err: any) => boolean;
+}) => {
+  return retryInternal({
+    ...params,
+    atTry: 1,
+  });
+};

package/src/sdk.ts

@@ -8,6 +8,10 @@ import { ClientConfig } from "./utils";
 import { IPremintAPI, PremintAPIClient } from "./premint/premint-api-client";
 import { SubgraphMintGetter } from "./mint/subgraph-mint-getter";
 import { IOnchainMintGetter } from "./mint/types";
+import {
+  IContractGetter,
+  SubgraphContractGetter,
+} from "./create/contract-getter";
 
 export type CreatorClient = {
   createPremint: PremintClient["createPremint"];
@@ -29,6 +33,7 @@ export type CollectorClient = {
 export type CreatorClientConfig = ClientConfig & {
   /** API for submitting and getting premints.  Defaults to the Zora Premint API */
   premintApi?: IPremintAPI;
+  contractGetter?: IContractGetter;
 };
 
 /**
@@ -50,6 +55,9 @@ export function createCreatorClient(
   const create1155CreatorClient = new Create1155Client({
     chainId: clientConfig.chainId,
     publicClient: clientConfig.publicClient,
+    contractGetter:
+      clientConfig.contractGetter ||
+      new SubgraphContractGetter(clientConfig.chainId),
   });
 
   return {

package/test-integration/create-multiple-tokens-on-contract.ts

@@ -0,0 +1,104 @@
+import { createCreatorClient } from "src";
+import {
+  Address,
+  Chain,
+  LocalAccount,
+  createPublicClient,
+  createWalletClient,
+  http,
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { zoraSepolia } from "viem/chains";
+
+const publicClient = createPublicClient({
+  chain: zoraSepolia as Chain,
+  transport: http(),
+});
+
+const walletClient = createWalletClient({
+  chain: zoraSepolia,
+  transport: http(),
+});
+
+const creatorClient = createCreatorClient({
+  chainId: zoraSepolia.id,
+  publicClient,
+});
+
+export const createMultipleTokensOnContract = async ({
+  creatorAccount,
+}: {
+  creatorAccount: LocalAccount;
+}) => {
+  console.log({ address: creatorAccount.address });
+  const { contractAddress, parameters } = await creatorClient.create1155({
+    account: creatorAccount.address,
+    contract: {
+      name: "testContractD",
+      uri: "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+    },
+    token: {
+      tokenMetadataURI:
+        "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+    },
+  });
+  console.log("creating contract and token");
+
+  const { request: requestA } = await publicClient.simulateContract(parameters);
+
+  const hashA = await walletClient.writeContract({
+    ...requestA,
+    account: creatorAccount,
+  });
+
+  const receiptA = await publicClient.waitForTransactionReceipt({
+    hash: hashA,
+  });
+
+  if (receiptA.status !== "success") {
+    throw new Error("create new contract failed");
+  }
+
+  console.log("creating new token on contract");
+
+  const { parameters: parametersB } =
+    await creatorClient.create1155OnExistingContract({
+      account: creatorAccount.address,
+      contractAddress,
+      token: {
+        tokenMetadataURI:
+          "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+      },
+    });
+
+  const { request: requestB } =
+    await publicClient.simulateContract(parametersB);
+
+  const hashB = await walletClient.writeContract({
+    ...requestB,
+    account: creatorAccount,
+  });
+
+  const receiptB = await publicClient.waitForTransactionReceipt({
+    hash: hashB,
+  });
+
+  if (receiptB.status !== "success") {
+    throw new Error("create token on contract failed");
+  }
+
+  console.log("created multiple tokens on contract");
+};
+
+const setupTestContracts = async () => {
+  const creatorAccount = privateKeyToAccount(
+    process.env.VITE_PRIVATE_KEY! as Address,
+  );
+
+  // create 2 premints on a contract
+  await createMultipleTokensOnContract({
+    creatorAccount,
+  });
+};
+
+setupTestContracts();