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

package/src/signature.ts

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

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

@@ -0,0 +1,48 @@
+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/{dist/esm/utils/book-id.js → src/utils/book-id.ts}

@@ -1,21 +1,31 @@
-import { encodeAbiParameters, keccak256, zeroAddress } from 'viem';
-import { MAKER_DEFAULT_POLICY, TAKER_DEFAULT_POLICY } from '../constants/fee';
-export const toBookId = (inputToken, outputToken, unit) => {
-    const value = keccak256(encodeAbiParameters([
+import { encodeAbiParameters, keccak256, zeroAddress } from 'viem'
+
+import { MAKER_DEFAULT_POLICY, TAKER_DEFAULT_POLICY } from '../constants/fee'
+
+export const toBookId = (
+  inputToken: `0x${string}`,
+  outputToken: `0x${string}`,
+  unit: bigint,
+) => {
+  const value = keccak256(
+    encodeAbiParameters(
+      [
         { name: 'base', type: 'address' },
         { name: 'unit', type: 'uint64' },
         { name: 'quote', type: 'address' },
         { name: 'makerPolicy', type: 'uint24' },
         { name: 'hooks', type: 'address' },
         { name: 'takerPolicy', type: 'uint24' },
-    ], [
+      ],
+      [
         outputToken,
         unit,
         inputToken,
         Number(MAKER_DEFAULT_POLICY.value),
         zeroAddress,
         Number(TAKER_DEFAULT_POLICY.value),
-    ]));
-    return BigInt(value) & (2n ** 192n - 1n);
-};
-//# sourceMappingURL=book-id.js.map
+      ],
+    ),
+  )
+  return BigInt(value) & (2n ** 192n - 1n)
+}

package/src/utils/build-transaction.ts

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

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

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

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

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