@0xtorch/evm 0.0.10 → 0.0.12

package/analyzer/spam/analyze.ts

@@ -1,34 +1,50 @@
-import { createBigDecimal } from '@0xtorch/big-decimal'
 import type {
   CryptoCurrencyPrice,
   NormalActionSpam,
   NormalActionTransfer,
 } from '@0xtorch/core'
+import { parseNormalActionToAccountActions } from '@0xtorch/core'
 import type { Chain } from '../../chains'
-import { createEvmAccount } from '../../creates/createEvmAccount'
-import type { EvmAccount, TransactionDecoded } from '../../types'
-import { toLowerHex } from '../../types'
-import { createAccountActionByAction } from '../createAccountActionByAction'
+import type { TransactionDecoded } from '../../types'
+import { createEvmAddressId } from '../../utils'
+import { createEvmActionSource } from '../../utils/create'
+import {
+  parseErc1155TransferToActionTransferIn,
+  parseErc20TransferToActionTransferIn,
+  parseErc20TransferToActionTransferNone,
+  parseErc721TransferToActionTransferIn,
+  parseInternalTransactionToActionTransferNone,
+  parseTransactionValueToActionTransferNone,
+} from '../parsers/transfer'
 import type { AnalyzeParameters, AnalyzeReturnType } from '../types'
 
 export const analyzeAsSpam = <Price extends CryptoCurrencyPrice | undefined>({
   chain,
   transaction,
   accountAddresses,
-}: AnalyzeParameters<Price>): Promise<AnalyzeReturnType<Price> | undefined> => {
+}: AnalyzeParameters<Price>): Promise<AnalyzeReturnType | undefined> => {
   // 全ての native token(include internalTx),erc20,721,1155 transfer を transfer action として normal action 作成
   const normalActions = generateNormalActions(chain, transaction)
 
   // accountAddresses が含まれているものについて account action 作成
-  const optionalAccountActions = normalActions.map((action) =>
-    createAccountActionByAction(action, transaction, accountAddresses),
+  const accountIds = new Set(
+    accountAddresses.map((address) =>
+      createEvmAddressId({ chainId: chain.id, address }),
+    ),
+  )
+  const source = createEvmActionSource({
+    chainId: chain.id,
+    transactionHash: transaction.transactionHash,
+  })
+  const accountActions = normalActions.flatMap((action) =>
+    parseNormalActionToAccountActions({
+      action,
+      accountIds,
+      source,
+      // TODO 値を入れる
+      cexAccountIds: undefined,
+    }),
   )
-  const accountActions = optionalAccountActions
-    .filter(
-      (action): action is Exclude<typeof action, undefined> =>
-        action !== undefined,
-    )
-    .map((action, index) => ({ ...action, order: index }))
 
   return Promise.resolve({
     actions: normalActions,
@@ -38,8 +54,9 @@ export const analyzeAsSpam = <Price extends CryptoCurrencyPrice | undefined>({
 
 const generateNormalActions = <Price extends CryptoCurrencyPrice | undefined>(
   chain: Chain,
-  {
-    from,
+  transaction: TransactionDecoded<Price>,
+): (NormalActionTransfer | NormalActionSpam)[] => {
+  const {
     to,
     value,
     block,
@@ -48,16 +65,9 @@ const generateNormalActions = <Price extends CryptoCurrencyPrice | undefined>(
     erc721Transfers,
     erc1155Transfers,
     app,
-    nativeTokenPrice,
-  }: TransactionDecoded<Price>,
-): (
-  | NormalActionTransfer<EvmAccount, Price>
-  | NormalActionSpam<EvmAccount, Price>
-)[] => {
-  const mut_actions: (
-    | NormalActionTransfer<EvmAccount, Price>
-    | NormalActionSpam<EvmAccount, Price>
-  )[] = []
+  } = transaction
+
+  const mut_actions: (NormalActionTransfer | NormalActionSpam)[] = []
   if (value > 0 && to !== null) {
     mut_actions.push({
       type: 'NormalAction',
@@ -67,21 +77,10 @@ const generateNormalActions = <Price extends CryptoCurrencyPrice | undefined>(
       comment: undefined,
       app,
       transfers: [
-        {
-          target: '',
-          direction: 'none',
-          from: createEvmAccount({
-            address: toLowerHex(from),
-            chainId: chain.id,
-          }),
-          to: createEvmAccount({
-            address: toLowerHex(to),
-            chainId: chain.id,
-          }),
-          asset: chain.nativeToken.currency,
-          amount: createBigDecimal(value, chain.nativeToken.decimals),
-          price: nativeTokenPrice,
-        },
+        parseTransactionValueToActionTransferNone({
+          chain,
+          transaction,
+        }),
       ],
     })
   }
@@ -100,24 +99,10 @@ const generateNormalActions = <Price extends CryptoCurrencyPrice | undefined>(
       comment: undefined,
       app,
       transfers: [
-        {
-          target: '',
-          direction: 'none',
-          from: createEvmAccount({
-            address: internalTx.from,
-            chainId: chain.id,
-          }),
-          to: createEvmAccount({
-            address: internalTx.to,
-            chainId: chain.id,
-          }),
-          asset: chain.nativeToken.currency,
-          amount: createBigDecimal(
-            internalTx.value,
-            chain.nativeToken.decimals,
-          ),
-          price: nativeTokenPrice,
-        },
+        parseInternalTransactionToActionTransferNone({
+          chain,
+          internalTransaction: internalTx,
+        }),
       ],
     })
   }
@@ -128,31 +113,37 @@ const generateNormalActions = <Price extends CryptoCurrencyPrice | undefined>(
   ].sort((a, b) => a.logIndex - b.logIndex)) {
     switch (transfer.type) {
       case 'Erc20Transfer': {
-        mut_actions.push({
-          type: 'NormalAction',
-          action: transfer.price === undefined ? 'spam' : 'transfer',
-          evidence: 'contract',
-          timestamp: Number(block.timestamp) * 1000,
-          comment: undefined,
-          app,
-          transfers: [
-            {
-              target: '',
-              direction: 'none',
-              from: createEvmAccount({
-                address: transfer.from,
+        if (transfer.price === undefined) {
+          mut_actions.push({
+            type: 'NormalAction',
+            action: 'spam',
+            evidence: 'contract',
+            timestamp: Number(block.timestamp) * 1000,
+            comment: undefined,
+            app,
+            transfers: [
+              parseErc20TransferToActionTransferIn({
                 chainId: chain.id,
+                transfer,
               }),
-              to: createEvmAccount({
-                address: transfer.to,
+            ],
+          })
+        } else {
+          mut_actions.push({
+            type: 'NormalAction',
+            action: 'transfer',
+            evidence: 'contract',
+            timestamp: Number(block.timestamp) * 1000,
+            comment: undefined,
+            app,
+            transfers: [
+              parseErc20TransferToActionTransferNone({
                 chainId: chain.id,
+                transfer,
               }),
-              asset: transfer.token.currency,
-              amount: createBigDecimal(transfer.value, transfer.token.decimals),
-              price: transfer.price,
-            },
-          ],
-        })
+            ],
+          })
+        }
         break
       }
       case 'Erc721Transfer': {
@@ -164,22 +155,10 @@ const generateNormalActions = <Price extends CryptoCurrencyPrice | undefined>(
           comment: undefined,
           app,
           transfers: [
-            {
-              target: '',
-              direction: 'none',
-              from: createEvmAccount({
-                address: transfer.from,
-                chainId: chain.id,
-              }),
-              to: createEvmAccount({
-                address: transfer.to,
-                chainId: chain.id,
-              }),
-              asset: transfer.nft,
-              amount: createBigDecimal('1'),
-              // TODO 適切な値を入れる (一律 undefined を入れたい)
-              price: undefined as Price,
-            },
+            parseErc721TransferToActionTransferIn({
+              chainId: chain.id,
+              transfer,
+            }),
           ],
         })
         break
@@ -193,22 +172,10 @@ const generateNormalActions = <Price extends CryptoCurrencyPrice | undefined>(
           comment: undefined,
           app,
           transfers: [
-            {
-              target: '',
-              direction: 'none',
-              from: createEvmAccount({
-                address: transfer.from,
-                chainId: chain.id,
-              }),
-              to: createEvmAccount({
-                address: transfer.to,
-                chainId: chain.id,
-              }),
-              asset: transfer.nft,
-              amount: createBigDecimal(transfer.value, 0),
-              // TODO 適切な値を入れる (一律 undefined を入れたい)
-              price: undefined as Price,
-            },
+            parseErc1155TransferToActionTransferIn({
+              chainId: chain.id,
+              transfer,
+            }),
           ],
         })
         break

package/analyzer/swap/analyze.ts

@@ -1,22 +1,27 @@
-import { createBigDecimal } from '@0xtorch/big-decimal'
 import type {
   CryptoCurrency,
   CryptoCurrencyPrice,
   NormalActionAtomicArbitrage,
   NormalActionTrade,
 } from '@0xtorch/core'
+import { parseNormalActionToAccountActions } from '@0xtorch/core'
 import { zeroAddress } from 'viem'
 import type { Chain } from '../../chains'
-import { createEvmAccount } from '../../creates/createEvmAccount'
 import type {
   DecodedLog,
   Erc20Transfer,
-  EvmAccount,
   InternalTransaction,
   LowerHex,
 } from '../../types'
 import { toLowerHex } from '../../types'
-import { createAccountActionByAction } from '../createAccountActionByAction'
+import { createEvmAddressId } from '../../utils'
+import { createEvmActionSource } from '../../utils/create'
+import {
+  parseErc20TransferToActionTransferIn,
+  parseErc20TransferToActionTransferOut,
+  parseInternalTransactionToActionTransferIn,
+  parseInternalTransactionToActionTransferOut,
+} from '../parsers/transfer'
 import type { AnalyzeParameters, AnalyzeReturnType } from '../types'
 import type { TraderJoeLBPairSwapLog } from './traderJoeLBPairSwap'
 import { parseToTraderJoeLBPairSwap } from './traderJoeLBPairSwap'
@@ -33,7 +38,7 @@ export const analyzeSwap = <Price extends CryptoCurrencyPrice | undefined>({
   chain,
   transaction,
   accountAddresses,
-}: AnalyzeParameters<Price>): Promise<AnalyzeReturnType<Price> | undefined> => {
+}: AnalyzeParameters<Price>): Promise<AnalyzeReturnType | undefined> => {
   const {
     transactionHash,
     from,
@@ -196,15 +201,26 @@ export const analyzeSwap = <Price extends CryptoCurrencyPrice | undefined>({
   const normalAction = generateNormalAction(swap, chain, timestamp)
 
   // account action を生成
-  const accountAction = createAccountActionByAction(
-    normalAction,
-    transaction,
-    accountAddresses,
+  const accountIds = new Set(
+    accountAddresses.map((address) =>
+      createEvmAddressId({ chainId: chain.id, address }),
+    ),
   )
+  const source = createEvmActionSource({
+    chainId: chain.id,
+    transactionHash: transaction.transactionHash,
+  })
+  const accountActions = parseNormalActionToAccountActions({
+    action: normalAction,
+    accountIds,
+    source,
+    // TODO 値を入れる
+    cexAccountIds: undefined,
+  })
 
   return Promise.resolve({
     actions: [normalAction],
-    accountActions: accountAction === undefined ? [] : [accountAction],
+    accountActions,
   })
 }
 
@@ -212,9 +228,7 @@ const generateNormalAction = <Price extends CryptoCurrencyPrice | undefined>(
   swap: Swap<Price>,
   chain: Chain,
   timestamp: number,
-):
-  | NormalActionAtomicArbitrage<EvmAccount, Price>
-  | NormalActionTrade<EvmAccount, Price, CryptoCurrency> => {
+): NormalActionAtomicArbitrage | NormalActionTrade => {
   if (
     swap.transferIn.type === 'InternalTransaction' &&
     swap.transferOut.type === 'InternalTransaction'
@@ -238,33 +252,12 @@ const generateNormalActionAtomicArbitrage = <
   swap: Swap<Price>,
   chain: Chain,
   timestamp: number,
-): NormalActionAtomicArbitrage<EvmAccount, Price> => {
+): NormalActionAtomicArbitrage => {
   const { transferIn, transferOut } = swap
-  const transferInAsset =
-    transferIn.type === 'Erc20Transfer'
-      ? transferIn.token.currency
-      : chain.nativeToken.currency
-  const transferOutAsset =
-    transferOut.type === 'Erc20Transfer'
-      ? transferOut.token.currency
-      : chain.nativeToken.currency
-  if (
-    transferIn.to === undefined ||
-    transferOut.to === undefined ||
-    transferInAsset === undefined ||
-    transferOutAsset === undefined
-  ) {
+  if (transferIn.to === undefined || transferOut.to === undefined) {
     throw new Error('invalid swap')
   }
 
-  const transferInDecimals =
-    transferIn.type === 'Erc20Transfer'
-      ? transferIn.token.decimals
-      : chain.nativeToken.decimals
-  const transferOutDecimals =
-    transferOut.type === 'Erc20Transfer'
-      ? transferOut.token.decimals
-      : chain.nativeToken.decimals
   return {
     type: 'NormalAction',
     action: 'atomic-arbitrage',
@@ -273,27 +266,24 @@ const generateNormalActionAtomicArbitrage = <
     comment: undefined,
     app: undefined,
     transfers: [
-      {
-        target: transferIn.from,
-        direction: 'out',
-        from: createEvmAccount({ address: transferIn.from, chainId: chain.id }),
-        to: createEvmAccount({ address: transferIn.to, chainId: chain.id }),
-        asset: transferInAsset,
-        amount: createBigDecimal(transferIn.value, transferInDecimals),
-        price: transferIn.price,
-      },
-      {
-        target: transferOut.to,
-        direction: 'in',
-        from: createEvmAccount({
-          address: transferOut.from,
-          chainId: chain.id,
-        }),
-        to: createEvmAccount({ address: transferOut.to, chainId: chain.id }),
-        asset: transferOutAsset,
-        amount: createBigDecimal(transferOut.value, transferOutDecimals),
-        price: transferOut.price,
-      },
+      transferIn.type === 'InternalTransaction'
+        ? parseInternalTransactionToActionTransferOut({
+            chain,
+            internalTransaction: transferIn,
+          })
+        : parseErc20TransferToActionTransferOut({
+            chainId: chain.id,
+            transfer: transferIn,
+          }),
+      transferOut.type === 'InternalTransaction'
+        ? parseInternalTransactionToActionTransferIn({
+            chain,
+            internalTransaction: transferOut,
+          })
+        : parseErc20TransferToActionTransferIn({
+            chainId: chain.id,
+            transfer: transferOut,
+          }),
     ],
   }
 }
@@ -304,33 +294,12 @@ const generateNormalActionTrade = <
   swap: Swap<Price>,
   chain: Chain,
   timestamp: number,
-): NormalActionTrade<EvmAccount, Price, CryptoCurrency> => {
+): NormalActionTrade => {
   const { transferIn, transferOut } = swap
-  const transferInAsset =
-    transferIn.type === 'Erc20Transfer'
-      ? transferIn.token.currency
-      : chain.nativeToken.currency
-  const transferOutAsset =
-    transferOut.type === 'Erc20Transfer'
-      ? transferOut.token.currency
-      : chain.nativeToken.currency
-  if (
-    transferIn.to === undefined ||
-    transferOut.to === undefined ||
-    transferInAsset === undefined ||
-    transferOutAsset === undefined
-  ) {
+  if (transferIn.to === undefined || transferOut.to === undefined) {
     throw new Error('invalid swap')
   }
 
-  const transferInDecimals =
-    transferIn.type === 'Erc20Transfer'
-      ? transferIn.token.decimals
-      : chain.nativeToken.decimals
-  const transferOutDecimals =
-    transferOut.type === 'Erc20Transfer'
-      ? transferOut.token.decimals
-      : chain.nativeToken.decimals
   return {
     type: 'NormalAction',
     action: 'trade',
@@ -339,27 +308,24 @@ const generateNormalActionTrade = <
     comment: undefined,
     app: undefined,
     transfers: [
-      {
-        target: transferIn.from,
-        direction: 'out',
-        from: createEvmAccount({ address: transferIn.from, chainId: chain.id }),
-        to: createEvmAccount({ address: transferIn.to, chainId: chain.id }),
-        asset: transferInAsset,
-        amount: createBigDecimal(transferIn.value, transferInDecimals),
-        price: transferIn.price,
-      },
-      {
-        target: transferOut.to,
-        direction: 'in',
-        from: createEvmAccount({
-          address: transferOut.from,
-          chainId: chain.id,
-        }),
-        to: createEvmAccount({ address: transferOut.to, chainId: chain.id }),
-        asset: transferOutAsset,
-        amount: createBigDecimal(transferOut.value, transferOutDecimals),
-        price: transferOut.price,
-      },
+      transferIn.type === 'InternalTransaction'
+        ? parseInternalTransactionToActionTransferOut({
+            chain,
+            internalTransaction: transferIn,
+          })
+        : parseErc20TransferToActionTransferOut({
+            chainId: chain.id,
+            transfer: transferIn,
+          }),
+      transferOut.type === 'InternalTransaction'
+        ? parseInternalTransactionToActionTransferIn({
+            chain,
+            internalTransaction: transferOut,
+          })
+        : parseErc20TransferToActionTransferIn({
+            chainId: chain.id,
+            transfer: transferOut,
+          }),
     ],
   }
 }