@zoralabs/protocol-sdk 0.6.0 → 0.7.1

package/src/mint/types.ts

@@ -1,5 +1,8 @@
 import { Account, Address } from "viem";
-import { GenericTokenIdTypes } from "src/types";
+import {
+  GenericTokenIdTypes,
+  SimulateContractParametersWithAccount,
+} from "src/types";
 
 export type MintParameters<MintType> = {
   /** Type of the collection to be minted. */
@@ -29,15 +32,25 @@ export type MintTypes =
   | Erc721MintParameters
   | PremintMintParameters;
 
+export type GetMintParameters = MintTypes & {
+  /** Address of the contract that the item belongs to */
+  tokenContract: Address;
+  preferredSaleType?: SaleType;
+};
+
+export type GetMintsOfContractParameters = {
+  /** Address of the contract to get the tokens of */
+  tokenContract: Address;
+  preferredSaleType?: SaleType;
+};
+
 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;
+export type MintParametersBase = {
   /** Account to execute the mint */
   minterAccount: Account | Address;
   /** Quantity of tokens to mint. Defaults to 1 */
@@ -48,16 +61,23 @@ export type MakeMintParametersArgumentsBase = {
   mintReferral?: Address;
   /** Address to receive the minted tokens. Defaults to the minting account */
   mintRecipient?: Address;
+  /** If this is a premint, the address to get the first minter reward */
+  firstMinter?: Address;
+};
+
+export type MakeMintParametersArgumentsBase = MintParametersBase & {
+  /** Premint contract address */
+  tokenContract: Address;
 };
 
 export type Make1155MintArguments = MakeMintParametersArgumentsBase &
   Erc1155MintParameters & {
-    saleType?: SaleType;
+    preferredSaleType?: SaleType;
   };
 
 export type Make721MintArguments = MakeMintParametersArgumentsBase &
   Erc721MintParameters & {
-    saleType?: SaleType;
+    preferredSaleType?: SaleType;
   };
 
 export type MakePremintMintParametersArguments =
@@ -79,44 +99,141 @@ export type GetMintCostsParameters = {
   quantityMinted: number | bigint;
 } & MintTypes;
 
-export type SaleType = "fixedPrice" | "erc20";
+export type SaleType = "fixedPrice" | "erc20" | "premint";
 
 type SaleStrategy<T extends SaleType> = {
   saleType: T;
-  address: Address;
   pricePerToken: bigint;
-  saleEnd: string;
-  saleStart: string;
   maxTokensPerAddress: bigint;
 };
 
-type FixedPriceSaleStrategy = SaleStrategy<"fixedPrice">;
+type FixedPriceSaleStrategy = SaleStrategy<"fixedPrice"> & {
+  address: Address;
+  saleStart: string;
+  saleEnd: string;
+};
 
 type ERC20SaleStrategy = SaleStrategy<"erc20"> & {
+  address: Address;
+  saleStart: string;
+  saleEnd: string;
   currency: Address;
 };
 
-type SaleStrategies = FixedPriceSaleStrategy | ERC20SaleStrategy;
+type PremintSaleStrategy = SaleStrategy<"premint"> & {
+  duration: bigint;
+};
+
+export type SaleStrategies =
+  | FixedPriceSaleStrategy
+  | ERC20SaleStrategy
+  | PremintSaleStrategy;
+
+export type OnchainSalesStrategies = FixedPriceSaleStrategy | ERC20SaleStrategy;
 
 export function isErc20SaleStrategy(
-  salesConfig: SaleStrategies,
+  salesConfig: FixedPriceSaleStrategy | ERC20SaleStrategy | PremintSaleStrategy,
 ): salesConfig is ERC20SaleStrategy {
   return salesConfig.saleType === "erc20";
 }
 
-export type SalesConfigAndTokenInfo = {
-  salesConfig: SaleStrategies;
+export type ContractInfo = {
+  /** Address of the contract */
+  address: Address;
+  /** Contract metadata uri */
+  URI: string;
+  /** Contract name */
+  name: string;
+};
+
+export type MintableBase = {
+  /** The contract the mintable belongs to */
+  contract: ContractInfo;
+  /** Token metadata URI */
+  tokenURI: string;
+  /** Price in eth to mint 1 item */
   mintFeePerQuantity: bigint;
+  /** Creator of the mintable item */
+  creator: Address;
+  /** Maximum total number of items that can be minted */
+  maxSupply: bigint;
+  /** Total number of items minted so far */
+  totalMinted: bigint;
+};
+
+export type OnchainMintable = MintableBase & {
+  mintType: "721" | "1155";
+  tokenId?: bigint;
+  contractVersion: string;
+};
+
+export type PremintMintable = MintableBase & {
+  mintType: "premint";
+  uid: number;
 };
 
-export interface IMintGetter {
-  getSalesConfigAndTokenInfo({
-    tokenAddress,
-    tokenId,
-    saleType,
-  }: {
+export type OnchainSalesConfigAndTokenInfo = {
+  salesConfig: FixedPriceSaleStrategy | ERC20SaleStrategy;
+} & OnchainMintable;
+
+export type PremintSalesConfigAndTokenInfo = {
+  salesConfig: PremintSaleStrategy;
+} & PremintMintable;
+
+export type SalesConfigAndTokenInfo =
+  | OnchainSalesConfigAndTokenInfo
+  | PremintMintable;
+
+export interface IOnchainMintGetter {
+  getMintable(params: {
     tokenAddress: Address;
     tokenId?: GenericTokenIdTypes;
-    saleType?: SaleType;
-  }): Promise<SalesConfigAndTokenInfo>;
+    preferredSaleType?: SaleType;
+  }): Promise<OnchainSalesConfigAndTokenInfo>;
+
+  getContractMintable(params: {
+    tokenAddress: Address;
+  }): Promise<OnchainSalesConfigAndTokenInfo[]>;
+
+  getContractPremintTokenIds(params: {
+    tokenAddress: Address;
+  }): Promise<{ tokenId: BigInt; uid: number }[]>;
 }
+
+export type MintCosts = {
+  /** The total of the mint fee, in eth */
+  mintFee: bigint;
+  /** If it is a paid or erc20 mint, the total price of the paid or erc20 mint in eth or erc20 value correspondingly. */
+  totalPurchaseCost: bigint;
+  /** If it is an erc20 mint, the erc20 address */
+  totalPurchaseCostCurrency?: Address;
+  /** The total cost in eth (mint fee + purchase cost) to mint */
+  totalCostEth: bigint;
+};
+
+export type Erc20Approval = {
+  /** ERC20 token address that must be approved */
+  erc20: Address;
+  /** Quantity of ERC20 that must be approved */
+  quantity: bigint;
+  /** Address that must be approved to transfer to */
+  approveTo: Address;
+};
+
+export type PrepareMintReturn = {
+  /** Prepared parameters to execute the mint transaction */
+  parameters: SimulateContractParametersWithAccount;
+  /** If an erc20 approval is necessary, information for the erc20 approval */
+  erc20Approval?: Erc20Approval;
+  /** Cost breakdown to mint the quantity of tokens */
+  costs: MintCosts;
+};
+
+export type PrepareMint = (params: MintParametersBase) => PrepareMintReturn;
+
+export type MintableReturn = {
+  /** Token information */
+  token: SalesConfigAndTokenInfo;
+  /** Function that takes a quantity of items to mint and returns a prepared transaction and the costs to mint that quantity */
+  prepareMint: PrepareMint;
+};

package/src/mint/utils.ts

@@ -0,0 +1,14 @@
+import * as semver from "semver";
+export const contractSupportsNewMintFunction = (
+  contractVersion?: string | null,
+) => {
+  if (!contractVersion) {
+    return false;
+  }
+
+  // Try force-convert version format to semver format
+  const semVerContractVersion = semver.coerce(contractVersion)?.raw;
+  if (!semVerContractVersion) return false;
+
+  return semver.gte(semVerContractVersion, "2.9.0");
+};

package/src/premint/conversions.ts

@@ -9,7 +9,10 @@ import {
   PremintConfigVersion,
   PremintConfigWithVersion,
 } from "@zoralabs/protocol-deployments";
-import { PremintSignatureGetResponse } from "./premint-api-client";
+import {
+  PremintSignatureGetOfCollectionResponse,
+  PremintSignatureGetResponse,
+} from "./premint-api-client";
 import { ContractCreationConfigOrAddress } from "./contract-types";
 
 export const convertCollectionFromApi = (
@@ -84,13 +87,34 @@ export const convertPremintFromApi = (
   }
 };
 
+export type PremintFromApi = ReturnType<typeof convertGetPremintApiResponse>;
+
 export const convertGetPremintApiResponse = (
   response: PremintSignatureGetResponse,
 ) => ({
-  ...convertPremintFromApi(response.premint),
   collection: convertCollectionFromApi(response.collection),
   collectionAddress: response.collection_address as Address,
   signature: response.signature as Hex,
+  signer: response.signer as Address,
+  premint: convertPremintFromApi(response.premint),
+});
+
+export type PremintCollectionFromApi = ReturnType<
+  typeof convertGetPremintOfCollectionApiResponse
+>;
+
+export const convertGetPremintOfCollectionApiResponse = (
+  response: PremintSignatureGetOfCollectionResponse,
+) => ({
+  collection: convertCollectionFromApi({
+    contractAdmin: response.contract_admin,
+    contractName: response.contract_name,
+    contractURI: response.contract_uri,
+  }),
+  premints: response.premints.map((premint) => ({
+    premint: convertPremintFromApi(premint),
+    signature: premint.signature as Hex,
+  })),
 });
 
 const encodePremintV1ForAPI = ({

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

@@ -6,16 +6,17 @@ import { components, paths } from "../apis/generated/premint-api-types";
 import { ZORA_API_BASE } from "../constants";
 import { getApiNetworkConfigForChain } from "src/mint/subgraph-mint-getter";
 import {
-  ContractCreationConfig,
-  PremintConfigAndVersion,
   PremintConfigVersion,
   PremintConfigWithVersion,
 } from "@zoralabs/protocol-deployments";
 import { Address, Hex } from "viem";
 import {
+  PremintCollectionFromApi,
+  PremintFromApi,
   PremintSignatureRequestBody,
   PremintSignatureResponse,
   convertGetPremintApiResponse,
+  convertGetPremintOfCollectionApiResponse,
   encodePostSignatureInput,
 } from "./conversions";
 import { ContractCreationConfigOrAddress } from "./contract-types";
@@ -32,6 +33,11 @@ type SignaturePremintGetType =
 export type PremintSignatureGetResponse =
   SignaturePremintGetType["responses"][200]["content"]["application/json"];
 
+type SignaturePremintGetOfCollectionType =
+  paths["/signature/{chain_name}/{collection_address}"]["get"];
+export type PremintSignatureGetOfCollectionResponse =
+  SignaturePremintGetOfCollectionType["responses"][200]["content"]["application/json"];
+
 export type PremintCollection = PremintSignatureGetResponse["collection"];
 
 export type BackendChainNames = components["schemas"]["ChainName"];
@@ -72,13 +78,7 @@ export const getSignature = async ({
   uid: number;
   chainId: number;
   httpClient?: Pick<IHttpClient, "retries" | "get">;
-}): Promise<
-  {
-    signature: Hex;
-    collection: ContractCreationConfig | undefined;
-    collectionAddress: Address;
-  } & PremintConfigAndVersion
-> => {
+}): Promise<PremintFromApi> => {
   const chainName = getApiNetworkConfigForChain(chainId).zoraBackendChainName;
   const result = await retries(() =>
     get<PremintSignatureGetResponse>(
@@ -89,15 +89,40 @@ export const getSignature = async ({
   return convertGetPremintApiResponse(result);
 };
 
+const getOfCollection = async ({
+  collectionAddress,
+  chainId,
+  httpClient: { retries, get } = defaultHttpClient,
+}: {
+  collectionAddress: Address;
+  chainId: number;
+  httpClient?: Pick<IHttpClient, "retries" | "get">;
+}) => {
+  const chainName = getApiNetworkConfigForChain(chainId).zoraBackendChainName;
+  const result = await retries(() =>
+    get<PremintSignatureGetOfCollectionResponse>(
+      `${ZORA_API_BASE}premint/signature/${chainName}/${collectionAddress.toLowerCase()}`,
+    ),
+  );
+
+  return convertGetPremintOfCollectionApiResponse(result);
+};
+
 export interface IPremintGetter {
-  getSignature(params: {
+  get(params: {
     collectionAddress: Address;
     uid: number;
-  }): ReturnType<typeof getSignature>;
+  }): Promise<PremintFromApi>;
+
+  getOfCollection(params: {
+    collectionAddress: Address;
+  }): Promise<PremintCollectionFromApi>;
 }
 
 export interface IPremintAPI {
-  getSignature: IPremintGetter["getSignature"];
+  get: IPremintGetter["get"];
+
+  getOfCollection: IPremintGetter["getOfCollection"];
 
   getNextUID(collectionAddress: Address): Promise<number>;
 
@@ -141,10 +166,7 @@ class PremintAPIClient implements IPremintAPI {
       })
     ).next_uid;
 
-  getSignature: IPremintAPI["getSignature"] = async ({
-    collectionAddress,
-    uid,
-  }) => {
+  get: IPremintAPI["get"] = async ({ collectionAddress, uid }) => {
     return getSignature({
       collectionAddress,
       uid,
@@ -152,6 +174,16 @@ class PremintAPIClient implements IPremintAPI {
       httpClient: this.httpClient,
     });
   };
+
+  getOfCollection: IPremintAPI["getOfCollection"] = async ({
+    collectionAddress,
+  }) => {
+    return getOfCollection({
+      collectionAddress,
+      chainId: this.chainId,
+      httpClient: this.httpClient,
+    });
+  };
 }
 
 export { ZORA_API_BASE, PremintAPIClient };

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

@@ -28,8 +28,8 @@ describe("ZoraCreator1155Premint", () => {
 
       const premintApiClient = new PremintAPIClient(chain.id);
 
-      premintApiClient.getSignature = vi
-        .fn<any, ReturnType<typeof premintApiClient.getSignature>>()
+      premintApiClient.get = vi
+        .fn<any, ReturnType<typeof premintApiClient.get>>()
         .mockResolvedValue({
           collection: {
             contractAdmin: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
@@ -39,25 +39,28 @@ describe("ZoraCreator1155Premint", () => {
             additionalAdmins: [],
           },
           collectionAddress: "0xf8dA7f53c283d898818af7FB9d98103F559bDac2",
-          premintConfig: {
-            deleted: false,
-            tokenConfig: {
-              fixedPriceMinter: getDefaultFixedPriceMinterAddress(chain.id),
-              maxSupply: 18446744073709551615n,
-              maxTokensPerAddress: 0n,
-              mintDuration: 604800n,
-              mintStart: 0n,
-              pricePerToken: 0n,
-              royaltyBPS: 1000,
-              royaltyMintSchedule: 0,
-              royaltyRecipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-              tokenURI:
-                "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+          premint: {
+            premintConfig: {
+              deleted: false,
+              tokenConfig: {
+                fixedPriceMinter: getDefaultFixedPriceMinterAddress(chain.id),
+                maxSupply: 18446744073709551615n,
+                maxTokensPerAddress: 0n,
+                mintDuration: 604800n,
+                mintStart: 0n,
+                pricePerToken: 0n,
+                royaltyBPS: 1000,
+                royaltyMintSchedule: 0,
+                royaltyRecipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+                tokenURI:
+                  "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+              },
+              uid: 3,
+              version: 0,
             },
-            uid: 3,
-            version: 0,
+            premintConfigVersion: PremintConfigVersion.V1,
           },
-          premintConfigVersion: PremintConfigVersion.V1,
+          signer: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           signature:
             "0x4d191dd60d428adfe507932a1758bee8ac5bbb77dcd3c05840c237416a3a25035bb8cc7c62177a4e9acb5f40c4032cdb3dbfefdd1575f2c3b4c57945b2076e2e1c",
         });
@@ -238,13 +241,16 @@ describe("ZoraCreator1155Premint - v2 signatures", () => {
         account: additionalAdmin!,
       });
 
-      premintApiClient.getSignature = vi
-        .fn<any, ReturnType<typeof premintApiClient.getSignature>>()
+      premintApiClient.get = vi
+        .fn<any, ReturnType<typeof premintApiClient.get>>()
         .mockResolvedValue({
           collection,
           collectionAddress,
-          premintConfig: premintConfig as PremintConfigV2,
-          premintConfigVersion: PremintConfigVersion.V2,
+          premint: {
+            premintConfig: premintConfig as PremintConfigV2,
+            premintConfigVersion: PremintConfigVersion.V2,
+          },
+          signer: collection.contractAdmin,
           signature,
         });
 

package/src/premint/premint-client.ts

@@ -27,6 +27,7 @@ import {
   emptyContractCreationConfig,
   defaultAdditionalAdmins,
   toContractCreationConfigOrAddress,
+  getPremintMintFee,
 } from "./preminter";
 import {
   PremintConfigVersion,
@@ -42,7 +43,6 @@ import { IPremintAPI, IPremintGetter } from "./premint-api-client";
 import type { DecodeEventLogReturnType } from "viem";
 import { OPEN_EDITION_MINT_SIZE } from "../constants";
 import { getApiNetworkConfigForChain } from "src/mint/subgraph-mint-getter";
-import { MintCosts } from "src/mint/mint-client";
 import {
   makeContractParameters,
   mintRecipientOrAccount,
@@ -52,14 +52,20 @@ import {
   ContractCreationConfigAndAddress,
   ContractCreationConfigOrAddress,
 } from "./contract-types";
-import { MakePremintMintParametersArguments } from "src/mint/types";
+import {
+  MakeMintParametersArgumentsBase,
+  MakePremintMintParametersArguments,
+  MintCosts,
+} from "src/mint/types";
+import { PremintFromApi } from "./conversions";
+import { SimulateContractParametersWithAccount } from "src/types";
 
 type PremintedV2LogType = DecodeEventLogReturnType<
   typeof zoraCreator1155PremintExecutorImplABI,
   "PremintedV2"
 >["args"];
 
-type URLSReturnType = {
+export type URLSReturnType = {
   explorer: null | string;
   zoraCollect: null | string;
   zoraManage: null | string;
@@ -297,7 +303,7 @@ export class PremintClient {
    * @returns PremintSignatureGetResponse of premint data from the API
    */
   async getPremint({ address, uid }: { address: Address; uid: number }) {
-    return await this.apiClient.getSignature({
+    return await this.apiClient.get({
       collectionAddress: address,
       uid,
     });
@@ -426,7 +432,8 @@ type PremintReturn<T extends PremintConfigVersion> = {
   /** Signs the Premint, and submits it and the signature to the Zora Premint API */
   signAndSubmit: (params: SignAndSubmitParams) => Promise<SignAndSubmitReturn>;
   /** For the case where the premint is signed externally, takes the signature for the Premint, and submits it and the Premint to the Zora Premint API */
-  submit: (params: SubmitParams) => void;
+  submit: (params: SubmitParams) => Promise<void>;
+  urls: URLSReturnType;
 } & PremintConfigWithVersion<T>;
 
 function makePremintReturn<T extends PremintConfigVersion>({
@@ -497,6 +504,12 @@ function makePremintReturn<T extends PremintConfigVersion>({
     });
   };
 
+  const urls = makeUrls({
+    chainId,
+    address: collectionAddress,
+    uid: premintConfig.uid,
+  });
+
   return {
     premintConfig,
     premintConfigVersion,
@@ -504,6 +517,7 @@ function makePremintReturn<T extends PremintConfigVersion>({
     collectionAddress,
     signAndSubmit,
     submit,
+    urls,
   };
 }
 
@@ -656,10 +670,9 @@ async function updatePremint({
   chainId: number;
 }) {
   const {
-    premintConfig,
+    premint: { premintConfig, premintConfigVersion },
     collection: collectionCreationConfig,
-    premintConfigVersion,
-  } = await apiClient.getSignature({
+  } = await apiClient.get({
     collectionAddress: collection,
     uid: uid,
   });
@@ -703,11 +716,10 @@ async function deletePremint({
   chainId: number;
 }) {
   const {
-    premintConfig,
-    premintConfigVersion,
+    premint: { premintConfig, premintConfigVersion },
     collection: collectionCreationConfig,
     collectionAddress,
-  } = await apiClient.getSignature({
+  } = await apiClient.get({
     collectionAddress: collection,
     uid: uid,
   });
@@ -781,32 +793,51 @@ export async function collectPremint({
     throw new Error("Quantity to mint cannot be below 1");
   }
 
-  const {
-    premintConfig,
-    premintConfigVersion,
-    collection,
-    collectionAddress,
-    signature,
-  } = await premintGetter.getSignature({
+  const premint = await premintGetter.get({
     collectionAddress: tokenContract,
     uid,
   });
 
-  const numberToMint = BigInt(quantityToMint || 1);
-
-  if (premintConfigVersion === PremintConfigVersion.V3) {
-    throw new Error("PremintV3 not supported in premint SDK");
-  }
+  const mintFee = await getPremintMintFee({
+    tokenContract,
+    publicClient,
+  });
 
-  const value = (
-    await getPremintMintCosts({
-      tokenContract,
-      quantityToMint: numberToMint,
-      publicClient,
-      tokenPrice: premintConfig.tokenConfig.pricePerToken,
-    })
-  ).totalCostEth;
+  return buildPremintMintCall({
+    mintArguments: {
+      minterAccount,
+      quantityToMint,
+      firstMinter,
+      mintComment,
+      mintRecipient,
+      mintReferral,
+    },
+    mintFee,
+    premint,
+  });
+}
 
+export const buildPremintMintCall = ({
+  mintArguments: {
+    minterAccount,
+    mintComment = "",
+    mintRecipient,
+    mintReferral,
+    firstMinter,
+    quantityToMint,
+  },
+  premint: { collection, collectionAddress, premint, signature },
+  mintFee,
+}: {
+  mintArguments: Omit<MakeMintParametersArgumentsBase, "tokenContract"> & {
+    firstMinter?: Address;
+  };
+  premint: Pick<
+    PremintFromApi,
+    "collection" | "collectionAddress" | "premint" | "signature"
+  >;
+  mintFee: bigint;
+}): SimulateContractParametersWithAccount => {
   const mintArgumentsContract: PremintMintArguments = {
     mintComment: mintComment,
     mintRecipient: mintRecipientOrAccount({
@@ -829,6 +860,14 @@ export async function collectPremint({
     firstMinter ||
     (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
 
+  if (premint.premintConfigVersion === PremintConfigVersion.V3) {
+    throw new Error("PremintV3 not supported in premint SDK");
+  }
+
+  const value =
+    (mintFee + premint.premintConfig.tokenConfig.pricePerToken) *
+    BigInt(quantityToMint);
+
   return makeContractParameters({
     account: minterAccount,
     abi: zoraCreator1155PremintExecutorImplABI,
@@ -838,18 +877,15 @@ export async function collectPremint({
     args: [
       collectionOrEmpty,
       collectionAddressToSubmit,
-      encodePremintConfig({
-        premintConfig,
-        premintConfigVersion,
-      }),
+      encodePremintConfig(premint),
       signature,
-      numberToMint,
+      BigInt(quantityToMint),
       mintArgumentsContract,
       firstMinterToSubmit,
       zeroAddress,
     ],
   });
-}
+};
 
 export function makeUrls({
   uid,