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

package/src/constants/addresses.ts

@@ -1,17 +0,0 @@
-import { getAddress } from 'viem'
-
-import { CHAIN_IDS } from './chain'
-
-export const CONTRACT_ADDRESSES: {
-  [chain in CHAIN_IDS]: {
-    Controller: `0x${string}`
-    BookManager: `0x${string}`
-    BookViewer: `0x${string}`
-  }
-} = {
-  [CHAIN_IDS.ARBITRUM_SEPOLIA]: {
-    Controller: getAddress('0xfAe4A04fa491DC21F77796394532a1B62d8331BF'),
-    BookManager: getAddress('0x4a4eaF7382821da4Fb85e8A8d515f5555383d58A'),
-    BookViewer: getAddress('0xA7603C4c895a533E66c30EA76cC6F6A6A0c5cbFe'),
-  },
-}

package/src/constants/chain.ts

@@ -1,12 +0,0 @@
-import { arbitrumSepolia, type Chain, mainnet } from 'viem/chains'
-
-export enum CHAIN_IDS {
-  MAINNET = mainnet.id,
-  ARBITRUM_SEPOLIA = arbitrumSepolia.id,
-}
-
-export const CHAIN_MAP: {
-  [chain in CHAIN_IDS]: Chain
-} = {
-  [CHAIN_IDS.ARBITRUM_SEPOLIA]: arbitrumSepolia,
-}

package/src/constants/currency.ts

@@ -1,15 +0,0 @@
-import { zeroAddress } from 'viem'
-
-import { CHAIN_IDS } from './chain'
-
-export const WETH_ADDRESSES: {
-  [chain in CHAIN_IDS]: `0x${string}`[]
-} = {
-  [CHAIN_IDS.ARBITRUM_SEPOLIA]: [zeroAddress],
-}
-
-export const STABLE_COIN_ADDRESSES: {
-  [chain in CHAIN_IDS]: `0x${string}`[]
-} = {
-  [CHAIN_IDS.ARBITRUM_SEPOLIA]: ['0x00BFD44e79FB7f6dd5887A9426c8EF85A0CD23e0'],
-}

package/src/constants/fee.ts

@@ -1,4 +0,0 @@
-import { FeePolicy } from '../model/fee-policy'
-
-export const MAKER_DEFAULT_POLICY = new FeePolicy(true, -300n) // -0.03%
-export const TAKER_DEFAULT_POLICY = new FeePolicy(true, 1000n) // 0.1%

package/src/constants/price.ts

@@ -1,3 +0,0 @@
-export const MAX_PRICE = 4647684107270898330752324302845848816923571339324334n
-
-export const PRICE_PRECISION = 96n

package/src/constants/subgraph-url.ts

