@0xtorch/evm 0.0.60 → 0.0.62

package/decoder/decode.ts

@@ -1,726 +0,0 @@
-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, createErc1155NftId, createEvmCurrencyId } 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: createErc1155NftId({
-                chainId: chain.id,
-                address: toLowerHex(log.address),
-                tokenId: id,
-              }),
-              name: undefined,
-              symbol: undefined,
-              image: undefined,
-              metadata: undefined,
-              updatedAt: 0,
-            },
-          }),
-        ),
-      ),
-    ],
-  }
-}
-
-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 ?? createEvmCurrencyId({ chainId: chain.id, address }),
-      name: coin?.name ?? name,
-      symbol: coin?.symbol.toUpperCase() ?? symbol,
-      icon: undefined,
-      market: {
-        coingeckoId: coin?.id,
-        marketCapUsd: undefined,
-      },
-      priceDatasourceId: 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/decoder/decoder.ts

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