@zoralabs/protocol-sdk 0.5.17 → 0.7.0

package/src/premint/preminter.ts

@@ -29,13 +29,15 @@ import {
   PremintConfigWithVersion,
   TokenCreationConfig,
 } from "@zoralabs/protocol-deployments";
-import { MintCosts } from "src/mint/mint-client";
 import { PublicClient } from "src/utils";
 import {
   ContractCreationConfigAndAddress,
   ContractCreationConfigOrAddress,
   ContractCreationConfigWithOptionalAdditionalAdmins,
 } from "./contract-types";
+import { IPremintGetter } from "./premint-api-client";
+import { isPremintConfigV1, isPremintConfigV2 } from "./conversions";
+import { MintCosts } from "src/mint/types";
 
 export const getPremintExecutorAddress = () =>
   zoraCreator1155PremintExecutorImplAddress[999] as Address;
@@ -271,8 +273,8 @@ export const supportsPremintVersion = async ({
 
 export async function getPremintCollectionAddress({
   publicClient,
-  collection,
-  collectionAddress,
+  contract: collection,
+  contractAddress: collectionAddress,
 }: {
   publicClient: PublicClient;
 } & ContractCreationConfigOrAddress): Promise<Address> {
@@ -355,25 +357,72 @@ export async function getPremintMintFee({
   }
 }
 
+type GetMintCostsParams = {
+  tokenContract: Address;
+  tokenPrice: bigint;
+  quantityToMint: bigint | number;
+  publicClient: PublicClient;
+};
+
 export async function getPremintMintCosts({
   publicClient,
   tokenContract,
   tokenPrice,
   quantityToMint,
-}: {
-  tokenContract: Address;
-  tokenPrice: bigint;
-  quantityToMint: bigint;
-  publicClient: PublicClient;
-}): Promise<MintCosts> {
+}: GetMintCostsParams): Promise<MintCosts> {
   const mintFee = await getPremintMintFee({ tokenContract, publicClient });
 
+  const quantityToMintBigInt = BigInt(quantityToMint);
+
   return {
-    mintFee: mintFee * quantityToMint,
-    tokenPurchaseCost: tokenPrice * quantityToMint,
-    totalCost: (mintFee + tokenPrice) * quantityToMint,
+    mintFee: mintFee * quantityToMintBigInt,
+    totalPurchaseCost: tokenPrice * quantityToMintBigInt,
+    totalCostEth: (mintFee + tokenPrice) * quantityToMintBigInt,
   };
 }
+export async function getPremintPricePerToken({
+  collection,
+  uid,
+  premintGetter,
+}: {
+  collection: Address;
+  uid: number;
+  premintGetter: IPremintGetter;
+}) {
+  const { premint: premintConfigWithVersion } = await premintGetter.get({
+    collectionAddress: collection,
+    uid,
+  });
+
+  if (
+    isPremintConfigV1(premintConfigWithVersion) ||
+    isPremintConfigV2(premintConfigWithVersion)
+  ) {
+    return premintConfigWithVersion.premintConfig.tokenConfig.pricePerToken;
+  }
+
+  throw new Error("Premint version not supported to get price");
+}
+
+export async function getPremintMintCostsWithUnknownTokenPrice({
+  premintGetter,
+  uid,
+  ...rest
+}: Omit<GetMintCostsParams, "tokenPrice"> & {
+  premintGetter: IPremintGetter;
+  uid: number;
+}) {
+  const pricePerToken = await getPremintPricePerToken({
+    uid,
+    premintGetter,
+    collection: rest.tokenContract,
+  });
+
+  return await getPremintMintCosts({
+    ...rest,
+    tokenPrice: pricePerToken,
+  });
+}
 
 export function makeMintRewardsRecipient({
   mintReferral = zeroAddress,
@@ -416,13 +465,13 @@ export const toContractCreationConfigOrAddress = ({
 }) => {
   if (typeof collection !== "undefined") {
     return {
-      collection,
+      contract: collection,
     };
   }
 
   if (typeof collectionAddress !== "undefined") {
     return {
-      collectionAddress,
+      contractAddress: collectionAddress,
     };
   }
 

package/src/sdk.ts

@@ -0,0 +1,101 @@
+import {
+  PremintClient,
+  getDataFromPremintReceipt,
+} from "./premint/premint-client";
+import { Create1155Client } from "./create/1155-create-helper";
+import { MintClient } from "./mint/mint-client";
+import { ClientConfig } from "./utils";
+import { IPremintAPI, PremintAPIClient } from "./premint/premint-api-client";
+import { SubgraphMintGetter } from "./mint/subgraph-mint-getter";
+import { IOnchainMintGetter } from "./mint/types";
+
+export type CreatorClient = {
+  createPremint: PremintClient["createPremint"];
+  updatePremint: PremintClient["updatePremint"];
+  deletePremint: PremintClient["deletePremint"];
+  create1155: Create1155Client["createNew1155Token"];
+};
+
+export type CollectorClient = {
+  getPremint: PremintClient["getPremint"];
+  getCollectDataFromPremintReceipt: PremintClient["getDataFromPremintReceipt"];
+  mint: MintClient["mint"];
+  getMintCosts: MintClient["getMintCosts"];
+  getToken: MintClient["get"];
+  getTokensOfContract: MintClient["getOfContract"];
+};
+
+export type CreatorClientConfig = ClientConfig & {
+  /** API for submitting and getting premints.  Defaults to the Zora Premint API */
+  premintApi?: IPremintAPI;
+};
+
+/**
+ * Builds the sdk for creating/managing 1155 contracts and tokens
+ *
+ * @param clientConfig - Configuration for the client {@link CreatorClientConfig}
+ * @returns CreatorClient {@link CreatorClient}
+ * */
+export function createCreatorClient(
+  clientConfig: CreatorClientConfig,
+): CreatorClient {
+  const premintClient = new PremintClient({
+    chainId: clientConfig.chainId,
+    publicClient: clientConfig.publicClient,
+    premintApi:
+      clientConfig.premintApi || new PremintAPIClient(clientConfig.chainId),
+  });
+
+  const create1155CreatorClient = new Create1155Client({
+    chainId: clientConfig.chainId,
+    publicClient: clientConfig.publicClient,
+  });
+
+  return {
+    createPremint: (p) => premintClient.createPremint(p),
+    updatePremint: (p) => premintClient.updatePremint(p),
+    deletePremint: (p) => premintClient.deletePremint(p),
+    create1155: (p) => create1155CreatorClient.createNew1155Token(p),
+  };
+}
+
+export type CollectorClientConfig = ClientConfig & {
+  /** API for getting premints.  Defaults to the Zora Premint API */
+  premintGetter?: IPremintAPI;
+  /** API for getting onchain mints.  Defaults to the Zora Creator Subgraph */
+  mintGetter?: IOnchainMintGetter;
+};
+
+/**
+ * Builds the sdk for collecting Premints, 1155, and 721 tokens.
+ *
+ * @param clientConfig - Configuration for the client {@link CollectorClientConfig}
+ * @returns CollectorClient {@link CollectorClient}
+ */
+export function createCollectorClient(
+  params: CollectorClientConfig,
+): CollectorClient {
+  const premintGetterToUse =
+    params.premintGetter || new PremintAPIClient(params.chainId);
+  const mintGetterToUse =
+    params.mintGetter || new SubgraphMintGetter(params.chainId);
+  const mintClient = new MintClient({
+    publicClient: params.publicClient,
+    premintGetter: premintGetterToUse,
+    mintGetter: mintGetterToUse,
+  });
+
+  return {
+    getPremint: (p) =>
+      premintGetterToUse.get({
+        collectionAddress: p.address,
+        uid: p.uid,
+      }),
+    getCollectDataFromPremintReceipt: (p) =>
+      getDataFromPremintReceipt(p, params.chainId),
+    getToken: (p) => mintClient.get(p),
+    getTokensOfContract: (p) => mintClient.getOfContract(p),
+    mint: (p) => mintClient.mint(p),
+    getMintCosts: (p) => mintClient.getMintCosts(p),
+  };
+}

package/src/types.ts

@@ -1 +1,19 @@
+import {
+  Account,
+  Address,
+  PublicClient,
+  SimulateContractParameters,
+} from "viem";
+
 export type GenericTokenIdTypes = number | bigint | string;
+
+export type IPublicClient = Pick<PublicClient, "readContract">;
+
+export type SimulateContractParametersWithAccount = SimulateContractParameters<
+  any,
+  any,
+  any,
+  any,
+  any,
+  Account | Address
+>;

package/src/utils.ts

@@ -1,55 +1,63 @@
-import {
-  Abi,
-  Account,
-  Address,
-  Chain,
-  ContractFunctionArgs,
-  ContractFunctionName,
-  PublicClient as BasePublicClient,
-  SimulateContractParameters,
-  Transport,
-  createPublicClient,
-  http,
-} from "viem";
-import {
-  IHttpClient,
-  httpClient as defaultHttpClient,
-} from "./apis/http-api-base";
-
-export const makeSimulateContractParamaters = <
-  const abi extends Abi | readonly unknown[],
-  functionName extends ContractFunctionName<abi, "nonpayable" | "payable">,
-  args extends ContractFunctionArgs<
-    abi,
-    "nonpayable" | "payable",
-    functionName
-  >,
-  chainOverride extends Chain | undefined,
-  accountOverride extends Account | Address | undefined = undefined,
->(
-  args: SimulateContractParameters<
-    abi,
-    functionName,
-    args,
-    Chain,
-    chainOverride,
-    accountOverride
-  >,
+import { Account, Address, PublicClient as BasePublicClient } from "viem";
+import { IHttpClient } from "./apis/http-api-base";
+import { SimulateContractParametersWithAccount } from "./types";
+
+export const makeContractParameters = (
+  args: SimulateContractParametersWithAccount,
 ) => args;
 
-export type PublicClient = BasePublicClient<Transport, Chain>;
+export type PublicClient = Pick<BasePublicClient, "readContract">;
 
 export type ClientConfig = {
-  chain: Chain;
-  publicClient?: PublicClient;
-  httpClient?: IHttpClient;
+  /** The chain that the client is to run on. */
+  chainId: number;
+  /** Optional public client for the chain.  If not provide, it is created. */
+  publicClient: PublicClient;
 };
 
-export function setupClient({ chain, httpClient, publicClient }: ClientConfig) {
+export function setupClient({ chainId, publicClient }: ClientConfig) {
   return {
-    chain,
-    httpClient: httpClient || defaultHttpClient,
-    publicClient:
-      publicClient || createPublicClient({ chain, transport: http() }),
+    chainId,
+    publicClient,
   };
 }
+
+export function mintRecipientOrAccount({
+  mintRecipient,
+  minterAccount,
+}: {
+  mintRecipient?: Address;
+  minterAccount: Address | Account;
+}): Address {
+  return (
+    mintRecipient ||
+    (typeof minterAccount === "string" ? minterAccount : minterAccount.address)
+  );
+}
+
+export type Concrete<Type> = {
+  [Property in keyof Type]-?: Type[Property];
+};
+
+export async function querySubgraphWithRetries({
+  httpClient,
+  subgraphUrl,
+  query,
+  variables,
+}: {
+  httpClient: IHttpClient;
+  subgraphUrl: string;
+  query: string;
+  variables: any;
+}) {
+  const { retries, post } = httpClient;
+
+  const result = await retries(async () => {
+    return await post<any>(subgraphUrl, {
+      query,
+      variables,
+    });
+  });
+
+  return result?.data;
+}

package/test-integration/setup-test-contracts.ts

@@ -0,0 +1,96 @@
+import {
+  createCollectorClient,
+  createCreatorClient,
+  getPremintCollectionAddress,
+} from "src";
+import {
+  LocalAccount,
+  createPublicClient,
+  createWalletClient,
+  http,
+  parseEther,
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { zoraSepolia } from "viem/chains";
+
+const publicClient = createPublicClient({
+  chain: zoraSepolia,
+  transport: http(),
+});
+
+const walletClient = createWalletClient({
+  chain: zoraSepolia,
+  transport: http(),
+});
+
+const creatorClient = createCreatorClient({
+  chainId: zoraSepolia.id,
+  publicClient,
+});
+
+const collectorClient = createCollectorClient({
+  chainId: zoraSepolia.id,
+  publicClient,
+});
+
+export const createPremintsOnContract = async ({
+  creatorAccount,
+}: {
+  creatorAccount: LocalAccount;
+}) => {
+  const collectionAddress = await getPremintCollectionAddress({
+    publicClient,
+    contract: {
+      contractAdmin: creatorAccount.address,
+      contractName: "testContract",
+      contractURI:
+        "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+    },
+  });
+
+  console.log({ collectionAddress });
+
+  const { typedDataDefinition, submit } = await creatorClient.createPremint({
+    contract: {
+      contractAdmin: creatorAccount.address,
+      contractName: "testContract",
+      contractURI:
+        "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+    },
+    token: {
+      payoutRecipient: creatorAccount.address,
+      tokenURI:
+        "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+      pricePerToken: parseEther("0.001"),
+    },
+  });
+
+  const signature = await walletClient.signTypedData({
+    account: creatorAccount,
+    ...typedDataDefinition,
+  });
+
+  await submit({
+    signature,
+  });
+
+  const mints = await collectorClient.getTokensOfContract({
+    tokenContract: collectionAddress,
+  });
+
+  console.log({ mints: mints.map((x) => x.mintable) });
+};
+
+const setupTestContracts = async () => {
+  const creatorAccount = privateKeyToAccount(
+    // random private key created by cast
+    "0x0d32fcabfe28c779974a77dc635163f062be2bc0b10eea62994235617b44092f",
+  );
+
+  // create 2 premints on a contract
+  await createPremintsOnContract({
+    creatorAccount,
+  });
+};
+
+setupTestContracts();

package/dist/mint/mint-api-client.d.ts

@@ -1,35 +0,0 @@
-import { Address } from "viem";
-import { IHttpClient } from "../apis/http-api-base";
-import { NetworkConfig } from "src/apis/chain-constants";
-import { GenericTokenIdTypes } from "src/types";
-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 type SalesConfigAndTokenInfo = {
-    salesConfig: SaleStrategies;
-    mintFeePerQuantity: bigint;
-};
-export declare const getApiNetworkConfigForChain: (chainId: number) => NetworkConfig;
-export declare class MintAPIClient {
-    httpClient: IHttpClient;
-    networkConfig: NetworkConfig;
-    constructor(chainId: number, httpClient?: IHttpClient);
-    getSalesConfigAndTokenInfo({ tokenAddress, tokenId, saleType, }: {
-        tokenAddress: Address;
-        tokenId?: GenericTokenIdTypes;
-        saleType?: SaleType;
-    }): Promise<SalesConfigAndTokenInfo>;
-}
-export {};
-//# sourceMappingURL=mint-api-client.d.ts.map

package/dist/mint/mint-api-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mint-api-client.d.ts","sourceRoot":"","sources":["../../src/mint/mint-api-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAEL,WAAW,EACZ,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAwB,MAAM,0BAA0B,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAGhD,MAAM,MAAM,QAAQ,GAAG,YAAY,GAAG,OAAO,CAAC;AAiC9C,KAAK,YAAY,CAAC,CAAC,SAAS,QAAQ,IAAI;IACtC,QAAQ,EAAE,CAAC,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF,KAAK,sBAAsB,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;AAEzD,KAAK,iBAAiB,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG;IAC/C,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,cAAc,GAAG,sBAAsB,GAAG,iBAAiB,CAAC;AAEjE,MAAM,MAAM,uBAAuB,GAAG;IACpC,WAAW,EAAE,cAAc,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,2BAA2B,YAAa,MAAM,KAAG,aAK7D,CAAC;AAEF,qBAAa,aAAa;IACxB,UAAU,EAAE,WAAW,CAAC;IACxB,aAAa,EAAE,aAAa,CAAC;gBAEjB,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,WAAW;IAK/C,0BAA0B,CAAC,EAC/B,YAAY,EACZ,OAAO,EACP,QAAQ,GACT,EAAE;QACD,YAAY,EAAE,OAAO,CAAC;QACtB,OAAO,CAAC,EAAE,mBAAmB,CAAC;QAC9B,QAAQ,CAAC,EAAE,QAAQ,CAAC;KACrB,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAwFrC"}

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

@@ -1,177 +0,0 @@
-import { Address } from "viem";
-import {
-  httpClient as defaultHttpClient,
-  IHttpClient,
-} from "../apis/http-api-base";
-import { NetworkConfig, networkConfigByChain } from "src/apis/chain-constants";
-import { GenericTokenIdTypes } from "src/types";
-import { NFT_SALE_QUERY } from "src/constants";
-
-export type SaleType = "fixedPrice" | "erc20";
-
-type FixedPriceSaleStrategyResult = {
-  address: Address;
-  pricePerToken: string;
-  saleEnd: string;
-  saleStart: string;
-  maxTokensPerAddress: string;
-};
-
-type ERC20SaleStrategyResult = FixedPriceSaleStrategyResult & {
-  currency: Address;
-};
-
-type SalesStrategyResult =
-  | {
-      type: "FIXED_PRICE";
-      fixedPrice: FixedPriceSaleStrategyResult;
-    }
-  | {
-      type: "ERC_20_MINTER";
-      erc20Minter: ERC20SaleStrategyResult;
-    };
-
-type TokenQueryResult = {
-  tokenId?: string;
-  salesStrategies?: SalesStrategyResult[];
-  contract: {
-    mintFeePerQuantity: "string";
-    salesStrategies: SalesStrategyResult[];
-  };
-};
-
-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 type SalesConfigAndTokenInfo = {
-  salesConfig: SaleStrategies;
-  mintFeePerQuantity: bigint;
-};
-
-export const getApiNetworkConfigForChain = (chainId: number): NetworkConfig => {
-  if (!networkConfigByChain[chainId]) {
-    throw new Error(`chain id ${chainId} network not configured `);
-  }
-  return networkConfigByChain[chainId]!;
-};
-
-export class MintAPIClient {
-  httpClient: IHttpClient;
-  networkConfig: NetworkConfig;
-
-  constructor(chainId: number, httpClient?: IHttpClient) {
-    this.httpClient = httpClient || defaultHttpClient;
-    this.networkConfig = getApiNetworkConfigForChain(chainId);
-  }
-
-  async getSalesConfigAndTokenInfo({
-    tokenAddress,
-    tokenId,
-    saleType,
-  }: {
-    tokenAddress: Address;
-    tokenId?: GenericTokenIdTypes;
-    saleType?: SaleType;
-  }): Promise<SalesConfigAndTokenInfo> {
-    const { retries, post } = this.httpClient;
-    return retries(async () => {
-      const response = await post<any>(this.networkConfig.subgraphUrl, {
-        query: NFT_SALE_QUERY,
-        variables: {
-          id:
-            tokenId !== undefined
-              ? // Generic Token ID types all stringify down to the base numeric equivalent.
-                `${tokenAddress.toLowerCase()}-${tokenId}`
-              : `${tokenAddress.toLowerCase()}-0`,
-        },
-      });
-
-      const token = response.data?.zoraCreateToken as TokenQueryResult;
-
-      if (!token) {
-        throw new Error("Cannot find a token to mint");
-      }
-
-      const allStrategies =
-        (typeof tokenId !== "undefined"
-          ? token.salesStrategies
-          : token.contract.salesStrategies) || [];
-
-      const saleStrategies = allStrategies.sort((a, b) =>
-        BigInt(
-          a.type === "ERC_20_MINTER"
-            ? a.erc20Minter.saleEnd
-            : a.fixedPrice.saleEnd,
-        ) >
-        BigInt(
-          b.type === "FIXED_PRICE"
-            ? b.fixedPrice.saleEnd
-            : b.erc20Minter.saleEnd,
-        )
-          ? 1
-          : -1,
-      );
-
-      let targetStrategy: SalesStrategyResult | undefined;
-
-      if (!saleType) {
-        targetStrategy = saleStrategies[0];
-        if (!targetStrategy) {
-          throw new Error("Cannot find sale strategy");
-        }
-      } else {
-        const mappedSaleType =
-          saleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
-        targetStrategy = saleStrategies.find(
-          (strategy: SalesStrategyResult) => strategy.type === mappedSaleType,
-        );
-        if (!targetStrategy) {
-          throw new Error(`Cannot find sale strategy for ${mappedSaleType}`);
-        }
-      }
-
-      if (targetStrategy.type === "FIXED_PRICE") {
-        return {
-          salesConfig: {
-            saleType: "fixedPrice",
-            ...targetStrategy.fixedPrice,
-            maxTokensPerAddress: BigInt(
-              targetStrategy.fixedPrice.maxTokensPerAddress,
-            ),
-            pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken),
-          },
-          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity),
-        };
-      }
-      if (targetStrategy.type === "ERC_20_MINTER") {
-        return {
-          salesConfig: {
-            saleType: "erc20",
-            ...targetStrategy.erc20Minter,
-            maxTokensPerAddress: BigInt(
-              targetStrategy.erc20Minter.maxTokensPerAddress,
-            ),
-            pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken),
-          },
-          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity),
-        };
-      }
-
-      throw new Error("Invalid saleType");
-    });
-  }
-}