@zoralabs/protocol-sdk 0.2.0 → 0.3.1

package/dist/index.cjs

@@ -22,14 +22,16 @@ var src_exports = {};
 __export(src_exports, {
   DEFAULT_SALE_SETTINGS: () => DEFAULT_SALE_SETTINGS,
   DefaultMintArguments: () => DefaultMintArguments,
+  Errors: () => Errors,
   MintAPIClient: () => MintAPIClient,
   PremintAPIClient: () => PremintAPIClient,
-  PremintClient: () => PremintClient,
   ZORA_API_BASE: () => ZORA_API_BASE,
   convertCollection: () => convertCollection,
   convertPremint: () => convertPremint,
+  create1155CreatorClient: () => create1155CreatorClient,
   create1155TokenSetupArgs: () => create1155TokenSetupArgs,
-  createNew1155Token: () => createNew1155Token,
+  createMintClient: () => createMintClient,
+  createPremintClient: () => createPremintClient,
   encodePremintForAPI: () => encodePremintForAPI,
   getPremintedLogFromReceipt: () => getPremintedLogFromReceipt,
   getSalesConfigFixedPrice: () => getSalesConfigFixedPrice,
@@ -381,6 +383,16 @@ var PremintClient = class extends ClientBase {
   getFixedPriceMinterAddress() {
     return import_protocol_deployments.zoraCreatorFixedPriceSaleStrategyAddress[999];
   }
+  getDataFromPremintReceipt(receipt) {
+    const premintedLog = getPremintedLogFromReceipt(receipt);
+    return {
+      premintedLog,
+      urls: this.makeUrls({
+        address: premintedLog?.contractAddress,
+        tokenId: premintedLog?.tokenId
+      })
+    };
+  }
   /**
    * Update existing premint given collection address and UID of existing premint.
    *
@@ -669,14 +681,11 @@ var PremintClient = class extends ClientBase {
    * @param settings.publicClient Optional public client for preflight checks.
    * @returns receipt, log, zoraURL
    */
-  async executePremintWithWallet({
+  async executePremint({
     data,
     account,
-    walletClient,
-    mintArguments,
-    publicClient
+    mintArguments
   }) {
-    publicClient = this.getPublicClient(publicClient);
     if (mintArguments && mintArguments?.quantityToMint < 1) {
       throw new Error("Quantity to mint cannot be below 1");
     }
@@ -689,34 +698,29 @@ var PremintClient = class extends ClientBase {
       numberToMint,
       mintArguments?.mintComment || ""
     ];
-    if (!account) {
-      account = walletClient.account;
-    }
     if (!account) {
       throw new Error("Wallet not passed in");
     }
     const value = numberToMint * REWARD_PER_TOKEN;
-    const { request } = await publicClient.simulateContract({
+    const request = {
       account,
       abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
       functionName: "premint",
       value,
       address: targetAddress,
       args
-    });
-    const hash = await walletClient.writeContract(request);
-    const receipt = await publicClient.waitForTransactionReceipt({ hash });
-    const premintedLog = getPremintedLogFromReceipt(receipt);
+    };
     return {
-      receipt,
-      premintedLog,
-      urls: this.makeUrls({
-        address: premintedLog?.contractAddress,
-        tokenId: premintedLog?.tokenId
-      })
+      request
     };
   }
 };
+function createPremintClient({
+  chain,
+  premintAPIClient
+}) {
+  return new PremintClient(chain, premintAPIClient);
+}
 
 // src/mint/mint-api-client.ts
 function encodeQueryParameters(params) {
@@ -743,13 +747,169 @@ var MintAPIClient = {
   getSalesConfigFixedPrice
 };
 
-// src/create/1155-create-helper.ts
-var import_protocol_deployments2 = require("@zoralabs/protocol-deployments");
+// src/mint/mint-client.ts
 var import_viem4 = require("viem");
+var import_protocol_deployments2 = require("@zoralabs/protocol-deployments");
+var MintError = class extends Error {
+};
+var MintInactiveError = class extends Error {
+};
+var Errors = {
+  MintError,
+  MintInactiveError
+};
+var zora721Abi = (0, import_viem4.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 extends ClientBase {
+  constructor(chain, apiClient) {
+    super(chain);
+    if (!apiClient) {
+      apiClient = MintAPIClient;
+    }
+    this.apiClient = apiClient;
+  }
+  async getMintable({
+    tokenContract,
+    tokenId
+  }) {
+    return this.apiClient.getMintable(
+      {
+        chain_name: this.network.zoraBackendChainName,
+        collection_address: tokenContract
+      },
+      { token_id: tokenId?.toString() }
+    );
+  }
+  async makePrepareMintTokenParams({
+    publicClient,
+    minterAccount,
+    mintable,
+    mintArguments
+  }) {
+    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.`
+      );
+    }
+    const thisPublicClient = this.getPublicClient(publicClient);
+    if (mintable.mint_context.mint_context_type === "zora_create_1155") {
+      return {
+        simulateContractParameters: await this.prepareMintZora1155({
+          publicClient: thisPublicClient,
+          mintArguments,
+          sender: minterAccount,
+          mintable
+        })
+      };
+    }
+    if (mintable.mint_context.mint_context_type === "zora_create") {
+      return {
+        simulateContractParameters: await this.prepareMintZora721({
+          publicClient: thisPublicClient,
+          mintArguments,
+          sender: minterAccount,
+          mintable
+        })
+      };
+    }
+    throw new Error("Mintable type not found or recognized.");
+  }
+  async prepareMintZora1155({
+    mintable,
+    sender,
+    publicClient,
+    mintArguments
+  }) {
+    const mintQuantity = BigInt(mintArguments.quantityToMint);
+    const address = mintable.collection.address;
+    const mintFee = await publicClient.readContract({
+      abi: import_protocol_deployments2.zoraCreator1155ImplABI,
+      functionName: "mintFee",
+      address
+    });
+    const tokenFixedPriceMinter = await this.apiClient.getSalesConfigFixedPrice(
+      {
+        contractAddress: mintable.contract_address,
+        tokenId: mintable.token_id,
+        subgraphUrl: this.network.subgraphUrl
+      }
+    );
+    const result = {
+      abi: import_protocol_deployments2.zoraCreator1155ImplABI,
+      functionName: "mintWithRewards",
+      account: sender,
+      value: (mintFee + BigInt(mintable.cost.native_price.raw)) * mintQuantity,
+      address,
+      /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+      args: [
+        tokenFixedPriceMinter || import_protocol_deployments2.zoraCreatorFixedPriceSaleStrategyAddress[999],
+        BigInt(mintable.token_id),
+        mintQuantity,
+        (0, import_viem4.encodeAbiParameters)((0, import_viem4.parseAbiParameters)("address, string"), [
+          mintArguments.mintToAddress,
+          mintArguments.mintComment || ""
+        ]),
+        mintArguments.mintReferral || import_viem4.zeroAddress
+      ]
+    };
+    return result;
+  }
+  async prepareMintZora721({
+    mintable,
+    publicClient,
+    sender,
+    mintArguments
+  }) {
+    const [_, mintFee] = await publicClient.readContract({
+      abi: zora721Abi,
+      address: mintable.contract_address,
+      functionName: "zoraFeeForAmount",
+      args: [BigInt(mintArguments.quantityToMint)]
+    });
+    const result = {
+      abi: zora721Abi,
+      address: mintable.contract_address,
+      account: sender,
+      functionName: "mintWithRewards",
+      value: mintFee + BigInt(mintable.cost.native_price.raw) * BigInt(mintArguments.quantityToMint),
+      /* args: mint recipient, quantity to mint, mint comment, mintReferral */
+      args: [
+        mintArguments.mintToAddress,
+        BigInt(mintArguments.quantityToMint),
+        mintArguments.mintComment || "",
+        mintArguments.mintReferral || import_viem4.zeroAddress
+      ]
+    };
+    return result;
+  }
+};
+function createMintClient({
+  chain,
+  mintAPIClient
+}) {
+  return new MintClient(chain, mintAPIClient);
+}
+
+// src/create/1155-create-helper.ts
+var import_protocol_deployments3 = require("@zoralabs/protocol-deployments");
+var import_viem5 = require("viem");
 var SALE_END_FOREVER = 18446744073709551615n;
 var ROYALTY_BPS_DEFAULT = 1e3;
 var DEFAULT_SALE_SETTINGS = {
-  fundsRecipient: import_viem4.zeroAddress,
+  fundsRecipient: import_viem5.zeroAddress,
   // Free Mint
   pricePerToken: 0n,
   // Sale start time – defaults to beginning of unix time
@@ -788,33 +948,33 @@ function create1155TokenSetupArgs({
     ...salesConfig
   };
   const setupActions = [
-    (0, import_viem4.encodeFunctionData)({
-      abi: import_protocol_deployments2.zoraCreator1155ImplABI,
-      functionName: "addPermission",
-      args: [0n, fixedPriceMinterAddress, PERMISSION_BIT_MINTER]
-    }),
-    (0, import_viem4.encodeFunctionData)({
-      abi: import_protocol_deployments2.zoraCreator1155ImplABI,
+    (0, import_viem5.encodeFunctionData)({
+      abi: import_protocol_deployments3.zoraCreator1155ImplABI,
       functionName: "assumeLastTokenIdMatches",
       args: [nextTokenId - 1n]
     }),
-    createReferral ? (0, import_viem4.encodeFunctionData)({
-      abi: import_protocol_deployments2.zoraCreator1155ImplABI,
+    createReferral ? (0, import_viem5.encodeFunctionData)({
+      abi: import_protocol_deployments3.zoraCreator1155ImplABI,
       functionName: "setupNewTokenWithCreateReferral",
       args: [tokenMetadataURI, maxSupply, createReferral]
-    }) : (0, import_viem4.encodeFunctionData)({
-      abi: import_protocol_deployments2.zoraCreator1155ImplABI,
+    }) : (0, import_viem5.encodeFunctionData)({
+      abi: import_protocol_deployments3.zoraCreator1155ImplABI,
       functionName: "setupNewToken",
       args: [tokenMetadataURI, maxSupply]
     }),
-    (0, import_viem4.encodeFunctionData)({
-      abi: import_protocol_deployments2.zoraCreator1155ImplABI,
+    (0, import_viem5.encodeFunctionData)({
+      abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+      functionName: "addPermission",
+      args: [0n, fixedPriceMinterAddress, PERMISSION_BIT_MINTER]
+    }),
+    (0, import_viem5.encodeFunctionData)({
+      abi: import_protocol_deployments3.zoraCreator1155ImplABI,
       functionName: "callSale",
       args: [
         nextTokenId,
         fixedPriceMinterAddress,
-        (0, import_viem4.encodeFunctionData)({
-          abi: import_protocol_deployments2.zoraCreatorFixedPriceSaleStrategyABI,
+        (0, import_viem5.encodeFunctionData)({
+          abi: import_protocol_deployments3.zoraCreatorFixedPriceSaleStrategyABI,
           functionName: "setSale",
           args: [nextTokenId, salesConfigWithDefaults]
         })
@@ -823,8 +983,8 @@ function create1155TokenSetupArgs({
   ];
   if (mintToCreatorCount) {
     setupActions.push(
-      (0, import_viem4.encodeFunctionData)({
-        abi: import_protocol_deployments2.zoraCreator1155ImplABI,
+      (0, import_viem5.encodeFunctionData)({
+        abi: import_protocol_deployments3.zoraCreator1155ImplABI,
         functionName: "adminMint",
         args: [account, nextTokenId, mintToCreatorCount, "0x"]
       })
@@ -832,8 +992,8 @@ function create1155TokenSetupArgs({
   }
   if (royaltySettings) {
     setupActions.push(
-      (0, import_viem4.encodeFunctionData)({
-        abi: import_protocol_deployments2.zoraCreator1155ImplABI,
+      (0, import_viem5.encodeFunctionData)({
+        abi: import_protocol_deployments3.zoraCreator1155ImplABI,
         functionName: "updateRoyaltiesForToken",
         args: [
           nextTokenId,
@@ -851,8 +1011,8 @@ function create1155TokenSetupArgs({
 var getTokenIdFromCreateReceipt = (receipt) => {
   for (const data of receipt.logs) {
     try {
-      const decodedLog = (0, import_viem4.decodeEventLog)({
-        abi: import_protocol_deployments2.zoraCreator1155ImplABI,
+      const decodedLog = (0, import_viem5.decodeEventLog)({
+        abi: import_protocol_deployments3.zoraCreator1155ImplABI,
         eventName: "SetupNewToken",
         ...data
       });
@@ -868,9 +1028,9 @@ async function getContractExists(publicClient, contract, account) {
   let contractExists = false;
   if (typeof contract !== "string") {
     contractAddress = await publicClient.readContract({
-      abi: import_protocol_deployments2.zoraCreator1155FactoryImplABI,
+      abi: import_protocol_deployments3.zoraCreator1155FactoryImplABI,
       // Since this address is deterministic we can hardcode a chain id safely here.
-      address: import_protocol_deployments2.zoraCreator1155FactoryImplAddress[999],
+      address: import_protocol_deployments3.zoraCreator1155FactoryImplAddress[999],
       functionName: "deterministicContractAddress",
       args: [
         account,
@@ -881,7 +1041,7 @@ async function getContractExists(publicClient, contract, account) {
     });
     try {
       await publicClient.readContract({
-        abi: import_protocol_deployments2.zoraCreator1155ImplABI,
+        abi: import_protocol_deployments3.zoraCreator1155ImplABI,
         address: contractAddress,
         functionName: "contractVersion"
       });
@@ -895,108 +1055,114 @@ async function getContractExists(publicClient, contract, account) {
     contractAddress: contract
   };
 }
-async function createNew1155Token({
-  publicClient,
-  contract,
-  tokenMetadataURI,
-  mintToCreatorCount = 1,
-  salesConfig = {},
-  maxSupply,
-  account,
-  royaltySettings,
-  getAdditionalSetupActions
+function create1155CreatorClient({
+  publicClient
 }) {
-  const { contractExists, contractAddress } = await getContractExists(
-    publicClient,
+  async function createNew1155Token({
     contract,
-    account
-  );
-  let nextTokenId = 1n;
-  if (contractExists) {
-    nextTokenId = await publicClient.readContract({
-      abi: import_protocol_deployments2.zoraCreator1155ImplABI,
-      functionName: "nextTokenId",
-      address: contractAddress
-    });
-  }
-  const fixedPriceMinterAddress = await publicClient.readContract({
-    abi: import_protocol_deployments2.zoraCreator1155FactoryImplABI,
-    address: import_protocol_deployments2.zoraCreator1155FactoryImplAddress[999],
-    functionName: "fixedPriceMinter"
-  });
-  let tokenSetupActions = create1155TokenSetupArgs({
     tokenMetadataURI,
-    nextTokenId,
-    salesConfig,
+    mintToCreatorCount = 1,
+    salesConfig = {},
     maxSupply,
-    fixedPriceMinterAddress,
     account,
-    mintToCreatorCount,
-    royaltySettings
-  });
-  if (getAdditionalSetupActions) {
-    tokenSetupActions = [
-      ...getAdditionalSetupActions({ tokenId: nextTokenId, contractAddress }),
-      ...tokenSetupActions
-    ];
-  }
-  if (!contractAddress && typeof contract === "string") {
-    throw new Error("Invariant: contract cannot be missing and an address");
-  }
-  if (!contractExists && typeof contract !== "string") {
-    const { request } = await publicClient.simulateContract({
-      abi: import_protocol_deployments2.zoraCreator1155FactoryImplABI,
-      functionName: "createContractDeterministic",
-      account,
-      address: import_protocol_deployments2.zoraCreator1155FactoryImplAddress[999],
-      args: [
-        contract.uri,
-        contract.name,
-        {
-          // deprecated
-          royaltyMintSchedule: 0,
-          royaltyBPS: royaltySettings?.royaltyBPS || ROYALTY_BPS_DEFAULT,
-          royaltyRecipient: royaltySettings?.royaltyRecipient || account
-        },
-        contract.defaultAdmin || account,
-        tokenSetupActions
-      ]
+    royaltySettings,
+    getAdditionalSetupActions
+  }) {
+    const { contractExists, contractAddress } = await getContractExists(
+      publicClient,
+      contract,
+      account
+    );
+    let nextTokenId = 1n;
+    if (contractExists) {
+      nextTokenId = await publicClient.readContract({
+        abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+        functionName: "nextTokenId",
+        address: contractAddress
+      });
+    }
+    const fixedPriceMinterAddress = await publicClient.readContract({
+      abi: import_protocol_deployments3.zoraCreator1155FactoryImplABI,
+      address: import_protocol_deployments3.zoraCreator1155FactoryImplAddress[999],
+      functionName: "fixedPriceMinter"
     });
-    return {
-      send: (walletClient) => walletClient.writeContract(request),
-      tokenSetupActions,
-      contractAddress,
-      contractExists
-    };
-  } else if (contractExists) {
-    const { request } = await publicClient.simulateContract({
-      abi: import_protocol_deployments2.zoraCreator1155ImplABI,
-      functionName: "multicall",
+    let tokenSetupActions = create1155TokenSetupArgs({
+      tokenMetadataURI,
+      nextTokenId,
+      salesConfig,
+      maxSupply,
+      fixedPriceMinterAddress,
       account,
-      address: contractAddress,
-      args: [tokenSetupActions]
+      mintToCreatorCount,
+      royaltySettings
     });
-    return {
-      send: (walletClient) => walletClient.writeContract(request),
-      tokenSetupActions,
-      contractAddress,
-      contractExists
-    };
+    if (getAdditionalSetupActions) {
+      tokenSetupActions = [
+        ...getAdditionalSetupActions({ tokenId: nextTokenId, contractAddress }),
+        ...tokenSetupActions
+      ];
+    }
+    if (!contractAddress && typeof contract === "string") {
+      throw new Error("Invariant: contract cannot be missing and an address");
+    }
+    if (!contractExists && typeof contract !== "string") {
+      const request = {
+        abi: import_protocol_deployments3.zoraCreator1155FactoryImplABI,
+        functionName: "createContractDeterministic",
+        account,
+        address: import_protocol_deployments3.zoraCreator1155FactoryImplAddress[999],
+        args: [
+          contract.uri,
+          contract.name,
+          {
+            // deprecated
+            royaltyMintSchedule: 0,
+            royaltyBPS: royaltySettings?.royaltyBPS || ROYALTY_BPS_DEFAULT,
+            royaltyRecipient: royaltySettings?.royaltyRecipient || account
+          },
+          contract.defaultAdmin || account,
+          tokenSetupActions
+        ]
+      };
+      return {
+        request,
+        tokenSetupActions,
+        contractAddress,
+        contractExists
+      };
+    } else if (contractExists) {
+      const request = {
+        abi: import_protocol_deployments3.zoraCreator1155ImplABI,
+        functionName: "multicall",
+        account,
+        address: contractAddress,
+        args: [tokenSetupActions]
+      };
+      return {
+        request,
+        tokenSetupActions,
+        contractAddress,
+        contractExists
+      };
+    }
+    throw new Error("Unsupported contract argument type");
   }
-  throw new Error("Unsupported contract argument type");
+  return { createNew1155Token };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_SALE_SETTINGS,
   DefaultMintArguments,
+  Errors,
   MintAPIClient,
   PremintAPIClient,
-  PremintClient,
   ZORA_API_BASE,
   convertCollection,
   convertPremint,
+  create1155CreatorClient,
   create1155TokenSetupArgs,
-  createNew1155Token,
+  createMintClient,
+  createPremintClient,
   encodePremintForAPI,
   getPremintedLogFromReceipt,
   getSalesConfigFixedPrice,