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

package/src/abis/core/params-abi.ts

@@ -0,0 +1,59 @@
+export const TAKE_ORDER_PARAMS_ABI = [
+  {
+    components: [
+      {
+        internalType: 'BookId',
+        name: 'id',
+        type: 'uint192',
+      },
+      {
+        internalType: 'uint256',
+        name: 'limitPrice',
+        type: 'uint256',
+      },
+      {
+        internalType: 'uint256',
+        name: 'quoteAmount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'bytes',
+        name: 'hookData',
+        type: 'bytes',
+      },
+    ],
+    internalType: 'struct IController.TakeOrderParams',
+    name: 'params',
+    type: 'tuple',
+  },
+]
+
+export const MAKE_ORDER_PARAMS_ABI = [
+  {
+    components: [
+      {
+        internalType: 'BookId',
+        name: 'id',
+        type: 'uint192',
+      },
+      {
+        internalType: 'Tick',
+        name: 'tick',
+        type: 'int24',
+      },
+      {
+        internalType: 'uint256',
+        name: 'quoteAmount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'bytes',
+        name: 'hookData',
+        type: 'bytes',
+      },
+    ],
+    internalType: 'struct IController.MakeOrderParams',
+    name: 'params',
+    type: 'tuple',
+  },
+]

package/src/apis/currency.ts

