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

package/test/limit-order.test.ts

@@ -0,0 +1,279 @@
+import { expect, test } from 'vitest'
+import { limitOrder, signERC20Permit } from '@clober/v2-sdk'
+import { formatUnits } from 'viem'
+import { arbitrumSepolia } from 'viem/chains'
+
+import { fetchTokenBalance } from './utils/currency'
+import { fetchAskDepth, fetchBidDepth, getSize } from './utils/depth'
+import { account, publicClient, walletClient } from './utils/constants'
+import { cloberTestChain } from './utils/test-chain'
+
+const IS_LOCAL = process.env.IS_LOCAL === 'true'
+
+test.runIf(IS_LOCAL)('limit order in not open market', async () => {
+  expect(
+    await limitOrder(
+      arbitrumSepolia.id,
+      '0x447ad4a108b5540c220f9f7e83723ac87c0f8fd8',
+      '0x447ad4a108b5540c220f9f7e83723ac87c0f8fd8',
+      '0x0000000000000000000000000000000000000000',
+      '10',
+      '1000',
+      { rpcUrl: publicClient.transport.url! },
+    ).catch((e) => e.message),
+  ).toEqual(`
+       import { openMarket } from '@clober/v2-sdk'
+
+       const transaction = await openMarket(
+            ${cloberTestChain.id},
+           '0x447ad4a108b5540c220f9f7e83723ac87c0f8fd8',
+           '0x0000000000000000000000000000000000000000',
+       )
+    `)
+})
+
+test.runIf(IS_LOCAL)('make bid order', async () => {
+  const signature = await signERC20Permit(
+    cloberTestChain.id,
+    account,
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '1000',
+    { rpcUrl: publicClient.transport.url! },
+  )
+  const transaction = await limitOrder(
+    cloberTestChain.id,
+    account.address,
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    '1000',
+    '0.01',
+    { signature, rpcUrl: publicClient.transport.url!, postOnly: true },
+  )
+
+  const [beforeBalance, beforeDepth] = await Promise.all([
+    fetchTokenBalance(
+      cloberTestChain.id,
+      '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+      account.address,
+      publicClient.transport.url!,
+    ),
+    fetchBidDepth(publicClient.transport.url!),
+  ])
+
+  const hash = await walletClient.sendTransaction({
+    ...transaction!,
+    account,
+    gasPrice: transaction!.gasPrice! * 2n,
+  })
+  const receipt = await publicClient.waitForTransactionReceipt({ hash })
+  expect(receipt.status).toBe('success')
+
+  const [afterBalance, afterDepth] = await Promise.all([
+    fetchTokenBalance(
+      cloberTestChain.id,
+      '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+      account.address,
+      publicClient.transport.url!,
+    ),
+    fetchBidDepth(publicClient.transport.url!),
+  ])
+
+  expect(beforeBalance - afterBalance).toEqual(1000000000n)
+  expect(getSize(afterDepth, 0, 0.01)).greaterThan(
+    getSize(beforeDepth, 0, 0.01),
+  )
+})
+
+test.runIf(IS_LOCAL)('make ask order', async () => {
+  const transaction = await limitOrder(
+    cloberTestChain.id,
+    account.address,
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0.001',
+    '8000.01',
+    { rpcUrl: publicClient.transport.url!, postOnly: true },
+  )
+
+  const [beforeBalance, beforeDepth] = await Promise.all([
+    publicClient.getBalance({
+      address: account.address,
+    }),
+    fetchAskDepth(publicClient.transport.url!),
+  ])
+
+  const hash = await walletClient.sendTransaction({
+    ...transaction!,
+    account,
+    gasPrice: transaction!.gasPrice! * 2n,
+  })
+  const receipt = await publicClient.waitForTransactionReceipt({ hash })
+  expect(receipt.status).toBe('success')
+
+  const [afterBalance, afterDepth] = await Promise.all([
+    publicClient.getBalance({
+      address: account.address,
+    }),
+    fetchAskDepth(publicClient.transport.url!),
+  ])
+
+  expect(Number(beforeBalance - afterBalance)).greaterThan(Number(10n ** 15n))
+  expect(getSize(afterDepth, 8000, 8001)).greaterThan(
+    getSize(beforeDepth, 8000, 8001),
+  )
+})
+
+test.runIf(IS_LOCAL)('limit bid order', async () => {
+  const beforeBidDepth = await fetchBidDepth(publicClient.transport.url!)
+  const makeTx = await limitOrder(
+    cloberTestChain.id,
+    account.address,
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0.001',
+    beforeBidDepth.length === 0
+      ? '5001'
+      : (beforeBidDepth[0]!.price + 1).toString(),
+    { rpcUrl: publicClient.transport.url!, postOnly: true },
+  )
+  await publicClient.waitForTransactionReceipt({
+    hash: await walletClient.sendTransaction({
+      ...makeTx!,
+      account,
+      gasPrice: makeTx!.gasPrice! * 2n,
+    }),
+  })
+
+  const [beforeUSDCBalance, beforeETHBalance] = await Promise.all([
+    fetchTokenBalance(
+      cloberTestChain.id,
+      '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+      account.address,
+      publicClient.transport.url!,
+    ),
+    publicClient.getBalance({
+      address: account.address,
+    }),
+  ])
+  const signature = await signERC20Permit(
+    cloberTestChain.id,
+    account,
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '100000',
+    { rpcUrl: publicClient.transport.url! },
+  )
+  const transaction = await limitOrder(
+    cloberTestChain.id,
+    account.address,
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    '100000',
+    beforeBidDepth.length === 0
+      ? '5002'
+      : (beforeBidDepth[0]!.price + 2).toString(),
+    { signature, rpcUrl: publicClient.transport.url! },
+  )
+
+  const hash = await walletClient.sendTransaction({
+    ...transaction!,
+    account,
+    gasPrice: transaction!.gasPrice! * 2n,
+  })
+  const receipt = await publicClient.waitForTransactionReceipt({ hash })
+  expect(receipt.status).toBe('success')
+
+  const [afterUSDCBalance, afterETHBalance] = await Promise.all([
+    fetchTokenBalance(
+      cloberTestChain.id,
+      '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+      account.address,
+      publicClient.transport.url!,
+    ),
+    publicClient.getBalance({
+      address: account.address,
+    }),
+  ])
+
+  expect(beforeUSDCBalance - afterUSDCBalance).toEqual(100000000000n)
+  expect(Number(formatUnits(afterETHBalance, 18))).greaterThan(
+    Number(formatUnits(beforeETHBalance, 18)),
+  )
+})
+
+test.runIf(IS_LOCAL)('limit ask order', async () => {
+  const beforeAskDepth = await fetchAskDepth(publicClient.transport.url!)
+  const signature = await signERC20Permit(
+    cloberTestChain.id,
+    account,
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '100',
+    { rpcUrl: publicClient.transport.url! },
+  )
+  const makeTx = await limitOrder(
+    cloberTestChain.id,
+    account.address,
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    '100',
+    beforeAskDepth.length === 0
+      ? '4999'
+      : (beforeAskDepth[0]!.price - 1).toString(),
+    { signature, rpcUrl: publicClient.transport.url!, postOnly: true },
+  )
+  await publicClient.waitForTransactionReceipt({
+    hash: await walletClient.sendTransaction({
+      ...makeTx!,
+      account,
+      gasPrice: makeTx!.gasPrice! * 2n,
+    }),
+  })
+
+  const transaction = await limitOrder(
+    cloberTestChain.id,
+    account.address,
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0.001',
+    beforeAskDepth.length === 0
+      ? '4998'
+      : (beforeAskDepth[0]!.price - 2).toString(),
+    { rpcUrl: publicClient.transport.url! },
+  )
+
+  const [beforeUSDCBalance, beforeETHBalance] = await Promise.all([
+    fetchTokenBalance(
+      cloberTestChain.id,
+      '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+      account.address,
+      publicClient.transport.url!,
+    ),
+    publicClient.getBalance({
+      address: account.address,
+    }),
+  ])
+
+  const hash = await walletClient.sendTransaction({
+    ...transaction!,
+    account,
+    gasPrice: transaction!.gasPrice! * 2n,
+  })
+  const receipt = await publicClient.waitForTransactionReceipt({ hash })
+  expect(receipt.status).toBe('success')
+
+  const [afterUSDCBalance, afterETHBalance] = await Promise.all([
+    fetchTokenBalance(
+      cloberTestChain.id,
+      '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+      account.address,
+      publicClient.transport.url!,
+    ),
+    publicClient.getBalance({
+      address: account.address,
+    }),
+  ])
+
+  expect(beforeETHBalance - afterETHBalance).toBeGreaterThan(1000000000000000)
+  expect(Number(formatUnits(afterUSDCBalance, 18))).greaterThan(
+    Number(formatUnits(beforeUSDCBalance, 18)),
+  )
+})

