@0xtorch/evm 0.0.1

package/src/getTransactionFull/withPDA.ts

@@ -0,0 +1,147 @@
+/* eslint-disable unicorn/filename-case */
+import type { Config, CryptoCurrency, CryptoCurrencyPrice } from '@0xtorch/core'
+import { toLowerHex } from '../types'
+import { getTransactionDetail } from './getTransactionDetail'
+import type {
+  GetTransactionFullCustomParametersPDA,
+  GetTransactionFullCustomReturnType,
+} from './types'
+
+export const getTransactionFullCustomWithPDA = async (
+  parameters: GetTransactionFullCustomParametersPDA,
+  config?: Config,
+): Promise<
+  GetTransactionFullCustomReturnType<GetTransactionFullCustomParametersPDA>
+> => {
+  const timeoutTimestamp =
+    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
+
+  const {
+    chain,
+    hash,
+    appDataSource,
+    priceDataSource,
+    fiat,
+    decoder,
+    analyzer,
+  } = parameters
+
+  // get transaction detail
+  const transactionDetail = await getTransactionDetail(chain, hash, config)
+  if (transactionDetail === undefined) {
+    return undefined
+  }
+
+  // decode
+  const decodedData = await decoder.decode(
+    {
+      chain,
+      transactions: [transactionDetail],
+    },
+    {
+      timeout: timeoutTimestamp - Date.now(),
+      logger: config?.logger,
+    },
+  )
+  const transactionDecoded = decodedData.transactions[0]
+
+  // get data from datasources
+  const mut_currencies: CryptoCurrency[] = [chain.nativeToken.currency]
+  for (const { token } of transactionDecoded.erc20Transfers) {
+    if (token.currency.market.coingeckoId === undefined) {
+      continue
+    }
+    if (mut_currencies.some((currency) => currency.id === token.currency.id)) {
+      continue
+    }
+    mut_currencies.push(token.currency)
+  }
+  const currencies = mut_currencies
+
+  const timestampMs = Number(transactionDecoded.block.timestamp) * 1000
+  const from = timestampMs - 1000 * 60 * 60
+  const to = timestampMs + 1000 * 60 * 60
+
+  const timeoutForDataSources = timeoutTimestamp - Date.now()
+  const [app, prices] = await Promise.all([
+    // get app
+    appDataSource === undefined || transactionDecoded.to === null
+      ? undefined
+      : appDataSource.getApp(chain.id, toLowerHex(transactionDecoded.to), {
+          timeout: timeoutForDataSources,
+          logger: config?.logger,
+        }),
+    // get native token prices
+    priceDataSource.getHistoricalPrices(
+      {
+        targetCurrencies: currencies,
+        vsCurrency: fiat,
+        from,
+        to,
+      },
+      {
+        timeout: timeoutForDataSources,
+        logger: config?.logger,
+      },
+    ),
+  ])
+
+  const closestPrices = currencies.map((currency) =>
+    prices
+      .filter((price) => price.cryptoCurrencyId === currency.id)
+      .reduce(
+        (closestPrice: CryptoCurrencyPrice | undefined, price) =>
+          closestPrice === undefined ||
+          Math.abs(price.timestamp - timestampMs) <
+            Math.abs(closestPrice.timestamp - timestampMs)
+            ? price
+            : closestPrice,
+        undefined,
+      ),
+  )
+  const nativeTokenPrice = closestPrices.find(
+    (price) =>
+      price !== undefined &&
+      price.cryptoCurrencyId === chain.nativeToken.currency.id,
+  )
+
+  const transactionForAnalyzer = {
+    ...transactionDecoded,
+    app,
+    nativeTokenPrice,
+    internalTransactions: transactionDecoded.internalTransactions.map(
+      (internalTransaction) => ({
+        ...internalTransaction,
+        price: nativeTokenPrice,
+      }),
+    ),
+    erc20Transfers: transactionDecoded.erc20Transfers.map((transfer) => ({
+      ...transfer,
+      price: closestPrices.find(
+        (price) =>
+          price !== undefined &&
+          price.cryptoCurrencyId === transfer.token.currency.id,
+      ),
+    })),
+  }
+
+  // analyze
+  const { actions, accountActions } = await analyzer.analyze(
+    {
+      chain,
+      transaction: transactionForAnalyzer,
+      accountAddresses: [],
+    },
+    {
+      timeout: timeoutTimestamp - Date.now(),
+      logger: config?.logger,
+    },
+  )
+
+  return {
+    ...transactionForAnalyzer,
+    accountAddresses: [],
+    actions,
+    accountActions,
+  }
+}

