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

package/src/utils/unit.ts

@@ -1,43 +0,0 @@
-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

@@ -1,258 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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))
-})

package/test/fee-policy.test.ts

@@ -1,228 +0,0 @@
-import { expect, test } from 'vitest'
-
-import { FeePolicy } from '../src/model/fee-policy'
-import {
-  MAKER_DEFAULT_POLICY,
-  TAKER_DEFAULT_POLICY,
-} from '../src/constants/fee'
-
-import { publicClient } from './utils/constants'
-
-const _abi = [
-  {
-    inputs: [],
-    name: 'InvalidFeePolicy',
-    type: 'error',
-  },
-  {
-    inputs: [
-      {
-        internalType: 'FeePolicy',
-        name: 'self',
-        type: 'uint24',
-      },
-      {
-        internalType: 'uint256',
-        name: 'amount',
-        type: 'uint256',
-      },
-      {
-        internalType: 'bool',
-        name: 'reverseRounding',
-        type: 'bool',
-      },
-    ],
-    name: 'calculateFee',
-    outputs: [
-      {
-        internalType: 'int256',
-        name: 'fee',
-        type: 'int256',
-      },
-    ],
-    stateMutability: 'pure',
-    type: 'function',
-  },
-  {
-    inputs: [
-      {
-        internalType: 'FeePolicy',
-        name: 'self',
-        type: 'uint24',
-      },
-      {
-        internalType: 'uint256',
-        name: 'amount',
-        type: 'uint256',
-      },
-      {
-        internalType: 'bool',
-        name: 'reverseFee',
-        type: 'bool',
-      },
-    ],
-    name: 'calculateOriginalAmount',
-    outputs: [
-      {
-        internalType: 'uint256',
-        name: 'originalAmount',
-        type: 'uint256',
-      },
-    ],
-    stateMutability: 'pure',
-    type: 'function',
-  },
-  {
-    inputs: [
-      {
-        internalType: 'bool',
-        name: 'usesQuote_',
-        type: 'bool',
-      },
-      {
-        internalType: 'int24',
-        name: 'rate_',
-        type: 'int24',
-      },
-    ],
-    name: 'encode',
-    outputs: [
-      {
-        internalType: 'FeePolicy',
-        name: 'feePolicy',
-        type: 'uint24',
-      },
-    ],
-    stateMutability: 'pure',
-    type: 'function',
-  },
-  {
-    inputs: [
-      {
-        internalType: 'FeePolicy',
-        name: 'self',
-        type: 'uint24',
-      },
-    ],
-    name: 'usesQuote',
-    outputs: [
-      {
-        internalType: 'bool',
-        name: 'f',
-        type: 'bool',
-      },
-    ],
-    stateMutability: 'pure',
-    type: 'function',
-  },
-] as const
-
-const FEE_POLICY_WRAPPER_ADDRESS = '0x226Dad19a0C0E0faEB488601B61B1B67E434db6a'
-
-const encode = async (usesQuote: boolean, rate: number) => {
-  const mockPolicy = new FeePolicy(usesQuote, BigInt(rate))
-  const policy = await publicClient.readContract({
-    address: FEE_POLICY_WRAPPER_ADDRESS,
-    abi: _abi,
-    functionName: 'encode',
-    args: [usesQuote, rate],
-  })
-  expect(policy).toEqual(Number(mockPolicy.value))
-  expect(
-    await publicClient.readContract({
-      address: FEE_POLICY_WRAPPER_ADDRESS,
-      abi: _abi,
-      functionName: 'usesQuote',
-      args: [policy],
-    }),
-  ).toEqual(mockPolicy.usesQuote)
-}
-
-const checkCalculateFee = async (
-  policy: FeePolicy,
-  amount: bigint,
-  reverseRounding: boolean,
-) => {
-  expect(
-    await publicClient.readContract({
-      address: FEE_POLICY_WRAPPER_ADDRESS,
-      abi: _abi,
-      functionName: 'calculateFee',
-      args: [Number(policy.value), amount, reverseRounding],
-    }),
-  ).toEqual(policy.calculateFee(amount, reverseRounding))
-}
-
-const checkCalculateOriginalAmount = async (
-  policy: FeePolicy,
-  amount: bigint,
-  reverseFee: boolean,
-) => {
-  expect(
-    await publicClient.readContract({
-      address: FEE_POLICY_WRAPPER_ADDRESS,
-      abi: _abi,
-      functionName: 'calculateOriginalAmount',
-      args: [Number(policy.value), amount, reverseFee],
-    }),
-  ).toEqual(policy.calculateOriginalAmount(amount, reverseFee))
-}
-
-const checkFrom = async (policy: FeePolicy) => {
-  const _feePolicy = FeePolicy.from(policy.value)
-  expect(policy.usesQuote).toEqual(_feePolicy.usesQuote)
-  expect(policy.value).toEqual(_feePolicy.value)
-}
-
-test('check encode function', async () => {
-  await encode(true, 0)
-  await encode(true, 1)
-  await encode(true, Number(MAKER_DEFAULT_POLICY.rate))
-  await encode(true, Number(TAKER_DEFAULT_POLICY.rate))
-  await encode(true, 500000)
-  await encode(true, -500000)
-  await encode(false, 0)
-  await encode(false, 1)
-  await encode(false, 500000)
-  await encode(false, -500000)
-  await encode(false, Number(MAKER_DEFAULT_POLICY.rate))
-  await encode(false, Number(TAKER_DEFAULT_POLICY.rate))
-})
-
-test('check calculateFee function', async () => {
-  await checkCalculateFee(new FeePolicy(true, 0n), 1000000n, false)
-  await checkCalculateFee(new FeePolicy(true, 1n), 1000000n, false)
-  await checkCalculateFee(MAKER_DEFAULT_POLICY, 1000000n, false)
-  await checkCalculateFee(TAKER_DEFAULT_POLICY, 1000000n, false)
-  await checkCalculateFee(new FeePolicy(true, 500000n), 1000000n, false)
-  await checkCalculateFee(new FeePolicy(true, -500000n), 1000000n, false)
-})
-
-test('check calculateOriginalAmount function', async () => {
-  await checkCalculateOriginalAmount(new FeePolicy(true, 0n), 1000000n, false)
-  await checkCalculateOriginalAmount(new FeePolicy(true, 1n), 1000000n, false)
-  await checkCalculateOriginalAmount(MAKER_DEFAULT_POLICY, 1000000n, false)
-  await checkCalculateOriginalAmount(TAKER_DEFAULT_POLICY, 1000000n, false)
-  await checkCalculateOriginalAmount(
-    new FeePolicy(true, 500000n),
-    1000000n,
-    false,
-  )
-  await checkCalculateOriginalAmount(
-    new FeePolicy(true, -500000n),
-    1000000n,
-    false,
-  )
-})
-
-test('check static object', async () => {
-  checkFrom(new FeePolicy(true, 0n))
-  checkFrom(new FeePolicy(true, 1n))
-  checkFrom(MAKER_DEFAULT_POLICY)
-  checkFrom(TAKER_DEFAULT_POLICY)
-
-  checkFrom(new FeePolicy(false, 0n))
-  checkFrom(new FeePolicy(false, 1n))
-  checkFrom(MAKER_DEFAULT_POLICY)
-  checkFrom(TAKER_DEFAULT_POLICY)
-})