@0xtorch/core 0.0.1

package/src/actions/types/trade.ts

@@ -0,0 +1,34 @@
+import type {
+  CryptoCurrency,
+  CryptoCurrencyPrice,
+  FiatCurrency,
+  Nft,
+} from '../../assets'
+import type { AccountAction, NormalAction } from './common'
+
+type Action = 'trade'
+
+export type NormalActionTrade<
+  Account = unknown,
+  // TODO crypto 以外の価格にも対応させる
+  Price extends CryptoCurrencyPrice | undefined =
+    | CryptoCurrencyPrice
+    | undefined,
+  Asset extends CryptoCurrency | FiatCurrency | Nft =
+    | CryptoCurrency
+    | FiatCurrency
+    | Nft,
+> = NormalAction<Action, Account, Price, Asset, 'in' | 'out'>
+
+export type AccountActionTrade<
+  Account = unknown,
+  Source extends string = string,
+  // TODO crypto 以外の価格にも対応させる
+  Price extends CryptoCurrencyPrice | undefined =
+    | CryptoCurrencyPrice
+    | undefined,
+  Asset extends CryptoCurrency | FiatCurrency | Nft =
+    | CryptoCurrency
+    | FiatCurrency
+    | Nft,
+> = AccountAction<Action, Source, Account, Price, Asset, 'in' | 'out'>

package/src/actions/types/transactionFee.ts

@@ -0,0 +1,19 @@
+import type { CryptoCurrency, CryptoCurrencyPrice } from '../../assets'
+import type { AccountAction, NormalAction } from './common'
+
+type Action = 'transaction-fee'
+
+export type NormalActionTransactionFee<
+  Account = unknown,
+  Price extends CryptoCurrencyPrice | undefined =
+    | CryptoCurrencyPrice
+    | undefined,
+> = NormalAction<Action, Account, Price, CryptoCurrency, 'out'>
+
+export type AccountActionTransactionFee<
+  Account = unknown,
+  Source extends string = string,
+  Price extends CryptoCurrencyPrice | undefined =
+    | CryptoCurrencyPrice
+    | undefined,
+> = AccountAction<Action, Source, Account, Price, CryptoCurrency, 'out'>

package/src/actions/types/transfer.ts

@@ -0,0 +1,36 @@
+import type {
+  CryptoCurrency,
+  CryptoCurrencyPrice,
+  FiatCurrency,
+  Nft,
+} from '../../assets'
+import type { AccountAction, NormalAction } from './common'
+
+export type Action = 'transfer'
+
+/** asset transfer */
+export type NormalActionTransfer<
+  Account = unknown,
+  // TODO crypto 以外の価格にも対応させる
+  Price extends CryptoCurrencyPrice | undefined =
+    | CryptoCurrencyPrice
+    | undefined,
+  Asset extends CryptoCurrency | FiatCurrency | Nft =
+    | CryptoCurrency
+    | FiatCurrency
+    | Nft,
+> = NormalAction<Action, Account, Price, Asset, 'none'>
+
+/** transfer from account to others */
+export type AccountActionTransfer<
+  Account = unknown,
+  Source extends string = string,
+  // TODO crypto 以外の価格にも対応させる
+  Price extends CryptoCurrencyPrice | undefined =
+    | CryptoCurrencyPrice
+    | undefined,
+  Asset extends CryptoCurrency | FiatCurrency | Nft =
+    | CryptoCurrency
+    | FiatCurrency
+    | Nft,
+> = AccountAction<Action, Source, Account, Price, Asset, 'out'>

package/src/actions/types/withdraw.ts

@@ -0,0 +1,23 @@
+import type { CryptoCurrency, CryptoCurrencyPrice, Nft } from '../../assets'
+import type { AccountAction, NormalAction } from './common'
+
+type Action = 'withdraw'
+
+export type NormalActionWithdraw<
+  Account = unknown,
+  // TODO crypto 以外の価格にも対応させる
+  Price extends CryptoCurrencyPrice | undefined =
+    | CryptoCurrencyPrice
+    | undefined,
+  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
+> = NormalAction<Action, Account, Price, Asset, 'in'>
+
+export type AccountActionWithdraw<
+  Account = unknown,
+  Source extends string = string,
+  // TODO crypto 以外の価格にも対応させる
+  Price extends CryptoCurrencyPrice | undefined =
+    | CryptoCurrencyPrice
+    | undefined,
+  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
+> = AccountAction<Action, Source, Account, Price, Asset, 'in'>

