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

package/test/open-order.test.ts

@@ -0,0 +1,112 @@
+import { expect, test } from 'vitest'
+import {
+  getOpenOrders,
+  getOpenOrder,
+  claimOrders,
+  setApprovalOfOpenOrdersForAll,
+  cancelOrders,
+} from '@clober/v2-sdk'
+
+import { cloberTestChain } from './utils/test-chain'
+import { account, publicClient, walletClient } from './utils/constants'
+
+const IS_LOCAL = process.env.IS_LOCAL === 'true'
+
+test.runIf(IS_LOCAL)('get open orders by user address', async () => {
+  const openOrders = await getOpenOrders(
+    cloberTestChain.id,
+    '0xf18Be2a91cF31Fc3f8D828b6c714e1806a75e0AA',
+    {
+      rpcUrl: publicClient.transport.url!,
+    },
+  )
+  expect(openOrders.length).toBeGreaterThan(0)
+})
+
+test.runIf(IS_LOCAL)('get undefined open orders', async () => {
+  expect(
+    await getOpenOrder(cloberTestChain.id, '200', {
+      rpcUrl: publicClient.transport.url!,
+    }).catch((e) => e.message),
+  ).toEqual('Open order not found: 200')
+})
+
+test.runIf(IS_LOCAL)('claim all orders', async () => {
+  const openOrders = (
+    await getOpenOrders(cloberTestChain.id, account.address, {
+      rpcUrl: publicClient.transport.url!,
+    })
+  ).slice(0, 5)
+  expect(
+    await claimOrders(
+      cloberTestChain.id,
+      account.address,
+      openOrders.map((order) => order.id),
+      { rpcUrl: publicClient.transport.url! },
+    ).catch((e) => e.message),
+  ).toEqual(`
+       import { setApprovalOfOpenOrdersForAll } from '@clober/v2-sdk'
+
+       const hash = await setApprovalOfOpenOrdersForAll(
+            ${cloberTestChain.id},
+            privateKeyToAccount('0x...')
+       )
+    `)
+
+  // be sure to approve before claim
+  await publicClient.waitForTransactionReceipt({
+    hash: (await setApprovalOfOpenOrdersForAll(cloberTestChain.id, account, {
+      rpcUrl: publicClient.transport.url!,
+    }))!,
+  })
+
+  const transaction = await claimOrders(
+    cloberTestChain.id,
+    account.address,
+    openOrders.map((order) => order.id),
+    { rpcUrl: publicClient.transport.url! },
+  )
+
+  await walletClient.sendTransaction({ ...transaction, account })
+})
+
+test.runIf(IS_LOCAL)('cancel all orders', async () => {
+  const openOrders = (
+    await getOpenOrders(cloberTestChain.id, account.address, {
+      rpcUrl: publicClient.transport.url!,
+    })
+  )
+    .filter((order) => order.cancelable)
+    .slice(0, 5)
+  expect(
+    await cancelOrders(
+      cloberTestChain.id,
+      account.address,
+      openOrders.map((order) => order.id),
+      { rpcUrl: publicClient.transport.url! },
+    ).catch((e) => e.message),
+  ).toEqual(`
+       import { setApprovalOfOpenOrdersForAll } from '@clober/v2-sdk'
+
+       const hash = await setApprovalOfOpenOrdersForAll(
+            ${cloberTestChain.id},
+            privateKeyToAccount('0x...')
+       )
+    `)
+
+  // be sure to approve before cancel
+  await publicClient.waitForTransactionReceipt({
+    hash: (await setApprovalOfOpenOrdersForAll(cloberTestChain.id, account, {
+      rpcUrl: publicClient.transport.url!,
+    }))!,
+  })
+
+  const transaction = await cancelOrders(
+    cloberTestChain.id,
+    account.address,
+    openOrders.map((order) => order.id),
+    { rpcUrl: publicClient.transport.url! },
+  )
+
+  await walletClient.sendTransaction({ ...transaction, account })
+})

package/test/open.test.ts

@@ -0,0 +1,15 @@
+import { expect, test } from 'vitest'
+import { openMarket } from '@clober/v2-sdk'
+
+import { publicClient } from './utils/constants'
+import { cloberTestChain } from './utils/test-chain'
+
+test('try already open market', async () => {
+  const transaction = await openMarket(
+    cloberTestChain.id,
+    '0x0000000000000000000000000000000000000000',
+    '0x447ad4a108b5540c220f9f7e83723ac87c0f8fd8',
+    { rpcUrl: publicClient.transport.url! },
+  )
+  expect(transaction).toBeUndefined()
+})

package/test/tick.test.ts

