@0xtorch/evm 0.0.1

package/src/analyzer/swap/index.ts

@@ -0,0 +1 @@
+export { analyzeSwap } from './analyze'

package/src/analyzer/swap/traderJoeLBPairSwap.ts

@@ -0,0 +1,92 @@
+/* eslint-disable unicorn/filename-case */
+import { z } from 'zod'
+import type { DecodedLog } from '../../types'
+import { isHex, toLowerHex } from '../../types'
+
+export const parseToTraderJoeLBPairSwap = (
+  log: DecodedLog,
+): TraderJoeLBPairSwapLog | undefined => {
+  if (log.topics[0] !== traderJoeLBPairSwapEventTopic) {
+    return undefined
+  }
+
+  try {
+    const arguments_ = traderJoeLBPairSwapArgumentsSchema.parse(log.args)
+    return {
+      ...log,
+      type: 'TraderJoeLBPairSwapLog',
+      args: arguments_,
+    }
+  } catch {
+    return undefined
+  }
+}
+
+const traderJoeLBPairSwapEventTopic =
+  '0xc528cda9e500228b16ce84fadae290d9a49aecb17483110004c5af0a07f6fd73'
+
+const traderJoeLBPairSwapArgumentsSchema = z.tuple([
+  // sender
+  z.object({
+    indexed: z.literal(true),
+    type: z.literal('address'),
+    value: z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{40}$/)
+      .transform((v) => (isHex(v) ? toLowerHex(v) : '0x')),
+  }),
+  // recipient
+  z.object({
+    indexed: z.literal(true),
+    type: z.literal('address'),
+    value: z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{40}$/)
+      .transform((v) => (isHex(v) ? toLowerHex(v) : '0x')),
+  }),
+  // id
+  z.object({
+    indexed: z.literal(true),
+    type: z.literal('uint256'),
+    value: z.bigint(),
+  }),
+  // swapForY
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('bool'),
+    value: z.boolean(),
+  }),
+  // amountIn
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('uint256'),
+    value: z.bigint(),
+  }),
+  // amountOut
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('uint256'),
+    value: z.bigint(),
+  }),
+  // volatilityAccumulated
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('uint256'),
+    value: z.bigint(),
+  }),
+  // fees
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('uint256'),
+    value: z.bigint(),
+  }),
+])
+type TraderJoeLBPairSwapArguments = z.infer<
+  typeof traderJoeLBPairSwapArgumentsSchema
+>
+
+export type TraderJoeLBPairSwapLog = Omit<DecodedLog, 'type' | 'args'> & {
+  readonly type: 'TraderJoeLBPairSwapLog'
+  /** [sender, recipient, id, swapForY, amountIn, amountOut, volatilityAccumulated, fees] */
+  readonly args: TraderJoeLBPairSwapArguments
+}

package/src/analyzer/swap/univ2PairSwap.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod'
+import type { DecodedLog } from '../../types'
+import { isHex, toLowerHex } from '../../types'
+
+export const parseToUniv2SwapLog = (
+  log: DecodedLog,
+): UniV2PairSwapLog | undefined => {
+  if (log.topics[0] !== univ2PairSwapEventTopic) {
+    return undefined
+  }
+
+  try {
+    const arguments_ = univ2PairSwapArgumentsSchema.parse(log.args)
+    return {
+      ...log,
+      type: 'UniV2PairSwapLog',
+      args: arguments_,
+    }
+  } catch {
+    return undefined
+  }
+}
+
+const univ2PairSwapEventTopic =
+  '0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822'
+
+const univ2PairSwapArgumentsSchema = z.tuple([
+  // sender
+  z.object({
+    indexed: z.literal(true),
+    type: z.literal('address'),
+    value: z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{40}$/)
+      .transform((v) => (isHex(v) ? toLowerHex(v) : '0x')),
+  }),
+  // amount0In
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('uint256'),
+    value: z.bigint(),
+  }),
+  // amount1In
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('uint256'),
+    value: z.bigint(),
+  }),
+  // amount0Out
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('uint256'),
+    value: z.bigint(),
+  }),
+  // amount1Out
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('uint256'),
+    value: z.bigint(),
+  }),
+  // to
+  z.object({
+    indexed: z.literal(true),
+    type: z.literal('address'),
+    value: z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{40}$/)
+      .transform((v) => (isHex(v) ? toLowerHex(v) : '0x')),
+  }),
+])
+type Univ2PairSwapArguments = z.infer<typeof univ2PairSwapArgumentsSchema>
+
+export type UniV2PairSwapLog = Omit<DecodedLog, 'type' | 'args'> & {
+  readonly type: 'UniV2PairSwapLog'
+  /** [sender, amount0In, amount1In, amount0Out, amount1Out, to] */
+  readonly args: Univ2PairSwapArguments
+}

