@zoralabs/protocol-sdk 0.2.0 → 0.3.1

package/dist/index.js

@@ -355,6 +355,16 @@ var PremintClient = class extends ClientBase {
   getFixedPriceMinterAddress() {
     return 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.
    *
@@ -643,14 +653,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");
     }
@@ -663,34 +670,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: 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) {
@@ -717,18 +719,182 @@ var MintAPIClient = {
   getSalesConfigFixedPrice
 };
 
+// src/mint/mint-client.ts
+import {
+  encodeAbiParameters,
+  parseAbi,
+  parseAbiParameters,
+  zeroAddress
+} from "viem";
+import {
+  zoraCreator1155ImplABI,
+  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
+} from "@zoralabs/protocol-deployments";
+var MintError = class extends Error {
+};
+var MintInactiveError = class extends Error {
+};
+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 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: 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: zoraCreator1155ImplABI,
+      functionName: "mintWithRewards",
+      account: sender,
+      value: (mintFee + BigInt(mintable.cost.native_price.raw)) * mintQuantity,
+      address,
+      /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+      args: [
+        tokenFixedPriceMinter || zoraCreatorFixedPriceSaleStrategyAddress2[999],
+        BigInt(mintable.token_id),
+        mintQuantity,
+        encodeAbiParameters(parseAbiParameters("address, string"), [
+          mintArguments.mintToAddress,
+          mintArguments.mintComment || ""
+        ]),
+        mintArguments.mintReferral || 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 || zeroAddress
+      ]
+    };
+    return result;
+  }
+};
+function createMintClient({
+  chain,
+  mintAPIClient
+}) {
+  return new MintClient(chain, mintAPIClient);
+}
+
 // src/create/1155-create-helper.ts
 import {
   zoraCreator1155FactoryImplABI,
   zoraCreator1155FactoryImplAddress,
-  zoraCreator1155ImplABI,
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI2,
   zoraCreatorFixedPriceSaleStrategyABI
 } from "@zoralabs/protocol-deployments";
