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

package/src/signature.ts

@@ -1,196 +0,0 @@
-import {
-  createPublicClient,
-  HDAccount,
-  hexToSignature,
-  http,
-  parseUnits,
-  PrivateKeyAccount,
-  verifyTypedData,
-  zeroHash,
-} from 'viem'
-
-import { CHAIN_IDS, CHAIN_MAP } from './constants/chain'
-import { getDeadlineTimestampInSeconds } from './utils/time'
-import { CONTRACT_ADDRESSES } from './constants/addresses'
-import { fetchCurrency } from './apis/currency'
-import { PermitSignature } from './type'
-
-const _abi = [
-  {
-    inputs: [],
-    name: 'version',
-    outputs: [
-      {
-        internalType: 'string',
-        name: '',
-        type: 'string',
-      },
-    ],
-    stateMutability: 'view',
-    type: 'function',
-  },
-  {
-    inputs: [
-      {
-        internalType: 'address',
-        name: 'owner',
-        type: 'address',
-      },
-    ],
-    name: 'nonces',
-    outputs: [
-      {
-        internalType: 'uint256',
-        name: '',
-        type: 'uint256',
-      },
-    ],
-    stateMutability: 'view',
-    type: 'function',
-  },
-  {
-    inputs: [],
-    name: 'name',
-    outputs: [
-      {
-        internalType: 'string',
-        name: '',
-        type: 'string',
-      },
-    ],
-    stateMutability: 'view',
-    type: 'function',
-  },
-] as const
-
-/**
- * Signs an ERC20 permit using EIP-712 encoding.
- *
- * @param {CHAIN_IDS} chainId The chain ID.
- * @param {HDAccount | PrivateKeyAccount} account The Ethereum account used for signing using
- * [viem - Local Accounts (Private Key, Mnemonic, etc)](https://viem.sh/docs/accounts/local#local-accounts-private-key-mnemonic-etc).
- * @param {`0x${string}`} token The ERC20 token address.
- * @param {string} amount The amount of tokens to permit.
- * @param options
- * @param options.rpcUrl The RPC URL of the blockchain.
- * @returns {Promise<PermitSignature>} Promise resolving to the permit signature.
- * @example
- * import { signERC20Permit } from '@clober/v2-sdk'
- * import { privateKeyToAccount } from 'viem/accounts'
- *
- * const { deadline, r, s, v } = await signERC20Permit(
- *   421614,
- *   privateKeyToAccount('0x...')
- *  '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
- *  '1000.123', // spend 1000.123 USDC
- * )
- *
- * @example
- * import { signERC20Permit } from '@clober/v2-sdk'
- * import { mnemonicToAccount } from 'viem/accounts'
- *
- * const { deadline, r, s, v } = await signERC20Permit(
- *   421614,
- *   mnemonicToAccount('legal ...')
- *  '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
- *  '1000.123', // spend 1000.123 USDC
- * )
- */
-export const signERC20Permit = async (
-  chainId: CHAIN_IDS,
-  account: HDAccount | PrivateKeyAccount,
-  token: `0x${string}`,
-  amount: string,
-  options?: {
-    rpcUrl: string
-  },
-): Promise<PermitSignature> => {
-  const currency = await fetchCurrency(chainId, token, options?.rpcUrl)
-  const spender = CONTRACT_ADDRESSES[chainId]!.Controller
-  const publicClient = createPublicClient({
-    chain: CHAIN_MAP[chainId],
-    transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
-  })
-  const value = parseUnits(amount, currency.decimals)
-  const [{ result: nonce }, { result: version }, { result: name }] =
-    await publicClient.multicall({
-      allowFailure: true,
-      contracts: [
-        {
-          address: token,
-          abi: _abi,
-          functionName: 'nonces',
-          args: [account.address],
-        },
-        {
-          address: token,
-          abi: _abi,
-          functionName: 'version',
-        },
-        {
-          address: token,
-          abi: _abi,
-          functionName: 'name',
-        },
-      ],
-    })
-
-  if (nonce === undefined || !name) {
-    return {
-      r: zeroHash,
-      s: zeroHash,
-      v: 0,
-      deadline: 0n,
-    }
-  }
-  const deadline = getDeadlineTimestampInSeconds()
-  const data = {
-    domain: {
-      name: name,
-      version: (version || '1').toString(),
-      chainId: BigInt(chainId),
-      verifyingContract: currency.address,
-    },
-    message: {
-      owner: account.address,
-      spender,
-      value,
-      nonce,
-      deadline,
-    },
-    primaryType: 'Permit',
-    types: {
-      Permit: [
-        { name: 'owner', type: 'address' },
-        { name: 'spender', type: 'address' },
-        { name: 'value', type: 'uint256' },
-        { name: 'nonce', type: 'uint256' },
-        { name: 'deadline', type: 'uint256' },
-      ],
-      EIP712Domain: [
-        { name: 'name', type: 'string' },
-        { name: 'version', type: 'string' },
-        { name: 'chainId', type: 'uint256' },
-        { name: 'verifyingContract', type: 'address' },
-      ],
-    },
-  } as const
-  const signature = await account.signTypedData({
-    ...data,
-  })
-  const valid = await verifyTypedData({
-    ...data,
-    signature,
-    address: account.address,
-  })
-  if (!valid) {
-    throw new Error('Invalid signature')
-  }
-  const { v, s, r } = hexToSignature(signature)
-  return {
-    v: Number(v),
-    s,
-    r,
-    deadline,
-  }
-}