package/src/analyzer/swap/univ3PoolSwap.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod'
+import type { DecodedLog } from '../../types'
+import { isHex, toLowerHex } from '../../types'
+
+export const parseToUniv3SwapLog = (
+  log: DecodedLog,
+): UniV3PoolSwapLog | undefined => {
+  if (log.topics[0] !== univ3PoolSwapEventTopic) {
+    return undefined
+  }
+
+  try {
+    const arguments_ = univ3PoolSwapArgumentsSchema.parse(log.args)
+    return {
+      ...log,
+      type: 'UniV3PoolSwapLog',
+      args: arguments_,
+    }
+  } catch {
+    return undefined
+  }
+}
+
+const univ3PoolSwapEventTopic =
+  '0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67'
+
+const univ3PoolSwapArgumentsSchema = z.tuple([
+  // sender
+  z.object({
+    indexed: z.literal(true),
+    type: z.literal('address'),
+    value: z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{40}$/)
+      .transform((v) => (isHex(v) ? toLowerHex(v) : '0x')),
+  }),
+  // recipient
+  z.object({
+    indexed: z.literal(true),
+    type: z.literal('address'),
+    value: z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{40}$/)
+      .transform((v) => (isHex(v) ? toLowerHex(v) : '0x')),
+  }),
+  // amount0
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('int256'),
+    value: z.bigint(),
+  }),
+  // amount1
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('int256'),
+    value: z.bigint(),
+  }),
+  // sqrtPriceX96
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('uint160'),
+    value: z.bigint(),
+  }),
+  // liquidity
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('uint128'),
+    value: z.bigint(),
+  }),
+  // tick
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('int24'),
+    value: z.number(),
+  }),
+])
+type UniV3PoolSwapArguments = z.infer<typeof univ3PoolSwapArgumentsSchema>
+
+export type UniV3PoolSwapLog = Omit<DecodedLog, 'type' | 'args'> & {
+  readonly type: 'UniV3PoolSwapLog'
+  /** [sender, recipient, amount0, amount1, sqrtPriceX96, liquidity, tick] */
+  readonly args: UniV3PoolSwapArguments
+}

package/src/analyzer/swap/wrappedDeposit.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod'
+import type { DecodedLog } from '../../types'
+import { isHex, toLowerHex } from '../../types'
+
+export const parseToWrappedDepositLog = (
+  log: DecodedLog,
+): WrappedDepositLog | undefined => {
+  if (log.topics[0] !== wrappedDepositEventTopic) {
+    return undefined
+  }
+
+  try {
+    const arguments_ = wrappedDepositArgumentsSchema.parse(log.args)
+    return {
+      ...log,
+      type: 'WrappedDepositLog',
+      args: arguments_,
+    }
+  } catch {
+    return undefined
+  }
+}
+
+const wrappedDepositEventTopic =
+  '0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c'
+
+const wrappedDepositArgumentsSchema = z.tuple([
+  // dst
+  z.object({
+    indexed: z.literal(true),
+    type: z.literal('address'),
+    value: z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{40}$/)
+      .transform((v) => (isHex(v) ? toLowerHex(v) : '0x')),
+  }),
+  // wad
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('uint256'),
+    value: z.bigint(),
+  }),
+])
+
+type WrappedDepositArguments = z.infer<typeof wrappedDepositArgumentsSchema>
+
+export type WrappedDepositLog = Omit<DecodedLog, 'type' | 'args'> & {
+  readonly type: 'WrappedDepositLog'
+  /** [dst, wad] */
+  readonly args: WrappedDepositArguments
+}

