@0xtorch/evm 0.0.59 → 0.0.61

package/analyzer/seaport/analyze.ts

@@ -14,9 +14,9 @@ import type {
 import type { Chain } from '../../chains'
 import type {
   DecodedLog,
-  Erc1155Transfer,
   Erc20Transfer,
   Erc721Transfer,
+  Erc1155Transfer,
   InternalTransaction,
   LowerHex,
   TransactionDecoded,
@@ -24,12 +24,12 @@ import type {
 import { toLowerHex } from '../../types'
 import { createEvmActionSource, includesEvmAddressId } from '../../utils/create'
 import {
-  parseErc1155TransferToActionTransferIn,
-  parseErc1155TransferToActionTransferOut,
   parseErc20TransferToActionTransferIn,
   parseErc20TransferToActionTransferOut,
   parseErc721TransferToActionTransferIn,
   parseErc721TransferToActionTransferOut,
+  parseErc1155TransferToActionTransferIn,
+  parseErc1155TransferToActionTransferOut,
   parseInternalTransactionToActionTransferIn,
   parseInternalTransactionToActionTransferOut,
 } from '../parsers/transfer'
@@ -130,10 +130,9 @@ export const analyzeSeaport = async <
           // 合致する internal transfer が 1 つ以下の場合は includeNativeToken を true にする
           mut_includeNativeToken = true
           break
-        } else {
-          // 合致する internal transfer が複数の場合は pattern 不一致として undefined を返す
-          return undefined
         }
+        // 合致する internal transfer が複数の場合は pattern 不一致として undefined を返す
+        return undefined
       }
       case 1: {
         // ERC20
@@ -155,24 +154,24 @@ export const analyzeSeaport = async <
           // 合致する ERC20 transfer が 1 つの場合は mut_offerTransfers に追加
           mut_offerTransfers.push(erc20OfferTransfers[0])
           break
-        } else if (erc20OfferTransfers.length > 1) {
+        }
+        if (erc20OfferTransfers.length > 1) {
           // 合致する ERC20 transfer が複数の場合は pattern 不一致として undefined を返す
           return undefined
+        }
+        // 合致する ERC20 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
+        if (
+          erc20Transfers.some(
+            (transfer) =>
+              transfer.token.contractAddress === offerItem.token &&
+              transfer.value === amount,
+          )
+        ) {
+          mut_isSpam = true
         } else {
-          // 合致する ERC20 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
-          if (
-            erc20Transfers.some(
-              (transfer) =>
-                transfer.token.contractAddress === offerItem.token &&
-                transfer.value === amount,
-            )
-          ) {
-            mut_isSpam = true
-          } else {
-            return undefined
-          }
-          break
+          return undefined
         }
+        break
       }
       case 2: {
         // ERC721
@@ -187,24 +186,24 @@ export const analyzeSeaport = async <
           // 合致する ERC721 transfer が 1 つの場合は mut_offerTransfers に追加
           mut_offerTransfers.push(erc721OfferTransfers[0])
           break
-        } else if (erc721OfferTransfers.length > 1) {
+        }
+        if (erc721OfferTransfers.length > 1) {
           // 合致する ERC721 transfer が複数の場合は pattern 不一致として undefined を返す
           return undefined
+        }
+        // 合致する ERC721 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
+        if (
+          erc721Transfers.some(
+            (transfer) =>
+              transfer.token.contractAddress === offerItem.token &&
+              transfer.tokenId === offerItem.identifier,
+          )
+        ) {
+          mut_isSpam = true
         } else {
-          // 合致する ERC721 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
-          if (
-            erc721Transfers.some(
-              (transfer) =>
-                transfer.token.contractAddress === offerItem.token &&
-                transfer.tokenId === offerItem.identifier,
-            )
-          ) {
-            mut_isSpam = true
-          } else {
-            return undefined
-          }
-          break
+          return undefined
         }