@@ -0,0 +1,230 @@
+import { expect, test } from 'vitest'
+import { getAddress } from 'viem'
+
+import { fromPrice, toPrice } from '../src/utils/tick'
+import { baseToQuote, quoteToBase } from '../src/utils/decimals'
+
+import { publicClient } from './utils/constants'
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: 'Tick',
+        name: 'tick',
+        type: 'int24',
+      },
+      {
+        internalType: 'uint256',
+        name: 'base',
+        type: 'uint256',
+      },
+      {
+        internalType: 'bool',
+        name: 'roundingUp',
+        type: 'bool',
+      },
+    ],
+    name: 'baseToQuote',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'uint256',
+        name: 'price',
+        type: 'uint256',
+      },
+    ],
+    name: 'fromPrice',
+    outputs: [
+      {
+        internalType: 'int24',
+        name: '',
+        type: 'int24',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'Tick',
+        name: 'tick',
+        type: 'int24',
+      },
+      {
+        internalType: 'uint256',
+        name: 'quote',
+        type: 'uint256',
+      },
+      {
+        internalType: 'bool',
+        name: 'roundingUp',
+        type: 'bool',
+      },
+    ],
+    name: 'quoteToBase',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'int24',
+        name: 'tick',
+        type: 'int24',
+      },
+    ],
+    name: 'toPrice',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: 'price',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+] as const
+
+const TICK_WRAPPER_ADDRESS =
+  '0xBEB8502F63A7c34a9591D3Fd1eEBca18a41FA0c8' as `0x${string}`
+
+const MAX_TICK = Math.pow(2, 19) - 1
+const MIN_TICK = -1 * MAX_TICK
+
+const MIN_PRICE = 1350587n
+const MAX_PRICE = 4647684107270898330752324302845848816923571339324334n
+
+const randomInteger = (start: number, end: number) => {
+  return Math.floor(Math.random() * (end - start + 1) + start)
+}
+
+test('index to price', async () => {
+  const randomPriceIndices = [
+    MIN_TICK,
+    ...Array.from({ length: 500 }, () => randomInteger(-500000, 500000)),
+    MAX_TICK,
+  ]
+  const actualPrices = (
+    (await publicClient.multicall({
+      contracts: randomPriceIndices.map((priceIndex) => ({
+        address: getAddress(TICK_WRAPPER_ADDRESS),
+        abi: _abi,
+        functionName: 'toPrice',
+        args: [priceIndex],
+      })),
+    })) as { result: bigint }[]
+  ).map(({ result }) => result)
+
+  const expectedPrices = randomPriceIndices.map((priceIndex) =>
+    toPrice(BigInt(priceIndex)),
+  )
+  expect(expectedPrices).toEqual(actualPrices)
+})
+
+test('price to index', async () => {
+  const randomPriceIndices = [
+    MIN_TICK,
+    ...Array.from({ length: 500 }, () => randomInteger(-500000, 500000)),
+    MAX_TICK,
+  ]
+
+  const actualPrices = (
+    (await publicClient.multicall({
+      contracts: randomPriceIndices.map((priceIndex) => ({
+        address: TICK_WRAPPER_ADDRESS,
+        abi: _abi,
+        functionName: 'toPrice',
+        args: [priceIndex],
+      })),
+    })) as { result: bigint }[]
+  ).map(({ result }) => result)
+
+  const actualPriceIndices = (
+    (await publicClient.multicall({
+      contracts: actualPrices.map((price) => ({
+        address: TICK_WRAPPER_ADDRESS,
+        abi: _abi,
+        functionName: 'fromPrice',
+        args: [price],
+      })),
+    })) as { result: number }[]
+  ).map(({ result }) => BigInt(result))
+  const expectedPriceIndices = actualPrices.map((price) => fromPrice(price))
+  expect(expectedPriceIndices).toEqual(actualPriceIndices)
+})
+
+test('price to index for min and max', async () => {
+  const actualPrices = [MIN_PRICE, MAX_PRICE]
+  const actualPriceIndices = (
+    (await publicClient.multicall({
+      contracts: actualPrices.map((price) => ({
+        address: TICK_WRAPPER_ADDRESS,
+        abi: _abi,
+        functionName: 'fromPrice',
+        args: [price],
+      })),
+    })) as { result: number }[]
+  ).map(({ result }) => BigInt(result))
+  const expectedPriceIndices = actualPrices.map((price) => fromPrice(price))
+  expect(expectedPriceIndices).toEqual(actualPriceIndices)
+})
+
+test('quote to base', async () => {
+  const randomPriceIndices = Array.from({ length: 100 }, () =>
+    randomInteger(-100000, 100000),
+  )
+  const actual = (
+    (await publicClient.multicall({
+      contracts: randomPriceIndices.map((priceIndex) => ({
+        address: TICK_WRAPPER_ADDRESS,
+        abi: _abi,
+        functionName: 'quoteToBase',
+        args: [priceIndex, 1000000n, true],
+      })),
+    })) as { result: bigint }[]
+  ).map(({ result }) => result)
+  const expected = randomPriceIndices.map((priceIndex) =>
+    quoteToBase(BigInt(priceIndex), 1000000n, true),
+  )
+  expect(expected).toEqual(actual)
+})
+
+test('base to quote', async () => {
+  const randomPriceIndices = Array.from({ length: 100 }, () =>
+    randomInteger(-100000, 100000),
+  )
+  const actual = (
+    (await publicClient.multicall({
+      contracts: randomPriceIndices.map((priceIndex) => ({
+        address: TICK_WRAPPER_ADDRESS,
+        abi: _abi,
+        functionName: 'baseToQuote',
+        args: [priceIndex, 1000000n, true],
+      })),
+    })) as { result: bigint }[]
+  ).map(({ result }) => result)
+  const expected = randomPriceIndices.map((priceIndex) =>
+    baseToQuote(BigInt(priceIndex), 1000000n, true),
+  )
+  expect(expected).toEqual(actual)
+})

