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

package/test/fee-policy.test.ts

@@ -0,0 +1,228 @@
+import { expect, test } from 'vitest'
+
+import { FeePolicy } from '../src/model/fee-policy'
+import {
+  MAKER_DEFAULT_POLICY,
+  TAKER_DEFAULT_POLICY,
+} from '../src/constants/fee'
+
+import { publicClient } from './utils/constants'
+
+const _abi = [
+  {
+    inputs: [],
+    name: 'InvalidFeePolicy',
+    type: 'error',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'FeePolicy',
+        name: 'self',
+        type: 'uint24',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'bool',
+        name: 'reverseRounding',
+        type: 'bool',
+      },
+    ],
+    name: 'calculateFee',
+    outputs: [
+      {
+        internalType: 'int256',
+        name: 'fee',
+        type: 'int256',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'FeePolicy',
+        name: 'self',
+        type: 'uint24',
+      },
+      {
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'bool',
+        name: 'reverseFee',
+        type: 'bool',
+      },
+    ],
+    name: 'calculateOriginalAmount',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: 'originalAmount',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'bool',
+        name: 'usesQuote_',
+        type: 'bool',
+      },
+      {
+        internalType: 'int24',
+        name: 'rate_',
+        type: 'int24',
+      },
+    ],
+    name: 'encode',
+    outputs: [
+      {
+        internalType: 'FeePolicy',
+        name: 'feePolicy',
+        type: 'uint24',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'FeePolicy',
+        name: 'self',
+        type: 'uint24',
+      },
+    ],
+    name: 'usesQuote',
+    outputs: [
+      {
+        internalType: 'bool',
+        name: 'f',
+        type: 'bool',
+      },
+    ],
+    stateMutability: 'pure',
+    type: 'function',
+  },
+] as const
+
+const FEE_POLICY_WRAPPER_ADDRESS = '0x226Dad19a0C0E0faEB488601B61B1B67E434db6a'
+
+const encode = async (usesQuote: boolean, rate: number) => {
+  const mockPolicy = new FeePolicy(usesQuote, BigInt(rate))
+  const policy = await publicClient.readContract({
+    address: FEE_POLICY_WRAPPER_ADDRESS,
+    abi: _abi,
+    functionName: 'encode',
+    args: [usesQuote, rate],
+  })
+  expect(policy).toEqual(Number(mockPolicy.value))
+  expect(
+    await publicClient.readContract({
+      address: FEE_POLICY_WRAPPER_ADDRESS,
+      abi: _abi,
+      functionName: 'usesQuote',
+      args: [policy],
+    }),
+  ).toEqual(mockPolicy.usesQuote)
+}
+
+const checkCalculateFee = async (
+  policy: FeePolicy,
+  amount: bigint,
+  reverseRounding: boolean,
+) => {
+  expect(
+    await publicClient.readContract({
+      address: FEE_POLICY_WRAPPER_ADDRESS,
+      abi: _abi,
+      functionName: 'calculateFee',
+      args: [Number(policy.value), amount, reverseRounding],
+    }),
+  ).toEqual(policy.calculateFee(amount, reverseRounding))
+}
+
+const checkCalculateOriginalAmount = async (
+  policy: FeePolicy,
+  amount: bigint,
+  reverseFee: boolean,
+) => {
+  expect(
+    await publicClient.readContract({
+      address: FEE_POLICY_WRAPPER_ADDRESS,
+      abi: _abi,
+      functionName: 'calculateOriginalAmount',
+      args: [Number(policy.value), amount, reverseFee],
+    }),
+  ).toEqual(policy.calculateOriginalAmount(amount, reverseFee))
+}
+
+const checkFrom = async (policy: FeePolicy) => {
+  const _feePolicy = FeePolicy.from(policy.value)
+  expect(policy.usesQuote).toEqual(_feePolicy.usesQuote)
+  expect(policy.value).toEqual(_feePolicy.value)
+}
+
+test('check encode function', async () => {
+  await encode(true, 0)
+  await encode(true, 1)
+  await encode(true, Number(MAKER_DEFAULT_POLICY.rate))
+  await encode(true, Number(TAKER_DEFAULT_POLICY.rate))
+  await encode(true, 500000)
+  await encode(true, -500000)
+  await encode(false, 0)
+  await encode(false, 1)
+  await encode(false, 500000)
+  await encode(false, -500000)
+  await encode(false, Number(MAKER_DEFAULT_POLICY.rate))
+  await encode(false, Number(TAKER_DEFAULT_POLICY.rate))
+})
+
+test('check calculateFee function', async () => {
+  await checkCalculateFee(new FeePolicy(true, 0n), 1000000n, false)
+  await checkCalculateFee(new FeePolicy(true, 1n), 1000000n, false)
+  await checkCalculateFee(MAKER_DEFAULT_POLICY, 1000000n, false)
+  await checkCalculateFee(TAKER_DEFAULT_POLICY, 1000000n, false)
+  await checkCalculateFee(new FeePolicy(true, 500000n), 1000000n, false)
+  await checkCalculateFee(new FeePolicy(true, -500000n), 1000000n, false)
+})
+
+test('check calculateOriginalAmount function', async () => {
+  await checkCalculateOriginalAmount(new FeePolicy(true, 0n), 1000000n, false)
+  await checkCalculateOriginalAmount(new FeePolicy(true, 1n), 1000000n, false)
+  await checkCalculateOriginalAmount(MAKER_DEFAULT_POLICY, 1000000n, false)
+  await checkCalculateOriginalAmount(TAKER_DEFAULT_POLICY, 1000000n, false)
+  await checkCalculateOriginalAmount(
+    new FeePolicy(true, 500000n),
+    1000000n,
+    false,
+  )
+  await checkCalculateOriginalAmount(
+    new FeePolicy(true, -500000n),
+    1000000n,
+    false,
+  )
+})
+
+test('check static object', async () => {
+  checkFrom(new FeePolicy(true, 0n))
+  checkFrom(new FeePolicy(true, 1n))
+  checkFrom(MAKER_DEFAULT_POLICY)
+  checkFrom(TAKER_DEFAULT_POLICY)
+
+  checkFrom(new FeePolicy(false, 0n))
+  checkFrom(new FeePolicy(false, 1n))
+  checkFrom(MAKER_DEFAULT_POLICY)
+  checkFrom(TAKER_DEFAULT_POLICY)
+})