+        break
       }
       case 3: {
         // ERC1155
@@ -220,24 +219,24 @@ export const analyzeSeaport = async <
           // 合致する ERC1155 transfer が 1 つの場合は mut_offerTransfers に追加
           mut_offerTransfers.push(erc1155OfferTransfers[0])
           break
-        } else if (erc1155OfferTransfers.length > 1) {
+        }
+        if (erc1155OfferTransfers.length > 1) {
           // 合致する ERC1155 transfer が複数の場合は pattern 不一致として undefined を返す
           return undefined
+        }
+        // 合致する ERC1155 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
+        if (
+          erc1155Transfers.some(
+            (transfer) =>
+              transfer.token.contractAddress === offerItem.token &&
+              transfer.id === offerItem.identifier,
+          )
+        ) {
+          mut_isSpam = true
         } else {
-          // 合致する ERC1155 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
-          if (
-            erc1155Transfers.some(
-              (transfer) =>
-                transfer.token.contractAddress === offerItem.token &&
-                transfer.id === offerItem.identifier,
-            )
-          ) {
-            mut_isSpam = true
-          } else {
-            return undefined
-          }
-          break
+          return undefined
         }
+        break
       }
     }
   }
@@ -267,10 +266,9 @@ export const analyzeSeaport = async <
           // 合致する internal transfer が 1 つ以下の場合は includeNativeToken を true にする
           mut_includeNativeToken = true
           break
-        } else {
-          // 合致する internal transfer が複数の場合は pattern 不一致として undefined を返す
-          return undefined
         }
+        // 合致する internal transfer が複数の場合は pattern 不一致として undefined を返す
+        return undefined
       }
       case 1: {
         // ERC20
@@ -292,24 +290,24 @@ export const analyzeSeaport = async <
           // 合致する ERC20 transfer が 1 つの場合は mut_considerationTransfers に追加
           mut_considerationTransfers.push(erc20ConsiderationTransfers[0])
           break
-        } else if (erc20ConsiderationTransfers.length > 1) {
+        }
+        if (erc20ConsiderationTransfers.length > 1) {
           // 合致する ERC20 transfer が複数の場合は pattern 不一致として undefined を返す
           return undefined
+        }
+        // 合致する ERC20 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
+        if (
+          erc20Transfers.some(
+            (transfer) =>
+              transfer.token.contractAddress === considerationItem.token &&
+              transfer.value === considerationItem.amount,
+          )
+        ) {
+          mut_isSpam = true
         } else {
-          // 合致する ERC20 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
-          if (
-            erc20Transfers.some(
-              (transfer) =>
-                transfer.token.contractAddress === considerationItem.token &&
-                transfer.value === considerationItem.amount,
-            )
-          ) {
-            mut_isSpam = true
-          } else {
-            return undefined
-          }
-          break
+          return undefined
         }
+        break
       }
       case 2: {
         // ERC721
@@ -324,24 +322,24 @@ export const analyzeSeaport = async <
           // 合致する ERC721 transfer が 1 つの場合は mut_considerationTransfers に追加
           mut_considerationTransfers.push(erc721ConsiderationTransfers[0])
           break
-        } else if (erc721ConsiderationTransfers.length > 1) {
+        }
+        if (erc721ConsiderationTransfers.length > 1) {
           // 合致する ERC721 transfer が複数の場合は pattern 不一致として undefined を返す
           return undefined
+        }
+        // 合致する ERC721 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
+        if (
+          erc721Transfers.some(
+            (transfer) =>
+              transfer.token.contractAddress === considerationItem.token &&
+              transfer.tokenId === considerationItem.identifier,
+          )
+        ) {
+          mut_isSpam = true
         } else {
-          // 合致する ERC721 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
-          if (
-            erc721Transfers.some(
-              (transfer) =>
-                transfer.token.contractAddress === considerationItem.token &&
-                transfer.tokenId === considerationItem.identifier,
-            )
-          ) {
-            mut_isSpam = true
-          } else {
-            return undefined
-          }
-          break
+          return undefined
         }