package/test/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../tsconfig.base.json",
+  "include": ["*.ts"],
+  "compilerOptions": {
+    "types": ["node"],
+    "lib": ["DOM"],
+    "baseUrl": ".",
+    "paths": {
+      "@clober/v2-sdk": ["../src/index.ts"]
+    },
+  }
+}

package/test/utils/chain.ts

@@ -0,0 +1,12 @@
+import { createPublicClient, http } from 'viem'
+import { arbitrumSepolia } from 'viem/chains'
+
+import { FORK_URL } from './constants'
+
+export const fetchBlockNumer = async (): Promise<bigint> => {
+  const publicClient = createPublicClient({
+    chain: arbitrumSepolia,
+    transport: http(FORK_URL),
+  })
+  return publicClient.getBlockNumber()
+}

package/test/utils/constants.ts

@@ -0,0 +1,25 @@
+import * as dotenv from 'dotenv'
+import { privateKeyToAccount } from 'viem/accounts'
+import { createPublicClient, createWalletClient, http } from 'viem'
+
+import { cloberTestChain } from './test-chain'
+
+dotenv.config()
+
+export const FORK_URL =
+  process.env.ARBITRUM_SEPOLIA_RPC_URL ||
+  'https://arbitrum-sepolia-archive.allthatnode.com'
+export const account = privateKeyToAccount(
+  process.env.DEV_PRIVATE_KEY as `0x${string}`,
+)
+
+export const publicClient = createPublicClient({
+  chain: cloberTestChain,
+  transport: http(FORK_URL),
+})
+
+export const walletClient = createWalletClient({
+  chain: cloberTestChain,
+  account,
+  transport: http(FORK_URL),
+})

package/test/utils/currency.ts

@@ -0,0 +1,44 @@
+import { createPublicClient, http } from 'viem'
+
+import { CHAIN_IDS } from '../../src'
+import { CHAIN_MAP } from '../../src/constants/chain'
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'account',
+        type: 'address',
+      },
+    ],
+    name: 'balanceOf',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
+export const fetchTokenBalance = async (
+  chainId: CHAIN_IDS,
+  token: `0x${string}`,
+  userAddress: `0x${string}`,
+  rpcUrl: string,
+): Promise<bigint> => {
+  const publicClient = createPublicClient({
+    chain: CHAIN_MAP[chainId],
+    transport: http(rpcUrl),
+  })
+  return publicClient.readContract({
+    address: token,
+    abi: _abi,
+    functionName: 'balanceOf',
+    args: [userAddress],
+  })
+}

package/test/utils/depth.ts

