@zoralabs/protocol-sdk 0.9.6 → 0.11.0

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

@@ -0,0 +1,310 @@
+import { describe, expect, vi } from "vitest";
+import { encodeAbiParameters, erc20Abi, parseEther } from "viem";
+import { zoraSepolia } from "viem/chains";
+import {
+  forkUrls,
+  makeAnvilTest,
+  simulateAndWriteContractWithRetries,
+} from "src/anvil";
+import { createCollectorClient } 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";
+import {
+  secondarySwapABI,
+  secondarySwapAddress,
+  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/secondary/secondary-client.test";
+
+describe("rewardsClient", () => {
+  makeAnvilTest({
+    forkBlockNumber: 13914833,
+    forkUrl: forkUrls.zoraSepolia,
+    anvilChainId: zoraSepolia.id,
+  })(
+    "it can view and withdraw rewards 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 } =
+        await setupContractAndToken({
+          chain,
+          publicClient,
+          creatorAccount,
+          walletClient,
+        });
+
+      await testClient.setBalance({
+        address: collectorAccount,
+        value: parseEther("10"),
+      });
+
+      const quantityToMint = 10n;
+
+      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 collectorClient = createCollectorClient({
+        chainId: chain.id,
+        publicClient,
+        mintGetter,
+      });
+
+      const { parameters: collectParameters } = await collectorClient.mint({
+        minterAccount: collectorAccount,
+        mintType: "1155",
+        quantityToMint,
+        tokenId: newTokenId,
+        tokenContract: contractAddress,
+      });
+
+      await simulateAndWriteContractWithRetries({
+        parameters: collectParameters,
+        walletClient,
+        publicClient,
+      });
+
+      const rewardsBalance = await creatorClient.getRewardsBalances({
+        account: creatorAccount,
+      });
+
+      // creator reward is
+      const expectedRewardsBalance = quantityToMint * parseEther("0.0000555");
+
+      expect(rewardsBalance.protocolRewards).toEqual(expectedRewardsBalance);
+
+      const beforeBalance = await publicClient.getBalance({
+        address: creatorAccount,
+      });
+
+      const { parameters: withdrawParams } =
+        await creatorClient.withdrawRewards({
+          account: collectorAccount,
+          withdrawFor: creatorAccount,
+          claimSecondaryRoyalties: false,
+        });
+
+      await simulateAndWriteContractWithRetries({
+        parameters: withdrawParams,
+        walletClient,
+        publicClient,
+      });
+
+      const afterBalance = await publicClient.getBalance({
+        address: creatorAccount,
+      });
+
+      expect(afterBalance - beforeBalance).toBe(expectedRewardsBalance);
+    },
+    30_000,
+  );
+  makeAnvilTest({
+    forkBlockNumber: 13914833,
+    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 = 10_000n;
+
+      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 collectorClient = createCollectorClient({
+        chainId: chain.id,
+        publicClient,
+        mintGetter,
+      });
+
+      const { parameters: collectParameters } = await collectorClient.mint({
+        minterAccount: collectorAccount,
+        mintType: "1155",
+        quantityToMint,
+        tokenId: newTokenId,
+        tokenContract: contractAddress,
+      });
+
+      await simulateAndWriteContractWithRetries({
+        parameters: collectParameters,
+        walletClient,
+        publicClient,
+      });
+
+      await advanceToSaleAndAndLaunchMarket({
+        chainId: chain.id,
+        account: collectorAccount,
+        publicClient,
+        walletClient,
+        collectorClient,
+        testClient,
+        contractAddress,
+        tokenId: newTokenId,
+      });
+
+      const erc20z = (await collectorClient.getSecondaryInfo({
+        contract: contractAddress,
+        tokenId: newTokenId,
+      }))!.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
+
+      // we need to stub the subgraph return
+      rewardsGetter.subgraphQuerier.query = vi
+        .fn<ISubgraphQuerier["query"]>()
+        .mockResolvedValue(
+          mockRewardsQueryResults({
+            erc20z: [erc20z],
+          }),
+        );
+
+      const rewardsBalance = await creatorClient.getRewardsBalances({
+        account: creatorAccount,
+      });
+
+      expect(rewardsBalance.secondaryRoyalties.eth).toBeGreaterThan(0);
+      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,
+  );
+});

package/src/rewards/rewards-client.ts

@@ -0,0 +1,67 @@
+import { IPublicClient } from "src/types";
+import { IRewardsGetter } from "./subgraph-rewards-getter";
+import { Account, Address } from "viem";
+import { getRewardsBalance, withdrawRewards } from "./rewards-queries";
+
+export type WithdrawRewardsParams = {
+  // account is the address that is withdrawing the rewards
+  account: Address | Account;
+  // withdrawFor is the address that is receiving the rewards
+  withdrawFor: Address;
+  // claimSecondaryRoyalties is an optional flag to claim secondary royalties. Defaults to `true`.
+  claimSecondaryRoyalties?: boolean;
+};
+
+export type GetRewardsBalancesParams = {
+  // The address or account to get the rewards balance for
+  account: Address | Account;
+};
+
+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;
+  }
+
+  /** Withdraws rewards for a given account */
+  async withdrawRewards({
+    account,
+    withdrawFor,
+    claimSecondaryRoyalties,
+  }: WithdrawRewardsParams) {
+    return {
+      parameters: await withdrawRewards({
+        chainId: this.chainId,
+        rewardsGetter: this.rewardsGetter,
+        withdrawFor,
+        claimSecondaryRoyalties,
+        account,
+      }),
+    };
+  }
+
+  /** Retrieves the rewards balances for a given account */
+  async getRewardsBalances(params: GetRewardsBalancesParams) {
+    return getRewardsBalance({
+      account: params.account,
+      chainId: this.chainId,
+      publicClient: this.publicClient,
+      rewardsGetter: this.rewardsGetter,
+    });
+  }
+}

