@0xtorch/core 0.0.35 → 0.0.37

package/actions/index.ts

@@ -1,256 +1,21 @@
 export {
-  parseNormalActionAddLiquidityToAccountActions,
-  parseNormalActionApproveToAccountActions,
-  parseNormalActionAtomicArbitrageToAccountActions,
-  parseNormalActionBorrowToAccountActions,
-  parseNormalActionBridgeFromToAccountActions,
-  parseNormalActionBridgeToToAccountActions,
-  parseNormalActionBuyCryptoToAccountActions,
-  parseNormalActionBuyNftToAccountActions,
-  parseNormalActionCrossReplaceToAccountActions,
-  parseNormalActionCrossTradeToAccountActions,
-  parseNormalActionDepositToAccountActions,
-  parseNormalActionDepositWithBondToAccountActions,
-  parseNormalActionFailTxToAccountActions,
-  parseNormalActionFeeToAccountActions,
-  parseNormalActionFreeMintNftToAccountActions,
-  parseNormalActionIncomeToAccountActions,
-  parseNormalActionMintNftToAccountActions,
-  parseNormalActionReceiveFromCexToAccountActions,
-  parseNormalActionRemoveLiquidityToAccountActions,
-  parseNormalActionRepaymentToAccountActions,
-  parseNormalActionRepaymentWithDebtToAccountActions,
-  parseNormalActionReplaceToAccountActions,
-  parseNormalActionRevokeToAccountActions,
-  parseNormalActionSellCryptoToAccountActions,
-  parseNormalActionSellNftToAccountActions,
-  parseNormalActionSendToCexToAccountActions,
-  parseNormalActionSpamToAccountActions,
-  parseNormalActionStakeToAccountActions,
-  parseNormalActionSwapNftToAccountActions,
-  parseNormalActionToAccountActions,
-  parseNormalActionTradeToAccountActions,
-  parseNormalActionTransactionFeeToAccountActions,
-  parseNormalActionTransferToAccountActions,
-  parseNormalActionUnstakeToAccountActions,
-  parseNormalActionUnwrapToAccountActions,
-  parseNormalActionValuedownToAccountActions,
-  parseNormalActionValueupToAccountActions,
-  parseNormalActionWithdrawToAccountActions,
-  parseNormalActionWithdrawWithBondToAccountActions,
-  parseNormalActionWrapToAccountActions,
-} from './parsers'
-export {
-  accountActionAddLiquiditySchema,
-  accountActionApproveSchema,
-  accountActionAtomicArbitrageSchema,
-  accountActionBorrowSchema,
-  accountActionBridgeFromSchema,
-  accountActionBridgeToSchema,
-  accountActionBuyCryptoSchema,
-  accountActionBuyNftSchema,
-  accountActionCrossReplaceSchema,
-  accountActionCrossTradeSchema,
-  accountActionDepositSchema,
-  accountActionDepositWithBondSchema,
-  accountActionFailTxSchema,
-  accountActionFeeSchema,
-  accountActionFreeMintNftSchema,
-  accountActionIgnoreSchema,
-  accountActionIncomeSchema,
-  accountActionMintNftSchema,
-  accountActionMoveSchema,
-  accountActionNftRoyaltySchema,
-  accountActionReceiveFromCexSchema,
-  accountActionReduceSchema,
-  accountActionRemoveLiquiditySchema,
-  accountActionRepaymentSchema,
-  accountActionRepaymentWithDebtSchema,
-  accountActionReplaceSchema,
-  accountActionRevokeSchema,
-  accountActionSchema,
-  accountActionSellCryptoSchema,
-  accountActionSellNftSchema,
-  accountActionSendToCexSchema,
-  accountActionSpamSchema,
-  accountActionStakeSchema,
-  accountActionSwapIncomeSchema,
-  accountActionSwapNftSchema,
-  accountActionSwapTransferSchema,
-  accountActionTradeSchema,
-  accountActionTransactionFeeSchema,
-  accountActionTransferSchema,
-  accountActionUnstakeSchema,
-  accountActionUnwrapSchema,
-  accountActionValuedownSchema,
-  accountActionValueupSchema,
-  accountActionWithdrawSchema,
-  accountActionWithdrawWithBondSchema,
-  accountActionWrapSchema,
-  crossActionBundleSchema,
-  crossTypeSchema,
-  normalActionActionSchema,
-  normalActionAddLiquiditySchema,
-  normalActionApproveSchema,
-  normalActionAtomicArbitrageSchema,
-  normalActionBorrowSchema,
-  normalActionBridgeFromSchema,
-  normalActionBridgeToSchema,
-  normalActionBuyCryptoSchema,
-  normalActionBuyNftSchema,
-  normalActionCrossReplaceSchema,
-  normalActionCrossTradeSchema,
-  normalActionDepositSchema,
-  normalActionDepositWithBondSchema,
-  normalActionFailTxSchema,
-  normalActionFeeSchema,
-  normalActionFreeMintNftSchema,
-  normalActionIncomeSchema,
-  normalActionMintNftSchema,
-  normalActionReceiveFromCexSchema,
-  normalActionRemoveLiquiditySchema,
-  normalActionRepaymentSchema,
-  normalActionRepaymentWithDebtSchema,
-  normalActionReplaceSchema,
-  normalActionRevokeSchema,
-  normalActionSchema,
-  normalActionSellCryptoSchema,
-  normalActionSellNftSchema,
-  normalActionSendToCexSchema,
-  normalActionSpamSchema,
-  normalActionStakeSchema,
-  normalActionSwapNftSchema,
-  normalActionTradeSchema,
-  normalActionTransactionFeeSchema,
-  normalActionTransferSchema,
-  normalActionUnstakeSchema,
-  normalActionUnwrapSchema,
-  normalActionValuedownSchema,
-  normalActionValueupSchema,
-  normalActionWithdrawSchema,
-  normalActionWithdrawWithBondSchema,
-  normalActionWrapSchema,
-} from './schemas'
+  actionTypes,
+  actionSchema,
+  crossActionTypes,
+  loanActionTypes,
+  targetActionTypes,
+} from './action'
 export type {
-  AccountAction,
-  AccountActionAddLiquidity,
-  AccountActionApprove,
-  AccountActionAtomicArbitrage,
-  AccountActionBorrow,
-  AccountActionBridgeFrom,
-  AccountActionBridgeTo,
-  AccountActionBuyCrypto,
-  AccountActionBuyNft,
-  AccountActionCrossReplace,
-  AccountActionCrossTrade,
-  AccountActionDeposit,
-  AccountActionDepositWithBond,
-  AccountActionFailTx,
-  AccountActionFee,
-  AccountActionFreeMintNft,
-  AccountActionIgnore,
-  AccountActionIncome,
-  AccountActionMintNft,
-  AccountActionMove,
-  AccountActionNftRoyalty,
-  AccountActionReceiveFromCex,
-  AccountActionReduce,
-  AccountActionRemoveLiquidity,
-  AccountActionRepayment,
-  AccountActionRepaymentWithDebt,
-  AccountActionReplace,
-  AccountActionRevoke,
-  AccountActionSellCrypto,
-  AccountActionSellNft,
-  AccountActionSendToCex,
-  AccountActionSpam,
-  AccountActionStake,
-  AccountActionSwapIncome,
-  AccountActionSwapNft,
-  AccountActionSwapTransfer,
-  AccountActionTrade,
-  AccountActionTransactionFee,
-  AccountActionTransfer,
-  AccountActionType,
-  AccountActionUnstake,
-  AccountActionUnwrap,
-  AccountActionValuedown,
-  AccountActionValueup,
-  AccountActionWithdraw,
-  AccountActionWithdrawWithBond,
-  AccountActionWrap,
   ActionType,
-  BaseAccountAction,
-  BaseNormalAction,
-  CrossActionBundle,
-  Evidence,
-  NormalAction,
-  NormalActionAddLiquidity,
-  NormalActionApprove,
-  NormalActionAtomicArbitrage,
-  NormalActionBorrow,
-  NormalActionBridgeFrom,
-  NormalActionBridgeTo,
-  NormalActionBuyCrypto,
-  NormalActionBuyNft,
-  NormalActionCrossReplace,
-  NormalActionCrossTrade,
-  NormalActionDeposit,
-  NormalActionDepositWithBond,
-  NormalActionFailTx,
-  NormalActionFee,
-  NormalActionFreeMintNft,
-  NormalActionIncome,
-  NormalActionMintNft,
-  NormalActionReceiveFromCex,
-  NormalActionRemoveLiquidity,
-  NormalActionRepayment,
-  NormalActionRepaymentWithDebt,
-  NormalActionReplace,
-  NormalActionRevoke,
-  NormalActionSellCrypto,
-  NormalActionSellNft,
-  NormalActionSendToCex,
-  NormalActionSpam,
-  NormalActionStake,
-  NormalActionSwapNft,
-  NormalActionTrade,
-  NormalActionTransactionFee,
-  NormalActionTransfer,
-  NormalActionUnstake,
-  NormalActionUnwrap,
-  NormalActionValuedown,
-  NormalActionValueup,
-  NormalActionWithdraw,
-  NormalActionWithdrawWithBond,
-  NormalActionWrap,
-  Transfer,
-  TransferCryptoCurrencyIn,
-  TransferCryptoCurrencyNone,
-  TransferCryptoCurrencyOut,
-  TransferFiatCurrencyIn,
-  TransferFiatCurrencyNone,
-  TransferFiatCurrencyOut,
-  TransferIn,
-  TransferNftIn,
-  TransferNftNone,
-  TransferNftOut,
-  TransferNone,
-  TransferOut,
-} from './types'
-export { checkIfAccountActionsIsValid } from './utils/checkIfAccountActionsIsValid'
-export { createEvidenceNoneAccountActions } from './utils/createEvidenceNoneAccountActions'
-export { mergeSameAssetTransfers } from './utils/mergeSameAssetTransfers'
-export { parseBaseAccountActionToAccountAction } from './utils/parseBaseAccountActionToAccountAction'
-export { parseBaseNormalActionToNormalAction } from './utils/parseBaseNormalActionToNormalAction'
-export {
-  isTransferCryptoCurrencyIn,
-  isTransferCryptoCurrencyNone,
-  isTransferCryptoCurrencyOut,
-  isTransferFiatCurrencyIn,
-  isTransferFiatCurrencyNone,
-  isTransferFiatCurrencyOut,
-  isTransferNftIn,
-  isTransferNftNone,
-  isTransferNftOut,
-} from './utils/transfer'
+  ActionEvidence,
+  ActionCrossType,
+  Action,
+} from './action'
+export { actionTransferPatterns } from './actionTransferPattern'
+export type { ActionTransferPatternCount } from './actionTransferPattern'
+export { transferSchema } from './transfer'
+export type { Transfer, TransferDirection } from './transfer'
+export { checkIfActionsIsValid } from './logic/checkIfActionsIsValid'
+export { createGeneralActionsByTransfers } from './logic/createGeneralActionsByTransfers'
+export { filterAvailableActionTypes } from './logic/filterAvailableActionTypes'
+export { setActionPrices } from './logic/setActionPrices'

