@0xtorch/evm 0.0.1

package/src/decoder/decode.ts

@@ -0,0 +1,716 @@
+import type { Config } from '@0xtorch/core'
+import { rest } from '@0xtorch/core'
+import type { Log } from 'viem'
+import {
+  decodeFunctionData,
+  getAbiItem,
+  parseEventLogs,
+  zeroAddress,
+} from 'viem'
+import { z } from 'zod'
+import { erc1155Abi, erc20Abi, erc721Abi, wethAbi } from '../abis'
+import type { Chain } from '../chains'
+import type {
+  Erc1155Transfer,
+  Erc20Token,
+  Erc20Transfer,
+  Erc721Token,
+  Erc721Transfer,
+  Hex,
+  InputData,
+  LogData,
+  LowerHex,
+  TransactionDecoded,
+} from '../types'
+import { parsedLogSchema, toLowerHex } from '../types'
+import { checkTimeout } from '../utils'
+import { parseErc1155TransferSingleLogs } from './parseErc1155TransferSingleLogs'
+import { parseErc20TransferLogs } from './parseErc20TransferLogs'
+import { parseErc721TransferLogs } from './parseErc721TransferLogs'
+import type { Decode } from './types'
+
+export const decode: Decode = async (
+  { chain, transactions },
+  config?: Config,
+) => {
+  const timeoutTimestamp =
+    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
+
+  // transactions の erc20,721,1155 transfer 生成
+  const txsTransfers = transactions.map(({ logs }) =>
+    getErcTransfers(chain, logs),
+  )
+
+  // erc20 token 情報を取得する
+  const erc20TokenAddresses = [
+    ...new Set(
+      txsTransfers.flatMap(({ erc20Transfers }) =>
+        erc20Transfers.map(({ contractAddress }) => contractAddress),
+      ),
+    ),
+  ]
+  const coins =
+    erc20TokenAddresses.length > 0
+      ? await getCoingeckoCoinsList({
+          logger: config?.logger,
+          timeout: timeoutTimestamp - Date.now(),
+        })
+      : []
+  const timeoutForGetErc20Tokens = timeoutTimestamp - Date.now()
+  const erc20Tokens = await Promise.all(
+    erc20TokenAddresses.map((address) =>
+      getErc20Token(chain, address, coins, {
+        timeout: timeoutForGetErc20Tokens,
+        logger: config?.logger,
+      }),
+    ),
+  )
+
+  // erc721 token 情報を取得する
+  const erc721TokenAddresses = [
+    ...new Set(
+      txsTransfers.flatMap(({ erc721Transfers }) =>
+        erc721Transfers.map(({ contractAddress }) => contractAddress),
+      ),
+    ),
+  ]
+  const timeoutForGetErc721Tokens = timeoutTimestamp - Date.now()
+  const erc721Tokens = await Promise.all(
+    erc721TokenAddresses.map((address) =>
+      getErc721Token(chain, address, {
+        timeout: timeoutForGetErc721Tokens,
+        logger: config?.logger,
+      }),
+    ),
+  )
+
+  // transactions から contract address を抽出
+  const addresses = [
+    ...new Set(
+      transactions.flatMap(({ to, logs }) => [
+        ...(to === null ? [] : [toLowerHex(to)]),
+        ...logs.map(({ address }) => toLowerHex(address)),
+      ]),
+    ),
+  ]
+
+  // contract address から abi を取得
+  const contracts = await getContracts(chain, addresses, {
+    timeout: timeoutTimestamp - Date.now(),
+    logger: config?.logger,
+  })
+
+  const transactionDecodeds = transactions.map(
+    (transaction, index): TransactionDecoded<undefined> => {
+      const { to, input, logs } = transaction
+      const { erc20Transfers, erc721Transfers, erc1155Transfers } =
+        txsTransfers[index]
+      const inputData =
+        to === null
+          ? undefined
+          : {
+              address: to,
+              data: input,
+            }
+      const decodedInput =
+        inputData === undefined
+          ? undefined
+          : decodeInput(
+              inputData,
+              contracts[addresses.indexOf(toLowerHex(inputData.address))],
+            )
+      return {
+        ...transaction,
+        function:
+          decodedInput?.type === 'decoded' ? decodedInput.function : undefined,
+        erc20Transfers: erc20Transfers
+          .filter((transfer) =>
+            erc20Tokens.some(
+              (token) => token?.contractAddress === transfer.contractAddress,
+            ),
+          )
+          .map((transfer) => ({
+            type: transfer.type,
+            logIndex: transfer.logIndex,
+            token: erc20Tokens.find(
+              (token) => token?.contractAddress === transfer.contractAddress,
+            )!,
+            from: transfer.from,
+            to: transfer.to,
+            value: transfer.value,
+            price: undefined,
+          })),
+        erc721Transfers: erc721Transfers
+          .filter((transfer) =>
+            erc721Tokens.some(
+              (token) => token?.contractAddress === transfer.contractAddress,
+            ),
+          )
+          .map((transfer) => ({
+            type: transfer.type,
+            logIndex: transfer.logIndex,
+            token: erc721Tokens.find(
+              (token) => token?.contractAddress === transfer.contractAddress,
+            )!,
+            from: transfer.from,
+            to: transfer.to,
+            tokenId: transfer.tokenId,
+            nft: transfer.nft,
+          })),
+        erc1155Transfers,
+        logs: logs.map((log) =>
+          decodeLog(log, contracts[addresses.indexOf(toLowerHex(log.address))]),
+        ),
+        app: undefined,
+        nativeTokenPrice: undefined,
+      }
+    },
+  )
+
+  return {
+    transactions: transactionDecodeds,
+  }
+}
+
+type ContractByExplorer =
+  | {
+      readonly name: string
+      readonly abi: unknown[]
+    }
+  | undefined
+
+const getContracts = async (
+  chain: Chain,
+  addresses: readonly LowerHex[],
+  config?: Config,
+): Promise<readonly ContractByExplorer[]> => {
+  const timeoutTimestamp =
+    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
+
+  const mut_contracts: ContractByExplorer[] = []
+  for (const address of addresses) {
+    const contract = await chain.explorer.getContract(address, config?.logger)
+    checkTimeout(timeoutTimestamp)
+    if (contract === undefined) {
+      mut_contracts.push(undefined)
+      continue
+    }
+    try {
+      const abi = z.array(z.unknown()).parse(JSON.parse(contract.abi))
+      mut_contracts.push({
+        name: contract.name,
+        abi,
+      })
+    } catch (error) {
+      console.debug(error)
+      mut_contracts.push(undefined)
+    }
+  }
+  return mut_contracts
+}
+
+const getErcTransfers = (
+  chain: Chain,
+  logs: readonly Log<bigint, number, false>[],
+): {
+  readonly erc20Transfers: readonly (Omit<Erc20Transfer, 'token'> & {
+    readonly contractAddress: LowerHex
+  })[]
+  readonly erc721Transfers: readonly (Omit<Erc721Transfer, 'token'> & {
+    readonly contractAddress: LowerHex
+  })[]
+  readonly erc1155Transfers: readonly Erc1155Transfer[]
+} => {
+  const erc20Logs = parseErc20TransferLogs(logs)
+  const erc721Logs = parseErc721TransferLogs(chain.id, logs)
+  const erc1155SingleLogs = parseErc1155TransferSingleLogs(chain.id, logs)
+  const transferBatchSignature =
+    '0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb'
+  const erc1155BatchLogs = parseEventLogs({
+    abi: erc1155Abi,
+    logs: logs.filter((log) => log.topics[0] === transferBatchSignature),
+    eventName: ['TransferBatch'],
+  })
+  // wrapped token の deposit , withdraw を ERC20 transfer として処理できるようにする
+  const wrappedLogs = parseEventLogs({
+    abi: wethAbi,
+    logs: logs.filter((log) => isWrappedTokenLog(chain, log)),
+    eventName: ['Deposit', 'Withdrawal'],
+  })
+  return {
+    erc20Transfers: [
+      ...erc20Logs,
+      ...wrappedLogs.map((log) =>
+        log.eventName === 'Deposit'
+          ? {
+              type: 'Erc20Transfer' as const,
+              logIndex: log.logIndex,
+              contractAddress: toLowerHex(log.address),
+              from: zeroAddress,
+              to: toLowerHex(log.args.dst),
+              value: log.args.wad,
+              price: undefined,
+            }
+          : {
+              type: 'Erc20Transfer' as const,
+              logIndex: log.logIndex,
+              contractAddress: toLowerHex(log.address),
+              from: toLowerHex(log.args.src),
+              to: zeroAddress,
+              value: log.args.wad,
+              price: undefined,
+            },
+      ),
+    ].sort((a, b) => a.logIndex - b.logIndex),
+    erc721Transfers: erc721Logs,
+    erc1155Transfers: [
+      ...erc1155SingleLogs,
+      ...erc1155BatchLogs.flatMap((log) =>
+        log.args.ids.map(
+          (id, index): Erc1155Transfer => ({
+            type: 'Erc1155Transfer',
+            logIndex: log.logIndex,
+            token: {
+              contractAddress: toLowerHex(log.address),
+            },
+            from: toLowerHex(log.args.from),
+            to: toLowerHex(log.args.to),
+            id: id,
+            value: log.args.values[index],
+            nft: {
+              type: 'Nft',
+              id: `evm_${chain.id}_${toLowerHex(log.address)}_${id.toString()}`,
+            },
+          }),
+        ),
+      ),
+    ],
+  }
+}
+
+const isWrappedTokenLog = (
+  chain: Chain,
+  log: Log<bigint, number, false>,
+): boolean => {
+  switch (chain.id) {
+    // Ethereum
+    case 1: {
+      return (
+        log.address.toLowerCase() ===
+        '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
+      )
+    }
+    // Optimism
+    case 10: {
+      return (
+        log.address.toLowerCase() ===
+        '0x4200000000000000000000000000000000000006'
+      )
+    }
+    // BNB Smart Chain
+    case 56: {
+      return (
+        log.address.toLowerCase() ===
+        '0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c'
+      )
+    }
+    // Polygon PoS
+    case 137: {
+      return (
+        log.address.toLowerCase() ===
+        '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270'
+      )
+    }
+    // Fantom
+    case 250: {
+      return (
+        log.address.toLowerCase() ===
+        '0x21be370d5312f44cb42ce377bc9b8a0cef1a4c83'
+      )
+    }
+    // Astar (EVM)
+    case 592: {
+      return (
+        log.address.toLowerCase() ===
+        '0xaeaaf0e2c81af264101b9129c00f4440ccf0f720'
+      )
+    }
+    // Metis
+    case 1088: {
+      return (
+        log.address.toLowerCase() ===
+        '0x75cb093e4d61d2a2e65d8e0bbb01de8d89b53481'
+      )
+    }
+    // Moonbeam
+    case 1284: {
+      return (
+        log.address.toLowerCase() ===
+        '0xacc15dc74880c9944775448304b263d191c6077f'
+      )
+    }
+    // Moonriver
+    case 1285: {
+      return (
+        log.address.toLowerCase() ===
+        '0x98878b06940ae243284ca214f92bb71a2b032b8a'
+      )
+    }
+    // Ronin
+    case 2020: {
+      return (
+        log.address.toLowerCase() ===
+        '0xe514d9deb7966c8be0ca922de8a064264ea6bcd4'
+      )
+    }
+    // Mantle
+    case 5000: {
+      return (
+        log.address.toLowerCase() ===
+        '0x78c1b0c915c4faa5fffa6cabf0219da63d7f4cb8'
+      )
+    }
+    // Base
+    case 8453: {
+      return (
+        log.address.toLowerCase() ===
+        '0x4200000000000000000000000000000000000006'
+      )
+    }
+    // Arbitrum One
+    case 42_161: {
+      return (
+        log.address.toLowerCase() ===
+        '0x82af49447d8a07e3bd95bd0d56f35241523fbab1'
+      )
+    }
+    // Avalanche C-Chain
+    case 43_114: {
+      return (
+        log.address.toLowerCase() ===
+        '0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7'
+      )
+    }
+    // Linea
+    case 59_144: {
+      return (
+        log.address.toLowerCase() ===
+        '0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f'
+      )
+    }
+    default: {
+      return false
+    }
+  }
+}
+
+const coingeckoCoinSchema = z.object({
+  id: z.string(),
+  symbol: z.string(),
+  name: z.string(),
+  platforms: z.record(z.string()),
+})
+const coingeckoCoinsSchema = z.array(coingeckoCoinSchema)
+type CoingeckoCoin = Readonly<z.infer<typeof coingeckoCoinSchema>>
+
+const getCoingeckoCoinsList = async (config?: Config) =>
+  await rest(
+    'https://api.coingecko.com/api/v3/coins/list?include_platform=true',
+    {
+      schema: coingeckoCoinsSchema,
+      timeout: config?.timeout,
+      logger: config?.logger,
+    },
+  )
+
+const getErc20Token = async (
+  chain: Chain,
+  address: LowerHex,
+  coingeckoCoins: readonly CoingeckoCoin[],
+  config?: Config,
+): Promise<Erc20Token | undefined> => {
+  const [nameData, symbolData, decimalsData] = await chain.client.multicall(
+    {
+      contracts: [
+        {
+          address,
+          abi: erc20Abi,
+          functionName: 'name',
+        },
+        {
+          address,
+          abi: erc20Abi,
+          functionName: 'symbol',
+        },
+        {
+          address,
+          abi: erc20Abi,
+          functionName: 'decimals',
+        },
+      ],
+    },
+    config,
+  )
+  if (nameData.status === 'failure') {
+    if (config?.logger !== undefined) {
+      config.logger.info(
+        `Failed to get erc20 token info of ${address} (chain: ${chain.name})`,
+      )
+    }
+    if (
+      nameData.error.message.includes('The contract function "name" reverted.')
+    ) {
+      return undefined
+    }
+    throw nameData.error
+  }
+  if (symbolData.status === 'failure') {
+    if (config?.logger !== undefined) {
+      config.logger.info(
+        `Failed to get erc20 token info of ${address} (chain: ${chain.name})`,
+      )
+    }
+    if (
+      symbolData.error.message.includes(
+        'The contract function "symbol" reverted.',
+      )
+    ) {
+      return undefined
+    }
+    throw symbolData.error
+  }
+  if (decimalsData.status === 'failure') {
+    if (config?.logger !== undefined) {
+      config.logger.info(
+        `Failed to get erc20 token info of ${address} (chain: ${chain.name})`,
+      )
+    }
+    if (
+      decimalsData.error.message.includes(
+        'The contract function "decimals" reverted.',
+      )
+    ) {
+      return undefined
+    }
+    if (
+      !decimalsData.error.message.includes(
+        'The contract function "decimals" returned no data ("0x").',
+      )
+    ) {
+      throw decimalsData.error
+    }
+  }
+  const name = nameData.result
+  const symbol = symbolData.result
+  const decimals = decimalsData.result ?? 0
+
+  const coin =
+    chain.coingeckoId === undefined
+      ? undefined
+      : coingeckoCoins.find(
+          ({ platforms }) =>
+            platforms[chain.coingeckoId!] !== undefined &&
+            platforms[chain.coingeckoId!].toLowerCase() === address,
+        )
+
+  return {
+    contractAddress: address,
+    name,
+    symbol,
+    decimals,
+    currency: {
+      type: 'CryptoCurrency',
+      id: coin?.id ?? `evm_${chain.id}_${address}`,
+      name: coin?.name ?? name,
+      symbol: coin?.symbol.toUpperCase() ?? symbol,
+      icon: undefined,
+      market: {
+        coingeckoId: coin?.id,
+        marketCapUsd: undefined,
+      },
+      updatedAt: Date.now(),
+    },
+  }
+}
+
+const getErc721Token = async (
+  chain: Chain,
+  address: LowerHex,
+  config?: Config,
+): Promise<Erc721Token | undefined> => {
+  const [nameData, symbolData] = await chain.client.multicall(
+    {
+      contracts: [
+        {
+          address,
+          abi: erc721Abi,
+          functionName: 'name',
+        },
+        {
+          address,
+          abi: erc721Abi,
+          functionName: 'symbol',
+        },
+      ],
+    },
+    config,
+  )
+  if (nameData.status === 'failure') {
+    if (config?.logger !== undefined) {
+      config.logger.info(
+        `Failed to get erc721 token info of ${address} (chain: ${chain.name})`,
+      )
+    }
+    if (
+      nameData.error.message.includes('The contract function "name" reverted.')
+    ) {
+      return undefined
+    }
+    throw nameData.error
+  }
+  if (symbolData.status === 'failure') {
+    if (config?.logger !== undefined) {
+      config.logger.info(
+        `Failed to get erc721 token info of ${address} (chain: ${chain.name})`,
+      )
+    }
+    if (
+      symbolData.error.message.includes(
+        'The contract function "symbol" reverted.',
+      )
+    ) {
+      return undefined
+    }
+    throw symbolData.error
+  }
+  const name = nameData.result
+  const symbol = symbolData.result
+  return {
+    contractAddress: address,
+    name,
+    symbol,
+    baseUri: undefined,
+  }
+}
+
+const decodeInput = (
+  {
+    address,
+    data,
+  }: {
+    readonly address: Hex
+    readonly data: Hex
+  },
+  contract: ContractByExplorer | undefined,
+): InputData => {
+  const lowerAddress = toLowerHex(address)
+  if (contract === undefined) {
+    return {
+      type: 'original',
+      address: lowerAddress,
+      data,
+    }
+  }
+  try {
+    const { functionName, args } = decodeFunctionData({
+      abi: contract.abi,
+      data,
+    })
+    const abiItem = getAbiItem({
+      abi: contract.abi,
+      name: functionName,
+    })
+    if (abiItem?.type !== 'function') {
+      return {
+        type: 'original',
+        address: lowerAddress,
+        data,
+      }
+    }
+    return {
+      type: 'decoded',
+      address: lowerAddress,
+      data,
+      function: {
+        name: functionName,
+        args:
+          args === undefined
+            ? undefined
+            : args.map((value, index) => ({
+                name: abiItem.inputs[index].name ?? '',
+                type: abiItem.inputs[index].type,
+                value,
+              })),
+      },
+      source: lowerAddress,
+    }
+  } catch (error) {
+    console.debug(error)
+    return {
+      type: 'original',
+      address: lowerAddress,
+      data,
+    }
+  }
+}
+
+const decodeLog = (
+  log: Log<bigint, number, false>,
+  contract: ContractByExplorer | undefined,
+): LogData => {
+  const originalLog = {
+    type: 'LogOriginal',
+    log,
+  } as const
+  const lowerAddress = toLowerHex(log.address)
+  if (contract === undefined) {
+    return originalLog
+  }
+  const parsedLogs = parseEventLogs({
+    abi: contract.abi,
+    logs: [log],
+  })
+  if (parsedLogs.length === 0) {
+    return originalLog
+  }
+  try {
+    const parsedLog = parsedLogSchema.parse(parsedLogs[0])
+    const abiItem = getAbiItem({
+      abi: contract.abi,
+      name: parsedLog.eventName,
+    })
+    if (abiItem?.type !== 'event') {
+      return originalLog
+    }
+    const arguments_ = Object.entries(parsedLog.args).map(([name, value]) => {
+      const index = abiItem.inputs.findIndex((input) => input.name === name)
+      const event = abiItem.inputs[index]
+      return {
+        name,
+        type: event.type,
+        value,
+        index,
+        indexed: event.indexed ?? false,
+      }
+    })
+    return {
+      type: 'decoded',
+      log: {
+        ...parsedLog,
+        type: 'DecodedLog',
+        args: arguments_
+          .toSorted((a, b) => a.index - b.index)
+          .map((argument) => ({
+            indexed: argument.indexed,
+            name: argument.name,
+            type: argument.type,
+            value: argument.value,
+          })),
+      },
+      source: lowerAddress,
+    }
+  } catch (error) {
+    console.debug(error)
+    return originalLog
+  }
+}

package/src/decoder/decoder.ts

@@ -0,0 +1,6 @@
+import { decode } from './decode'
+import type { Decoder } from './types'
+
+export const decoder: Decoder = {
+  decode,
+}

package/src/decoder/index.ts

@@ -0,0 +1,5 @@
+export { decoder } from './decoder'
+export { parseErc1155TransferSingleLogs } from './parseErc1155TransferSingleLogs'
+export { parseErc20TransferLogs } from './parseErc20TransferLogs'
+export { parseErc721TransferLogs } from './parseErc721TransferLogs'
+export type { Decoder } from './types'