@@ -0,0 +1,148 @@
+import { createPublicClient, http, isAddressEqual } from 'viem'
+import { arbitrumSepolia } from 'viem/chains'
+
+import { CHAIN_MAP, CHAIN_IDS } from '../../src/constants/chain'
+import { getMarketId } from '../../src/utils/market'
+import { formatPrice } from '../../src/utils/prices'
+import { invertPrice, toPrice } from '../../src/utils/tick'
+import { fetchCurrency } from '../../src/apis/currency'
+import { toBookId } from '../../src/utils/book-id'
+import { CONTRACT_ADDRESSES } from '../../src/constants/addresses'
+
+import { cloberTestChain } from './test-chain'
+
+const MAX_TICK = 2n ** 19n - 1n
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: 'BookId',
+        name: 'id',
+        type: 'uint192',
+      },
+      {
+        internalType: 'Tick',
+        name: 'tick',
+        type: 'int24',
+      },
+      {
+        internalType: 'uint256',
+        name: 'n',
+        type: 'uint256',
+      },
+    ],
+    name: 'getLiquidity',
+    outputs: [
+      {
+        components: [
+          {
+            internalType: 'Tick',
+            name: 'tick',
+            type: 'int24',
+          },
+          {
+            internalType: 'uint64',
+            name: 'depth',
+            type: 'uint64',
+          },
+        ],
+        internalType: 'struct IBookViewer.Liquidity[]',
+        name: 'liquidity',
+        type: 'tuple[]',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
+const fetchDepth = async (
+  chainId: CHAIN_IDS,
+  inputToken: `0x${string}`,
+  outputToken: `0x${string}`,
+  bookId: bigint,
+  rpcUrl: string,
+): Promise<
+  {
+    price: number
+    amount: bigint
+  }[]
+> => {
+  const { quoteTokenAddress, baseTokenAddress } = getMarketId(chainId, [
+    outputToken,
+    inputToken,
+  ])
+  const isBid = isAddressEqual(inputToken, quoteTokenAddress)
+  const [quoteCurrency, baseCurrency] = await Promise.all([
+    fetchCurrency(chainId, quoteTokenAddress, rpcUrl),
+    fetchCurrency(chainId, baseTokenAddress, rpcUrl),
+  ])
+  const publicClient = createPublicClient({
+    chain: CHAIN_MAP[chainId],
+    transport: http(rpcUrl),
+  })
+  const depths = await publicClient.readContract({
+    address: CONTRACT_ADDRESSES[arbitrumSepolia.id]!.BookViewer,
+    abi: _abi,
+    functionName: 'getLiquidity',
+    args: [bookId, Number(MAX_TICK), 50n],
+  })
+  return depths.map(({ tick, depth }: { tick: number; depth: bigint }) => ({
+    price: isBid
+      ? formatPrice(
+          toPrice(BigInt(tick)),
+          quoteCurrency.decimals,
+          baseCurrency.decimals,
+        )
+      : formatPrice(
+          invertPrice(toPrice(BigInt(tick))),
+          quoteCurrency.decimals,
+          baseCurrency.decimals,
+        ),
+    amount: depth,
+  }))
+}
+
+export const fetchAskDepth = async (rpcUrl: string) => {
+  const askBookId = toBookId(
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    10n ** 12n,
+  )
+  return fetchDepth(
+    cloberTestChain.id,
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    askBookId,
+    rpcUrl,
+  )
+}
+
+export const fetchBidDepth = async (rpcUrl: string) => {
+  const bidBookId = toBookId(
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    1n,
+  )
+  return fetchDepth(
+    cloberTestChain.id,
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    bidBookId,
+    rpcUrl,
+  )
+}
+
+export const getSize = (
+  depth: { price: number; amount: bigint }[],
+  from: number,
+  to: number,
+) => {
+  return Number(
+    (
+      depth.find(({ price }) => from <= price && price <= to) ?? {
+        amount: 0n,
+      }
+    ).amount,
+  )
+}

package/test/utils/test-chain.ts

@@ -0,0 +1,26 @@
+import { Chain } from 'viem'
+import { arbitrumSepolia } from 'viem/chains'
+
+export const cloberTestChain: Chain = {
+  id: arbitrumSepolia.id,
+  name: 'Clober Test Chain',
+  nativeCurrency: {
+    name: 'Ether',
+    symbol: 'ETH',
+    decimals: 18,
+  },
+  rpcUrls: {
+    default: {
+      http: [''],
+    },
+    public: {
+      http: [''],
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xca11bde05977b3631167028862be2a173976ca11',
+      blockCreated: 81930,
+    },
+  },
+}

package/test/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  envDir: '.',
+  test: {
+    disableConsoleIntercept: false,
+    environment: 'node',
+    include: ['*.test.ts'],
+    alias: {
+      '@clober/v2-sdk': '../src/index.ts',
+    },
+    testTimeout: 40000000,
+    hookTimeout: 40000000,
+  },
+})

package/tsconfig.base.json

@@ -0,0 +1,37 @@
+{
+  "include": [],
+  "compilerOptions": {
+    // Incremental builds
+    "incremental": true,
+
+    // Type checking
+    "strict": true,
+    "skipLibCheck": true,
+    "useDefineForClassFields": true,
+    "exactOptionalPropertyTypes": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noUncheckedIndexedAccess": true,
+
+    // Modules
+    "module": "ES2022",
+    "moduleResolution": "node",
+
+    // JavaScript support
+    "allowJs": false,
+    "checkJs": false,
+
+    // Interop constraints
+    "forceConsistentCasingInFileNames": true,
+
+    // Language and environment
+    "lib": ["ESNext"],
+    "target": "ESNext",
+
+    // Sourcemaps
+    "sourceMap": true
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.base.json",
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.test.ts"],
+  "compilerOptions": {
+    "types": ["node"],
+    "lib": ["DOM"]
+  }
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.base.json",
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.test.ts"],
+  "compilerOptions": {
+    "types": ["node"],
+    "lib": ["DOM"]
+  }
+}