package/src/getTransactionFull/withUndefined.ts

@@ -0,0 +1,39 @@
+import type { Config } from '@0xtorch/core'
+import { toLowerHex } from '../types'
+import { getTransactionDetail } from './getTransactionDetail'
+import type {
+  GetTransactionFullCustomParametersAllUndefined,
+  GetTransactionFullCustomReturnType,
+} from './types'
+
+export const getTransactionFullCustomWithAllUndefined = async (
+  parameters: GetTransactionFullCustomParametersAllUndefined,
+  config?: Config,
+): Promise<
+  GetTransactionFullCustomReturnType<GetTransactionFullCustomParametersAllUndefined>
+> => {
+  const timeoutTimestamp =
+    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
+
+  const { chain, hash, appDataSource } = parameters
+  const transactionDetail = await getTransactionDetail(chain, hash, config)
+  if (transactionDetail === undefined) {
+    return undefined
+  }
+  const app =
+    appDataSource === undefined || transactionDetail.to === null
+      ? undefined
+      : await appDataSource.getApp(chain.id, toLowerHex(transactionDetail.to), {
+          timeout: timeoutTimestamp - Date.now(),
+          logger: config?.logger,
+        })
+  if (transactionDetail === undefined) {
+    return undefined
+  }
+
+  return {
+    ...transactionDetail,
+    app,
+    nativeTokenPrice: undefined,
+  }
+}

package/src/index.cts

@@ -0,0 +1 @@
+module.exports = require('./index.mts')

package/src/index.mts

@@ -0,0 +1,110 @@
+export { erc1155Abi, erc20Abi, erc721Abi, wethAbi } from './abis'
+export {
+  analyzeAxieMarketplace,
+  analyzeGasFee,
+  analyzeSeaport,
+  analyzeSwap,
+  analyzeTransfer,
+  analyzer,
+  createAnalyzeByJsonRule,
+} from './analyzer'
+export type { AnalyzeParameters, AnalyzeReturnType, Analyzer } from './analyzer'
+export type { AppDataSource } from './apps'
+export {
+  arbitrumOneHttpRpcs,
+  arbitrumOneWebsocketRpcUrls,
+  astarHttpRpcs,
+  astarWebsocketRpcUrls,
+  avalancheCHttpRpcs,
+  avalancheCWebsocketRpcUrls,
+  baseHttpRpcs,
+  baseWebsocketRpcUrls,
+  bscHttpRpcs,
+  bscWebsocketRpcUrls,
+  createArbitrumOneChain,
+  createArbitrumOneChainCustom,
+  createAstarChain,
+  createAstarChainCustom,
+  createAvalancheCChain,
+  createAvalancheCChainCustom,
+  createBaseChain,
+  createBaseChainCustom,
+  createBscChain,
+  createBscChainCustom,
+  createEthereumChain,
+  createEthereumChainCustom,
+  createFantomChain,
+  createFantomChainCustom,
+  createLineaChain,
+  createLineaChainCustom,
+  createMantleChainCustom,
+  createMetisChainCustom,
+  createMoonbeamChain,
+  createMoonbeamChainCustom,
+  createMoonriverChain,
+  createMoonriverChainCustom,
+  createOptimismChain,
+  createOptimismChainCustom,
+  createPolygonPosChain,
+  createPolygonPosChainCustom,
+  createRoninChain,
+  createRoninChainCustom,
+  ethereumHttpRpcs,
+  ethereumWebsocketRpcUrls,
+  fantomHttpRpcs,
+  fantomWebsocketRpcUrls,
+  getBlockOfTimestampByDefillama,
+  lineaHttpRpcs,
+  lineaWebsocketRpcUrls,
+  mantleHttpRpcs,
+  mantleWebsocketRpcUrls,
+  metisHttpRpcs,
+  metisWebsocketRpcUrls,
+  moonbeamHttpRpcs,
+  moonbeamWebsocketRpcUrls,
+  moonriverHttpRpcs,
+  moonriverWebsocketRpcUrls,
+  optimismHttpRpcs,
+  optimismWebsocketRpcUrls,
+  polygonPosHttpRpcs,
+  polygonPosWebsocketRpcUrls,
+  roninHttpRpcs,
+  roninWebsocketRpcUrls,
+} from './chains'
+export type { Chain } from './chains'
+export {
+  decoder,
+  parseErc1155TransferSingleLogs,
+  parseErc20TransferLogs,
+  parseErc721TransferLogs,
+} from './decoder'
+export type { Decoder } from './decoder'
+export { createEtherscan, createRoninExplorer } from './explorers'
+export type { Explorer } from './explorers'
+export {
+  getAccountsTransactionFulls,
+  getAccountsTransactionFullsCustom,
+} from './getAccountsTransactionFulls'
+export {
+  getTransactionFull,
+  getTransactionFullCustom,
+} from './getTransactionFull'
+export { isHex, parsedLogSchema, toLowerHex } from './types'
+export type {
+  Erc1155Token,
+  Erc1155Transfer,
+  Erc20Token,
+  Erc20Transfer,
+  Erc721Token,
+  Erc721Transfer,
+  EvmAccount,
+  Hex,
+  InputData,
+  InternalTransaction,
+  LogData,
+  LowerHex,
+  TransactionDecoded,
+  TransactionDetail,
+  TransactionFull,
+  TransactionSource,
+} from './types'

