@zoralabs/protocol-sdk 0.6.0 → 0.7.0

package/src/premint/preminter.ts

@@ -29,7 +29,6 @@ import {
   PremintConfigWithVersion,
   TokenCreationConfig,
 } from "@zoralabs/protocol-deployments";
-import { MintCosts } from "src/mint/mint-client";
 import { PublicClient } from "src/utils";
 import {
   ContractCreationConfigAndAddress,
@@ -38,6 +37,7 @@ import {
 } 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;
@@ -380,7 +380,6 @@ export async function getPremintMintCosts({
     totalCostEth: (mintFee + tokenPrice) * quantityToMintBigInt,
   };
 }
-
 export async function getPremintPricePerToken({
   collection,
   uid,
@@ -390,7 +389,7 @@ export async function getPremintPricePerToken({
   uid: number;
   premintGetter: IPremintGetter;
 }) {
-  const premintConfigWithVersion = await premintGetter.getSignature({
+  const { premint: premintConfigWithVersion } = await premintGetter.get({
     collectionAddress: collection,
     uid,
   });

package/src/sdk.ts

@@ -7,7 +7,7 @@ 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 { IMintGetter } from "./mint/types";
+import { IOnchainMintGetter } from "./mint/types";
 
 export type CreatorClient = {
   createPremint: PremintClient["createPremint"];
@@ -21,6 +21,8 @@ export type CollectorClient = {
   getCollectDataFromPremintReceipt: PremintClient["getDataFromPremintReceipt"];
   mint: MintClient["mint"];
   getMintCosts: MintClient["getMintCosts"];
+  getToken: MintClient["get"];
+  getTokensOfContract: MintClient["getOfContract"];
 };
 
 export type CreatorClientConfig = ClientConfig & {
@@ -61,7 +63,7 @@ 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?: IMintGetter;
+  mintGetter?: IOnchainMintGetter;
 };
 
 /**
@@ -78,7 +80,6 @@ export function createCollectorClient(
   const mintGetterToUse =
     params.mintGetter || new SubgraphMintGetter(params.chainId);
   const mintClient = new MintClient({
-    chainId: params.chainId,
     publicClient: params.publicClient,
     premintGetter: premintGetterToUse,
     mintGetter: mintGetterToUse,
@@ -86,12 +87,14 @@ export function createCollectorClient(
 
   return {
     getPremint: (p) =>
-      premintGetterToUse.getSignature({
+      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,31 +1,9 @@
-import {
-  Abi,
-  Account,
-  Address,
-  Chain,
-  ContractFunctionArgs,
-  ContractFunctionName,
-  PublicClient as BasePublicClient,
-  SimulateContractParameters,
-  AbiStateMutability,
-} from "viem";
-
-export const makeContractParameters = <
-  const abi extends Abi | readonly unknown[],
-  stateMutabiliy extends AbiStateMutability,
-  functionName extends ContractFunctionName<abi, stateMutabiliy>,
-  args extends ContractFunctionArgs<abi, stateMutabiliy, 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 = Pick<BasePublicClient, "readContract">;
@@ -60,3 +38,26 @@ export function mintRecipientOrAccount({
 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/test-integration/premint-client.test.ts

@@ -1,148 +0,0 @@
-import { zoraSepolia, zoraTestnet } from "viem/chains";
-import { describe } from "vitest";
-
-import { createPremintClient } from "src/premint/premint-client";
-import { forkUrls, makeAnvilTest } from "src/anvil";
-import { PremintConfigVersion } from "src/premint/contract-types";
-
-const zoraGoerliTest = makeAnvilTest({
-  forkBlockNumber: 2107926,
-  forkUrl: forkUrls.zoraGoerli,
-  anvilChainId: zoraTestnet.id,
-});
-
-const zoraSepoliaTest = makeAnvilTest({
-  forkBlockNumber: 3118200,
-  forkUrl: forkUrls.zoraSepolia,
-  anvilChainId: zoraSepolia.id,
-});
-
-const tests = [
-  {
-    anvilTest: zoraGoerliTest,
-    chain: zoraTestnet,
-  },
-  {
-    anvilTest: zoraSepoliaTest,
-    chain: zoraSepolia,
-  },
-];
-
-tests.forEach(({ anvilTest, chain }) => {
-  describe(chain.name, () => {
-    describe("ZoraCreator1155Premint", () => {
-      describe("v2 signatures", () => {
-        anvilTest(
-          "can sign and execute on the forked premint contract",
-          async ({
-            viemClients: { walletClient, publicClient, testClient },
-          }) => {
-            const [creatorAccount, createReferralAccount, minterAccount] =
-              await walletClient.getAddresses();
-            const premintClient = createPremintClient({
-              chainId: chain,
-              publicClient,
-            });
-
-            const { uid, verifyingContract } =
-              await premintClient.createPremint({
-                walletClient,
-                payoutRecipient: creatorAccount!,
-                checkSignature: true,
-                contract: {
-                  contractAdmin: creatorAccount!,
-                  contractName: "Testing Contract Premint V2",
-                  contractURI:
-                    "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3f",
-                  additionalAdmins: [],
-                },
-                premintConfigVersion: PremintConfigVersion.V2,
-                token: {
-                  tokenURI:
-                    "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2f",
-                  createReferral: createReferralAccount!,
-                },
-              });
-
-            const mintParameters = await premintClient.makeMintParameters({
-              minterAccount: minterAccount!,
-              tokenContract: verifyingContract,
-              uid,
-            });
-
-            const mintCosts = await premintClient.getMintCosts({
-              tokenContract: verifyingContract,
-              quantityToMint: 1n,
-              pricePerToken: 0n,
-            });
-
-            await testClient.setBalance({
-              address: minterAccount!,
-              value: mintCosts.totalCostEth,
-            });
-
-            // if simulation succeeds, mint will succeed
-            await publicClient.simulateContract(mintParameters);
-          },
-          20 * 1000,
-        );
-      });
-
-      describe("v1 signatures", () => {
-        anvilTest(
-          "can sign and execute on the forked premint contract",
-          async ({
-            viemClients: { walletClient, publicClient, testClient },
-          }) => {
-            const [creatorAccount, minterAccount] =
-              await walletClient.getAddresses();
-            const premintClient = createPremintClient({
-              chainId: chain,
-              publicClient,
-            });
-
-            const { uid, verifyingContract } =
-              await premintClient.createPremint({
-                walletClient,
-                payoutRecipient: creatorAccount!,
-                checkSignature: true,
-                contract: {
-                  contractAdmin: creatorAccount!,
-                  contractName: `Testing Contract Premint V1 ${publicClient.chain?.name}`,
-                  contractURI:
-                    "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3fg",
-                  additionalAdmins: [],
-                },
-                premintConfigVersion: PremintConfigVersion.V1,
-                token: {
-                  tokenURI:
-                    "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
-                },
-              });
-
-            const mintParameters = await premintClient.makeMintParameters({
-              minterAccount: minterAccount!,
-              tokenContract: verifyingContract,
-              uid,
-            });
-
-            const mintCosts = await premintClient.getMintCosts({
-              tokenContract: verifyingContract,
-              quantityToMint: 1n,
-              pricePerToken: 0n,
-            });
-
-            await testClient.setBalance({
-              address: minterAccount!,
-              value: mintCosts.totalCostEth,
-            });
-
-            // if simulation succeeds, mint will succeed
-            await publicClient.simulateContract(mintParameters);
-          },
-          20 * 1000,
-        );
-      });
-    });
-  });
-});