package/src/rewards/rewards-queries.ts

@@ -0,0 +1,253 @@
+import {
+  protocolRewardsABI,
+  protocolRewardsAddress,
+  erc20ZRoyaltiesABI,
+  erc20ZRoyaltiesAddress,
+  wethAddress,
+} from "@zoralabs/protocol-deployments";
+import { makeContractParameters, PublicClient } from "src/utils";
+import { PublicClient as PublicClientWithMulticall } from "viem";
+import { Account, Address, encodeFunctionData, parseAbi } from "viem";
+import { IRewardsGetter } from "./subgraph-rewards-getter";
+import {
+  multicall3Abi,
+  multicall3Address,
+  Multicall3Call3,
+} from "src/apis/multicall3";
+
+// Aggregates unclaimed fees and separates ETH from other ERC20 tokens
+function aggregateUnclaimedFees(
+  unclaimedFees: readonly {
+    token0: `0x${string}`;
+    token1: `0x${string}`;
+    token0Amount: bigint;
+    token1Amount: bigint;
+  }[],
+  wethAddress: Address,
+) {
+  let ethBalance = 0n;
+  // Aggregate unclaimed fees by token address
+  const unclaimedFeesAggregate = unclaimedFees.reduce(
+    (acc, fee) => {
+      const addFee = (token: `0x${string}`, amount: bigint) => {
+        if (token === wethAddress) {
+          ethBalance += amount;
+        } else if (acc[token]) {
+          acc[token] += amount;
+        } else {
+          acc[token] = amount;
+        }
+      };
+      // Apply 75% fee to each token amount
+      addFee(fee.token0, (fee.token0Amount * 75n) / 100n);
+      addFee(fee.token1, (fee.token1Amount * 75n) / 100n);
+      return acc;
+    },
+    {} as Record<string, bigint>,
+  );
+
+  return {
+    eth: (ethBalance * 75n) / 100n, // Apply 75% fee to ETH balance
+    erc20: unclaimedFeesAggregate,
+  };
+}
+
+// Define the return type for getRewardsBalance
+type RewardsBalance = {
+  // The total balance, in eth of protocol rewards
+  protocolRewards: bigint;
+  // The secondary royalties balance.
+  secondaryRoyalties: {
+    // The balance, in eth, of secondary royalties
+    eth: bigint;
+    // The balance, aggregated by erc20 address, of secondary royalties
+    erc20: Record<Address, bigint>;
+  };
+};
+
+export const getRewardsBalance = 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;
+}): Promise<RewardsBalance> => {
+  const address = typeof account === "string" ? account : account.address;
+  const erc20Zs = await rewardsGetter.getErc20ZzForCreator({ address });
+
+  // Perform multicall to get protocol rewards balance and unclaimed fees
+  const result = await (publicClient as PublicClientWithMulticall).multicall({
+    contracts: [
+      {
+        address:
+          protocolRewardsAddress[
+            chainId as keyof typeof protocolRewardsAddress
+          ],
+        abi: protocolRewardsABI,
+        functionName: "balanceOf",
+        args: [address],
+      },
+      {
+        address:
+          erc20ZRoyaltiesAddress[
+            chainId as keyof typeof erc20ZRoyaltiesAddress
+          ],
+        abi: erc20ZRoyaltiesABI,
+        functionName: "getUnclaimedFeesBatch",
+        args: [erc20Zs],
+      },
+    ],
+    multicallAddress: multicall3Address,
+    allowFailure: false,
+  });
+
+  const protocolRewardsBalance = result[0];
+
+  const wethAddressForChain = wethAddress[chainId as keyof typeof wethAddress];
+
+  // Aggregate unclaimed fees
+  const unclaimedFeesAggregate = aggregateUnclaimedFees(
+    result[1],
+    wethAddressForChain,
+  );
+
+  return {
+    protocolRewards: protocolRewardsBalance,
+    secondaryRoyalties: unclaimedFeesAggregate,
+  };
+};
+
+export const withdrawProtocolRewards = ({
+  withdrawFor,
+  chainId,
+}: {
+  // Account to execute the transaction
+  withdrawFor: Address;
+  chainId: number;
+}) => {
+  return makeContractParameters({
+    abi: protocolRewardsABI,
+    functionName: "withdrawFor",
+    address:
+      protocolRewardsAddress[chainId as keyof typeof protocolRewardsAddress],
+    args: [withdrawFor, 0n],
+  });
+};
+
+const makeClaimSecondaryRoyaltiesCalls = async ({
+  claimFor,
+  chainId,
+  rewardsGetter,
+}: {
+  claimFor: Address;
+  chainId: number;
+  rewardsGetter: IRewardsGetter;
+}) => {
+  const erc20z = await rewardsGetter.getErc20ZzForCreator({
+    address: claimFor,
+  });
+
+  const royaltiesAddress =
+    erc20ZRoyaltiesAddress[chainId as keyof typeof erc20ZRoyaltiesAddress];
+
+  if (erc20z.length === 0) {
+    return [];
+  }
+
+  return erc20z.map((erc20z) => ({
+    target: royaltiesAddress,
+    callData: encodeFunctionData({
+      abi: erc20ZRoyaltiesABI,
+      functionName: "claimFor",
+      args: [erc20z],
+    }),
+    allowFailure: false,
+  }));
+};
+
+export async function withdrawSecondaryRoyalties({
+  claimFor,
+  chainId,
+  rewardsGetter,
+}: {
+  claimFor: Address;
+  chainId: number;
+  rewardsGetter: IRewardsGetter;
+}) {
+  const calls = await makeClaimSecondaryRoyaltiesCalls({
+    claimFor,
+    chainId,
+    rewardsGetter,
+  });
+
+  return makeContractParameters({
+    abi: multicall3Abi,
+    functionName: "aggregate3",
+    address: multicall3Address,
+    args: [calls],
+  });
+}
+
+// Extract protocol rewards withdrawal call creation
+const createProtocolRewardsCall = (
+  chainId: number,
+  withdrawFor: Address,
+): Multicall3Call3 => ({
+  target:
+    protocolRewardsAddress[chainId as keyof typeof protocolRewardsAddress],
+  callData: encodeFunctionData({
+    abi: protocolRewardsABI,
+    functionName: "withdrawFor",
+    args: [withdrawFor, 0n],
+  }),
+  allowFailure: false,
+});
+
+// Extract multicall parameters creation
+const createMulticallParameters = (
+  calls: Multicall3Call3[],
+  account: Address | Account,
+) =>
+  makeContractParameters({
+    abi: parseAbi(multicall3Abi),
+    functionName: "aggregate3",
+    address: multicall3Address,
+    args: [calls],
+    account,
+  });
+
+// Main withdrawRewards function
+export const withdrawRewards = async ({
+  account,
+  withdrawFor,
+  claimSecondaryRoyalties = true,
+  chainId,
+  rewardsGetter,
+}: {
+  account: Address | Account;
+  withdrawFor: Address;
+  claimSecondaryRoyalties?: boolean;
+  chainId: number;
+  rewardsGetter: IRewardsGetter;
+}) => {
+  if (!claimSecondaryRoyalties) {
+    return {
+      ...withdrawProtocolRewards({ chainId, withdrawFor }),
+      account,
+    };
+  }
+
+  const protocolRewardsCall = createProtocolRewardsCall(chainId, withdrawFor);
+  const secondaryRoyaltiesCalls = await makeClaimSecondaryRoyaltiesCalls({
+    chainId,
+    claimFor: withdrawFor,
+    rewardsGetter,
+  });
+
+  const allCalls = [protocolRewardsCall, ...secondaryRoyaltiesCalls];
+  return createMulticallParameters(allCalls, account);
+};