@@ -1,8 +0,0 @@
-import { CHAIN_IDS } from './chain'
-
-export const SUBGRAPH_URL: {
-  [chain in CHAIN_IDS]: string
-} = {
-  [CHAIN_IDS.ARBITRUM_SEPOLIA]:
-    'https://subgraph.satsuma-prod.com/f6a8c4889b7b/clober/v2-core-subgraph/api',
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from './type'
-export * from './view'
-export * from './call'
-export * from './signature'
-export * from './approval'

package/src/model/book.ts

@@ -1,166 +0,0 @@
-import { toPrice } from '../utils/tick'
-import { TAKER_DEFAULT_POLICY } from '../constants/fee'
-import { divide } from '../utils/math'
-import { baseToQuote, quoteToBase } from '../utils/decimals'
-
-import type { Currency } from './currency'
-import type { RawDepth } from './depth'
-
-export class Book {
-  id: bigint
-  base: Currency
-  unit: bigint
-  quote: Currency
-  depths: RawDepth[]
-
-  constructor({
-    id,
-    base,
-    quote,
-    unit,
-    depths,
-  }: {
-    id: bigint
-    base: Currency
-    quote: Currency
-    unit: bigint
-    depths: RawDepth[]
-  }) {
-    this.id = id
-    this.base = base
-    this.unit = unit
-    this.quote = quote
-    this.depths = depths
-  }
-
-  take = ({
-    limitPrice,
-    amountOut, // quote
-  }: {
-    limitPrice: bigint
-    amountOut: bigint
-  }) => {
-    let takenQuoteAmount = 0n
-    let spendBaseAmount = 0n
-    if (this.depths.length === 0) {
-      return {
-        takenQuoteAmount,
-        spendBaseAmount,
-      }
-    }
-
-    const ticks = this.depths
-      .sort((a, b) => Number(b.tick) - Number(a.tick))
-      .map((depth) => depth.tick)
-    let index = 0
-    let tick = ticks[index]!
-    while (tick > -8388608n) {
-      if (limitPrice > toPrice(tick)) {
-        break
-      }
-      let maxAmount = TAKER_DEFAULT_POLICY.usesQuote
-        ? TAKER_DEFAULT_POLICY.calculateOriginalAmount(
-            amountOut - takenQuoteAmount,
-            true,
-          )
-        : amountOut - takenQuoteAmount
-      maxAmount = divide(maxAmount, this.unit, true)
-
-      if (maxAmount === 0n) {
-        break
-      }
-      const currentDepth = this.depths.find((depth) => depth.tick === tick)!
-      let quoteAmount =
-        (currentDepth.rawAmount > maxAmount
-          ? maxAmount
-          : currentDepth.rawAmount) * this.unit
-      let baseAmount = quoteToBase(tick, quoteAmount, true)
-      if (TAKER_DEFAULT_POLICY.usesQuote) {
-        quoteAmount =
-          quoteAmount - TAKER_DEFAULT_POLICY.calculateFee(quoteAmount, false)
-      } else {
-        baseAmount =
-          baseAmount + TAKER_DEFAULT_POLICY.calculateFee(baseAmount, false)
-      }
-      if (quoteAmount === 0n) {
-        break
-      }
-
-      takenQuoteAmount += quoteAmount
-      spendBaseAmount += baseAmount
-      if (amountOut <= takenQuoteAmount) {
-        break
-      }
-      index++
-      tick = ticks[index]!
-    }
-    return {
-      takenQuoteAmount,
-      spendBaseAmount,
-    }
-  }
-
-  spend = ({
-    limitPrice,
-    amountIn, // base
-  }: {
-    limitPrice: bigint
-    amountIn: bigint
-  }) => {
-    let takenQuoteAmount = 0n
-    let spendBaseAmount = 0n
-    if (this.depths.length === 0) {
-      return {
-        takenQuoteAmount,
-        spendBaseAmount,
-      }
-    }
-
-    const ticks = this.depths
-      .sort((a, b) => Number(b.tick) - Number(a.tick))
-      .map((depth) => depth.tick)
-    let index = 0
-    let tick = ticks[index]!
-    while (spendBaseAmount <= amountIn && tick > -8388608n) {
-      if (limitPrice > toPrice(tick)) {
-        break
-      }
-      let maxAmount = TAKER_DEFAULT_POLICY.usesQuote
-        ? amountIn - spendBaseAmount
-        : TAKER_DEFAULT_POLICY.calculateOriginalAmount(
-            amountIn - spendBaseAmount,
-            false,
-          )
-      maxAmount = baseToQuote(tick, maxAmount, false) / this.unit
-
-      if (maxAmount === 0n) {
-        break
-      }
-      const currentDepth = this.depths.find((depth) => depth.tick === tick)!
-      let quoteAmount =
-        (currentDepth.rawAmount > maxAmount
-          ? maxAmount
-          : currentDepth.rawAmount) * this.unit
-      let baseAmount = quoteToBase(tick, quoteAmount, true)
-      if (TAKER_DEFAULT_POLICY.usesQuote) {
-        quoteAmount =
-          quoteAmount - TAKER_DEFAULT_POLICY.calculateFee(quoteAmount, false)
-      } else {
-        baseAmount =
-          baseAmount + TAKER_DEFAULT_POLICY.calculateFee(baseAmount, false)
-      }
-      if (baseAmount === 0n) {
-        break
-      }
-
-      takenQuoteAmount += quoteAmount
-      spendBaseAmount += baseAmount
-      index++
-      tick = ticks[index]!
-    }
-    return {
-      takenQuoteAmount,
-      spendBaseAmount,
-    }
-  }
-}

package/src/model/currency.ts

@@ -1,6 +0,0 @@
-export type Currency = {
-  address: `0x${string}`
-  name: string
-  symbol: string
-  decimals: number
-}

package/src/model/depth.ts

@@ -1,11 +0,0 @@
-export type RawDepth = {
-  bookId: string
-  unit: bigint
-  tick: bigint
-  rawAmount: bigint
-}
-
-export type Depth = {
-  price: number
-  baseAmount: bigint
-}

package/src/model/fee-policy.ts

@@ -1,51 +0,0 @@
-import { divide } from '../utils/math'
-
-export class FeePolicy {
-  static readonly MAX_FEE_RATE = 500000n
-  static readonly MIN_FEE_RATE = -500000n
-  static readonly RATE_MASK = 0x7fffffn
-  readonly RATE_PRECISION = 10n ** 6n
-  public usesQuote: boolean
-  public value: bigint
-  public rate: bigint
-
-  constructor(usesQuote: boolean, rate: bigint) {
-    this.usesQuote = usesQuote
-    this.rate = rate
-
-    if (rate > FeePolicy.MAX_FEE_RATE || rate < FeePolicy.MIN_FEE_RATE) {
-      throw new Error('InvalidFeePolicy')
-    }
-    const mask = usesQuote ? 1n << 23n : 0n
-    this.value = (rate + FeePolicy.MAX_FEE_RATE) | mask
-  }
-
-  public static from(value: bigint): FeePolicy {
-    const usesQuote = value >> 23n > 0n
-    return new FeePolicy(usesQuote, FeePolicy.getRateFromValue(value))
-  }
-
-  private static getRateFromValue = (value: bigint): bigint => {
-    return (value & FeePolicy.RATE_MASK) - FeePolicy.MAX_FEE_RATE
-  }
-
-  public calculateFee = (amount: bigint, reverseRounding: boolean): bigint => {
-    const positive = this.rate > 0n
-    const absRate = positive ? this.rate : -this.rate
-    const absFee = divide(
-      amount * absRate,
-      this.RATE_PRECISION,
-      reverseRounding ? !positive : positive,
-    )
-    return positive ? absFee : -absFee
-  }
-
-  public calculateOriginalAmount = (
-    amount: bigint,
-    reverseFee: boolean,
-  ): bigint => {
-    const positive = this.rate > 0
-    const divider = this.RATE_PRECISION + (reverseFee ? -this.rate : this.rate)
-    return divide(amount * this.RATE_PRECISION, divider, positive)
-  }
-}

package/src/model/market.ts

@@ -1,320 +0,0 @@
-import { isAddressEqual } from 'viem'
-
-import { getMarketId } from '../utils/market'
-import { CHAIN_IDS } from '../constants/chain'
-import { invertPrice, toPrice } from '../utils/tick'
-import { formatPrice } from '../utils/prices'
-import { MAKER_DEFAULT_POLICY, TAKER_DEFAULT_POLICY } from '../constants/fee'
-import { divide } from '../utils/math'
-import { baseToQuote, quoteToBase } from '../utils/decimals'
-
-import { Book } from './book'
-import type { Currency } from './currency'
-import type { Depth, RawDepth } from './depth'
-
-export class Market {
-  readonly makerFee = (Number(MAKER_DEFAULT_POLICY.rate) * 100) / 1e6
-  readonly takerFee = (Number(TAKER_DEFAULT_POLICY.rate) * 100) / 1e6
-
-  id: string
-  quote: Currency
-  base: Currency
-  bids: Depth[]
-  bidBookOpen: boolean
-  asks: Depth[]
-  askBookOpen: boolean
-  private books: Book[]
-
-  constructor({
-    chainId,
-    tokens,
-    books,
-  }: {
-    chainId: CHAIN_IDS
-    tokens: [Currency, Currency]
-    books: Book[]
-  }) {
-    const { marketId, quoteTokenAddress, baseTokenAddress } = getMarketId(
-      chainId,
-      tokens.map((token) => token.address),
-    )
-    this.id = marketId
-    this.quote = tokens.find((token) =>
-      isAddressEqual(token.address, quoteTokenAddress!),
-    )!
-    this.base = tokens.find((token) =>
-      isAddressEqual(token.address, baseTokenAddress!),
-    )!
-
-    this.bids = books
-      .filter((book) => isAddressEqual(book.quote.address, this.quote.address))
-      .flatMap((book) => book.depths)
-      .map(
-        (depth) =>
-          ({
-            price: formatPrice(
-              toPrice(depth.tick),
-              this.quote.decimals,
-              this.base.decimals,
-            ),
-            baseAmount: quoteToBase(
-              depth.tick,
-              depth.rawAmount * depth.unit,
-              false,
-            ),
-          }) as Depth,
-      )
-    this.bidBookOpen =
-      books.filter((book) =>
-        isAddressEqual(book.quote.address, this.quote.address),
-      ).length > 0
-    this.asks = books
-      .filter((book) => isAddressEqual(book.quote.address, this.base.address))
-      .flatMap((book) => book.depths)
-      .map((depth) => {
-        const price = invertPrice(toPrice(depth.tick))
-        const readablePrice = formatPrice(
-          price,
-          this.quote.decimals,
-          this.base.decimals,
-        )
-        const baseAmount = depth.rawAmount * depth.unit
-        return {
-          price: readablePrice,
-          baseAmount,
-        } as Depth
-      })
-    this.askBookOpen =
-      books.filter((book) =>
-        isAddressEqual(book.quote.address, this.base.address),
-      ).length > 0
-    this.books = books
-  }
-
-  take = ({
-    takeQuote,
-    limitPrice,
-    amountOut, // quote if takeQuote, base otherwise
-  }: {
-    takeQuote: boolean
-    limitPrice: bigint
-    amountOut: bigint
-  }) => {
-    if (takeQuote) {
-      const bidDepths = this.books
-        .filter((book) =>
-          isAddressEqual(book.quote.address, this.quote.address),
-        )
-        .flatMap((book) => book.depths)
-      return this.takeInner({ depths: bidDepths, limitPrice, amountOut })
-    } else {
-      const askDepths = this.books
-        .filter((book) => isAddressEqual(book.quote.address, this.base.address))
-        .flatMap((book) => book.depths)
-      return this.takeInner({
-        depths: askDepths,
-        limitPrice: invertPrice(limitPrice),
-        amountOut,
-      })
-    }
-  }
-
-  spend = ({
-    spendBase,
-    limitPrice,
-    amountIn, // base if spendBase, quote otherwise
-  }: {
-    spendBase: boolean
-    limitPrice: bigint
-    amountIn: bigint
-  }) => {
-    if (spendBase) {
-      const bidDepths = this.books
-        .filter((book) =>
-          isAddressEqual(book.quote.address, this.quote.address),
-        )
-        .flatMap((book) => book.depths)
-      return this.spendInner({ depths: bidDepths, limitPrice, amountIn })
-    } else {
-      const askDepths = this.books
-        .filter((book) => isAddressEqual(book.quote.address, this.base.address))
-        .flatMap((book) => book.depths)
-      return this.spendInner({
-        depths: askDepths,
-        limitPrice: invertPrice(limitPrice),
-        amountIn,
-      })
-    }
-  }
-
-  private takeInner = ({
-    depths, // only bid orders
-    limitPrice,
-    amountOut, // quote
-  }: {
-    depths: RawDepth[]
-    limitPrice: bigint
-    amountOut: bigint
-  }) => {
-    if (depths.length === 0) {
-      return {}
-    }
-    const takeResult: {
-      [key in string]: {
-        takenAmount: bigint
-        spendAmount: bigint
-      }
-    } = {}
-    for (const depth of depths) {
-      if (!takeResult[depth.bookId]) {
-        takeResult[depth.bookId] = {
-          takenAmount: 0n,
-          spendAmount: 0n,
-        }
-      }
-    }
-    let totalTakenQuoteAmount = 0n
-
-    const ticks = depths
-      .sort((a, b) => Number(b.tick) - Number(a.tick))
-      .map((depth) => depth.tick)
-    let index = 0
-    let tick = ticks[index]!
-    while (tick > -8388608n) {
-      if (limitPrice > toPrice(tick)) {
-        break
-      }
-      const currentDepth = depths.find((depth) => depth.tick === tick)!
-      const currentBook = this.books.find(
-        (book) => book.id === BigInt(currentDepth.bookId),
-      )!
-      let maxAmount = TAKER_DEFAULT_POLICY.usesQuote
-        ? TAKER_DEFAULT_POLICY.calculateOriginalAmount(
-            amountOut - totalTakenQuoteAmount,
-            true,
-          )
-        : amountOut - totalTakenQuoteAmount
-      maxAmount = divide(maxAmount, currentBook.unit, true)
-
-      if (maxAmount === 0n) {
-        break
-      }
-      let quoteAmount =
-        (currentDepth.rawAmount > maxAmount
-          ? maxAmount
-          : currentDepth.rawAmount) * currentBook.unit
-      let baseAmount = quoteToBase(tick, quoteAmount, true)
-      if (TAKER_DEFAULT_POLICY.usesQuote) {
-        quoteAmount =
-          quoteAmount - TAKER_DEFAULT_POLICY.calculateFee(quoteAmount, false)
-      } else {
-        baseAmount =
-          baseAmount + TAKER_DEFAULT_POLICY.calculateFee(baseAmount, false)
-      }
-      if (quoteAmount === 0n) {
-        break
-      }
-
-      takeResult[currentDepth.bookId]!.takenAmount += quoteAmount
-      takeResult[currentDepth.bookId]!.spendAmount += baseAmount
-      totalTakenQuoteAmount += quoteAmount
-      if (amountOut <= totalTakenQuoteAmount) {
-        break
-      }
-      if (ticks.length === index + 1) {
-        break
-      }
-      index++
-      tick = ticks[index]!
-    }
-    return Object.fromEntries(
-      Object.entries(takeResult).filter(
-        ([, value]) => value.spendAmount > 0 && value.takenAmount > 0,
-      ),
-    )
-  }
-
-  private spendInner = ({
-    depths, // only bid orders
-    limitPrice,
-    amountIn, // base
-  }: {
-    depths: RawDepth[]
-    limitPrice: bigint
-    amountIn: bigint
-  }) => {
-    if (depths.length === 0) {
-      return {}
-    }
-    const spendResult: {
-      [key in string]: {
-        takenAmount: bigint
-        spendAmount: bigint
-      }
-    } = {}
-    for (const depth of depths) {
-      if (!spendResult[depth.bookId]) {
-        spendResult[depth.bookId] = {
-          takenAmount: 0n,
-          spendAmount: 0n,
-        }
-      }
-    }
-    let totalSpendBaseAmount = 0n
-
-    const ticks = depths
-      .sort((a, b) => Number(b.tick) - Number(a.tick))
-      .map((depth) => depth.tick)
-    let index = 0
-    let tick = ticks[index]!
-    while (totalSpendBaseAmount <= amountIn && tick > -8388608n) {
-      if (limitPrice > toPrice(tick)) {
-        break
-      }
-      const currentDepth = depths.find((depth) => depth.tick === tick)!
-      const currentBook = this.books.find(
-        (book) => book.id === BigInt(currentDepth.bookId),
-      )!
-      let maxAmount = TAKER_DEFAULT_POLICY.usesQuote
-        ? amountIn - totalSpendBaseAmount
-        : TAKER_DEFAULT_POLICY.calculateOriginalAmount(
-            amountIn - totalSpendBaseAmount,
-            false,
-          )
-      maxAmount = baseToQuote(tick, maxAmount, false) / currentBook.unit
-
-      if (maxAmount === 0n) {
-        break
-      }
-      let quoteAmount =
-        (currentDepth.rawAmount > maxAmount
-          ? maxAmount
-          : currentDepth.rawAmount) * currentBook.unit
-      let baseAmount = quoteToBase(tick, quoteAmount, true)
-      if (TAKER_DEFAULT_POLICY.usesQuote) {
-        quoteAmount =
-          quoteAmount - TAKER_DEFAULT_POLICY.calculateFee(quoteAmount, false)
-      } else {
-        baseAmount =
-          baseAmount + TAKER_DEFAULT_POLICY.calculateFee(baseAmount, false)
-      }
-      if (baseAmount === 0n) {
-        break
-      }
-
-      spendResult[currentDepth.bookId]!.takenAmount += quoteAmount
-      spendResult[currentDepth.bookId]!.spendAmount += baseAmount
-      totalSpendBaseAmount += baseAmount
-      if (ticks.length === index + 1) {
-        break
-      }
-      index++
-      tick = ticks[index]!
-    }
-    return Object.fromEntries(
-      Object.entries(spendResult).filter(
-        ([, value]) => value.spendAmount > 0 && value.takenAmount > 0,
-      ),
-    )
-  }
-}

package/src/model/open-order.ts

@@ -1,16 +0,0 @@
-import { Currency } from './currency'
-
-export type OpenOrder = {
-  id: string
-  isBid: boolean
-  inputCurrency: Currency
-  outputCurrency: Currency
-  txHash: `0x${string}`
-  createdAt: number
-  price: number
-  amount: { currency: Currency; value: string }
-  filled: { currency: Currency; value: string }
-  claimed: { currency: Currency; value: string }
-  claimable: { currency: Currency; value: string }
-  cancelable: boolean
-}