@0xtorch/core 0.0.35 → 0.0.37

package/actions/utils/transfer.ts

@@ -1,57 +0,0 @@
-import type {
-  Transfer,
-  TransferCryptoCurrencyIn,
-  TransferCryptoCurrencyNone,
-  TransferCryptoCurrencyOut,
-  TransferFiatCurrencyIn,
-  TransferFiatCurrencyNone,
-  TransferFiatCurrencyOut,
-  TransferNftIn,
-  TransferNftNone,
-  TransferNftOut,
-} from '../types'
-
-export const isTransferCryptoCurrencyIn = (
-  transfer: Transfer,
-): transfer is TransferCryptoCurrencyIn =>
-  transfer.direction === 'in' && transfer.asset.type === 'CryptoCurrency'
-
-export const isTransferCryptoCurrencyOut = (
-  transfer: Transfer,
-): transfer is TransferCryptoCurrencyOut =>
-  transfer.direction === 'out' && transfer.asset.type === 'CryptoCurrency'
-
-export const isTransferCryptoCurrencyNone = (
-  transfer: Transfer,
-): transfer is TransferCryptoCurrencyNone =>
-  transfer.direction === 'none' && transfer.asset.type === 'CryptoCurrency'
-
-export const isTransferNftIn = (
-  transfer: Transfer,
-): transfer is TransferNftIn =>
-  transfer.direction === 'in' && transfer.asset.type === 'Nft'
-
-export const isTransferNftOut = (
-  transfer: Transfer,
-): transfer is TransferNftOut =>
-  transfer.direction === 'out' && transfer.asset.type === 'Nft'
-
-export const isTransferNftNone = (
-  transfer: Transfer,
-): transfer is TransferNftNone =>
-  transfer.direction === 'none' && transfer.asset.type === 'Nft'
-
-export const isTransferFiatCurrencyIn = (
-  transfer: Transfer,
-): transfer is TransferFiatCurrencyIn =>
-  transfer.direction === 'in' && transfer.asset.type === 'FiatCurrency'
-
-export const isTransferFiatCurrencyOut = (
-  transfer: Transfer,
-): transfer is TransferFiatCurrencyOut =>
-  transfer.direction === 'out' && transfer.asset.type === 'FiatCurrency'
-
-export const isTransferFiatCurrencyNone = (
-  transfer: Transfer,
-): transfer is TransferFiatCurrencyNone =>
-  transfer.direction === 'none' && transfer.asset.type === 'FiatCurrency'

package/assets/creates/index.ts

@@ -1,2 +0,0 @@
-export { createCryptoCurrency } from './createCryptoCurrency'
-export { createFiatCurrency } from './createFiatCurrency'

package/assets/definitions/coingeckoCryptoCurrencyDataSource.ts

