@0xtorch/core 0.0.36 → 0.0.37

package/actions/logic/setActionPrices.ts

@@ -0,0 +1,148 @@
+import { type BigDecimal, createBigDecimal } from '@0xtorch/big-decimal'
+import type {
+  CryptoCurrency,
+  CryptoCurrencyDataSource,
+  CryptoCurrencyPrice,
+  FiatCurrency,
+} from '../../assets'
+import type { Action } from '../action'
+
+type SetActionPricesParameters = {
+  readonly dataSource: CryptoCurrencyDataSource
+  readonly actions: readonly Action[]
+  readonly fiat: FiatCurrency
+}
+
+export const setActionPrices = async ({
+  dataSource,
+  actions,
+  fiat,
+}: SetActionPricesParameters): Promise<readonly Action[]> => {
+  // crypto currency 毎の取得期間を作成
+  const targets = getCryptoCurrencyTargets(actions)
+
+  // 取得期間をもとに価格を取得
+  const cryptoCurrencyPricesOfTarget = await Promise.all(
+    targets.map(({ currency, timestampList }) =>
+      dataSource.getHistoricalPrices({
+        targetCurrency: currency,
+        vsCurrency: fiat,
+        timestampList,
+      }),
+    ),
+  )
+  const prices = new Map<string, readonly CryptoCurrencyPrice[]>()
+  for (const [index, { currency }] of targets.entries()) {
+    prices.set(
+      currency.id,
+      cryptoCurrencyPricesOfTarget[index].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 Action[],
+): readonly CryptoCurrencyTarget[] => {
+  const timestamps = new Map<string, Set<number>>()
+  const assets = new Map<string, CryptoCurrency>()
+
+  for (const action of actions) {
+    for (const transfer of action.transfers) {
+      if (transfer.asset.type !== 'CryptoCurrency') {
+        continue
+      }
+      if (!assets.has(transfer.asset.id)) {
+        assets.set(transfer.asset.id, transfer.asset)
+      }
+      const targetTimestamps = timestamps.get(transfer.asset.id) ?? new Set()
+      targetTimestamps.add(action.timestamp)
+      timestamps.set(transfer.asset.id, targetTimestamps)
+    }
+  }
+
+  const targets: CryptoCurrencyTarget[] = []
+  for (const [id, currency] of assets) {
+    const timestampList = [...(timestamps.get(id) ?? [])]
+    if (timestampList.length === 0) {
+      continue
+    }
+    targets.push({ currency, timestampList })
+  }
+  return targets
+}
+
+const setPrices = (
+  action: Action,
+  prices: Map<string, readonly CryptoCurrencyPrice[]>,
+  fiat: FiatCurrency,
+): Action => ({
+  ...action,
+  transfers: action.transfers.map((transfer) => {
+    switch (transfer.asset.type) {
+      case 'CryptoCurrency': {
+        transfer.price = getPrice(
+          prices.get(transfer.asset.id) ?? [],
+          action.timestamp,
+        )
+        return transfer
+      }
+      case 'FiatCurrency': {
+        if (transfer.asset.id === fiat.id) {
+          transfer.price = createBigDecimal(1n)
+        }
+        return transfer
+      }
+      case 'Nft': {
+        return transfer
+      }
+    }
+  }),
+})
+
+const getPrice = (
+  prices: readonly CryptoCurrencyPrice[],
+  timestamp: number,
+): BigDecimal | undefined => {
+  const oneHourInMs = 1000 * 60 * 60
+  const minTimestamp = timestamp - oneHourInMs
+  const maxTimestamp = timestamp + oneHourInMs
+
+  let left = 0
+  let right = prices.length - 1
+  let closestIndex = -1
+  let minDifference = Number.POSITIVE_INFINITY
+
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2)
+    const midTimestamp = prices[mid].timestamp
+
+    if (midTimestamp < minTimestamp) {
+      left = mid + 1
+    } else if (midTimestamp > maxTimestamp) {
+      right = mid - 1
+    } else {
+      const difference = Math.abs(midTimestamp - timestamp)
+      if (difference < minDifference) {
+        minDifference = difference
+        closestIndex = mid
+      }
+      if (midTimestamp < timestamp) {
+        left = mid + 1
+      } else {
+        right = mid - 1
+      }
+    }
+  }
+
+  return closestIndex !== -1 ? prices[closestIndex].price : undefined
+}

