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

package/src/constants/addresses.ts

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

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

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

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

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

package/src/constants/subgraph-url.ts

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

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

package/src/model/book.ts

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

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

package/src/model/depth.ts

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

package/src/model/fee-policy.ts

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

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

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