@0xtorch/evm 0.0.10 → 0.0.12

package/analyzer/axieMarketplace/analyze.ts

@@ -1,13 +1,20 @@
-import { createBigDecimal } from '@0xtorch/big-decimal'
 import type {
   AccountActionBuyNft,
   AccountActionSellNft,
   CryptoCurrencyPrice,
   NormalActionTrade,
 } from '@0xtorch/core'
-import { createEvmAccount } from '../../creates/createEvmAccount'
-import type { EvmAccount, TransactionSource } from '../../types'
 import { toLowerHex } from '../../types'
+import {
+  parseErc1155TransferToActionTransferIn,
+  parseErc1155TransferToActionTransferOut,
+  parseErc20TransferToActionTransferIn,
+  parseErc20TransferToActionTransferOut,
+  parseErc721TransferToActionTransferIn,
+  parseErc721TransferToActionTransferOut,
+  parseInternalTransactionToActionTransferIn,
+  parseInternalTransactionToActionTransferOut,
+} from '../parsers/transfer'
 import type { AnalyzeParameters, AnalyzeReturnType } from '../types'
 
 export const analyzeAxieMarketplace = <
@@ -16,7 +23,7 @@ export const analyzeAxieMarketplace = <
   chain,
   transaction,
   accountAddresses,