package/actions/transfer.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod'
+import { assetSchema } from '../assets'
+import { createUnionSchema } from '../utils'
+import { bigDecimalTextSchema } from '../utils/schema'
+
+const transferDirections = ['in', 'out', 'none'] as const
+export type TransferDirection = (typeof transferDirections)[number]
+export const transferDirectionUnionSchema =
+  createUnionSchema(transferDirections)
+
+export const transferSchema = z.object({
+  direction: transferDirectionUnionSchema,
+  from: z.string().optional(),
+  to: z.string().optional(),
+  asset: assetSchema,
+  amount: bigDecimalTextSchema,
+  price: bigDecimalTextSchema.optional(),
+})
+
+export type Transfer = z.infer<typeof transferSchema>

package/actions/utils/createActionTransferPatternCount.ts

@@ -0,0 +1,97 @@
+import type { ActionTransferPatternCount } from '../actionTransferPattern'
+import type { Transfer } from '../transfer'
+
+export const createActionTransferPatternCount = (
+  transfers: readonly Transfer[],
+): Readonly<ActionTransferPatternCount> => {
+  const count: {
+    all: number
+    in: number
+    'in/crypto': number
+    'in/fiat': number
+    'in/nft': number
+    out: number
+    'out/crypto': number
+    'out/fiat': number
+    'out/nft': number
+    none: number
+    'none/crypto': number
+    'none/fiat': number
+    'none/nft': number
+  } = {
+    all: 0,
+    in: 0,
+    'in/crypto': 0,
+    'in/fiat': 0,
+    'in/nft': 0,
+    out: 0,
+    'out/crypto': 0,
+    'out/fiat': 0,
+    'out/nft': 0,
+    none: 0,
+    'none/crypto': 0,
+    'none/fiat': 0,
+    'none/nft': 0,
+  }
+  // transfer type 毎の transfer 数をカウント
+  for (const transfer of transfers) {
+    count.all += 1
+    switch (transfer.direction) {
+      case 'in': {
+        count.in += 1
+        switch (transfer.asset.type) {
+          case 'CryptoCurrency': {
+            count['in/crypto'] += 1
+            break
+          }
+          case 'FiatCurrency': {
+            count['in/fiat'] += 1
+            break
+          }
+          case 'Nft': {
+            count['in/nft'] += 1
+            break
+          }
+        }
+        break
+      }
+      case 'out': {
+        count.out += 1
+        switch (transfer.asset.type) {
+          case 'CryptoCurrency': {
+            count['out/crypto'] += 1
+            break
+          }
+          case 'FiatCurrency': {
+            count['out/fiat'] += 1
+            break
+          }
+          case 'Nft': {
+            count['out/nft'] += 1
+            break
+          }
+        }
+        break
+      }
+      case 'none': {
+        count.none += 1
+        switch (transfer.asset.type) {
+          case 'CryptoCurrency': {
+            count['none/crypto'] += 1
+            break
+          }
+          case 'FiatCurrency': {
+            count['none/fiat'] += 1
+            break
+          }
+          case 'Nft': {
+            count['none/nft'] += 1
+            break
+          }
+        }
+        break
+      }
+    }
+  }
+  return count
+}

package/actions/utils/isMatchActionTransferPatternCount.ts