package/actions/logic/checkIfActionsIsValid/checkIfActionsHaveAllTransfers.ts

@@ -0,0 +1,54 @@
+import { equals } from '@0xtorch/big-decimal'
+import type { Action } from '../../action'
+import type { Transfer } from '../../transfer'
+
+type CheckIfActionsHaveAllTransfersParameters = {
+  actions: readonly Action[]
+  transfers: readonly Transfer[]
+  accountIds: Set<string>
+}
+
+export const checkIfActionsHaveAllTransfers = ({
+  actions,
+  transfers,
+  accountIds,
+}: CheckIfActionsHaveAllTransfersParameters): boolean => {
+  let remainActionTransfers = actions.flatMap((action) => action.transfers)
+
+  for (const transfer of transfers) {
+    // amount, accountId を含む from, to が一致する transfer の index 取得
+    const index = remainActionTransfers.findIndex((actionTransfer) => {
+      if (!equals(actionTransfer.amount, transfer.amount)) {
+        return false
+      }
+      if (
+        transfer.from !== undefined &&
+        accountIds.has(transfer.from) &&
+        transfer.from !== actionTransfer.from
+      ) {
+        return false
+      }
+      if (
+        transfer.to !== undefined &&
+        accountIds.has(transfer.to) &&
+        transfer.to !== actionTransfer.to
+      ) {
+        return false
+      }
+      return true
+    })
+
+    // index = -1 だった場合は false を返す
+    if (index === -1) {
+      return false
+    }
+
+    // index >= 0 だった場合は、mut_remainActionTransfers から該当 transfer を削除
+    remainActionTransfers = remainActionTransfers.filter(
+      (_, index_) => index_ !== index,
+    )
+  }
+
+  // 全ての transfer が見つかったので true
+  return true
+}