package/test/get-expected-input.test.ts

@@ -0,0 +1,206 @@
+import { expect, test } from 'vitest'
+import { getExpectedInput } from '@clober/v2-sdk'
+import { arbitrumSepolia } from 'viem/chains'
+import { formatUnits, isAddressEqual, parseUnits, zeroHash } from 'viem'
+
+import { fetchMarket } from '../src/apis/market'
+import { parsePrice } from '../src/utils/prices'
+import { invertPrice } from '../src/utils/tick'
+import { CONTRACT_ADDRESSES } from '../src/constants/addresses'
+
+import { publicClient } from './utils/constants'
+
+const _ABI = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: 'BookId',
+            name: 'id',
+            type: 'uint192',
+          },
+          {
+            internalType: 'uint256',
+            name: 'limitPrice',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'quoteAmount',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'maxBaseAmount',
+            type: 'uint256',
+          },
+          {
+            internalType: 'bytes',
+            name: 'hookData',
+            type: 'bytes',
+          },
+        ],
+        internalType: 'struct IController.TakeOrderParams',
+        name: 'params',
+        type: 'tuple',
+      },
+    ],
+    name: 'getExpectedInput',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: 'takenQuoteAmount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'spendBaseAmount',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
+const isTakeResultEqual = async (
+  inputToken: `0x${string}`,
+  outputToken: `0x${string}`,
+  amountOut: string,
+  limitPrice: string,
+) => {
+  const market = await fetchMarket(arbitrumSepolia.id, [
+    inputToken,
+    outputToken,
+  ])
+
+  const isBid = isAddressEqual(market.quote.address, inputToken)
+  const outputCurrency = isBid ? market.base : market.quote
+  const [takenQuoteAmount, spendBaseAmount] = await publicClient.readContract({
+    address: CONTRACT_ADDRESSES[arbitrumSepolia.id]!.BookViewer,
+    abi: _ABI,
+    functionName: 'getExpectedInput',
+    args: [
+      {
+        id: isBid
+          ? 2753017174304248252793812478093441832431186343406437115611n
+          : 2505799676027433010421416925405481572661563164234992034276n,
+        limitPrice: isBid
+          ? invertPrice(
+              parsePrice(
+                Number(limitPrice),
+                market.quote.decimals,
+                market.base.decimals,
+              ),
+            )
+          : parsePrice(
+              Number(limitPrice),
+              market.quote.decimals,
+              market.base.decimals,
+            ),
+        quoteAmount: parseUnits(amountOut, outputCurrency.decimals),
+        maxBaseAmount: 0n,
+        hookData: zeroHash,
+      },
+    ],
+  })
+
+  const { takenAmount, spendAmount } = await getExpectedInput(
+    arbitrumSepolia.id,
+    inputToken,
+    outputToken,
+    amountOut,
+    { limitPrice, rpcUrl: publicClient.transport.url! },
+  )
+
+  expect(takenAmount).toBe(
+    formatUnits(
+      takenQuoteAmount,
+      isBid ? market.base.decimals : market.quote.decimals,
+    ),
+  )
+  expect(spendAmount).toBe(
+    formatUnits(
+      spendBaseAmount,
+      isBid ? market.quote.decimals : market.base.decimals,
+    ),
+  )
+  return {
+    takenAmount,
+    spendAmount,
+  }
+}
+
+test('get expected input ask', async () => {
+  await isTakeResultEqual(
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    '0.1',
+    '100.01',
+  )
+
+  await isTakeResultEqual(
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    '0.2',
+    '4005.01',
+  )
+
+  await isTakeResultEqual(
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    '0.23',
+    '10000.01',
+  )
+
+  await isTakeResultEqual(
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    '10',
+    (Math.pow(2, 256) - 1).toFixed(0),
+  )
+})
+
+test('get expected input bid', async () => {
+  await isTakeResultEqual(
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '100000',
+    '4010.01',
+  )
+
+  await isTakeResultEqual(
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '100000',
+    '4005.16',
+  )
+
+  await isTakeResultEqual(
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '100000',
+    '200.12',
+  )
+
+  await isTakeResultEqual(
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '200000',
+    '0',
+  )
+})
+
+// @dev: this test will be fail when the market is open
+test('get expected input in not open book', async () => {
+  const { takenAmount, spendAmount } = await getExpectedInput(
+    arbitrumSepolia.id,
+    '0xf18Be2a91cF31Fc3f8D828b6c714e1806a75e0AA',
+    '0x0000000000000000000000000000000000000000',
+    '0.1',
+    { rpcUrl: publicClient.transport.url! },
+  )
+  expect(takenAmount).toBe('0')
+  expect(spendAmount).toBe('0')
+})