package/src/analyzer/swap/wrappedWithdrawal.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod'
+import type { DecodedLog } from '../../types'
+import { isHex, toLowerHex } from '../../types'
+
+export const parseToWrappedWithdrawalLog = (
+  log: DecodedLog,
+): WrappedWithdrawalLog | undefined => {
+  if (log.topics[0] !== wrappedWithdrawalEventTopic) {
+    return undefined
+  }
+
+  try {
+    const arguments_ = wrappedWithdrawalArgumentsSchema.parse(log.args)
+    return {
+      ...log,
+      type: 'WrappedWithdrawalLog',
+      args: arguments_,
+    }
+  } catch {
+    return undefined
+  }
+}
+
+const wrappedWithdrawalEventTopic =
+  '0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65'
+
+const wrappedWithdrawalArgumentsSchema = z.tuple([
+  // src
+  z.object({
+    indexed: z.literal(true),
+    type: z.literal('address'),
+    value: z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{40}$/)
+      .transform((v) => (isHex(v) ? toLowerHex(v) : '0x')),
+  }),
+  // wad
+  z.object({
+    indexed: z.literal(false),
+    type: z.literal('uint256'),
+    value: z.bigint(),
+  }),
+])
+
+type WrappedWithdrawalArguments = z.infer<
+  typeof wrappedWithdrawalArgumentsSchema
+>
+
+export type WrappedWithdrawalLog = Omit<DecodedLog, 'type' | 'args'> & {
+  readonly type: 'WrappedWithdrawalLog'
+  /** [src, wad] */
+  readonly args: WrappedWithdrawalArguments
+}

package/src/analyzer/tests.ts

@@ -0,0 +1,2 @@
+export const testEthereumUniv2SwapTxHash =
+  '0x682586e8a5f4000c84e37aa0cef787b94340e8d8a3d1ae249902477370b60ffa'

package/src/analyzer/transfer/analyze.test.ts

@@ -0,0 +1,6 @@
+import { describe, it } from 'bun:test'
+
+describe('analyzeTransfer', () => {
+  // TODO
+  it.todo('Ethereum tx の ERC transfer の analyze が正常にされる')
+})

package/src/analyzer/transfer/analyze.ts

