@0xtorch/core 0.0.29 → 0.0.31

package/actions/utils/createEvidenceNoneAccountActions.ts

@@ -0,0 +1,470 @@
+import { absoluteValue, minus, plus } from '@0xtorch/big-decimal'
+import type {
+  AccountAction,
+  AccountActionBuyCrypto,
+  AccountActionBuyNft,
+  AccountActionSellCrypto,
+  AccountActionSellNft,
+  AccountActionSwapNft,
+  AccountActionTrade,
+  NormalActionTransfer,
+  Transfer,
+  TransferCryptoCurrencyIn,
+  TransferCryptoCurrencyOut,
+  TransferFiatCurrencyIn,
+  TransferFiatCurrencyOut,
+  TransferIn,
+  TransferNftIn,
+  TransferNftOut,
+  TransferOut,
+} from '../types'
+
+type CreateEvidenceNoneAccountActionsParameters = {
+  readonly source: string
+  readonly timestamp: number
+  readonly actionList: readonly NormalActionTransfer[]
+  readonly accountIdSet: Set<string>
+}
+
+export const createEvidenceNoneAccountActions = ({
+  source,
+  timestamp,
+  actionList,
+  accountIdSet,
+}: CreateEvidenceNoneAccountActionsParameters): readonly AccountAction[] => {
+  // transfer を asset , account id 毎に merge
+  const transferList = createTransferList({ actionList, accountIdSet })
+
+  // direction = none の transfer を move action に個別変換
+  const moveActionList = transferList
+    .filter((transfer) => transfer.direction === 'none')
+    .map(
+      (transfer): AccountAction => ({
+        type: 'NormalAccountAction',
+        action: 'move',
+        source,
+        order: 0,
+        comment: undefined,
+        app: undefined,
+        evidence: 'none',
+        timestamp,
+        transfers: [transfer],
+      }),
+    )
+
+  const inOutTransferList = transferList.filter(
+    (transfer): transfer is TransferIn | TransferOut =>
+      transfer.direction !== 'none',
+  )
+
+  if (inOutTransferList.length === 0) {
+    return moveActionList.map((action, order) => ({
+      ...action,
+      order,
+    }))
+  }
+  // transfer 全てが in のみの場合は個別に income action に変換
+  else if (inOutTransferList.every((transfer) => transfer.direction === 'in')) {
+    const incomeActionList = inOutTransferList
+      .filter((transfer): transfer is TransferIn => transfer.direction === 'in')
+      .map(
+        (transfer): AccountAction => ({
+          type: 'NormalAccountAction',
+          action: 'income',
+          source,
+          order: 0,
+          comment: undefined,
+          app: undefined,
+          evidence: 'none',
+          timestamp,
+          transfers: [transfer],
+        }),
+      )
+    return [...moveActionList, ...incomeActionList].map((action, order) => ({
+      ...action,
+      order,
+    }))
+  }
+  // transfer 全てが out のみの場合は個別に transfer action に変換
+  else if (
+    inOutTransferList.every((transfer) => transfer.direction === 'out')
+  ) {
+    const transferActionList = inOutTransferList
+      .filter(
+        (transfer): transfer is TransferOut => transfer.direction === 'out',
+      )
+      .map(
+        (transfer): AccountAction => ({
+          type: 'NormalAccountAction',
+          action: 'transfer',
+          source,
+          order: 0,
+          comment: undefined,
+          app: undefined,
+          evidence: 'none',
+          timestamp,
+          transfers: [transfer],
+        }),
+      )
+    return [...moveActionList, ...transferActionList].map((action, order) => ({
+      ...action,
+      order,
+    }))
+  }
+  // transfer asset 全てが NFT である場合、 swap-nft action に変換
+  else if (
+    inOutTransferList.every((transfer) => transfer.asset.type === 'Nft')
+  ) {
+    return [
+      ...moveActionList,
+      {
+        type: 'NormalAccountAction',
+        action: 'swap-nft',
+        source,
+        order: 0,
+        comment: undefined,
+        app: undefined,
+        evidence: 'none',
+        timestamp,
+        transfers: inOutTransferList.filter(
+          (transfer): transfer is TransferNftIn | TransferNftOut =>
+            transfer.asset.type === 'Nft',
+        ),
+      } satisfies AccountActionSwapNft,
+    ].map((action, order) => ({
+      ...action,
+      order,
+    }))
+  }
+  // in transfer asset 全て NFT である場合、 buy-nft action に変換
+  else if (
+    inOutTransferList
+      .filter((transfer) => transfer.direction === 'in')
+      .every((transfer) => transfer.asset.type === 'Nft')
+  ) {
+    return [
+      ...moveActionList,
+      {
+        type: 'NormalAccountAction',
+        action: 'buy-nft',
+        source,
+        order: 0,
+        comment: undefined,
+        app: undefined,
+        evidence: 'none',
+        timestamp,
+        transfers: [
+          ...inOutTransferList.filter(
+            (transfer): transfer is TransferNftIn =>
+              transfer.direction === 'in',
+          ),
+          ...inOutTransferList.filter(
+            (
+              transfer,
+            ): transfer is
+              | TransferCryptoCurrencyOut
+              | TransferFiatCurrencyOut => transfer.direction === 'out',
+          ),
+        ],
+      } satisfies AccountActionBuyNft,
+    ].map((action, order) => ({
+      ...action,
+      order,
+    }))
+  }
+  // out transfer 全て NFT である場合、 sell-nft action に変換
+  else if (
+    inOutTransferList
+      .filter((transfer) => transfer.direction === 'out')
+      .every((transfer) => transfer.asset.type === 'Nft')
+  ) {
+    return [
+      ...moveActionList,
+      {
+        type: 'NormalAccountAction',
+        action: 'sell-nft',
+        source,
+        order: 0,
+        comment: undefined,
+        app: undefined,
+        evidence: 'none',
+        timestamp,
+        transfers: [
+          ...inOutTransferList.filter(
+            (
+              transfer,
+            ): transfer is TransferCryptoCurrencyIn | TransferFiatCurrencyIn =>
+              transfer.direction === 'in',
+          ),
+          ...inOutTransferList.filter(
+            (transfer): transfer is TransferNftOut =>
+              transfer.direction === 'out',
+          ),
+        ],
+      } satisfies AccountActionSellNft,
+    ].map((action, order) => ({
+      ...action,
+      order,
+    }))
+  }
+  // in transfer asset 全て Crypto , out transfer asset 全て Fiat の場合、 buy-crypto action に変換
+  else if (
+    inOutTransferList
+      .filter((transfer) => transfer.direction === 'in')
+      .every((transfer) => transfer.asset.type === 'CryptoCurrency') &&
+    inOutTransferList
+      .filter((transfer) => transfer.direction === 'out')
+      .every((transfer) => transfer.asset.type === 'FiatCurrency')
+  ) {
+    return [
+      ...moveActionList,
+      {
+        type: 'NormalAccountAction',
+        action: 'buy-crypto',
+        source,
+        order: 0,
+        comment: undefined,
+        app: undefined,
+        evidence: 'none',
+        timestamp,
+        transfers: [
+          ...inOutTransferList.filter(
+            (transfer): transfer is TransferCryptoCurrencyIn =>
+              transfer.direction === 'in',
+          ),
+          ...inOutTransferList.filter(
+            (transfer): transfer is TransferFiatCurrencyOut =>
+              transfer.direction === 'out',
+          ),
+        ],
+      } satisfies AccountActionBuyCrypto,
+    ].map((action, order) => ({
+      ...action,
+      order,
+    }))
+  }
+  // in transfer asset 全て Fiat , out transfer asset 全て Crypto の場合、 sell-crypto action に変換
+  else if (
+    inOutTransferList
+      .filter((transfer) => transfer.direction === 'in')
+      .every((transfer) => transfer.asset.type === 'FiatCurrency') &&
+    inOutTransferList
+      .filter((transfer) => transfer.direction === 'out')
+      .every((transfer) => transfer.asset.type === 'CryptoCurrency')
+  ) {
+    return [
+      ...moveActionList,
+      {
+        type: 'NormalAccountAction',
+        action: 'sell-crypto',
+        source,
+        order: 0,
+        comment: undefined,
+        app: undefined,
+        evidence: 'none',
+        timestamp,
+        transfers: [
+          ...inOutTransferList.filter(
+            (transfer): transfer is TransferFiatCurrencyIn =>
+              transfer.direction === 'in',
+          ),
+          ...inOutTransferList.filter(
+            (transfer): transfer is TransferCryptoCurrencyOut =>
+              transfer.direction === 'out',
+          ),
+        ],
+      } satisfies AccountActionSellCrypto,
+    ].map((action, order) => ({
+      ...action,
+      order,
+    }))
+  }
+  // それ以外の場合、 trade action に変換
+  else {
+    return [
+      ...moveActionList,
+      {
+        type: 'NormalAccountAction',
+        action: 'trade',
+        source,
+        order: 0,
+        comment: undefined,
+        app: undefined,
+        evidence: 'none',
+        timestamp,
+        transfers: [
+          ...inOutTransferList.filter(
+            (transfer) => transfer.direction === 'in',
+          ),
+          ...inOutTransferList.filter(
+            (transfer) => transfer.direction === 'out',
+          ),
+        ],
+      } satisfies AccountActionTrade,
+    ].map((action, order) => ({
+      ...action,
+      order,
+    }))
+  }
+}
+
+const createTransferList = ({
+  actionList,
+  accountIdSet,
+}: Pick<
+  CreateEvidenceNoneAccountActionsParameters,
+  'accountIdSet' | 'actionList'
+>): readonly Transfer[] => {
+  const mut_transfers: (Transfer & { readonly key: string })[] = []
+
+  for (const transfer of actionList.flatMap((action) => action.transfers)) {
+    if (
+      (transfer.from === undefined || !accountIdSet.has(transfer.from)) &&
+      (transfer.to === undefined || !accountIdSet.has(transfer.to))
+    ) {
+      continue
+    }
+
+    const transferKey = createTransferKey(transfer, accountIdSet)
+    const transferIndex = mut_transfers.findIndex(
+      ({ key }) => key === transferKey,
+    )
+
+    if (transferIndex === -1) {
+      mut_transfers.push({
+        ...transfer,
+        direction: createTransferDirection(transfer, accountIdSet),
+        key: transferKey,
+      })
+    } 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),
+        }
+      }
+    }
+  }
+
+  // amount がマイナスの場合は from/to , direction を逆にして amount をプラスにする
+  return mut_transfers.map((transfer) =>
+    transfer.amount.value < 0
+      ? {
+          ...transfer,
+          from: transfer.to,
+          to: transfer.from,
+          direction: reverseTransferDirection(transfer.direction),
+          amount: absoluteValue(transfer.amount),
+        }
+      : transfer,
+  )
+}
+
+const createTransferDirection = (
+  transfer: Transfer,
+  accountIdSet: Set<string>,
+) => {
+  if (
+    transfer.from !== undefined &&
+    accountIdSet.has(transfer.from) &&
+    transfer.to !== undefined &&
+    accountIdSet.has(transfer.to)
+  ) {
+    return 'none'
+  } else if (transfer.from !== undefined && accountIdSet.has(transfer.from)) {
+    return 'out'
+  } else if (transfer.to !== undefined && accountIdSet.has(transfer.to)) {
+    return 'in'
+  } else {
+    return 'none'
+  }
+}
+
+const reverseTransferDirection = (
+  direction: Transfer['direction'],
+): Transfer['direction'] => {
+  switch (direction) {
+    case 'in': {
+      return 'out'
+    }
+    case 'none': {
+      return 'none'
+    }
+    case 'out': {
+      return 'in'
+    }
+  }
+}
+
+const createTransferKey = (
+  transfer: Transfer,
+  accountIdSet: Set<string>,
+): string => {
+  const addressKey = [transfer.from, transfer.to]
+    .filter(
+      (address): address is string =>
+        address !== undefined && accountIdSet.has(address),
+    )
+    .sort()
+    .join('/')
+  return `${transfer.asset.type}/${transfer.asset.id}/${addressKey}`
+}