@clober/v2-sdk 0.0.1-a → 0.0.1-b

package/src/utils/tick.ts

@@ -0,0 +1,104 @@
+import { PRICE_PRECISION } from '../constants/price'
+
+import { lnWad } from './math'
+
+const _R0 = 0xfff97272373d413259a46990n
+const _R1 = 0xfff2e50f5f656932ef12357cn
+const _R2 = 0xffe5caca7e10e4e61c3624ean
+const _R3 = 0xffcb9843d60f6159c9db5883n
+const _R4 = 0xff973b41fa98c081472e6896n
+const _R5 = 0xff2ea16466c96a3843ec78b3n
+const _R6 = 0xfe5dee046a99a2a811c461f1n
+const _R7 = 0xfcbe86c7900a88aedcffc83bn
+const _R8 = 0xf987a7253ac413176f2b074cn
+const _R9 = 0xf3392b0822b70005940c7a39n
+const _R10 = 0xe7159475a2c29b7443b29c7fn
+const _R11 = 0xd097f3bdfd2022b8845ad8f7n
+const _R12 = 0xa9f746462d870fdf8a65dc1fn
+const _R13 = 0x70d869a156d2a1b890bb3df6n
+const _R14 = 0x31be135f97d08fd981231505n
+const _R15 = 0x9aa508b5b7a84e1c677de54n
+const _R16 = 0x5d6af8dedb81196699c329n
+const _R17 = 0x2216e584f5fa1ea92604n
+const _R18 = 0x48a170391f7dc42n
+
+export const invertPrice = (price: bigint): bigint => {
+  return price ? (1n << (PRICE_PRECISION * 2n)) / price : 0n
+}
+
+export const fromPrice = (price: bigint): bigint => {
+  const tick = (lnWad(price) * 42951820407860n) / 2n ** 128n
+  if (toPrice(tick) > price) {
+    return tick - 1n
+  }
+  return tick
+}
+
+export const toPrice = (tick: bigint): bigint => {
+  const absTick = tick < 0n ? -tick : tick
+  let price = 0n
+  if ((absTick & 0x1n) !== 0n) {
+    price = _R0
+  } else {
+    price = 1n << PRICE_PRECISION
+  }
+  if ((absTick & 0x2n) != 0n) {
+    price = (price * _R1) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x4n) != 0n) {
+    price = (price * _R2) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x8n) != 0n) {
+    price = (price * _R3) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x10n) != 0n) {
+    price = (price * _R4) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x20n) != 0n) {
+    price = (price * _R5) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x40n) != 0n) {
+    price = (price * _R6) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x80n) != 0n) {
+    price = (price * _R7) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x100n) != 0n) {
+    price = (price * _R8) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x200n) != 0n) {
+    price = (price * _R9) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x400n) != 0n) {
+    price = (price * _R10) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x800n) != 0n) {
+    price = (price * _R11) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x1000n) != 0n) {
+    price = (price * _R12) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x2000n) != 0n) {
+    price = (price * _R13) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x4000n) != 0n) {
+    price = (price * _R14) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x8000n) != 0n) {
+    price = (price * _R15) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x10000n) != 0n) {
+    price = (price * _R16) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x20000n) != 0n) {
+    price = (price * _R17) >> PRICE_PRECISION
+  }
+  if ((absTick & 0x40000n) != 0n) {
+    price = (price * _R18) >> PRICE_PRECISION
+  }
+  if (tick > 0n) {
+    price = 0x1000000000000000000000000000000000000000000000000n / price
+  }
+
+  return price
+}

package/src/utils/time.ts

@@ -0,0 +1,6 @@
+const currentTimestampInSeconds = (): number =>
+  Math.floor(new Date().getTime() / 1000)
+
+export const getDeadlineTimestampInSeconds = (): bigint => {
+  return BigInt(Math.floor(currentTimestampInSeconds() + 60 * 20))
+}

package/src/utils/unit.ts