-}: AnalyzeParameters<Price>): Promise<AnalyzeReturnType<Price> | undefined> => {
+}: AnalyzeParameters<Price>): Promise<AnalyzeReturnType | undefined> => {
   const {
     transactionHash,
     from,
@@ -119,85 +126,43 @@ export const analyzeAxieMarketplace = <
       accountAddressSet.has(transfer.to),
     )
   ) {
-    const normalAction: NormalActionTrade<EvmAccount, Price> = {
+    const transfers = [
+      ...relatedErc721Transfers.map((transfer) =>
+        parseErc721TransferToActionTransferIn({
+          chainId: chain.id,
+          transfer,
+        }),
+      ),
+      ...relatedErc1155Transfers.map((transfer) =>
+        parseErc1155TransferToActionTransferIn({
+          chainId: chain.id,
+          transfer,
+        }),
+      ),
+      ...relatedInternalTransactions.map((internalTransaction) =>
+        parseInternalTransactionToActionTransferOut({
+          chain,
+          internalTransaction,
+        }),
+      ),
+      ...relatedErc20Transfers.map((transfer) =>
+        parseErc20TransferToActionTransferOut({
+          chainId: chain.id,
+          transfer,
+        }),
+      ),
+    ]
+    const normalAction: NormalActionTrade = {
       type: 'NormalAction',
       action: 'trade',
       evidence: 'contract',
       timestamp,
       comment: undefined,
       app,
-      transfers: [
-        ...relatedErc721Transfers.map((transfer) => ({
-          target: transfer.to,
-          direction: 'in' as const,
-          from: createEvmAccount({
-            address: transfer.from,
-            chainId: chain.id,
-          }),
-          to: createEvmAccount({
-            address: transfer.to,
-            chainId: chain.id,
-          }),
-          asset: transfer.nft,
-          amount: createBigDecimal(1n),
-          price: undefined as Price,
-        })),
-        ...relatedErc1155Transfers.map((transfer) => ({
-          target: transfer.to,
-          direction: 'in' as const,
-          from: createEvmAccount({
-            address: transfer.from,
-            chainId: chain.id,
-          }),
-          to: createEvmAccount({
-            address: transfer.to,
-            chainId: chain.id,
-          }),
-          asset: transfer.nft,
-          amount: createBigDecimal(transfer.value),
-          price: undefined as Price,
-        })),
-        ...relatedInternalTransactions.map((internalTransaction) => ({
-          target: internalTransaction.from,
-          direction: 'out' as const,
-          from: createEvmAccount({
-            address: internalTransaction.from,
-            chainId: chain.id,
-          }),
-          to: createEvmAccount({
-            address: internalTransaction.to ?? '0x',
-            chainId: chain.id,
-          }),
-          asset: chain.nativeToken.currency,
-          amount: createBigDecimal(
-            internalTransaction.value,
-            chain.nativeToken.decimals,
-          ),
-          price: nativeTokenPrice,
-        })),
-        ...relatedErc20Transfers.map((transfer) => ({
-          target: transfer.from,
-          direction: 'out' as const,
-          from: createEvmAccount({
-            address: transfer.from,
-            chainId: chain.id,
-          }),
-          to: createEvmAccount({
-            address: transfer.to,
-            chainId: chain.id,
-          }),
-          asset: transfer.token.currency,
-          amount: createBigDecimal(transfer.value, transfer.token.decimals),
-          price: transfer.price,
-        })),
-      ],
+      transfers,
     }
-    const accountAction: AccountActionBuyNft<
-      EvmAccount,
-      TransactionSource,
-      Price
-    > = {
-      type: 'AccountAction',
+    const accountAction: AccountActionBuyNft = {
+      type: 'NormalAccountAction',
       action: 'buy-nft',
       source: `evm_${chain.id}_${toLowerHex(transactionHash)}`,
       evidence: 'contract',
@@ -205,7 +170,7 @@ export const analyzeAxieMarketplace = <
       order: 0,
       comment: normalAction.comment,
       app,
-      transfers: normalAction.transfers,
+      transfers,
     }
     return Promise.resolve({
       actions: [normalAction],
@@ -228,85 +193,37 @@ export const analyzeAxieMarketplace = <
       accountAddressSet.has(transfer.from),
     )
   ) {
-    const normalAction: NormalActionTrade<EvmAccount, Price> = {
+    const transfers = [
+      ...relatedInternalTransactions.map((internalTransaction) =>
+        parseInternalTransactionToActionTransferIn({
+          chain,
+          internalTransaction,
+        }),
+      ),
+      ...relatedErc20Transfers.map((transfer) =>
+        parseErc20TransferToActionTransferIn({ chainId: chain.id, transfer }),
+      ),
+      ...relatedErc721Transfers.map((transfer) =>
+        parseErc721TransferToActionTransferOut({ chainId: chain.id, transfer }),
+      ),
+      ...relatedErc1155Transfers.map((transfer) =>
+        parseErc1155TransferToActionTransferOut({
+          chainId: chain.id,
+          transfer,
+        }),
+      ),
+    ]
+    const normalAction: NormalActionTrade = {
       type: 'NormalAction',
       action: 'trade',
       evidence: 'contract',
       timestamp,
       comment: undefined,
       app,
-      transfers: [
-        ...relatedInternalTransactions.map((internalTransaction) => ({
-          target: internalTransaction.to ?? '0x',
-          direction: 'in' as const,
-          from: createEvmAccount({
-            address: internalTransaction.from,
-            chainId: chain.id,
-          }),
-          to: createEvmAccount({
-            address: internalTransaction.to ?? '0x',
-            chainId: chain.id,
-          }),
-          asset: chain.nativeToken.currency,
-          amount: createBigDecimal(
-            internalTransaction.value,
-            chain.nativeToken.decimals,
-          ),
-          price: nativeTokenPrice,
-        })),
-        ...relatedErc20Transfers.map((transfer) => ({
-          target: transfer.to ?? '0x',
-          direction: 'in' as const,
-          from: createEvmAccount({
-            address: transfer.from,
-            chainId: chain.id,
-          }),
-          to: createEvmAccount({
-            address: transfer.to,
-            chainId: chain.id,
-          }),
-          asset: transfer.token.currency,
-          amount: createBigDecimal(transfer.value, transfer.token.decimals),
-          price: transfer.price,
-        })),
-        ...relatedErc721Transfers.map((transfer) => ({
-          target: transfer.from,
-          direction: 'out' as const,
-          from: createEvmAccount({
-            address: transfer.from,
-            chainId: chain.id,
-          }),
-          to: createEvmAccount({
-            address: transfer.to,
-            chainId: chain.id,
-          }),
-          asset: transfer.nft,
-          amount: createBigDecimal(1n),
-          price: undefined as Price,
-        })),
-        ...relatedErc1155Transfers.map((transfer) => ({
-          target: transfer.from,
-          direction: 'out' as const,
-          from: createEvmAccount({
-            address: transfer.from,
-            chainId: chain.id,
-          }),
-          to: createEvmAccount({
-            address: transfer.to,
-            chainId: chain.id,
-          }),
-          asset: transfer.nft,
-          amount: createBigDecimal(transfer.value),
-          price: undefined as Price,
-        })),
-      ],
+      transfers,
     }
-    const accountAction: AccountActionSellNft<
-      EvmAccount,
-      TransactionSource,
-      Price
-    > = {
-      type: 'AccountAction',
+    const accountAction: AccountActionSellNft = {
+      type: 'NormalAccountAction',
       action: 'sell-nft',
       source: `evm_${chain.id}_${toLowerHex(transactionHash)}`,
       evidence: 'contract',
@@ -314,7 +231,7 @@ export const analyzeAxieMarketplace = <
       order: 0,
       comment: normalAction.comment,
       app,
-      transfers: normalAction.transfers,
+      transfers,
     }
     return Promise.resolve({
       actions: [normalAction],

package/analyzer/gasFee/analyze.ts

@@ -1,13 +1,13 @@
-import { createBigDecimal } from '@0xtorch/big-decimal'
 import type {
   CryptoCurrencyPrice,
   NormalActionTransactionFee,
 } 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 { parseTransactionGasToActionTransferOut } from '../parsers/transfer'
 import type { AnalyzeParameters, AnalyzeReturnType } from '../types'
 
 // [MAYBE] zkSyncEra は gasRefund の仕組みがあるので、最初の gas から refund された分を引いた値を使う
@@ -15,38 +15,39 @@ export const analyzeGasFee = <Price extends CryptoCurrencyPrice | undefined>({
   chain,
   transaction,
   accountAddresses,
-}: AnalyzeParameters<Price>): Promise<AnalyzeReturnType<Price> | undefined> => {
+}: AnalyzeParameters<Price>): Promise<AnalyzeReturnType | undefined> => {
   // transaction gas fee を計算して、 normalAction 作成
   const normalAction = generateNormalAction(transaction, chain)
 
   // transaction.from が accountAddresses に含まれている場合は、 accountAction 作成
-  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,
   })
 }
 
 const generateNormalAction = <Price extends CryptoCurrencyPrice | undefined>(
-  {
-    gasUsed,
-    effectiveGasPrice,
-    block,
-    from,
-    nativeTokenPrice,
-  }: TransactionDecoded<Price>,
+  transaction: TransactionDecoded<Price>,
   chain: Chain,
-): NormalActionTransactionFee<EvmAccount | undefined, Price> => {
-  const gasFee = createBigDecimal(
-    gasUsed * effectiveGasPrice,
-    chain.nativeToken.decimals,
-  )
-  const lowerFrom = toLowerHex(from)
+): NormalActionTransactionFee => {
+  const { block } = transaction
   return {
     type: 'NormalAction',
     action: 'transaction-fee',
@@ -55,18 +56,10 @@ const generateNormalAction = <Price extends CryptoCurrencyPrice | undefined>(
     comment: undefined,
     app: undefined,
     transfers: [
-      {
-        target: lowerFrom,
-        direction: 'out',
-        from: createEvmAccount({
-          address: lowerFrom,
-          chainId: chain.id,
-        }),
-        to: undefined,
-        asset: chain.nativeToken.currency,
-        amount: gasFee,
-        price: nativeTokenPrice,
-      },
+      parseTransactionGasToActionTransferOut({
+        chain,
+        transaction,
+      }),
     ],
   }
 }

package/analyzer/index.ts

@@ -2,7 +2,7 @@ export { analyze } from './analyze'
 export { analyzer } from './analyzer'
 export { analyzeAxieMarketplace } from './axieMarketplace'
 export { analyzeGasFee } from './gasFee'
-export { createAnalyzeByJsonRule } from './json'
+export { createAnalyzeByJsonRule, evmAnalyzersSchema } from './json'
 export { analyzeSeaport } from './seaport'
 export { analyzeSwap } from './swap'
 export { analyzeTransfer } from './transfer'

package/analyzer/json/analyze.ts

@@ -1,15 +1,11 @@
-import type {
-  ActionType,
-  CryptoCurrencyPrice,
-  NormalAction,
-} from '@0xtorch/core'
-import type { EvmAccount, TransactionDecoded } from '../../types'
+import type { CryptoCurrencyPrice } from '@0xtorch/core'
+import { parseNormalActionToAccountActions } from '@0xtorch/core'
+import type { TransactionDecoded } from '../../types'
 import { toLowerHex } from '../../types'
-import { createAccountActionByAction } from '../createAccountActionByAction'
+import { createEvmAddressId } from '../../utils'
+import { createEvmActionSource } from '../../utils/create'
 import type { AnalyzeParameters, AnalyzeReturnType } from '../types'
-import { generateActionsByAnyLogGenerator } from './generatorAnyLog'
-import { generateActionsByAnyTokenTransferGenerator } from './generatorAnyTokenTransfer'
-import { generateActionBySpecificTokenTransferGenerator } from './generatorSpecificTokenTransfer'
+import { generateActionsByGenerator } from './generator'
 import type { AnalyzeRule, ParameterBase, ParameterIndex } from './types'
 
 export const createAnalyzeByJsonRule =
@@ -18,9 +14,7 @@ export const createAnalyzeByJsonRule =
     chain,
     transaction,
     accountAddresses,
-  }: AnalyzeParameters<Price>): Promise<
-    AnalyzeReturnType<Price> | undefined
-  > => {
+  }: AnalyzeParameters<Price>): Promise<AnalyzeReturnType | undefined> => {
     const {
       chainId,
       from,
@@ -264,51 +258,36 @@ export const createAnalyzeByJsonRule =
     }
 
     // rule に基づいて action を生成する
-    const mut_actions: NormalAction<ActionType, EvmAccount, Price>[] = []
-    for (const generator of generators) {
-      switch (generator.type) {
-        case 'any-token-transfer': {
-          const actions = generateActionsByAnyTokenTransferGenerator(
-            generator,
-            transaction,
-          )
-          mut_actions.push(...actions)
-          break
-        }
-        case 'any-log': {
-          const actions = generateActionsByAnyLogGenerator(
-            generator,
-            chain,
-            transaction,
-          )
-          mut_actions.push(...actions)
-          break
-        }
-        case 'specific-token-transfer': {
-          const action = generateActionBySpecificTokenTransferGenerator(
-            generator,
-            chain,
-            transaction,
-          )
-          mut_actions.push(action)
-          break
-        }
-      }
-    }
+    const actions = generators.flatMap((generator) =>
+      generateActionsByGenerator({
+        generator,
+        transaction,
+        chain,
+      }),
+    )
 
     // actions から account actions の作成
-    const optionalAccountActions = mut_actions.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 = actions.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: mut_actions,
+      actions,
       accountActions,
     })
   }

package/analyzer/json/components/comment.ts

@@ -0,0 +1,62 @@
+import { createBigDecimal, toStringBigDecimal } from '@0xtorch/big-decimal'
+import type { CryptoCurrencyPrice } from '@0xtorch/core'
+import type { Chain } from '../../../chains'
+import type { TransactionDecoded } from '../../../types'
+import { toLowerHex } from '../../../types'
+import type { CommentComponent, Target } from '../types'
+import { getLogArgumentComponent } from './logArgument'
+
+type CreateCommentByCommentComponentParameters<
+  Price extends CryptoCurrencyPrice | undefined,
+> = {
+  readonly component: CommentComponent
+  readonly transaction: TransactionDecoded<Price>
+  readonly chain: Chain
+} & Target<Price>
+
+export const createCommentByCommentComponent = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  component,
+  transaction,
+  chain,
+  targetsLog = [],
+}: CreateCommentByCommentComponentParameters<Price>): string => {
+  if (typeof component === 'string') {
+    return component
+  } else if (typeof component === 'number') {
+    return component.toString()
+  } else if (typeof component === 'bigint') {
+    return component.toString()
+  }
+  switch (component.type) {
+    case 'from': {
+      const address = toLowerHex(transaction.from)
+      return component.minify === true
+        ? `${address.slice(0, 6)}...${address.slice(-4)}`
+        : address
+    }
+    case 'to': {
+      if (transaction.to === null) {
+        return 'null'
+      }
+      const address = toLowerHex(transaction.to)
+      return component.minify === true
+        ? `${address.slice(0, 6)}...${address.slice(-4)}`
+        : address
+    }
+    case 'value': {
+      return toStringBigDecimal(
+        createBigDecimal(transaction.value, chain.nativeToken.decimals),
+      )
+    }
+    case 'log': {
+      const arguments_ = getLogArgumentComponent({
+        component,
+        transaction,
+        targetsLog,
+      })
+      return arguments_.map(String).join('')
+    }
+  }
+}