package/src/actions/types/withdrawWithBond.ts

@@ -0,0 +1,23 @@
+import type { CryptoCurrency, CryptoCurrencyPrice, Nft } from '../../assets'
+import type { AccountAction, NormalAction } from './common'
+
+type Action = 'withdraw-with-bond'
+
+export type NormalActionWithdrawWithBond<
+  Account = unknown,
+  // TODO crypto 以外の価格にも対応させる
+  Price extends CryptoCurrencyPrice | undefined =
+    | CryptoCurrencyPrice
+    | undefined,
+  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
+> = NormalAction<Action, Account, Price, Asset, 'in' | 'out'>
+
+export type AccountActionWithdrawWithBond<
+  Account = unknown,
+  Source extends string = string,
+  // TODO crypto 以外の価格にも対応させる
+  Price extends CryptoCurrencyPrice | undefined =
+    | CryptoCurrencyPrice
+    | undefined,
+  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
+> = AccountAction<Action, Source, Account, Price, Asset, 'in' | 'out'>

package/src/apps/index.ts

@@ -0,0 +1,2 @@
+export { appCategories } from './types'
+export type { App, AppCategory } from './types'

package/src/apps/types.ts

@@ -0,0 +1,20 @@
+export type App = {
+  readonly id: string
+  readonly categories: AppCategory[]
+  readonly name: string
+  readonly description: string | undefined
+  readonly website: string | undefined
+  readonly icon: string | undefined
+}
+
+export const appCategories = [
+  'bridge',
+  'cex',
+  'cross-chain',
+  'dex',
+  'gaming',
+  'lending',
+  'nft-marketplace',
+  'other',
+] as const
+export type AppCategory = (typeof appCategories)[number]

package/src/assets/constants.ts

@@ -0,0 +1 @@
+export const fiatCurrencyDecimals = 6

package/src/assets/creates/createCryptoCurrency.ts

@@ -0,0 +1,7 @@
+import type { CryptoCurrency } from '../types'
+
+export const createCryptoCurrency = <const currency extends CryptoCurrency>(
+  currency: currency,
+): currency => ({
+  ...currency,
+})

package/src/assets/creates/createFiatCurrency.ts

@@ -0,0 +1,10 @@
+import type { FiatCurrency, FiatCurrencyId } from '../types'
+
+export const createFiatCurrency = <
+  TId extends FiatCurrencyId,
+  const currency extends FiatCurrency<TId>,
+>(
+  currency: currency,
+): currency => ({
+  ...currency,
+})

package/src/assets/creates/index.ts

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

package/src/assets/definitions/astar.ts

@@ -0,0 +1,14 @@
+import { createCryptoCurrency } from '../creates'
+
+export const astar = createCryptoCurrency({
+  type: 'CryptoCurrency',
+  id: 'astar',
+  name: 'Astar',
+  symbol: 'ASTR',
+  icon: undefined,
+  market: {
+    coingeckoId: 'astar',
+    marketCapUsd: undefined,
+  },
+  updatedAt: Date.now(),
+})

package/src/assets/definitions/avalanche.ts

@@ -0,0 +1,14 @@
+import { createCryptoCurrency } from '../creates'
+
+export const avalanche = createCryptoCurrency({
+  type: 'CryptoCurrency',
+  id: 'avalanche-2',
+  name: 'Avalanche',
+  symbol: 'AVAX',
+  icon: undefined,
+  market: {
+    coingeckoId: 'avalanche-2',
+    marketCapUsd: undefined,
+  },
+  updatedAt: Date.now(),
+})

package/src/assets/definitions/bnb.ts

@@ -0,0 +1,14 @@
+import { createCryptoCurrency } from '../creates'
+
+export const bnb = createCryptoCurrency({
+  type: 'CryptoCurrency',
+  id: 'binancecoin',
+  name: 'BNB',
+  symbol: 'BNB',
+  icon: undefined,
+  market: {
+    coingeckoId: 'binancecoin',
+    marketCapUsd: undefined,
+  },
+  updatedAt: Date.now(),
+})

