@zoralabs/protocol-sdk 0.5.17 → 0.6.0

package/src/mint/types.ts

@@ -0,0 +1,122 @@
+import { Account, Address } from "viem";
+import { GenericTokenIdTypes } from "src/types";
+
+export type MintParameters<MintType> = {
+  /** Type of the collection to be minted. */
+  mintType: MintType;
+};
+
+export type Erc1155MintParameters = MintParameters<"1155"> & {
+  /** Token id to mint */
+  tokenId: GenericTokenIdTypes;
+};
+
+export type Erc721MintParameters = MintParameters<"721">;
+
+export type OnChainMintParameters =
+  | Erc1155MintParameters
+  | Erc721MintParameters;
+
+export type PremintMintParameters = MintParameters<"premint"> & {
+  /** uid of the Premint to mint */
+  uid: number;
+};
+
+export type MintType = "1155" | "721" | "premint";
+
+export type MintTypes =
+  | Erc1155MintParameters
+  | Erc721MintParameters
+  | PremintMintParameters;
+
+export const isOnChainMint = (mint: MintTypes): mint is OnChainMintParameters =>
+  mint.mintType !== "premint";
+
+export const is1155Mint = (mint: MintTypes): mint is Erc1155MintParameters =>
+  mint.mintType === "1155";
+
+export type MakeMintParametersArgumentsBase = {
+  /** Premint contract address */
+  tokenContract: Address;
+  /** Account to execute the mint */
+  minterAccount: Account | Address;
+  /** Quantity of tokens to mint. Defaults to 1 */
+  quantityToMint: number | bigint;
+  /** Comment to add to the mint */
+  mintComment?: string;
+  /** Address to receive the mint referral reward */
+  mintReferral?: Address;
+  /** Address to receive the minted tokens. Defaults to the minting account */
+  mintRecipient?: Address;
+};
+
+export type Make1155MintArguments = MakeMintParametersArgumentsBase &
+  Erc1155MintParameters & {
+    saleType?: SaleType;
+  };
+
+export type Make721MintArguments = MakeMintParametersArgumentsBase &
+  Erc721MintParameters & {
+    saleType?: SaleType;
+  };
+
+export type MakePremintMintParametersArguments =
+  MakeMintParametersArgumentsBase &
+    PremintMintParameters & {
+      /** Account to receive first minter reward, if this mint brings the premint onchain */
+      firstMinter?: Address;
+    };
+
+export type MakeMintParametersArguments =
+  | Make1155MintArguments
+  | Make721MintArguments
+  | MakePremintMintParametersArguments;
+
+export type GetMintCostsParameters = {
+  /** Address of token contract/collection to get the mint costs for */
+  collection: Address;
+  /** Quantity of tokens that will be minted */
+  quantityMinted: number | bigint;
+} & MintTypes;
+
+export type SaleType = "fixedPrice" | "erc20";
+
+type SaleStrategy<T extends SaleType> = {
+  saleType: T;
+  address: Address;
+  pricePerToken: bigint;
+  saleEnd: string;
+  saleStart: string;
+  maxTokensPerAddress: bigint;
+};
+
+type FixedPriceSaleStrategy = SaleStrategy<"fixedPrice">;
+
+type ERC20SaleStrategy = SaleStrategy<"erc20"> & {
+  currency: Address;
+};
+
+type SaleStrategies = FixedPriceSaleStrategy | ERC20SaleStrategy;
+
+export function isErc20SaleStrategy(
+  salesConfig: SaleStrategies,
+): salesConfig is ERC20SaleStrategy {
+  return salesConfig.saleType === "erc20";
+}
+
+export type SalesConfigAndTokenInfo = {
+  salesConfig: SaleStrategies;
+  mintFeePerQuantity: bigint;
+};
+
+export interface IMintGetter {
+  getSalesConfigAndTokenInfo({
+    tokenAddress,
+    tokenId,
+    saleType,
+  }: {
+    tokenAddress: Address;
+    tokenId?: GenericTokenIdTypes;
+    saleType?: SaleType;
+  }): Promise<SalesConfigAndTokenInfo>;
+}

package/src/mints/mints-contracts.test.ts

