@zoralabs/protocol-sdk 0.7.6 → 0.9.0

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

@@ -1,21 +1,78 @@
 import { describe, expect } from "vitest";
-import { getTokenIdFromCreateReceipt } from "./1155-create-helper";
-import { anvilTest } from "src/anvil";
+import {
+  getContractAddressFromReceipt,
+  getTokenIdFromCreateReceipt,
+} from "./1155-create-helper";
 import { createCreatorClient } from "src/sdk";
-import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
+import {
+  zoraCreator1155ImplABI,
+  zoraTimedSaleStrategyAddress,
+} from "@zoralabs/protocol-deployments";
 import { waitForSuccess } from "src/test-utils";
-import { parseEther } from "viem";
 import {
-  MintableParameters,
-  makePrepareMint1155TokenParams,
-} from "src/mint/mint-transactions";
+  Address,
+  parseEther,
+  PublicClient,
+  TransactionReceipt,
+  zeroAddress,
+} 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";
+
+export const demoTokenMetadataURI =
+  "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u";
+export const demoContractMetadataURI = "ipfs://DUMMY/contract.json";
+
+const anvilTest = makeAnvilTest({
+  forkUrl: forkUrls.zoraMainnet,
+  forkBlockNumber: 18094820,
+  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);
+  }
+}
 
-const demoTokenMetadataURI = "ipfs://DUMMY/token.json";
-const demoContractMetadataURI = "ipfs://DUMMY/contract.json";
+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]!;
@@ -24,61 +81,113 @@ describe("create-helper", () => {
         chainId: chain.id,
         publicClient: publicClient,
       });
-      const { parameters: request } = await creatorClient.create1155({
-        contract: {
-          name: "testContract",
-          uri: demoContractMetadataURI,
-        },
-        token: {
-          tokenMetadataURI: demoTokenMetadataURI,
-          mintToCreatorCount: 1,
-        },
-        account: creatorAddress,
-      });
-      const { request: simulationResponse } =
-        await publicClient.simulateContract(request);
-      const hash = await walletClient.writeContract(simulationResponse);
+      const { 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(
+        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 creatorAccount = addresses[0]!;
+      const creatorAddress = addresses[0]!;
 
       const creatorClient = createCreatorClient({
         chainId: chain.id,
         publicClient: publicClient,
       });
+      const { parameters, contractAddress, newTokenId } =
+        await creatorClient.create1155({
+          contract: randomNewContract(),
+          token: {
+            tokenMetadataURI: demoTokenMetadataURI,
+            salesConfig: {
+              pricePerToken: 0n,
+            },
+          },
+          account: creatorAddress,
+        });
 
-      const {
-        parameters: request,
-        collectionAddress: contractAddress,
-        contractExists,
-      } = await creatorClient.create1155({
-        contract: {
-          name: "testContract2",
-          uri: demoContractMetadataURI,
-        },
-        token: {
-          tokenMetadataURI: demoTokenMetadataURI,
-          mintToCreatorCount: 3,
-        },
-        account: creatorAccount,
+      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]!;
+
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient: publicClient,
       });
-      expect(contractAddress).to.be.equal(
-        "0xb1A8928dF830C21eD682949Aa8A83C1C215194d3",
-      );
-      expect(contractExists).to.be.false;
+
+      const { parameters: request, contractAddress: contractAddress } =
+        await creatorClient.create1155({
+          contract: randomNewContract(),
+          token: {
+            tokenMetadataURI: demoTokenMetadataURI,
+            mintToCreatorCount: 3,
+          },
+          account: creatorAccount,
+        });
       const { request: simulateResponse } =
         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();
@@ -93,21 +202,15 @@ describe("create-helper", () => {
         }),
       ).toBe(3n);
 
-      const newTokenOnExistingContract = await creatorClient.create1155({
-        contract: {
-          name: "testContract2",
-          uri: demoContractMetadataURI,
-        },
-        token: {
-          tokenMetadataURI: demoTokenMetadataURI,
-          mintToCreatorCount: 2,
-        },
-        account: creatorAccount,
-      });
-      expect(newTokenOnExistingContract.collectionAddress).to.be.equal(
-        "0xb1A8928dF830C21eD682949Aa8A83C1C215194d3",
-      );
-      expect(newTokenOnExistingContract.contractExists).to.be.true;
+      const newTokenOnExistingContract =
+        await creatorClient.create1155OnExistingContract({
+          contractAddress: contractAddress,
+          token: {
+            tokenMetadataURI: demoTokenMetadataURI,
+            mintToCreatorCount: 2,
+          },
+          account: creatorAccount,
+        });
       const { request: simulateRequest } = await publicClient.simulateContract(
         newTokenOnExistingContract.parameters,
       );