package/test/market-order.test.ts

@@ -0,0 +1,245 @@
+import { expect, test } from 'vitest'
+import { marketOrder } from '@clober/v2-sdk'
+
+import { cloberTestChain } from './utils/test-chain'
+import { publicClient } from './utils/constants'
+
+const IS_LOCAL = process.env.IS_LOCAL === 'true'
+
+test.runIf(IS_LOCAL)('market order in not open market', async () => {
+  expect(
+    await marketOrder(
+      cloberTestChain.id,
+      '0x447ad4a108b5540c220f9f7e83723ac87c0f8fd8',
+      '0x447ad4a108b5540c220f9f7e83723ac87c0f8fd8',
+      '0x0000000000000000000000000000000000000000',
+      '10',
+      { rpcUrl: publicClient.transport.url! },
+    ).catch((e) => e.message),
+  ).toEqual(`
+       import { openMarket } from '@clober/v2-sdk'
+
+       const transaction = await openMarket(
+            ${cloberTestChain.id},
+           '0x447ad4a108b5540c220f9f7e83723ac87c0f8fd8',
+           '0x0000000000000000000000000000000000000000',
+       )
+    `)
+})
+
+// test('market bid with unlimited slippage', async () => {
+//   const signature = await signERC20Permit(
+//     cloberTestChain.id,
+//     account,
+//     '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//     '100',
+//     { rpcUrl: publicClient.transport.url! },
+//   )
+//   const transaction = await marketOrder(
+//     cloberTestChain.id,
+//     account.address,
+//     '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//     '0x0000000000000000000000000000000000000000',
+//     '100',
+//     { signature, rpcUrl: publicClient.transport.url! },
+//   )
+//
+//   const [beforeUSDCBalance, beforeETHBalance, beforeAskDepth] =
+//     await Promise.all([
+//       fetchTokenBalance(
+//         cloberTestChain.id,
+//         '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//         account.address,
+//         publicClient.transport.url!,
+//       ),
+//       publicClient.getBalance({
+//         address: account.address,
+//       }),
+//       fetchAskDepth(publicClient.transport.url!),
+//     ])
+//   expect(beforeAskDepth.length).toBeGreaterThan(0)
+//
+//   await walletClient.sendTransaction({ ...transaction!, account })
+//
+//   const [afterUSDCBalance, afterETHBalance, afterAskDepth] = await Promise.all([
+//     fetchTokenBalance(
+//       cloberTestChain.id,
+//       '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//       account.address,
+//       publicClient.transport.url!,
+//     ),
+//     publicClient.getBalance({
+//       address: account.address,
+//     }),
+//     fetchAskDepth(publicClient.transport.url!),
+//   ])
+//
+//   expect(Number(beforeUSDCBalance)).toBeGreaterThan(Number(afterUSDCBalance))
+//   expect(Number(afterETHBalance)).toBeGreaterThan(Number(beforeETHBalance))
+//   expect(beforeAskDepth.length).toBeGreaterThan(afterAskDepth.length)
+//   expect(afterAskDepth.length).toBe(0)
+// })
+//
+// test('market ask with unlimited slippage', async () => {
+//   const transaction = await marketOrder(
+//     cloberTestChain.id,
+//     account.address,
+//     '0x0000000000000000000000000000000000000000',
+//     '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//     '10',
+//     { rpcUrl: publicClient.transport.url! },
+//   )
+//
+//   const [beforeUSDCBalance, beforeETHBalance, beforeBidDepth] =
+//     await Promise.all([
+//       fetchTokenBalance(
+//         cloberTestChain.id,
+//         '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//         account.address,
+//         publicClient.transport.url!,
+//       ),
+//       publicClient.getBalance({
+//         address: account.address,
+//       }),
+//       fetchBidDepth(publicClient.transport.url!),
+//     ])
+//   expect(beforeBidDepth.length).toBeGreaterThan(0)
+//
+//   await walletClient.sendTransaction({ ...transaction!, account })
+//
+//   const [afterUSDCBalance, afterETHBalance, afterBidDepth] = await Promise.all([
+//     fetchTokenBalance(
+//       cloberTestChain.id,
+//       '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//       account.address,
+//       publicClient.transport.url!,
+//     ),
+//     publicClient.getBalance({
+//       address: account.address,
+//     }),
+//     fetchBidDepth(publicClient.transport.url!),
+//   ])
+//
+//   expect(Number(afterUSDCBalance)).toBeGreaterThan(Number(beforeUSDCBalance))
+//   expect(Number(beforeETHBalance)).toBeGreaterThan(Number(afterETHBalance))
+//   expect(beforeBidDepth.length).toBeGreaterThan(afterBidDepth.length)
+//   expect(afterBidDepth.length).toBe(0)
+// })
+//
+// test('market bid with slippage tolerate', async () => {
+//   const market = await getMarket(
+//     cloberTestChain.id,
+//     '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//     '0x0000000000000000000000000000000000000000',
+//     { rpcUrl: publicClient.transport.url! },
+//   )
+//   const signature = await signERC20Permit(
+//     cloberTestChain.id,
+//     account,
+//     '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//     '1000000',
+//     { rpcUrl: publicClient.transport.url! },
+//   )
+//   const transaction = await marketOrder(
+//     cloberTestChain.id,
+//     account.address,
+//     '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//     '0x0000000000000000000000000000000000000000',
+//     '1000000',
+//     {
+//       signature,
+//       rpcUrl: publicClient.transport.url!,
+//       limitPrice: (market.asks[0]!.price + 1).toString(),
+//     },
+//   )
+//
+//   const [beforeUSDCBalance, beforeETHBalance, beforeAskDepth] =
+//     await Promise.all([
+//       fetchTokenBalance(
+//         cloberTestChain.id,
+//         '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//         account.address,
+//         publicClient.transport.url!,
+//       ),
+//       publicClient.getBalance({
+//         address: account.address,
+//       }),
+//       fetchAskDepth(publicClient.transport.url!),
+//     ])
+//   expect(beforeAskDepth.length).toBeGreaterThan(1)
+//
+//   await walletClient.sendTransaction({ ...transaction!, account })
+//
+//   const [afterUSDCBalance, afterETHBalance, afterAskDepth] = await Promise.all([
+//     fetchTokenBalance(
+//       cloberTestChain.id,
+//       '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//       account.address,
+//       publicClient.transport.url!,
+//     ),
+//     publicClient.getBalance({
+//       address: account.address,
+//     }),
+//     fetchAskDepth(publicClient.transport.url!),
+//   ])
+//
+//   expect(Number(beforeUSDCBalance)).toBeGreaterThan(Number(afterUSDCBalance))
+//   expect(Number(afterETHBalance)).toBeGreaterThan(Number(beforeETHBalance))
+//   expect(beforeAskDepth.length).toBeGreaterThan(afterAskDepth.length)
+//   expect(afterAskDepth.length).toBeGreaterThan(0)
+// })
+//
+// test('market ask with slippage tolerate', async () => {
+//   const market = await getMarket(
+//     cloberTestChain.id,
+//     '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//     '0x0000000000000000000000000000000000000000',
+//     { rpcUrl: publicClient.transport.url! },
+//   )
+//   const transaction = await marketOrder(
+//     cloberTestChain.id,
+//     account.address,
+//     '0x0000000000000000000000000000000000000000',
+//     '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//     '10',
+//     {
+//       rpcUrl: publicClient.transport.url!,
+//       limitPrice: (market.bids[0]!.price - 1).toString(),
+//     },
+//   )
+//
+//   const [beforeUSDCBalance, beforeETHBalance, beforeBidDepth] =
+//     await Promise.all([
+//       fetchTokenBalance(
+//         cloberTestChain.id,
+//         '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//         account.address,
+//         publicClient.transport.url!,
+//       ),
+//       publicClient.getBalance({
+//         address: account.address,
+//       }),
+//       fetchBidDepth(publicClient.transport.url!),
+//     ])
+//   expect(beforeBidDepth.length).toBeGreaterThan(1)
+//
+//   await walletClient.sendTransaction({ ...transaction!, account })
+//
+//   const [afterUSDCBalance, afterETHBalance, afterBidDepth] = await Promise.all([
+//     fetchTokenBalance(
+//       cloberTestChain.id,
+//       '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+//       account.address,
+//       publicClient.transport.url!,
+//     ),
+//     publicClient.getBalance({
+//       address: account.address,
+//     }),
+//     fetchBidDepth(publicClient.transport.url!),
+//   ])
+//
+//   expect(Number(afterUSDCBalance)).toBeGreaterThan(Number(beforeUSDCBalance))
+//   expect(Number(beforeETHBalance)).toBeGreaterThan(Number(afterETHBalance))
+//   expect(beforeBidDepth.length).toBeGreaterThan(afterBidDepth.length)
+//   expect(afterBidDepth.length).toBeGreaterThan(0)
+// })