package/test/get-expected-output.test.ts

@@ -0,0 +1,206 @@
+import { expect, test } from 'vitest'
+import { getExpectedOutput } from '@clober/v2-sdk'
+import { arbitrumSepolia } from 'viem/chains'
+import { formatUnits, isAddressEqual, parseUnits, zeroHash } from 'viem'
+
+import { fetchMarket } from '../src/apis/market'
+import { parsePrice } from '../src/utils/prices'
+import { invertPrice } from '../src/utils/tick'
+import { CONTRACT_ADDRESSES } from '../src/constants/addresses'
+
+import { publicClient } from './utils/constants'
+
+const _ABI = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: 'BookId',
+            name: 'id',
+            type: 'uint192',
+          },
+          {
+            internalType: 'uint256',
+            name: 'limitPrice',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'baseAmount',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'minQuoteAmount',
+            type: 'uint256',
+          },
+          {
+            internalType: 'bytes',
+            name: 'hookData',
+            type: 'bytes',
+          },
+        ],
+        internalType: 'struct IController.SpendOrderParams',
+        name: 'params',
+        type: 'tuple',
+      },
+    ],
+    name: 'getExpectedOutput',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: 'takenQuoteAmount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'spendBaseAmount',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
+const isSpendResultEqual = async (
+  inputToken: `0x${string}`,
+  outputToken: `0x${string}`,
+  amountIn: string,
+  limitPrice: string,
+) => {
+  const market = await fetchMarket(arbitrumSepolia.id, [
+    inputToken,
+    outputToken,
+  ])
+
+  const isBid = isAddressEqual(market.quote.address, inputToken)
+  const inputCurrency = isBid ? market.quote : market.base
+  const [takenQuoteAmount, spendBaseAmount] = await publicClient.readContract({
+    address: CONTRACT_ADDRESSES[arbitrumSepolia.id]!.BookViewer,
+    abi: _ABI,
+    functionName: 'getExpectedOutput',
+    args: [
+      {
+        id: isBid
+          ? 2753017174304248252793812478093441832431186343406437115611n
+          : 2505799676027433010421416925405481572661563164234992034276n,
+        limitPrice: isBid
+          ? invertPrice(
+              parsePrice(
+                Number(limitPrice),
+                market.quote.decimals,
+                market.base.decimals,
+              ),
+            )
+          : parsePrice(
+              Number(limitPrice),
+              market.quote.decimals,
+              market.base.decimals,
+            ),
+        baseAmount: parseUnits(amountIn, inputCurrency.decimals),
+        minQuoteAmount: 0n,
+        hookData: zeroHash,
+      },
+    ],
+  })
+
+  const { takenAmount, spendAmount } = await getExpectedOutput(
+    arbitrumSepolia.id,
+    inputToken,
+    outputToken,
+    amountIn,
+    { limitPrice, rpcUrl: publicClient.transport.url! },
+  )
+
+  expect(takenAmount).toBe(
+    formatUnits(
+      takenQuoteAmount,
+      isBid ? market.base.decimals : market.quote.decimals,
+    ),
+  )
+  expect(spendAmount).toBe(
+    formatUnits(
+      spendBaseAmount,
+      isBid ? market.quote.decimals : market.base.decimals,
+    ),
+  )
+  return {
+    takenAmount,
+    spendAmount,
+  }
+}
+
+test('get expected output ask', async () => {
+  await isSpendResultEqual(
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    '1000.123',
+    '100.01',
+  )
+
+  await isSpendResultEqual(
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    '1000000',
+    '4005.01',
+  )
+
+  await isSpendResultEqual(
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    '1000.123',
+    '10000.01',
+  )
+
+  await isSpendResultEqual(
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0x0000000000000000000000000000000000000000',
+    '1000000',
+    (Math.pow(2, 256) - 1).toFixed(0),
+  )
+})
+
+test('get expected output bid', async () => {
+  await isSpendResultEqual(
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0.01',
+    '4010.01',
+  )
+
+  await isSpendResultEqual(
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '0.1',
+    '4005.01',
+  )
+
+  await isSpendResultEqual(
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '1.1234',
+    '200.01',
+  )
+
+  await isSpendResultEqual(
+    '0x0000000000000000000000000000000000000000',
+    '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+    '3.14',
+    '0',
+  )
+})
+
+// @dev: this test will be fail when the market is open
+test('get expected output in not open book', async () => {
+  const { takenAmount, spendAmount } = await getExpectedOutput(
+    arbitrumSepolia.id,
+    '0xf18Be2a91cF31Fc3f8D828b6c714e1806a75e0AA',
+    '0x0000000000000000000000000000000000000000',
+    '10000',
+    { rpcUrl: publicClient.transport.url! },
+  )
+  expect(takenAmount).toBe('0')
+  expect(spendAmount).toBe('0')
+})