@zoralabs/protocol-sdk 0.10.0 → 0.11.1

package/dist/index.js

@@ -391,12 +391,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) {
@@ -409,11 +409,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];
               }
@@ -3023,6 +3023,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 = () => ({
@@ -5135,7 +5136,6 @@ import {
   encodeFunctionData as encodeFunctionData3,
   zeroAddress as zeroAddress7
 } from "viem";
-var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
 var mintWithEthParams = ({
   tokenId,
   quantity,
@@ -5668,6 +5668,527 @@ var SubgraphRewardsGetter = class extends SubgraphGetter {
   }
 };
 
+// src/secondary/secondary-client.ts
+import { encodeAbiParameters as encodeAbiParameters2 } from "viem";
+import {
+  secondarySwapAddress,
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI7,
+  safeTransferSwapAbiParameters,
+  secondarySwapABI
+} from "@zoralabs/protocol-deployments";
+
+// src/secondary/uniswap/uniswapQuote.ts
+import { erc20Abi } from "viem";
+
+// src/secondary/uniswap/uniswapReserves.ts
+import { createPublicClient, http } from "viem";
+import { mainnet as mainnet2 } from "viem/chains";
+
+// src/secondary/uniswap/abis.ts
+import { parseAbi as parseAbi3 } from "viem";
+var uniswapQuoterABI = parseAbi3([
+  "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 = parseAbi3([
+  "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 = parseAbi3([
+  "function getReserves() external view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast)"
+]);
+
+// src/secondary/uniswap/uniswapReserves.ts
+var uniswapV2USDCMainnetAddress = "0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc";
+function getUniswapV2USDCReserves() {
+  const mainnetClient = createPublicClient({
+    chain: mainnet2,
+    transport: 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
+import { formatEther } from "viem";
+var WEI_PER_SPARK = 1000000000000n;
+function convertWeiToSparks(wei) {
+  return BigInt(wei) / WEI_PER_SPARK;
+}
+function convertWeiToUSD({
+  amount,
+  ethPriceInUSD
+}) {
+  const amountInEth = formatEther(amount);
+  return parseFloat(amountInEth) * ethPriceInUSD;
+}
+
+// src/secondary/uniswap/uniswapQuote.ts
+import { wethAddress as wethAddresses } from "@zoralabs/protocol-deployments";
+
+// src/secondary/uniswap/uniswapQuoteExact.ts
+import {
+  mainnet as mainnet3,
+  sepolia as sepolia2,
+  zora as zora2,
+  zoraSepolia as zoraSepolia2,
+  base as base2,
+  baseSepolia as baseSepolia2,
+  optimism as optimism2,
+  arbitrum as arbitrum2,
+  blast
+} from "viem/chains";
+var UniswapQuoterAddress = {
+  [mainnet3.id]: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+  [sepolia2.id]: "0xEd1f6473345F45b75F8179591dd5bA1888cf2FB3",
+  [zora2.id]: "0x11867e1b3348F3ce4FcC170BC5af3d23E07E64Df",
+  [zoraSepolia2.id]: "0xC195976fEF0985886E37036E2DF62bF371E12Df0",
+  [base2.id]: "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a",
+  [baseSepolia2.id]: "0xC5290058841028F1614F3A6F0F5816cAd0df5E27",
+  [optimism2.id]: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+  [arbitrum2.id]: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+  [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: erc20Abi,
+        address: WETH,
+        functionName: "balanceOf",
+        args: [poolAddress]
+      },
+      {
+        abi: 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 = wethAddresses[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
+import {
+  zoraTimedSaleStrategyABI as zoraTimedSaleStrategyABI3,
+  zoraTimedSaleStrategyAddress as zoraTimedSaleStrategyAddress2
+} from "@zoralabs/protocol-deployments";
+async function getSecondaryInfo({
+  contract,
+  tokenId,
+  publicClient,
+  chainId
+}) {
+  const result = await publicClient.readContract({
+    abi: zoraTimedSaleStrategyABI3,
+    address: zoraTimedSaleStrategyAddress2[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: secondarySwapABI,
+      address: 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: zoraCreator1155ImplABI7,
+    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 = encodeAbiParameters2(safeTransferSwapAbiParameters, [
+    recipient || accountAddress,
+    receivedWithSlippage,
+    0n
+  ]);
+  return {
+    parameters: makeContractParameters({
+      abi: zoraCreator1155ImplABI7,
+      address: contract,
+      functionName: "safeTransferFrom",
+      account,
+      args: [
+        accountAddress,
+        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({
@@ -5703,6 +6224,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,
@@ -5712,7 +6237,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)
   };
 }
 
@@ -5748,7 +6276,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");
   }
@@ -5879,7 +6407,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;
 
@@ -6240,13 +6768,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();
@@ -6338,8 +6866,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) };
@@ -6498,8 +7026,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");
@@ -6508,50 +7036,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 {