@zoralabs/protocol-sdk 0.3.4 → 0.4.0

package/dist/index.js

@@ -1,60 +1,314 @@
 // src/premint/premint-client.ts
-import { createPublicClient, decodeEventLog, http } from "viem";
+import { createPublicClient, decodeEventLog, http, zeroAddress as zeroAddress2 } from "viem";
 import {
-  zoraCreator1155PremintExecutorImplABI,
-  zoraCreator1155PremintExecutorImplAddress,
+  zoraCreator1155PremintExecutorImplABI as zoraCreator1155PremintExecutorImplABI2,
   zoraCreatorFixedPriceSaleStrategyAddress
 } from "@zoralabs/protocol-deployments";
 
 // src/premint/preminter.ts
-var preminterTypedDataDefinition = ({
+import {
+  zoraCreator1155PremintExecutorImplABI as preminterAbi,
+  zoraCreator1155PremintExecutorImplABI,
+  zoraCreator1155PremintExecutorImplAddress
+} from "@zoralabs/protocol-deployments";
+import {
+  recoverTypedDataAddress,
+  zeroAddress,
+  hashDomain,
+  keccak256,
+  concat,
+  recoverAddress
+} from "viem";
+
+// src/premint/contract-types.ts
+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 = /* @__PURE__ */ ((PremintConfigVersion2) => {
+  PremintConfigVersion2["V1"] = "1";
+  PremintConfigVersion2["V2"] = "2";
+  return PremintConfigVersion2;
+})(PremintConfigVersion || {});
+
+// src/premint/preminter.ts
+var getPremintExecutorAddress = () => 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 === "1" /* V1 */)
+    return {
+      domain,
+      types: v1Types,
+      message: premintConfig,
+      primaryType: "CreatorAttribution"
+    };
+  if (version === "2" /* 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 === "1" /* V1 */) {
+    const [isValidSignature2] = await publicClient.readContract({
+      abi: zoraCreator1155PremintExecutorImplABI,
+      address: getPremintExecutorAddress(),
+      functionName: "isValidSignature",
+      args: [collection, premintConfig, signature]
+    });
+    return isValidSignature2;
+  }
+  return await publicClient.readContract({
+    abi: preminterAbi,
+    address: getPremintExecutorAddress(),
+    functionName: "isAuthorizedToCreatePremint",
+    args: [signer, collection.contractAdmin, collectionAddress]
+  });
+}
+async function recoverPremintSigner({
+  signature,
+  ...rest
+}) {
+  const typedData = premintTypedDataDefinition(rest);
+  return await 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 (!recoverAddress) {
+    return {
+      isAuthorized: false
+    };
+  }
+  const isAuthorized = await isAuthorizedToCreatePremint({
+    signer: recoveredAddress,
+    collection,
+    collectionAddress: tokenContract,
+    publicClient,
+    signature,
+    ...premintConfigAndVersion
+  });
+  return {
+    isAuthorized,
+    recoveredAddress
+  };
+}
+function migratePremintConfigToV2({
+  premintConfig,
+  createReferral = 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 = hashDomain({
     domain: {
       chainId,
-      name: "Preminter",
-      version: "1",
-      verifyingContract
+      name: domainName,
+      verifyingContract: tokenContract,
+      version
     },
-    types,
-    message: {
-      tokenConfig,
-      uid,
-      version,
-      deleted
-    },
-    primaryType: "CreatorAttribution"
+    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 = keccak256(concat(parts));
+  return await recoverAddress({
+    hash: hashedTypedData,
+    signature
+  });
+};
+var supportedPremintVersions = async ({
+  tokenContract,
+  publicClient
+}) => {
+  try {
+    return await publicClient.readContract({
+      abi: preminterAbi,
+      address: getPremintExecutorAddress(),
+      functionName: "supportedPremintSignatureVersions",
+      args: [tokenContract]
+    });
+  } catch (e) {
+    console.error(e);
+    return ["1"];
+  }
+};
+var supportsPremintVersion = async ({
+  version,
+  tokenContract,
+  publicClient
+}) => {
+  return (await supportedPremintVersions({ tokenContract, publicClient })).includes(version);
+};
+async function getPremintCollectionAddress({
+  collection,
+  publicClient
+}) {
+  return publicClient.readContract({
+    address: getPremintExecutorAddress(),
+    abi: zoraCreator1155PremintExecutorImplABI,
+    functionName: "getContractAddress",
+    args: [collection]
+  });
+}
+function markPremintDeleted(premintConfig) {
+  return {
+    ...premintConfig,
+    version: premintConfig.version + 1,
+    deleted: true
+  };
+}
+function applyUpdateToPremint({
+  uid,
+  version,
+  tokenConfig,
+  tokenConfigUpdates
+}) {
+  const updatedTokenConfig = {
+    ...tokenConfig,
+    ...tokenConfigUpdates
+  };
+  const result = {
+    deleted: false,
+    uid,
+    version: version + 1,
+    tokenConfig: updatedTokenConfig
   };
   return result;
-};
+}
+function makeNewPremint({
+  tokenConfig,
+  uid
+}) {
+  return {
+    deleted: false,
+    uid,
+    version: 0,
+    tokenConfig
+  };
+}
 
 // src/apis/http-api-base.ts
 var BadResponseError = class extends Error {
@@ -131,12 +385,17 @@ var httpClient = {
 };
 
 // src/constants.ts
+import { parseAbi } from "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 = 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
 import {
@@ -229,9 +488,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 `);
@@ -243,59 +499,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!) {
-          zoraCreateToken(id: $id) {
-            id
-            salesStrategies(where: {type: "FIXED_PRICE"}) {
-              type
-              fixedPrice {
-                address
-                pricePerToken
-                saleEnd
-                saleStart
-                maxTokensPerAddress
+        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`
         }
       });
-      const fixedPrice = response.data?.zoraCreateToken?.salesStrategies?.find(() => true)?.fixedPrice;
+      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 {
-        address: fixedPrice.address,
-        pricePerToken: BigInt(fixedPrice.pricePerToken)
+        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
@@ -319,39 +580,139 @@ var getSignature = async ({
   uid,
   chain_name,
   httpClient: { retries: retries2, get: get2 } = httpClient
-}) => retries2(
-  () => get2(
-    `${ZORA_API_BASE}premint/signature/${chain_name}/${collection_address}/${uid}`
-  )
-);
+}) => {
+  const result = await retries2(
+    () => get2(
+      `${ZORA_API_BASE}premint/signature/${chain_name}/${collection_address}/${uid}`
+    )
+  );
+  return {
+    ...result,
+    // for now - we stub the backend api to simulate returning v1
+    premint_config_version: "1" /* V1 */
+  };
+};
+var convertCollection = (collection) => ({
+  ...collection,
+  contractAdmin: collection.contractAdmin
+});
+var convertPremintV1 = (premint) => ({
+  ...premint,
+  tokenConfig: {
+    ...premint.tokenConfig,
+    fixedPriceMinter: premint.tokenConfig.fixedPriceMinter,
+    royaltyRecipient: premint.tokenConfig.royaltyRecipient,
+    maxSupply: BigInt(premint.tokenConfig.maxSupply),
+    pricePerToken: BigInt(premint.tokenConfig.pricePerToken),
+    mintStart: BigInt(premint.tokenConfig.mintStart),
+    mintDuration: BigInt(premint.tokenConfig.mintDuration),
+    maxTokensPerAddress: BigInt(premint.tokenConfig.maxTokensPerAddress)
+  }
+});
+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
+}) => ({
+  ...premint,
+  tokenConfig: {
+    ...tokenConfig,
+    maxSupply: tokenConfig.maxSupply.toString(),
+    pricePerToken: tokenConfig.pricePerToken.toString(),
+    mintStart: tokenConfig.mintStart.toString(),
+    mintDuration: tokenConfig.mintDuration.toString(),
+    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
+  }
+});
+var encodePremintForAPI = ({
+  premintConfig,
+  premintConfigVersion
+}) => {
+  if (premintConfigVersion === "1" /* V1 */) {
+    return encodePremintV1ForAPI(premintConfig);
+  }
+  if (premintConfigVersion === "2" /* V2 */) {
+    return encodePremintV2ForAPI(premintConfig);
+  }
+  throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+};
 var PremintAPIClient = class {
   constructor(chainId, httpClient2) {
-    this.postSignature = async (data) => postSignature({
-      ...data,
-      chain_name: this.networkConfig.zoraBackendChainName,
-      httpClient: this.httpClient
-    });
-    this.getNextUID = async (path) => getNextUID({
-      ...path,
+    this.postSignature = async ({
+      collection,
+      premintConfigVersion,
+      premintConfig,
+      signature
+    }) => {
+      if (premintConfigVersion === "1" /* V1 */) {
+        const data = {
+          premint: encodePremintForAPI({
+            premintConfig,
+            premintConfigVersion
+          }),
+          signature,
+          collection
+        };
+        return postSignature({
+          ...data,
+          chain_name: this.networkConfig.zoraBackendChainName,
+          httpClient: this.httpClient
+        });
+      } else {
+        throw new Error("Unsupported premint config version");
+      }
+    };
+    this.getNextUID = async (collectionAddress) => (await getNextUID({
+      collection_address: collectionAddress.toLowerCase(),
       chain_name: this.networkConfig.zoraBackendChainName,
       httpClient: this.httpClient
-    });
+    })).next_uid;
     this.getSignature = async ({
-      collection_address,
+      collectionAddress,
       uid
-    }) => getSignature({
-      collection_address,
-      uid,
-      chain_name: this.networkConfig.zoraBackendChainName,
-      httpClient: this.httpClient
-    });
+    }) => {
+      const response = await getSignature({
+        collection_address: collectionAddress.toLowerCase(),
+        uid,
+        chain_name: this.networkConfig.zoraBackendChainName,
+        httpClient: this.httpClient
+      });
+      const premintConfigVersion = response.premint_config_version || "1" /* V1 */;
+      let premintConfig;
+      if (premintConfigVersion === "1" /* V1 */) {
+        premintConfig = convertPremintV1(response.premint);
+      } else {
+        throw new Error(
+          `Unsupported premint config version: ${premintConfigVersion}`
+        );
+      }
+      return {
+        signature: response.signature,
+        collection: convertCollection(response.collection),
+        premintConfig,
+        premintConfigVersion
+      };
+    };
     this.httpClient = httpClient2 || httpClient;
     this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
 };
 
 // src/premint/premint-client.ts
