@0xtorch/evm 0.0.61 → 0.0.63

package/logic/getTransactionDetail/decodeTokenTransferLogs.ts

@@ -0,0 +1,487 @@
+import { decodeEventLog, zeroAddress } from 'viem'
+import { IS_DEBUG } from '../../tests'
+import {
+  type Erc20Transfer,
+  type Erc721Transfer,
+  type Erc1155Transfer,
+  type Hex,
+  type LowerHex,
+  toLowerHex,
+} from '../../types'
+import type { Log } from '../../types/log'
+
+type DecodeTokenTransferLogsReturnTypes = {
+  erc20Transfers: Erc20Transfer[]
+  erc721Transfers: Erc721Transfer[]
+  erc1155Transfers: Erc1155Transfer[]
+  logs: Log[]
+}
+
+export const decodeTokenTransferLogs = (
+  logs: Log[],
+  wrappedTokenAddresses: Set<LowerHex>,
+): DecodeTokenTransferLogsReturnTypes => {
+  const decodedLogs: Log[] = []
+  const erc20Transfers: Erc20Transfer[] = []
+  const erc721Transfers: Erc721Transfer[] = []
+  const erc1155Transfers: Erc1155Transfer[] = []
+  for (const log of logs) {
+    const {
+      log: decodedLog,
+      erc20Transfer,
+      erc721Transfer,
+      erc1155Transfers: optionalErc1155Transfers,
+    } = decodeTokenTransferLog(log, wrappedTokenAddresses)
+    decodedLogs.push(decodedLog)
+    if (erc20Transfer !== undefined) {
+      erc20Transfers.push(erc20Transfer)
+    }
+    if (erc721Transfer !== undefined) {
+      erc721Transfers.push(erc721Transfer)
+    }
+    if (optionalErc1155Transfers !== undefined) {
+      erc1155Transfers.push(...optionalErc1155Transfers)
+    }
+  }
+  return {
+    erc20Transfers,
+    erc721Transfers,
+    erc1155Transfers,
+    logs: decodedLogs,
+  }
+}
+
+const decodeTokenTransferLog = (
+  log: Log,
+  wrappedTokenAddresses: Set<LowerHex>,
+): {
+  log: Log
+  erc20Transfer?: Erc20Transfer
+  erc721Transfer?: Erc721Transfer
+  erc1155Transfers?: Erc1155Transfer[]
+} => {
+  // decode by ERC20
+  const decodedByErc20 = decodeErc20TransferLog(log)
+  if (decodedByErc20 !== undefined) {
+    return decodedByErc20
+  }
+
+  // decode by WrappedToken
+  if (wrappedTokenAddresses.has(log.address)) {
+    const decodedByWrappedTokenDeposit = decodeWrappedTokenDepositLog(log)
+    if (decodedByWrappedTokenDeposit !== undefined) {
+      return decodedByWrappedTokenDeposit
+    }
+    const decodedByWrappedTokenWithdrawal = decodeWrappedTokenWithdrawalLog(log)
+    if (decodedByWrappedTokenWithdrawal !== undefined) {
+      return decodedByWrappedTokenWithdrawal
+    }
+  }
+
+  // decode by ERC721
+  const decodedByErc721 = decodeErc721TransferLog(log)
+  if (decodedByErc721 !== undefined) {
+    return decodedByErc721
+  }
+
+  // decode by ERC1155
+  const decodedByErc1155Single = decodeErc1155TransferSingleLog(log)
+  if (decodedByErc1155Single !== undefined) {
+    return decodedByErc1155Single
+  }
+  const decodedByErc1155Batch = decodeErc1155TransferBatchLog(log)
+  if (decodedByErc1155Batch !== undefined) {
+    return decodedByErc1155Batch
+  }
+
+  return { log }
+}
+
+const erc20TransferSignature =
+  '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
+const erc20TransferIndexedCount = 2
+
+const decodeErc20TransferLog = (
+  log: Log,
+): { log: Log; erc20Transfer: Erc20Transfer } | undefined => {
+  if (
+    log.topics.length !== erc20TransferIndexedCount + 1 ||
+    log.topics[0] !== erc20TransferSignature ||
+    log.topics[1]?.slice(0, 26) !== '0x000000000000000000000000' ||
+    log.topics[2]?.slice(0, 26) !== '0x000000000000000000000000' ||
+    log.data.length !== 66
+  ) {
+    return undefined
+  }
+
+  const from = toLowerHex(`0x${log.topics[1].slice(26)}`)
+  const to = toLowerHex(`0x${log.topics[2].slice(26)}`)
+  const value = BigInt(log.data)
+
+  log.eventName = 'Transfer'
+  log.args = [
+    {
+      indexed: true,
+      name: 'from',
+      type: 'address',
+      value: from,
+    },
+    {
+      indexed: true,
+      name: 'to',
+      type: 'address',
+      value: to,
+    },
+    {
+      indexed: false,
+      name: 'value',
+      type: 'uint256',
+      value,
+    },
+  ]
+
+  return {
+    log,
+    erc20Transfer: {
+      address: log.address,
+      logIndex: log.logIndex,
+      from,
+      to,
+      value,
+    },
+  }
+}
+
+const wrappedTokenDepositSignature =
+  '0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c'
+const wrappedTokenDepositIndexedCount = 1
+const decodeWrappedTokenDepositLog = (
+  log: Log,
+): { log: Log; erc20Transfer: Erc20Transfer } | undefined => {
+  if (
+    log.topics.length !== wrappedTokenDepositIndexedCount + 1 ||
+    log.topics[0] !== wrappedTokenDepositSignature ||
+    log.topics[1]?.slice(0, 26) !== '0x000000000000000000000000' ||
+    log.data.length !== 66
+  ) {
+    return undefined
+  }
+
+  const dst = toLowerHex(`0x${log.topics[1].slice(26)}`)
+  const wad = BigInt(log.data)
+
+  log.eventName = 'Deposit'
+  log.args = [
+    {
+      indexed: true,
+      name: 'dst',
+      type: 'address',
+      value: dst,
+    },
+    {
+      indexed: false,
+      name: 'wad',
+      type: 'uint256',
+      value: wad,
+    },
+  ]
+
+  return {
+    log,
+    erc20Transfer: {
+      address: log.address,
+      logIndex: log.logIndex,
+      from: zeroAddress,
+      to: dst,
+      value: wad,
+    },
+  }
+}
+
+const wrappedTokenWithdrawalSignature =
+  '0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65'
+const wrappedTokenWithdrawalIndexedCount = 1
+const decodeWrappedTokenWithdrawalLog = (
+  log: Log,
+): { log: Log; erc20Transfer: Erc20Transfer } | undefined => {
+  if (
+    log.topics.length !== wrappedTokenWithdrawalIndexedCount + 1 ||
+    log.topics[0] !== wrappedTokenWithdrawalSignature ||
+    log.topics[1]?.slice(0, 26) !== '0x000000000000000000000000' ||
+    log.data.length !== 66
+  ) {
+    return undefined
+  }
+
+  const src = toLowerHex(`0x${log.topics[1].slice(26)}`)
+  const wad = BigInt(log.data)
+
+  log.eventName = 'Withdrawal'
+  log.args = [
+    {
+      indexed: true,
+      name: 'src',
+      type: 'address',
+      value: src,
+    },
+    {
+      indexed: false,
+      name: 'wad',
+      type: 'uint256',
+      value: wad,
+    },
+  ]
+
+  return {
+    log,
+    erc20Transfer: {
+      address: log.address,
+      logIndex: log.logIndex,
+      from: src,
+      to: zeroAddress,
+      value: wad,
+    },
+  }
+}
+
+const erc721TransferSignature =
+  '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
+const erc721TransferIndexedCount = 3
+
+const decodeErc721TransferLog = (
+  log: Log,
+): { log: Log; erc721Transfer: Erc721Transfer } | undefined => {
+  if (
+    log.topics.length !== erc721TransferIndexedCount + 1 ||
+    log.topics[0] !== erc721TransferSignature ||
+    log.topics[1]?.slice(0, 26) !== '0x000000000000000000000000' ||
+    log.topics[2]?.slice(0, 26) !== '0x000000000000000000000000' ||
+    log.data !== '0x'
+  ) {
+    return undefined
+  }
+
+  const from = toLowerHex(`0x${log.topics[1].slice(26)}`)
+  const to = toLowerHex(`0x${log.topics[2].slice(26)}`)
+  const tokenId = BigInt(log.topics[3])
+
+  log.eventName = 'Transfer'
+  log.args = [
+    {
+      indexed: true,
+      name: 'from',
+      type: 'address',
+      value: from,
+    },
+    {
+      indexed: true,
+      name: 'to',
+      type: 'address',
+      value: to,
+    },
+    {
+      indexed: true,
+      name: 'tokenId',
+      type: 'uint256',
+      value: tokenId,
+    },
+  ]
+
+  return {
+    log,
+    erc721Transfer: {
+      address: log.address,
+      logIndex: log.logIndex,
+      from,
+      to,
+      tokenId,
+    },
+  }
+}
+
+const erc1155TransferSingleSignature =
+  '0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62'
+const erc1155TransferSingleIndexedCount = 3
+
+const decodeErc1155TransferSingleLog = (
+  log: Log,
+): { log: Log; erc1155Transfers: Erc1155Transfer[] } | undefined => {
+  if (
+    log.topics.length !== erc1155TransferSingleIndexedCount + 1 ||
+    log.topics[0] !== erc1155TransferSingleSignature ||
+    log.topics[1]?.slice(0, 26) !== '0x000000000000000000000000' ||
+    log.topics[2]?.slice(0, 26) !== '0x000000000000000000000000' ||
+    log.topics[3]?.slice(0, 26) !== '0x000000000000000000000000' ||
+    log.data.length !== 130
+  ) {
+    return undefined
+  }
+
+  const from = toLowerHex(`0x${log.topics[2].slice(26)}`)
+  const to = toLowerHex(`0x${log.topics[3].slice(26)}`)
+  const tokenId = BigInt(log.data.slice(0, 66))
+  const value = BigInt(`0x${log.data.slice(66, 130)}`)
+
+  log.eventName = 'TransferSingle'
+  log.args = [
+    {
+      indexed: true,
+      name: 'operator',
+      type: 'address',
+      value: `0x${log.topics[1].slice(26)}`,
+    },
+    {
+      indexed: true,
+      name: 'from',
+      type: 'address',
+      value: from,
+    },
+    {
+      indexed: true,
+      name: 'to',
+      type: 'address',
+      value: to,
+    },
+    {
+      indexed: false,
+      name: 'id',
+      type: 'uint256',
+      value: tokenId,
+    },
+    {
+      indexed: false,
+      name: 'value',
+      type: 'uint256',
+      value,
+    },
+  ]
+
+  return {
+    log,
+    erc1155Transfers: [
+      {
+        address: log.address,
+        logIndex: log.logIndex,
+        from,
+        to,
+        tokenId,
+        value,
+      },
+    ],
+  }
+}
+
+const erc1155TransferBatchSignature =
+  '0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb'
+const erc1155TransferBatchIndexedCount = 3
+
+const decodeErc1155TransferBatchLog = (
+  log: Log,
+): { log: Log; erc1155Transfers: Erc1155Transfer[] } | undefined => {
+  if (
+    log.topics.length !== erc1155TransferBatchIndexedCount + 1 ||
+    log.topics[0] !== erc1155TransferBatchSignature
+  ) {
+    return undefined
+  }
+
+  try {
+    const decodedLog = decodeEventLog({
+      abi: [
+        {
+          anonymous: false,
+          inputs: [
+            {
+              indexed: true,
+              internalType: 'address',
+              name: 'operator',
+              type: 'address',
+            },
+            {
+              indexed: true,
+              internalType: 'address',
+              name: 'from',
+              type: 'address',
+            },
+            {
+              indexed: true,
+              internalType: 'address',
+              name: 'to',
+              type: 'address',
+            },
+            {
+              indexed: false,
+              internalType: 'uint256[]',
+              name: 'ids',
+              type: 'uint256[]',
+            },
+            {
+              indexed: false,
+              internalType: 'uint256[]',
+              name: 'values',
+              type: 'uint256[]',
+            },
+          ],
+          name: 'TransferBatch',
+          type: 'event',
+        },
+      ] as const,
+      topics: log.topics as [Hex, ...Hex[]] | [],
+      data: log.data,
+    })
+
+    const from = toLowerHex(decodedLog.args.from)
+    const to = toLowerHex(decodedLog.args.to)
+
+    log.eventName = decodedLog.eventName
+    log.args = [
+      {
+        indexed: true,
+        name: 'operator',
+        type: 'address',
+        value: decodedLog.args.operator,
+      },
+      {
+        indexed: true,
+        name: 'from',
+        type: 'address',
+        value: from,
+      },
+      {
+        indexed: true,
+        name: 'to',
+        type: 'address',
+        value: to,
+      },
+      {
+        indexed: false,
+        name: 'ids',
+        type: 'uint256[]',
+        value: decodedLog.args.ids,
+      },
+      {
+        indexed: false,
+        name: 'values',
+        type: 'uint256[]',
+        value: decodedLog.args.values,
+      },
+    ]
+
+    return {
+      log,
+      erc1155Transfers: decodedLog.args.ids.map((id, index) => ({
+        address: log.address,
+        logIndex: log.logIndex,
+        from,
+        to,
+        tokenId: id,
+        value: decodedLog.args.values[index],
+      })),
+    }
+  } catch (error) {
+    if (IS_DEBUG) {
+      console.debug(error)
+    }
+    return undefined
+  }
+}