@@ -0,0 +1,209 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type { CryptoCurrencyPrice, NormalActionTransfer } 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 { AnalyzeParameters, AnalyzeReturnType } from '../types'
+
+export const analyzeTransfer = <Price extends CryptoCurrencyPrice | undefined>({
+  chain,
+  transaction,
+  accountAddresses,
+}: AnalyzeParameters<Price>): Promise<AnalyzeReturnType<Price> | undefined> => {
+  // 全ての native token(include internalTx),erc20,721,1155 transfer を transfer action として normal action 作成
+  const normalActions = generateNormalActions(chain, transaction)
+
+  // accountAddresses が含まれているものについて account action 作成
+  const optionalAccountActions = normalActions.map((action) =>
+    createAccountActionByAction(action, transaction, accountAddresses),
+  )
+  const accountActions = optionalAccountActions
+    .filter(
+      (action): action is Exclude<typeof action, undefined> =>
+        action !== undefined,
+    )
+    .map((action, index) => ({ ...action, order: index }))
+
+  return Promise.resolve({
+    actions: normalActions,
+    accountActions: accountActions,
+  })
+}
+
+const generateNormalActions = <Price extends CryptoCurrencyPrice | undefined>(
+  chain: Chain,
+  {
+    from,
+    to,
+    value,
+    block,
+    internalTransactions,
+    erc20Transfers,
+    erc721Transfers,
+    erc1155Transfers,
+    app,
+    nativeTokenPrice,
+  }: TransactionDecoded<Price>,
+): NormalActionTransfer<EvmAccount, Price>[] => {
+  const mut_actions: NormalActionTransfer<EvmAccount, Price>[] = []
+  if (value > 0 && to !== null) {
+    mut_actions.push({
+      type: 'NormalAction',
+      action: 'transfer',
+      evidence: 'none',
+      timestamp: Number(block.timestamp) * 1000,
+      comment: undefined,
+      app,
+      transfers: [
+        {
+          target: '',
+          direction: 'none',
+          from: createEvmAccount({
+            address: toLowerHex(from),
+            chainId: chain.id,
+          }),
+          to: createEvmAccount({
+            address: toLowerHex(to),
+            chainId: chain.id,
+          }),
+          asset: chain.nativeToken.currency,
+          amount: createBigDecimal(value, chain.nativeToken.decimals),
+          price: nativeTokenPrice,
+        },
+      ],
+    })
+  }
+  for (const internalTx of internalTransactions.filter(
+    ({ value }) => value > 0,
+  )) {
+    if (internalTx.to === undefined) {
+      continue
+    }
+
+    mut_actions.push({
+      type: 'NormalAction',
+      action: 'transfer',
+      evidence: 'none',
+      timestamp: Number(block.timestamp) * 1000,
+      comment: undefined,
+      app,
+      transfers: [
+        {
+          target: '',
+          direction: 'none',
+          from: createEvmAccount({
+            address: internalTx.from,
+            chainId: chain.id,
+          }),
+          to: createEvmAccount({
+            address: internalTx.to,
+            chainId: chain.id,
+          }),
+          asset: chain.nativeToken.currency,
+          amount: createBigDecimal(
+            internalTx.value,
+            chain.nativeToken.decimals,
+          ),
+          price: nativeTokenPrice,
+        },
+      ],
+    })
+  }
+  for (const transfer of [
+    ...erc20Transfers,
+    ...erc721Transfers,
+    ...erc1155Transfers,
+  ].sort((a, b) => a.logIndex - b.logIndex)) {
+    switch (transfer.type) {
+      case 'Erc20Transfer': {
+        mut_actions.push({
+          type: 'NormalAction',
+          action: 'transfer',
+          evidence: 'none',
+          timestamp: Number(block.timestamp) * 1000,
+          comment: undefined,
+          app,
+          transfers: [
+            {
+              target: '',
+              direction: 'none',
+              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,
+            },
+          ],
+        })
+        break
+      }
+      case 'Erc721Transfer': {
+        mut_actions.push({
+          type: 'NormalAction',
+          action: 'transfer',
+          evidence: 'none',
+          timestamp: Number(block.timestamp) * 1000,
+          comment: undefined,
+          app,
+          transfers: [
+            {
+              target: '',
+              direction: 'none',
+              from: createEvmAccount({
+                address: transfer.from,
+                chainId: chain.id,
+              }),
+              to: createEvmAccount({
+                address: transfer.to,
+                chainId: chain.id,
+              }),
+              asset: transfer.nft,
+              amount: createBigDecimal('1'),
+              // TODO 適切な値を入れる (一律 undefined を入れたい)
+              price: undefined as Price,
+            },
+          ],
+        })
+        break
+      }
+      case 'Erc1155Transfer': {
+        mut_actions.push({
+          type: 'NormalAction',
+          action: 'transfer',
+          evidence: 'none',
+          timestamp: Number(block.timestamp) * 1000,
+          comment: undefined,
+          app,
+          transfers: [
+            {
+              target: '',
+              direction: 'none',
+              from: createEvmAccount({
+                address: transfer.from,
+                chainId: chain.id,
+              }),
+              to: createEvmAccount({
+                address: transfer.to,
+                chainId: chain.id,
+              }),
+              asset: transfer.nft,
+              amount: createBigDecimal(transfer.value, 0),
+              // TODO 適切な値を入れる (一律 undefined を入れたい)
+              price: undefined as Price,
+            },
+          ],
+        })
+        break
+      }
+    }
+  }
+  return mut_actions
+}

package/src/analyzer/transfer/index.ts

@@ -0,0 +1 @@
+export { analyzeTransfer } from './analyze'