@@ -1,165 +0,0 @@
-import { createBigDecimal } from '@0xtorch/big-decimal'
-
-import type { Config } from '../../types'
-import { fiatCurrencyDecimals } from '../constants'
-import { getCoinMarketChartRange, getCoinsMarkets } from '../externals'
-import type {
-  CryptoCurrency,
-  CryptoCurrencyDataSource,
-  CryptoCurrencyPrice,
-  FiatCurrency,
-} from '../types'
-
-const createCryptoCurrencyDataSource = <
-  const dataSource extends CryptoCurrencyDataSource,
->(
-  dataSource: dataSource,
-): dataSource => ({
-  ...dataSource,
-})
-
-export const coingeckoCryptoCurrencyDataSource = createCryptoCurrencyDataSource(
-  {
-    getCurrentPrice: async (
-      { targetCurrencies, vsCurrency },
-      config?: Config,
-    ) => {
-      if (
-        targetCurrencies.some(
-          (currency) => currency.market.coingeckoId === undefined,
-        )
-      ) {
-        throw new Error(
-          'require parameters.targetCurrencies.market.coingeckoId',
-        )
-      }
-      const coingeckoIds = targetCurrencies.map(
-        (currency) => currency.market.coingeckoId!,
-      )
-      const coins = await getCoinsMarkets(
-        {
-          vs_currency: vsCurrency.id,
-          ids: coingeckoIds,
-        },
-        config,
-      )
-      if (coins.length !== targetCurrencies.length) {
-        throw new Error('invalid response')
-      }
-      return targetCurrencies.map((currency) => {
-        const targetCoin = coins.find(
-          (coin) => coin.id === currency.market.coingeckoId,
-        )
-        if (targetCoin === undefined) {
-          throw new Error('invalid response')
-        }
-        return {
-          cryptoCurrencyId: currency.id,
-          crypto: currency,
-          fiatCurrencyId: vsCurrency.id,
-          price: createBigDecimal(
-            targetCoin.current_price.toFixed(fiatCurrencyDecimals),
-            fiatCurrencyDecimals,
-          ),
-          timestamp: new Date(targetCoin.last_updated).getTime(),
-        }
-      })
-    },
-    getHistoricalPrices: async (
-      { targetCurrency, vsCurrency, timestampList },
-      config?: Config,
-    ) => {
-      if (timestampList.length === 0) {
-        return []
-      }
-
-      const timeoutTimestamp =
-        Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
-      if (targetCurrency.market.coingeckoId === undefined) {
-        throw new Error(
-          'require parameters.targetCurrencies.market.coingeckoId',
-        )
-      }
-
-      // timestamp から from,to を生成する
-      const sortedTimestampList = timestampList.toSorted((a, b) => a - b)
-      const from = Math.floor(sortedTimestampList[0] / 1000)
-      const to = Math.ceil(sortedTimestampList.at(-1)! / 1000)
-
-      // from, to を 90 日間毎に分割する
-      const ranges = splitFromToBy90DaysSeconds(from, to)
-
-      // 通貨毎に価格を取得する
-      const prices = await getCryptoCurrencyPrices(
-        targetCurrency,
-        vsCurrency,
-        ranges,
-        {
-          timeout: timeoutTimestamp - Date.now(),
-          logger: config?.logger,
-        },
-      )
-      return prices
-    },
-  },
-)
-
-const getCryptoCurrencyPrices = async (
-  cryptoCurrency: CryptoCurrency,
-  vsCurrency: FiatCurrency,
-  ranges: readonly { readonly from: number; readonly to: number }[],
-  config?: Config,
-): Promise<readonly CryptoCurrencyPrice[]> => {
-  const timeoutTimestamp =
-    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
-
-  if (cryptoCurrency.market.coingeckoId === undefined) {
-    throw new Error('invalid cryptoCurrency')
-  }
-  const mut_prices: CryptoCurrencyPrice[] = []
-  for (const { from, to } of ranges) {
-    const { prices } = await getCoinMarketChartRange(
-      {
-        id: cryptoCurrency.market.coingeckoId,
-        vs_currency: vsCurrency.id,
-        from,
-        to,
-      },
-      {
-        timeout: timeoutTimestamp - Date.now(),
-        logger: config?.logger,
-      },
-    )
-    mut_prices.push(
-      ...prices.map(([timestamp, price]) => ({
-        cryptoCurrencyId: cryptoCurrency.id,
-        crypto: cryptoCurrency,
-        fiatCurrencyId: vsCurrency.id,
-        timestamp,
-        price: createBigDecimal(
-          price.toFixed(fiatCurrencyDecimals),
-          fiatCurrencyDecimals,
-        ),
-      })),
-    )
-  }
-  return mut_prices
-}
-
-/** 90日間の秒数 */
-const DAYS_90_SECONDS = 60 * 60 * 24 * 90
-
-/** from, to を 90 日間毎に分割する */
-export const splitFromToBy90DaysSeconds = (
-  from: number,
-  to: number,
-): { readonly from: number; readonly to: number }[] => {
-  const diffSeconds = to - from
-  const count = Math.ceil(diffSeconds / DAYS_90_SECONDS)
-
-  return Array.from({ length: count }, (_, index) => {
-    const currentFrom = from + DAYS_90_SECONDS * index
-    const currentTo = Math.min(to, from + DAYS_90_SECONDS * (index + 1))
-    return { from: currentFrom, to: currentTo }
-  })
-}

package/assets/definitions/index.ts

@@ -1,18 +0,0 @@
-export { astar } from './astar'
-export { avalanche } from './avalanche'
-export { bnb } from './bnb'
-export { coingeckoCryptoCurrencyDataSource } from './coingeckoCryptoCurrencyDataSource'
-export { ethereum } from './ethereum'
-export { eur } from './eur'
-export { fantom } from './fantom'
-export { jpy } from './jpy'
-export { kava } from './kava'
-export { mantle } from './mantle'
-export { maticNetwork } from './maticNetwork'
-export { metis } from './metis'
-export { moonbeam } from './moonbeam'
-export { moonriver } from './moonriver'
-export { oasys } from './oasys'
-export { ronin } from './ronin'
-export { solana } from './solana'
-export { usd } from './usd'

package/assets/externals/coingecko/constants.ts

@@ -1 +0,0 @@
-export const rootUrl = 'https://api.coingecko.com/api/v3'

package/assets/externals/coingecko/getAutoRetry.ts

