@0xtorch/evm 0.0.74 → 0.0.76

package/logic/analyzeTransaction/createActions/utils/createTokenTransfers.ts

@@ -1,6 +1,7 @@
 import { createBigDecimal } from '@0xtorch/big-decimal'
 import type { Transfer } from '@0xtorch/core'
 import type { Chain } from '../../../../chain'
+import type { LowerHex } from '../../../../types'
 import type { TransactionDecoded } from '../../../../types/transactionDecoded'
 import { createEvmAddressId } from '../../../../utils'
 import { createDirection } from './createDirection'
@@ -8,37 +9,43 @@ import { createDirection } from './createDirection'
 type CreateTokenTransfersParameters = {
   chain: Chain
   transaction: TransactionDecoded
-  accountIds: Set<string>
+  relatedAddresses: Set<LowerHex>
 }
 
 export const createTokenTransfers = ({
   chain,
   transaction,
-  accountIds,
+  relatedAddresses,
 }: CreateTokenTransfersParameters): readonly Transfer[] => {
   const transfers: Transfer[] = []
 
   // value
   if (transaction.value > 0n) {
-    const from = createEvmAddressId({
-      chainId: transaction.chainId,
-      address: transaction.from.address,
-    })
-    const to =
-      transaction.to === undefined
-        ? undefined
-        : createEvmAddressId({
-            chainId: transaction.chainId,
-            address: transaction.to.address,
-          })
-    if (accountIds.has(from) || (to !== undefined && accountIds.has(to))) {
+    if (
+      relatedAddresses.has(transaction.from.address) ||
+      (transaction.to !== undefined &&
+        relatedAddresses.has(transaction.to.address))
+    ) {
       transfers.push({
-        from,
-        to,
+        from: createEvmAddressId({
+          chainId: transaction.chainId,
+          address: transaction.from.address,
+        }),
+        to:
+          transaction.to === undefined
+            ? undefined
+            : createEvmAddressId({
+                chainId: transaction.chainId,
+                address: transaction.to.address,
+              }),
         price: undefined,
         asset: chain.nativeToken.currency,
         amount: createBigDecimal(transaction.value, chain.nativeToken.decimals),
-        direction: createDirection({ from, to, accountIds }),
+        direction: createDirection({
+          from: transaction.from.address,
+          to: transaction.to?.address,
+          relatedAddresses,
+        }),
       })
     }
   }
@@ -48,30 +55,36 @@ export const createTokenTransfers = ({
     if (internalTransaction.value <= 0n) {
       continue
     }
-    const from = createEvmAddressId({
-      chainId: transaction.chainId,
-      address: internalTransaction.from,
-    })
-    const to =
-      internalTransaction.to === undefined
-        ? undefined
-        : createEvmAddressId({
-            chainId: transaction.chainId,
-            address: internalTransaction.to,
-          })
-    if (!accountIds.has(from) && (to === undefined || !accountIds.has(to))) {
+    if (
+      !relatedAddresses.has(internalTransaction.from) &&
+      (internalTransaction.to === undefined ||
+        !relatedAddresses.has(internalTransaction.to))
+    ) {
       continue
     }
     transfers.push({
-      from,
-      to,
+      from: createEvmAddressId({
+        chainId: transaction.chainId,
+        address: internalTransaction.from,
+      }),
+      to:
+        internalTransaction.to === undefined
+          ? undefined
+          : createEvmAddressId({
+              chainId: transaction.chainId,
+              address: internalTransaction.to,
+            }),
       price: undefined,
       asset: chain.nativeToken.currency,
       amount: createBigDecimal(
         internalTransaction.value,
         chain.nativeToken.decimals,
       ),
-      direction: createDirection({ from, to, accountIds }),
+      direction: createDirection({
+        from: internalTransaction.from,
+        to: internalTransaction.to,
+        relatedAddresses,
+      }),
     })
   }
 
@@ -80,50 +93,60 @@ export const createTokenTransfers = ({
     if (erc20Transfer.value === 0n) {
       continue
     }
-    const from = createEvmAddressId({
-      chainId: transaction.chainId,
-      address: erc20Transfer.from,
-    })
-    const to = createEvmAddressId({
-      chainId: transaction.chainId,
-      address: erc20Transfer.to,
-    })
-    if (!accountIds.has(from) && !accountIds.has(to)) {
+    if (
+      !relatedAddresses.has(erc20Transfer.from) &&
+      !relatedAddresses.has(erc20Transfer.to)
+    ) {
       continue
     }
     transfers.push({
-      from,
-      to,
+      from: createEvmAddressId({
+        chainId: transaction.chainId,
+        address: erc20Transfer.from,
+      }),
+      to: createEvmAddressId({
+        chainId: transaction.chainId,
+        address: erc20Transfer.to,
+      }),
       price: undefined,
       asset: erc20Transfer.token.currency,
       amount: createBigDecimal(
         erc20Transfer.value,
         erc20Transfer.token.decimals,
       ),
-      direction: createDirection({ from, to, accountIds }),
+      direction: createDirection({
+        from: erc20Transfer.from,
+        to: erc20Transfer.to,
+        relatedAddresses,
+      }),
     })
   }
 
   // erc721 transfers
   for (const erc721Transfer of transaction.erc721Transfers) {
-    const from = createEvmAddressId({
-      chainId: transaction.chainId,
-      address: erc721Transfer.from,
-    })
-    const to = createEvmAddressId({
-      chainId: transaction.chainId,
-      address: erc721Transfer.to,
-    })
-    if (!accountIds.has(from) && !accountIds.has(to)) {
+    if (
+      !relatedAddresses.has(erc721Transfer.from) &&
+      !relatedAddresses.has(erc721Transfer.to)
+    ) {
       continue
     }
     transfers.push({
-      from,
-      to,
+      from: createEvmAddressId({
+        chainId: transaction.chainId,
+        address: erc721Transfer.from,
+      }),
+      to: createEvmAddressId({
+        chainId: transaction.chainId,
+        address: erc721Transfer.to,
+      }),
       price: undefined,
       asset: erc721Transfer.token,
       amount: createBigDecimal(1n),
-      direction: createDirection({ from, to, accountIds }),
+      direction: createDirection({
+        from: erc721Transfer.from,
+        to: erc721Transfer.to,
+        relatedAddresses,
+      }),
     })
   }
 
@@ -132,24 +155,29 @@ export const createTokenTransfers = ({
     if (erc1155Transfer.value === 0n) {
       continue
     }
-    const from = createEvmAddressId({
-      chainId: transaction.chainId,
-      address: erc1155Transfer.from,
-    })
-    const to = createEvmAddressId({
-      chainId: transaction.chainId,
-      address: erc1155Transfer.to,
-    })
-    if (!accountIds.has(from) && !accountIds.has(to)) {
+    if (
+      !relatedAddresses.has(erc1155Transfer.from) &&
+      !relatedAddresses.has(erc1155Transfer.to)
+    ) {
       continue
     }
     transfers.push({
-      from,
-      to,
+      from: createEvmAddressId({
+        chainId: transaction.chainId,
+        address: erc1155Transfer.from,
+      }),
+      to: createEvmAddressId({
+        chainId: transaction.chainId,
+        address: erc1155Transfer.to,
+      }),
       price: undefined,
       asset: erc1155Transfer.token,
       amount: createBigDecimal(erc1155Transfer.value),
-      direction: createDirection({ from, to, accountIds }),
+      direction: createDirection({
+        from: erc1155Transfer.from,
+        to: erc1155Transfer.to,
+        relatedAddresses,
+      }),
     })
   }
 

package/logic/analyzeTransaction/decodeTransaction/decodeLog.ts

@@ -92,10 +92,13 @@ const decodeInputByEventAbi = (log: Log, abiText: string): Log | undefined => {
   }
 }
 
-const createLogArgs = (args: Record<string, unknown>, abiItem: AbiEventType) =>
-  abiItem.inputs.map(({ indexed, name, type }) => ({
+const createLogArgs = (
+  args: Record<string, unknown> | unknown[],
+  abiItem: AbiEventType,
+) =>
+  abiItem.inputs.map(({ indexed, name, type }, index) => ({
     indexed: indexed ?? false,
     name: name ?? '',
     type: type,
-    value: args[name ?? ''],
+    value: Array.isArray(args) ? args[index] : args[name ?? ''],
   }))

package/logic/analyzeTransaction/getDataFromDatasource.ts

@@ -3,36 +3,32 @@ import type { Erc20Token, LowerHex } from '../../types'
 import type { EvmAddress } from '../../types/address'
 import type { AnalyzeDataSource } from '../../types/analyzeDataSource'
 import type { TransactionDetail } from '../../types/transactionDetail'
-import {
-  createErc721NftId,
-  createErc1155NftId,
-  createEvmAddressId,
-} from '../../utils'
+import { createErc721NftId, createErc1155NftId } from '../../utils'
+import type { JsonAnalyzer } from './createActions/json/type'
 
 type GetDataFromDatasourceParameters = {
-  transaction: TransactionDetail
-  datasource: AnalyzeDataSource
-  accountIds: Set<string>
+  readonly transaction: TransactionDetail
+  readonly datasource: AnalyzeDataSource
+  readonly relatedAddresses: Set<LowerHex>
 }
 
 type GetDataFromDatasourceReturnTypes = {
-  addresses: readonly EvmAddress[]
-  erc20Tokens: readonly Erc20Token[]
-  eventAbis: readonly {
+  readonly addresses: readonly EvmAddress[]
+  readonly erc20Tokens: readonly Erc20Token[]
+  readonly eventAbis: readonly {
     signature: LowerHex
     indexedCount: number
     abi: string
   }[]
-  functionAbis: readonly string[]
-  // TODO
-  jsonAnalyzers: readonly unknown[]
-  nfts: readonly Nft[]
+  readonly functionAbis: readonly string[]
+  readonly jsonAnalyzers: readonly JsonAnalyzer[]
+  readonly nfts: readonly Nft[]
 }
 
 export const getDataFromDatasource = async ({
   transaction,
   datasource,
-  accountIds,
+  relatedAddresses,
 }: GetDataFromDatasourceParameters): Promise<GetDataFromDatasourceReturnTypes> => {
   // Fetch data from datasource
   const erc20TransferAddresses = new Set(
@@ -42,12 +38,7 @@ export const getDataFromDatasource = async ({
     ...transaction.erc721Transfers
       .filter(
         ({ from, to }) =>
-          accountIds.has(
-            createEvmAddressId({ chainId: transaction.chainId, address: from }),
-          ) ||
-          accountIds.has(
-            createEvmAddressId({ chainId: transaction.chainId, address: to }),
-          ),
+          relatedAddresses.has(from) || relatedAddresses.has(to),
       )
       .map(({ address, tokenId }) =>
         createErc721NftId({ chainId: transaction.chainId, address, tokenId }),
@@ -55,12 +46,7 @@ export const getDataFromDatasource = async ({
     ...transaction.erc1155Transfers
       .filter(
         ({ from, to }) =>
-          accountIds.has(
-            createEvmAddressId({ chainId: transaction.chainId, address: from }),
-          ) ||
-          accountIds.has(
-            createEvmAddressId({ chainId: transaction.chainId, address: to }),
-          ),
+          relatedAddresses.has(from) || relatedAddresses.has(to),
       )
       .map(({ address, tokenId }) =>
         createErc1155NftId({ chainId: transaction.chainId, address, tokenId }),

package/logic/analyzeTransaction/index.ts

@@ -1,5 +1,6 @@
 import type { Action } from '@0xtorch/core'
 import type { Chain } from '../../chain'
+import type { LowerHex } from '../../types'
 import type { AnalyzeDataSource } from '../../types/analyzeDataSource'
 import type { TransactionDecoded } from '../../types/transactionDecoded'
 import type { TransactionDetail } from '../../types/transactionDetail'
@@ -8,24 +9,24 @@ import { decodeTransaction } from './decodeTransaction'
 import { getDataFromDatasource } from './getDataFromDatasource'
 
 type AnalyzeTransactionParameters = {
-  chain: Chain
-  transaction: TransactionDetail
-  datasource: AnalyzeDataSource
-  accountIds: string[]
+  readonly chain: Chain
+  readonly transaction: TransactionDetail
+  readonly datasource: AnalyzeDataSource
+  readonly relatedAddresses: readonly LowerHex[]
 }
 
 type AnalyzeTransactionReturnTypes = {
-  transaction: TransactionDecoded
-  actions: readonly Action[]
+  readonly transaction: TransactionDecoded
+  readonly actions: readonly Action[]
 }
 
 export const analyzeTransaction = async ({
   chain,
   transaction,
   datasource,
-  accountIds,
+  relatedAddresses,
 }: AnalyzeTransactionParameters): Promise<AnalyzeTransactionReturnTypes> => {
-  const accountIdSet = new Set(accountIds)
+  const addressSet = new Set(relatedAddresses)
   const {
     addresses,
     erc20Tokens,
@@ -36,7 +37,7 @@ export const analyzeTransaction = async ({
   } = await getDataFromDatasource({
     transaction,
     datasource,
-    accountIds: accountIdSet,
+    relatedAddresses: addressSet,
   })
 
   const transactionDecoded = decodeTransaction({
@@ -51,7 +52,7 @@ export const analyzeTransaction = async ({
   const actions = createActions({
     chain,
     transaction: transactionDecoded,
-    accountIds: accountIdSet,
+    relatedAddresses: addressSet,
     jsonAnalyzers,
   })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xtorch/evm",
-  "version": "0.0.74",
+  "version": "0.0.76",
   "description": "Cryptorch EVM extension",
   "keywords": [
     "cryptorch",
@@ -38,7 +38,7 @@
   ],
   "dependencies": {
     "@0xtorch/big-decimal": "^0.0.10",
-    "@0xtorch/core": "^0.0.44",
+    "@0xtorch/core": "^0.0.46",
     "abitype": "^1.0.6",
     "viem": "^2.21.7",
     "zod": "^3.23.8"

package/types/analyzeDataSource.ts

@@ -1,4 +1,5 @@
 import type { Nft } from '@0xtorch/core'
+import type { JsonAnalyzer } from '../logic/analyzeTransaction/createActions/json/type'
 import type { EvmAddress } from './address'
 import type { Erc20Token } from './erc20'
 import type { LowerHex } from './hex'
@@ -30,10 +31,9 @@ type GetFunctionAbi = (parameters: {
   functionId: LowerHex
 }) => Promise<string[]>
 
-// TODO JSON Analyzer の型・schema を改めて定義して、それを使う
 type GetJsonAnalyzer = (parameters: {
   functionId: LowerHex
-}) => Promise<{ functionId: string }[]>
+}) => Promise<JsonAnalyzer[]>
 
 type GetNfts = (parameters: {
   // TODO EVM NFT ID の専用型にした方が良さそう