@zoralabs/protocol-sdk 0.11.12 → 0.12.1

package/src/rewards/rewards-queries.ts

@@ -14,7 +14,8 @@ import {
   multicall3Address,
   Multicall3Call3,
 } from "src/apis/multicall3";
-
+import { SubgraphRewardsGetter } from "./subgraph-rewards-getter";
+import { SimulateContractParametersWithAccount } from "src/types";
 // Aggregates unclaimed fees and separates ETH from other ERC20 tokens
 function aggregateUnclaimedFees(
   unclaimedFees: readonly {
@@ -65,25 +66,64 @@ type RewardsBalance = {
   };
 };
 
-export const getRewardsBalance = async ({
+const getErc20zsWithPositions = async ({
+  address,
+  publicClient,
+  rewardsGetter,
+}: {
+  address: Address;
+  publicClient: PublicClient;
+  rewardsGetter?: IRewardsGetter;
+}): Promise<Address[]> => {
+  const chainId = publicClient.chain.id;
+  const rewardsGetterOrDefault =
+    rewardsGetter ?? new SubgraphRewardsGetter(chainId);
+
+  const erc20zsForCreator = await rewardsGetterOrDefault.getErc20ZzForCreator({
+    address,
+  });
+
+  const royaltiesAddress =
+    erc20ZRoyaltiesAddress[chainId as keyof typeof erc20ZRoyaltiesAddress];
+
+  const positionsByErc20z = await (
+    publicClient as PublicClientWithMulticall
+  ).multicall({
+    contracts: erc20zsForCreator.map((erc20z) => ({
+      address: royaltiesAddress,
+      abi: erc20ZRoyaltiesABI,
+      functionName: "positionsByErc20z",
+      args: [erc20z],
+    })),
+    multicallAddress: multicall3Address,
+    allowFailure: false,
+  });
+
+  const erc20zsWithPositions = erc20zsForCreator.filter(
+    (_, i) => positionsByErc20z[i] !== 0n,
+  );
+
+  return erc20zsWithPositions;
+};
+
+export const getRewardsBalances = async ({
   account, // The account to check rewards for (Address or Account object)
   publicClient, // The public client for making blockchain queries
-  chainId, // The ID of the blockchain network
   rewardsGetter, // Interface for getting ERC20Z tokens for a creator
 }: {
   account: Account | Address;
   publicClient: PublicClient;
-  chainId: number;
-  rewardsGetter: IRewardsGetter;
+  rewardsGetter?: IRewardsGetter;
 }): Promise<RewardsBalance> => {
+  const chainId = publicClient.chain.id;
   const address = typeof account === "string" ? account : account.address;
-  const erc20ZsAndSecondaryActivated = await rewardsGetter.getErc20ZzForCreator(
-    { address },
-  );
 
-  const validErc20Zs = erc20ZsAndSecondaryActivated
-    .filter(({ secondaryActivated }) => secondaryActivated)
-    .map(({ erc20z }) => erc20z);
+  // get erc20z that have positions in the royalties contract
+  const erc20zsWithPositions = await getErc20zsWithPositions({
+    address,
+    publicClient,
+    rewardsGetter,
+  });
 
   // Perform multicall to get protocol rewards balance and unclaimed fees
   const result = await (publicClient as PublicClientWithMulticall).multicall({
@@ -104,7 +144,7 @@ export const getRewardsBalance = async ({
           ],
         abi: erc20ZRoyaltiesABI,
         functionName: "getUnclaimedFeesBatch",
-        args: [validErc20Zs],
+        args: [erc20zsWithPositions],
       },
     ],
     multicallAddress: multicall3Address,
@@ -148,18 +188,18 @@ const makeClaimSecondaryRoyaltiesCalls = async ({
   claimFor,
   chainId,
   rewardsGetter,
+  publicClient,
 }: {
   claimFor: Address;
   chainId: number;
-  rewardsGetter: IRewardsGetter;
+  rewardsGetter?: IRewardsGetter;
+  publicClient: PublicClient;
 }) => {
-  const erc20ZsAndSecondaryActivated = await rewardsGetter.getErc20ZzForCreator(
-    { address: claimFor },
-  );
-
-  const erc20z = erc20ZsAndSecondaryActivated
-    .filter(({ secondaryActivated }) => secondaryActivated)
-    .map(({ erc20z }) => erc20z);
+  const erc20z = await getErc20zsWithPositions({
+    address: claimFor,
+    publicClient,
+    rewardsGetter,
+  });
 
   const royaltiesAddress =
     erc20ZRoyaltiesAddress[chainId as keyof typeof erc20ZRoyaltiesAddress];
@@ -183,15 +223,18 @@ export async function withdrawSecondaryRoyalties({
   claimFor,
   chainId,
   rewardsGetter,
+  publicClient,
 }: {
   claimFor: Address;
   chainId: number;
-  rewardsGetter: IRewardsGetter;
+  rewardsGetter?: IRewardsGetter;
+  publicClient: PublicClient;
 }) {
   const calls = await makeClaimSecondaryRoyaltiesCalls({
     claimFor,
     chainId,
     rewardsGetter,
+    publicClient,
   });
 
   return makeContractParameters({
@@ -230,34 +273,71 @@ const createMulticallParameters = (
     account,
   });
 
-// Main withdrawRewards function
-export const withdrawRewards = async ({
+// Handle the simple case of protocol rewards only
+const handleProtocolRewardsOnly = ({
+  chainId,
+  withdrawFor,
+  account,
+}: {
+  chainId: number;
+  withdrawFor: Address;
+  account: Address | Account;
+}) => ({
+  ...withdrawProtocolRewards({ chainId, withdrawFor }),
   account,
+});
+
+// Handle both protocol and secondary rewards
+const handleAllRewards = async ({
   withdrawFor,
-  claimSecondaryRoyalties = true,
-  chainId,
+  account,
   rewardsGetter,
+  publicClient,
 }: {
-  account: Address | Account;
   withdrawFor: Address;
-  claimSecondaryRoyalties?: boolean;
-  chainId: number;
-  rewardsGetter: IRewardsGetter;
+  account: Address | Account;
+  rewardsGetter?: IRewardsGetter;
+  publicClient: PublicClient;
 }) => {
-  if (!claimSecondaryRoyalties) {
-    return {
-      ...withdrawProtocolRewards({ chainId, withdrawFor }),
-      account,
-    };
-  }
-
+  const chainId = publicClient.chain.id;
   const protocolRewardsCall = createProtocolRewardsCall(chainId, withdrawFor);
   const secondaryRoyaltiesCalls = await makeClaimSecondaryRoyaltiesCalls({
     chainId,
     claimFor: withdrawFor,
     rewardsGetter,
+    publicClient,
   });
 
   const allCalls = [protocolRewardsCall, ...secondaryRoyaltiesCalls];
   return createMulticallParameters(allCalls, account);
 };
+
+// Main withdrawRewards function now acts as a router
+export const withdrawRewards = async ({
+  account,
+  withdrawFor,
+  claimSecondaryRoyalties = true,
+  rewardsGetter,
+  publicClient,
+}: {
+  account: Address | Account;
+  withdrawFor: Address;
+  claimSecondaryRoyalties?: boolean;
+  rewardsGetter?: IRewardsGetter;
+  publicClient: PublicClient;
+}): Promise<{ parameters: SimulateContractParametersWithAccount }> => {
+  const parameters = claimSecondaryRoyalties
+    ? await handleAllRewards({
+        withdrawFor,
+        account,
+        rewardsGetter,
+        publicClient,
+      })
+    : await handleProtocolRewardsOnly({
+        chainId: publicClient.chain.id,
+        withdrawFor,
+        account,
+      });
+
+  return { parameters };
+};

package/src/rewards/subgraph-queries.ts

@@ -5,7 +5,6 @@ export type RewardsToken = {
   salesStrategies: [
     {
       zoraTimedMinter?: {
-        secondaryActivated: boolean;
         erc20Z: {
           id: Address;
         };
@@ -34,7 +33,6 @@ export function buildCreatorERC20zs({
         }
         salesStrategies {
           zoraTimedMinter {
-            secondaryActivated
             erc20Z {
               id
             }

package/src/rewards/subgraph-rewards-getter.ts

@@ -4,9 +4,7 @@ import { Address } from "viem";
 import { buildCreatorERC20zs } from "./subgraph-queries";
 
 export interface IRewardsGetter {
-  getErc20ZzForCreator: (params: {
-    address: Address;
-  }) => Promise<{ secondaryActivated: boolean; erc20z: Address }[]>;
+  getErc20ZzForCreator: (params: { address: Address }) => Promise<Address[]>;
 }
 
 export class SubgraphRewardsGetter
@@ -30,17 +28,9 @@ export class SubgraphRewardsGetter
           return null;
         }
 
-        return {
-          secondaryActivated: timedMinter.secondaryActivated,
-          erc20z: timedMinter.erc20Z.id,
-        };
+        return timedMinter.erc20Z.id;
       }) || []
-    ).filter(
-      (
-        idAndActivated,
-      ): idAndActivated is { secondaryActivated: boolean; erc20z: Address } =>
-        !!idAndActivated,
-    );
+    ).filter((id): id is Address => !!id);
 
     return results;
   }

package/src/sdk.ts

@@ -2,7 +2,7 @@ import {
   PremintClient,
   getDataFromPremintReceipt,
 } from "./premint/premint-client";
-import { Create1155Client } from "./create/1155-create-helper";
+import { Create1155Client } from "./create/create-client";
 import { MintClient } from "./mint/mint-client";
 import { ClientConfig } from "./utils";
 import { IPremintAPI, PremintAPIClient } from "./premint/premint-api-client";
@@ -49,7 +49,10 @@ export type CreatorClientConfig = ClientConfig & {
 };
 
 /**
- * Builds the sdk for creating/managing 1155 contracts and tokens
+ * @deprecated Please use functions directly without creating a client.
+ * Example: Instead of `createCreatorClient().create1155()`, use `create1155()`
+ * Import the functions you need directly from their respective modules:
+ * import { create1155 } from '@zoralabs/protocol-sdk'
  *
  * @param clientConfig - Configuration for the client {@link CreatorClientConfig}
  * @returns CreatorClient {@link CreatorClient}
@@ -65,7 +68,6 @@ export function createCreatorClient(
   });
 
   const create1155CreatorClient = new Create1155Client({
-    chainId: clientConfig.chainId,
     publicClient: clientConfig.publicClient,
     contractGetter:
       clientConfig.contractGetter ||
@@ -73,7 +75,6 @@ export function createCreatorClient(
   });
 
   const rewardsClient = new RewardsClient({
-    chainId: clientConfig.chainId,
     publicClient: clientConfig.publicClient,
     rewardsGetter:
       clientConfig.rewardsGetter ||
@@ -100,7 +101,10 @@ export type CollectorClientConfig = ClientConfig & {
 };
 
 /**
- * Builds the sdk for collecting Premints, 1155, and 721 tokens.
+ * @deprecated Please use functions directly without creating a client.
+ * Example: Instead of `createCollectorClient().mint()`, use `mint()`
+ * Import the functions you need directly from their respective modules:
+ * import { mint } from '@zoralabs/protocol-sdk'
  *
  * @param clientConfig - Configuration for the client {@link CollectorClientConfig}
  * @returns CollectorClient {@link CollectorClient}
@@ -116,11 +120,9 @@ export function createCollectorClient(
     publicClient: params.publicClient,
     premintGetter: premintGetterToUse,
     mintGetter: mintGetterToUse,
-    chainId: params.chainId,
   });
   const secondaryClient = new SecondaryClient({
     publicClient: params.publicClient,
-    chainId: params.chainId,
   });
 
   return {

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

@@ -3,7 +3,6 @@ import { parseEther, Address, parseEventLogs } from "viem";
 import { zoraSepolia } from "viem/chains";
 import { forkUrls, makeAnvilTest } from "src/anvil";
 import { simulateAndWriteContractWithRetries } from "src/test-utils";
-import { createCollectorClient } from "src/sdk";
 import {
   zoraCreator1155ImplABI,
   commentsABI,
@@ -14,12 +13,18 @@ import {
   sparkValue,
 } from "@zoralabs/protocol-deployments";
 import { SubgraphMintGetter } from "src/mint/subgraph-mint-getter";
-import { ERROR_SECONDARY_NOT_STARTED } from "./secondary-client";
+import {
+  buy1155OnSecondary,
+  ERROR_SECONDARY_NOT_STARTED,
+  sell1155OnSecondary,
+} from "./secondary-client";
 import { ISubgraphQuerier } from "src/apis/subgraph-querier";
 import { mockTimedSaleStrategyTokenQueryResult } from "src/fixtures/mint-query-results";
 import { new1155ContractVersion } from "src/create/contract-setup";
 import { advanceToSaleAndAndLaunchMarket } from "src/fixtures/secondary";
 import { randomNonce } from "src/test-utils";
+import { getSecondaryInfo } from "./utils";
+import { mint } from "src/mint/mint-client";
 
 describe("secondary", () => {
   makeAnvilTest({
@@ -28,9 +33,7 @@ describe("secondary", () => {
     anvilChainId: zoraSepolia.id,
   })(
     "it returns an error when the market is not launched",
-    async ({
-      viemClients: { publicClient, chain, walletClient, testClient },
-    }) => {
+    async ({ viemClients: { publicClient, walletClient, testClient } }) => {
       const collectorAccount = (await walletClient.getAddresses()!)[1]!;
 
       const contractAddress: Address =
@@ -41,14 +44,10 @@ describe("secondary", () => {
         value: parseEther("100"),
       });
 
-      const collectorClient = createCollectorClient({
-        chainId: chain.id,
-        publicClient,
-      });
-
-      const secondaryInfo = await collectorClient.getSecondaryInfo({
+      const secondaryInfo = await getSecondaryInfo({
         contract: contractAddress,
         tokenId: newTokenId,
+        publicClient,
       });
 
       expect(secondaryInfo).toBeDefined();
@@ -56,11 +55,12 @@ describe("secondary", () => {
       expect(secondaryInfo!.minimumMintsForCountdown).toBe(1111n);
       expect(secondaryInfo!.secondaryActivated).toBe(false);
 
-      const buyResult = await collectorClient.buy1155OnSecondary({
+      const buyResult = await buy1155OnSecondary({
         account: collectorAccount,
         quantity: 100n,
         contract: contractAddress,
         tokenId: newTokenId,
+        publicClient,
       });
 
       expect(buyResult.error).toEqual(ERROR_SECONDARY_NOT_STARTED);
@@ -103,15 +103,10 @@ describe("secondary", () => {
           }),
         });
 
-      const collectorClient = createCollectorClient({
-        chainId: chain.id,
-        publicClient,
-        mintGetter,
-      });
-
-      const secondaryInfo = await collectorClient.getSecondaryInfo({
+      const secondaryInfo = await getSecondaryInfo({
         contract: contractAddress,
         tokenId: newTokenId,
+        publicClient,
       });
 
       expect(secondaryInfo).toBeDefined();
@@ -124,12 +119,14 @@ describe("secondary", () => {
         secondaryInfo!.mintCount -
         1n;
 
-      const { parameters: collectParameters } = await collectorClient.mint({
+      const { parameters: collectParameters } = await mint({
         minterAccount: collectorAccount,
         mintType: "1155",
         quantityToMint: quantityToMintFirst,
         tokenId: newTokenId,
         tokenContract: contractAddress,
+        publicClient,
+        mintGetter,
       });
 
       await simulateAndWriteContractWithRetries({
@@ -139,20 +136,23 @@ describe("secondary", () => {
       });
 
       // make sure that there is no sale end
-      let saleEnd = (await collectorClient.getSecondaryInfo({
+      let saleEnd = (await getSecondaryInfo({
         contract: contractAddress,
         tokenId: newTokenId,
+        publicClient,
       }))!.saleEnd;
 
       expect(saleEnd).toBeUndefined();
 
       // mint 1 more - this should cause the countdown to start
-      const { parameters: collectMoreParameters } = await collectorClient.mint({
+      const { parameters: collectMoreParameters } = await mint({
         minterAccount: collectorAccount,
         mintType: "1155",
         quantityToMint: 1n,
         tokenId: newTokenId,
         tokenContract: contractAddress,
+        publicClient,
+        mintGetter,
       });
 
       await simulateAndWriteContractWithRetries({
@@ -162,9 +162,10 @@ describe("secondary", () => {
       });
 
       // now there should be a sale end
-      saleEnd = (await collectorClient.getSecondaryInfo({
+      saleEnd = (await getSecondaryInfo({
         contract: contractAddress,
         tokenId: newTokenId,
+        publicClient,
       }))!.saleEnd;
 
       expect(saleEnd).toBeDefined();
@@ -175,8 +176,6 @@ describe("secondary", () => {
         testClient,
         publicClient,
         walletClient,
-        collectorClient,
-        chainId: chain.id,
         account: collectorAccount,
       });
 
@@ -190,11 +189,12 @@ describe("secondary", () => {
       // now get the price ot buy on secondary
       const quantityToBuy = 10n;
 
-      const buyResult = await collectorClient.buy1155OnSecondary({
+      const buyResult = await buy1155OnSecondary({
         account: collectorAccount,
         quantity: quantityToBuy,
         contract: contractAddress,
         tokenId: newTokenId,
+        publicClient,
       });
 
       expect(buyResult.error).toBeUndefined();
@@ -229,11 +229,12 @@ describe("secondary", () => {
       // now sell 10_000n tokens
       const quantityToSell = 100n;
 
-      const sellResult = await collectorClient.sell1155OnSecondary({
+      const sellResult = await sell1155OnSecondary({
         account: collectorAccount,
         quantity: quantityToSell,
         contract: contractAddress,
         tokenId: newTokenId,
+        publicClient,
       });
 
       expect(sellResult.error).toBeUndefined();
@@ -300,27 +301,24 @@ describe("secondary", () => {
           }),
         });
 
-      const collectorClient = createCollectorClient({
-        chainId: chain.id,
-        publicClient,
-        mintGetter,
-      });
-
-      const secondaryInfo = await collectorClient.getSecondaryInfo({
+      const secondaryInfo = await getSecondaryInfo({
         contract: contractAddress,
         tokenId: newTokenId,
+        publicClient,
       });
 
       // mint enough to start the countdown
       const quantityToMint =
         secondaryInfo!.minimumMintsForCountdown! - secondaryInfo!.mintCount;
 
-      const { parameters: collectParameters } = await collectorClient.mint({
+      const { parameters: collectParameters } = await mint({
         minterAccount: collectorAccount,
         mintType: "1155",
         quantityToMint: quantityToMint,
         tokenId: newTokenId,
         tokenContract: contractAddress,
+        publicClient,
+        mintGetter,
       });
 
       await simulateAndWriteContractWithRetries({
@@ -335,17 +333,16 @@ describe("secondary", () => {
         testClient,
         publicClient,
         walletClient,
-        collectorClient,
-        chainId: chain.id,
         account: collectorAccount,
       });
 
-      const buyResult = await collectorClient.buy1155OnSecondary({
+      const buyResult = await buy1155OnSecondary({
         account: collectorAccount,
         quantity: 5n,
         contract: contractAddress,
         tokenId: newTokenId,
         comment: "test comment",
+        publicClient,
       });
 
       const receipt = await simulateAndWriteContractWithRetries({
@@ -375,12 +372,13 @@ describe("secondary", () => {
       expect(boughtAndCommentedEvent[0]!.args.swapDirection).toBe(0);
 
       // PERMIT BUY TEST
-      const buyResultASecondTime = await collectorClient.buy1155OnSecondary({
+      const buyResultASecondTime = await buy1155OnSecondary({
         account: collectorAccount,
         quantity: 5n,
         contract: contractAddress,
         tokenId: newTokenId,
         comment: "test comment",
+        publicClient,
       });
 
       const valueToSend = (buyResultASecondTime.price!.wei.total * 105n) / 100n;
@@ -431,11 +429,12 @@ describe("secondary", () => {
       // now PERMIT SELL ON SECONDARY TEST
       const quantityToSell = 3n;
 
-      const sellResult = await collectorClient.sell1155OnSecondary({
+      const sellResult = await sell1155OnSecondary({
         account: collectorAccount,
         quantity: quantityToSell,
         contract: contractAddress,
         tokenId: newTokenId,
+        publicClient,
       });
 
       expect(sellResult.error).toBeUndefined();