package/src/rewards/subgraph-queries.ts

@@ -0,0 +1,49 @@
+import { ISubgraphQuery } from "src/apis/subgraph-querier";
+import { Address } from "viem";
+
+export type RewardsToken = {
+  salesStrategies: [
+    {
+      zoraTimedMinter: {
+        erc20Z: {
+          id: Address;
+        };
+      };
+    },
+  ];
+};
+
+export type CreatorERC20zQueryResult = {
+  zoraCreateTokens: RewardsToken[];
+};
+
+export function buildCreatorERC20zs({
+  address,
+}: {
+  address: Address;
+}): ISubgraphQuery<CreatorERC20zQueryResult["zoraCreateTokens"]> {
+  return {
+    query: `
+    query ($address: Bytes!) {
+      zoraCreateTokens(
+        where: { royalties_: { user: $address }, salesStrategies_: { type: "ZORA_TIMED" } }
+      ) {
+        royalties {
+          user
+        }
+        salesStrategies {
+          zoraTimedMinter {
+            erc20Z {
+              id
+            }
+          }
+        }
+      }
+    }
+    `,
+    variables: { address },
+    parseResponseData: (responseData: any | undefined) => {
+      return responseData?.zoraCreateTokens;
+    },
+  };
+}

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

@@ -0,0 +1,33 @@
+import { SubgraphGetter } from "src/apis/subgraph-getter";
+import { ISubgraphQuerier } from "src/apis/subgraph-querier";
+import { Address } from "viem";
+import { buildCreatorERC20zs } from "./subgraph-queries";
+
+export interface IRewardsGetter {
+  getErc20ZzForCreator: (params: { address: Address }) => Promise<Address[]>;
+}
+
+export class SubgraphRewardsGetter
+  extends SubgraphGetter
+  implements IRewardsGetter
+{
+  constructor(chainId: number, subgraphQuerier?: ISubgraphQuerier) {
+    super(chainId, subgraphQuerier);
+  }
+
+  async getErc20ZzForCreator({
+    address,
+  }: {
+    address: Address;
+  }): Promise<Address[]> {
+    const queryResults = await this.querySubgraphWithRetries(
+      buildCreatorERC20zs({ address }),
+    );
+
+    return (
+      queryResults?.map(
+        (result) => result.salesStrategies[0].zoraTimedMinter.erc20Z.id,
+      ) || []
+    );
+  }
+}