@@ -77,7 +77,7 @@ const setupContractUsingPremint = async ({
   contractConfig.contractName = "Testing contract for MINTS";
 
   const contractAddress = await getPremintCollectionAddress({
-    collection: contractConfig,
+    contract: contractConfig,
     publicClient,
   });
 

package/src/mints/mints-contracts.ts

@@ -12,7 +12,7 @@ import {
   PremintConfigV2,
 } from "@zoralabs/protocol-deployments";
 import { ContractCreationConfig } from "src/preminter";
-import { makeSimulateContractParamaters } from "src/utils";
+import { makeContractParameters } from "src/utils";
 import {
   Account,
   Address,
@@ -53,7 +53,7 @@ export const mintWithEthParams = ({
   pricePerMint: bigint;
   account: Address | Account;
 }) =>
-  makeSimulateContractParamaters({
+  makeContractParameters({
     abi: zoraMintsManagerImplConfig.abi,
     address: zoraMintsManagerImplConfig.address[chainId],
     functionName: "mintWithEth",
@@ -152,7 +152,7 @@ export function collectWithMintsParams({
     mintArguments,
   });
 
-  return makeSimulateContractParamaters({
+  return makeContractParameters({
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",
@@ -416,7 +416,7 @@ export function collectPremintV2WithMintsParams({
     ...rest,
   });
 
-  return makeSimulateContractParamaters({
+  return makeContractParameters({
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",

package/src/premint/contract-types.ts

@@ -28,11 +28,11 @@ export type ContractCreationConfigAndAddress = {
 export type ContractCreationConfigOrAddress =
   | {
       /** Parameters for creating the contract for new premints. */
-      collection: ContractCreationConfigWithOptionalAdditionalAdmins;
-      collectionAddress?: undefined;
+      contract: ContractCreationConfigWithOptionalAdditionalAdmins;
+      contractAddress?: undefined;
     }
   | {
-      collection?: undefined;
+      contract?: undefined;
       /** Premint collection address */
-      collectionAddress: Address;
+      contractAddress: Address;
     };

package/src/premint/conversions.ts

@@ -150,8 +150,8 @@ export type PremintSignatureResponse =
  * @returns
  */
 export const encodePostSignatureInput = <T extends PremintConfigVersion>({
-  collection,
-  collectionAddress,
+  contract: collection,
+  contractAddress: collectionAddress,
   premintConfigVersion,
   premintConfig,
   signature,
@@ -172,3 +172,13 @@ export const encodePostSignatureInput = <T extends PremintConfigVersion>({
   collection_address: collectionAddress,
   chain_name: networkConfigByChain[chainId]!.zoraBackendChainName,
 });
+
+export const isPremintConfigV1 = (
+  premintConfigAndVersion: PremintConfigAndVersion,
+): premintConfigAndVersion is PremintConfigWithVersion<PremintConfigVersion.V1> =>
+  premintConfigAndVersion.premintConfigVersion === PremintConfigVersion.V1;
+
+export const isPremintConfigV2 = (
+  premintConfigAndVersion: PremintConfigAndVersion,
+): premintConfigAndVersion is PremintConfigWithVersion<PremintConfigVersion.V2> =>
+  premintConfigAndVersion.premintConfigVersion === PremintConfigVersion.V2;

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

@@ -4,8 +4,7 @@ import {
 } from "../apis/http-api-base";
 import { components, paths } from "../apis/generated/premint-api-types";
 import { ZORA_API_BASE } from "../constants";
-import { NetworkConfig } from "src/apis/chain-constants";
-import { getApiNetworkConfigForChain } from "src/mint/mint-api-client";
+import { getApiNetworkConfigForChain } from "src/mint/subgraph-mint-getter";
 import {
   ContractCreationConfig,
   PremintConfigAndVersion,
@@ -30,8 +29,6 @@ export type PremintNextUIDGetResponse =
 
 type SignaturePremintGetType =
   paths["/signature/{chain_name}/{collection_address}/{uid}"]["get"];
-type PremintSignatureGetPathParameters =
-  SignaturePremintGetType["parameters"]["path"];
 export type PremintSignatureGetResponse =
   SignaturePremintGetType["responses"][200]["content"]["application/json"];
 
@@ -50,57 +47,83 @@ const postSignature = async ({
   );
 
 const getNextUID = async ({
-  chain_name,
+  chainId,
   collection_address,
   httpClient: { retries, get } = defaultHttpClient,
-}: PremintNextUIDGetPathParameters & {
+}: Omit<PremintNextUIDGetPathParameters, "chain_name"> & {
+  chainId: number;
   httpClient?: Pick<IHttpClient, "retries" | "get">;
 }): Promise<PremintNextUIDGetResponse> =>
   retries(() =>
     get<PremintNextUIDGetResponse>(
-      `${ZORA_API_BASE}premint/signature/${chain_name}/${collection_address}/next_uid`,
+      `${ZORA_API_BASE}premint/signature/${
+        getApiNetworkConfigForChain(chainId).zoraBackendChainName
+      }/${collection_address}/next_uid`,
     ),
   );
 
-const getSignature = async ({
-  collection_address,
+export const getSignature = async ({
+  collectionAddress,
   uid,
-  chain_name,
+  chainId,
   httpClient: { retries, get } = defaultHttpClient,
-}: PremintSignatureGetPathParameters & {
+}: {
+  collectionAddress: Address;
+  uid: number;
+  chainId: number;
   httpClient?: Pick<IHttpClient, "retries" | "get">;
 }): Promise<
-  PremintSignatureGetResponse & {
-    premint_config_version?: PremintConfigVersion;
-  }
+  {
+    signature: Hex;
+    collection: ContractCreationConfig | undefined;
+    collectionAddress: Address;
+  } & PremintConfigAndVersion
 > => {
+  const chainName = getApiNetworkConfigForChain(chainId).zoraBackendChainName;
   const result = await retries(() =>
     get<PremintSignatureGetResponse>(
-      `${ZORA_API_BASE}premint/signature/${chain_name}/${collection_address}/${uid}`,
+      `${ZORA_API_BASE}premint/signature/${chainName}/${collectionAddress.toLowerCase()}/${uid}`,
     ),
   );
 
-  return result;
+  return convertGetPremintApiResponse(result);
 };
 
-class PremintAPIClient {
+export interface IPremintGetter {
+  getSignature(params: {
+    collectionAddress: Address;
+    uid: number;
+  }): ReturnType<typeof getSignature>;
+}
+
+export interface IPremintAPI {
+  getSignature: IPremintGetter["getSignature"];
+
+  getNextUID(collectionAddress: Address): Promise<number>;
+
+  postSignature<T extends PremintConfigVersion>(
+    params: {
+      signature: Hex;
+    } & PremintConfigWithVersion<T> &
+      ContractCreationConfigOrAddress,
+  ): Promise<PremintSignatureResponse>;
+}
+
+class PremintAPIClient implements IPremintAPI {
+  chainId: number;
   httpClient: IHttpClient;
-  networkConfig: NetworkConfig;
 
   constructor(chainId: number, httpClient?: IHttpClient) {
+    this.chainId = chainId;
     this.httpClient = httpClient || defaultHttpClient;
-    this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
-  postSignature = async <T extends PremintConfigVersion>({
+  postSignature: IPremintAPI["postSignature"] = ({
     signature,
     ...rest
-  }: {
-    signature: Hex;
-  } & PremintConfigWithVersion<T> &
-    ContractCreationConfigOrAddress): Promise<PremintSignatureResponse> => {
+  }): Promise<PremintSignatureResponse> => {
     const data = encodePostSignatureInput({
       ...rest,
-      chainId: this.networkConfig.chainId,
+      chainId: this.chainId,
       signature,
     });
     return postSignature({
@@ -109,36 +132,25 @@ class PremintAPIClient {
     });
   };
 
-  getNextUID = async (collectionAddress: Address): Promise<number> =>
+  getNextUID: IPremintAPI["getNextUID"] = async (collectionAddress) =>
     (
       await getNextUID({
         collection_address: collectionAddress.toLowerCase(),
-        chain_name: this.networkConfig.zoraBackendChainName,
+        chainId: this.chainId,
         httpClient: this.httpClient,
       })
     ).next_uid;
 
-  getSignature = async ({
+  getSignature: IPremintAPI["getSignature"] = async ({
     collectionAddress,
     uid,
-  }: {
-    collectionAddress: Address;
-    uid: number;
-  }): Promise<
-    {
-      signature: Hex;
-      collection: ContractCreationConfig | undefined;
-      collectionAddress: Address;
-    } & PremintConfigAndVersion
-  > => {
-    const response = await getSignature({
-      collection_address: collectionAddress.toLowerCase(),
+  }) => {
+    return getSignature({
+      collectionAddress,
       uid,
-      chain_name: this.networkConfig.zoraBackendChainName,
+      chainId: this.chainId,
       httpClient: this.httpClient,
     });
-
-    return convertGetPremintApiResponse(response);
   };
 }
 

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

@@ -1,7 +1,6 @@
 import { zoraSepolia } from "viem/chains";
 import { describe, expect, vi } from "vitest";
 
-import { createPremintClient } from "./premint-client";
 import { PremintConfigVersion } from "./contract-types";
 import {
   getDefaultFixedPriceMinterAddress,
@@ -12,6 +11,8 @@ import {
   ContractCreationConfig,
   PremintConfigV2,
 } from "@zoralabs/protocol-deployments";
+import { PremintAPIClient } from "./premint-api-client";
+import { createCollectorClient, createCreatorClient } from "src/sdk";
 
 const anvilTest = makeAnvilTest({
   forkUrl: forkUrls.zoraSepolia,
@@ -24,13 +25,11 @@ describe("ZoraCreator1155Premint", () => {
     "can mint premints",
     async ({ viemClients: { walletClient, publicClient, chain } }) => {
       const [deployerAccount] = await walletClient.getAddresses();
-      const premintClient = createPremintClient({
-        chain,
-        publicClient,
-      });
 
-      premintClient.apiClient.getSignature = vi
-        .fn<any, ReturnType<typeof premintClient.apiClient.getSignature>>()
+      const premintApiClient = new PremintAPIClient(chain.id);
+
+      premintApiClient.getSignature = vi
+        .fn<any, ReturnType<typeof premintApiClient.getSignature>>()
         .mockResolvedValue({
           collection: {
             contractAdmin: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
@@ -63,26 +62,29 @@ describe("ZoraCreator1155Premint", () => {
             "0x4d191dd60d428adfe507932a1758bee8ac5bbb77dcd3c05840c237416a3a25035bb8cc7c62177a4e9acb5f40c4032cdb3dbfefdd1575f2c3b4c57945b2076e2e1c",
         });
 
-      premintClient.apiClient.postSignature = vi.fn();
+      premintApiClient.postSignature = vi.fn();
 
-      const simulateContractParameters = await premintClient.makeMintParameters(
-        {
-          minterAccount: deployerAccount!,
-          tokenContract: "0xf8dA7f53c283d898818af7FB9d98103F559bDac2",
-          uid: 3,
-          mintArguments: {
-            quantityToMint: 1,
-            mintComment: "",
-          },
-        },
-      );
-      const { request: simulateRequest } = await publicClient.simulateContract(
-        simulateContractParameters,
-      );
+      const collectorClient = createCollectorClient({
+        chainId: chain.id,
+        publicClient,
+        premintGetter: premintApiClient,
+      });
+
+      const { parameters } = await collectorClient.mint({
+        mintType: "premint",
+        minterAccount: deployerAccount!,
+        tokenContract: "0xf8dA7f53c283d898818af7FB9d98103F559bDac2",
+        uid: 3,
+        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 } =
-        premintClient.getDataFromPremintReceipt(receipt);
+        collectorClient.getCollectDataFromPremintReceipt(receipt);
 
       expect(urls).toEqual({
         explorer:
@@ -112,26 +114,29 @@ describe("ZoraCreator1155Premint - v2 signatures", () => {
     async ({ viemClients: { walletClient, publicClient, chain } }) => {
       const [creatorAccount, createReferralAccount] =
         await walletClient.getAddresses();
-      const premintClient = createPremintClient({
-        chain,
-        publicClient,
-      });
+      const premintApiClient = new PremintAPIClient(chain.id);
 
-      premintClient.apiClient.getNextUID = vi
-        .fn<any, ReturnType<typeof premintClient.apiClient.getNextUID>>()
+      premintApiClient.getNextUID = vi
+        .fn<any, ReturnType<typeof premintApiClient.getNextUID>>()
         .mockResolvedValue(3);
-      premintClient.apiClient.postSignature = vi
-        .fn<Parameters<typeof premintClient.apiClient.postSignature>>()
+      premintApiClient.postSignature = vi
+        .fn<Parameters<typeof premintApiClient.postSignature>>()
         .mockResolvedValue({ ok: true });
 
-      const { signAndSubmit } = await premintClient.createPremint({
-        collection: {
+      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",
         },
-        tokenCreationConfig: {
+        token: {
           tokenURI:
             "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
           payoutRecipient: creatorAccount!,
@@ -146,22 +151,22 @@ describe("ZoraCreator1155Premint - v2 signatures", () => {
       });
 
       const expectedPostSignatureArgs: Parameters<
-        typeof premintClient.apiClient.postSignature
+        typeof premintApiClient.postSignature
       >[0] = {
-        collection: {
+        contract: {
           contractAdmin: creatorAccount!,
           contractName: "Testing Contract Premint V2",
           contractURI:
             "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
         },
-        collectionAddress: undefined,
+        contractAddress: undefined,
         premintConfig: {
           deleted: false,
           tokenConfig: {
             fixedPriceMinter: "0x6d28164C3CE04A190D5F9f0f8881fc807EAD975A",
             maxSupply: 18446744073709551615n,
             maxTokensPerAddress: 0n,
-            mintDuration: 604800n,
+            mintDuration: 0n,
             mintStart: 0n,
             pricePerToken: 0n,
             royaltyBPS: 1000,
@@ -175,10 +180,10 @@ describe("ZoraCreator1155Premint - v2 signatures", () => {
         },
         premintConfigVersion: PremintConfigVersion.V2,
         signature:
-          "0x5cc8c0ab240920282cf936d8b5eb1dd151a91ad78cc4e89f8ddeae6ea432ce7904a38e145b734bdd438f18d457451cb1ae28beb2c44bda71d58638dfcc071e1b1c",
+          "0xfe5725c05754ad17a73cc9706bf940e30bd7b4a674bb1b283a66a1cc87022c8c13fcf8989f9feb675f8932a6a8ddb8d16af2abef28fa2fff3282487ef5385b3d1b",
       };
 
-      expect(premintClient.apiClient.postSignature).toHaveBeenCalledWith(
+      expect(premintApiClient.postSignature).toHaveBeenCalledWith(
         expectedPostSignatureArgs,
       );
     },
@@ -190,9 +195,19 @@ describe("ZoraCreator1155Premint - v2 signatures", () => {
     async ({ viemClients: { walletClient, publicClient, chain } }) => {
       const [deployerAccount, creatorAccount, additionalAdmin] =
         await walletClient.getAddresses();
-      const premintClient = createPremintClient({
-        chain,
+
+      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 = {
@@ -204,14 +219,14 @@ describe("ZoraCreator1155Premint - v2 signatures", () => {
       };
 
       const collectionAddress = await getPremintCollectionAddress({
-        collection,
+        contract: collection,
         publicClient,
       });
 
       const { premintConfig, typedDataDefinition } =
-        await premintClient.createPremint({
-          collection,
-          tokenCreationConfig: {
+        await creatorClient.createPremint({
+          contract: collection,
+          token: {
             tokenURI:
               "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
             payoutRecipient: creatorAccount!,
@@ -223,8 +238,8 @@ describe("ZoraCreator1155Premint - v2 signatures", () => {
         account: additionalAdmin!,
       });
 
-      premintClient.apiClient.getSignature = vi
-        .fn<any, ReturnType<typeof premintClient.apiClient.getSignature>>()
+      premintApiClient.getSignature = vi
+        .fn<any, ReturnType<typeof premintApiClient.getSignature>>()
         .mockResolvedValue({
           collection,
           collectionAddress,
@@ -233,26 +248,21 @@ describe("ZoraCreator1155Premint - v2 signatures", () => {
           signature,
         });
 
-      premintClient.apiClient.postSignature = vi.fn();
-
-      const simulateContractParameters = await premintClient.makeMintParameters(
-        {
-          minterAccount: deployerAccount!,
-          tokenContract: collectionAddress,
-          uid: premintConfig.uid,
-          mintArguments: {
-            quantityToMint: 1,
-            mintComment: "",
-          },
-        },
-      );
-      const { request: simulateRequest } = await publicClient.simulateContract(
-        simulateContractParameters,
-      );
+      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 } =
-        premintClient.getDataFromPremintReceipt(receipt);
+        collectorClient.getCollectDataFromPremintReceipt(receipt);
 
       expect(urls).toEqual({
         explorer: `https://undefined/token/${collectionAddress}/instance/1`,