package/src/type.ts

@@ -1,38 +0,0 @@
-import { Account } from 'viem'
-
-import { CHAIN_IDS } from './constants/chain'
-import { Currency } from './model/currency'
-import { Depth } from './model/depth'
-
-export { CHAIN_IDS } from './constants/chain'
-export { Currency } from './model/currency'
-export { Depth } from './model/depth'
-export { OpenOrder } from './model/open-order'
-
-export type Market = {
-  chainId: CHAIN_IDS
-  quote: Currency
-  base: Currency
-  makerFee: number
-  takerFee: number
-  bids: Depth[]
-  bidBookOpen: boolean
-  asks: Depth[]
-  askBookOpen: boolean
-}
-
-export type Transaction = {
-  data: `0x${string}`
-  gas: bigint
-  gasPrice: bigint
-  value: bigint
-  to: `0x${string}`
-  from: `0x${string}` | Account | undefined
-}
-
-export type PermitSignature = {
-  deadline: bigint
-  v: number
-  r: `0x${string}`
-  s: `0x${string}`
-}

package/src/utils/approval.ts

@@ -1,48 +0,0 @@
-import { createPublicClient, http } from 'viem'
-
-import { CHAIN_IDS, CHAIN_MAP } from '../constants/chain'
-import { CONTRACT_ADDRESSES } from '../constants/addresses'
-
-const _abi = [
-  {
-    inputs: [
-      {
-        internalType: 'address',
-        name: 'owner',
-        type: 'address',
-      },
-      {
-        internalType: 'address',
-        name: 'operator',
-        type: 'address',
-      },
-    ],
-    name: 'isApprovedForAll',
-    outputs: [
-      {
-        internalType: 'bool',
-        name: '',
-        type: 'bool',
-      },
-    ],
-    stateMutability: 'view',
-    type: 'function',
-  },
-] as const
-
-export async function fetchIsApprovedForAll(
-  chainId: CHAIN_IDS,
-  owner: `0x${string}`,
-  rpcUrl?: string,
-): Promise<boolean> {
-  const publicClient = createPublicClient({
-    chain: CHAIN_MAP[chainId],
-    transport: rpcUrl ? http(rpcUrl) : http(),
-  })
-  return publicClient.readContract({
-    address: CONTRACT_ADDRESSES[chainId]!.BookManager,
-    abi: _abi,
-    functionName: 'isApprovedForAll',
-    args: [owner, CONTRACT_ADDRESSES[chainId]!.Controller],
-  })
-}

package/src/utils/build-transaction.ts

@@ -1,39 +0,0 @@
-import {
-  createPublicClient,
-  encodeFunctionData,
-  http,
-  SimulateContractParameters,
-  WriteContractParameters,
-} from 'viem'
-
-import { CHAIN_IDS, CHAIN_MAP } from '../constants/chain'
-import { Transaction } from '../type'
-
-export const buildTransaction = async (
-  chainId: CHAIN_IDS,
-  args: WriteContractParameters | SimulateContractParameters,
-  rpcUrl?: string,
-): Promise<Transaction> => {
-  const publicClient = createPublicClient({
-    chain: CHAIN_MAP[chainId],
-    transport: rpcUrl ? http(rpcUrl) : http(),
-  })
-  const data = encodeFunctionData(args)
-  const [gas, gasPrice] = await Promise.all([
-    publicClient.estimateGas({
-      account: args.account,
-      data,
-      to: args.address,
-      value: args.value || 0n,
-    }),
-    publicClient.getGasPrice(),
-  ])
-  return {
-    gas,
-    gasPrice,
-    data,
-    value: args.value || 0n,
-    to: args.address,
-    from: args.account,
-  }
-}

package/src/utils/decimals.ts