@@ -0,0 +1,92 @@
+import { createPublicClient, http, isAddressEqual, zeroAddress } from 'viem'
+
+import type { Currency } from '../model/currency'
+import { CHAIN_IDS, CHAIN_MAP } from '../constants/chain'
+
+const _abi = [
+  {
+    inputs: [],
+    name: 'name',
+    outputs: [
+      {
+        internalType: 'string',
+        name: '',
+        type: 'string',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'symbol',
+    outputs: [
+      {
+        internalType: 'string',
+        name: '',
+        type: 'string',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'decimals',
+    outputs: [
+      {
+        internalType: 'uint8',
+        name: '',
+        type: 'uint8',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const
+
+export const fetchCurrency = async (
+  chainId: CHAIN_IDS,
+  address: `0x${string}`,
+  rpcUrl?: string,
+): Promise<Currency> => {
+  if (isAddressEqual(address, zeroAddress)) {
+    return {
+      address: zeroAddress,
+      name: 'Ethereum',
+      symbol: 'ETH',
+      decimals: 18,
+    }
+  }
+
+  const publicClient = createPublicClient({
+    chain: CHAIN_MAP[chainId],
+    transport: rpcUrl ? http(rpcUrl) : http(),
+  })
+  const [{ result: name }, { result: symbol }, { result: decimals }] =
+    await publicClient.multicall({
+      contracts: [
+        {
+          address,
+          abi: _abi,
+          functionName: 'name',
+        },
+        {
+          address,
+          abi: _abi,
+          functionName: 'symbol',
+        },
+        {
+          address,
+          abi: _abi,
+          functionName: 'decimals',
+        },
+      ],
+    })
+  return {
+    address,
+    name: name ?? 'Unknown',
+    symbol: symbol ?? 'Unknown',
+    decimals: decimals ?? 18,
+  }
+}

package/src/apis/graphql/books.graphql

@@ -0,0 +1,25 @@
+query getBooks($baseTokenAddress: String!, $quoteTokenAddress: String!) {
+    books(
+        where: {base: $baseTokenAddress, quote: $quoteTokenAddress, makerPolicy: "8888308", takerPolicy: "8889608", hooks: "0x0000000000000000000000000000000000000000"}
+    ) {
+        id
+        base {
+            id
+            name
+            symbol
+            decimals
+        }
+        quote {
+            id
+            name
+            symbol
+            decimals
+        }
+        unit
+        depths {
+            tick
+            price
+            rawAmount
+        }
+    }
+}

package/src/apis/graphql/open-order.graphql

@@ -0,0 +1,29 @@
+query getOpenOrder($orderId: ID!) {
+  openOrder(id: $orderId) {
+    id
+    book {
+      id
+      base {
+        id
+        name
+        symbol
+        decimals
+      }
+      quote {
+        id
+        name
+        symbol
+        decimals
+      }
+      unit
+    }
+    tick
+    txHash
+    createdAt
+
+    rawAmount
+    rawFilledAmount
+    rawClaimedAmount
+    rawClaimableAmount
+  }
+}

package/src/apis/graphql/open-orders.graphql

@@ -0,0 +1,29 @@
+query getOpenOrders($userAddress: String!) {
+  openOrders(where: { user: $userAddress }) {
+    id
+    book {
+      id
+      base {
+        id
+        name
+        symbol
+        decimals
+      }
+      quote {
+        id
+        name
+        symbol
+        decimals
+      }
+      unit
+    }
+    tick
+    txHash
+    createdAt
+
+    rawAmount
+    rawFilledAmount
+    rawClaimedAmount
+    rawClaimableAmount
+  }
+}

package/src/apis/market.ts

@@ -0,0 +1,85 @@
+import { getAddress, isAddressEqual } from 'viem'
+
+import { CHAIN_IDS } from '../constants/chain'
+import { Market } from '../model/market'
+import { SUBGRAPH_URL } from '../constants/subgraph-url'
+import { getBuiltGraphSDK } from '../.graphclient'
+import { Book } from '../model/book'
+import type { RawDepth } from '../model/depth'
+import { getMarketId } from '../utils/market'
+
+import { fetchCurrency } from './currency'
+
+const { getBooks } = getBuiltGraphSDK()
+
+export async function fetchMarket(
+  chainId: CHAIN_IDS,
+  tokenAddresses: `0x${string}`[],
+  rpcUrl?: string,
+): Promise<Market> {
+  if (tokenAddresses.length !== 2) {
+    throw new Error('Invalid token pair')
+  }
+
+  const { quoteTokenAddress, baseTokenAddress } = getMarketId(chainId, [
+    tokenAddresses[0]!,
+    tokenAddresses[1]!,
+  ])
+
+  const [
+    quoteCurrency,
+    baseCurrency,
+    { books: bidBooks },
+    { books: askBooks },
+  ] = await Promise.all([
+    fetchCurrency(chainId, quoteTokenAddress, rpcUrl),
+    fetchCurrency(chainId, baseTokenAddress, rpcUrl),
+    getBooks(
+      {
+        quoteTokenAddress: quoteTokenAddress.toLowerCase(),
+        baseTokenAddress: baseTokenAddress.toLowerCase(),
+      },
+      {
+        url: SUBGRAPH_URL[chainId],
+      },
+    ),
+    getBooks(
+      {
+        quoteTokenAddress: baseTokenAddress.toLowerCase(),
+        baseTokenAddress: quoteTokenAddress.toLowerCase(),
+      },
+      {
+        url: SUBGRAPH_URL[chainId],
+      },
+    ),
+  ])
+
+  return new Market({
+    chainId,
+    tokens: [quoteCurrency, baseCurrency],
+    books: [...bidBooks, ...askBooks].map((book) => {
+      const isBid = isAddressEqual(
+        getAddress(book.quote.id),
+        quoteCurrency.address,
+      )
+      return new Book({
+        id: BigInt(book.id),
+        base: isBid ? baseCurrency : quoteCurrency,
+        quote: isBid ? quoteCurrency : baseCurrency,
+        unit: BigInt(book.unit),
+        depths: book.depths
+          .map((depth) => {
+            const rawAmount = BigInt(depth.rawAmount)
+            const tick = BigInt(depth.tick)
+            return {
+              bookId: String(book.id),
+              unit: BigInt(book.unit),
+              tick,
+              rawAmount,
+            } as RawDepth
+          })
+          .sort((a, b) => Number(b.tick) - Number(a.tick)),
+      })
+    }),
+  })
+}

package/src/apis/open-order.ts

@@ -0,0 +1,145 @@
+import { formatUnits, getAddress, isAddressEqual } from 'viem'
+
+import {
+  Book,
+  OpenOrder as SubGraphOpenOrder,
+  getBuiltGraphSDK,
+} from '../.graphclient'
+import { CHAIN_IDS } from '../constants/chain'
+import { SUBGRAPH_URL } from '../constants/subgraph-url'
+import { getMarketId } from '../utils/market'
+import { Currency } from '../model/currency'
+import { quoteToBase } from '../utils/decimals'
+import { formatPrice } from '../utils/prices'
+import { invertPrice, toPrice } from '../utils/tick'
+import { OpenOrder } from '../model/open-order'
+
+import { fetchCurrency } from './currency'
+
+const { getOpenOrders, getOpenOrder } = getBuiltGraphSDK()
+
+export async function fetchOpenOrders(
+  chainId: CHAIN_IDS,
+  userAddress: `0x${string}`,
+  rpcUrl?: string,
+): Promise<OpenOrder[]> {
+  const { openOrders } = await getOpenOrders(
+    {
+      userAddress: userAddress.toLowerCase(),
+    },
+    {
+      url: SUBGRAPH_URL[chainId],
+    },
+  )
+  const currencies = await Promise.all(
+    openOrders
+      .map((openOrder) => [
+        getAddress(openOrder.book.base.id),
+        getAddress(openOrder.book.quote.id),
+      ])
+      .flat()
+      .filter(
+        (address, index, self) =>
+          self.findIndex((c) => isAddressEqual(c, address)) === index,
+      )
+      .map((address) => fetchCurrency(chainId, address, rpcUrl)),
+  )
+  return openOrders.map((openOrder) =>
+    toOpenOrder(chainId, currencies, openOrder),
+  )
+}
+
+export async function fetchOpenOrder(
+  chainId: CHAIN_IDS,
+  id: string,
+  rpcUrl?: string,
+): Promise<OpenOrder> {
+  const { openOrder } = await getOpenOrder(
+    {
+      orderId: id,
+    },
+    {
+      url: SUBGRAPH_URL[chainId],
+    },
+  )
+  if (!openOrder) {
+    throw new Error(`Open order not found: ${id}`)
+  }
+  const currencies = await Promise.all([
+    fetchCurrency(chainId, getAddress(openOrder.book.base.id), rpcUrl),
+    fetchCurrency(chainId, getAddress(openOrder.book.quote.id), rpcUrl),
+  ])
+  return toOpenOrder(chainId, currencies, openOrder)
+}
+
+const toOpenOrder = (
+  chainId: CHAIN_IDS,
+  currencies: Currency[],
+  openOrder: Pick<
+    SubGraphOpenOrder,
+    | 'id'
+    | 'tick'
+    | 'txHash'
+    | 'createdAt'
+    | 'rawAmount'
+    | 'rawFilledAmount'
+    | 'rawClaimedAmount'
+    | 'rawClaimableAmount'
+  > & {
+    book: Pick<Book, 'id' | 'unit'> & {
+      quote: { id: string }
+      base: { id: string }
+    }
+  },
+): OpenOrder => {
+  const inputCurrency = currencies.find((c: Currency) =>
+    isAddressEqual(c.address, getAddress(openOrder.book.quote.id)),
+  )!
+  const outputCurrency = currencies.find((c: Currency) =>
+    isAddressEqual(c.address, getAddress(openOrder.book.base.id)),
+  )!
+  const { quoteTokenAddress } = getMarketId(chainId, [
+    inputCurrency.address,
+    outputCurrency.address,
+  ])
+  const isBid = isAddressEqual(quoteTokenAddress, inputCurrency.address)
+  const quote = isBid ? inputCurrency : outputCurrency
+  const base = isBid ? outputCurrency : inputCurrency
+  const tick = BigInt(openOrder.tick)
+  const rawAmount = BigInt(openOrder.rawAmount)
+  const rawFilledAmount = BigInt(openOrder.rawFilledAmount)
+  const unit = BigInt(openOrder.book.unit)
+  const quoteAmount = unit * rawAmount
+  const rawClaimedAmount = BigInt(openOrder.rawClaimedAmount)
+  const rawClaimableAmount = BigInt(openOrder.rawClaimableAmount)
+  const amount = isBid ? quoteToBase(tick, quoteAmount, false) : quoteAmount
+  const filled = isBid
+    ? quoteToBase(tick, unit * rawFilledAmount, false)
+    : unit * rawFilledAmount
+  const claimed = quoteToBase(tick, unit * rawClaimedAmount, false)
+  const claimable = quoteToBase(tick, unit * rawClaimableAmount, false)
+  return {
+    id: openOrder.id,
+    isBid,
+    inputCurrency,
+    outputCurrency,
+    txHash: openOrder.txHash as `0x${string}`,
+    createdAt: Number(openOrder.createdAt),
+    price: formatPrice(
+      isBid ? toPrice(tick) : invertPrice(toPrice(tick)),
+      quote.decimals,
+      base.decimals,
+    ),
+    amount: { currency: base, value: formatUnits(amount, base.decimals) },
+    filled: { currency: base, value: formatUnits(filled, base.decimals) },
+    claimed: {
+      currency: outputCurrency,
+      value: formatUnits(claimed, outputCurrency.decimals),
+    },
+    claimable: {
+      currency: outputCurrency,
+      value: formatUnits(claimable, outputCurrency.decimals),
+    },
+    cancelable: rawAmount > rawFilledAmount,
+  }
+}

package/src/approval.ts

@@ -0,0 +1,82 @@
+import { createWalletClient, HDAccount, http, PrivateKeyAccount } from 'viem'
+
+import { CHAIN_IDS, CHAIN_MAP } from './constants/chain'
+import { CONTRACT_ADDRESSES } from './constants/addresses'
+import { fetchIsApprovedForAll } from './utils/approval'
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'operator',
+        type: 'address',
+      },
+      {
+        internalType: 'bool',
+        name: 'approved',
+        type: 'bool',
+      },
+    ],
+    name: 'setApprovalForAll',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const
+
+/**
+ * Sets approval of all open orders for the specified account on the given chain.
+ *
+ * @param {CHAIN_IDS} chainId The chain ID.
+ * @param {HDAccount | PrivateKeyAccount} account The Ethereum account for which approval is to be set.
+ * @param {Object} [options] Optional parameters for setting approval.
+ * @param {string} options.rpcUrl The RPC URL to use for executing the transaction.
+ * @returns {Promise<`0x${string}` | undefined>} Promise resolving to the transaction hash. If the account is already approved for all, the promise resolves to `undefined`.
+ * @example
+ * import { setApprovalOfOpenOrdersForAll } from '@clober/v2-sdk'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ *
+ * const hash = await setApprovalOfOpenOrdersForAll(
+ *   421614,
+ *   privateKeyToAccount('0x...')
+ * )
+ *
+ * @example
+ * import { setApprovalOfOpenOrdersForAll } from '@clober/v2-sdk'
+ * import { mnemonicToAccount } from 'viem/accounts'
+ *
+ * const hash = await setApprovalOfOpenOrdersForAll(
+ *   421614,
+ *   mnemonicToAccount('legal ...')
+ * )
+ */
+export const setApprovalOfOpenOrdersForAll = async (
+  chainId: CHAIN_IDS,
+  account: HDAccount | PrivateKeyAccount,
+  options?: {
+    rpcUrl: string
+  },
+): Promise<`0x${string}` | undefined> => {
+  const isApprovedForAll = await fetchIsApprovedForAll(
+    chainId,
+    account.address,
+    options?.rpcUrl,
+  )
+  if (isApprovedForAll) {
+    return undefined
+  }
+  const walletClient = createWalletClient({
+    chain: CHAIN_MAP[chainId],
+    account,
+    transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+  })
+  return walletClient.writeContract({
+    account,
+    chain: CHAIN_MAP[chainId],
+    address: CONTRACT_ADDRESSES[chainId]!.BookManager,
+    abi: _abi,
+    functionName: 'setApprovalForAll',
+    args: [CONTRACT_ADDRESSES[chainId]!.Controller, true],
+  })
+}