@@ -0,0 +1,159 @@
+import type { ActionType } from '../action'
+import {
+  type ActionTransferPatternCount,
+  actionTransferPatterns,
+} from '../actionTransferPattern'
+
+export const isMatchActionTransferPatternCount = (
+  type: ActionType,
+  count: ActionTransferPatternCount,
+): boolean => {
+  const pattern = actionTransferPatterns[type]
+  // all
+  if (pattern.all?.min !== undefined && count.all < pattern.all.min) {
+    return false
+  }
+  if (pattern.all?.max !== undefined && count.all > pattern.all.max) {
+    return false
+  }
+  // in
+  if (pattern.in?.min !== undefined && count.in < pattern.in.min) {
+    return false
+  }
+  if (pattern.in?.max !== undefined && count.in > pattern.in.max) {
+    return false
+  }
+  // in/crypto
+  if (
+    pattern['in/crypto']?.min !== undefined &&
+    count['in/crypto'] < pattern['in/crypto'].min
+  ) {
+    return false
+  }
+  if (
+    pattern['in/crypto']?.max !== undefined &&
+    count['in/crypto'] > pattern['in/crypto'].max
+  ) {
+    return false
+  }
+  // in/fiat
+  if (
+    pattern['in/fiat']?.min !== undefined &&
+    count['in/fiat'] < pattern['in/fiat'].min
+  ) {
+    return false
+  }
+  if (
+    pattern['in/fiat']?.max !== undefined &&
+    count['in/fiat'] > pattern['in/fiat'].max
+  ) {
+    return false
+  }
+  // in/nft
+  if (
+    pattern['in/nft']?.min !== undefined &&
+    count['in/nft'] < pattern['in/nft'].min
+  ) {
+    return false
+  }
+  if (
+    pattern['in/nft']?.max !== undefined &&
+    count['in/nft'] > pattern['in/nft'].max
+  ) {
+    return false
+  }
+  // out
+  if (pattern.out?.min !== undefined && count.out < pattern.out.min) {
+    return false
+  }
+  if (pattern.out?.max !== undefined && count.out > pattern.out.max) {
+    return false
+  }
+  // out/crypto
+  if (
+    pattern['out/crypto']?.min !== undefined &&
+    count['out/crypto'] < pattern['out/crypto'].min
+  ) {
+    return false
+  }
+  if (
+    pattern['out/crypto']?.max !== undefined &&
+    count['out/crypto'] > pattern['out/crypto'].max
+  ) {
+    return false
+  }
+  // out/fiat
+  if (
+    pattern['out/fiat']?.min !== undefined &&
+    count['out/fiat'] < pattern['out/fiat'].min
+  ) {
+    return false
+  }
+  if (
+    pattern['out/fiat']?.max !== undefined &&
+    count['out/fiat'] > pattern['out/fiat'].max
+  ) {
+    return false
+  }
+  // out/nft
+  if (
+    pattern['out/nft']?.min !== undefined &&
+    count['out/nft'] < pattern['out/nft'].min
+  ) {
+    return false
+  }
+  if (
+    pattern['out/nft']?.max !== undefined &&
+    count['out/nft'] > pattern['out/nft'].max
+  ) {
+    return false
+  }
+  // none
+  if (pattern.none?.min !== undefined && count.none < pattern.none.min) {
+    return false
+  }
+  if (pattern.none?.max !== undefined && count.none > pattern.none.max) {
+    return false
+  }
+  // none/crypto
+  if (
+    pattern['none/crypto']?.min !== undefined &&
+    count['none/crypto'] < pattern['none/crypto'].min
+  ) {
+    return false
+  }
+  if (
+    pattern['none/crypto']?.max !== undefined &&
+    count['none/crypto'] > pattern['none/crypto'].max
+  ) {
+    return false
+  }
+  // none/fiat
+  if (
+    pattern['none/fiat']?.min !== undefined &&
+    count['none/fiat'] < pattern['none/fiat'].min
+  ) {
+    return false
+  }
+  if (
+    pattern['none/fiat']?.max !== undefined &&
+    count['none/fiat'] > pattern['none/fiat'].max
+  ) {
+    return false
+  }
+  // none/nft
+  if (
+    pattern['none/nft']?.min !== undefined &&
+    count['none/nft'] < pattern['none/nft'].min
+  ) {
+    return false
+  }
+  if (
+    pattern['none/nft']?.max !== undefined &&
+    count['none/nft'] > pattern['none/nft'].max
+  ) {
+    return false
+  }
+
+  return true
+}

package/actions/utils/mergeSameAssetTransfers.ts