@@ -0,0 +1,43 @@
+import { createPublicClient, http, isAddressEqual, zeroAddress } from 'viem'
+
+import { Currency } from '../model/currency'
+import { CHAIN_IDS, CHAIN_MAP } from '../constants/chain'
+
+const _abi = [
+  {
+    inputs: [],
+    name: 'totalSupply',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
+export const calculateUnit = async (
+  chainId: CHAIN_IDS,
+  quote: Currency,
+  rpcUrl?: string,
+) => {
+  if (isAddressEqual(quote.address, zeroAddress)) {
+    return 10n ** 12n
+  }
+  const publicClient = createPublicClient({
+    chain: CHAIN_MAP[chainId],
+    transport: rpcUrl ? http(rpcUrl) : http(),
+  })
+  const totalSupply = await publicClient.readContract({
+    address: quote.address,
+    abi: _abi,
+    functionName: 'totalSupply',
+  })
+  return (
+    10n **
+    BigInt(totalSupply <= 2n ** 64n ? 0n : Math.max(quote.decimals - 6, 0))
+  )
+}

package/src/view.ts

@@ -0,0 +1,258 @@
+import { formatUnits, isAddressEqual, parseUnits } from 'viem'
+
+import { fetchMarket } from './apis/market'
+import { CHAIN_IDS } from './constants/chain'
+import { Market } from './type'
+import { parsePrice } from './utils/prices'
+import { MAX_PRICE } from './constants/price'
+import { fetchOpenOrder, fetchOpenOrders } from './apis/open-order'
+import { OpenOrder } from './model/open-order'
+
+/**
+ * Get market information by chain id and token addresses
+ * @param chainId - chain id from {@link CHAIN_IDS}
+ * @param token0 - token0 address
+ * @param token1 - token1 address
+ * @param options
+ * @param options.rpcUrl - RPC URL of the blockchain
+ * @returns A market {@link Market}
+ *
+ * @example
+ * import { getMarket } from '@clober/v2-sdk'
+ *
+ * const market = await getMarket(
+ *   421614,
+ *  '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+ *  '0x0000000000000000000000000000000000000000',
+ * )
+ */
+export const getMarket = async (
+  chainId: CHAIN_IDS,
+  token0: `0x${string}`,
+  token1: `0x${string}`,
+  options?: { rpcUrl?: string },
+): Promise<Market> => {
+  if (isAddressEqual(token0, token1)) {
+    throw new Error('Token0 and token1 must be different')
+  }
+  const market = await fetchMarket(chainId, [token0, token1], options?.rpcUrl)
+  return {
+    chainId,
+    quote: market.quote,
+    base: market.base,
+    makerFee: market.makerFee,
+    takerFee: market.takerFee,
+    bids: market.bids,
+    bidBookOpen: market.bidBookOpen,
+    asks: market.asks,
+    askBookOpen: market.askBookOpen,
+  }
+}
+
+/**
+ * Calculates the expected output for a given input amount, based on the provided market data.
+ *
+ * @param chainId The chain ID of the blockchain.
+ * @param inputToken The address of the input token.
+ * @param outputToken The address of the output token.
+ * @param amountIn The amount of expected input amount. (ex 1.2 ETH -> 1.2)
+ * @param options
+ * @param options.limitPrice The maximum limit price to spend.
+ * @param options.rpcUrl The RPC URL of the blockchain.
+ * @returns A Promise resolving to an object containing the taken amount, spend amount and result of the calculation.
+ * @example
+ * import { getExpectedOutput } from '@clober/v2-sdk'
+ *
+ * const { takenAmount, spendAmount } = await getExpectedOutput(
+ *   421614,
+ *  '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+ *  '0x0000000000000000000000000000000000000000',
+ *  '1000.123', // spend 1000.123 USDC
+ * )
+ */
+export const getExpectedOutput = async (
+  chainId: CHAIN_IDS,
+  inputToken: `0x${string}`,
+  outputToken: `0x${string}`,
+  amountIn: string,
+  options?: { limitPrice?: string; rpcUrl?: string },
+): Promise<{
+  takenAmount: string
+  spendAmount: string
+  result: { bookId: bigint; takenAmount: bigint; spendAmount: bigint }[]
+}> => {
+  const market = await fetchMarket(
+    chainId,
+    [inputToken, outputToken],
+    options?.rpcUrl,
+  )
+  const isBid = isAddressEqual(market.quote.address, inputToken)
+  const rawLimitPrice =
+    options && options.limitPrice
+      ? parsePrice(
+          Number(options.limitPrice),
+          market.quote.decimals,
+          market.base.decimals,
+        )
+      : isBid
+        ? MAX_PRICE
+        : 0n
+  const inputCurrency = isBid ? market.quote : market.base
+  const result = market.spend({
+    spendBase: !isBid,
+    limitPrice: rawLimitPrice,
+    amountIn: parseUnits(amountIn, inputCurrency.decimals),
+  })
+  const { takenAmount, spendAmount } = Object.values(result).reduce(
+    (acc, { takenAmount, spendAmount }) => ({
+      takenAmount: acc.takenAmount + takenAmount,
+      spendAmount: acc.spendAmount + spendAmount,
+    }),
+    { takenAmount: 0n, spendAmount: 0n },
+  )
+  return {
+    takenAmount: formatUnits(
+      takenAmount,
+      isBid ? market.base.decimals : market.quote.decimals,
+    ),
+    spendAmount: formatUnits(
+      spendAmount,
+      isBid ? market.quote.decimals : market.base.decimals,
+    ),
+    result: Object.entries(result).map(
+      ([bookId, { takenAmount, spendAmount }]) => ({
+        bookId: BigInt(bookId),
+        takenAmount,
+        spendAmount,
+      }),
+    ),
+  }
+}
+
+/**
+ * Calculates the expected input for a given output amount, based on the provided market data.
+ *
+ * @param chainId The chain ID of the blockchain.
+ * @param inputToken The address of the input token.
+ * @param outputToken The address of the output token.
+ * @param amountOut The amount of expected output amount. (ex 1.2 ETH -> 1.2)
+ * @param options
+ * @param options.limitPrice The maximum limit price to take.
+ * @param options.rpcUrl The RPC URL of the blockchain.
+ * @returns A Promise resolving to an object containing the taken amount, spend amount and result of the calculation.
+ * @example
+ * import { getExpectedInput } from '@clober/v2-sdk'
+ *
+ * const { takenAmount, spendAmount } = await getExpectedInput(
+ *   421614,
+ *  '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+ *  '0x0000000000000000000000000000000000000000',
+ *  '0.1', // take 0.1 ETH
+ * )
+ */
+export const getExpectedInput = async (
+  chainId: CHAIN_IDS,
+  inputToken: `0x${string}`,
+  outputToken: `0x${string}`,
+  amountOut: string,
+  options?: { limitPrice?: string; rpcUrl?: string },
+): Promise<{
+  takenAmount: string
+  spendAmount: string
+  result: { bookId: bigint; takenAmount: bigint; spendAmount: bigint }[]
+}> => {
+  const market = await fetchMarket(
+    chainId,
+    [inputToken, outputToken],
+    options?.rpcUrl,
+  )
+  const isBid = isAddressEqual(market.quote.address, inputToken)
+  const rawLimitPrice =
+    options && options.limitPrice
+      ? parsePrice(
+          Number(options.limitPrice),
+          market.quote.decimals,
+          market.base.decimals,
+        )
+      : isBid
+        ? MAX_PRICE
+        : 0n
+  const outputCurrency = isBid ? market.base : market.quote
+  const result = market.take({
+    takeQuote: !isBid,
+    limitPrice: rawLimitPrice,
+    amountOut: parseUnits(amountOut, outputCurrency.decimals),
+  })
+  const { takenAmount, spendAmount } = Object.values(result).reduce(
+    (acc, { takenAmount, spendAmount }) => ({
+      takenAmount: acc.takenAmount + takenAmount,
+      spendAmount: acc.spendAmount + spendAmount,
+    }),
+    { takenAmount: 0n, spendAmount: 0n },
+  )
+  return {
+    takenAmount: formatUnits(
+      takenAmount,
+      isBid ? market.base.decimals : market.quote.decimals,
+    ),
+    spendAmount: formatUnits(
+      spendAmount,
+      isBid ? market.quote.decimals : market.base.decimals,
+    ),
+    result: Object.entries(result).map(
+      ([bookId, { takenAmount, spendAmount }]) => ({
+        bookId: BigInt(bookId),
+        takenAmount,
+        spendAmount,
+      }),
+    ),
+  }
+}
+
+/**
+ * Retrieves the open order with the specified ID on the given chain.
+ *
+ * @param {CHAIN_IDS} chainId The chain ID.
+ * @param {string} id The ID of the open order.
+ * @param options
+ * @param options.rpcUrl The RPC URL of the blockchain.
+ * @returns {Promise<OpenOrder>} Promise resolving to the open order object, or undefined if not found.
+ * @example
+ * import { getOpenOrder } from '@clober/v2-sdk'
+ *
+ * const openOrder = await getOpenOrder(
+ *   421614,
+ *  '46223845323662364279893361453861711542636620039907198451770258805035840307200'
+ * )
+ */
+export const getOpenOrder = async (
+  chainId: CHAIN_IDS,
+  id: string,
+  options?: { rpcUrl?: string },
+): Promise<OpenOrder> => {
+  return fetchOpenOrder(chainId, id, options?.rpcUrl)
+}
+
+/**
+ * Retrieves open orders for the specified user on the given chain.
+ *
+ * @param {CHAIN_IDS} chainId The chain ID.
+ * @param {`0x${string}`} userAddress The Ethereum address of the user.
+ * @param options
+ * @param options.rpcUrl The RPC URL of the blockchain.
+ * @returns {Promise<OpenOrder[]>} Promise resolving to an array of open orders.
+ * @example
+ * import { getOpenOrders } from '@clober/v2-sdk'
+ *
+ * const openOrders = await getOpenOrders(
+ *   421614,
+ *  '0x5F79EE8f8fA862E98201120d83c4eC39D9468D49'
+ * )
+ */
+export const getOpenOrders = async (
+  chainId: CHAIN_IDS,
+  userAddress: `0x${string}`,
+  options?: { rpcUrl?: string },
+): Promise<OpenOrder[]> => {
+  return fetchOpenOrders(chainId, userAddress, options?.rpcUrl)
+}

package/test/book-id.test.ts

@@ -0,0 +1,101 @@
+import { expect, test } from 'vitest'
+
+import { toBookId } from '../src/utils/book-id'
+import {
+  MAKER_DEFAULT_POLICY,
+  TAKER_DEFAULT_POLICY,
+} from '../src/constants/fee'
+
+import { publicClient } from './utils/constants'
+
+const _abi = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: 'Currency',
+            name: 'base',
+            type: 'address',
+          },
+          {
+            internalType: 'uint64',
+            name: 'unit',
+            type: 'uint64',
+          },
+          {
+            internalType: 'Currency',
+            name: 'quote',
+            type: 'address',
+          },
+          {
+            internalType: 'FeePolicy',
+            name: 'makerPolicy',
+            type: 'uint24',
+          },
+          {
+            internalType: 'contract IHooks',
+            name: 'hooks',
+            type: 'address',
+          },
+          {
+            internalType: 'FeePolicy',
+            name: 'takerPolicy',
+            type: 'uint24',
+          },
+        ],
+        internalType: 'struct IBookManager.BookKey',
+        name: 'bookKey',
+        type: 'tuple',
+      },
+    ],
+    name: 'toId',
+    outputs: [
+      {
+        internalType: 'BookId',
+        name: 'id',
+        type: 'uint192',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+] as const
+
+const BOOK_ID_WRAPPER_ADDRESS = '0xbBa11dC70D31578fA426FB0EaCed79EB844F93A7'
+
+test('check toBookId function', async () => {
+  const bidBookKey = {
+    base: '0x0000000000000000000000000000000000000000' as `0x${string}`,
+    unit: 10n ** 12n,
+    quote: '0x447ad4a108b5540c220f9f7e83723ac87c0f8fd8' as `0x${string}`,
+    makerPolicy: Number(MAKER_DEFAULT_POLICY.value),
+    hooks: '0x0000000000000000000000000000000000000000' as `0x${string}`,
+    takerPolicy: Number(TAKER_DEFAULT_POLICY.value),
+  }
+  expect(
+    await publicClient.readContract({
+      address: BOOK_ID_WRAPPER_ADDRESS,
+      abi: _abi,
+      functionName: 'toId',
+      args: [bidBookKey],
+    }),
+  ).toBe(toBookId(bidBookKey.quote, bidBookKey.base, bidBookKey.unit))
+
+  const askBookKey = {
+    base: '0x447ad4a108b5540c220f9f7e83723ac87c0f8fd8' as `0x${string}`,
+    unit: 10n ** 1n,
+    quote: '0x0000000000000000000000000000000000000000' as `0x${string}`,
+    makerPolicy: Number(MAKER_DEFAULT_POLICY.value),
+    hooks: '0x0000000000000000000000000000000000000000' as `0x${string}`,
+    takerPolicy: Number(TAKER_DEFAULT_POLICY.value),
+  }
+  expect(
+    await publicClient.readContract({
+      address: BOOK_ID_WRAPPER_ADDRESS,
+      abi: _abi,
+      functionName: 'toId',
+      args: [askBookKey],
+    }),
+  ).toBe(toBookId(askBookKey.quote, askBookKey.base, askBookKey.unit))
+})