package/src/tests.ts

@@ -0,0 +1 @@
+export const isIntegrationTest = process.env.INTEGRATION_TEST === 'true'

package/src/types/erc1155.ts

@@ -0,0 +1,17 @@
+import type { Nft } from '@0xtorch/core'
+import type { LowerHex } from './hex'
+
+export type Erc1155Token = {
+  readonly contractAddress: LowerHex
+}
+
+export type Erc1155Transfer = {
+  readonly type: 'Erc1155Transfer'
+  readonly logIndex: number
+  readonly token: Erc1155Token
+  readonly from: LowerHex
+  readonly to: LowerHex
+  readonly id: bigint
+  readonly value: bigint
+  readonly nft: Nft
+}

package/src/types/erc20.ts

@@ -0,0 +1,22 @@
+import type { CryptoCurrency, CryptoCurrencyPrice } from '@0xtorch/core'
+import type { LowerHex } from './hex'
+
+export type Erc20Token = {
+  readonly contractAddress: LowerHex
+  readonly name: string
+  readonly symbol: string
+  readonly decimals: number
+  readonly currency: CryptoCurrency
+}
+
+export type Erc20Transfer<
+  Price extends CryptoCurrencyPrice | undefined = undefined,
+> = {
+  readonly type: 'Erc20Transfer'
+  readonly logIndex: number
+  readonly token: Erc20Token
+  readonly from: LowerHex
+  readonly to: LowerHex
+  readonly value: bigint
+  readonly price: Price
+}

package/src/types/erc721.ts

@@ -0,0 +1,19 @@
+import type { Nft } from '@0xtorch/core'
+import type { LowerHex } from './hex'
+
+export type Erc721Token = {
+  readonly contractAddress: LowerHex
+  readonly name: string
+  readonly symbol: string
+  readonly baseUri?: string
+}
+
+export type Erc721Transfer = {
+  readonly type: 'Erc721Transfer'
+  readonly logIndex: number
+  readonly token: Erc721Token
+  readonly from: LowerHex
+  readonly to: LowerHex
+  readonly tokenId: bigint
+  readonly nft: Nft
+}

package/src/types/evmAccount.ts

@@ -0,0 +1,12 @@
+import type { Account } from '@0xtorch/core'
+import type { Chain } from '../chains'
+import type { Prettify } from '../utils'
+import type { LowerHex } from './hex'
+
+export type EvmAccount = Prettify<
+  Account<'evm'> & {
+    readonly id: `evm_${Chain['id']}_${LowerHex}`
+    readonly chainId: number
+    readonly address: LowerHex
+  }
+>

package/src/types/hex.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'bun:test'
+
+import { isHex } from './hex'
+
+describe('isHex', () => {
+  it('should be true', () => {
+    const result = isHex('0x1234567890abcdefABCDEF')
+    expect(result).toBe(true)
+  })
+})

package/src/types/hex.ts

@@ -0,0 +1,9 @@
+export type Hex = `0x${string}`
+
+export type LowerHex = Lowercase<Hex>
+
+export const isHex = (value: string): value is Hex =>
+  /^0x[\da-f]+$/i.test(value)
+
+export const toLowerHex = (value: Hex): LowerHex =>
+  value.toLowerCase() as LowerHex

package/src/types/index.ts

