@zoralabs/protocol-sdk 0.9.1 → 0.9.2

package/dist/index.js

@@ -2503,6 +2503,44 @@ import {
   premintTypedDataDefinition as premintTypedDataDefinition2
 } from "@zoralabs/protocol-deployments";
 
+// src/retries.ts
+async function wait(delayMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+}
+var retryInternal = async ({
+  tryFn,
+  maxTries = 3,
+  atTry,
+  linearBackoffMS = 200,
+  shouldRetryOnError = () => true
+}) => {
+  try {
+    return await tryFn();
+  } catch (err) {
+    if (shouldRetryOnError(err)) {
+      if (atTry <= maxTries) {
+        await wait(atTry * linearBackoffMS);
+        return await retryInternal({
+          tryFn,
+          maxTries,
+          atTry: atTry + 1,
+          linearBackoffMS,
+          shouldRetryOnError
+        });
+      }
+    }
+    throw err;
+  }
+};
+var retriesGeneric = async (params) => {
+  return retryInternal({
+    ...params,
+    atTry: 1
+  });
+};
+
 // src/apis/http-api-base.ts
 var BadResponseError = class extends Error {
   constructor(message, status, json) {
@@ -2512,11 +2550,6 @@ var BadResponseError = class extends Error {
     this.json = json;
   }
 };
-async function wait(delayMs) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, delayMs);
-  });
-}
 var get = async (url) => {
   const response = await fetch(url, { method: "GET" });
   if (response.status !== 200) {
@@ -2562,20 +2595,16 @@ var post = async (url, data) => {
   }
   return await response.json();
 };
-var retries = async (tryFn, maxTries = 3, atTry = 1, linearBackoffMS = 200) => {
-  try {
-    return await tryFn();
-  } catch (err) {
-    if (err instanceof BadResponseError) {
-      if (err.status >= 500) {
-        if (atTry <= maxTries) {
-          await wait(atTry * linearBackoffMS);
-          return await retries(tryFn, maxTries, atTry + 1);
-        }
-      }
-    }
-    throw err;
-  }
+var retries = async (tryFn, maxTries = 3, linearBackoffMS = 200) => {
+  const shouldRetry = (err) => {
+    return err instanceof BadResponseError && err.status >= 500;
+  };
+  return retriesGeneric({
+    tryFn,
+    maxTries,
+    linearBackoffMS,
+    shouldRetryOnError: shouldRetry
+  });
 };
 var httpClient = {
   get,
@@ -4212,7 +4241,7 @@ async function mint({
 import {
   zoraCreator1155FactoryImplABI as zoraCreator1155FactoryImplABI2,
   zoraCreator1155FactoryImplAddress as zoraCreator1155FactoryImplAddress2,
-  zoraCreator1155ImplABI as zoraCreator1155ImplABI7
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI6
 } from "@zoralabs/protocol-deployments";
 import { decodeEventLog as decodeEventLog2 } from "viem";
 
@@ -4230,36 +4259,6 @@ function new1155ContractVersion(chainId) {
   }
   return address.CONTRACT_1155_IMPL_VERSION;
 }
-async function getContractInfoExistingContract({
-  publicClient,
-  contractAddress
-}) {
-  let contractVersion;
-  try {
-    contractVersion = await publicClient.readContract({
-      abi: zoraCreator1155ImplABI3,
-      address: contractAddress,
-      functionName: "contractVersion"
-    });
-  } catch (e) {
-    throw new Error(`Contract does not exist at ${contractAddress}`);
-  }
-  const nextTokenId = await publicClient.readContract({
-    address: contractAddress,
-    abi: zoraCreator1155ImplABI3,
-    functionName: "nextTokenId"
-  });
-  const contractName = await publicClient.readContract({
-    address: contractAddress,
-    abi: zoraCreator1155ImplABI3,
-    functionName: "name"
-  });
-  return {
-    contractVersion,
-    contractName,
-    nextTokenId
-  };
-}
 async function getDeterministicContractAddress({
   publicClient,
   account,
@@ -4281,6 +4280,17 @@ async function getDeterministicContractAddress({
   });
   return contractAddress;
 }
+async function getNewContractMintFee({
+  publicClient,
+  chainId
+}) {
+  const implAddress = contracts1155.addresses[chainId].CONTRACT_1155_IMPL;
+  return await publicClient.readContract({
+    abi: zoraCreator1155ImplABI3,
+    address: implAddress,
+    functionName: "mintFee"
+  });
+}
 
 // src/create/token-setup.ts
 var semver2 = __toESM(require_semver2(), 1);
@@ -5816,12 +5826,10 @@ var contractSupportsMintRewards = (contractVersion, contractStandard) => {
 
 // src/create/mint-from-create.ts
 import { parseEther as parseEther3, zeroAddress as zeroAddress6 } from "viem";
-import { zoraCreator1155ImplABI as zoraCreator1155ImplABI6 } from "@zoralabs/protocol-deployments";
 async function toSalesStrategyFromSubgraph({
   minter,
   salesConfig,
-  publicClient,
-  contractAddress
+  getContractMintFee
 }) {
   if (salesConfig.type === "timed") {
     return {
@@ -5850,11 +5858,7 @@ async function toSalesStrategyFromSubgraph({
       maxTokensPerAddress: salesConfig.maxTokensPerAddress
     };
   }
-  const contractMintFee = await publicClient.readContract({
-    abi: zoraCreator1155ImplABI6,
-    address: contractAddress,
-    functionName: "mintFee"
-  });
+  const contractMintFee = await getContractMintFee();
   if (salesConfig.type === "fixedPrice") {
     return {
       saleType: "fixedPrice",
@@ -5880,14 +5884,13 @@ function makeOnchainPrepareMintFromCreate({
   tokenId,
   result,
   minter,
-  publicClient,
+  getContractMintFee,
   contractVersion
 }) {
   return async (params) => {
     const subgraphSalesConfig = await toSalesStrategyFromSubgraph({
       minter,
-      contractAddress,
-      publicClient,
+      getContractMintFee,
       salesConfig: result
     });
     return {
@@ -5916,7 +5919,7 @@ var getTokenIdFromCreateReceipt = (receipt) => {
   for (const data of receipt.logs) {
     try {
       const decodedLog = decodeEventLog2({
-        abi: zoraCreator1155ImplABI7,
+        abi: zoraCreator1155ImplABI6,
         eventName: "SetupNewToken",
         ...data
       });
@@ -5982,7 +5985,7 @@ function makeCreateTokenCall({
   tokenSetupActions
 }) {
   return makeContractParameters({
-    abi: zoraCreator1155ImplABI7,
+    abi: zoraCreator1155ImplABI6,
     functionName: "multicall",
     account,
     address: contractAddress,
@@ -5992,10 +5995,12 @@ function makeCreateTokenCall({
 var Create1155Client = class {
   constructor({
     chainId,
-    publicClient
+    publicClient,
+    contractGetter
   }) {
     this.chainId = chainId;
     this.publicClient = publicClient;
+    this.contractGetter = contractGetter;
   }
   async createNew1155(props) {
     return createNew1155ContractAndToken({
@@ -6016,7 +6021,8 @@ var Create1155Client = class {
       token,
       getAdditionalSetupActions,
       publicClient: this.publicClient,
-      chainId: this.chainId
+      chainId: this.chainId,
+      contractGetter: this.contractGetter
     });
   }
 };
@@ -6061,9 +6067,13 @@ async function createNew1155ContractAndToken({
     contractAddress,
     contractVersion,
     minter,
-    publicClient,
     result: newToken.salesConfig,
-    tokenId: nextTokenId
+    tokenId: nextTokenId,
+    // to get the contract wide mint fee, we get what it would be for a new contract
+    getContractMintFee: async () => getNewContractMintFee({
+      publicClient,
+      chainId
+    })
   });
   return {
     parameters: request,
@@ -6081,13 +6091,10 @@ async function createNew1155Token({
   account,
   getAdditionalSetupActions,
   token,
-  publicClient,
-  chainId
+  chainId,
+  contractGetter
 }) {
-  const { nextTokenId, contractVersion } = await getContractInfoExistingContract({
-    publicClient,
-    contractAddress
-  });
+  const { nextTokenId, contractVersion, mintFee } = await contractGetter.getContractInfo({ contractAddress, retries: 5 });
   const {
     minter,
     newToken,
@@ -6109,9 +6116,9 @@ async function createNew1155Token({
     contractAddress,
     contractVersion,
     minter,
-    publicClient,
     result: newToken.salesConfig,
-    tokenId: nextTokenId
+    tokenId: nextTokenId,
+    getContractMintFee: async () => mintFee
   });
   return {
     parameters: request,
@@ -6452,6 +6459,77 @@ function decodeCallFailedError(error) {
   });
 }
 
+// src/create/subgraph-queries.ts
+function buildContractInfoQuery({
+  contractAddress
+}) {
+  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) => responseData.zoraCreateContract
+  };
+}
+
+// src/create/contract-getter.ts
+var SubgraphContractGetter = class {
+  constructor(chainId, subgraphQuerier) {
+    this.subgraphQuerier = subgraphQuerier || new SubgraphQuerier(httpClient);
+    this.networkConfig = getApiNetworkConfigForChain(chainId);
+  }
+  async querySubgraphWithRetries({
+    query,
+    variables,
+    parseResponseData
+  }) {
+    const responseData = await this.subgraphQuerier.query({
+      subgraphUrl: this.networkConfig.subgraphUrl,
+      query,
+      variables
+    });
+    return parseResponseData(responseData);
+  }
+  async getContractInfo({
+    contractAddress,
+    retries: retries2 = 1
+  }) {
+    const tryFn = async () => {
+      const responseData2 = await this.querySubgraphWithRetries(
+        buildContractInfoQuery({ contractAddress })
+      );
+      if (!responseData2) {
+        console.log("could not find contract");
+        throw new Error("Cannot find contract");
+      }
+      return responseData2;
+    };
+    const responseData = await retriesGeneric({
+      tryFn,
+      maxTries: retries2,
+      linearBackoffMS: 1e3
+    });
+    const nextTokenId = responseData.tokens.length === 0 ? 1n : BigInt(responseData.tokens[0].tokenId) + 1n;
+    return {
+      name: responseData.name,
+      contractVersion: responseData.contractVersion,
+      mintFee: BigInt(responseData.mintFeePerQuantity),
+      nextTokenId
+    };
+  }
+};
+
 // src/sdk.ts
 function createCreatorClient(clientConfig) {
   const premintClient = new PremintClient({
@@ -6461,7 +6539,8 @@ function createCreatorClient(clientConfig) {
   });
   const create1155CreatorClient = new Create1155Client({
     chainId: clientConfig.chainId,
-    publicClient: clientConfig.publicClient
+    publicClient: clientConfig.publicClient,
+    contractGetter: clientConfig.contractGetter || new SubgraphContractGetter(clientConfig.chainId)
   });
   return {
     createPremint: (p) => premintClient.createPremint(p),