@0xtorch/core 0.0.1

package/src/assets/externals/coingecko/getAutoRetry.ts

@@ -0,0 +1,35 @@
+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/src/assets/externals/coingecko/getCoinMarketChartRange.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'bun:test'
+import { isIntegrationTest } from '../../../tests'
+import { getCoinMarketChartRange } from './getCoinMarketChartRange'
+
+describe('getCoinMarketChartRange', () => {
+  it.if(isIntegrationTest)('Should return validated object', async () => {
+    const to = Math.floor(Date.now() / 1000)
+    const days90Seconds = 60 * 60 * 24 * 90
+    const from = to - days90Seconds
+    const data = await getCoinMarketChartRange({ id: 'bitcoin', from, to })
+
+    // expected length is 90 days * 24 hours
+    const expectedLength = 90 * 24
+    expect(data.prices.length).toEqual(expectedLength)
+    expect(data.market_caps.length).toEqual(expectedLength)
+
+    // expected time difference between two prices is 1 hour
+    const hourMilliseconds = 1000 * 60 * 60
+    const expectedDiffTimeMin = hourMilliseconds * 0.9
+    const expectedDiffTimeMax = hourMilliseconds * 1.1
+    expect(data.prices[1][0] - data.prices[0][0]).toBeGreaterThan(
+      expectedDiffTimeMin,
+    )
+    expect(data.prices[1][0] - data.prices[0][0]).toBeLessThan(
+      expectedDiffTimeMax,
+    )
+  })
+})

package/src/assets/externals/coingecko/getCoinMarketChartRange.ts

@@ -0,0 +1,88 @@
+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/src/assets/externals/coingecko/getCoinsMarkets.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'bun:test'
+import { isIntegrationTest } from '../../../tests'
+import { getCoinsMarkets } from './getCoinsMarkets'
+
+describe('getCoinsMarkets', () => {
+  it.if(isIntegrationTest)('Should return validated object', async () => {
+    const data = await getCoinsMarkets({ ids: ['bitcoin'] })
+    expect(data).toHaveLength(1)
+    expect(data[0].id).toEqual('bitcoin')
+  })
+})

package/src/assets/externals/coingecko/getCoinsMarkets.ts

@@ -0,0 +1,106 @@
+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/src/assets/externals/coingecko/index.ts

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

package/src/assets/externals/index.ts

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

package/src/assets/index.ts

@@ -0,0 +1,27 @@
+export { fiatCurrencyDecimals } from './constants'
+export { createCryptoCurrency, createFiatCurrency } from './creates'
+export {
+  astar,
+  avalanche,
+  bnb,
+  coingeckoCryptoCurrencyDataSource,
+  ethereum,
+  eur,
+  fantom,
+  jpy,
+  kava,
+  mantle,
+  maticNetwork,
+  metis,
+  moonbeam,
+  moonriver,
+  ronin,
+  usd,
+} from './definitions'
+export type {
+  CryptoCurrency,
+  CryptoCurrencyDataSource,
+  CryptoCurrencyPrice,
+  FiatCurrency,
+  Nft,
+} from './types'

package/src/assets/types/cryptoCurrency.ts

@@ -0,0 +1,17 @@
+import type { BigDecimal } from '@0xtorch/big-decimal'
+
+export type CryptoCurrency = {
+  readonly type: 'CryptoCurrency'
+  readonly id: string
+  readonly name: string
+  readonly symbol: string
+  /** icon image's url */
+  readonly icon: string | undefined
+  readonly market: CryptoCurrencyMarket
+  readonly updatedAt: number
+}
+
+type CryptoCurrencyMarket = {
+  readonly coingeckoId: string | undefined
+  readonly marketCapUsd: BigDecimal | undefined
+}

package/src/assets/types/cryptoCurrencyPrice.ts

@@ -0,0 +1,14 @@
+import type { BigDecimal } from '@0xtorch/big-decimal'
+import type { CryptoCurrency } from '.'
+
+export type CryptoCurrencyPrice<
+  TCryptoCurrency extends CryptoCurrency | undefined =
+    | CryptoCurrency
+    | undefined,
+> = {
+  readonly cryptoCurrencyId: string
+  readonly crypto: TCryptoCurrency
+  readonly fiatCurrencyId: string
+  readonly price: BigDecimal
+  readonly timestamp: number
+}

package/src/assets/types/dataSource.ts

@@ -0,0 +1,26 @@
+import type { CryptoCurrency, FiatCurrency } from '.'
+import type { Config } from '../../types'
+import type { CryptoCurrencyPrice } from './cryptoCurrencyPrice'
+
+export type GetCurrentPriceParameters = {
+  readonly targetCurrencies: readonly CryptoCurrency[]
+  readonly vsCurrency: FiatCurrency
+}
+
+export type GetHistoricalPricesParameters = {
+  readonly targetCurrencies: readonly CryptoCurrency[]
+  readonly vsCurrency: FiatCurrency
+  readonly from: number
+  readonly to: number
+}
+
+export type CryptoCurrencyDataSource = {
+  readonly getCurrentPrice: (
+    parameters: GetCurrentPriceParameters,
+    config?: Config,
+  ) => Promise<readonly CryptoCurrencyPrice[]>
+  readonly getHistoricalPrices: (
+    parameters: GetHistoricalPricesParameters,
+    config?: Config,
+  ) => Promise<readonly CryptoCurrencyPrice[]>
+}

