@zoralabs/protocol-sdk 0.3.3 → 0.3.5

package/dist/index.cjs

@@ -25,75 +25,277 @@ __export(src_exports, {
   Errors: () => Errors,
   MintAPIClient: () => MintAPIClient,
   PremintAPIClient: () => PremintAPIClient,
+  PremintConfigVersion: () => PremintConfigVersion,
+  PreminterDomain: () => PreminterDomain,
   ZORA_API_BASE: () => ZORA_API_BASE,
   convertCollection: () => convertCollection,
-  convertPremint: () => convertPremint,
+  convertPremintV1: () => convertPremintV1,
   create1155CreatorClient: () => create1155CreatorClient,
   create1155TokenSetupArgs: () => create1155TokenSetupArgs,
   createMintClient: () => createMintClient,
   createPremintClient: () => createPremintClient,
   encodePremintForAPI: () => encodePremintForAPI,
-  get1155MintCosts: () => get1155MintCosts,
+  encodePremintV1ForAPI: () => encodePremintV1ForAPI,
+  encodePremintV2ForAPI: () => encodePremintV2ForAPI,
   getApiNetworkConfigForChain: () => getApiNetworkConfigForChain,
+  getMintCosts: () => getMintCosts,
+  getPremintCollectionAddress: () => getPremintCollectionAddress,
+  getPremintExecutorAddress: () => getPremintExecutorAddress,
   getPremintedLogFromReceipt: () => getPremintedLogFromReceipt,
   getTokenIdFromCreateReceipt: () => getTokenIdFromCreateReceipt,
-  preminterTypedDataDefinition: () => preminterTypedDataDefinition
+  isAuthorizedToCreatePremint: () => isAuthorizedToCreatePremint,
+  isValidSignature: () => isValidSignature,
+  migratePremintConfigToV2: () => migratePremintConfigToV2,
+  premintTypedDataDefinition: () => premintTypedDataDefinition,
+  recoverCreatorFromCreatorAttribution: () => recoverCreatorFromCreatorAttribution,
+  recoverPremintSigner: () => recoverPremintSigner,
+  supportsPremintVersion: () => supportsPremintVersion,
+  tryRecoverPremintSigner: () => tryRecoverPremintSigner
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/premint/premint-client.ts
-var import_viem2 = require("viem");
-var import_protocol_deployments = require("@zoralabs/protocol-deployments");
+var import_viem4 = require("viem");
+var import_protocol_deployments2 = require("@zoralabs/protocol-deployments");
 
 // src/premint/preminter.ts
-var preminterTypedDataDefinition = ({
+var import_protocol_deployments = require("@zoralabs/protocol-deployments");
+var import_viem = require("viem");
+var v1Types = {
+  CreatorAttribution: [
+    { name: "tokenConfig", type: "TokenCreationConfig" },
+    // unique id scoped to the contract and token to create.
+    // ensure that a signature can be replaced, as long as the replacement
+    // has the same uid, and a newer version.
+    { name: "uid", type: "uint32" },
+    { name: "version", type: "uint32" },
+    // if this update should result in the signature being deleted.
+    { name: "deleted", type: "bool" }
+  ],
+  TokenCreationConfig: [
+    { name: "tokenURI", type: "string" },
+    { name: "maxSupply", type: "uint256" },
+    { name: "maxTokensPerAddress", type: "uint64" },
+    { name: "pricePerToken", type: "uint96" },
+    { name: "mintStart", type: "uint64" },
+    { name: "mintDuration", type: "uint64" },
+    { name: "royaltyMintSchedule", type: "uint32" },
+    { name: "royaltyBPS", type: "uint32" },
+    { name: "royaltyRecipient", type: "address" },
+    { name: "fixedPriceMinter", type: "address" }
+  ]
+};
+var v2Types = {
+  CreatorAttribution: [
+    { name: "tokenConfig", type: "TokenCreationConfig" },
+    // unique id scoped to the contract and token to create.
+    // ensure that a signature can be replaced, as long as the replacement
+    // has the same uid, and a newer version.
+    { name: "uid", type: "uint32" },
+    { name: "version", type: "uint32" },
+    // if this update should result in the signature being deleted.
+    { name: "deleted", type: "bool" }
+  ],
+  TokenCreationConfig: [
+    { name: "tokenURI", type: "string" },
+    { name: "maxSupply", type: "uint256" },
+    { name: "maxTokensPerAddress", type: "uint64" },
+    { name: "pricePerToken", type: "uint96" },
+    { name: "mintStart", type: "uint64" },
+    { name: "mintDuration", type: "uint64" },
+    { name: "royaltyBPS", type: "uint32" },
+    { name: "payoutRecipient", type: "address" },
+    { name: "fixedPriceMinter", type: "address" },
+    { name: "createReferral", type: "address" }
+  ]
+};
+var PreminterDomain = "Preminter";
+var PremintConfigVersion = {
+  V1: "1",
+  V2: "2"
+};
+var getPremintExecutorAddress = () => import_protocol_deployments.zoraCreator1155PremintExecutorImplAddress[999];
+var premintTypedDataDefinition = ({
   verifyingContract,
-  premintConfig,
-  chainId
+  chainId,
+  premintConfigVersion: version,
+  premintConfig
 }) => {
-  const { tokenConfig, uid, version, deleted } = premintConfig;
-  const types = {
-    CreatorAttribution: [
-      { name: "tokenConfig", type: "TokenCreationConfig" },
-      // unique id scoped to the contract and token to create.
-      // ensure that a signature can be replaced, as long as the replacement
-      // has the same uid, and a newer version.
-      { name: "uid", type: "uint32" },
-      { name: "version", type: "uint32" },
-      // if this update should result in the signature being deleted.
-      { name: "deleted", type: "bool" }
-    ],
-    TokenCreationConfig: [
-      { name: "tokenURI", type: "string" },
-      { name: "maxSupply", type: "uint256" },
-      { name: "maxTokensPerAddress", type: "uint64" },
-      { name: "pricePerToken", type: "uint96" },
-      { name: "mintStart", type: "uint64" },
-      { name: "mintDuration", type: "uint64" },
-      { name: "royaltyMintSchedule", type: "uint32" },
-      { name: "royaltyBPS", type: "uint32" },
-      { name: "royaltyRecipient", type: "address" },
-      { name: "fixedPriceMinter", type: "address" }
-    ]
+  const domain = {
+    chainId,
+    name: PreminterDomain,
+    version,
+    verifyingContract
   };
-  const result = {
+  if (version === PremintConfigVersion.V1)
+    return {
+      domain,
+      types: v1Types,
+      message: premintConfig,
+      primaryType: "CreatorAttribution"
+    };
+  if (version === PremintConfigVersion.V2) {
+    return {
+      domain,
+      types: v2Types,
+      message: premintConfig,
+      primaryType: "CreatorAttribution"
+    };
+  }
+  throw new Error(`Invalid version ${version}`);
+};
+async function isAuthorizedToCreatePremint({
+  collection,
+  collectionAddress,
+  publicClient,
+  premintConfig,
+  premintConfigVersion,
+  signature,
+  signer
+}) {
+  if (premintConfigVersion === PremintConfigVersion.V1) {
+    const [isValidSignature2] = await publicClient.readContract({
+      abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
+      address: getPremintExecutorAddress(),
+      functionName: "isValidSignature",
+      args: [collection, premintConfig, signature]
+    });
+    return isValidSignature2;
+  }
+  return await publicClient.readContract({
+    abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
+    address: getPremintExecutorAddress(),
+    functionName: "isAuthorizedToCreatePremint",
+    args: [signer, collection.contractAdmin, collectionAddress]
+  });
+}
+async function recoverPremintSigner({
+  signature,
+  ...rest
+}) {
+  const typedData = premintTypedDataDefinition(rest);
+  return await (0, import_viem.recoverTypedDataAddress)({
+    ...typedData,
+    signature
+  });
+}
+async function tryRecoverPremintSigner(params) {
+  try {
+    return await recoverPremintSigner(params);
+  } catch (error) {
+    console.error(error);
+    return void 0;
+  }
+}
+async function isValidSignature({
+  signature,
+  publicClient,
+  collection,
+  chainId,
+  ...premintConfigAndVersion
+}) {
+  const tokenContract = await getPremintCollectionAddress({
+    collection,
+    publicClient
+  });
+  const recoveredAddress = await tryRecoverPremintSigner({
+    ...premintConfigAndVersion,
+    signature,
+    verifyingContract: tokenContract,
+    chainId
+  });
+  if (!import_viem.recoverAddress) {
+    return {
+      isAuthorized: false
+    };
+  }
+  const isAuthorized = await isAuthorizedToCreatePremint({
+    signer: recoveredAddress,
+    collection,
+    collectionAddress: tokenContract,
+    publicClient,
+    signature,
+    ...premintConfigAndVersion
+  });
+  return {
+    isAuthorized,
+    recoveredAddress
+  };
+}
+function migratePremintConfigToV2({
+  premintConfig,
+  createReferral = import_viem.zeroAddress
+}) {
+  return {
+    ...premintConfig,
+    tokenConfig: {
+      tokenURI: premintConfig.tokenConfig.tokenURI,
+      maxSupply: premintConfig.tokenConfig.maxSupply,
+      maxTokensPerAddress: premintConfig.tokenConfig.maxTokensPerAddress,
+      pricePerToken: premintConfig.tokenConfig.pricePerToken,
+      mintStart: premintConfig.tokenConfig.mintStart,
+      mintDuration: premintConfig.tokenConfig.mintDuration,
+      payoutRecipient: premintConfig.tokenConfig.royaltyRecipient,
+      royaltyBPS: premintConfig.tokenConfig.royaltyBPS,
+      fixedPriceMinter: premintConfig.tokenConfig.fixedPriceMinter,
+      createReferral
+    }
+  };
+}
+var recoverCreatorFromCreatorAttribution = async ({
+  creatorAttribution: { version, domainName, structHash, signature },
+  chainId,
+  tokenContract
+}) => {
+  const hashedDomain = (0, import_viem.hashDomain)({
     domain: {
       chainId,
-      name: "Preminter",
-      version: "1",
-      verifyingContract
+      name: domainName,
+      verifyingContract: tokenContract,
+      version
     },
-    types,
-    message: {
-      tokenConfig,
-      uid,
-      version,
-      deleted
-    },
-    primaryType: "CreatorAttribution"
-  };
-  return result;
+    types: {
+      EIP712Domain: [
+        { name: "name", type: "string" },
+        { name: "version", type: "string" },
+        {
+          name: "chainId",
+          type: "uint256"
+        },
+        {
+          name: "verifyingContract",
+          type: "address"
+        }
+      ]
+    }
+  });
+  const parts = ["0x1901", hashedDomain, structHash];
+  const hashedTypedData = (0, import_viem.keccak256)((0, import_viem.concat)(parts));
+  return await (0, import_viem.recoverAddress)({
+    hash: hashedTypedData,
+    signature
+  });
 };
+var supportsPremintVersion = async (version, tokenContract, publicClient) => {
+  const supportedPremintSignatureVersions = await publicClient.readContract({
+    abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
+    address: getPremintExecutorAddress(),
+    functionName: "supportedPremintSignatureVersions",
+    args: [tokenContract]
+  });
+  return supportedPremintSignatureVersions.includes(version);
+};
+async function getPremintCollectionAddress({
+  collection,
+  publicClient
+}) {
+  return publicClient.readContract({
+    address: getPremintExecutorAddress(),
+    abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
+    functionName: "getContractAddress",
+    args: [collection]
+  });
+}
 
 // src/apis/http-api-base.ts
 var BadResponseError = class extends Error {
@@ -170,17 +372,22 @@ var httpClient = {
 };
 
 // src/constants.ts
+var import_viem2 = require("viem");
 var ZORA_API_BASE = "https://api.zora.co/";
 var OPEN_EDITION_MINT_SIZE = BigInt("18446744073709551615");
 var SUBGRAPH_CONFIG_BASE = "https://api.goldsky.com/api/public/project_clhk16b61ay9t49vm6ntn4mkz/subgraphs";
 function getSubgraph(name, version) {
   return `${SUBGRAPH_CONFIG_BASE}/${name}/${version}/gn`;
 }
+var zora721Abi = (0, import_viem2.parseAbi)([
+  "function mintWithRewards(address recipient, uint256 quantity, string calldata comment, address mintReferral) external payable",
+  "function zoraFeeForAmount(uint256 amount) public view returns (address, uint256)"
+]);
 
 // src/apis/chain-constants.ts
 var import_chains = require("viem/chains");
-var import_viem = require("viem");
-var REWARD_PER_TOKEN = (0, import_viem.parseEther)("0.000777");
+var import_viem3 = require("viem");
+var REWARD_PER_TOKEN = (0, import_viem3.parseEther)("0.000777");
 var BackendChainNamesLookup = {
   ZORA_MAINNET: "ZORA-MAINNET",
   ZORA_GOERLI: "ZORA-GOERLI",
@@ -258,9 +465,6 @@ var networkConfigByChain = {
 };
 
 // src/mint/mint-api-client.ts
-function encodeQueryParameters(params) {
-  return new URLSearchParams(params).toString();
-}
 var getApiNetworkConfigForChain = (chainId) => {
   if (!networkConfigByChain[chainId]) {
     throw new Error(`chain id ${chainId} network not configured `);
@@ -272,41 +476,64 @@ var MintAPIClient = class {
     this.httpClient = httpClient2 || httpClient;
     this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
-  async getMintable(path, query) {
-    const httpClient2 = this.httpClient;
-    return httpClient2.retries(() => {
-      return httpClient2.get(
-        `${ZORA_API_BASE}discover/mintables/${path.chain_name}/${path.collection_address}${query?.token_id ? `?${encodeQueryParameters(query)}` : ""}`
-      );
-    });
-  }
-  async getSalesConfigFixedPrice({
-    contractAddress,
+  async getSalesConfigAndTokenInfo({
+    tokenAddress,
     tokenId
   }) {
     const { retries: retries2, post: post2 } = this.httpClient;
     return retries2(async () => {
       const response = await post2(this.networkConfig.subgraphUrl, {
-        query: "query($id: ID!) {\n  zoraCreateToken(id: $id) {\n    id\n    salesStrategies{\n      fixedPrice {\n        address\n      }\n    }\n  }\n}",
+        query: `
+          fragment SaleStrategy on SalesStrategyConfig {
+            type
+            fixedPrice {
+              address
+              pricePerToken
+              saleEnd
+              saleStart
+              maxTokensPerAddress
+            }
+          }
+          
+          query ($id: ID!) {
+            zoraCreateToken(id: $id) {
+              id
+              contract {
+                mintFeePerQuantity
+                salesStrategies(where: {type: "FIXED_PRICE"}) {
+                  ...SaleStrategy
+                }
+              }
+              salesStrategies(where: {type: "FIXED_PRICE"}) {
+                ...SaleStrategy
+              }
+            }
+          }
+        `,
         variables: {
-          id: `${contractAddress.toLowerCase()}-${tokenId.toString()}`
+          id: tokenId !== void 0 ? (
+            // Generic Token ID types all stringify down to the base numeric equivalent.
+            `${tokenAddress.toLowerCase()}-${tokenId}`
+          ) : `${tokenAddress.toLowerCase()}-0`
         }
       });
-      return response.zoraCreateToken?.salesStrategies?.find(() => true)?.fixedPriceMinterAddress;
+      const token = response.data?.zoraCreateToken;
+      if (!token) {
+        throw new Error("Cannot find a token to mint");
+      }
+      const saleStrategies = tokenId !== void 0 ? token.salesStrategies : token.contract.salesStrategies;
+      const fixedPrice = saleStrategies?.sort(
+        (a, b) => BigInt(a.fixedPrice.saleEnd) > BigInt(b.fixedPrice.saleEnd) ? 1 : -1
+      )?.find(() => true)?.fixedPrice;
+      if (!fixedPrice) {
+        throw new Error("Cannot find fixed price sale strategy");
+      }
+      return {
+        fixedPrice,
+        mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
+      };
     });
   }
-  async getMintableForToken({
-    tokenContract,
-    tokenId
-  }) {
-    return await this.getMintable(
-      {
-        chain_name: this.networkConfig.zoraBackendChainName,
-        collection_address: tokenContract
-      },
-      { token_id: tokenId?.toString() }
-    );
-  }
 };
 
 // src/premint/premint-api-client.ts
@@ -376,8 +603,8 @@ var DefaultMintArguments = {
 function getPremintedLogFromReceipt(receipt) {
   for (const data of receipt.logs) {
     try {
-      const decodedLog = (0, import_viem2.decodeEventLog)({
-        abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
+      const decodedLog = (0, import_viem4.decodeEventLog)({
+        abi: import_protocol_deployments2.zoraCreator1155PremintExecutorImplABI,
         eventName: "Preminted",
         ...data
       });
@@ -388,7 +615,7 @@ function getPremintedLogFromReceipt(receipt) {
     }
   }
 }
-var convertPremint = (premint) => ({
+var convertPremintV1 = (premint) => ({
   ...premint,
   tokenConfig: {
     ...premint.tokenConfig,
@@ -405,7 +632,21 @@ var convertCollection = (collection) => ({
   ...collection,
   contractAdmin: collection.contractAdmin
 });
-var encodePremintForAPI = ({
+var encodePremintV1ForAPI = ({
+  tokenConfig,
+  ...premint
+}) => ({
+  ...premint,
+  tokenConfig: {
+    ...tokenConfig,
+    maxSupply: tokenConfig.maxSupply.toString(),
+    pricePerToken: tokenConfig.pricePerToken.toString(),
+    mintStart: tokenConfig.mintStart.toString(),
+    mintDuration: tokenConfig.mintDuration.toString(),
+    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
+  }
+});
+var encodePremintV2ForAPI = ({
   tokenConfig,
   ...premint
 }) => ({
@@ -419,20 +660,23 @@ var encodePremintForAPI = ({
     maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
   }
 });
+var encodePremintForAPI = ({
+  premintConfig,
+  premintConfigVersion
+}) => {
+  if (premintConfigVersion === PremintConfigVersion.V1) {
+    return encodePremintV1ForAPI(premintConfig);
+  }
+  if (premintConfigVersion === PremintConfigVersion.V2) {
+    return encodePremintV2ForAPI(premintConfig);
+  }
+  throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+};
 var PremintClient = class {
   constructor(chain, publicClient, httpClient2) {
     this.chain = chain;
     this.apiClient = new PremintAPIClient(chain.id, httpClient2);
-    this.publicClient = publicClient || (0, import_viem2.createPublicClient)({ chain, transport: (0, import_viem2.http)() });
-  }
-  /**
-   * The premint executor address is deployed to the same address across all chains.
-   * Can be overridden as needed by making a parent class.
-   *
-   * @returns Executor address for premints
-   */
-  getExecutorAddress() {
-    return import_protocol_deployments.zoraCreator1155PremintExecutorImplAddress[999];
+    this.publicClient = publicClient || (0, import_viem4.createPublicClient)({ chain, transport: (0, import_viem4.http)() });
   }
   /**
    * The fixed price minter address is the same across all chains for our current
@@ -442,7 +686,7 @@ var PremintClient = class {
    * @returns Fixed price sale strategy
    */
   getFixedPriceMinterAddress() {
-    return import_protocol_deployments.zoraCreatorFixedPriceSaleStrategyAddress[999];
+    return import_protocol_deployments2.zoraCreatorFixedPriceSaleStrategyAddress[999];
   }
   getDataFromPremintReceipt(receipt) {
     const premintedLog = getPremintedLogFromReceipt(receipt);
@@ -483,7 +727,7 @@ var PremintClient = class {
       collection_address: collection.toLowerCase(),
       uid
     });
-    const convertedPremint = convertPremint(signatureResponse.premint);
+    const convertedPremint = convertPremintV1(signatureResponse.premint);
     const signerData = {
       ...signatureResponse,
       premint: {
@@ -504,7 +748,8 @@ var PremintClient = class {
         ...signerData.collection,
         contractAdmin: signerData.collection.contractAdmin
       },
-      premintConfig: signerData.premint
+      premintConfig: signerData.premint,
+      premintConfigVersion: PremintConfigVersion.V1
     });
   }
   /**
@@ -535,7 +780,7 @@ var PremintClient = class {
       ...signatureResponse,
       collection: convertCollection(signatureResponse.collection),
       premint: {
-        ...convertPremint(signatureResponse.premint),
+        ...convertPremintV1(signatureResponse.premint),
         deleted: true
       }
     };
@@ -546,7 +791,8 @@ var PremintClient = class {
       verifyingContract: collection,
       uid,
       collection: signerData.collection,
-      premintConfig: signerData.premint
+      premintConfig: signerData.premint,
+      premintConfigVersion: PremintConfigVersion.V1
     });
   }
   /**
@@ -558,11 +804,11 @@ var PremintClient = class {
   async signAndSubmitPremint({
     walletClient,
     verifyingContract,
-    premintConfig,
     uid,
     account,
     checkSignature,
-    collection
+    collection,
+    ...premintConfigAndVersion
   }) {
     if (!account) {
       account = walletClient.account;
@@ -572,26 +818,32 @@ var PremintClient = class {
     }
     const signature = await walletClient.signTypedData({
       account,
-      ...preminterTypedDataDefinition({
+      ...premintTypedDataDefinition({
         verifyingContract,
-        premintConfig,
+        ...premintConfigAndVersion,
         chainId: this.chain.id
       })
     });
     if (checkSignature) {
-      const [isValidSignature] = await this.publicClient.readContract({
-        abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
-        address: this.getExecutorAddress(),
-        functionName: "isValidSignature",
-        args: [convertCollection(collection), premintConfig, signature]
+      const convertedCollection = convertCollection(collection);
+      const isAuthorized = await isAuthorizedToCreatePremint({
+        collection: convertCollection(collection),
+        signature,
+        publicClient: this.publicClient,
+        signer: typeof account === "string" ? account : account.address,
+        collectionAddress: await this.getCollectionAddress(convertedCollection),
+        ...premintConfigAndVersion
       });
-      if (!isValidSignature) {
-        throw new Error("Invalid signature");
+      if (!isAuthorized) {
+        throw new Error("Not authorized to create premint");
       }
     }
+    if (premintConfigAndVersion.premintConfigVersion === PremintConfigVersion.V2) {
+      throw new Error("premint config v2 not supported yet");
+    }
     const apiData = {
       collection,
-      premint: encodePremintForAPI(premintConfig),
+      premint: encodePremintV1ForAPI(premintConfigAndVersion.premintConfig),
       signature
     };
     const premint = await this.apiClient.postSignature(apiData);
@@ -625,11 +877,9 @@ var PremintClient = class {
     executionSettings,
     checkSignature = false
   }) {
-    const newContractAddress = await this.publicClient.readContract({
-      address: this.getExecutorAddress(),
-      abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
-      functionName: "getContractAddress",
-      args: [convertCollection(collection)]
+    const newContractAddress = await getPremintCollectionAddress({
+      publicClient: this.publicClient,
+      collection: convertCollection(collection)
     });
     const tokenConfig = {
       ...DefaultMintArguments,
@@ -658,6 +908,7 @@ var PremintClient = class {
       uid,
       verifyingContract: newContractAddress,
       premintConfig,
+      premintConfigVersion: PremintConfigVersion.V1,
       checkSignature,
       account,
       walletClient,
@@ -680,26 +931,37 @@ var PremintClient = class {
       uid
     });
   }
+  /**
+   * Gets the deterministic contract address for a premint collection
+   * @param collection Collection to get the address for
+   * @returns deterministic contract address
+   */
+  async getCollectionAddress(collection) {
+    return await getPremintCollectionAddress({
+      collection,
+      publicClient: this.publicClient
+    });
+  }
   /**
    * Check user signature for v1
    *
    * @param data Signature data from the API
-   * @returns isValid = signature is valid or not, contractAddress = assumed contract address, recoveredSigner = signer from contract
+   * @returns isValid = signature is valid or not, recoveredSigner = signer from contract
    */
   async isValidSignature({
-    data
+    signature,
+    premint,
+    collection
   }) {
-    const [isValid, contractAddress, recoveredSigner] = await this.publicClient.readContract({
-      abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
-      address: this.getExecutorAddress(),
-      functionName: "isValidSignature",
-      args: [
-        convertCollection(data.collection),
-        convertPremint(data.premint),
-        data.signature
-      ]
+    const { isAuthorized, recoveredAddress } = await isValidSignature({
+      chainId: this.chain.id,
+      signature,
+      premintConfig: convertPremintV1(premint),
+      premintConfigVersion: PremintConfigVersion.V1,
+      collection: convertCollection(collection),
+      publicClient: this.publicClient
     });
-    return { isValid, contractAddress, recoveredSigner };
+    return { isValid: isAuthorized, recoveredSigner: recoveredAddress };
   }
   makeUrls({
     uid,
@@ -737,11 +999,10 @@ var PremintClient = class {
     if (mintArguments && mintArguments?.quantityToMint < 1) {
       throw new Error("Quantity to mint cannot be below 1");
     }
-    const targetAddress = this.getExecutorAddress();
     const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
     const args = [
       convertCollection(data.collection),
-      convertPremint(data.premint),
+      convertPremintV1(data.premint),
       data.signature,
       numberToMint,
       mintArguments?.mintComment || ""
@@ -752,10 +1013,10 @@ var PremintClient = class {
     const value = numberToMint * REWARD_PER_TOKEN;
     const request = {
       account,
-      abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
+      abi: import_protocol_deployments2.zoraCreator1155PremintExecutorImplABI,
       functionName: "premint",
       value,
-      address: targetAddress,
+      address: getPremintExecutorAddress(),
       args
     };
     return request;
@@ -770,8 +1031,8 @@ function createPremintClient({
 }
 
 // src/mint/mint-client.ts
-var import_viem3 = require("viem");
-var import_protocol_deployments2 = require("@zoralabs/protocol-deployments");
+var import_viem5 = require("viem");
+var import_protocol_deployments3 = require("@zoralabs/protocol-deployments");
 var MintError = class extends Error {
 };
 var MintInactiveError = class extends Error {
@@ -780,29 +1041,10 @@ var Errors = {
   MintError,
   MintInactiveError
 };
-var zora721Abi = (0, import_viem3.parseAbi)([
-  "function mintWithRewards(address recipient, uint256 quantity, string calldata comment, address mintReferral) external payable",
-  "function zoraFeeForAmount(uint256 amount) public view returns (address, uint256)"
-]);
 var MintClient = class {
   constructor(chain, publicClient, httpClient2) {
     this.apiClient = new MintAPIClient(chain.id, httpClient2);
-    this.publicClient = publicClient || (0, import_viem3.createPublicClient)({ chain, transport: (0, import_viem3.http)() });
-  }
-  /**
-   * Gets mintable information for a given token
-   * @param param0.tokenContract The contract address of the token to mint.
-   * @param param0.tokenId The token id to mint.
-   * @returns
-   */
-  async getMintable({
-    tokenContract,
-    tokenId
-  }) {
-    return await this.apiClient.getMintableForToken({
-      tokenContract,
-      tokenId: tokenId?.toString()
-    });
+    this.publicClient = publicClient || (0, import_viem5.createPublicClient)({ chain, transport: (0, import_viem5.http)() });
   }
   /**
    * Returns the parameters needed to prepare a transaction mint a token.
@@ -820,35 +1062,6 @@ var MintClient = class {
       publicClient: this.publicClient
     });
   }
-  /**
-   * Returns the mintFee, sale fee, and total cost of minting x quantities of a token.
-   * @param param0.mintable The mintable token to mint.
-   * @param param0.quantityToMint The quantity of tokens to mint.
-   * @returns
-   */
-  async getMintCosts({
-    mintable,
-    quantityToMint
-  }) {
-    const mintContextType = validateMintableAndGetContextType(mintable);
-    if (mintContextType === "zora_create_1155") {
-      return await get1155MintCosts({
-        mintable,
-        publicClient: this.publicClient,
-        quantityToMint: BigInt(quantityToMint)
-      });
-    }
-    if (mintContextType === "zora_create") {
-      return await get721MintCosts({
-        mintable,
-        publicClient: this.publicClient,
-        quantityToMint: BigInt(quantityToMint)
-      });
-    }
-    throw new MintError(
-      `Mintable type ${mintContextType} is currently unsupported.`
-    );
-  }
 };
 function createMintClient({
   chain,
@@ -857,91 +1070,44 @@ function createMintClient({
 }) {
   return new MintClient(chain, publicClient, httpClient2);
 }
-function validateMintableAndGetContextType(mintable) {
-  if (!mintable) {
-    throw new MintError("No mintable found");
-  }
-  if (!mintable.is_active) {
-    throw new MintInactiveError("Minting token is inactive");
-  }
-  if (!mintable.mint_context) {
-    throw new MintError("No minting context data from zora API");
-  }
-  if (!["zora_create", "zora_create_1155"].includes(
-    mintable.mint_context?.mint_context_type
-  )) {
-    throw new MintError(
-      `Mintable type ${mintable.mint_context.mint_context_type} is currently unsupported.`
-    );
-  }
-  return mintable.mint_context.mint_context_type;
-}
 async function makePrepareMintTokenParams({
   publicClient,
-  mintable,
   apiClient,
+  tokenId,
+  tokenAddress,
   ...rest
 }) {
-  const mintContextType = validateMintableAndGetContextType(mintable);
-  const thisPublicClient = publicClient;
-  if (mintContextType === "zora_create_1155") {
-    return makePrepareMint1155TokenParams({
-      apiClient,
-      publicClient: thisPublicClient,
-      mintable,
-      mintContextType,
-      ...rest
-    });
-  }
-  if (mintContextType === "zora_create") {
+  const salesConfigAndTokenInfo = await apiClient.getSalesConfigAndTokenInfo({
+    tokenId,
+    tokenAddress
+  });
+  if (tokenId === void 0) {
     return makePrepareMint721TokenParams({
-      publicClient: thisPublicClient,
-      mintable,
-      mintContextType,
+      salesConfigAndTokenInfo,
+      tokenAddress,
       ...rest
     });
   }
-  throw new MintError(
-    `Mintable type ${mintContextType} is currently unsupported.`
-  );
-}
-async function get721MintCosts({
-  mintable,
-  publicClient,
-  quantityToMint
-}) {
-  const address = mintable.collection.address;
-  const [_, mintFee] = await publicClient.readContract({
-    abi: zora721Abi,
-    address,
-    functionName: "zoraFeeForAmount",
-    args: [BigInt(quantityToMint)]
+  return makePrepareMint1155TokenParams({
+    salesConfigAndTokenInfo,
+    tokenAddress,
+    tokenId,
+    ...rest
   });
-  const tokenPurchaseCost = BigInt(mintable.cost.native_price.raw) * quantityToMint;
-  return {
-    mintFee,
-    tokenPurchaseCost,
-    totalCost: mintFee + tokenPurchaseCost
-  };
 }
 async function makePrepareMint721TokenParams({
-  publicClient,
+  tokenAddress,
+  salesConfigAndTokenInfo,
   minterAccount,
-  mintable,
-  mintContextType,
   mintArguments
 }) {
-  if (mintContextType !== "zora_create") {
-    throw new Error("Minted token type must be for 1155");
-  }
-  const mintValue = (await get721MintCosts({
-    mintable,
-    publicClient,
+  const mintValue = getMintCosts({
+    salesConfigAndTokenInfo,
     quantityToMint: BigInt(mintArguments.quantityToMint)
-  })).totalCost;
+  }).totalCost;
   const result = {
     abi: zora721Abi,
-    address: mintable.contract_address,
+    address: tokenAddress,
     account: minterAccount,
     functionName: "mintWithRewards",
     value: mintValue,
@@ -949,33 +1115,17 @@ async function makePrepareMint721TokenParams({
       mintArguments.mintToAddress,
       BigInt(mintArguments.quantityToMint),
       mintArguments.mintComment || "",
-      mintArguments.mintReferral || import_viem3.zeroAddress
+      mintArguments.mintReferral || import_viem5.zeroAddress
     ]
   };
   return result;
 }
-async function get1155MintFee({
-  collectionAddress,
-  publicClient
-}) {
-  return await publicClient.readContract({
-    abi: import_protocol_deployments2.zoraCreator1155ImplABI,
-    functionName: "mintFee",
-    address: collectionAddress
-  });
-}
-async function get1155MintCosts({
-  mintable,
-  publicClient,
+function getMintCosts({
+  salesConfigAndTokenInfo,
   quantityToMint
 }) {
-  const address = mintable.collection.address;
-  const mintFee = await get1155MintFee({
-    collectionAddress: address,
-    publicClient
-  });
-  const mintFeeForTokens = mintFee * quantityToMint;
-  const tokenPurchaseCost = BigInt(mintable.cost.native_price.raw) * quantityToMint;
+  const mintFeeForTokens = salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
+  const tokenPurchaseCost = BigInt(salesConfigAndTokenInfo.fixedPrice.pricePerToken) * quantityToMint;
   return {
     mintFee: mintFeeForTokens,
     tokenPurchaseCost,
@@ -983,55 +1133,45 @@ async function get1155MintCosts({
   };
 }
 async function makePrepareMint1155TokenParams({
-  apiClient,
-  publicClient,
+  tokenId,
+  salesConfigAndTokenInfo,
   minterAccount,
-  mintable,
-  mintContextType,
+  tokenAddress,
   mintArguments
 }) {
-  if (mintContextType !== "zora_create_1155") {
-    throw new Error("Minted token type must be for 1155");
-  }
   const mintQuantity = BigInt(mintArguments.quantityToMint);
-  const address = mintable.collection.address;
-  const mintValue = (await get1155MintCosts({
-    mintable,
-    publicClient,
+  const mintValue = getMintCosts({
+    salesConfigAndTokenInfo,
     quantityToMint: mintQuantity
-  })).totalCost;
-  const tokenFixedPriceMinter = await apiClient.getSalesConfigFixedPrice({
-    contractAddress: address,
-    tokenId: BigInt(mintable.token_id)
-  });
+  }).totalCost;
   const result = {
-    abi: import_protocol_deployments2.zoraCreator1155ImplABI,
+    abi: import_protocol_deployments3.zoraCreator1155ImplABI,
     functionName: "mintWithRewards",
     account: minterAccount,
     value: mintValue,
-    address,
+    address: tokenAddress,
     /* args: minter, tokenId, quantity, minterArguments, mintReferral */
     args: [
-      tokenFixedPriceMinter || import_protocol_deployments2.zoraCreatorFixedPriceSaleStrategyAddress[999],
-      BigInt(mintable.token_id),
+      salesConfigAndTokenInfo?.fixedPrice.address || import_protocol_deployments3.zoraCreatorFixedPriceSaleStrategyAddress[999],
+      BigInt(tokenId),
       mintQuantity,
-      (0, import_viem3.encodeAbiParameters)((0, import_viem3.parseAbiParameters)("address, string"), [
+      (0, import_viem5.encodeAbiParameters)((0, import_viem5.parseAbiParameters)("address, string"), [
         mintArguments.mintToAddress,
         mintArguments.mintComment || ""
       ]),
-      mintArguments.mintReferral || import_viem3.zeroAddress
+      mintArguments.mintReferral || import_viem5.zeroAddress
     ]
   };
   return result;
 }
 
 // src/create/1155-create-helper.ts
-var import_protocol_deployments3 = require("@zoralabs/protocol-deployments");
-var import_viem4 = require("viem");
+var import_protocol_deployments4 = require("@zoralabs/protocol-deployments");
+var import_viem6 = require("viem");
 var SALE_END_FOREVER = 18446744073709551615n;
 var ROYALTY_BPS_DEFAULT = 1e3;
 var DEFAULT_SALE_SETTINGS = {
-  fundsRecipient: import_viem4.zeroAddress,
+  fundsRecipient: import_viem6.zeroAddress,
   // Free Mint
   pricePerToken: 0n,
   // Sale start time – defaults to beginning of unix time
@@ -1041,7 +1181,7 @@ var DEFAULT_SALE_SETTINGS = {
   // 0 Here means no limit
   maxTokensPerAddress: 0n
 };
-var PERMISSION_BIT_MINTER = 2n ** 2n;
+var PERMISSION_BIT_MINTER = 4n;
 function create1155TokenSetupArgs({
   nextTokenId,
   // How many NFTs upon initialization to mint to the creator
@@ -1070,33 +1210,33 @@ function create1155TokenSetupArgs({
     ...salesConfig
   };
   const setupActions = [
-    (0, import_viem4.encodeFunctionData)({
-      abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+    (0, import_viem6.encodeFunctionData)({
+      abi: import_protocol_deployments4.zoraCreator1155ImplABI,
       functionName: "assumeLastTokenIdMatches",
       args: [nextTokenId - 1n]
     }),
-    createReferral ? (0, import_viem4.encodeFunctionData)({
-      abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+    createReferral ? (0, import_viem6.encodeFunctionData)({
+      abi: import_protocol_deployments4.zoraCreator1155ImplABI,
       functionName: "setupNewTokenWithCreateReferral",
       args: [tokenMetadataURI, maxSupply, createReferral]
-    }) : (0, import_viem4.encodeFunctionData)({
-      abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+    }) : (0, import_viem6.encodeFunctionData)({
+      abi: import_protocol_deployments4.zoraCreator1155ImplABI,
       functionName: "setupNewToken",
       args: [tokenMetadataURI, maxSupply]
     }),
-    (0, import_viem4.encodeFunctionData)({
-      abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+    (0, import_viem6.encodeFunctionData)({
+      abi: import_protocol_deployments4.zoraCreator1155ImplABI,
       functionName: "addPermission",
       args: [0n, fixedPriceMinterAddress, PERMISSION_BIT_MINTER]
     }),
-    (0, import_viem4.encodeFunctionData)({
-      abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+    (0, import_viem6.encodeFunctionData)({
+      abi: import_protocol_deployments4.zoraCreator1155ImplABI,
       functionName: "callSale",
       args: [
         nextTokenId,
         fixedPriceMinterAddress,
-        (0, import_viem4.encodeFunctionData)({
-          abi: import_protocol_deployments3.zoraCreatorFixedPriceSaleStrategyABI,
+        (0, import_viem6.encodeFunctionData)({
+          abi: import_protocol_deployments4.zoraCreatorFixedPriceSaleStrategyABI,
           functionName: "setSale",
           args: [nextTokenId, salesConfigWithDefaults]
         })
@@ -1105,8 +1245,8 @@ function create1155TokenSetupArgs({
   ];
   if (mintToCreatorCount) {
     setupActions.push(
-      (0, import_viem4.encodeFunctionData)({
-        abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+      (0, import_viem6.encodeFunctionData)({
+        abi: import_protocol_deployments4.zoraCreator1155ImplABI,
         functionName: "adminMint",
         args: [account, nextTokenId, mintToCreatorCount, "0x"]
       })
@@ -1114,8 +1254,8 @@ function create1155TokenSetupArgs({
   }
   if (royaltySettings) {
     setupActions.push(
-      (0, import_viem4.encodeFunctionData)({
-        abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+      (0, import_viem6.encodeFunctionData)({
+        abi: import_protocol_deployments4.zoraCreator1155ImplABI,
         functionName: "updateRoyaltiesForToken",
         args: [
           nextTokenId,
@@ -1133,8 +1273,8 @@ function create1155TokenSetupArgs({
 var getTokenIdFromCreateReceipt = (receipt) => {
   for (const data of receipt.logs) {
     try {
-      const decodedLog = (0, import_viem4.decodeEventLog)({
-        abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+      const decodedLog = (0, import_viem6.decodeEventLog)({
+        abi: import_protocol_deployments4.zoraCreator1155ImplABI,
         eventName: "SetupNewToken",
         ...data
       });
@@ -1150,9 +1290,9 @@ async function getContractExists(publicClient, contract, account) {
   let contractExists = false;
   if (typeof contract !== "string") {
     contractAddress = await publicClient.readContract({
-      abi: import_protocol_deployments3.zoraCreator1155FactoryImplABI,
+      abi: import_protocol_deployments4.zoraCreator1155FactoryImplABI,
       // Since this address is deterministic we can hardcode a chain id safely here.
-      address: import_protocol_deployments3.zoraCreator1155FactoryImplAddress[999],
+      address: import_protocol_deployments4.zoraCreator1155FactoryImplAddress[999],
       functionName: "deterministicContractAddress",
       args: [
         account,
@@ -1163,7 +1303,7 @@ async function getContractExists(publicClient, contract, account) {
     });
     try {
       await publicClient.readContract({
-        abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+        abi: import_protocol_deployments4.zoraCreator1155ImplABI,
         address: contractAddress,
         functionName: "contractVersion"
       });
@@ -1198,14 +1338,14 @@ function create1155CreatorClient({
     let nextTokenId = 1n;
     if (contractExists) {
       nextTokenId = await publicClient.readContract({
-        abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+        abi: import_protocol_deployments4.zoraCreator1155ImplABI,
         functionName: "nextTokenId",
         address: contractAddress
       });
     }
     const fixedPriceMinterAddress = await publicClient.readContract({
-      abi: import_protocol_deployments3.zoraCreator1155FactoryImplABI,
-      address: import_protocol_deployments3.zoraCreator1155FactoryImplAddress[999],
+      abi: import_protocol_deployments4.zoraCreator1155FactoryImplABI,
+      address: import_protocol_deployments4.zoraCreator1155FactoryImplAddress[999],
       functionName: "fixedPriceMinter"
     });
     let tokenSetupActions = create1155TokenSetupArgs({
@@ -1229,10 +1369,10 @@ function create1155CreatorClient({
     }
     if (!contractExists && typeof contract !== "string") {
       const request = {
-        abi: import_protocol_deployments3.zoraCreator1155FactoryImplABI,
+        abi: import_protocol_deployments4.zoraCreator1155FactoryImplABI,
         functionName: "createContractDeterministic",
         account,
-        address: import_protocol_deployments3.zoraCreator1155FactoryImplAddress[999],
+        address: import_protocol_deployments4.zoraCreator1155FactoryImplAddress[999],
         args: [
           contract.uri,
           contract.name,
@@ -1254,7 +1394,7 @@ function create1155CreatorClient({
       };
     } else if (contractExists) {
       const request = {
-        abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+        abi: import_protocol_deployments4.zoraCreator1155ImplABI,
         functionName: "multicall",
         account,
         address: contractAddress,
@@ -1278,18 +1418,31 @@ function create1155CreatorClient({
   Errors,
   MintAPIClient,
   PremintAPIClient,
+  PremintConfigVersion,
+  PreminterDomain,
   ZORA_API_BASE,
   convertCollection,
-  convertPremint,
+  convertPremintV1,
   create1155CreatorClient,
   create1155TokenSetupArgs,
   createMintClient,
   createPremintClient,
   encodePremintForAPI,
-  get1155MintCosts,
+  encodePremintV1ForAPI,
+  encodePremintV2ForAPI,
   getApiNetworkConfigForChain,
+  getMintCosts,
+  getPremintCollectionAddress,
+  getPremintExecutorAddress,
   getPremintedLogFromReceipt,
   getTokenIdFromCreateReceipt,
-  preminterTypedDataDefinition
+  isAuthorizedToCreatePremint,
+  isValidSignature,
+  migratePremintConfigToV2,
+  premintTypedDataDefinition,
+  recoverCreatorFromCreatorAttribution,
+  recoverPremintSigner,
+  supportsPremintVersion,
+  tryRecoverPremintSigner
 });
 //# sourceMappingURL=index.cjs.map