@zoralabs/protocol-sdk 0.5.12 → 0.5.14

package/src/premint/premint-client.ts

@@ -5,19 +5,16 @@ import type {
   Chain,
   Hex,
   PublicClient,
-  SimulateContractParameters,
   TransactionReceipt,
   WalletClient,
 } from "viem";
 import { zoraCreator1155PremintExecutorImplABI } from "@zoralabs/protocol-deployments";
 import {
   getPremintCollectionAddress,
-  premintTypedDataDefinition,
   isValidSignature,
   isAuthorizedToCreatePremint,
   getPremintExecutorAddress,
   applyUpdateToPremint,
-  markPremintDeleted,
   makeNewPremint,
   supportsPremintVersion,
   getPremintMintCosts,
@@ -28,13 +25,14 @@ import {
   PremintConfigVersion,
   ContractCreationConfig,
   TokenConfigForVersion,
-  PremintConfigWithVersion,
   TokenCreationConfigV1,
   TokenCreationConfigV2,
   TokenCreationConfig,
   PremintConfigForVersion,
-  MintArguments,
-} from "./contract-types";
+  PremintConfigWithVersion,
+  PremintMintArguments,
+  premintTypedDataDefinition,
+} from "@zoralabs/protocol-deployments";
 import { PremintAPIClient } from "./premint-api-client";
 import type { DecodeEventLogReturnType } from "viem";
 import { OPEN_EDITION_MINT_SIZE } from "../constants";
@@ -92,21 +90,28 @@ const makeTokenConfigWithDefaults = <T extends PremintConfigVersion>({
   creatorAccount,
 }: {
   chainId: number;
-  premintConfigVersion: PremintConfigVersion;
+  premintConfigVersion: T;
   tokenCreationConfig: Partial<TokenConfigForVersion<T>> & { tokenURI: string };
   creatorAccount: Address;
 }): TokenConfigForVersion<T> => {
+  if (premintConfigVersion === PremintConfigVersion.V3) {
+    throw new Error("PremintV3 not supported in SDK");
+  }
+
   const fixedPriceMinter =
-    tokenCreationConfig.fixedPriceMinter ||
-    getDefaultFixedPriceMinterAddress(chainId);
+    (
+      tokenCreationConfig as
+        | Partial<TokenCreationConfigV1>
+        | Partial<TokenCreationConfigV2>
+    ).fixedPriceMinter || getDefaultFixedPriceMinterAddress(chainId);
 
   if (premintConfigVersion === PremintConfigVersion.V1) {
     return {
       fixedPriceMinter,
       ...defaultTokenConfigV1MintArguments(),
       royaltyRecipient: creatorAccount,
-      ...tokenCreationConfig,
-    };
+      ...(tokenCreationConfig as Partial<TokenCreationConfigV1>),
+    } as TokenCreationConfigV1;
   } else if (premintConfigVersion === PremintConfigVersion.V2) {
     return {
       fixedPriceMinter,
@@ -265,7 +270,11 @@ class PremintClient {
       uid: uid,
     });
 
-    const deletedPremint = markPremintDeleted(premintConfig);
+    const deletedPremint = {
+      ...premintConfig,
+      version: premintConfig.version + 1,
+      deleted: true,
+    };
 
     return await this.signAndSubmitPremint({
       walletClient,
@@ -363,6 +372,7 @@ class PremintClient {
 
     const premintConfig = makeNewPremint({
       tokenConfig: makeTokenConfigWithDefaults({
+        // @ts-ignore
         premintConfigVersion: actualVersion,
         tokenCreationConfig,
         creatorAccount:
@@ -511,16 +521,7 @@ class PremintClient {
       platformReferral?: Address;
       mintRecipient?: Address;
     };
-  }): Promise<
-    SimulateContractParameters<
-      typeof zoraCreator1155PremintExecutorImplABI,
-      "premintV1" | "premintV2",
-      any,
-      any,
-      any,
-      Account | Address
-    >
-  > {
+  }) {
     if (mintArguments && mintArguments?.quantityToMint < 1) {
       throw new Error("Quantity to mint cannot be below 1");
     }
@@ -537,6 +538,10 @@ class PremintClient {
 
     const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
 
+    if (premintConfigVersion === PremintConfigVersion.V3) {
+      throw new Error("PremintV3 not supported in premint SDK");
+    }
+
     const value = (
       await getPremintMintCosts({
         tokenContract,
@@ -546,7 +551,7 @@ class PremintClient {
       })
     ).totalCost;
 
-    const mintArgumentsContract: MintArguments = {
+    const mintArgumentsContract: PremintMintArguments = {
       mintComment: mintArguments?.mintComment || "",
       mintRecipient:
         mintArguments?.mintRecipient ||

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,
+    );
 });