package/actions/logic/checkIfActionsIsValid/checkIfTransfersAreExactMatches.ts

@@ -0,0 +1,24 @@
+import { equals } from '@0xtorch/big-decimal'
+import type { Transfer } from '../../transfer'
+
+export const checkIfTransfersAreExactMatches = (
+  transfersA: readonly Transfer[],
+  transfersB: readonly Transfer[],
+): boolean => {
+  let mut_remainTransfersB = [...transfersB]
+  for (const transferA of transfersA) {
+    const index = mut_remainTransfersB.findIndex(
+      (transferB) =>
+        equals(transferA.amount, transferB.amount) &&
+        transferA.from === transferB.from &&
+        transferA.to === transferB.to,
+    )
+    if (index === -1) {
+      return false
+    }
+    mut_remainTransfersB = mut_remainTransfersB.filter(
+      (_, index_) => index_ !== index,
+    )
+  }
+  return mut_remainTransfersB.length === 0
+}

package/actions/logic/checkIfActionsIsValid/index.ts

@@ -0,0 +1,93 @@
+import { IS_DEBUG } from '../../../test'
+import {
+  type Action,
+  crossActionTypes,
+  loanActionTypes,
+  targetActionTypes,
+} from '../../action'
+import type { Transfer } from '../../transfer'
+import { mergeSameAssetTransfers } from '../../utils/mergeSameAssetTransfers'
+import { checkIfActionsHaveAllTransfers } from './checkIfActionsHaveAllTransfers'
+import { checkIfTransfersAreExactMatches } from './checkIfTransfersAreExactMatches'
+import { isMatchActionTransferPattern } from './isMatchActionTransferPattern'
+
+type CheckIfActionsIsValidParameters = {
+  actions: readonly Action[]
+  accountIds: Set<string>
+  transfers?: readonly Transfer[]
+}
+
+export const checkIfActionsIsValid = ({
+  actions,
+  accountIds,
+  transfers,
+}: CheckIfActionsIsValidParameters): boolean => {
+  // action 毎に action transfer pattern に合致するか確認
+  // action type が cross系だった場合、cross 系 property を保有しているか確認
+  // action type が loan 系だった場合、loan 系 property を保有しているか確認
+  // value-down/up 系 action だった場合に target property を保有しているか確認
+  // 合致しない場合は false
+  for (const action of actions) {
+    if (!isMatchActionTransferPattern(action)) {
+      if (IS_DEBUG) {
+        console.debug('Action transfer pattern mismatch')
+        console.dir(action, { depth: null })
+      }
+      return false
+    }
+    if (crossActionTypes.has(action.type)) {
+      if (action.crossId === undefined || action.crossId === '') {
+        if (IS_DEBUG) {
+          console.debug(`${action.type} action must have crossId`)
+        }
+        return false
+      }
+      if (action.crossType === undefined) {
+        if (IS_DEBUG) {
+          console.debug(`${action.type} action must have crossType`)
+        }
+        return false
+      }
+    }
+    if (
+      loanActionTypes.has(action.type) &&
+      (action.loanId === undefined || action.loanId === '')
+    ) {
+      if (IS_DEBUG) {
+        console.debug(`${action.type} action must have loanId`)
+      }
+      return false
+    }
+    if (targetActionTypes.has(action.type) && action.target === undefined) {
+      if (IS_DEBUG) {
+        console.debug(`${action.type} action must have target`)
+      }
+      return false
+    }
+  }
+
+  // transfers が指定されていない場合は true
+  if (transfers === undefined) {
+    return true
+  }
+
+  // 全ての transfers に合致する transfer が actions に含まれる場合は true
+  // 余剰 transfer が actions にあるのは問題なし
+  if (checkIfActionsHaveAllTransfers({ actions, transfers, accountIds })) {
+    return true
+  }
+
+  // transfers と actions transfers それぞれの、asset 毎の総増減量を計算
+  // 全ての asset の想像減量が transfers と actions transfers で一致すれば true
+  const mergedTransfers = mergeSameAssetTransfers(transfers, accountIds)
+  const mergedActionTransfers = mergeSameAssetTransfers(
+    actions.flatMap((action) => action.transfers),
+    accountIds,
+  )
+  if (checkIfTransfersAreExactMatches(mergedTransfers, mergedActionTransfers)) {
+    return true
+  }
+
+  // 一致しない場合は false
+  return false
+}

