@zoralabs/protocol-sdk 0.9.6 → 0.10.0

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,
+      ) || []
+    );
+  }
+}

package/src/sdk.ts

@@ -12,6 +12,11 @@ import {
   IContractGetter,
   SubgraphContractGetter,
 } from "./create/contract-getter";
+import { RewardsClient } from "./rewards/rewards-client";
+import {
+  IRewardsGetter,
+  SubgraphRewardsGetter,
+} from "./rewards/subgraph-rewards-getter";
 
 export type CreatorClient = {
   createPremint: PremintClient["createPremint"];
@@ -19,6 +24,8 @@ export type CreatorClient = {
   deletePremint: PremintClient["deletePremint"];
   create1155: Create1155Client["createNew1155"];
   create1155OnExistingContract: Create1155Client["createNew1155OnExistingContract"];
+  withdrawRewards: RewardsClient["withdrawRewards"];
+  getRewardsBalances: RewardsClient["getRewardsBalances"];
 };
 
 export type CollectorClient = {
@@ -34,6 +41,7 @@ export type CreatorClientConfig = ClientConfig & {
   /** API for submitting and getting premints.  Defaults to the Zora Premint API */
   premintApi?: IPremintAPI;
   contractGetter?: IContractGetter;
+  rewardsGetter?: IRewardsGetter;
 };
 
 /**
@@ -60,6 +68,14 @@ export function createCreatorClient(
       new SubgraphContractGetter(clientConfig.chainId),
   });
 
+  const rewardsClient = new RewardsClient({
+    chainId: clientConfig.chainId,
+    publicClient: clientConfig.publicClient,
+    rewardsGetter:
+      clientConfig.rewardsGetter ||
+      new SubgraphRewardsGetter(clientConfig.chainId),
+  });
+
   return {
     createPremint: (p) => premintClient.createPremint(p),
     updatePremint: (p) => premintClient.updatePremint(p),
@@ -67,6 +83,8 @@ export function createCreatorClient(
     create1155: (p) => create1155CreatorClient.createNew1155(p),
     create1155OnExistingContract: (p) =>
       create1155CreatorClient.createNew1155OnExistingContract(p),
+    getRewardsBalances: (p) => rewardsClient.getRewardsBalances(p),
+    withdrawRewards: (p) => rewardsClient.withdrawRewards(p),
   };
 }