package/test/market.test.ts

@@ -0,0 +1,68 @@
+import { expect, test } from 'vitest'
+import { arbitrumSepolia } from 'viem/chains'
+import { getAddress } from 'viem'
+import { getMarket } from '@clober/v2-sdk'
+
+import { publicClient } from './utils/constants'
+
+test('fetch open market', async () => {
+  const market = await getMarket(
+    arbitrumSepolia.id,
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    { rpcUrl: publicClient.transport.url! },
+  )
+
+  expect(market.makerFee).toEqual(-0.03)
+  expect(market.takerFee).toEqual(0.1)
+
+  expect(market.quote.address).toEqual(
+    getAddress('0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0'),
+  )
+  expect(market.quote.symbol).toEqual('MT')
+  expect(market.quote.name).toEqual('MockERC20')
+  expect(market.quote.decimals).toEqual(6)
+
+  expect(market.base.address).toEqual(
+    getAddress('0x0000000000000000000000000000000000000000'),
+  )
+  expect(market.base.symbol).toEqual('ETH')
+  expect(market.base.name).toEqual('Ethereum')
+  expect(market.base.decimals).toEqual(18)
+
+  expect(market.bidBookOpen).toEqual(true)
+  expect(market.askBookOpen).toEqual(true)
+})
+
+test('fetch empty market', async () => {
+  const market = await getMarket(
+    arbitrumSepolia.id,
+    '0x447ad4a108b5540c220f9f7e83723ac87c0f8fd8',
+    '0x0000000000000000000000000000000000000000',
+    { rpcUrl: publicClient.transport.url! },
+  )
+  expect(market.bidBookOpen).toEqual(true)
+})
+
+// @dev: this test will be fail when the market is open
+test('fetch not open market', async () => {
+  const market = await getMarket(
+    arbitrumSepolia.id,
+    '0xf18Be2a91cF31Fc3f8D828b6c714e1806a75e0AA',
+    '0x0000000000000000000000000000000000000000',
+    { rpcUrl: publicClient.transport.url! },
+  )
+  expect(market.bidBookOpen).toEqual(false)
+  expect(market.askBookOpen).toEqual(false)
+})
+
+test('fetch invalid market', async () => {
+  expect(
+    await getMarket(
+      arbitrumSepolia.id,
+      '0x0000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000',
+      { rpcUrl: publicClient.transport.url! },
+    ).catch((e) => e.message),
+  ).toEqual('Token0 and token1 must be different')
+})

