@zoralabs/protocol-sdk 0.9.6 → 0.11.0

package/dist/index.cjs

@@ -397,12 +397,12 @@ var require_semver = __commonJS({
             this.prerelease = [];
             break;
           case "pre": {
-            const base3 = Number(identifierBase) ? 1 : 0;
+            const base4 = Number(identifierBase) ? 1 : 0;
             if (!identifier && identifierBase === false) {
               throw new Error("invalid increment argument: identifier is empty");
             }
             if (this.prerelease.length === 0) {
-              this.prerelease = [base3];
+              this.prerelease = [base4];
             } else {
               let i = this.prerelease.length;
               while (--i >= 0) {
@@ -415,11 +415,11 @@ var require_semver = __commonJS({
                 if (identifier === this.prerelease.join(".") && identifierBase === false) {
                   throw new Error("invalid increment argument: identifier already exists");
                 }
-                this.prerelease.push(base3);
+                this.prerelease.push(base4);
               }
             }
             if (identifier) {
-              let prerelease = [identifier, base3];
+              let prerelease = [identifier, base4];
               if (identifierBase === false) {
                 prerelease = [identifier];
               }
@@ -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,59 +2677,209 @@ function buildPremintsOfContractQuery({
   };
 }
 
-// src/mint/subgraph-mint-getter.ts
-var getApiNetworkConfigForChain = (chainId) => {
-  if (!networkConfigByChain[chainId]) {
-    throw new Error(`chain id ${chainId} network not configured `);
+// 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;
   }
-  return networkConfigByChain[chainId];
 };
-function parseSalesConfig(targetStrategy, contractMintFee) {
-  if (targetStrategy.type === "FIXED_PRICE")
-    return {
-      saleType: "fixedPrice",
-      ...targetStrategy.fixedPrice,
-      maxTokensPerAddress: BigInt(
-        targetStrategy.fixedPrice.maxTokensPerAddress
-      ),
-      pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken),
-      mintFeePerQuantity: contractMintFee
-    };
-  if (targetStrategy.type === "ERC_20_MINTER") {
-    return {
-      saleType: "erc20",
-      ...targetStrategy.erc20Minter,
-      maxTokensPerAddress: BigInt(
-        targetStrategy.erc20Minter.maxTokensPerAddress
-      ),
-      pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken),
-      mintFeePerQuantity: 0n
-    };
+
+// 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;
   }
-  if (targetStrategy.type === "PRESALE") {
-    return {
-      saleType: "allowlist",
-      address: targetStrategy.presale.address,
-      merkleRoot: targetStrategy.presale.merkleRoot,
-      saleStart: targetStrategy.presale.presaleStart,
-      saleEnd: targetStrategy.presale.presaleEnd,
-      mintFeePerQuantity: contractMintFee
-    };
+};
+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;
   }
-  if (targetStrategy.type === "ZORA_TIMED") {
-    return {
-      saleType: "timed",
-      address: targetStrategy.zoraTimedMinter.address,
-      mintFee: BigInt(targetStrategy.zoraTimedMinter.mintFee),
-      saleStart: targetStrategy.zoraTimedMinter.saleStart,
-      saleEnd: targetStrategy.zoraTimedMinter.saleEnd,
-      erc20Z: targetStrategy.zoraTimedMinter.erc20Z.id,
-      pool: targetStrategy.zoraTimedMinter.erc20Z.pool,
-      secondaryActivated: targetStrategy.zoraTimedMinter.secondaryActivated,
-      mintFeePerQuantity: BigInt(targetStrategy.zoraTimedMinter.mintFee),
-      marketCountdown: targetStrategy.zoraTimedMinter.marketCountdown ? BigInt(targetStrategy.zoraTimedMinter.marketCountdown) : void 0,
-      minimumMarketEth: targetStrategy.zoraTimedMinter.minimumMarketEth ? BigInt(targetStrategy.zoraTimedMinter.minimumMarketEth) : void 0
-    };
+};
+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]) {
+    throw new Error(`chain id ${chainId} network not configured `);
+  }
+  return networkConfigByChain[chainId];
+};
+function parseSalesConfig(targetStrategy, contractMintFee) {
+  if (targetStrategy.type === "FIXED_PRICE")
+    return {
+      saleType: "fixedPrice",
+      ...targetStrategy.fixedPrice,
+      maxTokensPerAddress: BigInt(
+        targetStrategy.fixedPrice.maxTokensPerAddress
+      ),
+      pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken),
+      mintFeePerQuantity: contractMintFee
+    };
+  if (targetStrategy.type === "ERC_20_MINTER") {
+    return {
+      saleType: "erc20",
+      ...targetStrategy.erc20Minter,
+      maxTokensPerAddress: BigInt(
+        targetStrategy.erc20Minter.maxTokensPerAddress
+      ),
+      pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken),
+      mintFeePerQuantity: 0n
+    };
+  }
+  if (targetStrategy.type === "PRESALE") {
+    return {
+      saleType: "allowlist",
+      address: targetStrategy.presale.address,
+      merkleRoot: targetStrategy.presale.merkleRoot,
+      saleStart: targetStrategy.presale.presaleStart,
+      saleEnd: targetStrategy.presale.presaleEnd,
+      mintFeePerQuantity: contractMintFee
+    };
+  }
+  if (targetStrategy.type === "ZORA_TIMED") {
+    return {
+      saleType: "timed",
+      address: targetStrategy.zoraTimedMinter.address,
+      mintFee: BigInt(targetStrategy.zoraTimedMinter.mintFee),
+      saleStart: targetStrategy.zoraTimedMinter.saleStart,
+      saleEnd: targetStrategy.zoraTimedMinter.saleEnd,
+      erc20Z: targetStrategy.zoraTimedMinter.erc20Z.id,
+      pool: targetStrategy.zoraTimedMinter.erc20Z.pool,
+      secondaryActivated: targetStrategy.zoraTimedMinter.secondaryActivated,
+      mintFeePerQuantity: BigInt(targetStrategy.zoraTimedMinter.mintFee),
+      marketCountdown: targetStrategy.zoraTimedMinter.marketCountdown ? BigInt(targetStrategy.zoraTimedMinter.marketCountdown) : void 0,
+      minimumMarketEth: targetStrategy.zoraTimedMinter.minimumMarketEth ? BigInt(targetStrategy.zoraTimedMinter.minimumMarketEth) : void 0
+    };
   }
   throw new Error("Unknown saleType");
 }