@@ -1,22 +0,0 @@
-import { PRICE_PRECISION } from '../constants/price'
-
-import { divide } from './math'
-import { toPrice } from './tick'
-
-export const baseToQuote = (
-  tick: bigint,
-  base: bigint,
-  roundingUp: boolean,
-): bigint => {
-  const y = 1n << PRICE_PRECISION
-  return divide(base * toPrice(tick), y, roundingUp)
-}
-
-export const quoteToBase = (
-  tick: bigint,
-  quote: bigint,
-  roundingUp: boolean,
-): bigint => {
-  const x = quote << PRICE_PRECISION
-  return divide(x, toPrice(tick), roundingUp)
-}

package/src/utils/market.ts

@@ -1,74 +0,0 @@
-import { getAddress, isAddressEqual, zeroAddress } from 'viem'
-
-import { STABLE_COIN_ADDRESSES, WETH_ADDRESSES } from '../constants/currency'
-import { CHAIN_IDS } from '../constants/chain'
-
-export const getMarketId = (
-  chainId: CHAIN_IDS,
-  tokenAddresses: `0x${string}`[],
-): {
-  baseTokenAddress: `0x${string}`
-  quoteTokenAddress: `0x${string}`
-  marketId: string
-} => {
-  if (tokenAddresses.length !== 2) {
-    throw new Error('Invalid token pair')
-  }
-  tokenAddresses = tokenAddresses.map((address) => getAddress(address))
-
-  // include stable coin
-  const stable = tokenAddresses.find((address) => {
-    return STABLE_COIN_ADDRESSES[chainId]!.map((addresses) =>
-      getAddress(addresses),
-    ).some((addresses) => addresses.includes(address))
-  })
-  if (stable) {
-    const other = tokenAddresses.find(
-      (address) => !isAddressEqual(address, stable),
-    )!
-    return {
-      marketId: `${other}/${stable}`,
-      quoteTokenAddress: stable,
-      baseTokenAddress: other,
-    }
-  }
-
-  // include eth
-  const eth = tokenAddresses.find((address) =>
-    isAddressEqual(address, zeroAddress),
-  )
-  if (eth) {
-    const other = tokenAddresses.find(
-      (address) => !isAddressEqual(address, zeroAddress),
-    )!
-    return {
-      marketId: `${other}/${eth}`,
-      quoteTokenAddress: eth,
-      baseTokenAddress: other,
-    }
-  }
-
-  // include weth
-  const weth = tokenAddresses.find((address) => {
-    return WETH_ADDRESSES[chainId]!.map((addresses) =>
-      getAddress(addresses),
-    ).some((addresses) => addresses.includes(address))
-  })
-  if (weth) {
-    const other = tokenAddresses.find(
-      (address) => !isAddressEqual(address, weth),
-    )!
-    return {
-      marketId: `${other}/${weth}`,
-      quoteTokenAddress: weth,
-      baseTokenAddress: other,
-    }
-  }
-
-  const _tokens = tokenAddresses.sort((a, b) => a.localeCompare(b))
-  return {
-    marketId: `${_tokens[0]}/${_tokens[1]}`,
-    quoteTokenAddress: _tokens[0]!,
-    baseTokenAddress: _tokens[1]!,
-  }
-}

package/src/utils/math.ts

