@zoralabs/protocol-sdk 0.9.0 → 0.9.2

package/dist/index.cjs

@@ -2551,6 +2551,44 @@ var toContractCreationConfigOrAddress = ({
 // src/premint/premint-client.ts
 var import_protocol_deployments4 = require("@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) {
@@ -2560,11 +2598,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) {
@@ -2610,20 +2643,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,
@@ -4105,7 +4134,7 @@ var makeOnchainPrepareMint = (result) => (params) => {
       token: result,
       mintParams: params
     }),
-    erc20Approval: getRequiredErc20Approvals(params, result),
+    erc20Approval: getRequiredErc20Approvals(params, result.salesConfig),
     costs: parseMintCosts({
       salesConfig: result.salesConfig,
       quantityToMint: BigInt(params.quantityToMint),
@@ -4138,13 +4167,13 @@ function toPremintMintReturn({
     prepareMint: makePremintPrepareMint(mintable, mintFee, premint)
   };
 }
-function getRequiredErc20Approvals(params, result) {
-  if (result.salesConfig?.saleType !== "erc20")
+function getRequiredErc20Approvals(params, salesConfig) {
+  if (salesConfig?.saleType !== "erc20")
     return void 0;
   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
   };
 }
 
@@ -4248,7 +4277,7 @@ async function mint({
 
 // src/create/1155-create-helper.ts
 var import_protocol_deployments10 = require("@zoralabs/protocol-deployments");
-var import_viem9 = require("viem");
+var import_viem10 = require("viem");
 
 // src/create/contract-setup.ts
 var import_protocol_deployments7 = require("@zoralabs/protocol-deployments");
@@ -4259,36 +4288,6 @@ function new1155ContractVersion(chainId) {
   }
   return address.CONTRACT_1155_IMPL_VERSION;
 }
-async function getContractInfoExistingContract({
-  publicClient,
-  contractAddress
-}) {
-  let contractVersion;
-  try {
-    contractVersion = await publicClient.readContract({
-      abi: import_protocol_deployments7.zoraCreator1155ImplABI,
-      address: contractAddress,
-      functionName: "contractVersion"
-    });
-  } catch (e) {
-    throw new Error(`Contract does not exist at ${contractAddress}`);
-  }
-  const nextTokenId = await publicClient.readContract({
-    address: contractAddress,
-    abi: import_protocol_deployments7.zoraCreator1155ImplABI,
-    functionName: "nextTokenId"
-  });
-  const contractName = await publicClient.readContract({
-    address: contractAddress,
-    abi: import_protocol_deployments7.zoraCreator1155ImplABI,
-    functionName: "name"
-  });
-  return {
-    contractVersion,
-    contractName,
-    nextTokenId
-  };
-}
 async function getDeterministicContractAddress({
   publicClient,
   account,
@@ -4310,6 +4309,17 @@ async function getDeterministicContractAddress({
   });
   return contractAddress;
 }
+async function getNewContractMintFee({
+  publicClient,
+  chainId
+}) {
+  const implAddress = import_protocol_deployments7.contracts1155.addresses[chainId].CONTRACT_1155_IMPL;
+  return await publicClient.readContract({
+    abi: import_protocol_deployments7.zoraCreator1155ImplABI,
+    address: implAddress,
+    functionName: "mintFee"
+  });
+}
 
 // src/create/token-setup.ts
 var import_protocol_deployments9 = require("@zoralabs/protocol-deployments");
@@ -5833,12 +5843,101 @@ var contractSupportsMintRewards = (contractVersion, contractStandard) => {
   }
 };
 
+// src/create/mint-from-create.ts
+var import_viem9 = require("viem");
+async function toSalesStrategyFromSubgraph({
+  minter,
+  salesConfig,
+  getContractMintFee
+}) {
+  if (salesConfig.type === "timed") {
+    return {
+      saleType: "timed",
+      address: minter,
+      // for now we hardcode this
+      mintFeePerQuantity: (0, import_viem9.parseEther)("0.000111"),
+      saleStart: salesConfig.saleStart.toString(),
+      saleEnd: salesConfig.saleEnd.toString(),
+      // the following are not needed for now but we wanna satisfy concrete
+      erc20Z: import_viem9.zeroAddress,
+      mintFee: 0n,
+      pool: import_viem9.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
+  };
+}
+function makeOnchainPrepareMintFromCreate({
+  contractAddress,
+  tokenId,
+  result,
+  minter,
+  getContractMintFee,
+  contractVersion
+}) {
+  return async (params) => {
+    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)
+    };
+  };
+}
+
 // src/create/1155-create-helper.ts
 var ROYALTY_BPS_DEFAULT = 1e3;
 var getTokenIdFromCreateReceipt = (receipt) => {
   for (const data of receipt.logs) {
     try {
-      const decodedLog = (0, import_viem9.decodeEventLog)({
+      const decodedLog = (0, import_viem10.decodeEventLog)({
         abi: import_protocol_deployments10.zoraCreator1155ImplABI,
         eventName: "SetupNewToken",
         ...data
@@ -5856,7 +5955,7 @@ var getTokenIdFromCreateReceipt = (receipt) => {
 var getContractAddressFromReceipt = (receipt) => {
   for (const data of receipt.logs) {
     try {
-      const decodedLog = (0, import_viem9.decodeEventLog)({
+      const decodedLog = (0, import_viem10.decodeEventLog)({
         abi: import_protocol_deployments10.zoraCreator1155FactoryImplABI,
         eventName: "SetupNewContract",
         ...data
@@ -5915,10 +6014,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({
@@ -5939,7 +6040,8 @@ var Create1155Client = class {
       token,
       getAdditionalSetupActions,
       publicClient: this.publicClient,
-      chainId: this.chainId
+      chainId: this.chainId,
+      contractGetter: this.contractGetter
     });
   }
 };
@@ -5980,6 +6082,18 @@ async function createNew1155ContractAndToken({
     chainId,
     contract
   });
+  const prepareMint = makeOnchainPrepareMintFromCreate({
+    contractAddress,
+    contractVersion,
+    minter,
+    result: newToken.salesConfig,
+    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,
     tokenSetupActions,
@@ -5987,7 +6101,8 @@ async function createNew1155ContractAndToken({
     newToken,
     contractAddress,
     contractVersion,
-    minter
+    minter,
+    prepareMint
   };
 }
 async function createNew1155Token({
@@ -5995,13 +6110,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,
@@ -6019,13 +6131,22 @@ async function createNew1155Token({
     account,
     tokenSetupActions
   });
+  const prepareMint = makeOnchainPrepareMintFromCreate({
+    contractAddress,
+    contractVersion,
+    minter,
+    result: newToken.salesConfig,
+    tokenId: nextTokenId,
+    getContractMintFee: async () => mintFee
+  });
   return {
     parameters: request,
     tokenSetupActions,
     newTokenId: nextTokenId,
     newToken,
     contractVersion,
-    minter
+    minter,
+    prepareMint
   };
 }
 async function prepareSetupActions({
@@ -6114,7 +6235,7 @@ var sumBalances = (mintAccountBalances) => {
 
 // src/sparks/sparks-contracts.ts
 var import_protocol_deployments11 = require("@zoralabs/protocol-deployments");
-var import_viem10 = require("viem");
+var import_viem11 = require("viem");
 var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
 var mintWithEthParams = ({
   tokenId,
@@ -6150,7 +6271,7 @@ var encodeCollectOnManager = ({
   minter,
   zoraCreator1155TokenId,
   mintArguments
-}) => (0, import_viem10.encodeFunctionData)({
+}) => (0, import_viem11.encodeFunctionData)({
   abi: import_protocol_deployments11.zoraMintsManagerImplConfig.abi,
   functionName: "collect",
   args: [
@@ -6270,8 +6391,8 @@ var encodePremintOnManager = ({
   premintConfig,
   premintSignature,
   mintArguments,
-  signerContract = import_viem10.zeroAddress
-}) => (0, import_viem10.encodeFunctionData)({
+  signerContract = import_viem11.zeroAddress
+}) => (0, import_viem11.encodeFunctionData)({
   abi: import_protocol_deployments11.zoraMintsManagerImplConfig.abi,
   functionName: "collectPremintV2",
   args: [
@@ -6338,12 +6459,83 @@ function decodeCallFailedError(error) {
   if (error.data?.errorName !== "CallFailed")
     throw new Error("Not a CallFailed error");
   const internalErrorData = error.data?.args?.[0];
-  return (0, import_viem10.decodeErrorResult)({
+  return (0, import_viem11.decodeErrorResult)({
     abi: import_protocol_deployments11.zoraMintsManagerImplABI,
     data: internalErrorData
   });
 }
 
+// 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({
@@ -6353,7 +6545,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),