package/src/analyzer/types.ts

@@ -0,0 +1,44 @@
+import type {
+  AccountAction,
+  AccountActionType,
+  ActionType,
+  Config,
+  CryptoCurrencyPrice,
+  NormalAction,
+} from '@0xtorch/core'
+import type { Chain } from '../chains'
+import type {
+  EvmAccount,
+  LowerHex,
+  TransactionDecoded,
+  TransactionSource,
+} from '../types'
+
+export type Analyzer<Price extends CryptoCurrencyPrice | undefined> = {
+  readonly analyze: Analyze<Price>
+}
+
+export type Analyze<Price extends CryptoCurrencyPrice | undefined> = (
+  parameters: AnalyzeParameters<Price>,
+  config?: Config,
+) => Promise<AnalyzeReturnType<Price>>
+
+export type AnalyzeParameters<Price extends CryptoCurrencyPrice | undefined> = {
+  readonly chain: Chain
+  readonly transaction: TransactionDecoded<Price>
+  readonly accountAddresses: readonly LowerHex[]
+}
+
+export type AnalyzeReturnType<Price extends CryptoCurrencyPrice | undefined> = {
+  readonly actions: readonly NormalAction<
+    ActionType,
+    EvmAccount | undefined,
+    Price
+  >[]
+  readonly accountActions: readonly AccountAction<
+    AccountActionType,
+    TransactionSource,
+    EvmAccount | undefined,
+    Price
+  >[]
+}

package/src/apps/index.ts

@@ -0,0 +1 @@
+export type { AppDataSource } from './types'

package/src/apps/types.ts

@@ -0,0 +1,10 @@
+import type { App, Config } from '@0xtorch/core'
+import type { LowerHex } from '../types'
+
+export type AppDataSource = {
+  getApp: (
+    chainId: number,
+    address: LowerHex,
+    config?: Config,
+  ) => Promise<App | undefined>
+}

package/src/chains/definitions/arbitrumOne.test.ts

@@ -0,0 +1,50 @@
+import { expect, it } from 'bun:test'
+import { createPublicClient, http } from 'viem'
+import { arbitrum } from 'viem/chains'
+import { arbitrumOneHttpRpcs } from './arbitrumOne'
+import { sendMsgEvent as sendMessageEvent } from './tests'
+
+it('Should all arbitrumOneHttpRpcs be the rpc url of the archive node', async () => {
+  for (const rpc of arbitrumOneHttpRpcs) {
+    const { url, isArchive, getLogsIsUsable, getLogsMaxBlockRange } = rpc
+    console.debug('Checking >', url)
+    const client = createPublicClient({
+      chain: arbitrum,
+      transport: http(url),
+    })
+
+    // get latest block number
+    const blockNumber = await client.getBlockNumber()
+    console.debug('Result getBlockNumber >', blockNumber)
+    expect(blockNumber).toBeGreaterThan(0n)
+
+    // archive
+    // - getTransactionReceipt
+    // - getBlock
+    if (isArchive) {
+      const hash =
+        '0x04c4657215bbcf43db58e24ff6d082e086f6df018667e7c189042e7fbb106931'
+      const blockNumber = 43_870_014n
+      const receipt = await client.getTransactionReceipt({ hash })
+      console.debug('Result getTransactionReceipt >', receipt.status)
+      const block = await client.getBlock({ blockNumber })
+      console.debug('Result getBlock >', block.timestamp)
+      expect(receipt.transactionHash).toEqual(hash)
+      expect(block.number).toEqual(blockNumber)
+    }
+
+    // getLogs
+    if (getLogsIsUsable) {
+      const toBlock = blockNumber - 5n
+      const fromBlock = toBlock - getLogsMaxBlockRange + 1n
+      const logs = await client.getLogs({
+        address: '0x352d8275aae3e0c2404d9f68f6cee084b5beb3dd',
+        event: sendMessageEvent,
+        fromBlock,
+        toBlock,
+      })
+      console.debug('Result getLogs >', logs.length)
+      expect(logs).toBeDefined()
+    }
+  }
+}, 60_000)