@@ -1,35 +0,0 @@
-import type { Config } from '../../../types'
-import type { Schema } from '../../../utils'
-import { rest } from '../../../utils'
-import { HttpRequestError } from '../../../utils/errors'
-
-export const getAutoRetry = async <TData>(
-  url: string,
-  schema: Schema<TData>,
-  config?: Config,
-): Promise<TData> => {
-  const timeoutTimestamp =
-    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
-
-  let mut_retryCount = 0
-  const loop = true
-  while (loop) {
-    try {
-      return await rest(url, {
-        schema,
-        timeout: timeoutTimestamp - Date.now(),
-        logger: config?.logger,
-      })
-    } catch (error) {
-      if (error instanceof HttpRequestError && error.status === 429) {
-        mut_retryCount += 1
-        await new Promise<void>((resolve) =>
-          setTimeout(resolve, mut_retryCount + 1 * 60_000),
-        )
-      } else {
-        throw error
-      }
-    }
-  }
-  throw new Error('Unreachable')
-}

package/assets/externals/coingecko/getCoinMarketChartRange.ts

@@ -1,88 +0,0 @@
-import type { ReadonlyDeep } from 'type-fest'
-import { z } from 'zod'
-import type { Config } from '../../../types'
-import { rootUrl } from './constants'
-import { getAutoRetry } from './getAutoRetry'
-
-type GetCoinMarketChartRangeParameters = {
-  /**
-   * coin id
-   *
-   * @example "bitcoin"
-   * */
-  readonly id: string
-  /** The target currency of market data (usd, eur, jpy, etc.) */
-  readonly vs_currency?: string
-  /**
-   * From date in UNIX Timestamp
-   *
-   * @example 1392577232
-   */
-  readonly from: number
-  /**
-   * To date in UNIX Timestamp
-   *
-   * @example 1422577232
-   */
-  readonly to: number
-  /**
-   * **full** or any value between 0 - 18 to specify decimal place for currency price value
-   */
-  readonly precision?:
-    | 'full'
-    | '0'
-    | '1'
-    | '2'
-    | '3'
-    | '4'
-    | '5'
-    | '6'
-    | '7'
-    | '8'
-    | '9'
-    | '10'
-    | '11'
-    | '12'
-    | '13'
-    | '14'
-    | '15'
-    | '16'
-    | '17'
-    | '18'
-}
-
-const getCoinMarketChartRangeResponseSchema = z.object({
-  /** [UNIXTIME milliseconds, price][] @example [[1703229613690, 43920.82996790591]] */
-  prices: z.array(z.tuple([z.number(), z.number()])),
-  /** [UNIXTIME milliseconds, market_cap][] @example [[1703229613690, 860219630538.0055]] */
-  market_caps: z.array(z.tuple([z.number(), z.number()])),
-  /** [UNIXTIME milliseconds, total_volume][] @example [[1703229613690, 21233021243.384785]] */
-  total_volumes: z.array(z.tuple([z.number(), z.number()])),
-})
-type GetCoinMarketChartRangeResponse = ReadonlyDeep<
-  z.infer<typeof getCoinMarketChartRangeResponseSchema>
->
-
-export const getCoinMarketChartRange = async (
-  {
-    id,
-    vs_currency = 'usd',
-    from,
-    to,
-    precision = 'full',
-  }: GetCoinMarketChartRangeParameters,
-  config?: Config,
-): Promise<GetCoinMarketChartRangeResponse> => {
-  const url = new URL(`${rootUrl}/coins/${id}/market_chart/range`)
-  url.searchParams.set('vs_currency', vs_currency)
-  url.searchParams.set('from', from.toString())
-  url.searchParams.set('to', to.toString())
-  url.searchParams.set('precision', precision)
-
-  const response = await getAutoRetry(
-    url.toString(),
-    getCoinMarketChartRangeResponseSchema,
-    config,
-  )
-  return response
-}

package/assets/externals/coingecko/getCoinsMarkets.ts