-import { decodeEventLog as decodeEventLog2, encodeFunctionData, zeroAddress } from "viem";
+import { decodeEventLog as decodeEventLog2, encodeFunctionData, zeroAddress as zeroAddress2 } from "viem";
 var SALE_END_FOREVER = 18446744073709551615n;
 var ROYALTY_BPS_DEFAULT = 1e3;
 var DEFAULT_SALE_SETTINGS = {
-  fundsRecipient: zeroAddress,
+  fundsRecipient: zeroAddress2,
   // Free Mint
   pricePerToken: 0n,
   // Sale start time – defaults to beginning of unix time
@@ -768,26 +934,26 @@ function create1155TokenSetupArgs({
   };
   const setupActions = [
     encodeFunctionData({
-      abi: zoraCreator1155ImplABI,
-      functionName: "addPermission",
-      args: [0n, fixedPriceMinterAddress, PERMISSION_BIT_MINTER]
-    }),
-    encodeFunctionData({
-      abi: zoraCreator1155ImplABI,
+      abi: zoraCreator1155ImplABI2,
       functionName: "assumeLastTokenIdMatches",
       args: [nextTokenId - 1n]
     }),
     createReferral ? encodeFunctionData({
-      abi: zoraCreator1155ImplABI,
+      abi: zoraCreator1155ImplABI2,
       functionName: "setupNewTokenWithCreateReferral",
       args: [tokenMetadataURI, maxSupply, createReferral]
     }) : encodeFunctionData({
-      abi: zoraCreator1155ImplABI,
+      abi: zoraCreator1155ImplABI2,
       functionName: "setupNewToken",
       args: [tokenMetadataURI, maxSupply]
     }),
     encodeFunctionData({
-      abi: zoraCreator1155ImplABI,
+      abi: zoraCreator1155ImplABI2,
+      functionName: "addPermission",
+      args: [0n, fixedPriceMinterAddress, PERMISSION_BIT_MINTER]
+    }),
+    encodeFunctionData({
+      abi: zoraCreator1155ImplABI2,
       functionName: "callSale",
       args: [
         nextTokenId,
@@ -803,7 +969,7 @@ function create1155TokenSetupArgs({
   if (mintToCreatorCount) {
     setupActions.push(
       encodeFunctionData({
-        abi: zoraCreator1155ImplABI,
+        abi: zoraCreator1155ImplABI2,
         functionName: "adminMint",
         args: [account, nextTokenId, mintToCreatorCount, "0x"]
       })
@@ -812,7 +978,7 @@ function create1155TokenSetupArgs({
   if (royaltySettings) {
     setupActions.push(
       encodeFunctionData({
-        abi: zoraCreator1155ImplABI,
+        abi: zoraCreator1155ImplABI2,
         functionName: "updateRoyaltiesForToken",
         args: [
           nextTokenId,
@@ -831,7 +997,7 @@ var getTokenIdFromCreateReceipt = (receipt) => {
   for (const data of receipt.logs) {
     try {
       const decodedLog = decodeEventLog2({
-        abi: zoraCreator1155ImplABI,
+        abi: zoraCreator1155ImplABI2,
         eventName: "SetupNewToken",
         ...data
       });
@@ -860,7 +1026,7 @@ async function getContractExists(publicClient, contract, account) {
     });
     try {
       await publicClient.readContract({
-        abi: zoraCreator1155ImplABI,
+        abi: zoraCreator1155ImplABI2,
         address: contractAddress,
         functionName: "contractVersion"
       });
@@ -874,107 +1040,113 @@ 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: zoraCreator1155ImplABI,
-      functionName: "nextTokenId",
-      address: contractAddress
-    });
-  }
-  const fixedPriceMinterAddress = await publicClient.readContract({
-    abi: zoraCreator1155FactoryImplABI,
-    address: 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({
+    royaltySettings,
+    getAdditionalSetupActions
+  }) {
+    const { contractExists, contractAddress } = await getContractExists(
+      publicClient,
+      contract,
+      account
+    );
+    let nextTokenId = 1n;
+    if (contractExists) {
+      nextTokenId = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI2,
+        functionName: "nextTokenId",
+        address: contractAddress
+      });
+    }
+    const fixedPriceMinterAddress = await publicClient.readContract({
       abi: zoraCreator1155FactoryImplABI,
-      functionName: "createContractDeterministic",
-      account,
       address: zoraCreator1155FactoryImplAddress[999],
-      args: [
-        contract.uri,
-        contract.name,
-        {
-          // deprecated
-          royaltyMintSchedule: 0,
-          royaltyBPS: royaltySettings?.royaltyBPS || ROYALTY_BPS_DEFAULT,
-          royaltyRecipient: royaltySettings?.royaltyRecipient || account
-        },
-        contract.defaultAdmin || account,
-        tokenSetupActions
-      ]
+      functionName: "fixedPriceMinter"
     });
-    return {
-      send: (walletClient) => walletClient.writeContract(request),
-      tokenSetupActions,
-      contractAddress,
-      contractExists
-    };
-  } else if (contractExists) {
-    const { request } = await publicClient.simulateContract({
-      abi: 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: zoraCreator1155FactoryImplABI,
+        functionName: "createContractDeterministic",
+        account,
+        address: 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: zoraCreator1155ImplABI2,
+        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 };
 }
 export {
   DEFAULT_SALE_SETTINGS,
   DefaultMintArguments,
+  Errors,
   MintAPIClient,
   PremintAPIClient,
-  PremintClient,
   ZORA_API_BASE,
   convertCollection,
   convertPremint,
+  create1155CreatorClient,
   create1155TokenSetupArgs,
-  createNew1155Token,
+  createMintClient,
+  createPremintClient,
   encodePremintForAPI,
   getPremintedLogFromReceipt,
   getSalesConfigFixedPrice,