package/src/assets/definitions/coingeckoCryptoCurrencyDataSource.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'bun:test'
+import { isIntegrationTest } from '../../tests'
+import { bnb } from './bnb'
+import {
+  coingeckoCryptoCurrencyDataSource,
+  splitFromToBy90DaysSeconds,
+} from './coingeckoCryptoCurrencyDataSource'
+import { ethereum } from './ethereum'
+import { usd } from './usd'
+
+describe.if(isIntegrationTest)('coingeckoCryptoCurrencyDataSource', () => {
+  it('should get current price', async () => {
+    const prices = await coingeckoCryptoCurrencyDataSource.getCurrentPrice({
+      targetCurrencies: [ethereum, bnb],
+      vsCurrency: usd,
+    })
+    expect(prices).toHaveLength(2)
+    expect(prices[0].crypto.id).toBe(ethereum.id)
+    expect(prices[1].crypto.id).toBe(bnb.id)
+  })
+  it('should get historical prices', async () => {
+    const prices = await coingeckoCryptoCurrencyDataSource.getHistoricalPrices({
+      targetCurrencies: [ethereum],
+      vsCurrency: usd,
+      from: new Date('2021-01-01').getTime(),
+      to: new Date('2021-04-30').getTime(),
+    })
+    expect(prices.length).toBeGreaterThan(1000)
+  })
+})
+
+describe('splitFromToBy90DaysSeconds', () => {
+  it('should split the range into 90 day intervals', () => {
+    const from = 0
+    const to = 60 * 60 * 24 * 90 * 3 // 270 days in seconds
+    const result = splitFromToBy90DaysSeconds(from, to)
+    expect(result).toEqual([
+      { from: 0, to: 60 * 60 * 24 * 90 },
+      { from: 60 * 60 * 24 * 90, to: 60 * 60 * 24 * 90 * 2 },
+      { from: 60 * 60 * 24 * 90 * 2, to: 60 * 60 * 24 * 90 * 3 },
+    ])
+  })
+
+  it('should handle ranges that are not exact multiples of 90 days', () => {
+    const from = 0
+    const to = 60 * 60 * 24 * 95 // 95 days in seconds
+    const result = splitFromToBy90DaysSeconds(from, to)
+    expect(result).toEqual([
+      { from: 0, to: 60 * 60 * 24 * 90 },
+      { from: 60 * 60 * 24 * 90, to: 60 * 60 * 24 * 95 },
+    ])
+  })
+})

package/src/assets/definitions/coingeckoCryptoCurrencyDataSource.ts

