@zoralabs/protocol-sdk 0.12.2 → 0.13.0

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

@@ -2,17 +2,12 @@ import { zoraSepolia } from "viem/chains";
 import { describe, expect, vi } from "vitest";
 
 import { PremintConfigVersion } from "./contract-types";
-import {
-  getDefaultFixedPriceMinterAddress,
-  getPremintCollectionAddress,
-} from "./preminter";
 import { forkUrls, makeAnvilTest } from "src/anvil";
-import {
-  ContractCreationConfig,
-  PremintConfigV2,
-} from "@zoralabs/protocol-deployments";
 import { PremintAPIClient } from "./premint-api-client";
-import { createCollectorClient, createCreatorClient } from "src/sdk";
+import { mint } from "../mint/mint-client";
+import { getDataFromPremintReceipt } from "./premint-client";
+import { zoraCreatorFixedPriceSaleStrategyAddress } from "@zoralabs/protocol-deployments";
+import { Address } from "viem";
 
 const anvilTest = makeAnvilTest({
   forkUrl: forkUrls.zoraSepolia,
@@ -20,6 +15,12 @@ const anvilTest = makeAnvilTest({
   anvilChainId: zoraSepolia.id,
 });
 
+function getDefaultFixedPriceMinterAddress(chainId: number): Address {
+  return zoraCreatorFixedPriceSaleStrategyAddress[
+    chainId as keyof typeof zoraCreatorFixedPriceSaleStrategyAddress
+  ]!;
+}
+
 describe("ZoraCreator1155Premint", () => {
   anvilTest(
     "can mint premints",
@@ -67,27 +68,25 @@ describe("ZoraCreator1155Premint", () => {
 
       premintApiClient.postSignature = vi.fn();
 
-      const collectorClient = createCollectorClient({
-        chainId: chain.id,
-        publicClient,
-        premintGetter: premintApiClient,
-      });
-
-      const { parameters } = await collectorClient.mint({
+      const { parameters } = await mint({
         mintType: "premint",
         minterAccount: deployerAccount!,
         tokenContract: "0xf8dA7f53c283d898818af7FB9d98103F559bDac2",
         uid: 3,
         quantityToMint: 1,
         mintComment: "",
+        publicClient,
+        premintGetter: premintApiClient,
       });
       const { request: simulateRequest } =
         await publicClient.simulateContract(parameters);
       const hash = await walletClient.writeContract(simulateRequest);
       const receipt = await publicClient.waitForTransactionReceipt({ hash });
 
-      const { premintedLog, urls } =
-        collectorClient.getCollectDataFromPremintReceipt(receipt);
+      const { premintedLog, urls } = getDataFromPremintReceipt(
+        receipt,
+        publicClient.chain.id,
+      );
 
       expect(urls).toEqual({
         explorer:
@@ -110,182 +109,3 @@ describe("ZoraCreator1155Premint", () => {
     20 * 1000,
   );
 });
-
-describe("ZoraCreator1155Premint - v2 signatures", () => {
-  anvilTest(
-    "can sign and submit new premints on new contracts",
-    async ({ viemClients: { walletClient, publicClient, chain } }) => {
-      const [creatorAccount, createReferralAccount] =
-        await walletClient.getAddresses();
-      const premintApiClient = new PremintAPIClient(chain.id);
-
-      premintApiClient.getNextUID = vi
-        .fn<typeof premintApiClient.getNextUID>()
-        .mockResolvedValue(3);
-      premintApiClient.postSignature = vi
-        .fn<typeof premintApiClient.postSignature>()
-        // @ts-ignore
-        .mockResolvedValue({});
-
-      const creatorClient = createCreatorClient({
-        chainId: chain.id,
-        premintApi: premintApiClient,
-        publicClient,
-      });
-
-      const { signAndSubmit } = await creatorClient.createPremint({
-        contract: {
-          contractAdmin: creatorAccount!,
-          contractName: "Testing Contract Premint V2",
-          contractURI:
-            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
-        },
-        token: {
-          tokenURI:
-            "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
-          payoutRecipient: creatorAccount!,
-          createReferral: createReferralAccount,
-        },
-      });
-
-      await signAndSubmit({
-        account: creatorAccount!,
-        walletClient,
-        checkSignature: true,
-      });
-
-      const expectedPostSignatureArgs: Parameters<
-        typeof premintApiClient.postSignature
-      >[0] = {
-        contract: {
-          contractAdmin: creatorAccount!,
-          contractName: "Testing Contract Premint V2",
-          contractURI:
-            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
-        },
-        contractAddress: undefined,
-        premintConfig: {
-          deleted: false,
-          tokenConfig: {
-            fixedPriceMinter: "0x6d28164C3CE04A190D5F9f0f8881fc807EAD975A",
-            maxSupply: 18446744073709551615n,
-            maxTokensPerAddress: 0n,
-            mintDuration: 0n,
-            mintStart: 0n,
-            pricePerToken: 0n,
-            royaltyBPS: 1000,
-            payoutRecipient: creatorAccount!,
-            createReferral: createReferralAccount!,
-            tokenURI:
-              "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
-          },
-          uid: 3,
-          version: 0,
-        },
-        premintConfigVersion: PremintConfigVersion.V2,
-        signature:
-          "0xfe5725c05754ad17a73cc9706bf940e30bd7b4a674bb1b283a66a1cc87022c8c13fcf8989f9feb675f8932a6a8ddb8d16af2abef28fa2fff3282487ef5385b3d1b",
-      };
-
-      expect(premintApiClient.postSignature).toHaveBeenCalledWith(
-        expectedPostSignatureArgs,
-      );
-    },
-    20 * 1000,
-  );
-
-  anvilTest(
-    "can mint premints with additional admins",
-    async ({ viemClients: { walletClient, publicClient, chain } }) => {
-      const [deployerAccount, creatorAccount, additionalAdmin] =
-        await walletClient.getAddresses();
-
-      const premintApiClient = new PremintAPIClient(chain.id);
-
-      const collectorClient = createCollectorClient({
-        chainId: chain.id,
-        publicClient,
-        premintGetter: premintApiClient,
-      });
-
-      const creatorClient = createCreatorClient({
-        chainId: chain.id,
-        publicClient,
-        premintApi: premintApiClient,
-      });
-
-      const collection: ContractCreationConfig = {
-        contractAdmin: creatorAccount!,
-        contractName: "Testing Contract",
-        contractURI:
-          "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
-        additionalAdmins: [additionalAdmin!],
-      };
-
-      const collectionAddress = await getPremintCollectionAddress({
-        contract: collection,
-        publicClient,
-      });
-
-      const { premintConfig, typedDataDefinition } =
-        await creatorClient.createPremint({
-          contract: collection,
-          token: {
-            tokenURI:
-              "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
-            payoutRecipient: creatorAccount!,
-          },
-        });
-
-      const signature = await walletClient.signTypedData({
-        ...typedDataDefinition,
-        account: additionalAdmin!,
-      });
-
-      premintApiClient.get = vi
-        .fn<typeof premintApiClient.get>()
-        .mockResolvedValue({
-          collection,
-          collectionAddress,
-          premint: {
-            premintConfig: premintConfig as PremintConfigV2,
-            premintConfigVersion: PremintConfigVersion.V2,
-          },
-          signer: collection.contractAdmin,
-          signature,
-        });
-
-      const { parameters } = await collectorClient.mint({
-        mintType: "premint",
-        uid: premintConfig.uid,
-        minterAccount: deployerAccount!,
-        tokenContract: collectionAddress,
-        quantityToMint: 1,
-        mintComment: "",
-      });
-      const { request: simulateRequest } =
-        await publicClient.simulateContract(parameters);
-      const hash = await walletClient.writeContract(simulateRequest);
-      const receipt = await publicClient.waitForTransactionReceipt({ hash });
-
-      const { premintedLog, urls } =
-        collectorClient.getCollectDataFromPremintReceipt(receipt);
-
-      expect(urls).toEqual({
-        explorer: `https://undefined/token/${collectionAddress}/instance/1`,
-        zoraCollect: `https://testnet.zora.co/collect/zsep:${collectionAddress}/1`,
-        zoraManage: `https://testnet.zora.co/collect/zsep:${collectionAddress}/1`,
-      });
-
-      expect(premintedLog).toEqual({
-        contractAddress: collectionAddress,
-        createdNewContract: expect.any(Boolean),
-        minter: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        quantityMinted: 1n,
-        tokenId: 1n,
-        uid: premintConfig.uid,
-      });
-    },
-    20 * 1000,
-  );
-});

package/src/premint/premint-client.ts

@@ -9,8 +9,6 @@ import type {
   WalletClient,
 } from "viem";
 import {
-  PremintConfigAndVersion,
-  TokenConfigWithVersion,
   encodePremintConfig,
   zoraCreator1155PremintExecutorImplABI,
 } from "@zoralabs/protocol-deployments";
@@ -18,12 +16,8 @@ import {
   getPremintCollectionAddress,
   isAuthorizedToCreatePremint,
   getPremintExecutorAddress,
-  applyUpdateToPremint,
-  makeNewPremint,
-  supportedPremintVersions,
   getPremintMintCosts,
   makeMintRewardsRecipient,
-  getDefaultFixedPriceMinterAddress,
   emptyContractCreationConfig,
   defaultAdditionalAdmins,
   toContractCreationConfigOrAddress,
@@ -32,25 +26,18 @@ import {
 import {
   PremintConfigVersion,
   ContractCreationConfig,
-  TokenCreationConfigV1,
-  TokenCreationConfigV2,
-  TokenCreationConfig,
   PremintConfigWithVersion,
   PremintMintArguments,
   premintTypedDataDefinition,
 } from "@zoralabs/protocol-deployments";
 import { IPremintAPI, IPremintGetter } from "./premint-api-client";
 import type { DecodeEventLogReturnType } from "viem";
-import { OPEN_EDITION_MINT_SIZE } from "../constants";
 import {
   makeContractParameters,
   mintRecipientOrAccount,
   PublicClient,
 } from "src/utils";
-import {
-  ContractCreationConfigAndAddress,
-  ContractCreationConfigOrAddress,
-} from "./contract-types";
+import { ContractCreationConfigAndAddress } from "./contract-types";
 import {
   MakeMintParametersArgumentsBase,
   MakePremintMintParametersArguments,
@@ -65,143 +52,19 @@ type PremintedV2LogType = DecodeEventLogReturnType<
   "PremintedV2"
 >["args"];
 
-export type URLSReturnType = {
+type URLSReturnType = {
   explorer: null | string;
   zoraCollect: null | string;
   zoraManage: null | string;
 };
 
-export const defaultTokenConfigV1MintArguments = (): Omit<
-  TokenCreationConfigV1,
-  "fixedPriceMinter" | "tokenURI" | "royaltyRecipient"
-> => ({
-  maxSupply: OPEN_EDITION_MINT_SIZE,
-  maxTokensPerAddress: 0n,
-  pricePerToken: 0n,
-  mintDuration: 0n,
-  mintStart: 0n,
-  royaltyMintSchedule: 0,
-  royaltyBPS: 1000, // 10%,
-});
-
-const pickTokenConfigV1 = (tokenConfig: TokenConfigInput) => ({
-  maxSupply: tokenConfig.maxSupply,
-  maxTokensPerAddress: tokenConfig.maxTokensPerAddress,
-  pricePerToken: tokenConfig.pricePerToken,
-  mintDuration: tokenConfig.mintDuration,
-  mintStart: tokenConfig.mintStart,
-  royaltyBPS: tokenConfig.royaltyBPS,
-  tokenURI: tokenConfig.tokenURI,
-  royaltyRecipient: tokenConfig.payoutRecipient,
-});
-
-const pickTokenConfigV2 = (tokenConfig: TokenConfigInput) => ({
-  maxSupply: tokenConfig.maxSupply,
-  maxTokensPerAddress: tokenConfig.maxTokensPerAddress,
-  pricePerToken: tokenConfig.pricePerToken,
-  mintDuration: tokenConfig.mintDuration,
-  mintStart: tokenConfig.mintStart,
-  royaltyBPS: tokenConfig.royaltyBPS,
-  tokenURI: tokenConfig.tokenURI,
-  payoutRecipient: tokenConfig.payoutRecipient,
-  createReferral: tokenConfig.createReferral || zeroAddress,
-});
-
-const tokenConfigV1WithDefault = (
-  tokenConfig: TokenConfigInput,
-  fixedPriceMinter: Address,
-): TokenCreationConfigV1 => ({
-  ...pickTokenConfigV1(tokenConfig),
-  ...defaultTokenConfigV1MintArguments(),
-  fixedPriceMinter,
-});
-
-const tokenConfigV2WithDefault = (
-  tokenConfig: TokenConfigInput,
-  fixedPriceMinter: Address,
-): TokenCreationConfigV2 => ({
-  ...pickTokenConfigV2(tokenConfig),
-  ...defaultTokenConfigV2MintArguments(),
-  fixedPriceMinter,
-});
-
-export const defaultTokenConfigV2MintArguments = (): Omit<
-  TokenCreationConfigV2,
-  "fixedPriceMinter" | "tokenURI" | "payoutRecipient" | "createReferral"
-> => ({
-  maxSupply: OPEN_EDITION_MINT_SIZE,
-  maxTokensPerAddress: 0n,
-  pricePerToken: 0n,
-  mintDuration: 0n,
-  mintStart: 0n,
-  royaltyBPS: 1000, // 10%,
-});
-
-type TokenConfigInput = {
-  /** Metadata URI of the token to create. */
-  tokenURI: string;
-  /** Account to receive creator rewards if it's a free mint, and token price value if its a paid mint. Defaults to the premint signing account. */
-  payoutRecipient: Address;
-  /** Optional: account to receive the create referral award. */
-  createReferral?: Address;
-  /** Optional: max supply of tokens that can be minted.  Defaults to unlimited.  */
-  maxSupply?: bigint;
-  /** Optional: max tokens that can be minted for an address, 0 if unlimited. Defaults to unlimited. */
-  maxTokensPerAddress?: bigint;
-  /** Optional: price per token, if this is a paid mint. 0 if a free mint.  Defaults to 0, or a free mint. */
-  pricePerToken?: bigint;
-  /** Optional: duration of the mint, starting from the time the premint is brought onchain. 0 for infinite.  Defaults to infinite. */
-  mintDuration?: bigint;
-  /** Optional: earliest time the premint can be brought onchain and minted. 0 for immediately.  Defaults to immediately. */
-  mintStart?: bigint;
-  /** Optional: The royalty amount in basis points for secondary sales, in basis points.  Defaults to 1000. */
-  royaltyBPS?: number;
-};
-
-const makeTokenConfigWithDefaults = ({
-  chainId,
-  tokenCreationConfig,
-  supportedPremintVersions,
-}: {
-  chainId: number;
-  tokenCreationConfig: TokenConfigInput;
-  supportedPremintVersions: PremintConfigVersion[];
-}): TokenConfigWithVersion<
-  PremintConfigVersion.V1 | PremintConfigVersion.V2
-> => {
-  const fixedPriceMinter = getDefaultFixedPriceMinterAddress(chainId);
-
-  if (!supportedPremintVersions.includes(PremintConfigVersion.V2)) {
-    // we need to return a token config v1
-    if (tokenCreationConfig.createReferral) {
-      throw new Error("Contract does not support create referral");
-    }
-
-    return {
-      premintConfigVersion: PremintConfigVersion.V1,
-      tokenConfig: tokenConfigV1WithDefault(
-        tokenCreationConfig,
-        fixedPriceMinter,
-      ),
-    };
-  }
-
-  return {
-    premintConfigVersion: PremintConfigVersion.V2,
-    tokenConfig: tokenConfigV2WithDefault(
-      tokenCreationConfig,
-      fixedPriceMinter,
-    ),
-  };
-};
-
 /**
  * Gets the preminted log from receipt
  *
  * @param receipt Preminted log from receipt
  * @returns Premint event arguments
  */
-export function getPremintedLogFromReceipt(
+function getPremintedLogFromReceipt(
   receipt: TransactionReceipt,
 ): PremintedV2LogType | undefined {
   for (const data of receipt.logs) {
@@ -246,21 +109,6 @@ export class PremintClient {
     return getDataFromPremintReceipt(receipt, this.chainId, blockExplorerUrl);
   }
 
-  /**
-   * Prepares data for updating a premint
-   *
-   * @param parameters - Parameters for updating the premint {@link UpdatePremintParams}
-   * @returns A PremintReturn. {@link PremintReturn}
-   */
-  async updatePremint(args: UpdatePremintParams): Promise<PremintReturn<any>> {
-    return await updatePremint({
-      ...args,
-      apiClient: this.apiClient,
-      publicClient: this.publicClient,
-      chainId: this.chainId,
-    });
-  }
-
   /**
    * Prepares data for deleting a premint
    *
@@ -278,23 +126,6 @@ export class PremintClient {
     });
   }
 
-  /**
-   * Prepares data for creating a premint
-   *
-   * @param parameters - Parameters for creating the premint {@link CreatePremintParameters}
-   * @returns A PremintReturn. {@link PremintReturn}
-   */
-  async createPremint(
-    parameters: CreatePremintParameters,
-  ): Promise<PremintReturn<any>> {
-    return createPremint({
-      ...parameters,
-      publicClient: this.publicClient,
-      apiClient: this.apiClient,
-      chainId: this.chainId,
-    });
-  }
-
   /**
    * Fetches given premint data from the ZORA API.
    *
@@ -394,19 +225,19 @@ type PremintContext = {
 
 /** ======= ADMIN ======= */
 
-export type SignAndSubmitParams = {
+type SignAndSubmitParams = {
   /** The WalletClient used to sign the premint */
   walletClient: WalletClient;
 } & CheckSignatureParams;
 
-export type SignAndSubmitReturn = {
+type SignAndSubmitReturn = {
   /** The signature of the Premint  */
   signature: Hex;
   /** The account that signed the Premint */
   signerAccount: Account | Address;
 };
 
-export type CheckSignatureParams =
+type CheckSignatureParams =
   | {
       /** If the premint signature should be validated before submitting to the API */
       checkSignature: true;
@@ -419,7 +250,7 @@ export type CheckSignatureParams =
       account?: Account | Address;
     };
 
-export type SubmitParams = {
+type SubmitParams = {
   /** The signature of the Premint */
   signature: Hex;
 } & CheckSignatureParams;
@@ -551,153 +382,9 @@ async function signPremint({
   };
 }
 
-/** CREATE */
-
-type CreatePremintParameters = {
-  /** tokenCreationConfig Token creation settings, optional settings are overridden with sensible defaults */
-  token: TokenConfigInput;
-  /** uid the UID to use – optional and retrieved as a fresh UID from ZORA by default. */
-  uid?: number;
-} & ContractCreationConfigOrAddress;
-
-async function createPremint({
-  token: tokenCreationConfig,
-  uid,
-  publicClient,
-  apiClient,
-  chainId,
-  ...collectionOrAddress
-}: CreatePremintParameters & PremintContext) {
-  const {
-    premintConfig,
-    premintConfigVersion,
-    collectionAddress: collectionAddressToUse,
-  } = await prepareCreatePremintConfig({
-    ...collectionOrAddress,
-    tokenCreationConfig,
-    uid,
-    publicClient,
-    apiClient,
-    chainId,
-  });
-
-  return makePremintReturn({
-    premintConfig,
-    premintConfigVersion,
-    collectionAddress: collectionAddressToUse,
-    collection: collectionOrAddress.contract,
-    publicClient,
-    apiClient,
-    chainId,
-  });
-}
-
-type PreparePremintReturn = {
-  collectionAddress: Address;
-} & PremintConfigAndVersion;
-
-async function prepareCreatePremintConfig({
-  tokenCreationConfig,
-  uid,
-  publicClient,
-  apiClient,
-  chainId,
-  ...collectionOrAddress
-}: {
-  tokenCreationConfig: TokenConfigInput;
-  uid?: number;
-} & PremintContext &
-  ContractCreationConfigOrAddress): Promise<PreparePremintReturn> {
-  const newContractAddress = await getPremintCollectionAddress({
-    publicClient,
-    ...collectionOrAddress,
-  });
-
-  let uidToUse = uid;
-
-  if (typeof uidToUse !== "number") {
-    uidToUse = await apiClient.getNextUID(newContractAddress);
-  }
-
-  const supportedVersions = await supportedPremintVersions({
-    tokenContract: newContractAddress,
-    publicClient,
-  });
-
-  const tokenConfigAndVersion = makeTokenConfigWithDefaults({
-    tokenCreationConfig,
-    chainId,
-    supportedPremintVersions: supportedVersions,
-  });
-
-  const premintConfig = makeNewPremint({
-    ...tokenConfigAndVersion,
-    uid: uidToUse,
-  });
-
-  const premintConfigAndVersion = {
-    premintConfig,
-    premintConfigVersion: tokenConfigAndVersion.premintConfigVersion,
-  } as PremintConfigAndVersion;
-
-  return {
-    ...premintConfigAndVersion,
-    collectionAddress: newContractAddress,
-  };
-}
-
-/** UPDATE */
-
-export type UpdatePremintParams = {
-  /** uid of the Premint to update */
-  uid: number;
-  /** address of the Premint to update */
-  collection: Address;
-  /** update to apply to the Premint */
-  tokenConfigUpdates: Partial<TokenCreationConfig>;
-};
-
-async function updatePremint({
-  uid,
-  collection,
-  tokenConfigUpdates,
-  apiClient,
-  publicClient,
-  chainId,
-}: UpdatePremintParams & {
-  apiClient: IPremintAPI;
-  publicClient: PublicClient;
-  chainId: number;
-}) {
-  const {
-    premint: { premintConfig, premintConfigVersion },
-    collection: collectionCreationConfig,
-  } = await apiClient.get({
-    collectionAddress: collection,
-    uid: uid,
-  });
-
-  const updatedPremint = applyUpdateToPremint({
-    uid: premintConfig.uid,
-    version: premintConfig.version,
-    tokenConfig: premintConfig.tokenConfig,
-    tokenConfigUpdates: tokenConfigUpdates,
-  });
-
-  return makePremintReturn({
-    premintConfig: updatedPremint,
-    premintConfigVersion,
-    collectionAddress: collection,
-    collection: collectionCreationConfig,
-    publicClient,
-    apiClient,
-    chainId,
-  });
-}
-
 /** DELETE */
 
-export type DeletePremintParams = {
+type DeletePremintParams = {
   /** id of the premint to delete */
   uid: number;
   /** collection address of the Premint to delete */
@@ -741,7 +428,7 @@ async function deletePremint({
   });
 }
 
-export type MakeMintParametersArguments = {
+type MakeMintParametersArguments = {
   /** uid of the Premint to mint */
   uid: number;
   /** Premint contract address */
@@ -765,7 +452,7 @@ export type MakeMintParametersArguments = {
 
 /** ======== MINTING ======== */
 
-export async function collectPremint({
+async function collectPremint({
   uid,
   tokenContract,
   minterAccount,
@@ -887,7 +574,7 @@ export const buildPremintMintCall = ({
   });
 };
 
-export function makeUrls({
+function makeUrls({
   uid,
   address,
   tokenId,