@zoralabs/protocol-sdk 0.7.2-ALLOWLIST.0 → 0.7.2

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

@@ -0,0 +1,325 @@
+import { describe, expect } from "vitest";
+import { getTokenIdFromCreateReceipt } from "./1155-create-helper";
+import { anvilTest } from "src/anvil";
+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";
+
+const demoTokenMetadataURI = "ipfs://DUMMY/token.json";
+const demoContractMetadataURI = "ipfs://DUMMY/contract.json";
+
+describe("create-helper", () => {
+  anvilTest(
+    "creates a new 1155 contract and token",
+    async ({ viemClients: { publicClient, walletClient, chain } }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAddress = addresses[0]!;
+
+      const creatorClient = createCreatorClient({
+        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 receipt = await publicClient.waitForTransactionReceipt({ hash });
+      expect(receipt).not.toBeNull();
+      expect(receipt.to).to.equal("0x777777c338d93e2c7adf08d102d45ca7cc4ed021");
+      expect(getTokenIdFromCreateReceipt(receipt)).to.be.equal(1n);
+    },
+    20 * 1000,
+  );
+  anvilTest(
+    "creates 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,
+      });
+
+      const {
+        parameters: request,
+        collectionAddress: contractAddress,
+        contractExists,
+      } = await creatorClient.create1155({
+        contract: {
+          name: "testContract2",
+          uri: demoContractMetadataURI,
+        },
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+          mintToCreatorCount: 3,
+        },
+        account: creatorAccount,
+      });
+      expect(contractAddress).to.be.equal(
+        "0xb1A8928dF830C21eD682949Aa8A83C1C215194d3",
+      );
+      expect(contractExists).to.be.false;
+      const { request: simulateResponse } =
+        await publicClient.simulateContract(request);
+      const hash = await walletClient.writeContract(simulateResponse);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      const firstTokenId = getTokenIdFromCreateReceipt(receipt);
+      expect(firstTokenId).to.be.equal(1n);
+      expect(receipt).not.toBeNull();
+
+      // creator should have mint to creator count balance
+      expect(
+        await publicClient.readContract({
+          address: contractAddress,
+          abi: zoraCreator1155ImplABI,
+          functionName: "balanceOf",
+          args: [creatorAccount, firstTokenId!],
+        }),
+      ).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 { request: simulateRequest } = await publicClient.simulateContract(
+        newTokenOnExistingContract.parameters,
+      );
+      const newHash = await walletClient.writeContract(simulateRequest);
+      const newReceipt = await publicClient.waitForTransactionReceipt({
+        hash: newHash,
+      });
+      const tokenId = getTokenIdFromCreateReceipt(newReceipt);
+      expect(tokenId).to.be.equal(2n);
+      expect(newReceipt).not.toBeNull();
+    },
+    20 * 1000,
+  );
+  anvilTest(
+    "creates a new token with a create referral address",
+    async ({ viemClients: { publicClient, walletClient, chain } }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAddress = addresses[0]!;
+      const createReferral = addresses[1]!;
+
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient: publicClient,
+      });
+      const { parameters: request } = await creatorClient.create1155({
+        contract: {
+          name: "testContract",
+          uri: demoContractMetadataURI,
+        },
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+          createReferral,
+        },
+        account: creatorAddress,
+      });
+      const { request: simulationResponse } =
+        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(
+        await publicClient.readContract({
+          abi: zoraCreator1155ImplABI,
+          address: "0xa72724cc3dcef210141a1b84c61824074151dc99",
+          functionName: "createReferrals",
+          args: [2n],
+        }),
+      ).to.be.equal(createReferral);
+    },
+    20 * 1000,
+  );
+
+  anvilTest(
+    "creates a new 1155 free mint that can be minted",
+    async ({
+      viemClients: { testClient, publicClient, walletClient, chain },
+    }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAddress = addresses[0]!;
+
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient: publicClient,
+      });
+      const {
+        parameters: request,
+        collectionAddress,
+        newTokenId,
+        newToken,
+        minter,
+      } = await creatorClient.create1155({
+        contract: {
+          name: "testContract",
+          uri: demoContractMetadataURI,
+        },
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+        },
+        account: creatorAddress,
+      });
+      const { request: createSimulation } =
+        await publicClient.simulateContract(request);
+      await waitForSuccess(
+        await walletClient.writeContract(createSimulation),
+        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
+      const minterAddress = addresses[1]!;
+
+      await testClient.setBalance({
+        address: minterAddress,
+        value: parseEther("10"),
+      });
+
+      const mintParams = makePrepareMint1155TokenParams({
+        tokenContract: collectionAddress,
+        minterAccount: minterAddress,
+        tokenId: newTokenId,
+        salesConfigAndTokenInfo,
+        quantityToMint,
+      });
+
+      const { request: collectSimulation } =
+        await publicClient.simulateContract(mintParams);
+      await waitForSuccess(
+        await walletClient.writeContract(collectSimulation),
+        publicClient,
+      );
+    },
+    20 * 1000,
+  );
+
+  anvilTest(
+    "creates a new 1155 paid mint that can be minted",
+    async ({
+      viemClients: { testClient, publicClient, walletClient, chain },
+    }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAddress = addresses[0]!;
+
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient: publicClient,
+      });
+
+      const pricePerToken = parseEther("0.01");
+
+      const {
+        parameters: request,
+        collectionAddress,
+        newTokenId,
+        newToken,
+        minter,
+      } = await creatorClient.create1155({
+        contract: {
+          name: "testContract",
+          uri: demoContractMetadataURI,
+        },
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+          salesConfig: {
+            pricePerToken,
+          },
+        },
+        account: creatorAddress,
+      });
+      const { request: createSimulation } =
+        await publicClient.simulateContract(request);
+      await waitForSuccess(
+        await walletClient.writeContract(createSimulation),
+        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
+      const minterAddress = addresses[1]!;
+
+      await testClient.setBalance({
+        address: minterAddress,
+        value: parseEther("10"),
+      });
+
+      const mintParams = makePrepareMint1155TokenParams({
+        tokenContract: collectionAddress,
+        minterAccount: minterAddress,
+        tokenId: newTokenId,
+        salesConfigAndTokenInfo,
+        quantityToMint,
+      });
+
+      const { request: collectSimulation } =
+        await publicClient.simulateContract(mintParams);
+      await waitForSuccess(
+        await walletClient.writeContract(collectSimulation),
+        publicClient,
+      );
+    },
+    20 * 1000,
+  );
+});

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

