@zoralabs/protocol-sdk 0.8.0 → 0.9.1

package/src/create/1155-create-helper.test.ts

@@ -4,18 +4,22 @@ import {
   getTokenIdFromCreateReceipt,
 } from "./1155-create-helper";
 import { createCreatorClient } from "src/sdk";
-import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
-import { waitForSuccess } from "src/test-utils";
-import { parseEther } from "viem";
 import {
-  MintableParameters,
-  makePrepareMint1155TokenParams,
-} from "src/mint/mint-transactions";
+  zoraCreator1155ImplABI,
+  zoraTimedSaleStrategyAddress,
+} from "@zoralabs/protocol-deployments";
+import { waitForSuccess } from "src/test-utils";
+import { Address, parseEther, PublicClient, TransactionReceipt } from "viem";
+import { makePrepareMint1155TokenParams } from "src/mint/mint-transactions";
 import { forkUrls, makeAnvilTest } from "src/anvil";
 import { zora } from "viem/chains";
+import { AllowList } from "src/allow-list/types";
+import { createAllowList } from "src/allow-list/allow-list-client";
+import { NewContractParams } from "./types";
 
-const demoTokenMetadataURI = "ipfs://DUMMY/token.json";
-const demoContractMetadataURI = "ipfs://DUMMY/contract.json";
+export const demoTokenMetadataURI =
+  "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u";
+export const demoContractMetadataURI = "ipfs://DUMMY/contract.json";
 
 const anvilTest = makeAnvilTest({
   forkUrl: forkUrls.zoraMainnet,
@@ -23,9 +27,46 @@ const anvilTest = makeAnvilTest({
   anvilChainId: zora.id,
 });
 
+const PERMISSION_BITS = {
+  MINTER: 2n ** 2n,
+};
+
+const minterIsMinterOnToken = async ({
+  publicClient,
+  contractAddress,
+  tokenId,
+  minter,
+}: {
+  publicClient: Pick<PublicClient, "readContract">;
+  contractAddress: Address;
+  tokenId: bigint;
+  minter: Address;
+}) => {
+  return await publicClient.readContract({
+    abi: zoraCreator1155ImplABI,
+    address: contractAddress,
+    functionName: "isAdminOrRole",
+    args: [minter, tokenId, PERMISSION_BITS.MINTER],
+  });
+};
+
+function logFailure(receipt: TransactionReceipt) {
+  if (receipt.status !== "success") {
+    console.log("transaction failed");
+    console.log(receipt.logs);
+  }
+}
+
+function randomNewContract(): NewContractParams {
+  return {
+    name: `testContract-${Math.round(Math.random() * 1_000_000)}`,
+    uri: demoContractMetadataURI,
+  };
+}
+
 describe("create-helper", () => {
   anvilTest(
-    "creates a new 1155 contract and token",
+    "when no sales config is provided, it creates a new 1155 contract and token using the timed sale strategy",
     async ({ viemClients: { publicClient, walletClient, chain } }) => {
       const addresses = await walletClient.getAddresses();
       const creatorAddress = addresses[0]!;
@@ -34,32 +75,95 @@ describe("create-helper", () => {
         chainId: chain.id,
         publicClient: publicClient,
       });
-      const { parameters, contractAddress: collectionAddress } =
-        await creatorClient.create1155({
-          contract: {
-            name: "testContract",
-            uri: demoContractMetadataURI,
-          },
-          token: {
-            tokenMetadataURI: demoTokenMetadataURI,
-            mintToCreatorCount: 1,
-          },
-          account: creatorAddress,
-        });
+      const {
+        parameters: parameters,
+        contractAddress,
+        newTokenId,
+      } = await creatorClient.create1155({
+        contract: randomNewContract(),
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+          mintToCreatorCount: 1,
+        },
+        account: creatorAddress,
+      });
+
       const { request } = await publicClient.simulateContract(parameters);
       const hash = await walletClient.writeContract(request);
       const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      logFailure(receipt);
+      expect(receipt.status).toBe("success");
       expect(receipt).not.toBeNull();
       expect(receipt.to).to.equal("0x777777c338d93e2c7adf08d102d45ca7cc4ed021");
       expect(getTokenIdFromCreateReceipt(receipt)).to.be.equal(1n);
       expect(getContractAddressFromReceipt(receipt)).to.be.equal(
-        collectionAddress,
+        contractAddress,
       );
+
+      expect(
+        await minterIsMinterOnToken({
+          contractAddress,
+          tokenId: newTokenId,
+          publicClient,
+          minter:
+            zoraTimedSaleStrategyAddress[
+              chain.id as keyof typeof zoraTimedSaleStrategyAddress
+            ],
+        }),
+      ).toBe(true);
     },
     20 * 1000,
   );
   anvilTest(
-    "creates a new contract, then can create a new token on this existing contract",
+    "when price is set to 0, it creates a new 1155 contract and token using the timed sale strategy",
+    async ({ viemClients: { publicClient, walletClient, chain } }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAddress = addresses[0]!;
+
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient: publicClient,
+      });
+      const {
+        parameters: parameters,
+        contractAddress,
+        newTokenId,
+      } = await creatorClient.create1155({
+        contract: randomNewContract(),
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+          salesConfig: {
+            pricePerToken: 0n,
+          },
+        },
+        account: creatorAddress,
+      });
+
+      const { request } = await publicClient.simulateContract(parameters);
+      const hash = await walletClient.writeContract(request);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+      logFailure(receipt);
+
+      expect(receipt.status).toBe("success");
+
+      expect(
+        await minterIsMinterOnToken({
+          contractAddress,
+          tokenId: newTokenId,
+          minter:
+            zoraTimedSaleStrategyAddress[
+              chain.id as keyof typeof zoraTimedSaleStrategyAddress
+            ],
+          publicClient,
+        }),
+      ).toBe(true);
+    },
+    20 * 1000,
+  );
+
+  anvilTest(
+    "can create a new contract, then can create a new token on this existing contract",
     async ({ viemClients: { publicClient, walletClient, chain } }) => {
       const addresses = await walletClient.getAddresses();
       const creatorAccount = addresses[0]!;
@@ -71,10 +175,7 @@ describe("create-helper", () => {
 
       const { parameters: request, contractAddress: contractAddress } =
         await creatorClient.create1155({
-          contract: {
-            name: "testContract2",
-            uri: demoContractMetadataURI,
-          },
+          contract: randomNewContract(),
           token: {
             tokenMetadataURI: demoTokenMetadataURI,
             mintToCreatorCount: 3,
@@ -85,6 +186,8 @@ describe("create-helper", () => {
         await publicClient.simulateContract(request);
       const hash = await walletClient.writeContract(simulateResponse);
       const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      logFailure(receipt);
+      expect(receipt.status).toBe("success");
       const firstTokenId = getTokenIdFromCreateReceipt(receipt);
       expect(firstTokenId).to.be.equal(1n);
       expect(receipt).not.toBeNull();
@@ -115,9 +218,12 @@ describe("create-helper", () => {
       const newReceipt = await publicClient.waitForTransactionReceipt({
         hash: newHash,
       });
+
+      logFailure(receipt);
+
+      expect(newReceipt.status).toBe("success");
       const tokenId = getTokenIdFromCreateReceipt(newReceipt);
       expect(tokenId).to.be.equal(2n);
-      expect(newReceipt).not.toBeNull();
     },
     20 * 1000,
   );
@@ -137,10 +243,7 @@ describe("create-helper", () => {
         contractAddress: collectionAddress,
         newTokenId,
       } = await creatorClient.create1155({
-        contract: {
-          name: "testContract",
-          uri: demoContractMetadataURI,
-        },
+        contract: randomNewContract(),
         token: {
           tokenMetadataURI: demoTokenMetadataURI,
           createReferral,
@@ -151,7 +254,7 @@ describe("create-helper", () => {
         await publicClient.simulateContract(request);
       const hash = await walletClient.writeContract(simulationResponse);
       const receipt = await publicClient.waitForTransactionReceipt({ hash });
-      expect(receipt).not.toBeNull();
+      expect(receipt.status).toBe("success");
       expect(receipt.to).to.equal("0x777777c338d93e2c7adf08d102d45ca7cc4ed021");
       expect(getTokenIdFromCreateReceipt(receipt)).to.be.equal(newTokenId);
 
@@ -179,23 +282,14 @@ describe("create-helper", () => {
         chainId: chain.id,
         publicClient: publicClient,
       });
-      const {
-        parameters: request,
-        newTokenId,
-        newToken,
-        minter,
-        contractAddress: collectionAddress,
-        contractVersion,
-      } = await creatorClient.create1155({
-        contract: {
-          name: "testContract",
-          uri: demoContractMetadataURI,
-        },
-        token: {
-          tokenMetadataURI: demoTokenMetadataURI,
-        },
-        account: creatorAddress,
-      });
+      const { parameters: request, prepareMint } =
+        await creatorClient.create1155({
+          contract: randomNewContract(),
+          token: {
+            tokenMetadataURI: demoTokenMetadataURI,
+          },
+          account: creatorAddress,
+        });
       const { request: createSimulation } =
         await publicClient.simulateContract(request);
       await waitForSuccess(
@@ -203,20 +297,6 @@ describe("create-helper", () => {
         publicClient,
       );
 
-      const salesConfigAndTokenInfo: MintableParameters = {
-        mintFeePerQuantity: parseEther("0.000777"),
-        contractVersion,
-        salesConfig: {
-          saleType: "fixedPrice",
-          address: minter,
-          pricePerToken: newToken.salesConfig.pricePerToken,
-          // these dont matter
-          maxTokensPerAddress: 0n,
-          saleEnd: "",
-          saleStart: "",
-        },
-      };
-
       const quantityToMint = 5n;
 
       // now try to mint a free mint
@@ -227,11 +307,8 @@ describe("create-helper", () => {
         value: parseEther("10"),
       });
 
-      const mintParams = makePrepareMint1155TokenParams({
-        tokenContract: collectionAddress,
+      const { parameters: mintParams } = await prepareMint({
         minterAccount: minterAddress,
-        tokenId: newTokenId,
-        salesConfigAndTokenInfo,
         quantityToMint,
       });
 
@@ -246,7 +323,7 @@ describe("create-helper", () => {
   );
 
   anvilTest(
-    "creates a new 1155 paid mint that can be minted",
+    "creates a new 1155 paid mint that can be minted using the fixed price minter",
     async ({
       viemClients: { testClient, publicClient, walletClient, chain },
     }) => {
@@ -264,14 +341,10 @@ describe("create-helper", () => {
         parameters: request,
         contractAddress: collectionAddress,
         newTokenId,
-        newToken,
         minter,
         contractVersion,
       } = await creatorClient.create1155({
-        contract: {
-          name: "testContract",
-          uri: demoContractMetadataURI,
-        },
+        contract: randomNewContract(),
         token: {
           tokenMetadataURI: demoTokenMetadataURI,
           salesConfig: {
@@ -287,20 +360,6 @@ describe("create-helper", () => {
         publicClient,
       );
 
-      const salesConfigAndTokenInfo: MintableParameters = {
-        mintFeePerQuantity: parseEther("0.000777"),
-        contractVersion,
-        salesConfig: {
-          saleType: "fixedPrice",
-          address: minter,
-          pricePerToken: newToken.salesConfig.pricePerToken,
-          // these dont matter
-          maxTokensPerAddress: 0n,
-          saleEnd: "",
-          saleStart: "",
-        },
-      };
-
       const quantityToMint = 5n;
 
       // now try to mint a free mint
@@ -315,7 +374,23 @@ describe("create-helper", () => {
         tokenContract: collectionAddress,
         minterAccount: minterAddress,
         tokenId: newTokenId,
-        salesConfigAndTokenInfo,
+        salesConfigAndTokenInfo: {
+          contractVersion,
+          salesConfig: {
+            mintFeePerQuantity: await publicClient.readContract({
+              abi: zoraCreator1155ImplABI,
+              functionName: "mintFee",
+              address: collectionAddress,
+            }),
+            saleType: "fixedPrice",
+            address: minter,
+            pricePerToken,
+            // these dont matter
+            maxTokensPerAddress: 0n,
+            saleEnd: "",
+            saleStart: "",
+          },
+        },
         quantityToMint,
       });
 
@@ -328,4 +403,57 @@ describe("create-helper", () => {
     },
     20 * 1000,
   );
+
+  anvilTest(
+    "creates an allow list mint contract",
+    async ({ viemClients: { publicClient, walletClient, chain } }) => {
+      const creator = (await walletClient.getAddresses())[0]!;
+      const allowList: AllowList = {
+        entries: [
+          {
+            user: "0xf69fEc6d858c77e969509843852178bd24CAd2B6",
+            price: 2n,
+            maxCanMint: 10000,
+          },
+          {
+            user: "0xcD08da546414dd463C89705B5E72CE1AeebF1567",
+            price: 3n,
+            maxCanMint: 10,
+          },
+        ],
+      };
+
+      const root = await createAllowList({
+        allowList,
+      });
+
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient: publicClient,
+      });
+
+      const { parameters: parameters } = await creatorClient.create1155({
+        contract: {
+          name: "test allowlists",
+          uri: "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        token: {
+          tokenMetadataURI:
+            "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+          salesConfig: {
+            type: "allowlistMint",
+            presaleMerkleRoot: `0x${root}`,
+          },
+        },
+        account: creator,
+      });
+
+      const { request } = await publicClient.simulateContract(parameters);
+
+      await waitForSuccess(
+        await walletClient.writeContract(request),
+        publicClient,
+      );
+    },
+  );
 });

package/src/create/1155-create-helper.ts

@@ -26,6 +26,7 @@ import {
   NewContractParams,
 } from "./types";
 import { constructCreate1155TokenCalls } from "./token-setup";
+import { makeOnchainPrepareMintFromCreate } from "./mint-from-create";
 
 // Default royalty bps
 const ROYALTY_BPS_DEFAULT = 1000;
@@ -192,7 +193,7 @@ async function createNew1155ContractAndToken({
     minter,
     newToken,
     setupActions: tokenSetupActions,
-  } = prepareSetupActions({
+  } = await prepareSetupActions({
     chainId,
     account,
     contractVersion,
@@ -218,6 +219,15 @@ async function createNew1155ContractAndToken({
     contract,
   });
 
+  const prepareMint = makeOnchainPrepareMintFromCreate({
+    contractAddress: contractAddress,
+    contractVersion,
+    minter,
+    publicClient,
+    result: newToken.salesConfig,
+    tokenId: nextTokenId,
+  });
+
   return {
     parameters: request,
     tokenSetupActions,
@@ -226,6 +236,7 @@ async function createNew1155ContractAndToken({
     contractAddress: contractAddress,
     contractVersion,
     minter,
+    prepareMint,
   };
 }
 
@@ -250,7 +261,7 @@ async function createNew1155Token({
     minter,
     newToken,
     setupActions: tokenSetupActions,
-  } = prepareSetupActions({
+  } = await prepareSetupActions({
     chainId,
     account,
     contractVersion,
@@ -265,6 +276,15 @@ async function createNew1155Token({
     tokenSetupActions,
   });
 
+  const prepareMint = makeOnchainPrepareMintFromCreate({
+    contractAddress: contractAddress,
+    contractVersion,
+    minter,
+    publicClient,
+    result: newToken.salesConfig,
+    tokenId: nextTokenId,
+  });
+
   return {
     parameters: request,
     tokenSetupActions,
@@ -272,10 +292,11 @@ async function createNew1155Token({
     newToken,
     contractVersion,
     minter,
+    prepareMint,
   };
 }
 
-function prepareSetupActions({
+async function prepareSetupActions({
   chainId,
   account,
   contractVersion,
@@ -291,7 +312,7 @@ function prepareSetupActions({
     minter,
     newToken,
     setupActions: tokenSetupActions,
-  } = constructCreate1155TokenCalls({
+  } = await constructCreate1155TokenCalls({
     chainId: chainId,
     ownerAddress: account,
     contractVersion,

package/src/create/contract-setup.ts

@@ -27,6 +27,7 @@ export async function getContractInfoExistingContract({
   // Account that is the creator of the contract
 }): Promise<{
   contractVersion: string;
+  contractName: string;
   nextTokenId: bigint;
 }> {
   // Check if contract exists either from metadata or the static address passed in.
@@ -50,8 +51,15 @@ export async function getContractInfoExistingContract({
     functionName: "nextTokenId",
   });
 
+  const contractName = await publicClient.readContract({
+    address: contractAddress,
+    abi: zoraCreator1155ImplABI,
+    functionName: "name",
+  });
+
   return {
     contractVersion,
+    contractName,
     nextTokenId,
   };
 }

package/src/create/mint-from-create.ts

@@ -0,0 +1,119 @@
+import { Address, parseEther, PublicClient, zeroAddress } from "viem";
+import { ConcreteSalesConfig } from "./types";
+import {
+  AsyncPrepareMint,
+  MintParametersBase,
+  OnchainSalesStrategies,
+  PrepareMintReturn,
+} from "src/mint/types";
+import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
+import {
+  makePrepareMint1155TokenParams,
+  parseMintCosts,
+} from "src/mint/mint-transactions";
+import { getRequiredErc20Approvals } from "src/mint/mint-queries";
+
+async function toSalesStrategyFromSubgraph({
+  minter,
+  salesConfig,
+  publicClient,
+  contractAddress,
+}: {
+  minter: Address;
+  salesConfig: ConcreteSalesConfig;
+  publicClient: Pick<PublicClient, "readContract">;
+  contractAddress: Address;
+}): Promise<OnchainSalesStrategies> {
+  if (salesConfig.type === "timed") {
+    return {
+      saleType: "timed",
+      address: minter,
+      // for now we hardcode this
+      mintFeePerQuantity: parseEther("0.000111"),
+      saleStart: salesConfig.saleStart.toString(),
+      saleEnd: salesConfig.saleEnd.toString(),
+      // the following are not needed for now but we wanna satisfy concrete
+      erc20Z: zeroAddress,
+      mintFee: 0n,
+      pool: zeroAddress,
+      secondaryActivated: false,
+    };
+  }
+  if (salesConfig.type === "erc20Mint") {
+    return {
+      saleType: "erc20",
+      address: minter,
+      mintFeePerQuantity: 0n,
+      saleStart: salesConfig.saleStart.toString(),
+      saleEnd: salesConfig.saleEnd.toString(),
+      currency: salesConfig.currency,
+      pricePerToken: salesConfig.pricePerToken,
+      maxTokensPerAddress: salesConfig.maxTokensPerAddress,
+    };
+  }
+  const contractMintFee = await publicClient.readContract({
+    abi: zoraCreator1155ImplABI,
+    address: contractAddress,
+    functionName: "mintFee",
+  });
+  if (salesConfig.type === "fixedPrice") {
+    return {
+      saleType: "fixedPrice",
+      address: minter,
+      maxTokensPerAddress: salesConfig.maxTokensPerAddress,
+      mintFeePerQuantity: contractMintFee,
+      pricePerToken: salesConfig.pricePerToken,
+      saleStart: salesConfig.saleStart.toString(),
+      saleEnd: salesConfig.saleEnd.toString(),
+    };
+  }
+  return {
+    saleType: "allowlist",
+    address: minter,
+    saleStart: salesConfig.saleStart.toString(),
+    saleEnd: salesConfig.saleEnd.toString(),
+    merkleRoot: salesConfig.presaleMerkleRoot,
+    mintFeePerQuantity: contractMintFee,
+  };
+}
+export function makeOnchainPrepareMintFromCreate({
+  contractAddress,
+  tokenId,
+  result,
+  minter,
+  publicClient,
+  contractVersion,
+}: {
+  contractAddress: Address;
+  tokenId: bigint;
+  result: ConcreteSalesConfig;
+  minter: Address;
+  publicClient: Pick<PublicClient, "readContract">;
+  contractVersion: string;
+}): AsyncPrepareMint {
+  return async (params: MintParametersBase): Promise<PrepareMintReturn> => {
+    const subgraphSalesConfig = await toSalesStrategyFromSubgraph({
+      minter,
+      contractAddress,
+      publicClient,
+      salesConfig: result,
+    });
+    return {
+      parameters: makePrepareMint1155TokenParams({
+        salesConfigAndTokenInfo: {
+          salesConfig: subgraphSalesConfig,
+          contractVersion,
+        },
+        ...params,
+        tokenContract: contractAddress,
+        tokenId,
+      }),
+      costs: parseMintCosts({
+        allowListEntry: params.allowListEntry,
+        quantityToMint: BigInt(params.quantityToMint),
+        salesConfig: subgraphSalesConfig,
+      }),
+      erc20Approval: getRequiredErc20Approvals(params, subgraphSalesConfig),
+    };
+  };
+}

package/src/create/minter-defaults.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect, assert } from "vitest";
+import { parseNameIntoSymbol } from "./minter-defaults";
+
+describe("parseNameIntoSymbol", () => {
+  it("removes spaces and vowels and converts to uppercase", () => {
+    const symbol = parseNameIntoSymbol("My 4 To *5 @-Name");
+
+    expect(symbol).toBe("$MY4T");
+  });
+  it("works with less than 4 characters", () => {
+    const symbol = parseNameIntoSymbol("M4y a");
+
+    expect(symbol).toBe("$M4Y");
+  });
+
+  it("works with no characters", () => {
+    assert.throws(() => {
+      parseNameIntoSymbol("AEIO U");
+    }, "Not enough valid characters to generate a symbol");
+  });
+});