@@ -0,0 +1,169 @@
+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 (
+      { targetCurrencies, vsCurrency, from, to },
+      config?: Config,
+    ) => {
+      const timeoutTimestamp =
+        Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
+      if (
+        targetCurrencies.some(
+          (currency) => currency.market.coingeckoId === undefined,
+        )
+      ) {
+        throw new Error(
+          'require parameters.targetCurrencies.market.coingeckoId',
+        )
+      }
+
+      // from,to を seconds に変換する
+      const fromSeconds = Math.floor(from / 1000)
+      const toSeconds = Math.ceil(to / 1000)
+
+      // from, to を 90 日間毎に分割する
+      const ranges = splitFromToBy90DaysSeconds(fromSeconds, toSeconds)
+
+      // 通貨毎に価格を取得する
+      const mut_prices: CryptoCurrencyPrice[] = []
+      for (const currency of targetCurrencies) {
+        const prices = await getCryptoCurrencyPrices(
+          currency,
+          vsCurrency,
+          ranges,
+          {
+            timeout: timeoutTimestamp - Date.now(),
+            logger: config?.logger,
+          },
+        )
+        mut_prices.push(...prices)
+      }
+
+      return mut_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/src/assets/definitions/ethereum.ts

@@ -0,0 +1,14 @@
+import { createCryptoCurrency } from '../creates'
+
+export const ethereum = createCryptoCurrency({
+  type: 'CryptoCurrency',
+  id: 'ethereum',
+  name: 'Ethereum',
+  symbol: 'ETH',
+  icon: undefined,
+  market: {
+    coingeckoId: 'ethereum',
+    marketCapUsd: undefined,
+  },
+  updatedAt: Date.now(),
+})

package/src/assets/definitions/eur.ts

@@ -0,0 +1,9 @@
+import { createFiatCurrency } from '../creates'
+
+export const eur = createFiatCurrency({
+  type: 'FiatCurrency',
+  id: 'eur',
+  symbol: 'EUR',
+  name: 'Euro',
+  icon: undefined,
+})

package/src/assets/definitions/fantom.ts

@@ -0,0 +1,14 @@
+import { createCryptoCurrency } from '../creates'
+
+export const fantom = createCryptoCurrency({
+  type: 'CryptoCurrency',
+  id: 'fantom',
+  name: 'Fantom',
+  symbol: 'FTM',
+  icon: undefined,
+  market: {
+    coingeckoId: 'fantom',
+    marketCapUsd: undefined,
+  },
+  updatedAt: Date.now(),
+})

package/src/assets/definitions/index.ts

@@ -0,0 +1,16 @@
+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 { ronin } from './ronin'
+export { usd } from './usd'

package/src/assets/definitions/jpy.ts

@@ -0,0 +1,9 @@
+import { createFiatCurrency } from '../creates'
+
+export const jpy = createFiatCurrency({
+  type: 'FiatCurrency',
+  id: 'jpy',
+  symbol: 'JPY',
+  name: 'Japanese Yen',
+  icon: undefined,
+})

package/src/assets/definitions/kava.ts

@@ -0,0 +1,14 @@
+import { createCryptoCurrency } from '../creates'
+
+export const kava = createCryptoCurrency({
+  type: 'CryptoCurrency',
+  id: 'kava',
+  name: 'Kava',
+  symbol: 'KAVA',
+  icon: undefined,
+  market: {
+    coingeckoId: 'kava',
+    marketCapUsd: undefined,
+  },
+  updatedAt: Date.now(),
+})

package/src/assets/definitions/mantle.ts

@@ -0,0 +1,14 @@
+import { createCryptoCurrency } from '../creates'
+
+export const mantle = createCryptoCurrency({
+  type: 'CryptoCurrency',
+  id: 'mantle',
+  name: 'Mantle',
+  symbol: 'MNT',
+  icon: undefined,
+  market: {
+    coingeckoId: 'mantle',
+    marketCapUsd: undefined,
+  },
+  updatedAt: Date.now(),
+})

package/src/assets/definitions/maticNetwork.ts

@@ -0,0 +1,14 @@
+import { createCryptoCurrency } from '../creates'
+
+export const maticNetwork = createCryptoCurrency({
+  type: 'CryptoCurrency',
+  id: 'matic-network',
+  name: 'Polygon',
+  symbol: 'MATIC',
+  icon: undefined,
+  market: {
+    coingeckoId: 'matic-network',
+    marketCapUsd: undefined,
+  },
+  updatedAt: Date.now(),
+})

package/src/assets/definitions/metis.ts

@@ -0,0 +1,14 @@
+import { createCryptoCurrency } from '../creates'
+
+export const metis = createCryptoCurrency({
+  type: 'CryptoCurrency',
+  id: 'metis-token',
+  name: 'Metis',
+  symbol: 'METIS',
+  icon: undefined,
+  market: {
+    coingeckoId: 'metis-token',
+    marketCapUsd: undefined,
+  },
+  updatedAt: Date.now(),
+})

package/src/assets/definitions/moonbeam.ts

@@ -0,0 +1,14 @@
+import { createCryptoCurrency } from '../creates'
+
+export const moonbeam = createCryptoCurrency({
+  type: 'CryptoCurrency',
+  id: 'moonbeam',
+  name: 'Moonbeam',
+  symbol: 'GLMR',
+  icon: undefined,
+  market: {
+    coingeckoId: 'moonbeam',
+    marketCapUsd: undefined,
+  },
+  updatedAt: Date.now(),
+})

package/src/assets/definitions/moonriver.ts

@@ -0,0 +1,14 @@
+import { createCryptoCurrency } from '../creates'
+
+export const moonriver = createCryptoCurrency({
+  type: 'CryptoCurrency',
+  id: 'moonriver',
+  name: 'Moonriver',
+  symbol: 'MOVR',
+  icon: undefined,
+  market: {
+    coingeckoId: 'moonriver',
+    marketCapUsd: undefined,
+  },
+  updatedAt: Date.now(),
+})

package/src/assets/definitions/ronin.ts

@@ -0,0 +1,14 @@
+import { createCryptoCurrency } from '../creates'
+
+export const ronin = createCryptoCurrency({
+  type: 'CryptoCurrency',
+  id: 'ronin',
+  name: 'Ronin',
+  symbol: 'RON',
+  icon: undefined,
+  market: {
+    coingeckoId: 'ronin',
+    marketCapUsd: undefined,
+  },
+  updatedAt: Date.now(),
+})

package/src/assets/definitions/usd.ts

@@ -0,0 +1,9 @@
+import { createFiatCurrency } from '../creates'
+
+export const usd = createFiatCurrency({
+  type: 'FiatCurrency',
+  id: 'usd',
+  symbol: 'USD',
+  name: 'US Dollar',
+  icon: undefined,
+})

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

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