@@ -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,
   );
@@ -132,11 +238,12 @@ describe("create-helper", () => {
         chainId: chain.id,
         publicClient: publicClient,
       });
-      const { parameters: request } = await creatorClient.create1155({
-        contract: {
-          name: "testContract",
-          uri: demoContractMetadataURI,
-        },
+      const {
+        parameters: request,
+        contractAddress: collectionAddress,
+        newTokenId,
+      } = await creatorClient.create1155({
+        contract: randomNewContract(),
         token: {
           tokenMetadataURI: demoTokenMetadataURI,
           createReferral,
@@ -147,16 +254,16 @@ 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.to).to.equal("0xa72724cc3dcef210141a1b84c61824074151dc99");
-      expect(getTokenIdFromCreateReceipt(receipt)).to.be.equal(2n);
+      expect(receipt.status).toBe("success");
+      expect(receipt.to).to.equal("0x777777c338d93e2c7adf08d102d45ca7cc4ed021");
+      expect(getTokenIdFromCreateReceipt(receipt)).to.be.equal(newTokenId);
 
       expect(
         await publicClient.readContract({
           abi: zoraCreator1155ImplABI,
-          address: "0xa72724cc3dcef210141a1b84c61824074151dc99",
+          address: collectionAddress,
           functionName: "createReferrals",
-          args: [2n],
+          args: [newTokenId],
         }),
       ).to.be.equal(createReferral);
     },
@@ -177,15 +284,12 @@ describe("create-helper", () => {
       });
       const {
         parameters: request,
-        collectionAddress,
         newTokenId,
-        newToken,
         minter,
+        contractAddress: collectionAddress,
+        contractVersion,
       } = await creatorClient.create1155({
-        contract: {
-          name: "testContract",
-          uri: demoContractMetadataURI,
-        },
+        contract: randomNewContract(),
         token: {
           tokenMetadataURI: demoTokenMetadataURI,
         },
@@ -198,20 +302,6 @@ describe("create-helper", () => {
         publicClient,
       );
 
-      const salesConfigAndTokenInfo: MintableParameters = {
-        mintFeePerQuantity: parseEther("0.000777"),
-        contractVersion: "2.8.0",
-        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
@@ -226,7 +316,21 @@ describe("create-helper", () => {
         tokenContract: collectionAddress,
         minterAccount: minterAddress,
         tokenId: newTokenId,
-        salesConfigAndTokenInfo,
+        salesConfigAndTokenInfo: {
+          contractVersion,
+          salesConfig: {
+            saleType: "timed",
+            address: minter,
+            // below fields arent used when determining mint price for minting
+            saleEnd: "",
+            saleStart: "",
+            erc20Z: zeroAddress,
+            pool: zeroAddress,
+            secondaryActivated: false,
+            mintFeePerQuantity: parseEther("0.000111"),
+            mintFee: 0n,
+          },
+        },
         quantityToMint,
       });
 
@@ -241,7 +345,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 },
     }) => {
@@ -257,15 +361,12 @@ describe("create-helper", () => {
 
       const {
         parameters: request,
-        collectionAddress,
+        contractAddress: collectionAddress,
         newTokenId,
-        newToken,
         minter,
+        contractVersion,
       } = await creatorClient.create1155({
-        contract: {
-          name: "testContract",
-          uri: demoContractMetadataURI,
-        },
+        contract: randomNewContract(),
         token: {
           tokenMetadataURI: demoTokenMetadataURI,
           salesConfig: {
@@ -281,20 +382,6 @@ describe("create-helper", () => {
         publicClient,
       );
 
-      const salesConfigAndTokenInfo: MintableParameters = {
-        mintFeePerQuantity: parseEther("0.000777"),
-        contractVersion: "2.8.0",
-        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
@@ -309,7 +396,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,
       });
 
@@ -322,4 +425,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 } = 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,
+      );
+    },
+  );
 });