@0xtorch/core 0.0.36 → 0.0.37

package/_types/setAccountActionPrices.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setAccountActionPrices.d.ts","sourceRoot":"","sources":["../setAccountActionPrices.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,KAAK,EAEV,wBAAwB,EAExB,YAAY,EACb,MAAM,UAAU,CAAA;AAEjB,KAAK,gCAAgC,GAAG;IACtC,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAA;IAC1C,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,wBAAwB,EAAE,wBAAwB,CAAA;CAC5D,CAAA;AAED,eAAO,MAAM,sBAAsB,iDAIhC,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoBlC,CAAA"}

package/_types/tests/constants.d.ts

@@ -1,2 +0,0 @@
-export declare const isIntegrationTest: boolean;
-//# sourceMappingURL=constants.d.ts.map

package/_types/tests/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../tests/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,SAA0C,CAAA"}

package/_types/tests/index.d.ts

@@ -1,3 +0,0 @@
-export { isIntegrationTest } from './constants';
-export { cryptoCurrencyDataSourceTest } from './utils';
-//# sourceMappingURL=index.d.ts.map

package/_types/tests/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../tests/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAA"}

package/_types/tests/utils.d.ts

@@ -1,3 +0,0 @@
-import type { CryptoCurrencyDataSource } from '../assets';
-export declare const cryptoCurrencyDataSourceTest: CryptoCurrencyDataSource;
-//# sourceMappingURL=utils.d.ts.map

package/_types/tests/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../tests/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAA;AAEzD,eAAO,MAAM,4BAA4B,EAAE,wBAqB1C,CAAA"}

package/accounts/index.ts

@@ -1 +0,0 @@
-export type { Account } from './types'

package/accounts/types/account.ts

@@ -1,5 +0,0 @@
-export type Account<TCategory extends string> = {
-  readonly id: string
-  readonly category: TCategory
-  readonly name: string
-}

package/accounts/types/index.ts

@@ -1 +0,0 @@
-export type { Account } from './account'

package/actions/parsers/action.ts

