@zoralabs/protocol-sdk 0.11.12 → 0.12.0

package/src/mint/types.ts

@@ -2,8 +2,11 @@ import { Account, Address } from "viem";
 import {
   GenericTokenIdTypes,
   SimulateContractParametersWithAccount,
+  WithPublicClient,
 } from "src/types";
 import { AllowListEntry } from "src/allow-list/types";
+import { TokenQueryResult } from "./subgraph-queries";
+import { IPremintGetter } from "src/premint/premint-api-client";
 
 export type MintParameters<MintType> = {
   /** Type of the collection to be minted. */
@@ -33,18 +36,40 @@ export type MintTypes =
   | Erc721MintParameters
   | PremintMintParameters;
 
-export type GetMintParameters = MintTypes & {
+export type GetMintParametersArguments = MintTypes & {
   /** Address of the contract that the item belongs to */
   tokenContract: Address;
   preferredSaleType?: SaleType;
 };
 
-export type GetMintsOfContractParameters = {
+type WithOptionalGetters<T> = T & {
+  /** Optional override for getting onchain mints using indexed events */
+  mintGetter?: IOnchainMintGetter;
+  /** Optional override for getting premints */
+  premintGetter?: IPremintGetter;
+};
+
+export type WithPublicClientAndOptionalGetters<T> = WithOptionalGetters<
+  WithPublicClient<T>
+>;
+
+export type WithPublicClientAndRequiredGetters<T> = WithPublicClient<T> & {
+  mintGetter: IOnchainMintGetter;
+  premintGetter: IPremintGetter;
+};
+
+export type GetMintParameters =
+  WithPublicClientAndOptionalGetters<GetMintParametersArguments>;
+
+export type GetMintsOfContractParametersArguments = {
   /** Address of the contract to get the tokens of */
   tokenContract: Address;
   preferredSaleType?: SaleType;
 };
 
+export type GetMintsOfContractParameters =
+  WithPublicClientAndOptionalGetters<GetMintsOfContractParametersArguments>;
+
 export const isOnChainMint = (mint: MintTypes): mint is OnChainMintParameters =>
   mint.mintType !== "premint";
 
@@ -95,7 +120,13 @@ export type MakeMintParametersArguments =
   | Make721MintArguments
   | MakePremintMintParametersArguments;
 
-export type GetMintCostsParameters = {
+export type MakeMintParameters =
+  WithPublicClient<MakeMintParametersArguments> & {
+    mintGetter?: IOnchainMintGetter;
+    premintGetter?: IPremintGetter;
+  };
+
+export type GetMintCostsParameterArguments = {
   /** Address of token contract/collection to get the mint costs for */
   collection: Address;
   /** Quantity of tokens that will be minted */
@@ -144,7 +175,7 @@ type AllowListSaleStrategy = SaleStrategy<"allowlist"> & {
   merkleRoot: string;
 };
 
-type ZoraTimedSaleStrategy = SaleStrategy<"timed"> & {
+export type ZoraTimedSaleStrategy = SaleStrategy<"timed"> & {
   mintFee: bigint;
   erc20Z: Address;
   pool: Address;
@@ -237,9 +268,7 @@ export interface IOnchainMintGetter {
   getMintable(params: {
     tokenAddress: Address;
     tokenId?: GenericTokenIdTypes;
-    preferredSaleType?: SaleType;
-    blockTime: bigint;
-  }): Promise<GetMintableReturn>;
+  }): Promise<TokenQueryResult>;
 
   getContractMintable(params: {
     tokenAddress: Address;

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

@@ -4,7 +4,6 @@ import {
 } from "../apis/http-api-base";
 import { components, paths } from "../apis/generated/premint-api-types";
 import { ZORA_API_BASE } from "../constants";
-import { getApiNetworkConfigForChain } from "src/mint/subgraph-mint-getter";
 import {
   PremintConfigVersion,
   PremintConfigWithVersion,
@@ -20,6 +19,7 @@ import {
   encodePostSignatureInput,
 } from "./conversions";
 import { ContractCreationConfigOrAddress } from "./contract-types";
+import { getApiNetworkConfigForChain } from "src/apis/network-config";
 
 type PremintNextUIDGetType =
   paths["/signature/{chain_name}/{collection_address}/next_uid"]["get"];

package/src/premint/premint-client.ts

@@ -42,7 +42,6 @@ import {
 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 {
   makeContractParameters,
   mintRecipientOrAccount,
@@ -59,6 +58,7 @@ import {
 } from "src/mint/types";
 import { PremintFromApi } from "./conversions";
 import { SimulateContractParametersWithAccount } from "src/types";
+import { getApiNetworkConfigForChain } from "src/apis/network-config";
 
 type PremintedV2LogType = DecodeEventLogReturnType<
   typeof zoraCreator1155PremintExecutorImplABI,

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

@@ -3,7 +3,6 @@ import { encodeAbiParameters, erc20Abi, parseEther } from "viem";
 import { zoraSepolia, base } from "viem/chains";
 import { forkUrls, makeAnvilTest } from "src/anvil";
 import { simulateAndWriteContractWithRetries } from "src/test-utils";
-import { createCollectorClient, createCreatorClient } from "src/sdk";
 import { new1155ContractVersion } from "src/create/contract-setup";
 import { ISubgraphQuerier } from "src/apis/subgraph-querier";
 import { mockTimedSaleStrategyTokenQueryResult } from "src/fixtures/mint-query-results";
@@ -16,6 +15,9 @@ import { makeContractParameters } from "src/utils";
 import { setupContractAndToken } from "src/fixtures/contract-setup";
 import { advanceToSaleAndAndLaunchMarket } from "src/fixtures/secondary";
 import { CreatorERC20zQueryResult } from "./subgraph-queries";
+import { getRewardsBalances } from "./rewards-queries";
+import { mint } from "src/mint/mint-client";
+import { getSecondaryInfo } from "src/secondary/utils";
 
 describe("rewardsClient", () => {
   makeAnvilTest({
@@ -24,13 +26,10 @@ describe("rewardsClient", () => {
     anvilChainId: base.id,
   })(
     "it can query rewards balances where there are multiple minters",
-    async ({ viemClients: { publicClient, chain } }) => {
-      const creatorClient = createCreatorClient({
-        chainId: chain.id,
-        publicClient,
-      });
-      const rewardsBalance = await creatorClient.getRewardsBalances({
+    async ({ viemClients: { publicClient } }) => {
+      const rewardsBalance = await getRewardsBalances({
         account: "0x129F04B140Acc1AA350be2F9f048C178103c62f3",
+        publicClient,
       });
 
       const erc20zKeys = Object.keys(rewardsBalance.secondaryRoyalties.erc20);
@@ -80,18 +79,14 @@ describe("rewardsClient", () => {
           }),
         });
 
-      const collectorClient = createCollectorClient({
-        chainId: chain.id,
-        publicClient,
-        mintGetter,
-      });
-
-      const { parameters: collectParameters } = await collectorClient.mint({
+      const { parameters: collectParameters } = await mint({
         minterAccount: collectorAccount,
         mintType: "1155",
         quantityToMint,
         tokenId: newTokenId,
         tokenContract: contractAddress,
+        publicClient,
+        mintGetter,
       });
 
       await simulateAndWriteContractWithRetries({
@@ -180,18 +175,210 @@ describe("rewardsClient", () => {
           }),
         });
 
-      const collectorClient = createCollectorClient({
-        chainId: chain.id,
+      const { parameters: collectParameters } = await mint({
+        minterAccount: collectorAccount,
+        mintType: "1155",
+        quantityToMint,
+        tokenId: newTokenId,
+        tokenContract: contractAddress,
         publicClient,
         mintGetter,
       });
 
-      const { parameters: collectParameters } = await collectorClient.mint({
+      await simulateAndWriteContractWithRetries({
+        parameters: collectParameters,
+        walletClient,
+        publicClient,
+      });
+
+      await advanceToSaleAndAndLaunchMarket({
+        account: collectorAccount,
+        publicClient,
+        walletClient,
+        testClient,
+        contractAddress,
+        tokenId: newTokenId,
+      });
+
+      const erc20z = (await getSecondaryInfo({
+        contract: contractAddress,
+        tokenId: newTokenId,
+        publicClient,
+      }))!.erc20z!;
+
+      // after market is launched, by 100 from the pool.  there should be some rewards
+      // balances from secondary royalties
+      await simulateAndWriteContractWithRetries({
+        parameters: makeContractParameters({
+          abi: secondarySwapABI,
+          address:
+            secondarySwapAddress[chain.id as keyof typeof secondarySwapAddress],
+          functionName: "buy1155",
+          args: [
+            erc20z,
+            100n,
+            collectorAccount,
+            collectorAccount,
+            parseEther("1"),
+            0n,
+          ],
+          account: collectorAccount,
+          value: parseEther("1"),
+        }),
+        walletClient,
+        publicClient,
+      });
+
+      const abiParameters = [
+        { name: "recipient", internalType: "address payable", type: "address" },
+        { name: "minEthToAcquire", internalType: "uint256", type: "uint256" },
+        { name: "sqrtPriceLimitX96", internalType: "uint160", type: "uint160" },
+      ] as const;
+      const sellData = encodeAbiParameters(abiParameters, [
+        collectorAccount,
+        0n,
+        0n,
+      ]);
+      await simulateAndWriteContractWithRetries({
+        parameters: makeContractParameters({
+          functionName: "safeTransferFrom",
+          address: contractAddress,
+          abi: zoraCreator1155ImplABI,
+          account: collectorAccount,
+          args: [
+            collectorAccount,
+            secondarySwapAddress[chain.id as keyof typeof secondarySwapAddress],
+            newTokenId,
+            100n,
+            sellData,
+          ],
+        }),
+        walletClient,
+        publicClient,
+      });
+
+      // now we should be able to get rewards balances for these royalties
+
+      const mockResult: CreatorERC20zQueryResult = {
+        zoraCreateTokens: [
+          {
+            salesStrategies: [
+              {
+                zoraTimedMinter: {
+                  erc20Z: { id: erc20z },
+                },
+              },
+            ],
+          },
+        ],
+      };
+
+      // we need to stub the subgraph return
+      rewardsGetter.subgraphQuerier.query = vi
+        .fn<ISubgraphQuerier["query"]>()
+        .mockResolvedValue(mockResult);
+
+      const rewardsBalance = await creatorClient.getRewardsBalances({
+        account: creatorAccount,
+      });
+
+      expect(rewardsBalance.protocolRewards).toBeGreaterThan(0n);
+      expect(rewardsBalance.secondaryRoyalties.erc20[erc20z]).toBeGreaterThan(
+        0,
+      );
+
+      const beforeBalance = await publicClient.getBalance({
+        address: creatorAccount,
+      });
+
+      // it can withdraw all rewards
+      await simulateAndWriteContractWithRetries({
+        parameters: (
+          await creatorClient.withdrawRewards({
+            account: collectorAccount,
+            withdrawFor: creatorAccount,
+            claimSecondaryRoyalties: true,
+          })
+        ).parameters,
+        publicClient,
+        walletClient,
+      });
+
+      const afterBalance = await publicClient.getBalance({
+        address: creatorAccount,
+      });
+
+      // make sure that some additional royalties were withdrawn, this is how we can do greater than
+      // we cant get exact precision
+      expect(afterBalance - beforeBalance).toBeGreaterThan(
+        rewardsBalance.protocolRewards,
+      );
+
+      const erc20balance = await publicClient.readContract({
+        abi: erc20Abi,
+        address: erc20z,
+        functionName: "balanceOf",
+        args: [creatorAccount],
+      });
+
+      expect(erc20balance).toBeGreaterThan(0);
+    },
+    30_000,
+  );
+  makeAnvilTest({
+    forkBlockNumber: 17938475,
+    forkUrl: forkUrls.zoraSepolia,
+    anvilChainId: zoraSepolia.id,
+  })(
+    "it can view and withdraw rewards and secondary royalties for mints",
+    async ({
+      viemClients: { publicClient, chain, walletClient, testClient },
+    }) => {
+      const creatorAccount = (await walletClient.getAddresses()!)[0]!;
+      const collectorAccount = (await walletClient.getAddresses()!)[1]!;
+
+      const {
+        creatorClient,
+        contractAddress,
+        newTokenId,
+        mintGetter,
+        rewardsGetter,
+      } = await setupContractAndToken({
+        chain,
+        publicClient,
+        creatorAccount,
+        walletClient,
+      });
+
+      await testClient.setBalance({
+        address: collectorAccount,
+        value: parseEther("100"),
+      });
+
+      const quantityToMint = 1111n;
+
+      mintGetter.subgraphQuerier.query = vi
+        .fn<ISubgraphQuerier["query"]>()
+        .mockResolvedValue({
+          zoraCreateToken: mockTimedSaleStrategyTokenQueryResult({
+            chainId: chain.id,
+            tokenId: newTokenId,
+            contractAddress,
+            contractVersion:
+              new1155ContractVersion[
+                chain.id as keyof typeof new1155ContractVersion
+              ],
+          }),
+        });
+
+      const { parameters: collectParameters } = await mint({
         minterAccount: collectorAccount,
         mintType: "1155",
         quantityToMint,
         tokenId: newTokenId,
         tokenContract: contractAddress,
+        publicClient,
+        mintGetter,
       });
 
       await simulateAndWriteContractWithRetries({
@@ -201,19 +388,18 @@ describe("rewardsClient", () => {
       });
 
       await advanceToSaleAndAndLaunchMarket({
-        chainId: chain.id,
         account: collectorAccount,
         publicClient,
         walletClient,
-        collectorClient,
         testClient,
         contractAddress,
         tokenId: newTokenId,
       });
 
-      const erc20z = (await collectorClient.getSecondaryInfo({
+      const erc20z = (await getSecondaryInfo({
         contract: contractAddress,
         tokenId: newTokenId,
+        publicClient,
       }))!.erc20z!;
 
       // after market is launched, by 100 from the pool.  there should be some rewards
@@ -275,7 +461,6 @@ describe("rewardsClient", () => {
             salesStrategies: [
               {
                 zoraTimedMinter: {
-                  secondaryActivated: true,
                   erc20Z: { id: erc20z },
                 },
               },
@@ -336,4 +521,116 @@ describe("rewardsClient", () => {
     },
     30_000,
   );
+  makeAnvilTest({
+    forkBlockNumber: 17938475,
+    forkUrl: forkUrls.zoraSepolia,
+    anvilChainId: zoraSepolia.id,
+  })(
+    "it can view and withdraw rewards and secondary royalties for mints when secondary market is not activated yet",
+    async ({
+      viemClients: { publicClient, chain, walletClient, testClient },
+    }) => {
+      const creatorAccount = (await walletClient.getAddresses()!)[0]!;
+      const collectorAccount = (await walletClient.getAddresses()!)[1]!;
+
+      const {
+        creatorClient,
+        contractAddress,
+        newTokenId,
+        mintGetter,
+        rewardsGetter,
+      } = await setupContractAndToken({
+        chain,
+        publicClient,
+        creatorAccount,
+        walletClient,
+      });
+
+      await testClient.setBalance({
+        address: collectorAccount,
+        value: parseEther("100"),
+      });
+
+      const quantityToMint = 1111n;
+
+      mintGetter.subgraphQuerier.query = vi
+        .fn<ISubgraphQuerier["query"]>()
+        .mockResolvedValue({
+          zoraCreateToken: mockTimedSaleStrategyTokenQueryResult({
+            chainId: chain.id,
+            tokenId: newTokenId,
+            contractAddress,
+            contractVersion:
+              new1155ContractVersion[
+                chain.id as keyof typeof new1155ContractVersion
+              ],
+          }),
+        });
+
+      const { parameters: collectParameters } = await mint({
+        minterAccount: collectorAccount,
+        mintType: "1155",
+        quantityToMint,
+        tokenId: newTokenId,
+        tokenContract: contractAddress,
+        publicClient,
+        mintGetter,
+      });
+
+      await simulateAndWriteContractWithRetries({
+        parameters: collectParameters,
+        walletClient,
+        publicClient,
+      });
+
+      const erc20z = (await getSecondaryInfo({
+        contract: contractAddress,
+        tokenId: newTokenId,
+        publicClient,
+      }))!.erc20z!;
+
+      // now we should be able to get query rewards balances without any errors
+      // even though secondary market is not activated yet
+
+      const mockResult: CreatorERC20zQueryResult = {
+        zoraCreateTokens: [
+          {
+            salesStrategies: [
+              {
+                zoraTimedMinter: {
+                  erc20Z: { id: erc20z },
+                },
+              },
+            ],
+          },
+        ],
+      };
+
+      // we need to stub the subgraph return
+      rewardsGetter.subgraphQuerier.query = vi
+        .fn<ISubgraphQuerier["query"]>()
+        .mockResolvedValue(mockResult);
+
+      const rewardsBalance = await creatorClient.getRewardsBalances({
+        account: creatorAccount,
+      });
+
+      expect(rewardsBalance.protocolRewards).toBeGreaterThan(0n);
+      expect(rewardsBalance.secondaryRoyalties.erc20[erc20z]).toBeUndefined();
+
+      // it can withdraw all rewards
+      await simulateAndWriteContractWithRetries({
+        parameters: (
+          await creatorClient.withdrawRewards({
+            account: collectorAccount,
+            withdrawFor: creatorAccount,
+            claimSecondaryRoyalties: true,
+          })
+        ).parameters,
+        publicClient,
+        walletClient,
+      });
+    },
+    30_000,
+  );
 });

package/src/rewards/rewards-client.ts

@@ -1,7 +1,7 @@
 import { IPublicClient } from "src/types";
 import { IRewardsGetter } from "./subgraph-rewards-getter";
 import { Account, Address } from "viem";
-import { getRewardsBalance, withdrawRewards } from "./rewards-queries";
+import { getRewardsBalances, withdrawRewards } from "./rewards-queries";
 
 export type WithdrawRewardsParams = {
   // account is the address that is withdrawing the rewards
@@ -17,23 +17,25 @@ export type GetRewardsBalancesParams = {
   account: Address | Account;
 };
 
+/**
+ * @deprecated Please use functions directly without creating a client.
+ * Example: Instead of `new RewardsClient().withdrawRewards()`, use `withdrawRewards()`
+ * Import the functions you need directly from their respective modules:
+ * import { withdrawRewards, getRewardsBalances } from '@zoralabs/protocol-sdk'
+ */
 export class RewardsClient {
   // Private properties to store chain ID, public client, and rewards getter
-  private readonly chainId: number;
   private readonly publicClient: IPublicClient;
   private readonly rewardsGetter: IRewardsGetter;
 
   constructor({
-    chainId,
     publicClient,
     rewardsGetter,
   }: {
-    chainId: number;
     publicClient: IPublicClient;
     rewardsGetter: IRewardsGetter;
   }) {
     // Initialize the private properties
-    this.chainId = chainId;
     this.publicClient = publicClient;
     this.rewardsGetter = rewardsGetter;
   }
@@ -44,22 +46,19 @@ export class RewardsClient {
     withdrawFor,
     claimSecondaryRoyalties,
   }: WithdrawRewardsParams) {
-    return {
-      parameters: await withdrawRewards({
-        chainId: this.chainId,
-        rewardsGetter: this.rewardsGetter,
-        withdrawFor,
-        claimSecondaryRoyalties,
-        account,
-      }),
-    };
+    return await withdrawRewards({
+      rewardsGetter: this.rewardsGetter,
+      withdrawFor,
+      claimSecondaryRoyalties,
+      account,
+      publicClient: this.publicClient,
+    });
   }
 
   /** Retrieves the rewards balances for a given account */
   async getRewardsBalances(params: GetRewardsBalancesParams) {
-    return getRewardsBalance({
+    return getRewardsBalances({
       account: params.account,
-      chainId: this.chainId,
       publicClient: this.publicClient,
       rewardsGetter: this.rewardsGetter,
     });