@@ -0,0 +1,16 @@
+export type { Erc1155Token, Erc1155Transfer } from './erc1155'
+export type { Erc20Token, Erc20Transfer } from './erc20'
+export type { Erc721Token, Erc721Transfer } from './erc721'
+export type { EvmAccount } from './evmAccount'
+export { isHex, toLowerHex } from './hex'
+export type { Hex, LowerHex } from './hex'
+export type { InputData } from './input'
+export type { InternalTransaction } from './internalTransaction'
+export { parsedLogSchema } from './log'
+export type { DecodedLog, LogData } from './log'
+export type {
+  TransactionDecoded,
+  TransactionDetail,
+  TransactionFull,
+  TransactionSource,
+} from './transaction'

package/src/types/input.ts

@@ -0,0 +1,27 @@
+import type { Hex, LowerHex } from './hex'
+
+export type Argument = {
+  readonly name: string
+  readonly type: string
+  readonly value: unknown
+}
+
+export type InputFunction = {
+  readonly name: string
+  readonly args: readonly Argument[] | undefined
+}
+
+type InputOriginal = {
+  readonly type: 'original'
+  readonly address: LowerHex
+  readonly data: Hex
+}
+type InputDecoded = {
+  readonly type: 'decoded'
+  readonly address: LowerHex
+  readonly data: Hex
+  readonly function: InputFunction
+  /** contract address of ABI source */
+  readonly source: LowerHex
+}
+export type InputData = InputOriginal | InputDecoded

package/src/types/internalTransaction.ts

@@ -0,0 +1,19 @@
+import type { CryptoCurrency, CryptoCurrencyPrice } from '@0xtorch/core'
+import type { Hex, LowerHex } from './hex'
+
+export type InternalTransaction<Price extends CryptoCurrencyPrice | undefined> =
+  {
+    readonly type: 'InternalTransaction'
+    readonly transactionHash: Hex
+    readonly from: LowerHex
+    readonly to: LowerHex | undefined
+    readonly contractAddress: LowerHex | undefined
+    readonly txType: string
+    readonly value: bigint
+    readonly gas: bigint
+    readonly gasUsed: bigint
+    readonly isError: boolean
+    readonly input: string | undefined
+    readonly currency: CryptoCurrency
+    readonly price: Price
+  }

package/src/types/log.ts

@@ -0,0 +1,68 @@
+import type { Log } from 'viem'
+import { z } from 'zod'
+import type { LowerHex } from './hex'
+import { isHex, toLowerHex } from './hex'
+
+export type LogData = LogOriginal | LogDecoded
+
+type LogOriginal = {
+  readonly type: 'LogOriginal'
+  readonly log: Log<bigint, number, false>
+}
+
+type LogDecoded = {
+  readonly type: 'decoded'
+  readonly log: DecodedLog
+  /** contract address of ABI source */
+  readonly source: LowerHex
+}
+
+export type DecodedLog = z.infer<typeof decodedLogSchema> & {
+  readonly type: 'DecodedLog'
+}
+
+const logSchema = z.object({
+  address: z
+    .string()
+    .regex(/^0x[\dA-Fa-f]{40}$/)
+    .transform((x) => (isHex(x) ? toLowerHex(x) : '0x')),
+  blockHash: z
+    .string()
+    .regex(/^0x[\dA-Fa-f]*$/)
+    .transform((x) => (isHex(x) ? x : '0x')),
+  blockNumber: z.bigint(),
+  data: z
+    .string()
+    .regex(/^0x[\dA-Fa-f]*$/)
+    .transform((x) => (isHex(x) ? x : '0x')),
+  logIndex: z.number().int(),
+  transactionHash: z
+    .string()
+    .regex(/^0x[\dA-Fa-f]{64}$/)
+    .transform((x) => (isHex(x) ? x : '0x')),
+  transactionIndex: z.number().int(),
+  removed: z.boolean(),
+  topics: z.array(
+    z
+      .string()
+      .regex(/^0x[\dA-Fa-f]{64}$/)
+      .transform((x) => (isHex(x) ? x : '0x')),
+  ),
+})
+
+export const parsedLogSchema = logSchema.extend({
+  eventName: z.string(),
+  args: z.record(z.unknown()),
+})
+
+export const decodedLogSchema = logSchema.extend({
+  eventName: z.string(),
+  args: z.array(
+    z.object({
+      indexed: z.boolean(),
+      name: z.string(),
+      type: z.string(),
+      value: z.unknown(),
+    }),
+  ),
+})

package/src/types/transaction.ts

