@0xtorch/core 0.0.17 → 0.0.19

package/_types/{actions/schemas/borrow/borrowWithDebt.d.ts.map → setAccountActionPrices.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"borrowWithDebt.d.ts","sourceRoot":"","sources":["../../../../actions/schemas/borrow/borrowWithDebt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBxC,CAAA;AAEL,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBzC,CAAA"}
+{"version":3,"file":"setAccountActionPrices.d.ts","sourceRoot":"","sources":["../setAccountActionPrices.ts"],"names":[],"mappings":"AAAA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqBlC,CAAA"}

package/actions/index.ts

@@ -3,7 +3,6 @@ export {
   parseNormalActionApproveToAccountActions,
   parseNormalActionAtomicArbitrageToAccountActions,
   parseNormalActionBorrowToAccountActions,
-  parseNormalActionBorrowWithDebtToAccountActions,
   parseNormalActionBridgeFromToAccountActions,
   parseNormalActionBridgeToToAccountActions,
   parseNormalActionBuyCryptoToAccountActions,
@@ -46,7 +45,6 @@ export {
   accountActionApproveSchema,
   accountActionAtomicArbitrageSchema,
   accountActionBorrowSchema,
-  accountActionBorrowWithDebtSchema,
   accountActionBridgeFromSchema,
   accountActionBridgeToSchema,
   accountActionBuyCryptoSchema,
@@ -96,7 +94,6 @@ export {
   normalActionApproveSchema,
   normalActionAtomicArbitrageSchema,
   normalActionBorrowSchema,
-  normalActionBorrowWithDebtSchema,
   normalActionBridgeFromSchema,
   normalActionBridgeToSchema,
   normalActionBuyCryptoSchema,
@@ -140,7 +137,6 @@ export type {
   AccountActionApprove,
   AccountActionAtomicArbitrage,
   AccountActionBorrow,
-  AccountActionBorrowWithDebt,
   AccountActionBridgeFrom,
   AccountActionBridgeTo,
   AccountActionBuyCrypto,
@@ -193,7 +189,6 @@ export type {
   NormalActionApprove,
   NormalActionAtomicArbitrage,
   NormalActionBorrow,
-  NormalActionBorrowWithDebt,
   NormalActionBridgeFrom,
   NormalActionBridgeTo,
   NormalActionBuyCrypto,

package/actions/parsers/action.ts

@@ -1,8 +1,5 @@
 import type { AccountAction, NormalAction } from '../types'
-import {
-  parseNormalActionBorrowToAccountActions,
-  parseNormalActionBorrowWithDebtToAccountActions,
-} from './borrow'
+import { parseNormalActionBorrowToAccountActions } from './borrow'
 import {
   parseNormalActionBridgeFromToAccountActions,
   parseNormalActionBridgeToToAccountActions,
@@ -260,14 +257,6 @@ export const parseNormalActionToAccountActions = ({
         cexAccountIds,
       })
     }
-    case 'borrow-with-debt': {
-      return parseNormalActionBorrowWithDebtToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-      })
-    }
     case 'swap-nft': {
       return parseNormalActionSwapNftToAccountActions({
         action,

package/actions/parsers/borrow/index.ts

@@ -1,2 +1 @@
 export { parseNormalActionBorrowToAccountActions } from './borrow'
-export { parseNormalActionBorrowWithDebtToAccountActions } from './borrowWithDebt'

package/actions/parsers/index.ts

@@ -1,8 +1,5 @@
 export { parseNormalActionToAccountActions } from './action'
-export {
-  parseNormalActionBorrowToAccountActions,
-  parseNormalActionBorrowWithDebtToAccountActions,
-} from './borrow'
+export { parseNormalActionBorrowToAccountActions } from './borrow'
 export {
   parseNormalActionBridgeFromToAccountActions,
   parseNormalActionBridgeToToAccountActions,

package/actions/schemas/action.ts

@@ -1,10 +1,5 @@
 import { z } from 'zod'
-import {
-  accountActionBorrowSchema,
-  accountActionBorrowWithDebtSchema,
-  normalActionBorrowSchema,
-  normalActionBorrowWithDebtSchema,
-} from './borrow'
+import { accountActionBorrowSchema, normalActionBorrowSchema } from './borrow'
 import {
   accountActionBridgeFromSchema,
   accountActionBridgeToSchema,
@@ -117,7 +112,6 @@ import {
 export const normalActionSchema = z.union([
   // borrow
   normalActionBorrowSchema,
-  normalActionBorrowWithDebtSchema,
   // cross replace
   normalActionBridgeFromSchema,
   normalActionBridgeToSchema,
@@ -173,7 +167,6 @@ export const normalActionSchema = z.union([
 
 export const normalActionActionSchema = z.union([
   z.literal('borrow'),
-  z.literal('borrow-with-debt'),
   z.literal('bridge-from'),
   z.literal('bridge-to'),
   z.literal('cross-replace'),
@@ -217,7 +210,6 @@ export const normalActionActionSchema = z.union([
 export const accountActionSchema = z.union([
   // borrow
   accountActionBorrowSchema,
-  accountActionBorrowWithDebtSchema,
   // cross replace
   accountActionBridgeFromSchema,
   accountActionBridgeToSchema,

package/actions/schemas/borrow/index.ts

@@ -1,5 +1 @@
 export { accountActionBorrowSchema, normalActionBorrowSchema } from './borrow'
-export {
-  accountActionBorrowWithDebtSchema,
-  normalActionBorrowWithDebtSchema,
-} from './borrowWithDebt'

package/actions/schemas/default/unions.ts

@@ -5,7 +5,6 @@ const normalActions = [
   'approve',
   'atomic-arbitrage',
   'borrow',
-  'borrow-with-debt',
   'bridge-from',
   'bridge-to',
   'buy-nft',
@@ -44,7 +43,6 @@ const accountActions = [
   'approve',
   'atomic-arbitrage',
   'borrow',
-  'borrow-with-debt',
   'bridge-from',
   'bridge-to',
   'buy-nft',

package/actions/schemas/index.ts

@@ -3,12 +3,7 @@ export {
   normalActionActionSchema,
   normalActionSchema,
 } from './action'
-export {
-  accountActionBorrowSchema,
-  accountActionBorrowWithDebtSchema,
-  normalActionBorrowSchema,
-  normalActionBorrowWithDebtSchema,
-} from './borrow'
+export { accountActionBorrowSchema, normalActionBorrowSchema } from './borrow'
 export { crossActionBundleSchema } from './crossActionBundle'
 export {
   accountActionBridgeFromSchema,

package/actions/types/index.ts

@@ -17,10 +17,6 @@ export type {
   NormalActionAtomicArbitrage,
 } from './atomicArbitrage'
 export type { AccountActionBorrow, NormalActionBorrow } from './borrow'
-export type {
-  AccountActionBorrowWithDebt,
-  NormalActionBorrowWithDebt,
-} from './borrowWithDebt'
 export type {
   AccountActionBridgeFrom,
   NormalActionBridgeFrom,

package/actions/utils.ts

@@ -3,7 +3,6 @@ import type {
   AccountActionApprove,
   AccountActionAtomicArbitrage,
   AccountActionBorrow,
-  AccountActionBorrowWithDebt,
   AccountActionBridgeFrom,
   AccountActionBridgeTo,
   AccountActionBuyCrypto,
@@ -49,7 +48,6 @@ import type {
   NormalActionApprove,
   NormalActionAtomicArbitrage,
   NormalActionBorrow,
-  NormalActionBorrowWithDebt,
   NormalActionBridgeFrom,
   NormalActionBridgeTo,
   NormalActionBuyCrypto,
@@ -228,34 +226,6 @@ export const parseBaseNormalActionToNormalAction = (
         transfers,
       } satisfies NormalActionBorrow
     }
-    case 'borrow-with-debt': {
-      const transfers = action.transfers.filter(
-        (
-          transfer,
-        ): transfer is
-          | TransferCryptoCurrencyIn
-          | TransferNftIn
-          | TransferCryptoCurrencyOut
-          | TransferNftOut =>
-          isTransferCryptoCurrencyIn(transfer) ||
-          isTransferNftIn(transfer) ||
-          isTransferCryptoCurrencyOut(transfer) ||
-          isTransferNftOut(transfer),
-      )
-      if (transfers.length !== action.transfers.length) {
-        throw new Error('Invalid action.transfers for borrow-with-debt')
-      }
-      if (action.loanId === undefined) {
-        throw new Error('action.loandId is required for borrow-with-debt')
-      }
-      return {
-        ...action,
-        type: 'LoanNormalAction',
-        action: 'borrow-with-debt',
-        loanId: action.loanId,
-        transfers,
-      } satisfies NormalActionBorrowWithDebt
-    }
     case 'bridge-from': {
       const transfers = action.transfers.filter(
         (transfer): transfer is TransferCryptoCurrencyOut | TransferNftOut =>
@@ -1081,38 +1051,6 @@ export const parseBaseAccountActionToAccountAction = (
         transfers,
       } satisfies AccountActionBorrow
     }
-    case 'borrow-with-debt': {
-      // transferCryptoCurrencyInSchema,
-      // transferNftInSchema,
-      // transferCryptoCurrencyOutSchema,
-      // transferNftOutSchema,
-      const transfers = action.transfers.filter(
-        (
-          transfer,
-        ): transfer is
-          | TransferCryptoCurrencyIn
-          | TransferNftIn
-          | TransferCryptoCurrencyOut
-          | TransferNftOut =>
-          isTransferCryptoCurrencyIn(transfer) ||
-          isTransferNftIn(transfer) ||
-          isTransferCryptoCurrencyOut(transfer) ||
-          isTransferNftOut(transfer),
-      )
-      if (transfers.length !== action.transfers.length) {
-        throw new Error('Invalid action.transfers for borrow-with-debt')
-      }
-      if (action.loanId === undefined) {
-        throw new Error('action.loandId is required for borrow-with-debt')
-      }
-      return {
-        ...action,
-        type: 'LoanAccountAction',
-        action: 'borrow-with-debt',
-        loanId: action.loanId,
-        transfers,
-      } satisfies AccountActionBorrowWithDebt
-    }
     case 'bridge-from': {
       // transferCryptoCurrencyOutSchema, transferNftOutSchema
       const transfers = action.transfers.filter(

package/index.ts

@@ -4,7 +4,6 @@ export {
   accountActionApproveSchema,
   accountActionAtomicArbitrageSchema,
   accountActionBorrowSchema,
-  accountActionBorrowWithDebtSchema,
   accountActionBridgeFromSchema,
   accountActionBridgeToSchema,
   accountActionBuyCryptoSchema,
@@ -63,7 +62,6 @@ export {
   normalActionApproveSchema,
   normalActionAtomicArbitrageSchema,
   normalActionBorrowSchema,
-  normalActionBorrowWithDebtSchema,
   normalActionBridgeFromSchema,
   normalActionBridgeToSchema,
   normalActionBuyCryptoSchema,
@@ -110,7 +108,6 @@ export type {
   AccountActionApprove,
   AccountActionAtomicArbitrage,
   AccountActionBorrow,
-  AccountActionBorrowWithDebt,
   AccountActionBridgeFrom,
   AccountActionBridgeTo,
   AccountActionBuyCrypto,
@@ -163,7 +160,6 @@ export type {
   NormalActionApprove,
   NormalActionAtomicArbitrage,
   NormalActionBorrow,
-  NormalActionBorrowWithDebt,
   NormalActionBridgeFrom,
   NormalActionBridgeTo,
   NormalActionBuyCrypto,
@@ -248,6 +244,7 @@ export type {
 } from './assets'
 export { createPortfolio } from './portfolios'
 export type { Portfolio } from './portfolios'
+export { setAccountActionPrices } from './setAccountActionPrices'
 export type { Config, Logger } from './types'
 export { rest, stringify } from './utils'
 export type { Schema } from './utils'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xtorch/core",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Cryptorch | TypeScript Analyze Interface for Crypto Data.",
   "keywords": [
     "cryptorch",

package/setAccountActionPrices.ts

@@ -0,0 +1,123 @@
+import type { AccountAction } from './actions'
+import type {
+  CryptoCurrency,
+  CryptoCurrencyDataSource,
+  CryptoCurrencyPrice,
+  FiatCurrency,
+} from './assets'
+
+type SetAccountActionPricesParameters = {
+  readonly actions: readonly AccountAction[]
+  readonly fiat: FiatCurrency
+  readonly cryptoCurrencyDataSource: CryptoCurrencyDataSource
+}
+
+export const setAccountActionPrices = async ({
+  actions,
+  fiat,
+  cryptoCurrencyDataSource,
+}: SetAccountActionPricesParameters) => {
+  // crypto currency 毎の取得期間を作成
+  const targets = getCryptoCurrencyTargets(actions)
+
+  // 取得期間をもとに価格を取得
+  const cryptoCurrencyPricesOfTarget = await Promise.all(
+    targets.map(({ currency, from, to }) =>
+      cryptoCurrencyDataSource.getHistoricalPrices({
+        targetCurrencies: [currency],
+        vsCurrency: fiat,
+        from: from - 1000 * 60 * 60,
+        to: to + 1000 * 60 * 60,
+      }),
+    ),
+  )
+  const prices = cryptoCurrencyPricesOfTarget
+    .flat()
+    .toSorted((a, b) => a.timestamp - b.timestamp)
+
+  // 価格を設定して返す
+  return actions.map((action) => setPrices(action, prices))
+}
+
+type CryptoCurrencyTarget = {
+  readonly currency: CryptoCurrency
+  readonly from: number
+  readonly to: number
+}
+
+const getCryptoCurrencyTargets = (
+  actions: readonly AccountAction[],
+): readonly CryptoCurrencyTarget[] => {
+  const mut_targets: CryptoCurrencyTarget[] = []
+  for (const action of actions) {
+    for (const transfer of action.transfers) {
+      if (transfer.asset.type !== 'CryptoCurrency') {
+        continue
+      }
+      const targetIndex = mut_targets.findIndex(
+        (target) => target.currency.id === transfer.asset.id,
+      )
+      if (targetIndex === -1) {
+        mut_targets.push({
+          currency: transfer.asset,
+          from: action.timestamp,
+          to: action.timestamp,
+        })
+      } else {
+        const target = mut_targets[targetIndex]
+        mut_targets[targetIndex] = {
+          currency: target.currency,
+          from: Math.min(target.from, action.timestamp),
+          to: Math.max(target.to, action.timestamp),
+        }
+      }
+    }
+  }
+  return mut_targets
+}
+
+const setPrices = (
+  action: AccountAction,
+  prices: readonly CryptoCurrencyPrice[],
+): AccountAction =>
+  ({
+    ...action,
+    transfers: action.transfers.map((transfer) => {
+      switch (transfer.asset.type) {
+        case 'CryptoCurrency': {
+          return {
+            ...transfer,
+            price: getPrice(prices, action.timestamp, transfer.asset.id),
+          }
+        }
+        case 'FiatCurrency': {
+          return transfer
+        }
+        case 'Nft': {
+          return transfer
+        }
+      }
+    }),
+  }) as AccountAction
+
+const getPrice = (
+  prices: readonly CryptoCurrencyPrice[],
+  timestamp: number,
+  id: string | undefined,
+): CryptoCurrencyPrice | undefined =>
+  prices
+    .filter(
+      ({ cryptoCurrencyId, timestamp: priceTimestamp }) =>
+        cryptoCurrencyId === id &&
+        priceTimestamp >= timestamp - 1000 * 60 * 60 &&
+        priceTimestamp <= timestamp + 1000 * 60 * 60,
+    )
+    .reduce(
+      (closestPrice: CryptoCurrencyPrice | undefined, price) =>
+        closestPrice === undefined ||
+        Math.abs(price.timestamp - timestamp) <
+          Math.abs(closestPrice.timestamp - timestamp)
+          ? price
+          : closestPrice,
+      undefined,
+    )

package/_cjs/actions/parsers/borrow/borrowWithDebt.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNormalActionBorrowWithDebtToAccountActions = void 0;
-const default_1 = require("../default");
-const parseNormalActionBorrowWithDebtToAccountActions = ({ action, accountIds, source, cexAccountIds, }) => (0, default_1.allTransfersIsAccountRelated)(action.transfers, accountIds)
-    ? [
-        {
-            ...(0, default_1.createAccountActionCommon)(action, source),
-            type: 'LoanAccountAction',
-            action: 'borrow-with-debt',
-            evidence: action.evidence,
-            loanId: action.loanId,
-            transfers: action.transfers,
-        },
-    ]
-    : (0, default_1.parseNormalActionToAccountActions)({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-    });
-exports.parseNormalActionBorrowWithDebtToAccountActions = parseNormalActionBorrowWithDebtToAccountActions;
-//# sourceMappingURL=borrowWithDebt.js.map

package/_cjs/actions/parsers/borrow/borrowWithDebt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"borrowWithDebt.js","sourceRoot":"","sources":["../../../../actions/parsers/borrow/borrowWithDebt.ts"],"names":[],"mappings":";;;AASA,wCAImB;AAGZ,MAAM,+CAA+C,GAAG,CAAC,EAC9D,MAAM,EACN,UAAU,EACV,MAAM,EACN,aAAa,GAC2D,EAQlE,EAAE,CACR,IAAA,sCAA4B,EAAC,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC;IACxD,CAAC,CAAC;QACE;YACE,GAAG,IAAA,mCAAyB,EAAC,MAAM,EAAE,MAAM,CAAC;YAC5C,IAAI,EAAE,mBAAmB;YACzB,MAAM,EAAE,kBAAkB;YAC1B,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,SAAS,EAAE,MAAM,CAAC,SAAS;SAC5B;KACF;IACH,CAAC,CAAC,IAAA,2CAAiC,EAAC;QAChC,MAAM;QACN,UAAU;QACV,MAAM;QACN,aAAa;KACd,CAAC,CAAA;AA9BK,QAAA,+CAA+C,mDA8BpD"}

package/_cjs/actions/schemas/borrow/borrowWithDebt.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.accountActionBorrowWithDebtSchema = exports.normalActionBorrowWithDebtSchema = void 0;
-const zod_1 = require("zod");
-const default_1 = require("../default");
-exports.normalActionBorrowWithDebtSchema = default_1.loanNormalActionDefaultSchema
-    .extend({
-    action: zod_1.z.literal('borrow-with-debt'),
-    transfers: zod_1.z.array(zod_1.z.union([
-        default_1.transferCryptoCurrencyInSchema,
-        default_1.transferNftInSchema,
-        default_1.transferCryptoCurrencyOutSchema,
-        default_1.transferNftOutSchema,
-    ])),
-})
-    .transform((v) => ({
-    ...v,
-    comment: v.comment,
-    app: v.app,
-}));
-exports.accountActionBorrowWithDebtSchema = default_1.loanAccountActionDefaultSchema
-    .extend({
-    action: zod_1.z.literal('borrow-with-debt'),
-    transfers: zod_1.z.array(zod_1.z.union([
-        default_1.transferCryptoCurrencyInSchema,
-        default_1.transferNftInSchema,
-        default_1.transferCryptoCurrencyOutSchema,
-        default_1.transferNftOutSchema,
-    ])),
-})
-    .transform((v) => ({
-    ...v,
-    comment: v.comment,
-    app: v.app,
-}));
-//# sourceMappingURL=borrowWithDebt.js.map

package/_cjs/actions/schemas/borrow/borrowWithDebt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"borrowWithDebt.js","sourceRoot":"","sources":["../../../../actions/schemas/borrow/borrowWithDebt.ts"],"names":[],"mappings":";;;AAAA,6BAAuB;AACvB,wCAOmB;AAEN,QAAA,gCAAgC,GAAG,uCAA6B;KAC1E,MAAM,CAAC;IACN,MAAM,EAAE,OAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC;IACrC,SAAS,EAAE,OAAC,CAAC,KAAK,CAChB,OAAC,CAAC,KAAK,CAAC;QACN,wCAA8B;QAC9B,6BAAmB;QACnB,yCAA+B;QAC/B,8BAAoB;KACrB,CAAC,CACH;CACF,CAAC;KACD,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACjB,GAAG,CAAC;IACJ,OAAO,EAAE,CAAC,CAAC,OAAO;IAClB,GAAG,EAAE,CAAC,CAAC,GAAG;CACX,CAAC,CAAC,CAAA;AAEQ,QAAA,iCAAiC,GAAG,wCAA8B;KAC5E,MAAM,CAAC;IACN,MAAM,EAAE,OAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC;IACrC,SAAS,EAAE,OAAC,CAAC,KAAK,CAChB,OAAC,CAAC,KAAK,CAAC;QACN,wCAA8B;QAC9B,6BAAmB;QACnB,yCAA+B;QAC/B,8BAAoB;KACrB,CAAC,CACH;CACF,CAAC;KACD,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACjB,GAAG,CAAC;IACJ,OAAO,EAAE,CAAC,CAAC,OAAO;IAClB,GAAG,EAAE,CAAC,CAAC,GAAG;CACX,CAAC,CAAC,CAAA"}

package/_cjs/actions/types/borrowWithDebt.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=borrowWithDebt.js.map

package/_cjs/actions/types/borrowWithDebt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"borrowWithDebt.js","sourceRoot":"","sources":["../../../actions/types/borrowWithDebt.ts"],"names":[],"mappings":""}

package/_esm/actions/parsers/borrow/borrowWithDebt.js

@@ -1,19 +0,0 @@
-import { allTransfersIsAccountRelated, createAccountActionCommon, parseNormalActionToAccountActions, } from '../default';
-export const parseNormalActionBorrowWithDebtToAccountActions = ({ action, accountIds, source, cexAccountIds, }) => allTransfersIsAccountRelated(action.transfers, accountIds)
-    ? [
-        {
-            ...createAccountActionCommon(action, source),
-            type: 'LoanAccountAction',
-            action: 'borrow-with-debt',
-            evidence: action.evidence,
-            loanId: action.loanId,
-            transfers: action.transfers,
-        },
-    ]
-    : parseNormalActionToAccountActions({
-        action,
-        accountIds,
-        source,
-        cexAccountIds,
-    });
-//# sourceMappingURL=borrowWithDebt.js.map

package/_esm/actions/parsers/borrow/borrowWithDebt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"borrowWithDebt.js","sourceRoot":"","sources":["../../../../actions/parsers/borrow/borrowWithDebt.ts"],"names":[],"mappings":"AASA,OAAO,EACL,4BAA4B,EAC5B,yBAAyB,EACzB,iCAAiC,GAClC,MAAM,YAAY,CAAA;AAGnB,MAAM,CAAC,MAAM,+CAA+C,GAAG,CAAC,EAC9D,MAAM,EACN,UAAU,EACV,MAAM,EACN,aAAa,GAC2D,EAQlE,EAAE,CACR,4BAA4B,CAAC,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC;IACxD,CAAC,CAAC;QACE;YACE,GAAG,yBAAyB,CAAC,MAAM,EAAE,MAAM,CAAC;YAC5C,IAAI,EAAE,mBAAmB;YACzB,MAAM,EAAE,kBAAkB;YAC1B,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,SAAS,EAAE,MAAM,CAAC,SAAS;SAC5B;KACF;IACH,CAAC,CAAC,iCAAiC,CAAC;QAChC,MAAM;QACN,UAAU;QACV,MAAM;QACN,aAAa;KACd,CAAC,CAAA"}

package/_esm/actions/schemas/borrow/borrowWithDebt.js

@@ -1,33 +0,0 @@
-import { z } from 'zod';
-import { loanAccountActionDefaultSchema, loanNormalActionDefaultSchema, transferCryptoCurrencyInSchema, transferCryptoCurrencyOutSchema, transferNftInSchema, transferNftOutSchema, } from '../default';
-export const normalActionBorrowWithDebtSchema = loanNormalActionDefaultSchema
-    .extend({
-    action: z.literal('borrow-with-debt'),
-    transfers: z.array(z.union([
-        transferCryptoCurrencyInSchema,
-        transferNftInSchema,
-        transferCryptoCurrencyOutSchema,
-        transferNftOutSchema,
-    ])),
-})
-    .transform((v) => ({
-    ...v,
-    comment: v.comment,
-    app: v.app,
-}));
-export const accountActionBorrowWithDebtSchema = loanAccountActionDefaultSchema
-    .extend({
-    action: z.literal('borrow-with-debt'),
-    transfers: z.array(z.union([
-        transferCryptoCurrencyInSchema,
-        transferNftInSchema,
-        transferCryptoCurrencyOutSchema,
-        transferNftOutSchema,
-    ])),
-})
-    .transform((v) => ({
-    ...v,
-    comment: v.comment,
-    app: v.app,
-}));
-//# sourceMappingURL=borrowWithDebt.js.map

package/_esm/actions/schemas/borrow/borrowWithDebt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"borrowWithDebt.js","sourceRoot":"","sources":["../../../../actions/schemas/borrow/borrowWithDebt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,EAC7B,8BAA8B,EAC9B,+BAA+B,EAC/B,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,YAAY,CAAA;AAEnB,MAAM,CAAC,MAAM,gCAAgC,GAAG,6BAA6B;KAC1E,MAAM,CAAC;IACN,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC;IACrC,SAAS,EAAE,CAAC,CAAC,KAAK,CAChB,CAAC,CAAC,KAAK,CAAC;QACN,8BAA8B;QAC9B,mBAAmB;QACnB,+BAA+B;QAC/B,oBAAoB;KACrB,CAAC,CACH;CACF,CAAC;KACD,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACjB,GAAG,CAAC;IACJ,OAAO,EAAE,CAAC,CAAC,OAAO;IAClB,GAAG,EAAE,CAAC,CAAC,GAAG;CACX,CAAC,CAAC,CAAA;AAEL,MAAM,CAAC,MAAM,iCAAiC,GAAG,8BAA8B;KAC5E,MAAM,CAAC;IACN,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC;IACrC,SAAS,EAAE,CAAC,CAAC,KAAK,CAChB,CAAC,CAAC,KAAK,CAAC;QACN,8BAA8B;QAC9B,mBAAmB;QACnB,+BAA+B;QAC/B,oBAAoB;KACrB,CAAC,CACH;CACF,CAAC;KACD,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACjB,GAAG,CAAC;IACJ,OAAO,EAAE,CAAC,CAAC,OAAO;IAClB,GAAG,EAAE,CAAC,CAAC,GAAG;CACX,CAAC,CAAC,CAAA"}

package/_esm/actions/types/borrowWithDebt.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=borrowWithDebt.js.map

package/_esm/actions/types/borrowWithDebt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"borrowWithDebt.js","sourceRoot":"","sources":["../../../actions/types/borrowWithDebt.ts"],"names":[],"mappings":""}

package/_types/actions/parsers/borrow/borrowWithDebt.d.ts

@@ -1,4 +0,0 @@
-import type { AccountActionBorrowWithDebt, AccountActionIncome, AccountActionMove, AccountActionReceiveFromCex, AccountActionSendToCex, AccountActionTransfer, NormalActionBorrowWithDebt } from '../../types';
-import type { ParseNormalActionToAccountActionsParameters } from '../types';
-export declare const parseNormalActionBorrowWithDebtToAccountActions: ({ action, accountIds, source, cexAccountIds, }: ParseNormalActionToAccountActionsParameters<NormalActionBorrowWithDebt>) => [AccountActionBorrowWithDebt] | readonly (AccountActionIncome | AccountActionTransfer | AccountActionMove | AccountActionReceiveFromCex | AccountActionSendToCex)[];
-//# sourceMappingURL=borrowWithDebt.d.ts.map

package/_types/actions/parsers/borrow/borrowWithDebt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"borrowWithDebt.d.ts","sourceRoot":"","sources":["../../../../actions/parsers/borrow/borrowWithDebt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,mBAAmB,EACnB,iBAAiB,EACjB,2BAA2B,EAC3B,sBAAsB,EACtB,qBAAqB,EACrB,0BAA0B,EAC3B,MAAM,aAAa,CAAA;AAMpB,OAAO,KAAK,EAAE,2CAA2C,EAAE,MAAM,UAAU,CAAA;AAE3E,eAAO,MAAM,+CAA+C,mDAKzD,4CAA4C,0BAA0B,CAAC,KACtE,CAAC,2BAA2B,CAAC,GAC7B,SAAS,CACL,mBAAmB,GACnB,qBAAqB,GACrB,iBAAiB,GACjB,2BAA2B,GAC3B,sBAAsB,CACzB,EAiBG,CAAA"}

package/_types/actions/types/borrowWithDebt.d.ts

@@ -1,5 +0,0 @@
-import type { z } from 'zod';
-import type { accountActionBorrowWithDebtSchema, normalActionBorrowWithDebtSchema } from '../schemas';
-export type NormalActionBorrowWithDebt = z.infer<typeof normalActionBorrowWithDebtSchema>;
-export type AccountActionBorrowWithDebt = z.infer<typeof accountActionBorrowWithDebtSchema>;
-//# sourceMappingURL=borrowWithDebt.d.ts.map

package/_types/actions/types/borrowWithDebt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"borrowWithDebt.d.ts","sourceRoot":"","sources":["../../../actions/types/borrowWithDebt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EACV,iCAAiC,EACjC,gCAAgC,EACjC,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAA"}

package/actions/parsers/borrow/borrowWithDebt.ts

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