@@ -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,
@@ -3064,6 +3071,7 @@ function mintRecipientOrAccount({
 }) {
   return mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
 }
+var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
 
 // src/premint/premint-client.ts
 var defaultTokenConfigV1MintArguments = () => ({
@@ -5134,7 +5142,6 @@ var sumBalances = (mintAccountBalances) => {
 // src/sparks/sparks-contracts.ts
 var import_protocol_deployments11 = require("@zoralabs/protocol-deployments");
 var import_viem11 = require("viem");
-var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
 var mintWithEthParams = ({
   tokenId,
   quantity,
@@ -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,749 @@ 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/secondary/secondary-client.ts
+var import_viem17 = require("viem");
+var import_protocol_deployments15 = require("@zoralabs/protocol-deployments");
+
+// src/secondary/uniswap/uniswapQuote.ts
+var import_viem16 = require("viem");
+
+// src/secondary/uniswap/uniswapReserves.ts
+var import_viem14 = require("viem");
+var import_chains2 = require("viem/chains");
+
+// src/secondary/uniswap/abis.ts
+var import_viem13 = require("viem");
+var uniswapQuoterABI = (0, import_viem13.parseAbi)([
+  "struct QuoteExactInputSingleParams { address tokenIn; address tokenOut; uint256 amountIn; uint24 fee; uint160 sqrtPriceLimitX96; }",
+  "struct QuoteExactOutputSingleParams { address tokenIn; address tokenOut; uint256 amount; uint24 fee; uint160 sqrtPriceLimitX96; }",
+  "function quoteExactInputSingle(QuoteExactInputSingleParams calldata params) external returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)",
+  "function quoteExactOutputSingle(QuoteExactOutputSingleParams calldata params) external returns (uint256 amountIn, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)"
+]);
+var uniswapV3PoolAbi = (0, import_viem13.parseAbi)([
+  "function fee() external view returns (uint24)",
+  "function liquidity() external view returns (uint128)",
+  "function slot0() external view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked)",
+  "function token0() external view returns (address)",
+  "function token1() external view returns (address)"
+]);
+var uniswapV2USDCAbi = (0, import_viem13.parseAbi)([
+  "function getReserves() external view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast)"
+]);
+
+// src/secondary/uniswap/uniswapReserves.ts
+var uniswapV2USDCMainnetAddress = "0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc";
+function getUniswapV2USDCReserves() {
+  const mainnetClient = (0, import_viem14.createPublicClient)({
+    chain: import_chains2.mainnet,
+    transport: (0, import_viem14.http)()
+  });
+  return mainnetClient.readContract({
+    address: uniswapV2USDCMainnetAddress,
+    abi: uniswapV2USDCAbi,
+    functionName: "getReserves"
+  });
+}
+function toEthPriceInUSDC({
+  reserve0,
+  reserve1
+}) {
+  return Number(reserve0 * BigInt(1e14) / reserve1) / 100;
+}
+async function getEthPriceInUSDC() {
+  const reserves = await getUniswapV2USDCReserves();
+  return toEthPriceInUSDC({ reserve0: reserves[0], reserve1: reserves[1] });
+}
+
+// src/secondary/conversions.ts
+var import_viem15 = require("viem");
+var WEI_PER_SPARK = 1000000000000n;
+function convertWeiToSparks(wei) {
+  return BigInt(wei) / WEI_PER_SPARK;
+}
+function convertWeiToUSD({
+  amount,
+  ethPriceInUSD
+}) {
+  const amountInEth = (0, import_viem15.formatEther)(amount);
+  return parseFloat(amountInEth) * ethPriceInUSD;
+}
+
+// src/secondary/uniswap/uniswapQuote.ts
+var import_protocol_deployments13 = require("@zoralabs/protocol-deployments");
+
+// src/secondary/uniswap/uniswapQuoteExact.ts
+var import_chains3 = require("viem/chains");
+var UniswapQuoterAddress = {
+  [import_chains3.mainnet.id]: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+  [import_chains3.sepolia.id]: "0xEd1f6473345F45b75F8179591dd5bA1888cf2FB3",
+  [import_chains3.zora.id]: "0x11867e1b3348F3ce4FcC170BC5af3d23E07E64Df",
+  [import_chains3.zoraSepolia.id]: "0xC195976fEF0985886E37036E2DF62bF371E12Df0",
+  [import_chains3.base.id]: "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a",
+  [import_chains3.baseSepolia.id]: "0xC5290058841028F1614F3A6F0F5816cAd0df5E27",
+  [import_chains3.optimism.id]: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+  [import_chains3.arbitrum.id]: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+  [import_chains3.blast.id]: "0x6Cdcd65e03c1CEc3730AeeCd45bc140D57A25C77"
+};
+async function quoteExactOutputSingle({
+  tokenIn,
+  tokenOut,
+  amountOut,
+  fee,
+  chainId,
+  client
+}) {
+  const quote = await client.simulateContract({
+    abi: uniswapQuoterABI,
+    address: UniswapQuoterAddress[chainId],
+    functionName: "quoteExactOutputSingle",
+    args: [
+      {
+        tokenIn,
+        tokenOut,
+        amount: amountOut,
+        fee,
+        sqrtPriceLimitX96: 0n
+      }
+    ]
+  });
+  return quote.result[0];
+}
+async function quoteExactInputSingle({
+  tokenIn,
+  tokenOut,
+  amountIn,
+  fee,
+  chainId,
+  client
+}) {
+  const quote = await client.simulateContract({
+    abi: uniswapQuoterABI,
+    address: UniswapQuoterAddress[chainId],
+    functionName: "quoteExactInputSingle",
+    args: [
+      {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        fee,
+        sqrtPriceLimitX96: 0n
+      }
+    ]
+  });
+  return quote.result[0];
+}
+
+// src/secondary/uniswap/uniswapQuote.ts
+async function getPoolInfo({
+  poolAddress,
+  client,
+  WETH,
+  erc20z
+}) {
+  const [fee, wethBalance, erc20zBalance] = await client.multicall({
+    contracts: [
+      {
+        abi: uniswapV3PoolAbi,
+        address: poolAddress,
+        functionName: "fee"
+      },
+      // get WETH and erc20z balance for pool
+      {
+        abi: import_viem16.erc20Abi,
+        address: WETH,
+        functionName: "balanceOf",
+        args: [poolAddress]
+      },
+      {
+        abi: import_viem16.erc20Abi,
+        address: erc20z,
+        functionName: "balanceOf",
+        args: [poolAddress]
+      }
+    ],
+    multicallAddress: multicall3Address,
+    allowFailure: false
+  });
+  return {
+    wethBalance,
+    erc20zBalance,
+    fee
+  };
+}
+async function getUniswapQuote(input, client) {
+  const { type, quantity, poolAddress, chainId, erc20z } = input;
+  const WETH = import_protocol_deployments13.wethAddress[chainId];
+  const pool = await getPoolInfo({ poolAddress, WETH, erc20z, client });
+  const { fee, wethBalance, erc20zBalance } = pool;
+  const amountWithDecimals = input.quantity * 10n ** 18n;
+  const amount = type === "buy" ? await quoteExactOutputSingle({
+    tokenIn: WETH,
+    tokenOut: erc20z,
+    amountOut: amountWithDecimals,
+    fee,
+    chainId,
+    client
+  }) : await quoteExactInputSingle({
+    tokenIn: erc20z,
+    tokenOut: WETH,
+    amountIn: amountWithDecimals,
+    fee,
+    chainId,
+    client
+  });
+  const price = amount;
+  const pricePerToken = amount / BigInt(quantity);
+  const getUsdPrice = async () => {
+    const ethPriceInUSD = await getEthPriceInUSDC();
+    return {
+      perToken: convertWeiToUSD({ amount: pricePerToken, ethPriceInUSD }),
+      total: convertWeiToUSD({ amount: price, ethPriceInUSD })
+    };
+  };
+  return {
+    amount,
+    poolBalance: {
+      erc20z: erc20zBalance,
+      weth: wethBalance
+    },
+    price: {
+      wei: {
+        perToken: pricePerToken,
+        total: price
+      },
+      sparks: {
+        perToken: convertWeiToSparks(pricePerToken),
+        total: convertWeiToSparks(price)
+      },
+      usdc: getUsdPrice
+    }
+  };
+}
+
+// src/secondary/slippage.ts
+var SCALE = 1e18;
+var ONE_SCALED = BigInt(SCALE);
+function calculateSlippageUp(amount, slippage) {
+  return typeof amount === "bigint" ? amount * (ONE_SCALED + BigInt(slippage * SCALE)) / ONE_SCALED : parseFloat(String(amount)) * (1 + slippage);
+}
+function calculateSlippageDown(amount, slippage) {
+  return typeof amount === "bigint" ? amount * (ONE_SCALED - BigInt(slippage * SCALE)) / ONE_SCALED : parseFloat(String(amount)) * (1 - slippage);
+}
+
+// src/secondary/utils.ts
+var import_protocol_deployments14 = require("@zoralabs/protocol-deployments");
+async function getSecondaryInfo({
+  contract,
+  tokenId,
+  publicClient,
+  chainId
+}) {
+  const result = await publicClient.readContract({
+    abi: import_protocol_deployments14.zoraTimedSaleStrategyABI,
+    address: import_protocol_deployments14.zoraTimedSaleStrategyAddress[chainId],
+    functionName: "sale",
+    args: [contract, tokenId]
+  });
+  if (!result.erc20zAddress) {
+    return void 0;
+  }
+  return {
+    erc20z: result.erc20zAddress,
+    pool: result.poolAddress,
+    secondaryActivated: result.secondaryActivated,
+    saleEnd: result.saleEnd === 0n ? void 0 : result.saleEnd
+  };
+}
+
+// src/secondary/secondary-client.ts
+var UNISWAP_SLIPPAGE = 5e-3;
+var ERROR_INSUFFICIENT_WALLET_FUNDS = "Insufficient wallet funds";
+var ERROR_INSUFFICIENT_POOL_SUPPLY = "Insufficient pool supply";
+var ERROR_SECONDARY_NOT_CONFIGURED = "Secondary not configured for given contract and token";
+var ERROR_SECONDARY_NOT_STARTED = "Secondary market has not started";
+function makeError(errorMessage) {
+  return { error: errorMessage };
+}
+async function makeBuy({
+  erc20z,
+  poolBalance,
+  amount,
+  quantity,
+  account,
+  recipient,
+  chainId,
+  slippage,
+  publicClient
+}) {
+  const costWithSlippage = calculateSlippageUp(amount, slippage);
+  const availableToBuy = poolBalance.erc20z / BigInt(1e18) - 1n;
+  const accountAddress = addressOrAccountAddress(account);
+  const availableToSpend = await publicClient.getBalance({
+    address: accountAddress
+  });
+  if (costWithSlippage > availableToSpend) {
+    return makeError(ERROR_INSUFFICIENT_WALLET_FUNDS);
+  }
+  if (availableToBuy < BigInt(quantity)) {
+    return makeError(ERROR_INSUFFICIENT_POOL_SUPPLY);
+  }
+  return {
+    parameters: makeContractParameters({
+      abi: import_protocol_deployments15.secondarySwapABI,
+      address: import_protocol_deployments15.secondarySwapAddress[chainId],
+      functionName: "buy1155",
+      args: [
+        erc20z,
+        quantity,
+        recipient || accountAddress,
+        accountAddress,
+        costWithSlippage,
+        0n
+      ],
+      account,
+      value: costWithSlippage
+    })
+  };
+}
+async function buyWithSlippage({
+  contract,
+  tokenId,
+  publicClient,
+  quantity,
+  chainId,
+  account,
+  slippage = UNISWAP_SLIPPAGE,
+  recipient
+}) {
+  const secondaryInfo = await getSecondaryInfo({
+    contract,
+    tokenId,
+    publicClient,
+    chainId
+  });
+  if (!secondaryInfo) {
+    return makeError(ERROR_SECONDARY_NOT_CONFIGURED);
+  }
+  const { erc20z, pool, secondaryActivated } = secondaryInfo;
+  if (!secondaryActivated) {
+    return makeError(ERROR_SECONDARY_NOT_STARTED);
+  }
+  const { poolBalance, amount, price } = await getUniswapQuote(
+    {
+      type: "buy",
+      quantity,
+      poolAddress: pool,
+      erc20z,
+      chainId
+    },
+    publicClient
+  );
+  const call = await makeBuy({
+    erc20z,
+    poolBalance,
+    amount,
+    quantity,
+    account,
+    recipient,
+    chainId,
+    slippage,
+    publicClient
+  });
+  return {
+    ...call,
+    price
+  };
+}
+async function makeSell({
+  contract,
+  tokenId,
+  poolBalance,
+  amount,
+  quantity,
+  account,
+  recipient,
+  chainId,
+  slippage,
+  publicClient
+}) {
+  const accountAddress = addressOrAccountAddress(account);
+  const tokenCount = await publicClient.readContract({
+    abi: import_protocol_deployments15.zoraCreator1155ImplABI,
+    address: contract,
+    functionName: "balanceOf",
+    args: [accountAddress, tokenId]
+  });
+  const availableToSell = tokenCount ?? 0n;
+  const availableToReceive = poolBalance.weth;
+  if (quantity > availableToSell) {
+    return makeError(ERROR_INSUFFICIENT_WALLET_FUNDS);
+  }
+  if (amount > availableToReceive) {
+    return makeError(ERROR_INSUFFICIENT_POOL_SUPPLY);
+  }
+  const receivedWithSlippage = calculateSlippageDown(amount, slippage);
+  const data = (0, import_viem17.encodeAbiParameters)(import_protocol_deployments15.safeTransferSwapAbiParameters, [
+    recipient || accountAddress,
+    receivedWithSlippage,
+    0n
+  ]);
+  return {
+    parameters: makeContractParameters({
+      abi: import_protocol_deployments15.zoraCreator1155ImplABI,
+      address: contract,
+      functionName: "safeTransferFrom",
+      account,
+      args: [
+        accountAddress,
+        import_protocol_deployments15.secondarySwapAddress[chainId],
+        tokenId,
+        quantity,
+        data
+      ]
+    })
+  };
+}
+async function sellWithSlippage({
+  contract,
+  tokenId,
+  publicClient,
+  quantity,
+  chainId,
+  account,
+  slippage = UNISWAP_SLIPPAGE,
+  recipient
+}) {
+  const secondaryInfo = await getSecondaryInfo({
+    contract,
+    tokenId,
+    publicClient,
+    chainId
+  });
+  if (!secondaryInfo) {
+    return makeError(ERROR_SECONDARY_NOT_CONFIGURED);
+  }
+  const { pool, secondaryActivated, erc20z } = secondaryInfo;
+  if (!secondaryActivated) {
+    return makeError(ERROR_SECONDARY_NOT_STARTED);
+  }
+  const { poolBalance, amount, price } = await getUniswapQuote(
+    { type: "sell", quantity, poolAddress: pool, chainId, erc20z },
+    publicClient
+  );
+  const call = await makeSell({
+    contract,
+    tokenId,
+    poolBalance,
+    amount,
+    quantity,
+    account,
+    recipient,
+    chainId,
+    slippage,
+    publicClient
+  });
+  return {
+    ...call,
+    price
+  };
+}
+var SecondaryClient = class {
+  /**
+   * Creates a new SecondaryClient instance.
+   * @param publicClient - The public client for interacting with the blockchain.
+   * @param chainId - The ID of the blockchain network.
+   */
+  constructor({
+    publicClient,
+    chainId
+  }) {
+    this.publicClient = publicClient;
+    this.chainId = chainId;
+  }
+  /**
+   * Get the secondary info for a given contract and token ID.
+   * @param contract - The address of the contract.
+   * @param tokenId - The ID of the token.
+   * @returns A promise that resolves to the secondary info.
+   */
+  async getSecondaryInfo({
+    contract,
+    tokenId
+  }) {
+    return getSecondaryInfo({
+      contract,
+      tokenId,
+      publicClient: this.publicClient,
+      chainId: this.chainId
+    });
+  }
+  /**
+   * Prepares a buy operation with slippage protection for purchasing a quantity of ERC1155 tokens with ETH on the secondary market.
+   * @param input - The input parameters for the buy operation.
+   * @returns A promise that resolves to the result of the buy operation, including price breakdown and transaction parameters.
+   */
+  async buy1155OnSecondary(input) {
+    return buyWithSlippage({
+      ...input,
+      publicClient: this.publicClient,
+      chainId: this.chainId
+    });
+  }
+  /**
+   * Prepares a sell operation with slippage protection for selling a quantity of ERC1155 tokens for ETH on the secondary market.
+   * @param input - The input parameters for the sell operation.
+   * @returns A promise that resolves to the result of the sell operation, including price breakdown and transaction parameters.
+   */
+  async sell1155OnSecondary(input) {
+    return sellWithSlippage({
+      ...input,
+      publicClient: this.publicClient,
+      chainId: this.chainId
+    });
+  }
+};
+
 // src/sdk.ts
 function createCreatorClient(clientConfig) {
   const premintClient = new PremintClient({
@@ -5446,12 +6183,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) {
@@ -5462,6 +6206,10 @@ function createCollectorClient(params) {
     premintGetter: premintGetterToUse,
     mintGetter: mintGetterToUse
   });
+  const secondaryClient = new SecondaryClient({
+    publicClient: params.publicClient,
+    chainId: params.chainId
+  });
   return {
     getPremint: (p) => premintGetterToUse.get({
       collectionAddress: p.address,
@@ -5471,7 +6219,10 @@ function createCollectorClient(params) {
     getToken: (p) => mintClient.get(p),
     getTokensOfContract: (p) => mintClient.getOfContract(p),
     mint: (p) => mintClient.mint(p),
-    getMintCosts: (p) => mintClient.getMintCosts(p)
+    getMintCosts: (p) => mintClient.getMintCosts(p),
+    buy1155OnSecondary: (p) => secondaryClient.buy1155OnSecondary(p),
+    sell1155OnSecondary: (p) => secondaryClient.sell1155OnSecondary(p),
+    getSecondaryInfo: (p) => secondaryClient.getSecondaryInfo(p)
   };
 }
 
@@ -5507,7 +6258,7 @@ function coerce3(o) {
 }
 
 // ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/vendor/base-x.js
-function base2(ALPHABET, name) {
+function base3(ALPHABET, name) {
   if (ALPHABET.length >= 255) {
     throw new TypeError("Alphabet too long");
   }
@@ -5638,7 +6389,7 @@ function base2(ALPHABET, name) {
     decode: decode5
   };
 }
-var src = base2;
+var src = base3;
 var _brrp__multiformats_scope_baseX = src;
 var base_x_default = _brrp__multiformats_scope_baseX;
 
@@ -5999,13 +6750,13 @@ var Digest = class {
 };
 
 // ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/cid.js
-function format(link, base3) {
+function format(link, base4) {
   const { bytes, version } = link;
   switch (version) {
     case 0:
-      return toStringV0(bytes, baseCache(link), base3 ?? base58btc.encoder);
+      return toStringV0(bytes, baseCache(link), base4 ?? base58btc.encoder);
     default:
-      return toStringV1(bytes, baseCache(link), base3 ?? base32.encoder);
+      return toStringV1(bytes, baseCache(link), base4 ?? base32.encoder);
   }
 }
 var cache = /* @__PURE__ */ new WeakMap();
@@ -6097,8 +6848,8 @@ var CID = class _CID {
     const unknown = other;
     return unknown != null && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
   }
-  toString(base3) {
-    return format(this, base3);
+  toString(base4) {
+    return format(this, base4);
   }
   toJSON() {
     return { "/": format(this) };
@@ -6257,8 +7008,8 @@ var CID = class _CID {
    * throw an error if encoding of the CID is not compatible with supplied (or
    * a default decoder).
    */
-  static parse(source, base3) {
-    const [prefix, bytes] = parseCIDtoBytes(source, base3);
+  static parse(source, base4) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base4);
     const cid = _CID.decode(bytes);
     if (cid.version === 0 && source[0] !== "Q") {
       throw Error("Version 0 CID string must not include multibase prefix");
@@ -6267,50 +7018,50 @@ var CID = class _CID {
     return cid;
   }
 };
-function parseCIDtoBytes(source, base3) {
+function parseCIDtoBytes(source, base4) {
   switch (source[0]) {
     case "Q": {
-      const decoder = base3 ?? base58btc;
+      const decoder = base4 ?? base58btc;
       return [
         base58btc.prefix,
         decoder.decode(`${base58btc.prefix}${source}`)
       ];
     }
     case base58btc.prefix: {
-      const decoder = base3 ?? base58btc;
+      const decoder = base4 ?? base58btc;
       return [base58btc.prefix, decoder.decode(source)];
     }
     case base32.prefix: {
-      const decoder = base3 ?? base32;
+      const decoder = base4 ?? base32;
       return [base32.prefix, decoder.decode(source)];
     }
     default: {
-      if (base3 == null) {
+      if (base4 == null) {
         throw Error("To parse non base32 or base58btc encoded CID multibase decoder must be provided");
       }
-      return [source[0], base3.decode(source)];
+      return [source[0], base4.decode(source)];
     }
   }
 }
-function toStringV0(bytes, cache2, base3) {
-  const { prefix } = base3;
+function toStringV0(bytes, cache2, base4) {
+  const { prefix } = base4;
   if (prefix !== base58btc.prefix) {
-    throw Error(`Cannot string encode V0 in ${base3.name} encoding`);
+    throw Error(`Cannot string encode V0 in ${base4.name} encoding`);
   }
   const cid = cache2.get(prefix);
   if (cid == null) {
-    const cid2 = base3.encode(bytes).slice(1);
+    const cid2 = base4.encode(bytes).slice(1);
     cache2.set(prefix, cid2);
     return cid2;
   } else {
     return cid;
   }
 }
-function toStringV1(bytes, cache2, base3) {
-  const { prefix } = base3;
+function toStringV1(bytes, cache2, base4) {
+  const { prefix } = base4;
   const cid = cache2.get(prefix);
   if (cid == null) {
-    const cid2 = base3.encode(bytes);
+    const cid2 = base4.encode(bytes);
     cache2.set(prefix, cid2);
     return cid2;
   } else {