package/actions/logic/checkIfActionsIsValid/isMatchActionTransferPattern.ts

@@ -0,0 +1,17 @@
+import type { ActionType } from '../../action'
+import type { Transfer } from '../../transfer'
+import { createActionTransferPatternCount } from '../../utils/createActionTransferPatternCount'
+import { isMatchActionTransferPatternCount } from '../../utils/isMatchActionTransferPatternCount'
+
+type IsMatchActionTransferPatternParameters = {
+  type: ActionType
+  transfers: Transfer[]
+}
+
+export const isMatchActionTransferPattern = ({
+  type,
+  transfers,
+}: IsMatchActionTransferPatternParameters): boolean => {
+  const count = createActionTransferPatternCount(transfers)
+  return isMatchActionTransferPatternCount(type, count)
+}

package/actions/logic/createGeneralActionsByTransfers.ts

@@ -0,0 +1,162 @@
+import type { Action } from '../action'
+import type { Transfer } from '../transfer'
+import { createActionTransferPatternCount } from '../utils/createActionTransferPatternCount'
+import { mergeSameAssetTransfers } from '../utils/mergeSameAssetTransfers'
+
+type CreateGeneralActionsByTransfersParameters = {
+  readonly transfers: readonly Transfer[]
+  readonly accountIds: Set<string>
+  readonly source: string
+  readonly timestamp: number
+}
+
+export const createGeneralActionsByTransfers = ({
+  transfers,
+  accountIds,
+  source,
+  timestamp,
+}: CreateGeneralActionsByTransfersParameters): readonly Action[] => {
+  const evidence = 'none'
+  const mergedTransfers = mergeSameAssetTransfers(transfers, accountIds)
+
+  if (mergedTransfers.length === 0) {
+    console.debug('No transfers')
+    return []
+  }
+
+  const actions: Action[] = []
+  const inOutTransfers: Transfer[] = []
+  for (const transfer of transfers) {
+    switch (transfer.direction) {
+      case 'none': {
+        // generate move action
+        actions.push({
+          type: 'move',
+          transfers: [transfer],
+          source,
+          order: 0,
+          timestamp,
+          evidence,
+        })
+        break
+      }
+      case 'in':
+      case 'out': {
+        inOutTransfers.push(transfer)
+        break
+      }
+    }
+  }
+  const count = createActionTransferPatternCount(inOutTransfers)
+
+  // return actions if all transfers are none
+  if (inOutTransfers.length === 0) {
+    return actions
+  }
+
+  // generate gift action per transfer if all transfers are in
+  if (count.in > 0 && count.out === 0) {
+    for (const transfer of inOutTransfers) {
+      actions.push({
+        type: 'gift',
+        transfers: [transfer],
+        source,
+        order: 0,
+        timestamp,
+        evidence,
+      })
+    }
+    return actions
+  }
+
+  // generate transfer action per transfer if all transfers are out
+  if (count.in === 0 && count.out > 0) {
+    for (const transfer of inOutTransfers) {
+      actions.push({
+        type: 'transfer',
+        transfers: [transfer],
+        source,
+        order: 0,
+        timestamp,
+        evidence,
+      })
+    }
+    return actions
+  }
+
+  // generate swap-nft action if all transfers are in/nft or out/nft
+  if (count['in/nft'] === count.in && count['out/nft'] === count.out) {
+    actions.push({
+      type: 'swap-nft',
+      transfers: inOutTransfers,
+      source,
+      order: 0,
+      timestamp,
+      evidence,
+    })
+    return actions
+  }
+
+  // generate buy-nft action if all in transfers are nft and all out transfer are not nft
+  if (count['in/nft'] === count.in && count['out/nft'] === 0) {
+    actions.push({
+      type: 'buy-nft',
+      transfers: inOutTransfers,
+      source,
+      order: 0,
+      timestamp,
+      evidence,
+    })
+    return actions
+  }
+
+  // generate sell-nft action if all in transfers are not nft and all out transfer are nft
+  if (count['in/nft'] === 0 && count['out/nft'] === count.out) {
+    actions.push({
+      type: 'sell-nft',
+      transfers: inOutTransfers,
+      source,
+      order: 0,
+      timestamp,
+      evidence,
+    })
+    return actions
+  }
+
+  // generate buy-crypto action if all in transfers are crypto and all out transfer are fiat
+  if (count['in/crypto'] === count.in && count['out/fiat'] === count.out) {
+    actions.push({
+      type: 'buy-crypto',
+      transfers: inOutTransfers,
+      source,
+      order: 0,
+      timestamp,
+      evidence,
+    })
+    return actions
+  }
+
+  // generate sell-crypto action if all in transfers are fiat and all out transfer are crypto
+  if (count['in/fiat'] === count.in && count['out/crypto'] === count.out) {
+    actions.push({
+      type: 'sell-crypto',
+      transfers: inOutTransfers,
+      source,
+      order: 0,
+      timestamp,
+      evidence,
+    })
+    return actions
+  }
+
+  // generate trade action if other cases are not matched
+  actions.push({
+    type: 'trade',
+    transfers: inOutTransfers,
+    source,
+    order: 0,
+    timestamp,
+    evidence,
+  })
+  return actions
+}

package/actions/logic/filterAvailableActionTypes.ts

@@ -0,0 +1,13 @@
+import { type ActionType, actionTypes } from '../action'
+import type { Transfer } from '../transfer'
+import { createActionTransferPatternCount } from '../utils/createActionTransferPatternCount'
+import { isMatchActionTransferPatternCount } from '../utils/isMatchActionTransferPatternCount'
+
+export const filterAvailableActionTypes = (
+  transfers: readonly Transfer[],
+): readonly ActionType[] => {
+  const count = createActionTransferPatternCount(transfers)
+  return actionTypes.filter((type) =>
+    isMatchActionTransferPatternCount(type, count),
+  )
+}