@@ -1,117 +0,0 @@
-export const divide = (x: bigint, y: bigint, roundUp: boolean): bigint => {
-  if (roundUp) {
-    if (x === 0n) {
-      return 0n
-    } else {
-      return (x - 1n) / y + 1n
-    }
-  } else {
-    return x / y
-  }
-}
-
-export const lnWad = (x: bigint): bigint => {
-  const or = (a: bigint, b: bigint) => a | b
-  const xor = (a: bigint, b: bigint) => a ^ b
-  const and = (a: bigint, b: bigint) => a & b
-  const add = (a: bigint, b: bigint) => a + b
-  const sub = (a: bigint, b: bigint) => a - b
-  const mul = (a: bigint, b: bigint) => a * b
-  const sdiv = (a: bigint, b: bigint) => a / b
-  const lt = (a: bigint, b: bigint) => (a < b ? 1n : 0n)
-  const shl = (x: bigint, y: bigint) => y << x
-  const shr = (x: bigint, y: bigint) => y >> x
-  const sar = (x: bigint, y: bigint) => y >> x
-  const byte = (i: bigint, x: bigint) => (x >> (248n - i * 8n)) & 0xffn
-
-  // We want to convert `x` from `10**18` fixed point to `2**96` fixed point.
-  // We do this by multiplying by `2**96 / 10**18`. But since
-  // `ln(x * C) = ln(x) + ln(C)`, we can simply do nothing here
-  // and add `ln(2**96 / 10**18)` at the end.
-
-  // Compute `k = log2(x) - 96`, `r = 159 - k = 255 - log2(x) = 255 ^ log2(x)`.
-  let r = shl(7n, lt(0xffffffffffffffffffffffffffffffffn, x))
-  r = or(r, shl(6n, lt(0xffffffffffffffffn, shr(r, x))))
-  r = or(r, shl(5n, lt(0xffffffffn, shr(r, x))))
-  r = or(r, shl(4n, lt(0xffffn, shr(r, x))))
-  r = or(r, shl(3n, lt(0xffn, shr(r, x))))
-  // forgefmt: disable-next-item
-  r = xor(
-    r,
-    byte(
-      and(0x1fn, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54ben)),
-      0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffffn,
-    ),
-  )
-
-  // Reduce range of x to (1, 2) * 2**96
-  // ln(2^k * x) = k * ln(2) + ln(x)
-  x = shr(159n, shl(r, x))
-
-  // Evaluate using a (8, 8)-term rational approximation.
-  // `p` is made monic, we will multiply by a scale factor later.
-  // forgefmt: disable-next-item
-  let p = sub(
-    // This heavily nested expression is to avoid stack-too-deep for via-ir.
-    sar(
-      96n,
-      mul(
-        add(
-          43456485725739037958740375743393n,
-          sar(
-            96n,
-            mul(
-              add(
-                24828157081833163892658089445524n,
-                sar(96n, mul(add(3273285459638523848632254066296n, x), x)),
-              ),
-              x,
-            ),
-          ),
-        ),
-        x,
-      ),
-    ),
-    11111509109440967052023855526967n,
-  )
-  p = sub(sar(96n, mul(p, x)), 45023709667254063763336534515857n)
-  p = sub(sar(96n, mul(p, x)), 14706773417378608786704636184526n)
-  p = sub(mul(p, x), shl(96n, 795164235651350426258249787498n))
-  // We leave `p` in `2**192` basis so we don't need to scale it back up for the division.
-
-  // `q` is monic by convention.
-  let q = add(5573035233440673466300451813936n, x)
-  q = add(71694874799317883764090561454958n, sar(96n, mul(x, q)))
-  q = add(283447036172924575727196451306956n, sar(96n, mul(x, q)))
-  q = add(401686690394027663651624208769553n, sar(96n, mul(x, q)))
-  q = add(204048457590392012362485061816622n, sar(96n, mul(x, q)))
-  q = add(31853899698501571402653359427138n, sar(96n, mul(x, q)))
-  q = add(909429971244387300277376558375n, sar(96n, mul(x, q)))
-
-  // `p / q` is in the range `(0, 0.125) * 2**96`.
-
-  // Finalization, we need to:
-  // - Multiply by the scale factor `s = 5.549…`.
-  // - Add `ln(2**96 / 10**18)`.
-  // - Add `k * ln(2)`.
-  // - Multiply by `10**18 / 2**96 = 5**18 >> 78`.
-
-  // The q polynomial is known not to have zeros in the domain.
-  // No scaling required because p is already `2**96` too large.
-  p = sdiv(p, q)
-  // Multiply by the scaling factor: `s * 5**18 * 2**96`, base is now `5**18 * 2**192`.
-  p = mul(1677202110996718588342820967067443963516166n, p)
-  // Add `ln(2) * k * 5**18 * 2**192`.
-  // forgefmt: disable-next-item
-  p = add(
-    mul(
-      16597577552685614221487285958193947469193820559219878177908093499208371n,
-      sub(159n, r),
-    ),
-    p,
-  )
-  // Base conversion: mul `2**96 / (5**18 * 2**192)`.
-  r = sdiv(p, 302231454903657293676544000000000000000000n)
-
-  return r
-}

package/src/utils/prices.ts

@@ -1,29 +0,0 @@
-import BigNumber from 'bignumber.js'
-
-import { PRICE_PRECISION } from '../constants/price'
-
-export const formatPrice = (
-  price: bigint,
-  quoteDecimals: number,
-  baseDecimals: number,
-): number => {
-  return new BigNumber(price.toString())
-    .div(new BigNumber(2).pow(PRICE_PRECISION.toString()))
-    .times(new BigNumber(10).pow(baseDecimals))
-    .div(new BigNumber(10).pow(quoteDecimals))
-    .toNumber()
-}
-
-export const parsePrice = (
-  price: number,
-  quoteDecimals: number,
-  baseDecimals: number,
-): bigint => {
-  const value = new BigNumber(price)
-    .times(new BigNumber(2).pow(PRICE_PRECISION.toString()))
-    .times(new BigNumber(10).pow(quoteDecimals))
-    .div(new BigNumber(10).pow(baseDecimals))
-  return BigInt(
-    value.isInteger() ? value.toFixed() : value.integerValue().toFixed(),
-  )
-}

package/src/utils/tick.ts

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

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