@@ -0,0 +1,78 @@
+import type {
+  AccountAction,
+  AccountActionType,
+  ActionType,
+  App,
+  CryptoCurrencyPrice,
+  NormalAction,
+} from '@0xtorch/core'
+import type { Block, BlockTag, Transaction, TransactionReceipt } from 'viem'
+import type { Prettify } from '../utils'
+import type { Erc1155Transfer } from './erc1155'
+import type { Erc20Transfer } from './erc20'
+import type { Erc721Transfer } from './erc721'
+import type { EvmAccount } from './evmAccount'
+import type { LowerHex } from './hex'
+import type { InputFunction } from './input'
+import type { InternalTransaction } from './internalTransaction'
+import type { LogData } from './log'
+
+export type TransactionSource = `evm_${number}_${LowerHex}`
+
+export type TransactionDetail = Prettify<
+  Omit<Transaction<bigint, number, false>, 'type'> &
+    Omit<TransactionReceipt, 'type'> & {
+      readonly type: Transaction['type']
+      readonly chainId: number
+      readonly block: Block<bigint, false, Exclude<BlockTag, 'pending'>>
+      readonly internalTransactions: readonly InternalTransaction<undefined>[]
+    }
+>
+
+export type TransactionDecoded<Price extends CryptoCurrencyPrice | undefined> =
+  Prettify<
+    Omit<TransactionDetail, 'logs' | 'internalTransactions'> & {
+      readonly function: InputFunction | undefined
+      readonly internalTransactions: readonly InternalTransaction<Price>[]
+      readonly erc20Transfers: readonly Erc20Transfer<Price>[]
+      readonly erc721Transfers: readonly Erc721Transfer[]
+      readonly erc1155Transfers: readonly Erc1155Transfer[]
+      readonly logs: readonly LogData[]
+      readonly app: App | undefined
+      readonly nativeTokenPrice: Price
+    }
+  >
+
+export type TransactionFull<
+  Price extends CryptoCurrencyPrice | undefined,
+  Decoded extends boolean,
+  Analyzed extends boolean,
+> = Omit<TransactionDetail, 'logs' | 'internalTransactions'> & {
+  readonly app: App | undefined
+  readonly nativeTokenPrice: Price
+  readonly internalTransactions: readonly InternalTransaction<Price>[]
+} & (Decoded extends true
+    ? {
+        readonly function: InputFunction | undefined
+        readonly erc20Transfers: readonly Erc20Transfer<Price>[]
+        readonly erc721Transfers: readonly Erc721Transfer[]
+        readonly erc1155Transfers: readonly Erc1155Transfer[]
+        readonly logs: readonly LogData[]
+      }
+    : Pick<TransactionDetail, 'logs'>) &
+  (Analyzed extends true
+    ? {
+        readonly accountAddresses: readonly LowerHex[]
+        readonly actions: readonly NormalAction<
+          ActionType,
+          EvmAccount | undefined,
+          Price
+        >[]
+        readonly accountActions: readonly AccountAction<
+          AccountActionType,
+          TransactionSource,
+          EvmAccount | undefined,
+          Price
+        >[]
+      }
+    : unknown)

package/src/utils/bigint.ts

@@ -0,0 +1,5 @@
+export const bigIntMax = (...arguments_: readonly bigint[]): bigint =>
+  arguments_.reduce((m, c) => (c > m ? c : m))
+
+export const bigIntMin = (...arguments_: readonly bigint[]): bigint =>
+  arguments_.reduce((m, c) => (c < m ? c : m))

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export { bigIntMax, bigIntMin } from './bigint'
+export { checkTimeout } from './timeout'
+export type { Prettify } from './types'

package/src/utils/timeout.ts

@@ -0,0 +1,5 @@
+export const checkTimeout = (timeoutTimestamp: number) => {
+  if (Date.now() > timeoutTimestamp) {
+    throw new Error('timeout')
+  }
+}

package/src/utils/types.ts

@@ -0,0 +1,12 @@
+/**
+ * @description Combines members of an intersection into a readable type.
+ *
+ * @see {@link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg}
+ * @example
+ * Prettify<{ a: string } & { b: string } & { c: number, d: bigint }>
+ * => { a: string, b: string, c: number, d: bigint }
+ */
+export type Prettify<T> = {
+  [K in keyof T]: T[K]
+  // eslint-disable-next-line @typescript-eslint/ban-types
+} & {}

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+
+    "types": ["bun-types"]
+  }
+}