+        break
       }
       case 3: {
         // ERC1155
@@ -357,24 +355,24 @@ export const analyzeSeaport = async <
           // 合致する ERC1155 transfer が 1 つの場合は mut_considerationTransfers に追加
           mut_considerationTransfers.push(erc1155ConsiderationTransfers[0])
           break
-        } else if (erc1155ConsiderationTransfers.length > 1) {
+        }
+        if (erc1155ConsiderationTransfers.length > 1) {
           // 合致する ERC1155 transfer が複数の場合は pattern 不一致として undefined を返す
           return undefined
+        }
+        // 合致する ERC1155 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
+        if (
+          erc1155Transfers.some(
+            (transfer) =>
+              transfer.token.contractAddress === considerationItem.token &&
+              transfer.id === considerationItem.identifier,
+          )
+        ) {
+          mut_isSpam = true
         } else {
-          // 合致する ERC1155 transfer がない場合、同一 token に対する別の transfer が存在すれば spam として処理・なければ pattern 不一致として undefined を返す
-          if (
-            erc1155Transfers.some(
-              (transfer) =>
-                transfer.token.contractAddress === considerationItem.token &&
-                transfer.id === considerationItem.identifier,
-            )
-          ) {
-            mut_isSpam = true
-          } else {
-            return undefined
-          }
-          break
+          return undefined
         }
+        break
       }
     }
   }
@@ -503,7 +501,8 @@ const generateNormalAction = <Price extends CryptoCurrencyPrice | undefined>(
     }
     if (transfer.from === recipient && transfer.to === recipient) {
       continue
-    } else if (transfer.from === recipient || transfer.to === recipient) {
+    }
+    if (transfer.from === recipient || transfer.to === recipient) {
       const direction = transfer.from === recipient ? 'out' : 'in'
       switch (transfer.type) {
         case 'InternalTransaction': {
@@ -566,9 +565,7 @@ const generateNormalAction = <Price extends CryptoCurrencyPrice | undefined>(
           break
         }
       }
-    } else if (transfer.type === 'InternalTransaction') {
-      continue
-    } else {
+    } else if (transfer.type !== 'InternalTransaction') {
       mut_existNoRecipientTransfer = true
       break
     }
@@ -599,7 +596,8 @@ const generateNormalAction = <Price extends CryptoCurrencyPrice | undefined>(
   ]) {
     if (transfer.from === offerer && transfer.to === offerer) {
       continue
-    } else if (transfer.from === offerer || transfer.to === offerer) {
+    }
+    if (transfer.from === offerer || transfer.to === offerer) {
       const direction = transfer.from === offerer ? 'out' : 'in'
       switch (transfer.type) {
         case 'InternalTransaction': {
@@ -662,9 +660,7 @@ const generateNormalAction = <Price extends CryptoCurrencyPrice | undefined>(
           break
         }
       }
-    } else if (transfer.type === 'InternalTransaction') {
-      continue
-    } else {
+    } else if (transfer.type !== 'InternalTransaction') {
       return undefined
     }
   }
@@ -722,7 +718,8 @@ const generateAccountActions = <Price extends CryptoCurrencyPrice | undefined>(
   ) {
     // direction: none が含まれる場合は undefined を返す
     return undefined
-  } else if (
+  }
+  if (
     transfers.every(
       (transfer) =>
         includesEvmAddressId({
@@ -754,7 +751,8 @@ const generateAccountActions = <Price extends CryptoCurrencyPrice | undefined>(
         ],
       }
     })
-  } else if (
+  }
+  if (
     transfers.every((transfer) =>
       includesEvmAddressId({
         addresses: accountAddresses,
@@ -826,7 +824,8 @@ const generateAccountActions = <Price extends CryptoCurrencyPrice | undefined>(
         ],
       },
     ]
-  } else if (
+  }
+  if (
     inTransfers.every((transfer) => transfer.asset.type === 'Nft') &&
     outTransfers.every((transfer) => transfer.asset.type === 'CryptoCurrency')
   ) {
@@ -870,7 +869,8 @@ const generateAccountActions = <Price extends CryptoCurrencyPrice | undefined>(
         }),
       },
     ]
-  } else if (
+  }
+  if (
     inTransfers.every((transfer) => transfer.asset.type === 'CryptoCurrency') &&
     outTransfers.every((transfer) => transfer.asset.type === 'Nft')
   ) {
@@ -914,37 +914,36 @@ const generateAccountActions = <Price extends CryptoCurrencyPrice | undefined>(
         }),
       },
     ]
