@zoralabs/protocol-sdk 0.5.13 → 0.5.15

package/src/premint/preminter.test.ts

@@ -1,5 +1,5 @@
 import { Address, zeroAddress } from "viem";
-import { foundry } from "viem/chains";
+import { zoraSepolia } from "viem/chains";
 import { describe, expect } from "vitest";
 import { parseEther } from "viem";
 import {
@@ -7,24 +7,22 @@ import {
   zoraCreator1155ImplABI,
   zoraCreator1155FactoryImplAddress,
   zoraCreator1155FactoryImplConfig,
+  PremintConfigV1,
+  TokenCreationConfigV1,
+  PremintConfigVersion,
+  TokenCreationConfigV2,
+  PremintConfigV2,
+  PremintMintArguments,
+  ContractCreationConfig,
+  premintTypedDataDefinition,
+  encodePremintConfig,
 } from "@zoralabs/protocol-deployments";
 
 import {
-  premintTypedDataDefinition,
   isValidSignature,
-  recoverCreatorFromCreatorAttribution,
   getPremintExecutorAddress,
   getPremintMintCosts,
 } from "./preminter";
-import {
-  ContractCreationConfig,
-  PremintConfigV1,
-  TokenCreationConfigV1,
-  PremintConfigVersion,
-  TokenCreationConfigV2,
-  PremintConfigV2,
-  MintArguments,
-} from "./contract-types";
 import { AnvilViemClientsTest, forkUrls, makeAnvilTest } from "src/anvil";
 
 // create token and contract creation config:
@@ -36,6 +34,7 @@ export const defaultContractConfig = ({
   contractAdmin,
   contractURI: "ipfs://asdfasdfasdf",
   contractName: "My fun NFT",
+  additionalAdmins: [],
 });
 
 const defaultTokenConfigV1 = (
@@ -109,17 +108,21 @@ export const defaultPremintConfigV2 = ({
 
 const PREMINTER_ADDRESS = getPremintExecutorAddress();
 
-const anvilTest = makeAnvilTest({
-  forkUrl: forkUrls.zoraSepolia,
-  forkBlockNumber: 1265490,
-});
-
 async function setupContracts({
-  viemClients: { walletClient, testClient, publicClient },
+  viemClients: { walletClient, testClient, publicClient, chain },
 }: AnvilViemClientsTest) {
   // JSON-RPC Account
-  const [deployerAccount, creatorAccount, collectorAccount] =
-    (await walletClient.getAddresses()) as [Address, Address, Address, Address];
+  const [
+    deployerAccount,
+    creatorAccount,
+    collectorAccount,
+    collaboratorAccount,
+  ] = (await walletClient.getAddresses()) as [
+    Address,
+    Address,
+    Address,
+    Address,
+  ];
 
   // deploy signature minter contract
   await testClient.setBalance({
@@ -129,7 +132,10 @@ async function setupContracts({
 
   const fixedPriceMinterAddress = await publicClient.readContract({
     abi: zoraCreator1155FactoryImplConfig.abi,
-    address: zoraCreator1155FactoryImplAddress[999],
+    address:
+      zoraCreator1155FactoryImplAddress[
+        chain.id as keyof typeof zoraCreator1155FactoryImplAddress
+      ],
     functionName: "fixedPriceMinter",
   });
 
@@ -138,6 +144,7 @@ async function setupContracts({
       deployerAccount,
       creatorAccount,
       collectorAccount,
+      collaboratorAccount,
     },
     fixedPriceMinterAddress,
   };
@@ -145,12 +152,12 @@ async function setupContracts({
 
 const zoraSepoliaAnvilTest = makeAnvilTest({
   forkUrl: forkUrls.zoraSepolia,
-  forkBlockNumber: 3118200,
+  forkBlockNumber: 8948974,
+  anvilChainId: zoraSepolia.id,
 });
 
 describe("ZoraCreator1155Preminter", () => {
-  // skip for now - we need to make this work on zora testnet chain too
-  anvilTest(
+  zoraSepoliaAnvilTest(
     "can sign on the forked premint contract",
     async ({ viemClients }) => {
       const {
@@ -170,14 +177,14 @@ describe("ZoraCreator1155Preminter", () => {
       const contractAddress = await viemClients.publicClient.readContract({
         abi: preminterAbi,
         address: preminterAddress,
-        functionName: "getContractAddress",
+        functionName: "getContractWithAdditionalAdminsAddress",
         args: [contractConfig],
       });
 
       const signedMessage = await viemClients.walletClient.signTypedData({
         ...premintTypedDataDefinition({
           verifyingContract: contractAddress,
-          chainId: 999,
+          chainId: viemClients.chain.id,
           premintConfig,
           premintConfigVersion: PremintConfigVersion.V1,
         }),
@@ -213,7 +220,7 @@ describe("ZoraCreator1155Preminter", () => {
       const tokenContract = await viemClients.publicClient.readContract({
         abi: preminterAbi,
         address: PREMINTER_ADDRESS,
-        functionName: "getContractAddress",
+        functionName: "getContractWithAdditionalAdminsAddress",
         args: [contractConfig],
       });
 
@@ -222,7 +229,7 @@ describe("ZoraCreator1155Preminter", () => {
         ...premintTypedDataDefinition({
           verifyingContract: tokenContract,
           // we need to sign here for the anvil chain, cause thats where it is run on
-          chainId: foundry.id,
+          chainId: viemClients.chain.id,
           premintConfig,
           premintConfigVersion: PremintConfigVersion.V1,
         }),
@@ -267,7 +274,7 @@ describe("ZoraCreator1155Preminter", () => {
       const tokenContract = await viemClients.publicClient.readContract({
         abi: preminterAbi,
         address: PREMINTER_ADDRESS,
-        functionName: "getContractAddress",
+        functionName: "getContractWithAdditionalAdminsAddress",
         args: [contractConfig],
       });
 
@@ -276,7 +283,7 @@ describe("ZoraCreator1155Preminter", () => {
         ...premintTypedDataDefinition({
           verifyingContract: tokenContract,
           // we need to sign here for the anvil chain, cause thats where it is run on
-          chainId: foundry.id,
+          chainId: viemClients.chain.id,
           premintConfig,
           premintConfigVersion: PremintConfigVersion.V2,
         }),
@@ -323,7 +330,7 @@ describe("ZoraCreator1155Preminter", () => {
       let contractAddress = await viemClients.publicClient.readContract({
         abi: preminterAbi,
         address: PREMINTER_ADDRESS,
-        functionName: "getContractAddress",
+        functionName: "getContractWithAdditionalAdminsAddress",
         args: [contractConfig],
       });
 
@@ -333,7 +340,7 @@ describe("ZoraCreator1155Preminter", () => {
         ...premintTypedDataDefinition({
           verifyingContract: contractAddress,
           // we need to sign here for the anvil chain, cause thats where it is run on
-          chainId: foundry.id,
+          chainId: viemClients.chain.id,
           premintConfig: premintConfig1,
           premintConfigVersion: PremintConfigVersion.V1,
         }),
@@ -368,12 +375,14 @@ describe("ZoraCreator1155Preminter", () => {
       expect(contractCreated).toBe(false);
       expect(tokenId).toBe(0n);
 
-      const mintArguments: MintArguments = {
+      const mintArguments: PremintMintArguments = {
         mintComment: "",
         mintRecipient: collectorAccount,
         mintRewardsRecipients: [],
       };
 
+      const firstMinter = collectorAccount;
+
       // now have the collector execute the first signed message;
       // it should create the contract, the token,
       // and min the quantity to mint tokens to the collector
@@ -381,16 +390,22 @@ describe("ZoraCreator1155Preminter", () => {
       // parameters are required to call this function
       const mintHash = await viemClients.walletClient.writeContract({
         abi: preminterAbi,
-        functionName: "premintV1",
+        functionName: "premint",
         account: collectorAccount,
-        chain: foundry,
+        chain: viemClients.chain,
         address: PREMINTER_ADDRESS,
         args: [
           contractConfig,
-          premintConfig1,
+          zeroAddress,
+          encodePremintConfig({
+            premintConfig: premintConfig1,
+            premintConfigVersion: PremintConfigVersion.V1,
+          }),
           signedMessage,
           quantityToMint,
           mintArguments,
+          firstMinter,
+          zeroAddress,
         ],
         value: valueToSend,
       });
@@ -434,7 +449,7 @@ describe("ZoraCreator1155Preminter", () => {
       const signedMessage2 = await viemClients.walletClient.signTypedData({
         ...premintTypedDataDefinition({
           verifyingContract: contractAddress,
-          chainId: foundry.id,
+          chainId: viemClients.chain.id,
           premintConfig: premintConfig2,
           premintConfigVersion: PremintConfigVersion.V2,
         }),
@@ -454,16 +469,22 @@ describe("ZoraCreator1155Preminter", () => {
 
       const simulationResult = await viemClients.publicClient.simulateContract({
         abi: preminterAbi,
-        functionName: "premintV2",
+        functionName: "premint",
         account: collectorAccount,
-        chain: foundry,
+        chain: viemClients.chain,
         address: PREMINTER_ADDRESS,
         args: [
           contractConfig,
-          premintConfig2,
+          zeroAddress,
+          encodePremintConfig({
+            premintConfig: premintConfig2,
+            premintConfigVersion: PremintConfigVersion.V2,
+          }),
           signedMessage2,
           quantityToMint2,
           mintArguments,
+          firstMinter,
+          zeroAddress,
         ],
         value: valueToSend2,
       });
@@ -501,119 +522,194 @@ describe("ZoraCreator1155Preminter", () => {
 
       expect(tokenBalance2).toBe(quantityToMint2);
     },
-    // 10 second timeout
     40 * 1000,
-  );
-
-  zoraSepoliaAnvilTest(
-    "can decode the CreatorAttribution event",
-    async ({ viemClients }) => {
-      const {
-        fixedPriceMinterAddress,
-        accounts: { creatorAccount, collectorAccount },
-      } = await setupContracts({ viemClients });
-      const premintConfig = defaultPremintConfigV2({
-        fixedPriceMinter: fixedPriceMinterAddress,
-        creatorAccount,
-      });
-      const contractConfig = defaultContractConfig({
-        contractAdmin: creatorAccount,
-      });
-
-      // lets make it a random number to not break the existing tests that expect fresh data
-      premintConfig.uid = Math.round(Math.random() * 1000000);
-
-      let contractAddress = await viemClients.publicClient.readContract({
-        abi: preminterAbi,
-        address: PREMINTER_ADDRESS,
-        functionName: "getContractAddress",
-        args: [contractConfig],
-      });
-
-      const signingChainId = foundry.id;
-
-      // have creator sign the message to create the contract
-      // and the token
-      const signedMessage = await viemClients.walletClient.signTypedData({
-        ...premintTypedDataDefinition({
-          verifyingContract: contractAddress,
-          // we need to sign here for the anvil chain, cause thats where it is run on
-          chainId: signingChainId,
-          premintConfig,
-          premintConfigVersion: PremintConfigVersion.V2,
-        }),
-        account: creatorAccount,
-      });
-
-      const quantityToMint = 2n;
+  ),
+    zoraSepoliaAnvilTest(
+      "can have collaborators create premints that can be executed on existing contracts",
+      async ({ viemClients }) => {
+        const {
+          fixedPriceMinterAddress,
+          accounts: { creatorAccount, collectorAccount, collaboratorAccount },
+        } = await setupContracts({ viemClients });
+
+        await viemClients.testClient.setBalance({
+          address: collectorAccount,
+          value: parseEther("10"),
+        });
 
-      const valueToSend = (
-        await getPremintMintCosts({
-          publicClient: viemClients.publicClient,
-          quantityToMint,
-          tokenContract: contractAddress,
-          tokenPrice: premintConfig.tokenConfig.pricePerToken,
-        })
-      ).totalCost;
+        // setup contract and token creation parameters
+        const premintConfig = defaultPremintConfigV2({
+          fixedPriceMinter: fixedPriceMinterAddress,
+          creatorAccount,
+        });
+        // lets make it a random number to not break the existing tests that expect fresh data
+        premintConfig.uid = Math.round(Math.random() * 1000000);
 
-      await viemClients.testClient.setBalance({
-        address: collectorAccount,
-        value: parseEther("10"),
-      });
+        // create a premint config that a collaboratorw ill sign
+        const collaboratorPremintConfig = {
+          ...premintConfig,
+          uid: Math.round(Math.random() * 1000000),
+        };
 
-      // now have the collector execute the first signed message;
-      // it should create the contract, the token,
-      // and min the quantity to mint tokens to the collector
-      // the signature along with contract + token creation
-      // parameters are required to call this function
-      const mintHash = await viemClients.walletClient.writeContract({
-        abi: preminterAbi,
-        functionName: "premintV2",
-        account: collectorAccount,
-        chain: foundry,
-        address: PREMINTER_ADDRESS,
-        args: [
-          contractConfig,
-          premintConfig,
-          signedMessage,
-          quantityToMint,
-          {
-            mintComment: "",
-            mintRecipient: collectorAccount,
-            mintRewardsRecipients: [],
-          },
-        ],
-        value: valueToSend,
-      });
+        const contractConfig = defaultContractConfig({
+          contractAdmin: creatorAccount,
+        });
 
-      // ensure it succeeded
-      const receipt = await viemClients.publicClient.waitForTransactionReceipt({
-        hash: mintHash,
-      });
+        // modify contract config to have collaborators
+        contractConfig.additionalAdmins = [collaboratorAccount];
 
-      expect(receipt.status).toBe("success");
+        const contractAddress = await viemClients.publicClient.readContract({
+          abi: preminterAbi,
+          address: PREMINTER_ADDRESS,
+          functionName: "getContractWithAdditionalAdminsAddress",
+          args: [contractConfig],
+        });
 
-      // get the CreatorAttribution event from the erc1155 contract:
-      const topics = await viemClients.publicClient.getContractEvents({
-        abi: zoraCreator1155ImplABI,
-        address: contractAddress,
-        eventName: "CreatorAttribution",
-      });
+        // have creator sign the message to create the contract
+        // and the token
+        const creatorSignedMessage =
+          await viemClients.walletClient.signTypedData({
+            ...premintTypedDataDefinition({
+              verifyingContract: contractAddress,
+              // we need to sign here for the anvil chain, cause thats where it is run on
+              chainId: viemClients.chain.id,
+              premintConfig: premintConfig,
+              premintConfigVersion: PremintConfigVersion.V2,
+            }),
+            account: creatorAccount,
+          });
+
+        const collaboratorSignedMessage =
+          await viemClients.walletClient.signTypedData({
+            ...premintTypedDataDefinition({
+              verifyingContract: contractAddress,
+              // we need to sign here for the anvil chain, cause thats where it is run on
+              chainId: viemClients.chain.id,
+              premintConfig: collaboratorPremintConfig,
+              premintConfigVersion: PremintConfigVersion.V2,
+            }),
+            account: collaboratorAccount,
+          });
+
+        const quantityToMint = 2n;
+
+        const valueToSend = (
+          await getPremintMintCosts({
+            publicClient: viemClients.publicClient,
+            quantityToMint,
+            tokenContract: contractAddress,
+            tokenPrice: premintConfig.tokenConfig.pricePerToken,
+          })
+        ).totalCost;
+
+        const mintArguments: PremintMintArguments = {
+          mintComment: "",
+          mintRecipient: collectorAccount,
+          mintRewardsRecipients: [],
+        };
+
+        const firstMinter = collectorAccount;
+
+        await viemClients.publicClient.simulateContract({
+          abi: preminterAbi,
+          functionName: "premint",
+          account: collectorAccount,
+          chain: viemClients.chain,
+          address: PREMINTER_ADDRESS,
+          args: [
+            contractConfig,
+            zeroAddress,
+            encodePremintConfig({
+              premintConfig: collaboratorPremintConfig,
+              premintConfigVersion: PremintConfigVersion.V2,
+            }),
+            collaboratorSignedMessage,
+            quantityToMint,
+            mintArguments,
+            firstMinter,
+            zeroAddress,
+          ],
+          value: valueToSend,
+        });
 
-      expect(topics.length).toBe(1);
+        // now have the collector execute collaborators signed message;
+        // it should create the contract, the token, and add the collaborator
+        // as an admin to the contract along with the original creator
+        let tx = await viemClients.walletClient.writeContract({
+          abi: preminterAbi,
+          functionName: "premint",
+          account: collectorAccount,
+          chain: viemClients.chain,
+          address: PREMINTER_ADDRESS,
+          args: [
+            contractConfig,
+            zeroAddress,
+            encodePremintConfig({
+              premintConfig: collaboratorPremintConfig,
+              premintConfigVersion: PremintConfigVersion.V2,
+            }),
+            collaboratorSignedMessage,
+            quantityToMint,
+            mintArguments,
+            firstMinter,
+            zeroAddress,
+          ],
+          value: valueToSend,
+        });
 
-      const creatorAttributionEvent = topics[0]!;
+        // ensure it succeeded
+        expect(
+          (
+            await viemClients.publicClient.waitForTransactionReceipt({
+              hash: tx,
+            })
+          ).status,
+        ).toBe("success");
 
-      const { creator: creatorFromEvent } = creatorAttributionEvent.args;
+        tx = await viemClients.walletClient.writeContract({
+          abi: preminterAbi,
+          functionName: "premint",
+          account: collectorAccount,
+          chain: viemClients.chain,
+          address: PREMINTER_ADDRESS,
+          args: [
+            contractConfig,
+            zeroAddress,
+            encodePremintConfig({
+              premintConfig: premintConfig,
+              premintConfigVersion: PremintConfigVersion.V2,
+            }),
+            creatorSignedMessage,
+            quantityToMint,
+            mintArguments,
+            firstMinter,
+            zeroAddress,
+          ],
+          value: valueToSend,
+        });
 
-      const recoveredSigner = await recoverCreatorFromCreatorAttribution({
-        creatorAttribution: creatorAttributionEvent.args,
-        chainId: signingChainId,
-        tokenContract: contractAddress,
-      });
+        expect(
+          (
+            await viemClients.publicClient.waitForTransactionReceipt({
+              hash: tx,
+            })
+          ).status,
+        ).toBe("success");
+
+        // get balance of second token
+        const tokenBalances = await viemClients.publicClient.readContract({
+          abi: zoraCreator1155ImplABI,
+          address: contractAddress,
+          functionName: "balanceOfBatch",
+          args: [
+            [collectorAccount, collectorAccount],
+            [1n, 2n],
+          ],
+        });
 
-      expect(creatorFromEvent).toBe(creatorAccount);
-      expect(recoveredSigner).toBe(creatorFromEvent);
-    },
-  );
+        expect(tokenBalances).toEqual([quantityToMint, quantityToMint]);
+      },
+      // 10 second timeout
+      40 * 1000,
+    );
 });

package/src/premint/preminter.ts

@@ -5,9 +5,9 @@ import {
   zoraCreator1155PremintExecutorImplABI,
   zoraCreator1155PremintExecutorImplAddress,
   zoraCreatorFixedPriceSaleStrategyAddress,
+  premintTypedDataDefinition,
 } from "@zoralabs/protocol-deployments";
 import {
-  TypedDataDefinition,
   recoverTypedDataAddress,
   Hex,
   PublicClient,
@@ -28,50 +28,11 @@ import {
   PremintConfigVersion,
   PremintConfigWithVersion,
   TokenCreationConfig,
-} from "./contract-types";
-import {
-  premintV1TypedDataDefinition,
-  premintV2TypedDataDefinition,
 } from "@zoralabs/protocol-deployments";
 import { MintCosts } from "src/mint/mint-client";
 
 export const getPremintExecutorAddress = () =>
-  zoraCreator1155PremintExecutorImplAddress[999];
-
-/**
- * Creates a typed data definition for a premint config.  Works for all versions of the premint config by specifying the premintConfigVersion.
- *
- * @param params.verifyingContract the address of the 1155 contract
- * @param params.chainId the chain id the premint is signed for
- * @param params.premintConfigVersion the version of the premint config
- * @param params.premintConfig the premint config
- * @returns
- */
-export const premintTypedDataDefinition = <T extends PremintConfigVersion>({
-  verifyingContract,
-  chainId,
-  premintConfigVersion: version,
-  premintConfig,
-}: {
-  verifyingContract: Address;
-  chainId: number;
-} & PremintConfigWithVersion<T>): TypedDataDefinition => {
-  if (version === PremintConfigVersion.V1)
-    return premintV1TypedDataDefinition({
-      chainId,
-      creator1155Contract: verifyingContract,
-      message: premintConfig as PremintConfigV1,
-    });
-  if (version === PremintConfigVersion.V2) {
-    return premintV2TypedDataDefinition({
-      chainId,
-      creator1155Contract: verifyingContract,
-      message: premintConfig as PremintConfigV2,
-    });
-  }
-
-  throw new Error(`Invalid version ${version}`);
-};
+  zoraCreator1155PremintExecutorImplAddress[999] as Address;
 
 export type IsValidSignatureReturn = {
   isAuthorized: boolean;
@@ -89,12 +50,19 @@ export async function isAuthorizedToCreatePremint({
   publicClient: PublicClient;
   signer: Address;
 }) {
+  if (collection.additionalAdmins.length > 0)
+    throw new Error("additionalAdmins not supported yet.");
   // otherwize, we must assume the newer version of premint executor is deployed, so we call that.
   return await publicClient.readContract({
     abi: preminterAbi,
     address: getPremintExecutorAddress(),
-    functionName: "isAuthorizedToCreatePremint",
-    args: [signer, collection.contractAdmin, collectionAddress],
+    functionName: "isAuthorizedToCreatePremintWithAdditionalAdmins",
+    args: [
+      signer,
+      collection.contractAdmin,
+      collectionAddress,
+      collection.additionalAdmins,
+    ],
   });
 }
 
@@ -106,9 +74,8 @@ export async function recoverPremintSigner<T extends PremintConfigVersion>({
   chainId: number;
   verifyingContract: Address;
 } & PremintConfigWithVersion<T>): Promise<Address> {
-  const typedData = premintTypedDataDefinition(rest);
   return await recoverTypedDataAddress({
-    ...typedData,
+    ...premintTypedDataDefinition(rest),
     signature,
   });
 }
@@ -313,16 +280,6 @@ export async function getPremintCollectionAddress({
   });
 }
 
-export function markPremintDeleted<T extends PremintConfig>(
-  premintConfig: T,
-): T {
-  return {
-    ...premintConfig,
-    version: premintConfig.version + 1,
-    deleted: true,
-  };
-}
-
 export function applyUpdateToPremint({
   uid,
   version,

package/test-integration/premint-client.test.ts

@@ -54,6 +54,7 @@ tests.forEach(({ anvilTest, chain }) => {
                   contractName: "Testing Contract Premint V2",
                   contractURI:
                     "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3f",
+                  additionalAdmins: [],
                 },
                 premintConfigVersion: PremintConfigVersion.V2,
                 tokenCreationConfig: {
@@ -110,6 +111,7 @@ tests.forEach(({ anvilTest, chain }) => {
                   contractName: `Testing Contract Premint V1 ${publicClient.chain?.name}`,
                   contractURI:
                     "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3fg",
+                  additionalAdmins: [],
                 },
                 premintConfigVersion: PremintConfigVersion.V1,
                 tokenCreationConfig: {