@@ -1,11 +1,19 @@
-import { absoluteValue, minus, plus } from '@0xtorch/big-decimal'
-import type { Transfer } from '../types'
+import {
+  type BigDecimal,
+  absoluteValue,
+  createBigDecimal,
+  minus,
+  plus,
+} from '@0xtorch/big-decimal'
+import type { Transfer } from '../transfer'
 
 export const mergeSameAssetTransfers = (
   transfers: readonly Transfer[],
   accountIds: Set<string>,
 ): readonly Transfer[] => {
-  const mut_transfers: (Transfer & { readonly key: string })[] = []
+  const transferAmounts = new Map<string, BigDecimal>()
+  const transferAssets = new Map<string, Transfer['asset']>()
+  const transferAccountIds = new Map<string, Set<string | undefined>>()
 
   for (const transfer of transfers) {
     if (
@@ -15,149 +23,99 @@ export const mergeSameAssetTransfers = (
       continue
     }
 
-    const transferKey = createTransferKey(transfer, accountIds)
-    const transferIndex = mut_transfers.findIndex(
-      ({ key }) => key === transferKey,
+    const { key, from, to } = createTransferKey(transfer, accountIds)
+
+    if (!transferAssets.has(key)) {
+      transferAssets.set(key, transfer.asset)
+    }
+
+    const isMinus = transfer.from === to || transfer.to === from
+    transferAmounts.set(
+      key,
+      isMinus
+        ? minus(
+            transferAmounts.get(key) ?? createBigDecimal(0n),
+            transfer.amount,
+          )
+        : plus(
+            transferAmounts.get(key) ?? createBigDecimal(0n),
+            transfer.amount,
+          ),
     )
+    const accountSet =
+      transferAccountIds.get(key) ?? new Set<string | undefined>()
+    if (transfer.from === undefined || !accountIds.has(transfer.from)) {
+      accountSet.add(transfer.from)
+    }
+    if (transfer.to === undefined || !accountIds.has(transfer.to)) {
+      accountSet.add(transfer.to)
+    }
+    transferAccountIds.set(key, accountSet)
+  }
+  const mergedTransfers: Transfer[] = []
+  for (const [key, amount] of transferAmounts.entries()) {
+    if (amount.value === 0n) {
+      continue
+    }
+
+    const asset = transferAssets.get(key)
+    if (asset === undefined) {
+      throw new Error('asset is undefined')
+    }
+    const accountSet = transferAccountIds.get(key)
+    const [, , fromText, toText] = key.split('/')
+    const from = fromText === '' ? undefined : fromText
+    const to = toText === '' ? undefined : toText
 
-    if (transferIndex === -1) {
-      mut_transfers.push({
-        ...transfer,
-        direction: createTransferDirection(transfer, accountIds),
-        key: transferKey,
+    if (to !== undefined) {
+      mergedTransfers.push({
+        direction: 'none',
+        asset,
+        amount: absoluteValue(amount),
+        from: amount.value > 0n ? from : to,
+        to: amount.value > 0n ? to : from,
+      })
+    } else if (amount.value > 0n) {
+      mergedTransfers.push({
+        direction: 'out',
+        asset,
+        amount,
+        from,
+        to: accountSet?.size === 1 ? [...accountSet][0] : undefined,
       })
     } else {
-      const baseTransfer = mut_transfers[transferIndex]
-      // from=new-from/to=new-to の場合は加算
-      if (
-        baseTransfer.from === transfer.from &&
-        baseTransfer.to === transfer.to
-      ) {
-        mut_transfers[transferIndex] = {
-          ...baseTransfer,
-          amount: plus(baseTransfer.amount, transfer.amount),
-        }
-      }
-      // from=new-to/to=new-from の場合は減算
-      else if (
-        baseTransfer.from === transfer.to &&
-        baseTransfer.to === transfer.from
-      ) {
-        mut_transfers[transferIndex] = {
-          ...baseTransfer,
-          amount: minus(baseTransfer.amount, transfer.amount),
-        }
-      }
-      // from=new-from/to!=new-to の場合は to を undefined にして加算
-      else if (
-        baseTransfer.from === transfer.from &&
-        baseTransfer.to !== transfer.to
-      ) {
-        mut_transfers[transferIndex] = {
-          ...baseTransfer,
-          to: undefined,
-          amount: plus(baseTransfer.amount, transfer.amount),
-        }
-      }
-      // from!=new-from/to=new-to の場合は from を undefined にして加算
-      else if (
-        baseTransfer.from !== transfer.from &&
-        baseTransfer.to === transfer.to
-      ) {
-        mut_transfers[transferIndex] = {
-          ...baseTransfer,
-          from: undefined,
-          amount: plus(baseTransfer.amount, transfer.amount),
-        }
-      }
-      // from=new-to/to!=new-from の場合は to を undefined にして減算
-      else if (
-        baseTransfer.from === transfer.to &&
-        baseTransfer.to !== transfer.from
-      ) {
-        mut_transfers[transferIndex] = {
-          ...baseTransfer,
-          to: undefined,
-          amount: minus(baseTransfer.amount, transfer.amount),
-        }
-      }
-      // from!=new-to/to=new-from の場合は from を undefined にして減算
-      else if (
-        baseTransfer.from !== transfer.to &&
-        baseTransfer.to === transfer.from
-      ) {
-        mut_transfers[transferIndex] = {
-          ...baseTransfer,
-          from: undefined,
-          amount: minus(baseTransfer.amount, transfer.amount),
-        }
-      }
+      mergedTransfers.push({
+        direction: 'in',
+        asset,
+        amount: absoluteValue(amount),
+        from: accountSet?.size === 1 ? [...accountSet][0] : undefined,
+        to: from,
+      })
     }
   }
 
-  // amount がマイナスの場合は from/to , direction を逆にして amount をプラスにする
-  return mut_transfers
-    .filter((transfer) => transfer.amount.value !== 0n)
-    .map((transfer) =>
-      transfer.amount.value < 0
-        ? {
-            ...transfer,
-            from: transfer.to,
-            to: transfer.from,
-            direction: reverseTransferDirection(transfer.direction),
-            amount: absoluteValue(transfer.amount),
-          }
-        : transfer,
-    )
+  return mergedTransfers.toSorted((a, b) =>
+    `${a.direction}/${a.asset.id}`.localeCompare(
+      `${b.direction}/${b.asset.id}`,
+    ),
+  )
 }
 
 const createTransferKey = (
   transfer: Transfer,
   accountIds: Set<string>,
-): string => {
+): { key: string; from?: string; to?: string } => {
   const addressKey = [transfer.from, transfer.to]
     .filter(
       (address): address is string =>
         address !== undefined && accountIds.has(address),
     )
     .sort()
-    .join('/')
-  return `${transfer.asset.type}/${transfer.asset.id}/${addressKey}`
-}
-
-const createTransferDirection = (
-  transfer: Transfer,
-  accountIds: Set<string>,
-) => {
-  if (
-    transfer.from !== undefined &&
-    accountIds.has(transfer.from) &&
-    transfer.to !== undefined &&
-    accountIds.has(transfer.to)
-  ) {
-    return 'none'
-  }
-  if (transfer.from !== undefined && accountIds.has(transfer.from)) {
-    return 'out'
-  }
-  if (transfer.to !== undefined && accountIds.has(transfer.to)) {
-    return 'in'
-  }
-  return 'none'
-}
-
-const reverseTransferDirection = (
-  direction: Transfer['direction'],
-): Transfer['direction'] => {
-  switch (direction) {
-    case 'in': {
-      return 'out'
-    }
-    case 'none': {
-      return 'none'
-    }
-    case 'out': {
-      return 'in'
-    }
+  const from = addressKey.length > 0 ? addressKey[0] : undefined
+  const to = addressKey.length > 1 ? addressKey[1] : undefined
+  return {
+    key: `${transfer.asset.type}/${transfer.asset.id}/${from ?? ''}/${to ?? ''}`,
+    from,
+    to,
   }
 }

package/apps/schemas.ts

@@ -13,18 +13,11 @@ export const appCategories = [
 ] as const
 export const appCategoryUnionSchema = createUnionSchema(appCategories)
 
-export const appSchema = z
-  .object({
-    id: z.string(),
-    categories: z.array(appCategoryUnionSchema),
-    name: z.string(),
-    description: z.string().optional(),
-    website: z.string().optional(),
-    icon: z.string().optional(),
-  })
-  .transform((v) => ({
-    ...v,
-    description: v.description,
-    website: v.website,
-    icon: v.icon,
-  }))
+export const appSchema = z.object({
+  id: z.string(),
+  categories: z.array(appCategoryUnionSchema),
+  name: z.string(),
+  description: z.string().optional(),
+  website: z.string().optional(),
+  icon: z.string().optional(),
+})