-  } else {
-    // それ以外の場合は trade action 作成
-    return [
-      {
-        type: 'NormalAccountAction',
-        action: 'trade',
-        source,
-        evidence: 'contract',
-        timestamp: action.timestamp,
-        order: 0,
-        comment: action.comment,
-        app: action.app,
-        transfers: [
-          ...inTransfers.map((transfer) => ({
-            from: transfer.from,
-            to: transfer.to,
-            price: transfer.price,
-            asset: transfer.asset,
-            amount: transfer.amount,
-            direction: 'in' as const,
-          })),
-          ...outTransfers.map((transfer) => ({
-            from: transfer.from,
-            to: transfer.to,
-            price: transfer.price,
-            asset: transfer.asset,
-            amount: transfer.amount,
-            direction: 'out' as const,
-          })),
-        ],
-      },
-    ]
   }
+  // それ以外の場合は trade action 作成
+  return [
+    {
+      type: 'NormalAccountAction',
+      action: 'trade',
+      source,
+      evidence: 'contract',
+      timestamp: action.timestamp,
+      order: 0,
+      comment: action.comment,
+      app: action.app,
+      transfers: [
+        ...inTransfers.map((transfer) => ({
+          from: transfer.from,
+          to: transfer.to,
+          price: transfer.price,
+          asset: transfer.asset,
+          amount: transfer.amount,
+          direction: 'in' as const,
+        })),
+        ...outTransfers.map((transfer) => ({
+          from: transfer.from,
+          to: transfer.to,
+          price: transfer.price,
+          asset: transfer.asset,
+          amount: transfer.amount,
+          direction: 'out' as const,
+        })),
+      ],
+    },
+  ]
 }

package/analyzer/spam/analyze.ts

@@ -9,10 +9,10 @@ import type { TransactionDecoded } from '../../types'
 import { createEvmAddressId } from '../../utils'
 import { createEvmActionSource } from '../../utils/create'
 import {
-  parseErc1155TransferToActionTransferIn,
   parseErc20TransferToActionTransferIn,
   parseErc20TransferToActionTransferNone,
   parseErc721TransferToActionTransferIn,
+  parseErc1155TransferToActionTransferIn,
   parseInternalTransactionToActionTransferNone,
   parseTransactionValueToActionTransferNone,
 } from '../parsers/transfer'

package/analyzer/swap/analyze.ts

@@ -234,16 +234,16 @@ const generateNormalAction = <Price extends CryptoCurrencyPrice | undefined>(
     swap.transferOut.type === 'InternalTransaction'
   ) {
     return generateNormalActionAtomicArbitrage(swap, chain, timestamp)
-  } else if (
+  }
+  if (
     swap.transferIn.type === 'Erc20Transfer' &&
     swap.transferOut.type === 'Erc20Transfer' &&
     swap.transferIn.token.contractAddress ===
       swap.transferOut.token.contractAddress
   ) {
     return generateNormalActionAtomicArbitrage(swap, chain, timestamp)
-  } else {
-    return generateNormalActionTrade(swap, chain, timestamp)
   }
+  return generateNormalActionTrade(swap, chain, timestamp)
 }
 
 const generateNormalActionAtomicArbitrage = <
@@ -391,7 +391,7 @@ const createSwapFromUniv2SwapLog = <
   )
 
   // なければ undefined を返す
-  if (transferIn == undefined || transferOut === undefined) {
+  if (transferIn === undefined || transferOut === undefined) {
     return undefined
   }
 
@@ -442,7 +442,7 @@ const createSwapFromUniv3SwapLog = <
   )
 
   // なければ undefined を返す
-  if (transferIn == undefined || transferOut === undefined) {
+  if (transferIn === undefined || transferOut === undefined) {
     return undefined
   }
 
@@ -479,7 +479,7 @@ const createSwapFromTraderJoeLBPairSwapLog = <
   )
 
   // なければ undefined を返す