@@ -1,381 +0,0 @@
-import type { AccountAction, NormalAction } from '../types'
-import { parseNormalActionBorrowToAccountActions } from './borrow'
-import {
-  parseNormalActionBridgeFromToAccountActions,
-  parseNormalActionBridgeToToAccountActions,
-  parseNormalActionCrossReplaceToAccountActions,
-} from './crossReplace'
-import { parseNormalActionCrossTradeToAccountActions } from './crossTrade'
-import {
-  parseNormalActionAddLiquidityToAccountActions,
-  parseNormalActionDepositToAccountActions,
-  parseNormalActionDepositWithBondToAccountActions,
-  parseNormalActionStakeToAccountActions,
-} from './deposit'
-import {
-  parseNormalActionFeeToAccountActions,
-  parseNormalActionTransactionFeeToAccountActions,
-} from './fee'
-import {
-  parseNormalActionApproveToAccountActions,
-  parseNormalActionFailTxToAccountActions,
-  parseNormalActionReceiveFromCexToAccountActions,
-  parseNormalActionRevokeToAccountActions,
-  parseNormalActionSendToCexToAccountActions,
-  parseNormalActionSpamToAccountActions,
-} from './ignore'
-import {
-  parseNormalActionAtomicArbitrageToAccountActions,
-  parseNormalActionFreeMintNftToAccountActions,
-  parseNormalActionIncomeToAccountActions,
-} from './income'
-import {
-  parseNormalActionRepaymentToAccountActions,
-  parseNormalActionRepaymentWithDebtToAccountActions,
-} from './repayment'
-import {
-  parseNormalActionReplaceToAccountActions,
-  parseNormalActionSwapNftToAccountActions,
-  parseNormalActionUnwrapToAccountActions,
-  parseNormalActionWrapToAccountActions,
-} from './replace'
-import {
-  parseNormalActionBuyCryptoToAccountActions,
-  parseNormalActionBuyNftToAccountActions,
-  parseNormalActionMintNftToAccountActions,
-  parseNormalActionSellCryptoToAccountActions,
-  parseNormalActionSellNftToAccountActions,
-  parseNormalActionTradeToAccountActions,
-} from './trade'
-import { parseNormalActionTransferToAccountActions } from './transfer'
-import type { ParseNormalActionToAccountActionsParameters } from './types'
-import { parseNormalActionValuedownToAccountActions } from './valuedown'
-import { parseNormalActionValueupToAccountActions } from './valueup'
-import {
-  parseNormalActionRemoveLiquidityToAccountActions,
-  parseNormalActionUnstakeToAccountActions,
-  parseNormalActionWithdrawToAccountActions,
-  parseNormalActionWithdrawWithBondToAccountActions,
-} from './withdraw'
-
-export const parseNormalActionToAccountActions = ({
-  action,
-  accountIds,
-  source,
-  cexAccountIds,
-}: ParseNormalActionToAccountActionsParameters<NormalAction>): readonly AccountAction[] => {
-  switch (action.action) {
-    case 'add-liquidity': {
-      return parseNormalActionAddLiquidityToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'approve': {
-      return parseNormalActionApproveToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'atomic-arbitrage': {
-      return parseNormalActionAtomicArbitrageToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'borrow': {
-      return parseNormalActionBorrowToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'bridge-from': {
-      return parseNormalActionBridgeFromToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'bridge-to': {
-      return parseNormalActionBridgeToToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'buy-crypto': {
-      return parseNormalActionBuyCryptoToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'buy-nft': {
-      return parseNormalActionBuyNftToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'cross-replace': {
-      return parseNormalActionCrossReplaceToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'cross-trade': {
-      return parseNormalActionCrossTradeToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'deposit': {
-      return parseNormalActionDepositToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'fail-tx': {
-      return parseNormalActionFailTxToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'fee': {
-      return parseNormalActionFeeToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'free-mint-nft': {
-      return parseNormalActionFreeMintNftToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'income': {
-      return parseNormalActionIncomeToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'mint-nft': {
-      return parseNormalActionMintNftToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'receive-from-cex': {
-      return parseNormalActionReceiveFromCexToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'repayment': {
-      return parseNormalActionRepaymentToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'repayment-with-debt': {
-      return parseNormalActionRepaymentWithDebtToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'replace': {
-      return parseNormalActionReplaceToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'sell-crypto': {
-      return parseNormalActionSellCryptoToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'sell-nft': {
-      return parseNormalActionSellNftToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'spam': {
-      return parseNormalActionSpamToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'stake': {
-      return parseNormalActionStakeToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'swap-nft': {
-      return parseNormalActionSwapNftToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'transaction-fee': {
-      return parseNormalActionTransactionFeeToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'trade': {
-      return parseNormalActionTradeToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'transfer': {
-      return parseNormalActionTransferToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'unstake': {
-      return parseNormalActionUnstakeToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'unwrap': {
-      return parseNormalActionUnwrapToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'valuedown': {
-      return parseNormalActionValuedownToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'valueup': {
-      return parseNormalActionValueupToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'withdraw': {
-      return parseNormalActionWithdrawToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'withdraw-with-bond': {
-      return parseNormalActionWithdrawWithBondToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'wrap': {
-      return parseNormalActionWrapToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'revoke': {
-      return parseNormalActionRevokeToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'send-to-cex': {
-      return parseNormalActionSendToCexToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'remove-liquidity': {
-      return parseNormalActionRemoveLiquidityToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-    case 'deposit-with-bond': {
-      return parseNormalActionDepositWithBondToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
-  }
-}

package/actions/parsers/borrow/borrow.ts

@@ -1,47 +0,0 @@
-import type {
-  AccountActionBorrow,
-  AccountActionIncome,
-  AccountActionMove,
-  AccountActionReceiveFromCex,
-  AccountActionSendToCex,
-  AccountActionTransfer,
-  NormalActionBorrow,
-} from '../../types'
-import {
-  allTransfersIsAccountRelated,
-  createAccountActionCommon,
-  parseNormalActionToAccountActions,
-} from '../default'
-import type { ParseNormalActionToAccountActionsParameters } from '../types'
-
-export const parseNormalActionBorrowToAccountActions = ({
-  action,
-  accountIds,
-  source,
-  cexAccountIds,
-}: ParseNormalActionToAccountActionsParameters<NormalActionBorrow>):
-  | [AccountActionBorrow]
-  | readonly (
-      | AccountActionIncome
-      | AccountActionTransfer
-      | AccountActionMove
-      | AccountActionReceiveFromCex
-      | AccountActionSendToCex
-    )[] =>
-  allTransfersIsAccountRelated(action.transfers, accountIds)
-    ? [
-        {
-          ...createAccountActionCommon(action, source),
-          type: 'LoanAccountAction',
-          action: 'borrow',
-          evidence: action.evidence,
-          loanId: action.loanId,
-          transfers: action.transfers,
-        },
-      ]
-    : parseNormalActionToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })

package/actions/parsers/borrow/index.ts

@@ -1 +0,0 @@
-export { parseNormalActionBorrowToAccountActions } from './borrow'

package/actions/parsers/crossReplace/bridgeFrom.ts

@@ -1,48 +0,0 @@
-import type {
-  AccountActionBridgeFrom,
-  AccountActionIncome,
-  AccountActionMove,
-  AccountActionReceiveFromCex,
-  AccountActionSendToCex,
-  AccountActionTransfer,
-  NormalActionBridgeFrom,
-} from '../../types'
-import {
-  allTransfersIsAccountRelated,
-  createAccountActionCommon,
-  parseNormalActionToAccountActions,
-} from '../default'
-import type { ParseNormalActionToAccountActionsParameters } from '../types'
-
-export const parseNormalActionBridgeFromToAccountActions = ({
-  action,
-  accountIds,
-  source,
-  cexAccountIds,
-}: ParseNormalActionToAccountActionsParameters<NormalActionBridgeFrom>):
-  | [AccountActionBridgeFrom]
-  | readonly (
-      | AccountActionIncome
-      | AccountActionTransfer
-      | AccountActionMove
-      | AccountActionReceiveFromCex
-      | AccountActionSendToCex
-    )[] =>
-  allTransfersIsAccountRelated(action.transfers, accountIds)
-    ? [
-        {
-          ...createAccountActionCommon(action, source),
-          type: 'CrossAccountAction',
-          action: 'bridge-from',
-          evidence: action.evidence,
-          crossId: action.crossId,
-          crossType: action.crossType,
-          transfers: action.transfers,
-        },
-      ]
-    : parseNormalActionToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })

package/actions/parsers/crossReplace/bridgeTo.ts

@@ -1,48 +0,0 @@
-import type {
-  AccountActionBridgeTo,
-  AccountActionIncome,
-  AccountActionMove,
-  AccountActionReceiveFromCex,
-  AccountActionSendToCex,
-  AccountActionTransfer,
-  NormalActionBridgeTo,
-} from '../../types'
-import {
-  allTransfersIsAccountRelated,
-  createAccountActionCommon,
-  parseNormalActionToAccountActions,
-} from '../default'
-import type { ParseNormalActionToAccountActionsParameters } from '../types'
-
-export const parseNormalActionBridgeToToAccountActions = ({
-  action,
-  accountIds,
-  source,
-  cexAccountIds,
-}: ParseNormalActionToAccountActionsParameters<NormalActionBridgeTo>):
-  | [AccountActionBridgeTo]
-  | readonly (
-      | AccountActionIncome
-      | AccountActionTransfer
-      | AccountActionMove
-      | AccountActionReceiveFromCex
-      | AccountActionSendToCex
-    )[] =>
-  allTransfersIsAccountRelated(action.transfers, accountIds)
-    ? [
-        {
-          ...createAccountActionCommon(action, source),
-          type: 'CrossAccountAction',
-          action: 'bridge-to',
-          evidence: action.evidence,
-          crossId: action.crossId,
-          crossType: action.crossType,
-          transfers: action.transfers,
-        },
-      ]
-    : parseNormalActionToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })

package/actions/parsers/crossReplace/crossReplace.ts

@@ -1,48 +0,0 @@
-import type {
-  AccountActionCrossReplace,
-  AccountActionIncome,
-  AccountActionMove,
-  AccountActionReceiveFromCex,
-  AccountActionSendToCex,
-  AccountActionTransfer,
-  NormalActionCrossReplace,
-} from '../../types'
-import {
-  allTransfersIsAccountRelated,
-  createAccountActionCommon,
-  parseNormalActionToAccountActions,
-} from '../default'
-import type { ParseNormalActionToAccountActionsParameters } from '../types'
-
-export const parseNormalActionCrossReplaceToAccountActions = ({
-  action,
-  accountIds,
-  source,
-  cexAccountIds,
-}: ParseNormalActionToAccountActionsParameters<NormalActionCrossReplace>):
-  | [AccountActionCrossReplace]
-  | readonly (
-      | AccountActionIncome
-      | AccountActionTransfer
-      | AccountActionMove
-      | AccountActionReceiveFromCex
-      | AccountActionSendToCex
-    )[] =>
-  allTransfersIsAccountRelated(action.transfers, accountIds)
-    ? [
-        {
-          ...createAccountActionCommon(action, source),
-          type: 'CrossAccountAction',
-          action: 'cross-replace',
-          evidence: action.evidence,
-          crossId: action.crossId,
-          crossType: action.crossType,
-          transfers: action.transfers,
-        },
-      ]
-    : parseNormalActionToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })

package/actions/parsers/crossReplace/index.ts

@@ -1,3 +0,0 @@
-export { parseNormalActionBridgeFromToAccountActions } from './bridgeFrom'
-export { parseNormalActionBridgeToToAccountActions } from './bridgeTo'
-export { parseNormalActionCrossReplaceToAccountActions } from './crossReplace'

package/actions/parsers/crossTrade/crossTrade.ts

@@ -1,48 +0,0 @@
-import type {
-  AccountActionCrossTrade,
-  AccountActionIncome,
-  AccountActionMove,
-  AccountActionReceiveFromCex,
-  AccountActionSendToCex,
-  AccountActionTransfer,
-  NormalActionCrossTrade,
-} from '../../types'
-import {
-  allTransfersIsAccountRelated,
-  createAccountActionCommon,
-  parseNormalActionToAccountActions,
-} from '../default'
-import type { ParseNormalActionToAccountActionsParameters } from '../types'
-
-export const parseNormalActionCrossTradeToAccountActions = ({
-  action,
-  accountIds,
-  source,
-  cexAccountIds,
-}: ParseNormalActionToAccountActionsParameters<NormalActionCrossTrade>):
-  | [AccountActionCrossTrade]
-  | readonly (
-      | AccountActionIncome
-      | AccountActionTransfer
-      | AccountActionMove
-      | AccountActionReceiveFromCex
-      | AccountActionSendToCex
-    )[] =>
-  allTransfersIsAccountRelated(action.transfers, accountIds)
-    ? [
-        {
-          ...createAccountActionCommon(action, source),
-          type: 'CrossAccountAction',
-          action: 'cross-trade',
-          evidence: action.evidence,
-          crossId: action.crossId,
-          crossType: action.crossType,
-          transfers: action.transfers,
-        },
-      ]
-    : parseNormalActionToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })

package/actions/parsers/crossTrade/index.ts

@@ -1 +0,0 @@
-export { parseNormalActionCrossTradeToAccountActions } from './crossTrade'