@zoralabs/protocol-sdk 0.3.5 → 0.4.1

package/src/premint/preminter.test.ts

@@ -9,19 +9,22 @@ import {
   zoraCreator1155FactoryImplConfig,
 } from "@zoralabs/protocol-deployments";
 
+import {
+  premintTypedDataDefinition,
+  isValidSignature,
+  recoverCreatorFromCreatorAttribution,
+  getPremintExecutorAddress,
+  getPremintMintCosts,
+} from "./preminter";
 import {
   ContractCreationConfig,
   PremintConfigV1,
   TokenCreationConfigV1,
-  premintTypedDataDefinition,
-  isValidSignature,
   PremintConfigVersion,
   TokenCreationConfigV2,
   PremintConfigV2,
   MintArguments,
-  recoverCreatorFromCreatorAttribution,
-  getPremintExecutorAddress,
-} from "./preminter";
+} from "./contract-types";
 import { AnvilViemClientsTest, forkUrls, makeAnvilTest } from "src/anvil";
 
 // create token and contract creation config:
@@ -100,12 +103,10 @@ const defaultPremintConfigV2 = ({
   version: 0,
 });
 
-const ZORA_MINT_FEE = parseEther("0.000777");
-
 const PREMINTER_ADDRESS = getPremintExecutorAddress();
 
 const anvilTest = makeAnvilTest({
-  forkUrl: forkUrls.zoraSepoli,
+  forkUrl: forkUrls.zoraSepolia,
   forkBlockNumber: 1265490,
 });
 
@@ -138,6 +139,11 @@ async function setupContracts({
   };
 }
 