-  if (transferIn == undefined || transferOut === undefined) {
+  if (transferIn === undefined || transferOut === undefined) {
     return undefined
   }
 

package/analyzer/swap/traderJoeLBPairSwap.ts

@@ -1,4 +1,3 @@
-/* eslint-disable unicorn/filename-case */
 import { z } from 'zod'
 import type { DecodedLog } from '../../types'
 import { isHex, toLowerHex } from '../../types'

package/analyzer/transfer/analyze.ts

@@ -4,14 +4,8 @@ import type { Chain } from '../../chains'
 import type { TransactionDecoded } from '../../types'
 import { createEvmAddressId } from '../../utils'
 import { createEvmActionSource } from '../../utils/create'
-import {
-  parseErc1155TransferToActionTransferNone,
-  parseErc20TransferToActionTransferNone,
-  parseErc721TransferToActionTransferNone,
-  parseInternalTransactionToActionTransferNone,
-  parseTransactionValueToActionTransferNone,
-} from '../parsers/transfer'
 import type { AnalyzeParameters, AnalyzeReturnType } from '../types'
+import { createTransfersByTransaction } from '../utils/createTransfersByTransaction'
 
 export const analyzeTransfer = <Price extends CryptoCurrencyPrice | undefined>({
   chain,
@@ -54,113 +48,14 @@ const generateNormalActions = <Price extends CryptoCurrencyPrice | undefined>(
   chain: Chain,
   transaction: TransactionDecoded<Price>,
 ): NormalActionTransfer[] => {
-  const {
-    to,
-    value,
-    block,
-    internalTransactions,
-    erc20Transfers,
-    erc721Transfers,
-    erc1155Transfers,
-    app,
-  } = transaction
-  const mut_actions: NormalActionTransfer[] = []
-  if (value > 0 && to !== null) {
-    mut_actions.push({
-      type: 'NormalAction',
-      action: 'transfer',
-      evidence: 'none',
-      timestamp: Number(block.timestamp) * 1000,
-      comment: undefined,
-      app,
-      transfers: [
-        parseTransactionValueToActionTransferNone({
-          chain,
-          transaction,
-        }),
-      ],
-    })
-  }
-  for (const internalTx of internalTransactions.filter(
-    ({ value }) => value > 0,
-  )) {
-    if (internalTx.to === undefined) {
-      continue
-    }
-
-    mut_actions.push({
-      type: 'NormalAction',
-      action: 'transfer',
-      evidence: 'none',
-      timestamp: Number(block.timestamp) * 1000,
-      comment: undefined,
-      app,
-      transfers: [
-        parseInternalTransactionToActionTransferNone({
-          chain,
-          internalTransaction: internalTx,
-        }),
-      ],
-    })
-  }
-  for (const transfer of [
-    ...erc20Transfers,
-    ...erc721Transfers,
-    ...erc1155Transfers,
-  ].sort((a, b) => a.logIndex - b.logIndex)) {
-    switch (transfer.type) {
-      case 'Erc20Transfer': {
-        mut_actions.push({
-          type: 'NormalAction',
-          action: 'transfer',
-          evidence: 'none',
-          timestamp: Number(block.timestamp) * 1000,
-          comment: undefined,
-          app,
-          transfers: [
-            parseErc20TransferToActionTransferNone({
-              chainId: chain.id,
-              transfer,
-            }),
-          ],
-        })
-        break
-      }
-      case 'Erc721Transfer': {
-        mut_actions.push({
-          type: 'NormalAction',
-          action: 'transfer',
-          evidence: 'none',
-          timestamp: Number(block.timestamp) * 1000,
-          comment: undefined,
-          app,
-          transfers: [
-            parseErc721TransferToActionTransferNone({
-              chainId: chain.id,
-              transfer,
-            }),
-          ],
-        })
-        break
-      }
-      case 'Erc1155Transfer': {
-        mut_actions.push({
-          type: 'NormalAction',
-          action: 'transfer',
-          evidence: 'none',
-          timestamp: Number(block.timestamp) * 1000,
-          comment: undefined,
-          app,
-          transfers: [
-            parseErc1155TransferToActionTransferNone({
-              chainId: chain.id,
-              transfer,
-            }),
-          ],
-        })
-        break
-      }
-    }
-  }
-  return mut_actions
+  const transfers = createTransfersByTransaction(chain, transaction)
+  return transfers.map((transfer) => ({
+    type: 'NormalAction',
+    action: 'transfer',
+    evidence: 'none',
+    timestamp: Number(transaction.block.timestamp) * 1000,
+    comment: undefined,
+    app: transaction.app,
+    transfers: [transfer],
+  }))
 }