@zoralabs/protocol-sdk 0.8.0 → 0.9.0

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

@@ -4,18 +4,28 @@ import {
   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";
 
-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 +33,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 +81,89 @@ describe("create-helper", () => {
         chainId: chain.id,
         publicClient: publicClient,
       });
-      const { parameters, contractAddress: collectionAddress } =
+      const { parameters, contractAddress, newTokenId } =
         await creatorClient.create1155({
-          contract: {
-            name: "testContract",
-            uri: demoContractMetadataURI,
-          },
+          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(
+    "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, 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(
-    "creates a new contract, then can create a new token on this existing contract",
+    "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);
 
@@ -182,15 +285,11 @@ describe("create-helper", () => {
       const {
         parameters: request,
         newTokenId,
-        newToken,
         minter,
         contractAddress: collectionAddress,
         contractVersion,
       } = await creatorClient.create1155({
-        contract: {
-          name: "testContract",
-          uri: demoContractMetadataURI,
-        },
+        contract: randomNewContract(),
         token: {
           tokenMetadataURI: demoTokenMetadataURI,
         },
@@ -203,20 +302,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
@@ -231,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,
       });
 
@@ -246,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 },
     }) => {
@@ -264,14 +363,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 +382,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 +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,
       });
 
@@ -328,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,
+      );
+    },
+  );
 });

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

@@ -192,7 +192,7 @@ async function createNew1155ContractAndToken({
     minter,
     newToken,
     setupActions: tokenSetupActions,
-  } = prepareSetupActions({
+  } = await prepareSetupActions({
     chainId,
     account,
     contractVersion,
@@ -250,7 +250,7 @@ async function createNew1155Token({
     minter,
     newToken,
     setupActions: tokenSetupActions,
-  } = prepareSetupActions({
+  } = await prepareSetupActions({
     chainId,
     account,
     contractVersion,
@@ -275,7 +275,7 @@ async function createNew1155Token({
   };
 }
 
-function prepareSetupActions({
+async function prepareSetupActions({
   chainId,
   account,
   contractVersion,
@@ -291,7 +291,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/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");
+  });
+});

package/src/create/minter-defaults.ts

@@ -0,0 +1,134 @@
+import { Concrete } from "src/utils";
+import {
+  SalesConfigParamsType,
+  AllowListParamType,
+  Erc20ParamsType,
+  FixedPriceParamsType,
+  SaleStartAndEnd,
+  MaxTokensPerAddress,
+  ConcreteSalesConfig,
+  TimedSaleParamsType,
+} from "./types";
+import { fetchTokenMetadata } from "src/ipfs/token-metadata";
+
+// Sales end forever amount (uint64 max)
+export const SALE_END_FOREVER = 18446744073709551615n;
+
+const DEFAULT_SALE_START_AND_END: Concrete<SaleStartAndEnd> = {
+  // Sale start time – defaults to beginning of unix time
+  saleStart: 0n,
+  // This is the end of uint64, plenty of time
+  saleEnd: SALE_END_FOREVER,
+};
+
+const DEFAULT_MAX_TOKENS_PER_ADDRESS: Concrete<MaxTokensPerAddress> = {
+  maxTokensPerAddress: 0n,
+};
+
+const erc20SaleSettingsWithDefaults = (
+  params: Erc20ParamsType,
+): Concrete<Erc20ParamsType> => ({
+  ...DEFAULT_SALE_START_AND_END,
+  ...DEFAULT_MAX_TOKENS_PER_ADDRESS,
+  ...params,
+});
+
+const allowListWithDefaults = (
+  allowlist: AllowListParamType,
+): Concrete<AllowListParamType> => {
+  return {
+    ...DEFAULT_SALE_START_AND_END,
+    ...allowlist,
+  };
+};
+
+const fixedPriceSettingsWithDefaults = (
+  params: FixedPriceParamsType,
+): Concrete<FixedPriceParamsType> => ({
+  ...DEFAULT_SALE_START_AND_END,
+  ...DEFAULT_MAX_TOKENS_PER_ADDRESS,
+  type: "fixedPrice",
+  ...params,
+});
+
+export const parseNameIntoSymbol = (name: string) => {
+  if (name === "") {
+    throw new Error("Name must be provided to generate a symbol");
+  }
+  const result =
+    "$" +
+    name
+      // Remove all non-alphanumeric characters
+      .replace(/[^a-zA-Z0-9]/g, "")
+      // and leading dollar signs
+      .replace(/^\$+/, "")
+      .toUpperCase()
+      // Remove all vowels and spaces
+      .replace(/[AEIOU\s]/g, "")
+      // Strip down to 4 characters
+      .slice(0, 4);
+
+  if (result === "$") {
+    throw new Error("Not enough valid characters to generate a symbol");
+  }
+
+  return result;
+};
+
+async function fetchTokenNameFromMetadata(
+  tokenMetadataURI: string,
+): Promise<string> {
+  const tokenMetadata = await fetchTokenMetadata(tokenMetadataURI);
+
+  if (!tokenMetadata.name) {
+    throw new Error("No name found in token metadata");
+  }
+
+  return tokenMetadata.name;
+}
+const timedSaleSettingsWithDefaults = async (
+  params: TimedSaleParamsType,
+  tokenMetadataURI: string,
+): Promise<Concrete<TimedSaleParamsType>> => {
+  // If the name is not provided, try to fetch it from the metadata
+  const erc20Name =
+    params.erc20Name || (await fetchTokenNameFromMetadata(tokenMetadataURI));
+  const symbol = params.erc20Symbol || parseNameIntoSymbol(erc20Name);
+
+  return {
+    type: "timed",
+    ...DEFAULT_SALE_START_AND_END,
+    erc20Name,
+    erc20Symbol: symbol,
+  };
+};
+
+const isAllowList = (
+  salesConfig: SalesConfigParamsType,
+): salesConfig is AllowListParamType => salesConfig.type === "allowlistMint";
+const isErc20 = (
+  salesConfig: SalesConfigParamsType,
+): salesConfig is Erc20ParamsType => salesConfig.type === "erc20Mint";
+const isFixedPrice = (
+  salesConfig: SalesConfigParamsType,
+): salesConfig is FixedPriceParamsType => {
+  return (salesConfig as FixedPriceParamsType).pricePerToken > 0n;
+};
+
+export const getSalesConfigWithDefaults = async (
+  salesConfig: SalesConfigParamsType | undefined,
+  tokenMetadataURI: string,
+): Promise<ConcreteSalesConfig> => {
+  if (!salesConfig) return timedSaleSettingsWithDefaults({}, tokenMetadataURI);
+  if (isAllowList(salesConfig)) {
+    return allowListWithDefaults(salesConfig);
+  }
+  if (isErc20(salesConfig)) {
+    return erc20SaleSettingsWithDefaults(salesConfig);
+  }
+  if (isFixedPrice(salesConfig)) {
+    return fixedPriceSettingsWithDefaults(salesConfig);
+  }
+
+  return timedSaleSettingsWithDefaults(salesConfig, tokenMetadataURI);
+};