@zoralabs/protocol-sdk 0.10.0 → 0.11.0

package/src/secondary/secondary-client.ts

@@ -0,0 +1,374 @@
+import { Account, Address, encodeAbiParameters } from "viem";
+import {
+  secondarySwapAddress,
+  zoraCreator1155ImplABI,
+  safeTransferSwapAbiParameters,
+  secondarySwapABI,
+} from "@zoralabs/protocol-deployments";
+import { makeContractParameters, PublicClient } from "src/utils";
+import { getUniswapQuote } from "./uniswap/uniswapQuote";
+import { calculateSlippageUp, calculateSlippageDown } from "./slippage";
+import { getSecondaryInfo } from "./utils";
+import { addressOrAccountAddress } from "src/utils";
+import { SimulateContractParametersWithAccount } from "src/types";
+import {
+  QuotePrice,
+  BuyWithSlippageInput,
+  SellWithSlippageInput,
+} from "./types";
+
+// uniswap's auto slippage for L2s is 0.5% -> 0.005
+const UNISWAP_SLIPPAGE = 0.005;
+
+// Error constants
+const ERROR_INSUFFICIENT_WALLET_FUNDS = "Insufficient wallet funds";
+const ERROR_INSUFFICIENT_POOL_SUPPLY = "Insufficient pool supply";
+const ERROR_SECONDARY_NOT_CONFIGURED =
+  "Secondary not configured for given contract and token";
+export const ERROR_SECONDARY_NOT_STARTED = "Secondary market has not started";
+
+// Helper function to create error objects
+function makeError(errorMessage: string) {
+  return { error: errorMessage };
+}
+
+type Call =
+  | {
+      // Parameters for the buy or sell transaction
+      parameters: SimulateContractParametersWithAccount;
+      error?: undefined;
+    }
+  | {
+      parameters?: undefined;
+      // Error message if the buy or sell operation cannot be performed
+      error: string;
+    };
+
+async function makeBuy({
+  erc20z,
+  poolBalance,
+  amount,
+  quantity,
+  account,
+  recipient,
+  chainId,
+  slippage,
+  publicClient,
+}: {
+  erc20z: Address;
+  poolBalance: { erc20z: bigint };
+  amount: bigint;
+  quantity: bigint;
+  account: Address | Account;
+  recipient?: Address;
+  chainId: number;
+  slippage: number;
+  publicClient: PublicClient;
+}): Promise<Call> {
+  const costWithSlippage = calculateSlippageUp(amount, slippage);
+
+  // we cannot buy all the available tokens in a pool (the quote fails if we try doing that)
+  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 as keyof typeof secondarySwapAddress],
+      functionName: "buy1155",
+      args: [
+        erc20z,
+        quantity,
+        recipient || accountAddress,
+        accountAddress,
+        costWithSlippage,
+        0n,
+      ],
+      account: account,
+      value: costWithSlippage,
+    }),
+  };
+}
+
+type BuyOrSellWithSlippageResult =
+  | ({
+      // Price to buy or sell the quantity of 1155s
+      price: QuotePrice;
+    } & Call)
+  | {
+      error: string;
+      price?: undefined;
+      parameters?: undefined;
+    };
+
+export async function buyWithSlippage({
+  contract,
+  tokenId,
+  publicClient,
+  quantity,
+  chainId,
+  account,
+  slippage = UNISWAP_SLIPPAGE,
+  recipient,
+}: BuyWithSlippageInput & {
+  chainId: number;
+  publicClient: PublicClient;
+}): Promise<BuyOrSellWithSlippageResult> {
+  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,
+}: {
+  contract: Address;
+  tokenId: bigint;
+  poolBalance: { weth: bigint };
+  amount: bigint;
+  quantity: bigint;
+  account: Address | Account;
+  recipient?: Address;
+  chainId: number;
+  slippage: number;
+  publicClient: PublicClient;
+}): Promise<Call> {
+  const accountAddress = addressOrAccountAddress(account);
+
+  const tokenCount = await publicClient.readContract({
+    abi: 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 = encodeAbiParameters(safeTransferSwapAbiParameters, [
+    recipient || accountAddress,
+    receivedWithSlippage,
+    0n,
+  ]);
+
+  return {
+    parameters: makeContractParameters({
+      abi: zoraCreator1155ImplABI,
+      address: contract,
+      functionName: "safeTransferFrom",
+      account,
+      args: [
+        accountAddress,
+        secondarySwapAddress[chainId as keyof typeof secondarySwapAddress],
+        tokenId,
+        quantity,
+        data,
+      ],
+    }),
+  };
+}
+
+export async function sellWithSlippage({
+  contract,
+  tokenId,
+  publicClient,
+  quantity,
+  chainId,
+  account,
+  slippage = UNISWAP_SLIPPAGE,
+  recipient,
+}: SellWithSlippageInput & {
+  chainId: number;
+  publicClient: PublicClient;
+}): Promise<BuyOrSellWithSlippageResult> {
+  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,
+  };
+}
+
+/**
+ * A client for handling secondary market operations.
+ */
+export class SecondaryClient {
+  private publicClient: PublicClient;
+  private chainId: number;
+
+  /**
+   * 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,
+  }: {
+    publicClient: PublicClient;
+    chainId: number;
+  }) {
+    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,
+  }: {
+    contract: Address;
+    tokenId: bigint;
+  }) {
+    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: BuyWithSlippageInput,
+  ): Promise<BuyOrSellWithSlippageResult> {
+    // Call the buyWithSlippage function with the provided input and client details
+    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: SellWithSlippageInput,
+  ): Promise<BuyOrSellWithSlippageResult> {
+    // Call the sellWithSlippage function with the provided input and client details
+    return sellWithSlippage({
+      ...input,
+      publicClient: this.publicClient,
+      chainId: this.chainId,
+    });
+  }
+}

package/src/secondary/slippage.ts

@@ -0,0 +1,42 @@
+const SCALE = 1e18;
+const ONE_SCALED = BigInt(SCALE);
+
+/**
+ * Increase a base amount by a slippage percentage
+ *
+ * @remarks
+ * This is useful when trying to calculate how much a user would at maximum pay,
+ * when allowing for the specified amount of slippage (i.e. when buying 1155s).
+ *
+ * @param amount - the amount to calculate with slippage (if a bigint is passed we assume wei, otherwise we assume ether/usd/etc)
+ * @param slippage - the slippage percantage as a fraction (i.e. 5% -> 0.05)
+ * @returns the amount increased by the slippage
+ */
+export function calculateSlippageUp<
+  T extends bigint | number | string,
+  R = T extends bigint ? bigint : number,
+>(amount: T, slippage: number): R {
+  return typeof amount === "bigint"
+    ? (((amount * (ONE_SCALED + BigInt(slippage * SCALE))) / ONE_SCALED) as R)
+    : ((parseFloat(String(amount)) * (1 + slippage)) as R);
+}
+
+/**
+ * Decrease a base amount by a slippage percentage
+ *
+ * @remarks
+ * This is useful when trying to calculate how much a user would at minimum receive,
+ * when allowing for the specified amount of slippage (i.e. when selling 1155s).
+ *
+ * @param amount - the amount to calculate with slippage (if a bigint is passed we assume wei, otherwise we assume ether/usd/etc)
+ * @param slippage - the slippage percantage as a fraction (i.e. 5% -> 0.05)
+ * @returns the amount decreased by the slippage
+ */
+export function calculateSlippageDown<
+  T extends bigint | number | string,
+  R = T extends bigint ? bigint : number,
+>(amount: T, slippage: number): R {
+  return typeof amount === "bigint"
+    ? (((amount * (ONE_SCALED - BigInt(slippage * SCALE))) / ONE_SCALED) as R)
+    : ((parseFloat(String(amount)) * (1 - slippage)) as R);
+}

package/src/secondary/types.ts

@@ -0,0 +1,64 @@
+import { Address, Account } from "viem";
+
+export type PriceBreakdown = {
+  // Price per individual token
+  perToken: bigint;
+  // Total price for all tokens
+  total: bigint;
+};
+
+export type QuotePrice = {
+  // Price breakdown in wei
+  wei: PriceBreakdown;
+  // Price breakdown in sparks
+  sparks: PriceBreakdown;
+  // Function to get price breakdown in USDC
+  usdc: () => Promise<{
+    // Price per individual token in USDC
+    perToken: number;
+    // Total price in USDC
+    total: number;
+  }>;
+};
+
+export type GetQuoteOutput = {
+  // Amount needed to pay for the swap
+  amount: bigint;
+  poolBalance: {
+    // Balance of ERC20Z tokens in the pool
+    erc20z: bigint;
+    // Balance of WETH in the pool
+    weth: bigint;
+  };
+  // Detailed price information
+  price: QuotePrice;
+};
+
+export type BuyWithSlippageInput = {
+  // Address of the 1155 contract to interact with
+  contract: Address;
+  // 1155 token is to buy or sell
+  tokenId: bigint;
+  // Amount of tokens to buy or sell
+  quantity: bigint;
+  // Account to use for the transaction
+  account: Address | Account;
+  // Slippage percentage (optional), defaults to 0.005 (0.5%)
+  slippage?: number;
+  // Optional recipient address (if different from buyer/seller)
+  recipient?: Address;
+};
+
+// Same structure as BuyWithSlippageInput
+export type SellWithSlippageInput = BuyWithSlippageInput;
+
+export type SecondaryInfo = {
+  // Whether the secondary market is activated
+  secondaryActivated: boolean;
+  // Address of the liquidity pool for the erc20z to WETH pair
+  pool: Address;
+  // Address of the erc20z token
+  erc20z: Address;
+  // Timestamp when the secondary market will end
+  saleEnd?: bigint;
+};

package/src/secondary/uniswap/abis.ts

@@ -0,0 +1,20 @@
+import { parseAbi } from "viem";
+
+export const uniswapQuoterABI = 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)",
+]);
+
+export const uniswapV3PoolAbi = 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)",
+]);
+
+export const uniswapV2USDCAbi = parseAbi([
+  "function getReserves() external view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast)",
+]);

