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

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

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

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

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

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

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

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

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

@@ -1,82 +0,0 @@
-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],
-  })
-}