package/logic/getTransactionDetail/index.ts

@@ -0,0 +1,79 @@
+import type { Chain } from '../../chain'
+import {
+  type InternalTransaction,
+  type LowerHex,
+  toLowerHex,
+} from '../../types'
+import type { TransactionDetail } from '../../types/transactionDetail'
+import { decodeTokenTransferLogs } from './decodeTokenTransferLogs'
+
+type GetTransactionDetailParameters = {
+  chain: Chain
+  hash: LowerHex
+  timestamp?: number
+  internalTransactions?: readonly InternalTransaction[]
+}
+
+export const getTransactionDetail = async ({
+  chain,
+  hash,
+  timestamp: optionalTimestamp,
+  internalTransactions = [],
+}: GetTransactionDetailParameters): Promise<TransactionDetail> => {
+  const [transaction, receipt] = await Promise.all([
+    chain.client.call({
+      clientCall: (client) => client.getTransaction({ hash }),
+    }),
+    chain.client.call({
+      clientCall: (client) => client.getTransactionReceipt({ hash }),
+    }),
+  ])
+  const timestamp =
+    optionalTimestamp ??
+    (await getTimestampOfBlockNumber(chain, receipt.blockNumber))
+
+  const { erc20Transfers, erc721Transfers, erc1155Transfers, logs } =
+    decodeTokenTransferLogs(
+      receipt.logs.map((log) => ({
+        address: toLowerHex(log.address),
+        data: toLowerHex(log.data),
+        logIndex: log.logIndex,
+        topics: log.topics.map((topic) => toLowerHex(topic)),
+        transactionHash: toLowerHex(log.transactionHash),
+      })),
+      chain.wrappedTokenAddresses,
+    )
+
+  return {
+    blockNumber: Number(receipt.blockNumber),
+    chainId: chain.id,
+    contractAddress:
+      receipt.contractAddress !== undefined && receipt.contractAddress !== null
+        ? toLowerHex(receipt.contractAddress)
+        : undefined,
+    effectiveGasPrice: receipt.effectiveGasPrice,
+    erc20Transfers,
+    erc721Transfers,
+    erc1155Transfers,
+    from: toLowerHex(receipt.from),
+    gasUsed: receipt.gasUsed,
+    hash: toLowerHex(receipt.transactionHash),
+    input: toLowerHex(transaction.input),
+    internalTransactions: [...internalTransactions],
+    logs,
+    status: receipt.status,
+    timestamp,
+    to: receipt.to === null ? undefined : toLowerHex(receipt.to),
+    value: transaction.value,
+  }
+}
+
+const getTimestampOfBlockNumber = async (
+  chain: Chain,
+  blockNumber: bigint,
+): Promise<number> => {
+  const block = await chain.client.call({
+    clientCall: (client) => client.getBlock({ blockNumber }),
+  })
+  return Number(block.timestamp) * 1000
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xtorch/evm",
-  "version": "0.0.61",
+  "version": "0.0.63",
   "description": "Cryptorch EVM extension",
   "keywords": [
     "cryptorch",
@@ -38,10 +38,9 @@
   ],
   "dependencies": {
     "@0xtorch/big-decimal": "^0.0.10",
-    "@0xtorch/core": "^0.0.36",
-    "@supercharge/promise-pool": "^3.1.1",
+    "@0xtorch/core": "^0.0.38",
     "abitype": "^1.0.6",
-    "viem": "^2.17.3",
+    "viem": "^2.21.7",
     "zod": "^3.23.8"
   }
 }