-var DefaultMintArguments = {
+var defaultTokenConfigV1MintArguments = () => ({
   maxSupply: OPEN_EDITION_MINT_SIZE,
   maxTokensPerAddress: 0n,
   pricePerToken: 0n,
@@ -361,12 +722,47 @@ var DefaultMintArguments = {
   royaltyMintSchedule: 0,
   royaltyBPS: 1e3
   // 10%,
+});
+var defaultTokenConfigV2MintArguments = () => ({
+  maxSupply: OPEN_EDITION_MINT_SIZE,
+  maxTokensPerAddress: 0n,
+  pricePerToken: 0n,
+  mintDuration: BigInt(60 * 60 * 24 * 7),
+  // 1 week
+  mintStart: 0n,
+  royaltyBPS: 1e3
+  // 10%,
+});
+var makeTokenConfigWithDefaults = ({
+  premintConfigVersion,
+  tokenCreationConfig,
+  creatorAccount
+}) => {
+  const fixedPriceMinter = tokenCreationConfig.fixedPriceMinter || getDefaultFixedPriceMinterAddress();
+  if (premintConfigVersion === "1" /* V1 */) {
+    return {
+      fixedPriceMinter,
+      ...defaultTokenConfigV1MintArguments(),
+      royaltyRecipient: creatorAccount,
+      ...tokenCreationConfig
+    };
+  } else if (premintConfigVersion === "2" /* V2 */) {
+    return {
+      fixedPriceMinter,
+      ...defaultTokenConfigV2MintArguments(),
+      payoutRecipient: creatorAccount,
+      createReferral: zeroAddress2,
+      ...tokenCreationConfig
+    };
+  } else {
+    throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+  }
 };
 function getPremintedLogFromReceipt(receipt) {
   for (const data of receipt.logs) {
     try {
       const decodedLog = decodeEventLog({
-        abi: zoraCreator1155PremintExecutorImplABI,
+        abi: zoraCreator1155PremintExecutorImplABI2,
         eventName: "Preminted",
         ...data
       });
@@ -377,62 +773,12 @@ function getPremintedLogFromReceipt(receipt) {
     }
   }
 }
-var convertPremint = (premint) => ({
-  ...premint,
-  tokenConfig: {
-    ...premint.tokenConfig,
-    fixedPriceMinter: premint.tokenConfig.fixedPriceMinter,
-    royaltyRecipient: premint.tokenConfig.royaltyRecipient,
-    maxSupply: BigInt(premint.tokenConfig.maxSupply),
-    pricePerToken: BigInt(premint.tokenConfig.pricePerToken),
-    mintStart: BigInt(premint.tokenConfig.mintStart),
-    mintDuration: BigInt(premint.tokenConfig.mintDuration),
-    maxTokensPerAddress: BigInt(premint.tokenConfig.maxTokensPerAddress)
-  }
-});
-var convertCollection = (collection) => ({
-  ...collection,
-  contractAdmin: collection.contractAdmin
-});
-var encodePremintForAPI = ({
-  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 PremintClient = class {
   constructor(chain, publicClient, httpClient2) {
     this.chain = chain;
     this.apiClient = new PremintAPIClient(chain.id, httpClient2);
     this.publicClient = publicClient || createPublicClient({ chain, transport: 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 zoraCreator1155PremintExecutorImplAddress[999];
-  }
-  /**
-   * The fixed price minter address is the same across all chains for our current
-   * deployer strategy.
-   * Can be overridden as needed by making a parent class.
-   *
-   * @returns Fixed price sale strategy
-   */
-  getFixedPriceMinterAddress() {
-    return zoraCreatorFixedPriceSaleStrategyAddress[999];
-  }
   getDataFromPremintReceipt(receipt) {
     const premintedLog = getPremintedLogFromReceipt(receipt);
     return {
@@ -465,35 +811,31 @@ var PremintClient = class {
     walletClient,
     uid,
     collection,
-    token,
-    account
+    account,
+    tokenConfigUpdates
   }) {
-    const signatureResponse = await this.apiClient.getSignature({
-      collection_address: collection.toLowerCase(),
+    const {
+      premintConfig,
+      collection: collectionCreationConfig,
+      premintConfigVersion
+    } = await this.apiClient.getSignature({
+      collectionAddress: collection,
       uid
     });
-    const convertedPremint = convertPremint(signatureResponse.premint);
-    const signerData = {
-      ...signatureResponse,
-      premint: {
-        ...convertedPremint,
-        tokenConfig: {
-          ...convertedPremint.tokenConfig,
-          ...token
-        }
-      }
-    };
+    const updatedPremint = applyUpdateToPremint({
+      uid: premintConfig.uid,
+      version: premintConfig.version,
+      tokenConfig: premintConfig.tokenConfig,
+      tokenConfigUpdates
+    });
     return await this.signAndSubmitPremint({
       walletClient,
       account,
-      checkSignature: false,
+      checkSignature: true,
       verifyingContract: collection,
-      uid,
-      collection: {
-        ...signerData.collection,
-        contractAdmin: signerData.collection.contractAdmin
-      },
-      premintConfig: signerData.premint
+      collection: collectionCreationConfig,
+      premintConfig: updatedPremint,
+      premintConfigVersion
     });
   }
   /**
@@ -516,26 +858,23 @@ var PremintClient = class {
     account,
     collection
   }) {
-    const signatureResponse = await this.apiClient.getSignature({
-      collection_address: collection.toLowerCase(),
+    const {
+      premintConfig,
+      premintConfigVersion,
+      collection: collectionCreationConfig
+    } = await this.apiClient.getSignature({
+      collectionAddress: collection,
       uid
     });
-    const signerData = {
-      ...signatureResponse,
-      collection: convertCollection(signatureResponse.collection),
-      premint: {
-        ...convertPremint(signatureResponse.premint),
-        deleted: true
-      }
-    };
+    const deletedPremint = markPremintDeleted(premintConfig);
     return await this.signAndSubmitPremint({
       walletClient,
       account,
       checkSignature: false,
       verifyingContract: collection,
-      uid,
-      collection: signerData.collection,
-      premintConfig: signerData.premint
+      collection: collectionCreationConfig,
+      premintConfig: deletedPremint,
+      premintConfigVersion
     });
   }
   /**
@@ -544,46 +883,14 @@ var PremintClient = class {
    * @param premintArguments Arguments to premint
    * @returns
    */
-  async signAndSubmitPremint({
-    walletClient,
-    verifyingContract,
-    premintConfig,
-    uid,
-    account,
-    checkSignature,
-    collection
-  }) {
-    if (!account) {
-      account = walletClient.account;
-    }
-    if (!account) {
-      throw new Error("No account provided");
-    }
-    const signature = await walletClient.signTypedData({
-      account,
-      ...preminterTypedDataDefinition({
-        verifyingContract,
-        premintConfig,
-        chainId: this.chain.id
-      })
+  async signAndSubmitPremint(params) {
+    const { premint, verifyingContract } = await signAndSubmitPremint({
+      ...params,
+      chainId: this.chain.id,
+      apiClient: this.apiClient,
+      publicClient: this.publicClient
     });
-    if (checkSignature) {
-      const [isValidSignature] = await this.publicClient.readContract({
-        abi: zoraCreator1155PremintExecutorImplABI,
-        address: this.getExecutorAddress(),
-        functionName: "isValidSignature",
-        args: [convertCollection(collection), premintConfig, signature]
-      });
-      if (!isValidSignature) {
-        throw new Error("Invalid signature");
-      }
-    }
-    const apiData = {
-      collection,
-      premint: encodePremintForAPI(premintConfig),
-      signature
-    };
-    const premint = await this.apiClient.postSignature(apiData);
+    const uid = params.premintConfig.uid;
     return {
       urls: this.makeUrls({ address: verifyingContract, uid }),
       uid,
@@ -597,58 +904,53 @@ var PremintClient = class {
    * @param settings Settings for the new premint
    * @param settings.account Account to sign the premint with. Taken from walletClient if none passed in.
    * @param settings.collection Collection information for the mint
-   * @param settings.token Mint argument settings, optional settings are overridden with sensible defaults.
-   * @param settings.publicClient Public client (optional) – instantiated if not passed in with defaults.
-   * @param settings.walletClient Required wallet client for signing the premint message.
-   * @param settings.executionSettings Execution settings for premint options
-   * @param settings.executionSettings.deleted If this UID should be deleted. If omitted, set to false.
-   * @param settings.executionSettings.uid the UID to use – optional and retrieved as a fresh UID from ZORA by default.
+   * @param settings.tokenCreationConfig Mint argument settings, optional settings are overridden with sensible defaults.
+   * @param setings.premintConfigVersion Premint config version to use, defaults to V2
+   * @param settings.uid the UID to use – optional and retrieved as a fresh UID from ZORA by default.
    * @param settings.checkSignature if the signature should have a pre-flight check. Not required but helpful for debugging.
    * @returns premint url, uid, newContractAddress, and premint object
    */
   async createPremint({
-    account,
+    creatorAccount,
     collection,
-    token,
+    tokenCreationConfig,
+    premintConfigVersion,
     walletClient,
-    executionSettings,
+    uid,
     checkSignature = false
   }) {
-    const newContractAddress = await this.publicClient.readContract({
-      address: this.getExecutorAddress(),
-      abi: zoraCreator1155PremintExecutorImplABI,
-      functionName: "getContractAddress",
-      args: [convertCollection(collection)]
+    const newContractAddress = await getPremintCollectionAddress({
+      publicClient: this.publicClient,
+      collection
     });
-    const tokenConfig = {
-      ...DefaultMintArguments,
-      fixedPriceMinter: this.getFixedPriceMinterAddress(),
-      royaltyRecipient: account,
-      ...token
-    };
-    let uid = executionSettings?.uid;
-    if (!uid) {
-      const uidResponse = await this.apiClient.getNextUID({
-        collection_address: newContractAddress.toLowerCase()
-      });
-      uid = uidResponse.next_uid;
+    let uidToUse = uid;
+    if (typeof uidToUse !== "number") {
+      uidToUse = await this.apiClient.getNextUID(newContractAddress);
     }
-    if (!uid) {
-      throw new Error("UID is missing but required");
+    const actualVersion = premintConfigVersion || "1" /* V1 */;
+    if (!await supportsPremintVersion({
+      version: actualVersion,
+      publicClient: this.publicClient,
+      tokenContract: newContractAddress
+    })) {
+      throw new Error(
+        `Premint version ${actualVersion} not supported by contract`
+      );
     }
-    let deleted = executionSettings?.deleted || false;
-    const premintConfig = {
-      tokenConfig,
-      uid,
-      version: 1,
-      deleted
-    };
+    const premintConfig = makeNewPremint({
+      tokenConfig: makeTokenConfigWithDefaults({
+        premintConfigVersion: actualVersion,
+        tokenCreationConfig,
+        creatorAccount
+      }),
+      uid: uidToUse
+    });
     return await this.signAndSubmitPremint({
-      uid,
       verifyingContract: newContractAddress,
       premintConfig,
+      premintConfigVersion: actualVersion,
       checkSignature,
-      account,
+      account: creatorAccount,
       walletClient,
       collection
     });
@@ -660,51 +962,59 @@ var PremintClient = class {
    * @param uid UID for the desired premint
    * @returns PremintSignatureGetResponse of premint data from the API
    */
-  async getPremintData({
+  async getPremintSignature({
     address,
     uid
   }) {
     return await this.apiClient.getSignature({
-      collection_address: address,
+      collectionAddress: address,
       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,
+    collection,
+    premintConfig,
+    premintConfigVersion
   }) {
-    const [isValid, contractAddress, recoveredSigner] = await this.publicClient.readContract({
-      abi: 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,
+      collection,
+      publicClient: this.publicClient,
+      premintConfig,
+      premintConfigVersion: premintConfigVersion || "1" /* V1 */
     });
-    return { isValid, contractAddress, recoveredSigner };
+    return { isValid: isAuthorized, recoveredSigner: recoveredAddress };
   }
   makeUrls({
     uid,
     address,
     tokenId
   }) {
-    if ((!uid || !tokenId) && !address) {
-      return { explorer: null, zoraCollect: null, zoraManage: null };
-    }
-    const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
-    const network = getApiNetworkConfigForChain(this.chain.id);
-    return {
-      explorer: tokenId ? `https://${this.chain.blockExplorers?.default.url}/token/${address}/instance/${tokenId}` : null,
-      zoraCollect: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraPathChainName}:${address}/${zoraTokenPath}`,
-      zoraManage: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraPathChainName}:${address}/${zoraTokenPath}`
-    };
+    return makeUrls({
+      uid,
+      address,
+      tokenId,
+      chain: this.chain
+    });
   }
   /**
    * Execute premint on-chain
@@ -719,35 +1029,62 @@ var PremintClient = class {
    * @returns receipt, log, zoraURL
    */
   async makeMintParameters({
-    data,
+    uid,
+    tokenContract,
     account,
     mintArguments
   }) {
     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),
-      data.signature,
-      numberToMint,
-      mintArguments?.mintComment || ""
-    ];
     if (!account) {
       throw new Error("Wallet not passed in");
     }
+    const { premintConfig, premintConfigVersion, collection, signature } = await this.getPremintSignature({
+      address: tokenContract,
+      uid
+    });
+    const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
     const value = numberToMint * REWARD_PER_TOKEN;
-    const request = {
-      account,
-      abi: zoraCreator1155PremintExecutorImplABI,
-      functionName: "premint",
-      value,
-      address: targetAddress,
-      args
-    };
-    return request;
+    if (premintConfigVersion === "1" /* V1 */) {
+      return {
+        account,
+        abi: zoraCreator1155PremintExecutorImplABI2,
+        functionName: "premint",
+        value,
+        address: getPremintExecutorAddress(),
+        args: [
+          collection,
+          premintConfig,
+          signature,
+          numberToMint,
+          mintArguments?.mintComment || ""
+        ]
+      };
+    } else if (premintConfigVersion === "2" /* V2 */) {
+      const toPost = premintConfig;
+      const accountAddress = typeof account === "string" ? account : account.address;
+      return {
+        account,
+        abi: zoraCreator1155PremintExecutorImplABI2,
+        functionName: "premintV2",
+        value,
+        address: getPremintExecutorAddress(),
+        // args are:  ContractCreationConfig calldata contractConfig, PremintConfigV2 calldata premintConfig, bytes calldata signature, uint256 quantityToMint, MintArguments calldata mintArguments
+        args: [
+          collection,
+          toPost,
+          signature,
+          numberToMint,
+          {
+            mintComment: mintArguments?.mintComment || "",
+            mintRecipient: mintArguments?.mintRecipient || accountAddress,
+            mintReferral: mintArguments?.mintReferral || zeroAddress2
+          }
+        ]
+      };
+    }
+    throw new Error(`Invalid premint config version ${premintConfigVersion}`);
   }
 };
 function createPremintClient({
@@ -757,18 +1094,85 @@ function createPremintClient({
 }) {
   return new PremintClient(chain, publicClient, httpClient2);
 }
+function makeUrls({
+  uid,
+  address,
+  tokenId,
+  chain
+}) {
+  if ((!uid || !tokenId) && !address) {
+    return { explorer: null, zoraCollect: null, zoraManage: null };
+  }
+  const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
+  const network = getApiNetworkConfigForChain(chain.id);
+  return {
+    explorer: tokenId ? `https://${chain.blockExplorers?.default.url}/token/${address}/instance/${tokenId}` : null,
+    zoraCollect: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraPathChainName}:${address}/${zoraTokenPath}`,
+    zoraManage: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraPathChainName}:${address}/${zoraTokenPath}`
+  };
+}
+async function signAndSubmitPremint({
+  walletClient,
+  verifyingContract,
+  account,
+  checkSignature,
+  collection,
+  chainId,
+  publicClient,
+  apiClient,
+  ...premintConfigAndVersion
+}) {
+  if (!account) {
+    account = walletClient.account;
+  }
+  if (!account) {
+    throw new Error("No account provided");
+  }
+  const signature = await walletClient.signTypedData({
+    account,
+    ...premintTypedDataDefinition({
+      verifyingContract,
+      ...premintConfigAndVersion,
+      chainId
+    })
+  });
+  if (checkSignature) {
+    const isAuthorized = await isAuthorizedToCreatePremint({
+      collection,
+      signature,
+      publicClient,
+      signer: typeof account === "string" ? account : account.address,
+      collectionAddress: await getPremintCollectionAddress({
+        collection,
+        publicClient
+      }),
+      ...premintConfigAndVersion
+    });
+    if (!isAuthorized) {
+      throw new Error("Not authorized to create premint");
+    }
+  }
+  const premint = await apiClient.postSignature({
+    collection,
+    signature,
+    ...premintConfigAndVersion
+  });
+  return { premint, verifyingContract };
+}
+function getDefaultFixedPriceMinterAddress() {
+  return zoraCreatorFixedPriceSaleStrategyAddress[999];
+}
 
 // src/mint/mint-client.ts
 import {
   createPublicClient as createPublicClient2,
   encodeAbiParameters,
-  parseAbi,
   parseAbiParameters,
-  zeroAddress,
+  zeroAddress as zeroAddress3,
   http as http2
 } from "viem";
 import {
-  zoraCreator1155ImplABI,
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI2,
   zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
 } from "@zoralabs/protocol-deployments";
 var MintError = class extends Error {
@@ -779,30 +1183,11 @@ var Errors = {
   MintError,
   MintInactiveError
 };
-var zora721Abi = 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 || createPublicClient2({ chain, transport: http2() });
   }
-  /**
-   * 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()
-    });
-  }
   /**
    * Returns the parameters needed to prepare a transaction mint a token.
    * @param param0.minterAccount The account that will mint the token.
@@ -819,36 +1204,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,
-        price: BigInt(mintable.cost.native_price.raw),
-        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 +1212,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,34 +1257,17 @@ async function makePrepareMint721TokenParams({
       mintArguments.mintToAddress,
       BigInt(mintArguments.quantityToMint),
       mintArguments.mintComment || "",
-      mintArguments.mintReferral || zeroAddress
+      mintArguments.mintReferral || zeroAddress3
     ]
   };
   return result;
 }
-async function get1155MintFee({
-  collectionAddress,
-  publicClient
-}) {
-  return await publicClient.readContract({
-    abi: zoraCreator1155ImplABI,
-    functionName: "mintFee",
-    address: collectionAddress
-  });
-}
-async function get1155MintCosts({
-  mintable,
-  price,
-  publicClient,
+function getMintCosts({
+  salesConfigAndTokenInfo,
   quantityToMint
 }) {
-  const address = mintable.collection.address;
-  const mintFee = await get1155MintFee({
-    collectionAddress: address,
-    publicClient
-  });
-  const mintFeeForTokens = mintFee * quantityToMint;
-  const tokenPurchaseCost = price * quantityToMint;
+  const mintFeeForTokens = salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
+  const tokenPurchaseCost = BigInt(salesConfigAndTokenInfo.fixedPrice.pricePerToken) * quantityToMint;
   return {
     mintFee: mintFeeForTokens,
     tokenPurchaseCost,
@@ -984,44 +1275,33 @@ 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 tokenFixedPriceMinter = await apiClient.getSalesConfigFixedPrice({
-    contractAddress: address,
-    tokenId: BigInt(mintable.token_id)
-  });
-  const mintValue = (await get1155MintCosts({
-    mintable,
-    price: tokenFixedPriceMinter?.pricePerToken || BigInt(mintable.cost.native_price.raw),
-    publicClient,
+  const mintValue = getMintCosts({
+    salesConfigAndTokenInfo,
     quantityToMint: mintQuantity
-  })).totalCost;
+  }).totalCost;
   const result = {
-    abi: zoraCreator1155ImplABI,
+    abi: zoraCreator1155ImplABI2,
     functionName: "mintWithRewards",
     account: minterAccount,
     value: mintValue,
-    address,
+    address: tokenAddress,
     /* args: minter, tokenId, quantity, minterArguments, mintReferral */
     args: [
-      tokenFixedPriceMinter?.address || zoraCreatorFixedPriceSaleStrategyAddress2[999],
-      BigInt(mintable.token_id),
+      salesConfigAndTokenInfo?.fixedPrice.address || zoraCreatorFixedPriceSaleStrategyAddress2[999],
+      BigInt(tokenId),
       mintQuantity,
       encodeAbiParameters(parseAbiParameters("address, string"), [
         mintArguments.mintToAddress,
         mintArguments.mintComment || ""
       ]),
-      mintArguments.mintReferral || zeroAddress
+      mintArguments.mintReferral || zeroAddress3
     ]
   };
   return result;
@@ -1031,14 +1311,14 @@ async function makePrepareMint1155TokenParams({
 import {
   zoraCreator1155FactoryImplABI,
   zoraCreator1155FactoryImplAddress,
-  zoraCreator1155ImplABI as zoraCreator1155ImplABI2,
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI3,
   zoraCreatorFixedPriceSaleStrategyABI
 } from "@zoralabs/protocol-deployments";
-import { decodeEventLog as decodeEventLog2, encodeFunctionData, zeroAddress as zeroAddress2 } from "viem";
+import { decodeEventLog as decodeEventLog2, encodeFunctionData, zeroAddress as zeroAddress4 } from "viem";
 var SALE_END_FOREVER = 18446744073709551615n;
 var ROYALTY_BPS_DEFAULT = 1e3;
 var DEFAULT_SALE_SETTINGS = {
-  fundsRecipient: zeroAddress2,
+  fundsRecipient: zeroAddress4,
   // Free Mint
   pricePerToken: 0n,
   // Sale start time – defaults to beginning of unix time
@@ -1078,26 +1358,26 @@ function create1155TokenSetupArgs({
   };
   const setupActions = [
     encodeFunctionData({
-      abi: zoraCreator1155ImplABI2,
+      abi: zoraCreator1155ImplABI3,
       functionName: "assumeLastTokenIdMatches",
       args: [nextTokenId - 1n]
     }),
     createReferral ? encodeFunctionData({
-      abi: zoraCreator1155ImplABI2,
+      abi: zoraCreator1155ImplABI3,
       functionName: "setupNewTokenWithCreateReferral",
       args: [tokenMetadataURI, maxSupply, createReferral]
     }) : encodeFunctionData({
-      abi: zoraCreator1155ImplABI2,
+      abi: zoraCreator1155ImplABI3,
       functionName: "setupNewToken",
       args: [tokenMetadataURI, maxSupply]
     }),
     encodeFunctionData({
-      abi: zoraCreator1155ImplABI2,
+      abi: zoraCreator1155ImplABI3,
       functionName: "addPermission",
       args: [0n, fixedPriceMinterAddress, PERMISSION_BIT_MINTER]
     }),
     encodeFunctionData({
-      abi: zoraCreator1155ImplABI2,
+      abi: zoraCreator1155ImplABI3,
       functionName: "callSale",
       args: [
         nextTokenId,
@@ -1113,7 +1393,7 @@ function create1155TokenSetupArgs({
   if (mintToCreatorCount) {
     setupActions.push(
       encodeFunctionData({
-        abi: zoraCreator1155ImplABI2,
+        abi: zoraCreator1155ImplABI3,
         functionName: "adminMint",
         args: [account, nextTokenId, mintToCreatorCount, "0x"]
       })
@@ -1122,7 +1402,7 @@ function create1155TokenSetupArgs({
   if (royaltySettings) {
     setupActions.push(
       encodeFunctionData({
-        abi: zoraCreator1155ImplABI2,
+        abi: zoraCreator1155ImplABI3,
         functionName: "updateRoyaltiesForToken",
         args: [
           nextTokenId,
@@ -1141,7 +1421,7 @@ var getTokenIdFromCreateReceipt = (receipt) => {
   for (const data of receipt.logs) {
     try {
       const decodedLog = decodeEventLog2({
-        abi: zoraCreator1155ImplABI2,
+        abi: zoraCreator1155ImplABI3,
         eventName: "SetupNewToken",
         ...data
       });
@@ -1170,7 +1450,7 @@ async function getContractExists(publicClient, contract, account) {
     });
     try {
       await publicClient.readContract({
-        abi: zoraCreator1155ImplABI2,
+        abi: zoraCreator1155ImplABI3,
         address: contractAddress,
         functionName: "contractVersion"
       });
@@ -1205,7 +1485,7 @@ function create1155CreatorClient({
     let nextTokenId = 1n;
     if (contractExists) {
       nextTokenId = await publicClient.readContract({
-        abi: zoraCreator1155ImplABI2,
+        abi: zoraCreator1155ImplABI3,
         functionName: "nextTokenId",
         address: contractAddress
       });
@@ -1261,7 +1541,7 @@ function create1155CreatorClient({
       };
     } else if (contractExists) {
       const request = {
-        abi: zoraCreator1155ImplABI2,
+        abi: zoraCreator1155ImplABI3,
         functionName: "multicall",
         account,
         address: contractAddress,
@@ -1280,22 +1560,37 @@ function create1155CreatorClient({
 }
 export {
   DEFAULT_SALE_SETTINGS,
-  DefaultMintArguments,
   Errors,
   MintAPIClient,
   PremintAPIClient,
+  PremintConfigVersion,
+  PreminterDomain,
   ZORA_API_BASE,
-  convertCollection,
-  convertPremint,
+  applyUpdateToPremint,
   create1155CreatorClient,
   create1155TokenSetupArgs,
   createMintClient,
   createPremintClient,
-  encodePremintForAPI,
-  get1155MintCosts,
+  defaultTokenConfigV1MintArguments,
+  defaultTokenConfigV2MintArguments,
   getApiNetworkConfigForChain,
+  getMintCosts,
+  getPremintCollectionAddress,
+  getPremintExecutorAddress,
   getPremintedLogFromReceipt,
   getTokenIdFromCreateReceipt,
-  preminterTypedDataDefinition
+  isAuthorizedToCreatePremint,
+  isValidSignature,
+  makeNewPremint,
+  markPremintDeleted,
+  migratePremintConfigToV2,
+  premintTypedDataDefinition,
+  recoverCreatorFromCreatorAttribution,
+  recoverPremintSigner,
+  supportedPremintVersions,
+  supportsPremintVersion,
+  tryRecoverPremintSigner,
+  v1Types,
+  v2Types
 };
 //# sourceMappingURL=index.js.map