package/src/secondary/uniswap/uniswapQuote.ts

@@ -0,0 +1,134 @@
+import { Address, erc20Abi } from "viem";
+import { PublicClient as PublicClientWithMulticall } from "viem";
+import { PublicClient } from "src/utils";
+import { getEthPriceInUSDC } from "./uniswapReserves";
+import { convertWeiToSparks, convertWeiToUSD } from "../conversions";
+
+import { uniswapV3PoolAbi } from "./abis";
+import { wethAddress as wethAddresses } from "@zoralabs/protocol-deployments";
+
+import { GetQuoteOutput } from "../types";
+import {
+  quoteExactInputSingle,
+  quoteExactOutputSingle,
+} from "./uniswapQuoteExact";
+import { multicall3Address } from "src/apis/multicall3";
+
+async function getPoolInfo({
+  poolAddress,
+  client,
+  WETH,
+  erc20z,
+}: {
+  poolAddress: Address;
+  WETH: Address;
+  erc20z: Address;
+  client: PublicClient;
+}) {
+  const [fee, wethBalance, erc20zBalance] = await (
+    client as PublicClientWithMulticall
+  ).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,
+  };
+}
+
+type GetQuoteInput = {
+  // Indicates whether the quote is for buying or selling
+  type: "buy" | "sell";
+  // The amount of tokens to buy or sell
+  quantity: bigint;
+  poolAddress: Address;
+  erc20z: Address;
+  chainId: number;
+};
+export async function getUniswapQuote(
+  input: GetQuoteInput,
+  client: PublicClient,
+): Promise<GetQuoteOutput> {
+  const { type, quantity, poolAddress, chainId, erc20z } = input;
+
+  const WETH = wethAddresses[chainId as keyof typeof wethAddresses];
+
+  const pool = await getPoolInfo({ poolAddress, WETH, erc20z, client });
+
+  const { fee, wethBalance, erc20zBalance } = pool;
+
+  // 1 unit always comes to 1e18 erc20 equivalent
+  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,
+    },
+  };
+}