@zoralabs/protocol-sdk 0.11.7-COMMENTS.0 → 0.11.8

package/src/mint/mint-queries.ts

@@ -36,13 +36,11 @@ export async function getMint({
   mintGetter,
   premintGetter,
   publicClient,
-  chainId,
 }: {
   params: GetMintParameters;
   mintGetter: IOnchainMintGetter;
   premintGetter: IPremintGetter;
   publicClient: IPublicClient;
-  chainId: number;
 }): Promise<MintableReturn> {
   const { tokenContract } = params;
   if (isOnChainMint(params)) {
@@ -55,7 +53,7 @@ export async function getMint({
       blockTime: blockTime,
     });
 
-    return toMintableReturn(result, chainId);
+    return toMintableReturn(result);
   }
 
   const premint = await premintGetter.get({
@@ -105,19 +103,17 @@ export async function getMintsOfContract({
   mintGetter,
   premintGetter,
   publicClient,
-  chainId,
 }: {
   params: GetMintsOfContractParameters;
   mintGetter: IOnchainMintGetter;
   premintGetter: IPremintGetter;
   publicClient: IPublicClient;
-  chainId: number;
 }): Promise<{ contract?: ContractInfo; tokens: MintableReturn[] }> {
   const onchainMints = (
     await mintGetter.getContractMintable({
       tokenAddress: params.tokenContract,
     })
-  ).map((result) => toMintableReturn(result, chainId));
+  ).map(toMintableReturn);
 
   const offchainMints = await getPremintsOfContractMintable({
     mintGetter,
@@ -274,7 +270,7 @@ function parsePremint({
 }
 
 export const makeOnchainPrepareMint =
-  (result: OnchainSalesConfigAndTokenInfo, chainId: number): PrepareMint =>
+  (result: OnchainSalesConfigAndTokenInfo): PrepareMint =>
   (params: MintParametersBase) => {
     if (!result.salesConfig) {
       throw new Error("No valid sales config found for token");
@@ -284,7 +280,6 @@ export const makeOnchainPrepareMint =
       parameters: makeOnchainMintCall({
         token: result as Concrete<OnchainSalesConfigAndTokenInfo>,
         mintParams: params,
-        chainId,
       }),
       erc20Approval: getRequiredErc20Approvals(params, result.salesConfig),
       costs: parseMintCosts({
@@ -295,10 +290,7 @@ export const makeOnchainPrepareMint =
     };
   };
 
-function toMintableReturn(
-  result: GetMintableReturn,
-  chainId: number,
-): MintableReturn {
+function toMintableReturn(result: GetMintableReturn): MintableReturn {
   const primaryMintActive = result.primaryMintActive;
   if (!primaryMintActive) {
     return {
@@ -314,10 +306,7 @@ function toMintableReturn(
     primaryMintActive,
     primaryMintEnd: result.primaryMintEnd,
     secondaryMarketActive: result.secondaryMarketActive,
-    prepareMint: makeOnchainPrepareMint(
-      result.salesConfigAndTokenInfo,
-      chainId,
-    ),
+    prepareMint: makeOnchainPrepareMint(result.salesConfigAndTokenInfo),
   };
 }
 

package/src/mint/mint-transactions.ts

@@ -11,8 +11,6 @@ import {
   erc20MinterABI,
   zoraCreator1155ImplABI,
   zoraTimedSaleStrategyABI,
-  callerAndCommenterABI,
-  callerAndCommenterAddress,
 } from "@zoralabs/protocol-deployments";
 import { zora721Abi, zora1155LegacyAbi } from "src/constants";
 import {
@@ -34,11 +32,9 @@ import { AllowListEntry } from "src/allow-list/types";
 export function makeOnchainMintCall({
   token,
   mintParams,
-  chainId,
 }: {
   token: Concrete<OnchainSalesConfigAndTokenInfo>;
   mintParams: Omit<MakeMintParametersArgumentsBase, "tokenContract">;
-  chainId: number;
 }): SimulateContractParametersWithAccount {
   if (token.mintType === "721") {
     return makePrepareMint721TokenParams({
@@ -52,7 +48,6 @@ export function makeOnchainMintCall({
     salesConfigAndTokenInfo: token,
     tokenContract: token.contract.address,
     tokenId: token.tokenId!,
-    chainId,
     ...mintParams,
   });
 }
@@ -62,69 +57,6 @@ export type MintableParameters = Pick<
   "contractVersion" | "salesConfig"
 >;
 
-function makeZoraTimedSaleStrategyMintCall({
-  minterAccount,
-  salesConfigAndTokenInfo,
-  mintQuantity,
-  mintTo,
-  tokenContract,
-  tokenId,
-  mintReferral,
-  mintComment,
-  chainId,
-}: {
-  minterAccount: Address | Account;
-  salesConfigAndTokenInfo: Concrete<MintableParameters>;
-  mintQuantity: bigint;
-  mintTo: Address;
-  tokenContract: Address;
-  tokenId: GenericTokenIdTypes;
-  mintReferral?: Address;
-  mintComment?: string;
-  chainId: number;
-}) {
-  // if there is a mint comment, use the caller and commenter
-  if (mintComment && mintComment !== "") {
-    return makeContractParameters({
-      abi: callerAndCommenterABI,
-      address:
-        callerAndCommenterAddress[
-          chainId as keyof typeof callerAndCommenterAddress
-        ],
-      functionName: "timedSaleMintAndComment",
-      account: minterAccount,
-      value:
-        salesConfigAndTokenInfo.salesConfig.mintFeePerQuantity * mintQuantity,
-      args: [
-        mintTo,
-        mintQuantity,
-        tokenContract,
-        tokenId,
-        mintReferral || zeroAddress,
-        mintComment,
-      ],
-    });
-  }
-
-  return makeContractParameters({
-    abi: zoraTimedSaleStrategyABI,
-    functionName: "mint",
-    account: minterAccount,
-    address: salesConfigAndTokenInfo.salesConfig.address,
-    value:
-      salesConfigAndTokenInfo.salesConfig.mintFeePerQuantity * mintQuantity,
-    /* args: mintTo, quantity, collection, tokenId, mintReferral, comment */
-    args: [
-      mintTo,
-      mintQuantity,
-      tokenContract,
-      BigInt(tokenId),
-      mintReferral || zeroAddress,
-      "",
-    ],
-  });
-}
-
 export function makePrepareMint1155TokenParams({
   tokenContract: tokenContract,
   tokenId,
@@ -135,11 +67,9 @@ export function makePrepareMint1155TokenParams({
   mintRecipient,
   quantityToMint,
   allowListEntry,
-  chainId,
 }: {
   salesConfigAndTokenInfo: Concrete<MintableParameters>;
   tokenId: GenericTokenIdTypes;
-  chainId: number;
 } & Pick<
   MakeMintParametersArgumentsBase,
   | "minterAccount"
@@ -171,16 +101,22 @@ export function makePrepareMint1155TokenParams({
   }
 
   if (saleType === "timed") {
-    return makeZoraTimedSaleStrategyMintCall({
-      minterAccount,
-      salesConfigAndTokenInfo,
-      mintQuantity,
-      mintTo,
-      tokenContract,
-      tokenId,
-      mintReferral,
-      mintComment,
-      chainId,
+    return makeContractParameters({
+      abi: zoraTimedSaleStrategyABI,
+      functionName: "mint",
+      account: minterAccount,
+      address: salesConfigAndTokenInfo.salesConfig.address,
+      value:
+        salesConfigAndTokenInfo.salesConfig.mintFeePerQuantity * mintQuantity,
+      /* args: mintTo, quantity, collection, tokenId, mintReferral, comment */
+      args: [
+        mintTo,
+        mintQuantity,
+        tokenContract,
+        BigInt(tokenId),
+        mintReferral || zeroAddress,
+        mintComment || "",
+      ],
     });
   }
 

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

@@ -1,12 +1,12 @@
 import { describe, expect, vi } from "vitest";
 import { encodeAbiParameters, erc20Abi, parseEther } from "viem";
-import { zoraSepolia } from "viem/chains";
+import { zoraSepolia, base } from "viem/chains";
 import {
   forkUrls,
   makeAnvilTest,
   simulateAndWriteContractWithRetries,
 } from "src/anvil";
-import { createCollectorClient } from "src/sdk";
+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,11 +16,32 @@ import {
   zoraCreator1155ImplABI,
 } from "@zoralabs/protocol-deployments";
 import { makeContractParameters } from "src/utils";
-import { mockRewardsQueryResults } from "src/fixtures/rewards-query-results";
 import { setupContractAndToken } from "src/fixtures/contract-setup";
 import { advanceToSaleAndAndLaunchMarket } from "src/fixtures/secondary";
+import { CreatorERC20zQueryResult } from "./subgraph-queries";
 
 describe("rewardsClient", () => {
+  makeAnvilTest({
+    forkBlockNumber: 22375202,
+    forkUrl: forkUrls.baseMainnet,
+    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({
+        account: "0x129F04B140Acc1AA350be2F9f048C178103c62f3",
+      });
+
+      const erc20zKeys = Object.keys(rewardsBalance.secondaryRoyalties.erc20);
+
+      expect(erc20zKeys.length).toBeGreaterThan(0);
+    },
+    20_000,
+  );
   makeAnvilTest({
     forkBlockNumber: 14653556,
     forkUrl: forkUrls.zoraSepolia,
@@ -251,20 +272,31 @@ describe("rewardsClient", () => {
 
       // now we should be able to get rewards balances for these royalties
 
+      const mockResult: CreatorERC20zQueryResult = {
+        zoraCreateTokens: [
+          {
+            salesStrategies: [
+              {
+                zoraTimedMinter: {
+                  secondaryActivated: true,
+                  erc20Z: { id: erc20z },
+                },
+              },
+            ],
+          },
+        ],
+      };
+
       // we need to stub the subgraph return
       rewardsGetter.subgraphQuerier.query = vi
         .fn<ISubgraphQuerier["query"]>()
-        .mockResolvedValue(
-          mockRewardsQueryResults({
-            erc20z: [erc20z],
-          }),
-        );
+        .mockResolvedValue(mockResult);
 
       const rewardsBalance = await creatorClient.getRewardsBalances({
         account: creatorAccount,
       });
 
-      expect(rewardsBalance.secondaryRoyalties.eth).toBeGreaterThan(0);
+      expect(rewardsBalance.protocolRewards).toBeGreaterThan(0n);
       expect(rewardsBalance.secondaryRoyalties.erc20[erc20z]).toBeGreaterThan(
         0,
       );

package/src/rewards/rewards-queries.ts

@@ -77,7 +77,13 @@ export const getRewardsBalance = async ({
   rewardsGetter: IRewardsGetter;
 }): Promise<RewardsBalance> => {
   const address = typeof account === "string" ? account : account.address;
-  const erc20Zs = await rewardsGetter.getErc20ZzForCreator({ address });
+  const erc20ZsAndSecondaryActivated = await rewardsGetter.getErc20ZzForCreator(
+    { address },
+  );
+
+  const validErc20Zs = erc20ZsAndSecondaryActivated
+    .filter(({ secondaryActivated }) => secondaryActivated)
+    .map(({ erc20z }) => erc20z);
 
   // Perform multicall to get protocol rewards balance and unclaimed fees
   const result = await (publicClient as PublicClientWithMulticall).multicall({
@@ -98,7 +104,7 @@ export const getRewardsBalance = async ({
           ],
         abi: erc20ZRoyaltiesABI,
         functionName: "getUnclaimedFeesBatch",
-        args: [erc20Zs],
+        args: [validErc20Zs],
       },
     ],
     multicallAddress: multicall3Address,
@@ -147,9 +153,13 @@ const makeClaimSecondaryRoyaltiesCalls = async ({
   chainId: number;
   rewardsGetter: IRewardsGetter;
 }) => {
-  const erc20z = await rewardsGetter.getErc20ZzForCreator({
-    address: claimFor,
-  });
+  const erc20ZsAndSecondaryActivated = await rewardsGetter.getErc20ZzForCreator(
+    { address: claimFor },
+  );
+
+  const erc20z = erc20ZsAndSecondaryActivated
+    .filter(({ secondaryActivated }) => secondaryActivated)
+    .map(({ erc20z }) => erc20z);
 
   const royaltiesAddress =
     erc20ZRoyaltiesAddress[chainId as keyof typeof erc20ZRoyaltiesAddress];

package/src/rewards/subgraph-queries.ts

@@ -4,7 +4,8 @@ import { Address } from "viem";
 export type RewardsToken = {
   salesStrategies: [
     {
-      zoraTimedMinter: {
+      zoraTimedMinter?: {
+        secondaryActivated: boolean;
         erc20Z: {
           id: Address;
         };
@@ -26,13 +27,14 @@ export function buildCreatorERC20zs({
     query: `
     query ($address: Bytes!) {
       zoraCreateTokens(
-        where: { royalties_: { user: $address }, salesStrategies_: { type: "ZORA_TIMED" } }
+        where: { royalties_: { royaltyRecipient: $address }, salesStrategies_: { type: "ZORA_TIMED" } }
       ) {
         royalties {
           user
         }
         salesStrategies {
           zoraTimedMinter {
+            secondaryActivated
             erc20Z {
               id
             }

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

@@ -4,7 +4,9 @@ import { Address } from "viem";
 import { buildCreatorERC20zs } from "./subgraph-queries";
 
 export interface IRewardsGetter {
-  getErc20ZzForCreator: (params: { address: Address }) => Promise<Address[]>;
+  getErc20ZzForCreator: (params: {
+    address: Address;
+  }) => Promise<{ secondaryActivated: boolean; erc20z: Address }[]>;
 }
 
 export class SubgraphRewardsGetter
@@ -15,19 +17,31 @@ export class SubgraphRewardsGetter
     super(chainId, subgraphQuerier);
   }
 
-  async getErc20ZzForCreator({
-    address,
-  }: {
-    address: Address;
-  }): Promise<Address[]> {
+  async getErc20ZzForCreator({ address }: { address: Address }) {
     const queryResults = await this.querySubgraphWithRetries(
       buildCreatorERC20zs({ address }),
     );
 
-    return (
-      queryResults?.map(
-        (result) => result.salesStrategies[0].zoraTimedMinter.erc20Z.id,
-      ) || []
+    const results = (
+      queryResults?.map((result) => {
+        const timedMinter = result.salesStrategies[0].zoraTimedMinter;
+
+        if (!timedMinter) {
+          return null;
+        }
+
+        return {
+          secondaryActivated: timedMinter.secondaryActivated,
+          erc20z: timedMinter.erc20Z.id,
+        };
+      }) || []
+    ).filter(
+      (
+        idAndActivated,
+      ): idAndActivated is { secondaryActivated: boolean; erc20z: Address } =>
+        !!idAndActivated,
     );
+
+    return results;
   }
 }

package/src/sdk.ts

@@ -116,7 +116,6 @@ export function createCollectorClient(
     publicClient: params.publicClient,
     premintGetter: premintGetterToUse,
     mintGetter: mintGetterToUse,
-    chainId: params.chainId,
   });
   const secondaryClient = new SecondaryClient({
     publicClient: params.publicClient,