@@ -1,106 +0,0 @@
-import type { ReadonlyDeep } from 'type-fest'
-import { z } from 'zod'
-import type { Config } from '../../../types'
-import { rootUrl } from './constants'
-import { getAutoRetry } from './getAutoRetry'
-
-type GetCoinMarketsParameters = {
-  readonly vs_currency?: string
-  readonly ids?: readonly string[]
-  readonly category?: string
-  readonly order?:
-    | 'market_cap_asc'
-    | 'market_cap_desc'
-    | 'volume_asc'
-    | 'volume_desc'
-    | 'id_asc'
-    | 'id_desc'
-  readonly per_page?: number
-  readonly page?: number
-  readonly sparkline?: boolean
-  readonly price_change_percentage?: string
-  readonly precision?:
-    | 'full'
-    | '0'
-    | '1'
-    | '2'
-    | '3'
-    | '4'
-    | '5'
-    | '6'
-    | '7'
-    | '8'
-    | '9'
-    | '10'
-    | '11'
-    | '12'
-    | '13'
-    | '14'
-    | '15'
-    | '16'
-    | '17'
-    | '18'
-}
-
-const getCoinMarketsResponseSchema = z.array(
-  z.object({
-    /** @example "bitcoin" */
-    id: z.string(),
-    /** @example "btc" */
-    symbol: z.string(),
-    /** @example "Bitcoin" */
-    name: z.string(),
-    /** @example "https://assets.coingecko.com/coins/images/1/large/bitcoin.png?1696501400" */
-    image: z.string(),
-    /** @example 43639.197719840064 */
-    current_price: z.number(),
-    /** @example 854305524160 */
-    market_cap: z.number().nullable().optional(),
-    /** @example 1 */
-    market_cap_rank: z.number().int().nullable().optional(),
-    /** @example "2023-12-22T09:35:19.746Z" */
-    last_updated: z.string(),
-  }),
-)
-type CoinMarketsResponse = ReadonlyDeep<
-  z.infer<typeof getCoinMarketsResponseSchema>
->
-
-/**
- * List all supported coins price, market cap, volume, and market related data
- * @link https://www.coingecko.com/api/documentation
- * */
-export const getCoinsMarkets = async (
-  {
-    vs_currency = 'usd',
-    ids,
-    category,
-    order = 'market_cap_desc',
-    per_page = 250,
-    page = 1,
-    sparkline,
-    price_change_percentage,
-    precision = 'full',
-  }: GetCoinMarketsParameters,
-  config?: Config,
-): Promise<CoinMarketsResponse> => {
-  const url = new URL(`${rootUrl}/coins/markets`)
-  url.searchParams.append('vs_currency', vs_currency)
-  url.searchParams.append('order', order)
-  url.searchParams.append('per_page', per_page.toString())
-  url.searchParams.append('page', page.toString())
-  url.searchParams.append('precision', precision)
-  if (ids !== undefined) url.searchParams.append('ids', ids.join(','))
-  if (category !== undefined) url.searchParams.append('category', category)
-  if (sparkline !== undefined)
-    url.searchParams.append('sparkline', sparkline.toString())
-  if (price_change_percentage !== undefined)
-    url.searchParams.append('price_change_percentage', price_change_percentage)
-
-  const response = await getAutoRetry(
-    url.toString(),
-    getCoinMarketsResponseSchema,
-    config,
-  )
-  return response
-}

package/assets/externals/coingecko/index.ts

@@ -1,2 +0,0 @@
-export { getCoinMarketChartRange } from './getCoinMarketChartRange'
-export { getCoinsMarkets } from './getCoinsMarkets'

package/assets/externals/index.ts

@@ -1 +0,0 @@
-export { getCoinMarketChartRange, getCoinsMarkets } from './coingecko'

package/portfolios/createPortfolio.ts

@@ -1,3 +0,0 @@
-export const createPortfolio = () => {
-  throw new Error('Not implemented')
-}

package/portfolios/index.ts

@@ -1,2 +0,0 @@
-export { createPortfolio } from './createPortfolio'
-export type { Portfolio } from './type'

package/portfolios/type.ts

@@ -1,3 +0,0 @@
-export type Portfolio = {
-  readonly id: string
-}

package/setAccountActionPrices.ts