@@ -37,23 +37,6 @@ export const getTokenIdFromCreateReceipt = (
   }
 };
 
-export const getContractAddressFromCreateReceipt = (
-  receipt: TransactionReceipt,
-): Address | undefined => {
-  for (const data of receipt.logs) {
-    try {
-      const decodedLog = decodeEventLog({
-        abi: zoraCreator1155FactoryImplABI,
-        eventName: "SetupNewContract",
-        ...data,
-      });
-      if (decodedLog && decodedLog.eventName === "SetupNewContract") {
-        return decodedLog.args.newContract;
-      }
-    } catch (err: any) {}
-  }
-};
-
 type CreateNew1155TokenReturn = {
   parameters: SimulateContractParameters<
     any,

package/src/create/token-setup.ts

@@ -4,17 +4,13 @@ import {
   zoraCreator1155ImplABI,
   zoraCreatorFixedPriceSaleStrategyABI,
   zoraCreatorFixedPriceSaleStrategyAddress,
-  zoraCreatorMerkleMinterStrategyABI,
-  zoraCreatorMerkleMinterStrategyAddress,
 } from "@zoralabs/protocol-deployments";
 import { Address, encodeFunctionData, zeroAddress, Hex } from "viem";
 import * as semver from "semver";
 import {
-  AllowlistData,
   ContractProps,
   CreateNew1155TokenProps,
   New1155Token,
-  SalesConfigOrAllowList,
   SalesConfigParamsType,
 } from "./types";
 import { OPEN_EDITION_MINT_SIZE } from "src/constants";
@@ -28,15 +24,16 @@ type SetupMintersProps = {
   tokenId: bigint;
   chainId: number;
   fundsRecipient: Address;
-  salesConfigOrAllowList: SalesConfigOrAllowList;
+  salesConfig: Concrete<SalesConfigParamsType>;
 };
 
 // Sales end forever amount (uint64 max)
-const SALE_END_FOREVER = 18446744073709551615n;
 
 const saleSettingsOrDefault = (
   saleSettings?: SalesConfigParamsType,
 ): Concrete<SalesConfigParamsType> => {
+  const SALE_END_FOREVER = 18446744073709551615n;
+
   const DEFAULT_SALE_SETTINGS: Concrete<SalesConfigParamsType> = {
     currency: zeroAddress,
     // Free Mint
@@ -54,36 +51,6 @@ const saleSettingsOrDefault = (
   };
 };
 
-const allowListWithDefaults = (allowlist: AllowlistData) => {
-  const defaultAllowListSettings: Concrete<
-    Omit<AllowlistData, "presaleMerkleRoot">
-  > = {
-    // Sale start time – defaults to beginning of unix time
-    saleStart: 0n,
-    // This is the end of uint64, plenty of time
-    saleEnd: SALE_END_FOREVER,
-  };
-
-  return {
-    ...defaultAllowListSettings,
-    ...allowlist,
-  };
-};
-
-const getSalesConfigOrAllowListWithDefaults = ({
-  salesConfig,
-  allowlist,
-}: Pick<CreateNew1155TokenProps, "salesConfig" | "allowlist">) => {
-  if (!allowlist) {
-    return {
-      salesConfig: saleSettingsOrDefault(salesConfig),
-    };
-  }
-  return {
-    allowlist: allowListWithDefaults(allowlist),
-  };
-};
-
 function applyNew1155Defaults(
   props: CreateNew1155TokenProps,
   ownerAddress: Address,
@@ -101,11 +68,8 @@ function applyNew1155Defaults(
         ? OPEN_EDITION_MINT_SIZE
         : BigInt(props.maxSupply),
     royaltyBPS: props.royaltyBPS || 1000,
+    salesConfig: saleSettingsOrDefault(props.salesConfig),
     tokenMetadataURI: props.tokenMetadataURI,
-    salesConfigOrAllowList: getSalesConfigOrAllowListWithDefaults({
-      salesConfig: props.salesConfig,
-      allowlist: props.allowlist,
-    }),
   };
 }
 
@@ -223,84 +187,24 @@ function setupFixedPriceMinter({
   };
 }
 
-function setupAllowListMinter({
-  chainId,
-  tokenId: nextTokenId,
-  allowlist,
-  fundsRecipient,
-}: {
-  chainId: number;
-  tokenId: bigint;
-  allowlist: Concrete<AllowlistData>;
-  fundsRecipient: Address;
-}) {
-  const merkleSaleStrategyAddress =
-    zoraCreatorMerkleMinterStrategyAddress[
-      chainId as keyof typeof zoraCreatorMerkleMinterStrategyAddress
-    ];
-
-  const merkleApproval = encodeFunctionData({
-    abi: zoraCreator1155ImplABI,
-    functionName: "addPermission",
-    args: [nextTokenId, merkleSaleStrategyAddress, PERMISSION_BITS.MINTER],
-  });
-
-  const merkleRoot = allowlist.presaleMerkleRoot.startsWith("0x")
-    ? allowlist.presaleMerkleRoot
-    : (`0x${allowlist.presaleMerkleRoot}` as Hex);
-
-  const saleData = encodeFunctionData({
-    abi: zoraCreatorMerkleMinterStrategyABI,
-    functionName: "setSale",
-    args: [
-      BigInt(nextTokenId),
-      {
-        presaleStart: allowlist.saleStart,
-        presaleEnd: allowlist.saleEnd,
-        merkleRoot,
-        fundsRecipient: fundsRecipient,
-      },
-    ],
-  });
-
-  const callSaleMerkle = encodeFunctionData({
-    abi: zoraCreator1155ImplABI,
-    functionName: "callSale",
-    args: [BigInt(nextTokenId), merkleSaleStrategyAddress, saleData],
-  });
-
-  return {
-    minter: merkleSaleStrategyAddress,
-    setupActions: [merkleApproval, callSaleMerkle],
-  };
-}
-
-export function setupMinters({
-  salesConfigOrAllowList: { salesConfig, allowlist },
-  ...rest
-}: SetupMintersProps): {
+export function setupMinters({ salesConfig, ...rest }: SetupMintersProps): {
   minter: Address;
   setupActions: Hex[];
 } {
-  if (salesConfig) {
-    const { currency: currencyAddress } = salesConfig;
-
-    if (currencyAddress === zeroAddress) {
-      return setupFixedPriceMinter({
-        ...salesConfig,
-        ...rest,
-      });
-    } else {
-      return setupErc20Minter({
-        ...salesConfig,
-        ...rest,
-      });
-    }
+  if (!salesConfig) throw new Error("No sales config for token");
+  const { currency: currencyAddress } = salesConfig;
+
+  if (currencyAddress === zeroAddress) {
+    return setupFixedPriceMinter({
+      ...salesConfig,
+      ...rest,
+    });
+  } else {
+    return setupErc20Minter({
+      ...salesConfig,
+      ...rest,
+    });
   }
-  return setupAllowListMinter({
-    allowlist: allowlist as Concrete<AllowlistData>,
-    ...rest,
-  });
 }
 
 function buildSetupNewToken({
@@ -431,8 +335,7 @@ export function constructCreate1155TokenCalls(
     tokenId: nextTokenId,
     chainId,
     fundsRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
-    salesConfigOrAllowList:
-      new1155TokenPropsWithDefaults.salesConfigOrAllowList,
+    salesConfig: new1155TokenPropsWithDefaults.salesConfig,
   });
 
   const adminMintCall = makeAdminMintCall({

package/src/create/types.ts

@@ -32,54 +32,26 @@ export type CreateNew1155Params = {
   token: CreateNew1155TokenProps;
 };
 
-export type AllowlistData = {
-  saleStart?: bigint;
-  saleEnd?: bigint;
-  presaleMerkleRoot: `0x${string}`;
-};
-
-export type CreateNew1155TokenProps = {
+export interface CreateNew1155TokenProps {
   maxSupply?: bigint | number;
   tokenMetadataURI: string;
   royaltyBPS?: number;
+  salesConfig?: SalesConfigParamsType;
   createReferral?: Address;
   mintToCreatorCount?: number;
   payoutRecipient?: Address;
-} & (
-  | {
-      salesConfig: SalesConfigParamsType;
-      allowlist?: undefined;
-    }
-  | {
-      salesConfig?: undefined;
-      allowlist: AllowlistData;
-    }
-  | {
-      salesConfig?: undefined;
-      allowlist?: undefined;
-    }
-);
+}
 
 export interface ContractProps {
   nextTokenId: bigint;
   contractVersion: string;
 }
 
-export type SalesConfigOrAllowList =
-  | {
-      salesConfig: Concrete<SalesConfigParamsType>;
-      allowlist?: undefined;
-    }
-  | {
-      salesConfig: undefined;
-      allowlist: Concrete<AllowlistData>;
-    };
-
 export type New1155Token = {
   payoutRecipient: Address;
   createReferral: Address;
   maxSupply: bigint;
   royaltyBPS: number;
+  salesConfig: Concrete<SalesConfigParamsType>;
   tokenMetadataURI: string;
-  salesConfigOrAllowList: SalesConfigOrAllowList;
 };

package/src/index.ts

@@ -31,7 +31,3 @@ export * from "./create/types";
 export * from "./sdk";
 
 export * from "./ipfs";
-
-export { createAllowList } from "./allow-list/allow-list-client";
-
-export * from "./allow-list/types";