@zoralabs/protocol-sdk 0.9.5 → 0.10.0

package/dist/index.cjs

@@ -2551,136 +2551,6 @@ var toContractCreationConfigOrAddress = ({
 // src/premint/premint-client.ts
 var import_protocol_deployments4 = require("@zoralabs/protocol-deployments");
 
-// src/retries.ts
-async function wait(delayMs) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, delayMs);
-  });
-}
-var retryInternal = async ({
-  tryFn,
-  maxTries = 3,
-  atTry,
-  linearBackoffMS = 200,
-  shouldRetryOnError = () => true
-}) => {
-  try {
-    return await tryFn();
-  } catch (err) {
-    if (shouldRetryOnError(err)) {
-      if (atTry <= maxTries) {
-        await wait(atTry * linearBackoffMS);
-        return await retryInternal({
-          tryFn,
-          maxTries,
-          atTry: atTry + 1,
-          linearBackoffMS,
-          shouldRetryOnError
-        });
-      }
-    }
-    throw err;
-  }
-};
-var retriesGeneric = async (params) => {
-  return retryInternal({
-    ...params,
-    atTry: 1
-  });
-};
-
-// src/apis/http-api-base.ts
-var BadResponseError = class extends Error {
-  constructor(message, status, json) {
-    super(message);
-    this.name = "BadResponseError";
-    this.status = status;
-    this.json = json;
-  }
-};
-var get = async (url) => {
-  const response = await fetch(url, { method: "GET" });
-  if (response.status !== 200) {
-    let json;
-    try {
-      json = await response.json();
-    } catch (e) {
-    }
-    throw new BadResponseError(
-      `Invalid response, status ${response.status}`,
-      response.status,
-      json
-    );
-  }
-  return await response.json();
-};
-var post = async (url, data) => {
-  const controller = new AbortController();
-  const { signal } = controller;
-  const timeout = 30 * 60 * 1e3;
-  const timeoutId = setTimeout(() => controller.abort(), timeout);
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      accept: "application/json"
-    },
-    body: JSON.stringify(data),
-    signal
-  });
-  clearTimeout(timeoutId);
-  if (response.status !== 200) {
-    let json;
-    try {
-      json = await response.json();
-    } catch (e) {
-    }
-    throw new BadResponseError(
-      `Bad response: ${response.status}`,
-      response.status,
-      json
-    );
-  }
-  return await response.json();
-};
-var defaultShouldRetry = (err) => {
-  return err instanceof BadResponseError && err.status >= 500;
-};
-var retries = async (tryFn, maxTries = 3, linearBackoffMS = 200, shouldRetry = defaultShouldRetry) => {
-  return retriesGeneric({
-    tryFn,
-    maxTries,
-    linearBackoffMS,
-    shouldRetryOnError: shouldRetry
-  });
-};
-var httpClient = {
-  get,
-  post,
-  retries
-};
-
-// src/apis/subgraph-querier.ts
-var SubgraphQuerier = class {
-  constructor(httpClient2) {
-    this.httpClient = httpClient2;
-  }
-  async query({
-    subgraphUrl,
-    query,
-    variables
-  }) {
-    const { retries: retries2, post: post2 } = this.httpClient;
-    const result = await retries2(async () => {
-      return await post2(subgraphUrl, {
-        query,
-        variables
-      });
-    });
-    return result?.data;
-  }
-};
-
 // src/mint/subgraph-queries.ts
 var NFT_SALE_STRATEGY_FRAGMENT = `
 fragment SaleStrategy on SalesStrategyConfig {
@@ -2807,6 +2677,156 @@ function buildPremintsOfContractQuery({
   };
 }
 
+// src/apis/subgraph-querier.ts
+var SubgraphQuerier = class {
+  constructor(httpClient2) {
+    this.httpClient = httpClient2;
+  }
+  async query({
+    subgraphUrl,
+    query,
+    variables
+  }) {
+    const { retries: retries2, post: post2 } = this.httpClient;
+    const result = await retries2(async () => {
+      return await post2(subgraphUrl, {
+        query,
+        variables
+      });
+    });
+    return result?.data;
+  }
+};
+
+// src/retries.ts
+async function wait(delayMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+}
+var retryInternal = async ({
+  tryFn,
+  maxTries = 3,
+  atTry,
+  linearBackoffMS = 200,
+  shouldRetryOnError = () => true
+}) => {
+  try {
+    return await tryFn();
+  } catch (err) {
+    if (shouldRetryOnError(err)) {
+      if (atTry <= maxTries) {
+        await wait(atTry * linearBackoffMS);
+        return await retryInternal({
+          tryFn,
+          maxTries,
+          atTry: atTry + 1,
+          linearBackoffMS,
+          shouldRetryOnError
+        });
+      }
+    }
+    throw err;
+  }
+};
+var retriesGeneric = async (params) => {
+  return retryInternal({
+    ...params,
+    atTry: 1
+  });
+};
+
+// src/apis/http-api-base.ts
+var BadResponseError = class extends Error {
+  constructor(message, status, json) {
+    super(message);
+    this.name = "BadResponseError";
+    this.status = status;
+    this.json = json;
+  }
+};
+var get = async (url) => {
+  const response = await fetch(url, { method: "GET" });
+  if (response.status !== 200) {
+    let json;
+    try {
+      json = await response.json();
+    } catch (e) {
+    }
+    throw new BadResponseError(
+      `Invalid response, status ${response.status}`,
+      response.status,
+      json
+    );
+  }
+  return await response.json();
+};
+var post = async (url, data) => {
+  const controller = new AbortController();
+  const { signal } = controller;
+  const timeout = 30 * 60 * 1e3;
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json"
+    },
+    body: JSON.stringify(data),
+    signal
+  });
+  clearTimeout(timeoutId);
+  if (response.status !== 200) {
+    let json;
+    try {
+      json = await response.json();
+    } catch (e) {
+    }
+    throw new BadResponseError(
+      `Bad response: ${response.status}`,
+      response.status,
+      json
+    );
+  }
+  return await response.json();
+};
+var defaultShouldRetry = (err) => {
+  return err instanceof BadResponseError && err.status >= 500;
+};
+var retries = async (tryFn, maxTries = 3, linearBackoffMS = 200, shouldRetry = defaultShouldRetry) => {
+  return retriesGeneric({
+    tryFn,
+    maxTries,
+    linearBackoffMS,
+    shouldRetryOnError: shouldRetry
+  });
+};
+var httpClient = {
+  get,
+  post,
+  retries
+};
+
+// src/apis/subgraph-getter.ts
+var SubgraphGetter = class {
+  constructor(chainId, subgraphQuerier) {
+    this.subgraphQuerier = subgraphQuerier || new SubgraphQuerier(httpClient);
+    this.networkConfig = getApiNetworkConfigForChain(chainId);
+  }
+  async querySubgraphWithRetries({
+    query,
+    variables,
+    parseResponseData
+  }) {
+    const responseData = await this.subgraphQuerier.query({
+      subgraphUrl: this.networkConfig.subgraphUrl,
+      query,
+      variables
+    });
+    return parseResponseData(responseData);
+  }
+};
+
 // src/mint/subgraph-mint-getter.ts
 var getApiNetworkConfigForChain = (chainId) => {
   if (!networkConfigByChain[chainId]) {
@@ -2916,8 +2936,9 @@ function getTargetStrategy({
   }
   return targetStrategy;
 }
-var SubgraphMintGetter = class {
+var SubgraphMintGetter = class extends SubgraphGetter {
   constructor(chainId, subgraphQuerier) {
+    super(chainId, subgraphQuerier);
     this.getMintable = async ({
       tokenAddress,
       tokenId,
@@ -2942,24 +2963,10 @@ var SubgraphMintGetter = class {
         blockTime
       });
     };
-    this.subgraphQuerier = subgraphQuerier || new SubgraphQuerier(httpClient);
-    this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
   async getContractMintFee(contract) {
     return BigInt(contract.mintFeePerQuantity);
   }
-  async querySubgraphWithRetries({
-    query,
-    variables,
-    parseResponseData
-  }) {
-    const responseData = await this.subgraphQuerier.query({
-      subgraphUrl: this.networkConfig.subgraphUrl,
-      query,
-      variables
-    });
-    return parseResponseData(responseData);
-  }
   async getContractMintable({
     tokenAddress,
     preferredSaleType,
@@ -5388,22 +5395,9 @@ function buildContractInfoQuery({
 }
 
 // src/create/contract-getter.ts
-var SubgraphContractGetter = class {
+var SubgraphContractGetter = class extends SubgraphGetter {
   constructor(chainId, subgraphQuerier) {
-    this.subgraphQuerier = subgraphQuerier || new SubgraphQuerier(httpClient);
-    this.networkConfig = getApiNetworkConfigForChain(chainId);
-  }
-  async querySubgraphWithRetries({
-    query,
-    variables,
-    parseResponseData
-  }) {
-    const responseData = await this.subgraphQuerier.query({
-      subgraphUrl: this.networkConfig.subgraphUrl,
-      query,
-      variables
-    });
-    return parseResponseData(responseData);
+    super(chainId, subgraphQuerier);
   }
   async getContractInfo({
     contractAddress,
@@ -5434,6 +5428,246 @@ var SubgraphContractGetter = class {
   }
 };
 
+// src/rewards/rewards-queries.ts
+var import_protocol_deployments12 = require("@zoralabs/protocol-deployments");
+var import_viem12 = require("viem");
+
+// src/apis/multicall3.ts
+var multicall3Abi = [
+  "struct Call { address target; bytes callData; }",
+  "struct Call3 { address target; bool allowFailure; bytes callData; }",
+  "struct Call3Value { address target; bool allowFailure; uint256 value; bytes callData; }",
+  "struct Result { bool success; bytes returnData; }",
+  "function aggregate(Call[] calldata calls) public payable returns (uint256 blockNumber, bytes[] memory returnData)",
+  "function aggregate3(Call3[] calldata calls) public payable returns (Result[] memory returnData)",
+  "function aggregate3Value(Call3Value[] calldata calls) public payable returns (Result[] memory returnData)"
+];
+var multicall3Address = "0xcA11bde05977b3631167028862bE2a173976CA11";
+
+// src/rewards/rewards-queries.ts
+function aggregateUnclaimedFees(unclaimedFees, wethAddress2) {
+  let ethBalance = 0n;
+  const unclaimedFeesAggregate = unclaimedFees.reduce(
+    (acc, fee) => {
+      const addFee = (token, amount) => {
+        if (token === wethAddress2) {
+          ethBalance += amount;
+        } else if (acc[token]) {
+          acc[token] += amount;
+        } else {
+          acc[token] = amount;
+        }
+      };
+      addFee(fee.token0, fee.token0Amount * 75n / 100n);
+      addFee(fee.token1, fee.token1Amount * 75n / 100n);
+      return acc;
+    },
+    {}
+  );
+  return {
+    eth: ethBalance * 75n / 100n,
+    // Apply 75% fee to ETH balance
+    erc20: unclaimedFeesAggregate
+  };
+}
+var 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
+}) => {
+  const address = typeof account === "string" ? account : account.address;
+  const erc20Zs = await rewardsGetter.getErc20ZzForCreator({ address });
+  const result = await publicClient.multicall({
+    contracts: [
+      {
+        address: import_protocol_deployments12.protocolRewardsAddress[chainId],
+        abi: import_protocol_deployments12.protocolRewardsABI,
+        functionName: "balanceOf",
+        args: [address]
+      },
+      {
+        address: import_protocol_deployments12.erc20ZRoyaltiesAddress[chainId],
+        abi: import_protocol_deployments12.erc20ZRoyaltiesABI,
+        functionName: "getUnclaimedFeesBatch",
+        args: [erc20Zs]
+      }
+    ],
+    multicallAddress: multicall3Address,
+    allowFailure: false
+  });
+  const protocolRewardsBalance = result[0];
+  const wethAddressForChain = import_protocol_deployments12.wethAddress[chainId];
+  const unclaimedFeesAggregate = aggregateUnclaimedFees(
+    result[1],
+    wethAddressForChain
+  );
+  return {
+    protocolRewards: protocolRewardsBalance,
+    secondaryRoyalties: unclaimedFeesAggregate
+  };
+};
+var withdrawProtocolRewards = ({
+  withdrawFor,
+  chainId
+}) => {
+  return makeContractParameters({
+    abi: import_protocol_deployments12.protocolRewardsABI,
+    functionName: "withdrawFor",
+    address: import_protocol_deployments12.protocolRewardsAddress[chainId],
+    args: [withdrawFor, 0n]
+  });
+};
+var makeClaimSecondaryRoyaltiesCalls = async ({
+  claimFor,
+  chainId,
+  rewardsGetter
+}) => {
+  const erc20z = await rewardsGetter.getErc20ZzForCreator({
+    address: claimFor
+  });
+  const royaltiesAddress = import_protocol_deployments12.erc20ZRoyaltiesAddress[chainId];
+  if (erc20z.length === 0) {
+    return [];
+  }
+  return erc20z.map((erc20z2) => ({
+    target: royaltiesAddress,
+    callData: (0, import_viem12.encodeFunctionData)({
+      abi: import_protocol_deployments12.erc20ZRoyaltiesABI,
+      functionName: "claimFor",
+      args: [erc20z2]
+    }),
+    allowFailure: false
+  }));
+};
+var createProtocolRewardsCall = (chainId, withdrawFor) => ({
+  target: import_protocol_deployments12.protocolRewardsAddress[chainId],
+  callData: (0, import_viem12.encodeFunctionData)({
+    abi: import_protocol_deployments12.protocolRewardsABI,
+    functionName: "withdrawFor",
+    args: [withdrawFor, 0n]
+  }),
+  allowFailure: false
+});
+var createMulticallParameters = (calls, account) => makeContractParameters({
+  abi: (0, import_viem12.parseAbi)(multicall3Abi),
+  functionName: "aggregate3",
+  address: multicall3Address,
+  args: [calls],
+  account
+});
+var withdrawRewards = async ({
+  account,
+  withdrawFor,
+  claimSecondaryRoyalties = true,
+  chainId,
+  rewardsGetter
+}) => {
+  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);
+};
+
+// src/rewards/rewards-client.ts
+var RewardsClient = class {
+  constructor({
+    chainId,
+    publicClient,
+    rewardsGetter
+  }) {
+    this.chainId = chainId;
+    this.publicClient = publicClient;
+    this.rewardsGetter = rewardsGetter;
+  }
+  /** Withdraws rewards for a given account */
+  async withdrawRewards({
+    account,
+    withdrawFor,
+    claimSecondaryRoyalties
+  }) {
+    return {
+      parameters: await withdrawRewards({
+        chainId: this.chainId,
+        rewardsGetter: this.rewardsGetter,
+        withdrawFor,
+        claimSecondaryRoyalties,
+        account
+      })
+    };
+  }
+  /** Retrieves the rewards balances for a given account */
+  async getRewardsBalances(params) {
+    return getRewardsBalance({
+      account: params.account,
+      chainId: this.chainId,
+      publicClient: this.publicClient,
+      rewardsGetter: this.rewardsGetter
+    });
+  }
+};
+
+// src/rewards/subgraph-queries.ts
+function buildCreatorERC20zs({
+  address
+}) {
+  return {
+    query: `
+    query ($address: Bytes!) {
+      zoraCreateTokens(
+        where: { royalties_: { user: $address }, salesStrategies_: { type: "ZORA_TIMED" } }
+      ) {
+        royalties {
+          user
+        }
+        salesStrategies {
+          zoraTimedMinter {
+            erc20Z {
+              id
+            }
+          }
+        }
+      }
+    }
+    `,
+    variables: { address },
+    parseResponseData: (responseData) => {
+      return responseData?.zoraCreateTokens;
+    }
+  };
+}
+
+// src/rewards/subgraph-rewards-getter.ts
+var SubgraphRewardsGetter = class extends SubgraphGetter {
+  constructor(chainId, subgraphQuerier) {
+    super(chainId, subgraphQuerier);
+  }
+  async getErc20ZzForCreator({
+    address
+  }) {
+    const queryResults = await this.querySubgraphWithRetries(
+      buildCreatorERC20zs({ address })
+    );
+    return queryResults?.map(
+      (result) => result.salesStrategies[0].zoraTimedMinter.erc20Z.id
+    ) || [];
+  }
+};
+
 // src/sdk.ts
 function createCreatorClient(clientConfig) {
   const premintClient = new PremintClient({
@@ -5446,12 +5680,19 @@ function createCreatorClient(clientConfig) {
     publicClient: clientConfig.publicClient,
     contractGetter: clientConfig.contractGetter || 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),
     deletePremint: (p) => premintClient.deletePremint(p),
     create1155: (p) => create1155CreatorClient.createNew1155(p),
-    create1155OnExistingContract: (p) => create1155CreatorClient.createNew1155OnExistingContract(p)
+    create1155OnExistingContract: (p) => create1155CreatorClient.createNew1155OnExistingContract(p),
+    getRewardsBalances: (p) => rewardsClient.getRewardsBalances(p),
+    withdrawRewards: (p) => rewardsClient.withdrawRewards(p)
   };
 }
 function createCollectorClient(params) {