package/analyzer/json/components/erc1155.ts

@@ -0,0 +1,132 @@
+import type { CryptoCurrencyPrice } from '@0xtorch/core'
+import type { Erc1155Transfer, TransactionDecoded } from '../../../types'
+import {
+  getAddressByAddressCondition,
+  getValueByValueCondition,
+} from '../condition'
+import type { Erc1155Component, Target } from '../types'
+
+type GetErc1155ComponentParameters<
+  Price extends CryptoCurrencyPrice | undefined,
+> = {
+  readonly component: Erc1155Component
+  readonly transaction: TransactionDecoded<Price>
+} & Target<Price>
+
+export const getErc1155Component = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  component,
+  transaction,
+  targetsErc20 = [],
+  targetsErc721 = [],
+  targetsErc1155 = [],
+  targetsInternal = [],
+  targetsLog = [],
+}: GetErc1155ComponentParameters<Price>): readonly Erc1155Transfer[] => {
+  const transfers =
+    component.target === true ? targetsErc1155 : transaction.erc1155Transfers
+  const filteredTransfers = transfers.filter((transfer) =>
+    isMatchErc1155Component({
+      component,
+      transfer,
+      transaction,
+      targetsErc20,
+      targetsErc721,
+      targetsErc1155,
+      targetsInternal,
+      targetsLog,
+    }),
+  )
+  if (component.index === 'any') {
+    return filteredTransfers
+  } else {
+    if (filteredTransfers.length <= component.index) {
+      throw new Error('filteredTransfers.length <= component.index')
+    }
+    return [filteredTransfers[component.index]]
+  }
+}
+
+type IsMatchErc1155ComponentParameters<
+  Price extends CryptoCurrencyPrice | undefined,
+> = {
+  readonly component: Erc1155Component
+  readonly transfer: Erc1155Transfer
+  readonly transaction: TransactionDecoded<Price>
+} & Target<Price>
+
+export const isMatchErc1155Component = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  component,
+  transfer,
+  transaction,
+  targetsErc20 = [],
+  targetsErc721 = [],
+  targetsErc1155 = [],
+  targetsInternal = [],
+  targetsLog = [],
+}: IsMatchErc1155ComponentParameters<Price>): boolean => {
+  if (component.from !== undefined) {
+    const value = getAddressByAddressCondition({
+      condition: component.from,
+      transaction,
+      targetsErc20,
+      targetsErc721,
+      targetsErc1155,
+      targetsInternal,
+      targetsLog,
+    })
+    if (value !== transfer.from) {
+      return false
+    }
+  }
+  if (component.to !== undefined) {
+    const value = getAddressByAddressCondition({
+      condition: component.to,
+      transaction,
+      targetsErc20,
+      targetsErc721,
+      targetsErc1155,
+      targetsInternal,
+      targetsLog,
+    })
+    if (value !== transfer.to) {
+      return false
+    }
+  }
+  if (component.token !== undefined) {
+    const value = getAddressByAddressCondition({
+      condition: component.token,
+      transaction,
+      targetsErc20,
+      targetsErc721,
+      targetsErc1155,
+      targetsInternal,
+      targetsLog,
+    })
+    if (value !== transfer.token.contractAddress) {
+      return false
+    }
+  }
+  if (component.tokenId !== undefined && component.tokenId !== transfer.id) {
+    return false
+  }
+  if (component.value !== undefined) {
+    const value = getValueByValueCondition({
+      condition: component.value,
+      transaction,
+      targetsErc20,
+      targetsErc1155,
+      targetsInternal,
+      targetsLog,
+    })
+    if (value === 'plus' && transfer.value <= 0) {
+      return false
+    } else if (value !== 'plus' && value !== transfer.value) {
+      return false
+    }
+  }
+  return true
+}