package/test/math.test.ts

@@ -0,0 +1,91 @@
+import { expect, test } from 'vitest'
+import { getAddress } from 'viem'
+
+import { lnWad } from '../src/utils/math'
+
+import { publicClient } from './utils/constants'
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: 'uint256',
+        name: 'a',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'b',
+        type: 'uint256',
+      },
+      {
+        internalType: 'bool',
+        name: 'roundingUp',
+        type: 'bool',
+      },
+    ],
+    name: 'divide',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'int256',
+        name: 'x',
+        type: 'int256',
+      },
+    ],
+    name: 'lnWad',
+    outputs: [
+      {
+        internalType: 'int256',
+        name: '',
+        type: 'int256',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+] as const
+
+const MATH_WRAPPER_ADDRESS = '0x98d55f0AaEda3bad7815C8F3d8f8882e6B702D26'
+
+const randomInteger = (start: number, end: number) => {
+  return Math.floor(Math.random() * (end - start + 1) + start)
+}
+
+const MIN_PRICE = 1350587n
+const MAX_PRICE = 4647684107270898330752324302845848816923571339324334n
+
+test('lnWad', async () => {
+  const randomValues = [
+    MIN_PRICE,
+    ...Array.from({ length: 500 }, () =>
+      randomInteger(Number(MIN_PRICE + 1n), Number(MAX_PRICE - 1n)),
+    ),
+    MAX_PRICE,
+  ]
+  const actualValues = (
+    (await publicClient.multicall({
+      contracts: randomValues.map((value) => ({
+        address: getAddress(MATH_WRAPPER_ADDRESS),
+        abi: _abi,
+        functionName: 'lnWad',
+        args: [value],
+      })),
+    })) as { result: bigint }[]
+  ).map(({ result }) => result)
+
+  const expectedValues = randomValues.map((priceIndex) =>
+    lnWad(BigInt(priceIndex)),
+  )
+  expect(expectedValues).toEqual(actualValues)
+})