@@ -1,131 +0,0 @@
-import { createBigDecimal } from '@0xtorch/big-decimal'
-import type { AccountAction } from './actions'
-import type {
-  CryptoCurrency,
-  CryptoCurrencyDataSource,
-  CryptoCurrencyPrice,
-  FiatCurrency,
-} from './assets'
-
-type SetAccountActionPricesParameters = {
-  readonly actions: readonly AccountAction[]
-  readonly fiat: FiatCurrency
-  readonly cryptoCurrencyDataSource: CryptoCurrencyDataSource
-}
-
-export const setAccountActionPrices = async ({
-  actions,
-  fiat,
-  cryptoCurrencyDataSource,
-}: SetAccountActionPricesParameters) => {
-  // crypto currency 毎の取得期間を作成
-  const targets = getCryptoCurrencyTargets(actions)
-
-  // 取得期間をもとに価格を取得
-  const cryptoCurrencyPricesOfTarget = await Promise.all(
-    targets.map(({ currency, timestampList }) =>
-      cryptoCurrencyDataSource.getHistoricalPrices({
-        targetCurrency: currency,
-        vsCurrency: fiat,
-        timestampList: [...new Set(timestampList)],
-      }),
-    ),
-  )
-  const prices = cryptoCurrencyPricesOfTarget
-    .flat()
-    .toSorted((a, b) => a.timestamp - b.timestamp)
-
-  // 価格を設定して返す
-  return actions.map((action) => setPrices(action, prices, fiat))
-}
-
-type CryptoCurrencyTarget = {
-  readonly currency: CryptoCurrency
-  readonly timestampList: readonly number[]
-}
-
-const getCryptoCurrencyTargets = (
-  actions: readonly AccountAction[],
-): readonly CryptoCurrencyTarget[] => {
-  const mut_targets: CryptoCurrencyTarget[] = []
-  for (const action of actions) {
-    for (const transfer of action.transfers) {
-      if (transfer.asset.type !== 'CryptoCurrency') {
-        continue
-      }
-      const targetIndex = mut_targets.findIndex(
-        (target) => target.currency.id === transfer.asset.id,
-      )
-      if (targetIndex === -1) {
-        mut_targets.push({
-          currency: transfer.asset,
-          timestampList: [action.timestamp],
-        })
-      } else {
-        const target = mut_targets[targetIndex]
-        mut_targets[targetIndex] = {
-          currency: target.currency,
-          timestampList: [...target.timestampList, action.timestamp],
-        }
-      }
-    }
-  }
-  return mut_targets
-}
-
-const setPrices = (
-  action: AccountAction,
-  prices: readonly CryptoCurrencyPrice[],
-  fiat: FiatCurrency,
-): AccountAction =>
-  ({
-    ...action,
-    transfers: action.transfers.map((transfer) => {
-      switch (transfer.asset.type) {
-        case 'CryptoCurrency': {
-          return {
-            ...transfer,
-            price: getPrice(prices, action.timestamp, transfer.asset.id),
-          }
-        }
-        case 'FiatCurrency': {
-          return transfer.asset.id === fiat.id
-            ? {
-                ...transfer,
-                price: {
-                  timestamp: action.timestamp,
-                  cryptoCurrencyId: '',
-                  fiatCurrencyId: fiat,
-                  price: createBigDecimal(1n),
-                },
-              }
-            : transfer
-        }
-        case 'Nft': {
-          return transfer
-        }
-      }
-    }),
-  }) as AccountAction
-
-const getPrice = (
-  prices: readonly CryptoCurrencyPrice[],
-  timestamp: number,
-  id: string | undefined,
-): CryptoCurrencyPrice | undefined =>
-  prices
-    .filter(
-      ({ cryptoCurrencyId, timestamp: priceTimestamp }) =>
-        cryptoCurrencyId === id &&
-        priceTimestamp >= timestamp - 1000 * 60 * 60 &&
-        priceTimestamp <= timestamp + 1000 * 60 * 60,
-    )
-    .reduce(
-      (closestPrice: CryptoCurrencyPrice | undefined, price) =>
-        closestPrice === undefined ||
-        Math.abs(price.timestamp - timestamp) <
-          Math.abs(closestPrice.timestamp - timestamp)
-          ? price
-          : closestPrice,
-      undefined,
-    )

package/tests/constants.ts

@@ -1 +0,0 @@
-export const isIntegrationTest = process.env.INTEGRATION_TEST === 'true'

package/tests/index.ts

@@ -1,2 +0,0 @@
-export { isIntegrationTest } from './constants'
-export { cryptoCurrencyDataSourceTest } from './utils'

package/tests/utils.ts

@@ -1,25 +0,0 @@
-import { createBigDecimal } from '@0xtorch/big-decimal'
-import type { CryptoCurrencyDataSource } from '../assets'
-
-export const cryptoCurrencyDataSourceTest: CryptoCurrencyDataSource = {
-  getCurrentPrice: async ({ targetCurrencies, vsCurrency }) => {
-    await new Promise((resolve) => setTimeout(resolve))
-    const timestamp = Date.now()
-    return targetCurrencies.map((currency) => ({
-      cryptoCurrencyId: currency.id,
-      crypto: currency,
-      fiatCurrencyId: vsCurrency.id,
-      price: createBigDecimal(100n),
-      timestamp,
-    }))
-  },
-  getHistoricalPrices: ({ targetCurrency, vsCurrency, timestampList }) => {
-    // TODO implement
-    console.debug('getHistoricalPrices', {
-      targetCurrency,
-      vsCurrency,
-      timestampList,
-    })
-    throw new Error('Not implemented')
-  },
-}