package/tests.ts

@@ -7,3 +7,5 @@ export const IS_LARGE_TEST = (process.env.TEST_SIZE ?? '').includes('L')
 export const IS_END_TO_END_TEST = (process.env.TEST_SIZE ?? '').includes('E')
 
 export const IS_RPC_TEST = process.env.TEST_TARGET === 'RPC'
+
+export const IS_DEBUG = (process.env.DEBUG ?? '').length > 0

package/types/accountId.ts

@@ -0,0 +1,6 @@
+import type { LowerHex } from './hex'
+
+export type EvmAccountId = `evm_address_${number}_${LowerHex}`
+
+export const isEvmAccountId = (id: string): id is EvmAccountId =>
+  /^evm_address_\d+_0x[0-9a-f]{40}$/i.test(id)

package/types/address.ts

@@ -1,36 +1,13 @@
-import { Abi as AbiSchema } from 'abitype/zod'
-import type { Abi } from 'viem'
 import { z } from 'zod'
-import { isHex, toLowerHex } from './hex'
+import { addressPrimitiveSchema } from './primitive'
 
-export const evmAddressPremitiveSchema = z.object({
+export const evmAddressSchema = z.object({
   chainId: z.number().int(),
-  address: z.string().regex(/^0x[\dA-Fa-f]{40}$/),
+  address: addressPrimitiveSchema,
   label: z.string().optional(),
   isSpam: z.boolean().optional(),
-  appId: z.string().optional(),
+  app: z.string().optional(),
   abi: z.string().optional(),
 })
 
-export const evmAddressSchema = evmAddressPremitiveSchema.extend({
-  address: z
-    .string()
-    .regex(/^0x[\dA-Fa-f]{40}$/)
-    .transform((v) => (isHex(v) ? toLowerHex(v) : '0x')),
-  abi: z
-    .string()
-    .transform((value, context): Abi => {
-      try {
-        const abi = AbiSchema.parse(JSON.parse(value))
-        return abi
-      } catch {
-        context.addIssue({ code: 'custom', message: 'Invalid ABI format' })
-        return z.NEVER
-      }
-    })
-    .optional(),
-})
-
-export type EvmAddressPrimitive = z.infer<typeof evmAddressPremitiveSchema>
-
 export type EvmAddress = z.infer<typeof evmAddressSchema>

package/types/analyzeDataSource.ts

@@ -0,0 +1,41 @@
+import type { Nft } from '@0xtorch/core'
+import type { EvmAddress } from './address'
+import type { Erc20Token } from './erc20'
+import type { LowerHex } from './hex'
+
+export type AnalyzeDataSource = {
+  getAddresses: GetAddresses
+  getErc20Tokens: GetErc20Tokens
+  getEventAbis: GetEventAbis
+  getFunctionAbi: GetFunctionAbi
+  getJsonAnalyzer: GetJsonAnalyzer
+  getNfts: GetNfts
+}
+
+type GetAddresses = (parameters: {
+  chainId: number
+  addresses: LowerHex[]
+}) => Promise<EvmAddress[]>
+
+type GetErc20Tokens = (parameters: {
+  chainId: number
+  addresses: LowerHex[]
+}) => Promise<Erc20Token[]>
+
+type GetEventAbis = (parameters: {
+  signatures: LowerHex[]
+}) => Promise<{ signature: LowerHex; indexedCount: number; abi: string }[]>
+
+type GetFunctionAbi = (parameters: {
+  functionId: LowerHex
+}) => Promise<string[]>
+
+// TODO JSON Analyzer の型・schema を改めて定義して、それを使う
+type GetJsonAnalyzer = (parameters: {
+  functionId: LowerHex
+}) => Promise<{ functionId: string }[]>
+
+type GetNfts = (parameters: {
+  // TODO EVM NFT ID の専用型にした方が良さそう
+  ids: string[]
+}) => Promise<Nft[]>