package/src/assets/types/fiatCurrency.ts

@@ -0,0 +1,21 @@
+export type FiatCurrency<Id extends FiatCurrencyId = FiatCurrencyId> = {
+  readonly type: 'FiatCurrency'
+  // TODO implement
+  readonly id: Id
+  readonly symbol: Uppercase<Id>
+  readonly name: string
+  /** icon image's url */
+  readonly icon: string | undefined
+}
+
+const fiatCurrencyIds = [
+  'cny',
+  'eur',
+  'idr',
+  'jpy',
+  'krw',
+  'rub',
+  'twd',
+  'usd',
+] as const
+export type FiatCurrencyId = (typeof fiatCurrencyIds)[number]

package/src/assets/types/index.ts

@@ -0,0 +1,9 @@
+export type { CryptoCurrency } from './cryptoCurrency'
+export type { CryptoCurrencyPrice } from './cryptoCurrencyPrice'
+export type {
+  CryptoCurrencyDataSource,
+  GetCurrentPriceParameters,
+  GetHistoricalPricesParameters,
+} from './dataSource'
+export type { FiatCurrency, FiatCurrencyId } from './fiatCurrency'
+export type { Nft } from './nft'

package/src/assets/types/nft.ts

@@ -0,0 +1,5 @@
+export type Nft = {
+  // TODO implement
+  readonly type: 'Nft'
+  readonly id: string
+}

package/src/index.cts

@@ -0,0 +1 @@
+module.exports = require('./index.mts')

package/src/index.mts

@@ -0,0 +1,79 @@
+export type { Account } from './accounts'
+export type {
+  AccountAction,
+  AccountActionAddLiquidity,
+  AccountActionAtomicArbitrage,
+  AccountActionBridgeFrom,
+  AccountActionBridgeTo,
+  AccountActionBuyNft,
+  AccountActionDeposit,
+  AccountActionDepositWithBond,
+  AccountActionFreeMintNft,
+  AccountActionIncome,
+  AccountActionMove,
+  AccountActionNftRoyalty,
+  AccountActionRemoveLiquidity,
+  AccountActionSellNft,
+  AccountActionSpam,
+  AccountActionSwapIncome,
+  AccountActionSwapNft,
+  AccountActionSwapTransfer,
+  AccountActionTrade,
+  AccountActionTransactionFee,
+  AccountActionTransfer,
+  AccountActionType,
+  AccountActionWithdraw,
+  AccountActionWithdrawWithBond,
+  ActionType,
+  Evidence,
+  NormalAction,
+  NormalActionAddLiquidity,
+  NormalActionAtomicArbitrage,
+  NormalActionBridgeFrom,
+  NormalActionBridgeTo,
+  NormalActionBuyNft,
+  NormalActionDeposit,
+  NormalActionDepositWithBond,
+  NormalActionFreeMintNft,
+  NormalActionRemoveLiquidity,
+  NormalActionSpam,
+  NormalActionTrade,
+  NormalActionTransactionFee,
+  NormalActionTransfer,
+  NormalActionWithdraw,
+  NormalActionWithdrawWithBond,
+} from './actions'
+export { appCategories } from './apps'
+export type { App, AppCategory } from './apps'
+export {
+  astar,
+  avalanche,
+  bnb,
+  coingeckoCryptoCurrencyDataSource,
+  createCryptoCurrency,
+  ethereum,
+  eur,
+  fantom,
+  fiatCurrencyDecimals,
+  jpy,
+  kava,
+  mantle,
+  maticNetwork,
+  metis,
+  moonbeam,
+  moonriver,
+  ronin,
+  usd,
+} from './assets'
+export type {
+  CryptoCurrency,
+  CryptoCurrencyDataSource,
+  CryptoCurrencyPrice,
+  FiatCurrency,
+  Nft,
+} from './assets'
+export { createPortfolio } from './portfolios'
+export type { Portfolio } from './portfolios'
+export type { Config, Logger } from './types'
+export { rest, stringify } from './utils'
+export type { Schema } from './utils'

package/src/portfolios/createPortfolio.test.ts

@@ -0,0 +1,7 @@
+import { describe, it } from 'bun:test'
+
+describe('createPortfolio', () => {
+  it.todo('should create a portfolio', () => {
+    // TODO
+  })
+})

package/src/portfolios/createPortfolio.ts

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

package/src/portfolios/index.ts

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

package/src/portfolios/type.ts

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

package/src/tests/constants.ts

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

package/src/tests/index.ts

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

package/src/tests/utils.ts

@@ -0,0 +1,26 @@
+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: ({ targetCurrencies, vsCurrency, from, to }) => {
+    // TODO implement
+    console.debug('getHistoricalPrices', {
+      targetCurrencies,
+      vsCurrency,
+      from,
+      to,
+    })
+    throw new Error('Not implemented')
+  },
+}

package/src/types.ts

@@ -0,0 +1,11 @@
+export type Logger = {
+  debug: (...data: unknown[]) => void
+  info: (...data: unknown[]) => void
+  warn: (...data: unknown[]) => void
+  error: (...data: unknown[]) => void
+}
+
+export type Config = {
+  readonly timeout?: number
+  readonly logger?: Logger
+}