+const zoraSepoliaAnvilTest = makeAnvilTest({
+  forkUrl: forkUrls.zoraSepolia,
+  forkBlockNumber: 1905837,
+});
+
 describe("ZoraCreator1155Preminter", () => {
   // skip for now - we need to make this work on zora testnet chain too
   anvilTest(
@@ -184,7 +190,7 @@ describe("ZoraCreator1155Preminter", () => {
     },
     20 * 1000,
   );
-  anvilTest(
+  zoraSepoliaAnvilTest(
     "can sign and recover a v1 premint config signature",
     async ({ viemClients }) => {
       const {
@@ -237,10 +243,7 @@ describe("ZoraCreator1155Preminter", () => {
 
     20 * 1000,
   );
-  makeAnvilTest({
-    forkUrl: forkUrls.zoraSepoli,
-    forkBlockNumber: 1262991,
-  })(
+  zoraSepoliaAnvilTest(
     "can sign and recover a v2 premint config signature",
     async ({ viemClients }) => {
       const {
@@ -294,7 +297,7 @@ describe("ZoraCreator1155Preminter", () => {
 
     20 * 1000,
   );
-  anvilTest(
+  zoraSepoliaAnvilTest(
     "can sign and mint multiple tokens",
     async ({ viemClients }) => {
       const {
@@ -335,9 +338,14 @@ describe("ZoraCreator1155Preminter", () => {
 
       const quantityToMint = 2n;
 
-      const valueToSend =
-        (ZORA_MINT_FEE + premintConfig1.tokenConfig.pricePerToken) *
-        quantityToMint;
+      const valueToSend = (
+        await getPremintMintCosts({
+          publicClient: viemClients.publicClient,
+          quantityToMint,
+          tokenContract: contractAddress,
+          tokenPrice: premintConfig1.tokenConfig.pricePerToken,
+        })
+      ).totalCost;
 
       await viemClients.testClient.setBalance({
         address: collectorAccount,
@@ -359,7 +367,7 @@ describe("ZoraCreator1155Preminter", () => {
       const mintArguments: MintArguments = {
         mintComment: "",
         mintRecipient: collectorAccount,
-        mintReferral: collectorAccount,
+        mintRewardsRecipients: [],
       };
 
       // now have the collector execute the first signed message;
@@ -431,9 +439,14 @@ describe("ZoraCreator1155Preminter", () => {
 
       const quantityToMint2 = 4n;
 
-      const valueToSend2 =
-        (ZORA_MINT_FEE + premintConfig2.tokenConfig.pricePerToken) *
-        quantityToMint2;
+      const valueToSend2 = (
+        await getPremintMintCosts({
+          publicClient: viemClients.publicClient,
+          quantityToMint: quantityToMint2,
+          tokenContract: contractAddress,
+          tokenPrice: premintConfig2.tokenConfig.pricePerToken,
+        })
+      ).totalCost;
 
       const simulationResult = await viemClients.publicClient.simulateContract({
         abi: preminterAbi,
@@ -488,7 +501,7 @@ describe("ZoraCreator1155Preminter", () => {
     40 * 1000,
   );
 
-  anvilTest(
+  zoraSepoliaAnvilTest(
     "can decode the CreatorAttribution event",
     async ({ viemClients }) => {
       const {
@@ -530,9 +543,14 @@ describe("ZoraCreator1155Preminter", () => {
 
       const quantityToMint = 2n;
 
-      const valueToSend =
-        (ZORA_MINT_FEE + premintConfig.tokenConfig.pricePerToken) *
-        quantityToMint;
+      const valueToSend = (
+        await getPremintMintCosts({
+          publicClient: viemClients.publicClient,
+          quantityToMint,
+          tokenContract: contractAddress,
+          tokenPrice: premintConfig.tokenConfig.pricePerToken,
+        })
+      ).totalCost;
 
       await viemClients.testClient.setBalance({
         address: collectorAccount,
@@ -558,7 +576,7 @@ describe("ZoraCreator1155Preminter", () => {
           {
             mintComment: "",
             mintRecipient: collectorAccount,
-            mintReferral: zeroAddress,
+            mintRewardsRecipients: [],
           },
         ],
         value: valueToSend,

package/src/premint/preminter.ts

@@ -1,5 +1,4 @@
 import { Address } from "abitype";
-import { ExtractAbiFunction, AbiParametersToPrimitiveTypes } from "abitype";
 import {
   zoraCreator1155PremintExecutorImplABI as preminterAbi,
   zoraCreator1155ImplABI,
@@ -17,103 +16,22 @@ import {
   concat,
   recoverAddress,
   GetEventArgs,
+  parseEther,
 } from "viem";
-
-type PremintV1Inputs = ExtractAbiFunction<
-  typeof preminterAbi,
-  "premintV1"
->["inputs"];
-
-type PremintV1HashDataTypes = AbiParametersToPrimitiveTypes<PremintV1Inputs>;
-
-export type ContractCreationConfig = PremintV1HashDataTypes[0];
-
-export type PremintConfigV1 = PremintV1HashDataTypes[1];
-export type TokenCreationConfigV1 = PremintConfigV1["tokenConfig"];
-
-export type MintArguments = PremintV1HashDataTypes[4];
-
-type PremintV2Inputs = ExtractAbiFunction<
-  typeof preminterAbi,
-  "premintV2"
->["inputs"];
-
-type PremintV2HashDataTypes = AbiParametersToPrimitiveTypes<PremintV2Inputs>;
-
-export type PremintConfigV2 = PremintV2HashDataTypes[1];
-export type TokenCreationConfigV2 = PremintConfigV2["tokenConfig"];
-
-const v1Types = {
-  CreatorAttribution: [
-    { name: "tokenConfig", type: "TokenCreationConfig" },
-    // unique id scoped to the contract and token to create.
-    // ensure that a signature can be replaced, as long as the replacement
-    // has the same uid, and a newer version.
-    { name: "uid", type: "uint32" },
-    { name: "version", type: "uint32" },
-    // if this update should result in the signature being deleted.
-    { name: "deleted", type: "bool" },
-  ],
-  TokenCreationConfig: [
-    { name: "tokenURI", type: "string" },
-    { name: "maxSupply", type: "uint256" },
-    { name: "maxTokensPerAddress", type: "uint64" },
-    { name: "pricePerToken", type: "uint96" },
-    { name: "mintStart", type: "uint64" },
-    { name: "mintDuration", type: "uint64" },
-    { name: "royaltyMintSchedule", type: "uint32" },
-    { name: "royaltyBPS", type: "uint32" },
-    { name: "royaltyRecipient", type: "address" },
-    { name: "fixedPriceMinter", type: "address" },
-  ],
-} as const;
-
-const v2Types = {
-  CreatorAttribution: [
-    { name: "tokenConfig", type: "TokenCreationConfig" },
-    // unique id scoped to the contract and token to create.
-    // ensure that a signature can be replaced, as long as the replacement
-    // has the same uid, and a newer version.
-    { name: "uid", type: "uint32" },
-    { name: "version", type: "uint32" },
-    // if this update should result in the signature being deleted.
-    { name: "deleted", type: "bool" },
-  ],
-  TokenCreationConfig: [
-    { name: "tokenURI", type: "string" },
-    { name: "maxSupply", type: "uint256" },
-    { name: "maxTokensPerAddress", type: "uint64" },
-    { name: "pricePerToken", type: "uint96" },
-    { name: "mintStart", type: "uint64" },
-    { name: "mintDuration", type: "uint64" },
-    { name: "royaltyBPS", type: "uint32" },
-    { name: "payoutRecipient", type: "address" },
-    { name: "fixedPriceMinter", type: "address" },
-    { name: "createReferral", type: "address" },
-  ],
-} as const;
-
-export const PreminterDomain = "Preminter";
-
-type PremintConfigVersion = "1" | "2";
-
-export const PremintConfigVersion = {
-  V1: "1",
-  V2: "2",
-} as const;
-
-type PremintConfigForVersion<T extends PremintConfigVersion> = T extends "1"
-  ? PremintConfigV1
-  : PremintConfigV2;
-
-type PremintConfigWithVersion<T extends PremintConfigVersion> = {
-  premintConfig: PremintConfigForVersion<T>;
-  premintConfigVersion: T;
-};
-
-export type PremintConfigAndVersion =
-  | PremintConfigWithVersion<"1">
-  | PremintConfigWithVersion<"2">;
+import {
+  ContractCreationConfig,
+  PremintConfig,
+  PremintConfigForTokenCreationConfig,
+  PremintConfigV1,
+  PremintConfigV2,
+  PremintConfigVersion,
+  PremintConfigWithVersion,
+  PreminterDomain,
+  TokenCreationConfig,
+  v1Types,
+  v2Types,
+} from "./contract-types";
+import { MintCosts } from "src/mint/mint-client";
 
 export const getPremintExecutorAddress = () =>
   zoraCreator1155PremintExecutorImplAddress[999];
@@ -127,7 +45,7 @@ export const getPremintExecutorAddress = () =>
  * @param params.premintConfig the premint config
  * @returns
  */
-export const premintTypedDataDefinition = ({
+export const premintTypedDataDefinition = <T extends PremintConfigVersion>({
   verifyingContract,
   chainId,
   premintConfigVersion: version,
@@ -135,7 +53,7 @@ export const premintTypedDataDefinition = ({
 }: {
   verifyingContract: Address;
   chainId: number;
-} & PremintConfigAndVersion): TypedDataDefinition => {
+} & PremintConfigWithVersion<T>): TypedDataDefinition => {
   const domain = {
     chainId,
     name: PreminterDomain,
@@ -147,14 +65,14 @@ export const premintTypedDataDefinition = ({
     return {
       domain,
       types: v1Types,
-      message: premintConfig,
+      message: premintConfig as PremintConfigV1,
       primaryType: "CreatorAttribution",
     } satisfies TypedDataDefinition<typeof v1Types, "CreatorAttribution">;
   if (version === PremintConfigVersion.V2) {
     return {
       domain,
       types: v2Types,
-      message: premintConfig,
+      message: premintConfig as PremintConfigV2,
       primaryType: "CreatorAttribution",
     } satisfies TypedDataDefinition<typeof v2Types, "CreatorAttribution">;
   }
@@ -167,7 +85,9 @@ export type IsValidSignatureReturn = {
   recoveredAddress?: Address;
 };
 
-export async function isAuthorizedToCreatePremint({
+export async function isAuthorizedToCreatePremint<
+  T extends PremintConfigVersion,
+>({
   collection,
   collectionAddress,
   publicClient,
@@ -181,7 +101,7 @@ export async function isAuthorizedToCreatePremint({
   publicClient: PublicClient;
   signature: Hex;
   signer: Address;
-} & PremintConfigAndVersion) {
+} & PremintConfigWithVersion<T>) {
   // if we are using legacy version of premint config, we can use the function
   // "isValidSignature" which we know exists on the premint executor contract
   if (premintConfigVersion === PremintConfigVersion.V1) {
@@ -189,7 +109,7 @@ export async function isAuthorizedToCreatePremint({
       abi: zoraCreator1155PremintExecutorImplABI,
       address: getPremintExecutorAddress(),
       functionName: "isValidSignature",
-      args: [collection, premintConfig, signature],
+      args: [collection, premintConfig as PremintConfigV1, signature],
     });
 
     return isValidSignature;
@@ -204,14 +124,14 @@ export async function isAuthorizedToCreatePremint({
   });
 }
 
-export async function recoverPremintSigner({
+export async function recoverPremintSigner<T extends PremintConfigVersion>({
   signature,
   ...rest
 }: {
   signature: Hex;
   chainId: number;
   verifyingContract: Address;
-} & PremintConfigAndVersion): Promise<Address> {
+} & PremintConfigWithVersion<T>): Promise<Address> {
   const typedData = premintTypedDataDefinition(rest);
   return await recoverTypedDataAddress({
     ...typedData,
@@ -241,7 +161,7 @@ export async function tryRecoverPremintSigner(
  * @param params.tokenContract the address of the 1155 contract
  * @returns
  */
-export async function isValidSignature({
+export async function isValidSignature<T extends PremintConfigVersion>({
   signature,
   publicClient,
   collection,
@@ -252,7 +172,7 @@ export async function isValidSignature({
   signature: Hex;
   chainId: number;
   publicClient: PublicClient;
-} & PremintConfigAndVersion): Promise<IsValidSignatureReturn> {
+} & PremintConfigWithVersion<T>): Promise<IsValidSignatureReturn> {
   const tokenContract = await getPremintCollectionAddress({
     collection,
     publicClient,
@@ -375,22 +295,41 @@ export const recoverCreatorFromCreatorAttribution = async ({
   });
 };
 
+export const supportedPremintVersions = async ({
+  tokenContract,
+  publicClient,
+}: {
+  tokenContract: Address;
+  publicClient: PublicClient;
+}): Promise<readonly string[]> => {
+  try {
+    return await publicClient.readContract({
+      abi: preminterAbi,
+      address: getPremintExecutorAddress(),
+      functionName: "supportedPremintSignatureVersions",
+      args: [tokenContract],
+    });
+  } catch (e) {
+    console.error(e);
+    // if the premint executor contract doesn't support the function, it must be v1
+    return ["1"];
+  }
+};
 /**
  * Checks if the 1155 contract at that address supports the given version of the premint config.
  */
-export const supportsPremintVersion = async (
-  version: PremintConfigVersion,
-  tokenContract: Address,
-  publicClient: PublicClient,
-): Promise<boolean> => {
-  const supportedPremintSignatureVersions = await publicClient.readContract({
-    abi: preminterAbi,
-    address: getPremintExecutorAddress(),
-    functionName: "supportedPremintSignatureVersions",
-    args: [tokenContract],
-  });
-
-  return supportedPremintSignatureVersions.includes(version);
+export const supportsPremintVersion = async ({
+  version,
+  tokenContract,
+  publicClient,
+}: {
+  version: PremintConfigVersion;
+  tokenContract: Address;
+  publicClient: PublicClient;
+}): Promise<boolean> => {
+  return (
+    await supportedPremintVersions({ tokenContract, publicClient })
+  ).includes(version);
 };
 
 export async function getPremintCollectionAddress({
@@ -407,3 +346,105 @@ export async function getPremintCollectionAddress({
     args: [collection],
   });
 }
+
+export function markPremintDeleted<T extends PremintConfig>(
+  premintConfig: T,
+): T {
+  return {
+    ...premintConfig,
+    version: premintConfig.version + 1,
+    deleted: true,
+  };
+}
+
+export function applyUpdateToPremint({
+  uid,
+  version,
+  tokenConfig,
+  tokenConfigUpdates,
+}: {
+  tokenConfig: TokenCreationConfig;
+  tokenConfigUpdates: Partial<TokenCreationConfig>;
+} & Pick<PremintConfig, "uid" | "version">): PremintConfig {
+  const updatedTokenConfig: TokenCreationConfig = {
+    ...tokenConfig,
+    ...tokenConfigUpdates,
+  } as const;
+
+  const result = {
+    deleted: false,
+    uid,
+    version: version + 1,
+    tokenConfig: updatedTokenConfig,
+  } as PremintConfig;
+
+  return result;
+}
+
+export function makeNewPremint<T extends TokenCreationConfig>({
+  tokenConfig,
+  uid,
+}: {
+  tokenConfig: T;
+  uid: number;
+}): PremintConfigForTokenCreationConfig<T> {
+  return {
+    deleted: false,
+    uid,
+    version: 0,
+    tokenConfig,
+  } as PremintConfigForTokenCreationConfig<T>;
+}
+
+export async function getPremintMintFee({
+  tokenContract,
+  publicClient,
+}: {
+  tokenContract: Address;
+  publicClient: PublicClient;
+}) {
+  // try reading mint fee function from premint executor.  this will revert
+  // if the abi is not up to date yet
+  try {
+    return await publicClient.readContract({
+      address: getPremintExecutorAddress(),
+      abi: zoraCreator1155PremintExecutorImplABI,
+      functionName: "mintFee",
+      args: [tokenContract],
+    });
+  } catch (e) {
+    console.error(e);
+
+    return parseEther("0.000777");
+  }
+}
+
+export async function getPremintMintCosts({
+  publicClient,
+  tokenContract,
+  tokenPrice,
+  quantityToMint,
+}: {
+  tokenContract: Address;
+  tokenPrice: bigint;
+  quantityToMint: bigint;
+  publicClient: PublicClient;
+}): Promise<MintCosts> {
+  const mintFee = await getPremintMintFee({ tokenContract, publicClient });
+
+  return {
+    mintFee: mintFee * quantityToMint,
+    tokenPurchaseCost: tokenPrice * quantityToMint,
+    totalCost: (mintFee + tokenPrice) * quantityToMint,
+  };
+}
+
+export function makeMintRewardsRecipient({
+  mintReferral = zeroAddress,
+  platformReferral = zeroAddress,
+}: {
+  mintReferral?: Address;
+  platformReferral?: Address;
+}): Address[] {
+  return [mintReferral, platformReferral];
+}